zed 0.63.4

Fix bump-zed-patch-version script
Fix release channel parsing on stable
2022-11-10 09:28:16 -08:00 · 2022-11-10 09:27:35 -08:00 · 2022-11-10 09:25:43 -08:00 · 2022-11-09 17:08:16 -08:00 · 2022-11-09 13:48:07 -08:00 · 2022-11-08 18:23:01 +01:00
110 changed files with 6001 additions and 4684 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -45,11 +45,8 @@ jobs:
      - name: Run tests
        run: cargo test --workspace --no-fail-fast
    
-      - name: Build collab
-        run: cargo build -p collab
-
-      - name: Build other binaries
-        run: cargo build --workspace --bins --all-features
+      - name: Build collab binaries
+        run: cargo build --bins --all-features 

  bundle:
    name: Bundle app
--- a/.github/workflows/release_actions.yml
+++ b/.github/workflows/release_actions.yml
@@ -13,12 +13,12 @@ jobs:
        webhook-url: ${{ secrets.DISCORD_WEBHOOK_URL }}
        content: |
          📣 Zed ${{ github.event.release.tag_name }} was just released!
-          
-          Restart your Zed or head to https://zed.dev/releases/latest to grab it.
-        
+
+          Restart your Zed or head to https://zed.dev/releases to grab it.
+
          ```md
-          # Changelog
-          
+          ### Changelog
+
          ${{ github.event.release.body }}
          ```
  mixpanel_release:
@@ -31,7 +31,7 @@ jobs:
          architecture: "x64"
          cache: "pip"
      - run: pip install -r script/mixpanel_release/requirements.txt
-      - run: > 
+      - run: >
          python script/mixpanel_release/main.py
          ${{ github.event.release.tag_name }}
          ${{ secrets.MIXPANEL_PROJECT_ID }}
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1028,7 +1028,7 @@ dependencies = [

 [[package]]
 name = "collab"
-version = "0.2.4"
+version = "0.2.0"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -1953,18 +1953,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7bad48618fdb549078c333a7a8528acb57af271d0433bdecd523eb620628364e"

-[[package]]
-name = "flume"
-version = "0.10.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1657b4441c3403d9f7b3409e47575237dac27b1b5726df654a6ecbf92f0f7577"
-dependencies = [
- "futures-core",
- "futures-sink",
- "pin-project",
- "spin 0.9.4",
-]
-
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -3017,12 +3005,10 @@ dependencies = [
 "text",
 "theme",
 "tree-sitter",
- "tree-sitter-embedded-template",
 "tree-sitter-html",
 "tree-sitter-javascript",
 "tree-sitter-json 0.19.0",
 "tree-sitter-python",
- "tree-sitter-ruby",
 "tree-sitter-rust",
 "tree-sitter-typescript",
 "unindent",
@@ -3035,7 +3021,7 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 dependencies = [
- "spin 0.5.2",
+ "spin",
 ]

 [[package]]
@@ -4025,7 +4011,6 @@ dependencies = [
 "env_logger",
 "gpui",
 "menu",
- "parking_lot 0.11.2",
 "serde_json",
 "settings",
 "theme",
@@ -4278,7 +4263,6 @@ name = "project_panel"
 version = "0.1.0"
 dependencies = [
 "context_menu",
- "drag_and_drop",
 "editor",
 "futures 0.3.24",
 "gpui",
@@ -4739,7 +4723,7 @@ dependencies = [
 "cc",
 "libc",
 "once_cell",
- "spin 0.5.2",
+ "spin",
 "untrusted",
 "web-sys",
 "winapi 0.3.9",
@@ -5577,15 +5561,6 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"

-[[package]]
-name = "spin"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f6002a767bff9e83f8eeecf883ecb8011875a21ae8da43bffb817a57e78cc09"
-dependencies = [
- "lock_api",
-]
-
 [[package]]
 name = "spsc-buffer"
 version = "0.1.1"
@@ -5606,7 +5581,8 @@ dependencies = [
 [[package]]
 name = "sqlx"
 version = "0.6.2"
-source = "git+https://github.com/launchbadge/sqlx?rev=4b7053807c705df312bcb9b6281e184bf7534eb3#4b7053807c705df312bcb9b6281e184bf7534eb3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9249290c05928352f71c077cc44a464d880c63f26f7534728cca008e135c0428"
 dependencies = [
 "sqlx-core",
 "sqlx-macros",
@@ -5615,7 +5591,8 @@ dependencies = [
 [[package]]
 name = "sqlx-core"
 version = "0.6.2"
-source = "git+https://github.com/launchbadge/sqlx?rev=4b7053807c705df312bcb9b6281e184bf7534eb3#4b7053807c705df312bcb9b6281e184bf7534eb3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcbc16ddba161afc99e14d1713a453747a2b07fc097d2009f4c300ec99286105"
 dependencies = [
 "ahash",
 "atoi",
@@ -5629,10 +5606,8 @@ dependencies = [
 "dotenvy",
 "either",
 "event-listener",
- "flume",
 "futures-channel",
 "futures-core",
- "futures-executor",
 "futures-intrusive",
 "futures-util",
 "hashlink",
@@ -5642,7 +5617,6 @@ dependencies = [
 "indexmap",
 "itoa",
 "libc",
- "libsqlite3-sys",
 "log",
 "md-5",
 "memchr",
@@ -5672,7 +5646,8 @@ dependencies = [
 [[package]]
 name = "sqlx-macros"
 version = "0.6.2"
-source = "git+https://github.com/launchbadge/sqlx?rev=4b7053807c705df312bcb9b6281e184bf7534eb3#4b7053807c705df312bcb9b6281e184bf7534eb3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b850fa514dc11f2ee85be9d055c512aa866746adfacd1cb42d867d68e6a5b0d9"
 dependencies = [
 "dotenvy",
 "either",
@@ -5680,7 +5655,6 @@ dependencies = [
 "once_cell",
 "proc-macro2",
 "quote",
- "serde_json",
 "sha2 0.10.6",
 "sqlx-core",
 "sqlx-rt",
@@ -5691,7 +5665,8 @@ dependencies = [
 [[package]]
 name = "sqlx-rt"
 version = "0.6.2"
-source = "git+https://github.com/launchbadge/sqlx?rev=4b7053807c705df312bcb9b6281e184bf7534eb3#4b7053807c705df312bcb9b6281e184bf7534eb3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24c5b2d25fa654cc5f841750b8e1cdedbe21189bf9a9382ee90bfa9dd3562396"
 dependencies = [
 "once_cell",
 "tokio",
@@ -6404,8 +6379,8 @@ dependencies = [

 [[package]]
 name = "tree-sitter"
-version = "0.20.9"
-source = "git+https://github.com/tree-sitter/tree-sitter?rev=36b5b6c89e55ad1a502f8b3234bb3e12ec83a5da#36b5b6c89e55ad1a502f8b3234bb3e12ec83a5da"
+version = "0.20.8"
+source = "git+https://github.com/tree-sitter/tree-sitter?rev=366210ae925d7ea0891bc7a0c738f60c77c04d7b#366210ae925d7ea0891bc7a0c738f60c77c04d7b"
 dependencies = [
 "cc",
 "regex",
@@ -6449,16 +6424,6 @@ dependencies = [
 "tree-sitter",
 ]

-[[package]]
-name = "tree-sitter-embedded-template"
-version = "0.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33817ade928c73a32d4f904a602321e09de9fc24b71d106f3b4b3f8ab30dcc38"
-dependencies = [
- "cc",
- "tree-sitter",
-]
-
 [[package]]
 name = "tree-sitter-go"
 version = "0.19.1"
@@ -6526,16 +6491,6 @@ dependencies = [
 "tree-sitter",
 ]

-[[package]]
-name = "tree-sitter-ruby"
-version = "0.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ac30cbb1560363ae76e1ccde543d6d99087421e228cc47afcec004b86bb711a"
-dependencies = [
- "cc",
- "tree-sitter",
-]
-
 [[package]]
 name = "tree-sitter-rust"
 version = "0.20.3"
@@ -7673,7 +7628,7 @@ dependencies = [

 [[package]]
 name = "zed"
-version = "0.66.0"
+version = "0.63.4"
 dependencies = [
 "activity_indicator",
 "anyhow",
@@ -7752,13 +7707,11 @@ dependencies = [
 "tree-sitter-cpp",
 "tree-sitter-css",
 "tree-sitter-elixir",
- "tree-sitter-embedded-template",
 "tree-sitter-go",
 "tree-sitter-html",
 "tree-sitter-json 0.20.0",
 "tree-sitter-markdown",
 "tree-sitter-python",
- "tree-sitter-ruby",
 "tree-sitter-rust",
 "tree-sitter-toml",
 "tree-sitter-typescript",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -65,7 +65,7 @@ serde_json = { version = "1.0", features = ["preserve_order", "raw_value"] }
 rand = { version = "0.8" }

 [patch.crates-io]
-tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "36b5b6c89e55ad1a502f8b3234bb3e12ec83a5da" }
+tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "366210ae925d7ea0891bc7a0c738f60c77c04d7b" }
 async-task = { git = "https://github.com/zed-industries/async-task", rev = "341b57d6de98cdfd7b418567b8de2022ca993a6e" }

 # TODO - Remove when a version is released with this PR: https://github.com/servo/core-foundation-rs/pull/457
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 # syntax = docker/dockerfile:1.2

-FROM rust:1.65-bullseye as builder
+FROM rust:1.64-bullseye as builder
 WORKDIR app
 COPY . .

--- a/assets/keymaps/default.json
+++ b/assets/keymaps/default.json
@@ -75,7 +75,7 @@
            "ctrl-n": "editor::MoveDown",
            "ctrl-b": "editor::MoveLeft",
            "ctrl-f": "editor::MoveRight",
-            "ctrl-l": "editor::NextScreen",
+            "ctrl-l": "editor::CenterScreen",
            "alt-left": "editor::MoveToPreviousWordStart",
            "alt-b": "editor::MoveToPreviousWordStart",
            "alt-right": "editor::MoveToNextWordEnd",
@@ -472,15 +472,6 @@
                "terminal::SendText",
                "\u0001"
            ],
-            // Terminal.app compatability
-            "alt-left": [
-                "terminal::SendText",
-                "\u001bb"
-            ],
-            "alt-right": [
-                "terminal::SendText",
-                "\u001bf"
-            ],
            // There are conflicting bindings for these keys in the global context.
            // these bindings override them, remove at your own risk:
            "up": [
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -1,233 +1,230 @@
 {
-    // The name of the Zed theme to use for the UI
-    "theme": "One Dark",
-    // The name of a font to use for rendering text in the editor
-    "buffer_font_family": "Zed Mono",
-    // The default font size for text in the editor
-    "buffer_font_size": 15,
-    // The factor to grow the active pane by. Defaults to 1.0
-    // which gives the same size as all other panes.
-    "active_pane_magnification": 1.0,
-    // Whether to enable vim modes and key bindings
-    "vim_mode": false,
-    // Whether to show the informational hover box when moving the mouse
-    // over symbols in the editor.
-    "hover_popover_enabled": true,
-    // Whether the cursor blinks in the editor.
-    "cursor_blink": true,
-    // Whether to pop the completions menu while typing in an editor without
-    // explicitly requesting it.
-    "show_completions_on_input": true,
-    // Whether new projects should start out 'online'. Online projects
-    // appear in the contacts panel under your name, so that your contacts
-    // can see which projects you are working on. Regardless of this
-    // setting, projects keep their last online status when you reopen them.
-    "projects_online_by_default": true,
-    // Whether to use language servers to provide code intelligence.
-    "enable_language_server": true,
-    // When to automatically save edited buffers. This setting can
-    // take four values.
-    //
-    // 1. Never automatically save:
-    //     "autosave": "off",
-    // 2. Save when changing focus away from the Zed window:
-    //     "autosave": "on_window_change",
-    // 3. Save when changing focus away from a specific buffer:
-    //     "autosave": "on_focus_change",
-    // 4. Save when idle for a certain amount of time:
-    //     "autosave": { "after_delay": {"milliseconds": 500} },
-    "autosave": "off",
-    // Where to place the dock by default. This setting can take three
-    // values:
-    //
-    // 1. Position the dock attached to the bottom of the workspace
-    //     "default_dock_anchor": "bottom"
-    // 2. Position the dock to the right of the workspace like a side panel
-    //     "default_dock_anchor": "right"
-    // 3. Position the dock full screen over the entire workspace"
-    //     "default_dock_anchor": "expanded"
-    "default_dock_anchor": "right",
-    // Whether or not to perform a buffer format before saving
-    "format_on_save": "on",
-    // How to perform a buffer format. This setting can take two values:
-    //
-    // 1. Format code using the current language server:
-    //     "format_on_save": "language_server"
-    // 2. Format code using an external command:
-    //     "format_on_save": {
-    //       "external": {
-    //         "command": "prettier",
-    //         "arguments": ["--stdin-filepath", "{buffer_path}"]
-    //       }
+  // The name of the Zed theme to use for the UI
+  "theme": "One Dark",
+  // The name of a font to use for rendering text in the editor
+  "buffer_font_family": "Zed Mono",
+  // The default font size for text in the editor
+  "buffer_font_size": 15,
+  // Whether to enable vim modes and key bindings
+  "vim_mode": false,
+  // Whether to show the informational hover box when moving the mouse
+  // over symbols in the editor.
+  "hover_popover_enabled": true,
+  // Whether the cursor blinks in the editor.
+  "cursor_blink": true,
+  // Whether to pop the completions menu while typing in an editor without
+  // explicitly requesting it.
+  "show_completions_on_input": true,
+  // Whether new projects should start out 'online'. Online projects
+  // appear in the contacts panel under your name, so that your contacts
+  // can see which projects you are working on. Regardless of this
+  // setting, projects keep their last online status when you reopen them.
+  "projects_online_by_default": true,
+  // Whether to use language servers to provide code intelligence.
+  "enable_language_server": true,
+  // When to automatically save edited buffers. This setting can
+  // take four values.
+  //
+  // 1. Never automatically save:
+  //     "autosave": "off",
+  // 2. Save when changing focus away from the Zed window:
+  //     "autosave": "on_window_change",
+  // 3. Save when changing focus away from a specific buffer:
+  //     "autosave": "on_focus_change",
+  // 4. Save when idle for a certain amount of time:
+  //     "autosave": { "after_delay": {"milliseconds": 500} },
+  "autosave": "off",
+  // Where to place the dock by default. This setting can take three
+  // values:
+  //
+  // 1. Position the dock attached to the bottom of the workspace
+  //     "default_dock_anchor": "bottom"
+  // 2. Position the dock to the right of the workspace like a side panel
+  //     "default_dock_anchor": "right"
+  // 3. Position the dock full screen over the entire workspace"
+  //     "default_dock_anchor": "expanded"
+  "default_dock_anchor": "right",
+  // Whether or not to perform a buffer format before saving
+  "format_on_save": "on",
+  // How to perform a buffer format. This setting can take two values:
+  //
+  // 1. Format code using the current language server:
+  //     "format_on_save": "language_server"
+  // 2. Format code using an external command:
+  //     "format_on_save": {
+  //       "external": {
+  //         "command": "prettier",
+  //         "arguments": ["--stdin-filepath", "{buffer_path}"]
+  //       }
+  //     }
+  "formatter": "language_server",
+  // How to soft-wrap long lines of text. This setting can take
+  // three values:
+  //
+  // 1. Do not soft wrap.
+  //      "soft_wrap": "none",
+  // 2. Soft wrap lines that overflow the editor:
+  //      "soft_wrap": "editor_width",
+  // 3. Soft wrap lines at the preferred line length
+  //      "soft_wrap": "preferred_line_length",
+  "soft_wrap": "none",
+  // The column at which to soft-wrap lines, for buffers where soft-wrap
+  // is enabled.
+  "preferred_line_length": 80,
+  // Whether to indent lines using tab characters, as opposed to multiple
+  // spaces.
+  "hard_tabs": false,
+  // How many columns a tab should occupy.
+  "tab_size": 4,
+  // Git gutter behavior configuration.
+  "git": {
+    // Control whether the git gutter is shown. May take 2 values:
+    // 1. Show the gutter
+    //      "git_gutter": "tracked_files"
+    // 2. Hide the gutter
+    //      "git_gutter": "hide"
+    "git_gutter": "tracked_files"
+  },
+  // Settings specific to journaling
+  "journal": {
+    // The path of the directory where journal entries are stored
+    "path": "~",
+    // What format to display the hours in
+    // May take 2 values:
+    // 1. hour12
+    // 2. hour24
+    "hour_format": "hour12"
+  },
+  // Settings specific to the terminal
+  "terminal": {
+    // What shell to use when opening a terminal. May take 3 values:
+    // 1. Use the system's default terminal configuration (e.g. $TERM).
+    //      "shell": "system"
+    // 2. A program:
+    //      "shell": {
+    //        "program": "sh"
+    //      }
+    // 3. A program with arguments:
+    //     "shell": {
+    //         "with_arguments": {
+    //           "program": "/bin/bash",
+    //           "arguments": ["--login"]
+    //         }
    //     }
-    "formatter": "language_server",
-    // How to soft-wrap long lines of text. This setting can take
-    // three values:
+    "shell": "system",
+    // What working directory to use when launching the terminal.
+    // May take 4 values:
+    // 1. Use the current file's project directory.  Will Fallback to the
+    //    first project directory strategy if unsuccessful
+    //      "working_directory": "current_project_directory"
+    // 2. Use the first project in this workspace's directory
+    //      "working_directory": "first_project_directory"
+    // 3. Always use this platform's home directory (if we can find it)
+    //     "working_directory": "always_home"
+    // 4. Always use a specific directory. This value will be shell expanded.
+    //    If this path is not a valid directory the terminal will default to
+    //    this platform's home directory  (if we can find it)
+    //      "working_directory": {
+    //        "always": {
+    //          "directory": "~/zed/projects/"
+    //        }
+    //      }
    //
-    // 1. Do not soft wrap.
-    //      "soft_wrap": "none",
-    // 2. Soft wrap lines that overflow the editor:
-    //      "soft_wrap": "editor_width",
-    // 3. Soft wrap lines at the preferred line length
-    //      "soft_wrap": "preferred_line_length",
-    "soft_wrap": "none",
-    // The column at which to soft-wrap lines, for buffers where soft-wrap
-    // is enabled.
-    "preferred_line_length": 80,
-    // Whether to indent lines using tab characters, as opposed to multiple
-    // spaces.
-    "hard_tabs": false,
-    // How many columns a tab should occupy.
-    "tab_size": 4,
-    // Git gutter behavior configuration.
-    "git": {
-        // Control whether the git gutter is shown. May take 2 values:
-        // 1. Show the gutter
-        //      "git_gutter": "tracked_files"
-        // 2. Hide the gutter
-        //      "git_gutter": "hide"
-        "git_gutter": "tracked_files"
-    },
-    // Settings specific to journaling
-    "journal": {
-        // The path of the directory where journal entries are stored
-        "path": "~",
-        // What format to display the hours in
-        // May take 2 values:
-        // 1. hour12
-        // 2. hour24
-        "hour_format": "hour12"
-    },
-    // Settings specific to the terminal
-    "terminal": {
-        // What shell to use when opening a terminal. May take 3 values:
-        // 1. Use the system's default terminal configuration (e.g. $TERM).
-        //      "shell": "system"
-        // 2. A program:
-        //      "shell": {
-        //        "program": "sh"
-        //      }
-        // 3. A program with arguments:
-        //     "shell": {
-        //         "with_arguments": {
-        //           "program": "/bin/bash",
-        //           "arguments": ["--login"]
-        //         }
-        //     }
-        "shell": "system",
-        // What working directory to use when launching the terminal.
-        // May take 4 values:
-        // 1. Use the current file's project directory.  Will Fallback to the
-        //    first project directory strategy if unsuccessful
-        //      "working_directory": "current_project_directory"
-        // 2. Use the first project in this workspace's directory
-        //      "working_directory": "first_project_directory"
-        // 3. Always use this platform's home directory (if we can find it)
-        //     "working_directory": "always_home"
-        // 4. Always use a specific directory. This value will be shell expanded.
-        //    If this path is not a valid directory the terminal will default to
-        //    this platform's home directory  (if we can find it)
-        //      "working_directory": {
-        //        "always": {
-        //          "directory": "~/zed/projects/"
-        //        }
-        //      }
-        //
-        //
-        "working_directory": "current_project_directory",
-        // Set the cursor blinking behavior in the terminal.
-        // May take 4 values:
-        //  1. Never blink the cursor, ignoring the terminal mode
-        //         "blinking": "off",
-        //  2. Default the cursor blink to off, but allow the terminal to
-        //     set blinking
-        //         "blinking": "terminal_controlled",
-        //  3. Always blink the cursor, ignoring the terminal mode
-        //         "blinking": "on",
-        "blinking": "terminal_controlled",
-        // Set whether Alternate Scroll mode (code: ?1007) is active by default.
-        // Alternate Scroll mode converts mouse scroll events into up / down key
-        // presses when in the alternate screen (e.g. when running applications
-        // like vim or  less). The terminal can still set and unset this mode.
-        // May take 2 values:
-        //  1. Default alternate scroll mode to on
-        //         "alternate_scroll": "on",
-        //  2. Default alternate scroll mode to off
-        //         "alternate_scroll": "off",
-        "alternate_scroll": "off",
-        // Set whether the option key behaves as the meta key.
-        // May take 2 values:
-        //  1. Rely on default platform handling of option key, on macOS
-        //     this means generating certain unicode characters
-        //         "option_to_meta": false,
-        //  2. Make the option keys behave as a 'meta' key, e.g. for emacs
-        //         "option_to_meta": true,
-        "option_as_meta": false,
-        // Whether or not selecting text in the terminal will automatically
-        // copy to the system clipboard.
-        "copy_on_select": false,
-        // Any key-value pairs added to this list will be added to the terminal's
-        // enviroment. Use `:` to seperate multiple values.
-        "env": {
-            // "KEY": "value1:value2"
-        }
-        // Set the terminal's font size. If this option is not included,
-        // the terminal will default to matching the buffer's font size.
-        // "font_size": "15"
-        // Set the terminal's font family. If this option is not included,
-        // the terminal will default to matching the buffer's font family.
-        // "font_family": "Zed Mono"
-    },
-    // Different settings for specific languages.
-    "languages": {
-        "Plain Text": {
-            "soft_wrap": "preferred_line_length"
-        },
-        "C": {
-            "tab_size": 2
-        },
-        "C++": {
-            "tab_size": 2
-        },
-        "Elixir": {
-            "tab_size": 2
-        },
-        "Go": {
-            "tab_size": 4,
-            "hard_tabs": true
-        },
-        "Markdown": {
-            "soft_wrap": "preferred_line_length"
-        },
-        "Rust": {
-            "tab_size": 4
-        },
-        "JavaScript": {
-            "tab_size": 2
-        },
-        "TypeScript": {
-            "tab_size": 2
-        },
-        "TSX": {
-            "tab_size": 2
-        }
-    },
-    // LSP Specific settings.
-    "lsp": {
-        // Specify the LSP name as a key here.
-        // As of 8/10/22, supported LSPs are:
-        // pyright
-        // gopls
-        // rust-analyzer
-        // typescript-language-server
-        // vscode-json-languageserver
-        // "rust_analyzer": {
-        //     //These initialization options are merged into Zed's defaults
-        //     "initialization_options": {
-        //         "checkOnSave": {
-        //             "command": "clippy"
-        //         }
-        //     }
-        // }
+    //
+    "working_directory": "current_project_directory",
+    // Set the cursor blinking behavior in the terminal.
+    // May take 4 values:
+    //  1. Never blink the cursor, ignoring the terminal mode
+    //         "blinking": "off",
+    //  2. Default the cursor blink to off, but allow the terminal to
+    //     set blinking
+    //         "blinking": "terminal_controlled",
+    //  3. Always blink the cursor, ignoring the terminal mode
+    //         "blinking": "on",
+    "blinking": "terminal_controlled",
+    // Set whether Alternate Scroll mode (code: ?1007) is active by default.
+    // Alternate Scroll mode converts mouse scroll events into up / down key
+    // presses when in the alternate screen (e.g. when running applications
+    // like vim or  less). The terminal can still set and unset this mode.
+    // May take 2 values:
+    //  1. Default alternate scroll mode to on
+    //         "alternate_scroll": "on",
+    //  2. Default alternate scroll mode to off
+    //         "alternate_scroll": "off",
+    "alternate_scroll": "off",
+    // Set whether the option key behaves as the meta key.
+    // May take 2 values:
+    //  1. Rely on default platform handling of option key, on macOS
+    //     this means generating certain unicode characters
+    //         "option_to_meta": false,
+    //  2. Make the option keys behave as a 'meta' key, e.g. for emacs
+    //         "option_to_meta": true,
+    "option_as_meta": false,
+    // Whether or not selecting text in the terminal will automatically
+    // copy to the system clipboard.
+    "copy_on_select": false,
+    // Any key-value pairs added to this list will be added to the terminal's
+    // enviroment. Use `:` to seperate multiple values.
+    "env": {
+      // "KEY": "value1:value2"
    }
+    // Set the terminal's font size. If this option is not included,
+    // the terminal will default to matching the buffer's font size.
+    // "font_size": "15"
+    // Set the terminal's font family. If this option is not included,
+    // the terminal will default to matching the buffer's font family.
+    // "font_family": "Zed Mono"
+  },
+  // Different settings for specific languages.
+  "languages": {
+    "Plain Text": {
+      "soft_wrap": "preferred_line_length"
+    },
+    "C": {
+      "tab_size": 2
+    },
+    "C++": {
+      "tab_size": 2
+    },
+    "Elixir": {
+      "tab_size": 2
+    },
+    "Go": {
+      "tab_size": 4,
+      "hard_tabs": true
+    },
+    "Markdown": {
+      "soft_wrap": "preferred_line_length"
+    },
+    "Rust": {
+      "tab_size": 4
+    },
+    "JavaScript": {
+      "tab_size": 2
+    },
+    "TypeScript": {
+      "tab_size": 2
+    },
+    "TSX": {
+      "tab_size": 2
+    }
+  },
+  // LSP Specific settings.
+  "lsp": {
+    // Specify the LSP name as a key here.
+    // As of 8/10/22, supported LSPs are:
+    // pyright
+    // gopls
+    // rust-analyzer
+    // typescript-language-server
+    // vscode-json-languageserver
+    // "rust_analyzer": {
+    //     //These initialization options are merged into Zed's defaults
+    //     "initialization_options": {
+    //         "checkOnSave": {
+    //             "command": "clippy"
+    //         }
+    //     }
+    // }
+  }
 }
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -17,6 +17,7 @@ actions!(lsp_status, [ShowErrorMessage]);

 const DOWNLOAD_ICON: &str = "icons/download_12.svg";
 const WARNING_ICON: &str = "icons/triangle_exclamation_12.svg";
+const DONE_ICON: &str = "icons/circle_check_12.svg";

 pub enum Event {
    ShowError { lsp_name: Arc<str>, error: String },
@@ -236,6 +237,7 @@ impl ActivityIndicator {

        // Show any application auto-update info.
        if let Some(updater) = &self.auto_updater {
+            // let theme = &cx.global::<Settings>().theme.workspace.status_bar;
            match &updater.read(cx).status() {
                AutoUpdateStatus::Checking => (
                    Some(DOWNLOAD_ICON),
@@ -252,7 +254,9 @@ impl ActivityIndicator {
                    "Installing Zed update…".to_string(),
                    None,
                ),
-                AutoUpdateStatus::Updated => (None, "Restart to update Zed".to_string(), None),
+                AutoUpdateStatus::Updated => {
+                    (Some(DONE_ICON), "Restart to update Zed".to_string(), None)
+                }
                AutoUpdateStatus::Errored => (
                    Some(WARNING_ICON),
                    "Auto update failed".to_string(),
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -70,14 +70,7 @@ pub fn init(db: project::Db, http_client: Arc<dyn HttpClient>, cx: &mut MutableA
            }
        });
        cx.add_global_action(move |_: &ViewReleaseNotes, cx| {
-            let latest_release_url = if cx.has_global::<ReleaseChannel>()
-                && *cx.global::<ReleaseChannel>() == ReleaseChannel::Preview
-            {
-                format!("{server_url}/releases/preview/latest")
-            } else {
-                format!("{server_url}/releases/latest")
-            };
-            cx.platform().open_url(&latest_release_url);
+            cx.platform().open_url(&format!("{server_url}/releases"));
        });
        cx.add_action(UpdateNotification::dismiss);
    }
--- a/crates/client/src/channel.rs
+++ b/crates/client/src/channel.rs
@@ -0,0 +1,820 @@
+use super::{
+    proto,
+    user::{User, UserStore},
+    Client, Status, Subscription, TypedEnvelope,
+};
+use anyhow::{anyhow, Context, Result};
+use futures::lock::Mutex;
+use gpui::{
+    AsyncAppContext, Entity, ModelContext, ModelHandle, MutableAppContext, Task, WeakModelHandle,
+};
+use postage::prelude::Stream;
+use rand::prelude::*;
+use std::{
+    collections::{HashMap, HashSet},
+    mem,
+    ops::Range,
+    sync::Arc,
+};
+use sum_tree::{Bias, SumTree};
+use time::OffsetDateTime;
+use util::{post_inc, ResultExt as _, TryFutureExt};
+
+pub struct ChannelList {
+    available_channels: Option<Vec<ChannelDetails>>,
+    channels: HashMap<u64, WeakModelHandle<Channel>>,
+    client: Arc<Client>,
+    user_store: ModelHandle<UserStore>,
+    _task: Task<Option<()>>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ChannelDetails {
+    pub id: u64,
+    pub name: String,
+}
+
+pub struct Channel {
+    details: ChannelDetails,
+    messages: SumTree<ChannelMessage>,
+    loaded_all_messages: bool,
+    next_pending_message_id: usize,
+    user_store: ModelHandle<UserStore>,
+    rpc: Arc<Client>,
+    outgoing_messages_lock: Arc<Mutex<()>>,
+    rng: StdRng,
+    _subscription: Subscription,
+}
+
+#[derive(Clone, Debug)]
+pub struct ChannelMessage {
+    pub id: ChannelMessageId,
+    pub body: String,
+    pub timestamp: OffsetDateTime,
+    pub sender: Arc<User>,
+    pub nonce: u128,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum ChannelMessageId {
+    Saved(u64),
+    Pending(usize),
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct ChannelMessageSummary {
+    max_id: ChannelMessageId,
+    count: usize,
+}
+
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+struct Count(usize);
+
+pub enum ChannelListEvent {}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum ChannelEvent {
+    MessagesUpdated {
+        old_range: Range<usize>,
+        new_count: usize,
+    },
+}
+
+impl Entity for ChannelList {
+    type Event = ChannelListEvent;
+}
+
+impl ChannelList {
+    pub fn new(
+        user_store: ModelHandle<UserStore>,
+        rpc: Arc<Client>,
+        cx: &mut ModelContext<Self>,
+    ) -> Self {
+        let _task = cx.spawn_weak(|this, mut cx| {
+            let rpc = rpc.clone();
+            async move {
+                let mut status = rpc.status();
+                while let Some((status, this)) = status.recv().await.zip(this.upgrade(&cx)) {
+                    match status {
+                        Status::Connected { .. } => {
+                            let response = rpc
+                                .request(proto::GetChannels {})
+                                .await
+                                .context("failed to fetch available channels")?;
+                            this.update(&mut cx, |this, cx| {
+                                this.available_channels =
+                                    Some(response.channels.into_iter().map(Into::into).collect());
+
+                                let mut to_remove = Vec::new();
+                                for (channel_id, channel) in &this.channels {
+                                    if let Some(channel) = channel.upgrade(cx) {
+                                        channel.update(cx, |channel, cx| channel.rejoin(cx))
+                                    } else {
+                                        to_remove.push(*channel_id);
+                                    }
+                                }
+
+                                for channel_id in to_remove {
+                                    this.channels.remove(&channel_id);
+                                }
+                                cx.notify();
+                            });
+                        }
+                        Status::SignedOut { .. } => {
+                            this.update(&mut cx, |this, cx| {
+                                this.available_channels = None;
+                                this.channels.clear();
+                                cx.notify();
+                            });
+                        }
+                        _ => {}
+                    }
+                }
+                Ok(())
+            }
+            .log_err()
+        });
+
+        Self {
+            available_channels: None,
+            channels: Default::default(),
+            user_store,
+            client: rpc,
+            _task,
+        }
+    }
+
+    pub fn available_channels(&self) -> Option<&[ChannelDetails]> {
+        self.available_channels.as_deref()
+    }
+
+    pub fn get_channel(
+        &mut self,
+        id: u64,
+        cx: &mut MutableAppContext,
+    ) -> Option<ModelHandle<Channel>> {
+        if let Some(channel) = self.channels.get(&id).and_then(|c| c.upgrade(cx)) {
+            return Some(channel);
+        }
+
+        let channels = self.available_channels.as_ref()?;
+        let details = channels.iter().find(|details| details.id == id)?.clone();
+        let channel = cx.add_model(|cx| {
+            Channel::new(details, self.user_store.clone(), self.client.clone(), cx)
+        });
+        self.channels.insert(id, channel.downgrade());
+        Some(channel)
+    }
+}
+
+impl Entity for Channel {
+    type Event = ChannelEvent;
+
+    fn release(&mut self, _: &mut MutableAppContext) {
+        self.rpc
+            .send(proto::LeaveChannel {
+                channel_id: self.details.id,
+            })
+            .log_err();
+    }
+}
+
+impl Channel {
+    pub fn init(rpc: &Arc<Client>) {
+        rpc.add_model_message_handler(Self::handle_message_sent);
+    }
+
+    pub fn new(
+        details: ChannelDetails,
+        user_store: ModelHandle<UserStore>,
+        rpc: Arc<Client>,
+        cx: &mut ModelContext<Self>,
+    ) -> Self {
+        let _subscription = rpc.add_model_for_remote_entity(details.id, cx);
+
+        {
+            let user_store = user_store.clone();
+            let rpc = rpc.clone();
+            let channel_id = details.id;
+            cx.spawn(|channel, mut cx| {
+                async move {
+                    let response = rpc.request(proto::JoinChannel { channel_id }).await?;
+                    let messages =
+                        messages_from_proto(response.messages, &user_store, &mut cx).await?;
+                    let loaded_all_messages = response.done;
+
+                    channel.update(&mut cx, |channel, cx| {
+                        channel.insert_messages(messages, cx);
+                        channel.loaded_all_messages = loaded_all_messages;
+                    });
+
+                    Ok(())
+                }
+                .log_err()
+            })
+            .detach();
+        }
+
+        Self {
+            details,
+            user_store,
+            rpc,
+            outgoing_messages_lock: Default::default(),
+            messages: Default::default(),
+            loaded_all_messages: false,
+            next_pending_message_id: 0,
+            rng: StdRng::from_entropy(),
+            _subscription,
+        }
+    }
+
+    pub fn name(&self) -> &str {
+        &self.details.name
+    }
+
+    pub fn send_message(
+        &mut self,
+        body: String,
+        cx: &mut ModelContext<Self>,
+    ) -> Result<Task<Result<()>>> {
+        if body.is_empty() {
+            Err(anyhow!("message body can't be empty"))?;
+        }
+
+        let current_user = self
+            .user_store
+            .read(cx)
+            .current_user()
+            .ok_or_else(|| anyhow!("current_user is not present"))?;
+
+        let channel_id = self.details.id;
+        let pending_id = ChannelMessageId::Pending(post_inc(&mut self.next_pending_message_id));
+        let nonce = self.rng.gen();
+        self.insert_messages(
+            SumTree::from_item(
+                ChannelMessage {
+                    id: pending_id,
+                    body: body.clone(),
+                    sender: current_user,
+                    timestamp: OffsetDateTime::now_utc(),
+                    nonce,
+                },
+                &(),
+            ),
+            cx,
+        );
+        let user_store = self.user_store.clone();
+        let rpc = self.rpc.clone();
+        let outgoing_messages_lock = self.outgoing_messages_lock.clone();
+        Ok(cx.spawn(|this, mut cx| async move {
+            let outgoing_message_guard = outgoing_messages_lock.lock().await;
+            let request = rpc.request(proto::SendChannelMessage {
+                channel_id,
+                body,
+                nonce: Some(nonce.into()),
+            });
+            let response = request.await?;
+            drop(outgoing_message_guard);
+            let message = ChannelMessage::from_proto(
+                response.message.ok_or_else(|| anyhow!("invalid message"))?,
+                &user_store,
+                &mut cx,
+            )
+            .await?;
+            this.update(&mut cx, |this, cx| {
+                this.insert_messages(SumTree::from_item(message, &()), cx);
+                Ok(())
+            })
+        }))
+    }
+
+    pub fn load_more_messages(&mut self, cx: &mut ModelContext<Self>) -> bool {
+        if !self.loaded_all_messages {
+            let rpc = self.rpc.clone();
+            let user_store = self.user_store.clone();
+            let channel_id = self.details.id;
+            if let Some(before_message_id) =
+                self.messages.first().and_then(|message| match message.id {
+                    ChannelMessageId::Saved(id) => Some(id),
+                    ChannelMessageId::Pending(_) => None,
+                })
+            {
+                cx.spawn(|this, mut cx| {
+                    async move {
+                        let response = rpc
+                            .request(proto::GetChannelMessages {
+                                channel_id,
+                                before_message_id,
+                            })
+                            .await?;
+                        let loaded_all_messages = response.done;
+                        let messages =
+                            messages_from_proto(response.messages, &user_store, &mut cx).await?;
+                        this.update(&mut cx, |this, cx| {
+                            this.loaded_all_messages = loaded_all_messages;
+                            this.insert_messages(messages, cx);
+                        });
+                        Ok(())
+                    }
+                    .log_err()
+                })
+                .detach();
+                return true;
+            }
+        }
+        false
+    }
+
+    pub fn rejoin(&mut self, cx: &mut ModelContext<Self>) {
+        let user_store = self.user_store.clone();
+        let rpc = self.rpc.clone();
+        let channel_id = self.details.id;
+        cx.spawn(|this, mut cx| {
+            async move {
+                let response = rpc.request(proto::JoinChannel { channel_id }).await?;
+                let messages = messages_from_proto(response.messages, &user_store, &mut cx).await?;
+                let loaded_all_messages = response.done;
+
+                let pending_messages = this.update(&mut cx, |this, cx| {
+                    if let Some((first_new_message, last_old_message)) =
+                        messages.first().zip(this.messages.last())
+                    {
+                        if first_new_message.id > last_old_message.id {
+                            let old_messages = mem::take(&mut this.messages);
+                            cx.emit(ChannelEvent::MessagesUpdated {
+                                old_range: 0..old_messages.summary().count,
+                                new_count: 0,
+                            });
+                            this.loaded_all_messages = loaded_all_messages;
+                        }
+                    }
+
+                    this.insert_messages(messages, cx);
+                    if loaded_all_messages {
+                        this.loaded_all_messages = loaded_all_messages;
+                    }
+
+                    this.pending_messages().cloned().collect::<Vec<_>>()
+                });
+
+                for pending_message in pending_messages {
+                    let request = rpc.request(proto::SendChannelMessage {
+                        channel_id,
+                        body: pending_message.body,
+                        nonce: Some(pending_message.nonce.into()),
+                    });
+                    let response = request.await?;
+                    let message = ChannelMessage::from_proto(
+                        response.message.ok_or_else(|| anyhow!("invalid message"))?,
+                        &user_store,
+                        &mut cx,
+                    )
+                    .await?;
+                    this.update(&mut cx, |this, cx| {
+                        this.insert_messages(SumTree::from_item(message, &()), cx);
+                    });
+                }
+
+                Ok(())
+            }
+            .log_err()
+        })
+        .detach();
+    }
+
+    pub fn message_count(&self) -> usize {
+        self.messages.summary().count
+    }
+
+    pub fn messages(&self) -> &SumTree<ChannelMessage> {
+        &self.messages
+    }
+
+    pub fn message(&self, ix: usize) -> &ChannelMessage {
+        let mut cursor = self.messages.cursor::<Count>();
+        cursor.seek(&Count(ix), Bias::Right, &());
+        cursor.item().unwrap()
+    }
+
+    pub fn messages_in_range(&self, range: Range<usize>) -> impl Iterator<Item = &ChannelMessage> {
+        let mut cursor = self.messages.cursor::<Count>();
+        cursor.seek(&Count(range.start), Bias::Right, &());
+        cursor.take(range.len())
+    }
+
+    pub fn pending_messages(&self) -> impl Iterator<Item = &ChannelMessage> {
+        let mut cursor = self.messages.cursor::<ChannelMessageId>();
+        cursor.seek(&ChannelMessageId::Pending(0), Bias::Left, &());
+        cursor
+    }
+
+    async fn handle_message_sent(
+        this: ModelHandle<Self>,
+        message: TypedEnvelope<proto::ChannelMessageSent>,
+        _: Arc<Client>,
+        mut cx: AsyncAppContext,
+    ) -> Result<()> {
+        let user_store = this.read_with(&cx, |this, _| this.user_store.clone());
+        let message = message
+            .payload
+            .message
+            .ok_or_else(|| anyhow!("empty message"))?;
+
+        let message = ChannelMessage::from_proto(message, &user_store, &mut cx).await?;
+        this.update(&mut cx, |this, cx| {
+            this.insert_messages(SumTree::from_item(message, &()), cx)
+        });
+
+        Ok(())
+    }
+
+    fn insert_messages(&mut self, messages: SumTree<ChannelMessage>, cx: &mut ModelContext<Self>) {
+        if let Some((first_message, last_message)) = messages.first().zip(messages.last()) {
+            let nonces = messages
+                .cursor::<()>()
+                .map(|m| m.nonce)
+                .collect::<HashSet<_>>();
+
+            let mut old_cursor = self.messages.cursor::<(ChannelMessageId, Count)>();
+            let mut new_messages = old_cursor.slice(&first_message.id, Bias::Left, &());
+            let start_ix = old_cursor.start().1 .0;
+            let removed_messages = old_cursor.slice(&last_message.id, Bias::Right, &());
+            let removed_count = removed_messages.summary().count;
+            let new_count = messages.summary().count;
+            let end_ix = start_ix + removed_count;
+
+            new_messages.push_tree(messages, &());
+
+            let mut ranges = Vec::<Range<usize>>::new();
+            if new_messages.last().unwrap().is_pending() {
+                new_messages.push_tree(old_cursor.suffix(&()), &());
+            } else {
+                new_messages.push_tree(
+                    old_cursor.slice(&ChannelMessageId::Pending(0), Bias::Left, &()),
+                    &(),
+                );
+
+                while let Some(message) = old_cursor.item() {
+                    let message_ix = old_cursor.start().1 .0;
+                    if nonces.contains(&message.nonce) {
+                        if ranges.last().map_or(false, |r| r.end == message_ix) {
+                            ranges.last_mut().unwrap().end += 1;
+                        } else {
+                            ranges.push(message_ix..message_ix + 1);
+                        }
+                    } else {
+                        new_messages.push(message.clone(), &());
+                    }
+                    old_cursor.next(&());
+                }
+            }
+
+            drop(old_cursor);
+            self.messages = new_messages;
+
+            for range in ranges.into_iter().rev() {
+                cx.emit(ChannelEvent::MessagesUpdated {
+                    old_range: range,
+                    new_count: 0,
+                });
+            }
+            cx.emit(ChannelEvent::MessagesUpdated {
+                old_range: start_ix..end_ix,
+                new_count,
+            });
+            cx.notify();
+        }
+    }
+}
+
+async fn messages_from_proto(
+    proto_messages: Vec<proto::ChannelMessage>,
+    user_store: &ModelHandle<UserStore>,
+    cx: &mut AsyncAppContext,
+) -> Result<SumTree<ChannelMessage>> {
+    let unique_user_ids = proto_messages
+        .iter()
+        .map(|m| m.sender_id)
+        .collect::<HashSet<_>>()
+        .into_iter()
+        .collect();
+    user_store
+        .update(cx, |user_store, cx| {
+            user_store.get_users(unique_user_ids, cx)
+        })
+        .await?;
+
+    let mut messages = Vec::with_capacity(proto_messages.len());
+    for message in proto_messages {
+        messages.push(ChannelMessage::from_proto(message, user_store, cx).await?);
+    }
+    let mut result = SumTree::new();
+    result.extend(messages, &());
+    Ok(result)
+}
+
+impl From<proto::Channel> for ChannelDetails {
+    fn from(message: proto::Channel) -> Self {
+        Self {
+            id: message.id,
+            name: message.name,
+        }
+    }
+}
+
+impl ChannelMessage {
+    pub async fn from_proto(
+        message: proto::ChannelMessage,
+        user_store: &ModelHandle<UserStore>,
+        cx: &mut AsyncAppContext,
+    ) -> Result<Self> {
+        let sender = user_store
+            .update(cx, |user_store, cx| {
+                user_store.get_user(message.sender_id, cx)
+            })
+            .await?;
+        Ok(ChannelMessage {
+            id: ChannelMessageId::Saved(message.id),
+            body: message.body,
+            timestamp: OffsetDateTime::from_unix_timestamp(message.timestamp as i64)?,
+            sender,
+            nonce: message
+                .nonce
+                .ok_or_else(|| anyhow!("nonce is required"))?
+                .into(),
+        })
+    }
+
+    pub fn is_pending(&self) -> bool {
+        matches!(self.id, ChannelMessageId::Pending(_))
+    }
+}
+
+impl sum_tree::Item for ChannelMessage {
+    type Summary = ChannelMessageSummary;
+
+    fn summary(&self) -> Self::Summary {
+        ChannelMessageSummary {
+            max_id: self.id,
+            count: 1,
+        }
+    }
+}
+
+impl Default for ChannelMessageId {
+    fn default() -> Self {
+        Self::Saved(0)
+    }
+}
+
+impl sum_tree::Summary for ChannelMessageSummary {
+    type Context = ();
+
+    fn add_summary(&mut self, summary: &Self, _: &()) {
+        self.max_id = summary.max_id;
+        self.count += summary.count;
+    }
+}
+
+impl<'a> sum_tree::Dimension<'a, ChannelMessageSummary> for ChannelMessageId {
+    fn add_summary(&mut self, summary: &'a ChannelMessageSummary, _: &()) {
+        debug_assert!(summary.max_id > *self);
+        *self = summary.max_id;
+    }
+}
+
+impl<'a> sum_tree::Dimension<'a, ChannelMessageSummary> for Count {
+    fn add_summary(&mut self, summary: &'a ChannelMessageSummary, _: &()) {
+        self.0 += summary.count;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test::{FakeHttpClient, FakeServer};
+    use gpui::TestAppContext;
+
+    #[gpui::test]
+    async fn test_channel_messages(cx: &mut TestAppContext) {
+        cx.foreground().forbid_parking();
+
+        let user_id = 5;
+        let http_client = FakeHttpClient::with_404_response();
+        let client = cx.update(|cx| Client::new(http_client.clone(), cx));
+        let server = FakeServer::for_client(user_id, &client, cx).await;
+
+        Channel::init(&client);
+        let user_store = cx.add_model(|cx| UserStore::new(client.clone(), http_client, cx));
+
+        let channel_list = cx.add_model(|cx| ChannelList::new(user_store, client.clone(), cx));
+        channel_list.read_with(cx, |list, _| assert_eq!(list.available_channels(), None));
+
+        // Get the available channels.
+        let get_channels = server.receive::<proto::GetChannels>().await.unwrap();
+        server
+            .respond(
+                get_channels.receipt(),
+                proto::GetChannelsResponse {
+                    channels: vec![proto::Channel {
+                        id: 5,
+                        name: "the-channel".to_string(),
+                    }],
+                },
+            )
+            .await;
+        channel_list.next_notification(cx).await;
+        channel_list.read_with(cx, |list, _| {
+            assert_eq!(
+                list.available_channels().unwrap(),
+                &[ChannelDetails {
+                    id: 5,
+                    name: "the-channel".into(),
+                }]
+            )
+        });
+
+        let get_users = server.receive::<proto::GetUsers>().await.unwrap();
+        assert_eq!(get_users.payload.user_ids, vec![5]);
+        server
+            .respond(
+                get_users.receipt(),
+                proto::UsersResponse {
+                    users: vec![proto::User {
+                        id: 5,
+                        github_login: "nathansobo".into(),
+                        avatar_url: "http://avatar.com/nathansobo".into(),
+                    }],
+                },
+            )
+            .await;
+
+        // Join a channel and populate its existing messages.
+        let channel = channel_list
+            .update(cx, |list, cx| {
+                let channel_id = list.available_channels().unwrap()[0].id;
+                list.get_channel(channel_id, cx)
+            })
+            .unwrap();
+        channel.read_with(cx, |channel, _| assert!(channel.messages().is_empty()));
+        let join_channel = server.receive::<proto::JoinChannel>().await.unwrap();
+        server
+            .respond(
+                join_channel.receipt(),
+                proto::JoinChannelResponse {
+                    messages: vec![
+                        proto::ChannelMessage {
+                            id: 10,
+                            body: "a".into(),
+                            timestamp: 1000,
+                            sender_id: 5,
+                            nonce: Some(1.into()),
+                        },
+                        proto::ChannelMessage {
+                            id: 11,
+                            body: "b".into(),
+                            timestamp: 1001,
+                            sender_id: 6,
+                            nonce: Some(2.into()),
+                        },
+                    ],
+                    done: false,
+                },
+            )
+            .await;
+
+        // Client requests all users for the received messages
+        let mut get_users = server.receive::<proto::GetUsers>().await.unwrap();
+        get_users.payload.user_ids.sort();
+        assert_eq!(get_users.payload.user_ids, vec![6]);
+        server
+            .respond(
+                get_users.receipt(),
+                proto::UsersResponse {
+                    users: vec![proto::User {
+                        id: 6,
+                        github_login: "maxbrunsfeld".into(),
+                        avatar_url: "http://avatar.com/maxbrunsfeld".into(),
+                    }],
+                },
+            )
+            .await;
+
+        assert_eq!(
+            channel.next_event(cx).await,
+            ChannelEvent::MessagesUpdated {
+                old_range: 0..0,
+                new_count: 2,
+            }
+        );
+        channel.read_with(cx, |channel, _| {
+            assert_eq!(
+                channel
+                    .messages_in_range(0..2)
+                    .map(|message| (message.sender.github_login.clone(), message.body.clone()))
+                    .collect::<Vec<_>>(),
+                &[
+                    ("nathansobo".into(), "a".into()),
+                    ("maxbrunsfeld".into(), "b".into())
+                ]
+            );
+        });
+
+        // Receive a new message.
+        server.send(proto::ChannelMessageSent {
+            channel_id: channel.read_with(cx, |channel, _| channel.details.id),
+            message: Some(proto::ChannelMessage {
+                id: 12,
+                body: "c".into(),
+                timestamp: 1002,
+                sender_id: 7,
+                nonce: Some(3.into()),
+            }),
+        });
+
+        // Client requests user for message since they haven't seen them yet
+        let get_users = server.receive::<proto::GetUsers>().await.unwrap();
+        assert_eq!(get_users.payload.user_ids, vec![7]);
+        server
+            .respond(
+                get_users.receipt(),
+                proto::UsersResponse {
+                    users: vec![proto::User {
+                        id: 7,
+                        github_login: "as-cii".into(),
+                        avatar_url: "http://avatar.com/as-cii".into(),
+                    }],
+                },
+            )
+            .await;
+
+        assert_eq!(
+            channel.next_event(cx).await,
+            ChannelEvent::MessagesUpdated {
+                old_range: 2..2,
+                new_count: 1,
+            }
+        );
+        channel.read_with(cx, |channel, _| {
+            assert_eq!(
+                channel
+                    .messages_in_range(2..3)
+                    .map(|message| (message.sender.github_login.clone(), message.body.clone()))
+                    .collect::<Vec<_>>(),
+                &[("as-cii".into(), "c".into())]
+            )
+        });
+
+        // Scroll up to view older messages.
+        channel.update(cx, |channel, cx| {
+            assert!(channel.load_more_messages(cx));
+        });
+        let get_messages = server.receive::<proto::GetChannelMessages>().await.unwrap();
+        assert_eq!(get_messages.payload.channel_id, 5);
+        assert_eq!(get_messages.payload.before_message_id, 10);
+        server
+            .respond(
+                get_messages.receipt(),
+                proto::GetChannelMessagesResponse {
+                    done: true,
+                    messages: vec![
+                        proto::ChannelMessage {
+                            id: 8,
+                            body: "y".into(),
+                            timestamp: 998,
+                            sender_id: 5,
+                            nonce: Some(4.into()),
+                        },
+                        proto::ChannelMessage {
+                            id: 9,
+                            body: "z".into(),
+                            timestamp: 999,
+                            sender_id: 6,
+                            nonce: Some(5.into()),
+                        },
+                    ],
+                },
+            )
+            .await;
+
+        assert_eq!(
+            channel.next_event(cx).await,
+            ChannelEvent::MessagesUpdated {
+                old_range: 0..0,
+                new_count: 2,
+            }
+        );
+        channel.read_with(cx, |channel, _| {
+            assert_eq!(
+                channel
+                    .messages_in_range(0..2)
+                    .map(|message| (message.sender.github_login.clone(), message.body.clone()))
+                    .collect::<Vec<_>>(),
+                &[
+                    ("nathansobo".into(), "y".into()),
+                    ("maxbrunsfeld".into(), "z".into())
+                ]
+            );
+        });
+    }
+}
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -1,6 +1,7 @@
 #[cfg(any(test, feature = "test-support"))]
 pub mod test;

+pub mod channel;
 pub mod http;
 pub mod telemetry;
 pub mod user;
@@ -43,6 +44,7 @@ use thiserror::Error;
 use url::Url;
 use util::{ResultExt, TryFutureExt};

+pub use channel::*;
 pub use rpc::*;
 pub use user::*;

--- a/crates/client/src/user.rs
+++ b/crates/client/src/user.rs
@@ -150,6 +150,7 @@ impl UserStore {
                                    client.telemetry.set_authenticated_user_info(None, false);
                                }

+                                client.telemetry.report_event("sign in", Default::default());
                                current_user_tx.send(user).await.ok();
                            }
                        }
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -3,7 +3,7 @@ authors = ["Nathan Sobo <nathan@zed.dev>"]
 default-run = "collab"
 edition = "2021"
 name = "collab"
-version = "0.2.4"
+version = "0.2.0"

 [[bin]]
 name = "collab"
@@ -50,9 +50,8 @@ tracing-log = "0.1.3"
 tracing-subscriber = { version = "0.3.11", features = ["env-filter", "json"] }

 [dependencies.sqlx]
-git = "https://github.com/launchbadge/sqlx"
-rev = "4b7053807c705df312bcb9b6281e184bf7534eb3"
-features = ["runtime-tokio-rustls", "postgres", "json", "time", "uuid"]
+version = "0.6"
+features = ["runtime-tokio-rustls", "postgres", "time", "uuid"]

 [dev-dependencies]
 collections = { path = "../collections", features = ["test-support"] }
@@ -79,10 +78,5 @@ lazy_static = "1.4"
 serde_json = { version = "1.0", features = ["preserve_order"] }
 unindent = "0.1"

-[dev-dependencies.sqlx]
-git = "https://github.com/launchbadge/sqlx"
-rev = "4b7053807c705df312bcb9b6281e184bf7534eb3"
-features = ["sqlite"]
-
 [features]
 seed-support = ["clap", "lipsum", "reqwest"]
--- a/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
+++ b/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
@@ -1,41 +0,0 @@
-CREATE TABLE IF NOT EXISTS "users" (
-    "id" INTEGER PRIMARY KEY,
-    "github_login" VARCHAR,
-    "admin" BOOLEAN,
-    "email_address" VARCHAR(255) DEFAULT NULL,
-    "invite_code" VARCHAR(64),
-    "invite_count" INTEGER NOT NULL DEFAULT 0,
-    "inviter_id" INTEGER REFERENCES users (id),
-    "connected_once" BOOLEAN NOT NULL DEFAULT false,
-    "created_at" TIMESTAMP NOT NULL DEFAULT now,
-    "metrics_id" VARCHAR(255),
-    "github_user_id" INTEGER
-);
-CREATE UNIQUE INDEX "index_users_github_login" ON "users" ("github_login");
-CREATE UNIQUE INDEX "index_invite_code_users" ON "users" ("invite_code");
-CREATE INDEX "index_users_on_email_address" ON "users" ("email_address");
-CREATE INDEX "index_users_on_github_user_id" ON "users" ("github_user_id");
-
-CREATE TABLE IF NOT EXISTS "access_tokens" (
-    "id" INTEGER PRIMARY KEY,
-    "user_id" INTEGER REFERENCES users (id),
-    "hash" VARCHAR(128)
-);
-CREATE INDEX "index_access_tokens_user_id" ON "access_tokens" ("user_id");
-
-CREATE TABLE IF NOT EXISTS "contacts" (
-    "id" INTEGER PRIMARY KEY,
-    "user_id_a" INTEGER REFERENCES users (id) NOT NULL,
-    "user_id_b" INTEGER REFERENCES users (id) NOT NULL,
-    "a_to_b" BOOLEAN NOT NULL,
-    "should_notify" BOOLEAN NOT NULL,
-    "accepted" BOOLEAN NOT NULL
-);
-CREATE UNIQUE INDEX "index_contacts_user_ids" ON "contacts" ("user_id_a", "user_id_b");
-CREATE INDEX "index_contacts_user_id_b" ON "contacts" ("user_id_b");
-
-CREATE TABLE IF NOT EXISTS "projects" (
-    "id" INTEGER PRIMARY KEY,
-    "host_user_id" INTEGER REFERENCES users (id) NOT NULL,
-    "unregistered" BOOLEAN NOT NULL DEFAULT false
-);
--- a/crates/collab/src/api.rs
+++ b/crates/collab/src/api.rs
@@ -1,6 +1,6 @@
 use crate::{
    auth,
-    db::{Invite, NewUserParams, Signup, User, UserId, WaitlistSummary},
+    db::{Invite, NewUserParams, ProjectId, Signup, User, UserId, WaitlistSummary},
    rpc::{self, ResultExt},
    AppState, Error, Result,
 };
@@ -16,7 +16,9 @@ use axum::{
 };
 use axum_extra::response::ErasedJson;
 use serde::{Deserialize, Serialize};
-use std::sync::Arc;
+use serde_json::json;
+use std::{sync::Arc, time::Duration};
+use time::OffsetDateTime;
 use tower::ServiceBuilder;
 use tracing::instrument;

@@ -30,6 +32,16 @@ pub fn routes(rpc_server: Arc<rpc::Server>, state: Arc<AppState>) -> Router<Body
        .route("/invite_codes/:code", get(get_user_for_invite_code))
        .route("/panic", post(trace_panic))
        .route("/rpc_server_snapshot", get(get_rpc_server_snapshot))
+        .route(
+            "/user_activity/summary",
+            get(get_top_users_activity_summary),
+        )
+        .route(
+            "/user_activity/timeline/:user_id",
+            get(get_user_activity_timeline),
+        )
+        .route("/user_activity/counts", get(get_active_user_counts))
+        .route("/project_metadata", get(get_project_metadata))
        .route("/signups", post(create_signup))
        .route("/signups_summary", get(get_waitlist_summary))
        .route("/user_invites", post(create_invite_from_code))
@@ -271,6 +283,93 @@ async fn get_rpc_server_snapshot(
    Ok(ErasedJson::pretty(rpc_server.snapshot().await))
 }

+#[derive(Deserialize)]
+struct TimePeriodParams {
+    #[serde(with = "time::serde::iso8601")]
+    start: OffsetDateTime,
+    #[serde(with = "time::serde::iso8601")]
+    end: OffsetDateTime,
+}
+
+async fn get_top_users_activity_summary(
+    Query(params): Query<TimePeriodParams>,
+    Extension(app): Extension<Arc<AppState>>,
+) -> Result<ErasedJson> {
+    let summary = app
+        .db
+        .get_top_users_activity_summary(params.start..params.end, 100)
+        .await?;
+    Ok(ErasedJson::pretty(summary))
+}
+
+async fn get_user_activity_timeline(
+    Path(user_id): Path<i32>,
+    Query(params): Query<TimePeriodParams>,
+    Extension(app): Extension<Arc<AppState>>,
+) -> Result<ErasedJson> {
+    let summary = app
+        .db
+        .get_user_activity_timeline(params.start..params.end, UserId(user_id))
+        .await?;
+    Ok(ErasedJson::pretty(summary))
+}
+
+#[derive(Deserialize)]
+struct ActiveUserCountParams {
+    #[serde(flatten)]
+    period: TimePeriodParams,
+    durations_in_minutes: String,
+    #[serde(default)]
+    only_collaborative: bool,
+}
+
+#[derive(Serialize)]
+struct ActiveUserSet {
+    active_time_in_minutes: u64,
+    user_count: usize,
+}
+
+async fn get_active_user_counts(
+    Query(params): Query<ActiveUserCountParams>,
+    Extension(app): Extension<Arc<AppState>>,
+) -> Result<ErasedJson> {
+    let durations_in_minutes = params.durations_in_minutes.split(',');
+    let mut user_sets = Vec::new();
+    for duration in durations_in_minutes {
+        let duration = duration
+            .parse()
+            .map_err(|_| anyhow!("invalid duration: {duration}"))?;
+        user_sets.push(ActiveUserSet {
+            active_time_in_minutes: duration,
+            user_count: app
+                .db
+                .get_active_user_count(
+                    params.period.start..params.period.end,
+                    Duration::from_secs(duration * 60),
+                    params.only_collaborative,
+                )
+                .await?,
+        })
+    }
+    Ok(ErasedJson::pretty(user_sets))
+}
+
+#[derive(Deserialize)]
+struct GetProjectMetadataParams {
+    project_id: u64,
+}
+
+async fn get_project_metadata(
+    Query(params): Query<GetProjectMetadataParams>,
+    Extension(app): Extension<Arc<AppState>>,
+) -> Result<ErasedJson> {
+    let extensions = app
+        .db
+        .get_project_extensions(ProjectId::from_proto(params.project_id))
+        .await?;
+    Ok(ErasedJson::pretty(json!({ "extensions": extensions })))
+}
+
 #[derive(Deserialize)]
 struct CreateAccessTokenQueryParams {
    public_key: String,
@@ -338,7 +437,7 @@ async fn create_signup(
    Json(params): Json<Signup>,
    Extension(app): Extension<Arc<AppState>>,
 ) -> Result<()> {
-    app.db.create_signup(&params).await?;
+    app.db.create_signup(params).await?;
    Ok(())
 }

--- a/crates/collab/src/auth.rs
+++ b/crates/collab/src/auth.rs
@@ -75,7 +75,7 @@ pub async fn validate_header<B>(mut req: Request<B>, next: Next<B>) -> impl Into

 const MAX_ACCESS_TOKENS_TO_STORE: usize = 8;

-pub async fn create_access_token(db: &db::DefaultDb, user_id: UserId) -> Result<String> {
+pub async fn create_access_token(db: &dyn db::Db, user_id: UserId) -> Result<String> {
    let access_token = rpc::auth::random_token();
    let access_token_hash =
        hash_access_token(&access_token).context("failed to hash access token")?;
--- a/crates/collab/src/bin/seed.rs
+++ b/crates/collab/src/bin/seed.rs
@@ -1,7 +1,9 @@
 use collab::{Error, Result};
-use db::DefaultDb;
+use db::{Db, PostgresDb, UserId};
+use rand::prelude::*;
 use serde::{de::DeserializeOwned, Deserialize};
 use std::fmt::Write;
+use time::{Duration, OffsetDateTime};

 #[allow(unused)]
 #[path = "../db.rs"]
@@ -16,8 +18,9 @@ struct GitHubUser {

 #[tokio::main]
 async fn main() {
+    let mut rng = StdRng::from_entropy();
    let database_url = std::env::var("DATABASE_URL").expect("missing DATABASE_URL env var");
-    let db = DefaultDb::new(&database_url, 5)
+    let db = PostgresDb::new(&database_url, 5)
        .await
        .expect("failed to connect to postgres database");
    let github_token = std::env::var("GITHUB_TOKEN").expect("missing GITHUB_TOKEN env var");
@@ -61,14 +64,16 @@ async fn main() {
        }
    }

+    let mut zed_user_ids = Vec::<UserId>::new();
    for (github_user, admin) in zed_users {
-        if db
+        if let Some(user) = db
            .get_user_by_github_account(&github_user.login, Some(github_user.id))
            .await
            .expect("failed to fetch user")
-            .is_none()
        {
-            if let Some(email) = &github_user.email {
+            zed_user_ids.push(user.id);
+        } else if let Some(email) = &github_user.email {
+            zed_user_ids.push(
                db.create_user(
                    email,
                    admin,
@@ -79,8 +84,11 @@ async fn main() {
                    },
                )
                .await
-                .expect("failed to insert user");
-            } else if admin {
+                .expect("failed to insert user")
+                .user_id,
+            );
+        } else if admin {
+            zed_user_ids.push(
                db.create_user(
                    &format!("{}@zed.dev", github_user.login),
                    admin,
@@ -91,10 +99,62 @@ async fn main() {
                    },
                )
                .await
-                .expect("failed to insert user");
-            }
+                .expect("failed to insert user")
+                .user_id,
+            );
        }
    }
+
+    let zed_org_id = if let Some(org) = db
+        .find_org_by_slug("zed")
+        .await
+        .expect("failed to fetch org")
+    {
+        org.id
+    } else {
+        db.create_org("Zed", "zed")
+            .await
+            .expect("failed to insert org")
+    };
+
+    let general_channel_id = if let Some(channel) = db
+        .get_org_channels(zed_org_id)
+        .await
+        .expect("failed to fetch channels")
+        .iter()
+        .find(|c| c.name == "General")
+    {
+        channel.id
+    } else {
+        let channel_id = db
+            .create_org_channel(zed_org_id, "General")
+            .await
+            .expect("failed to insert channel");
+
+        let now = OffsetDateTime::now_utc();
+        let max_seconds = Duration::days(100).as_seconds_f64();
+        let mut timestamps = (0..1000)
+            .map(|_| now - Duration::seconds_f64(rng.gen_range(0_f64..=max_seconds)))
+            .collect::<Vec<_>>();
+        timestamps.sort();
+        for timestamp in timestamps {
+            let sender_id = *zed_user_ids.choose(&mut rng).unwrap();
+            let body = lipsum::lipsum_words(rng.gen_range(1..=50));
+            db.create_channel_message(channel_id, sender_id, &body, timestamp, rng.gen())
+                .await
+                .expect("failed to insert message");
+        }
+        channel_id
+    };
+
+    for user_id in zed_user_ids {
+        db.add_org_member(zed_org_id, user_id, true)
+            .await
+            .expect("failed to insert org membership");
+        db.add_channel_member(general_channel_id, user_id, true)
+            .await
+            .expect("failed to insert channel membership");
+    }
 }

 async fn fetch_github<T: DeserializeOwned>(
--- a/crates/collab/src/db.rs
+++ b/crates/collab/src/db.rs
--- a/crates/collab/src/db_tests.rs
+++ b/crates/collab/src/db_tests.rs
--- a/crates/collab/src/integration_tests.rs
+++ b/crates/collab/src/integration_tests.rs
@@ -1,14 +1,14 @@
 use crate::{
-    db::{NewUserParams, ProjectId, SqliteTestDb as TestDb, UserId},
-    rpc::{Executor, Server},
+    db::{NewUserParams, ProjectId, TestDb, UserId},
+    rpc::{Executor, Server, Store},
    AppState,
 };
 use ::rpc::Peer;
 use anyhow::anyhow;
 use call::{room, ActiveCall, ParticipantLocation, Room};
 use client::{
-    self, test::FakeHttpClient, Client, Connection, Credentials, EstablishConnectionError, PeerId,
-    User, UserStore, RECEIVE_TIMEOUT,
+    self, test::FakeHttpClient, Channel, ChannelDetails, ChannelList, Client, Connection,
+    Credentials, EstablishConnectionError, PeerId, User, UserStore, RECEIVE_TIMEOUT,
 };
 use collections::{BTreeMap, HashMap, HashSet};
 use editor::{
@@ -16,7 +16,10 @@ use editor::{
    ToggleCodeActions, Undo,
 };
 use fs::{FakeFs, Fs as _, HomeDir, LineEnding};
-use futures::{channel::oneshot, Future, StreamExt as _};
+use futures::{
+    channel::{mpsc, oneshot},
+    Future, StreamExt as _,
+};
 use gpui::{
    executor::{self, Deterministic},
    geometry::vector::vec2f,
@@ -36,6 +39,7 @@ use project::{
 use rand::prelude::*;
 use serde_json::json;
 use settings::{Formatter, Settings};
+use sqlx::types::time::OffsetDateTime;
 use std::{
    cell::{Cell, RefCell},
    env, mem,
@@ -69,10 +73,7 @@ async fn test_basic_calls(
    cx_c: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
-
-    let start = std::time::Instant::now();
-
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    let client_c = server.create_client(cx_c, "user_c").await;
@@ -258,8 +259,6 @@ async fn test_basic_calls(
            pending: Default::default()
        }
    );
-
-    eprintln!("finished test {:?}", start.elapsed());
 }

 #[gpui::test(iterations = 10)]
@@ -272,7 +271,7 @@ async fn test_room_uniqueness(
    cx_c: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let _client_a2 = server.create_client(cx_a2, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
@@ -377,7 +376,7 @@ async fn test_leaving_room_on_disconnection(
    cx_b: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -506,7 +505,7 @@ async fn test_calls_on_multiple_connections(
    cx_b2: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b1 = server.create_client(cx_b1, "user_b").await;
    let client_b2 = server.create_client(cx_b2, "user_b").await;
@@ -655,7 +654,7 @@ async fn test_share_project(
 ) {
    deterministic.forbid_parking();
    let (_, window_b) = cx_b.add_window(|_| EmptyView);
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    let client_c = server.create_client(cx_c, "user_c").await;
@@ -792,7 +791,7 @@ async fn test_unshare_project(
    cx_c: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    let client_c = server.create_client(cx_c, "user_c").await;
@@ -875,7 +874,7 @@ async fn test_host_disconnect(
 ) {
    cx_b.update(editor::init);
    deterministic.forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    let client_c = server.create_client(cx_c, "user_c").await;
@@ -909,7 +908,7 @@ async fn test_host_disconnect(
        cx_b.add_window(|cx| Workspace::new(project_b.clone(), |_, _| unimplemented!(), cx));
    let editor_b = workspace_b
        .update(cx_b, |workspace, cx| {
-            workspace.open_path((worktree_id, "b.txt"), None, true, cx)
+            workspace.open_path((worktree_id, "b.txt"), true, cx)
        })
        .await
        .unwrap()
@@ -980,7 +979,7 @@ async fn test_active_call_events(
    cx_b: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    client_a.fs.insert_tree("/a", json!({})).await;
@@ -1069,7 +1068,7 @@ async fn test_room_location(
    cx_b: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    client_a.fs.insert_tree("/a", json!({})).await;
@@ -1235,7 +1234,7 @@ async fn test_propagate_saves_and_fs_changes(
    cx_c: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    let client_c = server.create_client(cx_c, "user_c").await;
@@ -1410,7 +1409,7 @@ async fn test_git_diff_base_change(
    cx_b: &mut TestAppContext,
 ) {
    executor.forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -1662,7 +1661,7 @@ async fn test_fs_operations(
    cx_b: &mut TestAppContext,
 ) {
    executor.forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -1928,7 +1927,7 @@ async fn test_fs_operations(
 #[gpui::test(iterations = 10)]
 async fn test_buffer_conflict_after_save(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
    cx_a.foreground().forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -1982,7 +1981,7 @@ async fn test_buffer_conflict_after_save(cx_a: &mut TestAppContext, cx_b: &mut T
 #[gpui::test(iterations = 10)]
 async fn test_buffer_reloading(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
    cx_a.foreground().forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -2041,7 +2040,7 @@ async fn test_editing_while_guest_opens_buffer(
    cx_b: &mut TestAppContext,
 ) {
    cx_a.foreground().forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -2088,7 +2087,7 @@ async fn test_leaving_worktree_while_opening_buffer(
    cx_b: &mut TestAppContext,
 ) {
    cx_a.foreground().forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -2133,7 +2132,7 @@ async fn test_canceling_buffer_opening(
 ) {
    deterministic.forbid_parking();

-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -2184,7 +2183,7 @@ async fn test_leaving_project(
    cx_c: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    let client_c = server.create_client(cx_c, "user_c").await;
@@ -2317,7 +2316,7 @@ async fn test_collaborating_with_diagnostics(
    cx_c: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    let client_c = server.create_client(cx_c, "user_c").await;
@@ -2582,7 +2581,7 @@ async fn test_collaborating_with_diagnostics(
 #[gpui::test(iterations = 10)]
 async fn test_collaborating_with_completion(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
    cx_a.foreground().forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -2756,7 +2755,7 @@ async fn test_collaborating_with_completion(cx_a: &mut TestAppContext, cx_b: &mu
 #[gpui::test(iterations = 10)]
 async fn test_reloading_buffer_manually(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
    cx_a.foreground().forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -2849,7 +2848,7 @@ async fn test_reloading_buffer_manually(cx_a: &mut TestAppContext, cx_b: &mut Te
 async fn test_formatting_buffer(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
    use project::FormatTrigger;

-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -2950,7 +2949,7 @@ async fn test_formatting_buffer(cx_a: &mut TestAppContext, cx_b: &mut TestAppCon
 #[gpui::test(iterations = 10)]
 async fn test_definition(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
    cx_a.foreground().forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -3094,7 +3093,7 @@ async fn test_definition(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
 #[gpui::test(iterations = 10)]
 async fn test_references(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
    cx_a.foreground().forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -3195,7 +3194,7 @@ async fn test_references(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
 #[gpui::test(iterations = 10)]
 async fn test_project_search(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
    cx_a.foreground().forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -3274,7 +3273,7 @@ async fn test_project_search(cx_a: &mut TestAppContext, cx_b: &mut TestAppContex
 #[gpui::test(iterations = 10)]
 async fn test_document_highlights(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
    cx_a.foreground().forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -3376,7 +3375,7 @@ async fn test_document_highlights(cx_a: &mut TestAppContext, cx_b: &mut TestAppC
 #[gpui::test(iterations = 10)]
 async fn test_lsp_hover(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
    cx_a.foreground().forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -3479,7 +3478,7 @@ async fn test_lsp_hover(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
 #[gpui::test(iterations = 10)]
 async fn test_project_symbols(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
    cx_a.foreground().forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -3587,7 +3586,7 @@ async fn test_open_buffer_while_getting_definition_pointing_to_it(
    mut rng: StdRng,
 ) {
    cx_a.foreground().forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -3663,7 +3662,7 @@ async fn test_collaborating_with_code_actions(
 ) {
    cx_a.foreground().forbid_parking();
    cx_b.update(editor::init);
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -3705,7 +3704,7 @@ async fn test_collaborating_with_code_actions(
        cx_b.add_window(|cx| Workspace::new(project_b.clone(), |_, _| unimplemented!(), cx));
    let editor_b = workspace_b
        .update(cx_b, |workspace, cx| {
-            workspace.open_path((worktree_id, "main.rs"), None, true, cx)
+            workspace.open_path((worktree_id, "main.rs"), true, cx)
        })
        .await
        .unwrap()
@@ -3874,7 +3873,7 @@ async fn test_collaborating_with_code_actions(
 async fn test_collaborating_with_renames(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
    cx_a.foreground().forbid_parking();
    cx_b.update(editor::init);
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -3926,7 +3925,7 @@ async fn test_collaborating_with_renames(cx_a: &mut TestAppContext, cx_b: &mut T
        cx_b.add_window(|cx| Workspace::new(project_b.clone(), |_, _| unimplemented!(), cx));
    let editor_b = workspace_b
        .update(cx_b, |workspace, cx| {
-            workspace.open_path((worktree_id, "one.rs"), None, true, cx)
+            workspace.open_path((worktree_id, "one.rs"), true, cx)
        })
        .await
        .unwrap()
@@ -4066,7 +4065,7 @@ async fn test_language_server_statuses(
    deterministic.forbid_parking();

    cx_b.update(editor::init);
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -4170,6 +4169,415 @@ async fn test_language_server_statuses(
    });
 }

+#[gpui::test(iterations = 10)]
+async fn test_basic_chat(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
+    cx_a.foreground().forbid_parking();
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
+    let client_a = server.create_client(cx_a, "user_a").await;
+    let client_b = server.create_client(cx_b, "user_b").await;
+
+    // Create an org that includes these 2 users.
+    let db = &server.app_state.db;
+    let org_id = db.create_org("Test Org", "test-org").await.unwrap();
+    db.add_org_member(org_id, client_a.current_user_id(cx_a), false)
+        .await
+        .unwrap();
+    db.add_org_member(org_id, client_b.current_user_id(cx_b), false)
+        .await
+        .unwrap();
+
+    // Create a channel that includes all the users.
+    let channel_id = db.create_org_channel(org_id, "test-channel").await.unwrap();
+    db.add_channel_member(channel_id, client_a.current_user_id(cx_a), false)
+        .await
+        .unwrap();
+    db.add_channel_member(channel_id, client_b.current_user_id(cx_b), false)
+        .await
+        .unwrap();
+    db.create_channel_message(
+        channel_id,
+        client_b.current_user_id(cx_b),
+        "hello A, it's B.",
+        OffsetDateTime::now_utc(),
+        1,
+    )
+    .await
+    .unwrap();
+
+    let channels_a =
+        cx_a.add_model(|cx| ChannelList::new(client_a.user_store.clone(), client_a.clone(), cx));
+    channels_a
+        .condition(cx_a, |list, _| list.available_channels().is_some())
+        .await;
+    channels_a.read_with(cx_a, |list, _| {
+        assert_eq!(
+            list.available_channels().unwrap(),
+            &[ChannelDetails {
+                id: channel_id.to_proto(),
+                name: "test-channel".to_string()
+            }]
+        )
+    });
+    let channel_a = channels_a.update(cx_a, |this, cx| {
+        this.get_channel(channel_id.to_proto(), cx).unwrap()
+    });
+    channel_a.read_with(cx_a, |channel, _| assert!(channel.messages().is_empty()));
+    channel_a
+        .condition(cx_a, |channel, _| {
+            channel_messages(channel)
+                == [("user_b".to_string(), "hello A, it's B.".to_string(), false)]
+        })
+        .await;
+
+    let channels_b =
+        cx_b.add_model(|cx| ChannelList::new(client_b.user_store.clone(), client_b.clone(), cx));
+    channels_b
+        .condition(cx_b, |list, _| list.available_channels().is_some())
+        .await;
+    channels_b.read_with(cx_b, |list, _| {
+        assert_eq!(
+            list.available_channels().unwrap(),
+            &[ChannelDetails {
+                id: channel_id.to_proto(),
+                name: "test-channel".to_string()
+            }]
+        )
+    });
+
+    let channel_b = channels_b.update(cx_b, |this, cx| {
+        this.get_channel(channel_id.to_proto(), cx).unwrap()
+    });
+    channel_b.read_with(cx_b, |channel, _| assert!(channel.messages().is_empty()));
+    channel_b
+        .condition(cx_b, |channel, _| {
+            channel_messages(channel)
+                == [("user_b".to_string(), "hello A, it's B.".to_string(), false)]
+        })
+        .await;
+
+    channel_a
+        .update(cx_a, |channel, cx| {
+            channel
+                .send_message("oh, hi B.".to_string(), cx)
+                .unwrap()
+                .detach();
+            let task = channel.send_message("sup".to_string(), cx).unwrap();
+            assert_eq!(
+                channel_messages(channel),
+                &[
+                    ("user_b".to_string(), "hello A, it's B.".to_string(), false),
+                    ("user_a".to_string(), "oh, hi B.".to_string(), true),
+                    ("user_a".to_string(), "sup".to_string(), true)
+                ]
+            );
+            task
+        })
+        .await
+        .unwrap();
+
+    channel_b
+        .condition(cx_b, |channel, _| {
+            channel_messages(channel)
+                == [
+                    ("user_b".to_string(), "hello A, it's B.".to_string(), false),
+                    ("user_a".to_string(), "oh, hi B.".to_string(), false),
+                    ("user_a".to_string(), "sup".to_string(), false),
+                ]
+        })
+        .await;
+
+    assert_eq!(
+        server
+            .store()
+            .await
+            .channel(channel_id)
+            .unwrap()
+            .connection_ids
+            .len(),
+        2
+    );
+    cx_b.update(|_| drop(channel_b));
+    server
+        .condition(|state| state.channel(channel_id).unwrap().connection_ids.len() == 1)
+        .await;
+
+    cx_a.update(|_| drop(channel_a));
+    server
+        .condition(|state| state.channel(channel_id).is_none())
+        .await;
+}
+
+#[gpui::test(iterations = 10)]
+async fn test_chat_message_validation(cx_a: &mut TestAppContext) {
+    cx_a.foreground().forbid_parking();
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
+    let client_a = server.create_client(cx_a, "user_a").await;
+
+    let db = &server.app_state.db;
+    let org_id = db.create_org("Test Org", "test-org").await.unwrap();
+    let channel_id = db.create_org_channel(org_id, "test-channel").await.unwrap();
+    db.add_org_member(org_id, client_a.current_user_id(cx_a), false)
+        .await
+        .unwrap();
+    db.add_channel_member(channel_id, client_a.current_user_id(cx_a), false)
+        .await
+        .unwrap();
+
+    let channels_a =
+        cx_a.add_model(|cx| ChannelList::new(client_a.user_store.clone(), client_a.clone(), cx));
+    channels_a
+        .condition(cx_a, |list, _| list.available_channels().is_some())
+        .await;
+    let channel_a = channels_a.update(cx_a, |this, cx| {
+        this.get_channel(channel_id.to_proto(), cx).unwrap()
+    });
+
+    // Messages aren't allowed to be too long.
+    channel_a
+        .update(cx_a, |channel, cx| {
+            let long_body = "this is long.\n".repeat(1024);
+            channel.send_message(long_body, cx).unwrap()
+        })
+        .await
+        .unwrap_err();
+
+    // Messages aren't allowed to be blank.
+    channel_a.update(cx_a, |channel, cx| {
+        channel.send_message(String::new(), cx).unwrap_err()
+    });
+
+    // Leading and trailing whitespace are trimmed.
+    channel_a
+        .update(cx_a, |channel, cx| {
+            channel
+                .send_message("\n surrounded by whitespace  \n".to_string(), cx)
+                .unwrap()
+        })
+        .await
+        .unwrap();
+    assert_eq!(
+        db.get_channel_messages(channel_id, 10, None)
+            .await
+            .unwrap()
+            .iter()
+            .map(|m| &m.body)
+            .collect::<Vec<_>>(),
+        &["surrounded by whitespace"]
+    );
+}
+
+#[gpui::test(iterations = 10)]
+async fn test_chat_reconnection(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
+    cx_a.foreground().forbid_parking();
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
+    let client_a = server.create_client(cx_a, "user_a").await;
+    let client_b = server.create_client(cx_b, "user_b").await;
+
+    let mut status_b = client_b.status();
+
+    // Create an org that includes these 2 users.
+    let db = &server.app_state.db;
+    let org_id = db.create_org("Test Org", "test-org").await.unwrap();
+    db.add_org_member(org_id, client_a.current_user_id(cx_a), false)
+        .await
+        .unwrap();
+    db.add_org_member(org_id, client_b.current_user_id(cx_b), false)
+        .await
+        .unwrap();
+
+    // Create a channel that includes all the users.
+    let channel_id = db.create_org_channel(org_id, "test-channel").await.unwrap();
+    db.add_channel_member(channel_id, client_a.current_user_id(cx_a), false)
+        .await
+        .unwrap();
+    db.add_channel_member(channel_id, client_b.current_user_id(cx_b), false)
+        .await
+        .unwrap();
+    db.create_channel_message(
+        channel_id,
+        client_b.current_user_id(cx_b),
+        "hello A, it's B.",
+        OffsetDateTime::now_utc(),
+        2,
+    )
+    .await
+    .unwrap();
+
+    let channels_a =
+        cx_a.add_model(|cx| ChannelList::new(client_a.user_store.clone(), client_a.clone(), cx));
+    channels_a
+        .condition(cx_a, |list, _| list.available_channels().is_some())
+        .await;
+
+    channels_a.read_with(cx_a, |list, _| {
+        assert_eq!(
+            list.available_channels().unwrap(),
+            &[ChannelDetails {
+                id: channel_id.to_proto(),
+                name: "test-channel".to_string()
+            }]
+        )
+    });
+    let channel_a = channels_a.update(cx_a, |this, cx| {
+        this.get_channel(channel_id.to_proto(), cx).unwrap()
+    });
+    channel_a.read_with(cx_a, |channel, _| assert!(channel.messages().is_empty()));
+    channel_a
+        .condition(cx_a, |channel, _| {
+            channel_messages(channel)
+                == [("user_b".to_string(), "hello A, it's B.".to_string(), false)]
+        })
+        .await;
+
+    let channels_b =
+        cx_b.add_model(|cx| ChannelList::new(client_b.user_store.clone(), client_b.clone(), cx));
+    channels_b
+        .condition(cx_b, |list, _| list.available_channels().is_some())
+        .await;
+    channels_b.read_with(cx_b, |list, _| {
+        assert_eq!(
+            list.available_channels().unwrap(),
+            &[ChannelDetails {
+                id: channel_id.to_proto(),
+                name: "test-channel".to_string()
+            }]
+        )
+    });
+
+    let channel_b = channels_b.update(cx_b, |this, cx| {
+        this.get_channel(channel_id.to_proto(), cx).unwrap()
+    });
+    channel_b.read_with(cx_b, |channel, _| assert!(channel.messages().is_empty()));
+    channel_b
+        .condition(cx_b, |channel, _| {
+            channel_messages(channel)
+                == [("user_b".to_string(), "hello A, it's B.".to_string(), false)]
+        })
+        .await;
+
+    // Disconnect client B, ensuring we can still access its cached channel data.
+    server.forbid_connections();
+    server.disconnect_client(client_b.peer_id().unwrap());
+    cx_b.foreground().advance_clock(rpc::RECEIVE_TIMEOUT);
+    while !matches!(
+        status_b.next().await,
+        Some(client::Status::ReconnectionError { .. })
+    ) {}
+
+    channels_b.read_with(cx_b, |channels, _| {
+        assert_eq!(
+            channels.available_channels().unwrap(),
+            [ChannelDetails {
+                id: channel_id.to_proto(),
+                name: "test-channel".to_string()
+            }]
+        )
+    });
+    channel_b.read_with(cx_b, |channel, _| {
+        assert_eq!(
+            channel_messages(channel),
+            [("user_b".to_string(), "hello A, it's B.".to_string(), false)]
+        )
+    });
+
+    // Send a message from client B while it is disconnected.
+    channel_b
+        .update(cx_b, |channel, cx| {
+            let task = channel
+                .send_message("can you see this?".to_string(), cx)
+                .unwrap();
+            assert_eq!(
+                channel_messages(channel),
+                &[
+                    ("user_b".to_string(), "hello A, it's B.".to_string(), false),
+                    ("user_b".to_string(), "can you see this?".to_string(), true)
+                ]
+            );
+            task
+        })
+        .await
+        .unwrap_err();
+
+    // Send a message from client A while B is disconnected.
+    channel_a
+        .update(cx_a, |channel, cx| {
+            channel
+                .send_message("oh, hi B.".to_string(), cx)
+                .unwrap()
+                .detach();
+            let task = channel.send_message("sup".to_string(), cx).unwrap();
+            assert_eq!(
+                channel_messages(channel),
+                &[
+                    ("user_b".to_string(), "hello A, it's B.".to_string(), false),
+                    ("user_a".to_string(), "oh, hi B.".to_string(), true),
+                    ("user_a".to_string(), "sup".to_string(), true)
+                ]
+            );
+            task
+        })
+        .await
+        .unwrap();
+
+    // Give client B a chance to reconnect.
+    server.allow_connections();
+    cx_b.foreground().advance_clock(Duration::from_secs(10));
+
+    // Verify that B sees the new messages upon reconnection, as well as the message client B
+    // sent while offline.
+    channel_b
+        .condition(cx_b, |channel, _| {
+            channel_messages(channel)
+                == [
+                    ("user_b".to_string(), "hello A, it's B.".to_string(), false),
+                    ("user_a".to_string(), "oh, hi B.".to_string(), false),
+                    ("user_a".to_string(), "sup".to_string(), false),
+                    ("user_b".to_string(), "can you see this?".to_string(), false),
+                ]
+        })
+        .await;
+
+    // Ensure client A and B can communicate normally after reconnection.
+    channel_a
+        .update(cx_a, |channel, cx| {
+            channel.send_message("you online?".to_string(), cx).unwrap()
+        })
+        .await
+        .unwrap();
+    channel_b
+        .condition(cx_b, |channel, _| {
+            channel_messages(channel)
+                == [
+                    ("user_b".to_string(), "hello A, it's B.".to_string(), false),
+                    ("user_a".to_string(), "oh, hi B.".to_string(), false),
+                    ("user_a".to_string(), "sup".to_string(), false),
+                    ("user_b".to_string(), "can you see this?".to_string(), false),
+                    ("user_a".to_string(), "you online?".to_string(), false),
+                ]
+        })
+        .await;
+
+    channel_b
+        .update(cx_b, |channel, cx| {
+            channel.send_message("yep".to_string(), cx).unwrap()
+        })
+        .await
+        .unwrap();
+    channel_a
+        .condition(cx_a, |channel, _| {
+            channel_messages(channel)
+                == [
+                    ("user_b".to_string(), "hello A, it's B.".to_string(), false),
+                    ("user_a".to_string(), "oh, hi B.".to_string(), false),
+                    ("user_a".to_string(), "sup".to_string(), false),
+                    ("user_b".to_string(), "can you see this?".to_string(), false),
+                    ("user_a".to_string(), "you online?".to_string(), false),
+                    ("user_b".to_string(), "yep".to_string(), false),
+                ]
+        })
+        .await;
+}
+
 #[gpui::test(iterations = 10)]
 async fn test_contacts(
    deterministic: Arc<Deterministic>,
@@ -4178,7 +4586,7 @@ async fn test_contacts(
    cx_c: &mut TestAppContext,
 ) {
    cx_a.foreground().forbid_parking();
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    let client_c = server.create_client(cx_c, "user_c").await;
@@ -4504,7 +4912,7 @@ async fn test_contact_requests(
    cx_a.foreground().forbid_parking();

    // Connect to a server as 3 clients.
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_a2 = server.create_client(cx_a2, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
@@ -4685,7 +5093,7 @@ async fn test_following(
    cx_a.update(editor::init);
    cx_b.update(editor::init);

-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -4726,7 +5134,7 @@ async fn test_following(
    let pane_a = workspace_a.read_with(cx_a, |workspace, _| workspace.active_pane().clone());
    let editor_a1 = workspace_a
        .update(cx_a, |workspace, cx| {
-            workspace.open_path((worktree_id, "1.txt"), None, true, cx)
+            workspace.open_path((worktree_id, "1.txt"), true, cx)
        })
        .await
        .unwrap()
@@ -4734,7 +5142,7 @@ async fn test_following(
        .unwrap();
    let editor_a2 = workspace_a
        .update(cx_a, |workspace, cx| {
-            workspace.open_path((worktree_id, "2.txt"), None, true, cx)
+            workspace.open_path((worktree_id, "2.txt"), true, cx)
        })
        .await
        .unwrap()
@@ -4745,7 +5153,7 @@ async fn test_following(
    let workspace_b = client_b.build_workspace(&project_b, cx_b);
    let editor_b1 = workspace_b
        .update(cx_b, |workspace, cx| {
-            workspace.open_path((worktree_id, "1.txt"), None, true, cx)
+            workspace.open_path((worktree_id, "1.txt"), true, cx)
        })
        .await
        .unwrap()
@@ -4959,7 +5367,7 @@ async fn test_peers_following_each_other(cx_a: &mut TestAppContext, cx_b: &mut T
    cx_a.update(editor::init);
    cx_b.update(editor::init);

-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -5003,7 +5411,7 @@ async fn test_peers_following_each_other(cx_a: &mut TestAppContext, cx_b: &mut T
    let pane_a1 = workspace_a.read_with(cx_a, |workspace, _| workspace.active_pane().clone());
    let _editor_a1 = workspace_a
        .update(cx_a, |workspace, cx| {
-            workspace.open_path((worktree_id, "1.txt"), None, true, cx)
+            workspace.open_path((worktree_id, "1.txt"), true, cx)
        })
        .await
        .unwrap()
@@ -5015,7 +5423,7 @@ async fn test_peers_following_each_other(cx_a: &mut TestAppContext, cx_b: &mut T
    let pane_b1 = workspace_b.read_with(cx_b, |workspace, _| workspace.active_pane().clone());
    let _editor_b1 = workspace_b
        .update(cx_b, |workspace, cx| {
-            workspace.open_path((worktree_id, "2.txt"), None, true, cx)
+            workspace.open_path((worktree_id, "2.txt"), true, cx)
        })
        .await
        .unwrap()
@@ -5066,7 +5474,7 @@ async fn test_peers_following_each_other(cx_a: &mut TestAppContext, cx_b: &mut T

    workspace_a
        .update(cx_a, |workspace, cx| {
-            workspace.open_path((worktree_id, "3.txt"), None, true, cx)
+            workspace.open_path((worktree_id, "3.txt"), true, cx)
        })
        .await
        .unwrap();
@@ -5077,7 +5485,7 @@ async fn test_peers_following_each_other(cx_a: &mut TestAppContext, cx_b: &mut T
    workspace_b
        .update(cx_b, |workspace, cx| {
            assert_eq!(*workspace.active_pane(), pane_b1);
-            workspace.open_path((worktree_id, "4.txt"), None, true, cx)
+            workspace.open_path((worktree_id, "4.txt"), true, cx)
        })
        .await
        .unwrap();
@@ -5137,7 +5545,7 @@ async fn test_auto_unfollowing(cx_a: &mut TestAppContext, cx_b: &mut TestAppCont
    cx_b.update(editor::init);

    // 2 clients connect to a server.
-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -5178,7 +5586,7 @@ async fn test_auto_unfollowing(cx_a: &mut TestAppContext, cx_b: &mut TestAppCont
    let workspace_a = client_a.build_workspace(&project_a, cx_a);
    let _editor_a1 = workspace_a
        .update(cx_a, |workspace, cx| {
-            workspace.open_path((worktree_id, "1.txt"), None, true, cx)
+            workspace.open_path((worktree_id, "1.txt"), true, cx)
        })
        .await
        .unwrap()
@@ -5291,7 +5699,7 @@ async fn test_auto_unfollowing(cx_a: &mut TestAppContext, cx_b: &mut TestAppCont
    // When client B activates a different item in the original pane, it automatically stops following client A.
    workspace_b
        .update(cx_b, |workspace, cx| {
-            workspace.open_path((worktree_id, "2.txt"), None, true, cx)
+            workspace.open_path((worktree_id, "2.txt"), true, cx)
        })
        .await
        .unwrap();
@@ -5311,7 +5719,7 @@ async fn test_peers_simultaneously_following_each_other(
    cx_a.update(editor::init);
    cx_b.update(editor::init);

-    let mut server = TestServer::start(cx_a.background()).await;
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
    server
@@ -5381,7 +5789,7 @@ async fn test_random_collaboration(
        .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
        .unwrap_or(10);

-    let mut server = TestServer::start(cx.background()).await;
+    let mut server = TestServer::start(cx.foreground(), cx.background()).await;
    let db = server.app_state.db.clone();

    let mut available_guests = Vec::new();
@@ -5579,13 +5987,6 @@ async fn test_random_collaboration(
                                guest_client.username,
                                id
                            );
-                            assert_eq!(
-                                guest_snapshot.abs_path(),
-                                host_snapshot.abs_path(),
-                                "{} has different abs path than the host for worktree {}",
-                                guest_client.username,
-                                id
-                            );
                            assert_eq!(
                                guest_snapshot.entries(false).collect::<Vec<_>>(),
                                host_snapshot.entries(false).collect::<Vec<_>>(),
@@ -5675,6 +6076,8 @@ struct TestServer {
    peer: Arc<Peer>,
    app_state: Arc<AppState>,
    server: Arc<Server>,
+    foreground: Rc<executor::Foreground>,
+    notifications: mpsc::UnboundedReceiver<()>,
    connection_killers: Arc<Mutex<HashMap<PeerId, Arc<AtomicBool>>>>,
    forbid_connections: Arc<AtomicBool>,
    _test_db: TestDb,
@@ -5682,10 +6085,13 @@ struct TestServer {
 }

 impl TestServer {
-    async fn start(background: Arc<executor::Background>) -> Self {
+    async fn start(
+        foreground: Rc<executor::Foreground>,
+        background: Arc<executor::Background>,
+    ) -> Self {
        static NEXT_LIVE_KIT_SERVER_ID: AtomicUsize = AtomicUsize::new(0);

-        let test_db = TestDb::new(background.clone());
+        let test_db = TestDb::fake(background.clone());
        let live_kit_server_id = NEXT_LIVE_KIT_SERVER_ID.fetch_add(1, SeqCst);
        let live_kit_server = live_kit_client::TestServer::create(
            format!("http://livekit.{}.test", live_kit_server_id),
@@ -5696,11 +6102,14 @@ impl TestServer {
        .unwrap();
        let app_state = Self::build_app_state(&test_db, &live_kit_server).await;
        let peer = Peer::new();
-        let server = Server::new(app_state.clone());
+        let notifications = mpsc::unbounded();
+        let server = Server::new(app_state.clone(), Some(notifications.0));
        Self {
            peer,
            app_state,
            server,
+            foreground,
+            notifications: notifications.1,
            connection_killers: Default::default(),
            forbid_connections: Default::default(),
            _test_db: test_db,
@@ -5738,7 +6147,7 @@ impl TestServer {
                    },
                )
                .await
-                .expect("creating user failed")
+                .unwrap()
                .user_id
        };
        let client_name = name.to_string();
@@ -5778,11 +6187,7 @@ impl TestServer {
                        let (client_conn, server_conn, killed) =
                            Connection::in_memory(cx.background());
                        let (connection_id_tx, connection_id_rx) = oneshot::channel();
-                        let user = db
-                            .get_user_by_id(user_id)
-                            .await
-                            .expect("retrieving user failed")
-                            .unwrap();
+                        let user = db.get_user_by_id(user_id).await.unwrap().unwrap();
                        cx.background()
                            .spawn(server.handle_connection(
                                server_conn,
@@ -5816,6 +6221,7 @@ impl TestServer {
            default_item_factory: |_, _| unimplemented!(),
        });

+        Channel::init(&client);
        Project::init(&client);
        cx.update(|cx| {
            workspace::init(app_state.clone(), cx);
@@ -5916,6 +6322,21 @@ impl TestServer {
            config: Default::default(),
        })
    }
+
+    async fn condition<F>(&mut self, mut predicate: F)
+    where
+        F: FnMut(&Store) -> bool,
+    {
+        assert!(
+            self.foreground.parking_forbidden(),
+            "you must call forbid_parking to use server conditions so we don't block indefinitely"
+        );
+        while !(predicate)(&*self.server.store.lock().await) {
+            self.foreground.start_waiting();
+            self.notifications.next().await;
+            self.foreground.finish_waiting();
+        }
+    }
 }

 impl Deref for TestServer {
@@ -6631,6 +7052,20 @@ impl Executor for Arc<gpui::executor::Background> {
    }
 }

+fn channel_messages(channel: &Channel) -> Vec<(String, String, bool)> {
+    channel
+        .messages()
+        .cursor::<()>()
+        .map(|m| {
+            (
+                m.sender.github_login.clone(),
+                m.body.clone(),
+                m.is_pending(),
+            )
+        })
+        .collect()
+}
+
 #[derive(Debug, Eq, PartialEq)]
 struct RoomParticipants {
    remote: Vec<String>,
--- a/crates/collab/src/main.rs
+++ b/crates/collab/src/main.rs
@@ -13,12 +13,12 @@ use crate::rpc::ResultExt as _;
 use anyhow::anyhow;
 use axum::{routing::get, Router};
 use collab::{Error, Result};
-use db::DefaultDb as Db;
+use db::{Db, PostgresDb};
 use serde::Deserialize;
 use std::{
    env::args,
    net::{SocketAddr, TcpListener},
-    path::{Path, PathBuf},
+    path::PathBuf,
    sync::Arc,
    time::Duration,
 };
@@ -49,14 +49,14 @@ pub struct MigrateConfig {
 }

 pub struct AppState {
-    db: Arc<Db>,
+    db: Arc<dyn Db>,
    live_kit_client: Option<Arc<dyn live_kit_server::api::Client>>,
    config: Config,
 }

 impl AppState {
    async fn new(config: Config) -> Result<Arc<Self>> {
-        let db = Db::new(&config.database_url, 5).await?;
+        let db = PostgresDb::new(&config.database_url, 5).await?;
        let live_kit_client = if let Some(((server, key), secret)) = config
            .live_kit_server
            .as_ref()
@@ -96,12 +96,13 @@ async fn main() -> Result<()> {
        }
        Some("migrate") => {
            let config = envy::from_env::<MigrateConfig>().expect("error loading config");
-            let db = Db::new(&config.database_url, 5).await?;
+            let db = PostgresDb::new(&config.database_url, 5).await?;

            let migrations_path = config
                .migrations_path
                .as_deref()
-                .unwrap_or_else(|| Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/migrations")));
+                .or(db::DEFAULT_MIGRATIONS_PATH.map(|s| s.as_ref()))
+                .ok_or_else(|| anyhow!("missing MIGRATIONS_PATH environment variable"))?;

            let migrations = db.migrate(&migrations_path, false).await?;
            for (migration, duration) in migrations {
@@ -121,7 +122,9 @@ async fn main() -> Result<()> {
            let listener = TcpListener::bind(&format!("0.0.0.0:{}", state.config.http_port))
                .expect("failed to bind TCP listener");

-            let rpc_server = rpc::Server::new(state.clone());
+            let rpc_server = rpc::Server::new(state.clone(), None);
+            rpc_server
+                .start_recording_project_activity(Duration::from_secs(5 * 60), rpc::RealExecutor);

            let app = api::routes(rpc_server.clone(), state.clone())
                .merge(rpc::routes(rpc_server.clone()))
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -2,7 +2,7 @@ mod store;

 use crate::{
    auth,
-    db::{self, ProjectId, User, UserId},
+    db::{self, ChannelId, MessageId, ProjectId, User, UserId},
    AppState, Result,
 };
 use anyhow::anyhow;
@@ -24,7 +24,7 @@ use axum::{
 };
 use collections::{HashMap, HashSet};
 use futures::{
-    channel::oneshot,
+    channel::{mpsc, oneshot},
    future::{self, BoxFuture},
    stream::FuturesUnordered,
    FutureExt, SinkExt, StreamExt, TryStreamExt,
@@ -42,6 +42,7 @@ use std::{
    marker::PhantomData,
    net::SocketAddr,
    ops::{Deref, DerefMut},
+    os::unix::prelude::OsStrExt,
    rc::Rc,
    sync::{
        atomic::{AtomicBool, Ordering::SeqCst},
@@ -50,6 +51,7 @@ use std::{
    time::Duration,
 };
 pub use store::{Store, Worktree};
+use time::OffsetDateTime;
 use tokio::{
    sync::{Mutex, MutexGuard},
    time::Sleep,
@@ -60,6 +62,10 @@ use tracing::{info_span, instrument, Instrument};
 lazy_static! {
    static ref METRIC_CONNECTIONS: IntGauge =
        register_int_gauge!("connections", "number of connections").unwrap();
+    static ref METRIC_REGISTERED_PROJECTS: IntGauge =
+        register_int_gauge!("registered_projects", "number of registered projects").unwrap();
+    static ref METRIC_ACTIVE_PROJECTS: IntGauge =
+        register_int_gauge!("active_projects", "number of active projects").unwrap();
    static ref METRIC_SHARED_PROJECTS: IntGauge = register_int_gauge!(
        "shared_projects",
        "number of open projects with one or more guests"
@@ -89,6 +95,7 @@ pub struct Server {
    pub(crate) store: Mutex<Store>,
    app_state: Arc<AppState>,
    handlers: HashMap<TypeId, MessageHandler>,
+    notifications: Option<mpsc::UnboundedSender<()>>,
 }

 pub trait Executor: Send + Clone {
@@ -100,6 +107,9 @@ pub trait Executor: Send + Clone {
 #[derive(Clone)]
 pub struct RealExecutor;

+const MESSAGE_COUNT_PER_PAGE: usize = 100;
+const MAX_MESSAGE_LEN: usize = 1024;
+
 pub(crate) struct StoreGuard<'a> {
    guard: MutexGuard<'a, Store>,
    _not_send: PhantomData<Rc<()>>,
@@ -122,12 +132,16 @@ where
 }

 impl Server {
-    pub fn new(app_state: Arc<AppState>) -> Arc<Self> {
+    pub fn new(
+        app_state: Arc<AppState>,
+        notifications: Option<mpsc::UnboundedSender<()>>,
+    ) -> Arc<Self> {
        let mut server = Self {
            peer: Peer::new(),
            app_state,
            store: Default::default(),
            handlers: Default::default(),
+            notifications,
        };

        server
@@ -144,7 +158,9 @@ impl Server {
            .add_request_handler(Server::join_project)
            .add_message_handler(Server::leave_project)
            .add_message_handler(Server::update_project)
+            .add_message_handler(Server::register_project_activity)
            .add_request_handler(Server::update_worktree)
+            .add_message_handler(Server::update_worktree_extensions)
            .add_message_handler(Server::start_language_server)
            .add_message_handler(Server::update_language_server)
            .add_message_handler(Server::update_diagnostic_summary)
@@ -178,14 +194,19 @@ impl Server {
            .add_message_handler(Server::buffer_reloaded)
            .add_message_handler(Server::buffer_saved)
            .add_request_handler(Server::save_buffer)
+            .add_request_handler(Server::get_channels)
            .add_request_handler(Server::get_users)
            .add_request_handler(Server::fuzzy_search_users)
            .add_request_handler(Server::request_contact)
            .add_request_handler(Server::remove_contact)
            .add_request_handler(Server::respond_to_contact_request)
+            .add_request_handler(Server::join_channel)
+            .add_message_handler(Server::leave_channel)
+            .add_request_handler(Server::send_channel_message)
            .add_request_handler(Server::follow)
            .add_message_handler(Server::unfollow)
            .add_message_handler(Server::update_followers)
+            .add_request_handler(Server::get_channel_messages)
            .add_message_handler(Server::update_diff_base)
            .add_request_handler(Server::get_private_user_info);

@@ -269,6 +290,58 @@ impl Server {
        })
    }

+    /// Start a long lived task that records which users are active in which projects.
+    pub fn start_recording_project_activity<E: 'static + Executor>(
+        self: &Arc<Self>,
+        interval: Duration,
+        executor: E,
+    ) {
+        executor.spawn_detached({
+            let this = Arc::downgrade(self);
+            let executor = executor.clone();
+            async move {
+                let mut period_start = OffsetDateTime::now_utc();
+                let mut active_projects = Vec::<(UserId, ProjectId)>::new();
+                loop {
+                    let sleep = executor.sleep(interval);
+                    sleep.await;
+                    let this = if let Some(this) = this.upgrade() {
+                        this
+                    } else {
+                        break;
+                    };
+
+                    active_projects.clear();
+                    active_projects.extend(this.store().await.projects().flat_map(
+                        |(project_id, project)| {
+                            project.guests.values().chain([&project.host]).filter_map(
+                                |collaborator| {
+                                    if !collaborator.admin
+                                        && collaborator
+                                            .last_activity
+                                            .map_or(false, |activity| activity > period_start)
+                                    {
+                                        Some((collaborator.user_id, *project_id))
+                                    } else {
+                                        None
+                                    }
+                                },
+                            )
+                        },
+                    ));
+
+                    let period_end = OffsetDateTime::now_utc();
+                    this.app_state
+                        .db
+                        .record_user_activity(period_start..period_end, &active_projects)
+                        .await
+                        .trace_err();
+                    period_start = period_end;
+                }
+            }
+        });
+    }
+
    pub fn handle_connection<E: Executor>(
        self: &Arc<Self>,
        connection: Connection,
@@ -359,11 +432,18 @@ impl Server {
                            let span = tracing::info_span!("receive message", %user_id, %login, %connection_id, %address, type_name);
                            let span_enter = span.enter();
                            if let Some(handler) = this.handlers.get(&message.payload_type_id()) {
+                                let notifications = this.notifications.clone();
                                let is_background = message.is_background();
                                let handle_message = (handler)(this.clone(), message);
-                                drop(span_enter);

-                                let handle_message = handle_message.instrument(span);
+                                drop(span_enter);
+                                let handle_message = async move {
+                                    handle_message.await;
+                                    if let Some(mut notifications) = notifications {
+                                        let _ = notifications.send(()).await;
+                                    }
+                                }.instrument(span);
+
                                if is_background {
                                    executor.spawn_detached(handle_message);
                                } else {
@@ -944,7 +1024,7 @@ impl Server {
                id: *id,
                root_name: worktree.root_name.clone(),
                visible: worktree.visible,
-                abs_path: worktree.abs_path.clone(),
+                abs_path: worktree.abs_path.as_os_str().as_bytes().to_vec(),
            })
            .collect::<Vec<_>>();

@@ -995,7 +1075,7 @@ impl Server {
            let message = proto::UpdateWorktree {
                project_id: project_id.to_proto(),
                worktree_id: *worktree_id,
-                abs_path: worktree.abs_path.clone(),
+                abs_path: worktree.abs_path.as_os_str().as_bytes().to_vec(),
                root_name: worktree.root_name.clone(),
                updated_entries: worktree.entries.values().cloned().collect(),
                removed_entries: Default::default(),
@@ -1092,6 +1172,17 @@ impl Server {
        Ok(())
    }

+    async fn register_project_activity(
+        self: Arc<Server>,
+        request: TypedEnvelope<proto::RegisterProjectActivity>,
+    ) -> Result<()> {
+        self.store().await.register_project_activity(
+            ProjectId::from_proto(request.payload.project_id),
+            request.sender_id,
+        )?;
+        Ok(())
+    }
+
    async fn update_worktree(
        self: Arc<Server>,
        request: TypedEnvelope<proto::UpdateWorktree>,
@@ -1104,7 +1195,6 @@ impl Server {
            project_id,
            worktree_id,
            &request.payload.root_name,
-            &request.payload.abs_path,
            &request.payload.removed_entries,
            &request.payload.updated_entries,
            request.payload.scan_id,
@@ -1119,6 +1209,25 @@ impl Server {
        Ok(())
    }

+    async fn update_worktree_extensions(
+        self: Arc<Server>,
+        request: TypedEnvelope<proto::UpdateWorktreeExtensions>,
+    ) -> Result<()> {
+        let project_id = ProjectId::from_proto(request.payload.project_id);
+        let worktree_id = request.payload.worktree_id;
+        let extensions = request
+            .payload
+            .extensions
+            .into_iter()
+            .zip(request.payload.counts)
+            .collect();
+        self.app_state
+            .db
+            .update_worktree_extensions(project_id, worktree_id, extensions)
+            .await?;
+        Ok(())
+    }
+
    async fn update_diagnostic_summary(
        self: Arc<Server>,
        request: TypedEnvelope<proto::UpdateDiagnosticSummary>,
@@ -1254,7 +1363,8 @@ impl Server {
    ) -> Result<()> {
        let project_id = ProjectId::from_proto(request.payload.project_id);
        let receiver_ids = {
-            let store = self.store().await;
+            let mut store = self.store().await;
+            store.register_project_activity(project_id, request.sender_id)?;
            store.project_connection_ids(project_id, request.sender_id)?
        };

@@ -1320,13 +1430,15 @@ impl Server {
        let leader_id = ConnectionId(request.payload.leader_id);
        let follower_id = request.sender_id;
        {
-            let store = self.store().await;
+            let mut store = self.store().await;
            if !store
                .project_connection_ids(project_id, follower_id)?
                .contains(&leader_id)
            {
                Err(anyhow!("no such peer"))?;
            }
+
+            store.register_project_activity(project_id, follower_id)?;
        }

        let mut response_payload = self
@@ -1343,13 +1455,14 @@ impl Server {
    async fn unfollow(self: Arc<Self>, request: TypedEnvelope<proto::Unfollow>) -> Result<()> {
        let project_id = ProjectId::from_proto(request.payload.project_id);
        let leader_id = ConnectionId(request.payload.leader_id);
-        let store = self.store().await;
+        let mut store = self.store().await;
        if !store
            .project_connection_ids(project_id, request.sender_id)?
            .contains(&leader_id)
        {
            Err(anyhow!("no such peer"))?;
        }
+        store.register_project_activity(project_id, request.sender_id)?;
        self.peer
            .forward_send(request.sender_id, leader_id, request.payload)?;
        Ok(())
@@ -1360,7 +1473,8 @@ impl Server {
        request: TypedEnvelope<proto::UpdateFollowers>,
    ) -> Result<()> {
        let project_id = ProjectId::from_proto(request.payload.project_id);
-        let store = self.store().await;
+        let mut store = self.store().await;
+        store.register_project_activity(project_id, request.sender_id)?;
        let connection_ids = store.project_connection_ids(project_id, request.sender_id)?;
        let leader_id = request
            .payload
@@ -1381,6 +1495,28 @@ impl Server {
        Ok(())
    }

+    async fn get_channels(
+        self: Arc<Server>,
+        request: TypedEnvelope<proto::GetChannels>,
+        response: Response<proto::GetChannels>,
+    ) -> Result<()> {
+        let user_id = self
+            .store()
+            .await
+            .user_id_for_connection(request.sender_id)?;
+        let channels = self.app_state.db.get_accessible_channels(user_id).await?;
+        response.send(proto::GetChannelsResponse {
+            channels: channels
+                .into_iter()
+                .map(|chan| proto::Channel {
+                    id: chan.id.to_proto(),
+                    name: chan.name,
+                })
+                .collect(),
+        })?;
+        Ok(())
+    }
+
    async fn get_users(
        self: Arc<Server>,
        request: TypedEnvelope<proto::GetUsers>,
@@ -1576,6 +1712,175 @@ impl Server {
        Ok(())
    }

+    async fn join_channel(
+        self: Arc<Self>,
+        request: TypedEnvelope<proto::JoinChannel>,
+        response: Response<proto::JoinChannel>,
+    ) -> Result<()> {
+        let user_id = self
+            .store()
+            .await
+            .user_id_for_connection(request.sender_id)?;
+        let channel_id = ChannelId::from_proto(request.payload.channel_id);
+        if !self
+            .app_state
+            .db
+            .can_user_access_channel(user_id, channel_id)
+            .await?
+        {
+            Err(anyhow!("access denied"))?;
+        }
+
+        self.store()
+            .await
+            .join_channel(request.sender_id, channel_id);
+        let messages = self
+            .app_state
+            .db
+            .get_channel_messages(channel_id, MESSAGE_COUNT_PER_PAGE, None)
+            .await?
+            .into_iter()
+            .map(|msg| proto::ChannelMessage {
+                id: msg.id.to_proto(),
+                body: msg.body,
+                timestamp: msg.sent_at.unix_timestamp() as u64,
+                sender_id: msg.sender_id.to_proto(),
+                nonce: Some(msg.nonce.as_u128().into()),
+            })
+            .collect::<Vec<_>>();
+        response.send(proto::JoinChannelResponse {
+            done: messages.len() < MESSAGE_COUNT_PER_PAGE,
+            messages,
+        })?;
+        Ok(())
+    }
+
+    async fn leave_channel(
+        self: Arc<Self>,
+        request: TypedEnvelope<proto::LeaveChannel>,
+    ) -> Result<()> {
+        let user_id = self
+            .store()
+            .await
+            .user_id_for_connection(request.sender_id)?;
+        let channel_id = ChannelId::from_proto(request.payload.channel_id);
+        if !self
+            .app_state
+            .db
+            .can_user_access_channel(user_id, channel_id)
+            .await?
+        {
+            Err(anyhow!("access denied"))?;
+        }
+
+        self.store()
+            .await
+            .leave_channel(request.sender_id, channel_id);
+
+        Ok(())
+    }
+
+    async fn send_channel_message(
+        self: Arc<Self>,
+        request: TypedEnvelope<proto::SendChannelMessage>,
+        response: Response<proto::SendChannelMessage>,
+    ) -> Result<()> {
+        let channel_id = ChannelId::from_proto(request.payload.channel_id);
+        let user_id;
+        let connection_ids;
+        {
+            let state = self.store().await;
+            user_id = state.user_id_for_connection(request.sender_id)?;
+            connection_ids = state.channel_connection_ids(channel_id)?;
+        }
+
+        // Validate the message body.
+        let body = request.payload.body.trim().to_string();
+        if body.len() > MAX_MESSAGE_LEN {
+            return Err(anyhow!("message is too long"))?;
+        }
+        if body.is_empty() {
+            return Err(anyhow!("message can't be blank"))?;
+        }
+
+        let timestamp = OffsetDateTime::now_utc();
+        let nonce = request
+            .payload
+            .nonce
+            .ok_or_else(|| anyhow!("nonce can't be blank"))?;
+
+        let message_id = self
+            .app_state
+            .db
+            .create_channel_message(channel_id, user_id, &body, timestamp, nonce.clone().into())
+            .await?
+            .to_proto();
+        let message = proto::ChannelMessage {
+            sender_id: user_id.to_proto(),
+            id: message_id,
+            body,
+            timestamp: timestamp.unix_timestamp() as u64,
+            nonce: Some(nonce),
+        };
+        broadcast(request.sender_id, connection_ids, |conn_id| {
+            self.peer.send(
+                conn_id,
+                proto::ChannelMessageSent {
+                    channel_id: channel_id.to_proto(),
+                    message: Some(message.clone()),
+                },
+            )
+        });
+        response.send(proto::SendChannelMessageResponse {
+            message: Some(message),
+        })?;
+        Ok(())
+    }
+
+    async fn get_channel_messages(
+        self: Arc<Self>,
+        request: TypedEnvelope<proto::GetChannelMessages>,
+        response: Response<proto::GetChannelMessages>,
+    ) -> Result<()> {
+        let user_id = self
+            .store()
+            .await
+            .user_id_for_connection(request.sender_id)?;
+        let channel_id = ChannelId::from_proto(request.payload.channel_id);
+        if !self
+            .app_state
+            .db
+            .can_user_access_channel(user_id, channel_id)
+            .await?
+        {
+            Err(anyhow!("access denied"))?;
+        }
+
+        let messages = self
+            .app_state
+            .db
+            .get_channel_messages(
+                channel_id,
+                MESSAGE_COUNT_PER_PAGE,
+                Some(MessageId::from_proto(request.payload.before_message_id)),
+            )
+            .await?
+            .into_iter()
+            .map(|msg| proto::ChannelMessage {
+                id: msg.id.to_proto(),
+                body: msg.body,
+                timestamp: msg.sent_at.unix_timestamp() as u64,
+                sender_id: msg.sender_id.to_proto(),
+                nonce: Some(msg.nonce.as_u128().into()),
+            })
+            .collect::<Vec<_>>();
+        response.send(proto::GetChannelMessagesResponse {
+            done: messages.len() < MESSAGE_COUNT_PER_PAGE,
+            messages,
+        })?;
+        Ok(())
+    }
+
    async fn update_diff_base(
        self: Arc<Server>,
        request: TypedEnvelope<proto::UpdateDiffBase>,
@@ -1756,8 +2061,11 @@ pub async fn handle_websocket_request(
 }

 pub async fn handle_metrics(Extension(server): Extension<Arc<Server>>) -> axum::response::Response {
+    // We call `store_mut` here for its side effects of updating metrics.
    let metrics = server.store().await.metrics();
    METRIC_CONNECTIONS.set(metrics.connections as _);
+    METRIC_REGISTERED_PROJECTS.set(metrics.registered_projects as _);
+    METRIC_ACTIVE_PROJECTS.set(metrics.active_projects as _);
    METRIC_SHARED_PROJECTS.set(metrics.shared_projects as _);

    let encoder = prometheus::TextEncoder::new();
--- a/crates/collab/src/rpc/store.rs
+++ b/crates/collab/src/rpc/store.rs
@@ -1,10 +1,11 @@
-use crate::db::{self, ProjectId, UserId};
+use crate::db::{self, ChannelId, ProjectId, UserId};
 use anyhow::{anyhow, Result};
 use collections::{btree_map, BTreeMap, BTreeSet, HashMap, HashSet};
 use nanoid::nanoid;
 use rpc::{proto, ConnectionId};
 use serde::Serialize;
-use std::{borrow::Cow, mem, path::PathBuf, str};
+use std::{borrow::Cow, mem, path::PathBuf, str, time::Duration};
+use time::OffsetDateTime;
 use tracing::instrument;
 use util::post_inc;

@@ -17,6 +18,8 @@ pub struct Store {
    next_room_id: RoomId,
    rooms: BTreeMap<RoomId, proto::Room>,
    projects: BTreeMap<ProjectId, Project>,
+    #[serde(skip)]
+    channels: BTreeMap<ChannelId, Channel>,
 }

 #[derive(Default, Serialize)]
@@ -30,6 +33,7 @@ struct ConnectionState {
    user_id: UserId,
    admin: bool,
    projects: BTreeSet<ProjectId>,
+    channels: HashSet<ChannelId>,
 }

 #[derive(Copy, Clone, Eq, PartialEq, Serialize)]
@@ -56,12 +60,14 @@ pub struct Project {
 pub struct Collaborator {
    pub replica_id: ReplicaId,
    pub user_id: UserId,
+    #[serde(skip)]
+    pub last_activity: Option<OffsetDateTime>,
    pub admin: bool,
 }

 #[derive(Default, Serialize)]
 pub struct Worktree {
-    pub abs_path: Vec<u8>,
+    pub abs_path: PathBuf,
    pub root_name: String,
    pub visible: bool,
    #[serde(skip)]
@@ -72,6 +78,11 @@ pub struct Worktree {
    pub is_complete: bool,
 }

+#[derive(Default)]
+pub struct Channel {
+    pub connection_ids: HashSet<ConnectionId>,
+}
+
 pub type ReplicaId = u16;

 #[derive(Default)]
@@ -102,23 +113,38 @@ pub struct LeftRoom<'a> {
 #[derive(Copy, Clone)]
 pub struct Metrics {
    pub connections: usize,
+    pub registered_projects: usize,
+    pub active_projects: usize,
    pub shared_projects: usize,
 }

 impl Store {
    pub fn metrics(&self) -> Metrics {
+        const ACTIVE_PROJECT_TIMEOUT: Duration = Duration::from_secs(60);
+        let active_window_start = OffsetDateTime::now_utc() - ACTIVE_PROJECT_TIMEOUT;
+
        let connections = self.connections.values().filter(|c| !c.admin).count();
+        let mut registered_projects = 0;
+        let mut active_projects = 0;
        let mut shared_projects = 0;
        for project in self.projects.values() {
            if let Some(connection) = self.connections.get(&project.host_connection_id) {
                if !connection.admin {
-                    shared_projects += 1;
+                    registered_projects += 1;
+                    if project.is_active_since(active_window_start) {
+                        active_projects += 1;
+                        if !project.guests.is_empty() {
+                            shared_projects += 1;
+                        }
+                    }
                }
            }
        }

        Metrics {
            connections,
+            registered_projects,
+            active_projects,
            shared_projects,
        }
    }
@@ -136,6 +162,7 @@ impl Store {
                user_id,
                admin,
                projects: Default::default(),
+                channels: Default::default(),
            },
        );
        let connected_user = self.connected_users.entry(user_id).or_default();
@@ -174,12 +201,18 @@ impl Store {
            .ok_or_else(|| anyhow!("no such connection"))?;

        let user_id = connection.user_id;
+        let connection_channels = mem::take(&mut connection.channels);

        let mut result = RemovedConnectionState {
            user_id,
            ..Default::default()
        };

+        // Leave all channels.
+        for channel_id in connection_channels {
+            self.leave_channel(connection_id, channel_id);
+        }
+
        let connected_user = self.connected_users.get(&user_id).unwrap();
        if let Some(active_call) = connected_user.active_call.as_ref() {
            let room_id = active_call.room_id;
@@ -205,6 +238,34 @@ impl Store {
        Ok(result)
    }

+    #[cfg(test)]
+    pub fn channel(&self, id: ChannelId) -> Option<&Channel> {
+        self.channels.get(&id)
+    }
+
+    pub fn join_channel(&mut self, connection_id: ConnectionId, channel_id: ChannelId) {
+        if let Some(connection) = self.connections.get_mut(&connection_id) {
+            connection.channels.insert(channel_id);
+            self.channels
+                .entry(channel_id)
+                .or_default()
+                .connection_ids
+                .insert(connection_id);
+        }
+    }
+
+    pub fn leave_channel(&mut self, connection_id: ConnectionId, channel_id: ChannelId) {
+        if let Some(connection) = self.connections.get_mut(&connection_id) {
+            connection.channels.remove(&channel_id);
+            if let btree_map::Entry::Occupied(mut entry) = self.channels.entry(channel_id) {
+                entry.get_mut().connection_ids.remove(&connection_id);
+                if entry.get_mut().connection_ids.is_empty() {
+                    entry.remove();
+                }
+            }
+        }
+    }
+
    pub fn user_id_for_connection(&self, connection_id: ConnectionId) -> Result<UserId> {
        Ok(self
            .connections
@@ -699,6 +760,7 @@ impl Store {
                host: Collaborator {
                    user_id: connection.user_id,
                    replica_id: 0,
+                    last_activity: None,
                    admin: connection.admin,
                },
                guests: Default::default(),
@@ -711,11 +773,7 @@ impl Store {
                            Worktree {
                                root_name: worktree.root_name,
                                visible: worktree.visible,
-                                abs_path: worktree.abs_path.clone(),
-                                entries: Default::default(),
-                                diagnostic_summaries: Default::default(),
-                                scan_id: Default::default(),
-                                is_complete: Default::default(),
+                                ..Default::default()
                            },
                        )
                    })
@@ -794,11 +852,7 @@ impl Store {
                        Worktree {
                            root_name: worktree.root_name.clone(),
                            visible: worktree.visible,
-                            abs_path: worktree.abs_path.clone(),
-                            entries: Default::default(),
-                            diagnostic_summaries: Default::default(),
-                            scan_id: Default::default(),
-                            is_complete: false,
+                            ..Default::default()
                        },
                    );
                }
@@ -905,10 +959,12 @@ impl Store {
            Collaborator {
                replica_id,
                user_id: connection.user_id,
+                last_activity: Some(OffsetDateTime::now_utc()),
                admin: connection.admin,
            },
        );

+        project.host.last_activity = Some(OffsetDateTime::now_utc());
        Ok((project, replica_id))
    }

@@ -950,7 +1006,6 @@ impl Store {
        project_id: ProjectId,
        worktree_id: u64,
        worktree_root_name: &str,
-        worktree_abs_path: &[u8],
        removed_entries: &[u64],
        updated_entries: &[proto::Entry],
        scan_id: u64,
@@ -961,7 +1016,6 @@ impl Store {
        let connection_ids = project.connection_ids();
        let mut worktree = project.worktrees.entry(worktree_id).or_default();
        worktree.root_name = worktree_root_name.to_string();
-        worktree.abs_path = worktree_abs_path.to_vec();

        for entry_id in removed_entries {
            worktree.entries.remove(entry_id);
@@ -1002,12 +1056,44 @@ impl Store {
            .connection_ids())
    }

+    pub fn channel_connection_ids(&self, channel_id: ChannelId) -> Result<Vec<ConnectionId>> {
+        Ok(self
+            .channels
+            .get(&channel_id)
+            .ok_or_else(|| anyhow!("no such channel"))?
+            .connection_ids())
+    }
+
    pub fn project(&self, project_id: ProjectId) -> Result<&Project> {
        self.projects
            .get(&project_id)
            .ok_or_else(|| anyhow!("no such project"))
    }

+    pub fn register_project_activity(
+        &mut self,
+        project_id: ProjectId,
+        connection_id: ConnectionId,
+    ) -> Result<()> {
+        let project = self
+            .projects
+            .get_mut(&project_id)
+            .ok_or_else(|| anyhow!("no such project"))?;
+        let collaborator = if connection_id == project.host_connection_id {
+            &mut project.host
+        } else if let Some(guest) = project.guests.get_mut(&connection_id) {
+            guest
+        } else {
+            return Err(anyhow!("no such project"))?;
+        };
+        collaborator.last_activity = Some(OffsetDateTime::now_utc());
+        Ok(())
+    }
+
+    pub fn projects(&self) -> impl Iterator<Item = (&ProjectId, &Project)> {
+        self.projects.iter()
+    }
+
    pub fn read_project(
        &self,
        project_id: ProjectId,
@@ -1068,7 +1154,10 @@ impl Store {
                    }
                }
            }
-
+            for channel_id in &connection.channels {
+                let channel = self.channels.get(channel_id).unwrap();
+                assert!(channel.connection_ids.contains(connection_id));
+            }
            assert!(self
                .connected_users
                .get(&connection.user_id)
@@ -1164,10 +1253,28 @@ impl Store {
                "project was not shared in room"
            );
        }
+
+        for (channel_id, channel) in &self.channels {
+            for connection_id in &channel.connection_ids {
+                let connection = self.connections.get(connection_id).unwrap();
+                assert!(connection.channels.contains(channel_id));
+            }
+        }
    }
 }

 impl Project {
+    fn is_active_since(&self, start_time: OffsetDateTime) -> bool {
+        self.guests
+            .values()
+            .chain([&self.host])
+            .any(|collaborator| {
+                collaborator
+                    .last_activity
+                    .map_or(false, |active_time| active_time > start_time)
+            })
+    }
+
    pub fn guest_connection_ids(&self) -> Vec<ConnectionId> {
        self.guests.keys().copied().collect()
    }
@@ -1180,3 +1287,9 @@ impl Project {
            .collect()
    }
 }
+
+impl Channel {
+    fn connection_ids(&self) -> Vec<ConnectionId> {
+        self.connection_ids.iter().copied().collect()
+    }
+}
--- a/crates/collab_ui/src/contact_finder.rs
+++ b/crates/collab_ui/src/contact_finder.rs
@@ -170,8 +170,8 @@ impl ContactFinder {
        let this = cx.weak_handle();
        Self {
            picker: cx.add_view(|cx| {
-                Picker::new("Search collaborator by username...", this, cx)
-                    .with_theme(|theme| theme.contact_finder.picker.clone())
+                Picker::new(this, cx)
+                    .with_theme(|cx| &cx.global::<Settings>().theme.contact_finder.picker)
            }),
            potential_contacts: Arc::from([]),
            user_store,
--- a/crates/collab_ui/src/contact_list.rs
+++ b/crates/collab_ui/src/contact_list.rs
@@ -175,9 +175,7 @@ impl ContactList {
    ) -> Self {
        let filter_editor = cx.add_view(|cx| {
            let mut editor = Editor::single_line(
-                Some(Arc::new(|theme| {
-                    theme.contact_list.user_query_editor.clone()
-                })),
+                Some(|theme| theme.contact_list.user_query_editor.clone()),
                cx,
            );
            editor.set_placeholder_text("Filter contacts", cx);
--- a/crates/command_palette/src/command_palette.rs
+++ b/crates/command_palette/src/command_palette.rs
@@ -70,7 +70,7 @@ impl CommandPalette {
            })
            .collect();

-        let picker = cx.add_view(|cx| Picker::new("Execute a command...", this, cx));
+        let picker = cx.add_view(|cx| Picker::new(this, cx));
        Self {
            picker,
            actions,
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -452,7 +452,7 @@ impl ProjectDiagnosticsEditor {
            } else {
                groups = self.path_states.get(path_ix)?.diagnostic_groups.as_slice();
                new_excerpt_ids_by_selection_id =
-                    editor.change_selections(Some(Autoscroll::fit()), cx, |s| s.refresh());
+                    editor.change_selections(Some(Autoscroll::Fit), cx, |s| s.refresh());
                selections = editor.selections.all::<usize>(cx);
            }

--- a/crates/drag_and_drop/Cargo.toml
+++ b/crates/drag_and_drop/Cargo.toml
@@ -12,4 +12,4 @@ collections = { path = "../collections" }
 gpui = { path = "../gpui" }

 [dev-dependencies]
-gpui = { path = "../gpui", features = ["test-support"] }
+gpui = { path = "../gpui", features = ["test-support"] }
--- a/crates/drag_and_drop/src/drag_and_drop.rs
+++ b/crates/drag_and_drop/src/drag_and_drop.rs
@@ -2,55 +2,29 @@ use std::{any::Any, rc::Rc};

 use collections::HashSet;
 use gpui::{
-    elements::{Empty, MouseEventHandler, Overlay},
-    geometry::{rect::RectF, vector::Vector2F},
-    scene::{MouseDown, MouseDrag},
+    elements::{MouseEventHandler, Overlay},
+    geometry::vector::Vector2F,
+    scene::MouseDrag,
    CursorStyle, Element, ElementBox, EventContext, MouseButton, MutableAppContext, RenderContext,
    View, WeakViewHandle,
 };

-enum State<V: View> {
-    Down {
-        region_offset: Vector2F,
-        region: RectF,
-    },
-    Dragging {
-        window_id: usize,
-        position: Vector2F,
-        region_offset: Vector2F,
-        region: RectF,
-        payload: Rc<dyn Any + 'static>,
-        render: Rc<dyn Fn(Rc<dyn Any>, &mut RenderContext<V>) -> ElementBox>,
-    },
-    Canceled,
+struct State<V: View> {
+    window_id: usize,
+    position: Vector2F,
+    region_offset: Vector2F,
+    payload: Rc<dyn Any + 'static>,
+    render: Rc<dyn Fn(Rc<dyn Any>, &mut RenderContext<V>) -> ElementBox>,
 }

 impl<V: View> Clone for State<V> {
    fn clone(&self) -> Self {
-        match self {
-            &State::Down {
-                region_offset,
-                region,
-            } => State::Down {
-                region_offset,
-                region,
-            },
-            State::Dragging {
-                window_id,
-                position,
-                region_offset,
-                region,
-                payload,
-                render,
-            } => Self::Dragging {
-                window_id: window_id.clone(),
-                position: position.clone(),
-                region_offset: region_offset.clone(),
-                region: region.clone(),
-                payload: payload.clone(),
-                render: render.clone(),
-            },
-            State::Canceled => State::Canceled,
+        Self {
+            window_id: self.window_id.clone(),
+            position: self.position.clone(),
+            region_offset: self.region_offset.clone(),
+            payload: self.payload.clone(),
+            render: self.render.clone(),
        }
    }
 }
@@ -75,36 +49,24 @@ impl<V: View> DragAndDrop<V> {
    }

    pub fn currently_dragged<T: Any>(&self, window_id: usize) -> Option<(Vector2F, Rc<T>)> {
-        self.currently_dragged.as_ref().and_then(|state| {
-            if let State::Dragging {
-                position,
-                payload,
-                window_id: window_dragged_from,
-                ..
-            } = state
-            {
+        self.currently_dragged.as_ref().and_then(
+            |State {
+                 position,
+                 payload,
+                 window_id: window_dragged_from,
+                 ..
+             }| {
                if &window_id != window_dragged_from {
                    return None;
                }

                payload
-                    .is::<T>()
-                    .then(|| payload.clone().downcast::<T>().ok())
-                    .flatten()
+                    .clone()
+                    .downcast::<T>()
+                    .ok()
                    .map(|payload| (position.clone(), payload))
-            } else {
-                None
-            }
-        })
-    }
-
-    pub fn drag_started(event: MouseDown, cx: &mut EventContext) {
-        cx.update_global(|this: &mut Self, _| {
-            this.currently_dragged = Some(State::Down {
-                region_offset: event.region.origin() - event.position,
-                region: event.region,
-            });
-        })
+            },
+        )
    }

    pub fn dragging<T: Any>(
@@ -114,132 +76,75 @@ impl<V: View> DragAndDrop<V> {
        render: Rc<impl 'static + Fn(&T, &mut RenderContext<V>) -> ElementBox>,
    ) {
        let window_id = cx.window_id();
-        cx.update_global(|this: &mut Self, cx| {
-            this.notify_containers_for_window(window_id, cx);
+        cx.update_global::<Self, _, _>(|this, cx| {
+            let region_offset = if let Some(previous_state) = this.currently_dragged.as_ref() {
+                previous_state.region_offset
+            } else {
+                event.region.origin() - event.prev_mouse_position
+            };

-            match this.currently_dragged.as_ref() {
-                Some(&State::Down {
-                    region_offset,
-                    region,
-                })
-                | Some(&State::Dragging {
-                    region_offset,
-                    region,
-                    ..
-                }) => {
-                    this.currently_dragged = Some(State::Dragging {
-                        window_id,
-                        region_offset,
-                        region,
-                        position: event.position,
-                        payload,
-                        render: Rc::new(move |payload, cx| {
-                            render(payload.downcast_ref::<T>().unwrap(), cx)
-                        }),
-                    });
-                }
-                _ => {}
-            }
+            this.currently_dragged = Some(State {
+                window_id,
+                region_offset,
+                position: event.position,
+                payload,
+                render: Rc::new(move |payload, cx| {
+                    render(payload.downcast_ref::<T>().unwrap(), cx)
+                }),
+            });
+
+            this.notify_containers_for_window(window_id, cx);
        });
    }

    pub fn render(cx: &mut RenderContext<V>) -> Option<ElementBox> {
-        enum DraggedElementHandler {}
-        cx.global::<Self>()
-            .currently_dragged
-            .clone()
-            .and_then(|state| {
-                match state {
-                    State::Down { .. } => None,
-                    State::Dragging {
-                        window_id,
-                        region_offset,
-                        position,
-                        region,
-                        payload,
-                        render,
-                    } => {
-                        if cx.window_id() != window_id {
-                            return None;
-                        }
+        let currently_dragged = cx.global::<Self>().currently_dragged.clone();

-                        let position = position + region_offset;
-                        Some(
-                            Overlay::new(
-                                MouseEventHandler::<DraggedElementHandler>::new(0, cx, |_, cx| {
-                                    render(payload, cx)
-                                })
-                                .with_cursor_style(CursorStyle::Arrow)
-                                .on_up(MouseButton::Left, |_, cx| {
-                                    cx.defer(|cx| {
-                                        cx.update_global::<Self, _, _>(|this, cx| {
-                                            this.finish_dragging(cx)
-                                        });
-                                    });
-                                    cx.propagate_event();
-                                })
-                                .on_up_out(MouseButton::Left, |_, cx| {
-                                    cx.defer(|cx| {
-                                        cx.update_global::<Self, _, _>(|this, cx| {
-                                            this.finish_dragging(cx)
-                                        });
-                                    });
-                                })
-                                // Don't block hover events or invalidations
-                                .with_hoverable(false)
-                                .constrained()
-                                .with_width(region.width())
-                                .with_height(region.height())
-                                .boxed(),
-                            )
-                            .with_anchor_position(position)
-                            .boxed(),
-                        )
-                    }
+        currently_dragged.and_then(
+            |State {
+                 window_id,
+                 region_offset,
+                 position,
+                 payload,
+                 render,
+             }| {
+                if cx.window_id() != window_id {
+                    return None;
+                }

-                    State::Canceled => Some(
-                        MouseEventHandler::<DraggedElementHandler>::new(0, cx, |_, _| {
-                            Empty::new()
-                                .constrained()
-                                .with_width(0.)
-                                .with_height(0.)
-                                .boxed()
+                let position = position + region_offset;
+
+                enum DraggedElementHandler {}
+                Some(
+                    Overlay::new(
+                        MouseEventHandler::<DraggedElementHandler>::new(0, cx, |_, cx| {
+                            render(payload, cx)
                        })
+                        .with_cursor_style(CursorStyle::Arrow)
                        .on_up(MouseButton::Left, |_, cx| {
                            cx.defer(|cx| {
-                                cx.update_global::<Self, _, _>(|this, _| {
-                                    this.currently_dragged = None;
-                                });
+                                cx.update_global::<Self, _, _>(|this, cx| this.stop_dragging(cx));
                            });
+                            cx.propagate_event();
                        })
                        .on_up_out(MouseButton::Left, |_, cx| {
                            cx.defer(|cx| {
-                                cx.update_global::<Self, _, _>(|this, _| {
-                                    this.currently_dragged = None;
-                                });
+                                cx.update_global::<Self, _, _>(|this, cx| this.stop_dragging(cx));
                            });
                        })
+                        // Don't block hover events or invalidations
+                        .with_hoverable(false)
                        .boxed(),
-                    ),
-                }
-            })
+                    )
+                    .with_anchor_position(position)
+                    .boxed(),
+                )
+            },
+        )
    }

-    pub fn cancel_dragging<P: Any>(&mut self, cx: &mut MutableAppContext) {
-        if let Some(State::Dragging {
-            payload, window_id, ..
-        }) = &self.currently_dragged
-        {
-            if payload.is::<P>() {
-                let window_id = *window_id;
-                self.currently_dragged = Some(State::Canceled);
-                self.notify_containers_for_window(window_id, cx);
-            }
-        }
-    }
-
-    fn finish_dragging(&mut self, cx: &mut MutableAppContext) {
-        if let Some(State::Dragging { window_id, .. }) = self.currently_dragged.take() {
+    fn stop_dragging(&mut self, cx: &mut MutableAppContext) {
+        if let Some(State { window_id, .. }) = self.currently_dragged.take() {
            self.notify_containers_for_window(window_id, cx);
        }
    }
@@ -279,11 +184,7 @@ impl<Tag> Draggable for MouseEventHandler<Tag> {
    {
        let payload = Rc::new(payload);
        let render = Rc::new(render);
-        self.on_down(MouseButton::Left, move |e, cx| {
-            cx.propagate_event();
-            DragAndDrop::<V>::drag_started(e, cx);
-        })
-        .on_drag(MouseButton::Left, move |e, cx| {
+        self.on_drag(MouseButton::Left, move |e, cx| {
            let payload = payload.clone();
            let render = render.clone();
            DragAndDrop::<V>::dragging(e, payload, cx, render)
--- a/crates/editor/src/blink_manager.rs
+++ b/crates/editor/src/blink_manager.rs
@@ -93,9 +93,6 @@ impl BlinkManager {

    pub fn enable(&mut self, cx: &mut ModelContext<Self>) {
        self.enabled = true;
-        // Set cursors as invisible and start blinking: this causes cursors
-        // to be visible during the next render.
-        self.visible = false;
        self.blink_cursors(self.blink_epoch, cx);
    }

--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -73,7 +73,6 @@ use std::{
    mem,
    num::NonZeroU32,
    ops::{Deref, DerefMut, Range, RangeInclusive},
-    path::Path,
    sync::Arc,
    time::{Duration, Instant},
 };
@@ -188,7 +187,7 @@ actions!(
        Paste,
        Undo,
        Redo,
-        NextScreen,
+        CenterScreen,
        MoveUp,
        PageUp,
        MoveDown,
@@ -308,8 +307,7 @@ pub fn init(cx: &mut MutableAppContext) {
    cx.add_action(Editor::move_down);
    cx.add_action(Editor::move_page_down);
    cx.add_action(Editor::page_down);
-    cx.add_action(Editor::next_screen);
-
+    cx.add_action(Editor::center_screen);
    cx.add_action(Editor::move_left);
    cx.add_action(Editor::move_right);
    cx.add_action(Editor::move_to_previous_word_start);
@@ -411,42 +409,9 @@ pub enum SelectMode {

 #[derive(PartialEq, Eq)]
 pub enum Autoscroll {
-    Next,
-    Strategy(AutoscrollStrategy),
-}
-
-impl Autoscroll {
-    pub fn fit() -> Self {
-        Self::Strategy(AutoscrollStrategy::Fit)
-    }
-
-    pub fn newest() -> Self {
-        Self::Strategy(AutoscrollStrategy::Newest)
-    }
-
-    pub fn center() -> Self {
-        Self::Strategy(AutoscrollStrategy::Center)
-    }
-}
-
-#[derive(PartialEq, Eq, Default)]
-pub enum AutoscrollStrategy {
    Fit,
-    Newest,
-    #[default]
    Center,
-    Top,
-    Bottom,
-}
-
-impl AutoscrollStrategy {
-    fn next(&self) -> Self {
-        match self {
-            AutoscrollStrategy::Center => AutoscrollStrategy::Top,
-            AutoscrollStrategy::Top => AutoscrollStrategy::Bottom,
-            _ => AutoscrollStrategy::Center,
-        }
-    }
+    Newest,
 }

 #[derive(Copy, Clone, PartialEq, Eq)]
@@ -472,7 +437,8 @@ pub struct EditorStyle {

 type CompletionId = usize;

-type GetFieldEditorTheme = dyn Fn(&theme::Theme) -> theme::FieldEditor;
+pub type GetFieldEditorTheme = fn(&theme::Theme) -> theme::FieldEditor;
+
 type OverrideTextStyle = dyn Fn(&EditorStyle) -> Option<HighlightStyle>;

 #[derive(Clone, Copy)]
@@ -557,7 +523,7 @@ pub struct Editor {
    scroll_top_anchor: Anchor,
    autoscroll_request: Option<(Autoscroll, bool)>,
    soft_wrap_mode_override: Option<settings::SoftWrap>,
-    get_field_editor_theme: Option<Arc<GetFieldEditorTheme>>,
+    get_field_editor_theme: Option<GetFieldEditorTheme>,
    override_text_style: Option<Box<OverrideTextStyle>>,
    project: Option<ModelHandle<Project>>,
    focused: bool,
@@ -588,7 +554,6 @@ pub struct Editor {
    hover_state: HoverState,
    link_go_to_definition_state: LinkGoToDefinitionState,
    visible_line_count: Option<f32>,
-    last_autoscroll: Option<(Vector2F, f32, f32, AutoscrollStrategy)>,
    _subscriptions: Vec<Subscription>,
 }

@@ -1105,7 +1070,7 @@ enum GotoDefinitionKind {

 impl Editor {
    pub fn single_line(
-        field_editor_style: Option<Arc<GetFieldEditorTheme>>,
+        field_editor_style: Option<GetFieldEditorTheme>,
        cx: &mut ViewContext<Self>,
    ) -> Self {
        let buffer = cx.add_model(|cx| Buffer::new(0, String::new(), cx));
@@ -1115,7 +1080,7 @@ impl Editor {

    pub fn auto_height(
        max_lines: usize,
-        field_editor_style: Option<Arc<GetFieldEditorTheme>>,
+        field_editor_style: Option<GetFieldEditorTheme>,
        cx: &mut ViewContext<Self>,
    ) -> Self {
        let buffer = cx.add_model(|cx| Buffer::new(0, String::new(), cx));
@@ -1151,7 +1116,7 @@ impl Editor {
            self.mode,
            self.buffer.clone(),
            self.project.clone(),
-            self.get_field_editor_theme.clone(),
+            self.get_field_editor_theme,
            cx,
        );
        self.display_map.update(cx, |display_map, cx| {
@@ -1171,12 +1136,12 @@ impl Editor {
        mode: EditorMode,
        buffer: ModelHandle<MultiBuffer>,
        project: Option<ModelHandle<Project>>,
-        get_field_editor_theme: Option<Arc<GetFieldEditorTheme>>,
+        get_field_editor_theme: Option<GetFieldEditorTheme>,
        cx: &mut ViewContext<Self>,
    ) -> Self {
        let display_map = cx.add_model(|cx| {
            let settings = cx.global::<Settings>();
-            let style = build_style(&*settings, get_field_editor_theme.as_deref(), None, cx);
+            let style = build_style(&*settings, get_field_editor_theme, None, cx);
            DisplayMap::new(
                buffer.clone(),
                style.text.font_id,
@@ -1241,7 +1206,6 @@ impl Editor {
            hover_state: Default::default(),
            link_go_to_definition_state: Default::default(),
            visible_line_count: None,
-            last_autoscroll: None,
            _subscriptions: vec![
                cx.observe(&buffer, Self::on_buffer_changed),
                cx.subscribe(&buffer, Self::on_buffer_event),
@@ -1325,7 +1289,7 @@ impl Editor {
    fn style(&self, cx: &AppContext) -> EditorStyle {
        build_style(
            cx.global::<Settings>(),
-            self.get_field_editor_theme.as_deref(),
+            self.get_field_editor_theme,
            self.override_text_style.as_deref(),
            cx,
        )
@@ -1472,7 +1436,7 @@ impl Editor {
        if let Some(highlighted_rows) = &self.highlighted_rows {
            first_cursor_top = highlighted_rows.start as f32;
            last_cursor_bottom = first_cursor_top + 1.;
-        } else if autoscroll == Autoscroll::newest() {
+        } else if autoscroll == Autoscroll::Newest {
            let newest_selection = self.selections.newest::<Point>(cx);
            first_cursor_top = newest_selection.head().to_display_point(&display_map).row() as f32;
            last_cursor_bottom = first_cursor_top + 1.;
@@ -1502,27 +1466,8 @@ impl Editor {
            return false;
        }

-        let strategy = match autoscroll {
-            Autoscroll::Strategy(strategy) => strategy,
-            Autoscroll::Next => {
-                let last_autoscroll = &self.last_autoscroll;
-                if let Some(last_autoscroll) = last_autoscroll {
-                    if self.scroll_position == last_autoscroll.0
-                        && first_cursor_top == last_autoscroll.1
-                        && last_cursor_bottom == last_autoscroll.2
-                    {
-                        last_autoscroll.3.next()
-                    } else {
-                        AutoscrollStrategy::default()
-                    }
-                } else {
-                    AutoscrollStrategy::default()
-                }
-            }
-        };
-
-        match strategy {
-            AutoscrollStrategy::Fit | AutoscrollStrategy::Newest => {
+        match autoscroll {
+            Autoscroll::Fit | Autoscroll::Newest => {
                let margin = margin.min(self.vertical_scroll_margin);
                let target_top = (first_cursor_top - margin).max(0.0);
                let target_bottom = last_cursor_bottom + margin;
@@ -1537,27 +1482,12 @@ impl Editor {
                    self.set_scroll_position_internal(scroll_position, local, cx);
                }
            }
-            AutoscrollStrategy::Center => {
+            Autoscroll::Center => {
                scroll_position.set_y((first_cursor_top - margin).max(0.0));
                self.set_scroll_position_internal(scroll_position, local, cx);
            }
-            AutoscrollStrategy::Top => {
-                scroll_position.set_y((first_cursor_top).max(0.0));
-                self.set_scroll_position_internal(scroll_position, local, cx);
-            }
-            AutoscrollStrategy::Bottom => {
-                scroll_position.set_y((last_cursor_bottom - visible_lines).max(0.0));
-                self.set_scroll_position_internal(scroll_position, local, cx);
-            }
        }

-        self.last_autoscroll = Some((
-            self.scroll_position,
-            first_cursor_top,
-            last_cursor_bottom,
-            strategy,
-        ));
-
        true
    }

@@ -1805,7 +1735,7 @@ impl Editor {
            _ => {}
        }

-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.set_pending(pending_selection, pending_mode)
        });
    }
@@ -1866,7 +1796,7 @@ impl Editor {
            }
        }

-        self.change_selections(auto_scroll.then(|| Autoscroll::newest()), cx, |s| {
+        self.change_selections(auto_scroll.then(|| Autoscroll::Newest), cx, |s| {
            if !add {
                s.clear_disjoint();
            } else if click_count > 1 {
@@ -2083,7 +2013,7 @@ impl Editor {
                return;
            }

-            if self.change_selections(Some(Autoscroll::fit()), cx, |s| s.try_cancel()) {
+            if self.change_selections(Some(Autoscroll::Fit), cx, |s| s.try_cancel()) {
                return;
            }
        }
@@ -2249,7 +2179,7 @@ impl Editor {
            }

            drop(snapshot);
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| s.select(new_selections));
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| s.select(new_selections));
            this.trigger_completion_on_input(&text, cx);
        });
    }
@@ -2329,7 +2259,7 @@ impl Editor {
                })
                .collect();

-            this.change_selections(Some(Autoscroll::fit()), cx, |s| s.select(new_selections));
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| s.select(new_selections));
        });
    }

@@ -2359,7 +2289,7 @@ impl Editor {
        self.transact(cx, |editor, cx| {
            editor.edit_with_autoindent(edits, cx);

-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                let mut index = 0;
                s.move_cursors_with(|map, _, _| {
                    let row = rows[index];
@@ -2400,7 +2330,7 @@ impl Editor {
                anchors
            });

-            this.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.select_anchors(selection_anchors);
            })
        });
@@ -3096,7 +3026,7 @@ impl Editor {
        });

        if let Some(tabstop) = tabstops.first() {
-            self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            self.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.select_ranges(tabstop.iter().cloned());
            });
            self.snippet_stack.push(SnippetState {
@@ -3137,7 +3067,7 @@ impl Editor {
                }
            }
            if let Some(current_ranges) = snippet.ranges.get(snippet.active_index) {
-                self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                self.change_selections(Some(Autoscroll::Fit), cx, |s| {
                    s.select_anchor_ranges(current_ranges.iter().cloned())
                });
                // If snippet state is not at the last tabstop, push it back on the stack
@@ -3202,14 +3132,14 @@ impl Editor {
                }
            }

-            this.change_selections(Some(Autoscroll::fit()), cx, |s| s.select(selections));
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| s.select(selections));
            this.insert("", cx);
        });
    }

    pub fn delete(&mut self, _: &Delete, cx: &mut ViewContext<Self>) {
        self.transact(cx, |this, cx| {
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| {
                let line_mode = s.line_mode;
                s.move_with(|map, selection| {
                    if selection.is_empty() && !line_mode {
@@ -3303,7 +3233,7 @@ impl Editor {

        self.transact(cx, |this, cx| {
            this.buffer.update(cx, |b, cx| b.edit(edits, None, cx));
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| s.select(selections))
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| s.select(selections))
        });
    }

@@ -3326,7 +3256,7 @@ impl Editor {

        self.transact(cx, |this, cx| {
            this.buffer.update(cx, |b, cx| b.edit(edits, None, cx));
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| s.select(selections));
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| s.select(selections));
        });
    }

@@ -3458,7 +3388,7 @@ impl Editor {
                );
            });
            let selections = this.selections.all::<usize>(cx);
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| s.select(selections));
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| s.select(selections));
        });
    }

@@ -3538,7 +3468,7 @@ impl Editor {
                })
                .collect();

-            this.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.select(new_selections);
            });
        });
@@ -3580,7 +3510,7 @@ impl Editor {
                buffer.edit(edits, None, cx);
            });

-            this.request_autoscroll(Autoscroll::fit(), cx);
+            this.request_autoscroll(Autoscroll::Fit, cx);
        });
    }

@@ -3690,7 +3620,7 @@ impl Editor {
                }
            });
            this.fold_ranges(refold_ranges, cx);
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.select(new_selections);
            })
        });
@@ -3795,13 +3725,13 @@ impl Editor {
                }
            });
            this.fold_ranges(refold_ranges, cx);
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| s.select(new_selections));
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| s.select(new_selections));
        });
    }

    pub fn transpose(&mut self, _: &Transpose, cx: &mut ViewContext<Self>) {
        self.transact(cx, |this, cx| {
-            let edits = this.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            let edits = this.change_selections(Some(Autoscroll::Fit), cx, |s| {
                let mut edits: Vec<(Range<usize>, String)> = Default::default();
                let line_mode = s.line_mode;
                s.move_with(|display_map, selection| {
@@ -3845,7 +3775,7 @@ impl Editor {
            this.buffer
                .update(cx, |buffer, cx| buffer.edit(edits, None, cx));
            let selections = this.selections.all::<usize>(cx);
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.select(selections);
            });
        });
@@ -3879,7 +3809,7 @@ impl Editor {
        }

        self.transact(cx, |this, cx| {
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.select(selections);
            });
            this.insert("", cx);
@@ -3994,7 +3924,7 @@ impl Editor {
                    });

                    let selections = this.selections.all::<usize>(cx);
-                    this.change_selections(Some(Autoscroll::fit()), cx, |s| s.select(selections));
+                    this.change_selections(Some(Autoscroll::Fit), cx, |s| s.select(selections));
                } else {
                    this.insert(&clipboard_text, cx);
                }
@@ -4009,7 +3939,7 @@ impl Editor {
                    s.select_anchors(selections.to_vec());
                });
            }
-            self.request_autoscroll(Autoscroll::fit(), cx);
+            self.request_autoscroll(Autoscroll::Fit, cx);
            self.unmark_text(cx);
            cx.emit(Event::Edited);
        }
@@ -4023,7 +3953,7 @@ impl Editor {
                    s.select_anchors(selections.to_vec());
                });
            }
-            self.request_autoscroll(Autoscroll::fit(), cx);
+            self.request_autoscroll(Autoscroll::Fit, cx);
            self.unmark_text(cx);
            cx.emit(Event::Edited);
        }
@@ -4035,7 +3965,7 @@ impl Editor {
    }

    pub fn move_left(&mut self, _: &MoveLeft, cx: &mut ViewContext<Self>) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            let line_mode = s.line_mode;
            s.move_with(|map, selection| {
                let cursor = if selection.is_empty() && !line_mode {
@@ -4049,13 +3979,13 @@ impl Editor {
    }

    pub fn select_left(&mut self, _: &SelectLeft, cx: &mut ViewContext<Self>) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_heads_with(|map, head, _| (movement::left(map, head), SelectionGoal::None));
        })
    }

    pub fn move_right(&mut self, _: &MoveRight, cx: &mut ViewContext<Self>) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            let line_mode = s.line_mode;
            s.move_with(|map, selection| {
                let cursor = if selection.is_empty() && !line_mode {
@@ -4069,12 +3999,12 @@ impl Editor {
    }

    pub fn select_right(&mut self, _: &SelectRight, cx: &mut ViewContext<Self>) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_heads_with(|map, head, _| (movement::right(map, head), SelectionGoal::None));
        })
    }

-    pub fn next_screen(&mut self, _: &NextScreen, cx: &mut ViewContext<Editor>) {
+    pub fn center_screen(&mut self, _: &CenterScreen, cx: &mut ViewContext<Self>) {
        if self.take_rename(true, cx).is_some() {
            return;
        }
@@ -4088,7 +4018,7 @@ impl Editor {
            return;
        }

-        self.request_autoscroll(Autoscroll::Next, cx);
+        self.request_autoscroll(Autoscroll::Center, cx);
    }

    pub fn move_up(&mut self, _: &MoveUp, cx: &mut ViewContext<Self>) {
@@ -4107,7 +4037,7 @@ impl Editor {
            return;
        }

-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            let line_mode = s.line_mode;
            s.move_with(|map, selection| {
                if !selection.is_empty() && !line_mode {
@@ -4141,9 +4071,9 @@ impl Editor {
        };

        let autoscroll = if action.center_cursor {
-            Autoscroll::center()
+            Autoscroll::Center
        } else {
-            Autoscroll::fit()
+            Autoscroll::Fit
        };

        self.change_selections(Some(autoscroll), cx, |s| {
@@ -4186,7 +4116,7 @@ impl Editor {
    }

    pub fn select_up(&mut self, _: &SelectUp, cx: &mut ViewContext<Self>) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_heads_with(|map, head, goal| movement::up(map, head, goal, false))
        })
    }
@@ -4205,7 +4135,7 @@ impl Editor {
            return;
        }

-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            let line_mode = s.line_mode;
            s.move_with(|map, selection| {
                if !selection.is_empty() && !line_mode {
@@ -4239,9 +4169,9 @@ impl Editor {
        };

        let autoscroll = if action.center_cursor {
-            Autoscroll::center()
+            Autoscroll::Center
        } else {
-            Autoscroll::fit()
+            Autoscroll::Fit
        };

        self.change_selections(Some(autoscroll), cx, |s| {
@@ -4284,7 +4214,7 @@ impl Editor {
    }

    pub fn select_down(&mut self, _: &SelectDown, cx: &mut ViewContext<Self>) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_heads_with(|map, head, goal| movement::down(map, head, goal, false))
        });
    }
@@ -4294,7 +4224,7 @@ impl Editor {
        _: &MoveToPreviousWordStart,
        cx: &mut ViewContext<Self>,
    ) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_cursors_with(|map, head, _| {
                (
                    movement::previous_word_start(map, head),
@@ -4309,7 +4239,7 @@ impl Editor {
        _: &MoveToPreviousSubwordStart,
        cx: &mut ViewContext<Self>,
    ) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_cursors_with(|map, head, _| {
                (
                    movement::previous_subword_start(map, head),
@@ -4324,7 +4254,7 @@ impl Editor {
        _: &SelectToPreviousWordStart,
        cx: &mut ViewContext<Self>,
    ) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_heads_with(|map, head, _| {
                (
                    movement::previous_word_start(map, head),
@@ -4339,7 +4269,7 @@ impl Editor {
        _: &SelectToPreviousSubwordStart,
        cx: &mut ViewContext<Self>,
    ) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_heads_with(|map, head, _| {
                (
                    movement::previous_subword_start(map, head),
@@ -4356,7 +4286,7 @@ impl Editor {
    ) {
        self.transact(cx, |this, cx| {
            this.select_autoclose_pair(cx);
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| {
                let line_mode = s.line_mode;
                s.move_with(|map, selection| {
                    if selection.is_empty() && !line_mode {
@@ -4376,7 +4306,7 @@ impl Editor {
    ) {
        self.transact(cx, |this, cx| {
            this.select_autoclose_pair(cx);
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| {
                let line_mode = s.line_mode;
                s.move_with(|map, selection| {
                    if selection.is_empty() && !line_mode {
@@ -4390,7 +4320,7 @@ impl Editor {
    }

    pub fn move_to_next_word_end(&mut self, _: &MoveToNextWordEnd, cx: &mut ViewContext<Self>) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_cursors_with(|map, head, _| {
                (movement::next_word_end(map, head), SelectionGoal::None)
            });
@@ -4402,7 +4332,7 @@ impl Editor {
        _: &MoveToNextSubwordEnd,
        cx: &mut ViewContext<Self>,
    ) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_cursors_with(|map, head, _| {
                (movement::next_subword_end(map, head), SelectionGoal::None)
            });
@@ -4410,7 +4340,7 @@ impl Editor {
    }

    pub fn select_to_next_word_end(&mut self, _: &SelectToNextWordEnd, cx: &mut ViewContext<Self>) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_heads_with(|map, head, _| {
                (movement::next_word_end(map, head), SelectionGoal::None)
            });
@@ -4422,7 +4352,7 @@ impl Editor {
        _: &SelectToNextSubwordEnd,
        cx: &mut ViewContext<Self>,
    ) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_heads_with(|map, head, _| {
                (movement::next_subword_end(map, head), SelectionGoal::None)
            });
@@ -4431,7 +4361,7 @@ impl Editor {

    pub fn delete_to_next_word_end(&mut self, _: &DeleteToNextWordEnd, cx: &mut ViewContext<Self>) {
        self.transact(cx, |this, cx| {
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| {
                let line_mode = s.line_mode;
                s.move_with(|map, selection| {
                    if selection.is_empty() && !line_mode {
@@ -4450,7 +4380,7 @@ impl Editor {
        cx: &mut ViewContext<Self>,
    ) {
        self.transact(cx, |this, cx| {
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.move_with(|map, selection| {
                    if selection.is_empty() {
                        let cursor = movement::next_subword_end(map, selection.head());
@@ -4467,7 +4397,7 @@ impl Editor {
        _: &MoveToBeginningOfLine,
        cx: &mut ViewContext<Self>,
    ) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_cursors_with(|map, head, _| {
                (
                    movement::indented_line_beginning(map, head, true),
@@ -4482,7 +4412,7 @@ impl Editor {
        action: &SelectToBeginningOfLine,
        cx: &mut ViewContext<Self>,
    ) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_heads_with(|map, head, _| {
                (
                    movement::indented_line_beginning(map, head, action.stop_at_soft_wraps),
@@ -4498,7 +4428,7 @@ impl Editor {
        cx: &mut ViewContext<Self>,
    ) {
        self.transact(cx, |this, cx| {
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.move_with(|_, selection| {
                    selection.reversed = true;
                });
@@ -4515,7 +4445,7 @@ impl Editor {
    }

    pub fn move_to_end_of_line(&mut self, _: &MoveToEndOfLine, cx: &mut ViewContext<Self>) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_cursors_with(|map, head, _| {
                (movement::line_end(map, head, true), SelectionGoal::None)
            });
@@ -4527,7 +4457,7 @@ impl Editor {
        action: &SelectToEndOfLine,
        cx: &mut ViewContext<Self>,
    ) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_heads_with(|map, head, _| {
                (
                    movement::line_end(map, head, action.stop_at_soft_wraps),
@@ -4567,7 +4497,7 @@ impl Editor {
            return;
        }

-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.select_ranges(vec![0..0]);
        });
    }
@@ -4576,7 +4506,7 @@ impl Editor {
        let mut selection = self.selections.last::<Point>(cx);
        selection.set_head(Point::zero(), SelectionGoal::None);

-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.select(vec![selection]);
        });
    }
@@ -4588,7 +4518,7 @@ impl Editor {
        }

        let cursor = self.buffer.read(cx).read(cx).len();
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.select_ranges(vec![cursor..cursor])
        });
    }
@@ -4637,14 +4567,14 @@ impl Editor {
        let buffer = self.buffer.read(cx).snapshot(cx);
        let mut selection = self.selections.first::<usize>(cx);
        selection.set_head(buffer.len(), SelectionGoal::None);
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.select(vec![selection]);
        });
    }

    pub fn select_all(&mut self, _: &SelectAll, cx: &mut ViewContext<Self>) {
        let end = self.buffer.read(cx).read(cx).len();
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.select_ranges(vec![0..end]);
        });
    }
@@ -4659,7 +4589,7 @@ impl Editor {
            selection.end = cmp::min(max_point, Point::new(rows.end, 0));
            selection.reversed = false;
        }
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.select(selections);
        });
    }
@@ -4684,7 +4614,7 @@ impl Editor {
            }
        }
        self.unfold_ranges(to_unfold, true, cx);
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.select_ranges(new_selection_ranges);
        });
    }
@@ -4784,7 +4714,7 @@ impl Editor {
            state.stack.pop();
        }

-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.select(new_selections);
        });
        if state.stack.len() > 1 {
@@ -4833,7 +4763,7 @@ impl Editor {

                if let Some(next_selected_range) = next_selected_range {
                    self.unfold_ranges([next_selected_range.clone()], false, cx);
-                    self.change_selections(Some(Autoscroll::newest()), cx, |s| {
+                    self.change_selections(Some(Autoscroll::Newest), cx, |s| {
                        if action.replace_newest {
                            s.delete(s.newest_anchor().id);
                        }
@@ -4866,7 +4796,7 @@ impl Editor {
                    done: false,
                };
                self.unfold_ranges([selection.start..selection.end], false, cx);
-                self.change_selections(Some(Autoscroll::newest()), cx, |s| {
+                self.change_selections(Some(Autoscroll::Newest), cx, |s| {
                    s.select(selections);
                });
                self.select_next_state = Some(select_state);
@@ -5099,7 +5029,7 @@ impl Editor {
            }

            drop(snapshot);
-            this.change_selections(Some(Autoscroll::fit()), cx, |s| s.select(selections));
+            this.change_selections(Some(Autoscroll::Fit), cx, |s| s.select(selections));
        });
    }

@@ -5143,7 +5073,7 @@ impl Editor {

        if selected_larger_node {
            stack.push(old_selections);
-            self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            self.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.select(new_selections);
            });
        }
@@ -5157,7 +5087,7 @@ impl Editor {
    ) {
        let mut stack = mem::take(&mut self.select_larger_syntax_node_stack);
        if let Some(selections) = stack.pop() {
-            self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            self.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.select(selections.to_vec());
            });
        }
@@ -5188,7 +5118,7 @@ impl Editor {
            }
        }

-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.select(selections);
        });
    }
@@ -5200,7 +5130,7 @@ impl Editor {
            self.change_selections(None, cx, |s| s.select_anchors(entry.selections.to_vec()));
            self.select_next_state = entry.select_next_state;
            self.add_selections_state = entry.add_selections_state;
-            self.request_autoscroll(Autoscroll::newest(), cx);
+            self.request_autoscroll(Autoscroll::Newest, cx);
        }
        self.selection_history.mode = SelectionHistoryMode::Normal;
    }
@@ -5212,7 +5142,7 @@ impl Editor {
            self.change_selections(None, cx, |s| s.select_anchors(entry.selections.to_vec()));
            self.select_next_state = entry.select_next_state;
            self.add_selections_state = entry.add_selections_state;
-            self.request_autoscroll(Autoscroll::newest(), cx);
+            self.request_autoscroll(Autoscroll::Newest, cx);
        }
        self.selection_history.mode = SelectionHistoryMode::Normal;
    }
@@ -5234,7 +5164,7 @@ impl Editor {
            if let Some(popover) = self.hover_state.diagnostic_popover.as_ref() {
                let (group_id, jump_to) = popover.activation_info();
                if self.activate_diagnostics(group_id, cx) {
-                    self.change_selections(Some(Autoscroll::center()), cx, |s| {
+                    self.change_selections(Some(Autoscroll::Center), cx, |s| {
                        let mut new_selection = s.newest_anchor().clone();
                        new_selection.collapse_to(jump_to, SelectionGoal::None);
                        s.select_anchors(vec![new_selection.clone()]);
@@ -5280,7 +5210,7 @@ impl Editor {

            if let Some((primary_range, group_id)) = group {
                if self.activate_diagnostics(group_id, cx) {
-                    self.change_selections(Some(Autoscroll::center()), cx, |s| {
+                    self.change_selections(Some(Autoscroll::Center), cx, |s| {
                        s.select(vec![Selection {
                            id: selection.id,
                            start: primary_range.start,
@@ -5355,7 +5285,7 @@ impl Editor {
                .dedup();

            if let Some(hunk) = hunks.next() {
-                this.change_selections(Some(Autoscroll::center()), cx, |s| {
+                this.change_selections(Some(Autoscroll::Center), cx, |s| {
                    let row = hunk.start_display_row();
                    let point = DisplayPoint::new(row, 0);
                    s.select_display_ranges([point..point]);
@@ -5453,7 +5383,7 @@ impl Editor {
                if editor_handle != target_editor_handle {
                    pane.update(cx, |pane, _| pane.disable_history());
                }
-                target_editor.change_selections(Some(Autoscroll::center()), cx, |s| {
+                target_editor.change_selections(Some(Autoscroll::Center), cx, |s| {
                    s.select_ranges([range]);
                });

@@ -6075,7 +6005,7 @@ impl Editor {
        let mut ranges = ranges.into_iter().peekable();
        if ranges.peek().is_some() {
            self.display_map.update(cx, |map, cx| map.fold(ranges, cx));
-            self.request_autoscroll(Autoscroll::fit(), cx);
+            self.request_autoscroll(Autoscroll::Fit, cx);
            cx.notify();
        }
    }
@@ -6090,7 +6020,7 @@ impl Editor {
        if ranges.peek().is_some() {
            self.display_map
                .update(cx, |map, cx| map.unfold(ranges, inclusive, cx));
-            self.request_autoscroll(Autoscroll::fit(), cx);
+            self.request_autoscroll(Autoscroll::Fit, cx);
            cx.notify();
        }
    }
@@ -6103,7 +6033,7 @@ impl Editor {
        let blocks = self
            .display_map
            .update(cx, |display_map, cx| display_map.insert_blocks(blocks, cx));
-        self.request_autoscroll(Autoscroll::fit(), cx);
+        self.request_autoscroll(Autoscroll::Fit, cx);
        blocks
    }

@@ -6114,7 +6044,7 @@ impl Editor {
    ) {
        self.display_map
            .update(cx, |display_map, _| display_map.replace_blocks(blocks));
-        self.request_autoscroll(Autoscroll::fit(), cx);
+        self.request_autoscroll(Autoscroll::Fit, cx);
    }

    pub fn remove_blocks(&mut self, block_ids: HashSet<BlockId>, cx: &mut ViewContext<Self>) {
@@ -6454,7 +6384,7 @@ impl Editor {
            for (buffer, ranges) in new_selections_by_buffer.into_iter() {
                let editor = workspace.open_project_item::<Self>(buffer, cx);
                editor.update(cx, |editor, cx| {
-                    editor.change_selections(Some(Autoscroll::newest()), cx, |s| {
+                    editor.change_selections(Some(Autoscroll::Newest), cx, |s| {
                        s.select_ranges(ranges);
                    });
                });
@@ -6465,7 +6395,7 @@ impl Editor {
    }

    fn jump(workspace: &mut Workspace, action: &Jump, cx: &mut ViewContext<Workspace>) {
-        let editor = workspace.open_path(action.path.clone(), None, true, cx);
+        let editor = workspace.open_path(action.path.clone(), true, cx);
        let position = action.position;
        let anchor = action.anchor;
        cx.spawn_weak(|_, mut cx| async move {
@@ -6480,7 +6410,7 @@ impl Editor {
                };

                let nav_history = editor.nav_history.take();
-                editor.change_selections(Some(Autoscroll::newest()), cx, |s| {
+                editor.change_selections(Some(Autoscroll::Newest), cx, |s| {
                    s.select_ranges([cursor..cursor]);
                });
                editor.nav_history = nav_history;
@@ -6537,13 +6467,15 @@ impl Editor {
                .as_singleton()
                .and_then(|b| b.read(cx).file()),
        ) {
-            let extension = Path::new(file.file_name(cx))
-                .extension()
-                .and_then(|e| e.to_str());
-            project
-                .read(cx)
-                .client()
-                .report_event(name, json!({ "File Extension": extension }));
+            project.read(cx).client().report_event(
+                name,
+                json!({
+                    "File Extension": file
+                        .path()
+                        .extension()
+                        .and_then(|e| e.to_str())
+                }),
+            );
        }
    }
 }
@@ -6914,7 +6846,7 @@ impl View for Editor {

 fn build_style(
    settings: &Settings,
-    get_field_editor_theme: Option<&GetFieldEditorTheme>,
+    get_field_editor_theme: Option<GetFieldEditorTheme>,
    override_text_style: Option<&OverrideTextStyle>,
    cx: &AppContext,
 ) -> EditorStyle {
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -4146,26 +4146,14 @@ async fn test_completion(cx: &mut gpui::TestAppContext) {

    handle_resolve_completion_request(
        &mut cx,
-        Some(vec![
-            (
-                //This overlaps with the primary completion edit which is
-                //misbehavior from the LSP spec, test that we filter it out
-                indoc! {"
-                    one.second_ˇcompletion
-                    two
-                    threeˇ
-                "},
-                "overlapping aditional edit",
-            ),
-            (
-                indoc! {"
-                    one.second_completion
-                    two
-                    threeˇ
-                "},
-                "\nadditional edit",
-            ),
-        ]),
+        Some((
+            indoc! {"
+                one.second_completion
+                two
+                threeˇ
+            "},
+            "\nadditional edit",
+        )),
    )
    .await;
    apply_additional_edits.await.unwrap();
@@ -4315,24 +4303,19 @@ async fn test_completion(cx: &mut gpui::TestAppContext) {

    async fn handle_resolve_completion_request<'a>(
        cx: &mut EditorLspTestContext<'a>,
-        edits: Option<Vec<(&'static str, &'static str)>>,
+        edit: Option<(&'static str, &'static str)>,
    ) {
-        let edits = edits.map(|edits| {
-            edits
-                .iter()
-                .map(|(marked_string, new_text)| {
-                    let (_, marked_ranges) = marked_text_ranges(marked_string, false);
-                    let replace_range = cx.to_lsp_range(marked_ranges[0].clone());
-                    lsp::TextEdit::new(replace_range, new_text.to_string())
-                })
-                .collect::<Vec<_>>()
+        let edit = edit.map(|(marked_string, new_text)| {
+            let (_, marked_ranges) = marked_text_ranges(marked_string, false);
+            let replace_range = cx.to_lsp_range(marked_ranges[0].clone());
+            vec![lsp::TextEdit::new(replace_range, new_text.to_string())]
        });

        cx.handle_request::<lsp::request::ResolveCompletionItem, _, _>(move |_, _, _| {
-            let edits = edits.clone();
+            let edit = edit.clone();
            async move {
                Ok(lsp::CompletionItem {
-                    additional_text_edits: edits,
+                    additional_text_edits: edit,
                    ..Default::default()
                })
            }
@@ -5028,7 +5011,7 @@ fn test_following(cx: &mut gpui::MutableAppContext) {
    // Update the selections and scroll position
    leader.update(cx, |leader, cx| {
        leader.change_selections(None, cx, |s| s.select_ranges([0..0]));
-        leader.request_autoscroll(Autoscroll::newest(), cx);
+        leader.request_autoscroll(Autoscroll::Newest, cx);
        leader.set_scroll_position(vec2f(1.5, 3.5), cx);
    });
    follower.update(cx, |follower, cx| {
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -192,14 +192,8 @@ impl EditorElement {
                .on_scroll({
                    let position_map = position_map.clone();
                    move |e, cx| {
-                        if !Self::scroll(
-                            e.position,
-                            *e.delta.raw(),
-                            e.delta.precise(),
-                            &position_map,
-                            bounds,
-                            cx,
-                        ) {
+                        if !Self::scroll(e.position, e.delta, e.precise, &position_map, bounds, cx)
+                        {
                            cx.propagate_event()
                        }
                    }
@@ -1192,7 +1186,7 @@ impl EditorElement {
        }

        // When the editor is empty and unfocused, then show the placeholder.
-        if snapshot.is_empty() {
+        if snapshot.is_empty() && !snapshot.is_focused() {
            let placeholder_style = self
                .style
                .placeholder_text
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -204,7 +204,7 @@ impl FollowableItem for Editor {

                if !selections.is_empty() {
                    self.set_selections_from_remote(selections, cx);
-                    self.request_autoscroll_remotely(Autoscroll::newest(), cx);
+                    self.request_autoscroll_remotely(Autoscroll::Newest, cx);
                } else if let Some(anchor) = message.scroll_top_anchor {
                    self.set_scroll_top_anchor(
                        Anchor {
@@ -294,7 +294,7 @@ impl Item for Editor {
                let nav_history = self.nav_history.take();
                self.scroll_position = data.scroll_position;
                self.scroll_top_anchor = scroll_top_anchor;
-                self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                self.change_selections(Some(Autoscroll::Fit), cx, |s| {
                    s.select_ranges([offset..offset])
                });
                self.nav_history = nav_history;
@@ -466,7 +466,7 @@ impl Item for Editor {
        cx.spawn(|this, mut cx| async move {
            let transaction = reload_buffers.log_err().await;
            this.update(&mut cx, |editor, cx| {
-                editor.request_autoscroll(Autoscroll::fit(), cx)
+                editor.request_autoscroll(Autoscroll::Fit, cx)
            });
            buffer.update(&mut cx, |buffer, _| {
                if let Some(transaction) = transaction {
@@ -619,7 +619,7 @@ impl SearchableItem for Editor {
        cx: &mut ViewContext<Self>,
    ) {
        self.unfold_ranges([matches[index].clone()], false, cx);
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        self.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.select_ranges([matches[index].clone()])
        });
    }
@@ -819,20 +819,11 @@ impl StatusItemView for CursorPosition {

 fn path_for_buffer<'a>(
    buffer: &ModelHandle<MultiBuffer>,
-    height: usize,
-    include_filename: bool,
-    cx: &'a AppContext,
-) -> Option<Cow<'a, Path>> {
-    let file = buffer.read(cx).as_singleton()?.read(cx).file()?;
-    path_for_file(file, height, include_filename, cx)
-}
-
-fn path_for_file<'a>(
-    file: &'a dyn language::File,
    mut height: usize,
    include_filename: bool,
    cx: &'a AppContext,
 ) -> Option<Cow<'a, Path>> {
+    let file = buffer.read(cx).as_singleton()?.read(cx).file()?;
    // Ensure we always render at least the filename.
    height += 1;

@@ -854,82 +845,13 @@ fn path_for_file<'a>(
        if include_filename {
            Some(full_path.into())
        } else {
-            Some(full_path.parent()?.to_path_buf().into())
+            Some(full_path.parent().unwrap().to_path_buf().into())
        }
    } else {
-        let mut path = file.path().strip_prefix(prefix).ok()?;
+        let mut path = file.path().strip_prefix(prefix).unwrap();
        if !include_filename {
-            path = path.parent()?;
+            path = path.parent().unwrap();
        }
        Some(path.into())
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use gpui::MutableAppContext;
-    use std::{
-        path::{Path, PathBuf},
-        sync::Arc,
-    };
-
-    #[gpui::test]
-    fn test_path_for_file(cx: &mut MutableAppContext) {
-        let file = TestFile {
-            path: Path::new("").into(),
-            full_path: PathBuf::from(""),
-        };
-        assert_eq!(path_for_file(&file, 0, false, cx), None);
-    }
-
-    struct TestFile {
-        path: Arc<Path>,
-        full_path: PathBuf,
-    }
-
-    impl language::File for TestFile {
-        fn path(&self) -> &Arc<Path> {
-            &self.path
-        }
-
-        fn full_path(&self, _: &gpui::AppContext) -> PathBuf {
-            self.full_path.clone()
-        }
-
-        fn as_local(&self) -> Option<&dyn language::LocalFile> {
-            todo!()
-        }
-
-        fn mtime(&self) -> std::time::SystemTime {
-            todo!()
-        }
-
-        fn file_name<'a>(&'a self, _: &'a gpui::AppContext) -> &'a std::ffi::OsStr {
-            todo!()
-        }
-
-        fn is_deleted(&self) -> bool {
-            todo!()
-        }
-
-        fn save(
-            &self,
-            _: u64,
-            _: language::Rope,
-            _: clock::Global,
-            _: project::LineEnding,
-            _: &mut MutableAppContext,
-        ) -> gpui::Task<anyhow::Result<(clock::Global, String, std::time::SystemTime)>> {
-            todo!()
-        }
-
-        fn as_any(&self) -> &dyn std::any::Any {
-            todo!()
-        }
-
-        fn to_proto(&self) -> rpc::proto::File {
-            todo!()
-        }
-    }
-}
--- a/crates/editor/src/link_go_to_definition.rs
+++ b/crates/editor/src/link_go_to_definition.rs
@@ -811,7 +811,7 @@ mod tests {
            let snapshot = editor.buffer().read(cx).snapshot(cx);
            let anchor_range = snapshot.anchor_before(selection_range.start)
                ..snapshot.anchor_after(selection_range.end);
-            editor.change_selections(Some(crate::Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(crate::Autoscroll::Fit), cx, |s| {
                s.set_pending_anchor_range(anchor_range, crate::SelectMode::Character)
            });
        });
--- a/crates/editor/src/test/editor_lsp_test_context.rs
+++ b/crates/editor/src/test/editor_lsp_test_context.rs
@@ -76,9 +76,7 @@ impl<'a> EditorLspTestContext<'a> {

        let file = cx.read(|cx| workspace.file_project_paths(cx)[0].clone());
        let item = workspace
-            .update(cx, |workspace, cx| {
-                workspace.open_path(file, None, true, cx)
-            })
+            .update(cx, |workspace, cx| workspace.open_path(file, true, cx))
            .await
            .expect("Could not open test file");

--- a/crates/editor/src/test/editor_test_context.rs
+++ b/crates/editor/src/test/editor_test_context.rs
@@ -169,7 +169,7 @@ impl<'a> EditorTestContext<'a> {
        let (unmarked_text, selection_ranges) = marked_text_ranges(marked_text, true);
        self.editor.update(self.cx, |editor, cx| {
            editor.set_text(unmarked_text, cx);
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.select_ranges(selection_ranges)
            })
        });
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -104,7 +104,7 @@ impl FileFinder {
        match event {
            Event::Selected(project_path) => {
                workspace
-                    .open_path(project_path.clone(), None, true, cx)
+                    .open_path(project_path.clone(), true, cx)
                    .detach_and_log_err(cx);
                workspace.dismiss_modal(cx);
            }
@@ -119,7 +119,7 @@ impl FileFinder {
        cx.observe(&project, Self::project_updated).detach();
        Self {
            project,
-            picker: cx.add_view(|cx| Picker::new("Search project files...", handle, cx)),
+            picker: cx.add_view(|cx| Picker::new(handle, cx)),
            search_count: 0,
            latest_search_id: 0,
            latest_search_did_cancel: false,
--- a/crates/go_to_line/src/go_to_line.rs
+++ b/crates/go_to_line/src/go_to_line.rs
@@ -1,5 +1,3 @@
-use std::sync::Arc;
-
 use editor::{display_map::ToDisplayPoint, Autoscroll, DisplayPoint, Editor};
 use gpui::{
    actions, elements::*, geometry::vector::Vector2F, AnyViewHandle, Axis, Entity,
@@ -33,10 +31,7 @@ pub enum Event {
 impl GoToLine {
    pub fn new(active_editor: ViewHandle<Editor>, cx: &mut ViewContext<Self>) -> Self {
        let line_editor = cx.add_view(|cx| {
-            Editor::single_line(
-                Some(Arc::new(|theme| theme.picker.input_editor.clone())),
-                cx,
-            )
+            Editor::single_line(Some(|theme| theme.picker.input_editor.clone()), cx)
        });
        cx.subscribe(&line_editor, Self::on_line_editor_event)
            .detach();
@@ -83,7 +78,7 @@ impl GoToLine {
            if let Some(rows) = active_editor.highlighted_rows() {
                let snapshot = active_editor.snapshot(cx).display_snapshot;
                let position = DisplayPoint::new(rows.start, 0).to_point(&snapshot);
-                active_editor.change_selections(Some(Autoscroll::center()), cx, |s| {
+                active_editor.change_selections(Some(Autoscroll::Center), cx, |s| {
                    s.select_ranges([position..position])
                });
            }
@@ -127,7 +122,7 @@ impl GoToLine {
                        let display_point = point.to_display_point(&snapshot);
                        let row = display_point.row();
                        active_editor.highlight_rows(Some(row..row + 1));
-                        active_editor.request_autoscroll(Autoscroll::center(), cx);
+                        active_editor.request_autoscroll(Autoscroll::Center, cx);
                    });
                    cx.notify();
                }
@@ -175,8 +170,8 @@ impl View for GoToLine {
                            .boxed(),
                    )
                    .with_child(
-                        Container::new(Label::new(label, theme.no_matches.label.clone()).boxed())
-                            .with_style(theme.no_matches.container)
+                        Container::new(Label::new(label, theme.empty.label.clone()).boxed())
+                            .with_style(theme.empty.container)
                            .boxed(),
                    )
                    .boxed(),
--- a/crates/gpui/src/elements/flex.rs
+++ b/crates/gpui/src/elements/flex.rs
@@ -257,19 +257,17 @@ impl Element for Flex {
                        let axis = self.axis;
                        move |e, cx| {
                            if remaining_space < 0. {
-                                let scroll_delta = e.delta.raw();
-
                                let mut delta = match axis {
                                    Axis::Horizontal => {
-                                        if scroll_delta.x().abs() >= scroll_delta.y().abs() {
-                                            scroll_delta.x()
+                                        if e.delta.x().abs() >= e.delta.y().abs() {
+                                            e.delta.x()
                                        } else {
-                                            scroll_delta.y()
+                                            e.delta.y()
                                        }
                                    }
-                                    Axis::Vertical => scroll_delta.y(),
+                                    Axis::Vertical => e.delta.y(),
                                };
-                                if !e.delta.precise() {
+                                if !e.precise {
                                    delta *= 20.;
                                }

--- a/crates/gpui/src/elements/list.rs
+++ b/crates/gpui/src/elements/list.rs
@@ -258,8 +258,8 @@ impl Element for List {
                    state.0.borrow_mut().scroll(
                        &scroll_top,
                        height,
-                        *e.platform_event.delta.raw(),
-                        e.platform_event.delta.precise(),
+                        e.platform_event.delta,
+                        e.platform_event.precise,
                        cx,
                    )
                }
--- a/crates/gpui/src/elements/uniform_list.rs
+++ b/crates/gpui/src/elements/uniform_list.rs
@@ -295,19 +295,15 @@ impl Element for UniformList {
                move |MouseScrollWheel {
                          platform_event:
                              ScrollWheelEvent {
-                                  position, delta, ..
+                                  position,
+                                  delta,
+                                  precise,
+                                  ..
                              },
                          ..
                      },
                      cx| {
-                    if !Self::scroll(
-                        state.clone(),
-                        position,
-                        *delta.raw(),
-                        delta.precise(),
-                        scroll_max,
-                        cx,
-                    ) {
+                    if !Self::scroll(state.clone(), position, delta, precise, scroll_max, cx) {
                        cx.propagate_event();
                    }
                }
--- a/crates/gpui/src/platform/event.rs
+++ b/crates/gpui/src/platform/event.rs
@@ -1,7 +1,5 @@
 use std::ops::Deref;

-use pathfinder_geometry::vector::vec2f;
-
 use crate::{geometry::vector::Vector2F, keymap::Keystroke};

 #[derive(Clone, Debug)]
@@ -46,45 +44,11 @@ pub enum TouchPhase {
    Ended,
 }

-#[derive(Clone, Copy, Debug)]
-pub enum ScrollDelta {
-    Pixels(Vector2F),
-    Lines(Vector2F),
-}
-
-impl Default for ScrollDelta {
-    fn default() -> Self {
-        Self::Lines(Default::default())
-    }
-}
-
-impl ScrollDelta {
-    pub fn raw(&self) -> &Vector2F {
-        match self {
-            ScrollDelta::Pixels(v) => v,
-            ScrollDelta::Lines(v) => v,
-        }
-    }
-
-    pub fn precise(&self) -> bool {
-        match self {
-            ScrollDelta::Pixels(_) => true,
-            ScrollDelta::Lines(_) => false,
-        }
-    }
-
-    pub fn pixel_delta(&self, line_height: f32) -> Vector2F {
-        match self {
-            ScrollDelta::Pixels(delta) => *delta,
-            ScrollDelta::Lines(delta) => vec2f(delta.x() * line_height, delta.y() * line_height),
-        }
-    }
-}
-
 #[derive(Clone, Copy, Debug, Default)]
 pub struct ScrollWheelEvent {
    pub position: Vector2F,
-    pub delta: ScrollDelta,
+    pub delta: Vector2F,
+    pub precise: bool,
    pub modifiers: Modifiers,
    /// If the platform supports returning the phase of a scroll wheel event, it will be stored here
    pub phase: Option<TouchPhase>,
--- a/crates/gpui/src/platform/mac/event.rs
+++ b/crates/gpui/src/platform/mac/event.rs
@@ -3,7 +3,7 @@ use crate::{
    keymap::Keystroke,
    platform::{Event, NavigationDirection},
    KeyDownEvent, KeyUpEvent, Modifiers, ModifiersChangedEvent, MouseButton, MouseButtonEvent,
-    MouseMovedEvent, ScrollDelta, ScrollWheelEvent, TouchPhase,
+    MouseMovedEvent, ScrollWheelEvent, TouchPhase,
 };
 use cocoa::{
    appkit::{NSEvent, NSEventModifierFlags, NSEventPhase, NSEventType},
@@ -164,24 +164,17 @@ impl Event {
                    _ => Some(TouchPhase::Moved),
                };

-                let raw_data = vec2f(
-                    native_event.scrollingDeltaX() as f32,
-                    native_event.scrollingDeltaY() as f32,
-                );
-
-                let delta = if native_event.hasPreciseScrollingDeltas() == YES {
-                    ScrollDelta::Pixels(raw_data)
-                } else {
-                    ScrollDelta::Lines(raw_data)
-                };
-
                Self::ScrollWheel(ScrollWheelEvent {
                    position: vec2f(
                        native_event.locationInWindow().x as f32,
                        window_height - native_event.locationInWindow().y as f32,
                    ),
-                    delta,
+                    delta: vec2f(
+                        native_event.scrollingDeltaX() as f32,
+                        native_event.scrollingDeltaY() as f32,
+                    ),
                    phase,
+                    precise: native_event.hasPreciseScrollingDeltas() == YES,
                    modifiers: read_modifiers(native_event),
                })
            }),
--- a/crates/gpui/src/presenter.rs
+++ b/crates/gpui/src/presenter.rs
@@ -475,35 +475,27 @@ impl Presenter {
                if let MouseEvent::Down(e) = &mouse_event {
                    if valid_region
                        .handlers
-                        .contains(MouseEvent::click_disc(), Some(e.button))
+                        .contains_handler(MouseEvent::click_disc(), Some(e.button))
                        || valid_region
                            .handlers
-                            .contains(MouseEvent::drag_disc(), Some(e.button))
+                            .contains_handler(MouseEvent::drag_disc(), Some(e.button))
                    {
                        event_cx.handled = true;
                    }
                }

-                // `event_consumed` should only be true if there are any handlers for this event.
-                let mut event_consumed = event_cx.handled;
-                if let Some(callbacks) = valid_region.handlers.get(&mouse_event.handler_key()) {
-                    event_consumed = true;
-                    for callback in callbacks {
-                        event_cx.handled = true;
-                        event_cx.with_current_view(valid_region.id().view_id(), {
-                            let region_event = mouse_event.clone();
-                            |cx| callback(region_event, cx)
-                        });
-                        event_consumed &= event_cx.handled;
-                        any_event_handled |= event_cx.handled;
-                    }
+                if let Some(callback) = valid_region.handlers.get(&mouse_event.handler_key()) {
+                    event_cx.handled = true;
+                    event_cx.with_current_view(valid_region.id().view_id(), {
+                        let region_event = mouse_event.clone();
+                        |cx| callback(region_event, cx)
+                    });
                }

-                any_event_handled |= event_cx.handled;
-
-                // For bubbling events, if the event was handled, don't continue dispatching.
-                // This only makes sense for local events which return false from is_capturable.
-                if event_consumed && mouse_event.is_capturable() {
+                any_event_handled = any_event_handled || event_cx.handled;
+                // For bubbling events, if the event was handled, don't continue dispatching
+                // This only makes sense for local events.
+                if event_cx.handled && mouse_event.is_capturable() {
                    break;
                }
            }
--- a/crates/gpui/src/scene/mouse_event.rs
+++ b/crates/gpui/src/scene/mouse_event.rs
@@ -5,7 +5,7 @@ use std::{

 use pathfinder_geometry::{rect::RectF, vector::Vector2F};

-use crate::{scene::mouse_region::HandlerKey, MouseButtonEvent, MouseMovedEvent, ScrollWheelEvent};
+use crate::{MouseButton, MouseButtonEvent, MouseMovedEvent, ScrollWheelEvent};

 #[derive(Debug, Default, Clone)]
 pub struct MouseMove {
@@ -217,17 +217,17 @@ impl MouseEvent {
        discriminant(&MouseEvent::ScrollWheel(Default::default()))
    }

-    pub fn handler_key(&self) -> HandlerKey {
+    pub fn handler_key(&self) -> (Discriminant<MouseEvent>, Option<MouseButton>) {
        match self {
-            MouseEvent::Move(_) => HandlerKey::new(Self::move_disc(), None),
-            MouseEvent::Drag(e) => HandlerKey::new(Self::drag_disc(), e.pressed_button),
-            MouseEvent::Hover(_) => HandlerKey::new(Self::hover_disc(), None),
-            MouseEvent::Down(e) => HandlerKey::new(Self::down_disc(), Some(e.button)),
-            MouseEvent::Up(e) => HandlerKey::new(Self::up_disc(), Some(e.button)),
-            MouseEvent::Click(e) => HandlerKey::new(Self::click_disc(), Some(e.button)),
-            MouseEvent::UpOut(e) => HandlerKey::new(Self::up_out_disc(), Some(e.button)),
-            MouseEvent::DownOut(e) => HandlerKey::new(Self::down_out_disc(), Some(e.button)),
-            MouseEvent::ScrollWheel(_) => HandlerKey::new(Self::scroll_wheel_disc(), None),
+            MouseEvent::Move(_) => (Self::move_disc(), None),
+            MouseEvent::Drag(e) => (Self::drag_disc(), e.pressed_button),
+            MouseEvent::Hover(_) => (Self::hover_disc(), None),
+            MouseEvent::Down(e) => (Self::down_disc(), Some(e.button)),
+            MouseEvent::Up(e) => (Self::up_disc(), Some(e.button)),
+            MouseEvent::Click(e) => (Self::click_disc(), Some(e.button)),
+            MouseEvent::UpOut(e) => (Self::up_out_disc(), Some(e.button)),
+            MouseEvent::DownOut(e) => (Self::down_out_disc(), Some(e.button)),
+            MouseEvent::ScrollWheel(_) => (Self::scroll_wheel_disc(), None),
        }
    }
 }
--- a/crates/gpui/src/scene/mouse_region.rs
+++ b/crates/gpui/src/scene/mouse_region.rs
@@ -3,7 +3,6 @@ use std::{any::TypeId, fmt::Debug, mem::Discriminant, rc::Rc};
 use collections::HashMap;

 use pathfinder_geometry::rect::RectF;
-use smallvec::SmallVec;

 use crate::{EventContext, MouseButton};

@@ -178,105 +177,61 @@ impl MouseRegionId {
    }
 }

-pub type HandlerCallback = Rc<dyn Fn(MouseEvent, &mut EventContext)>;
-
-#[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HandlerKey {
-    event_kind: Discriminant<MouseEvent>,
-    button: Option<MouseButton>,
-}
-
-impl HandlerKey {
-    pub fn new(event_kind: Discriminant<MouseEvent>, button: Option<MouseButton>) -> HandlerKey {
-        HandlerKey { event_kind, button }
-    }
-}
-
 #[derive(Clone, Default)]
 pub struct HandlerSet {
-    set: HashMap<HandlerKey, SmallVec<[HandlerCallback; 1]>>,
+    #[allow(clippy::type_complexity)]
+    pub set: HashMap<
+        (Discriminant<MouseEvent>, Option<MouseButton>),
+        Rc<dyn Fn(MouseEvent, &mut EventContext)>,
+    >,
 }

 impl HandlerSet {
    pub fn capture_all() -> Self {
-        let mut set: HashMap<HandlerKey, SmallVec<[HandlerCallback; 1]>> = HashMap::default();
+        #[allow(clippy::type_complexity)]
+        let mut set: HashMap<
+            (Discriminant<MouseEvent>, Option<MouseButton>),
+            Rc<dyn Fn(MouseEvent, &mut EventContext)>,
+        > = Default::default();

-        set.insert(
-            HandlerKey::new(MouseEvent::move_disc(), None),
-            SmallVec::from_buf([Rc::new(|_, _| {})]),
-        );
-        set.insert(
-            HandlerKey::new(MouseEvent::hover_disc(), None),
-            SmallVec::from_buf([Rc::new(|_, _| {})]),
-        );
+        set.insert((MouseEvent::move_disc(), None), Rc::new(|_, _| {}));
+        set.insert((MouseEvent::hover_disc(), None), Rc::new(|_, _| {}));
        for button in MouseButton::all() {
+            set.insert((MouseEvent::drag_disc(), Some(button)), Rc::new(|_, _| {}));
+            set.insert((MouseEvent::down_disc(), Some(button)), Rc::new(|_, _| {}));
+            set.insert((MouseEvent::up_disc(), Some(button)), Rc::new(|_, _| {}));
+            set.insert((MouseEvent::click_disc(), Some(button)), Rc::new(|_, _| {}));
            set.insert(
-                HandlerKey::new(MouseEvent::drag_disc(), Some(button)),
-                SmallVec::from_buf([Rc::new(|_, _| {})]),
+                (MouseEvent::down_out_disc(), Some(button)),
+                Rc::new(|_, _| {}),
            );
            set.insert(
-                HandlerKey::new(MouseEvent::down_disc(), Some(button)),
-                SmallVec::from_buf([Rc::new(|_, _| {})]),
-            );
-            set.insert(
-                HandlerKey::new(MouseEvent::up_disc(), Some(button)),
-                SmallVec::from_buf([Rc::new(|_, _| {})]),
-            );
-            set.insert(
-                HandlerKey::new(MouseEvent::click_disc(), Some(button)),
-                SmallVec::from_buf([Rc::new(|_, _| {})]),
-            );
-            set.insert(
-                HandlerKey::new(MouseEvent::down_out_disc(), Some(button)),
-                SmallVec::from_buf([Rc::new(|_, _| {})]),
-            );
-            set.insert(
-                HandlerKey::new(MouseEvent::up_out_disc(), Some(button)),
-                SmallVec::from_buf([Rc::new(|_, _| {})]),
+                (MouseEvent::up_out_disc(), Some(button)),
+                Rc::new(|_, _| {}),
            );
        }
-        set.insert(
-            HandlerKey::new(MouseEvent::scroll_wheel_disc(), None),
-            SmallVec::from_buf([Rc::new(|_, _| {})]),
-        );
+        set.insert((MouseEvent::scroll_wheel_disc(), None), Rc::new(|_, _| {}));

        HandlerSet { set }
    }

-    pub fn get(&self, key: &HandlerKey) -> Option<&[HandlerCallback]> {
-        self.set.get(key).map(|vec| vec.as_slice())
+    pub fn get(
+        &self,
+        key: &(Discriminant<MouseEvent>, Option<MouseButton>),
+    ) -> Option<Rc<dyn Fn(MouseEvent, &mut EventContext)>> {
+        self.set.get(key).cloned()
    }

-    pub fn contains(
+    pub fn contains_handler(
        &self,
-        discriminant: Discriminant<MouseEvent>,
+        event: Discriminant<MouseEvent>,
        button: Option<MouseButton>,
    ) -> bool {
-        self.set
-            .contains_key(&HandlerKey::new(discriminant, button))
-    }
-
-    fn insert(
-        &mut self,
-        event_kind: Discriminant<MouseEvent>,
-        button: Option<MouseButton>,
-        callback: HandlerCallback,
-    ) {
-        use std::collections::hash_map::Entry;
-
-        match self.set.entry(HandlerKey::new(event_kind, button)) {
-            Entry::Occupied(mut vec) => {
-                vec.get_mut().push(callback);
-            }
-
-            Entry::Vacant(entry) => {
-                entry.insert(SmallVec::from_buf([callback]));
-            }
-        }
+        self.set.contains_key(&(event, button))
    }

    pub fn on_move(mut self, handler: impl Fn(MouseMove, &mut EventContext) + 'static) -> Self {
-        self.insert(MouseEvent::move_disc(), None,
+        self.set.insert((MouseEvent::move_disc(), None),
            Rc::new(move |region_event, cx| {
                if let MouseEvent::Move(e) = region_event {
                    handler(e, cx);
@@ -294,7 +249,7 @@ impl HandlerSet {
        button: MouseButton,
        handler: impl Fn(MouseDown, &mut EventContext) + 'static,
    ) -> Self {
-        self.insert(MouseEvent::down_disc(), Some(button),
+        self.set.insert((MouseEvent::down_disc(), Some(button)),
            Rc::new(move |region_event, cx| {
                if let MouseEvent::Down(e) = region_event {
                    handler(e, cx);
@@ -312,7 +267,7 @@ impl HandlerSet {
        button: MouseButton,
        handler: impl Fn(MouseUp, &mut EventContext) + 'static,
    ) -> Self {
-        self.insert(MouseEvent::up_disc(), Some(button),
+        self.set.insert((MouseEvent::up_disc(), Some(button)),
            Rc::new(move |region_event, cx| {
                if let MouseEvent::Up(e) = region_event {
                    handler(e, cx);
@@ -330,7 +285,7 @@ impl HandlerSet {
        button: MouseButton,
        handler: impl Fn(MouseClick, &mut EventContext) + 'static,
    ) -> Self {
-        self.insert(MouseEvent::click_disc(), Some(button),
+        self.set.insert((MouseEvent::click_disc(), Some(button)),
            Rc::new(move |region_event, cx| {
                if let MouseEvent::Click(e) = region_event {
                    handler(e, cx);
@@ -348,7 +303,7 @@ impl HandlerSet {
        button: MouseButton,
        handler: impl Fn(MouseDownOut, &mut EventContext) + 'static,
    ) -> Self {
-        self.insert(MouseEvent::down_out_disc(), Some(button),
+        self.set.insert((MouseEvent::down_out_disc(), Some(button)),
            Rc::new(move |region_event, cx| {
                if let MouseEvent::DownOut(e) = region_event {
                    handler(e, cx);
@@ -366,7 +321,7 @@ impl HandlerSet {
        button: MouseButton,
        handler: impl Fn(MouseUpOut, &mut EventContext) + 'static,
    ) -> Self {
-        self.insert(MouseEvent::up_out_disc(), Some(button),
+        self.set.insert((MouseEvent::up_out_disc(), Some(button)),
            Rc::new(move |region_event, cx| {
                if let MouseEvent::UpOut(e) = region_event {
                    handler(e, cx);
@@ -384,7 +339,7 @@ impl HandlerSet {
        button: MouseButton,
        handler: impl Fn(MouseDrag, &mut EventContext) + 'static,
    ) -> Self {
-        self.insert(MouseEvent::drag_disc(), Some(button),
+        self.set.insert((MouseEvent::drag_disc(), Some(button)),
            Rc::new(move |region_event, cx| {
                if let MouseEvent::Drag(e) = region_event {
                    handler(e, cx);
@@ -398,7 +353,7 @@ impl HandlerSet {
    }

    pub fn on_hover(mut self, handler: impl Fn(MouseHover, &mut EventContext) + 'static) -> Self {
-        self.insert(MouseEvent::hover_disc(), None,
+        self.set.insert((MouseEvent::hover_disc(), None),
            Rc::new(move |region_event, cx| {
                if let MouseEvent::Hover(e) = region_event {
                    handler(e, cx);
@@ -415,7 +370,7 @@ impl HandlerSet {
        mut self,
        handler: impl Fn(MouseScrollWheel, &mut EventContext) + 'static,
    ) -> Self {
-        self.insert(MouseEvent::scroll_wheel_disc(), None,
+        self.set.insert((MouseEvent::scroll_wheel_disc(), None),
            Rc::new(move |region_event, cx| {
                if let MouseEvent::ScrollWheel(e) = region_event {
                    handler(e, cx);
--- a/crates/journal/Cargo.toml
+++ b/crates/journal/Cargo.toml
@@ -16,4 +16,4 @@ chrono = "0.4"
 dirs = "4.0"
 log = { version = "0.4.16", features = ["kv_unstable_serde"] }
 settings = { path = "../settings" }
-shellexpand = "2.1.0"
+shellexpand = "2.1.0"
--- a/crates/journal/src/journal.rs
+++ b/crates/journal/src/journal.rs
@@ -61,7 +61,7 @@ pub fn new_journal_entry(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
                if let Some(editor) = item.downcast::<Editor>() {
                    editor.update(&mut cx, |editor, cx| {
                        let len = editor.buffer().read(cx).len(cx);
-                        editor.change_selections(Some(Autoscroll::center()), cx, |s| {
+                        editor.change_selections(Some(Autoscroll::Center), cx, |s| {
                            s.select_ranges([len..len])
                        });
                        if len > 0 {
--- a/crates/language/Cargo.toml
+++ b/crates/language/Cargo.toml
@@ -71,6 +71,4 @@ tree-sitter-json = "*"
 tree-sitter-rust = "*"
 tree-sitter-python = "*"
 tree-sitter-typescript = "*"
-tree-sitter-ruby = "*"
-tree-sitter-embedded-template = "*"
 unindent = "0.1.7"
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -1764,7 +1764,6 @@ impl BufferSnapshot {
            .collect::<Vec<_>>();

        let mut indent_ranges = Vec::<Range<Point>>::new();
-        let mut outdent_positions = Vec::<Point>::new();
        while let Some(mat) = matches.peek() {
            let mut start: Option<Point> = None;
            let mut end: Option<Point> = None;
@@ -1778,8 +1777,6 @@ impl BufferSnapshot {
                    start = Some(Point::from_ts_point(capture.node.end_position()));
                } else if Some(capture.index) == config.end_capture_ix {
                    end = Some(Point::from_ts_point(capture.node.start_position()));
-                } else if Some(capture.index) == config.outdent_capture_ix {
-                    outdent_positions.push(Point::from_ts_point(capture.node.start_position()));
                }
            }

@@ -1800,19 +1797,6 @@ impl BufferSnapshot {
            }
        }

-        outdent_positions.sort();
-        for outdent_position in outdent_positions {
-            // find the innermost indent range containing this outdent_position
-            // set its end to the outdent position
-            if let Some(range_to_truncate) = indent_ranges
-                .iter_mut()
-                .filter(|indent_range| indent_range.contains(&outdent_position))
-                .last()
-            {
-                range_to_truncate.end = outdent_position;
-            }
-        }
-
        // Find the suggested indentation increases and decreased based on regexes.
        let mut indent_change_rows = Vec::<(u32, Ordering)>::new();
        self.for_each_line(
--- a/crates/language/src/buffer_tests.rs
+++ b/crates/language/src/buffer_tests.rs
@@ -1150,49 +1150,6 @@ fn test_autoindent_with_injected_languages(cx: &mut MutableAppContext) {
    });
 }

-#[gpui::test]
-fn test_autoindent_query_with_outdent_captures(cx: &mut MutableAppContext) {
-    let mut settings = Settings::test(cx);
-    settings.editor_defaults.tab_size = Some(2.try_into().unwrap());
-    cx.set_global(settings);
-    cx.add_model(|cx| {
-        let mut buffer = Buffer::new(0, "", cx).with_language(Arc::new(ruby_lang()), cx);
-
-        let text = r#"
-            class C
-            def a(b, c)
-            puts b
-            puts c
-            rescue
-            puts "errored"
-            exit 1
-            end
-            end
-        "#
-        .unindent();
-
-        buffer.edit([(0..0, text)], Some(AutoindentMode::EachLine), cx);
-
-        assert_eq!(
-            buffer.text(),
-            r#"
-                class C
-                  def a(b, c)
-                    puts b
-                    puts c
-                  rescue
-                    puts "errored"
-                    exit 1
-                  end
-                end
-            "#
-            .unindent()
-        );
-
-        buffer
-    });
-}
-
 #[gpui::test]
 fn test_serialization(cx: &mut gpui::MutableAppContext) {
    let mut now = Instant::now();
@@ -1540,26 +1497,6 @@ impl Buffer {
    }
 }

-fn ruby_lang() -> Language {
-    Language::new(
-        LanguageConfig {
-            name: "Ruby".into(),
-            path_suffixes: vec!["rb".to_string()],
-            ..Default::default()
-        },
-        Some(tree_sitter_ruby::language()),
-    )
-    .with_indents_query(
-        r#"
-            (class "end" @end) @indent
-            (method "end" @end) @indent
-            (rescue) @outdent
-            (then) @indent
-        "#,
-    )
-    .unwrap()
-}
-
 fn rust_lang() -> Language {
    Language::new(
        LanguageConfig {
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -28,7 +28,6 @@ use std::{
    any::Any,
    cell::RefCell,
    fmt::Debug,
-    hash::Hash,
    mem,
    ops::Range,
    path::{Path, PathBuf},
@@ -135,10 +134,6 @@ impl CachedLspAdapter {
        self.adapter.process_diagnostics(params).await
    }

-    pub async fn process_completion(&self, completion_item: &mut lsp::CompletionItem) {
-        self.adapter.process_completion(completion_item).await
-    }
-
    pub async fn label_for_completion(
        &self,
        completion_item: &lsp::CompletionItem,
@@ -179,8 +174,6 @@ pub trait LspAdapter: 'static + Send + Sync {

    async fn process_diagnostics(&self, _: &mut lsp::PublishDiagnosticsParams) {}

-    async fn process_completion(&self, _: &mut lsp::CompletionItem) {}
-
    async fn label_for_completion(
        &self,
        _: &lsp::CompletionItem,
@@ -319,7 +312,6 @@ struct IndentConfig {
    indent_capture_ix: u32,
    start_capture_ix: Option<u32>,
    end_capture_ix: Option<u32>,
-    outdent_capture_ix: Option<u32>,
 }

 struct OutlineConfig {
@@ -333,13 +325,7 @@ struct InjectionConfig {
    query: Query,
    content_capture_ix: u32,
    language_capture_ix: Option<u32>,
-    patterns: Vec<InjectionPatternConfig>,
-}
-
-#[derive(Default, Clone)]
-struct InjectionPatternConfig {
-    language: Option<Box<str>>,
-    combined: bool,
+    languages_by_pattern_ix: Vec<Option<Box<str>>>,
 }

 struct BracketConfig {
@@ -650,10 +636,6 @@ impl Language {
        self.adapter.clone()
    }

-    pub fn id(&self) -> Option<usize> {
-        self.grammar.as_ref().map(|g| g.id)
-    }
-
    pub fn with_highlights_query(mut self, source: &str) -> Result<Self> {
        let grammar = self.grammar_mut();
        grammar.highlights_query = Some(Query::new(grammar.ts_language, source)?);
@@ -688,14 +670,12 @@ impl Language {
        let mut indent_capture_ix = None;
        let mut start_capture_ix = None;
        let mut end_capture_ix = None;
-        let mut outdent_capture_ix = None;
        get_capture_indices(
            &query,
            &mut [
                ("indent", &mut indent_capture_ix),
                ("start", &mut start_capture_ix),
                ("end", &mut end_capture_ix),
-                ("outdent", &mut outdent_capture_ix),
            ],
        );
        if let Some(indent_capture_ix) = indent_capture_ix {
@@ -704,7 +684,6 @@ impl Language {
                indent_capture_ix,
                start_capture_ix,
                end_capture_ix,
-                outdent_capture_ix,
            });
        }
        Ok(self)
@@ -747,21 +726,15 @@ impl Language {
                ("content", &mut content_capture_ix),
            ],
        );
-        let patterns = (0..query.pattern_count())
+        let languages_by_pattern_ix = (0..query.pattern_count())
            .map(|ix| {
-                let mut config = InjectionPatternConfig::default();
-                for setting in query.property_settings(ix) {
-                    match setting.key.as_ref() {
-                        "language" => {
-                            config.language = setting.value.clone();
-                        }
-                        "combined" => {
-                            config.combined = true;
-                        }
-                        _ => {}
+                query.property_settings(ix).iter().find_map(|setting| {
+                    if setting.key.as_ref() == "language" {
+                        return setting.value.clone();
+                    } else {
+                        None
                    }
-                }
-                config
+                })
            })
            .collect();
        if let Some(content_capture_ix) = content_capture_ix {
@@ -769,7 +742,7 @@ impl Language {
                query,
                language_capture_ix,
                content_capture_ix,
-                patterns,
+                languages_by_pattern_ix,
            });
        }
        Ok(self)
@@ -832,12 +805,6 @@ impl Language {
        }
    }

-    pub async fn process_completion(self: &Arc<Self>, completion: &mut lsp::CompletionItem) {
-        if let Some(adapter) = self.adapter.as_ref() {
-            adapter.process_completion(completion).await;
-        }
-    }
-
    pub async fn label_for_completion(
        self: &Arc<Self>,
        completion: &lsp::CompletionItem,
@@ -912,20 +879,6 @@ impl Language {
    }
 }

-impl Hash for Language {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.id().hash(state)
-    }
-}
-
-impl PartialEq for Language {
-    fn eq(&self, other: &Self) -> bool {
-        self.id().eq(&other.id())
-    }
-}
-
-impl Eq for Language {}
-
 impl Debug for Language {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Language")
--- a/crates/language/src/proto.rs
+++ b/crates/language/src/proto.rs
@@ -426,11 +426,10 @@ pub async fn deserialize_completion(
        .and_then(deserialize_anchor)
        .ok_or_else(|| anyhow!("invalid old end"))?;
    let lsp_completion = serde_json::from_slice(&completion.lsp_completion)?;
-
-    let mut label = None;
-    if let Some(language) = language {
-        label = language.label_for_completion(&lsp_completion).await;
-    }
+    let label = match language {
+        Some(l) => l.label_for_completion(&lsp_completion).await,
+        None => None,
+    };

    Ok(Completion {
        old_range: old_start..old_end,
--- a/crates/language/src/syntax_map.rs
+++ b/crates/language/src/syntax_map.rs
--- a/crates/outline/src/outline.rs
+++ b/crates/outline/src/outline.rs
@@ -67,9 +67,7 @@ impl OutlineView {
    ) -> Self {
        let handle = cx.weak_handle();
        Self {
-            picker: cx.add_view(|cx| {
-                Picker::new("Search buffer symbols...", handle, cx).with_max_size(800., 1200.)
-            }),
+            picker: cx.add_view(|cx| Picker::new(handle, cx).with_max_size(800., 1200.)),
            last_query: Default::default(),
            matches: Default::default(),
            selected_match_index: 0,
@@ -122,7 +120,7 @@ impl OutlineView {
                let display_rows = start.to_display_point(&snapshot).row()
                    ..end.to_display_point(&snapshot).row() + 1;
                active_editor.highlight_rows(Some(display_rows));
-                active_editor.request_autoscroll(Autoscroll::center(), cx);
+                active_editor.request_autoscroll(Autoscroll::Center, cx);
            });
        }
        cx.notify();
@@ -219,7 +217,7 @@ impl PickerDelegate for OutlineView {
            if let Some(rows) = active_editor.highlighted_rows() {
                let snapshot = active_editor.snapshot(cx).display_snapshot;
                let position = DisplayPoint::new(rows.start, 0).to_point(&snapshot);
-                active_editor.change_selections(Some(Autoscroll::center()), cx, |s| {
+                active_editor.change_selections(Some(Autoscroll::Center), cx, |s| {
                    s.select_ranges([position..position])
                });
            }
--- a/crates/picker/Cargo.toml
+++ b/crates/picker/Cargo.toml
@@ -16,8 +16,6 @@ util = { path = "../util" }
 theme = { path = "../theme" }
 workspace = { path = "../workspace" }

-parking_lot = "0.11.1"
-
 [dev-dependencies]
 gpui = { path = "../gpui", features = ["test-support"] }
 serde_json = { version = "1.0", features = ["preserve_order"] }
--- a/crates/picker/src/picker.rs
+++ b/crates/picker/src/picker.rs
@@ -1,22 +1,25 @@
 use editor::Editor;
 use gpui::{
-    elements::*,
+    elements::{
+        ChildView, Flex, Label, MouseEventHandler, ParentElement, ScrollTarget, UniformList,
+        UniformListState,
+    },
    geometry::vector::{vec2f, Vector2F},
    keymap,
    platform::CursorStyle,
-    AnyViewHandle, AppContext, Axis, Entity, MouseButton, MouseState, MutableAppContext,
-    RenderContext, Task, View, ViewContext, ViewHandle, WeakViewHandle,
+    AnyViewHandle, AppContext, Axis, Element, ElementBox, Entity, MouseButton, MouseState,
+    MutableAppContext, RenderContext, Task, View, ViewContext, ViewHandle, WeakViewHandle,
 };
 use menu::{Cancel, Confirm, SelectFirst, SelectIndex, SelectLast, SelectNext, SelectPrev};
-use parking_lot::Mutex;
-use std::{cmp, sync::Arc};
+use settings::Settings;
+use std::cmp;

 pub struct Picker<D: PickerDelegate> {
    delegate: WeakViewHandle<D>,
    query_editor: ViewHandle<Editor>,
    list_state: UniformListState,
    max_size: Vector2F,
-    theme: Arc<Mutex<Box<dyn Fn(&theme::Theme) -> theme::Picker>>>,
+    theme: Box<dyn FnMut(&AppContext) -> &theme::Picker>,
    confirmed: bool,
 }

@@ -49,8 +52,8 @@ impl<D: PickerDelegate> View for Picker<D> {
    }

    fn render(&mut self, cx: &mut RenderContext<Self>) -> gpui::ElementBox {
-        let theme = (self.theme.lock())(&cx.global::<settings::Settings>().theme);
-        let query = self.query(cx);
+        let theme = (self.theme)(cx);
+        let container_style = theme.container;
        let delegate = self.delegate.clone();
        let match_count = if let Some(delegate) = delegate.upgrade(cx.app) {
            delegate.read(cx).match_count()
@@ -58,36 +61,19 @@ impl<D: PickerDelegate> View for Picker<D> {
            0
        };

-        let container_style;
-        let editor_style;
-        if query.is_empty() && match_count == 0 {
-            container_style = theme.empty_container;
-            editor_style = theme.empty_input_editor.container;
-        } else {
-            container_style = theme.container;
-            editor_style = theme.input_editor.container;
-        };
-
        Flex::new(Axis::Vertical)
            .with_child(
                ChildView::new(&self.query_editor, cx)
                    .contained()
-                    .with_style(editor_style)
+                    .with_style(theme.input_editor.container)
                    .boxed(),
            )
-            .with_children(if match_count == 0 {
-                if query.is_empty() {
-                    None
+            .with_child(
+                if match_count == 0 {
+                    Label::new("No matches".into(), theme.empty.label.clone())
+                        .contained()
+                        .with_style(theme.empty.container)
                } else {
-                    Some(
-                        Label::new("No matches".into(), theme.no_matches.label.clone())
-                            .contained()
-                            .with_style(theme.no_matches.container)
-                            .boxed(),
-                    )
-                }
-            } else {
-                Some(
                    UniformList::new(
                        self.list_state.clone(),
                        match_count,
@@ -112,10 +98,10 @@ impl<D: PickerDelegate> View for Picker<D> {
                    )
                    .contained()
                    .with_margin_top(6.0)
-                    .flex(1., false)
-                    .boxed(),
-                )
-            })
+                }
+                .flex(1., false)
+                .boxed(),
+            )
            .contained()
            .with_style(container_style)
            .constrained()
@@ -148,26 +134,9 @@ impl<D: PickerDelegate> Picker<D> {
        cx.add_action(Self::cancel);
    }

-    pub fn new<P>(placeholder: P, delegate: WeakViewHandle<D>, cx: &mut ViewContext<Self>) -> Self
-    where
-        P: Into<Arc<str>>,
-    {
-        let theme = Arc::new(Mutex::new(
-            Box::new(|theme: &theme::Theme| theme.picker.clone())
-                as Box<dyn Fn(&theme::Theme) -> theme::Picker>,
-        ));
-        let query_editor = cx.add_view({
-            let picker_theme = theme.clone();
-            |cx| {
-                let mut editor = Editor::single_line(
-                    Some(Arc::new(move |theme| {
-                        (picker_theme.lock())(theme).input_editor.clone()
-                    })),
-                    cx,
-                );
-                editor.set_placeholder_text(placeholder, cx);
-                editor
-            }
+    pub fn new(delegate: WeakViewHandle<D>, cx: &mut ViewContext<Self>) -> Self {
+        let query_editor = cx.add_view(|cx| {
+            Editor::single_line(Some(|theme| theme.picker.input_editor.clone()), cx)
        });
        cx.subscribe(&query_editor, Self::on_query_editor_event)
            .detach();
@@ -176,7 +145,7 @@ impl<D: PickerDelegate> Picker<D> {
            list_state: Default::default(),
            delegate,
            max_size: vec2f(540., 420.),
-            theme,
+            theme: Box::new(|cx| &cx.global::<Settings>().theme.picker),
            confirmed: false,
        };
        cx.defer(|this, cx| {
@@ -193,11 +162,11 @@ impl<D: PickerDelegate> Picker<D> {
        self
    }

-    pub fn with_theme<F>(self, theme: F) -> Self
+    pub fn with_theme<F>(mut self, theme: F) -> Self
    where
-        F: 'static + Fn(&theme::Theme) -> theme::Picker,
+        F: 'static + FnMut(&AppContext) -> &theme::Picker,
    {
-        *self.theme.lock() = Box::new(theme);
+        self.theme = Box::new(theme);
        self
    }

--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -3329,91 +3329,88 @@ impl Project {
                    let snapshot = this.snapshot();
                    let clipped_position = this.clip_point_utf16(position, Bias::Left);
                    let mut range_for_token = None;
-                    completions
-                        .into_iter()
-                        .filter_map(move |mut lsp_completion| {
-                            // For now, we can only handle additional edits if they are returned
-                            // when resolving the completion, not if they are present initially.
-                            if lsp_completion
-                                .additional_text_edits
-                                .as_ref()
-                                .map_or(false, |edits| !edits.is_empty())
-                            {
-                                return None;
-                            }
+                    completions.into_iter().filter_map(move |lsp_completion| {
+                        // For now, we can only handle additional edits if they are returned
+                        // when resolving the completion, not if they are present initially.
+                        if lsp_completion
+                            .additional_text_edits
+                            .as_ref()
+                            .map_or(false, |edits| !edits.is_empty())
+                        {
+                            return None;
+                        }

-                            let (old_range, mut new_text) = match lsp_completion.text_edit.as_ref()
-                            {
-                                // If the language server provides a range to overwrite, then
-                                // check that the range is valid.
-                                Some(lsp::CompletionTextEdit::Edit(edit)) => {
-                                    let range = range_from_lsp(edit.range);
-                                    let start = snapshot.clip_point_utf16(range.start, Bias::Left);
-                                    let end = snapshot.clip_point_utf16(range.end, Bias::Left);
-                                    if start != range.start || end != range.end {
-                                        log::info!("completion out of expected range");
-                                        return None;
-                                    }
-                                    (
-                                        snapshot.anchor_before(start)..snapshot.anchor_after(end),
-                                        edit.new_text.clone(),
-                                    )
-                                }
-                                // If the language server does not provide a range, then infer
-                                // the range based on the syntax tree.
-                                None => {
-                                    if position != clipped_position {
-                                        log::info!("completion out of expected range");
-                                        return None;
-                                    }
-                                    let Range { start, end } = range_for_token
-                                        .get_or_insert_with(|| {
-                                            let offset = position.to_offset(&snapshot);
-                                            let (range, kind) = snapshot.surrounding_word(offset);
-                                            if kind == Some(CharKind::Word) {
-                                                range
-                                            } else {
-                                                offset..offset
-                                            }
-                                        })
-                                        .clone();
-                                    let text = lsp_completion
-                                        .insert_text
-                                        .as_ref()
-                                        .unwrap_or(&lsp_completion.label)
-                                        .clone();
-                                    (
-                                        snapshot.anchor_before(start)..snapshot.anchor_after(end),
-                                        text,
-                                    )
-                                }
-                                Some(lsp::CompletionTextEdit::InsertAndReplace(_)) => {
-                                    log::info!("unsupported insert/replace completion");
+                        let (old_range, mut new_text) = match lsp_completion.text_edit.as_ref() {
+                            // If the language server provides a range to overwrite, then
+                            // check that the range is valid.
+                            Some(lsp::CompletionTextEdit::Edit(edit)) => {
+                                let range = range_from_lsp(edit.range);
+                                let start = snapshot.clip_point_utf16(range.start, Bias::Left);
+                                let end = snapshot.clip_point_utf16(range.end, Bias::Left);
+                                if start != range.start || end != range.end {
+                                    log::info!("completion out of expected range");
                                    return None;
                                }
-                            };
+                                (
+                                    snapshot.anchor_before(start)..snapshot.anchor_after(end),
+                                    edit.new_text.clone(),
+                                )
+                            }
+                            // If the language server does not provide a range, then infer
+                            // the range based on the syntax tree.
+                            None => {
+                                if position != clipped_position {
+                                    log::info!("completion out of expected range");
+                                    return None;
+                                }
+                                let Range { start, end } = range_for_token
+                                    .get_or_insert_with(|| {
+                                        let offset = position.to_offset(&snapshot);
+                                        let (range, kind) = snapshot.surrounding_word(offset);
+                                        if kind == Some(CharKind::Word) {
+                                            range
+                                        } else {
+                                            offset..offset
+                                        }
+                                    })
+                                    .clone();
+                                let text = lsp_completion
+                                    .insert_text
+                                    .as_ref()
+                                    .unwrap_or(&lsp_completion.label)
+                                    .clone();
+                                (
+                                    snapshot.anchor_before(start)..snapshot.anchor_after(end),
+                                    text,
+                                )
+                            }
+                            Some(lsp::CompletionTextEdit::InsertAndReplace(_)) => {
+                                log::info!("unsupported insert/replace completion");
+                                return None;
+                            }
+                        };

-                            LineEnding::normalize(&mut new_text);
-                            let language = language.clone();
-                            Some(async move {
-                                let mut label = None;
-                                if let Some(language) = language {
-                                    language.process_completion(&mut lsp_completion).await;
-                                    label = language.label_for_completion(&lsp_completion).await;
-                                }
-                                Completion {
-                                    old_range,
-                                    new_text,
-                                    label: label.unwrap_or_else(|| {
-                                        CodeLabel::plain(
-                                            lsp_completion.label.clone(),
-                                            lsp_completion.filter_text.as_deref(),
-                                        )
-                                    }),
-                                    lsp_completion,
-                                }
-                            })
+                        LineEnding::normalize(&mut new_text);
+                        let language = language.clone();
+                        Some(async move {
+                            let label = if let Some(language) = language {
+                                language.label_for_completion(&lsp_completion).await
+                            } else {
+                                None
+                            };
+                            Completion {
+                                old_range,
+                                new_text,
+                                label: label.unwrap_or_else(|| {
+                                    CodeLabel::plain(
+                                        lsp_completion.label.clone(),
+                                        lsp_completion.filter_text.as_deref(),
+                                    )
+                                }),
+                                lsp_completion,
+                            }
                        })
+                    })
                });

                Ok(futures::future::join_all(completions).await)
@@ -3456,41 +3453,29 @@ impl Project {
        let buffer_id = buffer.remote_id();

        if self.is_local() {
-            let lang_server = match self.language_server_for_buffer(buffer, cx) {
-                Some((_, server)) => server.clone(),
-                _ => return Task::ready(Ok(Default::default())),
+            let lang_server = if let Some((_, server)) = self.language_server_for_buffer(buffer, cx)
+            {
+                server.clone()
+            } else {
+                return Task::ready(Ok(Default::default()));
            };

            cx.spawn(|this, mut cx| async move {
                let resolved_completion = lang_server
                    .request::<lsp::request::ResolveCompletionItem>(completion.lsp_completion)
                    .await?;
-
                if let Some(edits) = resolved_completion.additional_text_edits {
                    let edits = this
                        .update(&mut cx, |this, cx| {
                            this.edits_from_lsp(&buffer_handle, edits, None, cx)
                        })
                        .await?;
-
                    buffer_handle.update(&mut cx, |buffer, cx| {
                        buffer.finalize_last_transaction();
                        buffer.start_transaction();
-
                        for (range, text) in edits {
-                            let primary = &completion.old_range;
-                            let start_within = primary.start.cmp(&range.start, buffer).is_le()
-                                && primary.end.cmp(&range.start, buffer).is_ge();
-                            let end_within = range.start.cmp(&primary.end, buffer).is_le()
-                                && range.end.cmp(&primary.end, buffer).is_ge();
-
-                            //Skip addtional edits which overlap with the primary completion edit
-                            //https://github.com/zed-industries/zed/pull/1871
-                            if !start_within && !end_within {
-                                buffer.edit([(range, text)], None, cx);
-                            }
+                            buffer.edit([(range, text)], None, cx);
                        }
-
                        let transaction = if buffer.end_transaction(cx).is_some() {
                            let transaction = buffer.finalize_last_transaction().unwrap().clone();
                            if !push_to_history {
@@ -3589,7 +3574,6 @@ impl Project {
                        context: lsp::CodeActionContext {
                            diagnostics: relevant_diagnostics,
                            only: Some(vec![
-                                lsp::CodeActionKind::EMPTY,
                                lsp::CodeActionKind::QUICKFIX,
                                lsp::CodeActionKind::REFACTOR,
                                lsp::CodeActionKind::REFACTOR_EXTRACT,
--- a/crates/project/src/worktree.rs
+++ b/crates/project/src/worktree.rs
@@ -1179,10 +1179,6 @@ impl Snapshot {
        self.id
    }

-    pub fn abs_path(&self) -> &Arc<Path> {
-        &self.abs_path
-    }
-
    pub fn contains_entry(&self, entry_id: ProjectEntryId) -> bool {
        self.entries_by_id.get(&entry_id, &()).is_some()
    }
@@ -1374,6 +1370,10 @@ impl Snapshot {
 }

 impl LocalSnapshot {
+    pub fn abs_path(&self) -> &Arc<Path> {
+        &self.abs_path
+    }
+
    pub fn extension_counts(&self) -> &HashMap<OsString, usize> {
        &self.extension_counts
    }
--- a/crates/project_panel/Cargo.toml
+++ b/crates/project_panel/Cargo.toml
@@ -9,7 +9,6 @@ doctest = false

 [dependencies]
 context_menu = { path = "../context_menu" }
-drag_and_drop = { path = "../drag_and_drop" }
 editor = { path = "../editor" }
 gpui = { path = "../gpui" }
 menu = { path = "../menu" }
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -1,13 +1,12 @@
 use context_menu::{ContextMenu, ContextMenuItem};
-use drag_and_drop::{DragAndDrop, Draggable};
 use editor::{Cancel, Editor};
 use futures::stream::StreamExt;
 use gpui::{
    actions,
    anyhow::{anyhow, Result},
    elements::{
-        AnchorCorner, ChildView, ConstrainedBox, ContainerStyle, Empty, Flex, Label,
-        MouseEventHandler, ParentElement, ScrollTarget, Stack, Svg, UniformList, UniformListState,
+        AnchorCorner, ChildView, ConstrainedBox, Empty, Flex, Label, MouseEventHandler,
+        ParentElement, ScrollTarget, Stack, Svg, UniformList, UniformListState,
    },
    geometry::vector::Vector2F,
    impl_internal_actions, keymap,
@@ -24,9 +23,7 @@ use std::{
    ffi::OsStr,
    ops::Range,
    path::{Path, PathBuf},
-    sync::Arc,
 };
-use theme::ProjectPanelEntry;
 use unicase::UniCase;
 use workspace::Workspace;

@@ -43,7 +40,6 @@ pub struct ProjectPanel {
    filename_editor: ViewHandle<Editor>,
    clipboard_entry: Option<ClipboardEntry>,
    context_menu: ViewHandle<ContextMenu>,
-    dragged_entry_destination: Option<Arc<Path>>,
 }

 #[derive(Copy, Clone)]
@@ -74,9 +70,8 @@ pub enum ClipboardEntry {
 }

 #[derive(Debug, PartialEq, Eq)]
-pub struct EntryDetails {
+struct EntryDetails {
    filename: String,
-    path: Arc<Path>,
    depth: usize,
    kind: EntryKind,
    is_ignored: bool,
@@ -96,13 +91,6 @@ pub struct Open {
    pub change_focus: bool,
 }

-#[derive(Clone, PartialEq)]
-pub struct MoveProjectEntry {
-    pub entry_to_move: ProjectEntryId,
-    pub destination: ProjectEntryId,
-    pub destination_is_file: bool,
-}
-
 #[derive(Clone, PartialEq)]
 pub struct DeployContextMenu {
    pub position: Vector2F,
@@ -125,10 +113,7 @@ actions!(
        ToggleFocus
    ]
 );
-impl_internal_actions!(
-    project_panel,
-    [Open, ToggleExpanded, DeployContextMenu, MoveProjectEntry]
-);
+impl_internal_actions!(project_panel, [Open, ToggleExpanded, DeployContextMenu]);

 pub fn init(cx: &mut MutableAppContext) {
    cx.add_action(ProjectPanel::deploy_context_menu);
@@ -152,7 +137,6 @@ pub fn init(cx: &mut MutableAppContext) {
            this.paste(action, cx);
        },
    );
-    cx.add_action(ProjectPanel::move_entry);
 }

 pub enum Event {
@@ -191,11 +175,11 @@ impl ProjectPanel {

            let filename_editor = cx.add_view(|cx| {
                Editor::single_line(
-                    Some(Arc::new(|theme| {
+                    Some(|theme| {
                        let mut style = theme.project_panel.filename_editor.clone();
                        style.container.background_color.take();
                        style
-                    })),
+                    }),
                    cx,
                )
            });
@@ -231,12 +215,10 @@ impl ProjectPanel {
                filename_editor,
                clipboard_entry: None,
                context_menu: cx.add_view(ContextMenu::new),
-                dragged_entry_destination: None,
            };
            this.update_visible_entries(None, cx);
            this
        });
-
        cx.subscribe(&project_panel, {
            let project_panel = project_panel.downgrade();
            move |workspace, _, event, cx| match event {
@@ -252,7 +234,6 @@ impl ProjectPanel {
                                        worktree_id: worktree.read(cx).id(),
                                        path: entry.path.clone(),
                                    },
-                                    None,
                                    focus_opened_item,
                                    cx,
                                )
@@ -619,10 +600,6 @@ impl ProjectPanel {
                    cx.notify();
                }
            }
-
-            cx.update_global(|drag_and_drop: &mut DragAndDrop<Workspace>, cx| {
-                drag_and_drop.cancel_dragging::<ProjectEntryId>(cx);
-            })
        }
    }

@@ -787,39 +764,6 @@ impl ProjectPanel {
        }
    }

-    fn move_entry(
-        &mut self,
-        &MoveProjectEntry {
-            entry_to_move,
-            destination,
-            destination_is_file,
-        }: &MoveProjectEntry,
-        cx: &mut ViewContext<Self>,
-    ) {
-        let destination_worktree = self.project.update(cx, |project, cx| {
-            let entry_path = project.path_for_entry(entry_to_move, cx)?;
-            let destination_entry_path = project.path_for_entry(destination, cx)?.path.clone();
-
-            let mut destination_path = destination_entry_path.as_ref();
-            if destination_is_file {
-                destination_path = destination_path.parent()?;
-            }
-
-            let mut new_path = destination_path.to_path_buf();
-            new_path.push(entry_path.path.file_name()?);
-            if new_path != entry_path.path.as_ref() {
-                let task = project.rename_entry(entry_to_move, new_path, cx)?;
-                cx.foreground().spawn(task).detach_and_log_err(cx);
-            }
-
-            Some(project.worktree_id_for_entry(destination, cx)?)
-        });
-
-        if let Some(destination_worktree) = destination_worktree {
-            self.expand_entry(destination_worktree, destination, cx);
-        }
-    }
-
    fn index_for_selection(&self, selection: Selection) -> Option<(usize, usize, usize)> {
        let mut entry_index = 0;
        let mut visible_entries_index = 0;
@@ -1005,15 +949,14 @@ impl ProjectPanel {
            let end_ix = range.end.min(ix + visible_worktree_entries.len());
            if let Some(worktree) = self.project.read(cx).worktree_for_id(*worktree_id, cx) {
                let snapshot = worktree.read(cx).snapshot();
-                let root_name = OsStr::new(snapshot.root_name());
                let expanded_entry_ids = self
                    .expanded_dir_ids
                    .get(&snapshot.id())
                    .map(Vec::as_slice)
                    .unwrap_or(&[]);
-
-                let entry_range = range.start.saturating_sub(ix)..end_ix - ix;
-                for entry in &visible_worktree_entries[entry_range] {
+                let root_name = OsStr::new(snapshot.root_name());
+                for entry in &visible_worktree_entries[range.start.saturating_sub(ix)..end_ix - ix]
+                {
                    let mut details = EntryDetails {
                        filename: entry
                            .path
@@ -1021,7 +964,6 @@ impl ProjectPanel {
                            .unwrap_or(root_name)
                            .to_string_lossy()
                            .to_string(),
-                        path: entry.path.clone(),
                        depth: entry.path.components().count(),
                        kind: entry.kind,
                        is_ignored: entry.is_ignored,
@@ -1035,14 +977,12 @@ impl ProjectPanel {
                            .clipboard_entry
                            .map_or(false, |e| e.is_cut() && e.entry_id() == entry.id),
                    };
-
                    if let Some(edit_state) = &self.edit_state {
                        let is_edited_entry = if edit_state.is_new_entry {
                            entry.id == NEW_ENTRY_ID
                        } else {
                            entry.id == edit_state.entry_id
                        };
-
                        if is_edited_entry {
                            if let Some(processing_filename) = &edit_state.processing_filename {
                                details.is_processing = true;
@@ -1064,115 +1004,77 @@ impl ProjectPanel {
        }
    }

-    fn render_entry_visual_element<V: View>(
-        details: &EntryDetails,
-        editor: Option<&ViewHandle<Editor>>,
-        padding: f32,
-        row_container_style: ContainerStyle,
-        style: &ProjectPanelEntry,
-        cx: &mut RenderContext<V>,
-    ) -> ElementBox {
-        let kind = details.kind;
-        let show_editor = details.is_editing && !details.is_processing;
-
-        Flex::row()
-            .with_child(
-                ConstrainedBox::new(if kind == EntryKind::Dir {
-                    if details.is_expanded {
-                        Svg::new("icons/chevron_down_8.svg")
-                            .with_color(style.icon_color)
-                            .boxed()
-                    } else {
-                        Svg::new("icons/chevron_right_8.svg")
-                            .with_color(style.icon_color)
-                            .boxed()
-                    }
-                } else {
-                    Empty::new().boxed()
-                })
-                .with_max_width(style.icon_size)
-                .with_max_height(style.icon_size)
-                .aligned()
-                .constrained()
-                .with_width(style.icon_size)
-                .boxed(),
-            )
-            .with_child(if show_editor && editor.is_some() {
-                ChildView::new(editor.unwrap().clone(), cx)
-                    .contained()
-                    .with_margin_left(style.icon_spacing)
-                    .aligned()
-                    .left()
-                    .flex(1.0, true)
-                    .boxed()
-            } else {
-                Label::new(details.filename.clone(), style.text.clone())
-                    .contained()
-                    .with_margin_left(style.icon_spacing)
-                    .aligned()
-                    .left()
-                    .boxed()
-            })
-            .constrained()
-            .with_height(style.height)
-            .contained()
-            .with_style(row_container_style)
-            .with_padding_left(padding)
-            .boxed()
-    }
-
    fn render_entry(
        entry_id: ProjectEntryId,
        details: EntryDetails,
        editor: &ViewHandle<Editor>,
-        dragged_entry_destination: &mut Option<Arc<Path>>,
        theme: &theme::ProjectPanel,
        cx: &mut RenderContext<Self>,
    ) -> ElementBox {
-        let this = cx.handle();
        let kind = details.kind;
-        let path = details.path.clone();
-        let padding = theme.container.padding.left + details.depth as f32 * theme.indent_width;
-
-        let entry_style = if details.is_cut {
-            &theme.cut_entry
-        } else if details.is_ignored {
-            &theme.ignored_entry
-        } else {
-            &theme.entry
-        };
-
        let show_editor = details.is_editing && !details.is_processing;
-
        MouseEventHandler::<Self>::new(entry_id.to_usize(), cx, |state, cx| {
-            let mut style = entry_style.style_for(state, details.is_selected).clone();
+            let padding = theme.container.padding.left + details.depth as f32 * theme.indent_width;

-            if cx
-                .global::<DragAndDrop<Workspace>>()
-                .currently_dragged::<ProjectEntryId>(cx.window_id())
-                .is_some()
-                && dragged_entry_destination
-                    .as_ref()
-                    .filter(|destination| details.path.starts_with(destination))
-                    .is_some()
-            {
-                style = entry_style.active.clone().unwrap();
-            }
+            let entry_style = if details.is_cut {
+                &theme.cut_entry
+            } else if details.is_ignored {
+                &theme.ignored_entry
+            } else {
+                &theme.entry
+            };
+
+            let style = entry_style.style_for(state, details.is_selected).clone();

            let row_container_style = if show_editor {
                theme.filename_editor.container
            } else {
                style.container
            };
-
-            Self::render_entry_visual_element(
-                &details,
-                Some(editor),
-                padding,
-                row_container_style,
-                &style,
-                cx,
-            )
+            Flex::row()
+                .with_child(
+                    ConstrainedBox::new(if kind == EntryKind::Dir {
+                        if details.is_expanded {
+                            Svg::new("icons/chevron_down_8.svg")
+                                .with_color(style.icon_color)
+                                .boxed()
+                        } else {
+                            Svg::new("icons/chevron_right_8.svg")
+                                .with_color(style.icon_color)
+                                .boxed()
+                        }
+                    } else {
+                        Empty::new().boxed()
+                    })
+                    .with_max_width(style.icon_size)
+                    .with_max_height(style.icon_size)
+                    .aligned()
+                    .constrained()
+                    .with_width(style.icon_size)
+                    .boxed(),
+                )
+                .with_child(if show_editor {
+                    ChildView::new(editor.clone(), cx)
+                        .contained()
+                        .with_margin_left(theme.entry.default.icon_spacing)
+                        .aligned()
+                        .left()
+                        .flex(1.0, true)
+                        .boxed()
+                } else {
+                    Label::new(details.filename, style.text.clone())
+                        .contained()
+                        .with_margin_left(style.icon_spacing)
+                        .aligned()
+                        .left()
+                        .boxed()
+                })
+                .constrained()
+                .with_height(theme.entry.default.height)
+                .contained()
+                .with_style(row_container_style)
+                .with_padding_left(padding)
+                .boxed()
        })
        .on_click(MouseButton::Left, move |e, cx| {
            if kind == EntryKind::Dir {
@@ -1190,50 +1092,6 @@ impl ProjectPanel {
                position: e.position,
            })
        })
-        .on_up(MouseButton::Left, move |_, cx| {
-            if let Some((_, dragged_entry)) = cx
-                .global::<DragAndDrop<Workspace>>()
-                .currently_dragged::<ProjectEntryId>(cx.window_id())
-            {
-                cx.dispatch_action(MoveProjectEntry {
-                    entry_to_move: *dragged_entry,
-                    destination: entry_id,
-                    destination_is_file: matches!(details.kind, EntryKind::File(_)),
-                });
-            }
-        })
-        .on_move(move |_, cx| {
-            if cx
-                .global::<DragAndDrop<Workspace>>()
-                .currently_dragged::<ProjectEntryId>(cx.window_id())
-                .is_some()
-            {
-                if let Some(this) = this.upgrade(cx.app) {
-                    this.update(cx.app, |this, _| {
-                        this.dragged_entry_destination = if matches!(kind, EntryKind::File(_)) {
-                            path.parent().map(|parent| Arc::from(parent))
-                        } else {
-                            Some(path.clone())
-                        };
-                    })
-                }
-            }
-        })
-        .as_draggable(entry_id, {
-            let row_container_style = theme.dragged_entry.container;
-
-            move |_, cx: &mut RenderContext<Workspace>| {
-                let theme = cx.global::<Settings>().theme.clone();
-                Self::render_entry_visual_element(
-                    &details,
-                    None,
-                    padding,
-                    row_container_style,
-                    &theme.project_panel.dragged_entry,
-                    cx,
-                )
-            }
-        })
        .with_cursor_style(CursorStyle::PointingHand)
        .boxed()
    }
@@ -1245,15 +1103,14 @@ impl View for ProjectPanel {
    }

    fn render(&mut self, cx: &mut gpui::RenderContext<'_, Self>) -> gpui::ElementBox {
-        enum ProjectPanel {}
+        enum Tag {}
        let theme = &cx.global::<Settings>().theme.project_panel;
        let mut container_style = theme.container;
        let padding = std::mem::take(&mut container_style.padding);
        let last_worktree_root_id = self.last_worktree_root_id;
-
        Stack::new()
            .with_child(
-                MouseEventHandler::<ProjectPanel>::new(0, cx, |_, cx| {
+                MouseEventHandler::<Tag>::new(0, cx, |_, cx| {
                    UniformList::new(
                        self.list.clone(),
                        self.visible_entries
@@ -1263,19 +1120,15 @@ impl View for ProjectPanel {
                        cx,
                        move |this, range, items, cx| {
                            let theme = cx.global::<Settings>().theme.clone();
-                            let mut dragged_entry_destination =
-                                this.dragged_entry_destination.clone();
                            this.for_each_visible_entry(range, cx, |id, details, cx| {
                                items.push(Self::render_entry(
                                    id,
                                    details,
                                    &this.filename_editor,
-                                    &mut dragged_entry_destination,
                                    &theme.project_panel,
                                    cx,
                                ));
                            });
-                            this.dragged_entry_destination = dragged_entry_destination;
                        },
                    )
                    .with_padding_top(padding.top)
--- a/crates/project_symbols/Cargo.toml
+++ b/crates/project_symbols/Cargo.toml
@@ -28,4 +28,4 @@ settings = { path = "../settings", features = ["test-support"] }
 gpui = { path = "../gpui", features = ["test-support"] }
 language = { path = "../language", features = ["test-support"] }
 lsp = { path = "../lsp", features = ["test-support"] }
-project = { path = "../project", features = ["test-support"] }
+project = { path = "../project", features = ["test-support"] }
--- a/crates/project_symbols/src/project_symbols.rs
+++ b/crates/project_symbols/src/project_symbols.rs
@@ -63,7 +63,7 @@ impl ProjectSymbolsView {
        let handle = cx.weak_handle();
        Self {
            project,
-            picker: cx.add_view(|cx| Picker::new("Search project symbols...", handle, cx)),
+            picker: cx.add_view(|cx| Picker::new(handle, cx)),
            selected_match_index: 0,
            symbols: Default::default(),
            visible_match_candidates: Default::default(),
@@ -150,7 +150,7 @@ impl ProjectSymbolsView {

                        let editor = workspace.open_project_item::<Editor>(buffer, cx);
                        editor.update(cx, |editor, cx| {
-                            editor.change_selections(Some(Autoscroll::center()), cx, |s| {
+                            editor.change_selections(Some(Autoscroll::Center), cx, |s| {
                                s.select_ranges([position..position])
                            });
                        });
--- a/crates/search/src/buffer_search.rs
+++ b/crates/search/src/buffer_search.rs
@@ -12,7 +12,7 @@ use gpui::{
 use project::search::SearchQuery;
 use serde::Deserialize;
 use settings::Settings;
-use std::{any::Any, sync::Arc};
+use std::any::Any;
 use workspace::{
    searchable::{Direction, SearchEvent, SearchableItemHandle, WeakSearchableItemHandle},
    ItemHandle, Pane, ToolbarItemLocation, ToolbarItemView,
@@ -232,11 +232,7 @@ impl ToolbarItemView for BufferSearchBar {
 impl BufferSearchBar {
    pub fn new(cx: &mut ViewContext<Self>) -> Self {
        let query_editor = cx.add_view(|cx| {
-            Editor::auto_height(
-                2,
-                Some(Arc::new(|theme| theme.search.editor.input.clone())),
-                cx,
-            )
+            Editor::auto_height(2, Some(|theme| theme.search.editor.input.clone()), cx)
        });
        cx.subscribe(&query_editor, Self::on_query_editor_event)
            .detach();
--- a/crates/search/src/project_search.rs
+++ b/crates/search/src/project_search.rs
@@ -20,7 +20,6 @@ use std::{
    any::{Any, TypeId},
    ops::Range,
    path::PathBuf,
-    sync::Arc,
 };
 use util::ResultExt as _;
 use workspace::{
@@ -379,10 +378,8 @@ impl ProjectSearchView {
            .detach();

        let query_editor = cx.add_view(|cx| {
-            let mut editor = Editor::single_line(
-                Some(Arc::new(|theme| theme.search.editor.input.clone())),
-                cx,
-            );
+            let mut editor =
+                Editor::single_line(Some(|theme| theme.search.editor.input.clone()), cx);
            editor.set_text(query_text, cx);
            editor
        });
@@ -512,7 +509,7 @@ impl ProjectSearchView {
            let range_to_select = match_ranges[new_index].clone();
            self.results_editor.update(cx, |editor, cx| {
                editor.unfold_ranges([range_to_select.clone()], false, cx);
-                editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                    s.select_ranges([range_to_select])
                });
            });
@@ -546,7 +543,7 @@ impl ProjectSearchView {
        } else {
            self.results_editor.update(cx, |editor, cx| {
                if reset_selections {
-                    editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                    editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                        s.select_ranges(match_ranges.first().cloned())
                    });
                }
--- a/crates/settings/src/settings.rs
+++ b/crates/settings/src/settings.rs
@@ -28,7 +28,6 @@ pub struct Settings {
    pub buffer_font_family: FamilyId,
    pub default_buffer_font_size: f32,
    pub buffer_font_size: f32,
-    pub active_pane_magnification: f32,
    pub cursor_blink: bool,
    pub hover_popover_enabled: bool,
    pub show_completions_on_input: bool,
@@ -254,8 +253,6 @@ pub struct SettingsFileContent {
    #[serde(default)]
    pub buffer_font_size: Option<f32>,
    #[serde(default)]
-    pub active_pane_magnification: Option<f32>,
-    #[serde(default)]
    pub cursor_blink: Option<bool>,
    #[serde(default)]
    pub hover_popover_enabled: Option<bool>,
@@ -315,7 +312,6 @@ impl Settings {
                .load_family(&[defaults.buffer_font_family.as_ref().unwrap()])
                .unwrap(),
            buffer_font_size: defaults.buffer_font_size.unwrap(),
-            active_pane_magnification: defaults.active_pane_magnification.unwrap(),
            default_buffer_font_size: defaults.buffer_font_size.unwrap(),
            cursor_blink: defaults.cursor_blink.unwrap(),
            hover_popover_enabled: defaults.hover_popover_enabled.unwrap(),
@@ -371,10 +367,6 @@ impl Settings {
            data.projects_online_by_default,
        );
        merge(&mut self.buffer_font_size, data.buffer_font_size);
-        merge(
-            &mut self.active_pane_magnification,
-            data.active_pane_magnification,
-        );
        merge(&mut self.default_buffer_font_size, data.buffer_font_size);
        merge(&mut self.cursor_blink, data.cursor_blink);
        merge(&mut self.hover_popover_enabled, data.hover_popover_enabled);
@@ -466,7 +458,6 @@ impl Settings {
            experiments: FeatureFlags::default(),
            buffer_font_family: cx.font_cache().load_family(&["Monaco"]).unwrap(),
            buffer_font_size: 14.,
-            active_pane_magnification: 1.,
            default_buffer_font_size: 14.,
            cursor_blink: true,
            hover_popover_enabled: true,
--- a/crates/terminal/src/mappings/keys.rs
+++ b/crates/terminal/src/mappings/keys.rs
@@ -36,6 +36,18 @@ impl Modifiers {
    }
 }

+///This function checks if to_esc_str would work, assuming all terminal settings are off.
+///Note that this function is conservative. It can fail in cases where the actual to_esc_str succeeds.
+///This is unavoidable for our use case. GPUI cannot wait until we acquire the terminal
+///lock to determine whether we could actually send the keystroke with the current settings. Therefore,
+///This conservative guess is used instead. Note that in practice the case where this method
+///Returns false when the actual terminal would consume the keystroke never happens. All keystrokes
+///that depend on terminal modes also have a mapping that doesn't depend on the terminal mode.
+///This is fragile, but as these mappings are locked up in legacy compatibility, it's probably good enough
+pub fn might_convert(keystroke: &Keystroke) -> bool {
+    to_esc_str(keystroke, &TermMode::NONE, false).is_some()
+}
+
 pub fn to_esc_str(keystroke: &Keystroke, mode: &TermMode, alt_is_meta: bool) -> Option<String> {
    let modifiers = Modifiers::new(keystroke);

--- a/crates/terminal/src/mappings/mouse.rs
+++ b/crates/terminal/src/mappings/mouse.rs
@@ -97,7 +97,7 @@ impl MouseButton {
    }

    fn from_scroll(e: &ScrollWheelEvent) -> Self {
-        if e.delta.raw().y() > 0. {
+        if e.delta.y() > 0. {
            MouseButton::ScrollUp
        } else {
            MouseButton::ScrollDown
--- a/crates/terminal/src/terminal.rs
+++ b/crates/terminal/src/terminal.rs
@@ -407,18 +407,13 @@ impl TerminalBuilder {
                'outer: loop {
                    let mut events = vec![];
                    let mut timer = cx.background().timer(Duration::from_millis(4)).fuse();
-                    let mut wakeup = false;
+
                    loop {
                        futures::select_biased! {
                            _ = timer => break,
                            event = self.events_rx.next() => {
                                if let Some(event) = event {
-                                    if matches!(event, AlacTermEvent::Wakeup) {
-                                        wakeup = true;
-                                    } else {
-                                        events.push(event);
-                                    }
-
+                                    events.push(event);
                                    if events.len() > 100 {
                                        break;
                                    }
@@ -429,15 +424,11 @@ impl TerminalBuilder {
                        }
                    }

-                    if events.is_empty() && wakeup == false {
+                    if events.is_empty() {
                        smol::future::yield_now().await;
                        break 'outer;
                    } else {
                        this.upgrade(&cx)?.update(&mut cx, |this, cx| {
-                            if wakeup {
-                                this.process_event(&AlacTermEvent::Wakeup, cx);
-                            }
-
                            for event in events {
                                this.process_event(&event, cx);
                            }
@@ -636,7 +627,7 @@ impl Terminal {
                term.grid_mut().reset_region(..cursor.line);

                // Copy the current line up
-                let line = term.grid()[cursor.line][..Column(term.grid().columns())]
+                let line = term.grid()[cursor.line][..cursor.column]
                    .iter()
                    .cloned()
                    .enumerate()
@@ -1145,7 +1136,7 @@ impl Terminal {

    fn determine_scroll_lines(&mut self, e: &MouseScrollWheel, mouse_mode: bool) -> Option<i32> {
        let scroll_multiplier = if mouse_mode { 1. } else { SCROLL_MULTIPLIER };
-        let line_height = self.last_content.size.line_height;
+
        match e.phase {
            /* Reset scroll state on started */
            Some(gpui::TouchPhase::Started) => {
@@ -1154,11 +1145,11 @@ impl Terminal {
            }
            /* Calculate the appropriate scroll lines */
            Some(gpui::TouchPhase::Moved) => {
-                let old_offset = (self.scroll_px / line_height) as i32;
+                let old_offset = (self.scroll_px / self.last_content.size.line_height) as i32;

-                self.scroll_px += e.delta.pixel_delta(line_height).y() * scroll_multiplier;
+                self.scroll_px += e.delta.y() * scroll_multiplier;

-                let new_offset = (self.scroll_px / line_height) as i32;
+                let new_offset = (self.scroll_px / self.last_content.size.line_height) as i32;

                // Whenever we hit the edges, reset our stored scroll to 0
                // so we can respond to changes in direction quickly
@@ -1168,7 +1159,7 @@ impl Terminal {
            }
            /* Fall back to delta / line_height */
            None => Some(
-                ((e.delta.pixel_delta(line_height).y() * scroll_multiplier) / line_height) as i32,
+                ((e.delta.y() * scroll_multiplier) / self.last_content.size.line_height) as i32,
            ),
            _ => None,
        }
--- a/crates/theme/src/theme.rs
+++ b/crates/theme/src/theme.rs
@@ -326,7 +326,6 @@ pub struct ProjectPanel {
    #[serde(flatten)]
    pub container: ContainerStyle,
    pub entry: Interactive<ProjectPanelEntry>,
-    pub dragged_entry: ProjectPanelEntry,
    pub ignored_entry: Interactive<ProjectPanelEntry>,
    pub cut_entry: Interactive<ProjectPanelEntry>,
    pub filename_editor: FieldEditor,
@@ -424,14 +423,12 @@ pub struct ChannelName {
    pub name: TextStyle,
 }

-#[derive(Clone, Deserialize, Default)]
+#[derive(Deserialize, Default)]
 pub struct Picker {
    #[serde(flatten)]
    pub container: ContainerStyle,
-    pub empty_container: ContainerStyle,
+    pub empty: ContainedLabel,
    pub input_editor: FieldEditor,
-    pub empty_input_editor: FieldEditor,
-    pub no_matches: ContainedLabel,
    pub item: Interactive<ContainedLabel>,
 }

--- a/crates/theme_selector/src/theme_selector.rs
+++ b/crates/theme_selector/src/theme_selector.rs
@@ -38,7 +38,7 @@ pub enum Event {
 impl ThemeSelector {
    fn new(registry: Arc<ThemeRegistry>, cx: &mut ViewContext<Self>) -> Self {
        let handle = cx.weak_handle();
-        let picker = cx.add_view(|cx| Picker::new("Select Theme...", handle, cx));
+        let picker = cx.add_view(|cx| Picker::new(handle, cx));
        let settings = cx.global::<Settings>();

        let original_theme = settings.theme.clone();
--- a/crates/theme_testbench/Cargo.toml
+++ b/crates/theme_testbench/Cargo.toml
@@ -15,4 +15,4 @@ settings = { path = "../settings" }
 workspace = { path = "../workspace" }
 project = { path = "../project" }

-smallvec = { version = "1.6", features = ["union"] }
+smallvec = { version = "1.6", features = ["union"] }
--- a/crates/vim/Cargo.toml
+++ b/crates/vim/Cargo.toml
@@ -42,4 +42,4 @@ language = { path = "../language", features = ["test-support"] }
 project = { path = "../project", features = ["test-support"] }
 util = { path = "../util", features = ["test-support"] }
 settings = { path = "../settings" }
-workspace = { path = "../workspace", features = ["test-support"] }
+workspace = { path = "../workspace", features = ["test-support"] }
--- a/crates/vim/src/insert.rs
+++ b/crates/vim/src/insert.rs
@@ -13,7 +13,7 @@ pub fn init(cx: &mut MutableAppContext) {
 fn normal_before(_: &mut Workspace, _: &NormalBefore, cx: &mut ViewContext<Workspace>) {
    Vim::update(cx, |state, cx| {
        state.update_active_editor(cx, |editor, cx| {
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.move_cursors_with(|map, mut cursor, _| {
                    *cursor.column_mut() = cursor.column().saturating_sub(1);
                    (map.clip_point(cursor, Bias::Left), SelectionGoal::None)
--- a/crates/vim/src/normal.rs
+++ b/crates/vim/src/normal.rs
@@ -114,7 +114,7 @@ pub fn normal_object(object: Object, cx: &mut MutableAppContext) {

 fn move_cursor(vim: &mut Vim, motion: Motion, times: usize, cx: &mut MutableAppContext) {
    vim.update_active_editor(cx, |editor, cx| {
-        editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+        editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
            s.move_cursors_with(|map, cursor, goal| {
                motion
                    .move_point(map, cursor, goal, times)
@@ -128,7 +128,7 @@ fn insert_after(_: &mut Workspace, _: &InsertAfter, cx: &mut ViewContext<Workspa
    Vim::update(cx, |vim, cx| {
        vim.switch_mode(Mode::Insert, false, cx);
        vim.update_active_editor(cx, |editor, cx| {
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.maybe_move_cursors_with(|map, cursor, goal| {
                    Motion::Right.move_point(map, cursor, goal, 1)
                });
@@ -145,7 +145,7 @@ fn insert_first_non_whitespace(
    Vim::update(cx, |vim, cx| {
        vim.switch_mode(Mode::Insert, false, cx);
        vim.update_active_editor(cx, |editor, cx| {
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.maybe_move_cursors_with(|map, cursor, goal| {
                    Motion::FirstNonWhitespace.move_point(map, cursor, goal, 1)
                });
@@ -158,7 +158,7 @@ fn insert_end_of_line(_: &mut Workspace, _: &InsertEndOfLine, cx: &mut ViewConte
    Vim::update(cx, |vim, cx| {
        vim.switch_mode(Mode::Insert, false, cx);
        vim.update_active_editor(cx, |editor, cx| {
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.maybe_move_cursors_with(|map, cursor, goal| {
                    Motion::EndOfLine.move_point(map, cursor, goal, 1)
                });
@@ -187,7 +187,7 @@ fn insert_line_above(_: &mut Workspace, _: &InsertLineAbove, cx: &mut ViewContex
                    (start_of_line..start_of_line, new_text)
                });
                editor.edit_with_autoindent(edits, cx);
-                editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                    s.move_cursors_with(|map, mut cursor, _| {
                        *cursor.row_mut() -= 1;
                        *cursor.column_mut() = map.line_len(cursor.row());
@@ -218,7 +218,7 @@ fn insert_line_below(_: &mut Workspace, _: &InsertLineBelow, cx: &mut ViewContex
                    new_text.push_str(&" ".repeat(indent as usize));
                    (end_of_line..end_of_line, new_text)
                });
-                editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                    s.maybe_move_cursors_with(|map, cursor, goal| {
                        Motion::EndOfLine.move_point(map, cursor, goal, 1)
                    });
@@ -336,7 +336,7 @@ fn paste(_: &mut Workspace, _: &Paste, cx: &mut ViewContext<Workspace>) {
                            buffer.edit(edits, Some(AutoindentMode::EachLine), cx);
                        });

-                        editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                        editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                            s.move_with(|map, selection| {
                                if let Some(new_position) = new_selections.get(&selection.id) {
                                    match new_position {
--- a/crates/vim/src/normal/change.rs
+++ b/crates/vim/src/normal/change.rs
@@ -15,7 +15,7 @@ pub fn change_motion(vim: &mut Vim, motion: Motion, times: usize, cx: &mut Mutab
        editor.transact(cx, |editor, cx| {
            // We are swapping to insert mode anyway. Just set the line end clipping behavior now
            editor.set_clip_at_line_ends(false, cx);
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.move_with(|map, selection| {
                    motion_succeeded |= if let Motion::NextWordStart { ignore_punctuation } = motion
                    {
@@ -43,7 +43,7 @@ pub fn change_object(vim: &mut Vim, object: Object, around: bool, cx: &mut Mutab
        // We are swapping to insert mode anyway. Just set the line end clipping behavior now
        editor.set_clip_at_line_ends(false, cx);
        editor.transact(cx, |editor, cx| {
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.move_with(|map, selection| {
                    objects_found |= object.expand_selection(map, selection, around);
                });
--- a/crates/vim/src/normal/delete.rs
+++ b/crates/vim/src/normal/delete.rs
@@ -8,7 +8,7 @@ pub fn delete_motion(vim: &mut Vim, motion: Motion, times: usize, cx: &mut Mutab
        editor.transact(cx, |editor, cx| {
            editor.set_clip_at_line_ends(false, cx);
            let mut original_columns: HashMap<_, _> = Default::default();
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.move_with(|map, selection| {
                    let original_head = selection.head();
                    original_columns.insert(selection.id, original_head.column());
@@ -20,7 +20,7 @@ pub fn delete_motion(vim: &mut Vim, motion: Motion, times: usize, cx: &mut Mutab

            // Fixup cursor position after the deletion
            editor.set_clip_at_line_ends(true, cx);
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.move_with(|map, selection| {
                    let mut cursor = selection.head();
                    if motion.linewise() {
@@ -43,7 +43,7 @@ pub fn delete_object(vim: &mut Vim, object: Object, around: bool, cx: &mut Mutab
            // Emulates behavior in vim where if we expanded backwards to include a newline
            // the cursor gets set back to the start of the line
            let mut should_move_to_start: HashSet<_> = Default::default();
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.move_with(|map, selection| {
                    object.expand_selection(map, selection, around);
                    let offset_range = selection.map(|p| p.to_offset(map, Bias::Left)).range();
@@ -78,7 +78,7 @@ pub fn delete_object(vim: &mut Vim, object: Object, around: bool, cx: &mut Mutab

            // Fixup cursor position after the deletion
            editor.set_clip_at_line_ends(true, cx);
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.move_with(|map, selection| {
                    let mut cursor = selection.head();
                    if should_move_to_start.contains(&selection.id) {
--- a/crates/vim/src/test/vim_test_context.rs
+++ b/crates/vim/src/test/vim_test_context.rs
@@ -67,9 +67,7 @@ impl<'a> VimTestContext<'a> {

        let file = cx.read(|cx| workspace.file_project_paths(cx)[0].clone());
        let item = workspace
-            .update(cx, |workspace, cx| {
-                workspace.open_path(file, None, true, cx)
-            })
+            .update(cx, |workspace, cx| workspace.open_path(file, true, cx))
            .await
            .expect("Could not open test file");

--- a/crates/vim/src/visual.rs
+++ b/crates/vim/src/visual.rs
@@ -26,7 +26,7 @@ pub fn init(cx: &mut MutableAppContext) {
 pub fn visual_motion(motion: Motion, times: usize, cx: &mut MutableAppContext) {
    Vim::update(cx, |vim, cx| {
        vim.update_active_editor(cx, |editor, cx| {
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.move_with(|map, selection| {
                    let was_reversed = selection.reversed;

@@ -58,7 +58,7 @@ pub fn visual_object(object: Object, cx: &mut MutableAppContext) {
    Vim::update(cx, |vim, cx| {
        if let Operator::Object { around } = vim.pop_operator(cx) {
            vim.update_active_editor(cx, |editor, cx| {
-                editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                    s.move_with(|map, selection| {
                        let head = selection.head();
                        if let Some(mut range) = object.range(map, head, around) {
@@ -126,7 +126,7 @@ pub fn change(_: &mut Workspace, _: &VisualChange, cx: &mut ViewContext<Workspac
            });
            copy_selections_content(editor, editor.selections.line_mode, cx);
            editor.edit_with_autoindent(edits, cx);
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.select_anchors(new_selections);
            });
        });
@@ -140,7 +140,7 @@ pub fn delete(_: &mut Workspace, _: &VisualDelete, cx: &mut ViewContext<Workspac
            editor.set_clip_at_line_ends(false, cx);
            let mut original_columns: HashMap<_, _> = Default::default();
            let line_mode = editor.selections.line_mode;
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.move_with(|map, selection| {
                    if line_mode {
                        original_columns
@@ -159,7 +159,7 @@ pub fn delete(_: &mut Workspace, _: &VisualDelete, cx: &mut ViewContext<Workspac

            // Fixup cursor position after the deletion
            editor.set_clip_at_line_ends(true, cx);
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.move_with(|map, selection| {
                    let mut cursor = selection.head().to_point(map);

@@ -298,7 +298,7 @@ pub fn paste(_: &mut Workspace, _: &VisualPaste, cx: &mut ViewContext<Workspace>
                            buffer.edit(edits, Some(AutoindentMode::EachLine), cx);
                        });

-                        editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                        editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                            s.select(new_selections)
                        });
                    } else {
--- a/crates/workspace/Cargo.toml
+++ b/crates/workspace/Cargo.toml
@@ -46,4 +46,4 @@ client = { path = "../client", features = ["test-support"] }
 gpui = { path = "../gpui", features = ["test-support"] }
 project = { path = "../project", features = ["test-support"] }
 settings = { path = "../settings", features = ["test-support"] }
-fs = { path = "../fs", features = ["test-support"] }
+fs = { path = "../fs", features = ["test-support"] }
--- a/crates/workspace/src/pane/dragged_item_receiver.rs
+++ b/crates/workspace/src/pane/dragged_item_receiver.rs
@@ -7,13 +7,9 @@ use gpui::{
    AppContext, Element, ElementBox, EventContext, MouseButton, MouseState, Quad, RenderContext,
    WeakViewHandle,
 };
-use project::ProjectEntryId;
 use settings::Settings;

-use crate::{
-    MoveItem, OpenProjectEntryInPane, Pane, SplitDirection, SplitWithItem, SplitWithProjectEntry,
-    Workspace,
-};
+use crate::{MoveItem, Pane, SplitDirection, SplitWithItem, Workspace};

 use super::DraggedItem;

@@ -32,18 +28,12 @@ where
    MouseEventHandler::<Tag>::above(region_id, cx, |state, cx| {
        // Observing hovered will cause a render when the mouse enters regardless
        // of if mouse position was accessed before
-        let drag_position = if state.hovered() {
-            cx.global::<DragAndDrop<Workspace>>()
-                .currently_dragged::<DraggedItem>(cx.window_id())
-                .map(|(drag_position, _)| drag_position)
-                .or_else(|| {
-                    cx.global::<DragAndDrop<Workspace>>()
-                        .currently_dragged::<ProjectEntryId>(cx.window_id())
-                        .map(|(drag_position, _)| drag_position)
-                })
-        } else {
-            None
-        };
+        let hovered = state.hovered();
+        let drag_position = cx
+            .global::<DragAndDrop<Workspace>>()
+            .currently_dragged::<DraggedItem>(cx.window_id())
+            .filter(|_| hovered)
+            .map(|(drag_position, _)| drag_position);

        Stack::new()
            .with_child(render_child(state, cx))
@@ -80,14 +70,10 @@ where
        }
    })
    .on_move(|_, cx| {
-        let drag_and_drop = cx.global::<DragAndDrop<Workspace>>();
-
-        if drag_and_drop
+        if cx
+            .global::<DragAndDrop<Workspace>>()
            .currently_dragged::<DraggedItem>(cx.window_id())
            .is_some()
-            || drag_and_drop
-                .currently_dragged::<ProjectEntryId>(cx.window_id())
-                .is_some()
        {
            cx.notify();
        } else {
@@ -104,60 +90,30 @@ pub fn handle_dropped_item(
    split_margin: Option<f32>,
    cx: &mut EventContext,
 ) {
-    enum Action {
-        Move(WeakViewHandle<Pane>, usize),
-        Open(ProjectEntryId),
-    }
-    let drag_and_drop = cx.global::<DragAndDrop<Workspace>>();
-    let action = if let Some((_, dragged_item)) =
-        drag_and_drop.currently_dragged::<DraggedItem>(cx.window_id)
+    if let Some((_, dragged_item)) = cx
+        .global::<DragAndDrop<Workspace>>()
+        .currently_dragged::<DraggedItem>(cx.window_id)
    {
-        Action::Move(dragged_item.pane.clone(), dragged_item.item.id())
-    } else if let Some((_, project_entry)) =
-        drag_and_drop.currently_dragged::<ProjectEntryId>(cx.window_id)
-    {
-        Action::Open(*project_entry)
+        if let Some(split_direction) = split_margin
+            .and_then(|margin| drop_split_direction(event.position, event.region, margin))
+        {
+            cx.dispatch_action(SplitWithItem {
+                from: dragged_item.pane.clone(),
+                item_id_to_move: dragged_item.item.id(),
+                pane_to_split: pane.clone(),
+                split_direction,
+            });
+        } else if pane != &dragged_item.pane || allow_same_pane {
+            // If no split margin or not close enough to the edge, just move the item
+            cx.dispatch_action(MoveItem {
+                item_id: dragged_item.item.id(),
+                from: dragged_item.pane.clone(),
+                to: pane.clone(),
+                destination_index: index,
+            })
+        }
    } else {
        cx.propagate_event();
-        return;
-    };
-
-    if let Some(split_direction) =
-        split_margin.and_then(|margin| drop_split_direction(event.position, event.region, margin))
-    {
-        let pane_to_split = pane.clone();
-        match action {
-            Action::Move(from, item_id_to_move) => cx.dispatch_action(SplitWithItem {
-                from,
-                item_id_to_move,
-                pane_to_split,
-                split_direction,
-            }),
-            Action::Open(project_entry) => cx.dispatch_action(SplitWithProjectEntry {
-                pane_to_split,
-                split_direction,
-                project_entry,
-            }),
-        };
-    } else {
-        match action {
-            Action::Move(from, item_id) => {
-                if pane != &from || allow_same_pane {
-                    cx.dispatch_action(MoveItem {
-                        item_id,
-                        from,
-                        to: pane.clone(),
-                        destination_index: index,
-                    })
-                } else {
-                    cx.propagate_event();
-                }
-            }
-            Action::Open(project_entry) => cx.dispatch_action(OpenProjectEntryInPane {
-                pane: pane.clone(),
-                project_entry,
-            }),
-        }
    }
 }

--- a/crates/workspace/src/pane_group.rs
+++ b/crates/workspace/src/pane_group.rs
@@ -8,7 +8,6 @@ use gpui::{
 };
 use project::Project;
 use serde::Deserialize;
-use settings::Settings;
 use theme::Theme;

 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -64,17 +63,10 @@ impl PaneGroup {
        theme: &Theme,
        follower_states: &FollowerStatesByLeader,
        active_call: Option<&ModelHandle<ActiveCall>>,
-        active_pane: &ViewHandle<Pane>,
        cx: &mut RenderContext<Workspace>,
    ) -> ElementBox {
-        self.root.render(
-            project,
-            theme,
-            follower_states,
-            active_call,
-            active_pane,
-            cx,
-        )
+        self.root
+            .render(project, theme, follower_states, active_call, cx)
    }

    pub(crate) fn panes(&self) -> Vec<&ViewHandle<Pane>> {
@@ -112,20 +104,12 @@ impl Member {
        Member::Axis(PaneAxis { axis, members })
    }

-    fn contains(&self, needle: &ViewHandle<Pane>) -> bool {
-        match self {
-            Member::Axis(axis) => axis.members.iter().any(|member| member.contains(needle)),
-            Member::Pane(pane) => pane == needle,
-        }
-    }
-
    pub fn render(
        &self,
        project: &ModelHandle<Project>,
        theme: &Theme,
        follower_states: &FollowerStatesByLeader,
        active_call: Option<&ModelHandle<ActiveCall>>,
-        active_pane: &ViewHandle<Pane>,
        cx: &mut RenderContext<Workspace>,
    ) -> ElementBox {
        enum FollowIntoExternalProject {}
@@ -252,14 +236,7 @@ impl Member {
                    .with_children(prompt)
                    .boxed()
            }
-            Member::Axis(axis) => axis.render(
-                project,
-                theme,
-                follower_states,
-                active_call,
-                active_pane,
-                cx,
-            ),
+            Member::Axis(axis) => axis.render(project, theme, follower_states, active_call, cx),
        }
    }

@@ -360,19 +337,12 @@ impl PaneAxis {
        theme: &Theme,
        follower_state: &FollowerStatesByLeader,
        active_call: Option<&ModelHandle<ActiveCall>>,
-        active_pane: &ViewHandle<Pane>,
        cx: &mut RenderContext<Workspace>,
    ) -> ElementBox {
        let last_member_ix = self.members.len() - 1;
        Flex::new(self.axis)
            .with_children(self.members.iter().enumerate().map(|(ix, member)| {
-                let mut flex = 1.0;
-                if member.contains(active_pane) {
-                    flex = cx.global::<Settings>().active_pane_magnification;
-                }
-
-                let mut member =
-                    member.render(project, theme, follower_state, active_call, active_pane, cx);
+                let mut member = member.render(project, theme, follower_state, active_call, cx);
                if ix < last_member_ix {
                    let mut border = theme.workspace.pane_divider;
                    border.left = false;
@@ -386,7 +356,7 @@ impl PaneAxis {
                    member = Container::new(member).with_border(border).boxed();
                }

-                FlexItem::new(member).flex(flex, true).boxed()
+                FlexItem::new(member).flex(1.0, true).boxed()
            }))
            .boxed()
    }
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -128,23 +128,10 @@ pub struct OpenSharedScreen {

 #[derive(Clone, PartialEq)]
 pub struct SplitWithItem {
-    pane_to_split: WeakViewHandle<Pane>,
-    split_direction: SplitDirection,
    from: WeakViewHandle<Pane>,
-    item_id_to_move: usize,
-}
-
-#[derive(Clone, PartialEq)]
-pub struct SplitWithProjectEntry {
    pane_to_split: WeakViewHandle<Pane>,
    split_direction: SplitDirection,
-    project_entry: ProjectEntryId,
-}
-
-#[derive(Clone, PartialEq)]
-pub struct OpenProjectEntryInPane {
-    pane: WeakViewHandle<Pane>,
-    project_entry: ProjectEntryId,
+    item_id_to_move: usize,
 }

 impl_internal_actions!(
@@ -156,8 +143,6 @@ impl_internal_actions!(
        OpenSharedScreen,
        RemoveWorktreeFromProject,
        SplitWithItem,
-        SplitWithProjectEntry,
-        OpenProjectEntryInPane,
    ]
 );
 impl_actions!(workspace, [ActivatePane]);
@@ -249,57 +234,6 @@ pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
        },
    );

-    cx.add_async_action(
-        |workspace: &mut Workspace,
-         SplitWithProjectEntry {
-             pane_to_split,
-             split_direction,
-             project_entry,
-         }: &_,
-         cx| {
-            pane_to_split.upgrade(cx).and_then(|pane_to_split| {
-                let new_pane = workspace.add_pane(cx);
-                workspace
-                    .center
-                    .split(&pane_to_split, &new_pane, *split_direction)
-                    .unwrap();
-
-                workspace
-                    .project
-                    .read(cx)
-                    .path_for_entry(*project_entry, cx)
-                    .map(|path| {
-                        let task = workspace.open_path(path, Some(new_pane.downgrade()), true, cx);
-                        cx.foreground().spawn(async move {
-                            task.await?;
-                            Ok(())
-                        })
-                    })
-            })
-        },
-    );
-
-    cx.add_async_action(
-        |workspace: &mut Workspace,
-         OpenProjectEntryInPane {
-             pane,
-             project_entry,
-         }: &_,
-         cx| {
-            workspace
-                .project
-                .read(cx)
-                .path_for_entry(*project_entry, cx)
-                .map(|path| {
-                    let task = workspace.open_path(path, Some(pane.clone()), true, cx);
-                    cx.foreground().spawn(async move {
-                        task.await?;
-                        Ok(())
-                    })
-                })
-        },
-    );
-
    let client = &app_state.client;
    client.add_view_request_handler(Workspace::handle_follow);
    client.add_view_message_handler(Workspace::handle_unfollow);
@@ -1465,7 +1399,7 @@ impl Workspace {
        mut abs_paths: Vec<PathBuf>,
        visible: bool,
        cx: &mut ViewContext<Self>,
-    ) -> Task<Vec<Option<Result<Box<dyn ItemHandle>, anyhow::Error>>>> {
+    ) -> Task<Vec<Option<Result<Box<dyn ItemHandle>, Arc<anyhow::Error>>>>> {
        let fs = self.fs.clone();

        // Sort the paths to ensure we add worktrees for parents before their children.
@@ -1495,7 +1429,7 @@ impl Workspace {
                            if fs.is_file(&abs_path).await {
                                Some(
                                    this.update(&mut cx, |this, cx| {
-                                        this.open_path(project_path, None, true, cx)
+                                        this.open_path(project_path, true, cx)
                                    })
                                    .await,
                                )
@@ -1815,11 +1749,10 @@ impl Workspace {
    pub fn open_path(
        &mut self,
        path: impl Into<ProjectPath>,
-        pane: Option<WeakViewHandle<Pane>>,
        focus_item: bool,
        cx: &mut ViewContext<Self>,
-    ) -> Task<Result<Box<dyn ItemHandle>, anyhow::Error>> {
-        let pane = pane.unwrap_or_else(|| self.active_pane().downgrade());
+    ) -> Task<Result<Box<dyn ItemHandle>, Arc<anyhow::Error>>> {
+        let pane = self.active_pane().downgrade();
        let task = self.load_path(path.into(), cx);
        cx.spawn(|this, mut cx| async move {
            let (project_entry_id, build_item) = task.await?;
@@ -2787,7 +2720,6 @@ impl View for Workspace {
                                                        &theme,
                                                        &self.follower_states_by_leader,
                                                        self.active_call(),
-                                                        self.active_pane(),
                                                        cx,
                                                    ))
                                                    .flex(1., true)
@@ -2942,7 +2874,7 @@ pub fn open_paths(
    cx: &mut MutableAppContext,
 ) -> Task<(
    ViewHandle<Workspace>,
-    Vec<Option<Result<Box<dyn ItemHandle>, anyhow::Error>>>,
+    Vec<Option<Result<Box<dyn ItemHandle>, Arc<anyhow::Error>>>>,
 )> {
    log::info!("open paths {:?}", abs_paths);

--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -3,7 +3,7 @@ authors = ["Nathan Sobo <nathansobo@gmail.com>"]
 description = "The fast, collaborative code editor."
 edition = "2021"
 name = "zed"
-version = "0.66.0"
+version = "0.63.4"

 [lib]
 name = "zed"
@@ -95,7 +95,6 @@ tree-sitter-c = "0.20.1"
 tree-sitter-cpp = "0.20.0"
 tree-sitter-css = { git = "https://github.com/tree-sitter/tree-sitter-css", rev = "769203d0f9abe1a9a691ac2b9fe4bb4397a73c51" }
 tree-sitter-elixir = { git = "https://github.com/elixir-lang/tree-sitter-elixir", rev = "05e3631c6a0701c1fa518b0fee7be95a2ceef5e2" }
-tree-sitter-embedded-template = "0.20.0"
 tree-sitter-go = { git = "https://github.com/tree-sitter/tree-sitter-go", rev = "aeb2f33b366fd78d5789ff104956ce23508b85db" }
 tree-sitter-json = { git = "https://github.com/tree-sitter/tree-sitter-json", rev = "137e1ce6a02698fc246cdb9c6b886ed1de9a1ed8" }
 tree-sitter-rust = "0.20.3"
@@ -103,7 +102,6 @@ tree-sitter-markdown = { git = "https://github.com/MDeiml/tree-sitter-markdown",
 tree-sitter-python = "0.20.2"
 tree-sitter-toml = { git = "https://github.com/tree-sitter/tree-sitter-toml", rev = "342d9be207c2dba869b9967124c679b5e6fd0ebe" }
 tree-sitter-typescript = "0.20.1"
-tree-sitter-ruby = "0.20.0"
 tree-sitter-html = "0.19.0"
 url = "2.2"

--- a/crates/zed/src/languages.rs
+++ b/crates/zed/src/languages.rs
@@ -12,19 +12,9 @@ mod installation;
 mod json;
 mod language_plugin;
 mod python;
-mod ruby;
 mod rust;
 mod typescript;

-// 1. Add tree-sitter-{language} parser to zed crate
-// 2. Create a language directory in zed/crates/zed/src/languages and add the language to init function below
-// 3. Add config.toml to the newly created language directory using existing languages as a template
-// 4. Copy highlights from tree sitter repo for the language into a highlights.scm file.
-//      Note: github highlights take the last match while zed takes the first
-// 5. Add indents.scm, outline.scm, and brackets.scm to implement indent on newline, outline/breadcrumbs,
-//    and autoclosing brackets respectively
-// 6. If the language has injections add an injections.scm query file
-
 #[derive(RustEmbed)]
 #[folder = "src/languages"]
 #[exclude = "*.rs"]
@@ -117,16 +107,6 @@ pub async fn init(languages: Arc<LanguageRegistry>, _executor: Arc<Background>)
            tree_sitter_html::language(),
            Some(CachedLspAdapter::new(html::HtmlLspAdapter).await),
        ),
-        (
-            "ruby",
-            tree_sitter_ruby::language(),
-            Some(CachedLspAdapter::new(ruby::RubyLanguageServer).await),
-        ),
-        (
-            "erb",
-            tree_sitter_embedded_template::language(),
-            Some(CachedLspAdapter::new(ruby::RubyLanguageServer).await),
-        ),
    ] {
        languages.add(language(name, grammar, lsp_adapter));
    }
--- a/crates/zed/src/languages/erb/config.toml
+++ b/crates/zed/src/languages/erb/config.toml
@@ -1,8 +0,0 @@
-name = "ERB"
-path_suffixes = ["erb"]
-autoclose_before = ">})"
-brackets = [
-    { start = "<", end = ">", close = true, newline = true },
-]
-
-block_comment = ["<%#", "%>"]
--- a/crates/zed/src/languages/erb/highlights.scm
+++ b/crates/zed/src/languages/erb/highlights.scm
@@ -1,12 +0,0 @@
-(comment_directive) @comment
-
-[
-  "<%#"
-  "<%"
-  "<%="
-  "<%_"
-  "<%-"
-  "%>"
-  "-%>"
-  "_%>"
-] @keyword
--- a/crates/zed/src/languages/erb/injections.scm
+++ b/crates/zed/src/languages/erb/injections.scm
@@ -1,7 +0,0 @@
-((code) @content
- (#set! "language" "ruby")
- (#set! "combined"))
-
-((content) @content
- (#set! "language" "html")
- (#set! "combined"))
--- a/crates/zed/src/languages/python.rs
+++ b/crates/zed/src/languages/python.rs
@@ -87,25 +87,6 @@ impl LspAdapter for PythonLspAdapter {
        .log_err()
    }

-    async fn process_completion(&self, item: &mut lsp::CompletionItem) {
-        // Pyright assigns each completion item a `sortText` of the form `XX.YYYY.name`.
-        // Where `XX` is the sorting category, `YYYY` is based on most recent usage,
-        // and `name` is the symbol name itself.
-        //
-        // Because the the symbol name is included, there generally are not ties when
-        // sorting by the `sortText`, so the symbol's fuzzy match score is not taken
-        // into account. Here, we remove the symbol name from the sortText in order
-        // to allow our own fuzzy score to be used to break ties.
-        //
-        // see https://github.com/microsoft/pyright/blob/95ef4e103b9b2f129c9320427e51b73ea7cf78bd/packages/pyright-internal/src/languageService/completionProvider.ts#LL2873
-        let Some(sort_text) = &mut item.sort_text else { return };
-        let mut parts = sort_text.split('.');
-        let Some(first) = parts.next() else { return };
-        let Some(second) = parts.next() else { return };
-        let Some(_) = parts.next() else { return };
-        sort_text.replace_range(first.len() + second.len() + 1.., "");
-    }
-
    async fn label_for_completion(
        &self,
        item: &lsp::CompletionItem,
--- a/crates/zed/src/languages/ruby.rs
+++ b/crates/zed/src/languages/ruby.rs
@@ -1,145 +0,0 @@
-use anyhow::{anyhow, Result};
-use async_trait::async_trait;
-use client::http::HttpClient;
-use language::{LanguageServerName, LspAdapter};
-use std::{any::Any, path::PathBuf, sync::Arc};
-
-pub struct RubyLanguageServer;
-
-#[async_trait]
-impl LspAdapter for RubyLanguageServer {
-    async fn name(&self) -> LanguageServerName {
-        LanguageServerName("solargraph".into())
-    }
-
-    async fn server_args(&self) -> Vec<String> {
-        vec!["stdio".into()]
-    }
-
-    async fn fetch_latest_server_version(
-        &self,
-        _: Arc<dyn HttpClient>,
-    ) -> Result<Box<dyn 'static + Any + Send>> {
-        Ok(Box::new(()))
-    }
-
-    async fn fetch_server_binary(
-        &self,
-        _version: Box<dyn 'static + Send + Any>,
-        _: Arc<dyn HttpClient>,
-        _container_dir: PathBuf,
-    ) -> Result<PathBuf> {
-        Err(anyhow!("solargraph must be installed manually"))
-    }
-
-    async fn cached_server_binary(&self, _container_dir: PathBuf) -> Option<PathBuf> {
-        Some("solargraph".into())
-    }
-
-    async fn label_for_completion(
-        &self,
-        item: &lsp::CompletionItem,
-        language: &Arc<language::Language>,
-    ) -> Option<language::CodeLabel> {
-        let label = &item.label;
-        let grammar = language.grammar()?;
-        let highlight_id = match item.kind? {
-            lsp::CompletionItemKind::METHOD => grammar.highlight_id_for_name("function.method")?,
-            lsp::CompletionItemKind::CONSTANT => grammar.highlight_id_for_name("constant")?,
-            lsp::CompletionItemKind::CLASS | lsp::CompletionItemKind::MODULE => {
-                grammar.highlight_id_for_name("type")?
-            }
-            lsp::CompletionItemKind::KEYWORD => {
-                if label.starts_with(":") {
-                    grammar.highlight_id_for_name("string.special.symbol")?
-                } else {
-                    grammar.highlight_id_for_name("keyword")?
-                }
-            }
-            lsp::CompletionItemKind::VARIABLE => {
-                if label.starts_with("@") {
-                    grammar.highlight_id_for_name("property")?
-                } else {
-                    return None;
-                }
-            }
-            _ => return None,
-        };
-        Some(language::CodeLabel {
-            text: label.clone(),
-            runs: vec![(0..label.len(), highlight_id)],
-            filter_range: 0..label.len(),
-        })
-    }
-
-    async fn label_for_symbol(
-        &self,
-        label: &str,
-        kind: lsp::SymbolKind,
-        language: &Arc<language::Language>,
-    ) -> Option<language::CodeLabel> {
-        let grammar = language.grammar()?;
-        match kind {
-            lsp::SymbolKind::METHOD => {
-                let mut parts = label.split('#');
-                let classes = parts.next()?;
-                let method = parts.next()?;
-                if parts.next().is_some() {
-                    return None;
-                }
-
-                let class_id = grammar.highlight_id_for_name("type")?;
-                let method_id = grammar.highlight_id_for_name("function.method")?;
-
-                let mut ix = 0;
-                let mut runs = Vec::new();
-                for (i, class) in classes.split("::").enumerate() {
-                    if i > 0 {
-                        ix += 2;
-                    }
-                    let end_ix = ix + class.len();
-                    runs.push((ix..end_ix, class_id));
-                    ix = end_ix;
-                }
-
-                ix += 1;
-                let end_ix = ix + method.len();
-                runs.push((ix..end_ix, method_id));
-                Some(language::CodeLabel {
-                    text: label.to_string(),
-                    runs,
-                    filter_range: 0..label.len(),
-                })
-            }
-            lsp::SymbolKind::CONSTANT => {
-                let constant_id = grammar.highlight_id_for_name("constant")?;
-                Some(language::CodeLabel {
-                    text: label.to_string(),
-                    runs: vec![(0..label.len(), constant_id)],
-                    filter_range: 0..label.len(),
-                })
-            }
-            lsp::SymbolKind::CLASS | lsp::SymbolKind::MODULE => {
-                let class_id = grammar.highlight_id_for_name("type")?;
-
-                let mut ix = 0;
-                let mut runs = Vec::new();
-                for (i, class) in label.split("::").enumerate() {
-                    if i > 0 {
-                        ix += "::".len();
-                    }
-                    let end_ix = ix + class.len();
-                    runs.push((ix..end_ix, class_id));
-                    ix = end_ix;
-                }
-
-                Some(language::CodeLabel {
-                    text: label.to_string(),
-                    runs,
-                    filter_range: 0..label.len(),
-                })
-            }
-            _ => return None,
-        }
-    }
-}
--- a/crates/zed/src/languages/ruby/brackets.scm
+++ b/crates/zed/src/languages/ruby/brackets.scm
@@ -1,14 +0,0 @@
-("[" @open "]" @close)
-("{" @open "}" @close)
-("\"" @open "\"" @close)
-("do" @open "end" @close)
-
-(block_parameters "|" @open "|" @close)
-(interpolation "#{" @open "}" @close)
-
-(if "if" @open "end" @close)
-(unless "unless" @open "end" @close)
-(begin "begin" @open "end" @close)
-(module "module" @open "end" @close)
-(_ . "def" @open "end" @close)
-(_ . "class" @open "end" @close)
--- a/crates/zed/src/languages/ruby/config.toml
+++ b/crates/zed/src/languages/ruby/config.toml
@@ -1,11 +0,0 @@
-name = "Ruby"
-path_suffixes = ["rb", "Gemfile"]
-line_comment = "# "
-autoclose_before = ";:.,=}])>"
-brackets = [
-  { start = "{", end = "}", close = true, newline = true },
-  { start = "[", end = "]", close = true, newline = true },
-  { start = "(", end = ")", close = true, newline = true },
-  { start = "\"", end = "\"", close = true, newline = false },
-  { start = "'", end = "'", close = false, newline = false },
-]
--- a/crates/zed/src/languages/ruby/highlights.scm
+++ b/crates/zed/src/languages/ruby/highlights.scm
@@ -1,181 +0,0 @@
-; Keywords
-
-[
-  "alias"
-  "and"
-  "begin"
-  "break"
-  "case"
-  "class"
-  "def"
-  "do"
-  "else"
-  "elsif"
-  "end"
-  "ensure"
-  "for"
-  "if"
-  "in"
-  "module"
-  "next"
-  "or"
-  "rescue"
-  "retry"
-  "return"
-  "then"
-  "unless"
-  "until"
-  "when"
-  "while"
-  "yield"
-] @keyword
-
-(identifier) @variable
-
-((identifier) @keyword
- (#match? @keyword "^(private|protected|public)$"))
-
-; Function calls
-
-((identifier) @function.method.builtin
- (#eq? @function.method.builtin "require"))
-
-"defined?" @function.method.builtin
-
-(call
-  method: [(identifier) (constant)] @function.method)
-
-; Function definitions
-
-(alias (identifier) @function.method)
-(setter (identifier) @function.method)
-(method name: [(identifier) (constant)] @function.method)
-(singleton_method name: [(identifier) (constant)] @function.method)
-
-; Identifiers
-
-[
-  (class_variable)
-  (instance_variable)
-] @property
-
-((identifier) @constant.builtin
- (#match? @constant.builtin "^__(FILE|LINE|ENCODING)__$"))
-
-(file) @constant.builtin
-(line) @constant.builtin
-(encoding) @constant.builtin
-
-(hash_splat_nil
-  "**" @operator
-) @constant.builtin
-
-((constant) @constant
- (#match? @constant "^[A-Z\\d_]+$"))
-
-(constant) @type
-
-(self) @variable.special
-(super) @variable.special
-
-; Literals
-
-[
-  (string)
-  (bare_string)
-  (subshell)
-  (heredoc_body)
-  (heredoc_beginning)
-] @string
-
-[
-  (simple_symbol)
-  (delimited_symbol)
-  (hash_key_symbol)
-  (bare_symbol)
-] @string.special.symbol
-
-(regex) @string.special.regex
-(escape_sequence) @escape
-
-[
-  (integer)
-  (float)
-] @number
-
-[
-  (nil)
-  (true)
-  (false)
-] @constant.builtin
-
-(interpolation
-  "#{" @punctuation.special
-  "}" @punctuation.special) @embedded
-
-(comment) @comment
-
-; Operators
-
-[
-  "!"
-  "~"
-  "+"
-  "-"
-  "**"
-  "*"
-  "/"
-  "%"
-  "<<"
-  ">>"
-  "&"
-  "|"
-  "^"
-  ">"
-  "<"
-  "<="
-  ">="
-  "=="
-  "!="
-  "=~"
-  "!~"
-  "<=>"
-  "||"
-  "&&"
-  ".."
-  "..."
-  "="
-  "**="
-  "*="
-  "/="
-  "%="
-  "+="
-  "-="
-  "<<="
-  ">>="
-  "&&="
-  "&="
-  "||="
-  "|="
-  "^="
-  "=>"
-  "->"
-  (operator)
-] @operator
-
-[
-  ","
-  ";"
-  "."
-] @punctuation.delimiter
-
-[
-  "("
-  ")"
-  "["
-  "]"
-  "{"
-  "}"
-  "%w("
-  "%i("
-] @punctuation.bracket
--- a/crates/zed/src/languages/ruby/indents.scm
+++ b/crates/zed/src/languages/ruby/indents.scm
@@ -1,17 +0,0 @@
-(method "end" @end) @indent
-(class "end" @end) @indent
-(module "end" @end) @indent
-(begin "end" @end) @indent
-(do_block "end" @end) @indent
-
-(then) @indent
-(call) @indent
-
-(ensure) @outdent
-(rescue) @outdent
-(else) @outdent
-
-
-(_ "[" "]" @end) @indent
-(_ "{" "}" @end) @indent
-(_ "(" ")" @end) @indent
--- a/crates/zed/src/languages/ruby/outline.scm
+++ b/crates/zed/src/languages/ruby/outline.scm
@@ -1,11 +0,0 @@
-(class
-    "class" @context
-    name: (_) @name) @item
-
-(method
-    "def" @context
-    name: (_) @name) @item
-
-(module
-    "module" @context
-    name: (_) @name) @item
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -115,6 +115,7 @@ fn main() {

        context_menu::init(cx);
        project::Project::init(&client);
+        client::Channel::init(&client);
        client::init(client.clone(), cx);
        command_palette::init(cx);
        editor::init(cx);
@@ -213,6 +214,21 @@ fn init_paths() {
    std::fs::create_dir_all(&*zed::paths::LANGUAGES_DIR).expect("could not create languages path");
    std::fs::create_dir_all(&*zed::paths::DB_DIR).expect("could not create database path");
    std::fs::create_dir_all(&*zed::paths::LOGS_DIR).expect("could not create logs path");
+
+    // Copy setting files from legacy locations. TODO: remove this after a few releases.
+    thread::spawn(|| {
+        if std::fs::metadata(&*zed::paths::legacy::SETTINGS).is_ok()
+            && std::fs::metadata(&*zed::paths::SETTINGS).is_err()
+        {
+            std::fs::copy(&*zed::paths::legacy::SETTINGS, &*zed::paths::SETTINGS).log_err();
+        }
+
+        if std::fs::metadata(&*zed::paths::legacy::KEYMAP).is_ok()
+            && std::fs::metadata(&*zed::paths::KEYMAP).is_err()
+        {
+            std::fs::copy(&*zed::paths::legacy::KEYMAP, &*zed::paths::KEYMAP).log_err();
+        }
+    });
 }

 fn init_logger() {
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -818,7 +818,7 @@ mod tests {

        // Open the first entry
        let entry_1 = workspace
-            .update(cx, |w, cx| w.open_path(file1.clone(), None, true, cx))
+            .update(cx, |w, cx| w.open_path(file1.clone(), true, cx))
            .await
            .unwrap();
        cx.read(|cx| {
@@ -832,7 +832,7 @@ mod tests {

        // Open the second entry
        workspace
-            .update(cx, |w, cx| w.open_path(file2.clone(), None, true, cx))
+            .update(cx, |w, cx| w.open_path(file2.clone(), true, cx))
            .await
            .unwrap();
        cx.read(|cx| {
@@ -846,7 +846,7 @@ mod tests {

        // Open the first entry again. The existing pane item is activated.
        let entry_1b = workspace
-            .update(cx, |w, cx| w.open_path(file1.clone(), None, true, cx))
+            .update(cx, |w, cx| w.open_path(file1.clone(), true, cx))
            .await
            .unwrap();
        assert_eq!(entry_1.id(), entry_1b.id());
@@ -864,7 +864,7 @@ mod tests {
        workspace
            .update(cx, |w, cx| {
                w.split_pane(w.active_pane().clone(), SplitDirection::Right, cx);
-                w.open_path(file2.clone(), None, true, cx)
+                w.open_path(file2.clone(), true, cx)
            })
            .await
            .unwrap();
@@ -883,8 +883,8 @@ mod tests {
        // Open the third entry twice concurrently. Only one pane item is added.
        let (t1, t2) = workspace.update(cx, |w, cx| {
            (
-                w.open_path(file3.clone(), None, true, cx),
-                w.open_path(file3.clone(), None, true, cx),
+                w.open_path(file3.clone(), true, cx),
+                w.open_path(file3.clone(), true, cx),
            )
        });
        t1.await.unwrap();
@@ -1195,7 +1195,7 @@ mod tests {
        workspace
            .update(cx, |workspace, cx| {
                workspace.split_pane(workspace.active_pane().clone(), SplitDirection::Right, cx);
-                workspace.open_path((worktree.read(cx).id(), "the-new-name.rs"), None, true, cx)
+                workspace.open_path((worktree.read(cx).id(), "the-new-name.rs"), true, cx)
            })
            .await
            .unwrap();
@@ -1284,7 +1284,7 @@ mod tests {
        let pane_1 = cx.read(|cx| workspace.read(cx).active_pane().clone());

        workspace
-            .update(cx, |w, cx| w.open_path(file1.clone(), None, true, cx))
+            .update(cx, |w, cx| w.open_path(file1.clone(), true, cx))
            .await
            .unwrap();

@@ -1359,24 +1359,24 @@ mod tests {
        let file3 = entries[2].clone();

        let editor1 = workspace
-            .update(cx, |w, cx| w.open_path(file1.clone(), None, true, cx))
+            .update(cx, |w, cx| w.open_path(file1.clone(), true, cx))
            .await
            .unwrap()
            .downcast::<Editor>()
            .unwrap();
        editor1.update(cx, |editor, cx| {
-            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                s.select_display_ranges([DisplayPoint::new(10, 0)..DisplayPoint::new(10, 0)])
            });
        });
        let editor2 = workspace
-            .update(cx, |w, cx| w.open_path(file2.clone(), None, true, cx))
+            .update(cx, |w, cx| w.open_path(file2.clone(), true, cx))
            .await
            .unwrap()
            .downcast::<Editor>()
            .unwrap();
        let editor3 = workspace
-            .update(cx, |w, cx| w.open_path(file3.clone(), None, true, cx))
+            .update(cx, |w, cx| w.open_path(file3.clone(), true, cx))
            .await
            .unwrap()
            .downcast::<Editor>()
@@ -1384,7 +1384,7 @@ mod tests {

        editor3
            .update(cx, |editor, cx| {
-                editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                    s.select_display_ranges([DisplayPoint::new(12, 0)..DisplayPoint::new(12, 0)])
                });
                editor.newline(&Default::default(), cx);
@@ -1626,22 +1626,22 @@ mod tests {
        let file4 = entries[3].clone();

        let file1_item_id = workspace
-            .update(cx, |w, cx| w.open_path(file1.clone(), None, true, cx))
+            .update(cx, |w, cx| w.open_path(file1.clone(), true, cx))
            .await
            .unwrap()
            .id();
        let file2_item_id = workspace
-            .update(cx, |w, cx| w.open_path(file2.clone(), None, true, cx))
+            .update(cx, |w, cx| w.open_path(file2.clone(), true, cx))
            .await
            .unwrap()
            .id();
        let file3_item_id = workspace
-            .update(cx, |w, cx| w.open_path(file3.clone(), None, true, cx))
+            .update(cx, |w, cx| w.open_path(file3.clone(), true, cx))
            .await
            .unwrap()
            .id();
        let file4_item_id = workspace
-            .update(cx, |w, cx| w.open_path(file4.clone(), None, true, cx))
+            .update(cx, |w, cx| w.open_path(file4.clone(), true, cx))
            .await
            .unwrap()
            .id();
--- a/script/bootstrap
+++ b/script/bootstrap
@@ -7,7 +7,7 @@ echo "creating database..."
 script/sqlx database create

 echo "migrating database..."
-(cd crates/collab && cargo run -- migrate)
+cargo run -p collab -- migrate

 echo "seeding database..."
 script/seed-db
--- a/script/bump-zed-minor-versions
+++ b/script/bump-zed-minor-versions
@@ -15,6 +15,7 @@ if [[ $(git rev-parse --abbrev-ref HEAD) != "main" ]]; then
  exit 1
 fi
 git pull -q --ff-only origin main
+git fetch --tags

 # Parse the current version
 version=$(script/get-crate-version zed)
@@ -29,10 +30,6 @@ prev_minor_branch_name="v${major}.${prev_minor}.x"
 next_minor_branch_name="v${major}.${next_minor}.x"
 preview_tag_name="v${major}.${minor}.${patch}-pre"

-git fetch origin ${prev_minor_branch_name}:${prev_minor_branch_name}
-git fetch origin --tags
-cargo check -q
-
 function cleanup {
  git checkout -q main
 }
@@ -78,7 +75,6 @@ git commit -q --all --message "${prev_minor_branch_name} stable"
 git tag ${stable_tag_name}

 echo "Creating new preview branch ${minor_branch_name}..."
-git checkout -q main
 git checkout -q -b ${minor_branch_name}
 echo -n preview > crates/zed/RELEASE_CHANNEL
 git commit -q --all --message "${minor_branch_name} preview"
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Max Brunsfeld	b1d732e06c	zed 0.63.4	2022-11-10 09:28:16 -08:00
Max Brunsfeld	3ecbcf0cff	Fix bump-zed-patch-version script	2022-11-10 09:27:35 -08:00
Max Brunsfeld	2f7fad8480	Fix release channel parsing on stable	2022-11-10 09:25:43 -08:00
Nate Butler	d66e4901ea	Merge pull request #1868 from zed-industries/readd-search-match-highlight Update search match highlight and occurrence style	2022-11-09 17:08:16 -08:00
Max Brunsfeld	1375c6b9e5	0.63.x stable	2022-11-09 13:48:07 -08:00
Antonio Scandurra	4319745c52	zed 0.63.3	2022-11-08 18:23:01 +01:00
Antonio Scandurra	69d2b36788	Merge pull request #1862 from zed-industries/fix-catalina Weakly link ReplayKit to ensure this library can be used on macOS 10.15	2022-11-08 18:19:48 +01:00
Joseph T Lyons	eebc785e4c	zed 0.63.2	2022-11-04 18:35:09 -04:00
Kay Simmons	d109220e0d	Merge pull request #1857 from zed-industries/fix-unicode-vim-left fixes issue with left motion in vim mode clipping incorrectly	2022-11-04 18:33:11 -04:00
Nate Butler	a88a2e601d	Swap the color of diagnostic underlines to fix low contrast issue.	2022-11-04 18:33:11 -04:00
Kay Simmons	7cefb16086	Merge pull request #1845 from zed-industries/vim-dd-fix Vim dd fix	2022-11-04 18:33:11 -04:00
Joseph T. Lyons	c2c30f6615	Merge pull request #1855 from zed-industries/make-app-a-user-property-in-mixpanel Make `App` a user property in Mixpanel	2022-11-04 14:45:15 -04:00
Max Brunsfeld	bf9a1091e3	zed 0.63.1	2022-11-04 09:30:49 -07:00
Max Brunsfeld	e1f1a706a6	Merge pull request #1851 from zed-industries/rust-let-else Bump tree-sitter-rust for let-else, let-chains	2022-11-03 18:04:49 -07:00
Max Brunsfeld	75ebaabc2c	Merge pull request #1853 from zed-industries/diagnostics-focus-loop Fix infinite focus transfer loop in project diagnostics	2022-11-03 18:03:05 -07:00
Joseph T. Lyons	d608331f08	Merge pull request #1850 from zed-industries/add-automatic-annotations-for-mixpanel Add automatic annotations for mixpanel	2022-11-03 13:28:00 -04:00
Max Brunsfeld	448c472ee6	v0.63.x preview	2022-11-02 10:22:52 -07:00