zed 0.72.1

Merge pull request #2125 from zed-industries/trim-leading-and-trailing-whitespace-in-feedback
Trim leading and trailing whitespace in feedback
2023-02-06 14:24:41 -05:00 · 2023-02-06 14:19:33 -05:00 · 2023-02-06 14:15:58 -05:00 · 2023-02-03 08:35:55 -05:00 · 2023-02-02 14:41:59 -05:00 · 2023-02-01 13:44:50 -05:00
342 changed files with 9071 additions and 20649 deletions
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,6 +1,6 @@
 ## Description of feature or change

-## Link to related issues from zed or community
+## Link to related issues from zed or insiders

 ## Before Merging 

--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -17,26 +17,6 @@ env:
  RUST_BACKTRACE: 1

 jobs:
-  rustfmt:
-    name: Check formatting
-    runs-on:
-      - self-hosted
-      - test
-    steps:
-      - name: Install Rust
-        run: |
-          rustup set profile minimal
-          rustup update stable
-
-      - name: Checkout repo
-        uses: actions/checkout@v2
-        with:
-          clean: false
-          submodules: 'recursive'
-
-      - name: cargo fmt
-        run: cargo fmt --all -- --check
-
  tests:
    name: Run tests
    runs-on:
@@ -62,9 +42,6 @@ jobs:
          clean: false
          submodules: 'recursive'

-      - name: Run check
-        run: cargo check --workspace
-
      - name: Run tests
        run: cargo test --workspace --no-fail-fast

--- a/.github/workflows/release_actions.yml
+++ b/.github/workflows/release_actions.yml
@@ -21,6 +21,20 @@ jobs:

          ${{ github.event.release.body }}
          ```
+  discourse_release:
+    if: ${{ ! github.event.release.prerelease }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Node
+        uses: actions/setup-node@v2
+        with:
+          node-version: "19"
+      - run: >
+          node "./script/discourse_release"
+          ${{ secrets.DISCOURSE_RELEASES_API_KEY }}
+          ${{ github.event.release.tag_name }}
+          ${{ github.event.release.body }}
  mixpanel_release:
    runs-on: ubuntu-latest
    steps:
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -259,21 +259,6 @@ dependencies = [
 "futures-lite",
 ]

-[[package]]
-name = "async-global-executor"
-version = "2.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1b6f5d7df27bd294849f8eec66ecfc63d11814df7a4f5d74168a2394467b776"
-dependencies = [
- "async-channel",
- "async-executor",
- "async-io",
- "async-lock",
- "blocking",
- "futures-lite",
- "once_cell",
-]
-
 [[package]]
 name = "async-io"
 version = "1.12.0"
@@ -365,32 +350,6 @@ dependencies = [
 "syn",
 ]

-[[package]]
-name = "async-std"
-version = "1.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62565bb4402e926b29953c785397c6dc0391b7b446e45008b0049eb43cec6f5d"
-dependencies = [
- "async-channel",
- "async-global-executor",
- "async-io",
- "async-lock",
- "crossbeam-utils 0.8.14",
- "futures-channel",
- "futures-core",
- "futures-io",
- "futures-lite",
- "gloo-timers",
- "kv-log-macro",
- "log",
- "memchr",
- "once_cell",
- "pin-project-lite 0.2.9",
- "pin-utils",
- "slab",
- "wasm-bindgen-futures",
-]
-
 [[package]]
 name = "async-stream"
 version = "0.3.3"
@@ -412,20 +371,6 @@ dependencies = [
 "syn",
 ]

-[[package]]
-name = "async-tar"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c49359998a76e32ef6e870dbc079ebad8f1e53e8441c5dd39d27b44493fe331"
-dependencies = [
- "async-std",
- "filetime",
- "libc",
- "pin-project",
- "redox_syscall",
- "xattr",
-]
-
 [[package]]
 name = "async-task"
 version = "4.0.3"
@@ -794,7 +739,7 @@ dependencies = [
 [[package]]
 name = "bromberg_sl2"
 version = "0.6.0"
-source = "git+https://github.com/zed-industries/bromberg_sl2?rev=950bc5482c216c395049ae33ae4501e08975f17f#950bc5482c216c395049ae33ae4501e08975f17f"
+source = "git+https://github.com/zed-industries/bromberg_sl2?rev=dac565a90e8f9245f48ff46225c915dc50f76920#dac565a90e8f9245f48ff46225c915dc50f76920"
 dependencies = [
 "digest 0.9.0",
 "lazy_static",
@@ -883,7 +828,6 @@ dependencies = [
 "media",
 "postage",
 "project",
- "settings",
 "util",
 ]

@@ -1188,7 +1132,7 @@ dependencies = [

 [[package]]
 name = "collab"
-version = "0.8.0"
+version = "0.5.4"
 dependencies = [
 "anyhow",
 "async-tungstenite",
@@ -1252,14 +1196,11 @@ name = "collab_ui"
 version = "0.1.0"
 dependencies = [
 "anyhow",
- "auto_update",
 "call",
 "client",
 "clock",
 "collections",
- "context_menu",
 "editor",
- "feedback",
 "futures 0.3.25",
 "fuzzy",
 "gpui",
@@ -1959,7 +1900,6 @@ dependencies = [
 "tree-sitter-html",
 "tree-sitter-javascript",
 "tree-sitter-rust",
- "tree-sitter-typescript 0.20.2",
 "unindent",
 "util",
 "workspace",
@@ -2139,18 +2079,6 @@ dependencies = [
 "workspace",
 ]

-[[package]]
-name = "filetime"
-version = "0.2.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e884668cd0c7480504233e951174ddc3b382f7c2666e3b7310b5c4e7b0c37f9"
-dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "redox_syscall",
- "windows-sys 0.42.0",
-]
-
 [[package]]
 name = "fixedbitset"
 version = "0.4.2"
@@ -2599,18 +2527,6 @@ dependencies = [
 "regex",
 ]

-[[package]]
-name = "gloo-timers"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b995a66bb87bebce9a0f4a95aed01daca4872c050bfcb21653361c03bc35e5c"
-dependencies = [
- "futures-channel",
- "futures-core",
- "js-sys",
- "wasm-bindgen",
-]
-
 [[package]]
 name = "go_to_line"
 version = "0.1.0"
@@ -3019,17 +2935,6 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "adab1eaa3408fb7f0c777a73e7465fd5656136fc93b670eb6df3c88c2c1344e3"

-[[package]]
-name = "install_cli"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "gpui",
- "log",
- "smol",
- "util",
-]
-
 [[package]]
 name = "instant"
 version = "0.1.12"
@@ -3169,7 +3074,6 @@ dependencies = [
 name = "journal"
 version = "0.1.0"
 dependencies = [
- "anyhow",
 "chrono",
 "dirs 4.0.0",
 "editor",
@@ -3239,15 +3143,6 @@ dependencies = [
 "arrayvec 0.7.2",
 ]

-[[package]]
-name = "kv-log-macro"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0de8b303297635ad57c9f5059fd9cee7a47f8e8daa09df0fcd07dd39fb22977f"
-dependencies = [
- "log",
-]
-
 [[package]]
 name = "language"
 version = "0.1.0"
@@ -3265,7 +3160,6 @@ dependencies = [
 "fuzzy",
 "git",
 "gpui",
- "indoc",
 "lazy_static",
 "log",
 "lsp",
@@ -3292,28 +3186,12 @@ dependencies = [
 "tree-sitter-python",
 "tree-sitter-ruby",
 "tree-sitter-rust",
- "tree-sitter-typescript 0.20.1",
+ "tree-sitter-typescript",
 "unicase",
 "unindent",
 "util",
 ]

-[[package]]
-name = "language_selector"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "editor",
- "fuzzy",
- "gpui",
- "language",
- "picker",
- "project",
- "settings",
- "theme",
- "workspace",
-]
-
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -4621,7 +4499,6 @@ dependencies = [
 "lsp",
 "parking_lot 0.11.2",
 "postage",
- "pretty_assertions",
 "pulldown-cmark",
 "rand 0.8.5",
 "regex",
@@ -6138,6 +6015,7 @@ dependencies = [
 "libsqlite3-sys",
 "parking_lot 0.11.2",
 "smol",
+ "sqlez_macros",
 "thread_local",
 "uuid 1.2.2",
 ]
@@ -7036,7 +6914,7 @@ dependencies = [
 [[package]]
 name = "tree-sitter"
 version = "0.20.9"
-source = "git+https://github.com/tree-sitter/tree-sitter?rev=c51896d32dcc11a38e41f36e3deb1a6a9c4f4b14#c51896d32dcc11a38e41f36e3deb1a6a9c4f4b14"
+source = "git+https://github.com/tree-sitter/tree-sitter?rev=36b5b6c89e55ad1a502f8b3234bb3e12ec83a5da#36b5b6c89e55ad1a502f8b3234bb3e12ec83a5da"
 dependencies = [
 "cc",
 "regex",
@@ -7138,16 +7016,6 @@ dependencies = [
 "tree-sitter",
 ]

-[[package]]
-name = "tree-sitter-lua"
-version = "0.0.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d489873fd1a2fa6d5f04930bfc5c081c96f0c038c1437104518b5b842c69b282"
-dependencies = [
- "cc",
- "tree-sitter",
-]
-
 [[package]]
 name = "tree-sitter-markdown"
 version = "0.0.1"
@@ -7224,24 +7092,6 @@ dependencies = [
 "tree-sitter",
 ]

-[[package]]
-name = "tree-sitter-typescript"
-version = "0.20.2"
-source = "git+https://github.com/tree-sitter/tree-sitter-typescript?rev=5d20856f34315b068c41edaee2ac8a100081d259#5d20856f34315b068c41edaee2ac8a100081d259"
-dependencies = [
- "cc",
- "tree-sitter",
-]
-
-[[package]]
-name = "tree-sitter-yaml"
-version = "0.0.1"
-source = "git+https://github.com/zed-industries/tree-sitter-yaml?rev=9050a4a4a847ed29e25485b1292a36eab8ae3492#9050a4a4a847ed29e25485b1292a36eab8ae3492"
-dependencies = [
- "cc",
- "tree-sitter",
-]
-
 [[package]]
 name = "try-lock"
 version = "0.2.3"
@@ -8042,26 +7892,6 @@ version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9193164d4de03a926d909d3bc7c30543cecb35400c02114792c2cae20d5e2dbb"

-[[package]]
-name = "welcome"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "db",
- "editor",
- "fuzzy",
- "gpui",
- "install_cli",
- "log",
- "picker",
- "project",
- "settings",
- "theme",
- "theme_selector",
- "util",
- "workspace",
-]
-
 [[package]]
 name = "wepoll-ffi"
 version = "0.1.2"
@@ -8337,7 +8167,6 @@ dependencies = [
 "futures 0.3.25",
 "gpui",
 "indoc",
- "install_cli",
 "language",
 "lazy_static",
 "log",
@@ -8349,7 +8178,6 @@ dependencies = [
 "serde_json",
 "settings",
 "smallvec",
- "terminal",
 "theme",
 "util",
 "uuid 1.2.2",
@@ -8365,15 +8193,6 @@ dependencies = [
 "winapi-build",
 ]

-[[package]]
-name = "xattr"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d1526bbe5aaeb5eb06885f4d987bcdfa5e23187055de9b83fe00156a821fabc"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "xml-rs"
 version = "0.8.4"
@@ -8409,14 +8228,13 @@ checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"

 [[package]]
 name = "zed"
-version = "0.78.1"
+version = "0.72.1"
 dependencies = [
 "activity_indicator",
 "anyhow",
 "assets",
 "async-compression",
 "async-recursion 0.3.2",
- "async-tar",
 "async-trait",
 "auto_update",
 "backtrace",
@@ -8431,7 +8249,6 @@ dependencies = [
 "command_palette",
 "context_menu",
 "ctor",
- "db",
 "diagnostics",
 "easy-parallel",
 "editor",
@@ -8447,11 +8264,9 @@ dependencies = [
 "ignore",
 "image",
 "indexmap",
- "install_cli",
 "isahc",
 "journal",
 "language",
- "language_selector",
 "lazy_static",
 "libc",
 "log",
@@ -8497,7 +8312,6 @@ dependencies = [
 "tree-sitter-go",
 "tree-sitter-html",
 "tree-sitter-json 0.20.0",
- "tree-sitter-lua",
 "tree-sitter-markdown",
 "tree-sitter-python",
 "tree-sitter-racket",
@@ -8505,15 +8319,13 @@ dependencies = [
 "tree-sitter-rust",
 "tree-sitter-scheme",
 "tree-sitter-toml",
- "tree-sitter-typescript 0.20.2",
- "tree-sitter-yaml",
+ "tree-sitter-typescript",
 "unindent",
 "url",
 "urlencoding",
 "util",
 "uuid 1.2.2",
 "vim",
- "welcome",
 "workspace",
 ]

--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,10 +26,8 @@ members = [
    "crates/go_to_line",
    "crates/gpui",
    "crates/gpui_macros",
-    "crates/install_cli",
    "crates/journal",
    "crates/language",
-    "crates/language_selector",
    "crates/live_kit_client",
    "crates/live_kit_server",
    "crates/lsp",
@@ -60,7 +58,6 @@ members = [
    "crates/util",
    "crates/vim",
    "crates/workspace",
-    "crates/welcome",
    "crates/zed",
 ]
 default-members = ["crates/zed"]
@@ -72,7 +69,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 = "c51896d32dcc11a38e41f36e3deb1a6a9c4f4b14" }
+tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "36b5b6c89e55ad1a502f8b3234bb3e12ec83a5da" }
 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/README.md
+++ b/README.md
@@ -23,18 +23,10 @@ Welcome to Zed, a lightning-fast, collaborative code editor that makes your drea
    git clone https://github.com/zed-industries/zed.dev
    ```

-* Initialize submodules
-
-    ```
-    git submodule update --init --recursive
-    ```
-
 * Set up a local `zed` database and seed it with some initial users:

-    Create a personal GitHub token to run `script/bootstrap` once successfully. Then delete that token.
-
    ```
-    GITHUB_TOKEN=<$token> script/bootstrap
+    script/bootstrap
    ```

 ### Testing against locally-running servers
@@ -59,7 +51,7 @@ If you trigger `cmd-alt-i`, Zed will copy a JSON representation of the current w

 ### Licensing

-We use [`cargo-about`](https://github.com/EmbarkStudios/cargo-about) to automatically comply with open source licenses. If CI is failing, check the following:
+We use `[cargo-about](https://github.com/EmbarkStudios/cargo-about)` to automatically comply with open source licenses. If CI is failing, check the following:

 - Is it showing a `no license specified` error for a crate you've created? If so, add `publish = false` under `[package]` in your crate's Cargo.toml.
 - Is the error `failed to satisfy license requirements` for a dependency? If so, first determine what license the project has and whether this system is sufficient to comply with this license's requirements. If you're unsure, ask a lawyer. Once you've verified that this system is acceptable add the license's SPDX identifier to the `accepted` array in `script/licenses/zed-licenses.toml`.
--- a/assets/icons/ellipsis_14.svg
+++ b/assets/icons/ellipsis_14.svg
@@ -1,3 +0,0 @@
-<svg width="14" height="4" viewBox="0 0 14 4" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M3.125 2C3.125 2.62132 2.62132 3.125 2 3.125C1.37868 3.125 0.875 2.62132 0.875 2C0.875 1.37868 1.37868 0.875 2 0.875C2.62132 0.875 3.125 1.37868 3.125 2ZM8.125 2C8.125 2.62132 7.62132 3.125 7 3.125C6.37868 3.125 5.875 2.62132 5.875 2C5.875 1.37868 6.37868 0.875 7 0.875C7.62132 0.875 8.125 1.37868 8.125 2ZM12 3.125C12.6213 3.125 13.125 2.62132 13.125 2C13.125 1.37868 12.6213 0.875 12 0.875C11.3787 0.875 10.875 1.37868 10.875 2C10.875 2.62132 11.3787 3.125 12 3.125Z" fill="#ABB2BF"/>
-</svg>
--- a/assets/icons/leave_12.svg
+++ b/assets/icons/leave_12.svg
@@ -1,3 +0,0 @@
-<svg width="12" height="12" viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M0 1C0 0.585786 0.335786 0.25 0.75 0.25H7.25C7.66421 0.25 8 0.585786 8 1C8 1.41421 7.66421 1.75 7.25 1.75H1.5V10.25H7.25C7.66421 10.25 8 10.5858 8 11C8 11.4142 7.66421 11.75 7.25 11.75H0.75C0.335786 11.75 0 11.4142 0 11V1ZM8.78148 2.91435C9.10493 2.65559 9.57689 2.70803 9.83565 3.03148L11.8357 5.53148C12.0548 5.80539 12.0548 6.19461 11.8357 6.46852L9.83565 8.96852C9.57689 9.29197 9.10493 9.34441 8.78148 9.08565C8.45803 8.82689 8.40559 8.35493 8.66435 8.03148L9.68953 6.75H3.75C3.33579 6.75 3 6.41421 3 6C3 5.58579 3.33579 5.25 3.75 5.25H9.68953L8.66435 3.96852C8.40559 3.64507 8.45803 3.17311 8.78148 2.91435Z" fill="#ABB2BF"/>
-</svg>
--- a/assets/icons/logo_96.svg
+++ b/assets/icons/logo_96.svg
@@ -1,3 +0,0 @@
-<svg width="96" height="96" viewBox="0 0 96 96" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M9 6C7.34315 6 6 7.34315 6 9V75H0V9C0 4.02944 4.02944 0 9 0H89.3787C93.3878 0 95.3955 4.84715 92.5607 7.68198L43.0551 57.1875H57V51H63V58.6875C63 61.1728 60.9853 63.1875 58.5 63.1875H37.0551L26.7426 73.5H73.5V36H79.5V73.5C79.5 76.8137 76.8137 79.5 73.5 79.5H20.7426L10.2426 90H87C88.6569 90 90 88.6569 90 87V21H96V87C96 91.9706 91.9706 96 87 96H6.62132C2.61224 96 0.604504 91.1529 3.43934 88.318L52.7574 39H39V45H33V37.5C33 35.0147 35.0147 33 37.5 33H58.7574L69.2574 22.5H22.5V60H16.5V22.5C16.5 19.1863 19.1863 16.5 22.5 16.5H75.2574L85.7574 6H9Z" fill="white"/>
-</svg>
--- a/assets/icons/speech_bubble_12.svg
+++ b/assets/icons/speech_bubble_12.svg
@@ -1,3 +0,0 @@
-<svg width="12" height="12" viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M10.6667 0.400196H1.33346C0.819658 0.400196 0.399658 0.820196 0.399658 1.3326V10.6658C0.399658 11.181 0.816998 11.5982 1.33206 11.5982C1.58966 11.5982 1.82206 11.4932 1.99146 11.3238L4.51706 8.79684H10.6639C11.1763 8.79684 11.5963 8.37544 11.5963 7.86304V1.3298C11.5963 0.815996 11.1749 0.395996 10.6625 0.395996L10.6667 0.400196ZM2.2667 2.2664H6.00008V3.1988H2.26628V2.265L2.2667 2.2664ZM7.8667 6.93316H2.2667V5.99936H7.8667V6.93176V6.93316ZM9.7329 5.06556H2.26488V4.13176H9.73164V5.06416L9.7329 5.06556Z" fill="#282C34"/>
-</svg>
--- a/assets/icons/user_plus_12.svg
+++ b/assets/icons/user_plus_12.svg
@@ -1,5 +1,3 @@
 <svg width="12" height="12" viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M5.75062 7.09998H3.24938C1.45519 7.09998 0 8.55498 0 10.3493C0 10.7093 0.291 11 0.649875 11H8.3505C8.70938 11 9 10.7093 9 10.3493C9 8.55498 7.545 7.09998 5.75062 7.09998Z" fill="white"/>
-<path d="M7 3.5C7 4.82544 5.82562 6 4.5 6C3.17438 6 2 4.82544 2 3.5C2 2.17456 3.17438 1 4.5 1C5.82562 1 7 2.17456 7 3.5Z" fill="white"/>
-<path d="M9.5 3.75V5.5M9.5 7.25V5.5M9.5 5.5H11.25M9.5 5.5H7.75" stroke="white" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M4.2 6.00001C5.52563 6.00001 6.6 4.92545 6.6 3.60001C6.6 2.27457 5.52563 1.20001 4.2 1.20001C2.87438 1.20001 1.8 2.27457 1.8 3.60001C1.8 4.92545 2.87438 6.00001 4.2 6.00001ZM5.15063 6.90001H3.24938C1.45519 6.90001 0 8.35501 0 10.1494C0 10.5094 0.291 10.8 0.649875 10.8H7.7505C8.10938 10.8 8.4 10.5094 8.4 10.1494C8.4 8.35501 6.945 6.90001 5.15063 6.90001ZM11.55 4.95001H10.65V4.05001C10.65 3.80251 10.4494 3.60001 10.2 3.60001C9.95063 3.60001 9.75 3.80157 9.75 4.05001V4.95001H8.85C8.6025 4.95001 8.4 5.15251 8.4 5.40001C8.4 5.64751 8.60156 5.85001 8.85 5.85001H9.75V6.75001C9.75 6.99939 9.9525 7.20001 10.2 7.20001C10.4475 7.20001 10.65 6.99845 10.65 6.75001V5.85001H11.55C11.7994 5.85001 12 5.64939 12 5.40001C12 5.15064 11.7994 4.95001 11.55 4.95001Z" fill="white"/>
 </svg>
--- a/assets/icons/user_plus_16.svg
+++ b/assets/icons/user_plus_16.svg
@@ -1,5 +1,3 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M7.00906 8.99999H4.79094C2.69772 8.99999 1 11.1475 1 13.2409C1 13.6609 1.3395 14 1.75819 14H10.0422C10.4609 14 10.8 13.6609 10.8 13.2409C10.8 11.1475 9.1025 8.99999 7.00906 8.99999Z" fill="white"/>
-<path d="M9 5C9 6.54634 7.44657 7.99998 5.90001 7.99998C4.35344 7.99998 3 6.54634 3 5C3 3.45366 4.45344 2 6 2C7.54656 2 9 3.45366 9 5Z" fill="white"/>
-<path d="M13.025 6H14.475C14.7659 6 15 6.20906 15 6.5C15 6.79094 14.7659 7 14.475 7H13V8.49995C13 8.7898 12.7638 9.02495 12.475 9.02495C12.1863 9.02495 11.95 8.79089 11.95 8.49995V7H10.525C10.2352 7 10 6.78875 10 6.5C10 6.21125 10.2362 6 10.525 6H11.975V4.525C11.975 4.23516 12.2091 4 12.5 4C12.7909 4 13.025 4.23625 13.025 4.525V6Z" fill="white"/>
+<path d="M5.9 8.00002C7.44656 8.00002 8.7 6.74637 8.7 5.20002C8.7 3.65368 7.44656 2.40002 5.9 2.40002C4.35344 2.40002 3.1 3.65368 3.1 5.20002C3.1 6.74637 4.35344 8.00002 5.9 8.00002ZM7.00906 9.05002H4.79094C2.69772 9.05002 1 10.7475 1 12.841C1 13.261 1.3395 13.6 1.75819 13.6H10.0422C10.4609 13.6 10.8 13.261 10.8 12.841C10.8 10.7475 9.1025 9.05002 7.00906 9.05002ZM14.475 6.77502H13.425V5.72502C13.425 5.43627 13.1909 5.20002 12.9 5.20002C12.6091 5.20002 12.375 5.43518 12.375 5.72502V6.77502H11.325C11.0363 6.77502 10.8 7.01127 10.8 7.30002C10.8 7.58877 11.0352 7.82502 11.325 7.82502H12.375V8.87502C12.375 9.16596 12.6112 9.40002 12.9 9.40002C13.1887 9.40002 13.425 9.16487 13.425 8.87502V7.82502H14.475C14.7659 7.82502 15 7.59096 15 7.30002C15 7.00909 14.7659 6.77502 14.475 6.77502Z" fill="white"/>
 </svg>
--- a/assets/keymaps/atom.json
+++ b/assets/keymaps/atom.json
@@ -1,68 +0,0 @@
-[
-  {
-    "bindings": {
-      "cmd-k cmd-p": "workspace::ActivatePreviousPane",
-      "cmd-k cmd-n": "workspace::ActivateNextPane"
-    }
-  },
-  {
-    "context": "Editor",
-    "bindings": {
-      "cmd-b": "editor::GoToDefinition",
-      "cmd-<": "editor::ScrollCursorCenter",
-      "cmd-g": [
-        "editor::SelectNext",
-        {
-          "replace_newest": true
-        }
-      ],
-      "ctrl-shift-down": "editor::AddSelectionBelow",
-      "ctrl-shift-up": "editor::AddSelectionAbove",
-      "cmd-shift-backspace": "editor::DeleteToBeginningOfLine"
-    }
-  },
-  {
-    "context": "Editor && mode == full",
-    "bindings": {
-      "cmd-r": "outline::Toggle"
-    }
-  },
-  {
-    "context": "BufferSearchBar",
-    "bindings": {
-      "cmd-f3": "search::SelectNextMatch",
-      "cmd-shift-f3": "search::SelectPrevMatch"
-    }
-  },
-  {
-    "context": "Workspace",
-    "bindings": {
-      "cmd-\\": "workspace::ToggleLeftSidebar",
-      "cmd-k cmd-b": "workspace::ToggleLeftSidebar",
-      "cmd-t": "file_finder::Toggle",
-      "cmd-shift-r": "project_symbols::Toggle"
-    }
-  },
-  {
-    "context": "Pane",
-    "bindings": {
-      "alt-cmd-/": "search::ToggleRegex",
-      "ctrl-0": "project_panel::ToggleFocus"
-    }
-  },
-  {
-    "context": "ProjectPanel",
-    "bindings": {
-      "ctrl-[": "project_panel::CollapseSelectedEntry",
-      "ctrl-b": "project_panel::CollapseSelectedEntry",
-      "h": "project_panel::CollapseSelectedEntry",
-      "ctrl-]": "project_panel::ExpandSelectedEntry",
-      "ctrl-f": "project_panel::ExpandSelectedEntry",
-      "ctrl-shift-c": "project_panel::CopyPath"
-    }
-  },
-  {
-    "context": "Dock",
-    "bindings": {}
-  }
-]
--- a/assets/keymaps/default.json
+++ b/assets/keymaps/default.json
@@ -164,7 +164,6 @@
        "bindings": {
            "enter": "editor::Newline",
            "cmd-enter": "editor::NewlineBelow",
-            "alt-z": "editor::ToggleSoftWrap",
            "cmd-f": [
                "buffer_search::Deploy",
                {
@@ -228,13 +227,7 @@
                    "replace_newest": true
                }
            ],
-            "cmd-k cmd-i": "editor::Hover",
-            "cmd-/": [
-                "editor::ToggleComments",
-                {
-                    "advance_downwards": false
-                }
-            ],
+            "cmd-/": "editor::ToggleComments",
            "alt-up": "editor::SelectLargerSyntaxNode",
            "alt-down": "editor::SelectSmallerSyntaxNode",
            "cmd-u": "editor::UndoSelection",
@@ -249,8 +242,7 @@
            "alt-cmd-[": "editor::Fold",
            "alt-cmd-]": "editor::UnfoldLines",
            "ctrl-space": "editor::ShowCompletions",
-            "cmd-.": "editor::ToggleCodeActions",
-            "alt-cmd-r": "editor::RevealInFinder"
+            "cmd-.": "editor::ToggleCodeActions"
        }
    },
    {
@@ -354,8 +346,7 @@
            "cmd-shift-p": "command_palette::Toggle",
            "cmd-shift-m": "diagnostics::Deploy",
            "cmd-shift-e": "project_panel::ToggleFocus",
-            "cmd-alt-s": "workspace::SaveAll",
-            "cmd-k m": "language_selector::Toggle"
+            "cmd-alt-s": "workspace::SaveAll"
        }
    },
    // Bindings from Sublime Text
@@ -421,7 +412,7 @@
    {
        "bindings": {
            "ctrl-alt-cmd-f": "workspace::FollowNextCollaborator",
-            "cmd-shift-c": "collab::ToggleContactsMenu",
+            "cmd-shift-c": "collab::ToggleCollaborationMenu",
            "cmd-alt-i": "zed::DebugElements"
        }
    },
@@ -442,7 +433,8 @@
    {
        "context": "Workspace",
        "bindings": {
-            "shift-escape": "dock::FocusDock"
+            "shift-escape": "dock::FocusDock",
+            "cmd-shift-b": "workspace::ToggleRightSidebar"
        }
    },
    {
@@ -453,16 +445,15 @@
        }
    },
    {
-        "context": "Pane",
+        "context": "Dock",
        "bindings": {
-            "cmd-escape": "dock::AddTabToDock"
+            "shift-escape": "dock::HideDock"
        }
    },
    {
-        "context": "Pane && docked",
+        "context": "Pane",
        "bindings": {
-            "shift-escape": "dock::HideDock",
-            "cmd-escape": "dock::RemoveTabFromDock"
+            "cmd-escape": "dock::MoveActiveItemToDock"
        }
    },
    {
@@ -475,8 +466,7 @@
            "cmd-v": "project_panel::Paste",
            "cmd-alt-c": "project_panel::CopyPath",
            "f2": "project_panel::Rename",
-            "backspace": "project_panel::Delete",
-            "alt-cmd-r": "project_panel::RevealInFinder"
+            "backspace": "project_panel::Delete"
        }
    },
    {
@@ -540,4 +530,4 @@
            ]
        }
    }
-]
+]
--- a/assets/keymaps/jetbrains.json
+++ b/assets/keymaps/jetbrains.json
@@ -1,78 +0,0 @@
-[
-  {
-    "bindings": {
-      "cmd-shift-[": "pane::ActivatePrevItem",
-      "cmd-shift-]": "pane::ActivateNextItem"
-    }
-  },
-  {
-    "context": "Editor",
-    "bindings": {
-      "ctrl->": "zed::IncreaseBufferFontSize",
-      "ctrl-<": "zed::DecreaseBufferFontSize",
-      "cmd-d": "editor::DuplicateLine",
-      "cmd-pagedown": "editor::MovePageDown",
-      "cmd-pageup": "editor::MovePageUp",
-      "ctrl-alt-shift-b": "editor::SelectToPreviousWordStart",
-      "shift-enter": "editor::NewlineBelow",
-      "cmd--": "editor::Fold",
-      "cmd-=": "editor::UnfoldLines",
-      "alt-shift-g": "editor::SplitSelectionIntoLines",
-      "ctrl-g": [
-        "editor::SelectNext",
-        {
-          "replace_newest": false
-        }
-      ],
-      "cmd-/": [
-        "editor::ToggleComments",
-        {
-          "advance_downwards": true
-        }
-      ],
-      "shift-alt-up": "editor::MoveLineUp",
-      "shift-alt-down": "editor::MoveLineDown",
-      "cmd-[": "pane::GoBack",
-      "cmd-]": "pane::GoForward",
-      "alt-f7": "editor::FindAllReferences",
-      "cmd-alt-f7": "editor::FindAllReferences",
-      "cmd-b": "editor::GoToDefinition",
-      "cmd-alt-b": "editor::GoToDefinition",
-      "cmd-shift-b": "editor::GoToTypeDefinition",
-      "alt-enter": "editor::ToggleCodeActions",
-      "f2": "editor::GoToDiagnostic",
-      "cmd-f2": "editor::GoToPrevDiagnostic",
-      "ctrl-alt-shift-down": "editor::GoToHunk",
-      "ctrl-alt-shift-up": "editor::GoToPrevHunk",
-      "cmd-home": "editor::MoveToBeginning",
-      "cmd-end": "editor::MoveToEnd",
-      "cmd-shift-home": "editor::SelectToBeginning",
-      "cmd-shift-end": "editor::SelectToEnd"
-    }
-  },
-  {
-    "context": "Editor && mode == full",
-    "bindings": {
-      "cmd-f12": "outline::Toggle",
-      "cmd-7": "outline::Toggle",
-      "cmd-shift-o": "file_finder::Toggle",
-      "cmd-l": "go_to_line::Toggle"
-    }
-  },
-  {
-    "context": "Workspace",
-    "bindings": {
-      "cmd-shift-a": "command_palette::Toggle",
-      "cmd-alt-o": "project_symbols::Toggle",
-      "cmd-1": "workspace::ToggleLeftSidebar",
-      "cmd-6": "diagnostics::Deploy",
-      "alt-f12": "dock::FocusDock"
-    }
-  },
-  {
-    "context": "Dock",
-    "bindings": {
-      "alt-f12": "dock::HideDock"
-    }
-  }
-]
--- a/assets/keymaps/sublime_text.json
+++ b/assets/keymaps/sublime_text.json
@@ -1,60 +0,0 @@
-[
-  {
-    "bindings": {
-      "cmd-shift-[": "pane::ActivatePrevItem",
-      "cmd-shift-]": "pane::ActivateNextItem",
-      "ctrl-pagedown": "pane::ActivatePrevItem",
-      "ctrl-pageup": "pane::ActivateNextItem",
-      "ctrl-shift-tab": "pane::ActivateNextItem",
-      "ctrl-tab": "pane::ActivatePrevItem",
-      "cmd-+": "zed::IncreaseBufferFontSize"
-    }
-  },
-  {
-    "context": "Editor",
-    "bindings": {
-      "ctrl-shift-up": "editor::AddSelectionAbove",
-      "ctrl-shift-down": "editor::AddSelectionBelow",
-      "cmd-shift-space": "editor::SelectAll",
-      "ctrl-shift-m": "editor::SelectLargerSyntaxNode",
-      "cmd-shift-a": "editor::SelectLargerSyntaxNode",
-      "shift-f12": "editor::FindAllReferences",
-      "alt-cmd-down": "editor::GoToDefinition",
-      "alt-shift-cmd-down": "editor::FindAllReferences",
-      "ctrl-.": "editor::GoToHunk",
-      "ctrl-,": "editor::GoToPrevHunk",
-      "ctrl-backspace": "editor::DeleteToPreviousWordStart",
-      "ctrl-delete": "editor::DeleteToNextWordEnd"
-    }
-  },
-  {
-    "context": "Editor && mode == full",
-    "bindings": {
-      "cmd-r": "outline::Toggle"
-    }
-  },
-  {
-    "context": "Pane",
-    "bindings": {
-      "f4": "search::SelectNextMatch",
-      "shift-f4": "search::SelectPrevMatch"
-    }
-  },
-  {
-    "context": "Workspace",
-    "bindings": {
-      "ctrl-`": "dock::FocusDock",
-      "cmd-k cmd-b": "workspace::ToggleLeftSidebar",
-      "cmd-t": "file_finder::Toggle",
-      "shift-cmd-r": "project_symbols::Toggle",
-      // Currently busted: https://github.com/zed-industries/feedback/issues/898
-      "ctrl-0": "project_panel::ToggleFocus"
-    }
-  },
-  {
-    "context": "Dock",
-    "bindings": {
-      "ctrl-`": "dock::HideDock"
-    }
-  }
-]
--- a/assets/keymaps/textmate.json
+++ b/assets/keymaps/textmate.json
@@ -1,90 +0,0 @@
-[
-  {
-    "bindings": {
-      "cmd-shift-o": "projects::OpenRecent",
-      "cmd-alt-tab": "project_panel::ToggleFocus"
-    }
-  },
-  {
-    "context": "Editor",
-    "bindings": {
-      "cmd-l": "go_to_line::Toggle",
-      "ctrl-shift-d": "editor::DuplicateLine",
-      "cmd-b": "editor::GoToDefinition",
-      "cmd-j": "editor::ScrollCursorCenter",
-      "cmd-enter": "editor::NewlineBelow",
-      "cmd-shift-l": "editor::SelectLine",
-      "cmd-shift-t": "outline::Toggle",
-      "alt-backspace": "editor::DeleteToPreviousWordStart",
-      "alt-shift-backspace": "editor::DeleteToNextWordEnd",
-      "alt-delete": "editor::DeleteToNextWordEnd",
-      "alt-shift-delete": "editor::DeleteToNextWordEnd",
-      "ctrl-backspace": "editor::DeleteToPreviousSubwordStart",
-      "ctrl-delete": "editor::DeleteToNextSubwordEnd",
-      "alt-left": [
-        "editor::MoveToPreviousWordStart",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "alt-right": [
-        "editor::MoveToNextWordEnd",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "ctrl-left": "editor::MoveToPreviousSubwordStart",
-      "ctrl-right": "editor::MoveToNextSubwordEnd",
-      "cmd-shift-left": "editor::SelectToBeginningOfLine",
-      "cmd-shift-right": "editor::SelectToEndOfLine",
-      "alt-shift-left": [
-        "editor::SelectToBeginningOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "alt-shift-right": [
-        "editor::SelectToEndOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "ctrl-shift-left": "editor::SelectToPreviousSubwordStart",
-      "ctrl-shift-right": "editor::SelectToNextSubwordEnd"
-    }
-  },
-  {
-    "context": "Editor && mode == full",
-    "bindings": {}
-  },
-  {
-    "context": "BufferSearchBar",
-    "bindings": {
-      "ctrl-s": "search::SelectNextMatch",
-      "ctrl-shift-s": "search::SelectPrevMatch"
-    }
-  },
-  {
-    "context": "Workspace",
-    "bindings": {
-      "cmd-alt-ctrl-d": "workspace::ToggleLeftSidebar",
-      "cmd-t": "file_finder::Toggle",
-      "cmd-shift-t": "project_symbols::Toggle"
-    }
-  },
-  {
-    "context": "Pane",
-    "bindings": {
-      "alt-cmd-r": "search::ToggleRegex",
-      "ctrl-tab": "project_panel::ToggleFocus"
-    }
-  },
-  {
-    "context": "ProjectPanel",
-    "bindings": {}
-  },
-  {
-    "context": "Dock",
-    "bindings": {}
-  }
-]
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -27,7 +27,6 @@
            "h": "vim::Left",
            "backspace": "vim::Backspace",
            "j": "vim::Down",
-            "enter": "vim::NextLineStart",
            "k": "vim::Up",
            "l": "vim::Right",
            "$": "vim::EndOfLine",
@@ -234,8 +233,7 @@
            "escape": [
                "vim::SwitchMode",
                "Normal"
-            ],
-            "d": "editor::GoToDefinition"
+            ]
        }
    },
    {
@@ -317,9 +315,7 @@
    {
        "context": "Editor && VimWaiting",
        "bindings": {
-            "tab": "vim::Tab",
-            "enter": "vim::Enter",
-            "escape": "editor::Cancel"
+            "*": "gpui::KeyPressed"
        }
    }
 ]
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -20,8 +20,11 @@
    // Whether to pop the completions menu while typing in an editor without
    // explicitly requesting it.
    "show_completions_on_input": true,
-    // Whether the screen sharing icon is showed in the os status bar.
-    "show_call_status_icon": 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
@@ -45,13 +48,7 @@
    //     "default_dock_anchor": "right"
    // 3. Position the dock full screen over the entire workspace"
    //     "default_dock_anchor": "expanded"
-    "default_dock_anchor": "bottom",
-    // Whether or not to remove any trailing whitespace from lines of a buffer
-    // before saving it.
-    "remove_trailing_whitespace_on_save": true,
-    // Whether or not to ensure there's a single newline at the end of a buffer
-    // when saving it.
-    "ensure_final_newline_on_save": true,
+    "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:
@@ -84,15 +81,13 @@
    "hard_tabs": false,
    // How many columns a tab should occupy.
    "tab_size": 4,
-    // Control what info is collected by Zed.
+    // Control what info Zed sends to our servers
    "telemetry": {
        // Send debug info like crash reports.
        "diagnostics": true,
        // Send anonymized usage data like what languages you're using Zed with.
        "metrics": true
    },
-    // Automatically update Zed
-    "auto_update": true,
    // Git gutter behavior configuration.
    "git": {
        // Control whether the git gutter is shown. May take 2 values:
@@ -197,6 +192,12 @@
        "Plain Text": {
            "soft_wrap": "preferred_line_length"
        },
+        "C": {
+            "tab_size": 2
+        },
+        "C++": {
+            "tab_size": 2
+        },
        "Elixir": {
            "tab_size": 2
        },
@@ -207,6 +208,9 @@
        "Markdown": {
            "soft_wrap": "preferred_line_length"
        },
+        "Rust": {
+            "tab_size": 4
+        },
        "JavaScript": {
            "tab_size": 2
        },
@@ -215,9 +219,6 @@
        },
        "TSX": {
            "tab_size": 2
-        },
-        "YAML": {
-            "tab_size": 2
        }
    },
    // LSP Specific settings.
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -33,19 +33,6 @@ struct LspStatus {
    status: LanguageServerBinaryStatus,
 }

-struct PendingWork<'a> {
-    language_server_name: &'a str,
-    progress_token: &'a str,
-    progress: &'a LanguageServerProgress,
-}
-
-#[derive(Default)]
-struct Content {
-    icon: Option<&'static str>,
-    message: String,
-    action: Option<Box<dyn Action>>,
-}
-
 pub fn init(cx: &mut MutableAppContext) {
    cx.add_action(ActivityIndicator::show_error_message);
    cx.add_action(ActivityIndicator::dismiss_error_message);
@@ -82,8 +69,6 @@ impl ActivityIndicator {
            if let Some(auto_updater) = auto_updater.as_ref() {
                cx.observe(auto_updater, |_, _, cx| cx.notify()).detach();
            }
-            cx.observe_active_labeled_tasks(|_, cx| cx.notify())
-                .detach();

            Self {
                statuses: Default::default(),
@@ -145,7 +130,7 @@ impl ActivityIndicator {
    fn pending_language_server_work<'a>(
        &self,
        cx: &'a AppContext,
-    ) -> impl Iterator<Item = PendingWork<'a>> {
+    ) -> impl Iterator<Item = (&'a str, &'a str, &'a LanguageServerProgress)> {
        self.project
            .read(cx)
            .language_server_statuses()
@@ -157,29 +142,23 @@ impl ActivityIndicator {
                    let mut pending_work = status
                        .pending_work
                        .iter()
-                        .map(|(token, progress)| PendingWork {
-                            language_server_name: status.name.as_str(),
-                            progress_token: token.as_str(),
-                            progress,
-                        })
+                        .map(|(token, progress)| (status.name.as_str(), token.as_str(), progress))
                        .collect::<SmallVec<[_; 4]>>();
-                    pending_work.sort_by_key(|work| Reverse(work.progress.last_update_at));
+                    pending_work.sort_by_key(|(_, _, progress)| Reverse(progress.last_update_at));
                    Some(pending_work)
                }
            })
            .flatten()
    }

-    fn content_to_render(&mut self, cx: &mut RenderContext<Self>) -> Content {
+    fn content_to_render(
+        &mut self,
+        cx: &mut RenderContext<Self>,
+    ) -> (Option<&'static str>, String, Option<Box<dyn Action>>) {
        // Show any language server has pending activity.
        let mut pending_work = self.pending_language_server_work(cx);
-        if let Some(PendingWork {
-            language_server_name,
-            progress_token,
-            progress,
-        }) = pending_work.next()
-        {
-            let mut message = language_server_name.to_string();
+        if let Some((lang_server_name, progress_token, progress)) = pending_work.next() {
+            let mut message = lang_server_name.to_string();

            message.push_str(": ");
            if let Some(progress_message) = progress.message.as_ref() {
@@ -197,11 +176,7 @@ impl ActivityIndicator {
                write!(&mut message, " + {} more", additional_work_count).unwrap();
            }

-            return Content {
-                icon: None,
-                message,
-                action: None,
-            };
+            return (None, message, None);
        }

        // Show any language server installation info.
@@ -224,19 +199,19 @@ impl ActivityIndicator {
        }

        if !downloading.is_empty() {
-            return Content {
-                icon: Some(DOWNLOAD_ICON),
-                message: format!(
+            return (
+                Some(DOWNLOAD_ICON),
+                format!(
                    "Downloading {} language server{}...",
                    downloading.join(", "),
                    if downloading.len() > 1 { "s" } else { "" }
                ),
-                action: None,
-            };
+                None,
+            );
        } else if !checking_for_update.is_empty() {
-            return Content {
-                icon: Some(DOWNLOAD_ICON),
-                message: format!(
+            return (
+                Some(DOWNLOAD_ICON),
+                format!(
                    "Checking for updates to {} language server{}...",
                    checking_for_update.join(", "),
                    if checking_for_update.len() > 1 {
@@ -245,61 +220,49 @@ impl ActivityIndicator {
                        ""
                    }
                ),
-                action: None,
-            };
+                None,
+            );
        } else if !failed.is_empty() {
-            return Content {
-                icon: Some(WARNING_ICON),
-                message: format!(
+            return (
+                Some(WARNING_ICON),
+                format!(
                    "Failed to download {} language server{}. Click to show error.",
                    failed.join(", "),
                    if failed.len() > 1 { "s" } else { "" }
                ),
-                action: Some(Box::new(ShowErrorMessage)),
-            };
+                Some(Box::new(ShowErrorMessage)),
+            );
        }

        // Show any application auto-update info.
        if let Some(updater) = &self.auto_updater {
-            return match &updater.read(cx).status() {
-                AutoUpdateStatus::Checking => Content {
-                    icon: Some(DOWNLOAD_ICON),
-                    message: "Checking for Zed updates…".to_string(),
-                    action: None,
-                },
-                AutoUpdateStatus::Downloading => Content {
-                    icon: Some(DOWNLOAD_ICON),
-                    message: "Downloading Zed update…".to_string(),
-                    action: None,
-                },
-                AutoUpdateStatus::Installing => Content {
-                    icon: Some(DOWNLOAD_ICON),
-                    message: "Installing Zed update…".to_string(),
-                    action: None,
-                },
-                AutoUpdateStatus::Updated => Content {
-                    icon: None,
-                    message: "Click to restart and update Zed".to_string(),
-                    action: Some(Box::new(workspace::Restart)),
-                },
-                AutoUpdateStatus::Errored => Content {
-                    icon: Some(WARNING_ICON),
-                    message: "Auto update failed".to_string(),
-                    action: Some(Box::new(DismissErrorMessage)),
-                },
+            match &updater.read(cx).status() {
+                AutoUpdateStatus::Checking => (
+                    Some(DOWNLOAD_ICON),
+                    "Checking for Zed updates…".to_string(),
+                    None,
+                ),
+                AutoUpdateStatus::Downloading => (
+                    Some(DOWNLOAD_ICON),
+                    "Downloading Zed update…".to_string(),
+                    None,
+                ),
+                AutoUpdateStatus::Installing => (
+                    Some(DOWNLOAD_ICON),
+                    "Installing Zed update…".to_string(),
+                    None,
+                ),
+                AutoUpdateStatus::Updated => (None, "Restart to update Zed".to_string(), None),
+                AutoUpdateStatus::Errored => (
+                    Some(WARNING_ICON),
+                    "Auto update failed".to_string(),
+                    Some(Box::new(DismissErrorMessage)),
+                ),
                AutoUpdateStatus::Idle => Default::default(),
-            };
+            }
+        } else {
+            Default::default()
        }
-
-        if let Some(most_recent_active_task) = cx.active_labeled_tasks().last() {
-            return Content {
-                icon: None,
-                message: most_recent_active_task.to_string(),
-                action: None,
-            };
-        }
-
-        Default::default()
    }
 }

@@ -313,11 +276,7 @@ impl View for ActivityIndicator {
    }

    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
-        let Content {
-            icon,
-            message,
-            action,
-        } = self.content_to_render(cx);
+        let (icon, message, action) = self.content_to_render(cx);

        let mut element = MouseEventHandler::<Self>::new(0, cx, |state, cx| {
            let theme = &cx
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -9,7 +9,6 @@ use gpui::{
    MutableAppContext, Task, WeakViewHandle,
 };
 use serde::Deserialize;
-use settings::Settings;
 use smol::{fs::File, io::AsyncReadExt, process::Command};
 use std::{ffi::OsString, sync::Arc, time::Duration};
 use update_notification::UpdateNotification;
@@ -54,23 +53,7 @@ pub fn init(http_client: Arc<dyn HttpClient>, server_url: String, cx: &mut Mutab
        let server_url = server_url;
        let auto_updater = cx.add_model(|cx| {
            let updater = AutoUpdater::new(version, http_client, server_url.clone());
-
-            let mut update_subscription = cx
-                .global::<Settings>()
-                .auto_update
-                .then(|| updater.start_polling(cx));
-
-            cx.observe_global::<Settings, _>(move |updater, cx| {
-                if cx.global::<Settings>().auto_update {
-                    if update_subscription.is_none() {
-                        *(&mut update_subscription) = Some(updater.start_polling(cx))
-                    }
-                } else {
-                    (&mut update_subscription).take();
-                }
-            })
-            .detach();
-
+            updater.start_polling(cx).detach();
            updater
        });
        cx.set_global(Some(auto_updater));
--- a/crates/auto_update/src/update_notification.rs
+++ b/crates/auto_update/src/update_notification.rs
@@ -78,7 +78,7 @@ impl View for UpdateNotification {
                )
                .with_child({
                    let style = theme.action_message.style_for(state, false);
-                    Text::new("View the release notes", style.text.clone())
+                    Text::new("View the release notes".to_string(), style.text.clone())
                        .contained()
                        .with_style(style.container)
                        .boxed()
--- a/crates/breadcrumbs/src/breadcrumbs.rs
+++ b/crates/breadcrumbs/src/breadcrumbs.rs
@@ -47,7 +47,7 @@ impl View for Breadcrumbs {
        {
            Flex::row()
                .with_children(Itertools::intersperse_with(breadcrumbs.into_iter(), || {
-                    Label::new(" 〉 ", theme.breadcrumbs.text.clone()).boxed()
+                    Label::new(" 〉 ".to_string(), theme.breadcrumbs.text.clone()).boxed()
                }))
                .contained()
                .with_style(theme.breadcrumbs.container)
--- a/crates/call/Cargo.toml
+++ b/crates/call/Cargo.toml
@@ -28,7 +28,6 @@ fs = { path = "../fs" }
 language = { path = "../language" }
 media = { path = "../media" }
 project = { path = "../project" }
-settings = { path = "../settings" }
 util = { path = "../util" }

 anyhow = "1.0.38"
--- a/crates/call/src/call.rs
+++ b/crates/call/src/call.rs
@@ -1,22 +1,18 @@
 pub mod participant;
 pub mod room;

-use std::sync::Arc;
-
 use anyhow::{anyhow, Result};
 use client::{proto, Client, TypedEnvelope, User, UserStore};
 use collections::HashSet;
-use futures::{future::Shared, FutureExt};
-use postage::watch;
-
 use gpui::{
    AppContext, AsyncAppContext, Entity, ModelContext, ModelHandle, MutableAppContext,
    Subscription, Task, WeakModelHandle,
 };
-use project::Project;
-
 pub use participant::ParticipantLocation;
+use postage::watch;
+use project::Project;
 pub use room::Room;
+use std::sync::Arc;

 pub fn init(client: Arc<Client>, user_store: ModelHandle<UserStore>, cx: &mut MutableAppContext) {
    let active_call = cx.add_model(|cx| ActiveCall::new(client, user_store, cx));
@@ -31,10 +27,8 @@ pub struct IncomingCall {
    pub initial_project: Option<proto::ParticipantProject>,
 }

-/// Singleton global maintaining the user's participation in a room across workspaces.
 pub struct ActiveCall {
    room: Option<(ModelHandle<Room>, Vec<Subscription>)>,
-    pending_room_creation: Option<Shared<Task<Result<ModelHandle<Room>, Arc<anyhow::Error>>>>>,
    location: Option<WeakModelHandle<Project>>,
    pending_invites: HashSet<u64>,
    incoming_call: (
@@ -58,7 +52,6 @@ impl ActiveCall {
    ) -> Self {
        Self {
            room: None,
-            pending_room_creation: None,
            location: None,
            pending_invites: Default::default(),
            incoming_call: watch::channel(),
@@ -127,74 +120,45 @@ impl ActiveCall {
        initial_project: Option<ModelHandle<Project>>,
        cx: &mut ModelContext<Self>,
    ) -> Task<Result<()>> {
+        let client = self.client.clone();
+        let user_store = self.user_store.clone();
        if !self.pending_invites.insert(called_user_id) {
            return Task::ready(Err(anyhow!("user was already invited")));
        }
+
        cx.notify();
-
-        let room = if let Some(room) = self.room().cloned() {
-            Some(Task::ready(Ok(room)).shared())
-        } else {
-            self.pending_room_creation.clone()
-        };
-
-        let invite = if let Some(room) = room {
-            cx.spawn_weak(|_, mut cx| async move {
-                let room = room.await.map_err(|err| anyhow!("{:?}", err))?;
-
-                let initial_project_id = if let Some(initial_project) = initial_project {
-                    Some(
-                        room.update(&mut cx, |room, cx| room.share_project(initial_project, cx))
-                            .await?,
-                    )
-                } else {
-                    None
-                };
-
-                room.update(&mut cx, |room, cx| {
-                    room.call(called_user_id, initial_project_id, cx)
-                })
-                .await?;
-
-                anyhow::Ok(())
-            })
-        } else {
-            let client = self.client.clone();
-            let user_store = self.user_store.clone();
-            let room = cx
-                .spawn(|this, mut cx| async move {
-                    let create_room = async {
-                        let room = cx
-                            .update(|cx| {
-                                Room::create(
-                                    called_user_id,
-                                    initial_project,
-                                    client,
-                                    user_store,
-                                    cx,
-                                )
+        cx.spawn(|this, mut cx| async move {
+            let invite = async {
+                if let Some(room) = this.read_with(&cx, |this, _| this.room().cloned()) {
+                    let initial_project_id = if let Some(initial_project) = initial_project {
+                        Some(
+                            room.update(&mut cx, |room, cx| {
+                                room.share_project(initial_project, cx)
                            })
-                            .await?;
-
-                        this.update(&mut cx, |this, cx| this.set_room(Some(room.clone()), cx))
-                            .await?;
-
-                        anyhow::Ok(room)
+                            .await?,
+                        )
+                    } else {
+                        None
                    };

-                    let room = create_room.await;
-                    this.update(&mut cx, |this, _| this.pending_room_creation = None);
-                    room.map_err(Arc::new)
-                })
-                .shared();
-            self.pending_room_creation = Some(room.clone());
-            cx.foreground().spawn(async move {
-                room.await.map_err(|err| anyhow!("{:?}", err))?;
-                anyhow::Ok(())
-            })
-        };
+                    room.update(&mut cx, |room, cx| {
+                        room.call(called_user_id, initial_project_id, cx)
+                    })
+                    .await?;
+                } else {
+                    let room = cx
+                        .update(|cx| {
+                            Room::create(called_user_id, initial_project, client, user_store, cx)
+                        })
+                        .await?;
+
+                    this.update(&mut cx, |this, cx| this.set_room(Some(room), cx))
+                        .await?;
+                };
+
+                Ok(())
+            };

-        cx.spawn(|this, mut cx| async move {
            let result = invite.await;
            this.update(&mut cx, |this, cx| {
                this.pending_invites.remove(&called_user_id);
@@ -264,13 +228,12 @@ impl ActiveCall {
        Ok(())
    }

-    pub fn hang_up(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
-        cx.notify();
+    pub fn hang_up(&mut self, cx: &mut ModelContext<Self>) -> Result<()> {
        if let Some((room, _)) = self.room.take() {
-            room.update(cx, |room, cx| room.leave(cx))
-        } else {
-            Task::ready(Ok(()))
+            room.update(cx, |room, cx| room.leave(cx))?;
+            cx.notify();
        }
+        Ok(())
    }

    pub fn share_project(
@@ -285,18 +248,6 @@ impl ActiveCall {
        }
    }

-    pub fn unshare_project(
-        &mut self,
-        project: ModelHandle<Project>,
-        cx: &mut ModelContext<Self>,
-    ) -> Result<()> {
-        if let Some((room, _)) = self.room.as_ref() {
-            room.update(cx, |room, cx| room.unshare_project(project, cx))
-        } else {
-            Err(anyhow!("no active call"))
-        }
-    }
-
    pub fn set_location(
        &mut self,
        project: Option<&ModelHandle<Project>>,
--- a/crates/call/src/room.rs
+++ b/crates/call/src/room.rs
@@ -17,10 +17,10 @@ use language::LanguageRegistry;
 use live_kit_client::{LocalTrackPublication, LocalVideoTrack, RemoteVideoTrackUpdate};
 use postage::stream::Stream;
 use project::Project;
-use std::{future::Future, mem, pin::Pin, sync::Arc, time::Duration};
+use std::{mem, sync::Arc, time::Duration};
 use util::{post_inc, ResultExt, TryFutureExt};

-pub const RECONNECT_TIMEOUT: Duration = Duration::from_secs(30);
+pub const RECONNECT_TIMEOUT: Duration = client::RECEIVE_TIMEOUT;

 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Event {
@@ -55,7 +55,6 @@ pub struct Room {
    leave_when_empty: bool,
    client: Arc<Client>,
    user_store: ModelHandle<UserStore>,
-    follows_by_leader_id_project_id: HashMap<(PeerId, u64), Vec<PeerId>>,
    subscriptions: Vec<client::Subscription>,
    pending_room_update: Option<Task<()>>,
    maintain_connection: Option<Task<Option<()>>>,
@@ -64,27 +63,10 @@ pub struct Room {
 impl Entity for Room {
    type Event = Event;

-    fn release(&mut self, cx: &mut MutableAppContext) {
+    fn release(&mut self, _: &mut MutableAppContext) {
        if self.status.is_online() {
-            self.leave_internal(cx).detach_and_log_err(cx);
-        }
-    }
-
-    fn app_will_quit(
-        &mut self,
-        cx: &mut MutableAppContext,
-    ) -> Option<Pin<Box<dyn Future<Output = ()>>>> {
-        if self.status.is_online() {
-            let leave = self.leave_internal(cx);
-            Some(
-                cx.background()
-                    .spawn(async move {
-                        leave.await.log_err();
-                    })
-                    .boxed(),
-            )
-        } else {
-            None
+            log::info!("room was released, sending leave message");
+            let _ = self.client.send(proto::LeaveRoom {});
        }
    }
 }
@@ -166,7 +148,6 @@ impl Room {
            pending_room_update: None,
            client,
            user_store,
-            follows_by_leader_id_project_id: Default::default(),
            maintain_connection: Some(maintain_connection),
        }
    }
@@ -251,17 +232,13 @@ impl Room {
            && self.pending_call_count == 0
    }

-    pub(crate) fn leave(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
-        cx.notify();
-        cx.emit(Event::Left);
-        self.leave_internal(cx)
-    }
-
-    fn leave_internal(&mut self, cx: &mut MutableAppContext) -> Task<Result<()>> {
+    pub(crate) fn leave(&mut self, cx: &mut ModelContext<Self>) -> Result<()> {
        if self.status.is_offline() {
-            return Task::ready(Err(anyhow!("room is offline")));
+            return Err(anyhow!("room is offline"));
        }

+        cx.notify();
+        cx.emit(Event::Left);
        log::info!("leaving room");

        for project in self.shared_projects.drain() {
@@ -287,12 +264,8 @@ impl Room {
        self.live_kit.take();
        self.pending_room_update.take();
        self.maintain_connection.take();
-
-        let leave_room = self.client.request(proto::LeaveRoom {});
-        cx.background().spawn(async move {
-            leave_room.await?;
-            anyhow::Ok(())
-        })
+        self.client.send(proto::LeaveRoom {})?;
+        Ok(())
    }

    async fn maintain_connection(
@@ -302,12 +275,14 @@ impl Room {
    ) -> Result<()> {
        let mut client_status = client.status();
        loop {
-            let _ = client_status.try_recv();
-            let is_connected = client_status.borrow().is_connected();
+            let is_connected = client_status
+                .next()
+                .await
+                .map_or(false, |s| s.is_connected());
+
            // Even if we're initially connected, any future change of the status means we momentarily disconnected.
            if !is_connected || client_status.next().await.is_some() {
                log::info!("detected client disconnection");
-
                this.upgrade(&cx)
                    .ok_or_else(|| anyhow!("room was dropped"))?
                    .update(&mut cx, |this, cx| {
@@ -321,7 +296,12 @@ impl Room {
                    let client_reconnection = async {
                        let mut remaining_attempts = 3;
                        while remaining_attempts > 0 {
-                            if client_status.borrow().is_connected() {
+                            log::info!(
+                                "waiting for client status change, remaining attempts {}",
+                                remaining_attempts
+                            );
+                            let Some(status) = client_status.next().await else { break };
+                            if status.is_connected() {
                                log::info!("client reconnected, attempting to rejoin room");

                                let Some(this) = this.upgrade(&cx) else { break };
@@ -335,15 +315,7 @@ impl Room {
                                } else {
                                    remaining_attempts -= 1;
                                }
-                            } else if client_status.borrow().is_signed_out() {
-                                return false;
                            }
-
-                            log::info!(
-                                "waiting for client status change, remaining attempts {}",
-                                remaining_attempts
-                            );
-                            client_status.next().await;
                        }
                        false
                    }
@@ -365,20 +337,18 @@ impl Room {
                    }
                }

-                break;
+                // The client failed to re-establish a connection to the server
+                // or an error occurred while trying to re-join the room. Either way
+                // we leave the room and return an error.
+                if let Some(this) = this.upgrade(&cx) {
+                    log::info!("reconnection failed, leaving room");
+                    let _ = this.update(&mut cx, |this, cx| this.leave(cx));
+                }
+                return Err(anyhow!(
+                    "can't reconnect to room: client failed to re-establish connection"
+                ));
            }
        }
-
-        // The client failed to re-establish a connection to the server
-        // or an error occurred while trying to re-join the room. Either way
-        // we leave the room and return an error.
-        if let Some(this) = this.upgrade(&cx) {
-            log::info!("reconnection failed, leaving room");
-            let _ = this.update(&mut cx, |this, cx| this.leave(cx));
-        }
-        Err(anyhow!(
-            "can't reconnect to room: client failed to re-establish connection"
-        ))
    }

    fn rejoin(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
@@ -487,12 +457,6 @@ impl Room {
        self.participant_user_ids.contains(&user_id)
    }

-    pub fn followers_for(&self, leader_id: PeerId, project_id: u64) -> &[PeerId] {
-        self.follows_by_leader_id_project_id
-            .get(&(leader_id, project_id))
-            .map_or(&[], |v| v.as_slice())
-    }
-
    async fn handle_room_updated(
        this: ModelHandle<Self>,
        envelope: TypedEnvelope<proto::RoomUpdated>,
@@ -523,13 +487,11 @@ impl Room {
            .iter()
            .map(|p| p.user_id)
            .collect::<Vec<_>>();
-
        let remote_participant_user_ids = room
            .participants
            .iter()
            .map(|p| p.user_id)
            .collect::<Vec<_>>();
-
        let (remote_participants, pending_participants) =
            self.user_store.update(cx, move |user_store, cx| {
                (
@@ -537,7 +499,6 @@ impl Room {
                    user_store.get_users(pending_participant_user_ids, cx),
                )
            });
-
        self.pending_room_update = Some(cx.spawn(|this, mut cx| async move {
            let (remote_participants, pending_participants) =
                futures::join!(remote_participants, pending_participants);
@@ -626,7 +587,7 @@ impl Room {

                            if let Some(live_kit) = this.live_kit.as_ref() {
                                let tracks =
-                                    live_kit.room.remote_video_tracks(&user.id.to_string());
+                                    live_kit.room.remote_video_tracks(&peer_id.to_string());
                                for track in tracks {
                                    this.remote_video_track_updated(
                                        RemoteVideoTrackUpdate::Subscribed(track),
@@ -659,27 +620,6 @@ impl Room {
                    }
                }

-                this.follows_by_leader_id_project_id.clear();
-                for follower in room.followers {
-                    let project_id = follower.project_id;
-                    let (leader, follower) = match (follower.leader_id, follower.follower_id) {
-                        (Some(leader), Some(follower)) => (leader, follower),
-
-                        _ => {
-                            log::error!("Follower message {follower:?} missing some state");
-                            continue;
-                        }
-                    };
-
-                    let list = this
-                        .follows_by_leader_id_project_id
-                        .entry((leader, project_id))
-                        .or_insert(Vec::new());
-                    if !list.contains(&follower) {
-                        list.push(follower);
-                    }
-                }
-
                this.pending_room_update.take();
                if this.should_leave() {
                    log::info!("room is empty, leaving");
@@ -783,10 +723,10 @@ impl Room {
            this.update(&mut cx, |this, cx| {
                this.pending_call_count -= 1;
                if this.should_leave() {
-                    this.leave(cx).detach_and_log_err(cx);
+                    this.leave(cx)?;
                }
-            });
-            result?;
+                result
+            })?;
            Ok(())
        })
    }
@@ -853,20 +793,6 @@ impl Room {
        })
    }

-    pub(crate) fn unshare_project(
-        &mut self,
-        project: ModelHandle<Project>,
-        cx: &mut ModelContext<Self>,
-    ) -> Result<()> {
-        let project_id = match project.read(cx).remote_id() {
-            Some(project_id) => project_id,
-            None => return Ok(()),
-        };
-
-        self.client.send(proto::UnshareProject { project_id })?;
-        project.update(cx, |this, cx| this.unshare(cx))
-    }
-
    pub(crate) fn set_location(
        &mut self,
        project: Option<&ModelHandle<Project>>,
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -66,12 +66,12 @@ pub const ZED_SECRET_CLIENT_TOKEN: &str = "618033988749894";
 pub const INITIAL_RECONNECTION_DELAY: Duration = Duration::from_millis(100);
 pub const CONNECTION_TIMEOUT: Duration = Duration::from_secs(5);

-actions!(client, [SignIn, SignOut]);
+actions!(client, [Authenticate]);

 pub fn init(client: Arc<Client>, cx: &mut MutableAppContext) {
    cx.add_global_action({
        let client = client.clone();
-        move |_: &SignIn, cx| {
+        move |_: &Authenticate, cx| {
            let client = client.clone();
            cx.spawn(
                |cx| async move { client.authenticate_and_connect(true, &cx).log_err().await },
@@ -79,16 +79,6 @@ pub fn init(client: Arc<Client>, cx: &mut MutableAppContext) {
            .detach();
        }
    });
-    cx.add_global_action({
-        let client = client.clone();
-        move |_: &SignOut, cx| {
-            let client = client.clone();
-            cx.spawn(|cx| async move {
-                client.disconnect(&cx);
-            })
-            .detach();
-        }
-    });
 }

 pub struct Client {
@@ -179,10 +169,6 @@ impl Status {
    pub fn is_connected(&self) -> bool {
        matches!(self, Self::Connected { .. })
    }
-
-    pub fn is_signed_out(&self) -> bool {
-        matches!(self, Self::SignedOut | Self::UpgradeRequired)
-    }
 }

 struct ClientState {
@@ -1166,9 +1152,11 @@ impl Client {
        })
    }

-    pub fn disconnect(self: &Arc<Self>, cx: &AsyncAppContext) {
-        self.peer.teardown();
+    pub fn disconnect(self: &Arc<Self>, cx: &AsyncAppContext) -> Result<()> {
+        let conn_id = self.connection_id()?;
+        self.peer.disconnect(conn_id);
        self.set_status(Status::SignedOut, cx);
+        Ok(())
    }

    fn connection_id(&self) -> Result<ConnectionId> {
@@ -1336,10 +1324,6 @@ impl Client {
    pub fn metrics_id(&self) -> Option<Arc<str>> {
        self.telemetry.metrics_id()
    }
-
-    pub fn is_staff(&self) -> Option<bool> {
-        self.telemetry.is_staff()
-    }
 }

 impl WeakSubscriber {
--- a/crates/client/src/http.rs
+++ b/crates/client/src/http.rs
@@ -9,7 +9,7 @@ pub use isahc::{
    Error,
 };
 use smol::future::FutureExt;
-use std::{sync::Arc, time::Duration};
+use std::sync::Arc;
 pub use url::Url;

 pub type Request = isahc::Request<AsyncBody>;
@@ -41,13 +41,7 @@ pub trait HttpClient: Send + Sync {
 }

 pub fn client() -> Arc<dyn HttpClient> {
-    Arc::new(
-        isahc::HttpClient::builder()
-            .connect_timeout(Duration::from_secs(5))
-            .low_speed_timeout(100, Duration::from_secs(5))
-            .build()
-            .unwrap(),
-    )
+    Arc::new(isahc::HttpClient::builder().build().unwrap())
 }

 impl HttpClient for isahc::HttpClient {
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -40,7 +40,6 @@ struct TelemetryState {
    next_event_id: usize,
    flush_task: Option<Task<()>>,
    log_file: Option<NamedTempFile>,
-    is_staff: Option<bool>,
 }

 const MIXPANEL_EVENTS_URL: &'static str = "https://api.mixpanel.com/track";
@@ -126,7 +125,6 @@ impl Telemetry {
                flush_task: Default::default(),
                next_event_id: 0,
                log_file: None,
-                is_staff: None,
            }),
        });

@@ -204,7 +202,6 @@ impl Telemetry {
        let device_id = state.device_id.clone();
        let metrics_id: Option<Arc<str>> = metrics_id.map(|id| id.into());
        state.metrics_id = metrics_id.clone();
-        state.is_staff = Some(is_staff);
        drop(state);

        if let Some((token, device_id)) = MIXPANEL_TOKEN.as_ref().zip(device_id) {
@@ -224,7 +221,7 @@ impl Telemetry {
                            .header("Content-Type", "application/json")
                            .body(json_bytes.into())?;
                        this.http_client.send(request).await?;
-                        anyhow::Ok(())
+                        Ok(())
                    }
                    .log_err(),
                )
@@ -285,10 +282,6 @@ impl Telemetry {
        self.state.lock().metrics_id.clone()
    }

-    pub fn is_staff(self: &Arc<Self>) -> Option<bool> {
-        self.state.lock().is_staff
-    }
-
    fn flush(self: &Arc<Self>) {
        let mut state = self.state.lock();
        let mut events = mem::take(&mut state.queue);
@@ -320,7 +313,7 @@ impl Telemetry {
                            .header("Content-Type", "application/json")
                            .body(json_bytes.into())?;
                        this.http_client.send(request).await?;
-                        anyhow::Ok(())
+                        Ok(())
                    }
                    .log_err(),
                )
--- a/crates/client/src/user.rs
+++ b/crates/client/src/user.rs
@@ -183,11 +183,6 @@ impl UserStore {
        }
    }

-    #[cfg(feature = "test-support")]
-    pub fn clear_cache(&mut self) {
-        self.users.clear();
-    }
-
    async fn handle_update_invite_info(
        this: ModelHandle<Self>,
        message: TypedEnvelope<proto::UpdateInviteInfo>,
--- a/crates/collab/.env.toml
+++ b/crates/collab/.env.toml
@@ -1,5 +1,4 @@
 DATABASE_URL = "postgres://postgres@localhost/zed"
-DATABASE_MAX_CONNECTIONS = 5
 HTTP_PORT = 8080
 API_TOKEN = "secret"
 INVITE_LINK_PREFIX = "http://localhost:3000/invites/"
--- 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.8.0"
+version = "0.5.4"
 publish = false

 [[bin]]
--- a/crates/collab/k8s/environments/preview.sh
+++ b/crates/collab/k8s/environments/preview.sh
@@ -1,4 +1,3 @@
 ZED_ENVIRONMENT=preview
 RUST_LOG=info
 INVITE_LINK_PREFIX=https://zed.dev/invites/
-DATABASE_MAX_CONNECTIONS=10
--- a/crates/collab/k8s/environments/production.sh
+++ b/crates/collab/k8s/environments/production.sh
@@ -1,4 +1,3 @@
 ZED_ENVIRONMENT=production
 RUST_LOG=info
 INVITE_LINK_PREFIX=https://zed.dev/invites/
-DATABASE_MAX_CONNECTIONS=85
--- a/crates/collab/k8s/environments/staging.sh
+++ b/crates/collab/k8s/environments/staging.sh
@@ -1,4 +1,3 @@
 ZED_ENVIRONMENT=staging
 RUST_LOG=info
 INVITE_LINK_PREFIX=https://staging.zed.dev/invites/
-DATABASE_MAX_CONNECTIONS=5
--- a/crates/collab/k8s/manifest.template.yml
+++ b/crates/collab/k8s/manifest.template.yml
@@ -59,13 +59,6 @@ spec:
          ports:
            - containerPort: 8080
              protocol: TCP
-          livenessProbe:
-            httpGet:
-              path: /healthz
-              port: 8080
-            initialDelaySeconds: 5
-            periodSeconds: 5
-            timeoutSeconds: 5
          readinessProbe:
            httpGet:
              path: /
@@ -80,8 +73,6 @@ spec:
                secretKeyRef:
                  name: database
                  key: url
-            - name: DATABASE_MAX_CONNECTIONS
-              value: "${DATABASE_MAX_CONNECTIONS}"
            - name: API_TOKEN
              valueFrom:
                secretKeyRef:
--- a/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
+++ b/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
@@ -143,17 +143,3 @@ CREATE TABLE "servers" (
    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
    "environment" VARCHAR NOT NULL
 );
-
-CREATE TABLE "followers" (
-    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
-    "room_id" INTEGER NOT NULL REFERENCES rooms (id) ON DELETE CASCADE,
-    "project_id" INTEGER NOT NULL REFERENCES projects (id) ON DELETE CASCADE,
-    "leader_connection_server_id" INTEGER NOT NULL REFERENCES servers (id) ON DELETE CASCADE,
-    "leader_connection_id" INTEGER NOT NULL,
-    "follower_connection_server_id" INTEGER NOT NULL REFERENCES servers (id) ON DELETE CASCADE,
-    "follower_connection_id" INTEGER NOT NULL
-);
-CREATE UNIQUE INDEX 
-    "index_followers_on_project_id_and_leader_connection_server_id_and_leader_connection_id_and_follower_connection_server_id_and_follower_connection_id"
-ON "followers" ("project_id", "leader_connection_server_id", "leader_connection_id", "follower_connection_server_id", "follower_connection_id");
-CREATE INDEX "index_followers_on_room_id" ON "followers" ("room_id");
--- a/crates/collab/migrations/20230202155735_followers.sql
+++ b/crates/collab/migrations/20230202155735_followers.sql
@@ -1,15 +0,0 @@
-CREATE TABLE IF NOT EXISTS "followers" (
-    "id" SERIAL PRIMARY KEY,
-    "room_id" INTEGER NOT NULL REFERENCES rooms (id) ON DELETE CASCADE,
-    "project_id" INTEGER NOT NULL REFERENCES projects (id) ON DELETE CASCADE,
-    "leader_connection_server_id" INTEGER NOT NULL REFERENCES servers (id) ON DELETE CASCADE,
-    "leader_connection_id" INTEGER NOT NULL,
-    "follower_connection_server_id" INTEGER NOT NULL REFERENCES servers (id) ON DELETE CASCADE,
-    "follower_connection_id" INTEGER NOT NULL
-);
-
-CREATE UNIQUE INDEX 
-    "index_followers_on_project_id_and_leader_connection_server_id_and_leader_connection_id_and_follower_connection_server_id_and_follower_connection_id"
-ON "followers" ("project_id", "leader_connection_server_id", "leader_connection_id", "follower_connection_server_id", "follower_connection_id");
-
-CREATE INDEX "index_followers_on_room_id" ON "followers" ("room_id");
--- a/crates/collab/src/api.rs
+++ b/crates/collab/src/api.rs
@@ -78,7 +78,6 @@ pub async fn validate_api_token<B>(req: Request<B>, next: Next<B>) -> impl IntoR
 struct AuthenticatedUserParams {
    github_user_id: Option<i32>,
    github_login: String,
-    github_email: Option<String>,
 }

 #[derive(Debug, Serialize)]
@@ -93,11 +92,7 @@ async fn get_authenticated_user(
 ) -> Result<Json<AuthenticatedUserResponse>> {
    let user = app
        .db
-        .get_or_create_user_by_github_account(
-            &params.github_login,
-            params.github_user_id,
-            params.github_email.as_deref(),
-        )
+        .get_user_by_github_account(&params.github_login, params.github_user_id)
        .await?
        .ok_or_else(|| Error::Http(StatusCode::NOT_FOUND, "user not found".into()))?;
    let metrics_id = app.db.get_user_metrics_id(user.id).await?;
@@ -302,7 +297,11 @@ async fn create_access_token(
    let mut user_id = user.id;
    if let Some(impersonate) = params.impersonate {
        if user.admin {
-            if let Some(impersonated_user) = app.db.get_user_by_github_login(&impersonate).await? {
+            if let Some(impersonated_user) = app
+                .db
+                .get_user_by_github_account(&impersonate, None)
+                .await?
+            {
                user_id = impersonated_user.id;
            } else {
                return Err(Error::Http(
--- a/crates/collab/src/bin/seed.rs
+++ b/crates/collab/src/bin/seed.rs
@@ -59,7 +59,7 @@ async fn main() {

    for (github_user, admin) in zed_users {
        if db
-            .get_user_by_github_login(&github_user.login)
+            .get_user_by_github_account(&github_user.login, Some(github_user.id))
            .await
            .expect("failed to fetch user")
            .is_none()
--- a/crates/collab/src/db.rs
+++ b/crates/collab/src/db.rs
@@ -1,6 +1,5 @@
 mod access_token;
 mod contact;
-mod follower;
 mod language_server;
 mod project;
 mod project_collaborator;
@@ -158,7 +157,7 @@ impl Database {
        room_id: RoomId,
        new_server_id: ServerId,
    ) -> Result<RoomGuard<RefreshedRoom>> {
-        self.room_transaction(room_id, |tx| async move {
+        self.room_transaction(|tx| async move {
            let stale_participant_filter = Condition::all()
                .add(room_participant::Column::RoomId.eq(room_id))
                .add(room_participant::Column::AnsweringConnectionId.is_not_null())
@@ -191,18 +190,17 @@ impl Database {
                    .filter(room_participant::Column::RoomId.eq(room_id))
                    .exec(&*tx)
                    .await?;
-                project::Entity::delete_many()
-                    .filter(project::Column::RoomId.eq(room_id))
-                    .exec(&*tx)
-                    .await?;
                room::Entity::delete_by_id(room_id).exec(&*tx).await?;
            }

-            Ok(RefreshedRoom {
-                room,
-                stale_participant_user_ids,
-                canceled_calls_to_user_ids,
-            })
+            Ok((
+                room_id,
+                RefreshedRoom {
+                    room,
+                    stale_participant_user_ids,
+                    canceled_calls_to_user_ids,
+                },
+            ))
        })
        .await
    }
@@ -295,21 +293,10 @@ impl Database {
        .await
    }

-    pub async fn get_user_by_github_login(&self, github_login: &str) -> Result<Option<User>> {
-        self.transaction(|tx| async move {
-            Ok(user::Entity::find()
-                .filter(user::Column::GithubLogin.eq(github_login))
-                .one(&*tx)
-                .await?)
-        })
-        .await
-    }
-
-    pub async fn get_or_create_user_by_github_account(
+    pub async fn get_user_by_github_account(
        &self,
        github_login: &str,
        github_user_id: Option<i32>,
-        github_email: Option<&str>,
    ) -> Result<Option<User>> {
        self.transaction(|tx| async move {
            let tx = &*tx;
@@ -331,19 +318,7 @@ impl Database {
                    user_by_github_login.github_user_id = ActiveValue::set(Some(github_user_id));
                    Ok(Some(user_by_github_login.update(tx).await?))
                } else {
-                    let user = user::Entity::insert(user::ActiveModel {
-                        email_address: ActiveValue::set(github_email.map(|email| email.into())),
-                        github_login: ActiveValue::set(github_login.into()),
-                        github_user_id: ActiveValue::set(Some(github_user_id)),
-                        admin: ActiveValue::set(false),
-                        invite_count: ActiveValue::set(0),
-                        invite_code: ActiveValue::set(None),
-                        metrics_id: ActiveValue::set(Uuid::new_v4()),
-                        ..Default::default()
-                    })
-                    .exec_with_returning(&*tx)
-                    .await?;
-                    Ok(Some(user))
+                    Ok(None)
                }
            } else {
                Ok(user::Entity::find()
@@ -1154,16 +1129,18 @@ impl Database {
        user_id: UserId,
        connection: ConnectionId,
        live_kit_room: &str,
-    ) -> Result<proto::Room> {
-        self.transaction(|tx| async move {
+    ) -> Result<RoomGuard<proto::Room>> {
+        self.room_transaction(|tx| async move {
            let room = room::ActiveModel {
                live_kit_room: ActiveValue::set(live_kit_room.into()),
                ..Default::default()
            }
            .insert(&*tx)
            .await?;
+            let room_id = room.id;
+
            room_participant::ActiveModel {
-                room_id: ActiveValue::set(room.id),
+                room_id: ActiveValue::set(room_id),
                user_id: ActiveValue::set(user_id),
                answering_connection_id: ActiveValue::set(Some(connection.id as i32)),
                answering_connection_server_id: ActiveValue::set(Some(ServerId(
@@ -1180,8 +1157,8 @@ impl Database {
            .insert(&*tx)
            .await?;

-            let room = self.get_room(room.id, &tx).await?;
-            Ok(room)
+            let room = self.get_room(room_id, &tx).await?;
+            Ok((room_id, room))
        })
        .await
    }
@@ -1194,7 +1171,7 @@ impl Database {
        called_user_id: UserId,
        initial_project_id: Option<ProjectId>,
    ) -> Result<RoomGuard<(proto::Room, proto::IncomingCall)>> {
-        self.room_transaction(room_id, |tx| async move {
+        self.room_transaction(|tx| async move {
            room_participant::ActiveModel {
                room_id: ActiveValue::set(room_id),
                user_id: ActiveValue::set(called_user_id),
@@ -1213,7 +1190,7 @@ impl Database {
            let room = self.get_room(room_id, &tx).await?;
            let incoming_call = Self::build_incoming_call(&room, called_user_id)
                .ok_or_else(|| anyhow!("failed to build incoming call"))?;
-            Ok((room, incoming_call))
+            Ok((room_id, (room, incoming_call)))
        })
        .await
    }
@@ -1223,7 +1200,7 @@ impl Database {
        room_id: RoomId,
        called_user_id: UserId,
    ) -> Result<RoomGuard<proto::Room>> {
-        self.room_transaction(room_id, |tx| async move {
+        self.room_transaction(|tx| async move {
            room_participant::Entity::delete_many()
                .filter(
                    room_participant::Column::RoomId
@@ -1233,7 +1210,7 @@ impl Database {
                .exec(&*tx)
                .await?;
            let room = self.get_room(room_id, &tx).await?;
-            Ok(room)
+            Ok((room_id, room))
        })
        .await
    }
@@ -1280,7 +1257,7 @@ impl Database {
        calling_connection: ConnectionId,
        called_user_id: UserId,
    ) -> Result<RoomGuard<proto::Room>> {
-        self.room_transaction(room_id, |tx| async move {
+        self.room_transaction(|tx| async move {
            let participant = room_participant::Entity::find()
                .filter(
                    Condition::all()
@@ -1299,13 +1276,14 @@ impl Database {
                .one(&*tx)
                .await?
                .ok_or_else(|| anyhow!("no call to cancel"))?;
+            let room_id = participant.room_id;

            room_participant::Entity::delete(participant.into_active_model())
                .exec(&*tx)
                .await?;

            let room = self.get_room(room_id, &tx).await?;
-            Ok(room)
+            Ok((room_id, room))
        })
        .await
    }
@@ -1316,7 +1294,7 @@ impl Database {
        user_id: UserId,
        connection: ConnectionId,
    ) -> Result<RoomGuard<proto::Room>> {
-        self.room_transaction(room_id, |tx| async move {
+        self.room_transaction(|tx| async move {
            let result = room_participant::Entity::update_many()
                .filter(
                    Condition::all()
@@ -1338,7 +1316,7 @@ impl Database {
                Err(anyhow!("room does not exist or was already joined"))?
            } else {
                let room = self.get_room(room_id, &tx).await?;
-                Ok(room)
+                Ok((room_id, room))
            }
        })
        .await
@@ -1350,9 +1328,9 @@ impl Database {
        user_id: UserId,
        connection: ConnectionId,
    ) -> Result<RoomGuard<RejoinedRoom>> {
-        let room_id = RoomId::from_proto(rejoin_room.id);
-        self.room_transaction(room_id, |tx| async {
+        self.room_transaction(|tx| async {
            let tx = tx;
+            let room_id = RoomId::from_proto(rejoin_room.id);
            let participant_update = room_participant::Entity::update_many()
                .filter(
                    Condition::all()
@@ -1571,11 +1549,14 @@ impl Database {
            }

            let room = self.get_room(room_id, &tx).await?;
-            Ok(RejoinedRoom {
-                room,
-                rejoined_projects,
-                reshared_projects,
-            })
+            Ok((
+                room_id,
+                RejoinedRoom {
+                    room,
+                    rejoined_projects,
+                    reshared_projects,
+                },
+            ))
        })
        .await
    }
@@ -1736,75 +1717,13 @@ impl Database {
        .await
    }

-    pub async fn follow(
-        &self,
-        project_id: ProjectId,
-        leader_connection: ConnectionId,
-        follower_connection: ConnectionId,
-    ) -> Result<RoomGuard<proto::Room>> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
-            follower::ActiveModel {
-                room_id: ActiveValue::set(room_id),
-                project_id: ActiveValue::set(project_id),
-                leader_connection_server_id: ActiveValue::set(ServerId(
-                    leader_connection.owner_id as i32,
-                )),
-                leader_connection_id: ActiveValue::set(leader_connection.id as i32),
-                follower_connection_server_id: ActiveValue::set(ServerId(
-                    follower_connection.owner_id as i32,
-                )),
-                follower_connection_id: ActiveValue::set(follower_connection.id as i32),
-                ..Default::default()
-            }
-            .insert(&*tx)
-            .await?;
-
-            let room = self.get_room(room_id, &*tx).await?;
-            Ok(room)
-        })
-        .await
-    }
-
-    pub async fn unfollow(
-        &self,
-        project_id: ProjectId,
-        leader_connection: ConnectionId,
-        follower_connection: ConnectionId,
-    ) -> Result<RoomGuard<proto::Room>> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
-            follower::Entity::delete_many()
-                .filter(
-                    Condition::all()
-                        .add(follower::Column::ProjectId.eq(project_id))
-                        .add(
-                            follower::Column::LeaderConnectionServerId
-                                .eq(leader_connection.owner_id),
-                        )
-                        .add(follower::Column::LeaderConnectionId.eq(leader_connection.id))
-                        .add(
-                            follower::Column::FollowerConnectionServerId
-                                .eq(follower_connection.owner_id),
-                        )
-                        .add(follower::Column::FollowerConnectionId.eq(follower_connection.id)),
-                )
-                .exec(&*tx)
-                .await?;
-
-            let room = self.get_room(room_id, &*tx).await?;
-            Ok(room)
-        })
-        .await
-    }
-
    pub async fn update_room_participant_location(
        &self,
        room_id: RoomId,
        connection: ConnectionId,
        location: proto::ParticipantLocation,
    ) -> Result<RoomGuard<proto::Room>> {
-        self.room_transaction(room_id, |tx| async {
+        self.room_transaction(|tx| async {
            let tx = tx;
            let location_kind;
            let location_project_id;
@@ -1850,7 +1769,7 @@ impl Database {

            if result.rows_affected == 1 {
                let room = self.get_room(room_id, &tx).await?;
-                Ok(room)
+                Ok((room_id, room))
            } else {
                Err(anyhow!("could not update room participant location"))?
            }
@@ -2007,25 +1926,12 @@ impl Database {
                }
            }
        }
-        drop(db_projects);
-
-        let mut db_followers = db_room.find_related(follower::Entity).stream(tx).await?;
-        let mut followers = Vec::new();
-        while let Some(db_follower) = db_followers.next().await {
-            let db_follower = db_follower?;
-            followers.push(proto::Follower {
-                leader_id: Some(db_follower.leader_connection().into()),
-                follower_id: Some(db_follower.follower_connection().into()),
-                project_id: db_follower.project_id.to_proto(),
-            });
-        }

        Ok(proto::Room {
            id: db_room.id.to_proto(),
            live_kit_room: db_room.live_kit_room,
            participants: participants.into_values().collect(),
            pending_participants,
-            followers,
        })
    }

@@ -2057,7 +1963,7 @@ impl Database {
        connection: ConnectionId,
        worktrees: &[proto::WorktreeMetadata],
    ) -> Result<RoomGuard<(ProjectId, proto::Room)>> {
-        self.room_transaction(room_id, |tx| async move {
+        self.room_transaction(|tx| async move {
            let participant = room_participant::Entity::find()
                .filter(
                    Condition::all()
@@ -2118,7 +2024,7 @@ impl Database {
            .await?;

            let room = self.get_room(room_id, &tx).await?;
-            Ok((project.id, room))
+            Ok((room_id, (project.id, room)))
        })
        .await
    }
@@ -2128,8 +2034,7 @@ impl Database {
        project_id: ProjectId,
        connection: ConnectionId,
    ) -> Result<RoomGuard<(proto::Room, Vec<ConnectionId>)>> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+        self.room_transaction(|tx| async move {
            let guest_connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;

            let project = project::Entity::find_by_id(project_id)
@@ -2137,11 +2042,12 @@ impl Database {
                .await?
                .ok_or_else(|| anyhow!("project not found"))?;
            if project.host_connection()? == connection {
+                let room_id = project.room_id;
                project::Entity::delete(project.into_active_model())
                    .exec(&*tx)
                    .await?;
                let room = self.get_room(room_id, &tx).await?;
-                Ok((room, guest_connection_ids))
+                Ok((room_id, (room, guest_connection_ids)))
            } else {
                Err(anyhow!("cannot unshare a project hosted by another user"))?
            }
@@ -2155,8 +2061,7 @@ impl Database {
        connection: ConnectionId,
        worktrees: &[proto::WorktreeMetadata],
    ) -> Result<RoomGuard<(proto::Room, Vec<ConnectionId>)>> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+        self.room_transaction(|tx| async move {
            let project = project::Entity::find_by_id(project_id)
                .filter(
                    Condition::all()
@@ -2174,7 +2079,7 @@ impl Database {

            let guest_connection_ids = self.project_guest_connection_ids(project.id, &tx).await?;
            let room = self.get_room(project.room_id, &tx).await?;
-            Ok((room, guest_connection_ids))
+            Ok((project.room_id, (room, guest_connection_ids)))
        })
        .await
    }
@@ -2219,12 +2124,12 @@ impl Database {
        update: &proto::UpdateWorktree,
        connection: ConnectionId,
    ) -> Result<RoomGuard<Vec<ConnectionId>>> {
-        let project_id = ProjectId::from_proto(update.project_id);
-        let worktree_id = update.worktree_id as i64;
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+        self.room_transaction(|tx| async move {
+            let project_id = ProjectId::from_proto(update.project_id);
+            let worktree_id = update.worktree_id as i64;
+
            // Ensure the update comes from the host.
-            let _project = project::Entity::find_by_id(project_id)
+            let project = project::Entity::find_by_id(project_id)
                .filter(
                    Condition::all()
                        .add(project::Column::HostConnectionId.eq(connection.id as i32))
@@ -2235,6 +2140,7 @@ impl Database {
                .one(&*tx)
                .await?
                .ok_or_else(|| anyhow!("no such project"))?;
+            let room_id = project.room_id;

            // Update metadata.
            worktree::Entity::update(worktree::ActiveModel {
@@ -2314,7 +2220,7 @@ impl Database {
            }

            let connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;
-            Ok(connection_ids)
+            Ok((room_id, connection_ids))
        })
        .await
    }
@@ -2324,10 +2230,9 @@ impl Database {
        update: &proto::UpdateDiagnosticSummary,
        connection: ConnectionId,
    ) -> Result<RoomGuard<Vec<ConnectionId>>> {
-        let project_id = ProjectId::from_proto(update.project_id);
-        let worktree_id = update.worktree_id as i64;
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+        self.room_transaction(|tx| async move {
+            let project_id = ProjectId::from_proto(update.project_id);
+            let worktree_id = update.worktree_id as i64;
            let summary = update
                .summary
                .as_ref()
@@ -2369,7 +2274,7 @@ impl Database {
            .await?;

            let connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;
-            Ok(connection_ids)
+            Ok((project.room_id, connection_ids))
        })
        .await
    }
@@ -2379,9 +2284,8 @@ impl Database {
        update: &proto::StartLanguageServer,
        connection: ConnectionId,
    ) -> Result<RoomGuard<Vec<ConnectionId>>> {
-        let project_id = ProjectId::from_proto(update.project_id);
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+        self.room_transaction(|tx| async move {
+            let project_id = ProjectId::from_proto(update.project_id);
            let server = update
                .server
                .as_ref()
@@ -2415,7 +2319,7 @@ impl Database {
            .await?;

            let connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;
-            Ok(connection_ids)
+            Ok((project.room_id, connection_ids))
        })
        .await
    }
@@ -2425,8 +2329,7 @@ impl Database {
        project_id: ProjectId,
        connection: ConnectionId,
    ) -> Result<RoomGuard<(Project, ReplicaId)>> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+        self.room_transaction(|tx| async move {
            let participant = room_participant::Entity::find()
                .filter(
                    Condition::all()
@@ -2552,6 +2455,7 @@ impl Database {
                .all(&*tx)
                .await?;

+            let room_id = project.room_id;
            let project = Project {
                collaborators: collaborators
                    .into_iter()
@@ -2571,7 +2475,7 @@ impl Database {
                    })
                    .collect(),
            };
-            Ok((project, replica_id as ReplicaId))
+            Ok((room_id, (project, replica_id as ReplicaId)))
        })
        .await
    }
@@ -2580,9 +2484,8 @@ impl Database {
        &self,
        project_id: ProjectId,
        connection: ConnectionId,
-    ) -> Result<RoomGuard<(proto::Room, LeftProject)>> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+    ) -> Result<RoomGuard<LeftProject>> {
+        self.room_transaction(|tx| async move {
            let result = project_collaborator::Entity::delete_many()
                .filter(
                    Condition::all()
@@ -2612,39 +2515,13 @@ impl Database {
                .map(|collaborator| collaborator.connection())
                .collect();

-            follower::Entity::delete_many()
-                .filter(
-                    Condition::any()
-                        .add(
-                            Condition::all()
-                                .add(follower::Column::ProjectId.eq(project_id))
-                                .add(
-                                    follower::Column::LeaderConnectionServerId
-                                        .eq(connection.owner_id),
-                                )
-                                .add(follower::Column::LeaderConnectionId.eq(connection.id)),
-                        )
-                        .add(
-                            Condition::all()
-                                .add(follower::Column::ProjectId.eq(project_id))
-                                .add(
-                                    follower::Column::FollowerConnectionServerId
-                                        .eq(connection.owner_id),
-                                )
-                                .add(follower::Column::FollowerConnectionId.eq(connection.id)),
-                        ),
-                )
-                .exec(&*tx)
-                .await?;
-
-            let room = self.get_room(project.room_id, &tx).await?;
            let left_project = LeftProject {
                id: project_id,
                host_user_id: project.host_user_id,
                host_connection_id: project.host_connection()?,
                connection_ids,
            };
-            Ok((room, left_project))
+            Ok((project.room_id, left_project))
        })
        .await
    }
@@ -2654,8 +2531,11 @@ impl Database {
        project_id: ProjectId,
        connection_id: ConnectionId,
    ) -> Result<RoomGuard<Vec<ProjectCollaborator>>> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+        self.room_transaction(|tx| async move {
+            let project = project::Entity::find_by_id(project_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such project"))?;
            let collaborators = project_collaborator::Entity::find()
                .filter(project_collaborator::Column::ProjectId.eq(project_id))
                .all(&*tx)
@@ -2673,7 +2553,7 @@ impl Database {
                .iter()
                .any(|collaborator| collaborator.connection_id == connection_id)
            {
-                Ok(collaborators)
+                Ok((project.room_id, collaborators))
            } else {
                Err(anyhow!("no such project"))?
            }
@@ -2686,8 +2566,11 @@ impl Database {
        project_id: ProjectId,
        connection_id: ConnectionId,
    ) -> Result<RoomGuard<HashSet<ConnectionId>>> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+        self.room_transaction(|tx| async move {
+            let project = project::Entity::find_by_id(project_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such project"))?;
            let mut collaborators = project_collaborator::Entity::find()
                .filter(project_collaborator::Column::ProjectId.eq(project_id))
                .stream(&*tx)
@@ -2700,7 +2583,7 @@ impl Database {
            }

            if connection_ids.contains(&connection_id) {
-                Ok(connection_ids)
+                Ok((project.room_id, connection_ids))
            } else {
                Err(anyhow!("no such project"))?
            }
@@ -2730,17 +2613,6 @@ impl Database {
        Ok(guest_connection_ids)
    }

-    async fn room_id_for_project(&self, project_id: ProjectId) -> Result<RoomId> {
-        self.transaction(|tx| async move {
-            let project = project::Entity::find_by_id(project_id)
-                .one(&*tx)
-                .await?
-                .ok_or_else(|| anyhow!("project {} not found", project_id))?;
-            Ok(project.room_id)
-        })
-        .await
-    }
-
    // access tokens

    pub async fn create_access_token_hash(
@@ -2891,48 +2763,21 @@ impl Database {
        self.run(body).await
    }

-    async fn room_transaction<F, Fut, T>(&self, room_id: RoomId, f: F) -> Result<RoomGuard<T>>
+    async fn room_transaction<F, Fut, T>(&self, f: F) -> Result<RoomGuard<T>>
    where
        F: Send + Fn(TransactionHandle) -> Fut,
-        Fut: Send + Future<Output = Result<T>>,
+        Fut: Send + Future<Output = Result<(RoomId, T)>>,
    {
-        let body = async {
-            loop {
-                let lock = self.rooms.entry(room_id).or_default().clone();
-                let _guard = lock.lock_owned().await;
-                let (tx, result) = self.with_transaction(&f).await?;
-                match result {
-                    Ok(data) => {
-                        match tx.commit().await.map_err(Into::into) {
-                            Ok(()) => {
-                                return Ok(RoomGuard {
-                                    data,
-                                    _guard,
-                                    _not_send: PhantomData,
-                                });
-                            }
-                            Err(error) => {
-                                if is_serialization_error(&error) {
-                                    // Retry (don't break the loop)
-                                } else {
-                                    return Err(error);
-                                }
-                            }
-                        }
-                    }
-                    Err(error) => {
-                        tx.rollback().await?;
-                        if is_serialization_error(&error) {
-                            // Retry (don't break the loop)
-                        } else {
-                            return Err(error);
-                        }
-                    }
+        let data = self
+            .optional_room_transaction(move |tx| {
+                let future = f(tx);
+                async {
+                    let data = future.await?;
+                    Ok(Some(data))
                }
-            }
-        };
-
-        self.run(body).await
+            })
+            .await?;
+        Ok(data.unwrap())
    }

    async fn with_transaction<F, Fut, T>(&self, f: &F) -> Result<(DatabaseTransaction, Result<T>)>
@@ -3166,7 +3011,6 @@ macro_rules! id_type {

 id_type!(AccessTokenId);
 id_type!(ContactId);
-id_type!(FollowerId);
 id_type!(RoomId);
 id_type!(RoomParticipantId);
 id_type!(ProjectId);
--- a/crates/collab/src/db/follower.rs
+++ b/crates/collab/src/db/follower.rs
@@ -1,51 +0,0 @@
-use super::{FollowerId, ProjectId, RoomId, ServerId};
-use rpc::ConnectionId;
-use sea_orm::entity::prelude::*;
-use serde::Serialize;
-
-#[derive(Clone, Debug, Default, PartialEq, Eq, DeriveEntityModel, Serialize)]
-#[sea_orm(table_name = "followers")]
-pub struct Model {
-    #[sea_orm(primary_key)]
-    pub id: FollowerId,
-    pub room_id: RoomId,
-    pub project_id: ProjectId,
-    pub leader_connection_server_id: ServerId,
-    pub leader_connection_id: i32,
-    pub follower_connection_server_id: ServerId,
-    pub follower_connection_id: i32,
-}
-
-impl Model {
-    pub fn leader_connection(&self) -> ConnectionId {
-        ConnectionId {
-            owner_id: self.leader_connection_server_id.0 as u32,
-            id: self.leader_connection_id as u32,
-        }
-    }
-
-    pub fn follower_connection(&self) -> ConnectionId {
-        ConnectionId {
-            owner_id: self.follower_connection_server_id.0 as u32,
-            id: self.follower_connection_id as u32,
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {
-    #[sea_orm(
-        belongs_to = "super::room::Entity",
-        from = "Column::RoomId",
-        to = "super::room::Column::Id"
-    )]
-    Room,
-}
-
-impl Related<super::room::Entity> for Entity {
-    fn to() -> RelationDef {
-        Relation::Room.def()
-    }
-}
-
-impl ActiveModelBehavior for ActiveModel {}
--- a/crates/collab/src/db/room.rs
+++ b/crates/collab/src/db/room.rs
@@ -15,8 +15,6 @@ pub enum Relation {
    RoomParticipant,
    #[sea_orm(has_many = "super::project::Entity")]
    Project,
-    #[sea_orm(has_many = "super::follower::Entity")]
-    Follower,
 }

 impl Related<super::room_participant::Entity> for Entity {
@@ -31,10 +29,4 @@ impl Related<super::project::Entity> for Entity {
    }
 }

-impl Related<super::follower::Entity> for Entity {
-    fn to() -> RelationDef {
-        Relation::Follower.def()
-    }
-}
-
 impl ActiveModelBehavior for ActiveModel {}
--- a/crates/collab/src/db/tests.rs
+++ b/crates/collab/src/db/tests.rs
@@ -92,8 +92,8 @@ test_both_dbs!(
 );

 test_both_dbs!(
-    test_get_or_create_user_by_github_account_postgres,
-    test_get_or_create_user_by_github_account_sqlite,
+    test_get_user_by_github_account_postgres,
+    test_get_user_by_github_account_sqlite,
    db,
    {
        let user_id1 = db
@@ -124,7 +124,7 @@ test_both_dbs!(
            .user_id;

        let user = db
-            .get_or_create_user_by_github_account("login1", None, None)
+            .get_user_by_github_account("login1", None)
            .await
            .unwrap()
            .unwrap();
@@ -133,28 +133,19 @@ test_both_dbs!(
        assert_eq!(user.github_user_id, Some(101));

        assert!(db
-            .get_or_create_user_by_github_account("non-existent-login", None, None)
+            .get_user_by_github_account("non-existent-login", None)
            .await
            .unwrap()
            .is_none());

        let user = db
-            .get_or_create_user_by_github_account("the-new-login2", Some(102), None)
+            .get_user_by_github_account("the-new-login2", Some(102))
            .await
            .unwrap()
            .unwrap();
        assert_eq!(user.id, user_id2);
        assert_eq!(&user.github_login, "the-new-login2");
        assert_eq!(user.github_user_id, Some(102));
-
-        let user = db
-            .get_or_create_user_by_github_account("login3", Some(103), Some("user3@example.com"))
-            .await
-            .unwrap()
-            .unwrap();
-        assert_eq!(&user.github_login, "login3");
-        assert_eq!(user.github_user_id, Some(103));
-        assert_eq!(user.email_address, Some("user3@example.com".into()));
    }
 );

--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -91,7 +91,6 @@ impl std::error::Error for Error {}
 pub struct Config {
    pub http_port: u16,
    pub database_url: String,
-    pub database_max_connections: u32,
    pub api_token: String,
    pub invite_link_prefix: String,
    pub live_kit_server: Option<String>,
@@ -117,7 +116,7 @@ pub struct AppState {
 impl AppState {
    pub async fn new(config: Config) -> Result<Arc<Self>> {
        let mut db_options = db::ConnectOptions::new(config.database_url.clone());
-        db_options.max_connections(config.database_max_connections);
+        db_options.max_connections(5);
        let db = Database::new(db_options).await?;
        let live_kit_client = if let Some(((server, key), secret)) = config
            .live_kit_server
--- a/crates/collab/src/main.rs
+++ b/crates/collab/src/main.rs
@@ -1,12 +1,11 @@
 use anyhow::anyhow;
-use axum::{routing::get, Extension, Router};
+use axum::{routing::get, Router};
 use collab::{db, env, executor::Executor, AppState, Config, MigrateConfig, Result};
 use db::Database;
 use std::{
    env::args,
    net::{SocketAddr, TcpListener},
    path::Path,
-    sync::Arc,
 };
 use tokio::signal::unix::SignalKind;
 use tracing_log::LogTracer;
@@ -67,12 +66,7 @@ async fn main() -> Result<()> {

            let app = collab::api::routes(rpc_server.clone(), state.clone())
                .merge(collab::rpc::routes(rpc_server.clone()))
-                .merge(
-                    Router::new()
-                        .route("/", get(handle_root))
-                        .route("/healthz", get(handle_liveness_probe))
-                        .layer(Extension(state.clone())),
-                );
+                .merge(Router::new().route("/", get(handle_root)));

            axum::Server::from_tcp(listener)?
                .serve(app.into_make_service_with_connect_info::<SocketAddr>())
@@ -101,11 +95,6 @@ async fn handle_root() -> String {
    format!("collab v{VERSION}")
 }

-async fn handle_liveness_probe(Extension(state): Extension<Arc<AppState>>) -> Result<String> {
-    state.db.get_all_users(0, 1).await?;
-    Ok("ok".to_string())
-}
-
 pub fn init_tracing(config: &Config) -> Option<()> {
    use std::str::FromStr;
    use tracing_subscriber::layer::SubscriberExt;
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -53,11 +53,11 @@ use std::{
    },
    time::Duration,
 };
-use tokio::sync::{watch, Semaphore};
+use tokio::sync::watch;
 use tower::ServiceBuilder;
 use tracing::{info_span, instrument, Instrument};

-pub const RECONNECT_TIMEOUT: Duration = Duration::from_secs(30);
+pub const RECONNECT_TIMEOUT: Duration = Duration::from_secs(5);
 pub const CLEANUP_TIMEOUT: Duration = Duration::from_secs(10);

 lazy_static! {
@@ -186,7 +186,7 @@ impl Server {
            .add_request_handler(create_room)
            .add_request_handler(join_room)
            .add_request_handler(rejoin_room)
-            .add_request_handler(leave_room)
+            .add_message_handler(leave_room)
            .add_request_handler(call)
            .add_request_handler(cancel_call)
            .add_message_handler(decline_call)
@@ -270,11 +270,8 @@ impl Server {
                        let mut live_kit_room = String::new();
                        let mut delete_live_kit_room = false;

-                        if let Some(mut refreshed_room) = app_state
-                            .db
-                            .refresh_room(room_id, server_id)
-                            .await
-                            .trace_err()
+                        if let Ok(mut refreshed_room) =
+                            app_state.db.refresh_room(room_id, server_id).await
                        {
                            tracing::info!(
                                room_id = room_id.0,
@@ -542,13 +539,8 @@ impl Server {
            // This arrangement ensures we will attempt to process earlier messages first, but fall
            // back to processing messages arrived later in the spirit of making progress.
            let mut foreground_message_handlers = FuturesUnordered::new();
-            let concurrent_handlers = Arc::new(Semaphore::new(256));
            loop {
-                let next_message = async {
-                    let permit = concurrent_handlers.clone().acquire_owned().await.unwrap();
-                    let message = incoming_rx.next().await;
-                    (permit, message)
-                }.fuse();
+                let next_message = incoming_rx.next().fuse();
                futures::pin_mut!(next_message);
                futures::select_biased! {
                    _ = teardown.changed().fuse() => return Ok(()),
@@ -559,8 +551,7 @@ impl Server {
                        break;
                    }
                    _ = foreground_message_handlers.next() => {}
-                    next_message = next_message => {
-                        let (permit, message) = next_message;
+                    message = next_message => {
                        if let Some(message) = message {
                            let type_name = message.payload_type_name();
                            let span = tracing::info_span!("receive message", %user_id, %login, %connection_id, %address, type_name);
@@ -570,10 +561,7 @@ impl Server {
                                let handle_message = (handler)(message, session.clone());
                                drop(span_enter);

-                                let handle_message = async move {
-                                    handle_message.await;
-                                    drop(permit);
-                                }.instrument(span);
+                                let handle_message = handle_message.instrument(span);
                                if is_background {
                                    executor.spawn_detached(handle_message);
                                } else {
@@ -1102,14 +1090,8 @@ async fn rejoin_room(
    Ok(())
 }

-async fn leave_room(
-    _: proto::LeaveRoom,
-    response: Response<proto::LeaveRoom>,
-    session: Session,
-) -> Result<()> {
-    leave_room_for_session(&session).await?;
-    response.send(proto::Ack {})?;
-    Ok(())
+async fn leave_room(_message: proto::LeaveRoom, session: Session) -> Result<()> {
+    leave_room_for_session(&session).await
 }

 async fn call(
@@ -1330,7 +1312,6 @@ async fn join_project(
        .filter(|collaborator| collaborator.connection_id != session.connection_id)
        .map(|collaborator| collaborator.to_proto())
        .collect::<Vec<_>>();
-
    let worktrees = project
        .worktrees
        .iter()
@@ -1423,7 +1404,7 @@ async fn leave_project(request: proto::LeaveProject, session: Session) -> Result
    let sender_id = session.connection_id;
    let project_id = ProjectId::from_proto(request.project_id);

-    let (room, project) = &*session
+    let project = session
        .db()
        .await
        .leave_project(project_id, sender_id)
@@ -1434,9 +1415,7 @@ async fn leave_project(request: proto::LeaveProject, session: Session) -> Result
        host_connection_id = %project.host_connection_id,
        "leave project"
    );
-
    project_left(&project, &session);
-    room_updated(&room, &session.peer);

    Ok(())
 }
@@ -1745,7 +1724,6 @@ async fn follow(
        .ok_or_else(|| anyhow!("invalid leader id"))?
        .into();
    let follower_id = session.connection_id;
-
    {
        let project_connection_ids = session
            .db()
@@ -1766,14 +1744,6 @@ async fn follow(
        .views
        .retain(|view| view.leader_id != Some(follower_id.into()));
    response.send(response_payload)?;
-
-    let room = session
-        .db()
-        .await
-        .follow(project_id, leader_id, follower_id)
-        .await?;
-    room_updated(&room, &session.peer);
-
    Ok(())
 }

@@ -1783,29 +1753,17 @@ async fn unfollow(request: proto::Unfollow, session: Session) -> Result<()> {
        .leader_id
        .ok_or_else(|| anyhow!("invalid leader id"))?
        .into();
-    let follower_id = session.connection_id;
-
-    if !session
+    let project_connection_ids = session
        .db()
        .await
        .project_connection_ids(project_id, session.connection_id)
-        .await?
-        .contains(&leader_id)
-    {
+        .await?;
+    if !project_connection_ids.contains(&leader_id) {
        Err(anyhow!("no such peer"))?;
    }
-
    session
        .peer
        .forward_send(session.connection_id, leader_id, request)?;
-
-    let room = session
-        .db()
-        .await
-        .unfollow(project_id, leader_id, follower_id)
-        .await?;
-    room_updated(&room, &session.peer);
-
    Ok(())
 }

@@ -1875,7 +1833,7 @@ async fn fuzzy_search_users(
        1 | 2 => session
            .db()
            .await
-            .get_user_by_github_login(&query)
+            .get_user_by_github_account(&query, None)
            .await?
            .into_iter()
            .collect(),
--- a/crates/collab/src/tests.rs
+++ b/crates/collab/src/tests.rs
@@ -104,7 +104,11 @@ impl TestServer {
        });

        let http = FakeHttpClient::with_404_response();
-        let user_id = if let Ok(Some(user)) = self.app_state.db.get_user_by_github_login(name).await
+        let user_id = if let Ok(Some(user)) = self
+            .app_state
+            .db
+            .get_user_by_github_account(name, None)
+            .await
        {
            user.id
        } else {
@@ -193,8 +197,7 @@ impl TestServer {
            fs: fs.clone(),
            build_window_options: |_, _, _| Default::default(),
            initialize_workspace: |_, _, _| unimplemented!(),
-            dock_default_item_factory: |_, _| None,
-            background_actions: || &[],
+            dock_default_item_factory: |_, _| unimplemented!(),
        });

        Project::init(&client);
@@ -431,7 +434,15 @@ impl TestClient {
        cx: &mut TestAppContext,
    ) -> ViewHandle<Workspace> {
        let (_, root_view) = cx.add_window(|_| EmptyView);
-        cx.add_view(&root_view, |cx| Workspace::test_new(project.clone(), cx))
+        cx.add_view(&root_view, |cx| {
+            Workspace::new(
+                Default::default(),
+                0,
+                project.clone(),
+                |_, _| unimplemented!(),
+                cx,
+            )
+        })
    }

    fn create_new_root_dir(&mut self) -> PathBuf {
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -166,67 +166,9 @@ async fn test_basic_calls(
        }
    );

-    // Call user C again from user A.
-    active_call_a
-        .update(cx_a, |call, cx| {
-            call.invite(client_c.user_id().unwrap(), None, cx)
-        })
-        .await
-        .unwrap();
-
-    deterministic.run_until_parked();
-    assert_eq!(
-        room_participants(&room_a, cx_a),
-        RoomParticipants {
-            remote: vec!["user_b".to_string()],
-            pending: vec!["user_c".to_string()]
-        }
-    );
-    assert_eq!(
-        room_participants(&room_b, cx_b),
-        RoomParticipants {
-            remote: vec!["user_a".to_string()],
-            pending: vec!["user_c".to_string()]
-        }
-    );
-
-    // User C accepts the call.
-    let call_c = incoming_call_c.next().await.unwrap().unwrap();
-    assert_eq!(call_c.calling_user.github_login, "user_a");
-    active_call_c
-        .update(cx_c, |call, cx| call.accept_incoming(cx))
-        .await
-        .unwrap();
-    assert!(incoming_call_c.next().await.unwrap().is_none());
-    let room_c = active_call_c.read_with(cx_c, |call, _| call.room().unwrap().clone());
-
-    deterministic.run_until_parked();
-    assert_eq!(
-        room_participants(&room_a, cx_a),
-        RoomParticipants {
-            remote: vec!["user_b".to_string(), "user_c".to_string()],
-            pending: Default::default()
-        }
-    );
-    assert_eq!(
-        room_participants(&room_b, cx_b),
-        RoomParticipants {
-            remote: vec!["user_a".to_string(), "user_c".to_string()],
-            pending: Default::default()
-        }
-    );
-    assert_eq!(
-        room_participants(&room_c, cx_c),
-        RoomParticipants {
-            remote: vec!["user_a".to_string(), "user_b".to_string()],
-            pending: Default::default()
-        }
-    );
-
    // User A shares their screen
    let display = MacOSDisplay::new();
    let events_b = active_call_events(cx_b);
-    let events_c = active_call_events(cx_c);
    active_call_a
        .update(cx_a, |call, cx| {
            call.room().unwrap().update(cx, |room, cx| {
@@ -239,10 +181,9 @@ async fn test_basic_calls(

    deterministic.run_until_parked();

-    // User B observes the remote screen sharing track.
    assert_eq!(events_b.borrow().len(), 1);
-    let event_b = events_b.borrow().first().unwrap().clone();
-    if let call::room::Event::RemoteVideoTracksChanged { participant_id } = event_b {
+    let event = events_b.borrow().first().unwrap().clone();
+    if let call::room::Event::RemoteVideoTracksChanged { participant_id } = event {
        assert_eq!(participant_id, client_a.peer_id().unwrap());
        room_b.read_with(cx_b, |room, _| {
            assert_eq!(
@@ -256,32 +197,11 @@ async fn test_basic_calls(
        panic!("unexpected event")
    }

-    // User C observes the remote screen sharing track.
-    assert_eq!(events_c.borrow().len(), 1);
-    let event_c = events_c.borrow().first().unwrap().clone();
-    if let call::room::Event::RemoteVideoTracksChanged { participant_id } = event_c {
-        assert_eq!(participant_id, client_a.peer_id().unwrap());
-        room_c.read_with(cx_c, |room, _| {
-            assert_eq!(
-                room.remote_participants()[&client_a.user_id().unwrap()]
-                    .tracks
-                    .len(),
-                1
-            );
-        });
-    } else {
-        panic!("unexpected event")
-    }
-
    // User A leaves the room.
-    active_call_a
-        .update(cx_a, |call, cx| {
-            let hang_up = call.hang_up(cx);
-            assert!(call.room().is_none());
-            hang_up
-        })
-        .await
-        .unwrap();
+    active_call_a.update(cx_a, |call, cx| {
+        call.hang_up(cx).unwrap();
+        assert!(call.room().is_none());
+    });
    deterministic.run_until_parked();
    assert_eq!(
        room_participants(&room_a, cx_a),
@@ -293,28 +213,18 @@ async fn test_basic_calls(
    assert_eq!(
        room_participants(&room_b, cx_b),
        RoomParticipants {
-            remote: vec!["user_c".to_string()],
-            pending: Default::default()
-        }
-    );
-    assert_eq!(
-        room_participants(&room_c, cx_c),
-        RoomParticipants {
-            remote: vec!["user_b".to_string()],
+            remote: Default::default(),
            pending: Default::default()
        }
    );

    // User B gets disconnected from the LiveKit server, which causes them
-    // to automatically leave the room. User C leaves the room as well because
-    // nobody else is in there.
+    // to automatically leave the room.
    server
        .test_live_kit_server
-        .disconnect_client(client_b.user_id().unwrap().to_string())
+        .disconnect_client(client_b.peer_id().unwrap().to_string())
        .await;
-    deterministic.run_until_parked();
-    active_call_b.read_with(cx_b, |call, _| assert!(call.room().is_none()));
-    active_call_c.read_with(cx_c, |call, _| assert!(call.room().is_none()));
+    active_call_b.update(cx_b, |call, _| assert!(call.room().is_none()));
    assert_eq!(
        room_participants(&room_a, cx_a),
        RoomParticipants {
@@ -329,141 +239,6 @@ async fn test_basic_calls(
            pending: Default::default()
        }
    );
-    assert_eq!(
-        room_participants(&room_c, cx_c),
-        RoomParticipants {
-            remote: Default::default(),
-            pending: Default::default()
-        }
-    );
-}
-
-#[gpui::test(iterations = 10)]
-async fn test_calling_multiple_users_simultaneously(
-    deterministic: Arc<Deterministic>,
-    cx_a: &mut TestAppContext,
-    cx_b: &mut TestAppContext,
-    cx_c: &mut TestAppContext,
-    cx_d: &mut TestAppContext,
-) {
-    deterministic.forbid_parking();
-    let mut server = TestServer::start(&deterministic).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;
-    let client_d = server.create_client(cx_d, "user_d").await;
-    server
-        .make_contacts(&mut [
-            (&client_a, cx_a),
-            (&client_b, cx_b),
-            (&client_c, cx_c),
-            (&client_d, cx_d),
-        ])
-        .await;
-
-    let active_call_a = cx_a.read(ActiveCall::global);
-    let active_call_b = cx_b.read(ActiveCall::global);
-    let active_call_c = cx_c.read(ActiveCall::global);
-    let active_call_d = cx_d.read(ActiveCall::global);
-
-    // Simultaneously call user B and user C from client A.
-    let b_invite = active_call_a.update(cx_a, |call, cx| {
-        call.invite(client_b.user_id().unwrap(), None, cx)
-    });
-    let c_invite = active_call_a.update(cx_a, |call, cx| {
-        call.invite(client_c.user_id().unwrap(), None, cx)
-    });
-    b_invite.await.unwrap();
-    c_invite.await.unwrap();
-
-    let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
-    deterministic.run_until_parked();
-    assert_eq!(
-        room_participants(&room_a, cx_a),
-        RoomParticipants {
-            remote: Default::default(),
-            pending: vec!["user_b".to_string(), "user_c".to_string()]
-        }
-    );
-
-    // Call client D from client A.
-    active_call_a
-        .update(cx_a, |call, cx| {
-            call.invite(client_d.user_id().unwrap(), None, cx)
-        })
-        .await
-        .unwrap();
-    deterministic.run_until_parked();
-    assert_eq!(
-        room_participants(&room_a, cx_a),
-        RoomParticipants {
-            remote: Default::default(),
-            pending: vec![
-                "user_b".to_string(),
-                "user_c".to_string(),
-                "user_d".to_string()
-            ]
-        }
-    );
-
-    // Accept the call on all clients simultaneously.
-    let accept_b = active_call_b.update(cx_b, |call, cx| call.accept_incoming(cx));
-    let accept_c = active_call_c.update(cx_c, |call, cx| call.accept_incoming(cx));
-    let accept_d = active_call_d.update(cx_d, |call, cx| call.accept_incoming(cx));
-    accept_b.await.unwrap();
-    accept_c.await.unwrap();
-    accept_d.await.unwrap();
-
-    deterministic.run_until_parked();
-
-    let room_b = active_call_b.read_with(cx_b, |call, _| call.room().unwrap().clone());
-    let room_c = active_call_c.read_with(cx_c, |call, _| call.room().unwrap().clone());
-    let room_d = active_call_d.read_with(cx_d, |call, _| call.room().unwrap().clone());
-    assert_eq!(
-        room_participants(&room_a, cx_a),
-        RoomParticipants {
-            remote: vec![
-                "user_b".to_string(),
-                "user_c".to_string(),
-                "user_d".to_string(),
-            ],
-            pending: Default::default()
-        }
-    );
-    assert_eq!(
-        room_participants(&room_b, cx_b),
-        RoomParticipants {
-            remote: vec![
-                "user_a".to_string(),
-                "user_c".to_string(),
-                "user_d".to_string(),
-            ],
-            pending: Default::default()
-        }
-    );
-    assert_eq!(
-        room_participants(&room_c, cx_c),
-        RoomParticipants {
-            remote: vec![
-                "user_a".to_string(),
-                "user_b".to_string(),
-                "user_d".to_string(),
-            ],
-            pending: Default::default()
-        }
-    );
-    assert_eq!(
-        room_participants(&room_d, cx_d),
-        RoomParticipants {
-            remote: vec![
-                "user_a".to_string(),
-                "user_b".to_string(),
-                "user_c".to_string(),
-            ],
-            pending: Default::default()
-        }
-    );
 }

 #[gpui::test(iterations = 10)]
@@ -561,7 +336,6 @@ async fn test_room_uniqueness(
    // Client C can successfully call client B after client B leaves the room.
    active_call_b
        .update(cx_b, |call, cx| call.hang_up(cx))
-        .await
        .unwrap();
    deterministic.run_until_parked();
    active_call_c
@@ -738,14 +512,6 @@ async fn test_server_restarts(
    deterministic.forbid_parking();
    let mut server = TestServer::start(&deterministic).await;
    let client_a = server.create_client(cx_a, "user_a").await;
-    client_a
-        .fs
-        .insert_tree("/a", json!({ "a.txt": "a-contents" }))
-        .await;
-
-    // Invite client B to collaborate on a project
-    let (project_a, _) = client_a.build_local_project("/a", cx_a).await;
-
    let client_b = server.create_client(cx_b, "user_b").await;
    let client_c = server.create_client(cx_c, "user_c").await;
    let client_d = server.create_client(cx_d, "user_d").await;
@@ -766,19 +532,19 @@ async fn test_server_restarts(
    // User A calls users B, C, and D.
    active_call_a
        .update(cx_a, |call, cx| {
-            call.invite(client_b.user_id().unwrap(), Some(project_a.clone()), cx)
+            call.invite(client_b.user_id().unwrap(), None, cx)
        })
        .await
        .unwrap();
    active_call_a
        .update(cx_a, |call, cx| {
-            call.invite(client_c.user_id().unwrap(), Some(project_a.clone()), cx)
+            call.invite(client_c.user_id().unwrap(), None, cx)
        })
        .await
        .unwrap();
    active_call_a
        .update(cx_a, |call, cx| {
-            call.invite(client_d.user_id().unwrap(), Some(project_a.clone()), cx)
+            call.invite(client_d.user_id().unwrap(), None, cx)
        })
        .await
        .unwrap();
@@ -834,7 +600,7 @@ async fn test_server_restarts(

    // Users A and B reconnect to the call. User C has troubles reconnecting, so it leaves the room.
    client_c.override_establish_connection(|_, cx| cx.spawn(|_| future::pending()));
-    deterministic.advance_clock(RECONNECT_TIMEOUT);
+    deterministic.advance_clock(RECEIVE_TIMEOUT);
    assert_eq!(
        room_participants(&room_a, cx_a),
        RoomParticipants {
@@ -941,7 +707,6 @@ async fn test_server_restarts(
    // User D hangs up.
    active_call_d
        .update(cx_d, |call, cx| call.hang_up(cx))
-        .await
        .unwrap();
    deterministic.run_until_parked();
    assert_eq!(
@@ -1007,7 +772,7 @@ async fn test_server_restarts(
    client_a.override_establish_connection(|_, cx| cx.spawn(|_| future::pending()));
    client_b.override_establish_connection(|_, cx| cx.spawn(|_| future::pending()));
    client_c.override_establish_connection(|_, cx| cx.spawn(|_| future::pending()));
-    deterministic.advance_clock(RECONNECT_TIMEOUT);
+    deterministic.advance_clock(RECEIVE_TIMEOUT);
    assert_eq!(
        room_participants(&room_a, cx_a),
        RoomParticipants {
@@ -1097,7 +862,7 @@ async fn test_calls_on_multiple_connections(
    assert!(incoming_call_b2.next().await.unwrap().is_none());

    // User B disconnects the client that is not on the call. Everything should be fine.
-    client_b1.disconnect(&cx_b1.to_async());
+    client_b1.disconnect(&cx_b1.to_async()).unwrap();
    deterministic.advance_clock(RECEIVE_TIMEOUT);
    client_b1
        .authenticate_and_connect(false, &cx_b1.to_async())
@@ -1105,10 +870,7 @@ async fn test_calls_on_multiple_connections(
        .unwrap();

    // User B hangs up, and user A calls them again.
-    active_call_b2
-        .update(cx_b2, |call, cx| call.hang_up(cx))
-        .await
-        .unwrap();
+    active_call_b2.update(cx_b2, |call, cx| call.hang_up(cx).unwrap());
    deterministic.run_until_parked();
    active_call_a
        .update(cx_a, |call, cx| {
@@ -1143,10 +905,7 @@ async fn test_calls_on_multiple_connections(
    assert!(incoming_call_b2.next().await.unwrap().is_some());

    // User A hangs up, causing both connections to stop ringing.
-    active_call_a
-        .update(cx_a, |call, cx| call.hang_up(cx))
-        .await
-        .unwrap();
+    active_call_a.update(cx_a, |call, cx| call.hang_up(cx).unwrap());
    deterministic.run_until_parked();
    assert!(incoming_call_b1.next().await.unwrap().is_none());
    assert!(incoming_call_b2.next().await.unwrap().is_none());
@@ -1383,10 +1142,7 @@ async fn test_unshare_project(
        .unwrap();

    // When client B leaves the room, the project becomes read-only.
-    active_call_b
-        .update(cx_b, |call, cx| call.hang_up(cx))
-        .await
-        .unwrap();
+    active_call_b.update(cx_b, |call, cx| call.hang_up(cx).unwrap());
    deterministic.run_until_parked();
    assert!(project_b.read_with(cx_b, |project, _| project.is_read_only()));

@@ -1415,10 +1171,7 @@ async fn test_unshare_project(
        .unwrap();

    // When client A (the host) leaves the room, the project gets unshared and guests are notified.
-    active_call_a
-        .update(cx_a, |call, cx| call.hang_up(cx))
-        .await
-        .unwrap();
+    active_call_a.update(cx_a, |call, cx| call.hang_up(cx).unwrap());
    deterministic.run_until_parked();
    project_a.read_with(cx_a, |project, _| assert!(!project.is_shared()));
    project_c2.read_with(cx_c, |project, _| {
@@ -1467,7 +1220,15 @@ async fn test_host_disconnect(
    deterministic.run_until_parked();
    assert!(worktree_a.read_with(cx_a, |tree, _| tree.as_local().unwrap().is_shared()));

-    let (_, workspace_b) = cx_b.add_window(|cx| Workspace::test_new(project_b.clone(), cx));
+    let (_, workspace_b) = cx_b.add_window(|cx| {
+        Workspace::new(
+            Default::default(),
+            0,
+            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)
@@ -2262,9 +2023,7 @@ async fn test_propagate_saves_and_fs_changes(
    });

    // Edit the buffer as the host and concurrently save as guest B.
-    let save_b = project_b.update(cx_b, |project, cx| {
-        project.save_buffer(buffer_b.clone(), cx)
-    });
+    let save_b = buffer_b.update(cx_b, |buf, cx| buf.save(cx));
    buffer_a.update(cx_a, |buf, cx| buf.edit([(0..0, "hi-a, ")], None, cx));
    save_b.await.unwrap();
    assert_eq!(
@@ -2333,41 +2092,6 @@ async fn test_propagate_saves_and_fs_changes(
        assert_eq!(buffer.file().unwrap().path().to_str(), Some("file1.js"));
        assert_eq!(&*buffer.language().unwrap().name(), "JavaScript");
    });
-
-    let new_buffer_a = project_a
-        .update(cx_a, |p, cx| p.create_buffer("", None, cx))
-        .unwrap();
-    let new_buffer_id = new_buffer_a.read_with(cx_a, |buffer, _| buffer.remote_id());
-    let new_buffer_b = project_b
-        .update(cx_b, |p, cx| p.open_buffer_by_id(new_buffer_id, cx))
-        .await
-        .unwrap();
-    new_buffer_b.read_with(cx_b, |buffer, _| {
-        assert!(buffer.file().is_none());
-    });
-
-    new_buffer_a.update(cx_a, |buffer, cx| {
-        buffer.edit([(0..0, "ok")], None, cx);
-    });
-    project_a
-        .update(cx_a, |project, cx| {
-            project.save_buffer_as(new_buffer_a.clone(), "/a/file3.rs".into(), cx)
-        })
-        .await
-        .unwrap();
-
-    deterministic.run_until_parked();
-    new_buffer_b.read_with(cx_b, |buffer_b, _| {
-        assert_eq!(
-            buffer_b.file().unwrap().path().as_ref(),
-            Path::new("file3.rs")
-        );
-
-        new_buffer_a.read_with(cx_a, |buffer_a, _| {
-            assert_eq!(buffer_b.saved_mtime(), buffer_a.saved_mtime());
-            assert_eq!(buffer_b.saved_version(), buffer_a.saved_version());
-        });
-    });
 }

 #[gpui::test(iterations = 10)]
@@ -2848,7 +2572,7 @@ async fn test_fs_operations(
        .await
        .unwrap();
    deterministic.run_until_parked();
-
+    
    worktree_a.read_with(cx_a, |worktree, _| {
        assert_eq!(
            worktree
@@ -2937,12 +2661,7 @@ async fn test_buffer_conflict_after_save(
        assert!(!buf.has_conflict());
    });

-    project_b
-        .update(cx_b, |project, cx| {
-            project.save_buffer(buffer_b.clone(), cx)
-        })
-        .await
-        .unwrap();
+    buffer_b.update(cx_b, |buf, cx| buf.save(cx)).await.unwrap();
    cx_a.foreground().forbid_parking();
    buffer_b.read_with(cx_b, |buffer_b, _| assert!(!buffer_b.is_dirty()));
    buffer_b.read_with(cx_b, |buf, _| {
@@ -3245,7 +2964,7 @@ async fn test_leaving_project(
    buffer_b2.read_with(cx_b, |buffer, _| assert_eq!(buffer.text(), "a-contents"));

    // Drop client B's connection and ensure client A and client C observe client B leaving.
-    client_b.disconnect(&cx_b.to_async());
+    client_b.disconnect(&cx_b.to_async()).unwrap();
    deterministic.advance_clock(RECONNECT_TIMEOUT);
    project_a.read_with(cx_a, |project, _| {
        assert_eq!(project.collaborators().len(), 1);
@@ -3902,11 +3621,9 @@ async fn test_formatting_buffer(
        })
        .await
        .unwrap();
-
-    // The edits from the LSP are applied, and a final newline is added.
    assert_eq!(
        buffer_b.read_with(cx_b, |buffer, _| buffer.text()),
-        "let honey = \"two\"\n"
+        "let honey = \"two\""
    );

    // Ensure buffer can be formatted using an external command. Notice how the
@@ -4716,7 +4433,15 @@ async fn test_collaborating_with_code_actions(

    // Join the project as client B.
    let project_b = client_b.build_remote_project(project_id, cx_b).await;
-    let (_window_b, workspace_b) = cx_b.add_window(|cx| Workspace::test_new(project_b.clone(), cx));
+    let (_window_b, workspace_b) = cx_b.add_window(|cx| {
+        Workspace::new(
+            Default::default(),
+            0,
+            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)
@@ -4939,7 +4664,15 @@ async fn test_collaborating_with_renames(
        .unwrap();
    let project_b = client_b.build_remote_project(project_id, cx_b).await;

-    let (_window_b, workspace_b) = cx_b.add_window(|cx| Workspace::test_new(project_b.clone(), cx));
+    let (_window_b, workspace_b) = cx_b.add_window(|cx| {
+        Workspace::new(
+            Default::default(),
+            0,
+            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)
@@ -5473,10 +5206,7 @@ async fn test_contacts(
        [("user_b".to_string(), "online", "busy")]
    );

-    active_call_a
-        .update(cx_a, |call, cx| call.hang_up(cx))
-        .await
-        .unwrap();
+    active_call_a.update(cx_a, |call, cx| call.hang_up(cx).unwrap());
    deterministic.run_until_parked();
    assert_eq!(
        contacts(&client_a, cx_a),
@@ -5779,7 +5509,7 @@ async fn test_contact_requests(
        .is_empty());

    async fn disconnect_and_reconnect(client: &TestClient, cx: &mut TestAppContext) {
-        client.disconnect(&cx.to_async());
+        client.disconnect(&cx.to_async()).unwrap();
        client.clear_contacts(cx).await;
        client
            .authenticate_and_connect(false, &cx.to_async())
@@ -5789,12 +5519,10 @@ async fn test_contact_requests(
 }

 #[gpui::test(iterations = 10)]
-async fn test_basic_following(
+async fn test_following(
    deterministic: Arc<Deterministic>,
    cx_a: &mut TestAppContext,
    cx_b: &mut TestAppContext,
-    cx_c: &mut TestAppContext,
-    cx_d: &mut TestAppContext,
 ) {
    deterministic.forbid_parking();
    cx_a.update(editor::init);
@@ -5803,15 +5531,8 @@ async fn test_basic_following(
    let mut server = TestServer::start(&deterministic).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;
-    let client_d = server.create_client(cx_d, "user_d").await;
    server
-        .create_room(&mut [
-            (&client_a, cx_a),
-            (&client_b, cx_b),
-            (&client_c, cx_c),
-            (&client_d, cx_d),
-        ])
+        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
        .await;
    let active_call_a = cx_a.read(ActiveCall::global);
    let active_call_b = cx_b.read(ActiveCall::global);
@@ -5843,10 +5564,8 @@ async fn test_basic_following(
        .await
        .unwrap();

-    let workspace_a = client_a.build_workspace(&project_a, cx_a);
-    let workspace_b = client_b.build_workspace(&project_b, cx_b);
-
    // Client A opens some editors.
+    let workspace_a = client_a.build_workspace(&project_a, cx_a);
    let pane_a = workspace_a.read_with(cx_a, |workspace, _| workspace.active_pane().clone());
    let editor_a1 = workspace_a
        .update(cx_a, |workspace, cx| {
@@ -5866,6 +5585,7 @@ async fn test_basic_following(
        .unwrap();

    // Client B opens an editor.
+    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)
@@ -5875,184 +5595,29 @@ async fn test_basic_following(
        .downcast::<Editor>()
        .unwrap();

-    let peer_id_a = client_a.peer_id().unwrap();
-    let peer_id_b = client_b.peer_id().unwrap();
-    let peer_id_c = client_c.peer_id().unwrap();
-    let peer_id_d = client_d.peer_id().unwrap();
+    let client_a_id = project_b.read_with(cx_b, |project, _| {
+        project.collaborators().values().next().unwrap().peer_id
+    });
+    let client_b_id = project_a.read_with(cx_a, |project, _| {
+        project.collaborators().values().next().unwrap().peer_id
+    });

-    // Client A updates their selections in those editors
+    // When client B starts following client A, all visible view states are replicated to client B.
    editor_a1.update(cx_a, |editor, cx| {
        editor.change_selections(None, cx, |s| s.select_ranges([0..1]))
    });
    editor_a2.update(cx_a, |editor, cx| {
        editor.change_selections(None, cx, |s| s.select_ranges([2..3]))
    });
-
-    // When client B starts following client A, all visible view states are replicated to client B.
    workspace_b
        .update(cx_b, |workspace, cx| {
            workspace
-                .toggle_follow(&ToggleFollow(peer_id_a), cx)
+                .toggle_follow(&ToggleFollow(client_a_id), cx)
                .unwrap()
        })
        .await
        .unwrap();

-    cx_c.foreground().run_until_parked();
-    let active_call_c = cx_c.read(ActiveCall::global);
-    let project_c = client_c.build_remote_project(project_id, cx_c).await;
-    let workspace_c = client_c.build_workspace(&project_c, cx_c);
-    active_call_c
-        .update(cx_c, |call, cx| call.set_location(Some(&project_c), cx))
-        .await
-        .unwrap();
-    drop(project_c);
-
-    // Client C also follows client A.
-    workspace_c
-        .update(cx_c, |workspace, cx| {
-            workspace
-                .toggle_follow(&ToggleFollow(peer_id_a), cx)
-                .unwrap()
-        })
-        .await
-        .unwrap();
-
-    cx_d.foreground().run_until_parked();
-    let active_call_d = cx_d.read(ActiveCall::global);
-    let project_d = client_d.build_remote_project(project_id, cx_d).await;
-    let workspace_d = client_d.build_workspace(&project_d, cx_d);
-    active_call_d
-        .update(cx_d, |call, cx| call.set_location(Some(&project_d), cx))
-        .await
-        .unwrap();
-    drop(project_d);
-
-    // All clients see that clients B and C are following client A.
-    cx_c.foreground().run_until_parked();
-    for (name, active_call, cx) in [
-        ("A", &active_call_a, &cx_a),
-        ("B", &active_call_b, &cx_b),
-        ("C", &active_call_c, &cx_c),
-        ("D", &active_call_d, &cx_d),
-    ] {
-        active_call.read_with(*cx, |call, cx| {
-            let room = call.room().unwrap().read(cx);
-            assert_eq!(
-                room.followers_for(peer_id_a, project_id),
-                &[peer_id_b, peer_id_c],
-                "checking followers for A as {name}"
-            );
-        });
-    }
-
-    // Client C unfollows client A.
-    workspace_c.update(cx_c, |workspace, cx| {
-        workspace.toggle_follow(&ToggleFollow(peer_id_a), cx);
-    });
-
-    // All clients see that clients B is following client A.
-    cx_c.foreground().run_until_parked();
-    for (name, active_call, cx) in [
-        ("A", &active_call_a, &cx_a),
-        ("B", &active_call_b, &cx_b),
-        ("C", &active_call_c, &cx_c),
-        ("D", &active_call_d, &cx_d),
-    ] {
-        active_call.read_with(*cx, |call, cx| {
-            let room = call.room().unwrap().read(cx);
-            assert_eq!(
-                room.followers_for(peer_id_a, project_id),
-                &[peer_id_b],
-                "checking followers for A as {name}"
-            );
-        });
-    }
-
-    // Client C re-follows client A.
-    workspace_c.update(cx_c, |workspace, cx| {
-        workspace.toggle_follow(&ToggleFollow(peer_id_a), cx);
-    });
-
-    // All clients see that clients B and C are following client A.
-    cx_c.foreground().run_until_parked();
-    for (name, active_call, cx) in [
-        ("A", &active_call_a, &cx_a),
-        ("B", &active_call_b, &cx_b),
-        ("C", &active_call_c, &cx_c),
-        ("D", &active_call_d, &cx_d),
-    ] {
-        active_call.read_with(*cx, |call, cx| {
-            let room = call.room().unwrap().read(cx);
-            assert_eq!(
-                room.followers_for(peer_id_a, project_id),
-                &[peer_id_b, peer_id_c],
-                "checking followers for A as {name}"
-            );
-        });
-    }
-
-    // Client D follows client C.
-    workspace_d
-        .update(cx_d, |workspace, cx| {
-            workspace
-                .toggle_follow(&ToggleFollow(peer_id_c), cx)
-                .unwrap()
-        })
-        .await
-        .unwrap();
-
-    // All clients see that D is following C
-    cx_d.foreground().run_until_parked();
-    for (name, active_call, cx) in [
-        ("A", &active_call_a, &cx_a),
-        ("B", &active_call_b, &cx_b),
-        ("C", &active_call_c, &cx_c),
-        ("D", &active_call_d, &cx_d),
-    ] {
-        active_call.read_with(*cx, |call, cx| {
-            let room = call.room().unwrap().read(cx);
-            assert_eq!(
-                room.followers_for(peer_id_c, project_id),
-                &[peer_id_d],
-                "checking followers for C as {name}"
-            );
-        });
-    }
-
-    // Client C closes the project.
-    cx_c.drop_last(workspace_c);
-
-    // Clients A and B see that client B is following A, and client C is not present in the followers.
-    cx_c.foreground().run_until_parked();
-    for (name, active_call, cx) in [("A", &active_call_a, &cx_a), ("B", &active_call_b, &cx_b)] {
-        active_call.read_with(*cx, |call, cx| {
-            let room = call.room().unwrap().read(cx);
-            assert_eq!(
-                room.followers_for(peer_id_a, project_id),
-                &[peer_id_b],
-                "checking followers for A as {name}"
-            );
-        });
-    }
-
-    // All clients see that no-one is following C
-    for (name, active_call, cx) in [
-        ("A", &active_call_a, &cx_a),
-        ("B", &active_call_b, &cx_b),
-        ("C", &active_call_c, &cx_c),
-        ("D", &active_call_d, &cx_d),
-    ] {
-        active_call.read_with(*cx, |call, cx| {
-            let room = call.room().unwrap().read(cx);
-            assert_eq!(
-                room.followers_for(peer_id_c, project_id),
-                &[],
-                "checking followers for C as {name}"
-            );
-        });
-    }
-
    let editor_b2 = workspace_b.read_with(cx_b, |workspace, cx| {
        workspace
            .active_item(cx)
@@ -6205,14 +5770,14 @@ async fn test_basic_following(
    workspace_a
        .update(cx_a, |workspace, cx| {
            workspace
-                .toggle_follow(&ToggleFollow(peer_id_b), cx)
+                .toggle_follow(&ToggleFollow(client_b_id), cx)
                .unwrap()
        })
        .await
        .unwrap();
    assert_eq!(
        workspace_a.read_with(cx_a, |workspace, _| workspace.leader_for_pane(&pane_a)),
-        Some(peer_id_b)
+        Some(client_b_id)
    );
    assert_eq!(
        workspace_a.read_with(cx_a, |workspace, cx| workspace
@@ -6284,7 +5849,7 @@ async fn test_basic_following(
    );

    // Following interrupts when client B disconnects.
-    client_b.disconnect(&cx_b.to_async());
+    client_b.disconnect(&cx_b.to_async()).unwrap();
    deterministic.advance_clock(RECONNECT_TIMEOUT);
    assert_eq!(
        workspace_a.read_with(cx_a, |workspace, _| workspace.leader_for_pane(&pane_a)),
@@ -6292,99 +5857,6 @@ async fn test_basic_following(
    );
 }

-#[gpui::test(iterations = 10)]
-async fn test_join_call_after_screen_was_shared(
-    deterministic: Arc<Deterministic>,
-    cx_a: &mut TestAppContext,
-    cx_b: &mut TestAppContext,
-) {
-    deterministic.forbid_parking();
-    let mut server = TestServer::start(&deterministic).await;
-
-    let client_a = server.create_client(cx_a, "user_a").await;
-    let client_b = server.create_client(cx_b, "user_b").await;
-    server
-        .make_contacts(&mut [(&client_a, cx_a), (&client_b, cx_b)])
-        .await;
-
-    let active_call_a = cx_a.read(ActiveCall::global);
-    let active_call_b = cx_b.read(ActiveCall::global);
-
-    // Call users B and C from client A.
-    active_call_a
-        .update(cx_a, |call, cx| {
-            call.invite(client_b.user_id().unwrap(), None, cx)
-        })
-        .await
-        .unwrap();
-    let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
-    deterministic.run_until_parked();
-    assert_eq!(
-        room_participants(&room_a, cx_a),
-        RoomParticipants {
-            remote: Default::default(),
-            pending: vec!["user_b".to_string()]
-        }
-    );
-
-    // User B receives the call.
-    let mut incoming_call_b = active_call_b.read_with(cx_b, |call, _| call.incoming());
-    let call_b = incoming_call_b.next().await.unwrap().unwrap();
-    assert_eq!(call_b.calling_user.github_login, "user_a");
-
-    // User A shares their screen
-    let display = MacOSDisplay::new();
-    active_call_a
-        .update(cx_a, |call, cx| {
-            call.room().unwrap().update(cx, |room, cx| {
-                room.set_display_sources(vec![display.clone()]);
-                room.share_screen(cx)
-            })
-        })
-        .await
-        .unwrap();
-
-    client_b.user_store.update(cx_b, |user_store, _| {
-        user_store.clear_cache();
-    });
-
-    // User B joins the room
-    active_call_b
-        .update(cx_b, |call, cx| call.accept_incoming(cx))
-        .await
-        .unwrap();
-    let room_b = active_call_b.read_with(cx_b, |call, _| call.room().unwrap().clone());
-    assert!(incoming_call_b.next().await.unwrap().is_none());
-
-    deterministic.run_until_parked();
-    assert_eq!(
-        room_participants(&room_a, cx_a),
-        RoomParticipants {
-            remote: vec!["user_b".to_string()],
-            pending: vec![],
-        }
-    );
-    assert_eq!(
-        room_participants(&room_b, cx_b),
-        RoomParticipants {
-            remote: vec!["user_a".to_string()],
-            pending: vec![],
-        }
-    );
-
-    // Ensure User B sees User A's screenshare.
-    room_b.read_with(cx_b, |room, _| {
-        assert_eq!(
-            room.remote_participants()
-                .get(&client_a.user_id().unwrap())
-                .unwrap()
-                .tracks
-                .len(),
-            1
-        );
-    });
-}
-
 #[gpui::test]
 async fn test_following_tab_order(
    deterministic: Arc<Deterministic>,
--- a/crates/collab/src/tests/randomized_integration_tests.rs
+++ b/crates/collab/src/tests/randomized_integration_tests.rs
@@ -641,7 +641,7 @@ async fn randomly_mutate_active_call(
                if can_hang_up && active_call.read_with(cx, |call, _| call.room().is_some()) =>
            {
                log::info!("{}: hanging up", client.username);
-                active_call.update(cx, |call, cx| call.hang_up(cx)).await?;
+                active_call.update(cx, |call, cx| call.hang_up(cx))?;
            }
            _ => {}
        }
@@ -1064,16 +1064,15 @@ async fn randomly_query_and_mutate_buffers(
            }
        }
        30..=39 if buffer.read_with(cx, |buffer, _| buffer.is_dirty()) => {
-            let requested_version = buffer.update(cx, |buffer, cx| {
+            let (requested_version, save) = buffer.update(cx, |buffer, cx| {
                log::info!(
                    "{}: saving buffer {} ({:?})",
                    client.username,
                    buffer.remote_id(),
                    buffer.file().unwrap().full_path(cx)
                );
-                buffer.version()
+                (buffer.version(), buffer.save(cx))
            });
-            let save = project.update(cx, |project, cx| project.save_buffer(buffer, cx));
            let save = cx.background().spawn(async move {
                let (saved_version, _, _) = save
                    .await
--- a/crates/collab_ui/Cargo.toml
+++ b/crates/collab_ui/Cargo.toml
@@ -22,14 +22,11 @@ test-support = [
 ]

 [dependencies]
-auto_update = { path = "../auto_update" }
 call = { path = "../call" }
 client = { path = "../client" }
 clock = { path = "../clock" }
 collections = { path = "../collections" }
-context_menu = { path = "../context_menu" }
 editor = { path = "../editor" }
-feedback = { path = "../feedback" }
 fuzzy = { path = "../fuzzy" }
 gpui = { path = "../gpui" }
 menu = { path = "../menu" }
--- a/crates/collab_ui/src/collab_titlebar_item.rs
+++ b/crates/collab_ui/src/collab_titlebar_item.rs
--- a/crates/collab_ui/src/collab_ui.rs
+++ b/crates/collab_ui/src/collab_ui.rs
@@ -1,24 +1,19 @@
 mod collab_titlebar_item;
-mod collaborator_list_popover;
 mod contact_finder;
 mod contact_list;
 mod contact_notification;
 mod contacts_popover;
-mod face_pile;
 mod incoming_call_notification;
 mod notifications;
 mod project_shared_notification;
-mod sharing_status_indicator;

 use anyhow::anyhow;
 use call::ActiveCall;
-pub use collab_titlebar_item::{CollabTitlebarItem, ToggleContactsMenu};
-use gpui::{actions, MutableAppContext, Task};
+pub use collab_titlebar_item::{CollabTitlebarItem, ToggleCollaborationMenu};
+use gpui::MutableAppContext;
 use std::sync::Arc;
 use workspace::{AppState, JoinProject, ToggleFollow, Workspace};

-actions!(collab, [ToggleScreenSharing]);
-
 pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
    collab_titlebar_item::init(cx);
    contact_notification::init(cx);
@@ -27,108 +22,89 @@ pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
    contacts_popover::init(cx);
    incoming_call_notification::init(cx);
    project_shared_notification::init(cx);
-    sharing_status_indicator::init(cx);

-    cx.add_global_action(toggle_screen_sharing);
    cx.add_global_action(move |action: &JoinProject, cx| {
-        join_project(action, app_state.clone(), cx);
-    });
-}
+        let project_id = action.project_id;
+        let follow_user_id = action.follow_user_id;
+        let app_state = app_state.clone();
+        cx.spawn(|mut cx| async move {
+            let existing_workspace = cx.update(|cx| {
+                cx.window_ids()
+                    .filter_map(|window_id| cx.root_view::<Workspace>(window_id))
+                    .find(|workspace| {
+                        workspace.read(cx).project().read(cx).remote_id() == Some(project_id)
+                    })
+            });

-pub fn toggle_screen_sharing(_: &ToggleScreenSharing, cx: &mut MutableAppContext) {
-    if let Some(room) = ActiveCall::global(cx).read(cx).room().cloned() {
-        let toggle_screen_sharing = room.update(cx, |room, cx| {
-            if room.is_screen_sharing() {
-                Task::ready(room.unshare_screen(cx))
+            let workspace = if let Some(existing_workspace) = existing_workspace {
+                existing_workspace
            } else {
-                room.share_screen(cx)
-            }
-        });
-        toggle_screen_sharing.detach_and_log_err(cx);
-    }
-}
+                let active_call = cx.read(ActiveCall::global);
+                let room = active_call
+                    .read_with(&cx, |call, _| call.room().cloned())
+                    .ok_or_else(|| anyhow!("not in a call"))?;
+                let project = room
+                    .update(&mut cx, |room, cx| {
+                        room.join_project(
+                            project_id,
+                            app_state.languages.clone(),
+                            app_state.fs.clone(),
+                            cx,
+                        )
+                    })
+                    .await?;

-fn join_project(action: &JoinProject, app_state: Arc<AppState>, cx: &mut MutableAppContext) {
-    let project_id = action.project_id;
-    let follow_user_id = action.follow_user_id;
-    cx.spawn(|mut cx| async move {
-        let existing_workspace = cx.update(|cx| {
-            cx.window_ids()
-                .filter_map(|window_id| cx.root_view::<Workspace>(window_id))
-                .find(|workspace| {
-                    workspace.read(cx).project().read(cx).remote_id() == Some(project_id)
-                })
-        });
-
-        let workspace = if let Some(existing_workspace) = existing_workspace {
-            existing_workspace
-        } else {
-            let active_call = cx.read(ActiveCall::global);
-            let room = active_call
-                .read_with(&cx, |call, _| call.room().cloned())
-                .ok_or_else(|| anyhow!("not in a call"))?;
-            let project = room
-                .update(&mut cx, |room, cx| {
-                    room.join_project(
-                        project_id,
-                        app_state.languages.clone(),
-                        app_state.fs.clone(),
-                        cx,
-                    )
-                })
-                .await?;
-
-            let (_, workspace) = cx.add_window(
-                (app_state.build_window_options)(None, None, cx.platform().as_ref()),
-                |cx| {
-                    let mut workspace = Workspace::new(
-                        Default::default(),
-                        0,
-                        project,
-                        app_state.dock_default_item_factory,
-                        app_state.background_actions,
-                        cx,
-                    );
-                    (app_state.initialize_workspace)(&mut workspace, &app_state, cx);
-                    workspace
-                },
-            );
-            workspace
-        };
-
-        cx.activate_window(workspace.window_id());
-        cx.platform().activate(true);
-
-        workspace.update(&mut cx, |workspace, cx| {
-            if let Some(room) = ActiveCall::global(cx).read(cx).room().cloned() {
-                let follow_peer_id = room
-                    .read(cx)
-                    .remote_participants()
-                    .iter()
-                    .find(|(_, participant)| participant.user.id == follow_user_id)
-                    .map(|(_, p)| p.peer_id)
-                    .or_else(|| {
-                        // If we couldn't follow the given user, follow the host instead.
-                        let collaborator = workspace
-                            .project()
-                            .read(cx)
-                            .collaborators()
-                            .values()
-                            .find(|collaborator| collaborator.replica_id == 0)?;
-                        Some(collaborator.peer_id)
-                    });
-
-                if let Some(follow_peer_id) = follow_peer_id {
-                    if !workspace.is_being_followed(follow_peer_id) {
+                let (_, workspace) = cx.add_window(
+                    (app_state.build_window_options)(None, None, cx.platform().as_ref()),
+                    |cx| {
+                        let mut workspace = Workspace::new(
+                            Default::default(),
+                            0,
+                            project,
+                            app_state.dock_default_item_factory,
+                            cx,
+                        );
+                        (app_state.initialize_workspace)(&mut workspace, &app_state, cx);
                        workspace
-                            .toggle_follow(&ToggleFollow(follow_peer_id), cx)
-                            .map(|follow| follow.detach_and_log_err(cx));
+                    },
+                );
+                workspace
+            };
+
+            cx.activate_window(workspace.window_id());
+            cx.platform().activate(true);
+
+            workspace.update(&mut cx, |workspace, cx| {
+                if let Some(room) = ActiveCall::global(cx).read(cx).room().cloned() {
+                    let follow_peer_id = room
+                        .read(cx)
+                        .remote_participants()
+                        .iter()
+                        .find(|(_, participant)| participant.user.id == follow_user_id)
+                        .map(|(_, p)| p.peer_id)
+                        .or_else(|| {
+                            // If we couldn't follow the given user, follow the host instead.
+                            let collaborator = workspace
+                                .project()
+                                .read(cx)
+                                .collaborators()
+                                .values()
+                                .find(|collaborator| collaborator.replica_id == 0)?;
+                            Some(collaborator.peer_id)
+                        });
+
+                    if let Some(follow_peer_id) = follow_peer_id {
+                        if !workspace.is_following(follow_peer_id) {
+                            workspace
+                                .toggle_follow(&ToggleFollow(follow_peer_id), cx)
+                                .map(|follow| follow.detach_and_log_err(cx));
+                        }
                    }
                }
-            }
-        });
+            });

-        anyhow::Ok(())
-    })
-    .detach_and_log_err(cx);
+            anyhow::Ok(())
+        })
+        .detach_and_log_err(cx);
+    });
 }
--- a/crates/collab_ui/src/collaborator_list_popover.rs
+++ b/crates/collab_ui/src/collaborator_list_popover.rs
@@ -1,165 +0,0 @@
-use call::ActiveCall;
-use client::UserStore;
-use gpui::Action;
-use gpui::{
-    actions, elements::*, Entity, ModelHandle, MouseButton, RenderContext, View, ViewContext,
-};
-use settings::Settings;
-
-use crate::collab_titlebar_item::ToggleCollaboratorList;
-
-pub(crate) enum Event {
-    Dismissed,
-}
-
-enum Collaborator {
-    SelfUser { username: String },
-    RemoteUser { username: String },
-}
-
-actions!(collaborator_list_popover, [NoOp]);
-
-pub(crate) struct CollaboratorListPopover {
-    list_state: ListState,
-}
-
-impl Entity for CollaboratorListPopover {
-    type Event = Event;
-}
-
-impl View for CollaboratorListPopover {
-    fn ui_name() -> &'static str {
-        "CollaboratorListPopover"
-    }
-
-    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
-        let theme = cx.global::<Settings>().theme.clone();
-
-        MouseEventHandler::<Self>::new(0, cx, |_, _| {
-            List::new(self.list_state.clone())
-                .contained()
-                .with_style(theme.contacts_popover.container) //TODO: Change the name of this theme key
-                .constrained()
-                .with_width(theme.contacts_popover.width)
-                .with_height(theme.contacts_popover.height)
-                .boxed()
-        })
-        .on_down_out(MouseButton::Left, move |_, cx| {
-            cx.dispatch_action(ToggleCollaboratorList);
-        })
-        .boxed()
-    }
-
-    fn focus_out(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
-        cx.emit(Event::Dismissed);
-    }
-}
-
-impl CollaboratorListPopover {
-    pub fn new(user_store: ModelHandle<UserStore>, cx: &mut ViewContext<Self>) -> Self {
-        let active_call = ActiveCall::global(cx);
-
-        let mut collaborators = user_store
-            .read(cx)
-            .current_user()
-            .map(|u| Collaborator::SelfUser {
-                username: u.github_login.clone(),
-            })
-            .into_iter()
-            .collect::<Vec<_>>();
-
-        //TODO: What should the canonical sort here look like, consult contacts list implementation
-        if let Some(room) = active_call.read(cx).room() {
-            for participant in room.read(cx).remote_participants() {
-                collaborators.push(Collaborator::RemoteUser {
-                    username: participant.1.user.github_login.clone(),
-                });
-            }
-        }
-
-        Self {
-            list_state: ListState::new(
-                collaborators.len(),
-                Orientation::Top,
-                0.,
-                cx,
-                move |_, index, cx| match &collaborators[index] {
-                    Collaborator::SelfUser { username } => render_collaborator_list_entry(
-                        index,
-                        username,
-                        None::<NoOp>,
-                        None,
-                        Svg::new("icons/chevron_right_12.svg"),
-                        NoOp,
-                        "Leave call".to_owned(),
-                        cx,
-                    ),
-
-                    Collaborator::RemoteUser { username } => render_collaborator_list_entry(
-                        index,
-                        username,
-                        Some(NoOp),
-                        Some(format!("Follow {username}")),
-                        Svg::new("icons/x_mark_12.svg"),
-                        NoOp,
-                        format!("Remove {username} from call"),
-                        cx,
-                    ),
-                },
-            ),
-        }
-    }
-}
-
-fn render_collaborator_list_entry<UA: Action + Clone, IA: Action + Clone>(
-    index: usize,
-    username: &str,
-    username_action: Option<UA>,
-    username_tooltip: Option<String>,
-    icon: Svg,
-    icon_action: IA,
-    icon_tooltip: String,
-    cx: &mut RenderContext<CollaboratorListPopover>,
-) -> ElementBox {
-    enum Username {}
-    enum UsernameTooltip {}
-    enum Icon {}
-    enum IconTooltip {}
-
-    let theme = &cx.global::<Settings>().theme;
-    let username_theme = theme.contact_list.contact_username.text.clone();
-    let tooltip_theme = theme.tooltip.clone();
-
-    let username = MouseEventHandler::<Username>::new(index, cx, |_, _| {
-        Label::new(username.to_owned(), username_theme.clone()).boxed()
-    })
-    .on_click(MouseButton::Left, move |_, cx| {
-        if let Some(username_action) = username_action.clone() {
-            cx.dispatch_action(username_action);
-        }
-    });
-
-    Flex::row()
-        .with_child(if let Some(username_tooltip) = username_tooltip {
-            username
-                .with_tooltip::<UsernameTooltip, _>(
-                    index,
-                    username_tooltip,
-                    None,
-                    tooltip_theme.clone(),
-                    cx,
-                )
-                .boxed()
-        } else {
-            username.boxed()
-        })
-        .with_child(
-            MouseEventHandler::<Icon>::new(index, cx, |_, _| icon.boxed())
-                .on_click(MouseButton::Left, move |_, cx| {
-                    cx.dispatch_action(icon_action.clone())
-                })
-                .with_tooltip::<IconTooltip, _>(index, icon_tooltip, None, tooltip_theme, cx)
-                .boxed(),
-        )
-        .boxed()
-}
--- a/crates/collab_ui/src/contact_finder.rs
+++ b/crates/collab_ui/src/contact_finder.rs
@@ -1,7 +1,7 @@
 use client::{ContactRequestStatus, User, UserStore};
 use gpui::{
-    elements::*, AnyViewHandle, AppContext, Entity, ModelHandle, MouseState, MutableAppContext,
-    RenderContext, Task, View, ViewContext, ViewHandle,
+    elements::*, AnyViewHandle, Entity, ModelHandle, MouseState, MutableAppContext, RenderContext,
+    Task, View, ViewContext, ViewHandle,
 };
 use picker::{Picker, PickerDelegate};
 use settings::Settings;
@@ -68,7 +68,7 @@ impl PickerDelegate for ContactFinder {
                    this.potential_contacts = potential_contacts.into();
                    cx.notify();
                });
-                anyhow::Ok(())
+                Ok(())
            }
            .log_err()
            .await;
@@ -128,7 +128,7 @@ impl PickerDelegate for ContactFinder {
            .style_for(mouse_state, selected);
        Flex::row()
            .with_children(user.avatar.clone().map(|avatar| {
-                Image::from_data(avatar)
+                Image::new(avatar)
                    .with_style(theme.contact_finder.contact_avatar)
                    .aligned()
                    .left()
@@ -178,14 +178,4 @@ impl ContactFinder {
            selected_index: 0,
        }
    }
-
-    pub fn editor_text(&self, cx: &AppContext) -> String {
-        self.picker.read(cx).query(cx)
-    }
-
-    pub fn with_editor_text(self, editor_text: String, cx: &mut ViewContext<Self>) -> Self {
-        self.picker
-            .update(cx, |picker, cx| picker.set_query(editor_text, cx));
-        self
-    }
 }
--- a/crates/collab_ui/src/contact_list.rs
+++ b/crates/collab_ui/src/contact_list.rs
@@ -1,4 +1,3 @@
-use super::collab_titlebar_item::LeaveCall;
 use crate::contacts_popover;
 use call::ActiveCall;
 use client::{proto::PeerId, Contact, User, UserStore};
@@ -19,20 +18,22 @@ use serde::Deserialize;
 use settings::Settings;
 use std::{mem, sync::Arc};
 use theme::IconButton;
+use util::ResultExt;
 use workspace::{JoinProject, OpenSharedScreen};

 impl_actions!(contact_list, [RemoveContact, RespondToContactRequest]);
-impl_internal_actions!(contact_list, [ToggleExpanded, Call]);
+impl_internal_actions!(contact_list, [ToggleExpanded, Call, LeaveCall]);

 pub fn init(cx: &mut MutableAppContext) {
    cx.add_action(ContactList::remove_contact);
    cx.add_action(ContactList::respond_to_contact_request);
-    cx.add_action(ContactList::cancel);
+    cx.add_action(ContactList::clear_filter);
    cx.add_action(ContactList::select_next);
    cx.add_action(ContactList::select_prev);
    cx.add_action(ContactList::confirm);
    cx.add_action(ContactList::toggle_expanded);
    cx.add_action(ContactList::call);
+    cx.add_action(ContactList::leave_call);
 }

 #[derive(Clone, PartialEq)]
@@ -44,6 +45,9 @@ struct Call {
    initial_project: Option<ModelHandle<Project>>,
 }

+#[derive(Copy, Clone, PartialEq)]
+struct LeaveCall;
+
 #[derive(Clone, Copy, PartialEq, Eq, Debug, PartialOrd, Ord)]
 enum Section {
    ActiveCall,
@@ -141,10 +145,7 @@ impl PartialEq for ContactEntry {
 pub struct RequestContact(pub u64);

 #[derive(Clone, Deserialize, PartialEq)]
-pub struct RemoveContact {
-    user_id: u64,
-    github_login: String,
-}
+pub struct RemoveContact(pub u64);

 #[derive(Clone, Deserialize, PartialEq)]
 pub struct RespondToContactRequest {
@@ -297,25 +298,11 @@ impl ContactList {
        this
    }

-    pub fn editor_text(&self, cx: &AppContext) -> String {
-        self.filter_editor.read(cx).text(cx)
-    }
-
-    pub fn with_editor_text(self, editor_text: String, cx: &mut ViewContext<Self>) -> Self {
-        self.filter_editor
-            .update(cx, |picker, cx| picker.set_text(editor_text, cx));
-        self
-    }
-
    fn remove_contact(&mut self, request: &RemoveContact, cx: &mut ViewContext<Self>) {
-        let user_id = request.user_id;
-        let github_login = &request.github_login;
+        let user_id = request.0;
        let user_store = self.user_store.clone();
-        let prompt_message = format!(
-            "Are you sure you want to remove \"{}\" from your contacts?",
-            github_login
-        );
-        let mut answer = cx.prompt(PromptLevel::Warning, &prompt_message, &["Remove", "Cancel"]);
+        let prompt_message = "Are you sure you want to remove this contact?";
+        let mut answer = cx.prompt(PromptLevel::Warning, prompt_message, &["Remove", "Cancel"]);
        cx.spawn(|_, mut cx| async move {
            if answer.next().await == Some(0) {
                user_store
@@ -339,7 +326,7 @@ impl ContactList {
            .detach();
    }

-    fn cancel(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {
+    fn clear_filter(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {
        let did_clear = self.filter_editor.update(cx, |editor, cx| {
            if editor.buffer().read(cx).len(cx) > 0 {
                editor.set_text("", cx);
@@ -348,7 +335,6 @@ impl ContactList {
                false
            }
        });
-
        if !did_clear {
            cx.emit(Event::Dismissed);
        }
@@ -743,7 +729,7 @@ impl ContactList {
    ) -> ElementBox {
        Flex::row()
            .with_children(user.avatar.clone().map(|avatar| {
-                Image::from_data(avatar)
+                Image::new(avatar)
                    .with_style(theme.contact_avatar)
                    .aligned()
                    .left()
@@ -763,7 +749,7 @@ impl ContactList {
            )
            .with_children(if is_pending {
                Some(
-                    Label::new("Calling", theme.calling_indicator.text.clone())
+                    Label::new("Calling".to_string(), theme.calling_indicator.text.clone())
                        .contained()
                        .with_style(theme.calling_indicator.container)
                        .aligned()
@@ -964,7 +950,7 @@ impl ContactList {
                            .boxed(),
                    )
                    .with_child(
-                        Label::new("Screen", row.name.text.clone())
+                        Label::new("Screen".into(), row.name.text.clone())
                            .aligned()
                            .left()
                            .contained()
@@ -994,7 +980,6 @@ impl ContactList {
        cx: &mut RenderContext<Self>,
    ) -> ElementBox {
        enum Header {}
-        enum LeaveCallContactList {}

        let header_style = theme
            .header_row
@@ -1007,9 +992,9 @@ impl ContactList {
        };
        let leave_call = if section == Section::ActiveCall {
            Some(
-                MouseEventHandler::<LeaveCallContactList>::new(0, cx, |state, _| {
+                MouseEventHandler::<LeaveCall>::new(0, cx, |state, _| {
                    let style = theme.leave_call.style_for(state, false);
-                    Label::new("Leave Call", style.text.clone())
+                    Label::new("Leave Session".into(), style.text.clone())
                        .contained()
                        .with_style(style.container)
                        .boxed()
@@ -1041,7 +1026,7 @@ impl ContactList {
                    .boxed(),
                )
                .with_child(
-                    Label::new(text, header_style.text.clone())
+                    Label::new(text.to_string(), header_style.text.clone())
                        .aligned()
                        .left()
                        .contained()
@@ -1074,7 +1059,6 @@ impl ContactList {
        let online = contact.online;
        let busy = contact.busy || calling;
        let user_id = contact.user.id;
-        let github_login = contact.user.github_login.clone();
        let initial_project = project.clone();
        let mut element =
            MouseEventHandler::<Contact>::new(contact.user.id as usize, cx, |_, cx| {
@@ -1098,7 +1082,7 @@ impl ContactList {
                        };
                        Stack::new()
                            .with_child(
-                                Image::from_data(avatar)
+                                Image::new(avatar)
                                    .with_style(theme.contact_avatar)
                                    .aligned()
                                    .left()
@@ -1135,17 +1119,14 @@ impl ContactList {
                        .with_padding(Padding::uniform(2.))
                        .with_cursor_style(CursorStyle::PointingHand)
                        .on_click(MouseButton::Left, move |_, cx| {
-                            cx.dispatch_action(RemoveContact {
-                                user_id,
-                                github_login: github_login.clone(),
-                            })
+                            cx.dispatch_action(RemoveContact(user_id))
                        })
                        .flex_float()
                        .boxed(),
                    )
                    .with_children(if calling {
                        Some(
-                            Label::new("Calling", theme.calling_indicator.text.clone())
+                            Label::new("Calling".to_string(), theme.calling_indicator.text.clone())
                                .contained()
                                .with_style(theme.calling_indicator.container)
                                .aligned()
@@ -1194,7 +1175,7 @@ impl ContactList {

        let mut row = Flex::row()
            .with_children(user.avatar.clone().map(|avatar| {
-                Image::from_data(avatar)
+                Image::new(avatar)
                    .with_style(theme.contact_avatar)
                    .aligned()
                    .left()
@@ -1214,7 +1195,6 @@ impl ContactList {
            );

        let user_id = user.id;
-        let github_login = user.github_login.clone();
        let is_contact_request_pending = user_store.read(cx).is_contact_request_pending(&user);
        let button_spacing = theme.contact_button_spacing;

@@ -1276,10 +1256,7 @@ impl ContactList {
                .with_padding(Padding::uniform(2.))
                .with_cursor_style(CursorStyle::PointingHand)
                .on_click(MouseButton::Left, move |_, cx| {
-                    cx.dispatch_action(RemoveContact {
-                        user_id,
-                        github_login: github_login.clone(),
-                    })
+                    cx.dispatch_action(RemoveContact(user_id))
                })
                .flex_float()
                .boxed(),
@@ -1306,6 +1283,12 @@ impl ContactList {
            })
            .detach_and_log_err(cx);
    }
+
+    fn leave_call(&mut self, _: &LeaveCall, cx: &mut ViewContext<Self>) {
+        ActiveCall::global(cx)
+            .update(cx, |call, cx| call.hang_up(cx))
+            .log_err();
+    }
 }

 impl Entity for ContactList {
@@ -1319,7 +1302,7 @@ impl View for ContactList {

    fn keymap_context(&self, _: &AppContext) -> KeymapContext {
        let mut cx = Self::default_keymap_context();
-        cx.add_identifier("menu");
+        cx.set.insert("menu".into());
        cx
    }

@@ -1351,7 +1334,7 @@ impl View for ContactList {
                        })
                        .with_tooltip::<AddContact, _>(
                            0,
-                            "Search for new contact".into(),
+                            "Add contact".into(),
                            None,
                            theme.tooltip.clone(),
                            cx,
--- a/crates/collab_ui/src/contacts_popover.rs
+++ b/crates/collab_ui/src/contacts_popover.rs
@@ -1,8 +1,8 @@
-use crate::{contact_finder::ContactFinder, contact_list::ContactList, ToggleContactsMenu};
+use crate::{contact_finder::ContactFinder, contact_list::ContactList, ToggleCollaborationMenu};
 use client::UserStore;
 use gpui::{
-    actions, elements::*, Entity, ModelHandle, MouseButton, MutableAppContext, RenderContext, View,
-    ViewContext, ViewHandle,
+    actions, elements::*, ClipboardItem, CursorStyle, Entity, ModelHandle, MouseButton,
+    MutableAppContext, RenderContext, View, ViewContext, ViewHandle,
 };
 use project::Project;
 use settings::Settings;
@@ -43,23 +43,19 @@ impl ContactsPopover {
            user_store,
            _subscription: None,
        };
-        this.show_contact_list(String::new(), cx);
+        this.show_contact_list(cx);
        this
    }

    fn toggle_contact_finder(&mut self, _: &ToggleContactFinder, cx: &mut ViewContext<Self>) {
        match &self.child {
-            Child::ContactList(list) => self.show_contact_finder(list.read(cx).editor_text(cx), cx),
-            Child::ContactFinder(finder) => {
-                self.show_contact_list(finder.read(cx).editor_text(cx), cx)
-            }
+            Child::ContactList(_) => self.show_contact_finder(cx),
+            Child::ContactFinder(_) => self.show_contact_list(cx),
        }
    }

-    fn show_contact_finder(&mut self, editor_text: String, cx: &mut ViewContext<ContactsPopover>) {
-        let child = cx.add_view(|cx| {
-            ContactFinder::new(self.user_store.clone(), cx).with_editor_text(editor_text, cx)
-        });
+    fn show_contact_finder(&mut self, cx: &mut ViewContext<ContactsPopover>) {
+        let child = cx.add_view(|cx| ContactFinder::new(self.user_store.clone(), cx));
        cx.focus(&child);
        self._subscription = Some(cx.subscribe(&child, |_, _, event, cx| match event {
            crate::contact_finder::Event::Dismissed => cx.emit(Event::Dismissed),
@@ -68,11 +64,9 @@ impl ContactsPopover {
        cx.notify();
    }

-    fn show_contact_list(&mut self, editor_text: String, cx: &mut ViewContext<ContactsPopover>) {
-        let child = cx.add_view(|cx| {
-            ContactList::new(self.project.clone(), self.user_store.clone(), cx)
-                .with_editor_text(editor_text, cx)
-        });
+    fn show_contact_list(&mut self, cx: &mut ViewContext<ContactsPopover>) {
+        let child =
+            cx.add_view(|cx| ContactList::new(self.project.clone(), self.user_store.clone(), cx));
        cx.focus(&child);
        self._subscription = Some(cx.subscribe(&child, |_, _, event, cx| match event {
            crate::contact_list::Event::Dismissed => cx.emit(Event::Dismissed),
@@ -98,9 +92,61 @@ impl View for ContactsPopover {
            Child::ContactFinder(child) => ChildView::new(child, cx),
        };

-        MouseEventHandler::<ContactsPopover>::new(0, cx, |_, _| {
+        MouseEventHandler::<ContactsPopover>::new(0, cx, |_, cx| {
            Flex::column()
                .with_child(child.flex(1., true).boxed())
+                .with_children(
+                    self.user_store
+                        .read(cx)
+                        .invite_info()
+                        .cloned()
+                        .and_then(|info| {
+                            enum InviteLink {}
+
+                            if info.count > 0 {
+                                Some(
+                                    MouseEventHandler::<InviteLink>::new(0, cx, |state, cx| {
+                                        let style = theme
+                                            .contacts_popover
+                                            .invite_row
+                                            .style_for(state, false)
+                                            .clone();
+
+                                        let copied =
+                                            cx.read_from_clipboard().map_or(false, |item| {
+                                                item.text().as_str() == info.url.as_ref()
+                                            });
+
+                                        Label::new(
+                                            format!(
+                                                "{} invite link ({} left)",
+                                                if copied { "Copied" } else { "Copy" },
+                                                info.count
+                                            ),
+                                            style.label.clone(),
+                                        )
+                                        .aligned()
+                                        .left()
+                                        .constrained()
+                                        .with_height(theme.contacts_popover.invite_row_height)
+                                        .contained()
+                                        .with_style(style.container)
+                                        .boxed()
+                                    })
+                                    .with_cursor_style(CursorStyle::PointingHand)
+                                    .on_click(MouseButton::Left, move |_, cx| {
+                                        cx.write_to_clipboard(ClipboardItem::new(
+                                            info.url.to_string(),
+                                        ));
+                                        cx.notify();
+                                    })
+                                    .boxed(),
+                                )
+                            } else {
+                                None
+                            }
+                        }),
+                )
                .contained()
                .with_style(theme.contacts_popover.container)
                .constrained()
@@ -109,7 +155,7 @@ impl View for ContactsPopover {
                .boxed()
        })
        .on_down_out(MouseButton::Left, move |_, cx| {
-            cx.dispatch_action(ToggleContactsMenu);
+            cx.dispatch_action(ToggleCollaborationMenu);
        })
        .boxed()
    }
--- a/crates/collab_ui/src/face_pile.rs
+++ b/crates/collab_ui/src/face_pile.rs
@@ -1,101 +0,0 @@
-use std::ops::Range;
-
-use gpui::{
-    geometry::{
-        rect::RectF,
-        vector::{vec2f, Vector2F},
-    },
-    json::ToJson,
-    serde_json::{self, json},
-    Axis, DebugContext, Element, ElementBox, MeasurementContext, PaintContext,
-};
-
-pub(crate) struct FacePile {
-    overlap: f32,
-    faces: Vec<ElementBox>,
-}
-
-impl FacePile {
-    pub fn new(overlap: f32) -> FacePile {
-        FacePile {
-            overlap,
-            faces: Vec::new(),
-        }
-    }
-}
-
-impl Element for FacePile {
-    type LayoutState = ();
-    type PaintState = ();
-
-    fn layout(
-        &mut self,
-        constraint: gpui::SizeConstraint,
-        cx: &mut gpui::LayoutContext,
-    ) -> (Vector2F, Self::LayoutState) {
-        debug_assert!(constraint.max_along(Axis::Horizontal) == f32::INFINITY);
-
-        let mut width = 0.;
-        for face in &mut self.faces {
-            width += face.layout(constraint, cx).x();
-        }
-        width -= self.overlap * self.faces.len().saturating_sub(1) as f32;
-
-        (Vector2F::new(width, constraint.max.y()), ())
-    }
-
-    fn paint(
-        &mut self,
-        bounds: RectF,
-        visible_bounds: RectF,
-        _layout: &mut Self::LayoutState,
-        cx: &mut PaintContext,
-    ) -> Self::PaintState {
-        let visible_bounds = bounds.intersection(visible_bounds).unwrap_or_default();
-
-        let origin_y = bounds.upper_right().y();
-        let mut origin_x = bounds.upper_right().x();
-
-        for face in self.faces.iter_mut().rev() {
-            let size = face.size();
-            origin_x -= size.x();
-            cx.paint_layer(None, |cx| {
-                face.paint(vec2f(origin_x, origin_y), visible_bounds, cx);
-            });
-            origin_x += self.overlap;
-        }
-
-        ()
-    }
-
-    fn rect_for_text_range(
-        &self,
-        _: Range<usize>,
-        _: RectF,
-        _: RectF,
-        _: &Self::LayoutState,
-        _: &Self::PaintState,
-        _: &MeasurementContext,
-    ) -> Option<RectF> {
-        None
-    }
-
-    fn debug(
-        &self,
-        bounds: RectF,
-        _: &Self::LayoutState,
-        _: &Self::PaintState,
-        _: &DebugContext,
-    ) -> serde_json::Value {
-        json!({
-            "type": "FacePile",
-            "bounds": bounds.to_json()
-        })
-    }
-}
-
-impl Extend<ElementBox> for FacePile {
-    fn extend<T: IntoIterator<Item = ElementBox>>(&mut self, children: T) {
-        self.faces.extend(children);
-    }
-}
--- a/crates/collab_ui/src/incoming_call_notification.rs
+++ b/crates/collab_ui/src/incoming_call_notification.rs
@@ -108,7 +108,7 @@ impl IncomingCallNotification {
            .unwrap_or(&default_project);
        Flex::row()
            .with_children(self.call.calling_user.avatar.clone().map(|avatar| {
-                Image::from_data(avatar)
+                Image::new(avatar)
                    .with_style(theme.caller_avatar)
                    .aligned()
                    .boxed()
@@ -172,7 +172,7 @@ impl IncomingCallNotification {
            .with_child(
                MouseEventHandler::<Accept>::new(0, cx, |_, cx| {
                    let theme = &cx.global::<Settings>().theme.incoming_call_notification;
-                    Label::new("Accept", theme.accept_button.text.clone())
+                    Label::new("Accept".to_string(), theme.accept_button.text.clone())
                        .aligned()
                        .contained()
                        .with_style(theme.accept_button.container)
@@ -188,7 +188,7 @@ impl IncomingCallNotification {
            .with_child(
                MouseEventHandler::<Decline>::new(0, cx, |_, cx| {
                    let theme = &cx.global::<Settings>().theme.incoming_call_notification;
-                    Label::new("Decline", theme.decline_button.text.clone())
+                    Label::new("Decline".to_string(), theme.decline_button.text.clone())
                        .aligned()
                        .contained()
                        .with_style(theme.decline_button.container)
--- a/crates/collab_ui/src/notifications.rs
+++ b/crates/collab_ui/src/notifications.rs
@@ -11,8 +11,8 @@ enum Button {}

 pub fn render_user_notification<V: View, A: Action + Clone>(
    user: Arc<User>,
-    title: &'static str,
-    body: Option<&'static str>,
+    title: &str,
+    body: Option<&str>,
    dismiss_action: A,
    buttons: Vec<(&'static str, Box<dyn Action>)>,
    cx: &mut RenderContext<V>,
@@ -24,7 +24,7 @@ pub fn render_user_notification<V: View, A: Action + Clone>(
        .with_child(
            Flex::row()
                .with_children(user.avatar.clone().map(|avatar| {
-                    Image::from_data(avatar)
+                    Image::new(avatar)
                        .with_style(theme.header_avatar)
                        .aligned()
                        .constrained()
@@ -83,7 +83,7 @@ pub fn render_user_notification<V: View, A: Action + Clone>(
                .named("contact notification header"),
        )
        .with_children(body.map(|body| {
-            Label::new(body, theme.body_message.text.clone())
+            Label::new(body.to_string(), theme.body_message.text.clone())
                .contained()
                .with_style(theme.body_message.container)
                .boxed()
@@ -97,7 +97,7 @@ pub fn render_user_notification<V: View, A: Action + Clone>(
                        |(ix, (message, action))| {
                            MouseEventHandler::<Button>::new(ix, cx, |state, _| {
                                let button = theme.button.style_for(state, false);
-                                Label::new(message, button.text.clone())
+                                Label::new(message.to_string(), button.text.clone())
                                    .contained()
                                    .with_style(button.container)
                                    .boxed()
--- a/crates/collab_ui/src/project_shared_notification.rs
+++ b/crates/collab_ui/src/project_shared_notification.rs
@@ -108,7 +108,7 @@ impl ProjectSharedNotification {
        let theme = &cx.global::<Settings>().theme.project_shared_notification;
        Flex::row()
            .with_children(self.owner.avatar.clone().map(|avatar| {
-                Image::from_data(avatar)
+                Image::new(avatar)
                    .with_style(theme.owner_avatar)
                    .aligned()
                    .boxed()
@@ -175,7 +175,7 @@ impl ProjectSharedNotification {
            .with_child(
                MouseEventHandler::<Open>::new(0, cx, |_, cx| {
                    let theme = &cx.global::<Settings>().theme.project_shared_notification;
-                    Label::new("Open", theme.open_button.text.clone())
+                    Label::new("Open".to_string(), theme.open_button.text.clone())
                        .aligned()
                        .contained()
                        .with_style(theme.open_button.container)
@@ -194,7 +194,7 @@ impl ProjectSharedNotification {
            .with_child(
                MouseEventHandler::<Dismiss>::new(0, cx, |_, cx| {
                    let theme = &cx.global::<Settings>().theme.project_shared_notification;
-                    Label::new("Dismiss", theme.dismiss_button.text.clone())
+                    Label::new("Dismiss".to_string(), theme.dismiss_button.text.clone())
                        .aligned()
                        .contained()
                        .with_style(theme.dismiss_button.container)
--- a/crates/collab_ui/src/sharing_status_indicator.rs
+++ b/crates/collab_ui/src/sharing_status_indicator.rs
@@ -1,59 +0,0 @@
-use call::ActiveCall;
-use gpui::{
-    color::Color,
-    elements::{MouseEventHandler, Svg},
-    Appearance, Element, ElementBox, Entity, MouseButton, MutableAppContext, RenderContext, View,
-};
-use settings::Settings;
-
-use crate::ToggleScreenSharing;
-
-pub fn init(cx: &mut MutableAppContext) {
-    let active_call = ActiveCall::global(cx);
-
-    let mut status_indicator = None;
-    cx.observe(&active_call, move |call, cx| {
-        if let Some(room) = call.read(cx).room() {
-            if room.read(cx).is_screen_sharing() {
-                if status_indicator.is_none() && cx.global::<Settings>().show_call_status_icon {
-                    status_indicator = Some(cx.add_status_bar_item(|_| SharingStatusIndicator));
-                }
-            } else if let Some((window_id, _)) = status_indicator.take() {
-                cx.remove_status_bar_item(window_id);
-            }
-        }
-    })
-    .detach();
-}
-
-pub struct SharingStatusIndicator;
-
-impl Entity for SharingStatusIndicator {
-    type Event = ();
-}
-
-impl View for SharingStatusIndicator {
-    fn ui_name() -> &'static str {
-        "SharingStatusIndicator"
-    }
-
-    fn render(&mut self, cx: &mut RenderContext<'_, Self>) -> ElementBox {
-        let color = match cx.appearance {
-            Appearance::Light | Appearance::VibrantLight => Color::black(),
-            Appearance::Dark | Appearance::VibrantDark => Color::white(),
-        };
-
-        MouseEventHandler::<Self>::new(0, cx, |_, _| {
-            Svg::new("icons/disable_screen_sharing_12.svg")
-                .with_color(color)
-                .constrained()
-                .with_width(18.)
-                .aligned()
-                .boxed()
-        })
-        .on_click(MouseButton::Left, |_, cx| {
-            cx.dispatch_action(ToggleScreenSharing);
-        })
-        .boxed()
-    }
-}
--- a/crates/command_palette/src/command_palette.rs
+++ b/crates/command_palette/src/command_palette.rs
@@ -65,7 +65,7 @@ impl CommandPalette {
                    action,
                    keystrokes: bindings
                        .iter()
-                        .map(|binding| binding.keystrokes())
+                        .filter_map(|binding| binding.keystrokes())
                        .last()
                        .map_or(Vec::new(), |keystrokes| keystrokes.to_vec()),
                })
@@ -257,7 +257,7 @@ impl PickerDelegate for CommandPalette {
                        .filter_map(|(modifier, label)| {
                            if modifier {
                                Some(
-                                    Label::new(label, key_style.label.clone())
+                                    Label::new(label.into(), key_style.label.clone())
                                        .contained()
                                        .with_style(key_style.container)
                                        .boxed(),
@@ -352,7 +352,9 @@ mod tests {
        });

        let project = Project::test(app_state.fs.clone(), [], cx).await;
-        let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
+        let (_, workspace) = cx.add_window(|cx| {
+            Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
+        });
        let editor = cx.add_view(&workspace, |cx| {
            let mut editor = Editor::single_line(None, cx);
            editor.set_text("abc", cx);
--- a/crates/context_menu/src/context_menu.rs
+++ b/crates/context_menu/src/context_menu.rs
@@ -5,9 +5,7 @@ use gpui::{
 };
 use menu::*;
 use settings::Settings;
-use std::{any::TypeId, borrow::Cow, time::Duration};
-
-pub type StaticItem = Box<dyn Fn(&mut MutableAppContext) -> ElementBox>;
+use std::{any::TypeId, time::Duration};

 #[derive(Copy, Clone, PartialEq)]
 struct Clicked;
@@ -26,17 +24,16 @@ pub fn init(cx: &mut MutableAppContext) {

 pub enum ContextMenuItem {
    Item {
-        label: Cow<'static, str>,
+        label: String,
        action: Box<dyn Action>,
    },
-    Static(StaticItem),
    Separator,
 }

 impl ContextMenuItem {
-    pub fn item(label: impl Into<Cow<'static, str>>, action: impl 'static + Action) -> Self {
+    pub fn item(label: impl ToString, action: impl 'static + Action) -> Self {
        Self::Item {
-            label: label.into(),
+            label: label.to_string(),
            action: Box::new(action),
        }
    }
@@ -45,14 +42,14 @@ impl ContextMenuItem {
        Self::Separator
    }

-    fn is_action(&self) -> bool {
-        matches!(self, Self::Item { .. })
+    fn is_separator(&self) -> bool {
+        matches!(self, Self::Separator)
    }

    fn action_id(&self) -> Option<TypeId> {
        match self {
            ContextMenuItem::Item { action, .. } => Some(action.id()),
-            ContextMenuItem::Static(..) | ContextMenuItem::Separator => None,
+            ContextMenuItem::Separator => None,
        }
    }
 }
@@ -61,13 +58,11 @@ pub struct ContextMenu {
    show_count: usize,
    anchor_position: Vector2F,
    anchor_corner: AnchorCorner,
-    position_mode: OverlayPositionMode,
    items: Vec<ContextMenuItem>,
    selected_index: Option<usize>,
    visible: bool,
    previously_focused_view_id: Option<usize>,
    clicked: bool,
-    parent_view_id: usize,
    _actions_observation: Subscription,
 }

@@ -82,7 +77,7 @@ impl View for ContextMenu {

    fn keymap_context(&self, _: &AppContext) -> KeymapContext {
        let mut cx = Self::default_keymap_context();
-        cx.add_identifier("menu");
+        cx.set.insert("menu".into());
        cx
    }

@@ -109,7 +104,6 @@ impl View for ContextMenu {
            .with_fit_mode(OverlayFitMode::SnapToWindow)
            .with_anchor_position(self.anchor_position)
            .with_anchor_corner(self.anchor_corner)
-            .with_position_mode(self.position_mode)
            .boxed()
    }

@@ -120,19 +114,15 @@ impl View for ContextMenu {

 impl ContextMenu {
    pub fn new(cx: &mut ViewContext<Self>) -> Self {
-        let parent_view_id = cx.parent().unwrap();
-
        Self {
            show_count: 0,
            anchor_position: Default::default(),
            anchor_corner: AnchorCorner::TopLeft,
-            position_mode: OverlayPositionMode::Window,
            items: Default::default(),
            selected_index: Default::default(),
            visible: Default::default(),
            previously_focused_view_id: Default::default(),
            clicked: false,
-            parent_view_id,
            _actions_observation: cx.observe_actions(Self::action_dispatched),
        }
    }
@@ -194,13 +184,13 @@ impl ContextMenu {
    }

    fn select_first(&mut self, _: &SelectFirst, cx: &mut ViewContext<Self>) {
-        self.selected_index = self.items.iter().position(|item| item.is_action());
+        self.selected_index = self.items.iter().position(|item| !item.is_separator());
        cx.notify();
    }

    fn select_last(&mut self, _: &SelectLast, cx: &mut ViewContext<Self>) {
        for (ix, item) in self.items.iter().enumerate().rev() {
-            if item.is_action() {
+            if !item.is_separator() {
                self.selected_index = Some(ix);
                cx.notify();
                break;
@@ -211,7 +201,7 @@ impl ContextMenu {
    fn select_next(&mut self, _: &SelectNext, cx: &mut ViewContext<Self>) {
        if let Some(ix) = self.selected_index {
            for (ix, item) in self.items.iter().enumerate().skip(ix + 1) {
-                if item.is_action() {
+                if !item.is_separator() {
                    self.selected_index = Some(ix);
                    cx.notify();
                    break;
@@ -225,7 +215,7 @@ impl ContextMenu {
    fn select_prev(&mut self, _: &SelectPrev, cx: &mut ViewContext<Self>) {
        if let Some(ix) = self.selected_index {
            for (ix, item) in self.items.iter().enumerate().take(ix).rev() {
-                if item.is_action() {
+                if !item.is_separator() {
                    self.selected_index = Some(ix);
                    cx.notify();
                    break;
@@ -240,7 +230,7 @@ impl ContextMenu {
        &mut self,
        anchor_position: Vector2F,
        anchor_corner: AnchorCorner,
-        items: Vec<ContextMenuItem>,
+        items: impl IntoIterator<Item = ContextMenuItem>,
        cx: &mut ViewContext<Self>,
    ) {
        let mut items = items.into_iter().peekable();
@@ -260,12 +250,7 @@ impl ContextMenu {
        cx.notify();
    }

-    pub fn set_position_mode(&mut self, mode: OverlayPositionMode) {
-        self.position_mode = mode;
-    }
-
    fn render_menu_for_measurement(&self, cx: &mut RenderContext<Self>) -> impl Element {
-        let window_id = cx.window_id();
        let style = cx.global::<Settings>().theme.context_menu.clone();
        Flex::row()
            .with_child(
@@ -283,9 +268,6 @@ impl ContextMenu {
                                    .with_style(style.container)
                                    .boxed()
                            }
-
-                            ContextMenuItem::Static(f) => f(cx),
-
                            ContextMenuItem::Separator => Empty::new()
                                .collapsed()
                                .contained()
@@ -307,17 +289,12 @@ impl ContextMenu {
                                    Some(ix) == self.selected_index,
                                );
                                KeystrokeLabel::new(
-                                    window_id,
-                                    self.parent_view_id,
                                    action.boxed_clone(),
                                    style.keystroke.container,
                                    style.keystroke.text.clone(),
                                )
                                .boxed()
                            }
-
-                            ContextMenuItem::Static(_) => Empty::new().boxed(),
-
                            ContextMenuItem::Separator => Empty::new()
                                .collapsed()
                                .constrained()
@@ -341,7 +318,6 @@ impl ContextMenu {

        let style = cx.global::<Settings>().theme.context_menu.clone();

-        let window_id = cx.window_id();
        MouseEventHandler::<Menu>::new(0, cx, |_, cx| {
            Flex::column()
                .with_children(self.items.iter().enumerate().map(|(ix, item)| {
@@ -355,14 +331,12 @@ impl ContextMenu {

                                Flex::row()
                                    .with_child(
-                                        Label::new(label.clone(), style.label.clone())
+                                        Label::new(label.to_string(), style.label.clone())
                                            .contained()
                                            .boxed(),
                                    )
                                    .with_child({
                                        KeystrokeLabel::new(
-                                            window_id,
-                                            self.parent_view_id,
                                            action.boxed_clone(),
                                            style.keystroke.container,
                                            style.keystroke.text.clone(),
@@ -382,9 +356,6 @@ impl ContextMenu {
                            .on_drag(MouseButton::Left, |_, _| {})
                            .boxed()
                        }
-
-                        ContextMenuItem::Static(f) => f(cx),
-
                        ContextMenuItem::Separator => Empty::new()
                            .constrained()
                            .with_height(1.)
--- a/crates/db/src/db.rs
+++ b/crates/db/src/db.rs
@@ -4,7 +4,6 @@ pub mod query;
 // Re-export
 pub use anyhow;
 use anyhow::Context;
-use gpui::MutableAppContext;
 pub use indoc::indoc;
 pub use lazy_static;
 use parking_lot::{Mutex, RwLock};
@@ -18,7 +17,6 @@ use sqlez::domain::Migrator;
 use sqlez::thread_safe_connection::ThreadSafeConnection;
 use sqlez_macros::sql;
 use std::fs::create_dir_all;
-use std::future::Future;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -41,7 +39,6 @@ const FALLBACK_DB_NAME: &'static str = "FALLBACK_MEMORY_DB";
 const DB_FILE_NAME: &'static str = "db.sqlite";

 lazy_static::lazy_static! {
-    // !!!!!!! CHANGE BACK TO DEFAULT FALSE BEFORE SHIPPING
    static ref ZED_STATELESS: bool = std::env::var("ZED_STATELESS").map_or(false, |v| !v.is_empty());
    static ref DB_FILE_OPERATIONS: Mutex<()> = Mutex::new(());
    pub static ref BACKUP_DB_PATH: RwLock<Option<PathBuf>> = RwLock::new(None);
@@ -66,11 +63,11 @@ pub async fn open_db<M: Migrator + 'static>(
    let connection = async_iife!({
        // Note: This still has a race condition where 1 set of migrations succeeds
        // (e.g. (Workspace, Editor)) and another fails (e.g. (Workspace, Terminal))
-        // This will cause the first connection to have the database taken out
+        // This will cause the first connection to have the database taken out 
        // from under it. This *should* be fine though. The second dabatase failure will
        // cause errors in the log and so should be observed by developers while writing
        // soon-to-be good migrations. If user databases are corrupted, we toss them out
-        // and try again from a blank. As long as running all migrations from start to end
+        // and try again from a blank. As long as running all migrations from start to end 
        // on a blank database is ok, this race condition will never be triggered.
        //
        // Basically: Don't ever push invalid migrations to stable or everyone will have
@@ -88,7 +85,7 @@ pub async fn open_db<M: Migrator + 'static>(
            };
        }

-        // Take a lock in the failure case so that we move the db once per process instead
+        // Take a lock in the failure case so that we move the db once per process instead 
        // of potentially multiple times from different threads. This shouldn't happen in the
        // normal path
        let _lock = DB_FILE_OPERATIONS.lock();
@@ -239,15 +236,6 @@ macro_rules! define_connection {
    };
 }

-pub fn write_and_log<F>(cx: &mut MutableAppContext, db_write: impl FnOnce() -> F + Send + 'static)
-where
-    F: Future<Output = anyhow::Result<()>> + Send,
-{
-    cx.background()
-        .spawn(async move { db_write().await.log_err() })
-        .detach()
-}
-
 #[cfg(test)]
 mod tests {
    use std::{fs, thread};
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -21,7 +21,6 @@ use language::{
 use project::{DiagnosticSummary, Project, ProjectPath};
 use serde_json::json;
 use settings::Settings;
-use smallvec::SmallVec;
 use std::{
    any::{Any, TypeId},
    cmp::Ordering,
@@ -90,11 +89,14 @@ impl View for ProjectDiagnosticsEditor {
    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
        if self.path_states.is_empty() {
            let theme = &cx.global::<Settings>().theme.project_diagnostics;
-            Label::new("No problems in workspace", theme.empty_message.clone())
-                .aligned()
-                .contained()
-                .with_style(theme.container)
-                .boxed()
+            Label::new(
+                "No problems in workspace".to_string(),
+                theme.empty_message.clone(),
+            )
+            .aligned()
+            .contained()
+            .with_style(theme.container)
+            .boxed()
        } else {
            ChildView::new(&self.editor, cx).boxed()
        }
@@ -577,7 +579,7 @@ impl Item for ProjectDiagnosticsEditor {
            .update(cx, |editor, cx| editor.git_diff_recalc(project, cx))
    }

-    fn to_item_events(event: &Self::Event) -> SmallVec<[ItemEvent; 2]> {
+    fn to_item_events(event: &Self::Event) -> Vec<ItemEvent> {
        Editor::to_item_events(event)
    }

@@ -694,7 +696,7 @@ pub(crate) fn render_summary(
    theme: &theme::ProjectDiagnostics,
 ) -> ElementBox {
    if summary.error_count == 0 && summary.warning_count == 0 {
-        Label::new("No problems", text_style.clone()).boxed()
+        Label::new("No problems".to_string(), text_style.clone()).boxed()
    } else {
        let icon_width = theme.tab_icon_width;
        let icon_spacing = theme.tab_icon_spacing;
@@ -805,7 +807,15 @@ mod tests {
            .await;

        let project = Project::test(app_state.fs.clone(), ["/test".as_ref()], cx).await;
-        let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
+        let (_, workspace) = cx.add_window(|cx| {
+            Workspace::new(
+                Default::default(),
+                0,
+                project.clone(),
+                |_, _| unimplemented!(),
+                cx,
+            )
+        });

        // Create some diagnostics
        project.update(cx, |project, cx| {
--- a/crates/diagnostics/src/items.rs
+++ b/crates/diagnostics/src/items.rs
@@ -178,11 +178,14 @@ impl View for DiagnosticIndicator {

        if in_progress {
            element.add_child(
-                Label::new("Checking…", style.diagnostic_message.default.text.clone())
-                    .aligned()
-                    .contained()
-                    .with_margin_left(item_spacing)
-                    .boxed(),
+                Label::new(
+                    "Checking…".into(),
+                    style.diagnostic_message.default.text.clone(),
+                )
+                .aligned()
+                .contained()
+                .with_margin_left(item_spacing)
+                .boxed(),
            );
        } else if let Some(diagnostic) = &self.current_diagnostic {
            let message_style = style.diagnostic_message.clone();
--- a/crates/editor/Cargo.toml
+++ b/crates/editor/Cargo.toml
@@ -17,8 +17,7 @@ test-support = [
    "project/test-support",
    "util/test-support",
    "workspace/test-support",
-    "tree-sitter-rust",
-    "tree-sitter-typescript"
+    "tree-sitter-rust"
 ]

 [dependencies]
@@ -59,7 +58,6 @@ smol = "1.2"
 tree-sitter-rust = { version = "*", optional = true }
 tree-sitter-html = { version = "*", optional = true }
 tree-sitter-javascript = { version = "*", optional = true }
-tree-sitter-typescript = { git = "https://github.com/tree-sitter/tree-sitter-typescript", rev = "5d20856f34315b068c41edaee2ac8a100081d259", optional = true }

 [dev-dependencies]
 text = { path = "../text", features = ["test-support"] }
@@ -77,5 +75,4 @@ unindent = "0.1.7"
 tree-sitter = "0.20"
 tree-sitter-rust = "0.20"
 tree-sitter-html = "0.19"
-tree-sitter-typescript = { git = "https://github.com/tree-sitter/tree-sitter-typescript", rev = "5d20856f34315b068c41edaee2ac8a100081d259" }
 tree-sitter-javascript = "0.20"
--- a/crates/editor/src/display_map.rs
+++ b/crates/editor/src/display_map.rs
@@ -8,7 +8,6 @@ use block_map::{BlockMap, BlockPoint};
 use collections::{HashMap, HashSet};
 use fold_map::FoldMap;
 use gpui::{
-    color::Color,
    fonts::{FontId, HighlightStyle},
    Entity, ModelContext, ModelHandle,
 };
@@ -24,12 +23,6 @@ pub use block_map::{
    BlockDisposition, BlockId, BlockProperties, BlockStyle, RenderBlock, TransformBlock,
 };

-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum FoldStatus {
-    Folded,
-    Foldable,
-}
-
 pub trait ToDisplayPoint {
    fn to_display_point(&self, map: &DisplaySnapshot) -> DisplayPoint;
 }
@@ -219,10 +212,6 @@ impl DisplayMap {
            .update(cx, |map, cx| map.set_font(font_id, font_size, cx))
    }

-    pub fn set_fold_ellipses_color(&mut self, color: Color) -> bool {
-        self.fold_map.set_ellipses_color(color)
-    }
-
    pub fn set_wrap_width(&self, width: Option<f32>, cx: &mut ModelContext<Self>) -> bool {
        self.wrap_map
            .update(cx, |map, cx| map.set_wrap_width(width, cx))
@@ -348,7 +337,7 @@ impl DisplaySnapshot {
            .map(|h| h.text)
    }

-    /// Returns text chunks starting at the end of the given display row in reverse until the start of the file
+    // Returns text chunks starting at the end of the given display row in reverse until the start of the file
    pub fn reverse_text_chunks(&self, display_row: u32) -> impl Iterator<Item = &str> {
        (0..=display_row).into_iter().rev().flat_map(|row| {
            self.blocks_snapshot
@@ -422,67 +411,6 @@ impl DisplaySnapshot {
            })
    }

-    /// Returns an iterator of the start positions of the occurances of `target` in the `self` after `from`
-    /// Stops if `condition` returns false for any of the character position pairs observed.
-    pub fn find_while<'a>(
-        &'a self,
-        from: DisplayPoint,
-        target: &str,
-        condition: impl FnMut(char, DisplayPoint) -> bool + 'a,
-    ) -> impl Iterator<Item = DisplayPoint> + 'a {
-        Self::find_internal(self.chars_at(from), target.chars().collect(), condition)
-    }
-
-    /// Returns an iterator of the end positions of the occurances of `target` in the `self` before `from`
-    /// Stops if `condition` returns false for any of the character position pairs observed.
-    pub fn reverse_find_while<'a>(
-        &'a self,
-        from: DisplayPoint,
-        target: &str,
-        condition: impl FnMut(char, DisplayPoint) -> bool + 'a,
-    ) -> impl Iterator<Item = DisplayPoint> + 'a {
-        Self::find_internal(
-            self.reverse_chars_at(from),
-            target.chars().rev().collect(),
-            condition,
-        )
-    }
-
-    fn find_internal<'a>(
-        iterator: impl Iterator<Item = (char, DisplayPoint)> + 'a,
-        target: Vec<char>,
-        mut condition: impl FnMut(char, DisplayPoint) -> bool + 'a,
-    ) -> impl Iterator<Item = DisplayPoint> + 'a {
-        // List of partial matches with the index of the last seen character in target and the starting point of the match
-        let mut partial_matches: Vec<(usize, DisplayPoint)> = Vec::new();
-        iterator
-            .take_while(move |(ch, point)| condition(*ch, *point))
-            .filter_map(move |(ch, point)| {
-                if Some(&ch) == target.get(0) {
-                    partial_matches.push((0, point));
-                }
-
-                let mut found = None;
-                // Keep partial matches that have the correct next character
-                partial_matches.retain_mut(|(match_position, match_start)| {
-                    if target.get(*match_position) == Some(&ch) {
-                        *match_position += 1;
-                        if *match_position == target.len() {
-                            found = Some(match_start.clone());
-                            // This match is completed. No need to keep tracking it
-                            false
-                        } else {
-                            true
-                        }
-                    } else {
-                        false
-                    }
-                });
-
-                found
-            })
-    }
-
    pub fn column_to_chars(&self, display_row: u32, target: u32) -> u32 {
        let mut count = 0;
        let mut column = 0;
@@ -602,59 +530,6 @@ impl DisplaySnapshot {
        self.blocks_snapshot.longest_row()
    }

-    pub fn fold_for_line(self: &Self, display_row: u32) -> Option<FoldStatus> {
-        if self.is_foldable(display_row) {
-            Some(FoldStatus::Foldable)
-        } else if self.is_line_folded(display_row) {
-            Some(FoldStatus::Folded)
-        } else {
-            None
-        }
-    }
-
-    pub fn is_foldable(self: &Self, row: u32) -> bool {
-        let max_point = self.max_point();
-        if row >= max_point.row() {
-            return false;
-        }
-
-        let (start_indent, is_blank) = self.line_indent(row);
-        if is_blank {
-            return false;
-        }
-
-        for display_row in next_rows(row, self) {
-            let (indent, is_blank) = self.line_indent(display_row);
-            if !is_blank {
-                return indent > start_indent;
-            }
-        }
-
-        return false;
-    }
-
-    pub fn foldable_range(self: &Self, row: u32) -> Option<Range<DisplayPoint>> {
-        let start = DisplayPoint::new(row, self.line_len(row));
-
-        if self.is_foldable(row) && !self.is_line_folded(start.row()) {
-            let (start_indent, _) = self.line_indent(row);
-            let max_point = self.max_point();
-            let mut end = None;
-
-            for row in next_rows(row, self) {
-                let (indent, is_blank) = self.line_indent(row);
-                if !is_blank && indent <= start_indent {
-                    end = Some(DisplayPoint::new(row - 1, self.line_len(row - 1)));
-                    break;
-                }
-            }
-            let end = end.unwrap_or(max_point);
-            Some(start..end)
-        } else {
-            None
-        }
-    }
-
    #[cfg(any(test, feature = "test-support"))]
    pub fn highlight_ranges<Tag: ?Sized + 'static>(
        &self,
@@ -742,24 +617,6 @@ impl ToDisplayPoint for Anchor {
    }
 }

-pub fn next_rows(display_row: u32, display_map: &DisplaySnapshot) -> impl Iterator<Item = u32> {
-    let max_row = display_map.max_point().row();
-    let start_row = display_row + 1;
-    let mut current = None;
-    std::iter::from_fn(move || {
-        if current == None {
-            current = Some(start_row);
-        } else {
-            current = Some(current.unwrap() + 1)
-        }
-        if current.unwrap() > max_row {
-            None
-        } else {
-            current
-        }
-    })
-}
-
 #[cfg(test)]
 pub mod tests {
    use super::*;
@@ -770,7 +627,7 @@ pub mod tests {
    use smol::stream::StreamExt;
    use std::{env, sync::Arc};
    use theme::SyntaxTheme;
-    use util::test::{marked_text_offsets, marked_text_ranges, sample_text};
+    use util::test::{marked_text_ranges, sample_text};
    use Bias::*;

    #[gpui::test(iterations = 100)]
@@ -1249,7 +1106,7 @@ pub mod tests {
            vec![
                ("fn ".to_string(), None),
                ("out".to_string(), Some(Color::blue())),
-                ("⋯".to_string(), None),
+                ("…".to_string(), None),
                ("  fn ".to_string(), Some(Color::red())),
                ("inner".to_string(), Some(Color::blue())),
                ("() {}\n}".to_string(), Some(Color::red())),
@@ -1330,7 +1187,7 @@ pub mod tests {
            cx.update(|cx| syntax_chunks(1..4, &map, &theme, cx)),
            [
                ("out".to_string(), Some(Color::blue())),
-                ("⋯\n".to_string(), None),
+                ("…\n".to_string(), None),
                ("  \nfn ".to_string(), Some(Color::red())),
                ("i\n".to_string(), Some(Color::blue()))
            ]
@@ -1561,32 +1418,6 @@ pub mod tests {
        )
    }

-    #[test]
-    fn test_find_internal() {
-        assert("This is a ˇtest of find internal", "test");
-        assert("Some text ˇaˇaˇaa with repeated characters", "aa");
-
-        fn assert(marked_text: &str, target: &str) {
-            let (text, expected_offsets) = marked_text_offsets(marked_text);
-
-            let chars = text
-                .chars()
-                .enumerate()
-                .map(|(index, ch)| (ch, DisplayPoint::new(0, index as u32)));
-            let target = target.chars();
-
-            assert_eq!(
-                expected_offsets
-                    .into_iter()
-                    .map(|offset| offset as u32)
-                    .collect::<Vec<_>>(),
-                DisplaySnapshot::find_internal(chars, target.collect(), |_, _| true)
-                    .map(|point| point.column())
-                    .collect::<Vec<_>>()
-            )
-        }
-    }
-
    fn syntax_chunks<'a>(
        rows: Range<u32>,
        map: &ModelHandle<DisplayMap>,
--- a/crates/editor/src/display_map/fold_map.rs
+++ b/crates/editor/src/display_map/fold_map.rs
@@ -4,7 +4,7 @@ use crate::{
    ToOffset,
 };
 use collections::BTreeMap;
-use gpui::{color::Color, fonts::HighlightStyle};
+use gpui::fonts::HighlightStyle;
 use language::{Chunk, Edit, Point, TextSummary};
 use parking_lot::Mutex;
 use std::{
@@ -133,7 +133,6 @@ impl<'a> FoldMapWriter<'a> {
            folds: self.0.folds.clone(),
            buffer_snapshot: buffer,
            version: self.0.version.load(SeqCst),
-            ellipses_color: self.0.ellipses_color,
        };
        (snapshot, edits)
    }
@@ -183,7 +182,6 @@ impl<'a> FoldMapWriter<'a> {
            folds: self.0.folds.clone(),
            buffer_snapshot: buffer,
            version: self.0.version.load(SeqCst),
-            ellipses_color: self.0.ellipses_color,
        };
        (snapshot, edits)
    }
@@ -194,7 +192,6 @@ pub struct FoldMap {
    transforms: Mutex<SumTree<Transform>>,
    folds: SumTree<Fold>,
    version: AtomicUsize,
-    ellipses_color: Option<Color>,
 }

 impl FoldMap {
@@ -212,7 +209,6 @@ impl FoldMap {
                },
                &(),
            )),
-            ellipses_color: None,
            version: Default::default(),
        };

@@ -221,7 +217,6 @@ impl FoldMap {
            folds: this.folds.clone(),
            buffer_snapshot: this.buffer.lock().clone(),
            version: this.version.load(SeqCst),
-            ellipses_color: None,
        };
        (this, snapshot)
    }
@@ -238,7 +233,6 @@ impl FoldMap {
            folds: self.folds.clone(),
            buffer_snapshot: self.buffer.lock().clone(),
            version: self.version.load(SeqCst),
-            ellipses_color: self.ellipses_color,
        };
        (snapshot, edits)
    }
@@ -252,15 +246,6 @@ impl FoldMap {
        (FoldMapWriter(self), snapshot, edits)
    }

-    pub fn set_ellipses_color(&mut self, color: Color) -> bool {
-        if self.ellipses_color != Some(color) {
-            self.ellipses_color = Some(color);
-            true
-        } else {
-            false
-        }
-    }
-
    fn check_invariants(&self) {
        if cfg!(test) {
            assert_eq!(
@@ -385,7 +370,7 @@ impl FoldMap {
                    }

                    if fold.end > fold.start {
-                        let output_text = "⋯";
+                        let output_text = "…";
                        new_transforms.push(
                            Transform {
                                summary: TransformSummary {
@@ -492,7 +477,6 @@ pub struct FoldSnapshot {
    folds: SumTree<Fold>,
    buffer_snapshot: MultiBufferSnapshot,
    pub version: usize,
-    pub ellipses_color: Option<Color>,
 }

 impl FoldSnapshot {
@@ -755,7 +739,6 @@ impl FoldSnapshot {
            max_output_offset: range.end.0,
            highlight_endpoints: highlight_endpoints.into_iter().peekable(),
            active_highlights: Default::default(),
-            ellipses_color: self.ellipses_color,
        }
    }

@@ -1046,7 +1029,6 @@ pub struct FoldChunks<'a> {
    max_output_offset: usize,
    highlight_endpoints: Peekable<vec::IntoIter<HighlightEndpoint>>,
    active_highlights: BTreeMap<Option<TypeId>, HighlightStyle>,
-    ellipses_color: Option<Color>,
 }

 impl<'a> Iterator for FoldChunks<'a> {
@@ -1076,10 +1058,7 @@ impl<'a> Iterator for FoldChunks<'a> {
            return Some(Chunk {
                text: output_text,
                syntax_highlight_id: None,
-                highlight_style: self.ellipses_color.map(|color| HighlightStyle {
-                    color: Some(color),
-                    ..Default::default()
-                }),
+                highlight_style: None,
                diagnostic_severity: None,
                is_unnecessary: false,
            });
@@ -1235,7 +1214,7 @@ mod tests {
            Point::new(0, 2)..Point::new(2, 2),
            Point::new(2, 4)..Point::new(4, 1),
        ]);
-        assert_eq!(snapshot2.text(), "aa⋯cc⋯eeeee");
+        assert_eq!(snapshot2.text(), "aa…cc…eeeee");
        assert_eq!(
            edits,
            &[
@@ -1262,7 +1241,7 @@ mod tests {
            buffer.snapshot(cx)
        });
        let (snapshot3, edits) = map.read(buffer_snapshot, subscription.consume().into_inner());
-        assert_eq!(snapshot3.text(), "123a⋯c123c⋯eeeee");
+        assert_eq!(snapshot3.text(), "123a…c123c…eeeee");
        assert_eq!(
            edits,
            &[
@@ -1282,12 +1261,12 @@ mod tests {
            buffer.snapshot(cx)
        });
        let (snapshot4, _) = map.read(buffer_snapshot.clone(), subscription.consume().into_inner());
-        assert_eq!(snapshot4.text(), "123a⋯c123456eee");
+        assert_eq!(snapshot4.text(), "123a…c123456eee");

        let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
        writer.unfold(Some(Point::new(0, 4)..Point::new(0, 4)), false);
        let (snapshot5, _) = map.read(buffer_snapshot.clone(), vec![]);
-        assert_eq!(snapshot5.text(), "123a⋯c123456eee");
+        assert_eq!(snapshot5.text(), "123a…c123456eee");

        let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
        writer.unfold(Some(Point::new(0, 4)..Point::new(0, 4)), true);
@@ -1308,19 +1287,19 @@ mod tests {
            let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
            writer.fold(vec![5..8]);
            let (snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
-            assert_eq!(snapshot.text(), "abcde⋯ijkl");
+            assert_eq!(snapshot.text(), "abcde…ijkl");

            // Create an fold adjacent to the start of the first fold.
            let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
            writer.fold(vec![0..1, 2..5]);
            let (snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
-            assert_eq!(snapshot.text(), "⋯b⋯ijkl");
+            assert_eq!(snapshot.text(), "…b…ijkl");

            // Create an fold adjacent to the end of the first fold.
            let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
            writer.fold(vec![11..11, 8..10]);
            let (snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
-            assert_eq!(snapshot.text(), "⋯b⋯kl");
+            assert_eq!(snapshot.text(), "…b…kl");
        }

        {
@@ -1330,7 +1309,7 @@ mod tests {
            let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
            writer.fold(vec![0..2, 2..5]);
            let (snapshot, _) = map.read(buffer_snapshot, vec![]);
-            assert_eq!(snapshot.text(), "⋯fghijkl");
+            assert_eq!(snapshot.text(), "…fghijkl");

            // Edit within one of the folds.
            let buffer_snapshot = buffer.update(cx, |buffer, cx| {
@@ -1338,7 +1317,7 @@ mod tests {
                buffer.snapshot(cx)
            });
            let (snapshot, _) = map.read(buffer_snapshot, subscription.consume().into_inner());
-            assert_eq!(snapshot.text(), "12345⋯fghijkl");
+            assert_eq!(snapshot.text(), "12345…fghijkl");
        }
    }

@@ -1355,7 +1334,7 @@ mod tests {
            Point::new(3, 1)..Point::new(4, 1),
        ]);
        let (snapshot, _) = map.read(buffer_snapshot, vec![]);
-        assert_eq!(snapshot.text(), "aa⋯eeeee");
+        assert_eq!(snapshot.text(), "aa…eeeee");
    }

    #[gpui::test]
@@ -1372,14 +1351,14 @@ mod tests {
            Point::new(3, 1)..Point::new(4, 1),
        ]);
        let (snapshot, _) = map.read(buffer_snapshot, vec![]);
-        assert_eq!(snapshot.text(), "aa⋯cccc\nd⋯eeeee");
+        assert_eq!(snapshot.text(), "aa…cccc\nd…eeeee");

        let buffer_snapshot = buffer.update(cx, |buffer, cx| {
            buffer.edit([(Point::new(2, 2)..Point::new(3, 1), "")], None, cx);
            buffer.snapshot(cx)
        });
        let (snapshot, _) = map.read(buffer_snapshot, subscription.consume().into_inner());
-        assert_eq!(snapshot.text(), "aa⋯eeeee");
+        assert_eq!(snapshot.text(), "aa…eeeee");
    }

    #[gpui::test]
@@ -1471,7 +1450,7 @@ mod tests {

            let mut expected_text: String = buffer_snapshot.text().to_string();
            for fold_range in map.merged_fold_ranges().into_iter().rev() {
-                expected_text.replace_range(fold_range.start..fold_range.end, "⋯");
+                expected_text.replace_range(fold_range.start..fold_range.end, "…");
            }

            assert_eq!(snapshot.text(), expected_text);
@@ -1676,7 +1655,7 @@ mod tests {
        ]);

        let (snapshot, _) = map.read(buffer_snapshot, vec![]);
-        assert_eq!(snapshot.text(), "aa⋯cccc\nd⋯eeeee\nffffff\n");
+        assert_eq!(snapshot.text(), "aa…cccc\nd…eeeee\nffffff\n");
        assert_eq!(
            snapshot.buffer_rows(0).collect::<Vec<_>>(),
            [Some(0), Some(3), Some(5), Some(6)]
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -1,7 +1,6 @@
 mod blink_manager;
 pub mod display_map;
 mod element;
-
 mod git;
 mod highlight_matching_bracket;
 mod hover_popover;
@@ -78,14 +77,14 @@ use std::{
    cmp::{self, Ordering, Reverse},
    mem,
    num::NonZeroU32,
-    ops::{Deref, DerefMut, Range},
+    ops::{Deref, DerefMut, Range, RangeInclusive},
    path::Path,
    sync::Arc,
    time::{Duration, Instant},
 };
 pub use sum_tree::Bias;
 use theme::{DiagnosticStyle, Theme};
-use util::{post_inc, RangeExt, ResultExt, TryFutureExt};
+use util::{post_inc, ResultExt, TryFutureExt};
 use workspace::{ItemNavHistory, ViewId, Workspace, WorkspaceId};

 use crate::git::diff_hunk_to_display;
@@ -155,27 +154,6 @@ pub struct ConfirmCodeAction {
    pub item_ix: Option<usize>,
 }

-#[derive(Clone, Default, Deserialize, PartialEq)]
-pub struct ToggleComments {
-    #[serde(default)]
-    pub advance_downwards: bool,
-}
-
-#[derive(Clone, Default, Deserialize, PartialEq)]
-pub struct FoldAt {
-    pub display_row: u32,
-}
-
-#[derive(Clone, Default, Deserialize, PartialEq)]
-pub struct UnfoldAt {
-    pub display_row: u32,
-}
-
-#[derive(Clone, Default, Deserialize, PartialEq)]
-pub struct GutterHover {
-    pub hovered: bool,
-}
-
 actions!(
    editor,
    [
@@ -238,6 +216,7 @@ actions!(
        AddSelectionBelow,
        Tab,
        TabPrev,
+        ToggleComments,
        ShowCharacterPalette,
        SelectLargerSyntaxNode,
        SelectSmallerSyntaxNode,
@@ -257,8 +236,6 @@ actions!(
        RestartLanguageServer,
        Hover,
        Format,
-        ToggleSoftWrap,
-        RevealInFinder
    ]
 );

@@ -273,10 +250,6 @@ impl_actions!(
        MovePageDown,
        ConfirmCompletion,
        ConfirmCodeAction,
-        ToggleComments,
-        FoldAt,
-        UnfoldAt,
-        GutterHover
    ]
 );

@@ -367,17 +340,12 @@ pub fn init(cx: &mut MutableAppContext) {
    cx.add_action(Editor::go_to_definition);
    cx.add_action(Editor::go_to_type_definition);
    cx.add_action(Editor::fold);
-    cx.add_action(Editor::fold_at);
    cx.add_action(Editor::unfold_lines);
-    cx.add_action(Editor::unfold_at);
-    cx.add_action(Editor::gutter_hover);
    cx.add_action(Editor::fold_selected_ranges);
    cx.add_action(Editor::show_completions);
    cx.add_action(Editor::toggle_code_actions);
    cx.add_action(Editor::open_excerpts);
    cx.add_action(Editor::jump);
-    cx.add_action(Editor::toggle_soft_wrap);
-    cx.add_action(Editor::reveal_in_finder);
    cx.add_async_action(Editor::format);
    cx.add_action(Editor::restart_language_server);
    cx.add_action(Editor::show_character_palette);
@@ -432,7 +400,7 @@ pub enum SelectMode {
    All,
 }

-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub enum EditorMode {
    SingleLine,
    AutoHeight { max_lines: usize },
@@ -502,7 +470,6 @@ pub struct Editor {
    leader_replica_id: Option<u16>,
    remote_id: Option<ViewId>,
    hover_state: HoverState,
-    gutter_hovered: bool,
    link_go_to_definition_state: LinkGoToDefinitionState,
    _subscriptions: Vec<Subscription>,
 }
@@ -843,7 +810,7 @@ impl CompletionsMenu {
            fuzzy::match_strings(
                &self.match_candidates,
                query,
-                query.chars().any(|c| c.is_uppercase()),
+                false,
                100,
                &Default::default(),
                executor,
@@ -1174,7 +1141,6 @@ impl Editor {
            remote_id: None,
            hover_state: Default::default(),
            link_go_to_definition_state: Default::default(),
-            gutter_hovered: false,
            _subscriptions: vec![
                cx.observe(&buffer, Self::on_buffer_changed),
                cx.subscribe(&buffer, Self::on_buffer_event),
@@ -1254,15 +1220,6 @@ impl Editor {
        self.buffer.read(cx).language_at(point, cx)
    }

-    pub fn active_excerpt(
-        &self,
-        cx: &AppContext,
-    ) -> Option<(ExcerptId, ModelHandle<Buffer>, Range<text::Anchor>)> {
-        self.buffer
-            .read(cx)
-            .excerpt_containing(self.selections.newest_anchor().head(), cx)
-    }
-
    fn style(&self, cx: &AppContext) -> EditorStyle {
        build_style(
            cx.global::<Settings>(),
@@ -1775,13 +1732,11 @@ impl Editor {
    }

    pub fn handle_input(&mut self, text: &str, cx: &mut ViewContext<Self>) {
-        let text: Arc<str> = text.into();
-
        if !self.input_enabled {
-            cx.emit(Event::InputIgnored { text });
            return;
        }

+        let text: Arc<str> = text.into();
        let selections = self.selections.all_adjusted(cx);
        let mut edits = Vec::new();
        let mut new_selections = Vec::with_capacity(selections.len());
@@ -1796,8 +1751,8 @@ impl Editor {
                // bracket of any of this language's bracket pairs.
                let mut bracket_pair = None;
                let mut is_bracket_pair_start = false;
-                for (pair, enabled) in language.brackets() {
-                    if enabled && pair.close && pair.start.ends_with(text.as_ref()) {
+                for pair in language.brackets() {
+                    if pair.close && pair.start.ends_with(text.as_ref()) {
                        bracket_pair = Some(pair.clone());
                        is_bracket_pair_start = true;
                        break;
@@ -1859,9 +1814,9 @@ impl Editor {
                            }
                        }
                    }
-                    // If an opening bracket is 1 character long and is typed while
-                    // text is selected, then surround that text with the bracket pair.
-                    else if is_bracket_pair_start && bracket_pair.start.chars().count() == 1 {
+                    // If an opening bracket is typed while text is selected, then
+                    // surround that text with the bracket pair.
+                    else if is_bracket_pair_start {
                        edits.push((selection.start..selection.start, text.clone()));
                        edits.push((
                            selection.end..selection.end,
@@ -1965,12 +1920,11 @@ impl Editor {
                                .map(|c| c.len_utf8())
                                .sum::<usize>();

-                            insert_extra_newline = language.brackets().any(|(pair, enabled)| {
+                            insert_extra_newline = language.brackets().iter().any(|pair| {
                                let pair_start = pair.start.trim_end();
                                let pair_end = pair.end.trim_start();

-                                enabled
-                                    && pair.newline
+                                pair.newline
                                    && buffer
                                        .contains_str_at(end + trailing_whitespace_len, pair_end)
                                    && buffer.contains_str_at(
@@ -2678,15 +2632,14 @@ impl Editor {
    pub fn render_code_actions_indicator(
        &self,
        style: &EditorStyle,
-        active: bool,
        cx: &mut RenderContext<Self>,
    ) -> Option<ElementBox> {
        if self.available_code_actions.is_some() {
-            enum CodeActions {}
+            enum Tag {}
            Some(
-                MouseEventHandler::<CodeActions>::new(0, cx, |state, _| {
+                MouseEventHandler::<Tag>::new(0, cx, |_, _| {
                    Svg::new("icons/bolt_8.svg")
-                        .with_color(style.code_actions.indicator.style_for(state, active).color)
+                        .with_color(style.code_actions.indicator)
                        .boxed()
                })
                .with_cursor_style(CursorStyle::PointingHand)
@@ -2703,80 +2656,6 @@ impl Editor {
        }
    }

-    pub fn render_fold_indicators(
-        &self,
-        fold_data: Option<Vec<(u32, FoldStatus)>>,
-        active_rows: &BTreeMap<u32, bool>,
-        style: &EditorStyle,
-        gutter_hovered: bool,
-        line_height: f32,
-        gutter_margin: f32,
-        cx: &mut RenderContext<Self>,
-    ) -> Option<Vec<(u32, ElementBox)>> {
-        enum FoldIndicators {}
-
-        let style = style.folds.clone();
-
-        fold_data.map(|fold_data| {
-            fold_data
-                .iter()
-                .copied()
-                .filter_map(|(fold_location, fold_status)| {
-                    (gutter_hovered
-                        || fold_status == FoldStatus::Folded
-                        || !*active_rows.get(&fold_location).unwrap_or(&true))
-                    .then(|| {
-                        (
-                            fold_location,
-                            MouseEventHandler::<FoldIndicators>::new(
-                                fold_location as usize,
-                                cx,
-                                |mouse_state, _| -> ElementBox {
-                                    Svg::new(match fold_status {
-                                        FoldStatus::Folded => style.folded_icon.clone(),
-                                        FoldStatus::Foldable => style.foldable_icon.clone(),
-                                    })
-                                    .with_color(
-                                        style
-                                            .indicator
-                                            .style_for(
-                                                mouse_state,
-                                                fold_status == FoldStatus::Folded,
-                                            )
-                                            .color,
-                                    )
-                                    .constrained()
-                                    .with_width(gutter_margin * style.icon_margin_scale)
-                                    .aligned()
-                                    .constrained()
-                                    .with_height(line_height)
-                                    .with_width(gutter_margin)
-                                    .aligned()
-                                    .boxed()
-                                },
-                            )
-                            .with_cursor_style(CursorStyle::PointingHand)
-                            .with_padding(Padding::uniform(3.))
-                            .on_click(MouseButton::Left, {
-                                move |_, cx| {
-                                    cx.dispatch_any_action(match fold_status {
-                                        FoldStatus::Folded => Box::new(UnfoldAt {
-                                            display_row: fold_location,
-                                        }),
-                                        FoldStatus::Foldable => Box::new(FoldAt {
-                                            display_row: fold_location,
-                                        }),
-                                    });
-                                }
-                            })
-                            .boxed(),
-                        )
-                    })
-                })
-                .collect()
-        })
-    }
-
    pub fn context_menu_visible(&self) -> bool {
        self.context_menu
            .as_ref()
@@ -3359,12 +3238,26 @@ impl Editor {

        while let Some(selection) = selections.next() {
            // Find all the selections that span a contiguous row range
-            let (start_row, end_row) = consume_contiguous_rows(
-                &mut contiguous_row_selections,
-                selection,
-                &display_map,
-                &mut selections,
-            );
+            contiguous_row_selections.push(selection.clone());
+            let start_row = selection.start.row;
+            let mut end_row = if selection.end.column > 0 || selection.is_empty() {
+                display_map.next_line_boundary(selection.end).0.row + 1
+            } else {
+                selection.end.row
+            };
+
+            while let Some(next_selection) = selections.peek() {
+                if next_selection.start.row <= end_row {
+                    end_row = if next_selection.end.column > 0 || next_selection.is_empty() {
+                        display_map.next_line_boundary(next_selection.end).0.row + 1
+                    } else {
+                        next_selection.end.row
+                    };
+                    contiguous_row_selections.push(selections.next().unwrap().clone());
+                } else {
+                    break;
+                }
+            }

            // Move the text spanned by the row range to be before the line preceding the row range
            if start_row > 0 {
@@ -3429,13 +3322,13 @@ impl Editor {
        }

        self.transact(cx, |this, cx| {
-            this.unfold_ranges(unfold_ranges, true, true, cx);
+            this.unfold_ranges(unfold_ranges, true, cx);
            this.buffer.update(cx, |buffer, cx| {
                for (range, text) in edits {
                    buffer.edit([(range, text)], None, cx);
                }
            });
-            this.fold_ranges(refold_ranges, true, cx);
+            this.fold_ranges(refold_ranges, cx);
            this.change_selections(Some(Autoscroll::fit()), cx, |s| {
                s.select(new_selections);
            })
@@ -3457,12 +3350,26 @@ impl Editor {

        while let Some(selection) = selections.next() {
            // Find all the selections that span a contiguous row range
-            let (start_row, end_row) = consume_contiguous_rows(
-                &mut contiguous_row_selections,
-                selection,
-                &display_map,
-                &mut selections,
-            );
+            contiguous_row_selections.push(selection.clone());
+            let start_row = selection.start.row;
+            let mut end_row = if selection.end.column > 0 || selection.is_empty() {
+                display_map.next_line_boundary(selection.end).0.row + 1
+            } else {
+                selection.end.row
+            };
+
+            while let Some(next_selection) = selections.peek() {
+                if next_selection.start.row <= end_row {
+                    end_row = if next_selection.end.column > 0 || next_selection.is_empty() {
+                        display_map.next_line_boundary(next_selection.end).0.row + 1
+                    } else {
+                        next_selection.end.row
+                    };
+                    contiguous_row_selections.push(selections.next().unwrap().clone());
+                } else {
+                    break;
+                }
+            }

            // Move the text spanned by the row range to be after the last line of the row range
            if end_row <= buffer.max_point().row {
@@ -3520,13 +3427,13 @@ impl Editor {
        }

        self.transact(cx, |this, cx| {
-            this.unfold_ranges(unfold_ranges, true, true, cx);
+            this.unfold_ranges(unfold_ranges, true, cx);
            this.buffer.update(cx, |buffer, cx| {
                for (range, text) in edits {
                    buffer.edit([(range, text)], None, cx);
                }
            });
-            this.fold_ranges(refold_ranges, true, cx);
+            this.fold_ranges(refold_ranges, cx);
            this.change_selections(Some(Autoscroll::fit()), cx, |s| s.select(new_selections));
        });
    }
@@ -3893,7 +3800,7 @@ impl Editor {
            }
        }

-        if self.mode == EditorMode::SingleLine {
+        if matches!(self.mode, EditorMode::SingleLine) {
            cx.propagate_action();
            return;
        }
@@ -4354,7 +4261,7 @@ impl Editor {
                to_unfold.push(selection.start..selection.end);
            }
        }
-        self.unfold_ranges(to_unfold, true, true, cx);
+        self.unfold_ranges(to_unfold, true, cx);
        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
            s.select_ranges(new_selection_ranges);
        });
@@ -4503,7 +4410,7 @@ impl Editor {
                }

                if let Some(next_selected_range) = next_selected_range {
-                    self.unfold_ranges([next_selected_range.clone()], false, true, cx);
+                    self.unfold_ranges([next_selected_range.clone()], false, cx);
                    self.change_selections(Some(Autoscroll::newest()), cx, |s| {
                        if action.replace_newest {
                            s.delete(s.newest_anchor().id);
@@ -4536,7 +4443,7 @@ impl Editor {
                    wordwise: true,
                    done: false,
                };
-                self.unfold_ranges([selection.start..selection.end], false, true, cx);
+                self.unfold_ranges([selection.start..selection.end], false, cx);
                self.change_selections(Some(Autoscroll::newest()), cx, |s| {
                    s.select(selections);
                });
@@ -4555,7 +4462,7 @@ impl Editor {
        }
    }

-    pub fn toggle_comments(&mut self, action: &ToggleComments, cx: &mut ViewContext<Self>) {
+    pub fn toggle_comments(&mut self, _: &ToggleComments, cx: &mut ViewContext<Self>) {
        self.transact(cx, |this, cx| {
            let mut selections = this.selections.all::<Point>(cx);
            let mut edits = Vec::new();
@@ -4774,34 +4681,6 @@ impl Editor {

            drop(snapshot);
            this.change_selections(Some(Autoscroll::fit()), cx, |s| s.select(selections));
-
-            let selections = this.selections.all::<Point>(cx);
-            let selections_on_single_row = selections.windows(2).all(|selections| {
-                selections[0].start.row == selections[1].start.row
-                    && selections[0].end.row == selections[1].end.row
-                    && selections[0].start.row == selections[0].end.row
-            });
-            let selections_selecting = selections
-                .iter()
-                .any(|selection| selection.start != selection.end);
-            let advance_downwards = action.advance_downwards
-                && selections_on_single_row
-                && !selections_selecting
-                && this.mode != EditorMode::SingleLine;
-
-            if advance_downwards {
-                let snapshot = this.buffer.read(cx).snapshot(cx);
-
-                this.change_selections(Some(Autoscroll::fit()), cx, |s| {
-                    s.move_cursors_with(|display_snapshot, display_point, _| {
-                        let mut point = display_point.to_point(display_snapshot);
-                        point.row += 1;
-                        point = snapshot.clip_point(point, Bias::Left);
-                        let display_point = point.to_display_point(display_snapshot);
-                        (display_point, SelectionGoal::Column(display_point.column()))
-                    })
-                });
-            }
        });
    }

@@ -4871,54 +4750,27 @@ impl Editor {
        _: &MoveToEnclosingBracket,
        cx: &mut ViewContext<Self>,
    ) {
-        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
-            s.move_offsets_with(|snapshot, selection| {
-                let Some(enclosing_bracket_ranges) = snapshot.enclosing_bracket_ranges(selection.start..selection.end) else {
-                    return;
+        let buffer = self.buffer.read(cx).snapshot(cx);
+        let mut selections = self.selections.all::<usize>(cx);
+        for selection in &mut selections {
+            if let Some((open_range, close_range)) =
+                buffer.enclosing_bracket_ranges(selection.start..selection.end)
+            {
+                let close_range = close_range.to_inclusive();
+                let destination = if close_range.contains(&selection.start)
+                    && close_range.contains(&selection.end)
+                {
+                    open_range.end
+                } else {
+                    *close_range.start()
                };
+                selection.start = destination;
+                selection.end = destination;
+            }
+        }

-                let mut best_length = usize::MAX;
-                let mut best_inside = false;
-                let mut best_in_bracket_range = false;
-                let mut best_destination = None;
-                for (open, close) in enclosing_bracket_ranges {
-                    let close = close.to_inclusive();
-                    let length = close.end() - open.start;
-                    let inside = selection.start >= open.end && selection.end <= *close.start();
-                    let in_bracket_range = open.to_inclusive().contains(&selection.head()) || close.contains(&selection.head());
-
-                    // If best is next to a bracket and current isn't, skip
-                    if !in_bracket_range && best_in_bracket_range {
-                        continue;
-                    }
-
-                    // Prefer smaller lengths unless best is inside and current isn't
-                    if length > best_length && (best_inside || !inside) {
-                        continue;
-                    }
-
-                    best_length = length;
-                    best_inside = inside;
-                    best_in_bracket_range = in_bracket_range;
-                    best_destination = Some(if close.contains(&selection.start) && close.contains(&selection.end) {
-                        if inside {
-                            open.end
-                        } else {
-                            open.start
-                        }
-                    } else {
-                        if inside {
-                            *close.start()
-                        } else {
-                            *close.end()
-                        }
-                    });
-                }
-
-                if let Some(destination) = best_destination {
-                    selection.collapse_to(destination, SelectionGoal::None);
-                }
-            })
+        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            s.select(selections);
        });
    }

@@ -5151,7 +5003,7 @@ impl Editor {
            GotoDefinitionKind::Type => project.type_definition(&buffer, head, cx),
        });

-        cx.spawn_labeled("Fetching Definition...", |workspace, mut cx| async move {
+        cx.spawn(|workspace, mut cx| async move {
            let definitions = definitions.await?;
            workspace.update(&mut cx, |workspace, cx| {
                Editor::navigate_to_definitions(workspace, editor_handle, definitions, cx);
@@ -5231,36 +5083,31 @@ impl Editor {

        let project = workspace.project().clone();
        let references = project.update(cx, |project, cx| project.references(&buffer, head, cx));
-        Some(cx.spawn_labeled(
-            "Finding All References...",
-            |workspace, mut cx| async move {
-                let locations = references.await?;
-                if locations.is_empty() {
-                    return Ok(());
-                }
+        Some(cx.spawn(|workspace, mut cx| async move {
+            let locations = references.await?;
+            if locations.is_empty() {
+                return Ok(());
+            }

-                workspace.update(&mut cx, |workspace, cx| {
-                    let title = locations
-                        .first()
-                        .as_ref()
-                        .map(|location| {
-                            let buffer = location.buffer.read(cx);
-                            format!(
-                                "References to `{}`",
-                                buffer
-                                    .text_for_range(location.range.clone())
-                                    .collect::<String>()
-                            )
-                        })
-                        .unwrap();
-                    Self::open_locations_in_multibuffer(
-                        workspace, locations, replica_id, title, cx,
-                    );
-                });
+            workspace.update(&mut cx, |workspace, cx| {
+                let title = locations
+                    .first()
+                    .as_ref()
+                    .map(|location| {
+                        let buffer = location.buffer.read(cx);
+                        format!(
+                            "References to `{}`",
+                            buffer
+                                .text_for_range(location.range.clone())
+                                .collect::<String>()
+                        )
+                    })
+                    .unwrap();
+                Self::open_locations_in_multibuffer(workspace, locations, replica_id, title, cx);
+            });

-                Ok(())
-            },
-        ))
+            Ok(())
+        }))
    }

    /// Opens a multibuffer with the given project locations in it
@@ -5539,20 +5386,21 @@ impl Editor {
            None => return None,
        };

-        Some(self.perform_format(project, FormatTrigger::Manual, cx))
+        Some(self.perform_format(project, cx))
    }

    fn perform_format(
        &mut self,
        project: ModelHandle<Project>,
-        trigger: FormatTrigger,
        cx: &mut ViewContext<'_, Self>,
    ) -> Task<Result<()>> {
        let buffer = self.buffer().clone();
        let buffers = buffer.read(cx).all_buffers();

        let mut timeout = cx.background().timer(FORMAT_TIMEOUT).fuse();
-        let format = project.update(cx, |project, cx| project.format(buffers, true, trigger, cx));
+        let format = project.update(cx, |project, cx| {
+            project.format(buffers, true, FormatTrigger::Manual, cx)
+        });

        cx.spawn(|_, mut cx| async move {
            let transaction = futures::select_biased! {
@@ -5756,18 +5604,14 @@ impl Editor {
        let mut fold_ranges = Vec::new();

        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
-
        let selections = self.selections.all::<Point>(cx);
        for selection in selections {
            let range = selection.display_range(&display_map).sorted();
            let buffer_start_row = range.start.to_point(&display_map).row;

            for row in (0..=range.end.row()).rev() {
-                let fold_range = display_map.foldable_range(row).map(|range| {
-                    range.start.to_point(&display_map)..range.end.to_point(&display_map)
-                });
-
-                if let Some(fold_range) = fold_range {
+                if self.is_line_foldable(&display_map, row) && !display_map.is_line_folded(row) {
+                    let fold_range = self.foldable_range_for_line(&display_map, row);
                    if fold_range.end.row >= buffer_start_row {
                        fold_ranges.push(fold_range);
                        if row <= range.start.row() {
@@ -5778,26 +5622,7 @@ impl Editor {
            }
        }

-        self.fold_ranges(fold_ranges, true, cx);
-    }
-
-    pub fn fold_at(&mut self, fold_at: &FoldAt, cx: &mut ViewContext<Self>) {
-        let display_row = fold_at.display_row;
-
-        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
-
-        if let Some(fold_range) = display_map.foldable_range(display_row) {
-            let autoscroll = self
-                .selections
-                .all::<Point>(cx)
-                .iter()
-                .any(|selection| fold_range.overlaps(&selection.display_range(&display_map)));
-
-            let fold_range =
-                fold_range.start.to_point(&display_map)..fold_range.end.to_point(&display_map);
-
-            self.fold_ranges(std::iter::once(fold_range), autoscroll, cx);
-        }
+        self.fold_ranges(fold_ranges, cx);
    }

    pub fn unfold_lines(&mut self, _: &UnfoldLines, cx: &mut ViewContext<Self>) {
@@ -5815,86 +5640,85 @@ impl Editor {
                start..end
            })
            .collect::<Vec<_>>();
-
-        self.unfold_ranges(ranges, true, true, cx);
+        self.unfold_ranges(ranges, true, cx);
    }

-    pub fn unfold_at(&mut self, unfold_at: &UnfoldAt, cx: &mut ViewContext<Self>) {
-        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
+    fn is_line_foldable(&self, display_map: &DisplaySnapshot, display_row: u32) -> bool {
+        let max_point = display_map.max_point();
+        if display_row >= max_point.row() {
+            false
+        } else {
+            let (start_indent, is_blank) = display_map.line_indent(display_row);
+            if is_blank {
+                false
+            } else {
+                for display_row in display_row + 1..=max_point.row() {
+                    let (indent, is_blank) = display_map.line_indent(display_row);
+                    if !is_blank {
+                        return indent > start_indent;
+                    }
+                }
+                false
+            }
+        }
+    }

-        let intersection_range = DisplayPoint::new(unfold_at.display_row, 0)
-            ..DisplayPoint::new(
-                unfold_at.display_row,
-                display_map.line_len(unfold_at.display_row),
-            );
+    fn foldable_range_for_line(
+        &self,
+        display_map: &DisplaySnapshot,
+        start_row: u32,
+    ) -> Range<Point> {
+        let max_point = display_map.max_point();

-        let autoscroll =
-            self.selections.all::<Point>(cx).iter().any(|selection| {
-                intersection_range.overlaps(&selection.display_range(&display_map))
-            });
+        let (start_indent, _) = display_map.line_indent(start_row);
+        let start = DisplayPoint::new(start_row, display_map.line_len(start_row));
+        let mut end = None;
+        for row in start_row + 1..=max_point.row() {
+            let (indent, is_blank) = display_map.line_indent(row);
+            if !is_blank && indent <= start_indent {
+                end = Some(DisplayPoint::new(row - 1, display_map.line_len(row - 1)));
+                break;
+            }
+        }

-        let display_point = DisplayPoint::new(unfold_at.display_row, 0).to_point(&display_map);
-
-        let mut point_range = display_point..display_point;
-
-        point_range.start.column = 0;
-        point_range.end.column = display_map.buffer_snapshot.line_len(point_range.end.row);
-
-        self.unfold_ranges(std::iter::once(point_range), true, autoscroll, cx)
+        let end = end.unwrap_or(max_point);
+        start.to_point(display_map)..end.to_point(display_map)
    }

    pub fn fold_selected_ranges(&mut self, _: &FoldSelectedRanges, cx: &mut ViewContext<Self>) {
        let selections = self.selections.all::<Point>(cx);
        let ranges = selections.into_iter().map(|s| s.start..s.end);
-        self.fold_ranges(ranges, true, cx);
+        self.fold_ranges(ranges, cx);
    }

-    pub fn fold_ranges<T: ToOffset + Clone>(
+    pub fn fold_ranges<T: ToOffset>(
        &mut self,
        ranges: impl IntoIterator<Item = Range<T>>,
-        auto_scroll: bool,
        cx: &mut ViewContext<Self>,
    ) {
        let mut ranges = ranges.into_iter().peekable();
        if ranges.peek().is_some() {
            self.display_map.update(cx, |map, cx| map.fold(ranges, cx));
-
-            if auto_scroll {
-                self.request_autoscroll(Autoscroll::fit(), cx);
-            }
-
+            self.request_autoscroll(Autoscroll::fit(), cx);
            cx.notify();
        }
    }

-    pub fn unfold_ranges<T: ToOffset + Clone>(
+    pub fn unfold_ranges<T: ToOffset>(
        &mut self,
        ranges: impl IntoIterator<Item = Range<T>>,
        inclusive: bool,
-        auto_scroll: bool,
        cx: &mut ViewContext<Self>,
    ) {
        let mut ranges = ranges.into_iter().peekable();
        if ranges.peek().is_some() {
            self.display_map
                .update(cx, |map, cx| map.unfold(ranges, inclusive, cx));
-            if auto_scroll {
-                self.request_autoscroll(Autoscroll::fit(), cx);
-            }
-
+            self.request_autoscroll(Autoscroll::fit(), cx);
            cx.notify();
        }
    }

-    pub fn gutter_hover(
-        &mut self,
-        GutterHover { hovered }: &GutterHover,
-        cx: &mut ViewContext<Self>,
-    ) {
-        self.gutter_hovered = *hovered;
-        cx.notify();
-    }
-
    pub fn insert_blocks(
        &mut self,
        blocks: impl IntoIterator<Item = BlockProperties<Anchor>>,
@@ -5986,27 +5810,6 @@ impl Editor {
            .update(cx, |map, cx| map.set_wrap_width(width, cx))
    }

-    pub fn toggle_soft_wrap(&mut self, _: &ToggleSoftWrap, cx: &mut ViewContext<Self>) {
-        if self.soft_wrap_mode_override.is_some() {
-            self.soft_wrap_mode_override.take();
-        } else {
-            let soft_wrap = match self.soft_wrap_mode(cx) {
-                SoftWrap::None => settings::SoftWrap::EditorWidth,
-                SoftWrap::EditorWidth | SoftWrap::Column(_) => settings::SoftWrap::None,
-            };
-            self.soft_wrap_mode_override = Some(soft_wrap);
-        }
-        cx.notify();
-    }
-
-    pub fn reveal_in_finder(&mut self, _: &RevealInFinder, cx: &mut ViewContext<Self>) {
-        if let Some(buffer) = self.buffer().read(cx).as_singleton() {
-            if let Some(file) = buffer.read(cx).file().and_then(|f| f.as_local()) {
-                cx.reveal_path(&file.abs_path(cx));
-            }
-        }
-    }
-
    pub fn highlight_rows(&mut self, rows: Option<Range<u32>>) {
        self.highlighted_rows = rows;
    }
@@ -6356,35 +6159,6 @@ impl Editor {
    }
 }

-fn consume_contiguous_rows(
-    contiguous_row_selections: &mut Vec<Selection<Point>>,
-    selection: &Selection<Point>,
-    display_map: &DisplaySnapshot,
-    selections: &mut std::iter::Peekable<std::slice::Iter<Selection<Point>>>,
-) -> (u32, u32) {
-    contiguous_row_selections.push(selection.clone());
-    let start_row = selection.start.row;
-    let mut end_row = ending_row(selection, display_map);
-
-    while let Some(next_selection) = selections.peek() {
-        if next_selection.start.row <= end_row {
-            end_row = ending_row(next_selection, display_map);
-            contiguous_row_selections.push(selections.next().unwrap().clone());
-        } else {
-            break;
-        }
-    }
-    (start_row, end_row)
-}
-
-fn ending_row(next_selection: &Selection<Point>, display_map: &DisplaySnapshot) -> u32 {
-    if next_selection.end.column > 0 || next_selection.is_empty() {
-        display_map.next_line_boundary(next_selection.end).0.row + 1
-    } else {
-        next_selection.end.row
-    }
-}
-
 impl EditorSnapshot {
    pub fn language_at<T: ToOffset>(&self, position: T) -> Option<&Arc<Language>> {
        self.display_snapshot.buffer_snapshot.language_at(position)
@@ -6413,9 +6187,6 @@ impl Deref for EditorSnapshot {

 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Event {
-    InputIgnored {
-        text: Arc<str>,
-    },
    ExcerptsAdded {
        buffer: ModelHandle<Buffer>,
        predecessor: ExcerptId,
@@ -6456,7 +6227,6 @@ impl View for Editor {
    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
        let style = self.style(cx);
        let font_changed = self.display_map.update(cx, |map, cx| {
-            map.set_fold_ellipses_color(style.folds.ellipses.text_color);
            map.set_font(style.text.font_id, style.text.font_size, cx)
        });

@@ -6483,10 +6253,8 @@ impl View for Editor {
    }

    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
-        if cx.is_self_focused() {
-            let focused_event = EditorFocused(cx.handle());
-            cx.emit_global(focused_event);
-        }
+        let focused_event = EditorFocused(cx.handle());
+        cx.emit_global(focused_event);
        if let Some(rename) = self.pending_rename.as_ref() {
            cx.focus(&rename.editor);
        } else {
@@ -6566,13 +6334,17 @@ impl View for Editor {
            EditorMode::AutoHeight { .. } => "auto_height",
            EditorMode::Full => "full",
        };
-        context.add_key("mode", mode);
+        context.map.insert("mode".into(), mode.into());
        if self.pending_rename.is_some() {
-            context.add_identifier("renaming");
+            context.set.insert("renaming".into());
        }
        match self.context_menu.as_ref() {
-            Some(ContextMenu::Completions(_)) => context.add_identifier("showing_completions"),
-            Some(ContextMenu::CodeActions(_)) => context.add_identifier("showing_code_actions"),
+            Some(ContextMenu::Completions(_)) => {
+                context.set.insert("showing_completions".into());
+            }
+            Some(ContextMenu::CodeActions(_)) => {
+                context.set.insert("showing_code_actions".into());
+            }
            None => {}
        }

@@ -6621,29 +6393,26 @@ impl View for Editor {
        text: &str,
        cx: &mut ViewContext<Self>,
    ) {
-        self.transact(cx, |this, cx| {
-            if this.input_enabled {
-                let new_selected_ranges = if let Some(range_utf16) = range_utf16 {
-                    let range_utf16 = OffsetUtf16(range_utf16.start)..OffsetUtf16(range_utf16.end);
-                    Some(this.selection_replacement_ranges(range_utf16, cx))
-                } else {
-                    this.marked_text_ranges(cx)
-                };
-
-                if let Some(new_selected_ranges) = new_selected_ranges {
-                    this.change_selections(None, cx, |selections| {
-                        selections.select_ranges(new_selected_ranges)
-                    });
-                }
-            }
-
-            this.handle_input(text, cx);
-        });
-
        if !self.input_enabled {
            return;
        }

+        self.transact(cx, |this, cx| {
+            let new_selected_ranges = if let Some(range_utf16) = range_utf16 {
+                let range_utf16 = OffsetUtf16(range_utf16.start)..OffsetUtf16(range_utf16.end);
+                Some(this.selection_replacement_ranges(range_utf16, cx))
+            } else {
+                this.marked_text_ranges(cx)
+            };
+
+            if let Some(new_selected_ranges) = new_selected_ranges {
+                this.change_selections(None, cx, |selections| {
+                    selections.select_ranges(new_selected_ranges)
+                });
+            }
+            this.handle_input(text, cx);
+        });
+
        if let Some(transaction) = self.ime_transaction {
            self.buffer.update(cx, |buffer, cx| {
                buffer.group_until_transaction(transaction, cx);
@@ -7140,6 +6909,21 @@ pub fn split_words<'a>(text: &'a str) -> impl std::iter::Iterator<Item = &'a str
    .flat_map(|word| word.split_inclusive('_'))
 }

+trait RangeExt<T> {
+    fn sorted(&self) -> Range<T>;
+    fn to_inclusive(&self) -> RangeInclusive<T>;
+}
+
+impl<T: Ord + Clone> RangeExt<T> for Range<T> {
+    fn sorted(&self) -> Self {
+        cmp::min(&self.start, &self.end).clone()..cmp::max(&self.start, &self.end).clone()
+    }
+
+    fn to_inclusive(&self) -> RangeInclusive<T> {
+        self.start.clone()..=self.end.clone()
+    }
+}
+
 trait RangeToAnchorExt {
    fn to_anchors(self, snapshot: &MultiBufferSnapshot) -> Range<Anchor>;
 }
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -4,7 +4,7 @@ use super::{
    ToPoint, MAX_LINE_LEN,
 };
 use crate::{
-    display_map::{BlockStyle, DisplaySnapshot, FoldStatus, TransformBlock},
+    display_map::{BlockStyle, DisplaySnapshot, TransformBlock},
    git::{diff_hunk_to_display, DisplayDiffHunk},
    hover_popover::{
        HideHover, HoverAt, HOVER_POPOVER_GAP, MIN_POPOVER_CHARACTER_WIDTH, MIN_POPOVER_LINE_HEIGHT,
@@ -14,7 +14,7 @@ use crate::{
    },
    mouse_context_menu::DeployMouseContextMenu,
    scroll::actions::Scroll,
-    EditorStyle, GutterHover, UnfoldAt,
+    EditorStyle,
 };
 use clock::ReplicaId;
 use collections::{BTreeMap, HashMap};
@@ -48,9 +48,6 @@ use std::{
    ops::{DerefMut, Range},
    sync::Arc,
 };
-use workspace::item::Item;
-
-enum FoldMarkers {}

 struct SelectionLayout {
    head: DisplayPoint,
@@ -215,17 +212,6 @@ impl EditorElement {
                    }
                }),
        );
-
-        enum GutterHandlers {}
-        cx.scene.push_mouse_region(
-            MouseRegion::new::<GutterHandlers>(view.id(), view.id() + 1, gutter_bounds).on_hover(
-                |hover, cx| {
-                    cx.dispatch_action(GutterHover {
-                        hovered: hover.started,
-                    })
-                },
-            ),
-        )
    }

    fn mouse_down(
@@ -414,7 +400,16 @@ impl EditorElement {
    ) -> bool {
        // This will be handled more correctly once https://github.com/zed-industries/zed/issues/1218 is completed
        // Don't trigger hover popover if mouse is hovering over context menu
-        let point = position_to_display_point(position, text_bounds, position_map);
+        let point = if text_bounds.contains_point(position) {
+            let (point, target_point) = position_map.point_for_position(text_bounds, position);
+            if point == target_point {
+                Some(point)
+            } else {
+                None
+            }
+        } else {
+            None
+        };

        cx.dispatch_action(UpdateGoToDefinitionLink {
            point,
@@ -423,7 +418,6 @@ impl EditorElement {
        });

        cx.dispatch_action(HoverAt { point });
-
        true
    }

@@ -575,25 +569,12 @@ impl EditorElement {
        }

        if let Some((row, indicator)) = layout.code_actions_indicator.as_mut() {
-            let mut x = 0.;
+            let mut x = bounds.width() - layout.gutter_padding;
            let mut y = *row as f32 * line_height - scroll_top;
            x += ((layout.gutter_padding + layout.gutter_margin) - indicator.size().x()) / 2.;
            y += (line_height - indicator.size().y()) / 2.;
            indicator.paint(bounds.origin() + vec2f(x, y), visible_bounds, cx);
        }
-
-        layout.fold_indicators.as_mut().map(|fold_indicators| {
-            for (line, fold_indicator) in fold_indicators.iter_mut() {
-                let mut x = bounds.width() - layout.gutter_padding;
-                let mut y = *line as f32 * line_height - scroll_top;
-
-                x += ((layout.gutter_padding + layout.gutter_margin) - fold_indicator.size().x())
-                    / 2.;
-                y += (line_height - fold_indicator.size().y()) / 2.;
-
-                fold_indicator.paint(bounds.origin() + vec2f(x, y), visible_bounds, cx);
-            }
-        });
    }

    fn paint_diff_hunks(bounds: RectF, layout: &mut LayoutState, cx: &mut PaintContext) {
@@ -695,7 +676,6 @@ impl EditorElement {
        let max_glyph_width = layout.position_map.em_width;
        let scroll_left = scroll_position.x() * max_glyph_width;
        let content_origin = bounds.origin() + vec2f(layout.gutter_margin, 0.);
-        let line_end_overshoot = 0.15 * layout.position_map.line_height;

        cx.scene.push_layer(Some(bounds));

@@ -708,54 +688,12 @@ impl EditorElement {
            },
        });

-        let fold_corner_radius =
-            self.style.folds.ellipses.corner_radius_factor * layout.position_map.line_height;
-        for (id, range, color) in layout.fold_ranges.iter() {
-            self.paint_highlighted_range(
-                range.clone(),
-                *color,
-                fold_corner_radius,
-                fold_corner_radius * 2.,
-                layout,
-                content_origin,
-                scroll_top,
-                scroll_left,
-                bounds,
-                cx,
-            );
-
-            for bound in range_to_bounds(
-                &range,
-                content_origin,
-                scroll_left,
-                scroll_top,
-                &layout.visible_display_row_range,
-                line_end_overshoot,
-                &layout.position_map,
-            ) {
-                cx.scene.push_cursor_region(CursorRegion {
-                    bounds: bound,
-                    style: CursorStyle::PointingHand,
-                });
-
-                let display_row = range.start.row();
-                cx.scene.push_mouse_region(
-                    MouseRegion::new::<FoldMarkers>(self.view.id(), *id as usize, bound)
-                        .on_click(MouseButton::Left, move |_, cx| {
-                            cx.dispatch_action(UnfoldAt { display_row })
-                        })
-                        .with_notify_on_hover(true)
-                        .with_notify_on_click(true),
-                )
-            }
-        }
-
        for (range, color) in &layout.highlighted_ranges {
            self.paint_highlighted_range(
                range.clone(),
                *color,
                0.,
-                line_end_overshoot,
+                0.15 * layout.position_map.line_height,
                layout,
                content_origin,
                scroll_top,
@@ -766,10 +704,9 @@ impl EditorElement {
        }

        let mut cursors = SmallVec::<[Cursor; 32]>::new();
-        let corner_radius = 0.15 * layout.position_map.line_height;
-
        for (replica_id, selections) in &layout.selections {
            let selection_style = style.replica_selection_style(*replica_id);
+            let corner_radius = 0.15 * layout.position_map.line_height;

            for selection in selections {
                self.paint_highlighted_range(
@@ -1181,24 +1118,6 @@ impl EditorElement {
            .width()
    }

-    fn get_fold_indicators(
-        &self,
-        is_singleton: bool,
-        display_rows: Range<u32>,
-        snapshot: &EditorSnapshot,
-    ) -> Option<Vec<(u32, FoldStatus)>> {
-        is_singleton.then(|| {
-            display_rows
-                .into_iter()
-                .filter_map(|display_row| {
-                    snapshot
-                        .fold_for_line(display_row)
-                        .map(|fold_status| (display_row, fold_status))
-                })
-                .collect()
-        })
-    }
-
    //Folds contained in a hunk are ignored apart from shrinking visual size
    //If a fold contains any hunks then that fold line is marked as modified
    fn layout_git_gutters(
@@ -1519,7 +1438,7 @@ impl EditorElement {
                    } else {
                        let text_style = self.style.text.clone();
                        Flex::row()
-                            .with_child(Label::new("⋯", text_style).boxed())
+                            .with_child(Label::new("…".to_string(), text_style).boxed())
                            .with_children(jump_icon)
                            .contained()
                            .with_padding_left(gutter_padding)
@@ -1615,14 +1534,15 @@ impl Element for EditorElement {
        let snapshot = self.update_view(cx.app, |view, cx| {
            view.set_visible_line_count(size.y() / line_height);

-            let editor_width = text_width - gutter_margin - overscroll.x() - em_width;
            let wrap_width = match view.soft_wrap_mode(cx) {
-                SoftWrap::None => (MAX_LINE_LEN / 2) as f32 * em_advance,
-                SoftWrap::EditorWidth => editor_width,
-                SoftWrap::Column(column) => editor_width.min(column as f32 * em_advance),
+                SoftWrap::None => Some((MAX_LINE_LEN / 2) as f32 * em_advance),
+                SoftWrap::EditorWidth => {
+                    Some(text_width - gutter_margin - overscroll.x() - em_width)
+                }
+                SoftWrap::Column(column) => Some(column as f32 * em_advance),
            };

-            if view.set_wrap_width(Some(wrap_width), cx) {
+            if view.set_wrap_width(wrap_width, cx) {
                view.snapshot(cx)
            } else {
                snapshot
@@ -1687,13 +1607,9 @@ impl Element for EditorElement {
        let mut active_rows = BTreeMap::new();
        let mut highlighted_rows = None;
        let mut highlighted_ranges = Vec::new();
-        let mut fold_ranges = Vec::new();
        let mut show_scrollbars = false;
        let mut include_root = false;
-        let mut is_singleton = false;
        self.update_view(cx.app, |view, cx| {
-            is_singleton = view.is_singleton(cx);
-
            let display_map = view.display_map.update(cx, |map, cx| map.snapshot(cx));

            highlighted_rows = view.highlighted_rows();
@@ -1701,19 +1617,6 @@ impl Element for EditorElement {
            highlighted_ranges =
                view.background_highlights_in_range(start_anchor..end_anchor, &display_map, theme);

-            fold_ranges.extend(
-                snapshot
-                    .folds_in_range(start_anchor..end_anchor)
-                    .map(|anchor| {
-                        let start = anchor.start.to_point(&snapshot.buffer_snapshot);
-                        (
-                            start.row,
-                            start.to_display_point(&snapshot.display_snapshot)
-                                ..anchor.end.to_display_point(&snapshot),
-                        )
-                    }),
-            );
-
            let mut remote_selections = HashMap::default();
            for (replica_id, line_mode, cursor_shape, selection) in display_map
                .buffer_snapshot
@@ -1782,28 +1685,11 @@ impl Element for EditorElement {
                .unwrap_or_default()
        });

-        let fold_ranges: Vec<(BufferRow, Range<DisplayPoint>, Color)> = fold_ranges
-            .into_iter()
-            .map(|(id, fold)| {
-                let color = self
-                    .style
-                    .folds
-                    .ellipses
-                    .background
-                    .style_for(&mut cx.mouse_state::<FoldMarkers>(id as usize), false)
-                    .color;
-
-                (id, fold, color)
-            })
-            .collect();
-
        let line_number_layouts =
            self.layout_line_numbers(start_row..end_row, &active_rows, &snapshot, cx);

        let display_hunks = self.layout_git_gutters(start_row..end_row, &snapshot);

-        let folds = self.get_fold_indicators(is_singleton, start_row..end_row, &snapshot);
-
        let scrollbar_row_range = scroll_position.y()..(scroll_position.y() + height_in_lines);

        let mut max_visible_line_width = 0.0;
@@ -1870,7 +1756,7 @@ impl Element for EditorElement {
        let mut code_actions_indicator = None;
        let mut hover = None;
        let mut mode = EditorMode::Full;
-        let mut fold_indicators = cx.render(&self.view.upgrade(cx).unwrap(), |view, cx| {
+        cx.render(&self.view.upgrade(cx).unwrap(), |view, cx| {
            let newest_selection_head = view
                .selections
                .newest::<usize>(cx)
@@ -1884,26 +1770,14 @@ impl Element for EditorElement {
                        view.render_context_menu(newest_selection_head, style.clone(), cx);
                }

-                let active = matches!(view.context_menu, Some(crate::ContextMenu::CodeActions(_)));
-
                code_actions_indicator = view
-                    .render_code_actions_indicator(&style, active, cx)
+                    .render_code_actions_indicator(&style, cx)
                    .map(|indicator| (newest_selection_head.row(), indicator));
            }

            let visible_rows = start_row..start_row + line_layouts.len() as u32;
            hover = view.hover_state.render(&snapshot, &style, visible_rows, cx);
            mode = view.mode;
-
-            view.render_fold_indicators(
-                folds,
-                &active_rows,
-                &style,
-                view.gutter_hovered,
-                line_height,
-                gutter_margin,
-                cx,
-            )
        });

        if let Some((_, context_menu)) = context_menu.as_mut() {
@@ -1929,18 +1803,6 @@ impl Element for EditorElement {
            );
        }

-        fold_indicators.as_mut().map(|fold_indicators| {
-            for (_, indicator) in fold_indicators.iter_mut() {
-                indicator.layout(
-                    SizeConstraint::strict_along(
-                        Axis::Vertical,
-                        line_height * style.code_actions.vertical_scale,
-                    ),
-                    cx,
-                );
-            }
-        });
-
        if let Some((_, hover_popovers)) = hover.as_mut() {
            for hover_popover in hover_popovers.iter_mut() {
                hover_popover.layout(
@@ -1984,14 +1846,12 @@ impl Element for EditorElement {
                active_rows,
                highlighted_rows,
                highlighted_ranges,
-                fold_ranges,
                line_number_layouts,
                display_hunks,
                blocks,
                selections,
                context_menu,
                code_actions_indicator,
-                fold_indicators,
                hover_popovers: hover,
            },
        )
@@ -2099,8 +1959,6 @@ impl Element for EditorElement {
    }
 }

-type BufferRow = u32;
-
 pub struct LayoutState {
    position_map: Arc<PositionMap>,
    gutter_size: Vector2F,
@@ -2115,7 +1973,6 @@ pub struct LayoutState {
    display_hunks: Vec<DisplayDiffHunk>,
    blocks: Vec<BlockLayout>,
    highlighted_ranges: Vec<(Range<DisplayPoint>, Color)>,
-    fold_ranges: Vec<(BufferRow, Range<DisplayPoint>, Color)>,
    selections: Vec<(ReplicaId, Vec<SelectionLayout>)>,
    scrollbar_row_range: Range<f32>,
    show_scrollbars: bool,
@@ -2123,7 +1980,6 @@ pub struct LayoutState {
    context_menu: Option<(DisplayPoint, ElementBox)>,
    code_actions_indicator: Option<(u32, ElementBox)>,
    hover_popovers: Option<(DisplayPoint, Vec<ElementBox>)>,
-    fold_indicators: Option<Vec<(u32, ElementBox)>>,
 }

 pub struct PositionMap {
@@ -2422,75 +2278,6 @@ impl HighlightedRange {
    }
 }

-pub fn position_to_display_point(
-    position: Vector2F,
-    text_bounds: RectF,
-    position_map: &PositionMap,
-) -> Option<DisplayPoint> {
-    if text_bounds.contains_point(position) {
-        let (point, target_point) = position_map.point_for_position(text_bounds, position);
-        if point == target_point {
-            Some(point)
-        } else {
-            None
-        }
-    } else {
-        None
-    }
-}
-
-pub fn range_to_bounds(
-    range: &Range<DisplayPoint>,
-    content_origin: Vector2F,
-    scroll_left: f32,
-    scroll_top: f32,
-    visible_row_range: &Range<u32>,
-    line_end_overshoot: f32,
-    position_map: &PositionMap,
-) -> impl Iterator<Item = RectF> {
-    let mut bounds: SmallVec<[RectF; 1]> = SmallVec::new();
-
-    if range.start == range.end {
-        return bounds.into_iter();
-    }
-
-    let start_row = visible_row_range.start;
-    let end_row = visible_row_range.end;
-
-    let row_range = if range.end.column() == 0 {
-        cmp::max(range.start.row(), start_row)..cmp::min(range.end.row(), end_row)
-    } else {
-        cmp::max(range.start.row(), start_row)..cmp::min(range.end.row() + 1, end_row)
-    };
-
-    let first_y =
-        content_origin.y() + row_range.start as f32 * position_map.line_height - scroll_top;
-
-    for (idx, row) in row_range.enumerate() {
-        let line_layout = &position_map.line_layouts[(row - start_row) as usize];
-
-        let start_x = if row == range.start.row() {
-            content_origin.x() + line_layout.x_for_index(range.start.column() as usize)
-                - scroll_left
-        } else {
-            content_origin.x() - scroll_left
-        };
-
-        let end_x = if row == range.end.row() {
-            content_origin.x() + line_layout.x_for_index(range.end.column() as usize) - scroll_left
-        } else {
-            content_origin.x() + line_layout.width() + line_end_overshoot - scroll_left
-        };
-
-        bounds.push(RectF::from_points(
-            vec2f(start_x, first_y + position_map.line_height * idx as f32),
-            vec2f(end_x, first_y + position_map.line_height * (idx + 1) as f32),
-        ))
-    }
-
-    bounds.into_iter()
-}
-
 pub fn scale_vertical_mouse_autoscroll_delta(delta: f32) -> f32 {
    delta.powf(1.5) / 100.0
 }
--- a/crates/editor/src/highlight_matching_bracket.rs
+++ b/crates/editor/src/highlight_matching_bracket.rs
@@ -17,7 +17,7 @@ pub fn refresh_matching_bracket_highlights(editor: &mut Editor, cx: &mut ViewCon
    let snapshot = editor.snapshot(cx);
    if let Some((opening_range, closing_range)) = snapshot
        .buffer_snapshot
-        .innermost_enclosing_bracket_ranges(head..head)
+        .enclosing_bracket_ranges(head..head)
    {
        editor.highlight_background::<MatchingBracketHighlight>(
            vec![
@@ -32,10 +32,11 @@ pub fn refresh_matching_bracket_highlights(editor: &mut Editor, cx: &mut ViewCon

 #[cfg(test)]
 mod tests {
-    use super::*;
    use crate::test::editor_lsp_test_context::EditorLspTestContext;
+
+    use super::*;
    use indoc::indoc;
-    use language::{BracketPair, BracketPairConfig, Language, LanguageConfig};
+    use language::{BracketPair, Language, LanguageConfig};

    #[gpui::test]
    async fn test_matching_bracket_highlights(cx: &mut gpui::TestAppContext) {
@@ -44,23 +45,20 @@ mod tests {
                LanguageConfig {
                    name: "Rust".into(),
                    path_suffixes: vec!["rs".to_string()],
-                    brackets: BracketPairConfig {
-                        pairs: vec![
-                            BracketPair {
-                                start: "{".to_string(),
-                                end: "}".to_string(),
-                                close: false,
-                                newline: true,
-                            },
-                            BracketPair {
-                                start: "(".to_string(),
-                                end: ")".to_string(),
-                                close: false,
-                                newline: true,
-                            },
-                        ],
-                        ..Default::default()
-                    },
+                    brackets: vec![
+                        BracketPair {
+                            start: "{".to_string(),
+                            end: "}".to_string(),
+                            close: false,
+                            newline: true,
+                        },
+                        BracketPair {
+                            start: "(".to_string(),
+                            end: ")".to_string(),
+                            close: false,
+                            newline: true,
+                        },
+                    ],
                    ..Default::default()
                },
                Some(tree_sitter_rust::language()),
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -1,4 +1,3 @@
-use futures::FutureExt;
 use gpui::{
    actions,
    elements::{Flex, MouseEventHandler, Padding, Text},
@@ -328,10 +327,12 @@ impl InfoPopover {
        MouseEventHandler::<InfoPopover>::new(0, cx, |_, cx| {
            let mut flex = Flex::new(Axis::Vertical).scrollable::<HoverBlock, _>(1, None, cx);
            flex.extend(self.contents.iter().map(|content| {
-                let languages = self.project.read(cx).languages();
-                if let Some(language) = content.language.clone().and_then(|language| {
-                    languages.language_for_name(&language).now_or_never()?.ok()
-                }) {
+                let project = self.project.read(cx);
+                if let Some(language) = content
+                    .language
+                    .clone()
+                    .and_then(|language| project.languages().language_for_name(&language))
+                {
                    let runs = language
                        .highlight_text(&content.text.as_str().into(), 0..content.text.len());

--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -2,10 +2,12 @@ use crate::{
    display_map::ToDisplayPoint, link_go_to_definition::hide_link_definition,
    movement::surrounding_word, persistence::DB, scroll::ScrollAnchor, Anchor, Autoscroll, Editor,
    Event, ExcerptId, ExcerptRange, MultiBuffer, MultiBufferSnapshot, NavigationData, ToPoint as _,
+    FORMAT_TIMEOUT,
 };
 use anyhow::{anyhow, Context, Result};
 use collections::HashSet;
 use futures::future::try_join_all;
+use futures::FutureExt;
 use gpui::{
    elements::*, geometry::vector::vec2f, AppContext, Entity, ModelHandle, MutableAppContext,
    RenderContext, Subscription, Task, View, ViewContext, ViewHandle, WeakViewHandle,
@@ -17,7 +19,6 @@ use language::{
 use project::{FormatTrigger, Item as _, Project, ProjectPath};
 use rpc::proto::{self, update_view};
 use settings::Settings;
-use smallvec::SmallVec;
 use std::{
    borrow::Cow,
    cmp::{self, Ordering},
@@ -529,7 +530,7 @@ impl Item for Editor {
    ) -> ElementBox {
        Flex::row()
            .with_child(
-                Label::new(self.title(cx).to_string(), style.label.clone())
+                Label::new(self.title(cx).into(), style.label.clone())
                    .aligned()
                    .boxed(),
            )
@@ -608,38 +609,33 @@ impl Item for Editor {
        cx: &mut ViewContext<Self>,
    ) -> Task<Result<()>> {
        self.report_event("save editor", cx);
-        let format = self.perform_format(project.clone(), FormatTrigger::Save, cx);
-        let buffers = self.buffer().clone().read(cx).all_buffers();
-        cx.as_mut().spawn(|mut cx| async move {
-            format.await?;

-            if buffers.len() == 1 {
-                project
-                    .update(&mut cx, |project, cx| project.save_buffers(buffers, cx))
-                    .await?;
-            } else {
-                // For multi-buffers, only save those ones that contain changes. For clean buffers
-                // we simulate saving by calling `Buffer::did_save`, so that language servers or
-                // other downstream listeners of save events get notified.
-                let (dirty_buffers, clean_buffers) = buffers.into_iter().partition(|buffer| {
-                    buffer.read_with(&cx, |buffer, _| buffer.is_dirty() || buffer.has_conflict())
-                });
-
-                project
-                    .update(&mut cx, |project, cx| {
-                        project.save_buffers(dirty_buffers, cx)
-                    })
-                    .await?;
-                for buffer in clean_buffers {
-                    buffer.update(&mut cx, |buffer, cx| {
-                        let version = buffer.saved_version().clone();
-                        let fingerprint = buffer.saved_version_fingerprint();
-                        let mtime = buffer.saved_mtime();
-                        buffer.did_save(version, fingerprint, mtime, cx);
-                    });
+        let buffer = self.buffer().clone();
+        let buffers = buffer.read(cx).all_buffers();
+        let mut timeout = cx.background().timer(FORMAT_TIMEOUT).fuse();
+        let format = project.update(cx, |project, cx| {
+            project.format(buffers, true, FormatTrigger::Save, cx)
+        });
+        cx.spawn(|_, mut cx| async move {
+            let transaction = futures::select_biased! {
+                _ = timeout => {
+                    log::warn!("timed out waiting for formatting");
+                    None
                }
-            }
+                transaction = format.log_err().fuse() => transaction,
+            };

+            buffer
+                .update(&mut cx, |buffer, cx| {
+                    if let Some(transaction) = transaction {
+                        if !buffer.is_singleton() {
+                            buffer.push_transaction(&transaction.0);
+                        }
+                    }
+
+                    buffer.save(cx)
+                })
+                .await?;
            Ok(())
        })
    }
@@ -697,8 +693,8 @@ impl Item for Editor {
        Task::ready(Ok(()))
    }

-    fn to_item_events(event: &Self::Event) -> SmallVec<[ItemEvent; 2]> {
-        let mut result = SmallVec::new();
+    fn to_item_events(event: &Self::Event) -> Vec<ItemEvent> {
+        let mut result = Vec::new();
        match event {
            Event::Closed => result.push(ItemEvent::CloseItem),
            Event::Saved | Event::TitleChanged => {
@@ -911,7 +907,7 @@ impl SearchableItem for Editor {
        matches: Vec<Range<Anchor>>,
        cx: &mut ViewContext<Self>,
    ) {
-        self.unfold_ranges([matches[index].clone()], false, true, cx);
+        self.unfold_ranges([matches[index].clone()], false, cx);
        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
            s.select_ranges([matches[index].clone()])
        });
@@ -1162,6 +1158,7 @@ fn path_for_file<'a>(
 mod tests {
    use super::*;
    use gpui::MutableAppContext;
+    use language::RopeFingerprint;
    use std::{
        path::{Path, PathBuf},
        sync::Arc,
@@ -1207,6 +1204,17 @@ mod tests {
            todo!()
        }

+        fn save(
+            &self,
+            _: u64,
+            _: language::Rope,
+            _: clock::Global,
+            _: project::LineEnding,
+            _: &mut MutableAppContext,
+        ) -> gpui::Task<anyhow::Result<(clock::Global, RopeFingerprint, SystemTime)>> {
+            todo!()
+        }
+
        fn as_any(&self) -> &dyn std::any::Any {
            todo!()
        }
--- a/crates/editor/src/mouse_context_menu.rs
+++ b/crates/editor/src/mouse_context_menu.rs
@@ -6,7 +6,7 @@ use gpui::{

 use crate::{
    DisplayPoint, Editor, EditorMode, FindAllReferences, GoToDefinition, GoToTypeDefinition,
-    Rename, RevealInFinder, SelectMode, ToggleCodeActions,
+    Rename, SelectMode, ToggleCodeActions,
 };

 #[derive(Clone, PartialEq)]
@@ -52,8 +52,8 @@ pub fn deploy_context_menu(
            AnchorCorner::TopLeft,
            vec![
                ContextMenuItem::item("Rename Symbol", Rename),
-                ContextMenuItem::item("Go to Definition", GoToDefinition),
-                ContextMenuItem::item("Go to Type Definition", GoToTypeDefinition),
+                ContextMenuItem::item("Go To Definition", GoToDefinition),
+                ContextMenuItem::item("Go To Type Definition", GoToTypeDefinition),
                ContextMenuItem::item("Find All References", FindAllReferences),
                ContextMenuItem::item(
                    "Code Actions",
@@ -61,8 +61,6 @@ pub fn deploy_context_menu(
                        deployed_from_indicator: false,
                    },
                ),
-                ContextMenuItem::Separator,
-                ContextMenuItem::item("Reveal in Finder", RevealInFinder),
            ],
            cx,
        );
--- a/crates/editor/src/multi_buffer.rs
+++ b/crates/editor/src/multi_buffer.rs
@@ -1,6 +1,7 @@
 mod anchor;

 pub use anchor::{Anchor, AnchorRangeExt};
+use anyhow::Result;
 use clock::ReplicaId;
 use collections::{BTreeMap, Bound, HashMap, HashSet};
 use futures::{channel::mpsc, SinkExt};
@@ -384,13 +385,9 @@ impl MultiBuffer {
            _ => Default::default(),
        };

-        struct BufferEdit {
-            range: Range<usize>,
-            new_text: Arc<str>,
-            is_insertion: bool,
-            original_indent_column: u32,
-        }
-        let mut buffer_edits: HashMap<usize, Vec<BufferEdit>> = Default::default();
+        #[allow(clippy::type_complexity)]
+        let mut buffer_edits: HashMap<usize, Vec<(Range<usize>, Arc<str>, bool, u32)>> =
+            Default::default();
        let mut cursor = snapshot.excerpts.cursor::<usize>();
        for (ix, (range, new_text)) in edits.enumerate() {
            let new_text: Arc<str> = new_text.into();
@@ -425,12 +422,12 @@ impl MultiBuffer {
                buffer_edits
                    .entry(start_excerpt.buffer_id)
                    .or_insert(Vec::new())
-                    .push(BufferEdit {
-                        range: buffer_start..buffer_end,
+                    .push((
+                        buffer_start..buffer_end,
                        new_text,
-                        is_insertion: true,
+                        true,
                        original_indent_column,
-                    });
+                    ));
            } else {
                let start_excerpt_range = buffer_start
                    ..start_excerpt
@@ -447,21 +444,21 @@ impl MultiBuffer {
                buffer_edits
                    .entry(start_excerpt.buffer_id)
                    .or_insert(Vec::new())
-                    .push(BufferEdit {
-                        range: start_excerpt_range,
-                        new_text: new_text.clone(),
-                        is_insertion: true,
+                    .push((
+                        start_excerpt_range,
+                        new_text.clone(),
+                        true,
                        original_indent_column,
-                    });
+                    ));
                buffer_edits
                    .entry(end_excerpt.buffer_id)
                    .or_insert(Vec::new())
-                    .push(BufferEdit {
-                        range: end_excerpt_range,
-                        new_text: new_text.clone(),
-                        is_insertion: false,
+                    .push((
+                        end_excerpt_range,
+                        new_text.clone(),
+                        false,
                        original_indent_column,
-                    });
+                    ));

                cursor.seek(&range.start, Bias::Right, &());
                cursor.next(&());
@@ -472,19 +469,19 @@ impl MultiBuffer {
                    buffer_edits
                        .entry(excerpt.buffer_id)
                        .or_insert(Vec::new())
-                        .push(BufferEdit {
-                            range: excerpt.range.context.to_offset(&excerpt.buffer),
-                            new_text: new_text.clone(),
-                            is_insertion: false,
+                        .push((
+                            excerpt.range.context.to_offset(&excerpt.buffer),
+                            new_text.clone(),
+                            false,
                            original_indent_column,
-                        });
+                        ));
                    cursor.next(&());
                }
            }
        }

        for (buffer_id, mut edits) in buffer_edits {
-            edits.sort_unstable_by_key(|edit| edit.range.start);
+            edits.sort_unstable_by_key(|(range, _, _, _)| range.start);
            self.buffers.borrow()[&buffer_id]
                .buffer
                .update(cx, |buffer, cx| {
@@ -493,19 +490,14 @@ impl MultiBuffer {
                    let mut original_indent_columns = Vec::new();
                    let mut deletions = Vec::new();
                    let empty_str: Arc<str> = "".into();
-                    while let Some(BufferEdit {
+                    while let Some((
                        mut range,
                        new_text,
                        mut is_insertion,
                        original_indent_column,
-                    }) = edits.next()
+                    )) = edits.next()
                    {
-                        while let Some(BufferEdit {
-                            range: next_range,
-                            is_insertion: next_is_insertion,
-                            ..
-                        }) = edits.peek()
-                        {
+                        while let Some((next_range, _, next_is_insertion, _)) = edits.peek() {
                            if range.end >= next_range.start {
                                range.end = cmp::max(next_range.end, range.end);
                                is_insertion |= *next_is_insertion;
@@ -1082,21 +1074,18 @@ impl MultiBuffer {

        let mut cursor = snapshot.excerpts.cursor::<usize>();
        cursor.seek(&position, Bias::Right, &());
-        cursor
-            .item()
-            .or_else(|| snapshot.excerpts.last())
-            .map(|excerpt| {
-                (
-                    excerpt.id.clone(),
-                    self.buffers
-                        .borrow()
-                        .get(&excerpt.buffer_id)
-                        .unwrap()
-                        .buffer
-                        .clone(),
-                    excerpt.range.context.clone(),
-                )
-            })
+        cursor.item().map(|excerpt| {
+            (
+                excerpt.id.clone(),
+                self.buffers
+                    .borrow()
+                    .get(&excerpt.buffer_id)
+                    .unwrap()
+                    .buffer
+                    .clone(),
+                excerpt.range.context.clone(),
+            )
+        })
    }

    // If point is at the end of the buffer, the last excerpt is returned
@@ -1290,6 +1279,20 @@ impl MultiBuffer {
            .map(|state| state.buffer.clone())
    }

+    pub fn save(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
+        let mut save_tasks = Vec::new();
+        for BufferState { buffer, .. } in self.buffers.borrow().values() {
+            save_tasks.push(buffer.update(cx, |buffer, cx| buffer.save(cx)));
+        }
+
+        cx.spawn(|_, _| async move {
+            for save in save_tasks {
+                save.await?;
+            }
+            Ok(())
+        })
+    }
+
    pub fn is_completion_trigger<T>(&self, position: T, text: &str, cx: &AppContext) -> bool
    where
        T: ToOffset,
@@ -2618,89 +2621,57 @@ impl MultiBufferSnapshot {
        self.parse_count
    }

-    /// Returns the smallest enclosing bracket ranges containing the given range or
-    /// None if no brackets contain range or the range is not contained in a single
-    /// excerpt
-    pub fn innermost_enclosing_bracket_ranges<T: ToOffset>(
+    pub fn enclosing_bracket_ranges<T: ToOffset>(
        &self,
        range: Range<T>,
    ) -> Option<(Range<usize>, Range<usize>)> {
        let range = range.start.to_offset(self)..range.end.to_offset(self);

-        // Get the ranges of the innermost pair of brackets.
-        let mut result: Option<(Range<usize>, Range<usize>)> = None;
+        let mut cursor = self.excerpts.cursor::<usize>();
+        cursor.seek(&range.start, Bias::Right, &());
+        let start_excerpt = cursor.item();

-        let Some(enclosing_bracket_ranges) = self.enclosing_bracket_ranges(range.clone()) else { return None; };
+        cursor.seek(&range.end, Bias::Right, &());
+        let end_excerpt = cursor.item();

-        for (open, close) in enclosing_bracket_ranges {
-            let len = close.end - open.start;
-
-            if let Some((existing_open, existing_close)) = &result {
-                let existing_len = existing_close.end - existing_open.start;
-                if len > existing_len {
-                    continue;
+        start_excerpt
+            .zip(end_excerpt)
+            .and_then(|(start_excerpt, end_excerpt)| {
+                if start_excerpt.id != end_excerpt.id {
+                    return None;
                }
-            }

-            result = Some((open, close));
-        }
+                let excerpt_buffer_start = start_excerpt
+                    .range
+                    .context
+                    .start
+                    .to_offset(&start_excerpt.buffer);
+                let excerpt_buffer_end = excerpt_buffer_start + start_excerpt.text_summary.len;

-        result
-    }
+                let start_in_buffer =
+                    excerpt_buffer_start + range.start.saturating_sub(*cursor.start());
+                let end_in_buffer =
+                    excerpt_buffer_start + range.end.saturating_sub(*cursor.start());
+                let (mut start_bracket_range, mut end_bracket_range) = start_excerpt
+                    .buffer
+                    .enclosing_bracket_ranges(start_in_buffer..end_in_buffer)?;

-    /// Returns enclosing bracket ranges containing the given range or returns None if the range is
-    /// not contained in a single excerpt
-    pub fn enclosing_bracket_ranges<'a, T: ToOffset>(
-        &'a self,
-        range: Range<T>,
-    ) -> Option<impl Iterator<Item = (Range<usize>, Range<usize>)> + 'a> {
-        let range = range.start.to_offset(self)..range.end.to_offset(self);
-
-        self.bracket_ranges(range.clone()).map(|range_pairs| {
-            range_pairs
-                .filter(move |(open, close)| open.start <= range.start && close.end >= range.end)
-        })
-    }
-
-    /// Returns bracket range pairs overlapping the given `range` or returns None if the `range` is
-    /// not contained in a single excerpt
-    pub fn bracket_ranges<'a, T: ToOffset>(
-        &'a self,
-        range: Range<T>,
-    ) -> Option<impl Iterator<Item = (Range<usize>, Range<usize>)> + 'a> {
-        let range = range.start.to_offset(self)..range.end.to_offset(self);
-        let excerpt = self.excerpt_containing(range.clone());
-        excerpt.map(|(excerpt, excerpt_offset)| {
-            let excerpt_buffer_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
-            let excerpt_buffer_end = excerpt_buffer_start + excerpt.text_summary.len;
-
-            let start_in_buffer = excerpt_buffer_start + range.start.saturating_sub(excerpt_offset);
-            let end_in_buffer = excerpt_buffer_start + range.end.saturating_sub(excerpt_offset);
-
-            excerpt
-                .buffer
-                .bracket_ranges(start_in_buffer..end_in_buffer)
-                .filter_map(move |(start_bracket_range, end_bracket_range)| {
-                    if start_bracket_range.start < excerpt_buffer_start
-                        || end_bracket_range.end > excerpt_buffer_end
-                    {
-                        return None;
-                    }
-
-                    let mut start_bracket_range = start_bracket_range.clone();
+                if start_bracket_range.start >= excerpt_buffer_start
+                    && end_bracket_range.end <= excerpt_buffer_end
+                {
                    start_bracket_range.start =
-                        excerpt_offset + (start_bracket_range.start - excerpt_buffer_start);
+                        cursor.start() + (start_bracket_range.start - excerpt_buffer_start);
                    start_bracket_range.end =
-                        excerpt_offset + (start_bracket_range.end - excerpt_buffer_start);
-
-                    let mut end_bracket_range = end_bracket_range.clone();
+                        cursor.start() + (start_bracket_range.end - excerpt_buffer_start);
                    end_bracket_range.start =
-                        excerpt_offset + (end_bracket_range.start - excerpt_buffer_start);
+                        cursor.start() + (end_bracket_range.start - excerpt_buffer_start);
                    end_bracket_range.end =
-                        excerpt_offset + (end_bracket_range.end - excerpt_buffer_start);
+                        cursor.start() + (end_bracket_range.end - excerpt_buffer_start);
                    Some((start_bracket_range, end_bracket_range))
-                })
-        })
+                } else {
+                    None
+                }
+            })
    }

    pub fn diagnostics_update_count(&self) -> usize {
@@ -2841,23 +2812,40 @@ impl MultiBufferSnapshot {
    pub fn range_for_syntax_ancestor<T: ToOffset>(&self, range: Range<T>) -> Option<Range<usize>> {
        let range = range.start.to_offset(self)..range.end.to_offset(self);

-        self.excerpt_containing(range.clone())
-            .and_then(|(excerpt, excerpt_offset)| {
-                let excerpt_buffer_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
-                let excerpt_buffer_end = excerpt_buffer_start + excerpt.text_summary.len;
+        let mut cursor = self.excerpts.cursor::<usize>();
+        cursor.seek(&range.start, Bias::Right, &());
+        let start_excerpt = cursor.item();
+
+        cursor.seek(&range.end, Bias::Right, &());
+        let end_excerpt = cursor.item();
+
+        start_excerpt
+            .zip(end_excerpt)
+            .and_then(|(start_excerpt, end_excerpt)| {
+                if start_excerpt.id != end_excerpt.id {
+                    return None;
+                }
+
+                let excerpt_buffer_start = start_excerpt
+                    .range
+                    .context
+                    .start
+                    .to_offset(&start_excerpt.buffer);
+                let excerpt_buffer_end = excerpt_buffer_start + start_excerpt.text_summary.len;

                let start_in_buffer =
-                    excerpt_buffer_start + range.start.saturating_sub(excerpt_offset);
-                let end_in_buffer = excerpt_buffer_start + range.end.saturating_sub(excerpt_offset);
-                let mut ancestor_buffer_range = excerpt
+                    excerpt_buffer_start + range.start.saturating_sub(*cursor.start());
+                let end_in_buffer =
+                    excerpt_buffer_start + range.end.saturating_sub(*cursor.start());
+                let mut ancestor_buffer_range = start_excerpt
                    .buffer
                    .range_for_syntax_ancestor(start_in_buffer..end_in_buffer)?;
                ancestor_buffer_range.start =
                    cmp::max(ancestor_buffer_range.start, excerpt_buffer_start);
                ancestor_buffer_range.end = cmp::min(ancestor_buffer_range.end, excerpt_buffer_end);

-                let start = excerpt_offset + (ancestor_buffer_range.start - excerpt_buffer_start);
-                let end = excerpt_offset + (ancestor_buffer_range.end - excerpt_buffer_start);
+                let start = cursor.start() + (ancestor_buffer_range.start - excerpt_buffer_start);
+                let end = cursor.start() + (ancestor_buffer_range.end - excerpt_buffer_start);
                Some(start..end)
            })
    }
@@ -2941,35 +2929,6 @@ impl MultiBufferSnapshot {
        None
    }

-    /// Returns the excerpt containing range and its offset start within the multibuffer or none if `range` spans multiple excerpts
-    fn excerpt_containing<'a, T: ToOffset>(
-        &'a self,
-        range: Range<T>,
-    ) -> Option<(&'a Excerpt, usize)> {
-        let range = range.start.to_offset(self)..range.end.to_offset(self);
-
-        let mut cursor = self.excerpts.cursor::<usize>();
-        cursor.seek(&range.start, Bias::Right, &());
-        let start_excerpt = cursor.item();
-
-        if range.start == range.end {
-            return start_excerpt.map(|excerpt| (excerpt, *cursor.start()));
-        }
-
-        cursor.seek(&range.end, Bias::Right, &());
-        let end_excerpt = cursor.item();
-
-        start_excerpt
-            .zip(end_excerpt)
-            .and_then(|(start_excerpt, end_excerpt)| {
-                if start_excerpt.id != end_excerpt.id {
-                    return None;
-                }
-
-                Some((start_excerpt, *cursor.start()))
-            })
-    }
-
    pub fn remote_selections_in_range<'a>(
        &'a self,
        range: &'a Range<Anchor>,
--- a/crates/editor/src/selections_collection.rs
+++ b/crates/editor/src/selections_collection.rs
@@ -659,31 +659,6 @@ impl<'a> MutableSelectionsCollection<'a> {
        }
    }

-    pub fn move_offsets_with(
-        &mut self,
-        mut move_selection: impl FnMut(&MultiBufferSnapshot, &mut Selection<usize>),
-    ) {
-        let mut changed = false;
-        let snapshot = self.buffer().clone();
-        let selections = self
-            .all::<usize>(self.cx)
-            .into_iter()
-            .map(|selection| {
-                let mut moved_selection = selection.clone();
-                move_selection(&snapshot, &mut moved_selection);
-                if selection != moved_selection {
-                    changed = true;
-                }
-                moved_selection
-            })
-            .collect();
-        drop(snapshot);
-
-        if changed {
-            self.select(selections)
-        }
-    }
-
    pub fn move_heads_with(
        &mut self,
        mut update_head: impl FnMut(
--- a/crates/editor/src/test/editor_lsp_test_context.rs
+++ b/crates/editor/src/test/editor_lsp_test_context.rs
@@ -1,5 +1,4 @@
 use std::{
-    borrow::Cow,
    ops::{Deref, DerefMut, Range},
    sync::Arc,
 };
@@ -8,8 +7,7 @@ use anyhow::Result;

 use futures::Future;
 use gpui::{json, ViewContext, ViewHandle};
-use indoc::indoc;
-use language::{point_to_lsp, FakeLspAdapter, Language, LanguageConfig, LanguageQueries};
+use language::{point_to_lsp, FakeLspAdapter, Language, LanguageConfig};
 use lsp::{notification, request};
 use project::Project;
 use smol::stream::StreamExt;
@@ -39,7 +37,7 @@ impl<'a> EditorLspTestContext<'a> {
            pane::init(cx);
        });

-        let app_state = cx.update(AppState::test);
+        let params = cx.update(AppState::test);

        let file_name = format!(
            "file.{}",
@@ -56,16 +54,24 @@ impl<'a> EditorLspTestContext<'a> {
            }))
            .await;

-        let project = Project::test(app_state.fs.clone(), [], cx).await;
+        let project = Project::test(params.fs.clone(), [], cx).await;
        project.update(cx, |project, _| project.languages().add(Arc::new(language)));

-        app_state
+        params
            .fs
            .as_fake()
-            .insert_tree("/root", json!({ "dir": { file_name.clone(): "" }}))
+            .insert_tree("/root", json!({ "dir": { file_name: "" }}))
            .await;

-        let (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
+        let (window_id, workspace) = cx.add_window(|cx| {
+            Workspace::new(
+                Default::default(),
+                0,
+                project.clone(),
+                |_, _| unimplemented!(),
+                cx,
+            )
+        });
        project
            .update(cx, |project, cx| {
                project.find_or_create_local_worktree("/root", true, cx)
@@ -99,7 +105,7 @@ impl<'a> EditorLspTestContext<'a> {
            },
            lsp,
            workspace,
-            buffer_lsp_url: lsp::Url::from_file_path(format!("/root/dir/{file_name}")).unwrap(),
+            buffer_lsp_url: lsp::Url::from_file_path("/root/dir/file.rs").unwrap(),
        }
    }

@@ -114,59 +120,7 @@ impl<'a> EditorLspTestContext<'a> {
                ..Default::default()
            },
            Some(tree_sitter_rust::language()),
-        )
-        .with_queries(LanguageQueries {
-            indents: Some(Cow::from(indoc! {r#"
-                [
-                    ((where_clause) _ @end)
-                    (field_expression)
-                    (call_expression)
-                    (assignment_expression)
-                    (let_declaration)
-                    (let_chain)
-                    (await_expression)
-                ] @indent
-
-                (_ "[" "]" @end) @indent
-                (_ "<" ">" @end) @indent
-                (_ "{" "}" @end) @indent
-                (_ "(" ")" @end) @indent"#})),
-            brackets: Some(Cow::from(indoc! {r#"
-                ("(" @open ")" @close)
-                ("[" @open "]" @close)
-                ("{" @open "}" @close)
-                ("<" @open ">" @close)
-                ("\"" @open "\"" @close)
-                (closure_parameters "|" @open "|" @close)"#})),
-            ..Default::default()
-        })
-        .expect("Could not parse queries");
-
-        Self::new(language, capabilities, cx).await
-    }
-
-    pub async fn new_typescript(
-        capabilities: lsp::ServerCapabilities,
-        cx: &'a mut gpui::TestAppContext,
-    ) -> EditorLspTestContext<'a> {
-        let language = Language::new(
-            LanguageConfig {
-                name: "Typescript".into(),
-                path_suffixes: vec!["ts".to_string()],
-                ..Default::default()
-            },
-            Some(tree_sitter_typescript::language_typescript()),
-        )
-        .with_queries(LanguageQueries {
-            brackets: Some(Cow::from(indoc! {r#"
-                ("(" @open ")" @close)
-                ("[" @open "]" @close)
-                ("{" @open "}" @close)
-                ("<" @open ">" @close)
-                ("\"" @open "\"" @close)"#})),
-            ..Default::default()
-        })
-        .expect("Could not parse queries");
+        );

        Self::new(language, capabilities, cx).await
    }
--- a/crates/editor/src/test/editor_test_context.rs
+++ b/crates/editor/src/test/editor_test_context.rs
@@ -162,13 +162,10 @@ impl<'a> EditorTestContext<'a> {
    /// embedded range markers that represent the ranges and directions of
    /// each selection.
    ///
-    /// Returns a context handle so that assertion failures can print what
-    /// editor state was needed to cause the failure.
-    ///
    /// See the `util::test::marked_text_ranges` function for more information.
    pub fn set_state(&mut self, marked_text: &str) -> ContextHandle {
        let _state_context = self.add_assertion_context(format!(
-            "Initial Editor State: \"{}\"",
+            "Editor State: \"{}\"",
            marked_text.escape_debug().to_string()
        ));
        let (unmarked_text, selection_ranges) = marked_text_ranges(marked_text, true);
@@ -185,7 +182,6 @@ impl<'a> EditorTestContext<'a> {
    /// of its selections using a string containing embedded range markers.
    ///
    /// See the `util::test::marked_text_ranges` function for more information.
-    #[track_caller]
    pub fn assert_editor_state(&mut self, marked_text: &str) {
        let (unmarked_text, expected_selections) = marked_text_ranges(marked_text, true);
        let buffer_text = self.buffer_text();
--- a/crates/feedback/Cargo.toml
+++ b/crates/feedback/Cargo.toml
@@ -31,4 +31,4 @@ theme = { path = "../theme" }
 tree-sitter-markdown = { git = "https://github.com/MDeiml/tree-sitter-markdown", rev = "330ecab87a3e3a7211ac69bbadc19eabecdb1cca" }
 urlencoding = "2.1.2"
 util = { path = "../util" }
-workspace = { path = "../workspace" }
+workspace = { path = "../workspace" }
--- a/crates/feedback/src/deploy_feedback_button.rs
+++ b/crates/feedback/src/deploy_feedback_button.rs
@@ -1,82 +0,0 @@
-use gpui::{elements::*, CursorStyle, Entity, MouseButton, RenderContext, View, ViewContext};
-use settings::Settings;
-use workspace::{item::ItemHandle, StatusItemView};
-
-use crate::feedback_editor::{FeedbackEditor, GiveFeedback};
-
-pub struct DeployFeedbackButton {
-    active: bool,
-}
-
-impl Entity for DeployFeedbackButton {
-    type Event = ();
-}
-
-impl DeployFeedbackButton {
-    pub fn new() -> Self {
-        DeployFeedbackButton { active: false }
-    }
-}
-
-impl View for DeployFeedbackButton {
-    fn ui_name() -> &'static str {
-        "DeployFeedbackButton"
-    }
-
-    fn render(&mut self, cx: &mut RenderContext<'_, Self>) -> ElementBox {
-        let active = self.active;
-        let theme = cx.global::<Settings>().theme.clone();
-        Stack::new()
-            .with_child(
-                MouseEventHandler::<Self>::new(0, cx, |state, _| {
-                    let style = &theme
-                        .workspace
-                        .status_bar
-                        .sidebar_buttons
-                        .item
-                        .style_for(state, active);
-
-                    Svg::new("icons/speech_bubble_12.svg")
-                        .with_color(style.icon_color)
-                        .constrained()
-                        .with_width(style.icon_size)
-                        .aligned()
-                        .constrained()
-                        .with_width(style.icon_size)
-                        .with_height(style.icon_size)
-                        .contained()
-                        .with_style(style.container)
-                        .boxed()
-                })
-                .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, move |_, cx| {
-                    if !active {
-                        cx.dispatch_action(GiveFeedback)
-                    }
-                })
-                .with_tooltip::<Self, _>(
-                    0,
-                    "Give Feedback".into(),
-                    Some(Box::new(GiveFeedback)),
-                    theme.tooltip.clone(),
-                    cx,
-                )
-                .boxed(),
-            )
-            .boxed()
-    }
-}
-
-impl StatusItemView for DeployFeedbackButton {
-    fn set_active_pane_item(&mut self, item: Option<&dyn ItemHandle>, cx: &mut ViewContext<Self>) {
-        if let Some(item) = item {
-            if let Some(_) = item.downcast::<FeedbackEditor>() {
-                self.active = true;
-                cx.notify();
-                return;
-            }
-        }
-        self.active = false;
-        cx.notify();
-    }
-}
--- a/crates/feedback/src/feedback.rs
+++ b/crates/feedback/src/feedback.rs
@@ -1,10 +1,6 @@
-pub mod deploy_feedback_button;
-pub mod feedback_editor;
-pub mod feedback_info_text;
-pub mod submit_feedback_button;
-
 use std::sync::Arc;

+pub mod feedback_editor;
 mod system_specs;
 use gpui::{actions, impl_actions, ClipboardItem, MutableAppContext, PromptLevel, ViewContext};
 use serde::Deserialize;
@@ -20,12 +16,7 @@ impl_actions!(zed, [OpenBrowser]);

 actions!(
    zed,
-    [
-        CopySystemSpecsIntoClipboard,
-        FileBugReport,
-        RequestFeature,
-        OpenZedCommunityRepo
-    ]
+    [CopySystemSpecsIntoClipboard, FileBugReport, RequestFeature]
 );

 pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
@@ -37,7 +28,7 @@ pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
    cx.add_global_action(move |action: &OpenBrowser, cx| cx.platform().open_url(&action.url));

    let url = format!(
-        "https://github.com/zed-industries/community/issues/new?assignees=&labels=defect%2Ctriage&template=2_bug_report.yml&environment={}", 
+        "https://github.com/zed-industries/feedback/issues/new?assignees=&labels=defect%2Ctriage&template=2_bug_report.yml&environment={}", 
        urlencoding::encode(&system_specs_text)
    );

@@ -57,7 +48,7 @@ pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {

    cx.add_action(
        |_: &mut Workspace, _: &RequestFeature, cx: &mut ViewContext<Workspace>| {
-            let url = "https://github.com/zed-industries/community/issues/new?assignees=&labels=enhancement%2Ctriage&template=0_feature_request.yml";
+            let url = "https://github.com/zed-industries/feedback/issues/new?assignees=&labels=enhancement%2Ctriage&template=0_feature_request.yml";
            cx.dispatch_action(OpenBrowser {
                url: url.into(),
            });
@@ -71,11 +62,4 @@ pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
            });
        },
    );
-
-    cx.add_action(
-        |_: &mut Workspace, _: &OpenZedCommunityRepo, cx: &mut ViewContext<Workspace>| {
-            let url = "https://github.com/zed-industries/community";
-            cx.dispatch_action(OpenBrowser { url: url.into() });
-        },
-    );
 }
--- a/crates/feedback/src/feedback_editor.rs
+++ b/crates/feedback/src/feedback_editor.rs
@@ -10,9 +10,10 @@ use editor::{Anchor, Editor};
 use futures::AsyncReadExt;
 use gpui::{
    actions,
-    elements::{ChildView, Flex, Label, ParentElement},
-    serde_json, AnyViewHandle, AppContext, Element, ElementBox, Entity, ModelHandle,
-    MutableAppContext, PromptLevel, RenderContext, Task, View, ViewContext, ViewHandle,
+    elements::{ChildView, Flex, Label, MouseEventHandler, ParentElement, Stack, Text},
+    serde_json, AnyViewHandle, AppContext, CursorStyle, Element, ElementBox, Entity, ModelHandle,
+    MouseButton, MutableAppContext, PromptLevel, RenderContext, Task, View, ViewContext,
+    ViewHandle, WeakViewHandle,
 };
 use isahc::Request;
 use language::Buffer;
@@ -20,20 +21,21 @@ use postage::prelude::Stream;

 use project::Project;
 use serde::Serialize;
-use util::ResultExt;
+use settings::Settings;
 use workspace::{
    item::{Item, ItemHandle},
    searchable::{SearchableItem, SearchableItemHandle},
-    AppState, Workspace,
+    AppState, StatusItemView, Workspace,
 };

-use crate::{submit_feedback_button::SubmitFeedbackButton, system_specs::SystemSpecs};
+use crate::system_specs::SystemSpecs;

 const FEEDBACK_CHAR_LIMIT: RangeInclusive<usize> = 10..=5000;
+const FEEDBACK_PLACEHOLDER_TEXT: &str = "Save to submit feedback as Markdown.";
 const FEEDBACK_SUBMISSION_ERROR_TEXT: &str =
    "Feedback failed to submit, see error log for details.";

-actions!(feedback, [GiveFeedback, SubmitFeedback]);
+actions!(feedback, [SubmitFeedback, GiveFeedback, DeployFeedback]);

 pub fn init(system_specs: SystemSpecs, app_state: Arc<AppState>, cx: &mut MutableAppContext) {
    cx.add_action({
@@ -41,16 +43,42 @@ pub fn init(system_specs: SystemSpecs, app_state: Arc<AppState>, cx: &mut Mutabl
            FeedbackEditor::deploy(system_specs.clone(), workspace, app_state.clone(), cx);
        }
    });
+}

-    cx.add_async_action(
-        |submit_feedback_button: &mut SubmitFeedbackButton, _: &SubmitFeedback, cx| {
-            if let Some(active_item) = submit_feedback_button.active_item.as_ref() {
-                Some(active_item.update(cx, |feedback_editor, cx| feedback_editor.handle_save(cx)))
-            } else {
-                None
-            }
-        },
-    );
+pub struct FeedbackButton;
+
+impl Entity for FeedbackButton {
+    type Event = ();
+}
+
+impl View for FeedbackButton {
+    fn ui_name() -> &'static str {
+        "FeedbackButton"
+    }
+
+    fn render(&mut self, cx: &mut RenderContext<'_, Self>) -> ElementBox {
+        Stack::new()
+            .with_child(
+                MouseEventHandler::<Self>::new(0, cx, |state, cx| {
+                    let theme = &cx.global::<Settings>().theme;
+                    let theme = &theme.workspace.status_bar.feedback;
+
+                    Text::new(
+                        "Give Feedback".to_string(),
+                        theme.style_for(state, true).clone(),
+                    )
+                    .boxed()
+                })
+                .with_cursor_style(CursorStyle::PointingHand)
+                .on_click(MouseButton::Left, |_, cx| cx.dispatch_action(GiveFeedback))
+                .boxed(),
+            )
+            .boxed()
+    }
+}
+
+impl StatusItemView for FeedbackButton {
+    fn set_active_pane_item(&mut self, _: Option<&dyn ItemHandle>, _: &mut ViewContext<Self>) {}
 }

 #[derive(Serialize)]
@@ -58,12 +86,11 @@ struct FeedbackRequestBody<'a> {
    feedback_text: &'a str,
    metrics_id: Option<Arc<str>>,
    system_specs: SystemSpecs,
-    is_staff: bool,
    token: &'a str,
 }

 #[derive(Clone)]
-pub(crate) struct FeedbackEditor {
+struct FeedbackEditor {
    system_specs: SystemSpecs,
    editor: ViewHandle<Editor>,
    project: ModelHandle<Project>,
@@ -79,6 +106,7 @@ impl FeedbackEditor {
        let editor = cx.add_view(|cx| {
            let mut editor = Editor::for_buffer(buffer, Some(project.clone()), cx);
            editor.set_vertical_scroll_margin(5, cx);
+            editor.set_placeholder_text(FEEDBACK_PLACEHOLDER_TEXT, cx);
            editor
        });

@@ -92,7 +120,11 @@ impl FeedbackEditor {
        }
    }

-    fn handle_save(&mut self, cx: &mut ViewContext<Self>) -> Task<anyhow::Result<()>> {
+    fn handle_save(
+        &mut self,
+        _: ModelHandle<Project>,
+        cx: &mut ViewContext<Self>,
+    ) -> Task<anyhow::Result<()>> {
        let feedback_text = self.editor.read(cx).text(cx);
        let feedback_char_count = feedback_text.chars().count();
        let feedback_text = feedback_text.trim().to_string();
@@ -167,14 +199,12 @@ impl FeedbackEditor {
        let feedback_endpoint = format!("{}/api/feedback", *ZED_SERVER_URL);

        let metrics_id = zed_client.metrics_id();
-        let is_staff = zed_client.is_staff();
        let http_client = zed_client.http_client();

        let request = FeedbackRequestBody {
            feedback_text: &feedback_text,
            metrics_id,
            system_specs,
-            is_staff: is_staff.unwrap_or(false),
            token: ZED_SECRET_CLIENT_TOKEN,
        };

@@ -201,28 +231,24 @@ impl FeedbackEditor {
 impl FeedbackEditor {
    pub fn deploy(
        system_specs: SystemSpecs,
-        _: &mut Workspace,
+        workspace: &mut Workspace,
        app_state: Arc<AppState>,
        cx: &mut ViewContext<Workspace>,
    ) {
-        let markdown = app_state.languages.language_for_name("Markdown");
-        cx.spawn(|workspace, mut cx| async move {
-            let markdown = markdown.await.log_err();
-            workspace
-                .update(&mut cx, |workspace, cx| {
-                    workspace.with_local_workspace(&app_state, cx, |workspace, cx| {
-                        let project = workspace.project().clone();
-                        let buffer = project
-                            .update(cx, |project, cx| project.create_buffer("", markdown, cx))
-                            .expect("creating buffers on a local workspace always succeeds");
-                        let feedback_editor = cx
-                            .add_view(|cx| FeedbackEditor::new(system_specs, project, buffer, cx));
-                        workspace.add_item(Box::new(feedback_editor), cx);
+        workspace
+            .with_local_workspace(&app_state, cx, |workspace, cx| {
+                let project = workspace.project().clone();
+                let markdown_language = project.read(cx).languages().language_for_name("Markdown");
+                let buffer = project
+                    .update(cx, |project, cx| {
+                        project.create_buffer("", markdown_language, cx)
                    })
-                })
-                .await;
-        })
-        .detach();
+                    .expect("creating buffers on a local workspace always succeeds");
+                let feedback_editor =
+                    cx.add_view(|cx| FeedbackEditor::new(system_specs, project, buffer, cx));
+                workspace.add_item(Box::new(feedback_editor), cx);
+            })
+            .detach();
    }
 }

@@ -250,7 +276,7 @@ impl Item for FeedbackEditor {
    fn tab_content(&self, _: Option<usize>, style: &theme::Tab, _: &AppContext) -> ElementBox {
        Flex::row()
            .with_child(
-                Label::new("Feedback", style.label.clone())
+                Label::new("Feedback".to_string(), style.label.clone())
                    .aligned()
                    .contained()
                    .boxed(),
@@ -262,29 +288,35 @@ impl Item for FeedbackEditor {
        self.editor.for_each_project_item(cx, f)
    }

+    fn to_item_events(_: &Self::Event) -> Vec<workspace::item::ItemEvent> {
+        Vec::new()
+    }
+
    fn is_singleton(&self, _: &AppContext) -> bool {
        true
    }

+    fn set_nav_history(&mut self, _: workspace::ItemNavHistory, _: &mut ViewContext<Self>) {}
+
    fn can_save(&self, _: &AppContext) -> bool {
        true
    }

    fn save(
        &mut self,
-        _: ModelHandle<Project>,
+        project: ModelHandle<Project>,
        cx: &mut ViewContext<Self>,
    ) -> Task<anyhow::Result<()>> {
-        self.handle_save(cx)
+        self.handle_save(project, cx)
    }

    fn save_as(
        &mut self,
-        _: ModelHandle<Project>,
+        project: ModelHandle<Project>,
        _: std::path::PathBuf,
        cx: &mut ViewContext<Self>,
    ) -> Task<anyhow::Result<()>> {
-        self.handle_save(cx)
+        self.handle_save(project, cx)
    }

    fn reload(
@@ -292,7 +324,7 @@ impl Item for FeedbackEditor {
        _: ModelHandle<Project>,
        _: &mut ViewContext<Self>,
    ) -> Task<anyhow::Result<()>> {
-        Task::Ready(Some(Ok(())))
+        unreachable!("reload should not have been called")
    }

    fn clone_on_split(
@@ -319,6 +351,20 @@ impl Item for FeedbackEditor {
        ))
    }

+    fn serialized_item_kind() -> Option<&'static str> {
+        None
+    }
+
+    fn deserialize(
+        _: ModelHandle<Project>,
+        _: WeakViewHandle<Workspace>,
+        _: workspace::WorkspaceId,
+        _: workspace::ItemId,
+        _: &mut ViewContext<workspace::Pane>,
+    ) -> Task<anyhow::Result<ViewHandle<Self>>> {
+        unreachable!()
+    }
+
    fn as_searchable(&self, handle: &ViewHandle<Self>) -> Option<Box<dyn SearchableItemHandle>> {
        Some(Box::new(handle.clone()))
    }
--- a/crates/feedback/src/feedback_info_text.rs
+++ b/crates/feedback/src/feedback_info_text.rs
@@ -1,97 +0,0 @@
-use gpui::{
-    elements::{Flex, Label, MouseEventHandler, ParentElement, Text},
-    CursorStyle, Element, ElementBox, Entity, MouseButton, RenderContext, View, ViewContext,
-    ViewHandle,
-};
-use settings::Settings;
-use workspace::{item::ItemHandle, ToolbarItemLocation, ToolbarItemView};
-
-use crate::{feedback_editor::FeedbackEditor, OpenZedCommunityRepo};
-
-pub struct FeedbackInfoText {
-    active_item: Option<ViewHandle<FeedbackEditor>>,
-}
-
-impl FeedbackInfoText {
-    pub fn new() -> Self {
-        Self {
-            active_item: Default::default(),
-        }
-    }
-}
-
-impl Entity for FeedbackInfoText {
-    type Event = ();
-}
-
-impl View for FeedbackInfoText {
-    fn ui_name() -> &'static str {
-        "FeedbackInfoText"
-    }
-
-    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
-        let theme = cx.global::<Settings>().theme.clone();
-
-        Flex::row()
-            .with_child(
-                Text::new(
-                    "We read whatever you submit here. For issues and discussions, visit the ",
-                    theme.feedback.info_text_default.text.clone(),
-                )
-                .with_soft_wrap(false)
-                .aligned()
-                .boxed(),
-            )
-            .with_child(
-                MouseEventHandler::<OpenZedCommunityRepo>::new(0, cx, |state, _| {
-                    let contained_text = if state.hovered() {
-                        &theme.feedback.link_text_hover
-                    } else {
-                        &theme.feedback.link_text_default
-                    };
-
-                    Label::new("community repo", contained_text.text.clone())
-                        .contained()
-                        .aligned()
-                        .left()
-                        .clipped()
-                        .boxed()
-                })
-                .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, |_, cx| {
-                    cx.dispatch_action(OpenZedCommunityRepo)
-                })
-                .boxed(),
-            )
-            .with_child(
-                Text::new(" on GitHub.", theme.feedback.info_text_default.text.clone())
-                    .with_soft_wrap(false)
-                    .aligned()
-                    .boxed(),
-            )
-            .aligned()
-            .left()
-            .clipped()
-            .boxed()
-    }
-}
-
-impl ToolbarItemView for FeedbackInfoText {
-    fn set_active_pane_item(
-        &mut self,
-        active_pane_item: Option<&dyn ItemHandle>,
-        cx: &mut ViewContext<Self>,
-    ) -> workspace::ToolbarItemLocation {
-        cx.notify();
-        if let Some(feedback_editor) = active_pane_item.and_then(|i| i.downcast::<FeedbackEditor>())
-        {
-            self.active_item = Some(feedback_editor);
-            ToolbarItemLocation::PrimaryLeft {
-                flex: Some((1., false)),
-            }
-        } else {
-            self.active_item = None;
-            ToolbarItemLocation::Hidden
-        }
-    }
-}
--- a/crates/feedback/src/submit_feedback_button.rs
+++ b/crates/feedback/src/submit_feedback_button.rs
@@ -1,76 +0,0 @@
-use gpui::{
-    elements::{Label, MouseEventHandler},
-    CursorStyle, Element, ElementBox, Entity, MouseButton, RenderContext, View, ViewContext,
-    ViewHandle,
-};
-use settings::Settings;
-use workspace::{item::ItemHandle, ToolbarItemLocation, ToolbarItemView};
-
-use crate::feedback_editor::{FeedbackEditor, SubmitFeedback};
-
-pub struct SubmitFeedbackButton {
-    pub(crate) active_item: Option<ViewHandle<FeedbackEditor>>,
-}
-
-impl SubmitFeedbackButton {
-    pub fn new() -> Self {
-        Self {
-            active_item: Default::default(),
-        }
-    }
-}
-
-impl Entity for SubmitFeedbackButton {
-    type Event = ();
-}
-
-impl View for SubmitFeedbackButton {
-    fn ui_name() -> &'static str {
-        "SubmitFeedbackButton"
-    }
-
-    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
-        let theme = cx.global::<Settings>().theme.clone();
-        enum SubmitFeedbackButton {}
-        MouseEventHandler::<SubmitFeedbackButton>::new(0, cx, |state, _| {
-            let style = theme.feedback.submit_button.style_for(state, false);
-            Label::new("Submit as Markdown", style.text.clone())
-                .contained()
-                .with_style(style.container)
-                .boxed()
-        })
-        .with_cursor_style(CursorStyle::PointingHand)
-        .on_click(MouseButton::Left, |_, cx| {
-            cx.dispatch_action(SubmitFeedback)
-        })
-        .aligned()
-        .contained()
-        .with_margin_left(theme.feedback.button_margin)
-        .with_tooltip::<Self, _>(
-            0,
-            "cmd-s".into(),
-            Some(Box::new(SubmitFeedback)),
-            theme.tooltip.clone(),
-            cx,
-        )
-        .boxed()
-    }
-}
-
-impl ToolbarItemView for SubmitFeedbackButton {
-    fn set_active_pane_item(
-        &mut self,
-        active_pane_item: Option<&dyn ItemHandle>,
-        cx: &mut ViewContext<Self>,
-    ) -> workspace::ToolbarItemLocation {
-        cx.notify();
-        if let Some(feedback_editor) = active_pane_item.and_then(|i| i.downcast::<FeedbackEditor>())
-        {
-            self.active_item = Some(feedback_editor);
-            ToolbarItemLocation::PrimaryRight { flex: None }
-        } else {
-            self.active_item = None;
-            ToolbarItemLocation::Hidden
-        }
-    }
-}
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -23,7 +23,6 @@ pub struct FileFinder {
    latest_search_id: usize,
    latest_search_did_cancel: bool,
    latest_search_query: String,
-    relative_to: Option<Arc<Path>>,
    matches: Vec<PathMatch>,
    selected: Option<(usize, Arc<Path>)>,
    cancel_flag: Arc<AtomicBool>,
@@ -91,11 +90,7 @@ impl FileFinder {
    fn toggle(workspace: &mut Workspace, _: &Toggle, cx: &mut ViewContext<Workspace>) {
        workspace.toggle_modal(cx, |workspace, cx| {
            let project = workspace.project().clone();
-            let relative_to = workspace
-                .active_item(cx)
-                .and_then(|item| item.project_path(cx))
-                .map(|project_path| project_path.path.clone());
-            let finder = cx.add_view(|cx| Self::new(project, relative_to, cx));
+            let finder = cx.add_view(|cx| Self::new(project, cx));
            cx.subscribe(&finder, Self::on_event).detach();
            finder
        });
@@ -120,11 +115,7 @@ impl FileFinder {
        }
    }

-    pub fn new(
-        project: ModelHandle<Project>,
-        relative_to: Option<Arc<Path>>,
-        cx: &mut ViewContext<Self>,
-    ) -> Self {
+    pub fn new(project: ModelHandle<Project>, cx: &mut ViewContext<Self>) -> Self {
        let handle = cx.weak_handle();
        cx.observe(&project, Self::project_updated).detach();
        Self {
@@ -134,7 +125,6 @@ impl FileFinder {
            latest_search_id: 0,
            latest_search_did_cancel: false,
            latest_search_query: String::new(),
-            relative_to,
            matches: Vec::new(),
            selected: None,
            cancel_flag: Arc::new(AtomicBool::new(false)),
@@ -147,7 +137,6 @@ impl FileFinder {
    }

    fn spawn_search(&mut self, query: String, cx: &mut ViewContext<Self>) -> Task<()> {
-        let relative_to = self.relative_to.clone();
        let worktrees = self
            .project
            .read(cx)
@@ -176,7 +165,6 @@ impl FileFinder {
            let matches = fuzzy::match_path_sets(
                candidate_sets.as_slice(),
                &query,
-                relative_to,
                false,
                100,
                &cancel_flag,
@@ -329,7 +317,9 @@ mod tests {
            .await;

        let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await;
-        let (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
+        let (window_id, workspace) = cx.add_window(|cx| {
+            Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
+        });
        cx.dispatch_action(window_id, Toggle);

        let finder = cx.read(|cx| workspace.read(cx).modal::<FileFinder>().unwrap());
@@ -383,9 +373,11 @@ mod tests {
            .await;

        let project = Project::test(app_state.fs.clone(), ["/dir".as_ref()], cx).await;
-        let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
+        let (_, workspace) = cx.add_window(|cx| {
+            Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
+        });
        let (_, finder) =
-            cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx));
+            cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), cx));

        let query = "hi".to_string();
        finder
@@ -457,9 +449,11 @@ mod tests {
            cx,
        )
        .await;
-        let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
+        let (_, workspace) = cx.add_window(|cx| {
+            Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
+        });
        let (_, finder) =
-            cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx));
+            cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), cx));
        finder
            .update(cx, |f, cx| f.spawn_search("hi".into(), cx))
            .await;
@@ -481,9 +475,11 @@ mod tests {
            cx,
        )
        .await;
-        let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
+        let (_, workspace) = cx.add_window(|cx| {
+            Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
+        });
        let (_, finder) =
-            cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx));
+            cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), cx));

        // Even though there is only one worktree, that worktree's filename
        // is included in the matching, because the worktree is a single file.
@@ -533,10 +529,11 @@ mod tests {
            cx,
        )
        .await;
-        let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
-
+        let (_, workspace) = cx.add_window(|cx| {
+            Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
+        });
        let (_, finder) =
-            cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx));
+            cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), cx));

        // Run a search that matches two files with the same relative path.
        finder
@@ -554,46 +551,6 @@ mod tests {
        });
    }

-    #[gpui::test]
-    async fn test_path_distance_ordering(cx: &mut gpui::TestAppContext) {
-        cx.foreground().forbid_parking();
-
-        let app_state = cx.update(AppState::test);
-        app_state
-            .fs
-            .as_fake()
-            .insert_tree(
-                "/root",
-                json!({
-                    "dir1": { "a.txt": "" },
-                    "dir2": {
-                        "a.txt": "",
-                        "b.txt": ""
-                    }
-                }),
-            )
-            .await;
-
-        let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await;
-        let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
-
-        // When workspace has an active item, sort items which are closer to that item
-        // first when they have the same name. In this case, b.txt is closer to dir2's a.txt
-        // so that one should be sorted earlier
-        let b_path = Some(Arc::from(Path::new("/root/dir2/b.txt")));
-        let (_, finder) =
-            cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), b_path, cx));
-
-        finder
-            .update(cx, |f, cx| f.spawn_search("a.txt".into(), cx))
-            .await;
-
-        finder.read_with(cx, |f, _| {
-            assert_eq!(f.matches[0].path.as_ref(), Path::new("dir2/a.txt"));
-            assert_eq!(f.matches[1].path.as_ref(), Path::new("dir1/a.txt"));
-        });
-    }
-
    #[gpui::test]
    async fn test_search_worktree_without_files(cx: &mut gpui::TestAppContext) {
        let app_state = cx.update(AppState::test);
@@ -612,9 +569,11 @@ mod tests {
            .await;

        let project = Project::test(app_state.fs.clone(), ["/root".as_ref()], cx).await;
-        let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project, cx));
+        let (_, workspace) = cx.add_window(|cx| {
+            Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
+        });
        let (_, finder) =
-            cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), None, cx));
+            cx.add_window(|cx| FileFinder::new(workspace.read(cx).project().clone(), cx));
        finder
            .update(cx, |f, cx| f.spawn_search("dir".into(), cx))
            .await;
--- a/crates/fuzzy/src/matcher.rs
+++ b/crates/fuzzy/src/matcher.rs
@@ -443,7 +443,6 @@ mod tests {
                positions: Vec::new(),
                path: candidate.path.clone(),
                path_prefix: "".into(),
-                distance_to_relative_ancestor: usize::MAX,
            },
        );

--- a/crates/fuzzy/src/paths.rs
+++ b/crates/fuzzy/src/paths.rs
@@ -25,9 +25,6 @@ pub struct PathMatch {
    pub worktree_id: usize,
    pub path: Arc<Path>,
    pub path_prefix: Arc<str>,
-    /// Number of steps removed from a shared parent with the relative path
-    /// Used to order closer paths first in the search list
-    pub distance_to_relative_ancestor: usize,
 }

 pub trait PathMatchCandidateSet<'a>: Send + Sync {
@@ -81,11 +78,6 @@ impl Ord for PathMatch {
            .partial_cmp(&other.score)
            .unwrap_or(Ordering::Equal)
            .then_with(|| self.worktree_id.cmp(&other.worktree_id))
-            .then_with(|| {
-                other
-                    .distance_to_relative_ancestor
-                    .cmp(&self.distance_to_relative_ancestor)
-            })
            .then_with(|| self.path.cmp(&other.path))
    }
 }
@@ -93,7 +85,6 @@ impl Ord for PathMatch {
 pub async fn match_path_sets<'a, Set: PathMatchCandidateSet<'a>>(
    candidate_sets: &'a [Set],
    query: &str,
-    relative_to: Option<Arc<Path>>,
    smart_case: bool,
    max_results: usize,
    cancel_flag: &AtomicBool,
@@ -120,7 +111,6 @@ pub async fn match_path_sets<'a, Set: PathMatchCandidateSet<'a>>(
    background
        .scoped(|scope| {
            for (segment_idx, results) in segment_results.iter_mut().enumerate() {
-                let relative_to = relative_to.clone();
                scope.spawn(async move {
                    let segment_start = segment_idx * segment_size;
                    let segment_end = segment_start + segment_size;
@@ -159,15 +149,6 @@ pub async fn match_path_sets<'a, Set: PathMatchCandidateSet<'a>>(
                                    positions: Vec::new(),
                                    path: candidate.path.clone(),
                                    path_prefix: candidate_set.prefix(),
-                                    distance_to_relative_ancestor: relative_to.as_ref().map_or(
-                                        usize::MAX,
-                                        |relative_to| {
-                                            distance_between_paths(
-                                                candidate.path.as_ref(),
-                                                relative_to.as_ref(),
-                                            )
-                                        },
-                                    ),
                                },
                            );
                        }
@@ -191,30 +172,3 @@ pub async fn match_path_sets<'a, Set: PathMatchCandidateSet<'a>>(
    }
    results
 }
-
-/// Compute the distance from a given path to some other path
-/// If there is no shared path, returns usize::MAX
-fn distance_between_paths(path: &Path, relative_to: &Path) -> usize {
-    let mut path_components = path.components();
-    let mut relative_components = relative_to.components();
-
-    while path_components
-        .next()
-        .zip(relative_components.next())
-        .map(|(path_component, relative_component)| path_component == relative_component)
-        .unwrap_or_default()
-    {}
-    path_components.count() + relative_components.count() + 1
-}
-
-#[cfg(test)]
-mod tests {
-    use std::path::Path;
-
-    use super::distance_between_paths;
-
-    #[test]
-    fn test_distance_between_paths_empty() {
-        distance_between_paths(Path::new(""), Path::new(""));
-    }
-}
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
--- a/crates/gpui/src/app/action.rs
+++ b/crates/gpui/src/app/action.rs
@@ -16,14 +16,6 @@ pub trait Action: 'static {
        Self: Sized;
 }

-impl std::fmt::Debug for dyn Action {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("dyn Action")
-            .field("namespace", &self.namespace())
-            .field("name", &self.name())
-            .finish()
-    }
-}
 /// Define a set of unit struct types that all implement the `Action` trait.
 ///
 /// The first argument is a namespace that will be associated with each of
--- a/crates/gpui/src/app/menu.rs
+++ b/crates/gpui/src/app/menu.rs
@@ -1,89 +0,0 @@
-use crate::{Action, App, ForegroundPlatform, MutableAppContext};
-
-pub struct Menu<'a> {
-    pub name: &'a str,
-    pub items: Vec<MenuItem<'a>>,
-}
-
-pub enum MenuItem<'a> {
-    Separator,
-    Submenu(Menu<'a>),
-    Action {
-        name: &'a str,
-        action: Box<dyn Action>,
-        os_action: Option<OsAction>,
-    },
-}
-
-impl<'a> MenuItem<'a> {
-    pub fn separator() -> Self {
-        Self::Separator
-    }
-
-    pub fn submenu(menu: Menu<'a>) -> Self {
-        Self::Submenu(menu)
-    }
-
-    pub fn action(name: &'a str, action: impl Action) -> Self {
-        Self::Action {
-            name,
-            action: Box::new(action),
-            os_action: None,
-        }
-    }
-
-    pub fn os_action(name: &'a str, action: impl Action, os_action: OsAction) -> Self {
-        Self::Action {
-            name,
-            action: Box::new(action),
-            os_action: Some(os_action),
-        }
-    }
-}
-
-#[derive(Copy, Clone, Eq, PartialEq)]
-pub enum OsAction {
-    Cut,
-    Copy,
-    Paste,
-    SelectAll,
-    Undo,
-    Redo,
-}
-
-impl MutableAppContext {
-    pub fn set_menus(&mut self, menus: Vec<Menu>) {
-        self.foreground_platform
-            .set_menus(menus, &self.keystroke_matcher);
-    }
-}
-
-pub(crate) fn setup_menu_handlers(foreground_platform: &dyn ForegroundPlatform, app: &App) {
-    foreground_platform.on_will_open_menu(Box::new({
-        let cx = app.0.clone();
-        move || {
-            let mut cx = cx.borrow_mut();
-            cx.keystroke_matcher.clear_pending();
-        }
-    }));
-    foreground_platform.on_validate_menu_command(Box::new({
-        let cx = app.0.clone();
-        move |action| {
-            let cx = cx.borrow_mut();
-            !cx.keystroke_matcher.has_pending_keystrokes() && cx.is_action_available(action)
-        }
-    }));
-    foreground_platform.on_menu_command(Box::new({
-        let cx = app.0.clone();
-        move |action| {
-            let mut cx = cx.borrow_mut();
-            if let Some(main_window_id) = cx.cx.platform.main_window_id() {
-                if let Some(view_id) = cx.focused_view_id(main_window_id) {
-                    cx.handle_dispatch_action_from_effect(main_window_id, Some(view_id), action);
-                    return;
-                }
-            }
-            cx.dispatch_global_action_any(action);
-        }
-    }));
-}
--- a/crates/gpui/src/app/ref_counts.rs
+++ b/crates/gpui/src/app/ref_counts.rs
@@ -1,220 +0,0 @@
-#[cfg(any(test, feature = "test-support"))]
-use std::sync::Arc;
-
-use lazy_static::lazy_static;
-#[cfg(any(test, feature = "test-support"))]
-use parking_lot::Mutex;
-
-use collections::{hash_map::Entry, HashMap, HashSet};
-
-#[cfg(any(test, feature = "test-support"))]
-use crate::util::post_inc;
-use crate::ElementStateId;
-
-lazy_static! {
-    static ref LEAK_BACKTRACE: bool =
-        std::env::var("LEAK_BACKTRACE").map_or(false, |b| !b.is_empty());
-}
-
-struct ElementStateRefCount {
-    ref_count: usize,
-    frame_id: usize,
-}
-
-#[derive(Default)]
-pub struct RefCounts {
-    entity_counts: HashMap<usize, usize>,
-    element_state_counts: HashMap<ElementStateId, ElementStateRefCount>,
-    dropped_models: HashSet<usize>,
-    dropped_views: HashSet<(usize, usize)>,
-    dropped_element_states: HashSet<ElementStateId>,
-
-    #[cfg(any(test, feature = "test-support"))]
-    pub leak_detector: Arc<Mutex<LeakDetector>>,
-}
-
-impl RefCounts {
-    #[cfg(any(test, feature = "test-support"))]
-    pub fn new(leak_detector: Arc<Mutex<LeakDetector>>) -> Self {
-        Self {
-            #[cfg(any(test, feature = "test-support"))]
-            leak_detector,
-            ..Default::default()
-        }
-    }
-
-    pub fn inc_model(&mut self, model_id: usize) {
-        match self.entity_counts.entry(model_id) {
-            Entry::Occupied(mut entry) => {
-                *entry.get_mut() += 1;
-            }
-            Entry::Vacant(entry) => {
-                entry.insert(1);
-                self.dropped_models.remove(&model_id);
-            }
-        }
-    }
-
-    pub fn inc_view(&mut self, window_id: usize, view_id: usize) {
-        match self.entity_counts.entry(view_id) {
-            Entry::Occupied(mut entry) => *entry.get_mut() += 1,
-            Entry::Vacant(entry) => {
-                entry.insert(1);
-                self.dropped_views.remove(&(window_id, view_id));
-            }
-        }
-    }
-
-    pub fn inc_element_state(&mut self, id: ElementStateId, frame_id: usize) {
-        match self.element_state_counts.entry(id) {
-            Entry::Occupied(mut entry) => {
-                let entry = entry.get_mut();
-                if entry.frame_id == frame_id || entry.ref_count >= 2 {
-                    panic!("used the same element state more than once in the same frame");
-                }
-                entry.ref_count += 1;
-                entry.frame_id = frame_id;
-            }
-            Entry::Vacant(entry) => {
-                entry.insert(ElementStateRefCount {
-                    ref_count: 1,
-                    frame_id,
-                });
-                self.dropped_element_states.remove(&id);
-            }
-        }
-    }
-
-    pub fn dec_model(&mut self, model_id: usize) {
-        let count = self.entity_counts.get_mut(&model_id).unwrap();
-        *count -= 1;
-        if *count == 0 {
-            self.entity_counts.remove(&model_id);
-            self.dropped_models.insert(model_id);
-        }
-    }
-
-    pub fn dec_view(&mut self, window_id: usize, view_id: usize) {
-        let count = self.entity_counts.get_mut(&view_id).unwrap();
-        *count -= 1;
-        if *count == 0 {
-            self.entity_counts.remove(&view_id);
-            self.dropped_views.insert((window_id, view_id));
-        }
-    }
-
-    pub fn dec_element_state(&mut self, id: ElementStateId) {
-        let entry = self.element_state_counts.get_mut(&id).unwrap();
-        entry.ref_count -= 1;
-        if entry.ref_count == 0 {
-            self.element_state_counts.remove(&id);
-            self.dropped_element_states.insert(id);
-        }
-    }
-
-    pub fn is_entity_alive(&self, entity_id: usize) -> bool {
-        self.entity_counts.contains_key(&entity_id)
-    }
-
-    pub fn take_dropped(
-        &mut self,
-    ) -> (
-        HashSet<usize>,
-        HashSet<(usize, usize)>,
-        HashSet<ElementStateId>,
-    ) {
-        (
-            std::mem::take(&mut self.dropped_models),
-            std::mem::take(&mut self.dropped_views),
-            std::mem::take(&mut self.dropped_element_states),
-        )
-    }
-}
-
-#[cfg(any(test, feature = "test-support"))]
-#[derive(Default)]
-pub struct LeakDetector {
-    next_handle_id: usize,
-    #[allow(clippy::type_complexity)]
-    handle_backtraces: HashMap<
-        usize,
-        (
-            Option<&'static str>,
-            HashMap<usize, Option<backtrace::Backtrace>>,
-        ),
-    >,
-}
-
-#[cfg(any(test, feature = "test-support"))]
-impl LeakDetector {
-    pub fn handle_created(&mut self, type_name: Option<&'static str>, entity_id: usize) -> usize {
-        let handle_id = post_inc(&mut self.next_handle_id);
-        let entry = self.handle_backtraces.entry(entity_id).or_default();
-        let backtrace = if *LEAK_BACKTRACE {
-            Some(backtrace::Backtrace::new_unresolved())
-        } else {
-            None
-        };
-        if let Some(type_name) = type_name {
-            entry.0.get_or_insert(type_name);
-        }
-        entry.1.insert(handle_id, backtrace);
-        handle_id
-    }
-
-    pub fn handle_dropped(&mut self, entity_id: usize, handle_id: usize) {
-        if let Some((_, backtraces)) = self.handle_backtraces.get_mut(&entity_id) {
-            assert!(backtraces.remove(&handle_id).is_some());
-            if backtraces.is_empty() {
-                self.handle_backtraces.remove(&entity_id);
-            }
-        }
-    }
-
-    pub fn assert_dropped(&mut self, entity_id: usize) {
-        if let Some((type_name, backtraces)) = self.handle_backtraces.get_mut(&entity_id) {
-            for trace in backtraces.values_mut().flatten() {
-                trace.resolve();
-                eprintln!("{:?}", crate::util::CwdBacktrace(trace));
-            }
-
-            let hint = if *LEAK_BACKTRACE {
-                ""
-            } else {
-                " – set LEAK_BACKTRACE=1 for more information"
-            };
-
-            panic!(
-                "{} handles to {} {} still exist{}",
-                backtraces.len(),
-                type_name.unwrap_or("entity"),
-                entity_id,
-                hint
-            );
-        }
-    }
-
-    pub fn detect(&mut self) {
-        let mut found_leaks = false;
-        for (id, (type_name, backtraces)) in self.handle_backtraces.iter_mut() {
-            eprintln!(
-                "leaked {} handles to {} {}",
-                backtraces.len(),
-                type_name.unwrap_or("entity"),
-                id
-            );
-            for trace in backtraces.values_mut().flatten() {
-                trace.resolve();
-                eprintln!("{:?}", crate::util::CwdBacktrace(trace));
-            }
-            found_leaks = true;
-        }
-
-        let hint = if *LEAK_BACKTRACE {
-            ""
-        } else {
-            " – set LEAK_BACKTRACE=1 for more information"
-        };
-        assert!(!found_leaks, "detected leaked handles{}", hint);
-    }
-}
--- a/crates/gpui/src/app/test_app_context.rs
+++ b/crates/gpui/src/app/test_app_context.rs
@@ -18,16 +18,14 @@ use smol::stream::StreamExt;

 use crate::{
    executor, geometry::vector::Vector2F, keymap_matcher::Keystroke, platform, Action,
-    AnyViewHandle, AppContext, Appearance, Entity, Event, FontCache, Handle, InputHandler,
-    KeyDownEvent, ModelContext, ModelHandle, MutableAppContext, Platform, ReadModelWith,
+    AnyViewHandle, AppContext, Appearance, Entity, Event, FontCache, InputHandler, KeyDownEvent,
+    LeakDetector, ModelContext, ModelHandle, MutableAppContext, Platform, ReadModelWith,
    ReadViewWith, RenderContext, Task, UpdateModel, UpdateView, View, ViewContext, ViewHandle,
-    WeakHandle,
+    WeakHandle, WindowInputHandler,
 };
 use collections::BTreeMap;

-use super::{
-    ref_counts::LeakDetector, window_input_handler::WindowInputHandler, AsyncAppContext, RefCounts,
-};
+use super::{AsyncAppContext, RefCounts};

 pub struct TestAppContext {
    cx: Rc<RefCell<MutableAppContext>>,
@@ -54,7 +52,11 @@ impl TestAppContext {
            platform,
            foreground_platform.clone(),
            font_cache,
-            RefCounts::new(leak_detector),
+            RefCounts {
+                #[cfg(any(test, feature = "test-support"))]
+                leak_detector,
+                ..Default::default()
+            },
            (),
        );
        cx.next_entity_id = first_entity_id;
@@ -330,14 +332,6 @@ impl TestAppContext {
            .assert_dropped(handle.id())
    }

-    /// Drop a handle, assuming it is the last. If it is not the last, panic with debug information about
-    /// where the stray handles were created.
-    pub fn drop_last<T, W: WeakHandle, H: Handle<T, Weak = W>>(&mut self, handle: H) {
-        let weak = handle.downgrade();
-        self.update(|_| drop(handle));
-        self.assert_dropped(weak);
-    }
-
    fn window_mut(&self, window_id: usize) -> std::cell::RefMut<platform::test::Window> {
        std::cell::RefMut::map(self.cx.borrow_mut(), |state| {
            let (_, window) = state
@@ -630,8 +624,6 @@ impl<T: View> ViewHandle<T> {
    }
 }

-/// Tracks string context to be printed when assertions fail.
-/// Often this is done by storing a context string in the manager and returning the handle.
 #[derive(Clone)]
 pub struct AssertionContextManager {
    id: Arc<AtomicUsize>,
@@ -662,9 +654,6 @@ impl AssertionContextManager {
    }
 }

-/// Used to track the lifetime of a piece of context so that it can be provided when an assertion fails.
-/// For example, in the EditorTestContext, `set_state` returns a context handle so that if an assertion fails,
-/// the state that was set initially for the failure can be printed in the error message
 pub struct ContextHandle {
    id: usize,
    manager: AssertionContextManager,
--- a/crates/gpui/src/app/window_input_handler.rs
+++ b/crates/gpui/src/app/window_input_handler.rs
@@ -1,98 +0,0 @@
-use std::{cell::RefCell, ops::Range, rc::Rc};
-
-use pathfinder_geometry::rect::RectF;
-
-use crate::{AnyView, AppContext, InputHandler, MutableAppContext};
-
-pub struct WindowInputHandler {
-    pub app: Rc<RefCell<MutableAppContext>>,
-    pub window_id: usize,
-}
-
-impl WindowInputHandler {
-    fn read_focused_view<T, F>(&self, f: F) -> Option<T>
-    where
-        F: FnOnce(&dyn AnyView, &AppContext) -> T,
-    {
-        // Input-related application hooks are sometimes called by the OS during
-        // a call to a window-manipulation API, like prompting the user for file
-        // paths. In that case, the AppContext will already be borrowed, so any
-        // InputHandler methods need to fail gracefully.
-        //
-        // See https://github.com/zed-industries/community/issues/444
-        let app = self.app.try_borrow().ok()?;
-
-        let view_id = app.focused_view_id(self.window_id)?;
-        let view = app.cx.views.get(&(self.window_id, view_id))?;
-        let result = f(view.as_ref(), &app);
-        Some(result)
-    }
-
-    fn update_focused_view<T, F>(&mut self, f: F) -> Option<T>
-    where
-        F: FnOnce(usize, usize, &mut dyn AnyView, &mut MutableAppContext) -> T,
-    {
-        let mut app = self.app.try_borrow_mut().ok()?;
-        app.update(|app| {
-            let view_id = app.focused_view_id(self.window_id)?;
-            let mut view = app.cx.views.remove(&(self.window_id, view_id))?;
-            let result = f(self.window_id, view_id, view.as_mut(), &mut *app);
-            app.cx.views.insert((self.window_id, view_id), view);
-            Some(result)
-        })
-    }
-}
-
-impl InputHandler for WindowInputHandler {
-    fn text_for_range(&self, range: Range<usize>) -> Option<String> {
-        self.read_focused_view(|view, cx| view.text_for_range(range.clone(), cx))
-            .flatten()
-    }
-
-    fn selected_text_range(&self) -> Option<Range<usize>> {
-        self.read_focused_view(|view, cx| view.selected_text_range(cx))
-            .flatten()
-    }
-
-    fn replace_text_in_range(&mut self, range: Option<Range<usize>>, text: &str) {
-        self.update_focused_view(|window_id, view_id, view, cx| {
-            view.replace_text_in_range(range, text, cx, window_id, view_id);
-        });
-    }
-
-    fn marked_text_range(&self) -> Option<Range<usize>> {
-        self.read_focused_view(|view, cx| view.marked_text_range(cx))
-            .flatten()
-    }
-
-    fn unmark_text(&mut self) {
-        self.update_focused_view(|window_id, view_id, view, cx| {
-            view.unmark_text(cx, window_id, view_id);
-        });
-    }
-
-    fn replace_and_mark_text_in_range(
-        &mut self,
-        range: Option<Range<usize>>,
-        new_text: &str,
-        new_selected_range: Option<Range<usize>>,
-    ) {
-        self.update_focused_view(|window_id, view_id, view, cx| {
-            view.replace_and_mark_text_in_range(
-                range,
-                new_text,
-                new_selected_range,
-                cx,
-                window_id,
-                view_id,
-            );
-        });
-    }
-
-    fn rect_for_range(&self, range_utf16: Range<usize>) -> Option<RectF> {
-        let app = self.app.borrow();
-        let (presenter, _) = app.presenters_and_platform_windows.get(&self.window_id)?;
-        let presenter = presenter.borrow();
-        presenter.rect_for_text_range(range_utf16, &app)
-    }
-}
--- a/crates/gpui/src/assets.rs
+++ b/crates/gpui/src/assets.rs
@@ -1,8 +1,5 @@
 use anyhow::{anyhow, Result};
-use image::ImageFormat;
-use std::{borrow::Cow, cell::RefCell, collections::HashMap, sync::Arc};
-
-use crate::ImageData;
+use std::{borrow::Cow, cell::RefCell, collections::HashMap};

 pub trait AssetSource: 'static + Send + Sync {
    fn load(&self, path: &str) -> Result<Cow<[u8]>>;
@@ -25,7 +22,6 @@ impl AssetSource for () {
 pub struct AssetCache {
    source: Box<dyn AssetSource>,
    svgs: RefCell<HashMap<String, usvg::Tree>>,
-    pngs: RefCell<HashMap<String, Arc<ImageData>>>,
 }

 impl AssetCache {
@@ -33,7 +29,6 @@ impl AssetCache {
        Self {
            source: Box::new(source),
            svgs: RefCell::new(HashMap::new()),
-            pngs: RefCell::new(HashMap::new()),
        }
    }

@@ -48,18 +43,4 @@ impl AssetCache {
            Ok(svg)
        }
    }
-
-    pub fn png(&self, path: &str) -> Result<Arc<ImageData>> {
-        let mut pngs = self.pngs.borrow_mut();
-        if let Some(png) = pngs.get(path) {
-            Ok(png.clone())
-        } else {
-            let bytes = self.source.load(path)?;
-            let image = ImageData::new(
-                image::load_from_memory_with_format(&bytes, ImageFormat::Png)?.into_bgra8(),
-            );
-            pngs.insert(path.to_string(), image.clone());
-            Ok(image)
-        }
-    }
 }
--- a/crates/gpui/src/elements.rs
+++ b/crates/gpui/src/elements.rs
@@ -1,6 +1,5 @@
 mod align;
 mod canvas;
-mod clipped;
 mod constrained_box;
 mod container;
 mod empty;
@@ -20,12 +19,12 @@ mod text;
 mod tooltip;
 mod uniform_list;

+use self::expanded::Expanded;
 pub use self::{
    align::*, canvas::*, constrained_box::*, container::*, empty::*, flex::*, hook::*, image::*,
    keystroke_label::*, label::*, list::*, mouse_event_handler::*, overlay::*, resizable::*,
    stack::*, svg::*, text::*, tooltip::*, uniform_list::*,
 };
-use self::{clipped::Clipped, expanded::Expanded};
 pub use crate::presenter::ChildView;
 use crate::{
    geometry::{
@@ -136,13 +135,6 @@ pub trait Element {
        Align::new(self.boxed())
    }

-    fn clipped(self) -> Clipped
-    where
-        Self: 'static + Sized,
-    {
-        Clipped::new(self.boxed())
-    }
-
    fn contained(self) -> Container
    where
        Self: 'static + Sized,
@@ -296,10 +288,7 @@ impl<T: Element> AnyElement for Lifecycle<T> {
                    paint,
                }
            }
-            Lifecycle::Empty => panic!("invalid element lifecycle state"),
-            Lifecycle::Init { .. } => {
-                panic!("invalid element lifecycle state, paint called before layout")
-            }
+            _ => panic!("invalid element lifecycle state"),
        }
    }

@@ -366,7 +355,6 @@ impl<T: Element> AnyElement for Lifecycle<T> {
                    value
                }
            }
-
            _ => panic!("invalid element lifecycle state"),
        }
    }
--- a/crates/gpui/src/elements/clipped.rs
+++ b/crates/gpui/src/elements/clipped.rs
@@ -1,69 +0,0 @@
-use std::ops::Range;
-
-use pathfinder_geometry::{rect::RectF, vector::Vector2F};
-use serde_json::json;
-
-use crate::{
-    json, DebugContext, Element, ElementBox, LayoutContext, MeasurementContext, PaintContext,
-    SizeConstraint,
-};
-
-pub struct Clipped {
-    child: ElementBox,
-}
-
-impl Clipped {
-    pub fn new(child: ElementBox) -> Self {
-        Self { child }
-    }
-}
-
-impl Element for Clipped {
-    type LayoutState = ();
-    type PaintState = ();
-
-    fn layout(
-        &mut self,
-        constraint: SizeConstraint,
-        cx: &mut LayoutContext,
-    ) -> (Vector2F, Self::LayoutState) {
-        (self.child.layout(constraint, cx), ())
-    }
-
-    fn paint(
-        &mut self,
-        bounds: RectF,
-        visible_bounds: RectF,
-        _: &mut Self::LayoutState,
-        cx: &mut PaintContext,
-    ) -> Self::PaintState {
-        cx.scene.push_layer(Some(bounds));
-        self.child.paint(bounds.origin(), visible_bounds, cx);
-        cx.scene.pop_layer();
-    }
-
-    fn rect_for_text_range(
-        &self,
-        range_utf16: Range<usize>,
-        _: RectF,
-        _: RectF,
-        _: &Self::LayoutState,
-        _: &Self::PaintState,
-        cx: &MeasurementContext,
-    ) -> Option<RectF> {
-        self.child.rect_for_text_range(range_utf16, cx)
-    }
-
-    fn debug(
-        &self,
-        _: RectF,
-        _: &Self::LayoutState,
-        _: &Self::PaintState,
-        cx: &DebugContext,
-    ) -> json::Value {
-        json!({
-            "type": "Clipped",
-            "child": self.child.debug(cx)
-        })
-    }
-}
--- a/crates/gpui/src/elements/constrained_box.rs
+++ b/crates/gpui/src/elements/constrained_box.rs
@@ -153,9 +153,7 @@ impl Element for ConstrainedBox {
        _: &mut Self::LayoutState,
        cx: &mut PaintContext,
    ) -> Self::PaintState {
-        cx.paint_layer(Some(visible_bounds), |cx| {
-            self.child.paint(bounds.origin(), visible_bounds, cx);
-        })
+        self.child.paint(bounds.origin(), visible_bounds, cx);
    }

    fn rect_for_text_range(
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Joseph Lyons	6ae297832f	zed 0.72.1	2023-02-06 14:24:41 -05:00
Joseph T. Lyons	a7f788746c	Merge pull request #2125 from zed-industries/trim-leading-and-trailing-whitespace-in-feedback Trim leading and trailing whitespace in feedback	2023-02-06 14:19:33 -05:00
Kay Simmons	7ff55087f3	Merge pull request #2124 from zed-industries/fix-display-uuid-panic Make display uuid optional if the display is disconnected	2023-02-06 14:15:58 -05:00
Joseph Lyons	41102751ef	Reduce length of feedback placeholder text	2023-02-03 08:35:55 -05:00
Joseph T. Lyons	a25580fb7f	Merge pull request #2127 from zed-industries/fix-discourse-release Fix discourse release	2023-02-02 14:41:59 -05:00
Joseph Lyons	bc7bccf5f5	v0.72.x preview	2023-02-01 13:44:50 -05:00