linux:Add zed:// url support

Allow rpc_url to be assigned on Client with test-support feature (#13430 )
Also, allow proto messages to be deserialized. This is to support translating these messages JS types in a new server implementation based on CloudFlare durable objects. Release Notes: - N/A
2024-07-10 14:45:41 -06:00 · 2024-07-10 13:36:22 -06:00 · 2024-07-10 15:33:35 -04:00 · 2024-07-10 13:10:19 -06:00 · 2024-07-10 12:51:08 -06:00 · 2024-07-10 12:08:54 -06:00
258 changed files with 13761 additions and 11126 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,6 +1,13 @@
+.git
+.github
+**/.gitignore
+**/.gitkeep
+.gitattributes
+.mailmap
 **/target
 zed.xcworkspace
 .DS_Store
+compose.yml
 plugins/bin
 script/node_modules
 styles/node_modules
--- a/.github/ISSUE_TEMPLATE/1_bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/1_bug_report.yml
@@ -32,9 +32,10 @@ body:
      required: false
  - type: textarea
    attributes:
-      label: If applicable, attach your `~/Library/Logs/Zed/Zed.log` file to this issue.
+      label: If applicable, attach your Zed.log file to this issue.
      description: |
-        Drag Zed.log into the text input below.
+        macOS: `~/Library/Logs/Zed/Zed.log`
+        Linux: `~/.local/share/zed/logs/Zed.log` or $XDG_DATA_HOME
        If you only need the most recent lines, you can run the `zed: open log` command palette action to see the last 1000.
      value: |
        <details><summary>Zed.log</summary><pre>
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -2,7 +2,7 @@

 Release Notes:

- Added/Fixed/Improved ... ([#<public_issue_number_if_exists>](https://github.com/zed-industries/zed/issues/<public_issue_number_if_exists>)).
+- Added/Fixed/Improved ... ([#NNNNN](https://github.com/zed-industries/zed/issues/NNNNN)).

 Optionally, include screenshots / media showcasing your addition that can be included in the release notes.

--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+/.direnv
 .idea
 **/target
 **/cargo-target
--- a/.zed/settings.json
+++ b/.zed/settings.json
@@ -14,6 +14,12 @@
    },
    "JSON": {
      "tab_size": 2,
+      "preferred_line_length": 100,
+      "formatter": "prettier"
+    },
+    "JSONC": {
+      "tab_size": 2,
+      "preferred_line_length": 100,
      "formatter": "prettier"
    },
    "JavaScript": {
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -373,16 +373,17 @@ dependencies = [
 "anyhow",
 "assistant_slash_command",
 "async-watch",
+ "breadcrumbs",
 "cargo_toml",
 "chrono",
 "client",
+ "clock",
 "collections",
 "command_palette_hooks",
 "ctor",
 "editor",
 "env_logger",
 "feature_flags",
- "file_icons",
 "fs",
 "futures 0.3.28",
 "fuzzy",
@@ -419,6 +420,7 @@ dependencies = [
 "telemetry_events",
 "terminal",
 "terminal_view",
+ "text",
 "theme",
 "tiktoken-rs",
 "toml 0.8.10",
@@ -2405,6 +2407,7 @@ version = "0.1.0"
 dependencies = [
 "chrono",
 "parking_lot",
+ "serde",
 "smallvec",
 ]

@@ -2463,6 +2466,7 @@ version = "0.44.0"
 dependencies = [
 "anthropic",
 "anyhow",
+ "assistant",
 "async-trait",
 "async-tungstenite",
 "audio",
@@ -3932,6 +3936,7 @@ dependencies = [
 "serde_json",
 "serde_json_lenient",
 "settings",
+ "snippet_provider",
 "task",
 "theme",
 "toml 0.8.10",
@@ -7355,6 +7360,7 @@ dependencies = [
 "db",
 "editor",
 "file_icons",
+ "fuzzy",
 "gpui",
 "itertools 0.11.0",
 "language",
@@ -8040,6 +8046,7 @@ dependencies = [
 "similar",
 "smol",
 "snippet",
+ "snippet_provider",
 "task",
 "tempfile",
 "terminal",
@@ -8267,6 +8274,7 @@ dependencies = [
 "assistant",
 "editor",
 "gpui",
+ "repl",
 "search",
 "settings",
 "ui",
@@ -8493,7 +8501,7 @@ dependencies = [
 "task",
 "terminal_view",
 "ui",
- "ui_text_field",
+ "ui_input",
 "util",
 "workspace",
 ]
@@ -9856,6 +9864,22 @@ dependencies = [
 "smallvec",
 ]

+[[package]]
+name = "snippet_provider"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "collections",
+ "fs",
+ "futures 0.3.28",
+ "gpui",
+ "parking_lot",
+ "serde",
+ "serde_json",
+ "snippet",
+ "util",
+]
+
 [[package]]
 name = "socket2"
 version = "0.4.9"
@@ -10236,6 +10260,7 @@ dependencies = [
 "story",
 "strum",
 "theme",
+ "title_bar",
 "ui",
 ]

@@ -11691,7 +11716,7 @@ dependencies = [
 ]

 [[package]]
-name = "ui_text_field"
+name = "ui_input"
 version = "0.1.0"
 dependencies = [
 "editor",
@@ -13561,7 +13586,7 @@ dependencies = [

 [[package]]
 name = "zed"
-version = "0.143.7"
+version = "0.145.0"
 dependencies = [
 "activity_indicator",
 "anyhow",
@@ -13636,6 +13661,7 @@ dependencies = [
 "settings",
 "simplelog",
 "smol",
+ "snippet_provider",
 "supermaven",
 "tab_switcher",
 "task",
@@ -13674,9 +13700,9 @@ dependencies = [

 [[package]]
 name = "zed_clojure"
-version = "0.0.2"
+version = "0.0.3"
 dependencies = [
- "zed_extension_api 0.0.4",
+ "zed_extension_api 0.0.6",
 ]

 [[package]]
@@ -13788,14 +13814,14 @@ dependencies = [

 [[package]]
 name = "zed_lua"
-version = "0.0.2"
+version = "0.0.3"
 dependencies = [
 "zed_extension_api 0.0.6",
 ]

 [[package]]
 name = "zed_ocaml"
-version = "0.0.1"
+version = "0.0.2"
 dependencies = [
 "zed_extension_api 0.0.6",
 ]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -88,6 +88,7 @@ members = [
    "crates/semantic_version",
    "crates/settings",
    "crates/snippet",
+    "crates/snippet_provider",
    "crates/sqlez",
    "crates/sqlez_macros",
    "crates/story",
@@ -108,7 +109,7 @@ members = [
    "crates/time_format",
    "crates/title_bar",
    "crates/ui",
-    "crates/ui_text_field",
+    "crates/ui_input",
    "crates/util",
    "crates/vcs_menu",
    "crates/vim",
@@ -239,6 +240,7 @@ semantic_index = { path = "crates/semantic_index" }
 semantic_version = { path = "crates/semantic_version" }
 settings = { path = "crates/settings" }
 snippet = { path = "crates/snippet" }
+snippet_provider = { path = "crates/snippet_provider" }
 sqlez = { path = "crates/sqlez" }
 sqlez_macros = { path = "crates/sqlez_macros" }
 story = { path = "crates/story" }
@@ -259,7 +261,7 @@ theme_selector = { path = "crates/theme_selector" }
 time_format = { path = "crates/time_format" }
 title_bar = { path = "crates/title_bar" }
 ui = { path = "crates/ui" }
-ui_text_field = { path = "crates/ui_text_field" }
+ui_input = { path = "crates/ui_input" }
 util = { path = "crates/util" }
 vcs_menu = { path = "crates/vcs_menu" }
 vim = { path = "crates/vim" }
@@ -516,7 +518,7 @@ single_range_in_vec_init = "allow"

 # There are a bunch of rules currently failing in the `style` group, so
 # allow all of those, for now.
-style = "allow"
+style = { level = "allow", priority = -1 }

 # Individual rules that have violations in the codebase:
 almost_complete_range = "allow"
--- a/README.md
+++ b/README.md
@@ -4,42 +4,36 @@

 Welcome to Zed, a high-performance, multiplayer code editor from the creators of [Atom](https://github.com/atom/atom) and [Tree-sitter](https://github.com/tree-sitter/tree-sitter).

-## Installation
+--------

-You can [download](https://zed.dev/download) Zed today for macOS (v10.15+).
+### Installation

-Support for additional platforms is on our [roadmap](https://zed.dev/roadmap):

- Linux ([tracking issue](https://github.com/zed-industries/zed/issues/7015))
+<a href="https://repology.org/project/zed-editor/versions">
+    <img src="https://repology.org/badge/vertical-allrepos/zed-editor.svg?minversion=0.143.5" alt="Packaging status" align="right">
+</a>
+
+On macOS and Linux you can [download Zed directly](https://zed.dev/download) or [install Zed via your local package manager](https://zed.dev/docs/linux#installing-via-a-package-manager).
+
+Other platforms are not yet available:
+
 - Windows ([tracking issue](https://github.com/zed-industries/zed/issues/5394))
 - Web ([tracking issue](https://github.com/zed-industries/zed/issues/5396))

-For macOS users, you can also install Zed using [Homebrew](https://brew.sh/):
-
-```sh
-brew install --cask zed
-```
-
-Alternatively, to install the Preview release:
-
-```sh
-brew install --cask zed@preview
-```
-
-## Developing Zed
+### Developing Zed

 - [Building Zed for macOS](./docs/src/development/macos.md)
 - [Building Zed for Linux](./docs/src/development/linux.md)
 - [Building Zed for Windows](./docs/src/development/windows.md)
 - [Running Collaboration Locally](./docs/src/development/local-collaboration.md)

-## Contributing
+### Contributing

 See [CONTRIBUTING.md](./CONTRIBUTING.md) for ways you can contribute to Zed.

 Also... we're hiring! Check out our [jobs](https://zed.dev/jobs) page for open roles.

-## Licensing
+### Licensing

 License information for third party dependencies must be correctly provided for CI to pass.

--- a/assets/icons/repl_neutral.svg
+++ b/assets/icons/repl_neutral.svg
@@ -0,0 +1,14 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_32_58)">
+<path d="M19 7C20.1046 7 21 6.10457 21 5C21 3.89543 20.1046 3 19 3C17.8954 3 17 3.89543 17 5C17 6.10457 17.8954 7 19 7Z" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M5 21C6.10457 21 7 20.1046 7 19C7 17.8954 6.10457 17 5 17C3.89543 17 3 17.8954 3 19C3 20.1046 3.89543 21 5 21Z" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M10.3999 21.9C12.3227 22.2159 14.2958 21.9632 16.0769 21.173C17.858 20.3827 19.3694 19.0893 20.4254 17.4517C21.4814 15.8142 22.036 13.9037 22.021 11.9553C22.006 10.0068 21.422 8.10512 20.3409 6.48401" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M13.4998 2.10002C11.5849 1.8076 9.62631 2.07763 7.86198 2.87732C6.09765 3.677 4.60356 4.9719 3.56126 6.60468C2.51896 8.23745 1.97332 10.1378 1.99063 12.0748C2.00795 14.0118 2.58749 15.9021 3.65882 17.516" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M12 13C12.5523 13 13 12.5523 13 12C13 11.4477 12.5523 11 12 11C11.4477 11 11 11.4477 11 12C11 12.5523 11.4477 13 12 13Z" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+</g>
+<defs>
+<clipPath id="clip0_32_58">
+<rect width="24" height="24" fill="white"/>
+</clipPath>
+</defs>
+</svg>
--- a/assets/icons/repl_off.svg
+++ b/assets/icons/repl_off.svg
@@ -0,0 +1,20 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_39_129)">
+<path d="M22.0209 11.9553C22.0059 10.0068 21.4219 8.10512 20.3408 6.48401" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M10.1001 2.18C11.355 1.93537 12.1493 1.93674 13.5027 2.10594" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M21.8198 10.1C22.0644 11.3548 22.0644 12.6451 21.8198 13.9" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M20.2898 17.6C19.5716 18.6622 18.6548 19.5757 17.5898 20.29" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M13.9008 21.82C12.6459 22.0644 11.6432 22.1543 10.3883 21.91" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M2.18005 13.9C1.93543 12.6451 1.93543 11.3548 2.18005 10.1" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M3.70996 6.40002C4.42822 5.33775 5.34503 4.42433 6.40996 3.71002" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M12 13C12.5523 13 13 12.5523 13 12C13 11.4477 12.5523 11 12 11C11.4477 11 11 11.4477 11 12C11 12.5523 11.4477 13 12 13Z" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M19 7C20.1046 7 21 6.10457 21 5C21 3.89543 20.1046 3 19 3C17.8954 3 17 3.89543 17 5C17 6.10457 17.8954 7 19 7Z" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M5 21C6.10457 21 7 20.1046 7 19C7 17.8954 6.10457 17 5 17C3.89543 17 3 17.8954 3 19C3 20.1046 3.89543 21 5 21Z" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M1.99072 12.0748C2.00804 14.0118 2.58758 15.9021 3.65891 17.516" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+</g>
+<defs>
+<clipPath id="clip0_39_129">
+<rect width="24" height="24" fill="white"/>
+</clipPath>
+</defs>
+</svg>
--- a/assets/icons/repl_pause.svg
+++ b/assets/icons/repl_pause.svg
@@ -0,0 +1,15 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_32_70)">
+<path d="M19 7C20.1046 7 21 6.10457 21 5C21 3.89543 20.1046 3 19 3C17.8954 3 17 3.89543 17 5C17 6.10457 17.8954 7 19 7Z" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M5 21C6.10457 21 7 20.1046 7 19C7 17.8954 6.10457 17 5 17C3.89543 17 3 17.8954 3 19C3 20.1046 3.89543 21 5 21Z" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M10.3999 21.9C12.3227 22.2159 14.2958 21.9632 16.0769 21.173C17.858 20.3827 19.3694 19.0893 20.4254 17.4517C21.4814 15.8142 22.036 13.9037 22.021 11.9553C22.006 10.0068 21.422 8.10512 20.3409 6.48401" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M13.4998 2.10002C11.5849 1.8076 9.62631 2.07763 7.86198 2.87732C6.09765 3.677 4.60356 4.9719 3.56126 6.60468C2.51896 8.23745 1.97332 10.1378 1.99063 12.0748C2.00795 14.0118 2.58749 15.9021 3.65882 17.516" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M10 15V9" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M14 15V9" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+</g>
+<defs>
+<clipPath id="clip0_32_70">
+<rect width="24" height="24" fill="white"/>
+</clipPath>
+</defs>
+</svg>
--- a/assets/icons/repl_play.svg
+++ b/assets/icons/repl_play.svg
@@ -0,0 +1,14 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_32_64)">
+<path d="M19 7C20.1046 7 21 6.10457 21 5C21 3.89543 20.1046 3 19 3C17.8954 3 17 3.89543 17 5C17 6.10457 17.8954 7 19 7Z" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M5 21C6.10457 21 7 20.1046 7 19C7 17.8954 6.10457 17 5 17C3.89543 17 3 17.8954 3 19C3 20.1046 3.89543 21 5 21Z" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M10.3999 21.9C12.3227 22.2159 14.2958 21.9632 16.0769 21.173C17.858 20.3827 19.3694 19.0893 20.4254 17.4517C21.4814 15.8142 22.036 13.9037 22.021 11.9553C22.006 10.0068 21.422 8.10512 20.3409 6.48401" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M13.4998 2.10002C11.5849 1.8076 9.62631 2.07763 7.86198 2.87732C6.09765 3.677 4.60356 4.9719 3.56126 6.60468C2.51896 8.23745 1.97332 10.1378 1.99063 12.0748C2.00795 14.0118 2.58749 15.9021 3.65882 17.516" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M10 8.56055C10 8.32095 10.267 8.17803 10.4664 8.31094L15.6256 11.7504C15.8037 11.8691 15.8037 12.1309 15.6256 12.2496L10.4664 15.6891C10.267 15.822 10 15.6791 10 15.4394V8.56055Z" fill="white" stroke="white" stroke-linecap="round" stroke-linejoin="round"/>
+</g>
+<defs>
+<clipPath id="clip0_32_64">
+<rect width="24" height="24" fill="white"/>
+</clipPath>
+</defs>
+</svg>
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -20,18 +20,8 @@
      "ctrl-escape": "menu::Cancel",
      "ctrl-c": "menu::Cancel",
      "shift-enter": "picker::UseSelectedQuery",
-      "alt-enter": [
-        "picker::ConfirmInput",
-        {
-          "secondary": false
-        }
-      ],
-      "ctrl-alt-enter": [
-        "picker::ConfirmInput",
-        {
-          "secondary": true
-        }
-      ],
+      "alt-enter": ["picker::ConfirmInput", { "secondary": false }],
+      "ctrl-alt-enter": ["picker::ConfirmInput", { "secondary": true }],
      "ctrl-shift-w": "workspace::CloseWindow",
      "shift-escape": "workspace::ToggleZoom",
      "ctrl-o": "workspace::Open",
@@ -58,6 +48,7 @@
      // "ctrl-t": "editor::Transpose",
      "ctrl-backspace": "editor::DeleteToPreviousWordStart",
      "ctrl-delete": "editor::DeleteToNextWordEnd",
+      "shift-delete": "editor::Cut",
      "ctrl-x": "editor::Cut",
      "ctrl-insert": "editor::Copy",
      "ctrl-c": "editor::Copy",
@@ -97,54 +88,19 @@
      "ctrl-a": "editor::SelectAll",
      "ctrl-l": "editor::SelectLine",
      "ctrl-shift-i": "editor::Format",
-      // "cmd-shift-left": [
-      //   "editor::SelectToBeginningOfLine",
-      //   {
-      //     "stop_at_soft_wraps": true
-      //   }
-      // ],
-      "shift-home": [
-        "editor::SelectToBeginningOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      // "ctrl-shift-a": [
-      //   "editor::SelectToBeginningOfLine",
-      //   {
-      //     "stop_at_soft_wraps": true
-      //   }
-      // ],
-      // "cmd-shift-right": [
-      //   "editor::SelectToEndOfLine",
-      //   {
-      //     "stop_at_soft_wraps": true
-      //   }
-      // ],
-      "shift-end": [
-        "editor::SelectToEndOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      // "ctrl-shift-e": [
-      //   "editor::SelectToEndOfLine",
-      //   {
-      //     "stop_at_soft_wraps": true
-      //   }
-      // ],
-      // "alt-v": [
-      //   "editor::MovePageUp",
-      //   {
-      //     "center_cursor": true
-      //   }
-      // ],
+      // "cmd-shift-left": ["editor::SelectToBeginningOfLine", {"stop_at_soft_wraps": true }],
+      "shift-home": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true }],
+      // "ctrl-shift-a": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true }],
+      // "cmd-shift-right": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
+      "shift-end": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
+      // "ctrl-shift-e": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
+      // "alt-v": ["editor::MovePageUp", { "center_cursor": true }],
      "ctrl-alt-space": "editor::ShowCharacterPalette",
      "ctrl-;": "editor::ToggleLineNumbers",
      "ctrl-k ctrl-r": "editor::RevertSelectedHunks",
      "ctrl-'": "editor::ToggleHunkDiff",
      "ctrl-\"": "editor::ExpandAllHunkDiffs",
-      "ctrl-alt-g b": "editor::ToggleGitBlame"
+      "alt-g b": "editor::ToggleGitBlame"
    }
  },
  {
@@ -156,12 +112,7 @@
      "ctrl-enter": "editor::NewlineAbove",
      "alt-z": "editor::ToggleSoftWrap",
      "ctrl-f": "buffer_search::Deploy",
-      "ctrl-h": [
-        "buffer_search::Deploy",
-        {
-          "replace_enabled": true
-        }
-      ],
+      "ctrl-h": ["buffer_search::Deploy", { "replace_enabled": true }],
      // "cmd-e": ["buffer_search::Deploy", { "focus": false }],
      "ctrl->": "assistant::QuoteSelection",
      "ctrl-<": "assistant::InsertIntoEditor",
@@ -320,38 +271,13 @@
      "ctrl-shift-right": "editor::SelectToNextWordEnd",
      "ctrl-shift-up": "editor::SelectLargerSyntaxNode", //todo(linux) tmp keybinding
      "ctrl-shift-down": "editor::SelectSmallerSyntaxNode", //todo(linux) tmp keybinding
-      "ctrl-d": [
-        "editor::SelectNext",
-        {
-          "replace_newest": false
-        }
-      ],
+      "ctrl-d": ["editor::SelectNext", { "replace_newest": false }],
      "ctrl-shift-l": "editor::SelectAllMatches",
-      "ctrl-shift-d": [
-        "editor::SelectPrevious",
-        {
-          "replace_newest": false
-        }
-      ],
-      "ctrl-k ctrl-d": [
-        "editor::SelectNext",
-        {
-          "replace_newest": true
-        }
-      ],
-      "ctrl-k ctrl-shift-d": [
-        "editor::SelectPrevious",
-        {
-          "replace_newest": true
-        }
-      ],
+      "ctrl-shift-d": ["editor::SelectPrevious", { "replace_newest": false }],
+      "ctrl-k ctrl-d": ["editor::SelectNext", { "replace_newest": true }],
+      "ctrl-k ctrl-shift-d": ["editor::SelectPrevious", { "replace_newest": true }],
      "ctrl-k ctrl-i": "editor::Hover",
-      "ctrl-/": [
-        "editor::ToggleComments",
-        {
-          "advance_downwards": false
-        }
-      ],
+      "ctrl-/": ["editor::ToggleComments", { "advance_downwards": false }],
      "ctrl-u": "editor::UndoSelection",
      "ctrl-shift-u": "editor::RedoSelection",
      "f8": "editor::GoToDiagnostic",
@@ -400,7 +326,7 @@
      "alt-9": ["pane::ActivateItem", 8],
      "alt-0": "pane::ActivateLastItem",
      "ctrl-alt--": "pane::GoBack",
-      "ctrl-alt-_": "pane::GoForward",
+      "ctrl-alt-shift--": "pane::GoForward",
      "ctrl-shift-t": "pane::ReopenClosedItem",
      "f3": "search::SelectNextMatch",
      "shift-f3": "search::SelectPrevMatch",
@@ -435,23 +361,13 @@
      "ctrl-j": "workspace::ToggleBottomDock",
      "ctrl-alt-y": "workspace::CloseAllDocks",
      "ctrl-shift-f": "pane::DeploySearch",
-      "ctrl-shift-h": [
-        "pane::DeploySearch",
-        {
-          "replace_enabled": true
-        }
-      ],
+      "ctrl-shift-h": ["pane::DeploySearch", { "replace_enabled": true }],
      "ctrl-k ctrl-s": "zed::OpenKeymap",
      "ctrl-k ctrl-t": "theme_selector::Toggle",
      "ctrl-t": "project_symbols::Toggle",
      "ctrl-p": "file_finder::Toggle",
      "ctrl-tab": "tab_switcher::Toggle",
-      "ctrl-shift-tab": [
-        "tab_switcher::Toggle",
-        {
-          "select_last": true
-        }
-      ],
+      "ctrl-shift-tab": ["tab_switcher::Toggle", { "select_last": true }],
      "ctrl-e": "file_finder::Toggle",
      "ctrl-shift-p": "command_palette::Toggle",
      "f1": "command_palette::Toggle",
@@ -586,6 +502,7 @@
  {
    "context": "OutlinePanel",
    "bindings": {
+      "escape": "menu::Cancel",
      "left": "outline_panel::CollapseSelectedEntry",
      "right": "outline_panel::ExpandSelectedEntry",
      "ctrl-alt-c": "outline_panel::CopyPath",
@@ -657,9 +574,7 @@
  },
  {
    "context": "FileFinder",
-    "bindings": {
-      "ctrl-shift-p": "file_finder::SelectPrev"
-    }
+    "bindings": { "ctrl-shift-p": "file_finder::SelectPrev" }
  },
  {
    "context": "TabSwitcher",
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -113,54 +113,14 @@
      "cmd-a": "editor::SelectAll",
      "cmd-l": "editor::SelectLine",
      "cmd-shift-i": "editor::Format",
-      "cmd-shift-left": [
-        "editor::SelectToBeginningOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "shift-home": [
-        "editor::SelectToBeginningOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "ctrl-shift-a": [
-        "editor::SelectToBeginningOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "cmd-shift-right": [
-        "editor::SelectToEndOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "shift-end": [
-        "editor::SelectToEndOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "ctrl-shift-e": [
-        "editor::SelectToEndOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "ctrl-v": [
-        "editor::MovePageDown",
-        {
-          "center_cursor": true
-        }
-      ],
-      "alt-v": [
-        "editor::MovePageUp",
-        {
-          "center_cursor": true
-        }
-      ],
+      "cmd-shift-left": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true }],
+      "shift-home": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true }],
+      "ctrl-shift-a": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true }],
+      "cmd-shift-right": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
+      "shift-end": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
+      "ctrl-shift-e": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
+      "ctrl-v": ["editor::MovePageDown", { "center_cursor": true }],
+      "alt-v": ["editor::MovePageUp", { "center_cursor": true }],
      "ctrl-cmd-space": "editor::ShowCharacterPalette",
      "cmd-;": "editor::ToggleLineNumbers",
      "cmd-alt-z": "editor::RevertSelectedHunks",
@@ -175,32 +135,22 @@
      "enter": "editor::Newline",
      "shift-enter": "editor::Newline",
      "cmd-shift-enter": "editor::NewlineAbove",
-      "cmd-enter": "editor::NewlineBelow",
      "alt-z": "editor::ToggleSoftWrap",
      "cmd-f": "buffer_search::Deploy",
-      "cmd-alt-f": [
-        "buffer_search::Deploy",
-        {
-          "replace_enabled": true
-        }
-      ],
-      "cmd-alt-l": [
-        "buffer_search::Deploy",
-        {
-          "selection_search_enabled": true
-        }
-      ],
-      "cmd-e": [
-        "buffer_search::Deploy",
-        {
-          "focus": false
-        }
-      ],
+      "cmd-alt-f": ["buffer_search::Deploy", { "replace_enabled": true }],
+      "cmd-alt-l": ["buffer_search::Deploy", { "selection_search_enabled": true }],
+      "cmd-e": ["buffer_search::Deploy", { "focus": false }],
      "cmd->": "assistant::QuoteSelection",
      "cmd-<": "assistant::InsertIntoEditor",
      "cmd-alt-e": "editor::SelectEnclosingSymbol"
    }
  },
+  {
+    "context": "Editor && mode == full && !jupyter",
+    "bindings": {
+      "cmd-enter": "editor::NewlineBelow"
+    }
+  },
  {
    "context": "Editor && mode == full && inline_completion",
    "bindings": {
@@ -362,38 +312,13 @@
      "alt-shift-down": "editor::DuplicateLineDown",
      "ctrl-shift-right": "editor::SelectLargerSyntaxNode",
      "ctrl-shift-left": "editor::SelectSmallerSyntaxNode",
-      "cmd-d": [
-        "editor::SelectNext",
-        {
-          "replace_newest": false
-        }
-      ],
+      "cmd-d": ["editor::SelectNext", { "replace_newest": false }],
      "cmd-shift-l": "editor::SelectAllMatches",
-      "ctrl-cmd-d": [
-        "editor::SelectPrevious",
-        {
-          "replace_newest": false
-        }
-      ],
-      "cmd-k cmd-d": [
-        "editor::SelectNext",
-        {
-          "replace_newest": true
-        }
-      ],
-      "cmd-k ctrl-cmd-d": [
-        "editor::SelectPrevious",
-        {
-          "replace_newest": true
-        }
-      ],
+      "ctrl-cmd-d": ["editor::SelectPrevious", { "replace_newest": false }],
+      "cmd-k cmd-d": ["editor::SelectNext", { "replace_newest": true }],
+      "cmd-k ctrl-cmd-d": ["editor::SelectPrevious", { "replace_newest": true }],
      "cmd-k cmd-i": "editor::Hover",
-      "cmd-/": [
-        "editor::ToggleComments",
-        {
-          "advance_downwards": false
-        }
-      ],
+      "cmd-/": ["editor::ToggleComments", { "advance_downwards": false }],
      "cmd-u": "editor::UndoSelection",
      "cmd-shift-u": "editor::RedoSelection",
      "f8": "editor::GoToDiagnostic",
@@ -441,7 +366,7 @@
      "ctrl-9": ["pane::ActivateItem", 8],
      "ctrl-0": "pane::ActivateLastItem",
      "ctrl--": "pane::GoBack",
-      "ctrl-_": "pane::GoForward",
+      "ctrl-shift--": "pane::GoForward",
      "cmd-shift-t": "pane::ReopenClosedItem",
      "cmd-shift-f": "project_search::ToggleFocus"
    }
@@ -450,12 +375,7 @@
    "context": "Workspace",
    "bindings": {
      // Change the default action on `menu::Confirm` by setting the parameter
-      // "alt-cmd-o": [
-      //     "projects::OpenRecent",
-      //     {
-      //         "create_new_window": true
-      //     }
-      // ]
+      // "alt-cmd-o": ["projects::OpenRecent", {"create_new_window": true }],
      "alt-cmd-o": "projects::OpenRecent",
      "alt-cmd-b": "branches::OpenRecent",
      "ctrl-~": "workspace::NewTerminal",
@@ -479,12 +399,7 @@
      "cmd-j": "workspace::ToggleBottomDock",
      "alt-cmd-y": "workspace::CloseAllDocks",
      "cmd-shift-f": "pane::DeploySearch",
-      "cmd-shift-h": [
-        "pane::DeploySearch",
-        {
-          "replace_enabled": true
-        }
-      ],
+      "cmd-shift-h": ["pane::DeploySearch", { "replace_enabled": true }],
      "cmd-k cmd-s": "zed::OpenKeymap",
      "cmd-k cmd-t": "theme_selector::Toggle",
      "cmd-t": "project_symbols::Toggle",
@@ -608,6 +523,7 @@
  {
    "context": "OutlinePanel",
    "bindings": {
+      "escape": "menu::Cancel",
      "left": "outline_panel::CollapseSelectedEntry",
      "right": "outline_panel::ExpandSelectedEntry",
      "cmd-alt-c": "outline_panel::CopyPath",
@@ -652,6 +568,12 @@
      "space": "project_panel::Open"
    }
  },
+  {
+    "context": "Editor && jupyter && !ContextEditor",
+    "bindings": {
+      "cmd-enter": "repl::Run"
+    }
+  },
  {
    "context": "CollabPanel && not_editing",
    "bindings": {
--- a/assets/keymaps/macos/jetbrains.json
+++ b/assets/keymaps/macos/jetbrains.json
@@ -21,24 +21,9 @@
      "cmd--": "editor::Fold",
      "cmd-+": "editor::UnfoldLines",
      "alt-shift-g": "editor::SplitSelectionIntoLines",
-      "ctrl-g": [
-        "editor::SelectNext",
-        {
-          "replace_newest": false
-        }
-      ],
-      "ctrl-cmd-g": [
-        "editor::SelectPrevious",
-        {
-          "replace_newest": false
-        }
-      ],
-      "cmd-/": [
-        "editor::ToggleComments",
-        {
-          "advance_downwards": true
-        }
-      ],
+      "ctrl-g": ["editor::SelectNext", { "replace_newest": false }],
+      "ctrl-cmd-g": ["editor::SelectPrevious", { "replace_newest": false }],
+      "cmd-/": ["editor::ToggleComments", { "advance_downwards": true }],
      "alt-up": "editor::SelectLargerSyntaxNode",
      "alt-down": "editor::SelectSmallerSyntaxNode",
      "shift-alt-up": "editor::MoveLineUp",
--- a/assets/keymaps/macos/textmate.json
+++ b/assets/keymaps/macos/textmate.json
@@ -22,34 +22,14 @@
      "alt-shift-delete": "editor::DeleteToNextWordEnd",
      "ctrl-backspace": "editor::DeleteToPreviousSubwordStart",
      "ctrl-delete": "editor::DeleteToNextSubwordEnd",
-      "alt-left": [
-        "editor::MoveToPreviousWordStart",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "alt-right": [
-        "editor::MoveToNextWordEnd",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
+      "alt-left": ["editor::MoveToPreviousWordStart", { "stop_at_soft_wraps": true }],
+      "alt-right": ["editor::MoveToNextWordEnd", { "stop_at_soft_wraps": true }],
      "ctrl-left": "editor::MoveToPreviousSubwordStart",
      "ctrl-right": "editor::MoveToNextSubwordEnd",
      "cmd-shift-left": "editor::SelectToBeginningOfLine",
      "cmd-shift-right": "editor::SelectToEndOfLine",
-      "alt-shift-left": [
-        "editor::SelectToPreviousWordStart",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "alt-shift-right": [
-        "editor::SelectToNextWordEnd",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
+      "alt-shift-left": ["editor::SelectToPreviousWordStart", { "stop_at_soft_wraps": true }],
+      "alt-shift-right": ["editor::SelectToNextWordEnd", { "stop_at_soft_wraps": true }],
      "ctrl-shift-left": "editor::SelectToPreviousSubwordStart",
      "ctrl-shift-right": "editor::SelectToNextSubwordEnd",
      "ctrl-w": "editor::SelectNext",
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -8,22 +8,8 @@
  {
    "context": "Editor && VimControl && !VimWaiting && !menu",
    "bindings": {
-      "i": [
-        "vim::PushOperator",
-        {
-          "Object": {
-            "around": false
-          }
-        }
-      ],
-      "a": [
-        "vim::PushOperator",
-        {
-          "Object": {
-            "around": true
-          }
-        }
-      ],
+      "i": ["vim::PushOperator", { "Object": { "around": false } }],
+      "a": ["vim::PushOperator", { "Object": { "around": true } }],
      ":": "command_palette::Toggle",
      "h": "vim::Left",
      "left": "vim::Left",
@@ -31,6 +17,7 @@
      "j": "vim::Down",
      "down": "vim::Down",
      "enter": "vim::NextLineStart",
+      "ctrl-m": "vim::NextLineStart",
      "tab": "vim::Tab",
      "shift-tab": "vim::Tab",
      "k": "vim::Up",
@@ -57,92 +44,25 @@
      // "b": "vim::PreviousSubwordStart",
      // "e": "vim::NextSubwordEnd",
      // "g e": "vim::PreviousSubwordEnd",
-      "shift-w": [
-        "vim::NextWordStart",
-        {
-          "ignorePunctuation": true
-        }
-      ],
-      "shift-e": [
-        "vim::NextWordEnd",
-        {
-          "ignorePunctuation": true
-        }
-      ],
-      "shift-b": [
-        "vim::PreviousWordStart",
-        {
-          "ignorePunctuation": true
-        }
-      ],
-      "g shift-e": [
-        "vim::PreviousWordEnd",
-        {
-          "ignorePunctuation": true
-        }
-      ],
+      "shift-w": ["vim::NextWordStart", { "ignorePunctuation": true }],
+      "shift-e": ["vim::NextWordEnd", { "ignorePunctuation": true }],
+      "shift-b": ["vim::PreviousWordStart", { "ignorePunctuation": true }],
+      "g shift-e": ["vim::PreviousWordEnd", { "ignorePunctuation": true }],
      "/": "vim::Search",
      "g /": "pane::DeploySearch",
-      "?": [
-        "vim::Search",
-        {
-          "backwards": true
-        }
-      ],
+      "?": ["vim::Search", { "backwards": true }],
      "*": "vim::MoveToNext",
      "#": "vim::MoveToPrev",
      "n": "vim::MoveToNextMatch",
      "shift-n": "vim::MoveToPrevMatch",
      "%": "vim::Matching",
-      "f": [
-        "vim::PushOperator",
-        {
-          "FindForward": {
-            "before": false
-          }
-        }
-      ],
-      "t": [
-        "vim::PushOperator",
-        {
-          "FindForward": {
-            "before": true
-          }
-        }
-      ],
-      "shift-f": [
-        "vim::PushOperator",
-        {
-          "FindBackward": {
-            "after": false
-          }
-        }
-      ],
-      "shift-t": [
-        "vim::PushOperator",
-        {
-          "FindBackward": {
-            "after": true
-          }
-        }
-      ],
+      "f": ["vim::PushOperator", { "FindForward": { "before": false } }],
+      "t": ["vim::PushOperator", { "FindForward": { "before": true } }],
+      "shift-f": ["vim::PushOperator", { "FindBackward": { "after": false } }],
+      "shift-t": ["vim::PushOperator", { "FindBackward": { "after": true } }],
      "m": ["vim::PushOperator", "Mark"],
-      "'": [
-        "vim::PushOperator",
-        {
-          "Jump": {
-            "line": true
-          }
-        }
-      ],
-      "`": [
-        "vim::PushOperator",
-        {
-          "Jump": {
-            "line": false
-          }
-        }
-      ],
+      "'": ["vim::PushOperator", { "Jump": { "line": true } }],
+      "`": ["vim::PushOperator", { "Jump": { "line": false } }],
      ";": "vim::RepeatFind",
      ",": "vim::RepeatFindReversed",
      "ctrl-o": "pane::GoBack",
@@ -179,90 +99,25 @@
      "g shift-n": "vim::SelectPreviousMatch",
      "g l": "vim::SelectNext",
      "g shift-l": "vim::SelectPrevious",
-      "g >": [
-        "editor::SelectNext",
-        {
-          "replace_newest": true
-        }
-      ],
-      "g <": [
-        "editor::SelectPrevious",
-        {
-          "replace_newest": true
-        }
-      ],
+      "g >": ["editor::SelectNext", { "replace_newest": true }],
+      "g <": ["editor::SelectPrevious", { "replace_newest": true }],
      "g a": "editor::SelectAllMatches",
      "g s": "outline::Toggle",
      "g shift-s": "project_symbols::Toggle",
      "g .": "editor::ToggleCodeActions", // zed specific
      "g shift-a": "editor::FindAllReferences", // zed specific
      "g space": "editor::OpenExcerpts", // zed specific
-      "g *": [
-        "vim::MoveToNext",
-        {
-          "partialWord": true
-        }
-      ],
-      "g #": [
-        "vim::MoveToPrev",
-        {
-          "partialWord": true
-        }
-      ],
-      "g j": [
-        "vim::Down",
-        {
-          "displayLines": true
-        }
-      ],
-      "g down": [
-        "vim::Down",
-        {
-          "displayLines": true
-        }
-      ],
-      "g k": [
-        "vim::Up",
-        {
-          "displayLines": true
-        }
-      ],
-      "g up": [
-        "vim::Up",
-        {
-          "displayLines": true
-        }
-      ],
-      "g $": [
-        "vim::EndOfLine",
-        {
-          "displayLines": true
-        }
-      ],
-      "g end": [
-        "vim::EndOfLine",
-        {
-          "displayLines": true
-        }
-      ],
-      "g 0": [
-        "vim::StartOfLine",
-        {
-          "displayLines": true
-        }
-      ],
-      "g home": [
-        "vim::StartOfLine",
-        {
-          "displayLines": true
-        }
-      ],
-      "g ^": [
-        "vim::FirstNonWhitespace",
-        {
-          "displayLines": true
-        }
-      ],
+      "g *": ["vim::MoveToNext", { "partialWord": true }],
+      "g #": ["vim::MoveToPrev", { "partialWord": true }],
+      "g j": ["vim::Down", { "displayLines": true }],
+      "g down": ["vim::Down", { "displayLines": true }],
+      "g k": ["vim::Up", { "displayLines": true }],
+      "g up": ["vim::Up", { "displayLines": true }],
+      "g $": ["vim::EndOfLine", { "displayLines": true }],
+      "g end": ["vim::EndOfLine", { "displayLines": true }],
+      "g 0": ["vim::StartOfLine", { "displayLines": true }],
+      "g home": ["vim::StartOfLine", { "displayLines": true }],
+      "g ^": ["vim::FirstNonWhitespace", { "displayLines": true }],
      "g v": "vim::RestoreVisualSelection",
      "g ]": "editor::GoToDiagnostic",
      "g [": "editor::GoToPrevDiagnostic",
@@ -280,18 +135,8 @@
      "z c": "editor::Fold",
      "z o": "editor::UnfoldLines",
      "z f": "editor::FoldSelectedRanges",
-      "shift-z shift-q": [
-        "pane::CloseActiveItem",
-        {
-          "saveIntent": "skip"
-        }
-      ],
-      "shift-z shift-z": [
-        "pane::CloseActiveItem",
-        {
-          "saveIntent": "saveAll"
-        }
-      ],
+      "shift-z shift-q": ["pane::CloseActiveItem", { "saveIntent": "skip" }],
+      "shift-z shift-z": ["pane::CloseActiveItem", { "saveIntent": "saveAll" }],
      // Count support
      "1": ["vim::Number", 1],
      "2": ["vim::Number", 2],
@@ -303,6 +148,7 @@
      "8": ["vim::Number", 8],
      "9": ["vim::Number", 9],
      // window related commands (ctrl-w X)
+      "ctrl-w": null,
      "ctrl-w left": ["workspace::ActivatePaneInDirection", "Left"],
      "ctrl-w right": ["workspace::ActivatePaneInDirection", "Right"],
      "ctrl-w up": ["workspace::ActivatePaneInDirection", "Up"],
@@ -386,14 +232,9 @@
      "ctrl-a": "vim::Increment",
      "ctrl-x": "vim::Decrement",
      "p": "vim::Paste",
-      "shift-p": [
-        "vim::Paste",
-        {
-          "before": true
-        }
-      ],
-      "u": "editor::Undo",
-      "ctrl-r": "editor::Redo",
+      "shift-p": ["vim::Paste", { "before": true }],
+      "u": "vim::Undo",
+      "ctrl-r": "vim::Redo",
      "r": ["vim::PushOperator", "Replace"],
      "s": "vim::Substitute",
      "shift-s": "vim::SubstituteLine",
@@ -442,12 +283,7 @@
  {
    "context": "Editor && vim_mode == normal && vim_operator == c",
    "bindings": {
-      "s": [
-        "vim::PushOperator",
-        {
-          "ChangeSurrounds": {}
-        }
-      ]
+      "s": ["vim::PushOperator", { "ChangeSurrounds": {} }]
    }
  },
  {
@@ -492,12 +328,7 @@
  {
    "context": "Editor && vim_mode == normal && vim_operator == y",
    "bindings": {
-      "s": [
-        "vim::PushOperator",
-        {
-          "AddSurrounds": {}
-        }
-      ]
+      "s": ["vim::PushOperator", { "AddSurrounds": {} }]
    }
  },
  {
@@ -522,12 +353,7 @@
    "context": "Editor && VimObject",
    "bindings": {
      "w": "vim::Word",
-      "shift-w": [
-        "vim::Word",
-        {
-          "ignorePunctuation": true
-        }
-      ],
+      "shift-w": ["vim::Word", { "ignorePunctuation": true }],
      "t": "vim::Tag",
      "s": "vim::Sentence",
      "p": "vim::Paragraph",
@@ -562,43 +388,18 @@
      "y": "vim::VisualYank",
      "shift-y": "vim::VisualYank",
      "p": "vim::Paste",
-      "shift-p": [
-        "vim::Paste",
-        {
-          "preserveClipboard": true
-        }
-      ],
+      "shift-p": ["vim::Paste", { "preserveClipboard": true }],
      "s": "vim::Substitute",
      "shift-s": "vim::SubstituteLine",
      "shift-r": "vim::SubstituteLine",
      "c": "vim::Substitute",
      "~": "vim::ChangeCase",
-      "*": [
-        "vim::MoveToNext",
-        {
-          "partialWord": true
-        }
-      ],
-      "#": [
-        "vim::MoveToPrev",
-        {
-          "partialWord": true
-        }
-      ],
+      "*": ["vim::MoveToNext", { "partialWord": true }],
+      "#": ["vim::MoveToPrev", { "partialWord": true }],
      "ctrl-a": "vim::Increment",
      "ctrl-x": "vim::Decrement",
-      "g ctrl-a": [
-        "vim::Increment",
-        {
-          "step": true
-        }
-      ],
-      "g ctrl-x": [
-        "vim::Decrement",
-        {
-          "step": true
-        }
-      ],
+      "g ctrl-a": ["vim::Increment", { "step": true }],
+      "g ctrl-x": ["vim::Decrement", { "step": true }],
      "shift-i": "vim::InsertBefore",
      "shift-a": "vim::InsertAfter",
      "shift-j": "vim::JoinLines",
@@ -608,22 +409,8 @@
      "ctrl-[": ["vim::SwitchMode", "Normal"],
      ">": "vim::Indent",
      "<": "vim::Outdent",
-      "i": [
-        "vim::PushOperator",
-        {
-          "Object": {
-            "around": false
-          }
-        }
-      ],
-      "a": [
-        "vim::PushOperator",
-        {
-          "Object": {
-            "around": true
-          }
-        }
-      ]
+      "i": ["vim::PushOperator", { "Object": { "around": false } }],
+      "a": ["vim::PushOperator", { "Object": { "around": true } }]
    }
  },
  {
@@ -644,6 +431,7 @@
      "escape": "vim::NormalBefore",
      "ctrl-c": "vim::NormalBefore",
      "ctrl-[": "vim::NormalBefore",
+      "ctrl-x": null,
      "ctrl-x ctrl-o": "editor::ShowCompletions",
      "ctrl-x ctrl-a": "assistant::InlineAssist", // zed specific
      "ctrl-x ctrl-c": "editor::ShowInlineCompletion", // zed specific
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -690,6 +690,7 @@
  // }
  //
  "file_types": {
+    "JSON": ["flake.lock"],
    "JSONC": ["**/.zed/**/*.json", "**/zed/**/*.json"]
  },
  // The extensions that Zed should automatically install on startup.
--- a/assets/settings/initial_user_settings.json
+++ b/assets/settings/initial_user_settings.json
@@ -12,6 +12,6 @@
  "theme": {
    "mode": "system",
    "light": "One Light",
-    "dark": "One Dark",
-  },
+    "dark": "One Dark"
+  }
 }
--- a/assets/themes/one/one.json
+++ b/assets/themes/one/one.json
@@ -15,25 +15,25 @@
        "elevated_surface.background": "#2f343eff",
        "surface.background": "#2f343eff",
        "background": "#3b414dff",
-        "element.background": "#2f343eff",
+        "element.background": "#2e343eff",
        "element.hover": "#363c46ff",
        "element.active": "#454a56ff",
        "element.selected": "#454a56ff",
-        "element.disabled": "#2f343eff",
+        "element.disabled": "#2e343eff",
        "drop_target.background": "#83899480",
        "ghost_element.background": "#00000000",
        "ghost_element.hover": "#363c46ff",
        "ghost_element.active": "#454a56ff",
        "ghost_element.selected": "#454a56ff",
-        "ghost_element.disabled": "#2f343eff",
+        "ghost_element.disabled": "#2e343eff",
        "text": "#c8ccd4ff",
        "text.muted": "#838994ff",
-        "text.placeholder": "#555a63ff",
-        "text.disabled": "#555a63ff",
+        "text.placeholder": "#696B77ff",
+        "text.disabled": "#696B77ff",
        "text.accent": "#74ade8ff",
        "icon": "#c8ccd4ff",
        "icon.muted": "#838994ff",
-        "icon.disabled": "#555a63ff",
+        "icon.disabled": "#696B77ff",
        "icon.placeholder": "#838994ff",
        "icon.accent": "#74ade8ff",
        "status_bar.background": "#3b414dff",
@@ -59,7 +59,7 @@
        "editor.highlighted_line.background": "#2f343eff",
        "editor.line_number": "#c8ccd459",
        "editor.active_line_number": "#c8ccd4ff",
-        "editor.invisible": "#555a63ff",
+        "editor.invisible": "#696B77ff",
        "editor.wrap_guide": "#c8ccd40d",
        "editor.active_wrap_guide": "#c8ccd41a",
        "editor.document_highlight.read_background": "#74ade81a",
@@ -94,46 +94,46 @@
        "terminal.ansi.dim_white": "#575d65ff",
        "link_text.hover": "#74ade8ff",
        "conflict": "#dec184ff",
-        "conflict.background": "#41321dff",
+        "conflict.background": "#dec1841a",
        "conflict.border": "#5d4c2fff",
        "created": "#a1c181ff",
-        "created.background": "#222e1dff",
+        "created.background": "#a1c1811a",
        "created.border": "#38482fff",
        "deleted": "#d07277ff",
-        "deleted.background": "#301b1bff",
+        "deleted.background": "#d072771a",
        "deleted.border": "#4c2b2cff",
        "error": "#d07277ff",
-        "error.background": "#301b1bff",
+        "error.background": "#d072771a",
        "error.border": "#4c2b2cff",
-        "hidden": "#555a63ff",
-        "hidden.background": "#3b414dff",
+        "hidden": "#696B77ff",
+        "hidden.background": "#696B771a",
        "hidden.border": "#414754ff",
        "hint": "#5a6f89ff",
-        "hint.background": "#18243dff",
+        "hint.background": "#5a6f891a",
        "hint.border": "#293b5bff",
-        "ignored": "#555a63ff",
-        "ignored.background": "#3b414dff",
+        "ignored": "#696B77ff",
+        "ignored.background": "#696B771a",
        "ignored.border": "#464b57ff",
        "info": "#74ade8ff",
-        "info.background": "#18243dff",
+        "info.background": "#74ade81a",
        "info.border": "#293b5bff",
        "modified": "#dec184ff",
-        "modified.background": "#41321dff",
+        "modified.background": "#dec1841a",
        "modified.border": "#5d4c2fff",
        "predictive": "#5a6a87ff",
-        "predictive.background": "#222e1dff",
+        "predictive.background": "#5a6a871a",
        "predictive.border": "#38482fff",
        "renamed": "#74ade8ff",
-        "renamed.background": "#18243dff",
+        "renamed.background": "#74ade81a",
        "renamed.border": "#293b5bff",
        "success": "#a1c181ff",
-        "success.background": "#222e1dff",
+        "success.background": "#a1c1811a",
        "success.border": "#38482fff",
        "unreachable": "#838994ff",
-        "unreachable.background": "#3b414dff",
+        "unreachable.background": "#8389941a",
        "unreachable.border": "#464b57ff",
        "warning": "#dec184ff",
-        "warning.background": "#41321dff",
+        "warning.background": "#dec1841a",
        "warning.border": "#5d4c2fff",
        "players": [
          {
@@ -491,7 +491,7 @@
        "info": "#5c78e2ff",
        "info.background": "#e2e2faff",
        "info.border": "#cbcdf6ff",
-        "modified": "#dec184ff",
+        "modified": "#a47a23ff",
        "modified.background": "#faf2e6ff",
        "modified.border": "#f4e7d1ff",
        "predictive": "#9b9ec6ff",
--- a/crates/assistant/Cargo.toml
+++ b/crates/assistant/Cargo.toml
@@ -12,19 +12,28 @@ workspace = true
 path = "src/assistant.rs"
 doctest = false

+[features]
+test-support = [
+    "editor/test-support",
+    "language/test-support",
+    "project/test-support",
+    "text/test-support",
+]
+
 [dependencies]
 anthropic = { workspace = true, features = ["schemars"] }
 anyhow.workspace = true
 assistant_slash_command.workspace = true
 async-watch.workspace = true
+breadcrumbs.workspace = true
 cargo_toml.workspace = true
 chrono.workspace = true
 client.workspace = true
+clock.workspace = true
 collections.workspace = true
 command_palette_hooks.workspace = true
 editor.workspace = true
 feature_flags.workspace = true
-file_icons.workspace = true
 fs.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
@@ -72,7 +81,9 @@ picker.workspace = true
 ctor.workspace = true
 editor = { workspace = true, features = ["test-support"] }
 env_logger.workspace = true
+language = { workspace = true, features = ["test-support"] }
 log.workspace = true
 project = { workspace = true, features = ["test-support"] }
 rand.workspace = true
+text = { workspace = true, features = ["test-support"] }
 unindent.workspace = true
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -1,7 +1,8 @@
 pub mod assistant_panel;
 pub mod assistant_settings;
 mod completion_provider;
-mod context_store;
+mod context;
+pub mod context_store;
 mod inline_assistant;
 mod model_selector;
 mod prompt_library;
@@ -16,8 +17,9 @@ use assistant_settings::{AnthropicModel, AssistantSettings, CloudModel, OllamaMo
 use assistant_slash_command::SlashCommandRegistry;
 use client::{proto, Client};
 use command_palette_hooks::CommandPaletteFilter;
-pub(crate) use completion_provider::*;
-pub(crate) use context_store::*;
+pub use completion_provider::*;
+pub use context::*;
+pub use context_store::*;
 use fs::Fs;
 use gpui::{actions, AppContext, Global, SharedString, UpdateGlobal};
 use indexed_docs::IndexedDocsRegistry;
@@ -27,8 +29,9 @@ use semantic_index::{CloudEmbeddingProvider, SemanticIndex};
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsStore};
 use slash_command::{
-    active_command, default_command, diagnostics_command, fetch_command, file_command, now_command,
-    project_command, prompt_command, rustdoc_command, search_command, tabs_command, term_command,
+    active_command, default_command, diagnostics_command, docs_command, fetch_command,
+    file_command, now_command, project_command, prompt_command, search_command, tabs_command,
+    term_command,
 };
 use std::{
    fmt::{self, Display},
@@ -48,17 +51,22 @@ actions!(
        ResetKey,
        InlineAssist,
        InsertActivePrompt,
-        ToggleHistory,
+        DeployHistory,
+        DeployPromptLibrary,
        ApplyEdit,
        ConfirmCommand,
        ToggleModelSelector
    ]
 );

-#[derive(
-    Copy, Clone, Debug, Default, Eq, PartialEq, PartialOrd, Ord, Hash, Serialize, Deserialize,
-)]
-struct MessageId(usize);
+#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct MessageId(clock::Lamport);
+
+impl MessageId {
+    pub fn as_u64(self) -> u64 {
+        self.0.as_u64()
+    }
+}

 #[derive(Clone, Copy, Serialize, Deserialize, Debug, Eq, PartialEq)]
 #[serde(rename_all = "lowercase")]
@@ -69,8 +77,26 @@ pub enum Role {
 }

 impl Role {
-    pub fn cycle(&mut self) {
-        *self = match self {
+    pub fn from_proto(role: i32) -> Role {
+        match proto::LanguageModelRole::from_i32(role) {
+            Some(proto::LanguageModelRole::LanguageModelUser) => Role::User,
+            Some(proto::LanguageModelRole::LanguageModelAssistant) => Role::Assistant,
+            Some(proto::LanguageModelRole::LanguageModelSystem) => Role::System,
+            Some(proto::LanguageModelRole::LanguageModelTool) => Role::System,
+            None => Role::User,
+        }
+    }
+
+    pub fn to_proto(&self) -> proto::LanguageModelRole {
+        match self {
+            Role::User => proto::LanguageModelRole::LanguageModelUser,
+            Role::Assistant => proto::LanguageModelRole::LanguageModelAssistant,
+            Role::System => proto::LanguageModelRole::LanguageModelSystem,
+        }
+    }
+
+    pub fn cycle(self) -> Role {
+        match self {
            Role::User => Role::Assistant,
            Role::Assistant => Role::System,
            Role::System => Role::User,
@@ -149,11 +175,7 @@ pub struct LanguageModelRequestMessage {
 impl LanguageModelRequestMessage {
    pub fn to_proto(&self) -> proto::LanguageModelRequestMessage {
        proto::LanguageModelRequestMessage {
-            role: match self.role {
-                Role::User => proto::LanguageModelRole::LanguageModelUser,
-                Role::Assistant => proto::LanguageModelRole::LanguageModelAssistant,
-                Role::System => proto::LanguageModelRole::LanguageModelSystem,
-            } as i32,
+            role: self.role.to_proto() as i32,
            content: self.content.clone(),
            tool_calls: Vec::new(),
            tool_call_id: None,
@@ -161,7 +183,7 @@ impl LanguageModelRequestMessage {
    }
 }

-#[derive(Debug, Default, Serialize)]
+#[derive(Debug, Default, Serialize, Deserialize)]
 pub struct LanguageModelRequest {
    pub model: LanguageModel,
    pub messages: Vec<LanguageModelRequestMessage>,
@@ -220,19 +242,48 @@ pub struct LanguageModelChoiceDelta {
    pub finish_reason: Option<String>,
 }

-#[derive(Clone, Debug, Serialize, Deserialize)]
-struct MessageMetadata {
-    role: Role,
-    status: MessageStatus,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-enum MessageStatus {
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+pub enum MessageStatus {
    Pending,
    Done,
    Error(SharedString),
 }

+impl MessageStatus {
+    pub fn from_proto(status: proto::ContextMessageStatus) -> MessageStatus {
+        match status.variant {
+            Some(proto::context_message_status::Variant::Pending(_)) => MessageStatus::Pending,
+            Some(proto::context_message_status::Variant::Done(_)) => MessageStatus::Done,
+            Some(proto::context_message_status::Variant::Error(error)) => {
+                MessageStatus::Error(error.message.into())
+            }
+            None => MessageStatus::Pending,
+        }
+    }
+
+    pub fn to_proto(&self) -> proto::ContextMessageStatus {
+        match self {
+            MessageStatus::Pending => proto::ContextMessageStatus {
+                variant: Some(proto::context_message_status::Variant::Pending(
+                    proto::context_message_status::Pending {},
+                )),
+            },
+            MessageStatus::Done => proto::ContextMessageStatus {
+                variant: Some(proto::context_message_status::Variant::Done(
+                    proto::context_message_status::Done {},
+                )),
+            },
+            MessageStatus::Error(message) => proto::ContextMessageStatus {
+                variant: Some(proto::context_message_status::Variant::Error(
+                    proto::context_message_status::Error {
+                        message: message.to_string(),
+                    },
+                )),
+            },
+        }
+    }
+}
+
 /// The state pertaining to the Assistant.
 #[derive(Default)]
 struct Assistant {
@@ -285,6 +336,7 @@ pub fn init(fs: Arc<dyn Fs>, client: Arc<Client>, cx: &mut AppContext) {
    })
    .detach();

+    context_store::init(&client);
    prompt_library::init(cx);
    completion_provider::init(client.clone(), cx);
    assistant_slash_command::init(cx);
@@ -322,8 +374,8 @@ fn register_slash_commands(cx: &mut AppContext) {
    slash_command_registry.register_command(default_command::DefaultSlashCommand, true);
    slash_command_registry.register_command(term_command::TermSlashCommand, true);
    slash_command_registry.register_command(now_command::NowSlashCommand, true);
-    slash_command_registry.register_command(diagnostics_command::DiagnosticsCommand, true);
-    slash_command_registry.register_command(rustdoc_command::RustdocSlashCommand, false);
+    slash_command_registry.register_command(diagnostics_command::DiagnosticsSlashCommand, true);
+    slash_command_registry.register_command(docs_command::DocsSlashCommand, true);
    slash_command_registry.register_command(fetch_command::FetchSlashCommand, false);
 }

--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
--- a/crates/assistant/src/assistant_settings.rs
+++ b/crates/assistant/src/assistant_settings.rs
@@ -1,5 +1,6 @@
 use std::fmt;

+use crate::{preprocess_anthropic_request, LanguageModel, LanguageModelRequest};
 pub use anthropic::Model as AnthropicModel;
 use gpui::Pixels;
 pub use ollama::Model as OllamaModel;
@@ -15,8 +16,6 @@ use serde::{
 use settings::{Settings, SettingsSources};
 use strum::{EnumIter, IntoEnumIterator};

-use crate::{preprocess_anthropic_request, LanguageModel, LanguageModelRequest};
-
 #[derive(Clone, Debug, Default, PartialEq, EnumIter)]
 pub enum CloudModel {
    Gpt3Point5Turbo,
--- a/crates/assistant/src/completion_provider.rs
+++ b/crates/assistant/src/completion_provider.rs
@@ -1,16 +1,18 @@
 mod anthropic;
 mod cloud;
-#[cfg(test)]
+#[cfg(any(test, feature = "test-support"))]
 mod fake;
 mod ollama;
 mod open_ai;

 pub use anthropic::*;
 pub use cloud::*;
-#[cfg(test)]
+#[cfg(any(test, feature = "test-support"))]
 pub use fake::*;
 pub use ollama::*;
 pub use open_ai::*;
+use parking_lot::RwLock;
+use smol::lock::{Semaphore, SemaphoreGuardArc};

 use crate::{
    assistant_settings::{AssistantProvider, AssistantSettings},
@@ -21,8 +23,8 @@ use client::Client;
 use futures::{future::BoxFuture, stream::BoxStream};
 use gpui::{AnyView, AppContext, BorrowAppContext, Task, WindowContext};
 use settings::{Settings, SettingsStore};
-use std::sync::Arc;
 use std::time::Duration;
+use std::{any::Any, sync::Arc};

 /// Choose which model to use for openai provider.
 /// If the model is not available, try to use the first available model, or fallback to the original model.
@@ -39,176 +41,117 @@ fn choose_openai_model(
 }

 pub fn init(client: Arc<Client>, cx: &mut AppContext) {
-    let mut settings_version = 0;
-    let provider = match &AssistantSettings::get_global(cx).provider {
-        AssistantProvider::ZedDotDev { model } => CompletionProvider::Cloud(
-            CloudCompletionProvider::new(model.clone(), client.clone(), settings_version, cx),
-        ),
-        AssistantProvider::OpenAi {
-            model,
-            api_url,
-            low_speed_timeout_in_seconds,
-            available_models,
-        } => CompletionProvider::OpenAi(OpenAiCompletionProvider::new(
-            choose_openai_model(model, available_models),
-            api_url.clone(),
-            client.http_client(),
-            low_speed_timeout_in_seconds.map(Duration::from_secs),
-            settings_version,
-        )),
-        AssistantProvider::Anthropic {
-            model,
-            api_url,
-            low_speed_timeout_in_seconds,
-        } => CompletionProvider::Anthropic(AnthropicCompletionProvider::new(
-            model.clone(),
-            api_url.clone(),
-            client.http_client(),
-            low_speed_timeout_in_seconds.map(Duration::from_secs),
-            settings_version,
-        )),
-        AssistantProvider::Ollama {
-            model,
-            api_url,
-            low_speed_timeout_in_seconds,
-        } => CompletionProvider::Ollama(OllamaCompletionProvider::new(
-            model.clone(),
-            api_url.clone(),
-            client.http_client(),
-            low_speed_timeout_in_seconds.map(Duration::from_secs),
-            settings_version,
-            cx,
-        )),
-    };
-    cx.set_global(provider);
+    let provider = create_provider_from_settings(client.clone(), 0, cx);
+    cx.set_global(CompletionProvider::new(provider, Some(client)));

+    let mut settings_version = 0;
    cx.observe_global::<SettingsStore>(move |cx| {
        settings_version += 1;
        cx.update_global::<CompletionProvider, _>(|provider, cx| {
-            match (&mut *provider, &AssistantSettings::get_global(cx).provider) {
-                (
-                    CompletionProvider::OpenAi(provider),
-                    AssistantProvider::OpenAi {
-                        model,
-                        api_url,
-                        low_speed_timeout_in_seconds,
-                        available_models,
-                    },
-                ) => {
-                    provider.update(
-                        choose_openai_model(model, available_models),
-                        api_url.clone(),
-                        low_speed_timeout_in_seconds.map(Duration::from_secs),
-                        settings_version,
-                    );
-                }
-                (
-                    CompletionProvider::Anthropic(provider),
-                    AssistantProvider::Anthropic {
-                        model,
-                        api_url,
-                        low_speed_timeout_in_seconds,
-                    },
-                ) => {
-                    provider.update(
-                        model.clone(),
-                        api_url.clone(),
-                        low_speed_timeout_in_seconds.map(Duration::from_secs),
-                        settings_version,
-                    );
-                }
-
-                (
-                    CompletionProvider::Ollama(provider),
-                    AssistantProvider::Ollama {
-                        model,
-                        api_url,
-                        low_speed_timeout_in_seconds,
-                    },
-                ) => {
-                    provider.update(
-                        model.clone(),
-                        api_url.clone(),
-                        low_speed_timeout_in_seconds.map(Duration::from_secs),
-                        settings_version,
-                        cx,
-                    );
-                }
-
-                (CompletionProvider::Cloud(provider), AssistantProvider::ZedDotDev { model }) => {
-                    provider.update(model.clone(), settings_version);
-                }
-                (_, AssistantProvider::ZedDotDev { model }) => {
-                    *provider = CompletionProvider::Cloud(CloudCompletionProvider::new(
-                        model.clone(),
-                        client.clone(),
-                        settings_version,
-                        cx,
-                    ));
-                }
-                (
-                    _,
-                    AssistantProvider::OpenAi {
-                        model,
-                        api_url,
-                        low_speed_timeout_in_seconds,
-                        available_models,
-                    },
-                ) => {
-                    *provider = CompletionProvider::OpenAi(OpenAiCompletionProvider::new(
-                        choose_openai_model(model, available_models),
-                        api_url.clone(),
-                        client.http_client(),
-                        low_speed_timeout_in_seconds.map(Duration::from_secs),
-                        settings_version,
-                    ));
-                }
-                (
-                    _,
-                    AssistantProvider::Anthropic {
-                        model,
-                        api_url,
-                        low_speed_timeout_in_seconds,
-                    },
-                ) => {
-                    *provider = CompletionProvider::Anthropic(AnthropicCompletionProvider::new(
-                        model.clone(),
-                        api_url.clone(),
-                        client.http_client(),
-                        low_speed_timeout_in_seconds.map(Duration::from_secs),
-                        settings_version,
-                    ));
-                }
-                (
-                    _,
-                    AssistantProvider::Ollama {
-                        model,
-                        api_url,
-                        low_speed_timeout_in_seconds,
-                    },
-                ) => {
-                    *provider = CompletionProvider::Ollama(OllamaCompletionProvider::new(
-                        model.clone(),
-                        api_url.clone(),
-                        client.http_client(),
-                        low_speed_timeout_in_seconds.map(Duration::from_secs),
-                        settings_version,
-                        cx,
-                    ));
-                }
-            }
+            provider.update_settings(settings_version, cx);
        })
    })
    .detach();
 }

-pub enum CompletionProvider {
-    OpenAi(OpenAiCompletionProvider),
-    Anthropic(AnthropicCompletionProvider),
-    Cloud(CloudCompletionProvider),
-    #[cfg(test)]
-    Fake(FakeCompletionProvider),
-    Ollama(OllamaCompletionProvider),
+pub struct CompletionResponse {
+    pub inner: BoxFuture<'static, Result<BoxStream<'static, Result<String>>>>,
+    _lock: SemaphoreGuardArc,
+}
+
+pub trait LanguageModelCompletionProvider: Send + Sync {
+    fn available_models(&self, cx: &AppContext) -> Vec<LanguageModel>;
+    fn settings_version(&self) -> usize;
+    fn is_authenticated(&self) -> bool;
+    fn authenticate(&self, cx: &AppContext) -> Task<Result<()>>;
+    fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView;
+    fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>>;
+    fn model(&self) -> LanguageModel;
+    fn count_tokens(
+        &self,
+        request: LanguageModelRequest,
+        cx: &AppContext,
+    ) -> BoxFuture<'static, Result<usize>>;
+    fn complete(
+        &self,
+        request: LanguageModelRequest,
+    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>>;
+
+    fn as_any_mut(&mut self) -> &mut dyn Any;
+}
+
+const MAX_CONCURRENT_COMPLETION_REQUESTS: usize = 4;
+
+pub struct CompletionProvider {
+    provider: Arc<RwLock<dyn LanguageModelCompletionProvider>>,
+    client: Option<Arc<Client>>,
+    request_limiter: Arc<Semaphore>,
+}
+
+impl CompletionProvider {
+    pub fn new(
+        provider: Arc<RwLock<dyn LanguageModelCompletionProvider>>,
+        client: Option<Arc<Client>>,
+    ) -> Self {
+        Self {
+            provider,
+            client,
+            request_limiter: Arc::new(Semaphore::new(MAX_CONCURRENT_COMPLETION_REQUESTS)),
+        }
+    }
+
+    pub fn available_models(&self, cx: &AppContext) -> Vec<LanguageModel> {
+        self.provider.read().available_models(cx)
+    }
+
+    pub fn settings_version(&self) -> usize {
+        self.provider.read().settings_version()
+    }
+
+    pub fn is_authenticated(&self) -> bool {
+        self.provider.read().is_authenticated()
+    }
+
+    pub fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
+        self.provider.read().authenticate(cx)
+    }
+
+    pub fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
+        self.provider.read().authentication_prompt(cx)
+    }
+
+    pub fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
+        self.provider.read().reset_credentials(cx)
+    }
+
+    pub fn model(&self) -> LanguageModel {
+        self.provider.read().model()
+    }
+
+    pub fn count_tokens(
+        &self,
+        request: LanguageModelRequest,
+        cx: &AppContext,
+    ) -> BoxFuture<'static, Result<usize>> {
+        self.provider.read().count_tokens(request, cx)
+    }
+
+    pub fn complete(
+        &self,
+        request: LanguageModelRequest,
+        cx: &AppContext,
+    ) -> Task<CompletionResponse> {
+        let rate_limiter = self.request_limiter.clone();
+        let provider = self.provider.clone();
+        cx.background_executor().spawn(async move {
+            let lock = rate_limiter.acquire_arc().await;
+            let response = provider.read().complete(request);
+            CompletionResponse {
+                inner: response,
+                _lock: lock,
+            }
+        })
+    }
 }

 impl gpui::Global for CompletionProvider {}
@@ -218,121 +161,213 @@ impl CompletionProvider {
        cx.global::<Self>()
    }

-    pub fn available_models(&self, cx: &AppContext) -> Vec<LanguageModel> {
-        match self {
-            CompletionProvider::OpenAi(provider) => provider
-                .available_models(cx)
-                .map(LanguageModel::OpenAi)
-                .collect(),
-            CompletionProvider::Anthropic(provider) => provider
-                .available_models()
-                .map(LanguageModel::Anthropic)
-                .collect(),
-            CompletionProvider::Cloud(provider) => provider
-                .available_models()
-                .map(LanguageModel::Cloud)
-                .collect(),
-            CompletionProvider::Ollama(provider) => provider
-                .available_models()
-                .map(|model| LanguageModel::Ollama(model.clone()))
-                .collect(),
-            #[cfg(test)]
-            CompletionProvider::Fake(_) => unimplemented!(),
+    pub fn update_current_as<R, T: LanguageModelCompletionProvider + 'static>(
+        &mut self,
+        update: impl FnOnce(&mut T) -> R,
+    ) -> Option<R> {
+        let mut provider = self.provider.write();
+        if let Some(provider) = provider.as_any_mut().downcast_mut::<T>() {
+            Some(update(provider))
+        } else {
+            None
        }
    }

-    pub fn settings_version(&self) -> usize {
-        match self {
-            CompletionProvider::OpenAi(provider) => provider.settings_version(),
-            CompletionProvider::Anthropic(provider) => provider.settings_version(),
-            CompletionProvider::Cloud(provider) => provider.settings_version(),
-            CompletionProvider::Ollama(provider) => provider.settings_version(),
-            #[cfg(test)]
-            CompletionProvider::Fake(_) => unimplemented!(),
-        }
-    }
+    pub fn update_settings(&mut self, version: usize, cx: &mut AppContext) {
+        let updated = match &AssistantSettings::get_global(cx).provider {
+            AssistantProvider::ZedDotDev { model } => self
+                .update_current_as::<_, CloudCompletionProvider>(|provider| {
+                    provider.update(model.clone(), version);
+                }),
+            AssistantProvider::OpenAi {
+                model,
+                api_url,
+                low_speed_timeout_in_seconds,
+                available_models,
+            } => self.update_current_as::<_, OpenAiCompletionProvider>(|provider| {
+                provider.update(
+                    choose_openai_model(&model, &available_models),
+                    api_url.clone(),
+                    low_speed_timeout_in_seconds.map(Duration::from_secs),
+                    version,
+                );
+            }),
+            AssistantProvider::Anthropic {
+                model,
+                api_url,
+                low_speed_timeout_in_seconds,
+            } => self.update_current_as::<_, AnthropicCompletionProvider>(|provider| {
+                provider.update(
+                    model.clone(),
+                    api_url.clone(),
+                    low_speed_timeout_in_seconds.map(Duration::from_secs),
+                    version,
+                );
+            }),
+            AssistantProvider::Ollama {
+                model,
+                api_url,
+                low_speed_timeout_in_seconds,
+            } => self.update_current_as::<_, OllamaCompletionProvider>(|provider| {
+                provider.update(
+                    model.clone(),
+                    api_url.clone(),
+                    low_speed_timeout_in_seconds.map(Duration::from_secs),
+                    version,
+                    cx,
+                );
+            }),
+        };

-    pub fn is_authenticated(&self) -> bool {
-        match self {
-            CompletionProvider::OpenAi(provider) => provider.is_authenticated(),
-            CompletionProvider::Anthropic(provider) => provider.is_authenticated(),
-            CompletionProvider::Cloud(provider) => provider.is_authenticated(),
-            CompletionProvider::Ollama(provider) => provider.is_authenticated(),
-            #[cfg(test)]
-            CompletionProvider::Fake(_) => true,
-        }
-    }
-
-    pub fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
-        match self {
-            CompletionProvider::OpenAi(provider) => provider.authenticate(cx),
-            CompletionProvider::Anthropic(provider) => provider.authenticate(cx),
-            CompletionProvider::Cloud(provider) => provider.authenticate(cx),
-            CompletionProvider::Ollama(provider) => provider.authenticate(cx),
-            #[cfg(test)]
-            CompletionProvider::Fake(_) => Task::ready(Ok(())),
-        }
-    }
-
-    pub fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
-        match self {
-            CompletionProvider::OpenAi(provider) => provider.authentication_prompt(cx),
-            CompletionProvider::Anthropic(provider) => provider.authentication_prompt(cx),
-            CompletionProvider::Cloud(provider) => provider.authentication_prompt(cx),
-            CompletionProvider::Ollama(provider) => provider.authentication_prompt(cx),
-            #[cfg(test)]
-            CompletionProvider::Fake(_) => unimplemented!(),
-        }
-    }
-
-    pub fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
-        match self {
-            CompletionProvider::OpenAi(provider) => provider.reset_credentials(cx),
-            CompletionProvider::Anthropic(provider) => provider.reset_credentials(cx),
-            CompletionProvider::Cloud(_) => Task::ready(Ok(())),
-            CompletionProvider::Ollama(provider) => provider.reset_credentials(cx),
-            #[cfg(test)]
-            CompletionProvider::Fake(_) => Task::ready(Ok(())),
-        }
-    }
-
-    pub fn model(&self) -> LanguageModel {
-        match self {
-            CompletionProvider::OpenAi(provider) => LanguageModel::OpenAi(provider.model()),
-            CompletionProvider::Anthropic(provider) => LanguageModel::Anthropic(provider.model()),
-            CompletionProvider::Cloud(provider) => LanguageModel::Cloud(provider.model()),
-            CompletionProvider::Ollama(provider) => LanguageModel::Ollama(provider.model()),
-            #[cfg(test)]
-            CompletionProvider::Fake(_) => LanguageModel::default(),
-        }
-    }
-
-    pub fn count_tokens(
-        &self,
-        request: LanguageModelRequest,
-        cx: &AppContext,
-    ) -> BoxFuture<'static, Result<usize>> {
-        match self {
-            CompletionProvider::OpenAi(provider) => provider.count_tokens(request, cx),
-            CompletionProvider::Anthropic(provider) => provider.count_tokens(request, cx),
-            CompletionProvider::Cloud(provider) => provider.count_tokens(request, cx),
-            CompletionProvider::Ollama(provider) => provider.count_tokens(request, cx),
-            #[cfg(test)]
-            CompletionProvider::Fake(_) => futures::FutureExt::boxed(futures::future::ready(Ok(0))),
-        }
-    }
-
-    pub fn complete(
-        &self,
-        request: LanguageModelRequest,
-    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
-        match self {
-            CompletionProvider::OpenAi(provider) => provider.complete(request),
-            CompletionProvider::Anthropic(provider) => provider.complete(request),
-            CompletionProvider::Cloud(provider) => provider.complete(request),
-            CompletionProvider::Ollama(provider) => provider.complete(request),
-            #[cfg(test)]
-            CompletionProvider::Fake(provider) => provider.complete(),
+        // Previously configured provider was changed to another one
+        if updated.is_none() {
+            if let Some(client) = self.client.clone() {
+                self.provider = create_provider_from_settings(client, version, cx);
+            } else {
+                log::warn!("completion provider cannot be created because client is not set");
+            }
        }
    }
 }
+
+fn create_provider_from_settings(
+    client: Arc<Client>,
+    settings_version: usize,
+    cx: &mut AppContext,
+) -> Arc<RwLock<dyn LanguageModelCompletionProvider>> {
+    match &AssistantSettings::get_global(cx).provider {
+        AssistantProvider::ZedDotDev { model } => Arc::new(RwLock::new(
+            CloudCompletionProvider::new(model.clone(), client.clone(), settings_version, cx),
+        )),
+        AssistantProvider::OpenAi {
+            model,
+            api_url,
+            low_speed_timeout_in_seconds,
+            available_models,
+        } => Arc::new(RwLock::new(OpenAiCompletionProvider::new(
+            choose_openai_model(&model, &available_models),
+            api_url.clone(),
+            client.http_client(),
+            low_speed_timeout_in_seconds.map(Duration::from_secs),
+            settings_version,
+        ))),
+        AssistantProvider::Anthropic {
+            model,
+            api_url,
+            low_speed_timeout_in_seconds,
+        } => Arc::new(RwLock::new(AnthropicCompletionProvider::new(
+            model.clone(),
+            api_url.clone(),
+            client.http_client(),
+            low_speed_timeout_in_seconds.map(Duration::from_secs),
+            settings_version,
+        ))),
+        AssistantProvider::Ollama {
+            model,
+            api_url,
+            low_speed_timeout_in_seconds,
+        } => Arc::new(RwLock::new(OllamaCompletionProvider::new(
+            model.clone(),
+            api_url.clone(),
+            client.http_client(),
+            low_speed_timeout_in_seconds.map(Duration::from_secs),
+            settings_version,
+            cx,
+        ))),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use gpui::AppContext;
+    use parking_lot::RwLock;
+    use settings::SettingsStore;
+    use smol::stream::StreamExt;
+
+    use crate::{
+        completion_provider::MAX_CONCURRENT_COMPLETION_REQUESTS, CompletionProvider,
+        FakeCompletionProvider, LanguageModelRequest,
+    };
+
+    #[gpui::test]
+    fn test_rate_limiting(cx: &mut AppContext) {
+        SettingsStore::test(cx);
+        let fake_provider = FakeCompletionProvider::setup_test(cx);
+
+        let provider = CompletionProvider::new(Arc::new(RwLock::new(fake_provider.clone())), None);
+
+        // Enqueue some requests
+        for i in 0..MAX_CONCURRENT_COMPLETION_REQUESTS * 2 {
+            let response = provider.complete(
+                LanguageModelRequest {
+                    temperature: i as f32 / 10.0,
+                    ..Default::default()
+                },
+                cx,
+            );
+            cx.background_executor()
+                .spawn(async move {
+                    let response = response.await;
+                    let mut stream = response.inner.await.unwrap();
+                    while let Some(message) = stream.next().await {
+                        message.unwrap();
+                    }
+                })
+                .detach();
+        }
+        cx.background_executor().run_until_parked();
+
+        assert_eq!(
+            fake_provider.completion_count(),
+            MAX_CONCURRENT_COMPLETION_REQUESTS
+        );
+
+        // Get the first completion request that is in flight and mark it as completed.
+        let completion = fake_provider
+            .running_completions()
+            .into_iter()
+            .next()
+            .unwrap();
+        fake_provider.finish_completion(&completion);
+
+        // Ensure that the number of in-flight completion requests is reduced.
+        assert_eq!(
+            fake_provider.completion_count(),
+            MAX_CONCURRENT_COMPLETION_REQUESTS - 1
+        );
+
+        cx.background_executor().run_until_parked();
+
+        // Ensure that another completion request was allowed to acquire the lock.
+        assert_eq!(
+            fake_provider.completion_count(),
+            MAX_CONCURRENT_COMPLETION_REQUESTS
+        );
+
+        // Mark all completion requests as finished that are in flight.
+        for request in fake_provider.running_completions() {
+            fake_provider.finish_completion(&request);
+        }
+
+        assert_eq!(fake_provider.completion_count(), 0);
+
+        // Wait until the background tasks acquire the lock again.
+        cx.background_executor().run_until_parked();
+
+        assert_eq!(
+            fake_provider.completion_count(),
+            MAX_CONCURRENT_COMPLETION_REQUESTS - 1
+        );
+
+        // Finish all remaining completion requests.
+        for request in fake_provider.running_completions() {
+            fake_provider.finish_completion(&request);
+        }
+
+        cx.background_executor().run_until_parked();
+
+        assert_eq!(fake_provider.completion_count(), 0);
+    }
+}
--- a/crates/assistant/src/completion_provider/anthropic.rs
+++ b/crates/assistant/src/completion_provider/anthropic.rs
@@ -2,7 +2,7 @@ use crate::{
    assistant_settings::AnthropicModel, CompletionProvider, LanguageModel, LanguageModelRequest,
    Role,
 };
-use crate::{count_open_ai_tokens, LanguageModelRequestMessage};
+use crate::{count_open_ai_tokens, LanguageModelCompletionProvider, LanguageModelRequestMessage};
 use anthropic::{stream_completion, Request, RequestMessage};
 use anyhow::{anyhow, Result};
 use editor::{Editor, EditorElement, EditorStyle};
@@ -26,50 +26,22 @@ pub struct AnthropicCompletionProvider {
    settings_version: usize,
 }

-impl AnthropicCompletionProvider {
-    pub fn new(
-        model: AnthropicModel,
-        api_url: String,
-        http_client: Arc<dyn HttpClient>,
-        low_speed_timeout: Option<Duration>,
-        settings_version: usize,
-    ) -> Self {
-        Self {
-            api_key: None,
-            api_url,
-            model,
-            http_client,
-            low_speed_timeout,
-            settings_version,
-        }
-    }
-
-    pub fn update(
-        &mut self,
-        model: AnthropicModel,
-        api_url: String,
-        low_speed_timeout: Option<Duration>,
-        settings_version: usize,
-    ) {
-        self.model = model;
-        self.api_url = api_url;
-        self.low_speed_timeout = low_speed_timeout;
-        self.settings_version = settings_version;
-    }
-
-    pub fn available_models(&self) -> impl Iterator<Item = AnthropicModel> {
+impl LanguageModelCompletionProvider for AnthropicCompletionProvider {
+    fn available_models(&self, _cx: &AppContext) -> Vec<LanguageModel> {
        AnthropicModel::iter()
+            .map(LanguageModel::Anthropic)
+            .collect()
    }

-    pub fn settings_version(&self) -> usize {
+    fn settings_version(&self) -> usize {
        self.settings_version
    }

-    pub fn is_authenticated(&self) -> bool {
+    fn is_authenticated(&self) -> bool {
        self.api_key.is_some()
    }

-    pub fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
+    fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
        if self.is_authenticated() {
            Task::ready(Ok(()))
        } else {
@@ -85,36 +57,36 @@ impl AnthropicCompletionProvider {
                    String::from_utf8(api_key)?
                };
                cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                    if let CompletionProvider::Anthropic(provider) = provider {
+                    provider.update_current_as::<_, AnthropicCompletionProvider>(|provider| {
                        provider.api_key = Some(api_key);
-                    }
+                    });
                })
            })
        }
    }

-    pub fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
+    fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
        let delete_credentials = cx.delete_credentials(&self.api_url);
        cx.spawn(|mut cx| async move {
            delete_credentials.await.log_err();
            cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                if let CompletionProvider::Anthropic(provider) = provider {
+                provider.update_current_as::<_, AnthropicCompletionProvider>(|provider| {
                    provider.api_key = None;
-                }
+                });
            })
        })
    }

-    pub fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
+    fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
        cx.new_view(|cx| AuthenticationPrompt::new(self.api_url.clone(), cx))
            .into()
    }

-    pub fn model(&self) -> AnthropicModel {
-        self.model.clone()
+    fn model(&self) -> LanguageModel {
+        LanguageModel::Anthropic(self.model.clone())
    }

-    pub fn count_tokens(
+    fn count_tokens(
        &self,
        request: LanguageModelRequest,
        cx: &AppContext,
@@ -122,7 +94,7 @@ impl AnthropicCompletionProvider {
        count_open_ai_tokens(request, cx.background_executor())
    }

-    pub fn complete(
+    fn complete(
        &self,
        request: LanguageModelRequest,
    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
@@ -167,12 +139,48 @@ impl AnthropicCompletionProvider {
        .boxed()
    }

+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
+}
+
+impl AnthropicCompletionProvider {
+    pub fn new(
+        model: AnthropicModel,
+        api_url: String,
+        http_client: Arc<dyn HttpClient>,
+        low_speed_timeout: Option<Duration>,
+        settings_version: usize,
+    ) -> Self {
+        Self {
+            api_key: None,
+            api_url,
+            model,
+            http_client,
+            low_speed_timeout,
+            settings_version,
+        }
+    }
+
+    pub fn update(
+        &mut self,
+        model: AnthropicModel,
+        api_url: String,
+        low_speed_timeout: Option<Duration>,
+        settings_version: usize,
+    ) {
+        self.model = model;
+        self.api_url = api_url;
+        self.low_speed_timeout = low_speed_timeout;
+        self.settings_version = settings_version;
+    }
+
    fn to_anthropic_request(&self, mut request: LanguageModelRequest) -> Request {
        preprocess_anthropic_request(&mut request);

        let model = match request.model {
            LanguageModel::Anthropic(model) => model,
-            _ => self.model(),
+            _ => self.model.clone(),
        };

        let mut system_message = String::new();
@@ -278,9 +286,9 @@ impl AuthenticationPrompt {
        cx.spawn(|_, mut cx| async move {
            write_credentials.await?;
            cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                if let CompletionProvider::Anthropic(provider) = provider {
+                provider.update_current_as::<_, AnthropicCompletionProvider>(|provider| {
                    provider.api_key = Some(api_key);
-                }
+                });
            })
        })
        .detach_and_log_err(cx);
--- a/crates/assistant/src/completion_provider/cloud.rs
+++ b/crates/assistant/src/completion_provider/cloud.rs
@@ -1,6 +1,6 @@
 use crate::{
    assistant_settings::CloudModel, count_open_ai_tokens, CompletionProvider, LanguageModel,
-    LanguageModelRequest,
+    LanguageModelCompletionProvider, LanguageModelRequest,
 };
 use anyhow::{anyhow, Result};
 use client::{proto, Client};
@@ -30,11 +30,9 @@ impl CloudCompletionProvider {
        let maintain_client_status = cx.spawn(|mut cx| async move {
            while let Some(status) = status_rx.next().await {
                let _ = cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                    if let CompletionProvider::Cloud(provider) = provider {
+                    provider.update_current_as::<_, Self>(|provider| {
                        provider.status = status;
-                    } else {
-                        unreachable!()
-                    }
+                    });
                });
            }
        });
@@ -51,44 +49,53 @@ impl CloudCompletionProvider {
        self.model = model;
        self.settings_version = settings_version;
    }
+}

-    pub fn available_models(&self) -> impl Iterator<Item = CloudModel> {
+impl LanguageModelCompletionProvider for CloudCompletionProvider {
+    fn available_models(&self, _cx: &AppContext) -> Vec<LanguageModel> {
        let mut custom_model = if let CloudModel::Custom(custom_model) = self.model.clone() {
            Some(custom_model)
        } else {
            None
        };
-        CloudModel::iter().filter_map(move |model| {
-            if let CloudModel::Custom(_) = model {
-                Some(CloudModel::Custom(custom_model.take()?))
-            } else {
-                Some(model)
-            }
-        })
+        CloudModel::iter()
+            .filter_map(move |model| {
+                if let CloudModel::Custom(_) = model {
+                    Some(CloudModel::Custom(custom_model.take()?))
+                } else {
+                    Some(model)
+                }
+            })
+            .map(LanguageModel::Cloud)
+            .collect()
    }

-    pub fn settings_version(&self) -> usize {
+    fn settings_version(&self) -> usize {
        self.settings_version
    }

-    pub fn model(&self) -> CloudModel {
-        self.model.clone()
-    }
-
-    pub fn is_authenticated(&self) -> bool {
+    fn is_authenticated(&self) -> bool {
        self.status.is_connected()
    }

-    pub fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
+    fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
        let client = self.client.clone();
        cx.spawn(move |cx| async move { client.authenticate_and_connect(true, &cx).await })
    }

-    pub fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
+    fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
        cx.new_view(|_cx| AuthenticationPrompt).into()
    }

-    pub fn count_tokens(
+    fn reset_credentials(&self, _cx: &AppContext) -> Task<Result<()>> {
+        Task::ready(Ok(()))
+    }
+
+    fn model(&self) -> LanguageModel {
+        LanguageModel::Cloud(self.model.clone())
+    }
+
+    fn count_tokens(
        &self,
        request: LanguageModelRequest,
        cx: &AppContext,
@@ -128,7 +135,7 @@ impl CloudCompletionProvider {
        }
    }

-    pub fn complete(
+    fn complete(
        &self,
        mut request: LanguageModelRequest,
    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
@@ -161,6 +168,10 @@ impl CloudCompletionProvider {
            })
            .boxed()
    }
+
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
 }

 struct AuthenticationPrompt;
--- a/crates/assistant/src/completion_provider/fake.rs
+++ b/crates/assistant/src/completion_provider/fake.rs
@@ -1,29 +1,106 @@
 use anyhow::Result;
+use collections::HashMap;
 use futures::{channel::mpsc, future::BoxFuture, stream::BoxStream, FutureExt, StreamExt};
+use gpui::{AnyView, AppContext, Task};
 use std::sync::Arc;
+use ui::WindowContext;
+
+use crate::{LanguageModel, LanguageModelCompletionProvider, LanguageModelRequest};

 #[derive(Clone, Default)]
 pub struct FakeCompletionProvider {
-    current_completion_tx: Arc<parking_lot::Mutex<Option<mpsc::UnboundedSender<String>>>>,
+    current_completion_txs: Arc<parking_lot::Mutex<HashMap<String, mpsc::UnboundedSender<String>>>>,
 }

 impl FakeCompletionProvider {
-    pub fn complete(&self) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
-        let (tx, rx) = mpsc::unbounded();
-        *self.current_completion_tx.lock() = Some(tx);
-        async move { Ok(rx.map(Ok).boxed()) }.boxed()
+    pub fn setup_test(cx: &mut AppContext) -> Self {
+        use crate::CompletionProvider;
+        use parking_lot::RwLock;
+
+        let this = Self::default();
+        let provider = CompletionProvider::new(Arc::new(RwLock::new(this.clone())), None);
+        cx.set_global(provider);
+        this
    }

-    pub fn send_completion(&self, chunk: String) {
-        self.current_completion_tx
+    pub fn running_completions(&self) -> Vec<LanguageModelRequest> {
+        self.current_completion_txs
            .lock()
-            .as_ref()
+            .keys()
+            .map(|k| serde_json::from_str(k).unwrap())
+            .collect()
+    }
+
+    pub fn completion_count(&self) -> usize {
+        self.current_completion_txs.lock().len()
+    }
+
+    pub fn send_completion(&self, request: &LanguageModelRequest, chunk: String) {
+        let json = serde_json::to_string(request).unwrap();
+        self.current_completion_txs
+            .lock()
+            .get(&json)
            .unwrap()
            .unbounded_send(chunk)
            .unwrap();
    }

-    pub fn finish_completion(&self) {
-        self.current_completion_tx.lock().take();
+    pub fn finish_completion(&self, request: &LanguageModelRequest) {
+        self.current_completion_txs
+            .lock()
+            .remove(&serde_json::to_string(request).unwrap());
+    }
+}
+
+impl LanguageModelCompletionProvider for FakeCompletionProvider {
+    fn available_models(&self, _cx: &AppContext) -> Vec<LanguageModel> {
+        vec![LanguageModel::default()]
+    }
+
+    fn settings_version(&self) -> usize {
+        0
+    }
+
+    fn is_authenticated(&self) -> bool {
+        true
+    }
+
+    fn authenticate(&self, _cx: &AppContext) -> Task<Result<()>> {
+        Task::ready(Ok(()))
+    }
+
+    fn authentication_prompt(&self, _cx: &mut WindowContext) -> AnyView {
+        unimplemented!()
+    }
+
+    fn reset_credentials(&self, _cx: &AppContext) -> Task<Result<()>> {
+        Task::ready(Ok(()))
+    }
+
+    fn model(&self) -> LanguageModel {
+        LanguageModel::default()
+    }
+
+    fn count_tokens(
+        &self,
+        _request: LanguageModelRequest,
+        _cx: &AppContext,
+    ) -> BoxFuture<'static, Result<usize>> {
+        futures::future::ready(Ok(0)).boxed()
+    }
+
+    fn complete(
+        &self,
+        _request: LanguageModelRequest,
+    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
+        let (tx, rx) = mpsc::unbounded();
+        self.current_completion_txs
+            .lock()
+            .insert(serde_json::to_string(&_request).unwrap(), tx);
+        async move { Ok(rx.map(Ok).boxed()) }.boxed()
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
    }
 }
--- a/crates/assistant/src/completion_provider/ollama.rs
+++ b/crates/assistant/src/completion_provider/ollama.rs
@@ -1,3 +1,4 @@
+use crate::LanguageModelCompletionProvider;
 use crate::{
    assistant_settings::OllamaModel, CompletionProvider, LanguageModel, LanguageModelRequest, Role,
 };
@@ -26,6 +27,108 @@ pub struct OllamaCompletionProvider {
    available_models: Vec<OllamaModel>,
 }

+impl LanguageModelCompletionProvider for OllamaCompletionProvider {
+    fn available_models(&self, _cx: &AppContext) -> Vec<LanguageModel> {
+        self.available_models
+            .iter()
+            .map(|m| LanguageModel::Ollama(m.clone()))
+            .collect()
+    }
+
+    fn settings_version(&self) -> usize {
+        self.settings_version
+    }
+
+    fn is_authenticated(&self) -> bool {
+        !self.available_models.is_empty()
+    }
+
+    fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
+        if self.is_authenticated() {
+            Task::ready(Ok(()))
+        } else {
+            self.fetch_models(cx)
+        }
+    }
+
+    fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
+        let fetch_models = Box::new(move |cx: &mut WindowContext| {
+            cx.update_global::<CompletionProvider, _>(|provider, cx| {
+                provider
+                    .update_current_as::<_, OllamaCompletionProvider>(|provider| {
+                        provider.fetch_models(cx)
+                    })
+                    .unwrap_or_else(|| Task::ready(Ok(())))
+            })
+        });
+
+        cx.new_view(|cx| DownloadOllamaMessage::new(fetch_models, cx))
+            .into()
+    }
+
+    fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
+        self.fetch_models(cx)
+    }
+
+    fn model(&self) -> LanguageModel {
+        LanguageModel::Ollama(self.model.clone())
+    }
+
+    fn count_tokens(
+        &self,
+        request: LanguageModelRequest,
+        _cx: &AppContext,
+    ) -> BoxFuture<'static, Result<usize>> {
+        // There is no endpoint for this _yet_ in Ollama
+        // see: https://github.com/ollama/ollama/issues/1716 and https://github.com/ollama/ollama/issues/3582
+        let token_count = request
+            .messages
+            .iter()
+            .map(|msg| msg.content.chars().count())
+            .sum::<usize>()
+            / 4;
+
+        async move { Ok(token_count) }.boxed()
+    }
+
+    fn complete(
+        &self,
+        request: LanguageModelRequest,
+    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
+        let request = self.to_ollama_request(request);
+
+        let http_client = self.http_client.clone();
+        let api_url = self.api_url.clone();
+        let low_speed_timeout = self.low_speed_timeout;
+        async move {
+            let request =
+                stream_chat_completion(http_client.as_ref(), &api_url, request, low_speed_timeout);
+            let response = request.await?;
+            let stream = response
+                .filter_map(|response| async move {
+                    match response {
+                        Ok(delta) => {
+                            let content = match delta.message {
+                                ChatMessage::User { content } => content,
+                                ChatMessage::Assistant { content } => content,
+                                ChatMessage::System { content } => content,
+                            };
+                            Some(Ok(content))
+                        }
+                        Err(error) => Some(Err(error)),
+                    }
+                })
+                .boxed();
+            Ok(stream)
+        }
+        .boxed()
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
+}
+
 impl OllamaCompletionProvider {
    pub fn new(
        model: OllamaModel,
@@ -87,36 +190,12 @@ impl OllamaCompletionProvider {
        self.settings_version = settings_version;
    }

-    pub fn available_models(&self) -> impl Iterator<Item = &OllamaModel> {
-        self.available_models.iter()
-    }
-
    pub fn select_first_available_model(&mut self) {
        if let Some(model) = self.available_models.first() {
            self.model = model.clone();
        }
    }

-    pub fn settings_version(&self) -> usize {
-        self.settings_version
-    }
-
-    pub fn is_authenticated(&self) -> bool {
-        !self.available_models.is_empty()
-    }
-
-    pub fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
-        if self.is_authenticated() {
-            Task::ready(Ok(()))
-        } else {
-            self.fetch_models(cx)
-        }
-    }
-
-    pub fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
-        self.fetch_models(cx)
-    }
-
    pub fn fetch_models(&self, cx: &AppContext) -> Task<Result<()>> {
        let http_client = self.http_client.clone();
        let api_url = self.api_url.clone();
@@ -137,90 +216,21 @@ impl OllamaCompletionProvider {
            models.sort_by(|a, b| a.name.cmp(&b.name));

            cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                if let CompletionProvider::Ollama(provider) = provider {
+                provider.update_current_as::<_, OllamaCompletionProvider>(|provider| {
                    provider.available_models = models;

                    if !provider.available_models.is_empty() && provider.model.name.is_empty() {
                        provider.select_first_available_model()
                    }
-                }
+                });
            })
        })
    }

-    pub fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
-        let fetch_models = Box::new(move |cx: &mut WindowContext| {
-            cx.update_global::<CompletionProvider, _>(|provider, cx| {
-                if let CompletionProvider::Ollama(provider) = provider {
-                    provider.fetch_models(cx)
-                } else {
-                    Task::ready(Ok(()))
-                }
-            })
-        });
-
-        cx.new_view(|cx| DownloadOllamaMessage::new(fetch_models, cx))
-            .into()
-    }
-
-    pub fn model(&self) -> OllamaModel {
-        self.model.clone()
-    }
-
-    pub fn count_tokens(
-        &self,
-        request: LanguageModelRequest,
-        _cx: &AppContext,
-    ) -> BoxFuture<'static, Result<usize>> {
-        // There is no endpoint for this _yet_ in Ollama
-        // see: https://github.com/ollama/ollama/issues/1716 and https://github.com/ollama/ollama/issues/3582
-        let token_count = request
-            .messages
-            .iter()
-            .map(|msg| msg.content.chars().count())
-            .sum::<usize>()
-            / 4;
-
-        async move { Ok(token_count) }.boxed()
-    }
-
-    pub fn complete(
-        &self,
-        request: LanguageModelRequest,
-    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
-        let request = self.to_ollama_request(request);
-
-        let http_client = self.http_client.clone();
-        let api_url = self.api_url.clone();
-        let low_speed_timeout = self.low_speed_timeout;
-        async move {
-            let request =
-                stream_chat_completion(http_client.as_ref(), &api_url, request, low_speed_timeout);
-            let response = request.await?;
-            let stream = response
-                .filter_map(|response| async move {
-                    match response {
-                        Ok(delta) => {
-                            let content = match delta.message {
-                                ChatMessage::User { content } => content,
-                                ChatMessage::Assistant { content } => content,
-                                ChatMessage::System { content } => content,
-                            };
-                            Some(Ok(content))
-                        }
-                        Err(error) => Some(Err(error)),
-                    }
-                })
-                .boxed();
-            Ok(stream)
-        }
-        .boxed()
-    }
-
    fn to_ollama_request(&self, request: LanguageModelRequest) -> ChatRequest {
        let model = match request.model {
            LanguageModel::Ollama(model) => model,
-            _ => self.model(),
+            _ => self.model.clone(),
        };

        ChatRequest {
--- a/crates/assistant/src/completion_provider/open_ai.rs
+++ b/crates/assistant/src/completion_provider/open_ai.rs
@@ -1,5 +1,6 @@
 use crate::assistant_settings::CloudModel;
 use crate::assistant_settings::{AssistantProvider, AssistantSettings};
+use crate::LanguageModelCompletionProvider;
 use crate::{
    assistant_settings::OpenAiModel, CompletionProvider, LanguageModel, LanguageModelRequest, Role,
 };
@@ -57,37 +58,75 @@ impl OpenAiCompletionProvider {
        self.settings_version = settings_version;
    }

-    pub fn available_models(&self, cx: &AppContext) -> impl Iterator<Item = OpenAiModel> {
+    fn to_open_ai_request(&self, request: LanguageModelRequest) -> Request {
+        let model = match request.model {
+            LanguageModel::OpenAi(model) => model,
+            _ => self.model.clone(),
+        };
+
+        Request {
+            model,
+            messages: request
+                .messages
+                .into_iter()
+                .map(|msg| match msg.role {
+                    Role::User => RequestMessage::User {
+                        content: msg.content,
+                    },
+                    Role::Assistant => RequestMessage::Assistant {
+                        content: Some(msg.content),
+                        tool_calls: Vec::new(),
+                    },
+                    Role::System => RequestMessage::System {
+                        content: msg.content,
+                    },
+                })
+                .collect(),
+            stream: true,
+            stop: request.stop,
+            temperature: request.temperature,
+            tools: Vec::new(),
+            tool_choice: None,
+        }
+    }
+}
+
+impl LanguageModelCompletionProvider for OpenAiCompletionProvider {
+    fn available_models(&self, cx: &AppContext) -> Vec<LanguageModel> {
        if let AssistantProvider::OpenAi {
            available_models, ..
        } = &AssistantSettings::get_global(cx).provider
        {
            if !available_models.is_empty() {
-                // available_models is set, just return it
-                return available_models.clone().into_iter();
+                return available_models
+                    .iter()
+                    .cloned()
+                    .map(LanguageModel::OpenAi)
+                    .collect();
            }
        }
        let available_models = if matches!(self.model, OpenAiModel::Custom { .. }) {
-            // available_models is not set but the default model is set to custom, only show custom
            vec![self.model.clone()]
        } else {
-            // default case, use all models except custom
            OpenAiModel::iter()
                .filter(|model| !matches!(model, OpenAiModel::Custom { .. }))
                .collect()
        };
-        available_models.into_iter()
+        available_models
+            .into_iter()
+            .map(LanguageModel::OpenAi)
+            .collect()
    }

-    pub fn settings_version(&self) -> usize {
+    fn settings_version(&self) -> usize {
        self.settings_version
    }

-    pub fn is_authenticated(&self) -> bool {
+    fn is_authenticated(&self) -> bool {
        self.api_key.is_some()
    }

-    pub fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
+    fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
        if self.is_authenticated() {
            Task::ready(Ok(()))
        } else {
@@ -103,36 +142,36 @@ impl OpenAiCompletionProvider {
                    String::from_utf8(api_key)?
                };
                cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                    if let CompletionProvider::OpenAi(provider) = provider {
+                    provider.update_current_as::<_, Self>(|provider| {
                        provider.api_key = Some(api_key);
-                    }
+                    });
                })
            })
        }
    }

-    pub fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
+    fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
        let delete_credentials = cx.delete_credentials(&self.api_url);
        cx.spawn(|mut cx| async move {
            delete_credentials.await.log_err();
            cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                if let CompletionProvider::OpenAi(provider) = provider {
+                provider.update_current_as::<_, Self>(|provider| {
                    provider.api_key = None;
-                }
+                });
            })
        })
    }

-    pub fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
+    fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
        cx.new_view(|cx| AuthenticationPrompt::new(self.api_url.clone(), cx))
            .into()
    }

-    pub fn model(&self) -> OpenAiModel {
-        self.model.clone()
+    fn model(&self) -> LanguageModel {
+        LanguageModel::OpenAi(self.model.clone())
    }

-    pub fn count_tokens(
+    fn count_tokens(
        &self,
        request: LanguageModelRequest,
        cx: &AppContext,
@@ -140,7 +179,7 @@ impl OpenAiCompletionProvider {
        count_open_ai_tokens(request, cx.background_executor())
    }

-    pub fn complete(
+    fn complete(
        &self,
        request: LanguageModelRequest,
    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
@@ -173,36 +212,8 @@ impl OpenAiCompletionProvider {
        .boxed()
    }

-    fn to_open_ai_request(&self, request: LanguageModelRequest) -> Request {
-        let model = match request.model {
-            LanguageModel::OpenAi(model) => model,
-            _ => self.model(),
-        };
-
-        Request {
-            model,
-            messages: request
-                .messages
-                .into_iter()
-                .map(|msg| match msg.role {
-                    Role::User => RequestMessage::User {
-                        content: msg.content,
-                    },
-                    Role::Assistant => RequestMessage::Assistant {
-                        content: Some(msg.content),
-                        tool_calls: Vec::new(),
-                    },
-                    Role::System => RequestMessage::System {
-                        content: msg.content,
-                    },
-                })
-                .collect(),
-            stream: true,
-            stop: request.stop,
-            temperature: request.temperature,
-            tools: Vec::new(),
-            tool_choice: None,
-        }
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
    }
 }

@@ -284,9 +295,9 @@ impl AuthenticationPrompt {
        cx.spawn(|_, mut cx| async move {
            write_credentials.await?;
            cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                if let CompletionProvider::OpenAi(provider) = provider {
+                provider.update_current_as::<_, OpenAiCompletionProvider>(|provider| {
                    provider.api_key = Some(api_key);
-                }
+                });
            })
        })
        .detach_and_log_err(cx);
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
--- a/crates/assistant/src/context_store.rs
+++ b/crates/assistant/src/context_store.rs
@@ -1,97 +1,117 @@
-use crate::{assistant_settings::OpenAiModel, MessageId, MessageMetadata};
-use anyhow::{anyhow, Result};
-use assistant_slash_command::SlashCommandOutputSection;
-use collections::HashMap;
+use crate::{
+    Context, ContextEvent, ContextId, ContextOperation, ContextVersion, SavedContext,
+    SavedContextMetadata,
+};
+use anyhow::{anyhow, Context as _, Result};
+use client::{proto, telemetry::Telemetry, Client, TypedEnvelope};
+use clock::ReplicaId;
 use fs::Fs;
 use futures::StreamExt;
 use fuzzy::StringMatchCandidate;
-use gpui::{AppContext, Model, ModelContext, Task};
+use gpui::{AppContext, AsyncAppContext, Context as _, Model, ModelContext, Task, WeakModel};
+use language::LanguageRegistry;
 use paths::contexts_dir;
+use project::Project;
 use regex::Regex;
-use serde::{Deserialize, Serialize};
-use std::{cmp::Reverse, ffi::OsStr, path::PathBuf, sync::Arc, time::Duration};
-use ui::Context;
+use std::{
+    cmp::Reverse,
+    ffi::OsStr,
+    mem,
+    path::{Path, PathBuf},
+    sync::Arc,
+    time::Duration,
+};
 use util::{ResultExt, TryFutureExt};

-#[derive(Serialize, Deserialize)]
-pub struct SavedMessage {
-    pub id: MessageId,
-    pub start: usize,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct SavedContext {
-    pub id: Option<String>,
-    pub zed: String,
-    pub version: String,
-    pub text: String,
-    pub messages: Vec<SavedMessage>,
-    pub message_metadata: HashMap<MessageId, MessageMetadata>,
-    pub summary: String,
-    pub slash_command_output_sections: Vec<SlashCommandOutputSection<usize>>,
-}
-
-impl SavedContext {
-    pub const VERSION: &'static str = "0.3.0";
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct SavedContextV0_2_0 {
-    pub id: Option<String>,
-    pub zed: String,
-    pub version: String,
-    pub text: String,
-    pub messages: Vec<SavedMessage>,
-    pub message_metadata: HashMap<MessageId, MessageMetadata>,
-    pub summary: String,
-}
-
-#[derive(Serialize, Deserialize)]
-struct SavedContextV0_1_0 {
-    id: Option<String>,
-    zed: String,
-    version: String,
-    text: String,
-    messages: Vec<SavedMessage>,
-    message_metadata: HashMap<MessageId, MessageMetadata>,
-    summary: String,
-    api_url: Option<String>,
-    model: OpenAiModel,
+pub fn init(client: &Arc<Client>) {
+    client.add_model_message_handler(ContextStore::handle_advertise_contexts);
+    client.add_model_request_handler(ContextStore::handle_open_context);
+    client.add_model_message_handler(ContextStore::handle_update_context);
+    client.add_model_request_handler(ContextStore::handle_synchronize_contexts);
 }

 #[derive(Clone)]
-pub struct SavedContextMetadata {
-    pub title: String,
-    pub path: PathBuf,
-    pub mtime: chrono::DateTime<chrono::Local>,
+pub struct RemoteContextMetadata {
+    pub id: ContextId,
+    pub summary: Option<String>,
 }

 pub struct ContextStore {
+    contexts: Vec<ContextHandle>,
    contexts_metadata: Vec<SavedContextMetadata>,
+    host_contexts: Vec<RemoteContextMetadata>,
    fs: Arc<dyn Fs>,
+    languages: Arc<LanguageRegistry>,
+    telemetry: Arc<Telemetry>,
    _watch_updates: Task<Option<()>>,
+    client: Arc<Client>,
+    project: Model<Project>,
+    project_is_shared: bool,
+    client_subscription: Option<client::Subscription>,
+    _project_subscriptions: Vec<gpui::Subscription>,
+}
+
+enum ContextHandle {
+    Weak(WeakModel<Context>),
+    Strong(Model<Context>),
+}
+
+impl ContextHandle {
+    fn upgrade(&self) -> Option<Model<Context>> {
+        match self {
+            ContextHandle::Weak(weak) => weak.upgrade(),
+            ContextHandle::Strong(strong) => Some(strong.clone()),
+        }
+    }
+
+    fn downgrade(&self) -> WeakModel<Context> {
+        match self {
+            ContextHandle::Weak(weak) => weak.clone(),
+            ContextHandle::Strong(strong) => strong.downgrade(),
+        }
+    }
 }

 impl ContextStore {
-    pub fn new(fs: Arc<dyn Fs>, cx: &mut AppContext) -> Task<Result<Model<Self>>> {
+    pub fn new(project: Model<Project>, cx: &mut AppContext) -> Task<Result<Model<Self>>> {
+        let fs = project.read(cx).fs().clone();
+        let languages = project.read(cx).languages().clone();
+        let telemetry = project.read(cx).client().telemetry().clone();
        cx.spawn(|mut cx| async move {
            const CONTEXT_WATCH_DURATION: Duration = Duration::from_millis(100);
            let (mut events, _) = fs.watch(contexts_dir(), CONTEXT_WATCH_DURATION).await;

-            let this = cx.new_model(|cx: &mut ModelContext<Self>| Self {
-                contexts_metadata: Vec::new(),
-                fs,
-                _watch_updates: cx.spawn(|this, mut cx| {
-                    async move {
-                        while events.next().await.is_some() {
-                            this.update(&mut cx, |this, cx| this.reload(cx))?
-                                .await
-                                .log_err();
+            let this = cx.new_model(|cx: &mut ModelContext<Self>| {
+                let mut this = Self {
+                    contexts: Vec::new(),
+                    contexts_metadata: Vec::new(),
+                    host_contexts: Vec::new(),
+                    fs,
+                    languages,
+                    telemetry,
+                    _watch_updates: cx.spawn(|this, mut cx| {
+                        async move {
+                            while events.next().await.is_some() {
+                                this.update(&mut cx, |this, cx| this.reload(cx))?
+                                    .await
+                                    .log_err();
+                            }
+                            anyhow::Ok(())
                        }
-                        anyhow::Ok(())
-                    }
-                    .log_err()
-                }),
+                        .log_err()
+                    }),
+                    client_subscription: None,
+                    _project_subscriptions: vec![
+                        cx.observe(&project, Self::handle_project_changed),
+                        cx.subscribe(&project, Self::handle_project_event),
+                    ],
+                    project_is_shared: false,
+                    client: project.read(cx).client(),
+                    project: project.clone(),
+                };
+                this.handle_project_changed(project, cx);
+                this.synchronize_contexts(cx);
+                this
            })?;
            this.update(&mut cx, |this, cx| this.reload(cx))?
                .await
@@ -100,54 +120,433 @@ impl ContextStore {
        })
    }

-    pub fn load(&self, path: PathBuf, cx: &AppContext) -> Task<Result<SavedContext>> {
+    async fn handle_advertise_contexts(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::AdvertiseContexts>,
+        mut cx: AsyncAppContext,
+    ) -> Result<()> {
+        this.update(&mut cx, |this, cx| {
+            this.host_contexts = envelope
+                .payload
+                .contexts
+                .into_iter()
+                .map(|context| RemoteContextMetadata {
+                    id: ContextId::from_proto(context.context_id),
+                    summary: context.summary,
+                })
+                .collect();
+            cx.notify();
+        })
+    }
+
+    async fn handle_open_context(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::OpenContext>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::OpenContextResponse> {
+        let context_id = ContextId::from_proto(envelope.payload.context_id);
+        let operations = this.update(&mut cx, |this, cx| {
+            if this.project.read(cx).is_remote() {
+                return Err(anyhow!("only the host contexts can be opened"));
+            }
+
+            let context = this
+                .loaded_context_for_id(&context_id, cx)
+                .context("context not found")?;
+            if context.read(cx).replica_id() != ReplicaId::default() {
+                return Err(anyhow!("context must be opened via the host"));
+            }
+
+            anyhow::Ok(
+                context
+                    .read(cx)
+                    .serialize_ops(&ContextVersion::default(), cx),
+            )
+        })??;
+        let operations = operations.await;
+        Ok(proto::OpenContextResponse {
+            context: Some(proto::Context { operations }),
+        })
+    }
+
+    async fn handle_update_context(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::UpdateContext>,
+        mut cx: AsyncAppContext,
+    ) -> Result<()> {
+        this.update(&mut cx, |this, cx| {
+            let context_id = ContextId::from_proto(envelope.payload.context_id);
+            if let Some(context) = this.loaded_context_for_id(&context_id, cx) {
+                let operation_proto = envelope.payload.operation.context("invalid operation")?;
+                let operation = ContextOperation::from_proto(operation_proto)?;
+                context.update(cx, |context, cx| context.apply_ops([operation], cx))?;
+            }
+            Ok(())
+        })?
+    }
+
+    async fn handle_synchronize_contexts(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::SynchronizeContexts>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::SynchronizeContextsResponse> {
+        this.update(&mut cx, |this, cx| {
+            if this.project.read(cx).is_remote() {
+                return Err(anyhow!("only the host can synchronize contexts"));
+            }
+
+            let mut local_versions = Vec::new();
+            for remote_version_proto in envelope.payload.contexts {
+                let remote_version = ContextVersion::from_proto(&remote_version_proto);
+                let context_id = ContextId::from_proto(remote_version_proto.context_id);
+                if let Some(context) = this.loaded_context_for_id(&context_id, cx) {
+                    let context = context.read(cx);
+                    let operations = context.serialize_ops(&remote_version, cx);
+                    local_versions.push(context.version(cx).to_proto(context_id.clone()));
+                    let client = this.client.clone();
+                    let project_id = envelope.payload.project_id;
+                    cx.background_executor()
+                        .spawn(async move {
+                            let operations = operations.await;
+                            for operation in operations {
+                                client.send(proto::UpdateContext {
+                                    project_id,
+                                    context_id: context_id.to_proto(),
+                                    operation: Some(operation),
+                                })?;
+                            }
+                            anyhow::Ok(())
+                        })
+                        .detach_and_log_err(cx);
+                }
+            }
+
+            this.advertise_contexts(cx);
+
+            anyhow::Ok(proto::SynchronizeContextsResponse {
+                contexts: local_versions,
+            })
+        })?
+    }
+
+    fn handle_project_changed(&mut self, _: Model<Project>, cx: &mut ModelContext<Self>) {
+        let is_shared = self.project.read(cx).is_shared();
+        let was_shared = mem::replace(&mut self.project_is_shared, is_shared);
+        if is_shared == was_shared {
+            return;
+        }
+
+        if is_shared {
+            self.contexts.retain_mut(|context| {
+                if let Some(strong_context) = context.upgrade() {
+                    *context = ContextHandle::Strong(strong_context);
+                    true
+                } else {
+                    false
+                }
+            });
+            let remote_id = self.project.read(cx).remote_id().unwrap();
+            self.client_subscription = self
+                .client
+                .subscribe_to_entity(remote_id)
+                .log_err()
+                .map(|subscription| subscription.set_model(&cx.handle(), &mut cx.to_async()));
+            self.advertise_contexts(cx);
+        } else {
+            self.client_subscription = None;
+        }
+    }
+
+    fn handle_project_event(
+        &mut self,
+        _: Model<Project>,
+        event: &project::Event,
+        cx: &mut ModelContext<Self>,
+    ) {
+        match event {
+            project::Event::Reshared => {
+                self.advertise_contexts(cx);
+            }
+            project::Event::HostReshared | project::Event::Rejoined => {
+                self.synchronize_contexts(cx);
+            }
+            project::Event::DisconnectedFromHost => {
+                self.contexts.retain_mut(|context| {
+                    if let Some(strong_context) = context.upgrade() {
+                        *context = ContextHandle::Weak(context.downgrade());
+                        strong_context.update(cx, |context, cx| {
+                            if context.replica_id() != ReplicaId::default() {
+                                context.set_capability(language::Capability::ReadOnly, cx);
+                            }
+                        });
+                        true
+                    } else {
+                        false
+                    }
+                });
+                self.host_contexts.clear();
+                cx.notify();
+            }
+            _ => {}
+        }
+    }
+
+    pub fn create(&mut self, cx: &mut ModelContext<Self>) -> Model<Context> {
+        let context = cx.new_model(|cx| {
+            Context::local(self.languages.clone(), Some(self.telemetry.clone()), cx)
+        });
+        self.register_context(&context, cx);
+        context
+    }
+
+    pub fn open_local_context(
+        &mut self,
+        path: PathBuf,
+        cx: &ModelContext<Self>,
+    ) -> Task<Result<Model<Context>>> {
+        if let Some(existing_context) = self.loaded_context_for_path(&path, cx) {
+            return Task::ready(Ok(existing_context));
+        }
+
        let fs = self.fs.clone();
-        cx.background_executor().spawn(async move {
-            let saved_context = fs.load(&path).await?;
-            let saved_context_json = serde_json::from_str::<serde_json::Value>(&saved_context)?;
-            match saved_context_json
-                .get("version")
-                .ok_or_else(|| anyhow!("version not found"))?
-            {
-                serde_json::Value::String(version) => match version.as_str() {
-                    SavedContext::VERSION => {
-                        Ok(serde_json::from_value::<SavedContext>(saved_context_json)?)
-                    }
-                    "0.2.0" => {
-                        let saved_context =
-                            serde_json::from_value::<SavedContextV0_2_0>(saved_context_json)?;
-                        Ok(SavedContext {
-                            id: saved_context.id,
-                            zed: saved_context.zed,
-                            version: saved_context.version,
-                            text: saved_context.text,
-                            messages: saved_context.messages,
-                            message_metadata: saved_context.message_metadata,
-                            summary: saved_context.summary,
-                            slash_command_output_sections: Vec::new(),
-                        })
-                    }
-                    "0.1.0" => {
-                        let saved_context =
-                            serde_json::from_value::<SavedContextV0_1_0>(saved_context_json)?;
-                        Ok(SavedContext {
-                            id: saved_context.id,
-                            zed: saved_context.zed,
-                            version: saved_context.version,
-                            text: saved_context.text,
-                            messages: saved_context.messages,
-                            message_metadata: saved_context.message_metadata,
-                            summary: saved_context.summary,
-                            slash_command_output_sections: Vec::new(),
-                        })
-                    }
-                    _ => Err(anyhow!("unrecognized saved context version: {}", version)),
-                },
-                _ => Err(anyhow!("version not found on saved context")),
+        let languages = self.languages.clone();
+        let telemetry = self.telemetry.clone();
+        let load = cx.background_executor().spawn({
+            let path = path.clone();
+            async move {
+                let saved_context = fs.load(&path).await?;
+                SavedContext::from_json(&saved_context)
+            }
+        });
+
+        cx.spawn(|this, mut cx| async move {
+            let saved_context = load.await?;
+            let context = cx.new_model(|cx| {
+                Context::deserialize(saved_context, path.clone(), languages, Some(telemetry), cx)
+            })?;
+            this.update(&mut cx, |this, cx| {
+                if let Some(existing_context) = this.loaded_context_for_path(&path, cx) {
+                    existing_context
+                } else {
+                    this.register_context(&context, cx);
+                    context
+                }
+            })
+        })
+    }
+
+    fn loaded_context_for_path(&self, path: &Path, cx: &AppContext) -> Option<Model<Context>> {
+        self.contexts.iter().find_map(|context| {
+            let context = context.upgrade()?;
+            if context.read(cx).path() == Some(path) {
+                Some(context)
+            } else {
+                None
            }
        })
    }

+    fn loaded_context_for_id(&self, id: &ContextId, cx: &AppContext) -> Option<Model<Context>> {
+        self.contexts.iter().find_map(|context| {
+            let context = context.upgrade()?;
+            if context.read(cx).id() == id {
+                Some(context)
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn open_remote_context(
+        &mut self,
+        context_id: ContextId,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<Model<Context>>> {
+        let project = self.project.read(cx);
+        let Some(project_id) = project.remote_id() else {
+            return Task::ready(Err(anyhow!("project was not remote")));
+        };
+        if project.is_local() {
+            return Task::ready(Err(anyhow!("cannot open remote contexts as the host")));
+        }
+
+        if let Some(context) = self.loaded_context_for_id(&context_id, cx) {
+            return Task::ready(Ok(context));
+        }
+
+        let replica_id = project.replica_id();
+        let capability = project.capability();
+        let language_registry = self.languages.clone();
+        let telemetry = self.telemetry.clone();
+        let request = self.client.request(proto::OpenContext {
+            project_id,
+            context_id: context_id.to_proto(),
+        });
+        cx.spawn(|this, mut cx| async move {
+            let response = request.await?;
+            let context_proto = response.context.context("invalid context")?;
+            let context = cx.new_model(|cx| {
+                Context::new(
+                    context_id.clone(),
+                    replica_id,
+                    capability,
+                    language_registry,
+                    Some(telemetry),
+                    cx,
+                )
+            })?;
+            let operations = cx
+                .background_executor()
+                .spawn(async move {
+                    context_proto
+                        .operations
+                        .into_iter()
+                        .map(|op| ContextOperation::from_proto(op))
+                        .collect::<Result<Vec<_>>>()
+                })
+                .await?;
+            context.update(&mut cx, |context, cx| context.apply_ops(operations, cx))??;
+            this.update(&mut cx, |this, cx| {
+                if let Some(existing_context) = this.loaded_context_for_id(&context_id, cx) {
+                    existing_context
+                } else {
+                    this.register_context(&context, cx);
+                    this.synchronize_contexts(cx);
+                    context
+                }
+            })
+        })
+    }
+
+    fn register_context(&mut self, context: &Model<Context>, cx: &mut ModelContext<Self>) {
+        let handle = if self.project_is_shared {
+            ContextHandle::Strong(context.clone())
+        } else {
+            ContextHandle::Weak(context.downgrade())
+        };
+        self.contexts.push(handle);
+        self.advertise_contexts(cx);
+        cx.subscribe(context, Self::handle_context_event).detach();
+    }
+
+    fn handle_context_event(
+        &mut self,
+        context: Model<Context>,
+        event: &ContextEvent,
+        cx: &mut ModelContext<Self>,
+    ) {
+        let Some(project_id) = self.project.read(cx).remote_id() else {
+            return;
+        };
+
+        match event {
+            ContextEvent::SummaryChanged => {
+                self.advertise_contexts(cx);
+            }
+            ContextEvent::Operation(operation) => {
+                let context_id = context.read(cx).id().to_proto();
+                let operation = operation.to_proto();
+                self.client
+                    .send(proto::UpdateContext {
+                        project_id,
+                        context_id,
+                        operation: Some(operation),
+                    })
+                    .log_err();
+            }
+            _ => {}
+        }
+    }
+
+    fn advertise_contexts(&self, cx: &AppContext) {
+        let Some(project_id) = self.project.read(cx).remote_id() else {
+            return;
+        };
+
+        // For now, only the host can advertise their open contexts.
+        if self.project.read(cx).is_remote() {
+            return;
+        }
+
+        let contexts = self
+            .contexts
+            .iter()
+            .rev()
+            .filter_map(|context| {
+                let context = context.upgrade()?.read(cx);
+                if context.replica_id() == ReplicaId::default() {
+                    Some(proto::ContextMetadata {
+                        context_id: context.id().to_proto(),
+                        summary: context.summary().map(|summary| summary.text.clone()),
+                    })
+                } else {
+                    None
+                }
+            })
+            .collect();
+        self.client
+            .send(proto::AdvertiseContexts {
+                project_id,
+                contexts,
+            })
+            .ok();
+    }
+
+    fn synchronize_contexts(&mut self, cx: &mut ModelContext<Self>) {
+        let Some(project_id) = self.project.read(cx).remote_id() else {
+            return;
+        };
+
+        let contexts = self
+            .contexts
+            .iter()
+            .filter_map(|context| {
+                let context = context.upgrade()?.read(cx);
+                if context.replica_id() != ReplicaId::default() {
+                    Some(context.version(cx).to_proto(context.id().clone()))
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        let client = self.client.clone();
+        let request = self.client.request(proto::SynchronizeContexts {
+            project_id,
+            contexts,
+        });
+        cx.spawn(|this, cx| async move {
+            let response = request.await?;
+
+            let mut context_ids = Vec::new();
+            let mut operations = Vec::new();
+            this.read_with(&cx, |this, cx| {
+                for context_version_proto in response.contexts {
+                    let context_version = ContextVersion::from_proto(&context_version_proto);
+                    let context_id = ContextId::from_proto(context_version_proto.context_id);
+                    if let Some(context) = this.loaded_context_for_id(&context_id, cx) {
+                        context_ids.push(context_id);
+                        operations.push(context.read(cx).serialize_ops(&context_version, cx));
+                    }
+                }
+            })?;
+
+            let operations = futures::future::join_all(operations).await;
+            for (context_id, operations) in context_ids.into_iter().zip(operations) {
+                for operation in operations {
+                    client.send(proto::UpdateContext {
+                        project_id,
+                        context_id: context_id.to_proto(),
+                        operation: Some(operation),
+                    })?;
+                }
+            }
+
+            anyhow::Ok(())
+        })
+        .detach_and_log_err(cx);
+    }
+
    pub fn search(&self, query: String, cx: &AppContext) -> Task<Vec<SavedContextMetadata>> {
        let metadata = self.contexts_metadata.clone();
        let executor = cx.background_executor().clone();
@@ -178,6 +577,10 @@ impl ContextStore {
        })
    }

+    pub fn host_contexts(&self) -> &[RemoteContextMetadata] {
+        &self.host_contexts
+    }
+
    fn reload(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
        let fs = self.fs.clone();
        cx.spawn(|this, mut cx| async move {
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -1986,13 +1986,14 @@ impl Codegen {
            .unwrap_or_else(|| snapshot.indent_size_for_line(MultiBufferRow(selection_start.row)));

        let model_telemetry_id = prompt.model.telemetry_id();
-        let response = CompletionProvider::global(cx).complete(prompt);
+        let response = CompletionProvider::global(cx).complete(prompt, cx);
        let telemetry = self.telemetry.clone();
        self.edit_position = range.start;
        self.diff = Diff::default();
        self.status = CodegenStatus::Pending;
        self.generation = cx.spawn(|this, mut cx| {
            async move {
+                let response = response.await;
                let generate = async {
                    let mut edit_start = range.start.to_offset(&snapshot);

@@ -2002,7 +2003,7 @@ impl Codegen {
                            let mut response_latency = None;
                            let request_start = Instant::now();
                            let diff = async {
-                                let chunks = StripInvalidSpans::new(response.await?);
+                                let chunks = StripInvalidSpans::new(response.inner.await?);
                                futures::pin_mut!(chunks);
                                let mut diff = StreamingDiff::new(selected_text.to_string());

@@ -2473,9 +2474,8 @@ mod tests {

    #[gpui::test(iterations = 10)]
    async fn test_transform_autoindent(cx: &mut TestAppContext, mut rng: StdRng) {
-        let provider = FakeCompletionProvider::default();
        cx.set_global(cx.update(SettingsStore::test));
-        cx.set_global(CompletionProvider::Fake(provider.clone()));
+        let provider = cx.update(|cx| FakeCompletionProvider::setup_test(cx));
        cx.update(language_settings::init);

        let text = indoc! {"
@@ -2495,8 +2495,11 @@ mod tests {
        });
        let codegen = cx.new_model(|cx| Codegen::new(buffer.clone(), range, None, cx));

-        let request = LanguageModelRequest::default();
-        codegen.update(cx, |codegen, cx| codegen.start(request, cx));
+        codegen.update(cx, |codegen, cx| {
+            codegen.start(LanguageModelRequest::default(), cx)
+        });
+
+        cx.background_executor.run_until_parked();

        let mut new_text = concat!(
            "       let mut x = 0;\n",
@@ -2508,11 +2511,11 @@ mod tests {
            let max_len = cmp::min(new_text.len(), 10);
            let len = rng.gen_range(1..=max_len);
            let (chunk, suffix) = new_text.split_at(len);
-            provider.send_completion(chunk.into());
+            provider.send_completion(&LanguageModelRequest::default(), chunk.into());
            new_text = suffix;
            cx.background_executor.run_until_parked();
        }
-        provider.finish_completion();
+        provider.finish_completion(&LanguageModelRequest::default());
        cx.background_executor.run_until_parked();

        assert_eq!(
@@ -2533,8 +2536,7 @@ mod tests {
        cx: &mut TestAppContext,
        mut rng: StdRng,
    ) {
-        let provider = FakeCompletionProvider::default();
-        cx.set_global(CompletionProvider::Fake(provider.clone()));
+        let provider = cx.update(|cx| FakeCompletionProvider::setup_test(cx));
        cx.set_global(cx.update(SettingsStore::test));
        cx.update(language_settings::init);

@@ -2555,6 +2557,8 @@ mod tests {
        let request = LanguageModelRequest::default();
        codegen.update(cx, |codegen, cx| codegen.start(request, cx));

+        cx.background_executor.run_until_parked();
+
        let mut new_text = concat!(
            "t mut x = 0;\n",
            "while x < 10 {\n",
@@ -2565,11 +2569,11 @@ mod tests {
            let max_len = cmp::min(new_text.len(), 10);
            let len = rng.gen_range(1..=max_len);
            let (chunk, suffix) = new_text.split_at(len);
-            provider.send_completion(chunk.into());
+            provider.send_completion(&LanguageModelRequest::default(), chunk.into());
            new_text = suffix;
            cx.background_executor.run_until_parked();
        }
-        provider.finish_completion();
+        provider.finish_completion(&LanguageModelRequest::default());
        cx.background_executor.run_until_parked();

        assert_eq!(
@@ -2590,8 +2594,7 @@ mod tests {
        cx: &mut TestAppContext,
        mut rng: StdRng,
    ) {
-        let provider = FakeCompletionProvider::default();
-        cx.set_global(CompletionProvider::Fake(provider.clone()));
+        let provider = cx.update(|cx| FakeCompletionProvider::setup_test(cx));
        cx.set_global(cx.update(SettingsStore::test));
        cx.update(language_settings::init);

@@ -2612,6 +2615,8 @@ mod tests {
        let request = LanguageModelRequest::default();
        codegen.update(cx, |codegen, cx| codegen.start(request, cx));

+        cx.background_executor.run_until_parked();
+
        let mut new_text = concat!(
            "let mut x = 0;\n",
            "while x < 10 {\n",
@@ -2622,11 +2627,11 @@ mod tests {
            let max_len = cmp::min(new_text.len(), 10);
            let len = rng.gen_range(1..=max_len);
            let (chunk, suffix) = new_text.split_at(len);
-            provider.send_completion(chunk.into());
+            provider.send_completion(&LanguageModelRequest::default(), chunk.into());
            new_text = suffix;
            cx.background_executor.run_until_parked();
        }
-        provider.finish_completion();
+        provider.finish_completion(&LanguageModelRequest::default());
        cx.background_executor.run_until_parked();

        assert_eq!(
--- a/crates/assistant/src/model_selector.rs
+++ b/crates/assistant/src/model_selector.rs
@@ -49,6 +49,7 @@ impl RenderOnce for ModelSelector {
            })
            .trigger(
                ButtonLike::new("active-model")
+                    .style(ButtonStyle::Subtle)
                    .child(
                        h_flex()
                            .w_full()
@@ -67,18 +68,15 @@ impl RenderOnce for ModelSelector {
                                    ),
                            )
                            .child(
-                                div().child(
-                                    Icon::new(IconName::ChevronDown)
-                                        .color(Color::Muted)
-                                        .size(IconSize::XSmall),
-                                ),
+                                Icon::new(IconName::ChevronDown)
+                                    .color(Color::Muted)
+                                    .size(IconSize::XSmall),
                            ),
                    )
-                    .style(ButtonStyle::Subtle)
                    .tooltip(move |cx| {
                        Tooltip::for_action("Change Model", &ToggleModelSelector, cx)
                    }),
            )
-            .anchor(gpui::AnchorCorner::BottomRight)
+            .attach(gpui::AnchorCorner::BottomLeft)
    }
 }
--- a/crates/assistant/src/prompt_library.rs
+++ b/crates/assistant/src/prompt_library.rs
@@ -3,7 +3,6 @@ use crate::{
    InlineAssist, InlineAssistant, LanguageModelRequest, LanguageModelRequestMessage, Role,
 };
 use anyhow::{anyhow, Result};
-use assistant_slash_command::SlashCommandRegistry;
 use chrono::{DateTime, Utc};
 use collections::{HashMap, HashSet};
 use editor::{actions::Tab, CurrentLineHighlight, Editor, EditorElement, EditorEvent, EditorStyle};
@@ -448,7 +447,6 @@ impl PromptLibrary {
            self.set_active_prompt(Some(prompt_id), cx);
        } else if let Some(prompt_metadata) = self.store.metadata(prompt_id) {
            let language_registry = self.language_registry.clone();
-            let commands = SlashCommandRegistry::global(cx);
            let prompt = self.store.load(prompt_id);
            self.pending_load = cx.spawn(|this, mut cx| async move {
                let prompt = prompt.await;
@@ -477,7 +475,7 @@ impl PromptLibrary {
                            editor.set_use_modal_editing(false);
                            editor.set_current_line_highlight(Some(CurrentLineHighlight::None));
                            editor.set_completion_provider(Box::new(
-                                SlashCommandCompletionProvider::new(commands, None, None),
+                                SlashCommandCompletionProvider::new(None, None),
                            ));
                            if focus {
                                editor.focus(cx);
--- a/crates/assistant/src/slash_command.rs
+++ b/crates/assistant/src/slash_command.rs
@@ -20,18 +20,17 @@ use workspace::Workspace;
 pub mod active_command;
 pub mod default_command;
 pub mod diagnostics_command;
+pub mod docs_command;
 pub mod fetch_command;
 pub mod file_command;
 pub mod now_command;
 pub mod project_command;
 pub mod prompt_command;
-pub mod rustdoc_command;
 pub mod search_command;
 pub mod tabs_command;
 pub mod term_command;

 pub(crate) struct SlashCommandCompletionProvider {
-    commands: Arc<SlashCommandRegistry>,
    cancel_flag: Mutex<Arc<AtomicBool>>,
    editor: Option<WeakView<ContextEditor>>,
    workspace: Option<WeakView<Workspace>>,
@@ -46,14 +45,12 @@ pub(crate) struct SlashCommandLine {

 impl SlashCommandCompletionProvider {
    pub fn new(
-        commands: Arc<SlashCommandRegistry>,
        editor: Option<WeakView<ContextEditor>>,
        workspace: Option<WeakView<Workspace>>,
    ) -> Self {
        Self {
            cancel_flag: Mutex::new(Arc::new(AtomicBool::new(false))),
            editor,
-            commands,
            workspace,
        }
    }
@@ -65,8 +62,8 @@ impl SlashCommandCompletionProvider {
        name_range: Range<Anchor>,
        cx: &mut WindowContext,
    ) -> Task<Result<Vec<project::Completion>>> {
-        let candidates = self
-            .commands
+        let commands = SlashCommandRegistry::global(cx);
+        let candidates = commands
            .command_names()
            .into_iter()
            .enumerate()
@@ -76,7 +73,6 @@ impl SlashCommandCompletionProvider {
                char_bag: def.as_ref().into(),
            })
            .collect::<Vec<_>>();
-        let commands = self.commands.clone();
        let command_name = command_name.to_string();
        let editor = self.editor.clone();
        let workspace = self.workspace.clone();
@@ -155,7 +151,8 @@ impl SlashCommandCompletionProvider {
        flag.store(true, SeqCst);
        *flag = new_cancel_flag.clone();

-        if let Some(command) = self.commands.command(command_name) {
+        let commands = SlashCommandRegistry::global(cx);
+        if let Some(command) = commands.command(command_name) {
            let completions = command.complete_argument(
                argument,
                new_cancel_flag.clone(),
@@ -170,7 +167,7 @@ impl SlashCommandCompletionProvider {
                    .await?
                    .into_iter()
                    .map(|command_argument| {
-                        let confirm =
+                        let confirm = if command_argument.run_command {
                            editor
                                .clone()
                                .zip(workspace.clone())
@@ -178,7 +175,7 @@ impl SlashCommandCompletionProvider {
                                    Arc::new({
                                        let command_range = command_range.clone();
                                        let command_name = command_name.clone();
-                                        let command_argument = command_argument.clone();
+                                        let command_argument = command_argument.new_text.clone();
                                        move |cx: &mut WindowContext| {
                                            editor
                                                .update(cx, |editor, cx| {
@@ -194,15 +191,24 @@ impl SlashCommandCompletionProvider {
                                                .ok();
                                        }
                                    }) as Arc<_>
-                                });
+                                })
+                        } else {
+                            None
+                        };
+
+                        let mut new_text = command_argument.new_text.clone();
+                        if !command_argument.run_command {
+                            new_text.push(' ');
+                        }
+
                        project::Completion {
                            old_range: argument_range.clone(),
-                            label: CodeLabel::plain(command_argument.clone(), None),
-                            new_text: command_argument.clone(),
+                            label: CodeLabel::plain(command_argument.label, None),
+                            new_text,
                            documentation: None,
                            server_id: LanguageServerId(0),
                            lsp_completion: Default::default(),
-                            show_new_completions_on_confirm: false,
+                            show_new_completions_on_confirm: !command_argument.run_command,
                            confirm,
                        }
                    })
--- a/crates/assistant/src/slash_command/active_command.rs
+++ b/crates/assistant/src/slash_command/active_command.rs
@@ -4,6 +4,7 @@ use super::{
    SlashCommand, SlashCommandOutput,
 };
 use anyhow::{anyhow, Result};
+use assistant_slash_command::ArgumentCompletion;
 use editor::Editor;
 use gpui::{AppContext, Task, WeakView};
 use language::LspAdapterDelegate;
@@ -33,7 +34,7 @@ impl SlashCommand for ActiveSlashCommand {
        _cancel: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
        Task::ready(Err(anyhow!("this command does not require argument")))
    }

--- a/crates/assistant/src/slash_command/default_command.rs
+++ b/crates/assistant/src/slash_command/default_command.rs
@@ -1,7 +1,7 @@
 use super::{SlashCommand, SlashCommandOutput};
 use crate::prompt_library::PromptStore;
 use anyhow::{anyhow, Result};
-use assistant_slash_command::SlashCommandOutputSection;
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use gpui::{AppContext, Task, WeakView};
 use language::LspAdapterDelegate;
 use std::{
@@ -36,7 +36,7 @@ impl SlashCommand for DefaultSlashCommand {
        _cancellation_flag: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
        Task::ready(Err(anyhow!("this command does not require argument")))
    }

--- a/crates/assistant/src/slash_command/diagnostics_command.rs
+++ b/crates/assistant/src/slash_command/diagnostics_command.rs
@@ -1,6 +1,6 @@
 use super::{create_label_for_command, SlashCommand, SlashCommandOutput};
 use anyhow::{anyhow, Result};
-use assistant_slash_command::SlashCommandOutputSection;
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use fuzzy::{PathMatch, StringMatchCandidate};
 use gpui::{AppContext, Model, Task, View, WeakView};
 use language::{
@@ -20,9 +20,9 @@ use util::paths::PathMatcher;
 use util::ResultExt;
 use workspace::Workspace;

-pub(crate) struct DiagnosticsCommand;
+pub(crate) struct DiagnosticsSlashCommand;

-impl DiagnosticsCommand {
+impl DiagnosticsSlashCommand {
    fn search_paths(
        &self,
        query: String,
@@ -81,7 +81,7 @@ impl DiagnosticsCommand {
    }
 }

-impl SlashCommand for DiagnosticsCommand {
+impl SlashCommand for DiagnosticsSlashCommand {
    fn name(&self) -> String {
        "diagnostics".into()
    }
@@ -108,7 +108,7 @@ impl SlashCommand for DiagnosticsCommand {
        cancellation_flag: Arc<AtomicBool>,
        workspace: Option<WeakView<Workspace>>,
        cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
        let Some(workspace) = workspace.and_then(|workspace| workspace.upgrade()) else {
            return Task::ready(Err(anyhow!("workspace was dropped")));
        };
@@ -143,7 +143,14 @@ impl SlashCommand for DiagnosticsCommand {
                .map(|candidate| candidate.string),
            );

-            Ok(matches)
+            Ok(matches
+                .into_iter()
+                .map(|completion| ArgumentCompletion {
+                    label: completion.clone(),
+                    new_text: completion,
+                    run_command: true,
+                })
+                .collect())
        })
    }

--- a/crates/assistant/src/slash_command/docs_command.rs
+++ b/crates/assistant/src/slash_command/docs_command.rs
@@ -0,0 +1,373 @@
+use std::path::Path;
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+
+use anyhow::{anyhow, bail, Result};
+use assistant_slash_command::{
+    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
+};
+use gpui::{AppContext, Model, Task, WeakView};
+use indexed_docs::{
+    IndexedDocsRegistry, IndexedDocsStore, LocalProvider, PackageName, ProviderId, RustdocIndexer,
+};
+use language::LspAdapterDelegate;
+use project::{Project, ProjectPath};
+use ui::prelude::*;
+use util::{maybe, ResultExt};
+use workspace::Workspace;
+
+pub(crate) struct DocsSlashCommand;
+
+impl DocsSlashCommand {
+    pub const NAME: &'static str = "docs";
+
+    fn path_to_cargo_toml(project: Model<Project>, cx: &mut AppContext) -> Option<Arc<Path>> {
+        let worktree = project.read(cx).worktrees().next()?;
+        let worktree = worktree.read(cx);
+        let entry = worktree.entry_for_path("Cargo.toml")?;
+        let path = ProjectPath {
+            worktree_id: worktree.id(),
+            path: entry.path.clone(),
+        };
+        Some(Arc::from(
+            project.read(cx).absolute_path(&path, cx)?.as_path(),
+        ))
+    }
+
+    /// Ensures that the rustdoc provider is registered.
+    ///
+    /// Ideally we would do this sooner, but we need to wait until we're able to
+    /// access the workspace so we can read the project.
+    fn ensure_rustdoc_provider_is_registered(
+        &self,
+        workspace: Option<WeakView<Workspace>>,
+        cx: &mut AppContext,
+    ) {
+        let indexed_docs_registry = IndexedDocsRegistry::global(cx);
+        if indexed_docs_registry
+            .get_provider_store(ProviderId::rustdoc())
+            .is_none()
+        {
+            let index_provider_deps = maybe!({
+                let workspace = workspace.ok_or_else(|| anyhow!("no workspace"))?;
+                let workspace = workspace
+                    .upgrade()
+                    .ok_or_else(|| anyhow!("workspace was dropped"))?;
+                let project = workspace.read(cx).project().clone();
+                let fs = project.read(cx).fs().clone();
+                let cargo_workspace_root = Self::path_to_cargo_toml(project, cx)
+                    .and_then(|path| path.parent().map(|path| path.to_path_buf()))
+                    .ok_or_else(|| anyhow!("no Cargo workspace root found"))?;
+
+                anyhow::Ok((fs, cargo_workspace_root))
+            });
+
+            if let Some((fs, cargo_workspace_root)) = index_provider_deps.log_err() {
+                indexed_docs_registry.register_provider(Box::new(RustdocIndexer::new(Box::new(
+                    LocalProvider::new(fs, cargo_workspace_root),
+                ))));
+            }
+        }
+    }
+}
+
+impl SlashCommand for DocsSlashCommand {
+    fn name(&self) -> String {
+        Self::NAME.into()
+    }
+
+    fn description(&self) -> String {
+        "insert docs".into()
+    }
+
+    fn menu_text(&self) -> String {
+        "Insert Documentation".into()
+    }
+
+    fn requires_argument(&self) -> bool {
+        true
+    }
+
+    fn complete_argument(
+        self: Arc<Self>,
+        query: String,
+        _cancel: Arc<AtomicBool>,
+        workspace: Option<WeakView<Workspace>>,
+        cx: &mut AppContext,
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+        self.ensure_rustdoc_provider_is_registered(workspace, cx);
+
+        let indexed_docs_registry = IndexedDocsRegistry::global(cx);
+        let args = DocsSlashCommandArgs::parse(&query);
+        let store = args
+            .provider()
+            .ok_or_else(|| anyhow!("no docs provider specified"))
+            .and_then(|provider| IndexedDocsStore::try_global(provider, cx));
+        cx.background_executor().spawn(async move {
+            fn build_completions(
+                provider: ProviderId,
+                items: Vec<String>,
+            ) -> Vec<ArgumentCompletion> {
+                items
+                    .into_iter()
+                    .map(|item| ArgumentCompletion {
+                        label: item.clone(),
+                        new_text: format!("{provider} {item}"),
+                        run_command: true,
+                    })
+                    .collect()
+            }
+
+            match args {
+                DocsSlashCommandArgs::NoProvider => {
+                    let providers = indexed_docs_registry.list_providers();
+                    Ok(providers
+                        .into_iter()
+                        .map(|provider| ArgumentCompletion {
+                            label: provider.to_string(),
+                            new_text: provider.to_string(),
+                            run_command: false,
+                        })
+                        .collect())
+                }
+                DocsSlashCommandArgs::SearchPackageDocs {
+                    provider,
+                    package,
+                    index,
+                } => {
+                    let store = store?;
+
+                    if index {
+                        // We don't need to hold onto this task, as the `IndexedDocsStore` will hold it
+                        // until it completes.
+                        let _ = store.clone().index(package.as_str().into());
+                    }
+
+                    let items = store.search(package).await;
+                    Ok(build_completions(provider, items))
+                }
+                DocsSlashCommandArgs::SearchItemDocs {
+                    provider,
+                    item_path,
+                    ..
+                } => {
+                    let store = store?;
+                    let items = store.search(item_path).await;
+                    Ok(build_completions(provider, items))
+                }
+            }
+        })
+    }
+
+    fn run(
+        self: Arc<Self>,
+        argument: Option<&str>,
+        _workspace: WeakView<Workspace>,
+        _delegate: Arc<dyn LspAdapterDelegate>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<SlashCommandOutput>> {
+        let Some(argument) = argument else {
+            return Task::ready(Err(anyhow!("missing argument")));
+        };
+
+        let args = DocsSlashCommandArgs::parse(argument);
+        let text = cx.background_executor().spawn({
+            let store = args
+                .provider()
+                .ok_or_else(|| anyhow!("no docs provider specified"))
+                .and_then(|provider| IndexedDocsStore::try_global(provider, cx));
+            async move {
+                match args {
+                    DocsSlashCommandArgs::NoProvider => bail!("no docs provider specified"),
+                    DocsSlashCommandArgs::SearchPackageDocs {
+                        provider, package, ..
+                    } => {
+                        let store = store?;
+                        let item_docs = store.load(package.clone()).await?;
+
+                        anyhow::Ok((provider, package, item_docs.to_string()))
+                    }
+                    DocsSlashCommandArgs::SearchItemDocs {
+                        provider,
+                        item_path,
+                        ..
+                    } => {
+                        let store = store?;
+                        let item_docs = store.load(item_path.clone()).await?;
+
+                        anyhow::Ok((provider, item_path, item_docs.to_string()))
+                    }
+                }
+            }
+        });
+
+        cx.foreground_executor().spawn(async move {
+            let (provider, path, text) = text.await?;
+            let range = 0..text.len();
+            Ok(SlashCommandOutput {
+                text,
+                sections: vec![SlashCommandOutputSection {
+                    range,
+                    icon: IconName::FileRust,
+                    label: format!("docs ({provider}): {path}",).into(),
+                }],
+                run_commands_in_text: false,
+            })
+        })
+    }
+}
+
+fn is_item_path_delimiter(char: char) -> bool {
+    !char.is_alphanumeric() && char != '-' && char != '_'
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum DocsSlashCommandArgs {
+    NoProvider,
+    SearchPackageDocs {
+        provider: ProviderId,
+        package: String,
+        index: bool,
+    },
+    SearchItemDocs {
+        provider: ProviderId,
+        package: String,
+        item_path: String,
+    },
+}
+
+impl DocsSlashCommandArgs {
+    pub fn parse(argument: &str) -> Self {
+        let Some((provider, argument)) = argument.split_once(' ') else {
+            return Self::NoProvider;
+        };
+
+        let provider = ProviderId(provider.into());
+
+        if let Some((package, rest)) = argument.split_once(is_item_path_delimiter) {
+            if rest.trim().is_empty() {
+                Self::SearchPackageDocs {
+                    provider,
+                    package: package.to_owned(),
+                    index: true,
+                }
+            } else {
+                Self::SearchItemDocs {
+                    provider,
+                    package: package.to_owned(),
+                    item_path: argument.to_owned(),
+                }
+            }
+        } else {
+            Self::SearchPackageDocs {
+                provider,
+                package: argument.to_owned(),
+                index: false,
+            }
+        }
+    }
+
+    pub fn provider(&self) -> Option<ProviderId> {
+        match self {
+            Self::NoProvider => None,
+            Self::SearchPackageDocs { provider, .. } | Self::SearchItemDocs { provider, .. } => {
+                Some(provider.clone())
+            }
+        }
+    }
+
+    pub fn package(&self) -> Option<PackageName> {
+        match self {
+            Self::NoProvider => None,
+            Self::SearchPackageDocs { package, .. } | Self::SearchItemDocs { package, .. } => {
+                Some(package.as_str().into())
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_docs_slash_command_args() {
+        assert_eq!(
+            DocsSlashCommandArgs::parse(""),
+            DocsSlashCommandArgs::NoProvider
+        );
+        assert_eq!(
+            DocsSlashCommandArgs::parse("rustdoc"),
+            DocsSlashCommandArgs::NoProvider
+        );
+
+        assert_eq!(
+            DocsSlashCommandArgs::parse("rustdoc "),
+            DocsSlashCommandArgs::SearchPackageDocs {
+                provider: ProviderId("rustdoc".into()),
+                package: "".into(),
+                index: false
+            }
+        );
+        assert_eq!(
+            DocsSlashCommandArgs::parse("gleam "),
+            DocsSlashCommandArgs::SearchPackageDocs {
+                provider: ProviderId("gleam".into()),
+                package: "".into(),
+                index: false
+            }
+        );
+
+        assert_eq!(
+            DocsSlashCommandArgs::parse("rustdoc gpui"),
+            DocsSlashCommandArgs::SearchPackageDocs {
+                provider: ProviderId("rustdoc".into()),
+                package: "gpui".into(),
+                index: false,
+            }
+        );
+        assert_eq!(
+            DocsSlashCommandArgs::parse("gleam gleam_stdlib"),
+            DocsSlashCommandArgs::SearchPackageDocs {
+                provider: ProviderId("gleam".into()),
+                package: "gleam_stdlib".into(),
+                index: false
+            }
+        );
+
+        // Adding an item path delimiter indicates we can start indexing.
+        assert_eq!(
+            DocsSlashCommandArgs::parse("rustdoc gpui:"),
+            DocsSlashCommandArgs::SearchPackageDocs {
+                provider: ProviderId("rustdoc".into()),
+                package: "gpui".into(),
+                index: true,
+            }
+        );
+        assert_eq!(
+            DocsSlashCommandArgs::parse("gleam gleam_stdlib/"),
+            DocsSlashCommandArgs::SearchPackageDocs {
+                provider: ProviderId("gleam".into()),
+                package: "gleam_stdlib".into(),
+                index: true
+            }
+        );
+
+        assert_eq!(
+            DocsSlashCommandArgs::parse("rustdoc gpui::foo::bar::Baz"),
+            DocsSlashCommandArgs::SearchItemDocs {
+                provider: ProviderId("rustdoc".into()),
+                package: "gpui".into(),
+                item_path: "gpui::foo::bar::Baz".into()
+            }
+        );
+        assert_eq!(
+            DocsSlashCommandArgs::parse("gleam gleam_stdlib/gleam/int"),
+            DocsSlashCommandArgs::SearchItemDocs {
+                provider: ProviderId("gleam".into()),
+                package: "gleam_stdlib".into(),
+                item_path: "gleam_stdlib/gleam/int".into()
+            }
+        );
+    }
+}
--- a/crates/assistant/src/slash_command/fetch_command.rs
+++ b/crates/assistant/src/slash_command/fetch_command.rs
@@ -4,7 +4,9 @@ use std::sync::atomic::AtomicBool;
 use std::sync::Arc;

 use anyhow::{anyhow, bail, Context, Result};
-use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection};
+use assistant_slash_command::{
+    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
+};
 use futures::AsyncReadExt;
 use gpui::{AppContext, Task, WeakView};
 use html_to_markdown::{convert_html_to_markdown, markdown, TagHandler};
@@ -119,7 +121,7 @@ impl SlashCommand for FetchSlashCommand {
        _cancel: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
        Task::ready(Ok(Vec::new()))
    }

--- a/crates/assistant/src/slash_command/file_command.rs
+++ b/crates/assistant/src/slash_command/file_command.rs
@@ -1,6 +1,6 @@
 use super::{diagnostics_command::write_single_file_diagnostics, SlashCommand, SlashCommandOutput};
 use anyhow::{anyhow, Result};
-use assistant_slash_command::SlashCommandOutputSection;
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use fuzzy::PathMatch;
 use gpui::{AppContext, Model, Task, View, WeakView};
 use language::{BufferSnapshot, LineEnding, LspAdapterDelegate};
@@ -105,7 +105,7 @@ impl SlashCommand for FileSlashCommand {
        cancellation_flag: Arc<AtomicBool>,
        workspace: Option<WeakView<Workspace>>,
        cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
        let Some(workspace) = workspace.and_then(|workspace| workspace.upgrade()) else {
            return Task::ready(Err(anyhow!("workspace was dropped")));
        };
@@ -116,11 +116,17 @@ impl SlashCommand for FileSlashCommand {
                .await
                .into_iter()
                .map(|path_match| {
-                    format!(
+                    let text = format!(
                        "{}{}",
                        path_match.path_prefix,
                        path_match.path.to_string_lossy()
-                    )
+                    );
+
+                    ArgumentCompletion {
+                        label: text.clone(),
+                        new_text: text,
+                        run_command: true,
+                    }
                })
                .collect())
        })
--- a/crates/assistant/src/slash_command/now_command.rs
+++ b/crates/assistant/src/slash_command/now_command.rs
@@ -2,7 +2,9 @@ use std::sync::atomic::AtomicBool;
 use std::sync::Arc;

 use anyhow::Result;
-use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection};
+use assistant_slash_command::{
+    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
+};
 use chrono::Local;
 use gpui::{AppContext, Task, WeakView};
 use language::LspAdapterDelegate;
@@ -34,7 +36,7 @@ impl SlashCommand for NowSlashCommand {
        _cancel: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
        Task::ready(Ok(Vec::new()))
    }

--- a/crates/assistant/src/slash_command/project_command.rs
+++ b/crates/assistant/src/slash_command/project_command.rs
@@ -1,6 +1,6 @@
 use super::{SlashCommand, SlashCommandOutput};
 use anyhow::{anyhow, Context, Result};
-use assistant_slash_command::SlashCommandOutputSection;
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use fs::Fs;
 use gpui::{AppContext, Model, Task, WeakView};
 use language::LspAdapterDelegate;
@@ -107,7 +107,7 @@ impl SlashCommand for ProjectSlashCommand {
        _cancel: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
        Task::ready(Err(anyhow!("this command does not require argument")))
    }

--- a/crates/assistant/src/slash_command/prompt_command.rs
+++ b/crates/assistant/src/slash_command/prompt_command.rs
@@ -1,7 +1,7 @@
 use super::{SlashCommand, SlashCommandOutput};
 use crate::prompt_library::PromptStore;
 use anyhow::{anyhow, Context, Result};
-use assistant_slash_command::SlashCommandOutputSection;
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use gpui::{AppContext, Task, WeakView};
 use language::LspAdapterDelegate;
 use std::sync::{atomic::AtomicBool, Arc};
@@ -33,13 +33,20 @@ impl SlashCommand for PromptSlashCommand {
        _cancellation_flag: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
        let store = PromptStore::global(cx);
        cx.background_executor().spawn(async move {
            let prompts = store.await?.search(query).await;
            Ok(prompts
                .into_iter()
-                .filter_map(|prompt| Some(prompt.title?.to_string()))
+                .filter_map(|prompt| {
+                    let prompt_title = prompt.title?.to_string();
+                    Some(ArgumentCompletion {
+                        label: prompt_title.clone(),
+                        new_text: prompt_title,
+                        run_command: true,
+                    })
+                })
                .collect())
        })
    }
--- a/crates/assistant/src/slash_command/rustdoc_command.rs
+++ b/crates/assistant/src/slash_command/rustdoc_command.rs
@@ -1,265 +0,0 @@
-use std::path::Path;
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
-
-use anyhow::{anyhow, bail, Context, Result};
-use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection};
-use fs::Fs;
-use futures::AsyncReadExt;
-use gpui::{AppContext, Model, Task, WeakView};
-use http::{AsyncBody, HttpClient, HttpClientWithUrl};
-use indexed_docs::{
-    convert_rustdoc_to_markdown, IndexedDocsRegistry, IndexedDocsStore, LocalProvider, PackageName,
-    ProviderId, RustdocIndexer, RustdocSource,
-};
-use language::LspAdapterDelegate;
-use project::{Project, ProjectPath};
-use ui::prelude::*;
-use util::{maybe, ResultExt};
-use workspace::Workspace;
-
-pub(crate) struct RustdocSlashCommand;
-
-impl RustdocSlashCommand {
-    async fn build_message(
-        fs: Arc<dyn Fs>,
-        http_client: Arc<HttpClientWithUrl>,
-        crate_name: PackageName,
-        module_path: Vec<String>,
-        path_to_cargo_toml: Option<&Path>,
-    ) -> Result<(RustdocSource, String)> {
-        let cargo_workspace_root = path_to_cargo_toml.and_then(|path| path.parent());
-        if let Some(cargo_workspace_root) = cargo_workspace_root {
-            let mut local_cargo_doc_path = cargo_workspace_root.join("target/doc");
-            local_cargo_doc_path.push(crate_name.as_ref());
-            if !module_path.is_empty() {
-                local_cargo_doc_path.push(module_path.join("/"));
-            }
-            local_cargo_doc_path.push("index.html");
-
-            if let Ok(contents) = fs.load(&local_cargo_doc_path).await {
-                let (markdown, _items) = convert_rustdoc_to_markdown(contents.as_bytes())?;
-
-                return Ok((RustdocSource::Local, markdown));
-            }
-        }
-
-        let version = "latest";
-        let path = format!(
-            "{crate_name}/{version}/{crate_name}/{module_path}",
-            module_path = module_path.join("/")
-        );
-
-        let mut response = http_client
-            .get(
-                &format!("https://docs.rs/{path}"),
-                AsyncBody::default(),
-                true,
-            )
-            .await?;
-
-        let mut body = Vec::new();
-        response
-            .body_mut()
-            .read_to_end(&mut body)
-            .await
-            .context("error reading docs.rs response body")?;
-
-        if response.status().is_client_error() {
-            let text = String::from_utf8_lossy(body.as_slice());
-            bail!(
-                "status error {}, response: {text:?}",
-                response.status().as_u16()
-            );
-        }
-
-        let (markdown, _items) = convert_rustdoc_to_markdown(&body[..])?;
-
-        Ok((RustdocSource::DocsDotRs, markdown))
-    }
-
-    fn path_to_cargo_toml(project: Model<Project>, cx: &mut AppContext) -> Option<Arc<Path>> {
-        let worktree = project.read(cx).worktrees().next()?;
-        let worktree = worktree.read(cx);
-        let entry = worktree.entry_for_path("Cargo.toml")?;
-        let path = ProjectPath {
-            worktree_id: worktree.id(),
-            path: entry.path.clone(),
-        };
-        Some(Arc::from(
-            project.read(cx).absolute_path(&path, cx)?.as_path(),
-        ))
-    }
-
-    /// Ensures that the rustdoc provider is registered.
-    ///
-    /// Ideally we would do this sooner, but we need to wait until we're able to
-    /// access the workspace so we can read the project.
-    fn ensure_rustdoc_provider_is_registered(
-        &self,
-        workspace: Option<WeakView<Workspace>>,
-        cx: &mut AppContext,
-    ) {
-        let indexed_docs_registry = IndexedDocsRegistry::global(cx);
-        if indexed_docs_registry
-            .get_provider_store(ProviderId::rustdoc())
-            .is_none()
-        {
-            let index_provider_deps = maybe!({
-                let workspace = workspace.ok_or_else(|| anyhow!("no workspace"))?;
-                let workspace = workspace
-                    .upgrade()
-                    .ok_or_else(|| anyhow!("workspace was dropped"))?;
-                let project = workspace.read(cx).project().clone();
-                let fs = project.read(cx).fs().clone();
-                let cargo_workspace_root = Self::path_to_cargo_toml(project, cx)
-                    .and_then(|path| path.parent().map(|path| path.to_path_buf()))
-                    .ok_or_else(|| anyhow!("no Cargo workspace root found"))?;
-
-                anyhow::Ok((fs, cargo_workspace_root))
-            });
-
-            if let Some((fs, cargo_workspace_root)) = index_provider_deps.log_err() {
-                indexed_docs_registry.register_provider(Box::new(RustdocIndexer::new(Box::new(
-                    LocalProvider::new(fs, cargo_workspace_root),
-                ))));
-            }
-        }
-    }
-}
-
-impl SlashCommand for RustdocSlashCommand {
-    fn name(&self) -> String {
-        "rustdoc".into()
-    }
-
-    fn description(&self) -> String {
-        "insert Rust docs".into()
-    }
-
-    fn menu_text(&self) -> String {
-        "Insert Rust Documentation".into()
-    }
-
-    fn requires_argument(&self) -> bool {
-        true
-    }
-
-    fn complete_argument(
-        self: Arc<Self>,
-        query: String,
-        _cancel: Arc<AtomicBool>,
-        workspace: Option<WeakView<Workspace>>,
-        cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
-        self.ensure_rustdoc_provider_is_registered(workspace, cx);
-
-        let store = IndexedDocsStore::try_global(ProviderId::rustdoc(), cx);
-        cx.background_executor().spawn(async move {
-            let store = store?;
-
-            if let Some((crate_name, rest)) = query.split_once(':') {
-                if rest.is_empty() {
-                    // We don't need to hold onto this task, as the `IndexedDocsStore` will hold it
-                    // until it completes.
-                    let _ = store.clone().index(crate_name.into());
-                }
-            }
-
-            let items = store.search(query).await;
-            Ok(items)
-        })
-    }
-
-    fn run(
-        self: Arc<Self>,
-        argument: Option<&str>,
-        workspace: WeakView<Workspace>,
-        _delegate: Arc<dyn LspAdapterDelegate>,
-        cx: &mut WindowContext,
-    ) -> Task<Result<SlashCommandOutput>> {
-        let Some(argument) = argument else {
-            return Task::ready(Err(anyhow!("missing crate name")));
-        };
-        let Some(workspace) = workspace.upgrade() else {
-            return Task::ready(Err(anyhow!("workspace was dropped")));
-        };
-
-        let project = workspace.read(cx).project().clone();
-        let fs = project.read(cx).fs().clone();
-        let http_client = workspace.read(cx).client().http_client();
-        let path_to_cargo_toml = Self::path_to_cargo_toml(project, cx);
-
-        let mut path_components = argument.split("::");
-        let crate_name = match path_components
-            .next()
-            .ok_or_else(|| anyhow!("missing crate name"))
-        {
-            Ok(crate_name) => PackageName::from(crate_name),
-            Err(err) => return Task::ready(Err(err)),
-        };
-        let item_path = path_components.map(ToString::to_string).collect::<Vec<_>>();
-
-        let text = cx.background_executor().spawn({
-            let rustdoc_store = IndexedDocsStore::try_global(ProviderId::rustdoc(), cx);
-            let crate_name = crate_name.clone();
-            let item_path = item_path.clone();
-            async move {
-                let rustdoc_store = rustdoc_store?;
-                let item_docs = rustdoc_store
-                    .load(
-                        crate_name.clone(),
-                        if item_path.is_empty() {
-                            None
-                        } else {
-                            Some(item_path.join("::"))
-                        },
-                    )
-                    .await;
-
-                if let Ok(item_docs) = item_docs {
-                    anyhow::Ok((RustdocSource::Index, item_docs.to_string()))
-                } else {
-                    Self::build_message(
-                        fs,
-                        http_client,
-                        crate_name,
-                        item_path,
-                        path_to_cargo_toml.as_deref(),
-                    )
-                    .await
-                }
-            }
-        });
-
-        let module_path = if item_path.is_empty() {
-            None
-        } else {
-            Some(SharedString::from(item_path.join("::")))
-        };
-        cx.foreground_executor().spawn(async move {
-            let (source, text) = text.await?;
-            let range = 0..text.len();
-            let crate_path = module_path
-                .map(|module_path| format!("{}::{}", crate_name, module_path))
-                .unwrap_or_else(|| crate_name.to_string());
-            Ok(SlashCommandOutput {
-                text,
-                sections: vec![SlashCommandOutputSection {
-                    range,
-                    icon: IconName::FileRust,
-                    label: format!(
-                        "rustdoc ({source}): {crate_path}",
-                        source = match source {
-                            RustdocSource::Index => "index",
-                            RustdocSource::Local => "local",
-                            RustdocSource::DocsDotRs => "docs.rs",
-                        }
-                    )
-                    .into(),
-                }],
-                run_commands_in_text: false,
-            })
-        })
-    }
-}
--- a/crates/assistant/src/slash_command/search_command.rs
+++ b/crates/assistant/src/slash_command/search_command.rs
@@ -4,7 +4,7 @@ use super::{
    SlashCommand, SlashCommandOutput,
 };
 use anyhow::Result;
-use assistant_slash_command::SlashCommandOutputSection;
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use gpui::{AppContext, Task, WeakView};
 use language::{CodeLabel, LineEnding, LspAdapterDelegate};
 use semantic_index::SemanticIndex;
@@ -46,7 +46,7 @@ impl SlashCommand for SearchSlashCommand {
        _cancel: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
        Task::ready(Ok(Vec::new()))
    }

--- a/crates/assistant/src/slash_command/tabs_command.rs
+++ b/crates/assistant/src/slash_command/tabs_command.rs
@@ -4,6 +4,7 @@ use super::{
    SlashCommand, SlashCommandOutput,
 };
 use anyhow::{anyhow, Result};
+use assistant_slash_command::ArgumentCompletion;
 use collections::HashMap;
 use editor::Editor;
 use gpui::{AppContext, Entity, Task, WeakView};
@@ -37,7 +38,7 @@ impl SlashCommand for TabsSlashCommand {
        _cancel: Arc<std::sync::atomic::AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
        Task::ready(Err(anyhow!("this command does not require argument")))
    }

--- a/crates/assistant/src/slash_command/term_command.rs
+++ b/crates/assistant/src/slash_command/term_command.rs
@@ -2,7 +2,9 @@ use std::sync::atomic::AtomicBool;
 use std::sync::Arc;

 use anyhow::Result;
-use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection};
+use assistant_slash_command::{
+    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
+};
 use gpui::{AppContext, Task, WeakView};
 use language::{CodeLabel, LspAdapterDelegate};
 use terminal_view::{terminal_panel::TerminalPanel, TerminalView};
@@ -42,8 +44,12 @@ impl SlashCommand for TermSlashCommand {
        _cancel: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
-        Task::ready(Ok(vec![LINE_COUNT_ARG.to_string()]))
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+        Task::ready(Ok(vec![ArgumentCompletion {
+            label: LINE_COUNT_ARG.to_string(),
+            new_text: LINE_COUNT_ARG.to_string(),
+            run_command: true,
+        }]))
    }

    fn run(
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -1026,9 +1026,10 @@ impl Codegen {

        let telemetry = self.telemetry.clone();
        let model_telemetry_id = prompt.model.telemetry_id();
-        let response = CompletionProvider::global(cx).complete(prompt);
+        let response = CompletionProvider::global(cx).complete(prompt, cx);

        self.generation = cx.spawn(|this, mut cx| async move {
+            let response = response.await;
            let generate = async {
                let (mut hunks_tx, mut hunks_rx) = mpsc::channel(1);

@@ -1036,7 +1037,7 @@ impl Codegen {
                    let mut response_latency = None;
                    let request_start = Instant::now();
                    let task = async {
-                        let mut response = response.await?;
+                        let mut response = response.inner.await?;
                        while let Some(chunk) = response.next().await {
                            if response_latency.is_none() {
                                response_latency = Some(request_start.elapsed());
--- a/crates/assistant_slash_command/src/assistant_slash_command.rs
+++ b/crates/assistant_slash_command/src/assistant_slash_command.rs
@@ -15,6 +15,16 @@ pub fn init(cx: &mut AppContext) {
    SlashCommandRegistry::default_global(cx);
 }

+#[derive(Debug)]
+pub struct ArgumentCompletion {
+    /// The label to display for this completion.
+    pub label: String,
+    /// The new text that should be inserted into the command when this completion is accepted.
+    pub new_text: String,
+    /// Whether the command should be run when accepting this completion.
+    pub run_command: bool,
+}
+
 pub trait SlashCommand: 'static + Send + Sync {
    fn name(&self) -> String;
    fn label(&self, _cx: &AppContext) -> CodeLabel {
@@ -28,7 +38,7 @@ pub trait SlashCommand: 'static + Send + Sync {
        cancel: Arc<AtomicBool>,
        workspace: Option<WeakView<Workspace>>,
        cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>>;
+    ) -> Task<Result<Vec<ArgumentCompletion>>>;
    fn requires_argument(&self) -> bool;
    fn run(
        self: Arc<Self>,
@@ -57,7 +67,7 @@ pub struct SlashCommandOutput {
    pub run_commands_in_text: bool,
 }

-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct SlashCommandOutputSection<T> {
    pub range: Range<T>,
    pub icon: IconName,
--- a/crates/breadcrumbs/src/breadcrumbs.rs
+++ b/crates/breadcrumbs/src/breadcrumbs.rs
@@ -72,7 +72,7 @@ impl Render for Breadcrumbs {
                .into_any()
        });
        let breadcrumbs = Itertools::intersperse_with(highlighted_segments, || {
-            Label::new("›").color(Color::Muted).into_any_element()
+            Label::new("›").color(Color::Placeholder).into_any_element()
        });

        let breadcrumbs_stack = h_flex().gap_1().children(breadcrumbs);
@@ -83,7 +83,7 @@ impl Render for Breadcrumbs {
            Some(editor) => element.child(
                ButtonLike::new("toggle outline view")
                    .child(breadcrumbs_stack)
-                    .style(ButtonStyle::Subtle)
+                    .style(ButtonStyle::Transparent)
                    .on_click(move |_, cx| {
                        if let Some(editor) = editor.upgrade() {
                            outline::toggle(editor, &editor::actions::ToggleOutline, cx)
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -217,6 +217,9 @@ pub struct Client {
            >,
        >,
    >,
+
+    #[cfg(any(test, feature = "test-support"))]
+    rpc_url: RwLock<Option<Url>>,
 }

 #[derive(Error, Debug)]
@@ -527,6 +530,8 @@ impl Client {
            authenticate: Default::default(),
            #[cfg(any(test, feature = "test-support"))]
            establish_connection: Default::default(),
+            #[cfg(any(test, feature = "test-support"))]
+            rpc_url: RwLock::default(),
        })
    }

@@ -584,6 +589,12 @@ impl Client {
        self
    }

+    #[cfg(any(test, feature = "test-support"))]
+    pub fn override_rpc_url(&self, url: Url) -> &Self {
+        *self.rpc_url.write() = Some(url);
+        self
+    }
+
    pub fn global(cx: &AppContext) -> Arc<Self> {
        cx.global::<GlobalClient>().0.clone()
    }
@@ -1086,38 +1097,50 @@ impl Client {
        self.establish_websocket_connection(credentials, cx)
    }

-    async fn get_rpc_url(
+    fn rpc_url(
+        &self,
        http: Arc<HttpClientWithUrl>,
        release_channel: Option<ReleaseChannel>,
-    ) -> Result<Url> {
-        if let Some(url) = &*ZED_RPC_URL {
-            return Url::parse(url).context("invalid rpc url");
-        }
+    ) -> impl Future<Output = Result<Url>> {
+        #[cfg(any(test, feature = "test-support"))]
+        let url_override = self.rpc_url.read().clone();

-        let mut url = http.build_url("/rpc");
-        if let Some(preview_param) =
-            release_channel.and_then(|channel| channel.release_query_param())
-        {
-            url += "?";
-            url += preview_param;
-        }
-        let response = http.get(&url, Default::default(), false).await?;
-        let collab_url = if response.status().is_redirection() {
-            response
-                .headers()
-                .get("Location")
-                .ok_or_else(|| anyhow!("missing location header in /rpc response"))?
-                .to_str()
-                .map_err(EstablishConnectionError::other)?
-                .to_string()
-        } else {
-            Err(anyhow!(
-                "unexpected /rpc response status {}",
-                response.status()
-            ))?
-        };
+        async move {
+            #[cfg(any(test, feature = "test-support"))]
+            if let Some(url) = url_override {
+                return Ok(url);
+            }

-        Url::parse(&collab_url).context("invalid rpc url")
+            if let Some(url) = &*ZED_RPC_URL {
+                return Url::parse(url).context("invalid rpc url");
+            }
+
+            let mut url = http.build_url("/rpc");
+            if let Some(preview_param) =
+                release_channel.and_then(|channel| channel.release_query_param())
+            {
+                url += "?";
+                url += preview_param;
+            }
+
+            let response = http.get(&url, Default::default(), false).await?;
+            let collab_url = if response.status().is_redirection() {
+                response
+                    .headers()
+                    .get("Location")
+                    .ok_or_else(|| anyhow!("missing location header in /rpc response"))?
+                    .to_str()
+                    .map_err(EstablishConnectionError::other)?
+                    .to_string()
+            } else {
+                Err(anyhow!(
+                    "unexpected /rpc response status {}",
+                    response.status()
+                ))?
+            };
+
+            Url::parse(&collab_url).context("invalid rpc url")
+        }
    }

    fn establish_websocket_connection(
@@ -1144,8 +1167,9 @@ impl Client {
            );

        let http = self.http.clone();
+        let rpc_url = self.rpc_url(http, release_channel);
        cx.background_executor().spawn(async move {
-            let mut rpc_url = Self::get_rpc_url(http, release_channel).await?;
+            let mut rpc_url = rpc_url.await?;
            let rpc_host = rpc_url
                .host_str()
                .zip(rpc_url.port_or_known_default())
@@ -1186,6 +1210,7 @@ impl Client {
        cx: &AsyncAppContext,
    ) -> Task<Result<Credentials>> {
        let http = self.http.clone();
+        let this = self.clone();
        cx.spawn(|cx| async move {
            let background = cx.background_executor().clone();

@@ -1215,7 +1240,8 @@ impl Client {
                    {
                        eprintln!("authenticate as admin {login}, {token}");

-                        return Self::authenticate_as_admin(http, login.clone(), token.clone())
+                        return this
+                            .authenticate_as_admin(http, login.clone(), token.clone())
                            .await;
                    }

@@ -1303,6 +1329,7 @@ impl Client {
    }

    async fn authenticate_as_admin(
+        self: &Arc<Self>,
        http: Arc<HttpClientWithUrl>,
        login: String,
        mut api_token: String,
@@ -1319,7 +1346,7 @@ impl Client {

        // Use the collab server's admin API to retrieve the id
        // of the impersonated user.
-        let mut url = Self::get_rpc_url(http.clone(), None).await?;
+        let mut url = self.rpc_url(http.clone(), None).await?;
        url.set_path("/user");
        url.set_query(Some(&format!("github_login={login}")));
        let request = Request::get(url.as_str())
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -227,7 +227,7 @@ impl Telemetry {
                let state = state.clone();
                async move {
                    if let Some(tempfile) =
-                        NamedTempFile::new_in(paths::config_dir().as_path()).log_err()
+                        NamedTempFile::new_in(paths::logs_dir().as_path()).log_err()
                    {
                        state.lock().log_file = Some(tempfile);
                    }
--- a/crates/clock/Cargo.toml
+++ b/crates/clock/Cargo.toml
@@ -18,4 +18,5 @@ test-support = ["dep:parking_lot"]
 [dependencies]
 chrono.workspace = true
 parking_lot = { workspace = true, optional = true }
+serde.workspace = true
 smallvec.workspace = true
--- a/crates/clock/src/clock.rs
+++ b/crates/clock/src/clock.rs
@@ -1,5 +1,6 @@
 mod system_clock;

+use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 use std::{
    cmp::{self, Ordering},
@@ -16,7 +17,7 @@ pub type Seq = u32;

 /// A [Lamport timestamp](https://en.wikipedia.org/wiki/Lamport_timestamp),
 /// used to determine the ordering of events in the editor.
-#[derive(Clone, Copy, Default, Eq, Hash, PartialEq)]
+#[derive(Clone, Copy, Default, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct Lamport {
    pub replica_id: ReplicaId,
    pub value: Seq,
@@ -161,6 +162,10 @@ impl Lamport {
        }
    }

+    pub fn as_u64(self) -> u64 {
+        ((self.value as u64) << 32) | (self.replica_id as u64)
+    }
+
    pub fn tick(&mut self) -> Self {
        let timestamp = *self;
        self.value += 1;
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -71,6 +71,7 @@ util.workspace = true
 uuid.workspace = true

 [dev-dependencies]
+assistant = { workspace = true, features = ["test-support"] }
 async-trait.workspace = true
 audio.workspace = true
 call = { workspace = true, features = ["test-support"] }
--- a/crates/collab/src/api/extensions.rs
+++ b/crates/collab/src/api/extensions.rs
@@ -36,8 +36,6 @@ pub fn router() -> Router {
 struct GetExtensionsParams {
    filter: Option<String>,
    #[serde(default)]
-    ids: Option<String>,
-    #[serde(default)]
    max_schema_version: i32,
 }

@@ -45,26 +43,15 @@ async fn get_extensions(
    Extension(app): Extension<Arc<AppState>>,
    Query(params): Query<GetExtensionsParams>,
 ) -> Result<Json<GetExtensionsResponse>> {
-    let extension_ids = params
-        .ids
-        .as_ref()
-        .map(|s| s.split(',').map(|s| s.trim()).collect::<Vec<_>>());
+    let extensions = app
+        .db
+        .get_extensions(params.filter.as_deref(), params.max_schema_version, 500)
+        .await?;

-    let extensions = if let Some(extension_ids) = extension_ids {
-        app.db.get_extensions_by_ids(&extension_ids, None).await?
-    } else {
-        let result = app
-            .db
-            .get_extensions(params.filter.as_deref(), params.max_schema_version, 500)
-            .await?;
-
-        if let Some(query) = params.filter.as_deref() {
-            let count = result.len();
-            tracing::info!(query, count, "extension_search")
-        }
-
-        result
-    };
+    if let Some(query) = params.filter.as_deref() {
+        let count = extensions.len();
+        tracing::info!(query, count, "extension_search")
+    }

    Ok(Json(GetExtensionsResponse { data: extensions }))
 }
--- a/crates/collab/src/db/tests/db_tests.rs
+++ b/crates/collab/src/db/tests/db_tests.rs
@@ -562,7 +562,7 @@ fn test_fuzzy_like_string() {
    assert_eq!(Database::fuzzy_like_string(" z  "), "%z%");
 }

-#[cfg(target = "macos")]
+#[cfg(target_os = "macos")]
 #[gpui::test]
 async fn test_fuzzy_search_users(cx: &mut gpui::TestAppContext) {
    let test_db = tests::TestDb::postgres(cx.executor());
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -595,6 +595,14 @@ impl Server {
            .add_message_handler(user_message_handler(acknowledge_channel_message))
            .add_message_handler(user_message_handler(acknowledge_buffer_version))
            .add_request_handler(user_handler(get_supermaven_api_key))
+            .add_request_handler(user_handler(
+                forward_mutating_project_request::<proto::OpenContext>,
+            ))
+            .add_request_handler(user_handler(
+                forward_mutating_project_request::<proto::SynchronizeContexts>,
+            ))
+            .add_message_handler(broadcast_project_message_from_host::<proto::AdvertiseContexts>)
+            .add_message_handler(update_context)
            .add_streaming_request_handler({
                let app_state = app_state.clone();
                move |request, response, session| {
@@ -3056,6 +3064,53 @@ async fn update_buffer(
    Ok(())
 }

+async fn update_context(message: proto::UpdateContext, session: Session) -> Result<()> {
+    let project_id = ProjectId::from_proto(message.project_id);
+
+    let operation = message.operation.as_ref().context("invalid operation")?;
+    let capability = match operation.variant.as_ref() {
+        Some(proto::context_operation::Variant::BufferOperation(buffer_op)) => {
+            if let Some(buffer_op) = buffer_op.operation.as_ref() {
+                match buffer_op.variant {
+                    None | Some(proto::operation::Variant::UpdateSelections(_)) => {
+                        Capability::ReadOnly
+                    }
+                    _ => Capability::ReadWrite,
+                }
+            } else {
+                Capability::ReadWrite
+            }
+        }
+        Some(_) => Capability::ReadWrite,
+        None => Capability::ReadOnly,
+    };
+
+    let guard = session
+        .db()
+        .await
+        .connections_for_buffer_update(
+            project_id,
+            session.principal_id(),
+            session.connection_id,
+            capability,
+        )
+        .await?;
+
+    let (host, guests) = &*guard;
+
+    broadcast(
+        Some(session.connection_id),
+        guests.iter().chain([host]).copied(),
+        |connection_id| {
+            session
+                .peer
+                .forward_send(session.connection_id, connection_id, message.clone())
+        },
+    );
+
+    Ok(())
+}
+
 /// Notify other participants that a project has been updated.
 async fn broadcast_project_message_from_host<T: EntityMessage<Entity = ShareProject>>(
    request: T,
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -6,6 +6,7 @@ use crate::{
    },
 };
 use anyhow::{anyhow, Result};
+use assistant::ContextStore;
 use call::{room, ActiveCall, ParticipantLocation, Room};
 use client::{User, RECEIVE_TIMEOUT};
 use collections::{HashMap, HashSet};
@@ -6449,3 +6450,123 @@ async fn test_preview_tabs(cx: &mut TestAppContext) {
        assert!(!pane.can_navigate_forward());
    });
 }
+
+#[gpui::test(iterations = 10)]
+async fn test_context_collaboration_with_reconnect(
+    executor: BackgroundExecutor,
+    cx_a: &mut TestAppContext,
+    cx_b: &mut TestAppContext,
+) {
+    let mut server = TestServer::start(executor.clone()).await;
+    let client_a = server.create_client(cx_a, "user_a").await;
+    let client_b = server.create_client(cx_b, "user_b").await;
+    server
+        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+        .await;
+    let active_call_a = cx_a.read(ActiveCall::global);
+
+    client_a.fs().insert_tree("/a", Default::default()).await;
+    let (project_a, _) = client_a.build_local_project("/a", cx_a).await;
+    let project_id = active_call_a
+        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
+        .await
+        .unwrap();
+    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+
+    // Client A sees that a guest has joined.
+    executor.run_until_parked();
+
+    project_a.read_with(cx_a, |project, _| {
+        assert_eq!(project.collaborators().len(), 1);
+    });
+    project_b.read_with(cx_b, |project, _| {
+        assert_eq!(project.collaborators().len(), 1);
+    });
+
+    let context_store_a = cx_a
+        .update(|cx| ContextStore::new(project_a.clone(), cx))
+        .await
+        .unwrap();
+    let context_store_b = cx_b
+        .update(|cx| ContextStore::new(project_b.clone(), cx))
+        .await
+        .unwrap();
+
+    // Client A creates a new context.
+    let context_a = context_store_a.update(cx_a, |store, cx| store.create(cx));
+    executor.run_until_parked();
+
+    // Client B retrieves host's contexts and joins one.
+    let context_b = context_store_b
+        .update(cx_b, |store, cx| {
+            let host_contexts = store.host_contexts().to_vec();
+            assert_eq!(host_contexts.len(), 1);
+            store.open_remote_context(host_contexts[0].id.clone(), cx)
+        })
+        .await
+        .unwrap();
+
+    // Host and guest make changes
+    context_a.update(cx_a, |context, cx| {
+        context.buffer().update(cx, |buffer, cx| {
+            buffer.edit([(0..0, "Host change\n")], None, cx)
+        })
+    });
+    context_b.update(cx_b, |context, cx| {
+        context.buffer().update(cx, |buffer, cx| {
+            buffer.edit([(0..0, "Guest change\n")], None, cx)
+        })
+    });
+    executor.run_until_parked();
+    assert_eq!(
+        context_a.read_with(cx_a, |context, cx| context.buffer().read(cx).text()),
+        "Guest change\nHost change\n"
+    );
+    assert_eq!(
+        context_b.read_with(cx_b, |context, cx| context.buffer().read(cx).text()),
+        "Guest change\nHost change\n"
+    );
+
+    // Disconnect client A and make some changes while disconnected.
+    server.disconnect_client(client_a.peer_id().unwrap());
+    server.forbid_connections();
+    context_a.update(cx_a, |context, cx| {
+        context.buffer().update(cx, |buffer, cx| {
+            buffer.edit([(0..0, "Host offline change\n")], None, cx)
+        })
+    });
+    context_b.update(cx_b, |context, cx| {
+        context.buffer().update(cx, |buffer, cx| {
+            buffer.edit([(0..0, "Guest offline change\n")], None, cx)
+        })
+    });
+    executor.run_until_parked();
+    assert_eq!(
+        context_a.read_with(cx_a, |context, cx| context.buffer().read(cx).text()),
+        "Host offline change\nGuest change\nHost change\n"
+    );
+    assert_eq!(
+        context_b.read_with(cx_b, |context, cx| context.buffer().read(cx).text()),
+        "Guest offline change\nGuest change\nHost change\n"
+    );
+
+    // Allow client A to reconnect and verify that contexts converge.
+    server.allow_connections();
+    executor.advance_clock(RECEIVE_TIMEOUT);
+    assert_eq!(
+        context_a.read_with(cx_a, |context, cx| context.buffer().read(cx).text()),
+        "Guest offline change\nHost offline change\nGuest change\nHost change\n"
+    );
+    assert_eq!(
+        context_b.read_with(cx_b, |context, cx| context.buffer().read(cx).text()),
+        "Guest offline change\nHost offline change\nGuest change\nHost change\n"
+    );
+
+    // Client A disconnects without being able to reconnect. Context B becomes readonly.
+    server.forbid_connections();
+    server.disconnect_client(client_a.peer_id().unwrap());
+    executor.advance_clock(RECEIVE_TIMEOUT + RECONNECT_TIMEOUT);
+    context_b.read_with(cx_b, |context, cx| {
+        assert!(context.buffer().read(cx).read_only());
+    });
+}
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -294,6 +294,8 @@ impl TestServer {
            menu::init();
            dev_server_projects::init(client.clone(), cx);
            settings::KeymapFile::load_asset(os_keymap, cx).unwrap();
+            assistant::FakeCompletionProvider::setup_test(cx);
+            assistant::context_store::init(&client);
        });

        client
--- a/crates/collab_ui/src/chat_panel.rs
+++ b/crates/collab_ui/src/chat_panel.rs
@@ -355,11 +355,10 @@ impl ChatPanel {
                .child(Icon::new(IconName::ReplyArrowRight).color(Color::Muted))
                .child(Avatar::new(user_being_replied_to.avatar_uri.clone()).size(rems(0.7)))
                .child(
-                    div().font_weight(FontWeight::SEMIBOLD).child(
-                        Label::new(format!("@{}", user_being_replied_to.github_login))
-                            .size(LabelSize::XSmall)
-                            .color(Color::Muted),
-                    ),
+                    Label::new(format!("@{}", user_being_replied_to.github_login))
+                        .size(LabelSize::XSmall)
+                        .weight(FontWeight::SEMIBOLD)
+                        .color(Color::Muted),
                )
                .child(
                    div().overflow_y_hidden().child(
@@ -490,22 +489,16 @@ impl ChatPanel {
                        |this| {
                            this.child(
                                h_flex()
+                                    .gap_2()
                                    .text_ui_sm(cx)
                                    .child(
-                                        div().absolute().child(
-                                            Avatar::new(message.sender.avatar_uri.clone())
-                                                .size(rems(1.)),
-                                        ),
+                                        Avatar::new(message.sender.avatar_uri.clone())
+                                            .size(rems(1.)),
                                    )
                                    .child(
-                                        div()
-                                            .pl(cx.rem_size() + px(6.0))
-                                            .pr(px(8.0))
-                                            .font_weight(FontWeight::BOLD)
-                                            .child(
-                                                Label::new(message.sender.github_login.clone())
-                                                    .size(LabelSize::Small),
-                                            ),
+                                        Label::new(message.sender.github_login.clone())
+                                            .size(LabelSize::Small)
+                                            .weight(FontWeight::BOLD),
                                    )
                                    .child(
                                        Label::new(time_format::format_localized_timestamp(
@@ -1044,13 +1037,12 @@ impl Render for ChatPanel {
                                        .id(("reply-preview", reply_to_message_id))
                                        .child(Label::new("Replying to ").size(LabelSize::Small))
                                        .child(
-                                            div().font_weight(FontWeight::BOLD).child(
-                                                Label::new(format!(
-                                                    "@{}",
-                                                    user_being_replied_to.github_login.clone()
-                                                ))
-                                                .size(LabelSize::Small),
-                                            ),
+                                            Label::new(format!(
+                                                "@{}",
+                                                user_being_replied_to.github_login.clone()
+                                            ))
+                                            .size(LabelSize::Small)
+                                            .weight(FontWeight::BOLD),
                                        )
                                        .when_some(channel_id, |this, channel_id| {
                                            this.cursor_pointer().on_click(cx.listener(
--- a/crates/collab_ui/src/collab_panel.rs
+++ b/crates/collab_ui/src/collab_panel.rs
@@ -2547,9 +2547,8 @@ impl CollabPanel {
                    .take(FACEPILE_LIMIT)
                    .chain(if extra_count > 0 {
                        Some(
-                            div()
+                            Label::new(format!("+{extra_count}"))
                                .ml_2()
-                                .child(Label::new(format!("+{extra_count}")))
                                .into_any_element(),
                        )
                    } else {
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -89,13 +89,16 @@ use language::{
    CursorShape, Diagnostic, Documentation, IndentKind, IndentSize, Language, OffsetRangeExt,
    Point, Selection, SelectionGoal, TransactionId,
 };
-use language::{BufferRow, Runnable, RunnableRange};
+use language::{point_to_lsp, BufferRow, Runnable, RunnableRange};
 use linked_editing_ranges::refresh_linked_ranges;
 use task::{ResolvedTask, TaskTemplate, TaskVariables};

 use hover_links::{HoverLink, HoveredLinkState, InlayHighlight};
 pub use lsp::CompletionContext;
-use lsp::{CompletionTriggerKind, DiagnosticSeverity, LanguageServerId};
+use lsp::{
+    CompletionItemKind, CompletionTriggerKind, DiagnosticSeverity, InsertTextFormat,
+    LanguageServerId,
+};
 use mouse_context_menu::MouseContextMenu;
 use movement::TextLayoutDetails;
 pub use multi_buffer::{
@@ -1126,11 +1129,10 @@ impl CompletionsMenu {
                                    None
                                } else {
                                    Some(
-                                        h_flex().ml_4().child(
-                                            Label::new(text.clone())
-                                                .size(LabelSize::Small)
-                                                .color(Color::Muted),
-                                        ),
+                                        Label::new(text.clone())
+                                            .ml_4()
+                                            .size(LabelSize::Small)
+                                            .color(Color::Muted),
                                    )
                                }
                            } else {
@@ -1153,7 +1155,7 @@ impl CompletionsMenu {
                                    }
                                }))
                                .child(h_flex().overflow_hidden().child(completion_label))
-                                .end_slot::<Div>(documentation_label),
+                                .end_slot::<Label>(documentation_label),
                        )
                    })
                    .collect()
@@ -1927,6 +1929,11 @@ impl Editor {
            EditorMode::AutoHeight { .. } => "auto_height",
            EditorMode::Full => "full",
        };
+
+        if EditorSettings::get_global(cx).jupyter.enabled {
+            key_context.add("jupyter");
+        }
+
        key_context.set("mode", mode);
        if self.pending_rename.is_some() {
            key_context.add("renaming");
@@ -5152,7 +5159,6 @@ impl Editor {
                })
                .collect::<Vec<_>>()
        });
-
        if let Some(tabstop) = tabstops.first() {
            self.change_selections(Some(Autoscroll::fit()), cx, |s| {
                s.select_ranges(tabstop.ranges.iter().cloned());
@@ -11087,6 +11093,7 @@ impl Editor {
                if *singleton_buffer_edited {
                    if let Some(project) = &self.project {
                        let project = project.read(cx);
+                        #[allow(clippy::mutable_key_type)]
                        let languages_affected = multibuffer
                            .read(cx)
                            .all_buffers()
@@ -11752,6 +11759,97 @@ pub trait CompletionProvider {
    ) -> bool;
 }

+fn snippet_completions(
+    project: &Project,
+    buffer: &Model<Buffer>,
+    buffer_position: text::Anchor,
+    cx: &mut AppContext,
+) -> Vec<Completion> {
+    let language = buffer.read(cx).language_at(buffer_position);
+    let language_name = language.as_ref().map(|language| language.lsp_id());
+    let snippet_store = project.snippets().read(cx);
+    let snippets = snippet_store.snippets_for(language_name, cx);
+
+    if snippets.is_empty() {
+        return vec![];
+    }
+    let snapshot = buffer.read(cx).text_snapshot();
+    let chunks = snapshot.reversed_chunks_in_range(text::Anchor::MIN..buffer_position);
+
+    let mut lines = chunks.lines();
+    let Some(line_at) = lines.next().filter(|line| !line.is_empty()) else {
+        return vec![];
+    };
+
+    let scope = language.map(|language| language.default_scope());
+    let mut last_word = line_at
+        .chars()
+        .rev()
+        .take_while(|c| char_kind(&scope, *c) == CharKind::Word)
+        .collect::<String>();
+    last_word = last_word.chars().rev().collect();
+    let as_offset = text::ToOffset::to_offset(&buffer_position, &snapshot);
+    let to_lsp = |point: &text::Anchor| {
+        let end = text::ToPointUtf16::to_point_utf16(point, &snapshot);
+        point_to_lsp(end)
+    };
+    let lsp_end = to_lsp(&buffer_position);
+    snippets
+        .into_iter()
+        .filter_map(|snippet| {
+            let matching_prefix = snippet
+                .prefix
+                .iter()
+                .find(|prefix| prefix.starts_with(&last_word))?;
+            let start = as_offset - last_word.len();
+            let start = snapshot.anchor_before(start);
+            let range = start..buffer_position;
+            let lsp_start = to_lsp(&start);
+            let lsp_range = lsp::Range {
+                start: lsp_start,
+                end: lsp_end,
+            };
+            Some(Completion {
+                old_range: range,
+                new_text: snippet.body.clone(),
+                label: CodeLabel {
+                    text: matching_prefix.clone(),
+                    runs: vec![],
+                    filter_range: 0..matching_prefix.len(),
+                },
+                server_id: LanguageServerId(usize::MAX),
+                documentation: snippet
+                    .description
+                    .clone()
+                    .map(|description| Documentation::SingleLine(description)),
+                lsp_completion: lsp::CompletionItem {
+                    label: snippet.prefix.first().unwrap().clone(),
+                    kind: Some(CompletionItemKind::SNIPPET),
+                    label_details: snippet.description.as_ref().map(|description| {
+                        lsp::CompletionItemLabelDetails {
+                            detail: Some(description.clone()),
+                            description: None,
+                        }
+                    }),
+                    insert_text_format: Some(InsertTextFormat::SNIPPET),
+                    text_edit: Some(lsp::CompletionTextEdit::InsertAndReplace(
+                        lsp::InsertReplaceEdit {
+                            new_text: snippet.body.clone(),
+                            insert: lsp_range,
+                            replace: lsp_range,
+                        },
+                    )),
+                    filter_text: Some(snippet.body.clone()),
+                    sort_text: Some(char::MAX.to_string()),
+                    ..Default::default()
+                },
+                confirm: None,
+                show_new_completions_on_confirm: false,
+            })
+        })
+        .collect()
+}
+
 impl CompletionProvider for Model<Project> {
    fn completions(
        &self,
@@ -11761,7 +11859,14 @@ impl CompletionProvider for Model<Project> {
        cx: &mut ViewContext<Editor>,
    ) -> Task<Result<Vec<Completion>>> {
        self.update(cx, |project, cx| {
-            project.completions(&buffer, buffer_position, options, cx)
+            let snippets = snippet_completions(project, buffer, buffer_position, cx);
+            let project_completions = project.completions(&buffer, buffer_position, options, cx);
+            cx.background_executor().spawn(async move {
+                let mut completions = project_completions.await?;
+                //let snippets = snippets.into_iter().;
+                completions.extend(snippets);
+                Ok(completions)
+            })
        })
    }

@@ -12719,7 +12824,7 @@ pub(crate) fn split_words(text: &str) -> impl std::iter::Iterator<Item = &str> +
        })
 }

-trait RangeToAnchorExt {
+pub trait RangeToAnchorExt {
    fn to_anchors(self, snapshot: &MultiBufferSnapshot) -> Range<Anchor>;
 }

--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -25,6 +25,8 @@ pub struct EditorSettings {
    pub expand_excerpt_lines: u32,
    #[serde(default)]
    pub double_click_in_multibuffer: DoubleClickInMultibuffer,
+    #[serde(default)]
+    pub jupyter: Jupyter,
 }

 #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
@@ -64,6 +66,15 @@ pub enum DoubleClickInMultibuffer {
    Open,
 }

+#[derive(Default, Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub struct Jupyter {
+    /// Whether the Jupyter feature is enabled.
+    ///
+    /// Default: `false`
+    pub enabled: bool,
+}
+
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
 pub struct Toolbar {
    pub breadcrumbs: bool,
@@ -217,6 +228,9 @@ pub struct EditorSettingsContent {
    ///
    /// Default: select
    pub double_click_in_multibuffer: Option<DoubleClickInMultibuffer>,
+
+    /// Jupyter REPL settings.
+    pub jupyter: Option<Jupyter>,
 }

 // Toolbar related settings
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -3660,6 +3660,11 @@ impl EditorElement {
                        if scroll_position != current_scroll_position {
                            editor.scroll(scroll_position, axis, cx);
                            cx.stop_propagation();
+                        } else if y < 0. {
+                            // Due to clamping, we may fail to detect cases of overscroll to the top;
+                            // We want the scroll manager to get an update in such cases and detect the change of direction
+                            // on the next frame.
+                            cx.notify();
                        }
                    });
                }
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -19,7 +19,7 @@ use project::{HoverBlock, HoverBlockKind, InlayHintLabelPart};
 use settings::Settings;
 use smol::stream::StreamExt;
 use std::{ops::Range, sync::Arc, time::Duration};
-use ui::{prelude::*, Tooltip};
+use ui::{prelude::*, window_is_transparent, Tooltip};
 use util::TryFutureExt;
 use workspace::Workspace;

@@ -587,15 +587,12 @@ impl DiagnosticPopover {
        div()
            .id("diagnostic")
            .block()
-            .elevation_2(cx)
-            .overflow_y_scroll()
-            .px_2()
-            .py_1()
-            .bg(diagnostic_colors.background)
-            .text_color(style.text.color)
-            .border_1()
-            .border_color(diagnostic_colors.border)
-            .rounded_md()
+            .elevation_2_borderless(cx)
+            // Don't draw the background color if the theme
+            // allows transparent surfaces.
+            .when(window_is_transparent(cx), |this| {
+                this.bg(gpui::transparent_black())
+            })
            .max_w(max_size.width)
            .max_h(max_size.height)
            .cursor(CursorStyle::PointingHand)
@@ -607,7 +604,19 @@ impl DiagnosticPopover {
            // because that would move the cursor.
            .on_mouse_down(MouseButton::Left, |_, cx| cx.stop_propagation())
            .on_click(cx.listener(|editor, _, cx| editor.go_to_diagnostic(&Default::default(), cx)))
-            .child(SharedString::from(text))
+            .child(
+                div()
+                    .id("diagnostic-inner")
+                    .overflow_y_scroll()
+                    .px_2()
+                    .py_1()
+                    .bg(diagnostic_colors.background)
+                    .text_color(style.text.color)
+                    .border_1()
+                    .border_color(diagnostic_colors.border)
+                    .rounded_lg()
+                    .child(SharedString::from(text)),
+            )
            .into_any_element()
    }

--- a/crates/editor/src/mouse_context_menu.rs
+++ b/crates/editor/src/mouse_context_menu.rs
@@ -1,7 +1,10 @@
+use std::ops::Range;
+
 use crate::{
-    Copy, CopyPermalinkToLine, Cut, DisplayPoint, Editor, EditorMode, FindAllReferences,
-    GoToDefinition, GoToImplementation, GoToTypeDefinition, Paste, Rename, RevealInFileManager,
-    SelectMode, ToggleCodeActions,
+    selections_collection::SelectionsCollection, Copy, CopyPermalinkToLine, Cut, DisplayPoint,
+    DisplaySnapshot, Editor, EditorMode, FindAllReferences, GoToDefinition, GoToImplementation,
+    GoToTypeDefinition, Paste, Rename, RevealInFileManager, SelectMode, ToDisplayPoint,
+    ToggleCodeActions,
 };
 use gpui::prelude::FluentBuilder;
 use gpui::{DismissEvent, Pixels, Point, Subscription, View, ViewContext};
@@ -38,6 +41,23 @@ impl MouseContextMenu {
    }
 }

+fn display_ranges<'a>(
+    display_map: &'a DisplaySnapshot,
+    selections: &'a SelectionsCollection,
+) -> impl Iterator<Item = Range<DisplayPoint>> + 'a {
+    let pending = selections
+        .pending
+        .as_ref()
+        .map(|pending| &pending.selection);
+    selections.disjoint.iter().chain(pending).map(move |s| {
+        if s.reversed {
+            s.end.to_display_point(&display_map)..s.start.to_display_point(&display_map)
+        } else {
+            s.start.to_display_point(&display_map)..s.end.to_display_point(&display_map)
+        }
+    })
+}
+
 pub fn deploy_context_menu(
    editor: &mut Editor,
    position: Point<Pixels>,
@@ -66,11 +86,14 @@ pub fn deploy_context_menu(
            return;
        }

-        // Move the cursor to the clicked location so that dispatched actions make sense
-        editor.change_selections(None, cx, |s| {
-            s.clear_disjoint();
-            s.set_pending_display_range(point..point, SelectMode::Character);
-        });
+        let display_map = editor.selections.display_map(cx);
+        if !display_ranges(&display_map, &editor.selections).any(|r| r.contains(&point)) {
+            // Move the cursor to the clicked location so that dispatched actions make sense
+            editor.change_selections(None, cx, |s| {
+                s.clear_disjoint();
+                s.set_pending_display_range(point..point, SelectMode::Character);
+            });
+        }

        let focus = cx.focused();
        ui::ContextMenu::build(cx, |menu, _cx| {
--- a/crates/extension/Cargo.toml
+++ b/crates/extension/Cargo.toml
@@ -42,6 +42,7 @@ semantic_version.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
+snippet_provider.workspace = true
 theme.workspace = true
 toml.workspace = true
 ui.workspace = true
--- a/crates/extension/src/extension_builder.rs
+++ b/crates/extension/src/extension_builder.rs
@@ -526,6 +526,11 @@ fn populate_defaults(manifest: &mut ExtensionManifest, extension_path: &Path) ->
        }
    }

+    let snippets_json_path = extension_path.join("snippets.json");
+    if snippets_json_path.exists() {
+        manifest.snippets = Some(snippets_json_path);
+    }
+
    // For legacy extensions on the v0 schema (aka, using `extension.json`), we want to populate the grammars in
    // the manifest using the contents of the `grammars` directory.
    if manifest.schema_version.is_v0() {
--- a/crates/extension/src/extension_manifest.rs
+++ b/crates/extension/src/extension_manifest.rs
@@ -78,6 +78,8 @@ pub struct ExtensionManifest {
    pub slash_commands: BTreeMap<Arc<str>, SlashCommandManifestEntry>,
    #[serde(default)]
    pub indexed_docs_providers: BTreeMap<Arc<str>, IndexedDocsProviderEntry>,
+    #[serde(default)]
+    pub snippets: Option<PathBuf>,
 }

 #[derive(Clone, Default, PartialEq, Eq, Debug, Deserialize, Serialize)]
@@ -206,5 +208,6 @@ fn manifest_from_old_manifest(
        language_servers: Default::default(),
        slash_commands: BTreeMap::default(),
        indexed_docs_providers: BTreeMap::default(),
+        snippets: None,
    }
 }
--- a/crates/extension/src/extension_slash_command.rs
+++ b/crates/extension/src/extension_slash_command.rs
@@ -1,7 +1,9 @@
 use std::sync::{atomic::AtomicBool, Arc};

 use anyhow::{anyhow, Result};
-use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection};
+use assistant_slash_command::{
+    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
+};
 use futures::FutureExt;
 use gpui::{AppContext, Task, WeakView, WindowContext};
 use language::LspAdapterDelegate;
@@ -41,7 +43,7 @@ impl SlashCommand for ExtensionSlashCommand {
        _cancel: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
        cx.background_executor().spawn(async move {
            self.extension
                .call({
@@ -57,7 +59,16 @@ impl SlashCommand for ExtensionSlashCommand {
                                .await?
                                .map_err(|e| anyhow!("{}", e))?;

-                            anyhow::Ok(completions)
+                            anyhow::Ok(
+                                completions
+                                    .into_iter()
+                                    .map(|completion| ArgumentCompletion {
+                                        label: completion.label,
+                                        new_text: completion.new_text,
+                                        run_command: completion.run_command,
+                                    })
+                                    .collect(),
+                            )
                        }
                        .boxed()
                    }
--- a/crates/extension/src/extension_store.rs
+++ b/crates/extension/src/extension_store.rs
@@ -44,6 +44,7 @@ use release_channel::ReleaseChannel;
 use semantic_version::SemanticVersion;
 use serde::{Deserialize, Serialize};
 use settings::Settings;
+use snippet_provider::SnippetRegistry;
 use std::ops::RangeInclusive;
 use std::str::FromStr;
 use std::{
@@ -115,6 +116,7 @@ pub struct ExtensionStore {
    theme_registry: Arc<ThemeRegistry>,
    slash_command_registry: Arc<SlashCommandRegistry>,
    indexed_docs_registry: Arc<IndexedDocsRegistry>,
+    snippet_registry: Arc<SnippetRegistry>,
    modified_extensions: HashSet<Arc<str>>,
    wasm_host: Arc<WasmHost>,
    wasm_extensions: Vec<(Arc<ExtensionManifest>, WasmExtension)>,
@@ -193,6 +195,7 @@ pub fn init(
            theme_registry,
            SlashCommandRegistry::global(cx),
            IndexedDocsRegistry::global(cx),
+            SnippetRegistry::global(cx),
            cx,
        )
    });
@@ -227,6 +230,7 @@ impl ExtensionStore {
        theme_registry: Arc<ThemeRegistry>,
        slash_command_registry: Arc<SlashCommandRegistry>,
        indexed_docs_registry: Arc<IndexedDocsRegistry>,
+        snippet_registry: Arc<SnippetRegistry>,
        cx: &mut ModelContext<Self>,
    ) -> Self {
        let work_dir = extensions_dir.join("work");
@@ -259,6 +263,7 @@ impl ExtensionStore {
            theme_registry,
            slash_command_registry,
            indexed_docs_registry,
+            snippet_registry,
            reload_tx,
            tasks: Vec::new(),
        };
@@ -1045,6 +1050,7 @@ impl ExtensionStore {
            .collect::<Vec<_>>();
        let mut grammars_to_add = Vec::new();
        let mut themes_to_add = Vec::new();
+        let mut snippets_to_add = Vec::new();
        for extension_id in &extensions_to_load {
            let Some(extension) = new_index.extensions.get(extension_id) else {
                continue;
@@ -1062,6 +1068,11 @@ impl ExtensionStore {
                path.extend([Path::new(extension_id.as_ref()), theme_path.as_path()]);
                path
            }));
+            snippets_to_add.extend(extension.manifest.snippets.iter().map(|snippets_path| {
+                let mut path = self.installed_dir.clone();
+                path.extend([Path::new(extension_id.as_ref()), snippets_path.as_path()]);
+                path
+            }));
        }

        self.language_registry
@@ -1097,6 +1108,7 @@ impl ExtensionStore {
        let wasm_host = self.wasm_host.clone();
        let root_dir = self.installed_dir.clone();
        let theme_registry = self.theme_registry.clone();
+        let snippet_registry = self.snippet_registry.clone();
        let extension_entries = extensions_to_load
            .iter()
            .filter_map(|name| new_index.extensions.get(name).cloned())
@@ -1117,6 +1129,15 @@ impl ExtensionStore {
                                .await
                                .log_err();
                        }
+
+                        for snippets_path in &snippets_to_add {
+                            if let Some(snippets_contents) = fs.load(snippets_path).await.log_err()
+                            {
+                                snippet_registry
+                                    .register_snippets(snippets_path, &snippets_contents)
+                                    .log_err();
+                            }
+                        }
                    }
                })
                .await;
--- a/crates/extension/src/extension_store_test.rs
+++ b/crates/extension/src/extension_store_test.rs
@@ -19,6 +19,7 @@ use parking_lot::Mutex;
 use project::{Project, DEFAULT_COMPLETION_CONTEXT};
 use serde_json::json;
 use settings::{Settings as _, SettingsStore};
+use snippet_provider::SnippetRegistry;
 use std::{
    ffi::OsString,
    path::{Path, PathBuf},
@@ -160,6 +161,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                        language_servers: BTreeMap::default(),
                        slash_commands: BTreeMap::default(),
                        indexed_docs_providers: BTreeMap::default(),
+                        snippets: None,
                    }),
                    dev: false,
                },
@@ -185,6 +187,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                        language_servers: BTreeMap::default(),
                        slash_commands: BTreeMap::default(),
                        indexed_docs_providers: BTreeMap::default(),
+                        snippets: None,
                    }),
                    dev: false,
                },
@@ -258,6 +261,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
    let theme_registry = Arc::new(ThemeRegistry::new(Box::new(())));
    let slash_command_registry = SlashCommandRegistry::new();
    let indexed_docs_registry = Arc::new(IndexedDocsRegistry::new(cx.executor()));
+    let snippet_registry = Arc::new(SnippetRegistry::new());
    let node_runtime = FakeNodeRuntime::new();

    let store = cx.new_model(|cx| {
@@ -272,6 +276,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
            theme_registry.clone(),
            slash_command_registry.clone(),
            indexed_docs_registry.clone(),
+            snippet_registry.clone(),
            cx,
        )
    });
@@ -345,6 +350,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                language_servers: BTreeMap::default(),
                slash_commands: BTreeMap::default(),
                indexed_docs_providers: BTreeMap::default(),
+                snippets: None,
            }),
            dev: false,
        },
@@ -396,6 +402,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
            theme_registry.clone(),
            slash_command_registry,
            indexed_docs_registry,
+            snippet_registry,
            cx,
        )
    });
@@ -477,6 +484,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
    let theme_registry = Arc::new(ThemeRegistry::new(Box::new(())));
    let slash_command_registry = SlashCommandRegistry::new();
    let indexed_docs_registry = Arc::new(IndexedDocsRegistry::new(cx.executor()));
+    let snippet_registry = Arc::new(SnippetRegistry::new());
    let node_runtime = FakeNodeRuntime::new();

    let mut status_updates = language_registry.language_server_binary_statuses();
@@ -568,6 +576,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
            theme_registry.clone(),
            slash_command_registry,
            indexed_docs_registry,
+            snippet_registry,
            cx,
        )
    });
--- a/crates/extension/src/wasm_host/wit.rs
+++ b/crates/extension/src/wasm_host/wit.rs
@@ -20,7 +20,7 @@ use wasmtime::{
 pub use latest::CodeLabelSpanLiteral;
 pub use latest::{
    zed::extension::lsp::{Completion, CompletionKind, InsertTextFormat, Symbol, SymbolKind},
-    zed::extension::slash_command::SlashCommandOutput,
+    zed::extension::slash_command::{SlashCommandArgumentCompletion, SlashCommandOutput},
    CodeLabel, CodeLabelSpan, Command, Range, SlashCommand,
 };
 pub use since_v0_0_4::LanguageServerConfig;
@@ -263,7 +263,7 @@ impl Extension {
        store: &mut Store<WasmState>,
        command: &SlashCommand,
        query: &str,
-    ) -> Result<Result<Vec<String>, String>> {
+    ) -> Result<Result<Vec<SlashCommandArgumentCompletion>, String>> {
        match self {
            Extension::V007(ext) => {
                ext.call_complete_slash_command_argument(store, command, query)
--- a/crates/extension/src/wasm_host/wit/since_v0_0_7.rs
+++ b/crates/extension/src/wasm_host/wit/since_v0_0_7.rs
@@ -421,27 +421,10 @@ impl ExtensionImports for WasmState {
                        .await?;
                }
                DownloadedFileType::Zip => {
-                    let file_name = destination_path
-                        .file_name()
-                        .ok_or_else(|| anyhow!("invalid download path"))?
-                        .to_string_lossy();
-                    let zip_filename = format!("{file_name}.zip");
-                    let mut zip_path = destination_path.clone();
-                    zip_path.set_file_name(zip_filename);
-
                    futures::pin_mut!(body);
-                    self.host.fs.create_file_with(&zip_path, body).await?;
-
-                    let unzip_status = std::process::Command::new("unzip")
-                        .current_dir(&extension_work_dir)
-                        .arg("-d")
-                        .arg(&destination_path)
-                        .arg(&zip_path)
-                        .output()?
-                        .status;
-                    if !unzip_status.success() {
-                        Err(anyhow!("failed to unzip {} archive", path.display()))?;
-                    }
+                    node_runtime::extract_zip(&destination_path, body)
+                        .await
+                        .with_context(|| format!("failed to unzip {} archive", path.display()))?;
                }
            }

--- a/crates/extension_api/src/extension_api.rs
+++ b/crates/extension_api/src/extension_api.rs
@@ -25,7 +25,9 @@ pub use wit::{
        npm_package_latest_version,
    },
    zed::extension::platform::{current_platform, Architecture, Os},
-    zed::extension::slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection},
+    zed::extension::slash_command::{
+        SlashCommand, SlashCommandArgumentCompletion, SlashCommandOutput, SlashCommandOutputSection,
+    },
    CodeLabel, CodeLabelSpan, CodeLabelSpanLiteral, Command, DownloadedFileType, EnvVars,
    KeyValueStore, LanguageServerInstallationStatus, Range, Worktree,
 };
@@ -114,7 +116,7 @@ pub trait Extension: Send + Sync {
        &self,
        _command: SlashCommand,
        _query: String,
-    ) -> Result<Vec<String>, String> {
+    ) -> Result<Vec<SlashCommandArgumentCompletion>, String> {
        Ok(Vec::new())
    }

@@ -247,7 +249,7 @@ impl wit::Guest for Component {
    fn complete_slash_command_argument(
        command: SlashCommand,
        query: String,
-    ) -> Result<Vec<String>, String> {
+    ) -> Result<Vec<SlashCommandArgumentCompletion>, String> {
        extension().complete_slash_command_argument(command, query)
    }

--- a/crates/extension_api/wit/since_v0.0.7/extension.wit
+++ b/crates/extension_api/wit/since_v0.0.7/extension.wit
@@ -8,7 +8,7 @@ world extension {

    use common.{range};
    use lsp.{completion, symbol};
-    use slash-command.{slash-command, slash-command-output};
+    use slash-command.{slash-command, slash-command-argument-completion, slash-command-output};

    /// Initializes the extension.
    export init-extension: func();
@@ -130,7 +130,7 @@ world extension {
    export labels-for-symbols: func(language-server-id: string, symbols: list<symbol>) -> result<list<option<code-label>>, string>;

    /// Returns the completions that should be shown when completing the provided slash command with the given query.
-    export complete-slash-command-argument: func(command: slash-command, query: string) -> result<list<string>, string>;
+    export complete-slash-command-argument: func(command: slash-command, query: string) -> result<list<slash-command-argument-completion>, string>;

    /// Returns the output from running the provided slash command.
    export run-slash-command: func(command: slash-command, argument: option<string>, worktree: borrow<worktree>) -> result<slash-command-output, string>;
--- a/crates/extension_api/wit/since_v0.0.7/slash-command.wit
+++ b/crates/extension_api/wit/since_v0.0.7/slash-command.wit
@@ -28,4 +28,14 @@ interface slash-command {
        /// The label to display in the placeholder for this section.
        label: string,
    }
+
+    /// A completion for a slash command argument.
+    record slash-command-argument-completion {
+        /// The label to display for this completion.
+        label: string,
+        /// The new text that should be inserted into the command when this completion is accepted.
+        new-text: string,
+        /// Whether the command should be run when accepting this completion.
+        run-command: bool,
+    }
 }
--- a/crates/gpui/build.rs
+++ b/crates/gpui/build.rs
@@ -7,7 +7,7 @@ use std::env;

 fn main() {
    let target = env::var("CARGO_CFG_TARGET_OS");
-
+    println!("cargo::rustc-check-cfg=cfg(gles)");
    match target.as_deref() {
        Ok("macos") => {
            #[cfg(target_os = "macos")]
--- a/crates/gpui/examples/input.rs
+++ b/crates/gpui/examples/input.rs
@@ -26,6 +26,8 @@ struct TextInput {
    selection_reversed: bool,
    marked_range: Option<Range<usize>>,
    last_layout: Option<ShapedLine>,
+    last_bounds: Option<Bounds<Pixels>>,
+    is_selecting: bool,
 }

 impl TextInput {
@@ -80,6 +82,21 @@ impl TextInput {
        self.replace_text_in_range(None, "", cx)
    }

+    fn on_mouse_down(&mut self, event: &MouseDownEvent, cx: &mut ViewContext<Self>) {
+        self.is_selecting = true;
+        self.move_to(self.index_for_mouse_position(event.position), cx)
+    }
+
+    fn on_mouse_up(&mut self, _: &MouseUpEvent, _: &mut ViewContext<Self>) {
+        self.is_selecting = false;
+    }
+
+    fn on_mouse_move(&mut self, event: &MouseMoveEvent, cx: &mut ViewContext<Self>) {
+        if self.is_selecting {
+            self.select_to(self.index_for_mouse_position(event.position), cx);
+        }
+    }
+
    fn show_character_palette(&mut self, _: &ShowCharacterPalette, cx: &mut ViewContext<Self>) {
        cx.show_character_palette();
    }
@@ -97,6 +114,20 @@ impl TextInput {
        }
    }

+    fn index_for_mouse_position(&self, position: Point<Pixels>) -> usize {
+        let (Some(bounds), Some(line)) = (self.last_bounds.as_ref(), self.last_layout.as_ref())
+        else {
+            return 0;
+        };
+        if position.y < bounds.top() {
+            return 0;
+        }
+        if position.y > bounds.bottom() {
+            return self.content.len();
+        }
+        line.closest_index_for_x(position.x - bounds.left())
+    }
+
    fn select_to(&mut self, offset: usize, cx: &mut ViewContext<Self>) {
        if self.selection_reversed {
            self.selected_range.start = offset
@@ -409,6 +440,7 @@ impl Element for TextElement {
        }
        self.input.update(cx, |input, _cx| {
            input.last_layout = Some(line);
+            input.last_bounds = Some(bounds);
        });
    }
 }
@@ -419,6 +451,7 @@ impl Render for TextInput {
            .flex()
            .key_context("TextInput")
            .track_focus(&self.focus_handle)
+            .cursor(CursorStyle::IBeam)
            .on_action(cx.listener(Self::backspace))
            .on_action(cx.listener(Self::delete))
            .on_action(cx.listener(Self::left))
@@ -429,6 +462,10 @@ impl Render for TextInput {
            .on_action(cx.listener(Self::home))
            .on_action(cx.listener(Self::end))
            .on_action(cx.listener(Self::show_character_palette))
+            .on_mouse_down(MouseButton::Left, cx.listener(Self::on_mouse_down))
+            .on_mouse_up(MouseButton::Left, cx.listener(Self::on_mouse_up))
+            .on_mouse_up_out(MouseButton::Left, cx.listener(Self::on_mouse_up))
+            .on_mouse_move(cx.listener(Self::on_mouse_move))
            .bg(rgb(0xeeeeee))
            .size_full()
            .line_height(px(30.))
@@ -446,6 +483,39 @@ impl Render for TextInput {
    }
 }

+impl FocusableView for TextInput {
+    fn focus_handle(&self, _: &AppContext) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+struct InputExample {
+    text_input: View<TextInput>,
+    recent_keystrokes: Vec<Keystroke>,
+}
+
+impl Render for InputExample {
+    fn render(&mut self, _: &mut ViewContext<Self>) -> impl IntoElement {
+        div()
+            .bg(rgb(0xaaaaaa))
+            .flex()
+            .flex_col()
+            .size_full()
+            .child(self.text_input.clone())
+            .children(self.recent_keystrokes.iter().rev().map(|ks| {
+                format!(
+                    "{:} {}",
+                    ks,
+                    if let Some(ime_key) = ks.ime_key.as_ref() {
+                        format!("-> {}", ime_key)
+                    } else {
+                        "".to_owned()
+                    }
+                )
+            }))
+    }
+}
+
 fn main() {
    App::new().run(|cx: &mut AppContext| {
        let bounds = Bounds::centered(None, size(px(300.0), px(300.0)), cx);
@@ -468,21 +538,36 @@ fn main() {
                    ..Default::default()
                },
                |cx| {
-                    cx.new_view(|cx| TextInput {
+                    let text_input = cx.new_view(|cx| TextInput {
                        focus_handle: cx.focus_handle(),
                        content: "".into(),
                        selected_range: 0..0,
                        selection_reversed: false,
                        marked_range: None,
                        last_layout: None,
+                        last_bounds: None,
+                        is_selecting: false,
+                    });
+                    cx.new_view(|_| InputExample {
+                        text_input,
+                        recent_keystrokes: vec![],
                    })
                },
            )
            .unwrap();
+        cx.observe_keystrokes(move |ev, cx| {
+            window
+                .update(cx, |view, cx| {
+                    view.recent_keystrokes.push(ev.keystroke.clone());
+                    cx.notify();
+                })
+                .unwrap();
+        })
+        .detach();
        window
            .update(cx, |view, cx| {
-                view.focus_handle.focus(cx);
-                cx.activate(true)
+                cx.focus_view(&view.text_input);
+                cx.activate(true);
            })
            .unwrap();
    });
--- a/crates/gpui/examples/window_positioning.rs
+++ b/crates/gpui/examples/window_positioning.rs
@@ -2,63 +2,209 @@ use gpui::*;

 struct WindowContent {
    text: SharedString,
+    bounds: Bounds<Pixels>,
+    bg: Hsla,
 }

 impl Render for WindowContent {
-    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let window_bounds = cx.bounds();
+
        div()
            .flex()
-            .bg(rgb(0x1e2025))
+            .flex_col()
+            .bg(self.bg)
            .size_full()
-            .justify_center()
            .items_center()
-            .text_xl()
            .text_color(rgb(0xffffff))
            .child(self.text.clone())
+            .child(
+                div()
+                    .flex()
+                    .flex_col()
+                    .text_sm()
+                    .items_center()
+                    .size_full()
+                    .child(format!(
+                        "origin: {}, {} size: {}, {}",
+                        self.bounds.origin.x,
+                        self.bounds.origin.y,
+                        self.bounds.size.width,
+                        self.bounds.size.height
+                    ))
+                    .child(format!(
+                        "cx.bounds() origin: {}, {} size {}, {}",
+                        window_bounds.origin.x,
+                        window_bounds.origin.y,
+                        window_bounds.size.width,
+                        window_bounds.size.height
+                    )),
+            )
+    }
+}
+
+fn build_window_options(display_id: DisplayId, bounds: Bounds<Pixels>) -> WindowOptions {
+    WindowOptions {
+        // Set the bounds of the window in screen coordinates
+        window_bounds: Some(WindowBounds::Windowed(bounds)),
+        // Specify the display_id to ensure the window is created on the correct screen
+        display_id: Some(display_id),
+        titlebar: None,
+        window_background: WindowBackgroundAppearance::Transparent,
+        focus: false,
+        show: true,
+        kind: WindowKind::PopUp,
+        is_movable: false,
+        app_id: None,
+        window_min_size: None,
+        window_decorations: None,
    }
 }

 fn main() {
    App::new().run(|cx: &mut AppContext| {
        // Create several new windows, positioned in the top right corner of each screen
+        let size = Size {
+            width: px(350.),
+            height: px(75.),
+        };
+        let margin_offset = px(150.);

        for screen in cx.displays() {
-            let options = {
-                let margin_right = px(16.);
-                let margin_height = px(-48.);
-
-                let size = Size {
-                    width: px(400.),
-                    height: px(72.),
-                };
-
-                let bounds = gpui::Bounds::<Pixels> {
-                    origin: screen.bounds().upper_right()
-                        - point(size.width + margin_right, margin_height),
-                    size,
-                };
-
-                WindowOptions {
-                    // Set the bounds of the window in screen coordinates
-                    window_bounds: Some(WindowBounds::Windowed(bounds)),
-                    // Specify the display_id to ensure the window is created on the correct screen
-                    display_id: Some(screen.id()),
-
-                    titlebar: None,
-                    window_background: WindowBackgroundAppearance::default(),
-                    focus: false,
-                    show: true,
-                    kind: WindowKind::PopUp,
-                    is_movable: false,
-                    app_id: None,
-                    window_min_size: None,
-                    window_decorations: None,
-                }
+            let bounds = Bounds {
+                origin: point(margin_offset, margin_offset),
+                size,
            };

-            cx.open_window(options, |cx| {
+            cx.open_window(build_window_options(screen.id(), bounds), |cx| {
                cx.new_view(|_| WindowContent {
-                    text: format!("{:?}", screen.id()).into(),
+                    text: format!("Top Left {:?}", screen.id()).into(),
+                    bg: gpui::red(),
+                    bounds,
+                })
+            })
+            .unwrap();
+
+            let bounds = Bounds {
+                origin: screen.bounds().upper_right()
+                    - point(size.width + margin_offset, -margin_offset),
+                size,
+            };
+
+            cx.open_window(build_window_options(screen.id(), bounds), |cx| {
+                cx.new_view(|_| WindowContent {
+                    text: format!("Top Right {:?}", screen.id()).into(),
+                    bg: gpui::red(),
+                    bounds,
+                })
+            })
+            .unwrap();
+
+            let bounds = Bounds {
+                origin: screen.bounds().lower_left()
+                    - point(-margin_offset, size.height + margin_offset),
+                size,
+            };
+
+            cx.open_window(build_window_options(screen.id(), bounds), |cx| {
+                cx.new_view(|_| WindowContent {
+                    text: format!("Bottom Left {:?}", screen.id()).into(),
+                    bg: gpui::blue(),
+                    bounds,
+                })
+            })
+            .unwrap();
+
+            let bounds = Bounds {
+                origin: screen.bounds().lower_right()
+                    - point(size.width + margin_offset, size.height + margin_offset),
+                size,
+            };
+
+            cx.open_window(build_window_options(screen.id(), bounds), |cx| {
+                cx.new_view(|_| WindowContent {
+                    text: format!("Bottom Right {:?}", screen.id()).into(),
+                    bg: gpui::blue(),
+                    bounds,
+                })
+            })
+            .unwrap();
+
+            let bounds = Bounds {
+                origin: point(screen.bounds().center().x - size.center().x, margin_offset),
+                size,
+            };
+
+            cx.open_window(build_window_options(screen.id(), bounds), |cx| {
+                cx.new_view(|_| WindowContent {
+                    text: format!("Top Center {:?}", screen.id()).into(),
+                    bg: gpui::black(),
+                    bounds,
+                })
+            })
+            .unwrap();
+
+            let bounds = Bounds {
+                origin: point(margin_offset, screen.bounds().center().y - size.center().y),
+                size,
+            };
+
+            cx.open_window(build_window_options(screen.id(), bounds), |cx| {
+                cx.new_view(|_| WindowContent {
+                    text: format!("Left Center {:?}", screen.id()).into(),
+                    bg: gpui::black(),
+                    bounds,
+                })
+            })
+            .unwrap();
+
+            let bounds = Bounds {
+                origin: point(
+                    screen.bounds().center().x - size.center().x,
+                    screen.bounds().center().y - size.center().y,
+                ),
+                size,
+            };
+
+            cx.open_window(build_window_options(screen.id(), bounds), |cx| {
+                cx.new_view(|_| WindowContent {
+                    text: format!("Center {:?}", screen.id()).into(),
+                    bg: gpui::black(),
+                    bounds,
+                })
+            })
+            .unwrap();
+
+            let bounds = Bounds {
+                origin: point(
+                    screen.bounds().size.width - size.width - margin_offset,
+                    screen.bounds().center().y - size.center().y,
+                ),
+                size,
+            };
+
+            cx.open_window(build_window_options(screen.id(), bounds), |cx| {
+                cx.new_view(|_| WindowContent {
+                    text: format!("Right Center {:?}", screen.id()).into(),
+                    bg: gpui::black(),
+                    bounds,
+                })
+            })
+            .unwrap();
+
+            let bounds = Bounds {
+                origin: point(
+                    screen.bounds().center().x - size.center().x,
+                    screen.bounds().size.height - size.height - margin_offset,
+                ),
+                size,
+            };
+
+            cx.open_window(build_window_options(screen.id(), bounds), |cx| {
+                cx.new_view(|_| WindowContent {
+                    text: format!("Bottom Center {:?}", screen.id()).into(),
+                    bg: gpui::black(),
+                    bounds,
                })
            })
            .unwrap();
--- a/crates/gpui/src/platform.rs
+++ b/crates/gpui/src/platform.rs
@@ -318,6 +318,7 @@ pub(crate) trait PlatformWindow: HasWindowHandle + HasDisplayHandle {
    ) -> Option<oneshot::Receiver<usize>>;
    fn activate(&self);
    fn is_active(&self) -> bool;
+    fn is_hovered(&self) -> bool;
    fn set_title(&mut self, title: &str);
    fn set_background_appearance(&self, background_appearance: WindowBackgroundAppearance);
    fn minimize(&self);
@@ -327,6 +328,7 @@ pub(crate) trait PlatformWindow: HasWindowHandle + HasDisplayHandle {
    fn on_request_frame(&self, callback: Box<dyn FnMut()>);
    fn on_input(&self, callback: Box<dyn FnMut(PlatformInput) -> DispatchEventResult>);
    fn on_active_status_change(&self, callback: Box<dyn FnMut(bool)>);
+    fn on_hover_status_change(&self, callback: Box<dyn FnMut(bool)>);
    fn on_resize(&self, callback: Box<dyn FnMut(Size<Pixels>, f32)>);
    fn on_moved(&self, callback: Box<dyn FnMut()>);
    fn on_should_close(&self, callback: Box<dyn FnMut() -> bool>);
--- a/crates/gpui/src/platform/linux/wayland/client.rs
+++ b/crates/gpui/src/platform/linux/wayland/client.rs
@@ -1403,6 +1403,7 @@ impl Dispatch<wl_pointer::WlPointer, ()> for WaylandClientStatePtr {

                if let Some(window) = get_window(&mut state, &surface.id()) {
                    state.mouse_focused_window = Some(window.clone());
+
                    if state.enter_token.is_some() {
                        state.enter_token = None;
                    }
@@ -1416,7 +1417,7 @@ impl Dispatch<wl_pointer::WlPointer, ()> for WaylandClientStatePtr {
                        }
                    }
                    drop(state);
-                    window.set_focused(true);
+                    window.set_hovered(true);
                }
            }
            wl_pointer::Event::Leave { .. } => {
@@ -1432,7 +1433,7 @@ impl Dispatch<wl_pointer::WlPointer, ()> for WaylandClientStatePtr {

                    drop(state);
                    focused_window.handle_input(input);
-                    focused_window.set_focused(false);
+                    focused_window.set_hovered(false);
                }
            }
            wl_pointer::Event::Motion {
--- a/crates/gpui/src/platform/linux/wayland/window.rs
+++ b/crates/gpui/src/platform/linux/wayland/window.rs
@@ -36,6 +36,7 @@ pub(crate) struct Callbacks {
    request_frame: Option<Box<dyn FnMut()>>,
    input: Option<Box<dyn FnMut(crate::PlatformInput) -> crate::DispatchEventResult>>,
    active_status_change: Option<Box<dyn FnMut(bool)>>,
+    hover_status_change: Option<Box<dyn FnMut(bool)>>,
    resize: Option<Box<dyn FnMut(Size<Pixels>, f32)>>,
    moved: Option<Box<dyn FnMut()>>,
    should_close: Option<Box<dyn FnMut() -> bool>>,
@@ -97,6 +98,7 @@ pub struct WaylandWindowState {
    client: WaylandClientStatePtr,
    handle: AnyWindowHandle,
    active: bool,
+    hovered: bool,
    in_progress_configure: Option<InProgressConfigure>,
    in_progress_window_controls: Option<WindowControls>,
    window_controls: WindowControls,
@@ -181,6 +183,7 @@ impl WaylandWindowState {
            appearance,
            handle,
            active: false,
+            hovered: false,
            in_progress_window_controls: None,
            // Assume that we can do anything, unless told otherwise
            window_controls: WindowControls {
@@ -700,6 +703,12 @@ impl WaylandWindowStatePtr {
        }
    }

+    pub fn set_hovered(&self, focus: bool) {
+        if let Some(ref mut fun) = self.callbacks.borrow_mut().hover_status_change {
+            fun(focus);
+        }
+    }
+
    pub fn set_appearance(&mut self, appearance: WindowAppearance) {
        self.state.borrow_mut().appearance = appearance;

@@ -845,6 +854,10 @@ impl PlatformWindow for WaylandWindow {
        self.borrow().active
    }

+    fn is_hovered(&self) -> bool {
+        self.borrow().hovered
+    }
+
    fn set_title(&mut self, title: &str) {
        self.borrow().toplevel.set_title(title.to_string());
    }
@@ -899,6 +912,10 @@ impl PlatformWindow for WaylandWindow {
        self.0.callbacks.borrow_mut().active_status_change = Some(callback);
    }

+    fn on_hover_status_change(&self, callback: Box<dyn FnMut(bool)>) {
+        self.0.callbacks.borrow_mut().hover_status_change = Some(callback);
+    }
+
    fn on_resize(&self, callback: Box<dyn FnMut(Size<Pixels>, f32)>) {
        self.0.callbacks.borrow_mut().resize = Some(callback);
    }
--- a/crates/gpui/src/platform/linux/x11/client.rs
+++ b/crates/gpui/src/platform/linux/x11/client.rs
@@ -110,7 +110,8 @@ pub struct X11ClientState {
    pub(crate) _resource_database: Database,
    pub(crate) atoms: XcbAtoms,
    pub(crate) windows: HashMap<xproto::Window, WindowRef>,
-    pub(crate) focused_window: Option<xproto::Window>,
+    pub(crate) mouse_focused_window: Option<xproto::Window>,
+    pub(crate) keyboard_focused_window: Option<xproto::Window>,
    pub(crate) xkb: xkbc::State,
    pub(crate) ximc: Option<X11rbClient<Rc<XCBConnection>>>,
    pub(crate) xim_handler: Option<XimHandler>,
@@ -144,7 +145,12 @@ impl X11ClientStatePtr {
        if let Some(window_ref) = state.windows.remove(&x_window) {
            state.loop_handle.remove(window_ref.refresh_event_token);
        }
-
+        if state.mouse_focused_window == Some(x_window) {
+            state.mouse_focused_window = None;
+        }
+        if state.keyboard_focused_window == Some(x_window) {
+            state.keyboard_focused_window = None;
+        }
        state.cursor_styles.remove(&x_window);

        if state.windows.is_empty() {
@@ -341,7 +347,8 @@ impl X11Client {
            _resource_database: resource_database,
            atoms,
            windows: HashMap::default(),
-            focused_window: None,
+            mouse_focused_window: None,
+            keyboard_focused_window: None,
            xkb: xkb_state,
            ximc,
            xim_handler,
@@ -502,7 +509,7 @@ impl X11Client {
            .push(AttributeName::ClientWindow, xim_handler.window)
            .push(AttributeName::FocusWindow, xim_handler.window);

-        let window_id = state.focused_window;
+        let window_id = state.keyboard_focused_window;
        drop(state);
        if let Some(window_id) = window_id {
            let window = self.get_window(window_id).unwrap();
@@ -586,17 +593,17 @@ impl X11Client {
            }
            Event::FocusIn(event) => {
                let window = self.get_window(event.event)?;
-                window.set_focused(true);
+                window.set_active(true);
                let mut state = self.0.borrow_mut();
-                state.focused_window = Some(event.event);
+                state.keyboard_focused_window = Some(event.event);
                drop(state);
                self.enable_ime();
            }
            Event::FocusOut(event) => {
                let window = self.get_window(event.event)?;
-                window.set_focused(false);
+                window.set_active(false);
                let mut state = self.0.borrow_mut();
-                state.focused_window = None;
+                state.keyboard_focused_window = None;
                if let Some(compose_state) = state.compose_state.as_mut() {
                    compose_state.reset();
                }
@@ -620,7 +627,7 @@ impl X11Client {
                if state.modifiers == modifiers {
                    drop(state);
                } else {
-                    let focused_window_id = state.focused_window?;
+                    let focused_window_id = state.keyboard_focused_window?;
                    state.modifiers = modifiers;
                    drop(state);

@@ -871,12 +878,18 @@ impl X11Client {
                    valuator_idx += 1;
                }
            }
+            Event::XinputEnter(event) if event.mode == xinput::NotifyMode::NORMAL => {
+                let window = self.get_window(event.event)?;
+                window.set_hovered(true);
+                let mut state = self.0.borrow_mut();
+                state.mouse_focused_window = Some(event.event);
+            }
            Event::XinputLeave(event) if event.mode == xinput::NotifyMode::NORMAL => {
                self.0.borrow_mut().scroll_x = None; // Set last scroll to `None` so that a large delta isn't created if scrolling is done outside the window (the valuator is global)
                self.0.borrow_mut().scroll_y = None;

-                let window = self.get_window(event.event)?;
                let mut state = self.0.borrow_mut();
+                state.mouse_focused_window = None;
                let pressed_button = pressed_button_from_mask(event.buttons[0]);
                let position = point(
                    px(event.event_x as f32 / u16::MAX as f32 / state.scale_factor),
@@ -886,11 +899,13 @@ impl X11Client {
                state.modifiers = modifiers;
                drop(state);

+                let window = self.get_window(event.event)?;
                window.handle_input(PlatformInput::MouseExited(crate::MouseExitEvent {
                    pressed_button,
                    position,
                    modifiers,
                }));
+                window.set_hovered(false);
            }
            _ => {}
        };
@@ -1140,7 +1155,7 @@ impl LinuxClient for X11Client {

    fn set_cursor_style(&self, style: CursorStyle) {
        let mut state = self.0.borrow_mut();
-        let Some(focused_window) = state.focused_window else {
+        let Some(focused_window) = state.mouse_focused_window else {
            return;
        };
        let current_style = state
@@ -1272,7 +1287,7 @@ impl LinuxClient for X11Client {

    fn active_window(&self) -> Option<AnyWindowHandle> {
        let state = self.0.borrow();
-        state.focused_window.and_then(|focused_window| {
+        state.keyboard_focused_window.and_then(|focused_window| {
            state
                .windows
                .get(&focused_window)
--- a/crates/gpui/src/platform/linux/x11/window.rs
+++ b/crates/gpui/src/platform/linux/x11/window.rs
@@ -211,6 +211,7 @@ pub struct Callbacks {
    request_frame: Option<Box<dyn FnMut()>>,
    input: Option<Box<dyn FnMut(PlatformInput) -> crate::DispatchEventResult>>,
    active_status_change: Option<Box<dyn FnMut(bool)>>,
+    hovered_status_change: Option<Box<dyn FnMut(bool)>>,
    resize: Option<Box<dyn FnMut(Size<Pixels>, f32)>>,
    moved: Option<Box<dyn FnMut()>>,
    should_close: Option<Box<dyn FnMut() -> bool>>,
@@ -238,6 +239,7 @@ pub struct X11WindowState {
    maximized_horizontal: bool,
    hidden: bool,
    active: bool,
+    hovered: bool,
    fullscreen: bool,
    client_side_decorations_supported: bool,
    decorations: WindowDecorations,
@@ -451,6 +453,7 @@ impl X11WindowState {
                        xinput::XIEventMask::MOTION
                            | xinput::XIEventMask::BUTTON_PRESS
                            | xinput::XIEventMask::BUTTON_RELEASE
+                            | xinput::XIEventMask::ENTER
                            | xinput::XIEventMask::LEAVE,
                    ],
                }],
@@ -507,6 +510,7 @@ impl X11WindowState {
            atoms: *atoms,
            input_handler: None,
            active: false,
+            hovered: false,
            fullscreen: false,
            maximized_vertical: false,
            maximized_horizontal: false,
@@ -777,6 +781,15 @@ impl X11WindowStatePtr {
                state.hidden = true;
            }
        }
+
+        let hovered_window = self
+            .xcb_connection
+            .query_pointer(state.x_root_window)
+            .unwrap()
+            .reply()
+            .unwrap()
+            .child;
+        self.set_hovered(hovered_window == self.x_window);
    }

    pub fn close(&self) {
@@ -912,12 +925,18 @@ impl X11WindowStatePtr {
        }
    }

-    pub fn set_focused(&self, focus: bool) {
+    pub fn set_active(&self, focus: bool) {
        if let Some(ref mut fun) = self.callbacks.borrow_mut().active_status_change {
            fun(focus);
        }
    }

+    pub fn set_hovered(&self, focus: bool) {
+        if let Some(ref mut fun) = self.callbacks.borrow_mut().hovered_status_change {
+            fun(focus);
+        }
+    }
+
    pub fn set_appearance(&mut self, appearance: WindowAppearance) {
        let mut state = self.state.borrow_mut();
        state.appearance = appearance;
@@ -1046,6 +1065,10 @@ impl PlatformWindow for X11Window {
        self.0.state.borrow().active
    }

+    fn is_hovered(&self) -> bool {
+        self.0.state.borrow().hovered
+    }
+
    fn set_title(&mut self, title: &str) {
        self.0
            .xcb_connection
@@ -1162,6 +1185,10 @@ impl PlatformWindow for X11Window {
        self.0.callbacks.borrow_mut().active_status_change = Some(callback);
    }

+    fn on_hover_status_change(&self, callback: Box<dyn FnMut(bool)>) {
+        self.0.callbacks.borrow_mut().hovered_status_change = Some(callback);
+    }
+
    fn on_resize(&self, callback: Box<dyn FnMut(Size<Pixels>, f32)>) {
        self.0.callbacks.borrow_mut().resize = Some(callback);
    }
--- a/crates/gpui/src/platform/mac/window.rs
+++ b/crates/gpui/src/platform/mac/window.rs
@@ -452,7 +452,7 @@ impl MacWindowState {
        let bounds = Bounds::new(
            point(
                px((window_frame.origin.x - screen_frame.origin.x) as f32),
-                px((window_frame.origin.y - screen_frame.origin.y) as f32),
+                px((window_frame.origin.y + screen_frame.origin.y) as f32),
            ),
            size(
                px(window_frame.size.width as f32),
@@ -546,7 +546,7 @@ impl MacWindow {
            let count: u64 = cocoa::foundation::NSArray::count(screens);
            for i in 0..count {
                let screen = cocoa::foundation::NSArray::objectAtIndex(screens, i);
-                let frame = NSScreen::visibleFrame(screen);
+                let frame = NSScreen::frame(screen);
                let display_id = display_id_for_screen(screen);
                if display_id == display.0 {
                    screen_frame = Some(frame);
@@ -557,7 +557,7 @@ impl MacWindow {
            let screen_frame = screen_frame.unwrap_or_else(|| {
                let screen = NSScreen::mainScreen(nil);
                target_screen = screen;
-                NSScreen::visibleFrame(screen)
+                NSScreen::frame(screen)
            });

            let window_rect = NSRect::new(
@@ -940,6 +940,11 @@ impl PlatformWindow for MacWindow {
        unsafe { self.0.lock().native_window.isKeyWindow() == YES }
    }

+    // is_hovered is unused on macOS. See WindowContext::is_window_hovered.
+    fn is_hovered(&self) -> bool {
+        false
+    }
+
    fn set_title(&mut self, title: &str) {
        unsafe {
            let app = NSApplication::sharedApplication(nil);
@@ -1061,6 +1066,8 @@ impl PlatformWindow for MacWindow {
        self.0.as_ref().lock().activate_callback = Some(callback);
    }

+    fn on_hover_status_change(&self, _: Box<dyn FnMut(bool)>) {}
+
    fn on_resize(&self, callback: Box<dyn FnMut(Size<Pixels>, f32)>) {
        self.0.as_ref().lock().resize_callback = Some(callback);
    }
--- a/crates/gpui/src/platform/test/window.rs
+++ b/crates/gpui/src/platform/test/window.rs
@@ -23,6 +23,7 @@ pub(crate) struct TestWindowState {
    pub(crate) should_close_handler: Option<Box<dyn FnMut() -> bool>>,
    input_callback: Option<Box<dyn FnMut(PlatformInput) -> DispatchEventResult>>,
    active_status_change_callback: Option<Box<dyn FnMut(bool)>>,
+    hover_status_change_callback: Option<Box<dyn FnMut(bool)>>,
    resize_callback: Option<Box<dyn FnMut(Size<Pixels>, f32)>>,
    moved_callback: Option<Box<dyn FnMut()>>,
    input_handler: Option<PlatformInputHandler>,
@@ -66,6 +67,7 @@ impl TestWindow {
            should_close_handler: None,
            input_callback: None,
            active_status_change_callback: None,
+            hover_status_change_callback: None,
            resize_callback: None,
            moved_callback: None,
            input_handler: None,
@@ -182,6 +184,10 @@ impl PlatformWindow for TestWindow {
        false
    }

+    fn is_hovered(&self) -> bool {
+        false
+    }
+
    fn set_title(&mut self, title: &str) {
        self.0.lock().title = Some(title.to_owned());
    }
@@ -225,6 +231,10 @@ impl PlatformWindow for TestWindow {
        self.0.lock().active_status_change_callback = Some(callback)
    }

+    fn on_hover_status_change(&self, callback: Box<dyn FnMut(bool)>) {
+        self.0.lock().hover_status_change_callback = Some(callback)
+    }
+
    fn on_resize(&self, callback: Box<dyn FnMut(Size<Pixels>, f32)>) {
        self.0.lock().resize_callback = Some(callback)
    }
--- a/crates/gpui/src/platform/windows/events.rs
+++ b/crates/gpui/src/platform/windows/events.rs
@@ -659,6 +659,13 @@ fn handle_calc_client_size(
    requested_client_rect[0].left += frame_x + padding;
    requested_client_rect[0].bottom -= frame_y + padding;

+    if state_ptr.state.borrow().is_maximized() {
+        requested_client_rect[0].top += frame_y + padding;
+    } else {
+        // Magic number that calculates the width of the border
+        requested_client_rect[0].top += frame_y - 3;
+    }
+
    Some(0)
 }

@@ -821,14 +828,14 @@ fn handle_hit_test_msg(

    let dpi = unsafe { GetDpiForWindow(handle) };
    let frame_y = unsafe { GetSystemMetricsForDpi(SM_CYFRAME, dpi) };
-    let padding = unsafe { GetSystemMetricsForDpi(SM_CXPADDEDBORDER, dpi) };

    let mut cursor_point = POINT {
        x: lparam.signed_loword().into(),
        y: lparam.signed_hiword().into(),
    };
    unsafe { ScreenToClient(handle, &mut cursor_point).ok().log_err() };
-    if cursor_point.y > 0 && cursor_point.y < frame_y + padding {
+    if !state_ptr.state.borrow().is_maximized() && cursor_point.y >= 0 && cursor_point.y <= frame_y
+    {
        return Some(HTTOP as _);
    }

@@ -1044,6 +1051,8 @@ fn handle_system_settings_changed(state_ptr: Rc<WindowsWindowStatePtr>) -> Optio
    let mut lock = state_ptr.state.borrow_mut();
    // mouse wheel
    lock.system_settings.mouse_wheel_settings.update();
+    // mouse double click
+    lock.click_state.system_update();
    Some(0)
 }

@@ -1259,7 +1268,7 @@ fn is_modifier(virtual_key: VIRTUAL_KEY) -> bool {
 }

 #[inline]
-fn current_modifiers() -> Modifiers {
+pub(crate) fn current_modifiers() -> Modifiers {
    Modifiers {
        control: is_virtual_key_pressed(VK_CONTROL),
        alt: is_virtual_key_pressed(VK_MENU),
--- a/crates/gpui/src/platform/windows/platform.rs
+++ b/crates/gpui/src/platform/windows/platform.rs
@@ -27,10 +27,7 @@ use windows::{
        System::{Com::*, LibraryLoader::*, Ole::*, SystemInformation::*, Threading::*, Time::*},
        UI::{Input::KeyboardAndMouse::*, Shell::*, WindowsAndMessaging::*},
    },
-    UI::{
-        Color,
-        ViewManagement::{UIColorType, UISettings},
-    },
+    UI::ViewManagement::UISettings,
 };

 use crate::*;
@@ -678,25 +675,6 @@ fn load_icon() -> Result<HICON> {
    Ok(HICON(handle.0))
 }

-// https://learn.microsoft.com/en-us/windows/apps/desktop/modernize/apply-windows-themes
-#[inline]
-fn system_appearance() -> Result<WindowAppearance> {
-    let ui_settings = UISettings::new()?;
-    let foreground_color = ui_settings.GetColorValue(UIColorType::Foreground)?;
-    // If the foreground is light, then is_color_light will evaluate to true,
-    // meaning Dark mode is enabled.
-    if is_color_light(&foreground_color) {
-        Ok(WindowAppearance::Dark)
-    } else {
-        Ok(WindowAppearance::Light)
-    }
-}
-
-#[inline(always)]
-fn is_color_light(color: &Color) -> bool {
-    ((5 * color.G as u32) + (2 * color.R as u32) + color.B as u32) > (8 * 128)
-}
-
 #[inline]
 fn should_auto_hide_scrollbars() -> Result<bool> {
    let ui_settings = UISettings::new()?;
--- a/crates/gpui/src/platform/windows/util.rs
+++ b/crates/gpui/src/platform/windows/util.rs
@@ -1,7 +1,13 @@
 use std::sync::OnceLock;

 use ::util::ResultExt;
-use windows::Win32::{Foundation::*, UI::WindowsAndMessaging::*};
+use windows::{
+    Win32::{Foundation::*, UI::WindowsAndMessaging::*},
+    UI::{
+        Color,
+        ViewManagement::{UIColorType, UISettings},
+    },
+};

 use crate::*;

@@ -118,3 +124,22 @@ pub(crate) fn logical_point(x: f32, y: f32, scale_factor: f32) -> Point<Pixels>
        y: px(y / scale_factor),
    }
 }
+
+// https://learn.microsoft.com/en-us/windows/apps/desktop/modernize/apply-windows-themes
+#[inline]
+pub(crate) fn system_appearance() -> Result<WindowAppearance> {
+    let ui_settings = UISettings::new()?;
+    let foreground_color = ui_settings.GetColorValue(UIColorType::Foreground)?;
+    // If the foreground is light, then is_color_light will evaluate to true,
+    // meaning Dark mode is enabled.
+    if is_color_light(&foreground_color) {
+        Ok(WindowAppearance::Dark)
+    } else {
+        Ok(WindowAppearance::Light)
+    }
+}
+
+#[inline(always)]
+fn is_color_light(color: &Color) -> bool {
+    ((5 * color.G as u32) + (2 * color.R as u32) + color.B as u32) > (8 * 128)
+}
--- a/crates/gpui/src/platform/windows/window.rs
+++ b/crates/gpui/src/platform/windows/window.rs
@@ -252,7 +252,7 @@ impl WindowsWindow {
            .titlebar
            .as_ref()
            .map(|titlebar| titlebar.appears_transparent)
-            .unwrap_or(false);
+            .unwrap_or(true);
        let windowname = HSTRING::from(
            params
                .titlebar
@@ -383,9 +383,8 @@ impl PlatformWindow for WindowsWindow {
        self.0.state.borrow().scale_factor
    }

-    // todo(windows)
    fn appearance(&self) -> WindowAppearance {
-        WindowAppearance::Dark
+        system_appearance().log_err().unwrap_or_default()
    }

    fn display(&self) -> Option<Rc<dyn PlatformDisplay>> {
@@ -405,9 +404,8 @@ impl PlatformWindow for WindowsWindow {
        logical_point(point.x as f32, point.y as f32, scale_factor)
    }

-    // todo(windows)
    fn modifiers(&self) -> Modifiers {
-        Modifiers::none()
+        current_modifiers()
    }

    fn set_input_handler(&mut self, input_handler: PlatformInputHandler) {
@@ -505,6 +503,11 @@ impl PlatformWindow for WindowsWindow {
        self.0.hwnd == unsafe { GetActiveWindow() }
    }

+    // is_hovered is unused on Windows. See WindowContext::is_window_hovered.
+    fn is_hovered(&self) -> bool {
+        false
+    }
+
    fn set_title(&mut self, title: &str) {
        unsafe { SetWindowTextW(self.0.hwnd, &HSTRING::from(title)) }
            .inspect_err(|e| log::error!("Set title failed: {e}"))
@@ -606,6 +609,8 @@ impl PlatformWindow for WindowsWindow {
        self.0.state.borrow_mut().callbacks.active_status_change = Some(callback);
    }

+    fn on_hover_status_change(&self, _: Box<dyn FnMut(bool)>) {}
+
    fn on_resize(&self, callback: Box<dyn FnMut(Size<Pixels>, f32)>) {
        self.0.state.borrow_mut().callbacks.resize = Some(callback);
    }
@@ -787,15 +792,25 @@ pub(crate) struct ClickState {
    button: MouseButton,
    last_click: Instant,
    last_position: Point<DevicePixels>,
+    double_click_spatial_tolerance_width: i32,
+    double_click_spatial_tolerance_height: i32,
+    double_click_interval: Duration,
    pub(crate) current_count: usize,
 }

 impl ClickState {
    pub fn new() -> Self {
+        let double_click_spatial_tolerance_width = unsafe { GetSystemMetrics(SM_CXDOUBLECLK) };
+        let double_click_spatial_tolerance_height = unsafe { GetSystemMetrics(SM_CYDOUBLECLK) };
+        let double_click_interval = Duration::from_millis(unsafe { GetDoubleClickTime() } as u64);
+
        ClickState {
            button: MouseButton::Left,
            last_click: Instant::now(),
            last_position: Point::default(),
+            double_click_spatial_tolerance_width,
+            double_click_spatial_tolerance_height,
+            double_click_interval,
            current_count: 0,
        }
    }
@@ -814,13 +829,19 @@ impl ClickState {
        self.current_count
    }

+    pub fn system_update(&mut self) {
+        self.double_click_spatial_tolerance_width = unsafe { GetSystemMetrics(SM_CXDOUBLECLK) };
+        self.double_click_spatial_tolerance_height = unsafe { GetSystemMetrics(SM_CYDOUBLECLK) };
+        self.double_click_interval = Duration::from_millis(unsafe { GetDoubleClickTime() } as u64);
+    }
+
    #[inline]
    fn is_double_click(&self, new_position: Point<DevicePixels>) -> bool {
        let diff = self.last_position - new_position;

-        self.last_click.elapsed() < DOUBLE_CLICK_INTERVAL
-            && diff.x.0.abs() <= DOUBLE_CLICK_SPATIAL_TOLERANCE
-            && diff.y.0.abs() <= DOUBLE_CLICK_SPATIAL_TOLERANCE
+        self.last_click.elapsed() < self.double_click_interval
+            && diff.x.0.abs() <= self.double_click_spatial_tolerance_width
+            && diff.y.0.abs() <= self.double_click_spatial_tolerance_height
    }
 }

@@ -928,10 +949,6 @@ fn register_drag_drop(state_ptr: Rc<WindowsWindowStatePtr>) {

 // https://learn.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-dragqueryfilew
 const DRAGDROP_GET_FILES_COUNT: u32 = 0xFFFFFFFF;
-// https://learn.microsoft.com/en-us/windows/win32/controls/ttm-setdelaytime?redirectedfrom=MSDN
-const DOUBLE_CLICK_INTERVAL: Duration = Duration::from_millis(500);
-// https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getsystemmetrics
-const DOUBLE_CLICK_SPATIAL_TOLERANCE: i32 = 4;

 mod windows_renderer {
    use std::{num::NonZeroIsize, sync::Arc};
--- a/crates/gpui/src/styled.rs
+++ b/crates/gpui/src/styled.rs
@@ -1,11 +1,14 @@
+use crate::TextStyleRefinement;
 use crate::{
-    self as gpui, hsla, point, px, relative, rems, AbsoluteLength, AlignItems, CursorStyle,
-    DefiniteLength, Fill, FlexDirection, FlexWrap, Font, FontStyle, FontWeight, Hsla,
-    JustifyContent, Length, Position, SharedString, StyleRefinement, Visibility, WhiteSpace,
+    self as gpui, px, relative, rems, AbsoluteLength, AlignItems, CursorStyle, DefiniteLength,
+    Fill, FlexDirection, FlexWrap, Font, FontStyle, FontWeight, Hsla, JustifyContent, Length,
+    SharedString, StyleRefinement, WhiteSpace,
 };
-use crate::{BoxShadow, TextStyleRefinement};
-use smallvec::{smallvec, SmallVec};
-use taffy::style::{AlignContent, Display, Overflow};
+pub use gpui_macros::{
+    box_shadow_style_methods, cursor_style_methods, margin_style_methods, overflow_style_methods,
+    padding_style_methods, position_style_methods, visibility_style_methods,
+};
+use taffy::style::{AlignContent, Display};

 /// A trait for elements that can be styled.
 /// Use this to opt-in to a CSS-like styling API.
@@ -14,20 +17,13 @@ pub trait Styled: Sized {
    fn style(&mut self) -> &mut StyleRefinement;

    gpui_macros::style_helpers!();
-
-    /// Sets the position of the element to `relative`.
-    /// [Docs](https://tailwindcss.com/docs/position)
-    fn relative(mut self) -> Self {
-        self.style().position = Some(Position::Relative);
-        self
-    }
-
-    /// Sets the position of the element to `absolute`.
-    /// [Docs](https://tailwindcss.com/docs/position)
-    fn absolute(mut self) -> Self {
-        self.style().position = Some(Position::Absolute);
-        self
-    }
+    gpui_macros::visibility_style_methods!();
+    gpui_macros::margin_style_methods!();
+    gpui_macros::padding_style_methods!();
+    gpui_macros::position_style_methods!();
+    gpui_macros::overflow_style_methods!();
+    gpui_macros::cursor_style_methods!();
+    gpui_macros::box_shadow_style_methods!();

    /// Sets the display type of the element to `block`.
    /// [Docs](https://tailwindcss.com/docs/display)
@@ -43,195 +39,6 @@ pub trait Styled: Sized {
        self
    }

-    /// Sets the visibility of the element to `visible`.
-    /// [Docs](https://tailwindcss.com/docs/visibility)
-    fn visible(mut self) -> Self {
-        self.style().visibility = Some(Visibility::Visible);
-        self
-    }
-
-    /// Sets the visibility of the element to `hidden`.
-    /// [Docs](https://tailwindcss.com/docs/visibility)
-    fn invisible(mut self) -> Self {
-        self.style().visibility = Some(Visibility::Hidden);
-        self
-    }
-
-    /// Sets the behavior of content that overflows the container to be hidden.
-    /// [Docs](https://tailwindcss.com/docs/overflow#hiding-content-that-overflows)
-    fn overflow_hidden(mut self) -> Self {
-        self.style().overflow.x = Some(Overflow::Hidden);
-        self.style().overflow.y = Some(Overflow::Hidden);
-        self
-    }
-
-    /// Sets the behavior of content that overflows the container on the X axis to be hidden.
-    /// [Docs](https://tailwindcss.com/docs/overflow#hiding-content-that-overflows)
-    fn overflow_x_hidden(mut self) -> Self {
-        self.style().overflow.x = Some(Overflow::Hidden);
-        self
-    }
-
-    /// Sets the behavior of content that overflows the container on the Y axis to be hidden.
-    /// [Docs](https://tailwindcss.com/docs/overflow#hiding-content-that-overflows)
-    fn overflow_y_hidden(mut self) -> Self {
-        self.style().overflow.y = Some(Overflow::Hidden);
-        self
-    }
-
-    /// Set the cursor style when hovering over this element
-    fn cursor(mut self, cursor: CursorStyle) -> Self {
-        self.style().mouse_cursor = Some(cursor);
-        self
-    }
-
-    /// Sets the cursor style when hovering an element to `default`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_default(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::Arrow);
-        self
-    }
-
-    /// Sets the cursor style when hovering an element to `pointer`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_pointer(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::PointingHand);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `text`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_text(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::IBeam);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `move`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_move(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ClosedHand);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `not-allowed`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_not_allowed(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::OperationNotAllowed);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `context-menu`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_context_menu(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ContextualMenu);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `crosshair`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_crosshair(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::Crosshair);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `vertical-text`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_vertical_text(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::IBeamCursorForVerticalLayout);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `alias`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_alias(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::DragLink);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `copy`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_copy(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::DragCopy);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `no-drop`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_no_drop(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::OperationNotAllowed);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `grab`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_grab(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::OpenHand);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `grabbing`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_grabbing(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ClosedHand);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `ew-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_ew_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeLeftRight);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `ns-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_ns_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeUpDown);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `col-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_col_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeColumn);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `row-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_row_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeRow);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `n-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_n_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeUp);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `e-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_e_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeRight);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `s-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_s_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeDown);
-        self
-    }
-
-    /// Sets cursor style when hovering over an element to `w-resize`.
-    /// [Docs](https://tailwindcss.com/docs/cursor)
-    fn cursor_w_resize(mut self) -> Self {
-        self.style().mouse_cursor = Some(CursorStyle::ResizeLeft);
-        self
-    }
-
    /// Sets the whitespace of the element to `normal`.
    /// [Docs](https://tailwindcss.com/docs/whitespace#normal)
    fn whitespace_normal(mut self) -> Self {
@@ -499,104 +306,6 @@ pub trait Styled: Sized {
        self
    }

-    /// Sets the box shadow of the element.
-    /// [Docs](https://tailwindcss.com/docs/box-shadow)
-    fn shadow(mut self, shadows: SmallVec<[BoxShadow; 2]>) -> Self {
-        self.style().box_shadow = Some(shadows);
-        self
-    }
-
-    /// Clears the box shadow of the element.
-    /// [Docs](https://tailwindcss.com/docs/box-shadow)
-    fn shadow_none(mut self) -> Self {
-        self.style().box_shadow = Some(Default::default());
-        self
-    }
-
-    /// Sets the box shadow of the element.
-    /// [Docs](https://tailwindcss.com/docs/box-shadow)
-    fn shadow_sm(mut self) -> Self {
-        self.style().box_shadow = Some(smallvec::smallvec![BoxShadow {
-            color: hsla(0., 0., 0., 0.05),
-            offset: point(px(0.), px(1.)),
-            blur_radius: px(2.),
-            spread_radius: px(0.),
-        }]);
-        self
-    }
-
-    /// Sets the box shadow of the element.
-    /// [Docs](https://tailwindcss.com/docs/box-shadow)
-    fn shadow_md(mut self) -> Self {
-        self.style().box_shadow = Some(smallvec![
-            BoxShadow {
-                color: hsla(0.5, 0., 0., 0.1),
-                offset: point(px(0.), px(4.)),
-                blur_radius: px(6.),
-                spread_radius: px(-1.),
-            },
-            BoxShadow {
-                color: hsla(0., 0., 0., 0.1),
-                offset: point(px(0.), px(2.)),
-                blur_radius: px(4.),
-                spread_radius: px(-2.),
-            }
-        ]);
-        self
-    }
-
-    /// Sets the box shadow of the element.
-    /// [Docs](https://tailwindcss.com/docs/box-shadow)
-    fn shadow_lg(mut self) -> Self {
-        self.style().box_shadow = Some(smallvec![
-            BoxShadow {
-                color: hsla(0., 0., 0., 0.1),
-                offset: point(px(0.), px(10.)),
-                blur_radius: px(15.),
-                spread_radius: px(-3.),
-            },
-            BoxShadow {
-                color: hsla(0., 0., 0., 0.1),
-                offset: point(px(0.), px(4.)),
-                blur_radius: px(6.),
-                spread_radius: px(-4.),
-            }
-        ]);
-        self
-    }
-
-    /// Sets the box shadow of the element.
-    /// [Docs](https://tailwindcss.com/docs/box-shadow)
-    fn shadow_xl(mut self) -> Self {
-        self.style().box_shadow = Some(smallvec![
-            BoxShadow {
-                color: hsla(0., 0., 0., 0.1),
-                offset: point(px(0.), px(20.)),
-                blur_radius: px(25.),
-                spread_radius: px(-5.),
-            },
-            BoxShadow {
-                color: hsla(0., 0., 0., 0.1),
-                offset: point(px(0.), px(8.)),
-                blur_radius: px(10.),
-                spread_radius: px(-6.),
-            }
-        ]);
-        self
-    }
-
-    /// Sets the box shadow of the element.
-    /// [Docs](https://tailwindcss.com/docs/box-shadow)
-    fn shadow_2xl(mut self) -> Self {
-        self.style().box_shadow = Some(smallvec![BoxShadow {
-            color: hsla(0., 0., 0., 0.25),
-            offset: point(px(0.), px(25.)),
-            blur_radius: px(50.),
-            spread_radius: px(-12.),
-        }]);
-        self
-    }
-
    /// Get the text style that has been configured on this element.
    fn text_style(&mut self) -> &mut Option<TextStyleRefinement> {
        let style: &mut StyleRefinement = self.style();
--- a/crates/gpui/src/text_system.rs
+++ b/crates/gpui/src/text_system.rs
@@ -658,26 +658,6 @@ impl Hash for RenderGlyphParams {
    }
 }

-/// The parameters for rendering an emoji glyph.
-#[derive(Clone, Debug, PartialEq)]
-pub struct RenderEmojiParams {
-    pub(crate) font_id: FontId,
-    pub(crate) glyph_id: GlyphId,
-    pub(crate) font_size: Pixels,
-    pub(crate) scale_factor: f32,
-}
-
-impl Eq for RenderEmojiParams {}
-
-impl Hash for RenderEmojiParams {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.font_id.0.hash(state);
-        self.glyph_id.0.hash(state);
-        self.font_size.0.to_bits().hash(state);
-        self.scale_factor.to_bits().hash(state);
-    }
-}
-
 /// The configuration details for identifying a specific font.
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub struct Font {
--- a/crates/gpui/src/text_system/line_wrapper.rs
+++ b/crates/gpui/src/text_system/line_wrapper.rs
@@ -49,9 +49,17 @@ impl LineWrapper {
                    continue;
                }

-                if prev_c == ' ' && c != ' ' && first_non_whitespace_ix.is_some() {
-                    last_candidate_ix = ix;
-                    last_candidate_width = width;
+                if Self::is_word_char(c) {
+                    if prev_c == ' ' && c != ' ' && first_non_whitespace_ix.is_some() {
+                        last_candidate_ix = ix;
+                        last_candidate_width = width;
+                    }
+                } else {
+                    // CJK may not be space separated, e.g.: `Hello world你好世界`
+                    if c != ' ' && first_non_whitespace_ix.is_some() {
+                        last_candidate_ix = ix;
+                        last_candidate_width = width;
+                    }
                }

                if c != ' ' && first_non_whitespace_ix.is_none() {
@@ -90,6 +98,31 @@ impl LineWrapper {
        })
    }

+    pub(crate) fn is_word_char(c: char) -> bool {
+        // ASCII alphanumeric characters, for English, numbers: `Hello123`, etc.
+        c.is_ascii_alphanumeric() ||
+        // Latin script in Unicode for French, German, Spanish, etc.
+        // Latin-1 Supplement
+        // https://en.wikipedia.org/wiki/Latin-1_Supplement
+        matches!(c, '\u{00C0}'..='\u{00FF}') ||
+        // Latin Extended-A
+        // https://en.wikipedia.org/wiki/Latin_Extended-A
+        matches!(c, '\u{0100}'..='\u{017F}') ||
+        // Latin Extended-B
+        // https://en.wikipedia.org/wiki/Latin_Extended-B
+        matches!(c, '\u{0180}'..='\u{024F}') ||
+        // Cyrillic for Russian, Ukrainian, etc.
+        // https://en.wikipedia.org/wiki/Cyrillic_script_in_Unicode
+        matches!(c, '\u{0400}'..='\u{04FF}') ||
+        // Some other known special characters that should be treated as word characters,
+        // e.g. `a-b`, `var_name`, `I'm`, '@mention`, `#hashtag`, `100%`, `3.1415`, `2^3`, `a~b`, etc.
+        matches!(c, '-' | '_' | '.' | '\'' | '$' | '%' | '@' | '#' | '^' | '~') ||
+        // Characters that used in URL, e.g. `https://github.com/zed-industries/zed?a=1&b=2` for better wrapping a long URL.
+        matches!(c,  '/' | ':' | '?' | '&' | '=') ||
+        // `⋯` character is special used in Zed, to keep this at the end of the line.
+        matches!(c, '⋯')
+    }
+
    #[inline(always)]
    fn width_for_char(&mut self, c: char) -> Pixels {
        if (c as u32) < 128 {
@@ -219,6 +252,59 @@ mod tests {
        });
    }

+    #[test]
+    fn test_is_word_char() {
+        #[track_caller]
+        fn assert_word(word: &str) {
+            for c in word.chars() {
+                assert!(LineWrapper::is_word_char(c), "assertion failed for '{}'", c);
+            }
+        }
+
+        #[track_caller]
+        fn assert_not_word(word: &str) {
+            let found = word.chars().any(|c| !LineWrapper::is_word_char(c));
+            assert!(found, "assertion failed for '{}'", word);
+        }
+
+        assert_word("Hello123");
+        assert_word("non-English");
+        assert_word("var_name");
+        assert_word("123456");
+        assert_word("3.1415");
+        assert_word("10^2");
+        assert_word("1~2");
+        assert_word("100%");
+        assert_word("@mention");
+        assert_word("#hashtag");
+        assert_word("$variable");
+        assert_word("more⋯");
+
+        // Space
+        assert_not_word("foo bar");
+
+        // URL case
+        assert_word("https://github.com/zed-industries/zed/");
+        assert_word("github.com");
+        assert_word("a=1&b=2");
+
+        // Latin-1 Supplement
+        assert_word("ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏ");
+        // Latin Extended-A
+        assert_word("ĀāĂăĄąĆćĈĉĊċČčĎď");
+        // Latin Extended-B
+        assert_word("ƀƁƂƃƄƅƆƇƈƉƊƋƌƍƎƏ");
+        // Cyrillic
+        assert_word("АБВГДЕЖЗИЙКЛМНОП");
+
+        // non-word characters
+        assert_not_word("你好");
+        assert_not_word("안녕하세요");
+        assert_not_word("こんにちは");
+        assert_not_word("😀😁😂");
+        assert_not_word("()[]{}<>");
+    }
+
    // For compatibility with the test macro
    #[cfg(target_os = "macos")]
    use crate as gpui;
--- a/crates/gpui/src/window.rs
+++ b/crates/gpui/src/window.rs
@@ -541,6 +541,7 @@ pub struct Window {
    appearance: WindowAppearance,
    appearance_observers: SubscriberSet<(), AnyObserver>,
    active: Rc<Cell<bool>>,
+    hovered: Rc<Cell<bool>>,
    pub(crate) dirty: Rc<Cell<bool>>,
    pub(crate) needs_present: Rc<Cell<bool>>,
    pub(crate) last_input_timestamp: Rc<Cell<Instant>>,
@@ -672,6 +673,7 @@ impl Window {
        let text_system = Arc::new(WindowTextSystem::new(cx.text_system().clone()));
        let dirty = Rc::new(Cell::new(true));
        let active = Rc::new(Cell::new(platform_window.is_active()));
+        let hovered = Rc::new(Cell::new(platform_window.is_hovered()));
        let needs_present = Rc::new(Cell::new(false));
        let next_frame_callbacks: Rc<RefCell<Vec<FrameCallback>>> = Default::default();
        let last_input_timestamp = Rc::new(Cell::new(Instant::now()));
@@ -778,7 +780,17 @@ impl Window {
                    .log_err();
            }
        }));
-
+        platform_window.on_hover_status_change(Box::new({
+            let mut cx = cx.to_async();
+            move |active| {
+                handle
+                    .update(&mut cx, |_, cx| {
+                        cx.window.hovered.set(active);
+                        cx.refresh();
+                    })
+                    .log_err();
+            }
+        }));
        platform_window.on_input({
            let mut cx = cx.to_async();
            Box::new(move |event| {
@@ -829,6 +841,7 @@ impl Window {
            appearance,
            appearance_observers: SubscriberSet::new(),
            active,
+            hovered,
            dirty,
            needs_present,
            last_input_timestamp,
@@ -1222,6 +1235,17 @@ impl<'a> WindowContext<'a> {
        self.window.active.get()
    }

+    /// Returns whether this window is considered to be the window
+    /// that currently owns the mouse cursor.
+    /// On mac, this is equivalent to `is_window_active`.
+    pub fn is_window_hovered(&self) -> bool {
+        if cfg!(target_os = "linux") {
+            self.window.hovered.get()
+        } else {
+            self.is_window_active()
+        }
+    }
+
    /// Toggle zoom on the window.
    pub fn zoom_window(&self) {
        self.window.platform_window.zoom();
@@ -2980,7 +3004,7 @@ impl<'a> WindowContext<'a> {

    fn reset_cursor_style(&self) {
        // Set the cursor only if we're the active window.
-        if self.is_window_active() {
+        if self.is_window_hovered() {
            let style = self
                .window
                .rendered_frame
--- a/crates/gpui_macros/Cargo.toml
+++ b/crates/gpui_macros/Cargo.toml
@@ -16,4 +16,4 @@ doctest = false
 [dependencies]
 proc-macro2 = "1.0.66"
 quote = "1.0.9"
-syn = { version = "1.0.72", features = ["full"] }
+syn = { version = "1.0.72", features = ["full", "extra-traits"] }
--- a/crates/gpui_macros/src/gpui_macros.rs
+++ b/crates/gpui_macros/src/gpui_macros.rs
@@ -1,7 +1,7 @@
 mod derive_into_element;
 mod derive_render;
 mod register_action;
-mod style_helpers;
+mod styles;
 mod test;

 use proc_macro::TokenStream;
@@ -27,11 +27,53 @@ pub fn derive_render(input: TokenStream) -> TokenStream {
    derive_render::derive_render(input)
 }

-/// Used by gpui to generate the style helpers.
+/// Used by GPUI to generate the style helpers.
 #[proc_macro]
 #[doc(hidden)]
 pub fn style_helpers(input: TokenStream) -> TokenStream {
-    style_helpers::style_helpers(input)
+    styles::style_helpers(input)
+}
+
+/// Generates methods for visibility styles.
+#[proc_macro]
+pub fn visibility_style_methods(input: TokenStream) -> TokenStream {
+    styles::visibility_style_methods(input)
+}
+
+/// Generates methods for margin styles.
+#[proc_macro]
+pub fn margin_style_methods(input: TokenStream) -> TokenStream {
+    styles::margin_style_methods(input)
+}
+
+/// Generates methods for padding styles.
+#[proc_macro]
+pub fn padding_style_methods(input: TokenStream) -> TokenStream {
+    styles::padding_style_methods(input)
+}
+
+/// Generates methods for position styles.
+#[proc_macro]
+pub fn position_style_methods(input: TokenStream) -> TokenStream {
+    styles::position_style_methods(input)
+}
+
+/// Generates methods for overflow styles.
+#[proc_macro]
+pub fn overflow_style_methods(input: TokenStream) -> TokenStream {
+    styles::overflow_style_methods(input)
+}
+
+/// Generates methods for cursor styles.
+#[proc_macro]
+pub fn cursor_style_methods(input: TokenStream) -> TokenStream {
+    styles::cursor_style_methods(input)
+}
+
+/// Generates methods for box shadow styles.
+#[proc_macro]
+pub fn box_shadow_style_methods(input: TokenStream) -> TokenStream {
+    styles::box_shadow_style_methods(input)
 }

 /// #[gpui::test] can be used to annotate test functions that run with GPUI support.
--- a/Show More
+++ b/Show More