Checkpoint

2024-12-10 23:39:34 -05:00 · 2024-12-10 23:31:07 -05:00 · 2024-12-10 23:18:13 -05:00 · 2024-12-10 23:02:47 -05:00 · 2024-12-10 19:31:37 -05:00 · 2024-12-10 19:12:30 -05:00
310 changed files with 17583 additions and 5720 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -13,6 +13,12 @@ rustflags = ["-C", "link-arg=-fuse-ld=mold"]
 linker = "clang"
 rustflags = ["-C", "link-arg=-fuse-ld=mold"]

+[target.aarch64-apple-darwin]
+rustflags = ["-C", "link-args=-Objc -all_load"]
+
+[target.x86_64-apple-darwin]
+rustflags = ["-C", "link-args=-Objc -all_load"]
+
 # This cfg will reduce the size of `windows::core::Error` from 16 bytes to 4 bytes
 [target.'cfg(target_os = "windows")']
 rustflags = ["--cfg", "windows_slim_errors"]
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -113,6 +113,12 @@ jobs:
          script/check-licenses
          script/generate-licenses /tmp/zed_licenses_output

+      - name: Check for new vulnerable dependencies
+        if: github.event_name == 'pull_request'
+        uses: actions/dependency-review-action@3b139cfc5fae8b618d3eae3675e383bb1769c019 # v4
+        with:
+          license-check: false
+
      - name: Run tests
        uses: ./.github/actions/run_tests

@@ -123,6 +129,7 @@ jobs:
        run: |
          cargo build --workspace --bins --all-features
          cargo check -p gpui --features "macos-blade"
+          cargo check -p workspace --features "livekit-cross-platform"
          cargo build -p remote_server

  linux_tests:
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,6 +21,8 @@ members = [
    "crates/collab",
    "crates/collab_ui",
    "crates/collections",
+    "crates/component_preview",
+    "crates/component_system",
    "crates/command_palette",
    "crates/command_palette_hooks",
    "crates/context_server",
@@ -65,8 +67,9 @@ members = [
    "crates/language_selector",
    "crates/language_tools",
    "crates/languages",
-    "crates/live_kit_client",
-    "crates/live_kit_server",
+    "crates/livekit_client",
+    "crates/livekit_client_macos",
+    "crates/livekit_server",
    "crates/lsp",
    "crates/markdown",
    "crates/markdown_preview",
@@ -206,6 +209,8 @@ clock = { path = "crates/clock" }
 collab = { path = "crates/collab" }
 collab_ui = { path = "crates/collab_ui" }
 collections = { path = "crates/collections" }
+component_system = { path = "crates/component_system" }
+component_preview = { path = "crates/component_preview" }
 command_palette = { path = "crates/command_palette" }
 command_palette_hooks = { path = "crates/command_palette_hooks" }
 context_server = { path = "crates/context_server" }
@@ -248,8 +253,9 @@ language_models = { path = "crates/language_models" }
 language_selector = { path = "crates/language_selector" }
 language_tools = { path = "crates/language_tools" }
 languages = { path = "crates/languages" }
-live_kit_client = { path = "crates/live_kit_client" }
-live_kit_server = { path = "crates/live_kit_server" }
+livekit_client = { path = "crates/livekit_client" }
+livekit_client_macos = { path = "crates/livekit_client_macos" }
+livekit_server = { path = "crates/livekit_server" }
 lsp = { path = "crates/lsp" }
 markdown = { path = "crates/markdown" }
 markdown_preview = { path = "crates/markdown_preview" }
@@ -382,20 +388,25 @@ heed = { version = "0.20.1", features = ["read-txn-no-tls"] }
 hex = "0.4.3"
 html5ever = "0.27.0"
 hyper = "0.14"
+http = "1.1"
 ignore = "0.4.22"
 image = "0.25.1"
 indexmap = { version = "1.6.2", features = ["serde"] }
 indoc = "2"
 itertools = "0.13.0"
 jsonwebtoken = "9.3"
-jupyter-protocol = { version = "0.3.0" }
-jupyter-websocket-client = { version = "0.5.0" }
+jupyter-protocol = { version = "0.5.0" }
+jupyter-websocket-client = { version = "0.8.0" }
+lazy_static = "1.5.0"
 libc = "0.2"
+libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
 linkify = "0.10.0"
+linkme = "0.3"
+livekit = { git = "https://github.com/zed-industries/rust-sdks", rev="799f10133d93ba2a88642cd480d01ec4da53408c", features = ["dispatcher", "services-dispatcher", "rustls-tls-native-roots"], default-features = false }
 log = { version = "0.4.16", features = ["kv_unstable_serde", "serde"] }
 markup5ever_rcdom = "0.3.0"
 nanoid = "0.4"
-nbformat = { version = "0.7.0" }
+nbformat = { version = "0.9.0" }
 nix = "0.29"
 num-format = "0.4.4"
 once_cell = "1.19.0"
@@ -429,7 +440,7 @@ reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f
    "stream",
 ] }
 rsa = "0.9.6"
-runtimelib = { version = "0.22.0", default-features = false, features = [
+runtimelib = { version = "0.24.0", default-features = false, features = [
    "async-dispatcher-runtime",
 ] }
 rustc-demangle = "0.1.23"
@@ -570,6 +581,10 @@ features = [
    "Win32_UI_WindowsAndMessaging",
 ]

+# TODO livekit https://github.com/RustAudio/cpal/pull/891
+[patch.crates-io]
+cpal = { git = "https://github.com/zed-industries/cpal", rev = "fd8bc2fd39f1f5fdee5a0690656caff9a26d9d50" }
+
 [profile.dev]
 split-debuginfo = "unpacked"
 debug = "limited"
@@ -672,6 +687,7 @@ new_ret_no_self = { level = "allow" }
 # We have a few `next` functions that differ in lifetimes
 # compared to Iterator::next. Yet, clippy complains about those.
 should_implement_trait = { level = "allow" }
+let_underscore_future = "allow"

 [workspace.metadata.cargo-machete]
 ignored = ["bindgen", "cbindgen", "prost_build", "serde"]
--- a/assets/icons/file_icons/audio.svg
+++ b/assets/icons/file_icons/audio.svg
@@ -1,4 +1,8 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M9.20721 10.8551C7.67694 10.8551 6.33401 11.0424 5.52243 11.1878C5.15088 11.2543 4.808 10.9114 4.87454 10.5399C5.01987 9.72825 5.20721 8.38532 5.20721 6.85505C5.20721 5.69375 5.09932 4.64034 4.98377 3.84516C4.9431 3.56522 5.40267 3.3722 5.5684 3.60145C6.30333 4.61809 7.44022 6.08806 8.70721 7.35505C9.9742 8.62204 11.4442 9.75893 12.4608 10.4939C12.69 10.6596 12.497 11.1192 12.2171 11.0785C11.4219 10.963 10.3685 10.8551 9.20721 10.8551Z" fill="black" stroke="black" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M7.11129 10.6816L5.28324 8.85355C5.08798 8.65829 4.7714 8.65829 4.57613 8.85355L3.35355 10.0761C3.15829 10.2714 3.15829 10.588 3.35355 10.7832L5.1816 12.6113C5.37686 12.8066 5.69345 12.8066 5.88871 12.6113L7.11129 11.3887C7.30655 11.1934 7.30655 10.8769 7.11129 10.6816Z" fill="black"/>
+<path d="M3.5 6.66666V8.66666" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M5.5 5V11" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M7.5 3V13" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M9.5 5.33334V10" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M11.5 4V12" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M13.5 6.66666V8.66666" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
 </svg>
--- a/assets/icons/file_icons/diff.svg
+++ b/assets/icons/file_icons/diff.svg
@@ -0,0 +1,5 @@
+<svg width="17" height="16" viewBox="0 0 17 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M8.5 3L8.5 10" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M5 6.5H12" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M5 13H12" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
--- a/assets/icons/file_icons/file_types.json
+++ b/assets/icons/file_icons/file_types.json
@@ -34,6 +34,7 @@
    "dat": "storage",
    "db": "storage",
    "dbf": "storage",
+    "diff": "diff",
    "dll": "storage",
    "doc": "document",
    "docx": "document",
@@ -112,6 +113,7 @@
    "mkv": "video",
    "ml": "ocaml",
    "mli": "ocaml",
+    "mod": "go",
    "mov": "video",
    "mp3": "audio",
    "mp4": "video",
@@ -127,6 +129,7 @@
    "ogg": "audio",
    "opus": "audio",
    "otf": "font",
+    "pcss": "css",
    "pdb": "storage",
    "pdf": "document",
    "php": "php",
@@ -173,6 +176,9 @@
    "tsx": "react",
    "ttf": "font",
    "txt": "document",
+    "v": "v",
+    "vsh": "v",
+    "vv": "v",
    "vue": "vue",
    "wav": "audio",
    "webm": "video",
@@ -181,6 +187,7 @@
    "wmv": "video",
    "woff": "font",
    "woff2": "font",
+    "work": "go",
    "wv": "audio",
    "xls": "document",
    "xlsx": "document",
@@ -235,6 +242,9 @@
    "default": {
      "icon": "icons/file_icons/file.svg"
    },
+    "diff": {
+      "icon": "icons/file_icons/diff.svg"
+    },
    "docker": {
      "icon": "icons/file_icons/docker.svg"
    },
@@ -379,6 +389,9 @@
    "typescript": {
      "icon": "icons/file_icons/typescript.svg"
    },
+    "v": {
+      "icon": "icons/file_icons/v.svg"
+    },
    "vcs": {
      "icon": "icons/file_icons/git.svg"
    },
--- a/assets/icons/file_icons/v.svg
+++ b/assets/icons/file_icons/v.svg
@@ -0,0 +1,4 @@
+<svg width="17" height="16" viewBox="0 0 17 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path opacity="0.5" d="M10.0469 12.8661L13.3884 3.31889C13.4386 3.1754 13.3167 3.03055 13.1667 3.05554L10.7292 3.46179C10.5875 3.48542 10.4693 3.58324 10.4197 3.71807L7.24789 12.3271C7.12763 12.6536 7.36919 13 7.71706 13H9.8581C9.94309 13 10.0188 12.9463 10.0469 12.8661Z" fill="black"/>
+<path d="M6.90625 12.7321L3.61161 3.31889C3.56139 3.1754 3.6833 3.03055 3.83326 3.05554L6.27076 3.46179C6.4125 3.48542 6.53067 3.58324 6.58034 3.71807L9.90084 12.7309C9.94895 12.8614 9.85232 13 9.71317 13H7.28379C7.11381 13 6.9624 12.8926 6.90625 12.7321Z" fill="black"/>
+</svg>
--- a/assets/icons/triangle.svg
+++ b/assets/icons/triangle.svg
@@ -1,3 +1,3 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-  <path d="M8 4L4 12H12L8 4Z" fill="currentColor"/>
+<svg width="17" height="16" viewBox="0 0 17 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M8.5 3L3 12H14L8.5 3Z" fill="black"/>
 </svg>
--- a/assets/icons/x.svg
+++ b/assets/icons/x.svg
@@ -1,3 +1,3 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-  <path d="M4 4L12 12M12 4L4 12" stroke="currentColor" stroke-width="2"/>
+<svg width="17" height="16" viewBox="0 0 17 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M5 4.5L12 11.5M12 4.5L5 11.5" stroke="black" stroke-width="2" stroke-linecap="round"/>
 </svg>
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -108,7 +108,9 @@
      "ctrl-'": "editor::ToggleHunkDiff",
      "ctrl-\"": "editor::ExpandAllHunkDiffs",
      "ctrl-i": "editor::ShowSignatureHelp",
-      "alt-g b": "editor::ToggleGitBlame"
+      "alt-g b": "editor::ToggleGitBlame",
+      "menu": "editor::OpenContextMenu",
+      "shift-f10": "editor::OpenContextMenu"
    }
  },
  {
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -93,8 +93,6 @@
      "ctrl-e": "editor::MoveToEndOfLine",
      "cmd-up": "editor::MoveToBeginning",
      "cmd-down": "editor::MoveToEnd",
-      "ctrl-home": "editor::MoveToBeginning",
-      "ctrl-end": "editor::MoveToEnd",
      "shift-up": "editor::SelectUp",
      "ctrl-shift-p": "editor::SelectUp",
      "shift-down": "editor::SelectDown",
@@ -212,7 +210,8 @@
  {
    "context": "AssistantPanel2",
    "bindings": {
-      "cmd-n": "assistant2::NewThread"
+      "cmd-n": "assistant2::NewThread",
+      "cmd-shift-h": "assistant2::OpenHistory"
    }
  },
  {
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -33,6 +33,18 @@
      "(": "vim::SentenceBackward",
      ")": "vim::SentenceForward",
      "|": "vim::GoToColumn",
+      "] ]": "vim::NextSectionStart",
+      "] [": "vim::NextSectionEnd",
+      "[ [": "vim::PreviousSectionStart",
+      "[ ]": "vim::PreviousSectionEnd",
+      "] m": "vim::NextMethodStart",
+      "] M": "vim::NextMethodEnd",
+      "[ m": "vim::PreviousMethodStart",
+      "[ M": "vim::PreviousMethodEnd",
+      "[ *": "vim::PreviousComment",
+      "[ /": "vim::PreviousComment",
+      "] *": "vim::NextComment",
+      "] /": "vim::NextComment",
      // Word motions
      "w": "vim::NextWordStart",
      "e": "vim::NextWordEnd",
@@ -55,10 +67,10 @@
      "n": "vim::MoveToNextMatch",
      "shift-n": "vim::MoveToPrevMatch",
      "%": "vim::Matching",
-      "] }": ["vim::UnmatchedForward", { "char": "}" } ],
-      "[ {": ["vim::UnmatchedBackward", { "char": "{" } ],
-      "] )": ["vim::UnmatchedForward", { "char": ")" } ],
-      "[ (": ["vim::UnmatchedBackward", { "char": "(" } ],
+      "] }": ["vim::UnmatchedForward", { "char": "}" }],
+      "[ {": ["vim::UnmatchedBackward", { "char": "{" }],
+      "] )": ["vim::UnmatchedForward", { "char": ")" }],
+      "[ (": ["vim::UnmatchedBackward", { "char": "(" }],
      "f": ["vim::PushOperator", { "FindForward": { "before": false } }],
      "t": ["vim::PushOperator", { "FindForward": { "before": true } }],
      "shift-f": ["vim::PushOperator", { "FindBackward": { "after": false } }],
@@ -209,6 +221,7 @@
      "shift-s": "vim::SubstituteLine",
      ">": ["vim::PushOperator", "Indent"],
      "<": ["vim::PushOperator", "Outdent"],
+      "=": ["vim::PushOperator", "AutoIndent"],
      "g u": ["vim::PushOperator", "Lowercase"],
      "g shift-u": ["vim::PushOperator", "Uppercase"],
      "g ~": ["vim::PushOperator", "OppositeCase"],
@@ -275,6 +288,7 @@
      "ctrl-[": ["vim::SwitchMode", "Normal"],
      ">": "vim::Indent",
      "<": "vim::Outdent",
+      "=": "vim::AutoIndent",
      "i": ["vim::PushOperator", { "Object": { "around": false } }],
      "a": ["vim::PushOperator", { "Object": { "around": true } }],
      "g c": "vim::ToggleComments",
@@ -312,6 +326,22 @@
      "ctrl-o": "vim::TemporaryNormal"
    }
  },
+  {
+    "context": "vim_mode == helix_normal",
+    "bindings": {
+      "i": "vim::InsertBefore",
+      "a": "vim::InsertAfter",
+      "w": "vim::NextWordStart",
+      "e": "vim::NextWordEnd",
+      "b": "vim::PreviousWordStart",
+
+      "h": "vim::Left",
+      "j": "vim::Down",
+      "k": "vim::Up",
+      "l": "vim::Right"
+    }
+  },
+
  {
    "context": "vim_mode == insert && !(showing_code_actions || showing_completions)",
    "use_layout_keys": true,
@@ -358,7 +388,8 @@
    "bindings": {
      "escape": "vim::ClearOperators",
      "ctrl-c": "vim::ClearOperators",
-      "ctrl-[": "vim::ClearOperators"
+      "ctrl-[": "vim::ClearOperators",
+      "g c": "vim::Comment"
    }
  },
  {
@@ -387,7 +418,9 @@
      ">": "vim::AngleBrackets",
      "a": "vim::Argument",
      "i": "vim::IndentObj",
-      "shift-i": ["vim::IndentObj", { "includeBelow": true }]
+      "shift-i": ["vim::IndentObj", { "includeBelow": true }],
+      "f": "vim::Method",
+      "c": "vim::Class"
    }
  },
  {
@@ -472,6 +505,13 @@
      "<": "vim::CurrentLine"
    }
  },
+  {
+    "context": "vim_operator == eq",
+    "use_layout_keys": true,
+    "bindings": {
+      "=": "vim::CurrentLine"
+    }
+  },
  {
    "context": "vim_operator == gc",
    "use_layout_keys": true,
@@ -619,6 +659,12 @@
      "p": "project_panel::Open",
      "x": "project_panel::RevealInFileManager",
      "s": "project_panel::OpenWithSystem",
+      "] c": "project_panel::SelectNextGitEntry",
+      "[ c": "project_panel::SelectPrevGitEntry",
+      "] d": "project_panel::SelectNextDiagnostic",
+      "[ d": "project_panel::SelectPrevDiagnostic",
+      "}": "project_panel::SelectNextDirectory",
+      "{": "project_panel::SelectPrevDirectory",
      "shift-g": "menu::SelectLast",
      "g g": "menu::SelectFirst",
      "-": "project_panel::SelectParent",
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -559,13 +559,25 @@
    "close_position": "right",
    // Whether to show the file icon for a tab.
    "file_icons": false,
+    // Whether to always show the close button on tabs.
+    "always_show_close_button": 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"
+    "activate_on_close": "history",
+    /// Which files containing diagnostic errors/warnings to mark in the tabs.
+    /// This setting can take the following three values:
+    ///
+    /// 1. Do not mark any files:
+    ///    "off"
+    /// 2. Only mark files with errors:
+    ///    "errors"
+    /// 3. Mark files with errors and warnings:
+    ///    "all"
+    "show_diagnostics": "all"
  },
  // Settings related to preview tabs.
  "preview_tabs": {
@@ -1127,6 +1139,7 @@
    "use_system_clipboard": "always",
    "use_multiline_find": false,
    "use_smartcase_find": false,
+    "highlight_on_yank_duration": 200,
    "custom_digraphs": {}
  },
  // The server to connect to. If the environment variable
@@ -1184,6 +1197,8 @@
  //   "W": "workspace::Save"
  // }
  "command_aliases": {},
+  // Whether to show user picture in titlebar.
+  "show_user_picture": true,
  // ssh_connections is an array of ssh connections.
  // You can configure these from `project: Open Remote` in the command palette.
  // Zed's ssh support will pull configuration from your ~/.ssh too.
--- a/assets/themes/andromeda/andromeda.json
+++ b/assets/themes/andromeda/andromeda.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://zed.dev/schema/themes/v0.1.0.json",
+  "$schema": "https://zed.dev/schema/themes/v0.2.0.json",
  "name": "Andromeda",
  "author": "Zed Industries",
  "themes": [
@@ -46,7 +46,7 @@
        "tab.active_background": "#1e2025ff",
        "search.match_background": "#11a79366",
        "panel.background": "#21242bff",
-        "panel.focused_border": null,
+        "panel.focused_border": "#10a793ff",
        "pane.focused_border": null,
        "scrollbar.thumb.background": "#f7f7f84c",
        "scrollbar.thumb.hover_background": "#252931ff",
--- a/assets/themes/atelier/atelier.json
+++ b/assets/themes/atelier/atelier.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://zed.dev/schema/themes/v0.1.0.json",
+  "$schema": "https://zed.dev/schema/themes/v0.2.0.json",
  "name": "Atelier",
  "author": "Zed Industries",
  "themes": [
@@ -46,7 +46,7 @@
        "tab.active_background": "#19171cff",
        "search.match_background": "#576dda66",
        "panel.background": "#221f26ff",
-        "panel.focused_border": null,
+        "panel.focused_border": "#566ddaff",
        "pane.focused_border": null,
        "scrollbar.thumb.background": "#efecf44c",
        "scrollbar.thumb.hover_background": "#332f38ff",
@@ -431,7 +431,7 @@
        "tab.active_background": "#efecf4ff",
        "search.match_background": "#586dda66",
        "panel.background": "#e6e3ebff",
-        "panel.focused_border": null,
+        "panel.focused_border": "#586cdaff",
        "pane.focused_border": null,
        "scrollbar.thumb.background": "#19171c4c",
        "scrollbar.thumb.hover_background": "#cbc8d1ff",
--- a/assets/themes/ayu/ayu.json
+++ b/assets/themes/ayu/ayu.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://zed.dev/schema/themes/v0.1.0.json",
+  "$schema": "https://zed.dev/schema/themes/v0.2.0.json",
  "name": "Ayu",
  "author": "Zed Industries",
  "themes": [
@@ -46,7 +46,7 @@
        "tab.active_background": "#0d1016ff",
        "search.match_background": "#5ac2fe66",
        "panel.background": "#1f2127ff",
-        "panel.focused_border": null,
+        "panel.focused_border": "#5ac1feff",
        "pane.focused_border": null,
        "scrollbar.thumb.background": "#bfbdb64c",
        "scrollbar.thumb.hover_background": "#2d2f34ff",
@@ -416,7 +416,7 @@
        "tab.active_background": "#fcfcfcff",
        "search.match_background": "#3b9ee566",
        "panel.background": "#ececedff",
-        "panel.focused_border": null,
+        "panel.focused_border": "#3b9ee5ff",
        "pane.focused_border": null,
        "scrollbar.thumb.background": "#5c61664c",
        "scrollbar.thumb.hover_background": "#dfe0e1ff",
--- a/assets/themes/gruvbox/gruvbox.json
+++ b/assets/themes/gruvbox/gruvbox.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://zed.dev/schema/themes/v0.1.0.json",
+  "$schema": "https://zed.dev/schema/themes/v0.2.0.json",
  "name": "Gruvbox",
  "author": "Zed Industries",
  "themes": [
@@ -55,7 +55,7 @@
        "tab.active_background": "#282828ff",
        "search.match_background": "#83a59866",
        "panel.background": "#3a3735ff",
-        "panel.focused_border": null,
+        "panel.focused_border": "#83a598ff",
        "pane.focused_border": null,
        "scrollbar.thumb.background": "#fbf1c74c",
        "scrollbar.thumb.hover_background": "#494340ff",
@@ -439,7 +439,7 @@
        "tab.active_background": "#1d2021ff",
        "search.match_background": "#83a59866",
        "panel.background": "#393634ff",
-        "panel.focused_border": null,
+        "panel.focused_border": "#83a598ff",
        "pane.focused_border": null,
        "scrollbar.thumb.background": "#fbf1c74c",
        "scrollbar.thumb.hover_background": "#494340ff",
--- a/assets/themes/one/one.json
+++ b/assets/themes/one/one.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://zed.dev/schema/themes/v0.1.0.json",
+  "$schema": "https://zed.dev/schema/themes/v0.2.0.json",
  "name": "One",
  "author": "Zed Industries",
  "themes": [
--- a/assets/themes/rose_pine/rose_pine.json
+++ b/assets/themes/rose_pine/rose_pine.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://zed.dev/schema/themes/v0.1.0.json",
+  "$schema": "https://zed.dev/schema/themes/v0.2.0.json",
  "name": "Rosé Pine",
  "author": "Zed Industries",
  "themes": [
@@ -46,7 +46,7 @@
        "tab.active_background": "#191724ff",
        "search.match_background": "#57949f66",
        "panel.background": "#1c1b2aff",
-        "panel.focused_border": null,
+        "panel.focused_border": "#9bced6ff",
        "pane.focused_border": null,
        "scrollbar.thumb.background": "#e0def44c",
        "scrollbar.thumb.hover_background": "#232132ff",
@@ -426,7 +426,7 @@
        "tab.active_background": "#faf4edff",
        "search.match_background": "#9cced766",
        "panel.background": "#fef9f2ff",
-        "panel.focused_border": null,
+        "panel.focused_border": "#57949fff",
        "pane.focused_border": null,
        "scrollbar.thumb.background": "#5752794c",
        "scrollbar.thumb.hover_background": "#e5e0dfff",
@@ -806,7 +806,7 @@
        "tab.active_background": "#232136ff",
        "search.match_background": "#9cced766",
        "panel.background": "#28253cff",
-        "panel.focused_border": null,
+        "panel.focused_border": "#9bced6ff",
        "pane.focused_border": null,
        "scrollbar.thumb.background": "#e0def44c",
        "scrollbar.thumb.hover_background": "#322f48ff",
--- a/assets/themes/sandcastle/sandcastle.json
+++ b/assets/themes/sandcastle/sandcastle.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://zed.dev/schema/themes/v0.1.0.json",
+  "$schema": "https://zed.dev/schema/themes/v0.2.0.json",
  "name": "Sandcastle",
  "author": "Zed Industries",
  "themes": [
@@ -46,7 +46,7 @@
        "tab.active_background": "#282c33ff",
        "search.match_background": "#528b8b66",
        "panel.background": "#2b3038ff",
-        "panel.focused_border": null,
+        "panel.focused_border": "#518b8bff",
        "pane.focused_border": null,
        "scrollbar.thumb.background": "#fdf4c14c",
        "scrollbar.thumb.hover_background": "#313741ff",
--- a/assets/themes/solarized/solarized.json
+++ b/assets/themes/solarized/solarized.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://zed.dev/schema/themes/v0.1.0.json",
+  "$schema": "https://zed.dev/schema/themes/v0.2.0.json",
  "name": "Solarized",
  "author": "Zed Industries",
  "themes": [
@@ -46,7 +46,7 @@
        "tab.active_background": "#002a35ff",
        "search.match_background": "#288bd166",
        "panel.background": "#04313bff",
-        "panel.focused_border": null,
+        "panel.focused_border": "#278ad1ff",
        "pane.focused_border": null,
        "scrollbar.thumb.background": "#fdf6e34c",
        "scrollbar.thumb.hover_background": "#053541ff",
@@ -416,7 +416,7 @@
        "tab.active_background": "#fdf6e3ff",
        "search.match_background": "#298bd166",
        "panel.background": "#f3eddaff",
-        "panel.focused_border": null,
+        "panel.focused_border": "#288bd1ff",
        "pane.focused_border": null,
        "scrollbar.thumb.background": "#002a354c",
        "scrollbar.thumb.hover_background": "#dcdacbff",
--- a/assets/themes/summercamp/summercamp.json
+++ b/assets/themes/summercamp/summercamp.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://zed.dev/schema/themes/v0.1.0.json",
+  "$schema": "https://zed.dev/schema/themes/v0.2.0.json",
  "name": "Summercamp",
  "author": "Zed Industries",
  "themes": [
@@ -46,7 +46,7 @@
        "tab.active_background": "#1b1810ff",
        "search.match_background": "#499bef66",
        "panel.background": "#231f16ff",
-        "panel.focused_border": null,
+        "panel.focused_border": "#499befff",
        "pane.focused_border": null,
        "scrollbar.thumb.background": "#f8f5de4c",
        "scrollbar.thumb.hover_background": "#29251bff",
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -450,6 +450,7 @@ impl AssistantPanel {
                    .gap(DynamicSpacing::Base02.rems(cx))
                    .child(
                        IconButton::new("new-chat", IconName::Plus)
+                            .icon_size(IconSize::Small)
                            .on_click(
                                cx.listener(|_, _, cx| {
                                    cx.dispatch_action(NewContext.boxed_clone())
--- a/crates/assistant/src/slash_command/context_server_command.rs
+++ b/crates/assistant/src/slash_command/context_server_command.rs
@@ -164,7 +164,7 @@ impl SlashCommand for ContextServerSlashCommand {
                    .messages
                    .into_iter()
                    .filter_map(|msg| match msg.content {
-                        context_server::types::MessageContent::Text { text } => Some(text),
+                        context_server::types::MessageContent::Text { text, .. } => Some(text),
                        _ => None,
                    })
                    .collect::<Vec<String>>()
--- a/crates/assistant/src/slash_command_picker.rs
+++ b/crates/assistant/src/slash_command_picker.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;

 use gpui::{AnyElement, DismissEvent, SharedString, Task, WeakView};
 use picker::{Picker, PickerDelegate, PickerEditorPosition};
-use ui::{prelude::*, ListItem, ListItemSpacing, PopoverMenu, PopoverTrigger};
+use ui::{prelude::*, ListItem, ListItemSpacing, PopoverMenu, PopoverTrigger, Tooltip};

 use crate::assistant_panel::ContextEditor;
 use crate::SlashCommandWorkingSet;
@@ -177,11 +177,17 @@ impl PickerDelegate for SlashCommandDelegate {
                    .inset(true)
                    .spacing(ListItemSpacing::Dense)
                    .selected(selected)
+                    .tooltip({
+                        let description = info.description.clone();
+                        move |cx| cx.new_view(|_| Tooltip::new(description.clone())).into()
+                    })
                    .child(
                        v_flex()
                            .group(format!("command-entry-label-{ix}"))
                            .w_full()
+                            .py_0p5()
                            .min_w(px(250.))
+                            .max_w(px(400.))
                            .child(
                                h_flex()
                                    .gap_1p5()
@@ -192,7 +198,7 @@ impl PickerDelegate for SlashCommandDelegate {
                                        {
                                            label.push_str(&args);
                                        }
-                                        Label::new(label).size(LabelSize::Small)
+                                        Label::new(label).single_line().size(LabelSize::Small)
                                    }))
                                    .children(info.args.clone().filter(|_| !selected).map(
                                        |args| {
@@ -200,6 +206,7 @@ impl PickerDelegate for SlashCommandDelegate {
                                                .font_buffer(cx)
                                                .child(
                                                    Label::new(args)
+                                                        .single_line()
                                                        .size(LabelSize::Small)
                                                        .color(Color::Muted),
                                                )
@@ -210,9 +217,11 @@ impl PickerDelegate for SlashCommandDelegate {
                                    )),
                            )
                            .child(
-                                Label::new(info.description.clone())
-                                    .size(LabelSize::Small)
-                                    .color(Color::Muted),
+                                div().overflow_hidden().text_ellipsis().child(
+                                    Label::new(info.description.clone())
+                                        .size(LabelSize::Small)
+                                        .color(Color::Muted),
+                                ),
                            ),
                    ),
            ),
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -32,7 +32,7 @@ use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
 use terminal::Terminal;
 use terminal_view::TerminalView;
 use theme::ThemeSettings;
-use ui::{prelude::*, IconButtonShape, Tooltip};
+use ui::{prelude::*, text_for_action, IconButtonShape, Tooltip};
 use util::ResultExt;
 use workspace::{notifications::NotificationId, Toast, Workspace};

@@ -704,7 +704,7 @@ impl PromptEditor {
                cx,
            );
            editor.set_soft_wrap_mode(language::language_settings::SoftWrap::EditorWidth, cx);
-            editor.set_placeholder_text("Add a prompt…", cx);
+            editor.set_placeholder_text(Self::placeholder_text(cx), cx);
            editor
        });

@@ -737,6 +737,14 @@ impl PromptEditor {
        this
    }

+    fn placeholder_text(cx: &WindowContext) -> String {
+        let context_keybinding = text_for_action(&crate::ToggleFocus, cx)
+            .map(|keybinding| format!(" • {keybinding} for context"))
+            .unwrap_or_default();
+
+        format!("Generate…{context_keybinding} • ↓↑ for history")
+    }
+
    fn subscribe_to_editor(&mut self, cx: &mut ViewContext<Self>) {
        self.editor_subscriptions.clear();
        self.editor_subscriptions
--- a/crates/assistant2/Cargo.toml
+++ b/crates/assistant2/Cargo.toml
@@ -15,20 +15,33 @@ doctest = false
 [dependencies]
 anyhow.workspace = true
 assistant_tool.workspace = true
+chrono.workspace = true
+client.workspace = true
 collections.workspace = true
 command_palette_hooks.workspace = true
+context_server.workspace = true
 editor.workspace = true
 feature_flags.workspace = true
 futures.workspace = true
 gpui.workspace = true
+language.workspace = true
 language_model.workspace = true
 language_model_selector.workspace = true
+language_models.workspace = true
+log.workspace = true
+markdown.workspace = true
+picker.workspace = true
+project.workspace = true
 proto.workspace = true
-settings.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+settings.workspace = true
 smol.workspace = true
 theme.workspace = true
+time.workspace = true
+time_format.workspace = true
 ui.workspace = true
+unindent.workspace = true
 util.workspace = true
+uuid.workspace = true
 workspace.workspace = true
--- a/crates/assistant2/src/active_thread.rs
+++ b/crates/assistant2/src/active_thread.rs
@@ -0,0 +1,242 @@
+use std::sync::Arc;
+
+use assistant_tool::ToolWorkingSet;
+use collections::HashMap;
+use gpui::{
+    list, AnyElement, AppContext, Empty, ListAlignment, ListState, Model, StyleRefinement,
+    Subscription, TextStyleRefinement, View, WeakView,
+};
+use language::LanguageRegistry;
+use language_model::Role;
+use markdown::{Markdown, MarkdownStyle};
+use settings::Settings as _;
+use theme::ThemeSettings;
+use ui::prelude::*;
+use workspace::Workspace;
+
+use crate::thread::{MessageId, Thread, ThreadError, ThreadEvent};
+
+pub struct ActiveThread {
+    workspace: WeakView<Workspace>,
+    language_registry: Arc<LanguageRegistry>,
+    tools: Arc<ToolWorkingSet>,
+    thread: Model<Thread>,
+    messages: Vec<MessageId>,
+    list_state: ListState,
+    rendered_messages_by_id: HashMap<MessageId, View<Markdown>>,
+    last_error: Option<ThreadError>,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl ActiveThread {
+    pub fn new(
+        thread: Model<Thread>,
+        workspace: WeakView<Workspace>,
+        language_registry: Arc<LanguageRegistry>,
+        tools: Arc<ToolWorkingSet>,
+        cx: &mut ViewContext<Self>,
+    ) -> Self {
+        let subscriptions = vec![
+            cx.observe(&thread, |_, _, cx| cx.notify()),
+            cx.subscribe(&thread, Self::handle_thread_event),
+        ];
+
+        let mut this = Self {
+            workspace,
+            language_registry,
+            tools,
+            thread: thread.clone(),
+            messages: Vec::new(),
+            rendered_messages_by_id: HashMap::default(),
+            list_state: ListState::new(0, ListAlignment::Bottom, px(1024.), {
+                let this = cx.view().downgrade();
+                move |ix, cx: &mut WindowContext| {
+                    this.update(cx, |this, cx| this.render_message(ix, cx))
+                        .unwrap()
+                }
+            }),
+            last_error: None,
+            _subscriptions: subscriptions,
+        };
+
+        for message in thread.read(cx).messages().cloned().collect::<Vec<_>>() {
+            this.push_message(&message.id, message.text.clone(), cx);
+        }
+
+        this
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.messages.is_empty()
+    }
+
+    pub fn summary(&self, cx: &AppContext) -> Option<SharedString> {
+        self.thread.read(cx).summary()
+    }
+
+    pub fn last_error(&self) -> Option<ThreadError> {
+        self.last_error.clone()
+    }
+
+    pub fn clear_last_error(&mut self) {
+        self.last_error.take();
+    }
+
+    fn push_message(&mut self, id: &MessageId, text: String, cx: &mut ViewContext<Self>) {
+        let old_len = self.messages.len();
+        self.messages.push(*id);
+        self.list_state.splice(old_len..old_len, 1);
+
+        let theme_settings = ThemeSettings::get_global(cx);
+        let ui_font_size = TextSize::Default.rems(cx);
+        let buffer_font_size = theme_settings.buffer_font_size;
+
+        let mut text_style = cx.text_style();
+        text_style.refine(&TextStyleRefinement {
+            font_family: Some(theme_settings.ui_font.family.clone()),
+            font_size: Some(ui_font_size.into()),
+            color: Some(cx.theme().colors().text),
+            ..Default::default()
+        });
+
+        let markdown_style = MarkdownStyle {
+            base_text_style: text_style,
+            syntax: cx.theme().syntax().clone(),
+            selection_background_color: cx.theme().players().local().selection,
+            code_block: StyleRefinement {
+                text: Some(TextStyleRefinement {
+                    font_family: Some(theme_settings.buffer_font.family.clone()),
+                    font_size: Some(buffer_font_size.into()),
+                    ..Default::default()
+                }),
+                ..Default::default()
+            },
+            inline_code: TextStyleRefinement {
+                font_family: Some(theme_settings.buffer_font.family.clone()),
+                font_size: Some(ui_font_size.into()),
+                background_color: Some(cx.theme().colors().editor_background),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+
+        let markdown = cx.new_view(|cx| {
+            Markdown::new(
+                text,
+                markdown_style,
+                Some(self.language_registry.clone()),
+                None,
+                cx,
+            )
+        });
+        self.rendered_messages_by_id.insert(*id, markdown);
+    }
+
+    fn handle_thread_event(
+        &mut self,
+        _: Model<Thread>,
+        event: &ThreadEvent,
+        cx: &mut ViewContext<Self>,
+    ) {
+        match event {
+            ThreadEvent::ShowError(error) => {
+                self.last_error = Some(error.clone());
+            }
+            ThreadEvent::StreamedCompletion => {}
+            ThreadEvent::SummaryChanged => {}
+            ThreadEvent::StreamedAssistantText(message_id, text) => {
+                if let Some(markdown) = self.rendered_messages_by_id.get_mut(&message_id) {
+                    markdown.update(cx, |markdown, cx| {
+                        markdown.append(text, cx);
+                    });
+                }
+            }
+            ThreadEvent::MessageAdded(message_id) => {
+                if let Some(message_text) = self
+                    .thread
+                    .read(cx)
+                    .message(*message_id)
+                    .map(|message| message.text.clone())
+                {
+                    self.push_message(message_id, message_text, cx);
+                }
+
+                cx.notify();
+            }
+            ThreadEvent::UsePendingTools => {
+                let pending_tool_uses = self
+                    .thread
+                    .read(cx)
+                    .pending_tool_uses()
+                    .into_iter()
+                    .filter(|tool_use| tool_use.status.is_idle())
+                    .cloned()
+                    .collect::<Vec<_>>();
+
+                for tool_use in pending_tool_uses {
+                    if let Some(tool) = self.tools.tool(&tool_use.name, cx) {
+                        let task = tool.run(tool_use.input, self.workspace.clone(), cx);
+
+                        self.thread.update(cx, |thread, cx| {
+                            thread.insert_tool_output(
+                                tool_use.assistant_message_id,
+                                tool_use.id.clone(),
+                                task,
+                                cx,
+                            );
+                        });
+                    }
+                }
+            }
+            ThreadEvent::ToolFinished { .. } => {}
+        }
+    }
+
+    fn render_message(&self, ix: usize, cx: &mut ViewContext<Self>) -> AnyElement {
+        let message_id = self.messages[ix];
+        let Some(message) = self.thread.read(cx).message(message_id) else {
+            return Empty.into_any();
+        };
+
+        let Some(markdown) = self.rendered_messages_by_id.get(&message_id) else {
+            return Empty.into_any();
+        };
+
+        let (role_icon, role_name) = match message.role {
+            Role::User => (IconName::Person, "You"),
+            Role::Assistant => (IconName::ZedAssistant, "Assistant"),
+            Role::System => (IconName::Settings, "System"),
+        };
+
+        div()
+            .id(("message-container", ix))
+            .p_2()
+            .child(
+                v_flex()
+                    .border_1()
+                    .border_color(cx.theme().colors().border_variant)
+                    .rounded_md()
+                    .child(
+                        h_flex()
+                            .justify_between()
+                            .p_1p5()
+                            .border_b_1()
+                            .border_color(cx.theme().colors().border_variant)
+                            .child(
+                                h_flex()
+                                    .gap_2()
+                                    .child(Icon::new(role_icon).size(IconSize::Small))
+                                    .child(Label::new(role_name).size(LabelSize::Small)),
+                            ),
+                    )
+                    .child(v_flex().p_1p5().text_ui(cx).child(markdown.clone())),
+            )
+            .into_any()
+    }
+}
+
+impl Render for ActiveThread {
+    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+        list(self.list_state.clone()).flex_1()
+    }
+}
--- a/crates/assistant2/src/assistant.rs
+++ b/crates/assistant2/src/assistant.rs
@@ -1,6 +1,10 @@
+mod active_thread;
 mod assistant_panel;
+mod context_picker;
 mod message_editor;
 mod thread;
+mod thread_history;
+mod thread_store;

 use command_palette_hooks::CommandPaletteFilter;
 use feature_flags::{Assistant2FeatureFlag, FeatureFlagAppExt};
@@ -10,7 +14,13 @@ pub use crate::assistant_panel::AssistantPanel;

 actions!(
    assistant2,
-    [ToggleFocus, NewThread, ToggleModelSelector, Chat]
+    [
+        ToggleFocus,
+        NewThread,
+        ToggleModelSelector,
+        OpenHistory,
+        Chat
+    ]
 );

 const NAMESPACE: &str = "assistant2";
--- a/crates/assistant2/src/assistant_panel.rs
+++ b/crates/assistant2/src/assistant_panel.rs
@@ -2,19 +2,26 @@ use std::sync::Arc;

 use anyhow::Result;
 use assistant_tool::ToolWorkingSet;
+use client::zed_urls;
 use gpui::{
-    prelude::*, px, Action, AppContext, AsyncWindowContext, EventEmitter, FocusHandle,
-    FocusableView, Model, Pixels, Subscription, Task, View, ViewContext, WeakView, WindowContext,
+    prelude::*, px, svg, Action, AnyElement, AppContext, AsyncWindowContext, EventEmitter,
+    FocusHandle, FocusableView, FontWeight, Model, Pixels, Task, View, ViewContext, WeakView,
+    WindowContext,
 };
-use language_model::{LanguageModelRegistry, Role};
+use language::LanguageRegistry;
+use language_model::LanguageModelRegistry;
 use language_model_selector::LanguageModelSelector;
-use ui::{prelude::*, ButtonLike, Divider, IconButtonShape, Tab, Tooltip};
+use time::UtcOffset;
+use ui::{prelude::*, ButtonLike, Divider, IconButtonShape, KeyBinding, Tab, Tooltip};
 use workspace::dock::{DockPosition, Panel, PanelEvent};
 use workspace::Workspace;

+use crate::active_thread::ActiveThread;
 use crate::message_editor::MessageEditor;
-use crate::thread::{Message, Thread, ThreadEvent};
-use crate::{NewThread, ToggleFocus, ToggleModelSelector};
+use crate::thread::{ThreadError, ThreadId};
+use crate::thread_history::{PastThread, ThreadHistory};
+use crate::thread_store::ThreadStore;
+use crate::{NewThread, OpenHistory, ToggleFocus, ToggleModelSelector};

 pub fn init(cx: &mut AppContext) {
    cx.observe_new_views(
@@ -27,12 +34,21 @@ pub fn init(cx: &mut AppContext) {
    .detach();
 }

+enum ActiveView {
+    Thread,
+    History,
+}
+
 pub struct AssistantPanel {
    workspace: WeakView<Workspace>,
-    thread: Model<Thread>,
+    language_registry: Arc<LanguageRegistry>,
+    thread_store: Model<ThreadStore>,
+    thread: View<ActiveThread>,
    message_editor: View<MessageEditor>,
    tools: Arc<ToolWorkingSet>,
-    _subscriptions: Vec<Subscription>,
+    local_timezone: UtcOffset,
+    active_view: ActiveView,
+    history: View<ThreadHistory>,
 }

 impl AssistantPanel {
@@ -42,84 +58,111 @@ impl AssistantPanel {
    ) -> Task<Result<View<Self>>> {
        cx.spawn(|mut cx| async move {
            let tools = Arc::new(ToolWorkingSet::default());
+            let thread_store = workspace
+                .update(&mut cx, |workspace, cx| {
+                    let project = workspace.project().clone();
+                    ThreadStore::new(project, tools.clone(), cx)
+                })?
+                .await?;
+
            workspace.update(&mut cx, |workspace, cx| {
-                cx.new_view(|cx| Self::new(workspace, tools, cx))
+                cx.new_view(|cx| Self::new(workspace, thread_store, tools, cx))
            })
        })
    }

-    fn new(workspace: &Workspace, tools: Arc<ToolWorkingSet>, cx: &mut ViewContext<Self>) -> Self {
-        let thread = cx.new_model(|cx| Thread::new(tools.clone(), cx));
-        let subscriptions = vec![
-            cx.observe(&thread, |_, _, cx| cx.notify()),
-            cx.subscribe(&thread, Self::handle_thread_event),
-        ];
+    fn new(
+        workspace: &Workspace,
+        thread_store: Model<ThreadStore>,
+        tools: Arc<ToolWorkingSet>,
+        cx: &mut ViewContext<Self>,
+    ) -> Self {
+        let thread = thread_store.update(cx, |this, cx| this.create_thread(cx));
+        let language_registry = workspace.project().read(cx).languages().clone();
+        let workspace = workspace.weak_handle();
+        let weak_self = cx.view().downgrade();

        Self {
-            workspace: workspace.weak_handle(),
-            thread: thread.clone(),
-            message_editor: cx.new_view(|cx| MessageEditor::new(thread, cx)),
+            active_view: ActiveView::Thread,
+            workspace: workspace.clone(),
+            language_registry: language_registry.clone(),
+            thread_store: thread_store.clone(),
+            thread: cx.new_view(|cx| {
+                ActiveThread::new(
+                    thread.clone(),
+                    workspace,
+                    language_registry,
+                    tools.clone(),
+                    cx,
+                )
+            }),
+            message_editor: cx.new_view(|cx| MessageEditor::new(thread.clone(), cx)),
            tools,
-            _subscriptions: subscriptions,
+            local_timezone: UtcOffset::from_whole_seconds(
+                chrono::Local::now().offset().local_minus_utc(),
+            )
+            .unwrap(),
+            history: cx.new_view(|cx| ThreadHistory::new(weak_self, thread_store, cx)),
        }
    }

+    pub(crate) fn local_timezone(&self) -> UtcOffset {
+        self.local_timezone
+    }
+
    fn new_thread(&mut self, cx: &mut ViewContext<Self>) {
-        let tools = self.thread.read(cx).tools().clone();
-        let thread = cx.new_model(|cx| Thread::new(tools, cx));
-        let subscriptions = vec![
-            cx.observe(&thread, |_, _, cx| cx.notify()),
-            cx.subscribe(&thread, Self::handle_thread_event),
-        ];
-
-        self.message_editor = cx.new_view(|cx| MessageEditor::new(thread.clone(), cx));
-        self.thread = thread;
-        self._subscriptions = subscriptions;
+        let thread = self
+            .thread_store
+            .update(cx, |this, cx| this.create_thread(cx));

+        self.active_view = ActiveView::Thread;
+        self.thread = cx.new_view(|cx| {
+            ActiveThread::new(
+                thread.clone(),
+                self.workspace.clone(),
+                self.language_registry.clone(),
+                self.tools.clone(),
+                cx,
+            )
+        });
+        self.message_editor = cx.new_view(|cx| MessageEditor::new(thread, cx));
        self.message_editor.focus_handle(cx).focus(cx);
    }

-    fn handle_thread_event(
-        &mut self,
-        _: Model<Thread>,
-        event: &ThreadEvent,
-        cx: &mut ViewContext<Self>,
-    ) {
-        match event {
-            ThreadEvent::StreamedCompletion => {}
-            ThreadEvent::UsePendingTools => {
-                let pending_tool_uses = self
-                    .thread
-                    .read(cx)
-                    .pending_tool_uses()
-                    .into_iter()
-                    .filter(|tool_use| tool_use.status.is_idle())
-                    .cloned()
-                    .collect::<Vec<_>>();
+    pub(crate) fn open_thread(&mut self, thread_id: &ThreadId, cx: &mut ViewContext<Self>) {
+        let Some(thread) = self
+            .thread_store
+            .update(cx, |this, cx| this.open_thread(thread_id, cx))
+        else {
+            return;
+        };

-                for tool_use in pending_tool_uses {
-                    if let Some(tool) = self.tools.tool(&tool_use.name, cx) {
-                        let task = tool.run(tool_use.input, self.workspace.clone(), cx);
+        self.active_view = ActiveView::Thread;
+        self.thread = cx.new_view(|cx| {
+            ActiveThread::new(
+                thread.clone(),
+                self.workspace.clone(),
+                self.language_registry.clone(),
+                self.tools.clone(),
+                cx,
+            )
+        });
+        self.message_editor = cx.new_view(|cx| MessageEditor::new(thread, cx));
+        self.message_editor.focus_handle(cx).focus(cx);
+    }

-                        self.thread.update(cx, |thread, cx| {
-                            thread.insert_tool_output(
-                                tool_use.assistant_message_id,
-                                tool_use.id.clone(),
-                                task,
-                                cx,
-                            );
-                        });
-                    }
-                }
-            }
-            ThreadEvent::ToolFinished { .. } => {}
-        }
+    pub(crate) fn delete_thread(&mut self, thread_id: &ThreadId, cx: &mut ViewContext<Self>) {
+        self.thread_store
+            .update(cx, |this, cx| this.delete_thread(thread_id, cx));
    }
 }

 impl FocusableView for AssistantPanel {
    fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
-        self.message_editor.focus_handle(cx)
+        match self.active_view {
+            ActiveView::Thread => self.message_editor.focus_handle(cx),
+            ActiveView::History => self.history.focus_handle(cx),
+        }
    }
 }

@@ -178,7 +221,7 @@ impl AssistantPanel {
            .bg(cx.theme().colors().tab_bar_background)
            .border_b_1()
            .border_color(cx.theme().colors().border_variant)
-            .child(h_flex().child(Label::new("Thread Title Goes Here")))
+            .child(h_flex().children(self.thread.read(cx).summary(cx).map(Label::new)))
            .child(
                h_flex()
                    .gap(DynamicSpacing::Base08.rems(cx))
@@ -200,8 +243,8 @@ impl AssistantPanel {
                                    )
                                }
                            })
-                            .on_click(move |_event, _cx| {
-                                println!("New Thread");
+                            .on_click(move |_event, cx| {
+                                cx.dispatch_action(NewThread.boxed_clone());
                            }),
                    )
                    .child(
@@ -209,9 +252,19 @@ impl AssistantPanel {
                            .shape(IconButtonShape::Square)
                            .icon_size(IconSize::Small)
                            .style(ButtonStyle::Subtle)
-                            .tooltip(move |cx| Tooltip::text("Open History", cx))
-                            .on_click(move |_event, _cx| {
-                                println!("Open History");
+                            .tooltip({
+                                let focus_handle = focus_handle.clone();
+                                move |cx| {
+                                    Tooltip::for_action_in(
+                                        "Open History",
+                                        &OpenHistory,
+                                        &focus_handle,
+                                        cx,
+                                    )
+                                }
+                            })
+                            .on_click(move |_event, cx| {
+                                cx.dispatch_action(OpenHistory.boxed_clone());
                            }),
                    )
                    .child(
@@ -278,38 +331,270 @@ impl AssistantPanel {
        )
    }

-    fn render_message(&self, message: Message, cx: &mut ViewContext<Self>) -> impl IntoElement {
-        let (role_icon, role_name) = match message.role {
-            Role::User => (IconName::Person, "You"),
-            Role::Assistant => (IconName::ZedAssistant, "Assistant"),
-            Role::System => (IconName::Settings, "System"),
-        };
+    fn render_active_thread_or_empty_state(&self, cx: &mut ViewContext<Self>) -> AnyElement {
+        if self.thread.read(cx).is_empty() {
+            return self.render_thread_empty_state(cx).into_any_element();
+        }
+
+        self.thread.clone().into_any()
+    }
+
+    fn render_thread_empty_state(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let recent_threads = self
+            .thread_store
+            .update(cx, |this, cx| this.recent_threads(3, cx));

        v_flex()
-            .border_1()
-            .border_color(cx.theme().colors().border_variant)
-            .rounded_md()
+            .gap_2()
+            .mx_auto()
+            .child(
+                v_flex().w_full().child(
+                    svg()
+                        .path("icons/logo_96.svg")
+                        .text_color(cx.theme().colors().text)
+                        .w(px(40.))
+                        .h(px(40.))
+                        .mx_auto()
+                        .mb_4(),
+                ),
+            )
+            .child(v_flex())
            .child(
                h_flex()
-                    .justify_between()
-                    .p_1p5()
-                    .border_b_1()
-                    .border_color(cx.theme().colors().border_variant)
+                    .w_full()
+                    .justify_center()
+                    .child(Label::new("Context Examples:").size(LabelSize::Small)),
+            )
+            .child(
+                h_flex()
+                    .gap_2()
+                    .justify_center()
                    .child(
                        h_flex()
-                            .gap_2()
-                            .child(Icon::new(role_icon).size(IconSize::Small))
-                            .child(Label::new(role_name).size(LabelSize::Small)),
+                            .gap_1()
+                            .p_0p5()
+                            .rounded_md()
+                            .border_1()
+                            .border_color(cx.theme().colors().border_variant)
+                            .child(
+                                Icon::new(IconName::Terminal)
+                                    .size(IconSize::Small)
+                                    .color(Color::Disabled),
+                            )
+                            .child(Label::new("Terminal").size(LabelSize::Small)),
+                    )
+                    .child(
+                        h_flex()
+                            .gap_1()
+                            .p_0p5()
+                            .rounded_md()
+                            .border_1()
+                            .border_color(cx.theme().colors().border_variant)
+                            .child(
+                                Icon::new(IconName::Folder)
+                                    .size(IconSize::Small)
+                                    .color(Color::Disabled),
+                            )
+                            .child(Label::new("/src/components").size(LabelSize::Small)),
                    ),
            )
-            .child(v_flex().p_1p5().child(Label::new(message.text.clone())))
+            .when(!recent_threads.is_empty(), |parent| {
+                parent
+                    .child(
+                        h_flex()
+                            .w_full()
+                            .justify_center()
+                            .child(Label::new("Recent Threads:").size(LabelSize::Small)),
+                    )
+                    .child(
+                        v_flex().gap_2().children(
+                            recent_threads
+                                .into_iter()
+                                .map(|thread| PastThread::new(thread, cx.view().downgrade())),
+                        ),
+                    )
+                    .child(
+                        h_flex().w_full().justify_center().child(
+                            Button::new("view-all-past-threads", "View All Past Threads")
+                                .style(ButtonStyle::Subtle)
+                                .label_size(LabelSize::Small)
+                                .key_binding(KeyBinding::for_action_in(
+                                    &OpenHistory,
+                                    &self.focus_handle(cx),
+                                    cx,
+                                ))
+                                .on_click(move |_event, cx| {
+                                    cx.dispatch_action(OpenHistory.boxed_clone());
+                                }),
+                        ),
+                    )
+            })
+    }
+
+    fn render_last_error(&self, cx: &mut ViewContext<Self>) -> Option<AnyElement> {
+        let last_error = self.thread.read(cx).last_error()?;
+
+        Some(
+            div()
+                .absolute()
+                .right_3()
+                .bottom_12()
+                .max_w_96()
+                .py_2()
+                .px_3()
+                .elevation_2(cx)
+                .occlude()
+                .child(match last_error {
+                    ThreadError::PaymentRequired => self.render_payment_required_error(cx),
+                    ThreadError::MaxMonthlySpendReached => {
+                        self.render_max_monthly_spend_reached_error(cx)
+                    }
+                    ThreadError::Message(error_message) => {
+                        self.render_error_message(&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.";
+
+        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.thread.update(cx, |this, _cx| {
+                                this.clear_last_error();
+                            });
+
+                            cx.open_url(&zed_urls::account_url(cx));
+                            cx.notify();
+                        },
+                    )))
+                    .child(Button::new("dismiss", "Dismiss").on_click(cx.listener(
+                        |this, _, cx| {
+                            this.thread.update(cx, |this, _cx| {
+                                this.clear_last_error();
+                            });
+
+                            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.";
+
+        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.thread.update(cx, |this, _cx| {
+                                    this.clear_last_error();
+                                });
+
+                                cx.open_url(&zed_urls::account_url(cx));
+                                cx.notify();
+                            }),
+                        ),
+                    )
+                    .child(Button::new("dismiss", "Dismiss").on_click(cx.listener(
+                        |this, _, cx| {
+                            this.thread.update(cx, |this, _cx| {
+                                this.clear_last_error();
+                            });
+
+                            cx.notify();
+                        },
+                    ))),
+            )
+            .into_any()
+    }
+
+    fn render_error_message(
+        &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_32()
+                    .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.thread.update(cx, |this, _cx| {
+                                this.clear_last_error();
+                            });
+
+                            cx.notify();
+                        },
+                    ))),
+            )
+            .into_any()
    }
 }

 impl Render for AssistantPanel {
    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
-        let messages = self.thread.read(cx).messages().cloned().collect::<Vec<_>>();
-
        v_flex()
            .key_context("AssistantPanel2")
            .justify_between()
@@ -317,26 +602,23 @@ impl Render for AssistantPanel {
            .on_action(cx.listener(|this, _: &NewThread, cx| {
                this.new_thread(cx);
            }))
+            .on_action(cx.listener(|this, _: &OpenHistory, cx| {
+                this.active_view = ActiveView::History;
+                this.history.focus_handle(cx).focus(cx);
+                cx.notify();
+            }))
            .child(self.render_toolbar(cx))
-            .child(
-                v_flex()
-                    .id("message-list")
-                    .gap_2()
-                    .size_full()
-                    .p_2()
-                    .overflow_y_scroll()
-                    .bg(cx.theme().colors().panel_background)
-                    .children(
-                        messages
-                            .into_iter()
-                            .map(|message| self.render_message(message, cx)),
-                    ),
-            )
-            .child(
-                h_flex()
-                    .border_t_1()
-                    .border_color(cx.theme().colors().border_variant)
-                    .child(self.message_editor.clone()),
-            )
+            .map(|parent| match self.active_view {
+                ActiveView::Thread => parent
+                    .child(self.render_active_thread_or_empty_state(cx))
+                    .child(
+                        h_flex()
+                            .border_t_1()
+                            .border_color(cx.theme().colors().border_variant)
+                            .child(self.message_editor.clone()),
+                    )
+                    .children(self.render_last_error(cx)),
+                ActiveView::History => parent.child(self.history.clone()),
+            })
    }
 }
--- a/crates/assistant2/src/context_picker.rs
+++ b/crates/assistant2/src/context_picker.rs
@@ -0,0 +1,197 @@
+use std::sync::Arc;
+
+use gpui::{DismissEvent, SharedString, Task, WeakView};
+use picker::{Picker, PickerDelegate, PickerEditorPosition};
+use ui::{prelude::*, ListItem, ListItemSpacing, PopoverMenu, PopoverTrigger, Tooltip};
+
+use crate::message_editor::MessageEditor;
+
+#[derive(IntoElement)]
+pub(super) struct ContextPicker<T: PopoverTrigger> {
+    message_editor: WeakView<MessageEditor>,
+    trigger: T,
+}
+
+#[derive(Clone)]
+struct ContextPickerEntry {
+    name: SharedString,
+    description: SharedString,
+    icon: IconName,
+}
+
+pub(crate) struct ContextPickerDelegate {
+    all_entries: Vec<ContextPickerEntry>,
+    filtered_entries: Vec<ContextPickerEntry>,
+    message_editor: WeakView<MessageEditor>,
+    selected_ix: usize,
+}
+
+impl<T: PopoverTrigger> ContextPicker<T> {
+    pub(crate) fn new(message_editor: WeakView<MessageEditor>, trigger: T) -> Self {
+        ContextPicker {
+            message_editor,
+            trigger,
+        }
+    }
+}
+
+impl PickerDelegate for ContextPickerDelegate {
+    type ListItem = ListItem;
+
+    fn match_count(&self) -> usize {
+        self.filtered_entries.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_ix
+    }
+
+    fn set_selected_index(&mut self, ix: usize, cx: &mut ViewContext<Picker<Self>>) {
+        self.selected_ix = ix.min(self.filtered_entries.len().saturating_sub(1));
+        cx.notify();
+    }
+
+    fn placeholder_text(&self, _cx: &mut WindowContext) -> Arc<str> {
+        "Select a context source…".into()
+    }
+
+    fn update_matches(&mut self, query: String, cx: &mut ViewContext<Picker<Self>>) -> Task<()> {
+        let all_commands = self.all_entries.clone();
+        cx.spawn(|this, mut cx| async move {
+            let filtered_commands = cx
+                .background_executor()
+                .spawn(async move {
+                    if query.is_empty() {
+                        all_commands
+                    } else {
+                        all_commands
+                            .into_iter()
+                            .filter(|model_info| {
+                                model_info
+                                    .name
+                                    .to_lowercase()
+                                    .contains(&query.to_lowercase())
+                            })
+                            .collect()
+                    }
+                })
+                .await;
+
+            this.update(&mut cx, |this, cx| {
+                this.delegate.filtered_entries = filtered_commands;
+                this.delegate.set_selected_index(0, cx);
+                cx.notify();
+            })
+            .ok();
+        })
+    }
+
+    fn confirm(&mut self, _secondary: bool, cx: &mut ViewContext<Picker<Self>>) {
+        if let Some(entry) = self.filtered_entries.get(self.selected_ix) {
+            self.message_editor
+                .update(cx, |_message_editor, _cx| {
+                    println!("Insert context from {}", entry.name);
+                })
+                .ok();
+            cx.emit(DismissEvent);
+        }
+    }
+
+    fn dismissed(&mut self, _cx: &mut ViewContext<Picker<Self>>) {}
+
+    fn editor_position(&self) -> PickerEditorPosition {
+        PickerEditorPosition::End
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _cx: &mut ViewContext<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        let entry = self.filtered_entries.get(ix)?;
+
+        Some(
+            ListItem::new(ix)
+                .inset(true)
+                .spacing(ListItemSpacing::Dense)
+                .selected(selected)
+                .tooltip({
+                    let description = entry.description.clone();
+                    move |cx| cx.new_view(|_cx| Tooltip::new(description.clone())).into()
+                })
+                .child(
+                    v_flex()
+                        .group(format!("context-entry-label-{ix}"))
+                        .w_full()
+                        .py_0p5()
+                        .min_w(px(250.))
+                        .max_w(px(400.))
+                        .child(
+                            h_flex()
+                                .gap_1p5()
+                                .child(Icon::new(entry.icon).size(IconSize::XSmall))
+                                .child(
+                                    Label::new(entry.name.clone())
+                                        .single_line()
+                                        .size(LabelSize::Small),
+                                ),
+                        )
+                        .child(
+                            div().overflow_hidden().text_ellipsis().child(
+                                Label::new(entry.description.clone())
+                                    .size(LabelSize::Small)
+                                    .color(Color::Muted),
+                            ),
+                        ),
+                ),
+        )
+    }
+}
+
+impl<T: PopoverTrigger> RenderOnce for ContextPicker<T> {
+    fn render(self, cx: &mut WindowContext) -> impl IntoElement {
+        let entries = vec![
+            ContextPickerEntry {
+                name: "directory".into(),
+                description: "Insert any directory".into(),
+                icon: IconName::Folder,
+            },
+            ContextPickerEntry {
+                name: "file".into(),
+                description: "Insert any file".into(),
+                icon: IconName::File,
+            },
+            ContextPickerEntry {
+                name: "web".into(),
+                description: "Fetch content from URL".into(),
+                icon: IconName::Globe,
+            },
+        ];
+
+        let delegate = ContextPickerDelegate {
+            all_entries: entries.clone(),
+            message_editor: self.message_editor.clone(),
+            filtered_entries: entries,
+            selected_ix: 0,
+        };
+
+        let picker =
+            cx.new_view(|cx| Picker::uniform_list(delegate, cx).max_height(Some(rems(20.).into())));
+
+        let handle = self
+            .message_editor
+            .update(cx, |this, _| this.context_picker_handle.clone())
+            .ok();
+        PopoverMenu::new("context-picker")
+            .menu(move |_cx| Some(picker.clone()))
+            .trigger(self.trigger)
+            .attach(gpui::AnchorCorner::TopLeft)
+            .anchor(gpui::AnchorCorner::BottomLeft)
+            .offset(gpui::Point {
+                x: px(0.0),
+                y: px(-16.0),
+            })
+            .when_some(handle, |this, handle| this.with_handle(handle))
+    }
+}
--- a/crates/assistant2/src/message_editor.rs
+++ b/crates/assistant2/src/message_editor.rs
@@ -1,16 +1,22 @@
 use editor::{Editor, EditorElement, EditorStyle};
 use gpui::{AppContext, FocusableView, Model, TextStyle, View};
 use language_model::{LanguageModelRegistry, LanguageModelRequestTool};
+use picker::Picker;
 use settings::Settings;
 use theme::ThemeSettings;
-use ui::{prelude::*, ButtonLike, CheckboxWithLabel, ElevationIndex, KeyBinding};
+use ui::{
+    prelude::*, ButtonLike, CheckboxWithLabel, ElevationIndex, IconButtonShape, KeyBinding,
+    PopoverMenuHandle,
+};

+use crate::context_picker::{ContextPicker, ContextPickerDelegate};
 use crate::thread::{RequestKind, Thread};
 use crate::Chat;

 pub struct MessageEditor {
    thread: Model<Thread>,
    editor: View<Editor>,
+    pub(crate) context_picker_handle: PopoverMenuHandle<Picker<ContextPickerDelegate>>,
    use_tools: bool,
 }

@@ -24,6 +30,7 @@ impl MessageEditor {

                editor
            }),
+            context_picker_handle: PopoverMenuHandle::default(),
            use_tools: false,
        }
    }
@@ -56,7 +63,7 @@ impl MessageEditor {
        });

        self.thread.update(cx, |thread, cx| {
-            thread.insert_user_message(user_message);
+            thread.insert_user_message(user_message, cx);
            let mut request = thread.to_completion_request(request_kind, cx);

            if self.use_tools {
@@ -98,6 +105,14 @@ impl Render for MessageEditor {
            .gap_2()
            .p_2()
            .bg(cx.theme().colors().editor_background)
+            .child(
+                h_flex().gap_2().child(ContextPicker::new(
+                    cx.view().downgrade(),
+                    IconButton::new("add-context", IconName::Plus)
+                        .shape(IconButtonShape::Square)
+                        .icon_size(IconSize::Small),
+                )),
+            )
            .child({
                let settings = ThemeSettings::get_global(cx);
                let text_style = TextStyle {
@@ -123,26 +138,17 @@ impl Render for MessageEditor {
            .child(
                h_flex()
                    .justify_between()
-                    .child(
-                        h_flex()
-                            .child(
-                                Button::new("add-context", "Add Context")
-                                    .style(ButtonStyle::Filled)
-                                    .icon(IconName::Plus)
-                                    .icon_position(IconPosition::Start),
-                            )
-                            .child(CheckboxWithLabel::new(
-                                "use-tools",
-                                Label::new("Tools"),
-                                self.use_tools.into(),
-                                cx.listener(|this, selection, _cx| {
-                                    this.use_tools = match selection {
-                                        Selection::Selected => true,
-                                        Selection::Unselected | Selection::Indeterminate => false,
-                                    };
-                                }),
-                            )),
-                    )
+                    .child(h_flex().gap_2().child(CheckboxWithLabel::new(
+                        "use-tools",
+                        Label::new("Tools"),
+                        self.use_tools.into(),
+                        cx.listener(|this, selection, _cx| {
+                            this.use_tools = match selection {
+                                Selection::Selected => true,
+                                Selection::Unselected | Selection::Indeterminate => false,
+                            };
+                        }),
+                    )))
                    .child(
                        h_flex()
                            .gap_2()
--- a/crates/assistant2/src/thread.rs
+++ b/crates/assistant2/src/thread.rs
@@ -2,23 +2,41 @@ use std::sync::Arc;

 use anyhow::Result;
 use assistant_tool::ToolWorkingSet;
+use chrono::{DateTime, Utc};
 use collections::HashMap;
 use futures::future::Shared;
 use futures::{FutureExt as _, StreamExt as _};
-use gpui::{AppContext, EventEmitter, ModelContext, Task};
+use gpui::{AppContext, EventEmitter, ModelContext, SharedString, Task};
 use language_model::{
-    LanguageModel, LanguageModelCompletionEvent, LanguageModelRequest, LanguageModelRequestMessage,
-    LanguageModelToolResult, LanguageModelToolUse, LanguageModelToolUseId, MessageContent, Role,
-    StopReason,
+    LanguageModel, LanguageModelCompletionEvent, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, LanguageModelToolResult, LanguageModelToolUse,
+    LanguageModelToolUseId, MessageContent, Role, StopReason,
 };
+use language_models::provider::cloud::{MaxMonthlySpendReachedError, PaymentRequiredError};
 use serde::{Deserialize, Serialize};
-use util::post_inc;
+use util::{post_inc, TryFutureExt as _};
+use uuid::Uuid;

 #[derive(Debug, Clone, Copy)]
 pub enum RequestKind {
    Chat,
 }

+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Serialize, Deserialize)]
+pub struct ThreadId(Arc<str>);
+
+impl ThreadId {
+    pub fn new() -> Self {
+        Self(Uuid::new_v4().to_string().into())
+    }
+}
+
+impl std::fmt::Display for ThreadId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Serialize, Deserialize)]
 pub struct MessageId(usize);

@@ -38,6 +56,10 @@ pub struct Message {

 /// A thread of conversation with the LLM.
 pub struct Thread {
+    id: ThreadId,
+    updated_at: DateTime<Utc>,
+    summary: Option<SharedString>,
+    pending_summary: Task<Option<()>>,
    messages: Vec<Message>,
    next_message_id: MessageId,
    completion_count: usize,
@@ -51,6 +73,10 @@ pub struct Thread {
 impl Thread {
    pub fn new(tools: Arc<ToolWorkingSet>, _cx: &mut ModelContext<Self>) -> Self {
        Self {
+            id: ThreadId::new(),
+            updated_at: Utc::now(),
+            summary: None,
+            pending_summary: Task::ready(None),
            messages: Vec::new(),
            next_message_id: MessageId(0),
            completion_count: 0,
@@ -62,6 +88,35 @@ impl Thread {
        }
    }

+    pub fn id(&self) -> &ThreadId {
+        &self.id
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.messages.is_empty()
+    }
+
+    pub fn updated_at(&self) -> DateTime<Utc> {
+        self.updated_at
+    }
+
+    pub fn touch_updated_at(&mut self) {
+        self.updated_at = Utc::now();
+    }
+
+    pub fn summary(&self) -> Option<SharedString> {
+        self.summary.clone()
+    }
+
+    pub fn set_summary(&mut self, summary: impl Into<SharedString>, cx: &mut ModelContext<Self>) {
+        self.summary = Some(summary.into());
+        cx.emit(ThreadEvent::SummaryChanged);
+    }
+
+    pub fn message(&self, id: MessageId) -> Option<&Message> {
+        self.messages.iter().find(|message| message.id == id)
+    }
+
    pub fn messages(&self) -> impl Iterator<Item = &Message> {
        self.messages.iter()
    }
@@ -74,12 +129,24 @@ impl Thread {
        self.pending_tool_uses_by_id.values().collect()
    }

-    pub fn insert_user_message(&mut self, text: impl Into<String>) {
+    pub fn insert_user_message(&mut self, text: impl Into<String>, cx: &mut ModelContext<Self>) {
+        self.insert_message(Role::User, text, cx)
+    }
+
+    pub fn insert_message(
+        &mut self,
+        role: Role,
+        text: impl Into<String>,
+        cx: &mut ModelContext<Self>,
+    ) {
+        let id = self.next_message_id.post_inc();
        self.messages.push(Message {
-            id: self.next_message_id.post_inc(),
-            role: Role::User,
+            id,
+            role,
            text: text.into(),
        });
+        self.touch_updated_at();
+        cx.emit(ThreadEvent::MessageAdded(id));
    }

    pub fn to_completion_request(
@@ -149,11 +216,7 @@ impl Thread {
                    thread.update(&mut cx, |thread, cx| {
                        match event {
                            LanguageModelCompletionEvent::StartMessage { .. } => {
-                                thread.messages.push(Message {
-                                    id: thread.next_message_id.post_inc(),
-                                    role: Role::Assistant,
-                                    text: String::new(),
-                                });
+                                thread.insert_message(Role::Assistant, String::new(), cx);
                            }
                            LanguageModelCompletionEvent::Stop(reason) => {
                                stop_reason = reason;
@@ -162,6 +225,10 @@ impl Thread {
                                if let Some(last_message) = thread.messages.last_mut() {
                                    if last_message.role == Role::Assistant {
                                        last_message.text.push_str(&chunk);
+                                        cx.emit(ThreadEvent::StreamedAssistantText(
+                                            last_message.id,
+                                            chunk,
+                                        ));
                                    }
                                }
                            }
@@ -191,6 +258,7 @@ impl Thread {
                            }
                        }

+                        thread.touch_updated_at();
                        cx.emit(ThreadEvent::StreamedCompletion);
                        cx.notify();
                    })?;
@@ -198,10 +266,14 @@ impl Thread {
                    smol::future::yield_now().await;
                }

-                thread.update(&mut cx, |thread, _cx| {
+                thread.update(&mut cx, |thread, cx| {
                    thread
                        .pending_completions
                        .retain(|completion| completion.id != pending_completion_id);
+
+                    if thread.summary.is_none() && thread.messages.len() >= 2 {
+                        thread.summarize(cx);
+                    }
                })?;

                anyhow::Ok(stop_reason)
@@ -210,29 +282,28 @@ impl Thread {
            let result = stream_completion.await;

            thread
-                .update(&mut cx, |_thread, cx| {
-                    let error_message = if let Some(error) = result.as_ref().err() {
-                        let error_message = error
-                            .chain()
-                            .map(|err| err.to_string())
-                            .collect::<Vec<_>>()
-                            .join("\n");
-                        Some(error_message)
-                    } else {
-                        None
-                    };
-
-                    if let Some(error_message) = error_message {
-                        eprintln!("Completion failed: {error_message:?}");
-                    }
-
-                    if let Ok(stop_reason) = result {
-                        match stop_reason {
-                            StopReason::ToolUse => {
-                                cx.emit(ThreadEvent::UsePendingTools);
-                            }
-                            StopReason::EndTurn => {}
-                            StopReason::MaxTokens => {}
+                .update(&mut cx, |_thread, cx| match result.as_ref() {
+                    Ok(stop_reason) => match stop_reason {
+                        StopReason::ToolUse => {
+                            cx.emit(ThreadEvent::UsePendingTools);
+                        }
+                        StopReason::EndTurn => {}
+                        StopReason::MaxTokens => {}
+                    },
+                    Err(error) => {
+                        if error.is::<PaymentRequiredError>() {
+                            cx.emit(ThreadEvent::ShowError(ThreadError::PaymentRequired));
+                        } else if error.is::<MaxMonthlySpendReachedError>() {
+                            cx.emit(ThreadEvent::ShowError(ThreadError::MaxMonthlySpendReached));
+                        } else {
+                            let error_message = error
+                                .chain()
+                                .map(|err| err.to_string())
+                                .collect::<Vec<_>>()
+                                .join("\n");
+                            cx.emit(ThreadEvent::ShowError(ThreadError::Message(
+                                SharedString::from(error_message.clone()),
+                            )));
                        }
                    }
                })
@@ -245,6 +316,59 @@ impl Thread {
        });
    }

+    pub fn summarize(&mut self, cx: &mut ModelContext<Self>) {
+        let Some(provider) = LanguageModelRegistry::read_global(cx).active_provider() else {
+            return;
+        };
+        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
+            return;
+        };
+
+        if !provider.is_authenticated(cx) {
+            return;
+        }
+
+        let mut request = self.to_completion_request(RequestKind::Chat, cx);
+        request.messages.push(LanguageModelRequestMessage {
+            role: Role::User,
+            content: vec![
+                "Generate a concise 3-7 word title for this conversation, omitting punctuation. Go straight to the title, without any preamble and prefix like `Here's a concise suggestion:...` or `Title:`"
+                    .into(),
+            ],
+            cache: false,
+        });
+
+        self.pending_summary = cx.spawn(|this, mut cx| {
+            async move {
+                let stream = model.stream_completion_text(request, &cx);
+                let mut messages = stream.await?;
+
+                let mut new_summary = String::new();
+                while let Some(message) = messages.stream.next().await {
+                    let text = message?;
+                    let mut lines = text.lines();
+                    new_summary.extend(lines.next());
+
+                    // Stop if the LLM generated multiple lines.
+                    if lines.next().is_some() {
+                        break;
+                    }
+                }
+
+                this.update(&mut cx, |this, cx| {
+                    if !new_summary.is_empty() {
+                        this.summary = Some(new_summary.into());
+                    }
+
+                    cx.emit(ThreadEvent::SummaryChanged);
+                })?;
+
+                anyhow::Ok(())
+            }
+            .log_err()
+        });
+    }
+
    pub fn insert_tool_output(
        &mut self,
        assistant_message_id: MessageId,
@@ -305,9 +429,20 @@ impl Thread {
    }
 }

+#[derive(Debug, Clone)]
+pub enum ThreadError {
+    PaymentRequired,
+    MaxMonthlySpendReached,
+    Message(SharedString),
+}
+
 #[derive(Debug, Clone)]
 pub enum ThreadEvent {
+    ShowError(ThreadError),
    StreamedCompletion,
+    StreamedAssistantText(MessageId, String),
+    MessageAdded(MessageId),
+    SummaryChanged,
    UsePendingTools,
    ToolFinished {
        #[allow(unused)]
--- a/crates/assistant2/src/thread_history.rs
+++ b/crates/assistant2/src/thread_history.rs
@@ -0,0 +1,156 @@
+use gpui::{
+    uniform_list, AppContext, FocusHandle, FocusableView, Model, UniformListScrollHandle, WeakView,
+};
+use time::{OffsetDateTime, UtcOffset};
+use ui::{prelude::*, IconButtonShape, ListItem};
+
+use crate::thread::Thread;
+use crate::thread_store::ThreadStore;
+use crate::AssistantPanel;
+
+pub struct ThreadHistory {
+    focus_handle: FocusHandle,
+    assistant_panel: WeakView<AssistantPanel>,
+    thread_store: Model<ThreadStore>,
+    scroll_handle: UniformListScrollHandle,
+}
+
+impl ThreadHistory {
+    pub(crate) fn new(
+        assistant_panel: WeakView<AssistantPanel>,
+        thread_store: Model<ThreadStore>,
+        cx: &mut ViewContext<Self>,
+    ) -> Self {
+        Self {
+            focus_handle: cx.focus_handle(),
+            assistant_panel,
+            thread_store,
+            scroll_handle: UniformListScrollHandle::default(),
+        }
+    }
+}
+
+impl FocusableView for ThreadHistory {
+    fn focus_handle(&self, _cx: &AppContext) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for ThreadHistory {
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let threads = self.thread_store.update(cx, |this, cx| this.threads(cx));
+
+        v_flex()
+            .id("thread-history-container")
+            .track_focus(&self.focus_handle)
+            .overflow_y_scroll()
+            .size_full()
+            .p_1()
+            .map(|history| {
+                if threads.is_empty() {
+                    history
+                        .justify_center()
+                        .child(
+                            h_flex().w_full().justify_center().child(
+                                Label::new("You don't have any past threads yet.")
+                                    .size(LabelSize::Small),
+                            ),
+                        )
+                } else {
+                    history.child(
+                        uniform_list(
+                            cx.view().clone(),
+                            "thread-history",
+                            threads.len(),
+                            move |history, range, _cx| {
+                                threads[range]
+                                    .iter()
+                                    .map(|thread| {
+                                        PastThread::new(
+                                            thread.clone(),
+                                            history.assistant_panel.clone(),
+                                        )
+                                    })
+                                    .collect()
+                            },
+                        )
+                        .track_scroll(self.scroll_handle.clone())
+                        .flex_grow(),
+                    )
+                }
+            })
+    }
+}
+
+#[derive(IntoElement)]
+pub struct PastThread {
+    thread: Model<Thread>,
+    assistant_panel: WeakView<AssistantPanel>,
+}
+
+impl PastThread {
+    pub fn new(thread: Model<Thread>, assistant_panel: WeakView<AssistantPanel>) -> Self {
+        Self {
+            thread,
+            assistant_panel,
+        }
+    }
+}
+
+impl RenderOnce for PastThread {
+    fn render(self, cx: &mut WindowContext) -> impl IntoElement {
+        let (id, summary) = {
+            const DEFAULT_SUMMARY: SharedString = SharedString::new_static("New Thread");
+            let thread = self.thread.read(cx);
+            (
+                thread.id().clone(),
+                thread.summary().unwrap_or(DEFAULT_SUMMARY),
+            )
+        };
+
+        let thread_timestamp = time_format::format_localized_timestamp(
+            OffsetDateTime::from_unix_timestamp(self.thread.read(cx).updated_at().timestamp())
+                .unwrap(),
+            OffsetDateTime::now_utc(),
+            self.assistant_panel
+                .update(cx, |this, _cx| this.local_timezone())
+                .unwrap_or(UtcOffset::UTC),
+            time_format::TimestampFormat::EnhancedAbsolute,
+        );
+        ListItem::new(("past-thread", self.thread.entity_id()))
+            .start_slot(Icon::new(IconName::MessageBubbles))
+            .child(Label::new(summary))
+            .end_slot(
+                h_flex()
+                    .gap_2()
+                    .child(Label::new(thread_timestamp).color(Color::Disabled))
+                    .child(
+                        IconButton::new("delete", IconName::TrashAlt)
+                            .shape(IconButtonShape::Square)
+                            .icon_size(IconSize::Small)
+                            .on_click({
+                                let assistant_panel = self.assistant_panel.clone();
+                                let id = id.clone();
+                                move |_event, cx| {
+                                    assistant_panel
+                                        .update(cx, |this, cx| {
+                                            this.delete_thread(&id, cx);
+                                        })
+                                        .ok();
+                                }
+                            }),
+                    ),
+            )
+            .on_click({
+                let assistant_panel = self.assistant_panel.clone();
+                let id = id.clone();
+                move |_event, cx| {
+                    assistant_panel
+                        .update(cx, |this, cx| {
+                            this.open_thread(&id, cx);
+                        })
+                        .ok();
+                }
+            })
+    }
+}
--- a/crates/assistant2/src/thread_store.rs
+++ b/crates/assistant2/src/thread_store.rs
@@ -0,0 +1,242 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use assistant_tool::{ToolId, ToolWorkingSet};
+use collections::HashMap;
+use context_server::manager::ContextServerManager;
+use context_server::{ContextServerFactoryRegistry, ContextServerTool};
+use gpui::{prelude::*, AppContext, Model, ModelContext, Task};
+use project::Project;
+use unindent::Unindent;
+use util::ResultExt as _;
+
+use crate::thread::{Thread, ThreadId};
+
+pub struct ThreadStore {
+    #[allow(unused)]
+    project: Model<Project>,
+    tools: Arc<ToolWorkingSet>,
+    context_server_manager: Model<ContextServerManager>,
+    context_server_tool_ids: HashMap<Arc<str>, Vec<ToolId>>,
+    threads: Vec<Model<Thread>>,
+}
+
+impl ThreadStore {
+    pub fn new(
+        project: Model<Project>,
+        tools: Arc<ToolWorkingSet>,
+        cx: &mut AppContext,
+    ) -> Task<Result<Model<Self>>> {
+        cx.spawn(|mut cx| async move {
+            let this = cx.new_model(|cx: &mut ModelContext<Self>| {
+                let context_server_factory_registry =
+                    ContextServerFactoryRegistry::default_global(cx);
+                let context_server_manager = cx.new_model(|cx| {
+                    ContextServerManager::new(context_server_factory_registry, project.clone(), cx)
+                });
+
+                let mut this = Self {
+                    project,
+                    tools,
+                    context_server_manager,
+                    context_server_tool_ids: HashMap::default(),
+                    threads: Vec::new(),
+                };
+                this.mock_recent_threads(cx);
+                this.register_context_server_handlers(cx);
+
+                this
+            })?;
+
+            Ok(this)
+        })
+    }
+
+    pub fn threads(&self, cx: &ModelContext<Self>) -> Vec<Model<Thread>> {
+        let mut threads = self
+            .threads
+            .iter()
+            .filter(|thread| !thread.read(cx).is_empty())
+            .cloned()
+            .collect::<Vec<_>>();
+        threads.sort_unstable_by_key(|thread| std::cmp::Reverse(thread.read(cx).updated_at()));
+        threads
+    }
+
+    pub fn recent_threads(&self, limit: usize, cx: &ModelContext<Self>) -> Vec<Model<Thread>> {
+        self.threads(cx).into_iter().take(limit).collect()
+    }
+
+    pub fn create_thread(&mut self, cx: &mut ModelContext<Self>) -> Model<Thread> {
+        let thread = cx.new_model(|cx| Thread::new(self.tools.clone(), cx));
+        self.threads.push(thread.clone());
+        thread
+    }
+
+    pub fn open_thread(&self, id: &ThreadId, cx: &mut ModelContext<Self>) -> Option<Model<Thread>> {
+        self.threads
+            .iter()
+            .find(|thread| thread.read(cx).id() == id)
+            .cloned()
+    }
+
+    pub fn delete_thread(&mut self, id: &ThreadId, cx: &mut ModelContext<Self>) {
+        self.threads.retain(|thread| thread.read(cx).id() != id);
+    }
+
+    fn register_context_server_handlers(&self, cx: &mut ModelContext<Self>) {
+        cx.subscribe(
+            &self.context_server_manager.clone(),
+            Self::handle_context_server_event,
+        )
+        .detach();
+    }
+
+    fn handle_context_server_event(
+        &mut self,
+        context_server_manager: Model<ContextServerManager>,
+        event: &context_server::manager::Event,
+        cx: &mut ModelContext<Self>,
+    ) {
+        let tool_working_set = self.tools.clone();
+        match event {
+            context_server::manager::Event::ServerStarted { server_id } => {
+                if let Some(server) = context_server_manager.read(cx).get_server(server_id) {
+                    let context_server_manager = context_server_manager.clone();
+                    cx.spawn({
+                        let server = server.clone();
+                        let server_id = server_id.clone();
+                        |this, mut cx| async move {
+                            let Some(protocol) = server.client() else {
+                                return;
+                            };
+
+                            if protocol.capable(context_server::protocol::ServerCapability::Tools) {
+                                if let Some(tools) = protocol.list_tools().await.log_err() {
+                                    let tool_ids = tools
+                                        .tools
+                                        .into_iter()
+                                        .map(|tool| {
+                                            log::info!(
+                                                "registering context server tool: {:?}",
+                                                tool.name
+                                            );
+                                            tool_working_set.insert(Arc::new(
+                                                ContextServerTool::new(
+                                                    context_server_manager.clone(),
+                                                    server.id(),
+                                                    tool,
+                                                ),
+                                            ))
+                                        })
+                                        .collect::<Vec<_>>();
+
+                                    this.update(&mut cx, |this, _cx| {
+                                        this.context_server_tool_ids.insert(server_id, tool_ids);
+                                    })
+                                    .log_err();
+                                }
+                            }
+                        }
+                    })
+                    .detach();
+                }
+            }
+            context_server::manager::Event::ServerStopped { server_id } => {
+                if let Some(tool_ids) = self.context_server_tool_ids.remove(server_id) {
+                    tool_working_set.remove(&tool_ids);
+                }
+            }
+        }
+    }
+}
+
+impl ThreadStore {
+    /// Creates some mocked recent threads for testing purposes.
+    fn mock_recent_threads(&mut self, cx: &mut ModelContext<Self>) {
+        use language_model::Role;
+
+        self.threads.push(cx.new_model(|cx| {
+            let mut thread = Thread::new(self.tools.clone(), cx);
+            thread.set_summary("Introduction to quantum computing", cx);
+            thread.insert_user_message("Hello! Can you help me understand quantum computing?", cx);
+            thread.insert_message(Role::Assistant, "Of course! I'd be happy to help you understand quantum computing. Quantum computing is a fascinating field that uses the principles of quantum mechanics to process information. Unlike classical computers that use bits (0s and 1s), quantum computers use quantum bits or 'qubits'. These qubits can exist in multiple states simultaneously, a property called superposition. This allows quantum computers to perform certain calculations much faster than classical computers. What specific aspect of quantum computing would you like to know more about?", cx);
+            thread.insert_user_message("That's interesting! Can you explain how quantum entanglement is used in quantum computing?", cx);
+            thread.insert_message(Role::Assistant, "Certainly! Quantum entanglement is a key principle used in quantum computing. When two qubits become entangled, the state of one qubit is directly related to the state of the other, regardless of the distance between them. This property is used in quantum computing to create complex quantum states and to perform operations on multiple qubits simultaneously. Entanglement allows quantum computers to process information in ways that classical computers cannot, potentially solving certain problems much more efficiently. For example, it's crucial in quantum error correction and in algorithms like quantum teleportation, which is important for quantum communication.", cx);
+            thread
+        }));
+
+        self.threads.push(cx.new_model(|cx| {
+            let mut thread = Thread::new(self.tools.clone(), cx);
+            thread.set_summary("Rust web development and async programming", cx);
+            thread.insert_user_message("Can you show me an example of Rust code for a simple web server?", cx);
+            thread.insert_message(Role::Assistant, "Certainly! Here's an example of a simple web server in Rust using the `actix-web` framework:
+
+        ```rust
+        use actix_web::{web, App, HttpResponse, HttpServer, Responder};
+
+        async fn hello() -> impl Responder {
+            HttpResponse::Ok().body(\"Hello, World!\")
+        }
+
+        #[actix_web::main]
+        async fn main() -> std::io::Result<()> {
+            HttpServer::new(|| {
+                App::new()
+                    .route(\"/\", web::get().to(hello))
+            })
+            .bind(\"127.0.0.1:8080\")?
+            .run()
+            .await
+        }
+        ```
+
+        This code creates a basic web server that responds with 'Hello, World!' when you access the root URL. Here's a breakdown of what's happening:
+
+        1. We import necessary items from the `actix-web` crate.
+        2. We define an async `hello` function that returns a simple HTTP response.
+        3. In the `main` function, we set up the server to listen on `127.0.0.1:8080`.
+        4. We configure the app to respond to GET requests on the root path with our `hello` function.
+
+        To run this, you'd need to add `actix-web` to your `Cargo.toml` dependencies:
+
+        ```toml
+        [dependencies]
+        actix-web = \"4.0\"
+        ```
+
+        Then you can run the server with `cargo run` and access it at `http://localhost:8080`.".unindent(), cx);
+            thread.insert_user_message("That's great! Can you explain more about async functions in Rust?", cx);
+            thread.insert_message(Role::Assistant, "Certainly! Async functions are a key feature in Rust for writing efficient, non-blocking code, especially for I/O-bound operations. Here's an overview:
+
+        1. **Syntax**: Async functions are declared using the `async` keyword:
+
+           ```rust
+           async fn my_async_function() -> Result<(), Error> {
+               // Asynchronous code here
+           }
+           ```
+
+        2. **Futures**: Async functions return a `Future`. A `Future` represents a value that may not be available yet but will be at some point.
+
+        3. **Await**: Inside an async function, you can use the `.await` syntax to wait for other async operations to complete:
+
+           ```rust
+           async fn fetch_data() -> Result<String, Error> {
+               let response = make_http_request().await?;
+               let data = process_response(response).await?;
+               Ok(data)
+           }
+           ```
+
+        4. **Non-blocking**: Async functions allow the runtime to work on other tasks while waiting for I/O or other operations to complete, making efficient use of system resources.
+
+        5. **Runtime**: To execute async code, you need a runtime like `tokio` or `async-std`. Actix-web, which we used in the previous example, includes its own runtime.
+
+        6. **Error Handling**: Async functions work well with Rust's `?` operator for error handling.
+
+        Async programming in Rust provides a powerful way to write concurrent code that's both safe and efficient. It's particularly useful for servers, network programming, and any application that deals with many concurrent operations.".unindent(), cx);
+            thread
+        }));
+    }
+}
--- a/crates/call/Cargo.toml
+++ b/crates/call/Cargo.toml
@@ -17,21 +17,23 @@ test-support = [
    "client/test-support",
    "collections/test-support",
    "gpui/test-support",
-    "live_kit_client/test-support",
+    "livekit_client/test-support",
    "project/test-support",
    "util/test-support"
 ]
+livekit-macos = ["livekit_client_macos"]
+livekit-cross-platform = ["livekit_client"]

 [dependencies]
 anyhow.workspace = true
 audio.workspace = true
 client.workspace = true
 collections.workspace = true
+feature_flags.workspace = true
 fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
 language.workspace = true
-live_kit_client.workspace = true
 log.workspace = true
 postage.workspace = true
 project.workspace = true
@@ -40,6 +42,8 @@ serde.workspace = true
 serde_derive.workspace = true
 settings.workspace = true
 util.workspace = true
+livekit_client_macos = { workspace = true, optional = true }
+livekit_client = { workspace = true, optional = true }

 [dev-dependencies]
 client = { workspace = true, features = ["test-support"] }
@@ -47,7 +51,12 @@ collections = { workspace = true, features = ["test-support"] }
 fs = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, features = ["test-support"] }
 language = { workspace = true, features = ["test-support"] }
-live_kit_client = { workspace = true, features = ["test-support"] }
 project = { workspace = true, features = ["test-support"] }
 util = { workspace = true, features = ["test-support"] }
 http_client = { workspace = true, features = ["test-support"] }
+
+[target.'cfg(target_os = "macos")'.dev-dependencies]
+livekit_client_macos = { workspace = true, features = ["test-support"] }
+
+[target.'cfg(not(target_os = "macos"))'.dev-dependencies]
+livekit_client = { workspace = true, features = ["test-support"] }
--- a/crates/call/src/call.rs
+++ b/crates/call/src/call.rs
@@ -1,546 +1,41 @@
 pub mod call_settings;
-pub mod participant;
-pub mod room;

-use anyhow::{anyhow, Result};
-use audio::Audio;
-use call_settings::CallSettings;
-use client::{proto, ChannelId, Client, TypedEnvelope, User, UserStore, ZED_ALWAYS_ACTIVE};
-use collections::HashSet;
-use futures::{channel::oneshot, future::Shared, Future, FutureExt};
-use gpui::{
-    AppContext, AsyncAppContext, Context, EventEmitter, Global, Model, ModelContext, Subscription,
-    Task, WeakModel,
-};
-use postage::watch;
-use project::Project;
-use room::Event;
-use settings::Settings;
-use std::sync::Arc;
+#[cfg(any(
+    all(target_os = "macos", feature = "livekit-macos"),
+    all(
+        not(target_os = "macos"),
+        feature = "livekit-macos",
+        not(feature = "livekit-cross-platform")
+    )
+))]
+mod macos;

-pub use participant::ParticipantLocation;
-pub use room::Room;
+#[cfg(any(
+    all(target_os = "macos", feature = "livekit-macos"),
+    all(
+        not(target_os = "macos"),
+        feature = "livekit-macos",
+        not(feature = "livekit-cross-platform")
+    )
+))]
+pub use macos::*;

-struct GlobalActiveCall(Model<ActiveCall>);
-
-impl Global for GlobalActiveCall {}
-
-pub fn init(client: Arc<Client>, user_store: Model<UserStore>, cx: &mut AppContext) {
-    CallSettings::register(cx);
-
-    let active_call = cx.new_model(|cx| ActiveCall::new(client, user_store, cx));
-    cx.set_global(GlobalActiveCall(active_call));
-}
-
-pub struct OneAtATime {
-    cancel: Option<oneshot::Sender<()>>,
-}
-
-impl OneAtATime {
-    /// spawn a task in the given context.
-    /// if another task is spawned before that resolves, or if the OneAtATime itself is dropped, the first task will be cancelled and return Ok(None)
-    /// otherwise you'll see the result of the task.
-    fn spawn<F, Fut, R>(&mut self, cx: &mut AppContext, f: F) -> Task<Result<Option<R>>>
-    where
-        F: 'static + FnOnce(AsyncAppContext) -> Fut,
-        Fut: Future<Output = Result<R>>,
-        R: 'static,
-    {
-        let (tx, rx) = oneshot::channel();
-        self.cancel.replace(tx);
-        cx.spawn(|cx| async move {
-            futures::select_biased! {
-                _ = rx.fuse() => Ok(None),
-                result = f(cx).fuse() => result.map(Some),
-            }
-        })
-    }
-
-    fn running(&self) -> bool {
-        self.cancel
-            .as_ref()
-            .is_some_and(|cancel| !cancel.is_canceled())
-    }
-}
-
-#[derive(Clone)]
-pub struct IncomingCall {
-    pub room_id: u64,
-    pub calling_user: Arc<User>,
-    pub participants: Vec<Arc<User>>,
-    pub initial_project: Option<proto::ParticipantProject>,
-}
-
-/// Singleton global maintaining the user's participation in a room across workspaces.
-pub struct ActiveCall {
-    room: Option<(Model<Room>, Vec<Subscription>)>,
-    pending_room_creation: Option<Shared<Task<Result<Model<Room>, Arc<anyhow::Error>>>>>,
-    location: Option<WeakModel<Project>>,
-    _join_debouncer: OneAtATime,
-    pending_invites: HashSet<u64>,
-    incoming_call: (
-        watch::Sender<Option<IncomingCall>>,
-        watch::Receiver<Option<IncomingCall>>,
+#[cfg(any(
+    all(
+        target_os = "macos",
+        feature = "livekit-cross-platform",
+        not(feature = "livekit-macos"),
    ),
-    client: Arc<Client>,
-    user_store: Model<UserStore>,
-    _subscriptions: Vec<client::Subscription>,
-}
+    all(not(target_os = "macos"), feature = "livekit-cross-platform"),
+))]
+mod cross_platform;

-impl EventEmitter<Event> for ActiveCall {}
-
-impl ActiveCall {
-    fn new(client: Arc<Client>, user_store: Model<UserStore>, cx: &mut ModelContext<Self>) -> Self {
-        Self {
-            room: None,
-            pending_room_creation: None,
-            location: None,
-            pending_invites: Default::default(),
-            incoming_call: watch::channel(),
-            _join_debouncer: OneAtATime { cancel: None },
-            _subscriptions: vec![
-                client.add_request_handler(cx.weak_model(), Self::handle_incoming_call),
-                client.add_message_handler(cx.weak_model(), Self::handle_call_canceled),
-            ],
-            client,
-            user_store,
-        }
-    }
-
-    pub fn channel_id(&self, cx: &AppContext) -> Option<ChannelId> {
-        self.room()?.read(cx).channel_id()
-    }
-
-    async fn handle_incoming_call(
-        this: Model<Self>,
-        envelope: TypedEnvelope<proto::IncomingCall>,
-        mut cx: AsyncAppContext,
-    ) -> Result<proto::Ack> {
-        let user_store = this.update(&mut cx, |this, _| this.user_store.clone())?;
-        let call = IncomingCall {
-            room_id: envelope.payload.room_id,
-            participants: user_store
-                .update(&mut cx, |user_store, cx| {
-                    user_store.get_users(envelope.payload.participant_user_ids, cx)
-                })?
-                .await?,
-            calling_user: user_store
-                .update(&mut cx, |user_store, cx| {
-                    user_store.get_user(envelope.payload.calling_user_id, cx)
-                })?
-                .await?,
-            initial_project: envelope.payload.initial_project,
-        };
-        this.update(&mut cx, |this, _| {
-            *this.incoming_call.0.borrow_mut() = Some(call);
-        })?;
-
-        Ok(proto::Ack {})
-    }
-
-    async fn handle_call_canceled(
-        this: Model<Self>,
-        envelope: TypedEnvelope<proto::CallCanceled>,
-        mut cx: AsyncAppContext,
-    ) -> Result<()> {
-        this.update(&mut cx, |this, _| {
-            let mut incoming_call = this.incoming_call.0.borrow_mut();
-            if incoming_call
-                .as_ref()
-                .map_or(false, |call| call.room_id == envelope.payload.room_id)
-            {
-                incoming_call.take();
-            }
-        })?;
-        Ok(())
-    }
-
-    pub fn global(cx: &AppContext) -> Model<Self> {
-        cx.global::<GlobalActiveCall>().0.clone()
-    }
-
-    pub fn try_global(cx: &AppContext) -> Option<Model<Self>> {
-        cx.try_global::<GlobalActiveCall>()
-            .map(|call| call.0.clone())
-    }
-
-    pub fn invite(
-        &mut self,
-        called_user_id: u64,
-        initial_project: Option<Model<Project>>,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<Result<()>> {
-        if !self.pending_invites.insert(called_user_id) {
-            return Task::ready(Err(anyhow!("user was already invited")));
-        }
-        cx.notify();
-
-        if self._join_debouncer.running() {
-            return Task::ready(Ok(()));
-        }
-
-        let room = if let Some(room) = self.room().cloned() {
-            Some(Task::ready(Ok(room)).shared())
-        } else {
-            self.pending_room_creation.clone()
-        };
-
-        let invite = if let Some(room) = room {
-            cx.spawn(move |_, mut cx| async move {
-                let room = room.await.map_err(|err| anyhow!("{:?}", err))?;
-
-                let initial_project_id = if let Some(initial_project) = initial_project {
-                    Some(
-                        room.update(&mut cx, |room, cx| room.share_project(initial_project, cx))?
-                            .await?,
-                    )
-                } else {
-                    None
-                };
-
-                room.update(&mut cx, move |room, cx| {
-                    room.call(called_user_id, initial_project_id, cx)
-                })?
-                .await?;
-
-                anyhow::Ok(())
-            })
-        } else {
-            let client = self.client.clone();
-            let user_store = self.user_store.clone();
-            let room = cx
-                .spawn(move |this, mut cx| async move {
-                    let create_room = async {
-                        let room = cx
-                            .update(|cx| {
-                                Room::create(
-                                    called_user_id,
-                                    initial_project,
-                                    client,
-                                    user_store,
-                                    cx,
-                                )
-                            })?
-                            .await?;
-
-                        this.update(&mut cx, |this, cx| this.set_room(Some(room.clone()), cx))?
-                            .await?;
-
-                        anyhow::Ok(room)
-                    };
-
-                    let room = create_room.await;
-                    this.update(&mut cx, |this, _| this.pending_room_creation = None)?;
-                    room.map_err(Arc::new)
-                })
-                .shared();
-            self.pending_room_creation = Some(room.clone());
-            cx.background_executor().spawn(async move {
-                room.await.map_err(|err| anyhow!("{:?}", err))?;
-                anyhow::Ok(())
-            })
-        };
-
-        cx.spawn(move |this, mut cx| async move {
-            let result = invite.await;
-            if result.is_ok() {
-                this.update(&mut cx, |this, cx| this.report_call_event("invite", cx))?;
-            } else {
-                //TODO: report collaboration error
-                log::error!("invite failed: {:?}", result);
-            }
-
-            this.update(&mut cx, |this, cx| {
-                this.pending_invites.remove(&called_user_id);
-                cx.notify();
-            })?;
-            result
-        })
-    }
-
-    pub fn cancel_invite(
-        &mut self,
-        called_user_id: u64,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<Result<()>> {
-        let room_id = if let Some(room) = self.room() {
-            room.read(cx).id()
-        } else {
-            return Task::ready(Err(anyhow!("no active call")));
-        };
-
-        let client = self.client.clone();
-        cx.background_executor().spawn(async move {
-            client
-                .request(proto::CancelCall {
-                    room_id,
-                    called_user_id,
-                })
-                .await?;
-            anyhow::Ok(())
-        })
-    }
-
-    pub fn incoming(&self) -> watch::Receiver<Option<IncomingCall>> {
-        self.incoming_call.1.clone()
-    }
-
-    pub fn accept_incoming(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
-        if self.room.is_some() {
-            return Task::ready(Err(anyhow!("cannot join while on another call")));
-        }
-
-        let call = if let Some(call) = self.incoming_call.0.borrow_mut().take() {
-            call
-        } else {
-            return Task::ready(Err(anyhow!("no incoming call")));
-        };
-
-        if self.pending_room_creation.is_some() {
-            return Task::ready(Ok(()));
-        }
-
-        let room_id = call.room_id;
-        let client = self.client.clone();
-        let user_store = self.user_store.clone();
-        let join = self
-            ._join_debouncer
-            .spawn(cx, move |cx| Room::join(room_id, client, user_store, cx));
-
-        cx.spawn(|this, mut cx| async move {
-            let room = join.await?;
-            this.update(&mut cx, |this, cx| this.set_room(room.clone(), cx))?
-                .await?;
-            this.update(&mut cx, |this, cx| {
-                this.report_call_event("accept incoming", cx)
-            })?;
-            Ok(())
-        })
-    }
-
-    pub fn decline_incoming(&mut self, _: &mut ModelContext<Self>) -> Result<()> {
-        let call = self
-            .incoming_call
-            .0
-            .borrow_mut()
-            .take()
-            .ok_or_else(|| anyhow!("no incoming call"))?;
-        report_call_event_for_room("decline incoming", call.room_id, None, &self.client);
-        self.client.send(proto::DeclineCall {
-            room_id: call.room_id,
-        })?;
-        Ok(())
-    }
-
-    pub fn join_channel(
-        &mut self,
-        channel_id: ChannelId,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<Result<Option<Model<Room>>>> {
-        if let Some(room) = self.room().cloned() {
-            if room.read(cx).channel_id() == Some(channel_id) {
-                return Task::ready(Ok(Some(room)));
-            } else {
-                room.update(cx, |room, cx| room.clear_state(cx));
-            }
-        }
-
-        if self.pending_room_creation.is_some() {
-            return Task::ready(Ok(None));
-        }
-
-        let client = self.client.clone();
-        let user_store = self.user_store.clone();
-        let join = self._join_debouncer.spawn(cx, move |cx| async move {
-            Room::join_channel(channel_id, client, user_store, cx).await
-        });
-
-        cx.spawn(|this, mut cx| async move {
-            let room = join.await?;
-            this.update(&mut cx, |this, cx| this.set_room(room.clone(), cx))?
-                .await?;
-            this.update(&mut cx, |this, cx| {
-                this.report_call_event("join channel", cx)
-            })?;
-            Ok(room)
-        })
-    }
-
-    pub fn hang_up(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
-        cx.notify();
-        self.report_call_event("hang up", cx);
-
-        Audio::end_call(cx);
-
-        let channel_id = self.channel_id(cx);
-        if let Some((room, _)) = self.room.take() {
-            cx.emit(Event::RoomLeft { channel_id });
-            room.update(cx, |room, cx| room.leave(cx))
-        } else {
-            Task::ready(Ok(()))
-        }
-    }
-
-    pub fn share_project(
-        &mut self,
-        project: Model<Project>,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<Result<u64>> {
-        if let Some((room, _)) = self.room.as_ref() {
-            self.report_call_event("share project", cx);
-            room.update(cx, |room, cx| room.share_project(project, cx))
-        } else {
-            Task::ready(Err(anyhow!("no active call")))
-        }
-    }
-
-    pub fn unshare_project(
-        &mut self,
-        project: Model<Project>,
-        cx: &mut ModelContext<Self>,
-    ) -> Result<()> {
-        if let Some((room, _)) = self.room.as_ref() {
-            self.report_call_event("unshare project", cx);
-            room.update(cx, |room, cx| room.unshare_project(project, cx))
-        } else {
-            Err(anyhow!("no active call"))
-        }
-    }
-
-    pub fn location(&self) -> Option<&WeakModel<Project>> {
-        self.location.as_ref()
-    }
-
-    pub fn set_location(
-        &mut self,
-        project: Option<&Model<Project>>,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<Result<()>> {
-        if project.is_some() || !*ZED_ALWAYS_ACTIVE {
-            self.location = project.map(|project| project.downgrade());
-            if let Some((room, _)) = self.room.as_ref() {
-                return room.update(cx, |room, cx| room.set_location(project, cx));
-            }
-        }
-        Task::ready(Ok(()))
-    }
-
-    fn set_room(
-        &mut self,
-        room: Option<Model<Room>>,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<Result<()>> {
-        if room.as_ref() == self.room.as_ref().map(|room| &room.0) {
-            Task::ready(Ok(()))
-        } else {
-            cx.notify();
-            if let Some(room) = room {
-                if room.read(cx).status().is_offline() {
-                    self.room = None;
-                    Task::ready(Ok(()))
-                } else {
-                    let subscriptions = vec![
-                        cx.observe(&room, |this, room, cx| {
-                            if room.read(cx).status().is_offline() {
-                                this.set_room(None, cx).detach_and_log_err(cx);
-                            }
-
-                            cx.notify();
-                        }),
-                        cx.subscribe(&room, |_, _, event, cx| cx.emit(event.clone())),
-                    ];
-                    self.room = Some((room.clone(), subscriptions));
-                    let location = self
-                        .location
-                        .as_ref()
-                        .and_then(|location| location.upgrade());
-                    let channel_id = room.read(cx).channel_id();
-                    cx.emit(Event::RoomJoined { channel_id });
-                    room.update(cx, |room, cx| room.set_location(location.as_ref(), cx))
-                }
-            } else {
-                self.room = None;
-                Task::ready(Ok(()))
-            }
-        }
-    }
-
-    pub fn room(&self) -> Option<&Model<Room>> {
-        self.room.as_ref().map(|(room, _)| room)
-    }
-
-    pub fn client(&self) -> Arc<Client> {
-        self.client.clone()
-    }
-
-    pub fn pending_invites(&self) -> &HashSet<u64> {
-        &self.pending_invites
-    }
-
-    pub fn report_call_event(&self, operation: &'static str, cx: &mut AppContext) {
-        if let Some(room) = self.room() {
-            let room = room.read(cx);
-            report_call_event_for_room(operation, room.id(), room.channel_id(), &self.client);
-        }
-    }
-}
-
-pub fn report_call_event_for_room(
-    operation: &'static str,
-    room_id: u64,
-    channel_id: Option<ChannelId>,
-    client: &Arc<Client>,
-) {
-    let telemetry = client.telemetry();
-
-    telemetry.report_call_event(operation, Some(room_id), channel_id)
-}
-
-pub fn report_call_event_for_channel(
-    operation: &'static str,
-    channel_id: ChannelId,
-    client: &Arc<Client>,
-    cx: &AppContext,
-) {
-    let room = ActiveCall::global(cx).read(cx).room();
-
-    let telemetry = client.telemetry();
-
-    telemetry.report_call_event(operation, room.map(|r| r.read(cx).id()), Some(channel_id))
-}
-
-#[cfg(test)]
-mod test {
-    use gpui::TestAppContext;
-
-    use crate::OneAtATime;
-
-    #[gpui::test]
-    async fn test_one_at_a_time(cx: &mut TestAppContext) {
-        let mut one_at_a_time = OneAtATime { cancel: None };
-
-        assert_eq!(
-            cx.update(|cx| one_at_a_time.spawn(cx, |_| async { Ok(1) }))
-                .await
-                .unwrap(),
-            Some(1)
-        );
-
-        let (a, b) = cx.update(|cx| {
-            (
-                one_at_a_time.spawn(cx, |_| async {
-                    panic!("");
-                }),
-                one_at_a_time.spawn(cx, |_| async { Ok(3) }),
-            )
-        });
-
-        assert_eq!(a.await.unwrap(), None::<u32>);
-        assert_eq!(b.await.unwrap(), Some(3));
-
-        let promise = cx.update(|cx| one_at_a_time.spawn(cx, |_| async { Ok(4) }));
-        drop(one_at_a_time);
-
-        assert_eq!(promise.await.unwrap(), None);
-    }
-}
+#[cfg(any(
+    all(
+        target_os = "macos",
+        feature = "livekit-cross-platform",
+        not(feature = "livekit-macos"),
+    ),
+    all(not(target_os = "macos"), feature = "livekit-cross-platform"),
+))]
+pub use cross_platform::*;
--- a/crates/call/src/cross_platform/mod.rs
+++ b/crates/call/src/cross_platform/mod.rs
@@ -0,0 +1,552 @@
+pub mod participant;
+pub mod room;
+
+use crate::call_settings::CallSettings;
+use anyhow::{anyhow, Result};
+use audio::Audio;
+use client::{proto, ChannelId, Client, TypedEnvelope, User, UserStore, ZED_ALWAYS_ACTIVE};
+use collections::HashSet;
+use futures::{channel::oneshot, future::Shared, Future, FutureExt};
+use gpui::{
+    AppContext, AsyncAppContext, Context, EventEmitter, Global, Model, ModelContext, Subscription,
+    Task, WeakModel,
+};
+use postage::watch;
+use project::Project;
+use room::Event;
+use settings::Settings;
+use std::sync::Arc;
+
+pub use livekit_client::{
+    track::RemoteVideoTrack, RemoteVideoTrackView, RemoteVideoTrackViewEvent,
+};
+pub use participant::ParticipantLocation;
+pub use room::Room;
+
+struct GlobalActiveCall(Model<ActiveCall>);
+
+impl Global for GlobalActiveCall {}
+
+pub fn init(client: Arc<Client>, user_store: Model<UserStore>, cx: &mut AppContext) {
+    livekit_client::init(
+        cx.background_executor().dispatcher.clone(),
+        cx.http_client(),
+    );
+    CallSettings::register(cx);
+
+    let active_call = cx.new_model(|cx| ActiveCall::new(client, user_store, cx));
+    cx.set_global(GlobalActiveCall(active_call));
+}
+
+pub struct OneAtATime {
+    cancel: Option<oneshot::Sender<()>>,
+}
+
+impl OneAtATime {
+    /// spawn a task in the given context.
+    /// if another task is spawned before that resolves, or if the OneAtATime itself is dropped, the first task will be cancelled and return Ok(None)
+    /// otherwise you'll see the result of the task.
+    fn spawn<F, Fut, R>(&mut self, cx: &mut AppContext, f: F) -> Task<Result<Option<R>>>
+    where
+        F: 'static + FnOnce(AsyncAppContext) -> Fut,
+        Fut: Future<Output = Result<R>>,
+        R: 'static,
+    {
+        let (tx, rx) = oneshot::channel();
+        self.cancel.replace(tx);
+        cx.spawn(|cx| async move {
+            futures::select_biased! {
+                _ = rx.fuse() => Ok(None),
+                result = f(cx).fuse() => result.map(Some),
+            }
+        })
+    }
+
+    fn running(&self) -> bool {
+        self.cancel
+            .as_ref()
+            .is_some_and(|cancel| !cancel.is_canceled())
+    }
+}
+
+#[derive(Clone)]
+pub struct IncomingCall {
+    pub room_id: u64,
+    pub calling_user: Arc<User>,
+    pub participants: Vec<Arc<User>>,
+    pub initial_project: Option<proto::ParticipantProject>,
+}
+
+/// Singleton global maintaining the user's participation in a room across workspaces.
+pub struct ActiveCall {
+    room: Option<(Model<Room>, Vec<Subscription>)>,
+    pending_room_creation: Option<Shared<Task<Result<Model<Room>, Arc<anyhow::Error>>>>>,
+    location: Option<WeakModel<Project>>,
+    _join_debouncer: OneAtATime,
+    pending_invites: HashSet<u64>,
+    incoming_call: (
+        watch::Sender<Option<IncomingCall>>,
+        watch::Receiver<Option<IncomingCall>>,
+    ),
+    client: Arc<Client>,
+    user_store: Model<UserStore>,
+    _subscriptions: Vec<client::Subscription>,
+}
+
+impl EventEmitter<Event> for ActiveCall {}
+
+impl ActiveCall {
+    fn new(client: Arc<Client>, user_store: Model<UserStore>, cx: &mut ModelContext<Self>) -> Self {
+        Self {
+            room: None,
+            pending_room_creation: None,
+            location: None,
+            pending_invites: Default::default(),
+            incoming_call: watch::channel(),
+            _join_debouncer: OneAtATime { cancel: None },
+            _subscriptions: vec![
+                client.add_request_handler(cx.weak_model(), Self::handle_incoming_call),
+                client.add_message_handler(cx.weak_model(), Self::handle_call_canceled),
+            ],
+            client,
+            user_store,
+        }
+    }
+
+    pub fn channel_id(&self, cx: &AppContext) -> Option<ChannelId> {
+        self.room()?.read(cx).channel_id()
+    }
+
+    async fn handle_incoming_call(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::IncomingCall>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::Ack> {
+        let user_store = this.update(&mut cx, |this, _| this.user_store.clone())?;
+        let call = IncomingCall {
+            room_id: envelope.payload.room_id,
+            participants: user_store
+                .update(&mut cx, |user_store, cx| {
+                    user_store.get_users(envelope.payload.participant_user_ids, cx)
+                })?
+                .await?,
+            calling_user: user_store
+                .update(&mut cx, |user_store, cx| {
+                    user_store.get_user(envelope.payload.calling_user_id, cx)
+                })?
+                .await?,
+            initial_project: envelope.payload.initial_project,
+        };
+        this.update(&mut cx, |this, _| {
+            *this.incoming_call.0.borrow_mut() = Some(call);
+        })?;
+
+        Ok(proto::Ack {})
+    }
+
+    async fn handle_call_canceled(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::CallCanceled>,
+        mut cx: AsyncAppContext,
+    ) -> Result<()> {
+        this.update(&mut cx, |this, _| {
+            let mut incoming_call = this.incoming_call.0.borrow_mut();
+            if incoming_call
+                .as_ref()
+                .map_or(false, |call| call.room_id == envelope.payload.room_id)
+            {
+                incoming_call.take();
+            }
+        })?;
+        Ok(())
+    }
+
+    pub fn global(cx: &AppContext) -> Model<Self> {
+        cx.global::<GlobalActiveCall>().0.clone()
+    }
+
+    pub fn try_global(cx: &AppContext) -> Option<Model<Self>> {
+        cx.try_global::<GlobalActiveCall>()
+            .map(|call| call.0.clone())
+    }
+
+    pub fn invite(
+        &mut self,
+        called_user_id: u64,
+        initial_project: Option<Model<Project>>,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        if !self.pending_invites.insert(called_user_id) {
+            return Task::ready(Err(anyhow!("user was already invited")));
+        }
+        cx.notify();
+
+        if self._join_debouncer.running() {
+            return Task::ready(Ok(()));
+        }
+
+        let room = if let Some(room) = self.room().cloned() {
+            Some(Task::ready(Ok(room)).shared())
+        } else {
+            self.pending_room_creation.clone()
+        };
+
+        let invite = if let Some(room) = room {
+            cx.spawn(move |_, mut cx| async move {
+                let room = room.await.map_err(|err| anyhow!("{:?}", err))?;
+
+                let initial_project_id = if let Some(initial_project) = initial_project {
+                    Some(
+                        room.update(&mut cx, |room, cx| room.share_project(initial_project, cx))?
+                            .await?,
+                    )
+                } else {
+                    None
+                };
+
+                room.update(&mut cx, move |room, cx| {
+                    room.call(called_user_id, initial_project_id, cx)
+                })?
+                .await?;
+
+                anyhow::Ok(())
+            })
+        } else {
+            let client = self.client.clone();
+            let user_store = self.user_store.clone();
+            let room = cx
+                .spawn(move |this, mut cx| async move {
+                    let create_room = async {
+                        let room = cx
+                            .update(|cx| {
+                                Room::create(
+                                    called_user_id,
+                                    initial_project,
+                                    client,
+                                    user_store,
+                                    cx,
+                                )
+                            })?
+                            .await?;
+
+                        this.update(&mut cx, |this, cx| this.set_room(Some(room.clone()), cx))?
+                            .await?;
+
+                        anyhow::Ok(room)
+                    };
+
+                    let room = create_room.await;
+                    this.update(&mut cx, |this, _| this.pending_room_creation = None)?;
+                    room.map_err(Arc::new)
+                })
+                .shared();
+            self.pending_room_creation = Some(room.clone());
+            cx.background_executor().spawn(async move {
+                room.await.map_err(|err| anyhow!("{:?}", err))?;
+                anyhow::Ok(())
+            })
+        };
+
+        cx.spawn(move |this, mut cx| async move {
+            let result = invite.await;
+            if result.is_ok() {
+                this.update(&mut cx, |this, cx| this.report_call_event("invite", cx))?;
+            } else {
+                //TODO: report collaboration error
+                log::error!("invite failed: {:?}", result);
+            }
+
+            this.update(&mut cx, |this, cx| {
+                this.pending_invites.remove(&called_user_id);
+                cx.notify();
+            })?;
+            result
+        })
+    }
+
+    pub fn cancel_invite(
+        &mut self,
+        called_user_id: u64,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        let room_id = if let Some(room) = self.room() {
+            room.read(cx).id()
+        } else {
+            return Task::ready(Err(anyhow!("no active call")));
+        };
+
+        let client = self.client.clone();
+        cx.background_executor().spawn(async move {
+            client
+                .request(proto::CancelCall {
+                    room_id,
+                    called_user_id,
+                })
+                .await?;
+            anyhow::Ok(())
+        })
+    }
+
+    pub fn incoming(&self) -> watch::Receiver<Option<IncomingCall>> {
+        self.incoming_call.1.clone()
+    }
+
+    pub fn accept_incoming(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
+        if self.room.is_some() {
+            return Task::ready(Err(anyhow!("cannot join while on another call")));
+        }
+
+        let call = if let Some(call) = self.incoming_call.0.borrow_mut().take() {
+            call
+        } else {
+            return Task::ready(Err(anyhow!("no incoming call")));
+        };
+
+        if self.pending_room_creation.is_some() {
+            return Task::ready(Ok(()));
+        }
+
+        let room_id = call.room_id;
+        let client = self.client.clone();
+        let user_store = self.user_store.clone();
+        let join = self
+            ._join_debouncer
+            .spawn(cx, move |cx| Room::join(room_id, client, user_store, cx));
+
+        cx.spawn(|this, mut cx| async move {
+            let room = join.await?;
+            this.update(&mut cx, |this, cx| this.set_room(room.clone(), cx))?
+                .await?;
+            this.update(&mut cx, |this, cx| {
+                this.report_call_event("accept incoming", cx)
+            })?;
+            Ok(())
+        })
+    }
+
+    pub fn decline_incoming(&mut self, _: &mut ModelContext<Self>) -> Result<()> {
+        let call = self
+            .incoming_call
+            .0
+            .borrow_mut()
+            .take()
+            .ok_or_else(|| anyhow!("no incoming call"))?;
+        report_call_event_for_room("decline incoming", call.room_id, None, &self.client);
+        self.client.send(proto::DeclineCall {
+            room_id: call.room_id,
+        })?;
+        Ok(())
+    }
+
+    pub fn join_channel(
+        &mut self,
+        channel_id: ChannelId,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<Option<Model<Room>>>> {
+        if let Some(room) = self.room().cloned() {
+            if room.read(cx).channel_id() == Some(channel_id) {
+                return Task::ready(Ok(Some(room)));
+            } else {
+                room.update(cx, |room, cx| room.clear_state(cx));
+            }
+        }
+
+        if self.pending_room_creation.is_some() {
+            return Task::ready(Ok(None));
+        }
+
+        let client = self.client.clone();
+        let user_store = self.user_store.clone();
+        let join = self._join_debouncer.spawn(cx, move |cx| async move {
+            Room::join_channel(channel_id, client, user_store, cx).await
+        });
+
+        cx.spawn(|this, mut cx| async move {
+            let room = join.await?;
+            this.update(&mut cx, |this, cx| this.set_room(room.clone(), cx))?
+                .await?;
+            this.update(&mut cx, |this, cx| {
+                this.report_call_event("join channel", cx)
+            })?;
+            Ok(room)
+        })
+    }
+
+    pub fn hang_up(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
+        cx.notify();
+        self.report_call_event("hang up", cx);
+
+        Audio::end_call(cx);
+
+        let channel_id = self.channel_id(cx);
+        if let Some((room, _)) = self.room.take() {
+            cx.emit(Event::RoomLeft { channel_id });
+            room.update(cx, |room, cx| room.leave(cx))
+        } else {
+            Task::ready(Ok(()))
+        }
+    }
+
+    pub fn share_project(
+        &mut self,
+        project: Model<Project>,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<u64>> {
+        if let Some((room, _)) = self.room.as_ref() {
+            self.report_call_event("share project", cx);
+            room.update(cx, |room, cx| room.share_project(project, cx))
+        } else {
+            Task::ready(Err(anyhow!("no active call")))
+        }
+    }
+
+    pub fn unshare_project(
+        &mut self,
+        project: Model<Project>,
+        cx: &mut ModelContext<Self>,
+    ) -> Result<()> {
+        if let Some((room, _)) = self.room.as_ref() {
+            self.report_call_event("unshare project", cx);
+            room.update(cx, |room, cx| room.unshare_project(project, cx))
+        } else {
+            Err(anyhow!("no active call"))
+        }
+    }
+
+    pub fn location(&self) -> Option<&WeakModel<Project>> {
+        self.location.as_ref()
+    }
+
+    pub fn set_location(
+        &mut self,
+        project: Option<&Model<Project>>,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        if project.is_some() || !*ZED_ALWAYS_ACTIVE {
+            self.location = project.map(|project| project.downgrade());
+            if let Some((room, _)) = self.room.as_ref() {
+                return room.update(cx, |room, cx| room.set_location(project, cx));
+            }
+        }
+        Task::ready(Ok(()))
+    }
+
+    fn set_room(
+        &mut self,
+        room: Option<Model<Room>>,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        if room.as_ref() == self.room.as_ref().map(|room| &room.0) {
+            Task::ready(Ok(()))
+        } else {
+            cx.notify();
+            if let Some(room) = room {
+                if room.read(cx).status().is_offline() {
+                    self.room = None;
+                    Task::ready(Ok(()))
+                } else {
+                    let subscriptions = vec![
+                        cx.observe(&room, |this, room, cx| {
+                            if room.read(cx).status().is_offline() {
+                                this.set_room(None, cx).detach_and_log_err(cx);
+                            }
+
+                            cx.notify();
+                        }),
+                        cx.subscribe(&room, |_, _, event, cx| cx.emit(event.clone())),
+                    ];
+                    self.room = Some((room.clone(), subscriptions));
+                    let location = self
+                        .location
+                        .as_ref()
+                        .and_then(|location| location.upgrade());
+                    let channel_id = room.read(cx).channel_id();
+                    cx.emit(Event::RoomJoined { channel_id });
+                    room.update(cx, |room, cx| room.set_location(location.as_ref(), cx))
+                }
+            } else {
+                self.room = None;
+                Task::ready(Ok(()))
+            }
+        }
+    }
+
+    pub fn room(&self) -> Option<&Model<Room>> {
+        self.room.as_ref().map(|(room, _)| room)
+    }
+
+    pub fn client(&self) -> Arc<Client> {
+        self.client.clone()
+    }
+
+    pub fn pending_invites(&self) -> &HashSet<u64> {
+        &self.pending_invites
+    }
+
+    pub fn report_call_event(&self, operation: &'static str, cx: &mut AppContext) {
+        if let Some(room) = self.room() {
+            let room = room.read(cx);
+            report_call_event_for_room(operation, room.id(), room.channel_id(), &self.client);
+        }
+    }
+}
+
+pub fn report_call_event_for_room(
+    operation: &'static str,
+    room_id: u64,
+    channel_id: Option<ChannelId>,
+    client: &Arc<Client>,
+) {
+    let telemetry = client.telemetry();
+
+    telemetry.report_call_event(operation, Some(room_id), channel_id)
+}
+
+pub fn report_call_event_for_channel(
+    operation: &'static str,
+    channel_id: ChannelId,
+    client: &Arc<Client>,
+    cx: &AppContext,
+) {
+    let room = ActiveCall::global(cx).read(cx).room();
+
+    let telemetry = client.telemetry();
+
+    telemetry.report_call_event(operation, room.map(|r| r.read(cx).id()), Some(channel_id))
+}
+
+#[cfg(test)]
+mod test {
+    use gpui::TestAppContext;
+
+    use crate::OneAtATime;
+
+    #[gpui::test]
+    async fn test_one_at_a_time(cx: &mut TestAppContext) {
+        let mut one_at_a_time = OneAtATime { cancel: None };
+
+        assert_eq!(
+            cx.update(|cx| one_at_a_time.spawn(cx, |_| async { Ok(1) }))
+                .await
+                .unwrap(),
+            Some(1)
+        );
+
+        let (a, b) = cx.update(|cx| {
+            (
+                one_at_a_time.spawn(cx, |_| async {
+                    panic!("");
+                }),
+                one_at_a_time.spawn(cx, |_| async { Ok(3) }),
+            )
+        });
+
+        assert_eq!(a.await.unwrap(), None::<u32>);
+        assert_eq!(b.await.unwrap(), Some(3));
+
+        let promise = cx.update(|cx| one_at_a_time.spawn(cx, |_| async { Ok(4) }));
+        drop(one_at_a_time);
+
+        assert_eq!(promise.await.unwrap(), None);
+    }
+}
--- a/crates/call/src/cross_platform/participant.rs
+++ b/crates/call/src/cross_platform/participant.rs
@@ -0,0 +1,68 @@
+#![cfg_attr(target_os = "windows", allow(unused))]
+
+use anyhow::{anyhow, Result};
+use client::{proto, ParticipantIndex, User};
+use collections::HashMap;
+use gpui::WeakModel;
+use livekit_client::AudioStream;
+use project::Project;
+use std::sync::Arc;
+
+#[cfg(not(target_os = "windows"))]
+pub use livekit_client::id::TrackSid;
+pub use livekit_client::track::{RemoteAudioTrack, RemoteVideoTrack};
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum ParticipantLocation {
+    SharedProject { project_id: u64 },
+    UnsharedProject,
+    External,
+}
+
+impl ParticipantLocation {
+    pub fn from_proto(location: Option<proto::ParticipantLocation>) -> Result<Self> {
+        match location.and_then(|l| l.variant) {
+            Some(proto::participant_location::Variant::SharedProject(project)) => {
+                Ok(Self::SharedProject {
+                    project_id: project.id,
+                })
+            }
+            Some(proto::participant_location::Variant::UnsharedProject(_)) => {
+                Ok(Self::UnsharedProject)
+            }
+            Some(proto::participant_location::Variant::External(_)) => Ok(Self::External),
+            None => Err(anyhow!("participant location was not provided")),
+        }
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct LocalParticipant {
+    pub projects: Vec<proto::ParticipantProject>,
+    pub active_project: Option<WeakModel<Project>>,
+    pub role: proto::ChannelRole,
+}
+
+pub struct RemoteParticipant {
+    pub user: Arc<User>,
+    pub peer_id: proto::PeerId,
+    pub role: proto::ChannelRole,
+    pub projects: Vec<proto::ParticipantProject>,
+    pub location: ParticipantLocation,
+    pub participant_index: ParticipantIndex,
+    pub muted: bool,
+    pub speaking: bool,
+    #[cfg(not(target_os = "windows"))]
+    pub video_tracks: HashMap<TrackSid, RemoteVideoTrack>,
+    #[cfg(not(target_os = "windows"))]
+    pub audio_tracks: HashMap<TrackSid, (RemoteAudioTrack, AudioStream)>,
+}
+
+impl RemoteParticipant {
+    pub fn has_video_tracks(&self) -> bool {
+        #[cfg(not(target_os = "windows"))]
+        return !self.video_tracks.is_empty();
+        #[cfg(target_os = "windows")]
+        return false;
+    }
+}
--- a/crates/call/src/cross_platform/room.rs
+++ b/crates/call/src/cross_platform/room.rs
--- a/crates/call/src/macos/mod.rs
+++ b/crates/call/src/macos/mod.rs
@@ -0,0 +1,545 @@
+pub mod participant;
+pub mod room;
+
+use crate::call_settings::CallSettings;
+use anyhow::{anyhow, Result};
+use audio::Audio;
+use client::{proto, ChannelId, Client, TypedEnvelope, User, UserStore, ZED_ALWAYS_ACTIVE};
+use collections::HashSet;
+use futures::{channel::oneshot, future::Shared, Future, FutureExt};
+use gpui::{
+    AppContext, AsyncAppContext, Context, EventEmitter, Global, Model, ModelContext, Subscription,
+    Task, WeakModel,
+};
+use postage::watch;
+use project::Project;
+use room::Event;
+use settings::Settings;
+use std::sync::Arc;
+
+pub use participant::ParticipantLocation;
+pub use room::Room;
+
+struct GlobalActiveCall(Model<ActiveCall>);
+
+impl Global for GlobalActiveCall {}
+
+pub fn init(client: Arc<Client>, user_store: Model<UserStore>, cx: &mut AppContext) {
+    CallSettings::register(cx);
+
+    let active_call = cx.new_model(|cx| ActiveCall::new(client, user_store, cx));
+    cx.set_global(GlobalActiveCall(active_call));
+}
+
+pub struct OneAtATime {
+    cancel: Option<oneshot::Sender<()>>,
+}
+
+impl OneAtATime {
+    /// spawn a task in the given context.
+    /// if another task is spawned before that resolves, or if the OneAtATime itself is dropped, the first task will be cancelled and return Ok(None)
+    /// otherwise you'll see the result of the task.
+    fn spawn<F, Fut, R>(&mut self, cx: &mut AppContext, f: F) -> Task<Result<Option<R>>>
+    where
+        F: 'static + FnOnce(AsyncAppContext) -> Fut,
+        Fut: Future<Output = Result<R>>,
+        R: 'static,
+    {
+        let (tx, rx) = oneshot::channel();
+        self.cancel.replace(tx);
+        cx.spawn(|cx| async move {
+            futures::select_biased! {
+                _ = rx.fuse() => Ok(None),
+                result = f(cx).fuse() => result.map(Some),
+            }
+        })
+    }
+
+    fn running(&self) -> bool {
+        self.cancel
+            .as_ref()
+            .is_some_and(|cancel| !cancel.is_canceled())
+    }
+}
+
+#[derive(Clone)]
+pub struct IncomingCall {
+    pub room_id: u64,
+    pub calling_user: Arc<User>,
+    pub participants: Vec<Arc<User>>,
+    pub initial_project: Option<proto::ParticipantProject>,
+}
+
+/// Singleton global maintaining the user's participation in a room across workspaces.
+pub struct ActiveCall {
+    room: Option<(Model<Room>, Vec<Subscription>)>,
+    pending_room_creation: Option<Shared<Task<Result<Model<Room>, Arc<anyhow::Error>>>>>,
+    location: Option<WeakModel<Project>>,
+    _join_debouncer: OneAtATime,
+    pending_invites: HashSet<u64>,
+    incoming_call: (
+        watch::Sender<Option<IncomingCall>>,
+        watch::Receiver<Option<IncomingCall>>,
+    ),
+    client: Arc<Client>,
+    user_store: Model<UserStore>,
+    _subscriptions: Vec<client::Subscription>,
+}
+
+impl EventEmitter<Event> for ActiveCall {}
+
+impl ActiveCall {
+    fn new(client: Arc<Client>, user_store: Model<UserStore>, cx: &mut ModelContext<Self>) -> Self {
+        Self {
+            room: None,
+            pending_room_creation: None,
+            location: None,
+            pending_invites: Default::default(),
+            incoming_call: watch::channel(),
+            _join_debouncer: OneAtATime { cancel: None },
+            _subscriptions: vec![
+                client.add_request_handler(cx.weak_model(), Self::handle_incoming_call),
+                client.add_message_handler(cx.weak_model(), Self::handle_call_canceled),
+            ],
+            client,
+            user_store,
+        }
+    }
+
+    pub fn channel_id(&self, cx: &AppContext) -> Option<ChannelId> {
+        self.room()?.read(cx).channel_id()
+    }
+
+    async fn handle_incoming_call(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::IncomingCall>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::Ack> {
+        let user_store = this.update(&mut cx, |this, _| this.user_store.clone())?;
+        let call = IncomingCall {
+            room_id: envelope.payload.room_id,
+            participants: user_store
+                .update(&mut cx, |user_store, cx| {
+                    user_store.get_users(envelope.payload.participant_user_ids, cx)
+                })?
+                .await?,
+            calling_user: user_store
+                .update(&mut cx, |user_store, cx| {
+                    user_store.get_user(envelope.payload.calling_user_id, cx)
+                })?
+                .await?,
+            initial_project: envelope.payload.initial_project,
+        };
+        this.update(&mut cx, |this, _| {
+            *this.incoming_call.0.borrow_mut() = Some(call);
+        })?;
+
+        Ok(proto::Ack {})
+    }
+
+    async fn handle_call_canceled(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::CallCanceled>,
+        mut cx: AsyncAppContext,
+    ) -> Result<()> {
+        this.update(&mut cx, |this, _| {
+            let mut incoming_call = this.incoming_call.0.borrow_mut();
+            if incoming_call
+                .as_ref()
+                .map_or(false, |call| call.room_id == envelope.payload.room_id)
+            {
+                incoming_call.take();
+            }
+        })?;
+        Ok(())
+    }
+
+    pub fn global(cx: &AppContext) -> Model<Self> {
+        cx.global::<GlobalActiveCall>().0.clone()
+    }
+
+    pub fn try_global(cx: &AppContext) -> Option<Model<Self>> {
+        cx.try_global::<GlobalActiveCall>()
+            .map(|call| call.0.clone())
+    }
+
+    pub fn invite(
+        &mut self,
+        called_user_id: u64,
+        initial_project: Option<Model<Project>>,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        if !self.pending_invites.insert(called_user_id) {
+            return Task::ready(Err(anyhow!("user was already invited")));
+        }
+        cx.notify();
+
+        if self._join_debouncer.running() {
+            return Task::ready(Ok(()));
+        }
+
+        let room = if let Some(room) = self.room().cloned() {
+            Some(Task::ready(Ok(room)).shared())
+        } else {
+            self.pending_room_creation.clone()
+        };
+
+        let invite = if let Some(room) = room {
+            cx.spawn(move |_, mut cx| async move {
+                let room = room.await.map_err(|err| anyhow!("{:?}", err))?;
+
+                let initial_project_id = if let Some(initial_project) = initial_project {
+                    Some(
+                        room.update(&mut cx, |room, cx| room.share_project(initial_project, cx))?
+                            .await?,
+                    )
+                } else {
+                    None
+                };
+
+                room.update(&mut cx, move |room, cx| {
+                    room.call(called_user_id, initial_project_id, cx)
+                })?
+                .await?;
+
+                anyhow::Ok(())
+            })
+        } else {
+            let client = self.client.clone();
+            let user_store = self.user_store.clone();
+            let room = cx
+                .spawn(move |this, mut cx| async move {
+                    let create_room = async {
+                        let room = cx
+                            .update(|cx| {
+                                Room::create(
+                                    called_user_id,
+                                    initial_project,
+                                    client,
+                                    user_store,
+                                    cx,
+                                )
+                            })?
+                            .await?;
+
+                        this.update(&mut cx, |this, cx| this.set_room(Some(room.clone()), cx))?
+                            .await?;
+
+                        anyhow::Ok(room)
+                    };
+
+                    let room = create_room.await;
+                    this.update(&mut cx, |this, _| this.pending_room_creation = None)?;
+                    room.map_err(Arc::new)
+                })
+                .shared();
+            self.pending_room_creation = Some(room.clone());
+            cx.background_executor().spawn(async move {
+                room.await.map_err(|err| anyhow!("{:?}", err))?;
+                anyhow::Ok(())
+            })
+        };
+
+        cx.spawn(move |this, mut cx| async move {
+            let result = invite.await;
+            if result.is_ok() {
+                this.update(&mut cx, |this, cx| this.report_call_event("invite", cx))?;
+            } else {
+                //TODO: report collaboration error
+                log::error!("invite failed: {:?}", result);
+            }
+
+            this.update(&mut cx, |this, cx| {
+                this.pending_invites.remove(&called_user_id);
+                cx.notify();
+            })?;
+            result
+        })
+    }
+
+    pub fn cancel_invite(
+        &mut self,
+        called_user_id: u64,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        let room_id = if let Some(room) = self.room() {
+            room.read(cx).id()
+        } else {
+            return Task::ready(Err(anyhow!("no active call")));
+        };
+
+        let client = self.client.clone();
+        cx.background_executor().spawn(async move {
+            client
+                .request(proto::CancelCall {
+                    room_id,
+                    called_user_id,
+                })
+                .await?;
+            anyhow::Ok(())
+        })
+    }
+
+    pub fn incoming(&self) -> watch::Receiver<Option<IncomingCall>> {
+        self.incoming_call.1.clone()
+    }
+
+    pub fn accept_incoming(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
+        if self.room.is_some() {
+            return Task::ready(Err(anyhow!("cannot join while on another call")));
+        }
+
+        let call = if let Some(call) = self.incoming_call.0.borrow_mut().take() {
+            call
+        } else {
+            return Task::ready(Err(anyhow!("no incoming call")));
+        };
+
+        if self.pending_room_creation.is_some() {
+            return Task::ready(Ok(()));
+        }
+
+        let room_id = call.room_id;
+        let client = self.client.clone();
+        let user_store = self.user_store.clone();
+        let join = self
+            ._join_debouncer
+            .spawn(cx, move |cx| Room::join(room_id, client, user_store, cx));
+
+        cx.spawn(|this, mut cx| async move {
+            let room = join.await?;
+            this.update(&mut cx, |this, cx| this.set_room(room.clone(), cx))?
+                .await?;
+            this.update(&mut cx, |this, cx| {
+                this.report_call_event("accept incoming", cx)
+            })?;
+            Ok(())
+        })
+    }
+
+    pub fn decline_incoming(&mut self, _: &mut ModelContext<Self>) -> Result<()> {
+        let call = self
+            .incoming_call
+            .0
+            .borrow_mut()
+            .take()
+            .ok_or_else(|| anyhow!("no incoming call"))?;
+        report_call_event_for_room("decline incoming", call.room_id, None, &self.client);
+        self.client.send(proto::DeclineCall {
+            room_id: call.room_id,
+        })?;
+        Ok(())
+    }
+
+    pub fn join_channel(
+        &mut self,
+        channel_id: ChannelId,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<Option<Model<Room>>>> {
+        if let Some(room) = self.room().cloned() {
+            if room.read(cx).channel_id() == Some(channel_id) {
+                return Task::ready(Ok(Some(room)));
+            } else {
+                room.update(cx, |room, cx| room.clear_state(cx));
+            }
+        }
+
+        if self.pending_room_creation.is_some() {
+            return Task::ready(Ok(None));
+        }
+
+        let client = self.client.clone();
+        let user_store = self.user_store.clone();
+        let join = self._join_debouncer.spawn(cx, move |cx| async move {
+            Room::join_channel(channel_id, client, user_store, cx).await
+        });
+
+        cx.spawn(|this, mut cx| async move {
+            let room = join.await?;
+            this.update(&mut cx, |this, cx| this.set_room(room.clone(), cx))?
+                .await?;
+            this.update(&mut cx, |this, cx| {
+                this.report_call_event("join channel", cx)
+            })?;
+            Ok(room)
+        })
+    }
+
+    pub fn hang_up(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
+        cx.notify();
+        self.report_call_event("hang up", cx);
+
+        Audio::end_call(cx);
+
+        let channel_id = self.channel_id(cx);
+        if let Some((room, _)) = self.room.take() {
+            cx.emit(Event::RoomLeft { channel_id });
+            room.update(cx, |room, cx| room.leave(cx))
+        } else {
+            Task::ready(Ok(()))
+        }
+    }
+
+    pub fn share_project(
+        &mut self,
+        project: Model<Project>,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<u64>> {
+        if let Some((room, _)) = self.room.as_ref() {
+            self.report_call_event("share project", cx);
+            room.update(cx, |room, cx| room.share_project(project, cx))
+        } else {
+            Task::ready(Err(anyhow!("no active call")))
+        }
+    }
+
+    pub fn unshare_project(
+        &mut self,
+        project: Model<Project>,
+        cx: &mut ModelContext<Self>,
+    ) -> Result<()> {
+        if let Some((room, _)) = self.room.as_ref() {
+            self.report_call_event("unshare project", cx);
+            room.update(cx, |room, cx| room.unshare_project(project, cx))
+        } else {
+            Err(anyhow!("no active call"))
+        }
+    }
+
+    pub fn location(&self) -> Option<&WeakModel<Project>> {
+        self.location.as_ref()
+    }
+
+    pub fn set_location(
+        &mut self,
+        project: Option<&Model<Project>>,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        if project.is_some() || !*ZED_ALWAYS_ACTIVE {
+            self.location = project.map(|project| project.downgrade());
+            if let Some((room, _)) = self.room.as_ref() {
+                return room.update(cx, |room, cx| room.set_location(project, cx));
+            }
+        }
+        Task::ready(Ok(()))
+    }
+
+    fn set_room(
+        &mut self,
+        room: Option<Model<Room>>,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        if room.as_ref() == self.room.as_ref().map(|room| &room.0) {
+            Task::ready(Ok(()))
+        } else {
+            cx.notify();
+            if let Some(room) = room {
+                if room.read(cx).status().is_offline() {
+                    self.room = None;
+                    Task::ready(Ok(()))
+                } else {
+                    let subscriptions = vec![
+                        cx.observe(&room, |this, room, cx| {
+                            if room.read(cx).status().is_offline() {
+                                this.set_room(None, cx).detach_and_log_err(cx);
+                            }
+
+                            cx.notify();
+                        }),
+                        cx.subscribe(&room, |_, _, event, cx| cx.emit(event.clone())),
+                    ];
+                    self.room = Some((room.clone(), subscriptions));
+                    let location = self
+                        .location
+                        .as_ref()
+                        .and_then(|location| location.upgrade());
+                    let channel_id = room.read(cx).channel_id();
+                    cx.emit(Event::RoomJoined { channel_id });
+                    room.update(cx, |room, cx| room.set_location(location.as_ref(), cx))
+                }
+            } else {
+                self.room = None;
+                Task::ready(Ok(()))
+            }
+        }
+    }
+
+    pub fn room(&self) -> Option<&Model<Room>> {
+        self.room.as_ref().map(|(room, _)| room)
+    }
+
+    pub fn client(&self) -> Arc<Client> {
+        self.client.clone()
+    }
+
+    pub fn pending_invites(&self) -> &HashSet<u64> {
+        &self.pending_invites
+    }
+
+    pub fn report_call_event(&self, operation: &'static str, cx: &mut AppContext) {
+        if let Some(room) = self.room() {
+            let room = room.read(cx);
+            report_call_event_for_room(operation, room.id(), room.channel_id(), &self.client);
+        }
+    }
+}
+
+pub fn report_call_event_for_room(
+    operation: &'static str,
+    room_id: u64,
+    channel_id: Option<ChannelId>,
+    client: &Arc<Client>,
+) {
+    let telemetry = client.telemetry();
+
+    telemetry.report_call_event(operation, Some(room_id), channel_id)
+}
+
+pub fn report_call_event_for_channel(
+    operation: &'static str,
+    channel_id: ChannelId,
+    client: &Arc<Client>,
+    cx: &AppContext,
+) {
+    let room = ActiveCall::global(cx).read(cx).room();
+
+    let telemetry = client.telemetry();
+
+    telemetry.report_call_event(operation, room.map(|r| r.read(cx).id()), Some(channel_id))
+}
+
+#[cfg(test)]
+mod test {
+    use gpui::TestAppContext;
+
+    use crate::OneAtATime;
+
+    #[gpui::test]
+    async fn test_one_at_a_time(cx: &mut TestAppContext) {
+        let mut one_at_a_time = OneAtATime { cancel: None };
+
+        assert_eq!(
+            cx.update(|cx| one_at_a_time.spawn(cx, |_| async { Ok(1) }))
+                .await
+                .unwrap(),
+            Some(1)
+        );
+
+        let (a, b) = cx.update(|cx| {
+            (
+                one_at_a_time.spawn(cx, |_| async {
+                    panic!("");
+                }),
+                one_at_a_time.spawn(cx, |_| async { Ok(3) }),
+            )
+        });
+
+        assert_eq!(a.await.unwrap(), None::<u32>);
+        assert_eq!(b.await.unwrap(), Some(3));
+
+        let promise = cx.update(|cx| one_at_a_time.spawn(cx, |_| async { Ok(4) }));
+        drop(one_at_a_time);
+
+        assert_eq!(promise.await.unwrap(), None);
+    }
+}
--- a/crates/call/src/macos/participant.rs
+++ b/crates/call/src/macos/participant.rs
@@ -3,8 +3,8 @@ use client::ParticipantIndex;
 use client::{proto, User};
 use collections::HashMap;
 use gpui::WeakModel;
-pub use live_kit_client::Frame;
-pub use live_kit_client::{RemoteAudioTrack, RemoteVideoTrack};
+pub use livekit_client_macos::Frame;
+pub use livekit_client_macos::{RemoteAudioTrack, RemoteVideoTrack};
 use project::Project;
 use std::sync::Arc;

@@ -49,6 +49,12 @@ pub struct RemoteParticipant {
    pub participant_index: ParticipantIndex,
    pub muted: bool,
    pub speaking: bool,
-    pub video_tracks: HashMap<live_kit_client::Sid, Arc<RemoteVideoTrack>>,
-    pub audio_tracks: HashMap<live_kit_client::Sid, Arc<RemoteAudioTrack>>,
+    pub video_tracks: HashMap<livekit_client_macos::Sid, Arc<RemoteVideoTrack>>,
+    pub audio_tracks: HashMap<livekit_client_macos::Sid, Arc<RemoteAudioTrack>>,
+}
+
+impl RemoteParticipant {
+    pub fn has_video_tracks(&self) -> bool {
+        !self.video_tracks.is_empty()
+    }
 }
--- a/crates/call/src/macos/room.rs
+++ b/crates/call/src/macos/room.rs
@@ -15,7 +15,7 @@ use gpui::{
    AppContext, AsyncAppContext, Context, EventEmitter, Model, ModelContext, Task, WeakModel,
 };
 use language::LanguageRegistry;
-use live_kit_client::{LocalAudioTrack, LocalTrackPublication, LocalVideoTrack, RoomUpdate};
+use livekit_client_macos::{LocalAudioTrack, LocalTrackPublication, LocalVideoTrack, RoomUpdate};
 use postage::{sink::Sink, stream::Stream, watch};
 use project::Project;
 use settings::Settings as _;
@@ -97,7 +97,7 @@ impl Room {
        if let Some(live_kit) = self.live_kit.as_ref() {
            matches!(
                *live_kit.room.status().borrow(),
-                live_kit_client::ConnectionState::Connected { .. }
+                livekit_client_macos::ConnectionState::Connected { .. }
            )
        } else {
            false
@@ -113,7 +113,7 @@ impl Room {
        cx: &mut ModelContext<Self>,
    ) -> Self {
        let live_kit_room = if let Some(connection_info) = live_kit_connection_info {
-            let room = live_kit_client::Room::new();
+            let room = livekit_client_macos::Room::new();
            let mut status = room.status();
            // Consume the initial status of the room.
            let _ = status.try_recv();
@@ -125,7 +125,7 @@ impl Room {
                        break;
                    };

-                    if status == live_kit_client::ConnectionState::Disconnected {
+                    if status == livekit_client_macos::ConnectionState::Disconnected {
                        this.update(&mut cx, |this, cx| this.leave(cx).log_err())
                            .ok();
                        break;
@@ -156,7 +156,7 @@ impl Room {
            cx.spawn(|this, mut cx| async move {
                connect.await?;
                this.update(&mut cx, |this, cx| {
-                    if this.can_use_microphone() {
+                    if this.can_use_microphone(cx) {
                        if let Some(live_kit) = &this.live_kit {
                            if !live_kit.muted_by_user && !live_kit.deafened {
                                return this.share_microphone(cx);
@@ -1317,7 +1317,7 @@ impl Room {
        self.live_kit.as_ref().map(|live_kit| live_kit.deafened)
    }

-    pub fn can_use_microphone(&self) -> bool {
+    pub fn can_use_microphone(&self, _cx: &AppContext) -> bool {
        use proto::ChannelRole::*;
        match self.local_participant.role {
            Admin | Member | Talker => true,
@@ -1631,7 +1631,7 @@ impl Room {
    }

    #[cfg(any(test, feature = "test-support"))]
-    pub fn set_display_sources(&self, sources: Vec<live_kit_client::MacOSDisplay>) {
+    pub fn set_display_sources(&self, sources: Vec<livekit_client_macos::MacOSDisplay>) {
        self.live_kit
            .as_ref()
            .unwrap()
@@ -1641,7 +1641,7 @@ impl Room {
 }

 struct LiveKitRoom {
-    room: Arc<live_kit_client::Room>,
+    room: Arc<livekit_client_macos::Room>,
    screen_track: LocalTrack,
    microphone_track: LocalTrack,
    /// Tracks whether we're currently in a muted state due to auto-mute from deafening or manual mute performed by user.
--- a/crates/collab/.env.toml
+++ b/crates/collab/.env.toml
@@ -5,9 +5,9 @@ HTTP_PORT = 8080
 API_TOKEN = "secret"
 INVITE_LINK_PREFIX = "http://localhost:3000/invites/"
 ZED_ENVIRONMENT = "development"
-LIVE_KIT_SERVER = "http://localhost:7880"
-LIVE_KIT_KEY = "devkey"
-LIVE_KIT_SECRET = "secret"
+LIVEKIT_SERVER = "http://localhost:7880"
+LIVEKIT_KEY = "devkey"
+LIVEKIT_SECRET = "secret"
 BLOB_STORE_ACCESS_KEY = "the-blob-store-access-key"
 BLOB_STORE_SECRET_KEY = "the-blob-store-secret-key"
 BLOB_STORE_BUCKET = "the-extensions-bucket"
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -40,7 +40,7 @@ google_ai.workspace = true
 hex.workspace = true
 http_client.workspace = true
 jsonwebtoken.workspace = true
-live_kit_server.workspace = true
+livekit_server.workspace = true
 log.workspace = true
 nanoid.workspace = true
 open_ai.workspace = true
@@ -77,6 +77,12 @@ tracing-subscriber = { version = "0.3.18", features = ["env-filter", "json", "re
 util.workspace = true
 uuid.workspace = true

+[target.'cfg(target_os = "macos")'.dependencies]
+livekit_client_macos = { workspace = true, features = ["test-support"] }
+
+[target.'cfg(not(target_os = "macos"))'.dependencies]
+livekit_client = { workspace = true, features = ["test-support"] }
+
 [dev-dependencies]
 assistant = { workspace = true, features = ["test-support"] }
 assistant_tool.workspace = true
@@ -101,7 +107,6 @@ hyper.workspace = true
 indoc.workspace = true
 language = { workspace = true, features = ["test-support"] }
 language_model = { workspace = true, features = ["test-support"] }
-live_kit_client = { workspace = true, features = ["test-support"] }
 lsp = { workspace = true, features = ["test-support"] }
 menu.workspace = true
 multi_buffer = { workspace = true, features = ["test-support"] }
@@ -125,5 +130,11 @@ util.workspace = true
 workspace = { workspace = true, features = ["test-support"] }
 worktree = { workspace = true, features = ["test-support"] }

+[target.'cfg(target_os = "macos")'.dev-dependencies]
+livekit_client_macos = { workspace = true, features = ["test-support"] }
+
+[target.'cfg(not(target_os = "macos"))'.dev-dependencies]
+livekit_client =  {workspace = true, features = ["test-support"] }
+
 [package.metadata.cargo-machete]
 ignored = ["async-stripe"]
--- a/crates/collab/k8s/collab.template.yml
+++ b/crates/collab/k8s/collab.template.yml
@@ -109,17 +109,17 @@ spec:
                secretKeyRef:
                  name: zed-client
                  key: checksum-seed
-            - name: LIVE_KIT_SERVER
+            - name: LIVEKIT_SERVER
              valueFrom:
                secretKeyRef:
                  name: livekit
                  key: server
-            - name: LIVE_KIT_KEY
+            - name: LIVEKIT_KEY
              valueFrom:
                secretKeyRef:
                  name: livekit
                  key: key
-            - name: LIVE_KIT_SECRET
+            - name: LIVEKIT_SECRET
              valueFrom:
                secretKeyRef:
                  name: livekit
--- a/crates/collab/src/db/queries/channels.rs
+++ b/crates/collab/src/db/queries/channels.rs
@@ -154,9 +154,9 @@ impl Database {
            }
            let role = role.unwrap();

-            let live_kit_room = format!("channel-{}", nanoid::nanoid!(30));
+            let livekit_room = format!("channel-{}", nanoid::nanoid!(30));
            let room_id = self
-                .get_or_create_channel_room(channel_id, &live_kit_room, &tx)
+                .get_or_create_channel_room(channel_id, &livekit_room, &tx)
                .await?;

            self.join_channel_room_internal(room_id, user_id, connection, role, &tx)
@@ -896,7 +896,7 @@ impl Database {
    pub(crate) async fn get_or_create_channel_room(
        &self,
        channel_id: ChannelId,
-        live_kit_room: &str,
+        livekit_room: &str,
        tx: &DatabaseTransaction,
    ) -> Result<RoomId> {
        let room = room::Entity::find()
@@ -909,7 +909,7 @@ impl Database {
        } else {
            let result = room::Entity::insert(room::ActiveModel {
                channel_id: ActiveValue::Set(Some(channel_id)),
-                live_kit_room: ActiveValue::Set(live_kit_room.to_string()),
+                live_kit_room: ActiveValue::Set(livekit_room.to_string()),
                ..Default::default()
            })
            .exec(tx)
--- a/crates/collab/src/db/queries/rooms.rs
+++ b/crates/collab/src/db/queries/rooms.rs
@@ -103,11 +103,11 @@ impl Database {
        &self,
        user_id: UserId,
        connection: ConnectionId,
-        live_kit_room: &str,
+        livekit_room: &str,
    ) -> Result<proto::Room> {
        self.transaction(|tx| async move {
            let room = room::ActiveModel {
-                live_kit_room: ActiveValue::set(live_kit_room.into()),
+                live_kit_room: ActiveValue::set(livekit_room.into()),
                ..Default::default()
            }
            .insert(&*tx)
@@ -1316,7 +1316,7 @@ impl Database {
            channel,
            proto::Room {
                id: db_room.id.to_proto(),
-                live_kit_room: db_room.live_kit_room,
+                livekit_room: db_room.live_kit_room,
                participants: participants.into_values().collect(),
                pending_participants,
                followers,
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -156,9 +156,9 @@ pub struct Config {
    pub clickhouse_password: Option<String>,
    pub clickhouse_database: Option<String>,
    pub invite_link_prefix: String,
-    pub live_kit_server: Option<String>,
-    pub live_kit_key: Option<String>,
-    pub live_kit_secret: Option<String>,
+    pub livekit_server: Option<String>,
+    pub livekit_key: Option<String>,
+    pub livekit_secret: Option<String>,
    pub llm_database_url: Option<String>,
    pub llm_database_max_connections: Option<u32>,
    pub llm_database_migrations_path: Option<PathBuf>,
@@ -210,9 +210,9 @@ impl Config {
            database_max_connections: 0,
            api_token: "".into(),
            invite_link_prefix: "".into(),
-            live_kit_server: None,
-            live_kit_key: None,
-            live_kit_secret: None,
+            livekit_server: None,
+            livekit_key: None,
+            livekit_secret: None,
            llm_database_url: None,
            llm_database_max_connections: None,
            llm_database_migrations_path: None,
@@ -277,7 +277,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 livekit_client: Option<Arc<dyn livekit_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>>,
@@ -309,17 +309,17 @@ impl AppState {
            None
        };

-        let live_kit_client = if let Some(((server, key), secret)) = config
-            .live_kit_server
+        let livekit_client = if let Some(((server, key), secret)) = config
+            .livekit_server
            .as_ref()
-            .zip(config.live_kit_key.as_ref())
-            .zip(config.live_kit_secret.as_ref())
+            .zip(config.livekit_key.as_ref())
+            .zip(config.livekit_secret.as_ref())
        {
-            Some(Arc::new(live_kit_server::api::LiveKitClient::new(
+            Some(Arc::new(livekit_server::api::LiveKitClient::new(
                server.clone(),
                key.clone(),
                secret.clone(),
-            )) as Arc<dyn live_kit_server::api::Client>)
+            )) as Arc<dyn livekit_server::api::Client>)
        } else {
            None
        };
@@ -329,7 +329,7 @@ impl AppState {
        let this = Self {
            db: db.clone(),
            llm_db,
-            live_kit_client,
+            livekit_client,
            blob_store_client: build_blob_store_client(&config).await.log_err(),
            stripe_billing: stripe_client
                .clone()
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -309,6 +309,7 @@ impl Server {
            .add_request_handler(forward_read_only_project_request::<proto::ResolveInlayHint>)
            .add_request_handler(forward_read_only_project_request::<proto::OpenBufferByPath>)
            .add_request_handler(forward_read_only_project_request::<proto::GitBranches>)
+            .add_request_handler(forward_read_only_project_request::<proto::GetStagedText>)
            .add_request_handler(forward_mutating_project_request::<proto::UpdateGitBranch>)
            .add_request_handler(forward_mutating_project_request::<proto::GetCompletions>)
            .add_request_handler(
@@ -418,7 +419,7 @@ impl Server {
        let peer = self.peer.clone();
        let timeout = self.app_state.executor.sleep(CLEANUP_TIMEOUT);
        let pool = self.connection_pool.clone();
-        let live_kit_client = self.app_state.live_kit_client.clone();
+        let livekit_client = self.app_state.livekit_client.clone();

        let span = info_span!("start server");
        self.app_state.executor.spawn_detached(
@@ -463,8 +464,8 @@ impl Server {
                    for room_id in room_ids {
                        let mut contacts_to_update = HashSet::default();
                        let mut canceled_calls_to_user_ids = Vec::new();
-                        let mut live_kit_room = String::new();
-                        let mut delete_live_kit_room = false;
+                        let mut livekit_room = String::new();
+                        let mut delete_livekit_room = false;

                        if let Some(mut refreshed_room) = app_state
                            .db
@@ -487,8 +488,8 @@ impl Server {
                                .extend(refreshed_room.canceled_calls_to_user_ids.iter().copied());
                            canceled_calls_to_user_ids =
                                mem::take(&mut refreshed_room.canceled_calls_to_user_ids);
-                            live_kit_room = mem::take(&mut refreshed_room.room.live_kit_room);
-                            delete_live_kit_room = refreshed_room.room.participants.is_empty();
+                            livekit_room = mem::take(&mut refreshed_room.room.livekit_room);
+                            delete_livekit_room = refreshed_room.room.participants.is_empty();
                        }

                        {
@@ -539,9 +540,9 @@ impl Server {
                            }
                        }

-                        if let Some(live_kit) = live_kit_client.as_ref() {
-                            if delete_live_kit_room {
-                                live_kit.delete_room(live_kit_room).await.trace_err();
+                        if let Some(live_kit) = livekit_client.as_ref() {
+                            if delete_livekit_room {
+                                live_kit.delete_room(livekit_room).await.trace_err();
                            }
                        }
                    }
@@ -1210,15 +1211,15 @@ async fn create_room(
    response: Response<proto::CreateRoom>,
    session: Session,
 ) -> Result<()> {
-    let live_kit_room = nanoid::nanoid!(30);
+    let livekit_room = nanoid::nanoid!(30);

    let live_kit_connection_info = util::maybe!(async {
-        let live_kit = session.app_state.live_kit_client.as_ref();
+        let live_kit = session.app_state.livekit_client.as_ref();
        let live_kit = live_kit?;
        let user_id = session.user_id().to_string();

        let token = live_kit
-            .room_token(&live_kit_room, &user_id.to_string())
+            .room_token(&livekit_room, &user_id.to_string())
            .trace_err()?;

        Some(proto::LiveKitConnectionInfo {
@@ -1232,7 +1233,7 @@ async fn create_room(
    let room = session
        .db()
        .await
-        .create_room(session.user_id(), session.connection_id, &live_kit_room)
+        .create_room(session.user_id(), session.connection_id, &livekit_room)
        .await?;

    response.send(proto::CreateRoomResponse {
@@ -1284,22 +1285,22 @@ async fn join_room(
            .trace_err();
    }

-    let live_kit_connection_info =
-        if let Some(live_kit) = session.app_state.live_kit_client.as_ref() {
-            live_kit
-                .room_token(
-                    &joined_room.room.live_kit_room,
-                    &session.user_id().to_string(),
-                )
-                .trace_err()
-                .map(|token| proto::LiveKitConnectionInfo {
-                    server_url: live_kit.url().into(),
-                    token,
-                    can_publish: true,
-                })
-        } else {
-            None
-        };
+    let live_kit_connection_info = if let Some(live_kit) = session.app_state.livekit_client.as_ref()
+    {
+        live_kit
+            .room_token(
+                &joined_room.room.livekit_room,
+                &session.user_id().to_string(),
+            )
+            .trace_err()
+            .map(|token| proto::LiveKitConnectionInfo {
+                server_url: live_kit.url().into(),
+                token,
+                can_publish: true,
+            })
+    } else {
+        None
+    };

    response.send(proto::JoinRoomResponse {
        room: Some(joined_room.room),
@@ -1506,7 +1507,7 @@ async fn set_room_participant_role(
    let user_id = UserId::from_proto(request.user_id);
    let role = ChannelRole::from(request.role());

-    let (live_kit_room, can_publish) = {
+    let (livekit_room, can_publish) = {
        let room = session
            .db()
            .await
@@ -1518,18 +1519,18 @@ async fn set_room_participant_role(
            )
            .await?;

-        let live_kit_room = room.live_kit_room.clone();
+        let livekit_room = room.livekit_room.clone();
        let can_publish = ChannelRole::from(request.role()).can_use_microphone();
        room_updated(&room, &session.peer);
-        (live_kit_room, can_publish)
+        (livekit_room, can_publish)
    };

-    if let Some(live_kit) = session.app_state.live_kit_client.as_ref() {
+    if let Some(live_kit) = session.app_state.livekit_client.as_ref() {
        live_kit
            .update_participant(
-                live_kit_room.clone(),
+                livekit_room.clone(),
                request.user_id.to_string(),
-                live_kit_server::proto::ParticipantPermission {
+                livekit_server::proto::ParticipantPermission {
                    can_subscribe: true,
                    can_publish,
                    can_publish_data: can_publish,
@@ -3091,7 +3092,7 @@ async fn join_channel_internal(
        let live_kit_connection_info =
            session
                .app_state
-                .live_kit_client
+                .livekit_client
                .as_ref()
                .and_then(|live_kit| {
                    let (can_publish, token) = if role == ChannelRole::Guest {
@@ -3099,7 +3100,7 @@ async fn join_channel_internal(
                            false,
                            live_kit
                                .guest_token(
-                                    &joined_room.room.live_kit_room,
+                                    &joined_room.room.livekit_room,
                                    &session.user_id().to_string(),
                                )
                                .trace_err()?,
@@ -3109,7 +3110,7 @@ async fn join_channel_internal(
                            true,
                            live_kit
                                .room_token(
-                                    &joined_room.room.live_kit_room,
+                                    &joined_room.room.livekit_room,
                                    &session.user_id().to_string(),
                                )
                                .trace_err()?,
@@ -4313,8 +4314,8 @@ async fn leave_room_for_session(session: &Session, connection_id: ConnectionId)

    let room_id;
    let canceled_calls_to_user_ids;
-    let live_kit_room;
-    let delete_live_kit_room;
+    let livekit_room;
+    let delete_livekit_room;
    let room;
    let channel;

@@ -4327,8 +4328,8 @@ async fn leave_room_for_session(session: &Session, connection_id: ConnectionId)

        room_id = RoomId::from_proto(left_room.room.id);
        canceled_calls_to_user_ids = mem::take(&mut left_room.canceled_calls_to_user_ids);
-        live_kit_room = mem::take(&mut left_room.room.live_kit_room);
-        delete_live_kit_room = left_room.deleted;
+        livekit_room = mem::take(&mut left_room.room.livekit_room);
+        delete_livekit_room = left_room.deleted;
        room = mem::take(&mut left_room.room);
        channel = mem::take(&mut left_room.channel);

@@ -4368,14 +4369,14 @@ async fn leave_room_for_session(session: &Session, connection_id: ConnectionId)
        update_user_contacts(contact_user_id, session).await?;
    }

-    if let Some(live_kit) = session.app_state.live_kit_client.as_ref() {
+    if let Some(live_kit) = session.app_state.livekit_client.as_ref() {
        live_kit
-            .remove_participant(live_kit_room.clone(), session.user_id().to_string())
+            .remove_participant(livekit_room.clone(), session.user_id().to_string())
            .await
            .trace_err();

-        if delete_live_kit_room {
-            live_kit.delete_room(live_kit_room).await.trace_err();
+        if delete_livekit_room {
+            live_kit.delete_room(livekit_room).await.trace_err();
        }
    }

--- a/crates/collab/src/tests.rs
+++ b/crates/collab/src/tests.rs
@@ -1,3 +1,6 @@
+// todo(windows): Actually run the tests
+#![cfg(not(target_os = "windows"))]
+
 use std::sync::Arc;

 use call::Room;
--- a/crates/collab/src/tests/channel_guest_tests.rs
+++ b/crates/collab/src/tests/channel_guest_tests.rs
@@ -107,7 +107,9 @@ async fn test_channel_guest_promotion(cx_a: &mut TestAppContext, cx_b: &mut Test
    });
    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()));
+    cx_b.update(|cx_b| {
+        assert!(room_b.read_with(cx_b, |room, cx| !room.can_use_microphone(cx)));
+    });
    assert!(room_b
        .update(cx_b, |room, cx| room.share_microphone(cx))
        .await
@@ -133,7 +135,9 @@ async fn test_channel_guest_promotion(cx_a: &mut TestAppContext, cx_b: &mut Test
    assert!(editor_b.update(cx_b, |editor, cx| !editor.read_only(cx)));

    // B sees themselves as muted, and can unmute.
-    assert!(room_b.read_with(cx_b, |room, _| room.can_use_microphone()));
+    cx_b.update(|cx_b| {
+        assert!(room_b.read_with(cx_b, |room, cx| room.can_use_microphone(cx)));
+    });
    room_b.read_with(cx_b, |room, _| assert!(room.is_muted()));
    room_b.update(cx_b, |room, cx| room.toggle_mute(cx));
    cx_a.run_until_parked();
@@ -226,7 +230,9 @@ async fn test_channel_requires_zed_cla(cx_a: &mut TestAppContext, cx_b: &mut Tes
    let room_b = cx_b
        .read(ActiveCall::global)
        .update(cx_b, |call, _| call.room().unwrap().clone());
-    assert!(room_b.read_with(cx_b, |room, _| !room.can_use_microphone()));
+    cx_b.update(|cx_b| {
+        assert!(room_b.read_with(cx_b, |room, cx| !room.can_use_microphone(cx)));
+    });

    // A tries to grant write access to B, but cannot because B has not
    // yet signed the zed CLA.
@@ -244,7 +250,9 @@ async fn test_channel_requires_zed_cla(cx_a: &mut TestAppContext, cx_b: &mut Tes
        .unwrap_err();
    cx_a.run_until_parked();
    assert!(room_b.read_with(cx_b, |room, _| !room.can_share_projects()));
-    assert!(room_b.read_with(cx_b, |room, _| !room.can_use_microphone()));
+    cx_b.update(|cx_b| {
+        assert!(room_b.read_with(cx_b, |room, cx| !room.can_use_microphone(cx)));
+    });

    // A tries to grant write access to B, but cannot because B has not
    // yet signed the zed CLA.
@@ -262,7 +270,9 @@ async fn test_channel_requires_zed_cla(cx_a: &mut TestAppContext, cx_b: &mut Tes
        .unwrap();
    cx_a.run_until_parked();
    assert!(room_b.read_with(cx_b, |room, _| !room.can_share_projects()));
-    assert!(room_b.read_with(cx_b, |room, _| room.can_use_microphone()));
+    cx_b.update(|cx_b| {
+        assert!(room_b.read_with(cx_b, |room, cx| room.can_use_microphone(cx)));
+    });

    // User B signs the zed CLA.
    server
@@ -287,5 +297,7 @@ async fn test_channel_requires_zed_cla(cx_a: &mut TestAppContext, cx_b: &mut Tes
        .unwrap();
    cx_a.run_until_parked();
    assert!(room_b.read_with(cx_b, |room, _| room.can_share_projects()));
-    assert!(room_b.read_with(cx_b, |room, _| room.can_use_microphone()));
+    cx_b.update(|cx_b| {
+        assert!(room_b.read_with(cx_b, |room, cx| room.can_use_microphone(cx)));
+    });
 }
--- a/crates/collab/src/tests/following_tests.rs
+++ b/crates/collab/src/tests/following_tests.rs
@@ -1,5 +1,5 @@
 #![allow(clippy::reversed_empty_ranges)]
-use crate::{rpc::RECONNECT_TIMEOUT, tests::TestServer};
+use crate::tests::TestServer;
 use call::{ActiveCall, ParticipantLocation};
 use client::ChannelId;
 use collab_ui::{
@@ -12,17 +12,11 @@ use gpui::{
    View, VisualContext, VisualTestContext,
 };
 use language::Capability;
-use live_kit_client::MacOSDisplay;
 use project::WorktreeSettings;
 use rpc::proto::PeerId;
 use serde_json::json;
 use settings::SettingsStore;
-use workspace::{
-    dock::{test::TestPanel, DockPosition},
-    item::{test::TestItem, ItemHandle as _},
-    shared_screen::SharedScreen,
-    SplitDirection, Workspace,
-};
+use workspace::{item::ItemHandle as _, SplitDirection, Workspace};

 use super::TestClient;

@@ -428,106 +422,118 @@ async fn test_basic_following(
        editor_a1.item_id()
    );

-    // Client B activates an external window, which causes a new screen-sharing item to be added to the pane.
-    let display = MacOSDisplay::new();
-    active_call_b
-        .update(cx_b, |call, cx| call.set_location(None, cx))
-        .await
-        .unwrap();
-    active_call_b
-        .update(cx_b, |call, cx| {
-            call.room().unwrap().update(cx, |room, cx| {
-                room.set_display_sources(vec![display.clone()]);
-                room.share_screen(cx)
+    // TODO: Re-enable this test once we can replace our swift Livekit SDK with the rust SDK
+    #[cfg(not(target_os = "macos"))]
+    {
+        use crate::rpc::RECONNECT_TIMEOUT;
+        use gpui::TestScreenCaptureSource;
+        use workspace::{
+            dock::{test::TestPanel, DockPosition},
+            item::test::TestItem,
+            shared_screen::SharedScreen,
+        };
+
+        // Client B activates an external window, which causes a new screen-sharing item to be added to the pane.
+        let display = TestScreenCaptureSource::new();
+        active_call_b
+            .update(cx_b, |call, cx| call.set_location(None, cx))
+            .await
+            .unwrap();
+        cx_b.set_screen_capture_sources(vec![display]);
+        active_call_b
+            .update(cx_b, |call, cx| {
+                call.room()
+                    .unwrap()
+                    .update(cx, |room, cx| room.share_screen(cx))
            })
-        })
-        .await
-        .unwrap();
-    executor.run_until_parked();
-    let shared_screen = workspace_a.update(cx_a, |workspace, cx| {
-        workspace
-            .active_item(cx)
-            .expect("no active item")
-            .downcast::<SharedScreen>()
-            .expect("active item isn't a shared screen")
-    });
+            .await
+            .unwrap(); // This is what breaks
+        executor.run_until_parked();
+        let shared_screen = workspace_a.update(cx_a, |workspace, cx| {
+            workspace
+                .active_item(cx)
+                .expect("no active item")
+                .downcast::<SharedScreen>()
+                .expect("active item isn't a shared screen")
+        });

-    // Client B activates Zed again, which causes the previous editor to become focused again.
-    active_call_b
-        .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
-        .await
-        .unwrap();
-    executor.run_until_parked();
-    workspace_a.update(cx_a, |workspace, cx| {
+        // Client B activates Zed again, which causes the previous editor to become focused again.
+        active_call_b
+            .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
+            .await
+            .unwrap();
+        executor.run_until_parked();
+        workspace_a.update(cx_a, |workspace, cx| {
+            assert_eq!(
+                workspace.active_item(cx).unwrap().item_id(),
+                editor_a1.item_id()
+            )
+        });
+
+        // Client B activates a multibuffer that was created by following client A. Client A returns to that multibuffer.
+        workspace_b.update(cx_b, |workspace, cx| {
+            workspace.activate_item(&multibuffer_editor_b, true, true, cx)
+        });
+        executor.run_until_parked();
+        workspace_a.update(cx_a, |workspace, cx| {
+            assert_eq!(
+                workspace.active_item(cx).unwrap().item_id(),
+                multibuffer_editor_a.item_id()
+            )
+        });
+
+        // Client B activates a panel, and the previously-opened screen-sharing item gets activated.
+        let panel = cx_b.new_view(|cx| TestPanel::new(DockPosition::Left, cx));
+        workspace_b.update(cx_b, |workspace, cx| {
+            workspace.add_panel(panel, cx);
+            workspace.toggle_panel_focus::<TestPanel>(cx);
+        });
+        executor.run_until_parked();
        assert_eq!(
-            workspace.active_item(cx).unwrap().item_id(),
-            editor_a1.item_id()
-        )
-    });
+            workspace_a.update(cx_a, |workspace, cx| workspace
+                .active_item(cx)
+                .unwrap()
+                .item_id()),
+            shared_screen.item_id()
+        );

-    // Client B activates a multibuffer that was created by following client A. Client A returns to that multibuffer.
-    workspace_b.update(cx_b, |workspace, cx| {
-        workspace.activate_item(&multibuffer_editor_b, true, true, cx)
-    });
-    executor.run_until_parked();
-    workspace_a.update(cx_a, |workspace, cx| {
+        // Toggling the focus back to the pane causes client A to return to the multibuffer.
+        workspace_b.update(cx_b, |workspace, cx| {
+            workspace.toggle_panel_focus::<TestPanel>(cx);
+        });
+        executor.run_until_parked();
+        workspace_a.update(cx_a, |workspace, cx| {
+            assert_eq!(
+                workspace.active_item(cx).unwrap().item_id(),
+                multibuffer_editor_a.item_id()
+            )
+        });
+
+        // Client B activates an item that doesn't implement following,
+        // so the previously-opened screen-sharing item gets activated.
+        let unfollowable_item = cx_b.new_view(TestItem::new);
+        workspace_b.update(cx_b, |workspace, cx| {
+            workspace.active_pane().update(cx, |pane, cx| {
+                pane.add_item(Box::new(unfollowable_item), true, true, None, cx)
+            })
+        });
+        executor.run_until_parked();
        assert_eq!(
-            workspace.active_item(cx).unwrap().item_id(),
-            multibuffer_editor_a.item_id()
-        )
-    });
+            workspace_a.update(cx_a, |workspace, cx| workspace
+                .active_item(cx)
+                .unwrap()
+                .item_id()),
+            shared_screen.item_id()
+        );

-    // Client B activates a panel, and the previously-opened screen-sharing item gets activated.
-    let panel = cx_b.new_view(|cx| TestPanel::new(DockPosition::Left, cx));
-    workspace_b.update(cx_b, |workspace, cx| {
-        workspace.add_panel(panel, cx);
-        workspace.toggle_panel_focus::<TestPanel>(cx);
-    });
-    executor.run_until_parked();
-    assert_eq!(
-        workspace_a.update(cx_a, |workspace, cx| workspace
-            .active_item(cx)
-            .unwrap()
-            .item_id()),
-        shared_screen.item_id()
-    );
-
-    // Toggling the focus back to the pane causes client A to return to the multibuffer.
-    workspace_b.update(cx_b, |workspace, cx| {
-        workspace.toggle_panel_focus::<TestPanel>(cx);
-    });
-    executor.run_until_parked();
-    workspace_a.update(cx_a, |workspace, cx| {
+        // Following interrupts when client B disconnects.
+        client_b.disconnect(&cx_b.to_async());
+        executor.advance_clock(RECONNECT_TIMEOUT);
        assert_eq!(
-            workspace.active_item(cx).unwrap().item_id(),
-            multibuffer_editor_a.item_id()
-        )
-    });
-
-    // Client B activates an item that doesn't implement following,
-    // so the previously-opened screen-sharing item gets activated.
-    let unfollowable_item = cx_b.new_view(TestItem::new);
-    workspace_b.update(cx_b, |workspace, cx| {
-        workspace.active_pane().update(cx, |pane, cx| {
-            pane.add_item(Box::new(unfollowable_item), true, true, None, cx)
-        })
-    });
-    executor.run_until_parked();
-    assert_eq!(
-        workspace_a.update(cx_a, |workspace, cx| workspace
-            .active_item(cx)
-            .unwrap()
-            .item_id()),
-        shared_screen.item_id()
-    );
-
-    // Following interrupts when client B disconnects.
-    client_b.disconnect(&cx_b.to_async());
-    executor.advance_clock(RECONNECT_TIMEOUT);
-    assert_eq!(
-        workspace_a.update(cx_a, |workspace, _| workspace.leader_for_pane(&pane_a)),
-        None
-    );
+            workspace_a.update(cx_a, |workspace, _| workspace.leader_for_pane(&pane_a)),
+            None
+        );
+    }
 }

 #[gpui::test]
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -25,7 +25,6 @@ use language::{
    tree_sitter_rust, tree_sitter_typescript, Diagnostic, DiagnosticEntry, FakeLspAdapter,
    Language, LanguageConfig, LanguageMatcher, LineEnding, OffsetRangeExt, Point, Rope,
 };
-use live_kit_client::MacOSDisplay;
 use lsp::LanguageServerId;
 use parking_lot::Mutex;
 use project::lsp_store::FormatTarget;
@@ -241,56 +240,60 @@ async fn test_basic_calls(
        }
    );

-    // User A shares their screen
-    let display = MacOSDisplay::new();
-    let events_b = active_call_events(cx_b);
-    let events_c = active_call_events(cx_c);
-    active_call_a
-        .update(cx_a, |call, cx| {
-            call.room().unwrap().update(cx, |room, cx| {
-                room.set_display_sources(vec![display.clone()]);
-                room.share_screen(cx)
+    // TODO: Re-enable this test once we can replace our swift Livekit SDK with the rust SDK
+    #[cfg(not(target_os = "macos"))]
+    {
+        // User A shares their screen
+        let display = gpui::TestScreenCaptureSource::new();
+        let events_b = active_call_events(cx_b);
+        let events_c = active_call_events(cx_c);
+        cx_a.set_screen_capture_sources(vec![display]);
+        active_call_a
+            .update(cx_a, |call, cx| {
+                call.room()
+                    .unwrap()
+                    .update(cx, |room, cx| room.share_screen(cx))
            })
-        })
-        .await
-        .unwrap();
+            .await
+            .unwrap();

-    executor.run_until_parked();
+        executor.run_until_parked();

-    // User B observes the remote screen sharing track.
-    assert_eq!(events_b.borrow().len(), 1);
-    let event_b = events_b.borrow().first().unwrap().clone();
-    if let call::room::Event::RemoteVideoTracksChanged { participant_id } = event_b {
-        assert_eq!(participant_id, client_a.peer_id().unwrap());
+        // User B observes the remote screen sharing track.
+        assert_eq!(events_b.borrow().len(), 1);
+        let event_b = events_b.borrow().first().unwrap().clone();
+        if let call::room::Event::RemoteVideoTracksChanged { participant_id } = event_b {
+            assert_eq!(participant_id, client_a.peer_id().unwrap());

-        room_b.read_with(cx_b, |room, _| {
-            assert_eq!(
-                room.remote_participants()[&client_a.user_id().unwrap()]
-                    .video_tracks
-                    .len(),
-                1
-            );
-        });
-    } else {
-        panic!("unexpected event")
-    }
+            room_b.read_with(cx_b, |room, _| {
+                assert_eq!(
+                    room.remote_participants()[&client_a.user_id().unwrap()]
+                        .video_tracks
+                        .len(),
+                    1
+                );
+            });
+        } else {
+            panic!("unexpected event")
+        }

-    // User C observes the remote screen sharing track.
-    assert_eq!(events_c.borrow().len(), 1);
-    let event_c = events_c.borrow().first().unwrap().clone();
-    if let call::room::Event::RemoteVideoTracksChanged { participant_id } = event_c {
-        assert_eq!(participant_id, client_a.peer_id().unwrap());
+        // User C observes the remote screen sharing track.
+        assert_eq!(events_c.borrow().len(), 1);
+        let event_c = events_c.borrow().first().unwrap().clone();
+        if let call::room::Event::RemoteVideoTracksChanged { participant_id } = event_c {
+            assert_eq!(participant_id, client_a.peer_id().unwrap());

-        room_c.read_with(cx_c, |room, _| {
-            assert_eq!(
-                room.remote_participants()[&client_a.user_id().unwrap()]
-                    .video_tracks
-                    .len(),
-                1
-            );
-        });
-    } else {
-        panic!("unexpected event")
+            room_c.read_with(cx_c, |room, _| {
+                assert_eq!(
+                    room.remote_participants()[&client_a.user_id().unwrap()]
+                        .video_tracks
+                        .len(),
+                    1
+                );
+            });
+        } else {
+            panic!("unexpected event")
+        }
    }

    // User A leaves the room.
@@ -329,7 +332,7 @@ async fn test_basic_calls(
    // to automatically leave the room. User C leaves the room as well because
    // nobody else is in there.
    server
-        .test_live_kit_server
+        .test_livekit_server
        .disconnect_client(client_b.user_id().unwrap().to_string())
        .await;
    executor.run_until_parked();
@@ -844,7 +847,7 @@ async fn test_client_disconnecting_from_room(
    // User B gets disconnected from the LiveKit server, which causes it
    // to automatically leave the room.
    server
-        .test_live_kit_server
+        .test_livekit_server
        .disconnect_client(client_b.user_id().unwrap().to_string())
        .await;
    executor.run_until_parked();
@@ -1943,7 +1946,7 @@ async fn test_mute_deafen(
    room_a.read_with(cx_a, |room, _| assert!(!room.is_muted()));
    room_b.read_with(cx_b, |room, _| assert!(!room.is_muted()));

-    // Users A and B are both muted.
+    // Users A and B are both unmuted.
    assert_eq!(
        participant_audio_state(&room_a, cx_a),
        &[ParticipantAudioState {
@@ -2075,7 +2078,17 @@ async fn test_mute_deafen(
                    audio_tracks_playing: participant
                        .audio_tracks
                        .values()
-                        .map(|track| track.is_playing())
+                        .map({
+                            #[cfg(target_os = "macos")]
+                            {
+                                |track| track.is_playing()
+                            }
+
+                            #[cfg(not(target_os = "macos"))]
+                            {
+                                |(track, _)| track.rtc_track().enabled()
+                            }
+                        })
                        .collect(),
                })
                .collect::<Vec<_>>()
@@ -2561,19 +2574,23 @@ async fn test_git_diff_base_change(
        .update(cx_a, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
        .await
        .unwrap();
+    let change_set_local_a = project_local
+        .update(cx_a, |p, cx| {
+            p.open_unstaged_changes(buffer_local_a.clone(), cx)
+        })
+        .await
+        .unwrap();

    // Wait for it to catch up to the new diff
    executor.run_until_parked();
-
-    // Smoke test diffing
-
-    buffer_local_a.read_with(cx_a, |buffer, _| {
+    change_set_local_a.read_with(cx_a, |change_set, cx| {
+        let buffer = buffer_local_a.read(cx);
        assert_eq!(
-            buffer.diff_base().map(|rope| rope.to_string()).as_deref(),
+            change_set.base_text_string(cx).as_deref(),
            Some(diff_base.as_str())
        );
        git::diff::assert_hunks(
-            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
            buffer,
            &diff_base,
            &[(1..2, "", "two\n")],
@@ -2585,25 +2602,30 @@ async fn test_git_diff_base_change(
        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
        .await
        .unwrap();
+    let change_set_remote_a = project_remote
+        .update(cx_b, |p, cx| {
+            p.open_unstaged_changes(buffer_remote_a.clone(), cx)
+        })
+        .await
+        .unwrap();

    // Wait remote buffer to catch up to the new diff
    executor.run_until_parked();
-
-    // Smoke test diffing
-
-    buffer_remote_a.read_with(cx_b, |buffer, _| {
+    change_set_remote_a.read_with(cx_b, |change_set, cx| {
+        let buffer = buffer_remote_a.read(cx);
        assert_eq!(
-            buffer.diff_base().map(|rope| rope.to_string()).as_deref(),
+            change_set.base_text_string(cx).as_deref(),
            Some(diff_base.as_str())
        );
        git::diff::assert_hunks(
-            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
            buffer,
            &diff_base,
            &[(1..2, "", "two\n")],
        );
    });

+    // Update the staged text of the open buffer
    client_a.fs().set_index_for_repo(
        Path::new("/dir/.git"),
        &[(Path::new("a.txt"), new_diff_base.clone())],
@@ -2611,40 +2633,35 @@ async fn test_git_diff_base_change(

    // Wait for buffer_local_a to receive it
    executor.run_until_parked();
-
-    // Smoke test new diffing
-
-    buffer_local_a.read_with(cx_a, |buffer, _| {
+    change_set_local_a.read_with(cx_a, |change_set, cx| {
+        let buffer = buffer_local_a.read(cx);
        assert_eq!(
-            buffer.diff_base().map(|rope| rope.to_string()).as_deref(),
+            change_set.base_text_string(cx).as_deref(),
            Some(new_diff_base.as_str())
        );
-
        git::diff::assert_hunks(
-            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
            buffer,
-            &diff_base,
+            &new_diff_base,
            &[(2..3, "", "three\n")],
        );
    });

-    // Smoke test B
-
-    buffer_remote_a.read_with(cx_b, |buffer, _| {
+    change_set_remote_a.read_with(cx_b, |change_set, cx| {
+        let buffer = buffer_remote_a.read(cx);
        assert_eq!(
-            buffer.diff_base().map(|rope| rope.to_string()).as_deref(),
+            change_set.base_text_string(cx).as_deref(),
            Some(new_diff_base.as_str())
        );
        git::diff::assert_hunks(
-            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
            buffer,
-            &diff_base,
+            &new_diff_base,
            &[(2..3, "", "three\n")],
        );
    });

-    //Nested git dir
-
+    // Nested git dir
    let diff_base = "
        one
        three
@@ -2667,19 +2684,23 @@ async fn test_git_diff_base_change(
        .update(cx_a, |p, cx| p.open_buffer((worktree_id, "sub/b.txt"), cx))
        .await
        .unwrap();
+    let change_set_local_b = project_local
+        .update(cx_a, |p, cx| {
+            p.open_unstaged_changes(buffer_local_b.clone(), cx)
+        })
+        .await
+        .unwrap();

    // Wait for it to catch up to the new diff
    executor.run_until_parked();
-
-    // Smoke test diffing
-
-    buffer_local_b.read_with(cx_a, |buffer, _| {
+    change_set_local_b.read_with(cx_a, |change_set, cx| {
+        let buffer = buffer_local_b.read(cx);
        assert_eq!(
-            buffer.diff_base().map(|rope| rope.to_string()).as_deref(),
+            change_set.base_text_string(cx).as_deref(),
            Some(diff_base.as_str())
        );
        git::diff::assert_hunks(
-            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
            buffer,
            &diff_base,
            &[(1..2, "", "two\n")],
@@ -2691,25 +2712,29 @@ async fn test_git_diff_base_change(
        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "sub/b.txt"), cx))
        .await
        .unwrap();
+    let change_set_remote_b = project_remote
+        .update(cx_b, |p, cx| {
+            p.open_unstaged_changes(buffer_remote_b.clone(), cx)
+        })
+        .await
+        .unwrap();

-    // Wait remote buffer to catch up to the new diff
    executor.run_until_parked();
-
-    // Smoke test diffing
-
-    buffer_remote_b.read_with(cx_b, |buffer, _| {
+    change_set_remote_b.read_with(cx_b, |change_set, cx| {
+        let buffer = buffer_remote_b.read(cx);
        assert_eq!(
-            buffer.diff_base().map(|rope| rope.to_string()).as_deref(),
+            change_set.base_text_string(cx).as_deref(),
            Some(diff_base.as_str())
        );
        git::diff::assert_hunks(
-            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
            buffer,
            &diff_base,
            &[(1..2, "", "two\n")],
        );
    });

+    // Update the staged text
    client_a.fs().set_index_for_repo(
        Path::new("/dir/sub/.git"),
        &[(Path::new("b.txt"), new_diff_base.clone())],
@@ -2717,43 +2742,30 @@ async fn test_git_diff_base_change(

    // Wait for buffer_local_b to receive it
    executor.run_until_parked();
-
-    // Smoke test new diffing
-
-    buffer_local_b.read_with(cx_a, |buffer, _| {
+    change_set_local_b.read_with(cx_a, |change_set, cx| {
+        let buffer = buffer_local_b.read(cx);
        assert_eq!(
-            buffer.diff_base().map(|rope| rope.to_string()).as_deref(),
+            change_set.base_text_string(cx).as_deref(),
            Some(new_diff_base.as_str())
        );
-        println!("{:?}", buffer.as_rope().to_string());
-        println!("{:?}", buffer.diff_base());
-        println!(
-            "{:?}",
-            buffer
-                .snapshot()
-                .git_diff_hunks_in_row_range(0..4)
-                .collect::<Vec<_>>()
-        );
-
        git::diff::assert_hunks(
-            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
            buffer,
-            &diff_base,
+            &new_diff_base,
            &[(2..3, "", "three\n")],
        );
    });

-    // Smoke test B
-
-    buffer_remote_b.read_with(cx_b, |buffer, _| {
+    change_set_remote_b.read_with(cx_b, |change_set, cx| {
+        let buffer = buffer_remote_b.read(cx);
        assert_eq!(
-            buffer.diff_base().map(|rope| rope.to_string()).as_deref(),
+            change_set.base_text_string(cx).as_deref(),
            Some(new_diff_base.as_str())
        );
        git::diff::assert_hunks(
-            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
            buffer,
-            &diff_base,
+            &new_diff_base,
            &[(2..3, "", "three\n")],
        );
    });
@@ -6016,6 +6028,8 @@ async fn test_contact_requests(
    }
 }

+// TODO: Re-enable this test once we can replace our swift Livekit SDK with the rust SDK
+#[cfg(not(target_os = "macos"))]
 #[gpui::test(iterations = 10)]
 async fn test_join_call_after_screen_was_shared(
    executor: BackgroundExecutor,
@@ -6058,13 +6072,13 @@ async fn test_join_call_after_screen_was_shared(
    assert_eq!(call_b.calling_user.github_login, "user_a");

    // User A shares their screen
-    let display = MacOSDisplay::new();
+    let display = gpui::TestScreenCaptureSource::new();
+    cx_a.set_screen_capture_sources(vec![display]);
    active_call_a
        .update(cx_a, |call, cx| {
-            call.room().unwrap().update(cx, |room, cx| {
-                room.set_display_sources(vec![display.clone()]);
-                room.share_screen(cx)
-            })
+            call.room()
+                .unwrap()
+                .update(cx, |room, cx| room.share_screen(cx))
        })
        .await
        .unwrap();
--- a/crates/collab/src/tests/random_project_collaboration_tests.rs
+++ b/crates/collab/src/tests/random_project_collaboration_tests.rs
@@ -1336,10 +1336,24 @@ impl RandomizedTest for ProjectCollaborationTest {
                        (_, None) => panic!("guest's file is None, hosts's isn't"),
                    }

-                    let host_diff_base = host_buffer
-                        .read_with(host_cx, |b, _| b.diff_base().map(ToString::to_string));
-                    let guest_diff_base = guest_buffer
-                        .read_with(client_cx, |b, _| b.diff_base().map(ToString::to_string));
+                    let host_diff_base = host_project.read_with(host_cx, |project, cx| {
+                        project
+                            .buffer_store()
+                            .read(cx)
+                            .get_unstaged_changes(host_buffer.read(cx).remote_id())
+                            .unwrap()
+                            .read(cx)
+                            .base_text_string(cx)
+                    });
+                    let guest_diff_base = guest_project.read_with(client_cx, |project, cx| {
+                        project
+                            .buffer_store()
+                            .read(cx)
+                            .get_unstaged_changes(guest_buffer.read(cx).remote_id())
+                            .unwrap()
+                            .read(cx)
+                            .base_text_string(cx)
+                    });
                    assert_eq!(
                            guest_diff_base, host_diff_base,
                            "guest {} diff base does not match host's for path {path:?} in project {project_id}",
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -45,9 +45,15 @@ use std::{
 };
 use workspace::{Workspace, WorkspaceStore};

+#[cfg(not(target_os = "macos"))]
+use livekit_client::test::TestServer as LivekitTestServer;
+
+#[cfg(target_os = "macos")]
+use livekit_client_macos::TestServer as LivekitTestServer;
+
 pub struct TestServer {
    pub app_state: Arc<AppState>,
-    pub test_live_kit_server: Arc<live_kit_client::TestServer>,
+    pub test_livekit_server: Arc<LivekitTestServer>,
    server: Arc<Server>,
    next_github_user_id: i32,
    connection_killers: Arc<Mutex<HashMap<PeerId, Arc<AtomicBool>>>>,
@@ -79,7 +85,7 @@ pub struct ContactsSummary {

 impl TestServer {
    pub async fn start(deterministic: BackgroundExecutor) -> Self {
-        static NEXT_LIVE_KIT_SERVER_ID: AtomicUsize = AtomicUsize::new(0);
+        static NEXT_LIVEKIT_SERVER_ID: AtomicUsize = AtomicUsize::new(0);

        let use_postgres = env::var("USE_POSTGRES").ok();
        let use_postgres = use_postgres.as_deref();
@@ -88,16 +94,16 @@ impl TestServer {
        } else {
            TestDb::sqlite(deterministic.clone())
        };
-        let live_kit_server_id = NEXT_LIVE_KIT_SERVER_ID.fetch_add(1, SeqCst);
-        let live_kit_server = live_kit_client::TestServer::create(
-            format!("http://livekit.{}.test", live_kit_server_id),
-            format!("devkey-{}", live_kit_server_id),
-            format!("secret-{}", live_kit_server_id),
+        let livekit_server_id = NEXT_LIVEKIT_SERVER_ID.fetch_add(1, SeqCst);
+        let livekit_server = LivekitTestServer::create(
+            format!("http://livekit.{}.test", livekit_server_id),
+            format!("devkey-{}", livekit_server_id),
+            format!("secret-{}", livekit_server_id),
            deterministic.clone(),
        )
        .unwrap();
        let executor = Executor::Deterministic(deterministic.clone());
-        let app_state = Self::build_app_state(&test_db, &live_kit_server, executor.clone()).await;
+        let app_state = Self::build_app_state(&test_db, &livekit_server, executor.clone()).await;
        let epoch = app_state
            .db
            .create_server(&app_state.config.zed_environment)
@@ -114,7 +120,7 @@ impl TestServer {
            forbid_connections: Default::default(),
            next_github_user_id: 0,
            _test_db: test_db,
-            test_live_kit_server: live_kit_server,
+            test_livekit_server: livekit_server,
        }
    }

@@ -500,13 +506,13 @@ impl TestServer {

    pub async fn build_app_state(
        test_db: &TestDb,
-        live_kit_test_server: &live_kit_client::TestServer,
+        livekit_test_server: &LivekitTestServer,
        executor: Executor,
    ) -> 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())),
+            livekit_client: Some(Arc::new(livekit_test_server.create_api_client())),
            blob_store_client: None,
            stripe_client: None,
            stripe_billing: None,
@@ -520,9 +526,9 @@ impl TestServer {
                database_max_connections: 0,
                api_token: "".into(),
                invite_link_prefix: "".into(),
-                live_kit_server: None,
-                live_kit_key: None,
-                live_kit_secret: None,
+                livekit_server: None,
+                livekit_key: None,
+                livekit_secret: None,
                llm_database_url: None,
                llm_database_max_connections: None,
                llm_database_migrations_path: None,
@@ -572,7 +578,7 @@ impl Deref for TestServer {
 impl Drop for TestServer {
    fn drop(&mut self) {
        self.server.teardown();
-        self.test_live_kit_server.teardown().unwrap();
+        self.test_livekit_server.teardown().unwrap();
    }
 }

@@ -585,7 +591,7 @@ impl Deref for TestClient {
 }

 impl TestClient {
-    pub fn fs(&self) -> &FakeFs {
+    pub fn fs(&self) -> Arc<FakeFs> {
        self.app_state.fs.as_fake()
    }

--- a/crates/collab_ui/src/collab_panel.rs
+++ b/crates/collab_ui/src/collab_panel.rs
@@ -474,11 +474,10 @@ impl CollabPanel {
                            project_id: project.id,
                            worktree_root_names: project.worktree_root_names.clone(),
                            host_user_id: participant.user.id,
-                            is_last: projects.peek().is_none()
-                                && participant.video_tracks.is_empty(),
+                            is_last: projects.peek().is_none() && !participant.has_video_tracks(),
                        });
                    }
-                    if !participant.video_tracks.is_empty() {
+                    if participant.has_video_tracks() {
                        self.entries.push(ListEntry::ParticipantScreen {
                            peer_id: Some(participant.peer_id),
                            is_last: true,
--- a/crates/component_preview/Cargo.toml
+++ b/crates/component_preview/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "component_preview"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/component_preview.rs"
+
+[dependencies]
+gpui.workspace = true
+ui.workspace = true
+component_system.workspace = true
+strum.workspace = true
+workspace.workspace = true
+
+[features]
+default = []
--- a/crates/component_preview/src/component_preview.rs
+++ b/crates/component_preview/src/component_preview.rs
@@ -0,0 +1,110 @@
+//! # Component Preview
+//!
+//! A view for exploring Zed components.
+
+use component_system::components;
+use gpui::{prelude::*, AppContext, EventEmitter, FocusHandle, FocusableView};
+use strum::{EnumIter, IntoEnumIterator};
+use ui::{prelude::*, TintColor};
+
+use workspace::{item::ItemEvent, Item, Workspace, WorkspaceId};
+
+pub fn init(cx: &mut AppContext) {
+    cx.observe_new_views(|workspace: &mut Workspace, _cx| {
+        workspace.register_action(|workspace, _: &workspace::ComponentPreview, cx| {
+            let component_preview = cx.new_view(ComponentPreview::new);
+            workspace.add_item_to_active_pane(Box::new(component_preview), None, true, cx)
+        });
+    })
+    .detach();
+}
+
+struct ComponentPreview {
+    focus_handle: FocusHandle,
+}
+
+impl ComponentPreview {
+    pub fn new(cx: &mut ViewContext<Self>) -> Self {
+        Self {
+            focus_handle: cx.focus_handle(),
+        }
+    }
+
+    fn render_sidebar(&self, cx: &ViewContext<Self>) -> impl IntoElement {
+        h_flex().children(components().all().iter().map(|component| {
+            Button::new(component.name().clone(), component.name()).on_click(cx.listener(
+                move |_this, _, _cx| {
+                    // Handle button click
+                },
+            ))
+        }))
+    }
+
+    fn render_preview(&self, cx: &ViewContext<Self>) -> impl IntoElement {
+        v_flex()
+            .size_full()
+            .children(components().all_previews().iter().map(|component| {
+                if let Some(preview) = component.preview() {
+                    preview(cx)
+                } else {
+                    div().into_any_element()
+                }
+            }))
+    }
+}
+
+impl Render for ComponentPreview {
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        h_flex()
+            .id("component-preview")
+            .key_context("ComponentPreview")
+            .items_start()
+            .overflow_hidden()
+            .size_full()
+            .max_h_full()
+            .track_focus(&self.focus_handle)
+            .px_2()
+            .bg(cx.theme().colors().editor_background)
+            .child(self.render_sidebar(cx))
+            .child(self.render_preview(cx))
+    }
+}
+
+impl EventEmitter<ItemEvent> for ComponentPreview {}
+
+impl FocusableView for ComponentPreview {
+    fn focus_handle(&self, _: &AppContext) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Item for ComponentPreview {
+    type Event = ItemEvent;
+
+    fn tab_content_text(&self, _cx: &WindowContext) -> Option<SharedString> {
+        Some("Component Preview".into())
+    }
+
+    fn telemetry_event_text(&self) -> Option<&'static str> {
+        None
+    }
+
+    fn show_toolbar(&self) -> bool {
+        false
+    }
+
+    fn clone_on_split(
+        &self,
+        _workspace_id: Option<WorkspaceId>,
+        cx: &mut ViewContext<Self>,
+    ) -> Option<gpui::View<Self>>
+    where
+        Self: Sized,
+    {
+        Some(cx.new_view(Self::new))
+    }
+
+    fn to_item_events(event: &Self::Event, mut f: impl FnMut(workspace::item::ItemEvent)) {
+        f(*event)
+    }
+}
--- a/crates/component_system/Cargo.toml
+++ b/crates/component_system/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "component_system"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/component_system.rs"
+
+[dependencies]
+gpui.workspace = true
+lazy_static.workspace = true
+linkme.workspace = true
+once_cell.workspace = true
+collections.workspace = true
+parking_lot.workspace = true
+
+[features]
+default = []
--- a/crates/component_system/src/component_system.rs
+++ b/crates/component_system/src/component_system.rs
@@ -0,0 +1,142 @@
+use collections::HashMap;
+use gpui::{AnyElement, SharedString, WindowContext};
+use linkme::distributed_slice;
+use once_cell::sync::Lazy;
+use parking_lot::RwLock;
+
+pub trait Component {
+    fn scope() -> Option<&'static str>;
+    fn name() -> &'static str {
+        std::any::type_name::<Self>()
+    }
+    fn description() -> Option<&'static str> {
+        None
+    }
+}
+
+pub trait ComponentPreview: Component {
+    fn preview(_cx: &WindowContext) -> AnyElement;
+}
+
+#[distributed_slice]
+pub static __ALL_COMPONENTS: [fn()] = [..];
+
+#[distributed_slice]
+pub static __ALL_PREVIEWS: [fn()] = [..];
+
+pub static COMPONENT_DATA: Lazy<RwLock<ComponentData>> =
+    Lazy::new(|| RwLock::new(ComponentData::new()));
+
+pub struct ComponentData {
+    components: Vec<(Option<&'static str>, &'static str, Option<&'static str>)>,
+    previews: HashMap<&'static str, fn(&WindowContext) -> AnyElement>,
+}
+
+impl ComponentData {
+    fn new() -> Self {
+        ComponentData {
+            components: Vec::new(),
+            previews: HashMap::default(),
+        }
+    }
+}
+
+pub fn init() {
+    let component_fns: Vec<_> = __ALL_COMPONENTS.iter().cloned().collect();
+    let preview_fns: Vec<_> = __ALL_PREVIEWS.iter().cloned().collect();
+
+    for f in component_fns {
+        f();
+    }
+    for f in preview_fns {
+        f();
+    }
+}
+
+pub fn register_component<T: Component>() {
+    let component_data = (T::scope(), T::name(), T::description());
+    COMPONENT_DATA.write().components.push(component_data);
+}
+
+pub fn register_preview<T: ComponentPreview>() {
+    let preview_data = (T::name(), T::preview as fn(&WindowContext) -> AnyElement);
+    COMPONENT_DATA
+        .write()
+        .previews
+        .insert(preview_data.0, preview_data.1);
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ComponentId(pub &'static str);
+
+pub struct ComponentMetadata {
+    name: SharedString,
+    scope: Option<SharedString>,
+    description: Option<SharedString>,
+    preview: Option<fn(&WindowContext) -> AnyElement>,
+}
+
+impl ComponentMetadata {
+    pub fn name(&self) -> SharedString {
+        self.name.clone()
+    }
+
+    pub fn scope(&self) -> Option<SharedString> {
+        self.scope.clone()
+    }
+
+    pub fn description(&self) -> Option<SharedString> {
+        self.description.clone()
+    }
+
+    pub fn preview(&self) -> Option<fn(&WindowContext) -> AnyElement> {
+        self.preview
+    }
+}
+
+pub struct AllComponents(pub HashMap<ComponentId, ComponentMetadata>);
+
+impl AllComponents {
+    pub fn new() -> Self {
+        AllComponents(HashMap::default())
+    }
+
+    pub fn add(&mut self, id: ComponentId, metadata: ComponentMetadata) {
+        self.0.insert(id, metadata);
+    }
+
+    pub fn get(&self, id: &ComponentId) -> Option<&ComponentMetadata> {
+        self.0.get(id)
+    }
+
+    /// Returns all components with previews
+    pub fn all_previews(&self) -> Vec<&ComponentMetadata> {
+        self.0.values().filter(|c| c.preview.is_some()).collect()
+    }
+
+    /// Returns all components
+    pub fn all(&self) -> Vec<&ComponentMetadata> {
+        self.0.values().collect()
+    }
+}
+
+pub fn components() -> AllComponents {
+    let data = COMPONENT_DATA.read();
+    let mut all_components = AllComponents::new();
+
+    for &(scope, name, description) in &data.components {
+        let scope = scope.map(Into::into);
+        let preview = data.previews.get(name).cloned();
+        all_components.add(
+            ComponentId(name),
+            ComponentMetadata {
+                name: name.into(),
+                scope,
+                description: description.map(Into::into),
+                preview,
+            },
+        );
+    }
+
+    all_components
+}
--- a/crates/context_server/src/types.rs
+++ b/crates/context_server/src/types.rs
@@ -167,11 +167,18 @@ pub struct InitializeResponse {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesReadResponse {
-    pub contents: Vec<ResourceContents>,
+    pub contents: Vec<ResourceContentsType>,
    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

+#[derive(Debug, Deserialize)]
+#[serde(untagged)]
+pub enum ResourceContentsType {
+    Text(TextResourceContents),
+    Blob(BlobResourceContents),
+}
+
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesListResponse {
@@ -181,6 +188,7 @@ pub struct ResourcesListResponse {
    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SamplingMessage {
@@ -188,6 +196,35 @@ pub struct SamplingMessage {
    pub content: MessageContent,
 }

+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateMessageRequest {
+    pub messages: Vec<SamplingMessage>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub model_preferences: Option<ModelPreferences>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub system_prompt: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub include_context: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub temperature: Option<f64>,
+    pub max_tokens: u32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stop_sequences: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<serde_json::Value>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateMessageResult {
+    pub role: Role,
+    pub content: MessageContent,
+    pub model: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stop_reason: Option<String>,
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PromptMessage {
@@ -206,11 +243,33 @@ pub enum Role {
 #[serde(tag = "type")]
 pub enum MessageContent {
    #[serde(rename = "text")]
-    Text { text: String },
+    Text {
+        text: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        annotations: Option<MessageAnnotations>,
+    },
    #[serde(rename = "image")]
-    Image { data: String, mime_type: String },
+    Image {
+        data: String,
+        mime_type: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        annotations: Option<MessageAnnotations>,
+    },
    #[serde(rename = "resource")]
-    Resource { resource: ResourceContents },
+    Resource {
+        resource: ResourceContents,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        annotations: Option<MessageAnnotations>,
+    },
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MessageAnnotations {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub audience: Option<Vec<Role>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub priority: Option<f64>,
 }

 #[derive(Debug, Deserialize)]
@@ -460,6 +519,11 @@ pub enum ClientNotification {
    Initialized,
    Progress(ProgressParams),
    RootsListChanged,
+    Cancelled {
+        request_id: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        reason: Option<String>,
+    },
 }

 #[derive(Debug, Serialize, Deserialize)]
@@ -532,6 +596,16 @@ pub struct ListToolsResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ListResourceTemplatesResponse {
+    pub resource_templates: Vec<ResourceTemplate>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub next_cursor: Option<String>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
+}
+
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ListRootsResponse {
--- a/crates/copilot/src/copilot_chat.rs
+++ b/crates/copilot/src/copilot_chat.rs
@@ -197,7 +197,7 @@ pub fn init(fs: Arc<dyn Fs>, client: Arc<dyn HttpClient>, cx: &mut AppContext) {
    cx.set_global(GlobalCopilotChat(copilot_chat));
 }

-fn copilot_chat_config_path() -> &'static PathBuf {
+fn copilot_chat_config_dir() -> &'static PathBuf {
    static COPILOT_CHAT_CONFIG_DIR: OnceLock<PathBuf> = OnceLock::new();

    COPILOT_CHAT_CONFIG_DIR.get_or_init(|| {
@@ -207,10 +207,14 @@ fn copilot_chat_config_path() -> &'static PathBuf {
            home_dir().join(".config")
        }
        .join("github-copilot")
-        .join("hosts.json")
    })
 }

+fn copilot_chat_config_paths() -> [PathBuf; 2] {
+    let base_dir = copilot_chat_config_dir();
+    [base_dir.join("hosts.json"), base_dir.join("apps.json")]
+}
+
 impl CopilotChat {
    pub fn global(cx: &AppContext) -> Option<gpui::Model<Self>> {
        cx.try_global::<GlobalCopilotChat>()
@@ -218,13 +222,24 @@ impl CopilotChat {
    }

    pub fn new(fs: Arc<dyn Fs>, client: Arc<dyn HttpClient>, cx: &AppContext) -> Self {
-        let mut config_file_rx = watch_config_file(
-            cx.background_executor(),
-            fs,
-            copilot_chat_config_path().clone(),
-        );
+        let config_paths = copilot_chat_config_paths();
+
+        let resolve_config_path = {
+            let fs = fs.clone();
+            async move {
+                for config_path in config_paths.iter() {
+                    if fs.metadata(config_path).await.is_ok_and(|v| v.is_some()) {
+                        return config_path.clone();
+                    }
+                }
+                config_paths[0].clone()
+            }
+        };

        cx.spawn(|cx| async move {
+            let config_file = resolve_config_path.await;
+            let mut config_file_rx = watch_config_file(cx.background_executor(), fs, config_file);
+
            while let Some(contents) = config_file_rx.next().await {
                let oauth_token = extract_oauth_token(contents);

@@ -318,9 +333,15 @@ async fn request_api_token(oauth_token: &str, client: Arc<dyn HttpClient>) -> Re
 fn extract_oauth_token(contents: String) -> Option<String> {
    serde_json::from_str::<serde_json::Value>(&contents)
        .map(|v| {
-            v["github.com"]["oauth_token"]
-                .as_str()
-                .map(|v| v.to_string())
+            v.as_object().and_then(|obj| {
+                obj.iter().find_map(|(key, value)| {
+                    if key.starts_with("github.com") {
+                        value["oauth_token"].as_str().map(|v| v.to_string())
+                    } else {
+                        None
+                    }
+                })
+            })
        })
        .ok()
        .flatten()
--- a/crates/copilot/src/copilot_completion_provider.rs
+++ b/crates/copilot/src/copilot_completion_provider.rs
@@ -2,7 +2,7 @@ use crate::{Completion, Copilot};
 use anyhow::Result;
 use client::telemetry::Telemetry;
 use gpui::{AppContext, EntityId, Model, ModelContext, Task};
-use inline_completion::{CompletionEdit, CompletionProposal, Direction, InlineCompletionProvider};
+use inline_completion::{CompletionProposal, Direction, InlayProposal, InlineCompletionProvider};
 use language::{
    language_settings::{all_language_settings, AllLanguageSettings},
    Buffer, OffsetRangeExt, ToOffset,
@@ -267,12 +267,13 @@ impl InlineCompletionProvider for CopilotCompletionProvider {
            if completion_text.trim().is_empty() {
                None
            } else {
-                let position = cursor_position.bias_right(buffer);
                Some(CompletionProposal {
-                    edits: vec![CompletionEdit {
-                        text: completion_text.into(),
-                        range: position..position,
-                    }],
+                    inlays: vec![InlayProposal::Suggestion(
+                        cursor_position.bias_right(buffer),
+                        completion_text.into(),
+                    )],
+                    text: completion_text.into(),
+                    delete_range: None,
                })
            }
        } else {
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -16,8 +16,8 @@ use editor::{
 };
 use gpui::{
    actions, div, svg, AnyElement, AnyView, AppContext, Context, EventEmitter, FocusHandle,
-    FocusableView, HighlightStyle, InteractiveElement, IntoElement, Model, ParentElement, Render,
-    SharedString, Styled, StyledText, Subscription, Task, View, ViewContext, VisualContext,
+    FocusableView, Global, HighlightStyle, InteractiveElement, IntoElement, Model, ParentElement,
+    Render, SharedString, Styled, StyledText, Subscription, Task, View, ViewContext, VisualContext,
    WeakView, WindowContext,
 };
 use language::{
@@ -46,6 +46,9 @@ use workspace::{

 actions!(diagnostics, [Deploy, ToggleWarnings]);

+struct IncludeWarnings(bool);
+impl Global for IncludeWarnings {}
+
 pub fn init(cx: &mut AppContext) {
    ProjectDiagnosticsSettings::register(cx);
    cx.observe_new_views(ProjectDiagnosticsEditor::register)
@@ -117,6 +120,7 @@ impl ProjectDiagnosticsEditor {

    fn new_with_context(
        context: u32,
+        include_warnings: bool,
        project_handle: Model<Project>,
        workspace: WeakView<Workspace>,
        cx: &mut ViewContext<Self>,
@@ -186,19 +190,24 @@ impl ProjectDiagnosticsEditor {
            }
        })
        .detach();
+        cx.observe_global::<IncludeWarnings>(|this, cx| {
+            this.include_warnings = cx.global::<IncludeWarnings>().0;
+            this.update_all_excerpts(cx);
+        })
+        .detach();

        let project = project_handle.read(cx);
        let mut this = Self {
            project: project_handle.clone(),
            context,
            summary: project.diagnostic_summary(false, cx),
+            include_warnings,
            workspace,
            excerpts,
            focus_handle,
            editor,
            path_states: Default::default(),
            paths_to_update: Default::default(),
-            include_warnings: ProjectDiagnosticsSettings::get_global(cx).include_warnings,
            update_excerpts_task: None,
            _subscription: project_event_subscription,
        };
@@ -243,11 +252,13 @@ impl ProjectDiagnosticsEditor {

    fn new(
        project_handle: Model<Project>,
+        include_warnings: bool,
        workspace: WeakView<Workspace>,
        cx: &mut ViewContext<Self>,
    ) -> Self {
        Self::new_with_context(
            editor::DEFAULT_MULTIBUFFER_CONTEXT,
+            include_warnings,
            project_handle,
            workspace,
            cx,
@@ -259,8 +270,19 @@ impl ProjectDiagnosticsEditor {
            workspace.activate_item(&existing, true, true, cx);
        } else {
            let workspace_handle = cx.view().downgrade();
+
+            let include_warnings = match cx.try_global::<IncludeWarnings>() {
+                Some(include_warnings) => include_warnings.0,
+                None => ProjectDiagnosticsSettings::get_global(cx).include_warnings,
+            };
+
            let diagnostics = cx.new_view(|cx| {
-                ProjectDiagnosticsEditor::new(workspace.project().clone(), workspace_handle, cx)
+                ProjectDiagnosticsEditor::new(
+                    workspace.project().clone(),
+                    include_warnings,
+                    workspace_handle,
+                    cx,
+                )
            });
            workspace.add_item_to_active_pane(Box::new(diagnostics), None, true, cx);
        }
@@ -268,6 +290,7 @@ impl ProjectDiagnosticsEditor {

    fn toggle_warnings(&mut self, _: &ToggleWarnings, cx: &mut ViewContext<Self>) {
        self.include_warnings = !self.include_warnings;
+        cx.set_global(IncludeWarnings(self.include_warnings));
        self.update_all_excerpts(cx);
        cx.notify();
    }
@@ -740,7 +763,12 @@ impl Item for ProjectDiagnosticsEditor {
        Self: Sized,
    {
        Some(cx.new_view(|cx| {
-            ProjectDiagnosticsEditor::new(self.project.clone(), self.workspace.clone(), cx)
+            ProjectDiagnosticsEditor::new(
+                self.project.clone(),
+                self.include_warnings,
+                self.workspace.clone(),
+                cx,
+            )
        }))
    }

--- a/crates/diagnostics/src/diagnostics_tests.rs
+++ b/crates/diagnostics/src/diagnostics_tests.rs
@@ -151,7 +151,13 @@ async fn test_diagnostics(cx: &mut TestAppContext) {

    // Open the project diagnostics view while there are already diagnostics.
    let view = window.build_view(cx, |cx| {
-        ProjectDiagnosticsEditor::new_with_context(1, project.clone(), workspace.downgrade(), cx)
+        ProjectDiagnosticsEditor::new_with_context(
+            1,
+            true,
+            project.clone(),
+            workspace.downgrade(),
+            cx,
+        )
    });
    let editor = view.update(cx, |view, _| view.editor.clone());

@@ -459,7 +465,13 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
    let workspace = window.root(cx).unwrap();

    let view = window.build_view(cx, |cx| {
-        ProjectDiagnosticsEditor::new_with_context(1, project.clone(), workspace.downgrade(), cx)
+        ProjectDiagnosticsEditor::new_with_context(
+            1,
+            true,
+            project.clone(),
+            workspace.downgrade(),
+            cx,
+        )
    });
    let editor = view.update(cx, |view, _| view.editor.clone());

@@ -720,7 +732,13 @@ async fn test_random_diagnostics(cx: &mut TestAppContext, mut rng: StdRng) {
    let workspace = window.root(cx).unwrap();

    let mutated_view = window.build_view(cx, |cx| {
-        ProjectDiagnosticsEditor::new_with_context(1, project.clone(), workspace.downgrade(), cx)
+        ProjectDiagnosticsEditor::new_with_context(
+            1,
+            true,
+            project.clone(),
+            workspace.downgrade(),
+            cx,
+        )
    });

    workspace.update(cx, |workspace, cx| {
@@ -816,7 +834,13 @@ async fn test_random_diagnostics(cx: &mut TestAppContext, mut rng: StdRng) {

    log::info!("constructing reference diagnostics view");
    let reference_view = window.build_view(cx, |cx| {
-        ProjectDiagnosticsEditor::new_with_context(1, project.clone(), workspace.downgrade(), cx)
+        ProjectDiagnosticsEditor::new_with_context(
+            1,
+            true,
+            project.clone(),
+            workspace.downgrade(),
+            cx,
+        )
    });
    cx.run_until_parked();

--- a/crates/diagnostics/src/items.rs
+++ b/crates/diagnostics/src/items.rs
@@ -1,7 +1,9 @@
+use std::time::Duration;
+
 use editor::Editor;
 use gpui::{
-    EventEmitter, IntoElement, ParentElement, Render, Styled, Subscription, View, ViewContext,
-    WeakView,
+    EventEmitter, IntoElement, ParentElement, Render, Styled, Subscription, Task, View,
+    ViewContext, WeakView,
 };
 use language::Diagnostic;
 use ui::{h_flex, prelude::*, Button, ButtonLike, Color, Icon, IconName, Label, Tooltip};
@@ -15,6 +17,7 @@ pub struct DiagnosticIndicator {
    workspace: WeakView<Workspace>,
    current_diagnostic: Option<Diagnostic>,
    _observe_active_editor: Option<Subscription>,
+    diagnostics_update: Task<()>,
 }

 impl Render for DiagnosticIndicator {
@@ -126,6 +129,7 @@ impl DiagnosticIndicator {
            workspace: workspace.weak_handle(),
            current_diagnostic: None,
            _observe_active_editor: None,
+            diagnostics_update: Task::ready(()),
        }
    }

@@ -149,8 +153,17 @@ impl DiagnosticIndicator {
            .min_by_key(|entry| (entry.diagnostic.severity, entry.range.len()))
            .map(|entry| entry.diagnostic);
        if new_diagnostic != self.current_diagnostic {
-            self.current_diagnostic = new_diagnostic;
-            cx.notify();
+            self.diagnostics_update = cx.spawn(|diagnostics_indicator, mut cx| async move {
+                cx.background_executor()
+                    .timer(Duration::from_millis(50))
+                    .await;
+                diagnostics_indicator
+                    .update(&mut cx, |diagnostics_indicator, cx| {
+                        diagnostics_indicator.current_diagnostic = new_diagnostic;
+                        cx.notify();
+                    })
+                    .ok();
+            });
        }
    }
 }
--- a/crates/editor/Cargo.toml
+++ b/crates/editor/Cargo.toml
@@ -39,6 +39,7 @@ collections.workspace = true
 convert_case.workspace = true
 db.workspace = true
 emojis.workspace = true
+feature_flags.workspace = true
 file_icons.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
@@ -97,6 +98,7 @@ project = { workspace = true, features = ["test-support"] }
 release_channel.workspace = true
 rand.workspace = true
 settings = { workspace = true, features = ["test-support"] }
+tempfile.workspace = true
 text = { workspace = true, features = ["test-support"] }
 theme = { workspace = true, features = ["test-support"] }
 tree-sitter-html.workspace = true
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -248,6 +248,7 @@ gpui::actions!(
        FindAllReferences,
        Fold,
        FoldAll,
+        FoldFunctionBodies,
        FoldRecursive,
        FoldSelectedRanges,
        ToggleFold,
@@ -295,6 +296,7 @@ gpui::actions!(
        NewlineBelow,
        NextInlineCompletion,
        NextScreen,
+        OpenContextMenu,
        OpenExcerpts,
        OpenExcerptsSplit,
        OpenProposedChangesEditor,
@@ -303,6 +305,7 @@ gpui::actions!(
        OpenPermalinkToLine,
        OpenUrl,
        Outdent,
+        AutoIndent,
        PageDown,
        PageUp,
        Paste,
--- a/crates/editor/src/display_map.rs
+++ b/crates/editor/src/display_map.rs
@@ -684,8 +684,8 @@ impl DisplaySnapshot {
            .map(|row| row.map(MultiBufferRow))
    }

-    pub fn max_buffer_row(&self) -> MultiBufferRow {
-        self.buffer_snapshot.max_buffer_row()
+    pub fn widest_line_number(&self) -> u32 {
+        self.buffer_snapshot.widest_line_number()
    }

    pub fn prev_line_boundary(&self, mut point: MultiBufferPoint) -> (Point, DisplayPoint) {
@@ -726,11 +726,10 @@ impl DisplaySnapshot {

    // used by line_mode selections and tries to match vim behavior
    pub fn expand_to_line(&self, range: Range<Point>) -> Range<Point> {
+        let max_row = self.buffer_snapshot.max_row().0;
        let new_start = if range.start.row == 0 {
            MultiBufferPoint::new(0, 0)
-        } else if range.start.row == self.max_buffer_row().0
-            || (range.end.column > 0 && range.end.row == self.max_buffer_row().0)
-        {
+        } else if range.start.row == max_row || (range.end.column > 0 && range.end.row == max_row) {
            MultiBufferPoint::new(
                range.start.row - 1,
                self.buffer_snapshot
@@ -742,7 +741,7 @@ impl DisplaySnapshot {

        let new_end = if range.end.column == 0 {
            range.end
-        } else if range.end.row < self.max_buffer_row().0 {
+        } else if range.end.row < max_row {
            self.buffer_snapshot
                .clip_point(MultiBufferPoint::new(range.end.row + 1, 0), Bias::Left)
        } else {
@@ -1127,7 +1126,7 @@ impl DisplaySnapshot {
    }

    pub fn starts_indent(&self, buffer_row: MultiBufferRow) -> bool {
-        let max_row = self.buffer_snapshot.max_buffer_row();
+        let max_row = self.buffer_snapshot.max_row();
        if buffer_row >= max_row {
            return false;
        }
--- a/crates/editor/src/display_map/inlay_map.rs
+++ b/crates/editor/src/display_map/inlay_map.rs
@@ -1019,7 +1019,7 @@ impl InlaySnapshot {
        let inlay_point = InlayPoint::new(row, 0);
        cursor.seek(&inlay_point, Bias::Left, &());

-        let max_buffer_row = MultiBufferRow(self.buffer.max_point().row);
+        let max_buffer_row = self.buffer.max_row();
        let mut buffer_point = cursor.start().1;
        let buffer_row = if row == 0 {
            MultiBufferRow(0)
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -16,13 +16,13 @@ use crate::{
    items::BufferSearchHighlights,
    mouse_context_menu::{self, MenuPosition, MouseContextMenu},
    scroll::scroll_amount::ScrollAmount,
-    BlockId, ChunkReplacement, CodeActionsMenu, ComputedCompletionEdit, CursorShape, CustomBlockId,
-    DisplayPoint, DisplayRow, DocumentHighlightRead, DocumentHighlightWrite, Editor, EditorMode,
-    EditorSettings, EditorSnapshot, EditorStyle, ExpandExcerpts, FocusedBlock, GutterDimensions,
-    HalfPageDown, HalfPageUp, HandleInput, HoveredCursor, HoveredHunk, JumpData, LineDown, LineUp,
-    OpenExcerpts, PageDown, PageUp, Point, RowExt, RowRangeExt, SelectPhase, Selection, SoftWrap,
-    ToPoint, CURSORS_VISIBLE_FOR, FILE_HEADER_HEIGHT, GIT_BLAME_MAX_AUTHOR_CHARS_DISPLAYED,
-    MAX_LINE_LEN, MULTI_BUFFER_EXCERPT_HEADER_HEIGHT,
+    BlockId, ChunkReplacement, CodeActionsMenu, CursorShape, CustomBlockId, DisplayPoint,
+    DisplayRow, DocumentHighlightRead, DocumentHighlightWrite, Editor, EditorMode, EditorSettings,
+    EditorSnapshot, EditorStyle, ExpandExcerpts, FocusedBlock, GutterDimensions, HalfPageDown,
+    HalfPageUp, HandleInput, HoveredCursor, HoveredHunk, JumpData, LineDown, LineUp, OpenExcerpts,
+    PageDown, PageUp, Point, RowExt, RowRangeExt, SelectPhase, Selection, SoftWrap, ToPoint,
+    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, HashSet};
@@ -31,7 +31,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,
-    FontId, GlobalElementId, HighlightStyle, 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, TextStyleRefinement, View, ViewContext,
@@ -169,6 +169,7 @@ impl EditorElement {

        crate::rust_analyzer_ext::apply_related_actions(view, cx);
        crate::clangd_ext::apply_related_actions(view, cx);
+        register_action(view, cx, Editor::open_context_menu);
        register_action(view, cx, Editor::move_left);
        register_action(view, cx, Editor::move_right);
        register_action(view, cx, Editor::move_down);
@@ -189,6 +190,7 @@ impl EditorElement {
        register_action(view, cx, Editor::tab_prev);
        register_action(view, cx, Editor::indent);
        register_action(view, cx, Editor::outdent);
+        register_action(view, cx, Editor::autoindent);
        register_action(view, cx, Editor::delete_line);
        register_action(view, cx, Editor::join_lines);
        register_action(view, cx, Editor::sort_lines_case_sensitive);
@@ -341,6 +343,7 @@ impl EditorElement {
        register_action(view, cx, Editor::fold);
        register_action(view, cx, Editor::fold_at_level);
        register_action(view, cx, Editor::fold_all);
+        register_action(view, cx, Editor::fold_function_bodies);
        register_action(view, cx, Editor::fold_at);
        register_action(view, cx, Editor::fold_recursive);
        register_action(view, cx, Editor::toggle_fold);
@@ -593,7 +596,7 @@ impl EditorElement {
            position_map.point_for_position(text_hitbox.bounds, event.position);
        mouse_context_menu::deploy_context_menu(
            editor,
-            event.position,
+            Some(event.position),
            point_for_position.previous_valid,
            cx,
        );
@@ -1166,7 +1169,7 @@ impl EditorElement {
                let editor = self.editor.read(cx);
                let is_singleton = editor.is_singleton(cx);
                // Git
-                (is_singleton && scrollbar_settings.git_diff && snapshot.buffer_snapshot.has_git_diffs())
+                (is_singleton && scrollbar_settings.git_diff && !snapshot.diff_map.is_empty())
                    ||
                    // Buffer Search Results
                    (is_singleton && scrollbar_settings.search_results && editor.has_background_highlights::<BufferSearchHighlights>())
@@ -1317,17 +1320,8 @@ impl EditorElement {
        cx: &mut WindowContext,
    ) -> Vec<(DisplayDiffHunk, Option<Hitbox>)> {
        let buffer_snapshot = &snapshot.buffer_snapshot;
-
-        let buffer_start_row = MultiBufferRow(
-            DisplayPoint::new(display_rows.start, 0)
-                .to_point(snapshot)
-                .row,
-        );
-        let buffer_end_row = MultiBufferRow(
-            DisplayPoint::new(display_rows.end, 0)
-                .to_point(snapshot)
-                .row,
-        );
+        let buffer_start = DisplayPoint::new(display_rows.start, 0).to_point(snapshot);
+        let buffer_end = DisplayPoint::new(display_rows.end, 0).to_point(snapshot);

        let git_gutter_setting = ProjectSettings::get_global(cx)
            .git
@@ -1335,7 +1329,7 @@ impl EditorElement {
            .unwrap_or_default();

        self.editor.update(cx, |editor, cx| {
-            let expanded_hunks = &editor.expanded_hunks.hunks;
+            let expanded_hunks = &editor.diff_map.hunks;
            let expanded_hunks_start_ix = expanded_hunks
                .binary_search_by(|hunk| {
                    hunk.hunk_range
@@ -1346,8 +1340,10 @@ impl EditorElement {
                .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)
+            let mut display_hunks: Vec<(DisplayDiffHunk, Option<Hitbox>)> = editor
+                .diff_map
+                .snapshot
+                .diff_hunks_in_range(buffer_start..buffer_end, &buffer_snapshot)
                .filter_map(|hunk| {
                    let display_hunk = diff_hunk_to_display(&hunk, snapshot);

@@ -1390,25 +1386,23 @@ impl EditorElement {
                    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),
-                })
+                .map(|hunk| (hunk, None))
                .collect();
+
+            if let GitGutterSetting::TrackedFiles = git_gutter_setting {
+                for (hunk, hitbox) in &mut display_hunks {
+                    if let DisplayDiffHunk::Unfolded { .. } = hunk {
+                        let hunk_bounds = Self::diff_hunk_bounds(
+                            snapshot,
+                            line_height,
+                            gutter_hitbox.bounds,
+                            &hunk,
+                        );
+                        *hitbox = Some(cx.insert_hitbox(hunk_bounds, true));
+                    };
+                }
+            }
+
            display_hunks
        })
    }
@@ -2724,136 +2718,11 @@ impl EditorElement {
        true
    }

-    #[allow(clippy::too_many_arguments)]
-    fn layout_inline_completion_popover(
-        &self,
-        text_bounds: &Bounds<Pixels>,
-        editor_snapshot: &EditorSnapshot,
-        visible_row_range: Range<DisplayRow>,
-        line_layouts: &[LineWithInvisibles],
-        line_height: Pixels,
-        scroll_pixel_position: gpui::Point<Pixels>,
-        text_style: &gpui::TextStyle,
-        cx: &mut WindowContext,
-    ) -> Option<AnyElement> {
-        const X_OFFSET: f32 = 25.;
-        const PADDING_Y: f32 = 2.;
-
-        let accept_completion_keystroke = cx.keystroke_text_for_action_in(
-            &crate::AcceptInlineCompletion,
-            &self.editor.read(cx).focus_handle,
-        );
-
-        let edit = self
-            .editor
-            .read(cx)
-            .active_inline_completion
-            .as_ref()?
-            .active_edit();
-
-        let show_go_to_edit_hint = self
-            .editor
-            .read(cx)
-            .cursor_needs_repositioning_for_inline_completion(cx)
-            .is_some();
-
-        let upper_left = edit.position().to_display_point(editor_snapshot);
-        let is_visible = visible_row_range.contains(&upper_left.row());
-
-        let container_element = div()
-            .bg(cx.theme().colors().editor_background)
-            .border_1()
-            .border_color(cx.theme().colors().border)
-            .rounded_md()
-            .px_1();
-
-        let (origin, mut element) = if show_go_to_edit_hint {
-            if is_visible {
-                let element = container_element
-                    .child(Label::new(format!(
-                        "{} jump to edit",
-                        accept_completion_keystroke
-                    )))
-                    .into_any();
-
-                let len = editor_snapshot.line_len(upper_left.row());
-                let popup_position = DisplayPoint::new(upper_left.row(), len);
-                let origin = self.editor.update(cx, |editor, cx| {
-                    editor.display_to_pixel_point(popup_position, editor_snapshot, cx)
-                })?;
-                (
-                    text_bounds.origin + origin + point(px(X_OFFSET), px(0.)),
-                    element,
-                )
-            } else {
-                let is_above = visible_row_range.start > upper_left.row();
-
-                let mut element = container_element
-                    .child(
-                        h_flex()
-                            .gap_1()
-                            .child(Label::new(format!(
-                                "{} jump to edit",
-                                accept_completion_keystroke
-                            )))
-                            .child(Icon::new(if is_above {
-                                IconName::ArrowUp
-                            } else {
-                                IconName::ArrowDown
-                            })),
-                    )
-                    .into_any();
-
-                let size = element.layout_as_root(AvailableSpace::min_size(), cx);
-
-                let offset_y = if is_above {
-                    px(PADDING_Y)
-                } else {
-                    text_bounds.size.height - size.height - px(PADDING_Y)
-                };
-
-                let origin = text_bounds.origin
-                    + point((text_bounds.size.width - size.width) / 2., offset_y);
-                (origin, element)
-            }
-        } else if let ComputedCompletionEdit::Diff {
-            text, additions, ..
-        } = edit
-        {
-            let row = &line_layouts[upper_left.row().minus(visible_row_range.start) as usize];
-            let origin = text_bounds.origin
-                + point(
-                    row.width + px(X_OFFSET) - scroll_pixel_position.x,
-                    upper_left.row().as_f32() * line_height - scroll_pixel_position.y,
-                );
-
-            let text = gpui::StyledText::new(text.to_string()).with_highlights(
-                text_style,
-                additions.iter().map(|range| {
-                    (
-                        range.clone(),
-                        HighlightStyle {
-                            background_color: Some(cx.theme().status().created_background),
-                            ..Default::default()
-                        },
-                    )
-                }),
-            );
-
-            let element = container_element.child(text).into_any();
-            (origin, element)
-        } else {
-            return None;
-        };
-
-        element.prepaint_as_root(origin, AvailableSpace::min_size(), cx);
-        Some(element)
-    }
-
    fn layout_mouse_context_menu(
        &self,
        editor_snapshot: &EditorSnapshot,
        visible_range: Range<DisplayRow>,
+        content_origin: gpui::Point<Pixels>,
        cx: &mut WindowContext,
    ) -> Option<AnyElement> {
        let position = self.editor.update(cx, |editor, cx| {
@@ -2871,16 +2740,11 @@ impl EditorElement {
            let mouse_context_menu = editor.mouse_context_menu.as_ref()?;
            let (source_display_point, position) = match mouse_context_menu.position {
                MenuPosition::PinnedToScreen(point) => (None, point),
-                MenuPosition::PinnedToEditor {
-                    source,
-                    offset_x,
-                    offset_y,
-                } => {
+                MenuPosition::PinnedToEditor { source, offset } => {
                    let source_display_point = source.to_display_point(editor_snapshot);
-                    let mut source_point = editor.to_pixel_point(source, editor_snapshot, cx)?;
-                    source_point.x += offset_x;
-                    source_point.y += offset_y;
-                    (Some(source_display_point), source_point)
+                    let source_point = editor.to_pixel_point(source, editor_snapshot, cx)?;
+                    let position = content_origin + source_point + offset;
+                    (Some(source_display_point), position)
                }
            };

@@ -3882,10 +3746,8 @@ impl EditorElement {
                            let mut marker_quads = Vec::new();
                            if scrollbar_settings.git_diff {
                                let marker_row_ranges = snapshot
-                                    .buffer_snapshot
-                                    .git_diff_hunks_in_range(
-                                        MultiBufferRow::MIN..MultiBufferRow::MAX,
-                                    )
+                                    .diff_map
+                                    .diff_hunks(&snapshot.buffer_snapshot)
                                    .map(|hunk| {
                                        let start_display_row =
                                            MultiBufferPoint::new(hunk.row_range.start.0, 0)
@@ -4078,16 +3940,6 @@ impl EditorElement {
        }
    }

-    fn paint_inline_completion_popover(
-        &mut self,
-        layout: &mut EditorLayout,
-        cx: &mut WindowContext,
-    ) {
-        if let Some(inline_completion_popover) = layout.inline_completion_popover.as_mut() {
-            inline_completion_popover.paint(cx);
-        }
-    }
-
    fn paint_mouse_context_menu(&mut self, layout: &mut EditorLayout, cx: &mut WindowContext) {
        if let Some(mouse_context_menu) = layout.mouse_context_menu.as_mut() {
            mouse_context_menu.paint(cx);
@@ -4275,13 +4127,7 @@ impl EditorElement {
    }

    fn max_line_number_width(&self, snapshot: &EditorSnapshot, cx: &WindowContext) -> Pixels {
-        let digit_count = snapshot
-            .max_buffer_row()
-            .next_row()
-            .as_f32()
-            .log10()
-            .floor() as usize
-            + 1;
+        let digit_count = (snapshot.widest_line_number() as f32).log10().floor() as usize + 1;
        self.column_pixels(digit_count, cx)
    }
 }
@@ -4465,8 +4311,8 @@ fn deploy_blame_entry_context_menu(
    });

    editor.update(cx, move |editor, cx| {
-        editor.mouse_context_menu = Some(MouseContextMenu::pinned_to_screen(
-            position,
+        editor.mouse_context_menu = Some(MouseContextMenu::new(
+            MenuPosition::PinnedToScreen(position),
            context_menu,
            cx,
        ));
@@ -5583,7 +5429,7 @@ impl Element for EditorElement {

                    let expanded_add_hunks_by_rows = self.editor.update(cx, |editor, _| {
                        editor
-                            .expanded_hunks
+                            .diff_map
                            .hunks(false)
                            .filter(|hunk| hunk.status == DiffHunkStatus::Added)
                            .map(|expanded_hunk| {
@@ -5718,20 +5564,13 @@ impl Element for EditorElement {
                        );
                    }

-                    let inline_completion_popover = self.layout_inline_completion_popover(
-                        &text_hitbox.bounds,
+                    let mouse_context_menu = self.layout_mouse_context_menu(
                        &snapshot,
                        start_row..end_row,
-                        &line_layouts,
-                        line_height,
-                        scroll_pixel_position,
-                        &style.text,
+                        content_origin,
                        cx,
                    );

-                    let mouse_context_menu =
-                        self.layout_mouse_context_menu(&snapshot, start_row..end_row, cx);
-
                    cx.with_element_namespace("crease_toggles", |cx| {
                        self.prepaint_crease_toggles(
                            &mut crease_toggles,
@@ -5811,7 +5650,6 @@ impl Element for EditorElement {
                        cursors,
                        visible_cursors,
                        selections,
-                        inline_completion_popover,
                        mouse_context_menu,
                        test_indicators,
                        code_actions_indicator,
@@ -5901,7 +5739,6 @@ impl Element for EditorElement {
                    }

                    self.paint_scrollbar(layout, cx);
-                    self.paint_inline_completion_popover(layout, cx);
                    self.paint_mouse_context_menu(layout, cx);
                });
            })
@@ -5957,7 +5794,6 @@ pub struct EditorLayout {
    test_indicators: Vec<AnyElement>,
    crease_toggles: Vec<Option<AnyElement>>,
    crease_trailers: Vec<Option<CreaseTrailerLayout>>,
-    inline_completion_popover: Option<AnyElement>,
    mouse_context_menu: Option<AnyElement>,
    tab_invisible: ShapedLine,
    space_invisible: ShapedLine,
--- a/crates/editor/src/git.rs
+++ b/crates/editor/src/git.rs
@@ -1 +1,2 @@
 pub mod blame;
+pub mod project_diff;
--- a/crates/editor/src/git/blame.rs
+++ b/crates/editor/src/git/blame.rs
@@ -154,7 +154,7 @@ impl GitBlame {
                        this.generate(cx);
                    }
                }
-                project::Event::WorktreeUpdatedGitRepositories => {
+                project::Event::WorktreeUpdatedGitRepositories(_) => {
                    log::debug!("Status of git repositories updated. Regenerating blame data...",);
                    this.generate(cx);
                }
--- a/crates/editor/src/git/project_diff.rs
+++ b/crates/editor/src/git/project_diff.rs
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -378,7 +378,7 @@ fn show_hover(
                            },
                            ..Default::default()
                        };
-                        Markdown::new_text(text, markdown_style.clone(), None, cx, None)
+                        Markdown::new_text(text, markdown_style.clone(), None, None, cx)
                    })
                    .ok();

@@ -593,8 +593,8 @@ async fn parse_blocks(
                combined_text,
                markdown_style.clone(),
                Some(language_registry.clone()),
-                cx,
                fallback_language_name,
+                cx,
            )
        })
        .ok();
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -1,12 +1,17 @@
-use collections::{hash_map, HashMap, HashSet};
+use collections::{HashMap, HashSet};
 use git::diff::DiffHunkStatus;
-use gpui::{Action, AnchorCorner, AppContext, CursorStyle, Hsla, Model, MouseButton, Task, View};
+use gpui::{
+    Action, AnchorCorner, AppContext, CursorStyle, Hsla, Model, MouseButton, Subscription, Task,
+    View,
+};
 use language::{Buffer, BufferId, Point};
 use multi_buffer::{
    Anchor, AnchorRangeExt, ExcerptRange, MultiBuffer, MultiBufferDiffHunk, MultiBufferRow,
-    MultiBufferSnapshot, ToPoint,
+    MultiBufferSnapshot, ToOffset, ToPoint,
 };
+use project::buffer_store::BufferChangeSet;
 use std::{ops::Range, sync::Arc};
+use sum_tree::TreeMap;
 use text::OffsetRangeExt;
 use ui::{
    prelude::*, ActiveTheme, ContextMenu, IconButtonShape, InteractiveElement, IntoElement,
@@ -29,10 +34,11 @@ pub(super) struct HoveredHunk {
    pub diff_base_byte_range: Range<usize>,
 }

-#[derive(Debug, Default)]
-pub(super) struct ExpandedHunks {
+#[derive(Default)]
+pub(super) struct DiffMap {
    pub(crate) hunks: Vec<ExpandedHunk>,
-    diff_base: HashMap<BufferId, DiffBaseBuffer>,
+    pub(crate) diff_bases: HashMap<BufferId, DiffBaseState>,
+    pub(crate) snapshot: DiffMapSnapshot,
    hunk_update_tasks: HashMap<Option<BufferId>, Task<()>>,
    expand_all: bool,
 }
@@ -46,10 +52,13 @@ pub(super) struct ExpandedHunk {
    pub folded: bool,
 }

-#[derive(Debug)]
-struct DiffBaseBuffer {
-    buffer: Model<Buffer>,
-    diff_base_version: usize,
+#[derive(Clone, Debug, Default)]
+pub(crate) struct DiffMapSnapshot(TreeMap<BufferId, git::diff::BufferDiff>);
+
+pub(crate) struct DiffBaseState {
+    pub(crate) change_set: Model<BufferChangeSet>,
+    pub(crate) last_version: Option<usize>,
+    _subscription: Subscription,
 }

 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -66,7 +75,38 @@ pub enum DisplayDiffHunk {
    },
 }

-impl ExpandedHunks {
+impl DiffMap {
+    pub fn snapshot(&self) -> DiffMapSnapshot {
+        self.snapshot.clone()
+    }
+
+    pub fn add_change_set(
+        &mut self,
+        change_set: Model<BufferChangeSet>,
+        cx: &mut ViewContext<Editor>,
+    ) {
+        let buffer_id = change_set.read(cx).buffer_id;
+        self.snapshot
+            .0
+            .insert(buffer_id, change_set.read(cx).diff_to_buffer.clone());
+        Editor::sync_expanded_diff_hunks(self, buffer_id, cx);
+        self.diff_bases.insert(
+            buffer_id,
+            DiffBaseState {
+                last_version: None,
+                _subscription: cx.observe(&change_set, move |editor, change_set, cx| {
+                    editor
+                        .diff_map
+                        .snapshot
+                        .0
+                        .insert(buffer_id, change_set.read(cx).diff_to_buffer.clone());
+                    Editor::sync_expanded_diff_hunks(&mut editor.diff_map, buffer_id, cx);
+                }),
+                change_set,
+            },
+        );
+    }
+
    pub fn hunks(&self, include_folded: bool) -> impl Iterator<Item = &ExpandedHunk> {
        self.hunks
            .iter()
@@ -74,9 +114,92 @@ impl ExpandedHunks {
    }
 }

+impl DiffMapSnapshot {
+    pub fn is_empty(&self) -> bool {
+        self.0.values().all(|diff| diff.is_empty())
+    }
+
+    pub fn diff_hunks<'a>(
+        &'a self,
+        buffer_snapshot: &'a MultiBufferSnapshot,
+    ) -> impl Iterator<Item = MultiBufferDiffHunk> + 'a {
+        self.diff_hunks_in_range(0..buffer_snapshot.len(), buffer_snapshot)
+    }
+
+    pub fn diff_hunks_in_range<'a, T: ToOffset>(
+        &'a self,
+        range: Range<T>,
+        buffer_snapshot: &'a MultiBufferSnapshot,
+    ) -> impl Iterator<Item = MultiBufferDiffHunk> + 'a {
+        let range = range.start.to_offset(buffer_snapshot)..range.end.to_offset(buffer_snapshot);
+        buffer_snapshot
+            .excerpts_for_range(range.clone())
+            .filter_map(move |excerpt| {
+                let buffer = excerpt.buffer();
+                let buffer_id = buffer.remote_id();
+                let diff = self.0.get(&buffer_id)?;
+                let buffer_range = excerpt.map_range_to_buffer(range.clone());
+                let buffer_range =
+                    buffer.anchor_before(buffer_range.start)..buffer.anchor_after(buffer_range.end);
+                Some(
+                    diff.hunks_intersecting_range(buffer_range, excerpt.buffer())
+                        .map(move |hunk| {
+                            let start =
+                                excerpt.map_point_from_buffer(Point::new(hunk.row_range.start, 0));
+                            let end =
+                                excerpt.map_point_from_buffer(Point::new(hunk.row_range.end, 0));
+                            MultiBufferDiffHunk {
+                                row_range: MultiBufferRow(start.row)..MultiBufferRow(end.row),
+                                buffer_id,
+                                buffer_range: hunk.buffer_range.clone(),
+                                diff_base_byte_range: hunk.diff_base_byte_range.clone(),
+                            }
+                        }),
+                )
+            })
+            .flatten()
+    }
+
+    pub fn diff_hunks_in_range_rev<'a, T: ToOffset>(
+        &'a self,
+        range: Range<T>,
+        buffer_snapshot: &'a MultiBufferSnapshot,
+    ) -> impl Iterator<Item = MultiBufferDiffHunk> + 'a {
+        let range = range.start.to_offset(buffer_snapshot)..range.end.to_offset(buffer_snapshot);
+        buffer_snapshot
+            .excerpts_for_range_rev(range.clone())
+            .filter_map(move |excerpt| {
+                let buffer = excerpt.buffer();
+                let buffer_id = buffer.remote_id();
+                let diff = self.0.get(&buffer_id)?;
+                let buffer_range = excerpt.map_range_to_buffer(range.clone());
+                let buffer_range =
+                    buffer.anchor_before(buffer_range.start)..buffer.anchor_after(buffer_range.end);
+                Some(
+                    diff.hunks_intersecting_range_rev(buffer_range, excerpt.buffer())
+                        .map(move |hunk| {
+                            let start_row = excerpt
+                                .map_point_from_buffer(Point::new(hunk.row_range.start, 0))
+                                .row;
+                            let end_row = excerpt
+                                .map_point_from_buffer(Point::new(hunk.row_range.end, 0))
+                                .row;
+                            MultiBufferDiffHunk {
+                                row_range: MultiBufferRow(start_row)..MultiBufferRow(end_row),
+                                buffer_id,
+                                buffer_range: hunk.buffer_range.clone(),
+                                diff_base_byte_range: hunk.diff_base_byte_range.clone(),
+                            }
+                        }),
+                )
+            })
+            .flatten()
+    }
+}
+
 impl Editor {
    pub fn set_expand_all_diff_hunks(&mut self) {
-        self.expanded_hunks.expand_all = true;
+        self.diff_map.expand_all = true;
    }

    pub(super) fn toggle_hovered_hunk(
@@ -92,18 +215,15 @@ impl Editor {
    }

    pub fn toggle_hunk_diff(&mut self, _: &ToggleHunkDiff, cx: &mut ViewContext<Self>) {
-        let multi_buffer_snapshot = self.buffer().read(cx).snapshot(cx);
-        let selections = self.selections.disjoint_anchors();
-        self.toggle_hunks_expanded(
-            hunks_for_selections(&multi_buffer_snapshot, &selections),
-            cx,
-        );
+        let snapshot = self.snapshot(cx);
+        let selections = self.selections.all(cx);
+        self.toggle_hunks_expanded(hunks_for_selections(&snapshot, &selections), cx);
    }

    pub fn expand_all_hunk_diffs(&mut self, _: &ExpandAllHunkDiffs, cx: &mut ViewContext<Self>) {
        let snapshot = self.snapshot(cx);
        let display_rows_with_expanded_hunks = self
-            .expanded_hunks
+            .diff_map
            .hunks(false)
            .map(|hunk| &hunk.hunk_range)
            .map(|anchor_range| {
@@ -119,10 +239,10 @@ impl Editor {
                )
            })
            .collect::<HashMap<_, _>>();
-        let hunks = snapshot
-            .display_snapshot
-            .buffer_snapshot
-            .git_diff_hunks_in_range(MultiBufferRow::MIN..MultiBufferRow::MAX)
+        let hunks = self
+            .diff_map
+            .snapshot
+            .diff_hunks(&snapshot.display_snapshot.buffer_snapshot)
            .filter(|hunk| {
                let hunk_display_row_range = Point::new(hunk.row_range.start.0, 0)
                    .to_display_point(&snapshot.display_snapshot)
@@ -140,11 +260,11 @@ impl Editor {
        hunks_to_toggle: Vec<MultiBufferDiffHunk>,
        cx: &mut ViewContext<Self>,
    ) {
-        if self.expanded_hunks.expand_all {
+        if self.diff_map.expand_all {
            return;
        }

-        let previous_toggle_task = self.expanded_hunks.hunk_update_tasks.remove(&None);
+        let previous_toggle_task = self.diff_map.hunk_update_tasks.remove(&None);
        let new_toggle_task = cx.spawn(move |editor, mut cx| async move {
            if let Some(task) = previous_toggle_task {
                task.await;
@@ -154,11 +274,10 @@ impl Editor {
                .update(&mut cx, |editor, cx| {
                    let snapshot = editor.snapshot(cx);
                    let mut hunks_to_toggle = hunks_to_toggle.into_iter().fuse().peekable();
-                    let mut highlights_to_remove =
-                        Vec::with_capacity(editor.expanded_hunks.hunks.len());
+                    let mut highlights_to_remove = Vec::with_capacity(editor.diff_map.hunks.len());
                    let mut blocks_to_remove = HashSet::default();
                    let mut hunks_to_expand = Vec::new();
-                    editor.expanded_hunks.hunks.retain(|expanded_hunk| {
+                    editor.diff_map.hunks.retain(|expanded_hunk| {
                        if expanded_hunk.folded {
                            return true;
                        }
@@ -238,7 +357,7 @@ impl Editor {
                .ok();
        });

-        self.expanded_hunks
+        self.diff_map
            .hunk_update_tasks
            .insert(None, cx.background_executor().spawn(new_toggle_task));
    }
@@ -252,30 +371,34 @@ impl Editor {
        let buffer = self.buffer.clone();
        let multi_buffer_snapshot = buffer.read(cx).snapshot(cx);
        let hunk_range = hunk.multi_buffer_range.clone();
-        let (diff_base_buffer, deleted_text_lines) = buffer.update(cx, |buffer, cx| {
-            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 buffer_id = hunk_range.start.buffer_id?;
+        let diff_base_buffer = diff_base_buffer.or_else(|| {
+            self.diff_map
+                .diff_bases
+                .get(&buffer_id)?
+                .change_set
+                .read(cx)
+                .base_text
+                .clone()
        })?;

-        let block_insert_index = match self.expanded_hunks.hunks.binary_search_by(|probe| {
-            probe
-                .hunk_range
-                .start
-                .cmp(&hunk_range.start, &multi_buffer_snapshot)
-        }) {
-            Ok(_already_present) => return None,
-            Err(ix) => ix,
-        };
+        let diff_base = diff_base_buffer.read(cx);
+        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;
+        let deleted_text_lines = diff_end_row - diff_start_row;
+
+        let block_insert_index = self
+            .diff_map
+            .hunks
+            .binary_search_by(|probe| {
+                probe
+                    .hunk_range
+                    .start
+                    .cmp(&hunk_range.start, &multi_buffer_snapshot)
+            })
+            .err()?;

        let blocks;
        match hunk.status {
@@ -315,7 +438,7 @@ impl Editor {
                );
            }
        };
-        self.expanded_hunks.hunks.insert(
+        self.diff_map.hunks.insert(
            block_insert_index,
            ExpandedHunk {
                blocks,
@@ -374,8 +497,8 @@ impl Editor {
        _: &ApplyDiffHunk,
        cx: &mut ViewContext<Self>,
    ) {
-        let snapshot = self.buffer.read(cx).snapshot(cx);
-        let hunks = hunks_for_selections(&snapshot, &self.selections.disjoint_anchors());
+        let snapshot = self.snapshot(cx);
+        let hunks = hunks_for_selections(&snapshot, &self.selections.all(cx));
        let mut ranges_by_buffer = HashMap::default();
        self.transact(cx, |editor, cx| {
            for hunk in hunks {
@@ -399,6 +522,12 @@ impl Editor {
        }
    }

+    fn has_multiple_hunks(&self, cx: &AppContext) -> bool {
+        let snapshot = self.buffer.read(cx).snapshot(cx);
+        let mut hunks = self.diff_map.snapshot.diff_hunks(&snapshot);
+        hunks.nth(1).is_some()
+    }
+
    fn hunk_header_block(
        &self,
        hunk: &HoveredHunk,
@@ -409,7 +538,7 @@ impl Editor {
            .read(cx)
            .point_to_buffer_offset(hunk.multi_buffer_range.start, cx)
            .map_or(false, |(buffer, _, _)| {
-                buffer.read(cx).diff_base_buffer().is_some()
+                buffer.read(cx).base_buffer().is_some()
            });

        let border_color = cx.theme().colors().border_variant;
@@ -428,6 +557,7 @@ impl Editor {
            render: Arc::new({
                let editor = cx.view().clone();
                let hunk = hunk.clone();
+                let has_multiple_hunks = self.has_multiple_hunks(cx);

                move |cx| {
                    let hunk_controls_menu_handle =
@@ -471,6 +601,7 @@ impl Editor {
                                                IconButton::new("next-hunk", IconName::ArrowDown)
                                                    .shape(IconButtonShape::Square)
                                                    .icon_size(IconSize::Small)
+                                                    .disabled(!has_multiple_hunks)
                                                    .tooltip({
                                                        let focus_handle = editor.focus_handle(cx);
                                                        move |cx| {
@@ -499,6 +630,7 @@ impl Editor {
                                                IconButton::new("prev-hunk", IconName::ArrowUp)
                                                    .shape(IconButtonShape::Square)
                                                    .icon_size(IconSize::Small)
+                                                    .disabled(!has_multiple_hunks)
                                                    .tooltip({
                                                        let focus_handle = editor.focus_handle(cx);
                                                        move |cx| {
@@ -543,29 +675,9 @@ impl Editor {
                                                    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)
-                                                            });
-                                                        }
+                                                        editor.update(cx, |editor, cx| {
+                                                            editor.revert_hunk(hunk.clone(), cx);
+                                                        });
                                                    }
                                                }),
                                        )
@@ -754,13 +866,13 @@ impl Editor {
    }

    pub(super) fn clear_expanded_diff_hunks(&mut self, cx: &mut ViewContext<'_, Editor>) -> bool {
-        if self.expanded_hunks.expand_all {
+        if self.diff_map.expand_all {
            return false;
        }
-        self.expanded_hunks.hunk_update_tasks.clear();
+        self.diff_map.hunk_update_tasks.clear();
        self.clear_row_highlights::<DiffRowHighlight>();
        let to_remove = self
-            .expanded_hunks
+            .diff_map
            .hunks
            .drain(..)
            .flat_map(|expanded_hunk| expanded_hunk.blocks.into_iter())
@@ -774,48 +886,39 @@ impl Editor {
    }

    pub(super) fn sync_expanded_diff_hunks(
-        &mut self,
-        buffer: Model<Buffer>,
+        diff_map: &mut DiffMap,
+        buffer_id: BufferId,
        cx: &mut ViewContext<'_, Self>,
    ) {
-        let buffer_id = buffer.read(cx).remote_id();
-        let buffer_diff_base_version = buffer.read(cx).diff_base_version();
-        self.expanded_hunks
-            .hunk_update_tasks
-            .remove(&Some(buffer_id));
-        let diff_base_buffer = self.current_diff_base_buffer(&buffer, cx);
+        let diff_base_state = diff_map.diff_bases.get_mut(&buffer_id);
+        let mut diff_base_buffer = None;
+        let mut diff_base_buffer_unchanged = true;
+        if let Some(diff_base_state) = diff_base_state {
+            diff_base_state.change_set.update(cx, |change_set, _| {
+                if diff_base_state.last_version != Some(change_set.base_text_version) {
+                    diff_base_state.last_version = Some(change_set.base_text_version);
+                    diff_base_buffer_unchanged = false;
+                }
+                diff_base_buffer = change_set.base_text.clone();
+            })
+        }
+
+        diff_map.hunk_update_tasks.remove(&Some(buffer_id));
+
        let new_sync_task = cx.spawn(move |editor, mut cx| async move {
-            let diff_base_buffer_unchanged = diff_base_buffer.is_some();
-            let Ok(diff_base_buffer) =
-                cx.update(|cx| diff_base_buffer.or_else(|| create_diff_base_buffer(&buffer, cx)))
-            else {
-                return;
-            };
            editor
                .update(&mut cx, |editor, cx| {
-                    if let Some(diff_base_buffer) = &diff_base_buffer {
-                        editor.expanded_hunks.diff_base.insert(
-                            buffer_id,
-                            DiffBaseBuffer {
-                                buffer: diff_base_buffer.clone(),
-                                diff_base_version: buffer_diff_base_version,
-                            },
-                        );
-                    }
-
                    let snapshot = editor.snapshot(cx);
                    let mut recalculated_hunks = snapshot
-                        .buffer_snapshot
-                        .git_diff_hunks_in_range(MultiBufferRow::MIN..MultiBufferRow::MAX)
+                        .diff_map
+                        .diff_hunks(&snapshot.buffer_snapshot)
                        .filter(|hunk| hunk.buffer_id == buffer_id)
                        .fuse()
                        .peekable();
-                    let mut highlights_to_remove =
-                        Vec::with_capacity(editor.expanded_hunks.hunks.len());
+                    let mut highlights_to_remove = Vec::with_capacity(editor.diff_map.hunks.len());
                    let mut blocks_to_remove = HashSet::default();
-                    let mut hunks_to_reexpand =
-                        Vec::with_capacity(editor.expanded_hunks.hunks.len());
-                    editor.expanded_hunks.hunks.retain_mut(|expanded_hunk| {
+                    let mut hunks_to_reexpand = Vec::with_capacity(editor.diff_map.hunks.len());
+                    editor.diff_map.hunks.retain_mut(|expanded_hunk| {
                        if expanded_hunk.hunk_range.start.buffer_id != Some(buffer_id) {
                            return true;
                        };
@@ -865,7 +968,7 @@ impl Editor {
                                            > hunk_display_range.end
                                        {
                                            recalculated_hunks.next();
-                                            if editor.expanded_hunks.expand_all {
+                                            if editor.diff_map.expand_all {
                                                hunks_to_reexpand.push(HoveredHunk {
                                                    status,
                                                    multi_buffer_range,
@@ -908,7 +1011,7 @@ impl Editor {
                        retain
                    });

-                    if editor.expanded_hunks.expand_all {
+                    if editor.diff_map.expand_all {
                        for hunk in recalculated_hunks {
                            match diff_hunk_to_display(&hunk, &snapshot) {
                                DisplayDiffHunk::Folded { .. } => {}
@@ -926,6 +1029,8 @@ impl Editor {
                                }
                            }
                        }
+                    } else {
+                        drop(recalculated_hunks);
                    }

                    editor.remove_highlighted_rows::<DiffRowHighlight>(highlights_to_remove, cx);
@@ -940,32 +1045,12 @@ impl Editor {
                .ok();
        });

-        self.expanded_hunks.hunk_update_tasks.insert(
+        diff_map.hunk_update_tasks.insert(
            Some(buffer_id),
            cx.background_executor().spawn(new_sync_task),
        );
    }

-    fn current_diff_base_buffer(
-        &mut self,
-        buffer: &Model<Buffer>,
-        cx: &mut AppContext,
-    ) -> Option<Model<Buffer>> {
-        buffer.update(cx, |buffer, _| {
-            match self.expanded_hunks.diff_base.entry(buffer.remote_id()) {
-                hash_map::Entry::Occupied(o) => {
-                    if o.get().diff_base_version != buffer.diff_base_version() {
-                        o.remove();
-                        None
-                    } else {
-                        Some(o.get().buffer.clone())
-                    }
-                }
-                hash_map::Entry::Vacant(_) => None,
-            }
-        })
-    }
-
    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);
@@ -1012,7 +1097,7 @@ impl Editor {
    }
 }

-fn to_diff_hunk(
+pub(crate) fn to_diff_hunk(
    hovered_hunk: &HoveredHunk,
    multi_buffer_snapshot: &MultiBufferSnapshot,
 ) -> Option<MultiBufferDiffHunk> {
@@ -1034,24 +1119,6 @@ fn to_diff_hunk(
    })
 }

-fn create_diff_base_buffer(buffer: &Model<Buffer>, cx: &mut AppContext) -> Option<Model<Buffer>> {
-    buffer
-        .update(cx, |buffer, _| {
-            let language = buffer.language().cloned();
-            let diff_base = buffer.diff_base()?.clone();
-            Some((buffer.line_ending(), diff_base, language))
-        })
-        .map(|(line_ending, diff_base, language)| {
-            cx.new_model(|cx| {
-                let buffer = Buffer::local_normalized(diff_base, line_ending, cx);
-                match language {
-                    Some(language) => buffer.with_language(language, cx),
-                    None => buffer,
-                }
-            })
-        })
-}
-
 fn added_hunk_color(cx: &AppContext) -> Hsla {
    let mut created_color = cx.theme().status().git().created;
    created_color.fade_out(0.7);
@@ -1109,51 +1176,27 @@ fn editor_with_deleted_text(
                });
            })]);

-        let original_multi_buffer_range = hunk.multi_buffer_range.clone();
-        let diff_base_range = hunk.diff_base_byte_range.clone();
        editor
            .register_action::<RevertSelectedHunks>({
+                let hunk = hunk.clone();
                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,
-                                )
-                            });
-                        })
+                        .update(cx, |editor, cx| editor.revert_hunk(hunk.clone(), cx))
                        .ok();
                }
            })
            .detach();
-        let hunk = hunk.clone();
        editor
-            .register_action::<ToggleHunkDiff>(move |_, cx| {
-                parent_editor
-                    .update(cx, |editor, cx| {
-                        editor.toggle_hovered_hunk(&hunk, cx);
-                    })
-                    .ok();
+            .register_action::<ToggleHunkDiff>({
+                let hunk = hunk.clone();
+                move |_, cx| {
+                    parent_editor
+                        .update(cx, |editor, cx| {
+                            editor.toggle_hovered_hunk(&hunk, cx);
+                        })
+                        .ok();
+                }
            })
            .detach();
        editor
@@ -1263,78 +1306,57 @@ mod tests {
        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,
-            );
-        });
+        let diff_base_1 = "
+            1.zero
+            1.one
+            1.two
+            1.three
+            1.four
+            1.five
+            1.six
+        "
+        .unindent();
+
+        let text_1 = "
+            1.zero
+            1.ONE
+            1.TWO
+            1.three
+            1.FOUR
+            1.FIVE
+            1.six
+        "
+        .unindent();

        // 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,
-            );
-        });
+        let diff_base_2 = "
+            2.zero
+            2.one
+            2.one-and-a-half
+            2.two
+            2.three
+            2.four
+            2.six
+        "
+        .unindent();

-        cx.background_executor.run_until_parked();
+        let text_2 = "
+            2.zero
+            2.one
+            2.two
+            2.three
+            2.four
+            2.five
+            2.six
+        "
+        .unindent();
+
+        let buffer_1 = project.update(cx, |project, cx| {
+            project.create_local_buffer(text_1.as_str(), None, cx)
+        });
+        let buffer_2 = project.update(cx, |project, cx| {
+            project.create_local_buffer(text_2.as_str(), None, cx)
+        });

        let multibuffer = cx.new_model(|cx| {
            let mut multibuffer = MultiBuffer::new(ReadWrite);
@@ -1383,10 +1405,30 @@ mod tests {
            multibuffer
        });

-        let snapshot = multibuffer.read_with(cx, |b, cx| b.snapshot(cx));
+        let editor = cx.add_window(|cx| Editor::for_multibuffer(multibuffer, None, false, cx));
+        editor
+            .update(cx, |editor, cx| {
+                for (buffer, diff_base) in [
+                    (buffer_1.clone(), diff_base_1),
+                    (buffer_2.clone(), diff_base_2),
+                ] {
+                    let change_set = cx.new_model(|cx| {
+                        BufferChangeSet::new_with_base_text(
+                            diff_base.to_string(),
+                            buffer.read(cx).text_snapshot(),
+                            cx,
+                        )
+                    });
+                    editor.diff_map.add_change_set(change_set, cx)
+                }
+            })
+            .unwrap();
+        cx.background_executor.run_until_parked();
+
+        let snapshot = editor.update(cx, |editor, cx| editor.snapshot(cx)).unwrap();

        assert_eq!(
-            snapshot.text(),
+            snapshot.buffer_snapshot.text(),
            "
                1.zero
                1.ONE
@@ -1429,7 +1471,8 @@ mod tests {

        assert_eq!(
            snapshot
-                .git_diff_hunks_in_range(MultiBufferRow(0)..MultiBufferRow(12))
+                .diff_map
+                .diff_hunks_in_range(Point::zero()..Point::new(12, 0), &snapshot.buffer_snapshot)
                .map(|hunk| (hunk_status(&hunk), hunk.row_range))
                .collect::<Vec<_>>(),
            &expected,
@@ -1437,7 +1480,11 @@ mod tests {

        assert_eq!(
            snapshot
-                .git_diff_hunks_in_range_rev(MultiBufferRow(0)..MultiBufferRow(12))
+                .diff_map
+                .diff_hunks_in_range_rev(
+                    Point::zero()..Point::new(12, 0),
+                    &snapshot.buffer_snapshot
+                )
                .map(|hunk| (hunk_status(&hunk), hunk.row_range))
                .collect::<Vec<_>>(),
            expected
--- a/crates/editor/src/inlay_hint_cache.rs
+++ b/crates/editor/src/inlay_hint_cache.rs
@@ -1258,6 +1258,7 @@ pub mod tests {

    use crate::{
        scroll::{scroll_amount::ScrollAmount, Autoscroll},
+        test::editor_lsp_test_context::rust_lang,
        ExcerptRange,
    };
    use futures::StreamExt;
@@ -2274,7 +2275,7 @@ pub mod tests {
        let project = Project::test(fs, ["/a".as_ref()], cx).await;

        let language_registry = project.read_with(cx, |project, _| project.languages().clone());
-        language_registry.add(crate::editor_tests::rust_lang());
+        language_registry.add(rust_lang());
        let mut fake_servers = language_registry.register_fake_lsp(
            "Rust",
            FakeLspAdapter {
@@ -2570,7 +2571,7 @@ pub mod tests {
        let project = Project::test(fs, ["/a".as_ref()], cx).await;

        let language_registry = project.read_with(cx, |project, _| project.languages().clone());
-        let language = crate::editor_tests::rust_lang();
+        let language = rust_lang();
        language_registry.add(language);
        let mut fake_servers = language_registry.register_fake_lsp(
            "Rust",
@@ -2922,7 +2923,7 @@ pub mod tests {
        let project = Project::test(fs, ["/a".as_ref()], cx).await;

        let language_registry = project.read_with(cx, |project, _| project.languages().clone());
-        language_registry.add(crate::editor_tests::rust_lang());
+        language_registry.add(rust_lang());
        let mut fake_servers = language_registry.register_fake_lsp(
            "Rust",
            FakeLspAdapter {
@@ -3153,7 +3154,7 @@ pub mod tests {
        let project = Project::test(fs, ["/a".as_ref()], cx).await;

        let language_registry = project.read_with(cx, |project, _| project.languages().clone());
-        language_registry.add(crate::editor_tests::rust_lang());
+        language_registry.add(rust_lang());
        let mut fake_servers = language_registry.register_fake_lsp(
            "Rust",
            FakeLspAdapter {
@@ -3396,7 +3397,7 @@ pub mod tests {
        let project = Project::test(fs, ["/a".as_ref()], cx).await;

        let language_registry = project.read_with(cx, |project, _| project.languages().clone());
-        language_registry.add(crate::editor_tests::rust_lang());
+        language_registry.add(rust_lang());
        let mut fake_servers = language_registry.register_fake_lsp(
            "Rust",
            FakeLspAdapter {
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -737,7 +737,7 @@ impl Item for Editor {
        let buffers = self.buffer().clone().read(cx).all_buffers();
        let buffers = buffers
            .into_iter()
-            .map(|handle| handle.read(cx).diff_base_buffer().unwrap_or(handle.clone()))
+            .map(|handle| handle.read(cx).base_buffer().unwrap_or(handle.clone()))
            .collect::<HashSet<_>>();
        cx.spawn(|this, mut cx| async move {
            if format {
--- a/crates/editor/src/mouse_context_menu.rs
+++ b/crates/editor/src/mouse_context_menu.rs
@@ -20,8 +20,7 @@ pub enum MenuPosition {
    /// Disappears when the position is no longer visible.
    PinnedToEditor {
        source: multi_buffer::Anchor,
-        offset_x: Pixels,
-        offset_y: Pixels,
+        offset: Point<Pixels>,
    },
 }

@@ -48,36 +47,22 @@ impl MouseContextMenu {
        context_menu: View<ui::ContextMenu>,
        cx: &mut ViewContext<Editor>,
    ) -> Option<Self> {
-        let context_menu_focus = context_menu.focus_handle(cx);
-        cx.focus(&context_menu_focus);
-
-        let _subscription = cx.subscribe(
-            &context_menu,
-            move |editor, _, _event: &DismissEvent, cx| {
-                editor.mouse_context_menu.take();
-                if context_menu_focus.contains_focused(cx) {
-                    editor.focus(cx);
-                }
-            },
-        );
-
        let editor_snapshot = editor.snapshot(cx);
-        let source_point = editor.to_pixel_point(source, &editor_snapshot, cx)?;
-        let offset = position - source_point;
-
-        Some(Self {
-            position: MenuPosition::PinnedToEditor {
-                source,
-                offset_x: offset.x,
-                offset_y: offset.y,
-            },
-            context_menu,
-            _subscription,
-        })
+        let content_origin = editor.last_bounds?.origin
+            + Point {
+                x: editor.gutter_dimensions.width,
+                y: Pixels(0.0),
+            };
+        let source_position = editor.to_pixel_point(source, &editor_snapshot, cx)?;
+        let menu_position = MenuPosition::PinnedToEditor {
+            source,
+            offset: position - (source_position + content_origin),
+        };
+        return Some(MouseContextMenu::new(menu_position, context_menu, cx));
    }

-    pub(crate) fn pinned_to_screen(
-        position: Point<Pixels>,
+    pub(crate) fn new(
+        position: MenuPosition,
        context_menu: View<ui::ContextMenu>,
        cx: &mut ViewContext<Editor>,
    ) -> Self {
@@ -95,7 +80,7 @@ impl MouseContextMenu {
        );

        Self {
-            position: MenuPosition::PinnedToScreen(position),
+            position,
            context_menu,
            _subscription,
        }
@@ -119,7 +104,7 @@ fn display_ranges<'a>(

 pub fn deploy_context_menu(
    editor: &mut Editor,
-    position: Point<Pixels>,
+    position: Option<Point<Pixels>>,
    point: DisplayPoint,
    cx: &mut ViewContext<Editor>,
 ) {
@@ -213,8 +198,18 @@ pub fn deploy_context_menu(
        })
    };

-    editor.mouse_context_menu =
-        MouseContextMenu::pinned_to_editor(editor, source_anchor, position, context_menu, cx);
+    editor.mouse_context_menu = match position {
+        Some(position) => {
+            MouseContextMenu::pinned_to_editor(editor, source_anchor, position, context_menu, cx)
+        }
+        None => {
+            let menu_position = MenuPosition::PinnedToEditor {
+                source: source_anchor,
+                offset: editor.character_size(cx),
+            };
+            Some(MouseContextMenu::new(menu_position, context_menu, cx))
+        }
+    };
    cx.notify();
 }

@@ -248,7 +243,9 @@ mod tests {
            }
        "});
        cx.editor(|editor, _app| assert!(editor.mouse_context_menu.is_none()));
-        cx.update_editor(|editor, cx| deploy_context_menu(editor, Default::default(), point, cx));
+        cx.update_editor(|editor, cx| {
+            deploy_context_menu(editor, Some(Default::default()), point, cx)
+        });

        cx.assert_editor_state(indoc! {"
            fn test() {
--- a/crates/editor/src/movement.rs
+++ b/crates/editor/src/movement.rs
@@ -2,7 +2,7 @@
 //! in editor given a given motion (e.g. it handles converting a "move left" command into coordinates in editor). It is exposed mostly for use by vim crate.

 use super::{Bias, DisplayPoint, DisplaySnapshot, SelectionGoal, ToDisplayPoint};
-use crate::{scroll::ScrollAnchor, CharKind, DisplayRow, EditorStyle, RowExt, ToOffset, ToPoint};
+use crate::{scroll::ScrollAnchor, CharKind, DisplayRow, EditorStyle, ToOffset, ToPoint};
 use gpui::{Pixels, WindowTextSystem};
 use language::Point;
 use multi_buffer::{MultiBufferRow, MultiBufferSnapshot};
@@ -382,12 +382,12 @@ pub fn end_of_paragraph(
    mut count: usize,
 ) -> DisplayPoint {
    let point = display_point.to_point(map);
-    if point.row == map.max_buffer_row().0 {
+    if point.row == map.buffer_snapshot.max_row().0 {
        return map.max_point();
    }

    let mut found_non_blank_line = false;
-    for row in point.row..map.max_buffer_row().next_row().0 {
+    for row in point.row..=map.buffer_snapshot.max_row().0 {
        let blank = map.buffer_snapshot.is_line_blank(MultiBufferRow(row));
        if found_non_blank_line && blank {
            if count <= 1 {
@@ -488,6 +488,101 @@ pub fn find_boundary_point(
    map.clip_point(offset.to_display_point(map), Bias::Right)
 }

+pub fn find_preceding_boundary_trail(
+    map: &DisplaySnapshot,
+    head: DisplayPoint,
+    mut is_boundary: impl FnMut(char, char) -> bool,
+) -> (Option<DisplayPoint>, DisplayPoint) {
+    let mut offset = head.to_offset(map, Bias::Left);
+    let mut trail_offset = None;
+
+    let mut prev_ch = map.buffer_snapshot.chars_at(offset).next();
+    let mut forward = map.buffer_snapshot.reversed_chars_at(offset).peekable();
+
+    // Skip newlines
+    while let Some(&ch) = forward.peek() {
+        if ch == '\n' {
+            prev_ch = forward.next();
+            offset -= ch.len_utf8();
+            trail_offset = Some(offset);
+        } else {
+            break;
+        }
+    }
+
+    // Find the boundary
+    let start_offset = offset;
+    for ch in forward {
+        if let Some(prev_ch) = prev_ch {
+            if is_boundary(prev_ch, ch) {
+                if start_offset == offset {
+                    trail_offset = Some(offset);
+                } else {
+                    break;
+                }
+            }
+        }
+        offset -= ch.len_utf8();
+        prev_ch = Some(ch);
+    }
+
+    let trail = trail_offset
+        .map(|trail_offset: usize| map.clip_point(trail_offset.to_display_point(map), Bias::Left));
+
+    (
+        trail,
+        map.clip_point(offset.to_display_point(map), Bias::Left),
+    )
+}
+
+/// Finds the location of a boundary
+pub fn find_boundary_trail(
+    map: &DisplaySnapshot,
+    head: DisplayPoint,
+    mut is_boundary: impl FnMut(char, char) -> bool,
+) -> (Option<DisplayPoint>, DisplayPoint) {
+    let mut offset = head.to_offset(map, Bias::Right);
+    let mut trail_offset = None;
+
+    let mut prev_ch = map.buffer_snapshot.reversed_chars_at(offset).next();
+    let mut forward = map.buffer_snapshot.chars_at(offset).peekable();
+
+    // Skip newlines
+    while let Some(&ch) = forward.peek() {
+        if ch == '\n' {
+            prev_ch = forward.next();
+            offset += ch.len_utf8();
+            trail_offset = Some(offset);
+        } else {
+            break;
+        }
+    }
+
+    // Find the boundary
+    let start_offset = offset;
+    for ch in forward {
+        if let Some(prev_ch) = prev_ch {
+            if is_boundary(prev_ch, ch) {
+                if start_offset == offset {
+                    trail_offset = Some(offset);
+                } else {
+                    break;
+                }
+            }
+        }
+        offset += ch.len_utf8();
+        prev_ch = Some(ch);
+    }
+
+    let trail = trail_offset
+        .map(|trail_offset: usize| map.clip_point(trail_offset.to_display_point(map), Bias::Right));
+
+    (
+        trail,
+        map.clip_point(offset.to_display_point(map), Bias::Right),
+    )
+}
+
 pub fn find_boundary(
    map: &DisplaySnapshot,
    from: DisplayPoint,
--- a/crates/editor/src/proposed_changes_editor.rs
+++ b/crates/editor/src/proposed_changes_editor.rs
@@ -4,7 +4,7 @@ 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 project::{buffer_store::BufferChangeSet, Project};
 use smol::stream::StreamExt;
 use std::{any::TypeId, ops::Range, rc::Rc, time::Duration};
 use text::ToOffset;
@@ -75,7 +75,7 @@ impl ProposedChangesEditor {
            title: title.into(),
            buffer_entries: Vec::new(),
            recalculate_diffs_tx,
-            _recalculate_diffs_task: cx.spawn(|_, mut cx| async move {
+            _recalculate_diffs_task: cx.spawn(|this, mut cx| async move {
                let mut buffers_to_diff = HashSet::default();
                while let Some(mut recalculate_diff) = recalculate_diffs_rx.next().await {
                    buffers_to_diff.insert(recalculate_diff.buffer);
@@ -96,12 +96,37 @@ impl ProposedChangesEditor {
                        }
                    }

-                    join_all(buffers_to_diff.drain().filter_map(|buffer| {
-                        buffer
-                            .update(&mut cx, |buffer, cx| buffer.recalculate_diff(cx))
-                            .ok()?
-                    }))
-                    .await;
+                    let recalculate_diff_futures = this
+                        .update(&mut cx, |this, cx| {
+                            buffers_to_diff
+                                .drain()
+                                .filter_map(|buffer| {
+                                    let buffer = buffer.read(cx);
+                                    let base_buffer = buffer.base_buffer()?;
+                                    let buffer = buffer.text_snapshot();
+                                    let change_set = this.editor.update(cx, |editor, _| {
+                                        Some(
+                                            editor
+                                                .diff_map
+                                                .diff_bases
+                                                .get(&buffer.remote_id())?
+                                                .change_set
+                                                .clone(),
+                                        )
+                                    })?;
+                                    Some(change_set.update(cx, |change_set, cx| {
+                                        change_set.set_base_text(
+                                            base_buffer.read(cx).text(),
+                                            buffer,
+                                            cx,
+                                        )
+                                    }))
+                                })
+                                .collect::<Vec<_>>()
+                        })
+                        .ok()?;
+
+                    join_all(recalculate_diff_futures).await;
                }
                None
            }),
@@ -154,6 +179,7 @@ impl ProposedChangesEditor {
        });

        let mut buffer_entries = Vec::new();
+        let mut new_change_sets = Vec::new();
        for location in locations {
            let branch_buffer;
            if let Some(ix) = self
@@ -166,6 +192,15 @@ impl ProposedChangesEditor {
                buffer_entries.push(entry);
            } else {
                branch_buffer = location.buffer.update(cx, |buffer, cx| buffer.branch(cx));
+                new_change_sets.push(cx.new_model(|cx| {
+                    let mut change_set = BufferChangeSet::new(branch_buffer.read(cx));
+                    let _ = change_set.set_base_text(
+                        location.buffer.read(cx).text(),
+                        branch_buffer.read(cx).text_snapshot(),
+                        cx,
+                    );
+                    change_set
+                }));
                buffer_entries.push(BufferEntry {
                    branch: branch_buffer.clone(),
                    base: location.buffer.clone(),
@@ -187,7 +222,10 @@ impl ProposedChangesEditor {

        self.buffer_entries = buffer_entries;
        self.editor.update(cx, |editor, cx| {
-            editor.change_selections(None, cx, |selections| selections.refresh())
+            editor.change_selections(None, cx, |selections| selections.refresh());
+            for change_set in new_change_sets {
+                editor.diff_map.add_change_set(change_set, cx)
+            }
        });
    }

@@ -217,14 +255,14 @@ impl ProposedChangesEditor {
                    })
                    .ok();
            }
-            BufferEvent::DiffBaseChanged => {
-                self.recalculate_diffs_tx
-                    .unbounded_send(RecalculateDiff {
-                        buffer,
-                        debounce: false,
-                    })
-                    .ok();
-            }
+            // BufferEvent::DiffBaseChanged => {
+            //     self.recalculate_diffs_tx
+            //         .unbounded_send(RecalculateDiff {
+            //             buffer,
+            //             debounce: false,
+            //         })
+            //         .ok();
+            // }
            _ => (),
        }
    }
@@ -373,7 +411,7 @@ impl BranchBufferSemanticsProvider {
        positions: &[text::Anchor],
        cx: &AppContext,
    ) -> Option<Model<Buffer>> {
-        let base_buffer = buffer.read(cx).diff_base_buffer()?;
+        let base_buffer = buffer.read(cx).base_buffer()?;
        let version = base_buffer.read(cx).version();
        if positions
            .iter()
--- a/crates/editor/src/test/editor_lsp_test_context.rs
+++ b/crates/editor/src/test/editor_lsp_test_context.rs
@@ -31,6 +31,47 @@ pub struct EditorLspTestContext {
    pub buffer_lsp_url: lsp::Url,
 }

+pub(crate) fn rust_lang() -> Arc<Language> {
+    let language = Language::new(
+        LanguageConfig {
+            name: "Rust".into(),
+            matcher: LanguageMatcher {
+                path_suffixes: vec!["rs".to_string()],
+                ..Default::default()
+            },
+            line_comments: vec!["// ".into(), "/// ".into(), "//! ".into()],
+            ..Default::default()
+        },
+        Some(tree_sitter_rust::LANGUAGE.into()),
+    )
+    .with_queries(LanguageQueries {
+        indents: Some(Cow::from(indoc! {r#"
+            [
+                ((where_clause) _ @end)
+                (field_expression)
+                (call_expression)
+                (assignment_expression)
+                (let_declaration)
+                (let_chain)
+                (await_expression)
+            ] @indent
+
+            (_ "[" "]" @end) @indent
+            (_ "<" ">" @end) @indent
+            (_ "{" "}" @end) @indent
+            (_ "(" ")" @end) @indent"#})),
+        brackets: Some(Cow::from(indoc! {r#"
+            ("(" @open ")" @close)
+            ("[" @open "]" @close)
+            ("{" @open "}" @close)
+            ("<" @open ">" @close)
+            ("\"" @open "\"" @close)
+            (closure_parameters "|" @open "|" @close)"#})),
+        ..Default::default()
+    })
+    .expect("Could not parse queries");
+    Arc::new(language)
+}
 impl EditorLspTestContext {
    pub async fn new(
        language: Language,
@@ -72,7 +113,15 @@ impl EditorLspTestContext {
        app_state
            .fs
            .as_fake()
-            .insert_tree(root, json!({ "dir": { file_name.clone(): "" }}))
+            .insert_tree(
+                root,
+                json!({
+                    ".git": {},
+                    "dir": {
+                        file_name.clone(): ""
+                    }
+                }),
+            )
            .await;

        let window = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
@@ -119,46 +168,7 @@ impl EditorLspTestContext {
        capabilities: lsp::ServerCapabilities,
        cx: &mut gpui::TestAppContext,
    ) -> EditorLspTestContext {
-        let language = Language::new(
-            LanguageConfig {
-                name: "Rust".into(),
-                matcher: LanguageMatcher {
-                    path_suffixes: vec!["rs".to_string()],
-                    ..Default::default()
-                },
-                line_comments: vec!["// ".into(), "/// ".into(), "//! ".into()],
-                ..Default::default()
-            },
-            Some(tree_sitter_rust::LANGUAGE.into()),
-        )
-        .with_queries(LanguageQueries {
-            indents: Some(Cow::from(indoc! {r#"
-                [
-                    ((where_clause) _ @end)
-                    (field_expression)
-                    (call_expression)
-                    (assignment_expression)
-                    (let_declaration)
-                    (let_chain)
-                    (await_expression)
-                ] @indent
-
-                (_ "[" "]" @end) @indent
-                (_ "<" ">" @end) @indent
-                (_ "{" "}" @end) @indent
-                (_ "(" ")" @end) @indent"#})),
-            brackets: Some(Cow::from(indoc! {r#"
-                ("(" @open ")" @close)
-                ("[" @open "]" @close)
-                ("{" @open "}" @close)
-                ("<" @open ">" @close)
-                ("\"" @open "\"" @close)
-                (closure_parameters "|" @open "|" @close)"#})),
-            ..Default::default()
-        })
-        .expect("Could not parse queries");
-
-        Self::new(language, capabilities, cx).await
+        Self::new(Arc::into_inner(rust_lang()).unwrap(), capabilities, cx).await
    }

    pub async fn new_typescript(
--- a/crates/editor/src/test/editor_test_context.rs
+++ b/crates/editor/src/test/editor_test_context.rs
@@ -42,16 +42,16 @@ pub struct EditorTestContext {
 impl EditorTestContext {
    pub async fn new(cx: &mut gpui::TestAppContext) -> EditorTestContext {
        let fs = FakeFs::new(cx.executor());
-        // fs.insert_file("/file", "".to_owned()).await;
        let root = Self::root_path();
        fs.insert_tree(
            root,
            serde_json::json!({
+                ".git": {},
                "file": "",
            }),
        )
        .await;
-        let project = Project::test(fs, [root], cx).await;
+        let project = Project::test(fs.clone(), [root], cx).await;
        let buffer = project
            .update(cx, |project, cx| {
                project.open_local_buffer(root.join("file"), cx)
@@ -65,6 +65,8 @@ impl EditorTestContext {
            editor
        });
        let editor_view = editor.root_view(cx).unwrap();
+
+        cx.run_until_parked();
        Self {
            cx: VisualTestContext::from_window(*editor.deref(), cx),
            window: editor.into(),
@@ -276,8 +278,16 @@ impl EditorTestContext {
        snapshot.anchor_before(ranges[0].start)..snapshot.anchor_after(ranges[0].end)
    }

-    pub fn set_diff_base(&mut self, diff_base: Option<&str>) {
-        self.update_buffer(|buffer, cx| buffer.set_diff_base(diff_base.map(ToOwned::to_owned), cx));
+    pub fn set_diff_base(&mut self, diff_base: &str) {
+        self.cx.run_until_parked();
+        let fs = self
+            .update_editor(|editor, cx| editor.project.as_ref().unwrap().read(cx).fs().as_fake());
+        let path = self.update_buffer(|buffer, _| buffer.file().unwrap().path().clone());
+        fs.set_index_for_repo(
+            &Self::root_path().join(".git"),
+            &[(path.as_ref(), diff_base.to_string())],
+        );
+        self.cx.run_until_parked();
    }

    /// Change the editor's text and selections using a string containing
@@ -319,10 +329,12 @@ impl EditorTestContext {
        state_context
    }

+    /// Assert about the text of the editor, the selections, and the expanded
+    /// diff hunks.
+    ///
+    /// Diff hunks are indicated by lines starting with `+` and `-`.
    #[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.
+    pub fn assert_state_with_diff(&mut self, expected_diff: String) {
        let has_diff_markers = expected_diff
            .lines()
            .any(|line| line.starts_with("+") || line.starts_with("-"));
@@ -340,11 +352,14 @@ impl EditorTestContext {
            })
            .join("\n");

+        let actual_selections = self.editor_selections();
+        let actual_marked_text =
+            generate_marked_text(&self.buffer_text(), &actual_selections, true);
+
        // 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, _)| {
@@ -354,7 +369,7 @@ impl EditorTestContext {
                })
                .collect::<Vec<_>>();
            let deletions = editor
-                .expanded_hunks
+                .diff_map
                .hunks
                .iter()
                .filter_map(|hunk| {
@@ -371,10 +386,20 @@ impl EditorTestContext {
                        .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()
+                    let buffer_id = buffer.read(cx).remote_id();
+                    let change_set = &editor
+                        .diff_map
+                        .diff_bases
+                        .get(&buffer_id)
                        .expect("should have a diff base for expanded hunk")
+                        .change_set;
+                    let deleted_text = change_set
+                        .read(cx)
+                        .base_text
+                        .as_ref()
+                        .expect("no base text for expanded hunk")
+                        .read(cx)
+                        .as_rope()
                        .slice(hunk.diff_base_byte_range.clone())
                        .to_string();
                    if let DiffHunkStatus::Modified | DiffHunkStatus::Removed = hunk.status {
@@ -384,7 +409,7 @@ impl EditorTestContext {
                    }
                })
                .collect::<Vec<_>>();
-            format_diff(text, deletions, insertions)
+            format_diff(actual_marked_text, deletions, insertions)
        });

        pretty_assertions::assert_eq!(actual_diff, expected_diff_text, "unexpected diff state");
--- a/crates/extension/src/extension_host_proxy.rs
+++ b/crates/extension/src/extension_host_proxy.rs
@@ -159,6 +159,7 @@ pub trait ExtensionLanguageProxy: Send + Sync + 'static {
        language: LanguageName,
        grammar: Option<Arc<str>>,
        matcher: LanguageMatcher,
+        hidden: bool,
        load: Arc<dyn Fn() -> Result<LoadedLanguage> + Send + Sync + 'static>,
    );

@@ -175,13 +176,14 @@ impl ExtensionLanguageProxy for ExtensionHostProxy {
        language: LanguageName,
        grammar: Option<Arc<str>>,
        matcher: LanguageMatcher,
+        hidden: bool,
        load: Arc<dyn Fn() -> Result<LoadedLanguage> + Send + Sync + 'static>,
    ) {
        let Some(proxy) = self.language_proxy.read().clone() else {
            return;
        };

-        proxy.register_language(language, grammar, matcher, load)
+        proxy.register_language(language, grammar, matcher, hidden, load)
    }

    fn remove_languages(
--- a/crates/extension_host/src/extension_host.rs
+++ b/crates/extension_host/src/extension_host.rs
@@ -162,6 +162,7 @@ pub struct ExtensionIndexLanguageEntry {
    pub extension: Arc<str>,
    pub path: PathBuf,
    pub matcher: LanguageMatcher,
+    pub hidden: bool,
    pub grammar: Option<Arc<str>>,
 }

@@ -1097,6 +1098,7 @@ impl ExtensionStore {
                language_name.clone(),
                language.grammar.clone(),
                language.matcher.clone(),
+                language.hidden,
                Arc::new(move || {
                    let config = std::fs::read_to_string(language_path.join("config.toml"))?;
                    let config: LanguageConfig = ::toml::from_str(&config)?;
@@ -1324,6 +1326,7 @@ impl ExtensionStore {
                        extension: extension_id.clone(),
                        path: relative_path,
                        matcher: config.matcher,
+                        hidden: config.hidden,
                        grammar: config.grammar,
                    },
                );
--- a/crates/extension_host/src/extension_store_test.rs
+++ b/crates/extension_host/src/extension_store_test.rs
@@ -203,6 +203,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                    extension: "zed-ruby".into(),
                    path: "languages/erb".into(),
                    grammar: Some("embedded_template".into()),
+                    hidden: false,
                    matcher: LanguageMatcher {
                        path_suffixes: vec!["erb".into()],
                        first_line_pattern: None,
@@ -215,6 +216,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                    extension: "zed-ruby".into(),
                    path: "languages/ruby".into(),
                    grammar: Some("ruby".into()),
+                    hidden: false,
                    matcher: LanguageMatcher {
                        path_suffixes: vec!["rb".into()],
                        first_line_pattern: None,
--- a/crates/extension_host/src/headless_host.rs
+++ b/crates/extension_host/src/headless_host.rs
@@ -156,6 +156,7 @@ impl HeadlessExtensionStore {
                    config.name.clone(),
                    None,
                    config.matcher.clone(),
+                    config.hidden,
                    Arc::new(move || {
                        Ok(LoadedLanguage {
                            config: config.clone(),
--- a/crates/extensions_ui/src/extensions_ui.rs
+++ b/crates/extensions_ui/src/extensions_ui.rs
@@ -14,7 +14,7 @@ use editor::{Editor, EditorElement, EditorStyle};
 use extension_host::{ExtensionManifest, ExtensionOperation, ExtensionStore};
 use fuzzy::{match_strings, StringMatchCandidate};
 use gpui::{
-    actions, uniform_list, Action, AppContext, EventEmitter, Flatten, FocusableView,
+    actions, uniform_list, Action, AppContext, ClipboardItem, EventEmitter, Flatten, FocusableView,
    InteractiveElement, KeyContext, ParentElement, Render, Styled, Task, TextStyle,
    UniformListScrollHandle, View, ViewContext, VisualContext, WeakView, WindowContext,
 };
@@ -637,13 +637,21 @@ impl ExtensionsPage {
        cx: &mut WindowContext,
    ) -> View<ContextMenu> {
        let context_menu = ContextMenu::build(cx, |context_menu, cx| {
-            context_menu.entry(
-                "Install Another Version...",
-                None,
-                cx.handler_for(this, move |this, cx| {
-                    this.show_extension_version_list(extension_id.clone(), cx)
-                }),
-            )
+            context_menu
+                .entry(
+                    "Install Another Version...",
+                    None,
+                    cx.handler_for(this, {
+                        let extension_id = extension_id.clone();
+                        move |this, cx| this.show_extension_version_list(extension_id.clone(), cx)
+                    }),
+                )
+                .entry("Copy Extension ID", None, {
+                    let extension_id = extension_id.clone();
+                    move |cx| {
+                        cx.write_to_clipboard(ClipboardItem::new_string(extension_id.to_string()));
+                    }
+                })
        });

        context_menu
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -1,7 +1,7 @@
 #[cfg(test)]
 mod file_finder_tests;

-mod file_finder_settings;
+pub mod file_finder_settings;
 mod new_path_prompt;
 mod open_path_prompt;

@@ -648,7 +648,7 @@ impl FileFinderDelegate {
        cx.subscribe(project, |file_finder, _, event, cx| {
            match event {
                project::Event::WorktreeUpdatedEntries(_, _)
-                | project::Event::WorktreeAdded
+                | project::Event::WorktreeAdded(_)
                | project::Event::WorktreeRemoved(_) => file_finder
                    .picker
                    .update(cx, |picker, cx| picker.refresh(cx)),
--- a/crates/fs/src/fs.rs
+++ b/crates/fs/src/fs.rs
@@ -132,7 +132,7 @@ pub trait Fs: Send + Sync {
    async fn is_case_sensitive(&self) -> Result<bool>;

    #[cfg(any(test, feature = "test-support"))]
-    fn as_fake(&self) -> &FakeFs {
+    fn as_fake(&self) -> Arc<FakeFs> {
        panic!("called as_fake on a real fs");
    }
 }
@@ -840,6 +840,7 @@ impl Watcher for RealWatcher {

 #[cfg(any(test, feature = "test-support"))]
 pub struct FakeFs {
+    this: std::sync::Weak<Self>,
    // Use an unfair lock to ensure tests are deterministic.
    state: Mutex<FakeFsState>,
    executor: gpui::BackgroundExecutor,
@@ -1022,7 +1023,8 @@ impl FakeFs {
    pub fn new(executor: gpui::BackgroundExecutor) -> Arc<Self> {
        let (tx, mut rx) = smol::channel::bounded::<PathBuf>(10);

-        let this = Arc::new(Self {
+        let this = Arc::new_cyclic(|this| Self {
+            this: this.clone(),
            executor: executor.clone(),
            state: Mutex::new(FakeFsState {
                root: Arc::new(Mutex::new(FakeFsEntry::Dir {
@@ -1474,7 +1476,8 @@ struct FakeHandle {
 #[cfg(any(test, feature = "test-support"))]
 impl FileHandle for FakeHandle {
    fn current_path(&self, fs: &Arc<dyn Fs>) -> Result<PathBuf> {
-        let state = fs.as_fake().state.lock();
+        let fs = fs.as_fake();
+        let state = fs.state.lock();
        let Some(target) = state.moves.get(&self.inode) else {
            anyhow::bail!("fake fd not moved")
        };
@@ -1970,8 +1973,8 @@ impl Fs for FakeFs {
    }

    #[cfg(any(test, feature = "test-support"))]
-    fn as_fake(&self) -> &FakeFs {
-        self
+    fn as_fake(&self) -> Arc<FakeFs> {
+        self.this.upgrade().unwrap()
    }
 }

--- a/crates/git/Cargo.toml
+++ b/crates/git/Cargo.toml
@@ -14,7 +14,6 @@ path = "src/git.rs"
 [dependencies]
 anyhow.workspace = true
 async-trait.workspace = true
-clock.workspace = true
 collections.workspace = true
 derive_more.workspace = true
 git2.workspace = true
@@ -22,6 +21,7 @@ gpui.workspace = true
 http_client.workspace = true
 log.workspace = true
 parking_lot.workspace = true
+regex.workspace = true
 rope.workspace = true
 serde.workspace = true
 smol.workspace = true
--- a/crates/git/src/diff.rs
+++ b/crates/git/src/diff.rs
@@ -64,23 +64,37 @@ impl sum_tree::Summary for DiffHunkSummary {

 #[derive(Debug, Clone)]
 pub struct BufferDiff {
-    last_buffer_version: Option<clock::Global>,
    tree: SumTree<InternalDiffHunk>,
 }

 impl BufferDiff {
    pub fn new(buffer: &BufferSnapshot) -> BufferDiff {
        BufferDiff {
-            last_buffer_version: None,
            tree: SumTree::new(buffer),
        }
    }

+    pub async fn build(diff_base: &str, buffer: &text::BufferSnapshot) -> Self {
+        let mut tree = SumTree::new(buffer);
+
+        let buffer_text = buffer.as_rope().to_string();
+        let patch = Self::diff(diff_base, &buffer_text);
+
+        if let Some(patch) = patch {
+            let mut divergence = 0;
+            for hunk_index in 0..patch.num_hunks() {
+                let hunk = Self::process_patch_hunk(&patch, hunk_index, buffer, &mut divergence);
+                tree.push(hunk, buffer);
+            }
+        }
+
+        Self { tree }
+    }
+
    pub fn is_empty(&self) -> bool {
        self.tree.is_empty()
    }

-    #[cfg(any(test, feature = "test-support"))]
    pub fn hunks_in_row_range<'a>(
        &'a self,
        range: Range<u32>,
@@ -169,27 +183,11 @@ impl BufferDiff {

    #[cfg(test)]
    fn clear(&mut self, buffer: &text::BufferSnapshot) {
-        self.last_buffer_version = Some(buffer.version().clone());
        self.tree = SumTree::new(buffer);
    }

    pub async fn update(&mut self, diff_base: &Rope, buffer: &text::BufferSnapshot) {
-        let mut tree = SumTree::new(buffer);
-
-        let diff_base_text = diff_base.to_string();
-        let buffer_text = buffer.as_rope().to_string();
-        let patch = Self::diff(&diff_base_text, &buffer_text);
-
-        if let Some(patch) = patch {
-            let mut divergence = 0;
-            for hunk_index in 0..patch.num_hunks() {
-                let hunk = Self::process_patch_hunk(&patch, hunk_index, buffer, &mut divergence);
-                tree.push(hunk, buffer);
-            }
-        }
-
-        self.tree = tree;
-        self.last_buffer_version = Some(buffer.version().clone());
+        *self = Self::build(&diff_base.to_string(), buffer).await;
    }

    #[cfg(test)]
--- a/crates/git/src/remote.rs
+++ b/crates/git/src/remote.rs
@@ -1,17 +1,23 @@
+use std::sync::LazyLock;
+
 use derive_more::Deref;
+use regex::Regex;
 use url::Url;

 /// The URL to a Git remote.
 #[derive(Debug, PartialEq, Eq, Clone, Deref)]
 pub struct RemoteUrl(Url);

+static USERNAME_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^[0-9a-zA-Z\-_]+@").expect("Failed to create USERNAME_REGEX"));
+
 impl std::str::FromStr for RemoteUrl {
    type Err = url::ParseError;

    fn from_str(input: &str) -> Result<Self, Self::Err> {
-        if input.starts_with("git@") {
+        if USERNAME_REGEX.is_match(input) {
            // Rewrite remote URLs like `git@github.com:user/repo.git` to `ssh://git@github.com/user/repo.git`
-            let ssh_url = input.replacen(':', "/", 1).replace("git@", "ssh://git@");
+            let ssh_url = format!("ssh://{}", input.replacen(':', "/", 1));
            Ok(RemoteUrl(Url::parse(&ssh_url)?))
        } else {
            Ok(RemoteUrl(Url::parse(input)?))
@@ -40,6 +46,12 @@ mod tests {
                "github.com",
                "/octocat/zed.git",
            ),
+            (
+                "org-000000@github.com:octocat/zed.git",
+                "ssh",
+                "github.com",
+                "/octocat/zed.git",
+            ),
            (
                "ssh://git@github.com/octocat/zed.git",
                "ssh",
--- a/crates/gpui/Cargo.toml
+++ b/crates/gpui/Cargo.toml
@@ -80,7 +80,7 @@ gpui_macros.workspace = true
 http_client = { optional = true, workspace = true }
 image = "0.25.1"
 itertools.workspace = true
-linkme = "0.3"
+linkme.workspace = true
 log.workspace = true
 num_cpus = "1.13"
 parking = "2.0.0"
--- a/crates/gpui/build.rs
+++ b/crates/gpui/build.rs
@@ -50,6 +50,7 @@ mod macos {

    fn generate_dispatch_bindings() {
        println!("cargo:rustc-link-lib=framework=System");
+        println!("cargo:rustc-link-lib=framework=ScreenCaptureKit");
        println!("cargo:rerun-if-changed=src/platform/mac/dispatch.h");

        let bindings = bindgen::Builder::default()
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -33,8 +33,8 @@ use crate::{
    Entity, EventEmitter, ForegroundExecutor, Global, KeyBinding, Keymap, Keystroke, LayoutId,
    Menu, MenuItem, OwnedMenu, PathPromptOptions, Pixels, Platform, PlatformDisplay, Point,
    PromptBuilder, PromptHandle, PromptLevel, Render, RenderablePromptHandle, Reservation,
-    SharedString, SubscriberSet, Subscription, SvgRenderer, Task, TextSystem, View, ViewContext,
-    Window, WindowAppearance, WindowContext, WindowHandle, WindowId,
+    ScreenCaptureSource, SharedString, SubscriberSet, Subscription, SvgRenderer, Task, TextSystem,
+    View, ViewContext, Window, WindowAppearance, WindowContext, WindowHandle, WindowId,
 };

 mod async_context;
@@ -599,6 +599,13 @@ impl AppContext {
        self.platform.primary_display()
    }

+    /// Returns a list of available screen capture sources.
+    pub fn screen_capture_sources(
+        &self,
+    ) -> oneshot::Receiver<Result<Vec<Box<dyn ScreenCaptureSource>>>> {
+        self.platform.screen_capture_sources()
+    }
+
    /// Returns the display with the given ID, if one exists.
    pub fn find_display(&self, id: DisplayId) -> Option<Rc<dyn PlatformDisplay>> {
        self.displays()
--- a/Show More
+++ b/Show More