One more doc

More docs
Write some docs
2023-11-22 13:32:08 -07:00 · 2023-11-22 13:03:31 -07:00 · 2023-11-22 12:57:47 -07:00 · 2023-11-22 12:39:55 -07:00 · 2023-11-22 12:16:27 -07:00
647 changed files with 49669 additions and 97181 deletions
--- a/.cargo/ci-config.toml
+++ b/.cargo/ci-config.toml
@@ -1,12 +0,0 @@
-# This config is different from config.toml in this directory, as the latter is recognized by Cargo.
-# This file is placed in $HOME/.cargo/config.toml on CI runs. Cargo then merges Zeds .cargo/config.toml with $HOME/.cargo/config.toml
-# with preference for settings from Zeds config.toml.
-# TL;DR: If a value is set in both ci-config.toml and config.toml, config.toml value takes precedence.
-# Arrays are merged together though. See: https://doc.rust-lang.org/cargo/reference/config.html#hierarchical-structure
-# The intent for this file is to configure CI build process with a divergance from Zed developers experience; for example, in this config file
-# we use `-D warnings` for rustflags (which makes compilation fail in presence of warnings during build process). Placing that in developers `config.toml`
-# would be incovenient.
-# We *could* override things like RUSTFLAGS manually by setting them as environment variables, but that is less DRY; worse yet, if you forget to set proper environment variables
-# in one spot, that's going to trigger a rebuild of all of the artifacts. Using ci-config.toml we can define these overrides for CI in one spot and not worry about it.
-[build]
-rustflags = ["-D", "warnings"]
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,149 +1,146 @@
 name: CI

 on:
-    push:
-        branches:
-            - main
-            - "v[0-9]+.[0-9]+.x"
-        tags:
-            - "v*"
-    pull_request:
-        branches:
-            - "**"
-
-concurrency:
-    # Allow only one workflow per any non-`main` branch.
-    group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.ref_name == 'main' && github.sha || 'anysha' }}
-    cancel-in-progress: true
+  push:
+    branches:
+      - main
+      - "v[0-9]+.[0-9]+.x"
+    tags:
+      - "v*"
+  pull_request:
+    branches:
+      - "**"

 env:
-    CARGO_TERM_COLOR: always
-    CARGO_INCREMENTAL: 0
-    RUST_BACKTRACE: 1
+  CARGO_TERM_COLOR: always
+  CARGO_INCREMENTAL: 0
+  RUST_BACKTRACE: 1

 jobs:
-    rustfmt:
-        name: Check formatting
-        runs-on:
-            - self-hosted
-            - test
-        steps:
-            - name: Checkout repo
-              uses: actions/checkout@v3
-              with:
-                  clean: false
-                  submodules: "recursive"
+  rustfmt:
+    name: Check formatting
+    runs-on:
+      - self-hosted
+      - test
+    steps:
+      - name: Set up default .cargo/config.toml
+        run: printf "[build]\nrustflags = [\"-D\", \"warnings\"]" > $HOME/.cargo/config.toml

-            - name: Set up default .cargo/config.toml
-              run: cp ./.cargo/ci-config.toml ~/.cargo/config.toml
+      - name: Checkout repo
+        uses: actions/checkout@v3
+        with:
+          clean: false
+          submodules: "recursive"

-            - name: Run rustfmt
-              uses: ./.github/actions/check_formatting
+      - name: Run rustfmt
+        uses: ./.github/actions/check_formatting

-    tests:
-        name: Run tests
-        runs-on:
-            - self-hosted
-            - test
-        needs: rustfmt
-        steps:
-            - name: Checkout repo
-              uses: actions/checkout@v3
-              with:
-                  clean: false
-                  submodules: "recursive"
+  tests:
+    name: Run tests
+    runs-on:
+      - self-hosted
+      - test
+    needs: rustfmt
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v3
+        with:
+          clean: false
+          submodules: "recursive"

-            - name: Run tests
-              uses: ./.github/actions/run_tests
+      - name: Run tests
+        uses: ./.github/actions/run_tests

-            - name: Build collab
-              run: cargo build -p collab
+      - name: Build collab
+        run: cargo build -p collab

-            - name: Build other binaries
-              run: cargo build --workspace --bins --all-features
+      - name: Build other binaries
+        run: cargo build --workspace --bins --all-features

-    bundle:
-        name: Bundle app
-        runs-on:
-            - self-hosted
-            - bundle
-        if: ${{ startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-build-dmg') }}
-        needs: tests
+  bundle:
+    name: Bundle app
+    runs-on:
+      - self-hosted
+      - bundle
+    if: ${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-build-dmg') }}
+    needs: tests
+    env:
+      MACOS_CERTIFICATE: ${{ secrets.MACOS_CERTIFICATE }}
+      MACOS_CERTIFICATE_PASSWORD: ${{ secrets.MACOS_CERTIFICATE_PASSWORD }}
+      APPLE_NOTARIZATION_USERNAME: ${{ secrets.APPLE_NOTARIZATION_USERNAME }}
+      APPLE_NOTARIZATION_PASSWORD: ${{ secrets.APPLE_NOTARIZATION_PASSWORD }}
+    steps:
+      - name: Install Rust
+        run: |
+          rustup set profile minimal
+          rustup update stable
+          rustup target add aarch64-apple-darwin
+          rustup target add x86_64-apple-darwin
+          rustup target add wasm32-wasi
+
+      - name: Install Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: "18"
+
+      - name: Checkout repo
+        uses: actions/checkout@v3
+        with:
+          clean: false
+          submodules: "recursive"
+
+      - name: Limit target directory size
+        run: script/clear-target-dir-if-larger-than 100
+
+      - name: Determine version and release channel
+        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
+        run: |
+          set -eu
+
+          version=$(script/get-crate-version zed)
+          channel=$(cat crates/zed/RELEASE_CHANNEL)
+          echo "Publishing version: ${version} on release channel ${channel}"
+          echo "RELEASE_CHANNEL=${channel}" >> $GITHUB_ENV
+
+          expected_tag_name=""
+          case ${channel} in
+            stable)
+              expected_tag_name="v${version}";;
+            preview)
+              expected_tag_name="v${version}-pre";;
+            nightly)
+              expected_tag_name="v${version}-nightly";;
+            *)
+              echo "can't publish a release on channel ${channel}"
+              exit 1;;
+          esac
+          if [[ $GITHUB_REF_NAME != $expected_tag_name ]]; then
+            echo "invalid release tag ${GITHUB_REF_NAME}. expected ${expected_tag_name}"
+            exit 1
+          fi
+
+      - name: Generate license file
+        run: script/generate-licenses
+
+      - name: Create app bundle
+        run: script/bundle
+
+      - name: Upload app bundle to workflow run if main branch or specific label
+        uses: actions/upload-artifact@v3
+        if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-build-dmg') }}
+        with:
+          name: Zed_${{ github.event.pull_request.head.sha || github.sha }}.dmg
+          path: target/release/Zed.dmg
+
+      - uses: softprops/action-gh-release@v1
+        name: Upload app bundle to release
+        # TODO kb seems that zed.dev relies on GitHub releases for release version tracking.
+        # Find alternatives for `nightly` or just go on with more releases?
+        if: ${{ env.RELEASE_CHANNEL == 'preview' || env.RELEASE_CHANNEL == 'stable' }}
+        with:
+          draft: true
+          prerelease: ${{ env.RELEASE_CHANNEL == 'preview' }}
+          files: target/release/Zed.dmg
+          body: ""
        env:
-            MACOS_CERTIFICATE: ${{ secrets.MACOS_CERTIFICATE }}
-            MACOS_CERTIFICATE_PASSWORD: ${{ secrets.MACOS_CERTIFICATE_PASSWORD }}
-            APPLE_NOTARIZATION_USERNAME: ${{ secrets.APPLE_NOTARIZATION_USERNAME }}
-            APPLE_NOTARIZATION_PASSWORD: ${{ secrets.APPLE_NOTARIZATION_PASSWORD }}
-        steps:
-            - name: Install Rust
-              run: |
-                  rustup set profile minimal
-                  rustup update stable
-                  rustup target add aarch64-apple-darwin
-                  rustup target add x86_64-apple-darwin
-                  rustup target add wasm32-wasi
-
-            - name: Install Node
-              uses: actions/setup-node@v3
-              with:
-                  node-version: "18"
-
-            - name: Checkout repo
-              uses: actions/checkout@v3
-              with:
-                  clean: false
-                  submodules: "recursive"
-
-            - name: Limit target directory size
-              run: script/clear-target-dir-if-larger-than 100
-
-            - name: Determine version and release channel
-              if: ${{ startsWith(github.ref, 'refs/tags/v') }}
-              run: |
-                  set -eu
-
-                  version=$(script/get-crate-version zed)
-                  channel=$(cat crates/zed/RELEASE_CHANNEL)
-                  echo "Publishing version: ${version} on release channel ${channel}"
-                  echo "RELEASE_CHANNEL=${channel}" >> $GITHUB_ENV
-
-                  expected_tag_name=""
-                  case ${channel} in
-                    stable)
-                      expected_tag_name="v${version}";;
-                    preview)
-                      expected_tag_name="v${version}-pre";;
-                    nightly)
-                      expected_tag_name="v${version}-nightly";;
-                    *)
-                      echo "can't publish a release on channel ${channel}"
-                      exit 1;;
-                  esac
-                  if [[ $GITHUB_REF_NAME != $expected_tag_name ]]; then
-                    echo "invalid release tag ${GITHUB_REF_NAME}. expected ${expected_tag_name}"
-                    exit 1
-                  fi
-
-            - name: Generate license file
-              run: script/generate-licenses
-
-            - name: Create app bundle
-              run: script/bundle
-
-            - name: Upload app bundle to workflow run if main branch or specific label
-              uses: actions/upload-artifact@v3
-              if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-build-dmg') }}
-              with:
-                  name: Zed_${{ github.event.pull_request.head.sha || github.sha }}.dmg
-                  path: target/release/Zed.dmg
-
-            - uses: softprops/action-gh-release@v1
-              name: Upload app bundle to release
-              if: ${{ env.RELEASE_CHANNEL == 'preview' || env.RELEASE_CHANNEL == 'stable' }}
-              with:
-                  draft: true
-                  prerelease: ${{ env.RELEASE_CHANNEL == 'preview' }}
-                  files: target/release/Zed.dmg
-                  body: ""
-              env:
-                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -1,98 +1,98 @@
 name: Release Nightly

 on:
-    schedule:
-        # Fire every day at 1:00pm and 1:00am
-        - cron: "0 1,13 * * *"
-    push:
-        tags:
-            - "nightly"
+  schedule:
+    # Fire every night at 1:00am
+    - cron: "0 1 * * *"
+  push:
+    tags:
+      - "nightly"

 env:
-    CARGO_TERM_COLOR: always
-    CARGO_INCREMENTAL: 0
-    RUST_BACKTRACE: 1
+  CARGO_TERM_COLOR: always
+  CARGO_INCREMENTAL: 0
+  RUST_BACKTRACE: 1

 jobs:
-    rustfmt:
-        name: Check formatting
-        runs-on:
-            - self-hosted
-            - test
-        steps:
-            - name: Checkout repo
-              uses: actions/checkout@v3
-              with:
-                  clean: false
-                  submodules: "recursive"
+  rustfmt:
+    name: Check formatting
+    runs-on:
+      - self-hosted
+      - test
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v3
+        with:
+          clean: false
+          submodules: "recursive"

-            - name: Run rustfmt
-              uses: ./.github/actions/check_formatting
+      - name: Run rustfmt
+        uses: ./.github/actions/check_formatting

-    tests:
-        name: Run tests
-        runs-on:
-            - self-hosted
-            - test
-        needs: rustfmt
-        steps:
-            - name: Checkout repo
-              uses: actions/checkout@v3
-              with:
-                  clean: false
-                  submodules: "recursive"
+  tests:
+    name: Run tests
+    runs-on:
+      - self-hosted
+      - test
+    needs: rustfmt
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v3
+        with:
+          clean: false
+          submodules: "recursive"

-            - name: Run tests
-              uses: ./.github/actions/run_tests
+      - name: Run tests
+        uses: ./.github/actions/run_tests

-    bundle:
-        name: Bundle app
-        runs-on:
-            - self-hosted
-            - bundle
-        needs: tests
-        env:
-            MACOS_CERTIFICATE: ${{ secrets.MACOS_CERTIFICATE }}
-            MACOS_CERTIFICATE_PASSWORD: ${{ secrets.MACOS_CERTIFICATE_PASSWORD }}
-            APPLE_NOTARIZATION_USERNAME: ${{ secrets.APPLE_NOTARIZATION_USERNAME }}
-            APPLE_NOTARIZATION_PASSWORD: ${{ secrets.APPLE_NOTARIZATION_PASSWORD }}
-            DIGITALOCEAN_SPACES_ACCESS_KEY: ${{ secrets.DIGITALOCEAN_SPACES_ACCESS_KEY }}
-            DIGITALOCEAN_SPACES_SECRET_KEY: ${{ secrets.DIGITALOCEAN_SPACES_SECRET_KEY }}
-        steps:
-            - name: Install Rust
-              run: |
-                  rustup set profile minimal
-                  rustup update stable
-                  rustup target add aarch64-apple-darwin
-                  rustup target add x86_64-apple-darwin
-                  rustup target add wasm32-wasi
+  bundle:
+    name: Bundle app
+    runs-on:
+      - self-hosted
+      - bundle
+    needs: tests
+    env:
+      MACOS_CERTIFICATE: ${{ secrets.MACOS_CERTIFICATE }}
+      MACOS_CERTIFICATE_PASSWORD: ${{ secrets.MACOS_CERTIFICATE_PASSWORD }}
+      APPLE_NOTARIZATION_USERNAME: ${{ secrets.APPLE_NOTARIZATION_USERNAME }}
+      APPLE_NOTARIZATION_PASSWORD: ${{ secrets.APPLE_NOTARIZATION_PASSWORD }}
+      DIGITALOCEAN_SPACES_ACCESS_KEY: ${{ secrets.DIGITALOCEAN_SPACES_ACCESS_KEY }}
+      DIGITALOCEAN_SPACES_SECRET_KEY: ${{ secrets.DIGITALOCEAN_SPACES_SECRET_KEY }}
+    steps:
+      - name: Install Rust
+        run: |
+          rustup set profile minimal
+          rustup update stable
+          rustup target add aarch64-apple-darwin
+          rustup target add x86_64-apple-darwin
+          rustup target add wasm32-wasi

-            - name: Install Node
-              uses: actions/setup-node@v3
-              with:
-                  node-version: "18"
+      - name: Install Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: "18"

-            - name: Checkout repo
-              uses: actions/checkout@v3
-              with:
-                  clean: false
-                  submodules: "recursive"
+      - name: Checkout repo
+        uses: actions/checkout@v3
+        with:
+          clean: false
+          submodules: "recursive"

-            - name: Limit target directory size
-              run: script/clear-target-dir-if-larger-than 100
+      - name: Limit target directory size
+        run: script/clear-target-dir-if-larger-than 100

-            - name: Set release channel to nightly
-              run: |
-                  set -eu
-                  version=$(git rev-parse --short HEAD)
-                  echo "Publishing version: ${version} on release channel nightly"
-                  echo "nightly" > crates/zed/RELEASE_CHANNEL
+      - name: Set release channel to nightly
+        run: |
+          set -eu
+          version=$(git rev-parse --short HEAD)
+          echo "Publishing version: ${version} on release channel nightly"
+          echo "nightly" > crates/zed/RELEASE_CHANNEL

-            - name: Generate license file
-              run: script/generate-licenses
+      - name: Generate license file
+        run: script/generate-licenses

-            - name: Create app bundle
-              run: script/bundle -2
+      - name: Create app bundle
+        run: script/bundle -2

-            - name: Upload Zed Nightly
-              run: script/upload-nightly
+      - name: Upload Zed Nightly
+        run: script/upload-nightly
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,16 +1,13 @@
 [workspace]
 members = [
    "crates/activity_indicator",
-    "crates/activity_indicator2",
    "crates/ai",
    "crates/assistant",
-    "crates/assistant2",
    "crates/audio",
    "crates/audio2",
    "crates/auto_update",
    "crates/auto_update2",
    "crates/breadcrumbs",
-    "crates/breadcrumbs2",
    "crates/call",
    "crates/call2",
    "crates/channel",
@@ -62,7 +59,6 @@ members = [
    "crates/language",
    "crates/language2",
    "crates/language_selector",
-    "crates/language_selector2",
    "crates/language_tools",
    "crates/live_kit_client",
    "crates/live_kit_server",
@@ -77,7 +73,6 @@ members = [
    "crates/notifications",
    "crates/notifications2",
    "crates/outline",
-    "crates/outline2",
    "crates/picker",
    "crates/picker2",
    "crates/plugin",
@@ -90,17 +85,12 @@ members = [
    "crates/project_panel",
    "crates/project_panel2",
    "crates/project_symbols",
-    "crates/project_symbols2",
-    "crates/quick_action_bar2",
    "crates/recent_projects",
-    "crates/recent_projects2",
    "crates/rope",
    "crates/rpc",
    "crates/rpc2",
    "crates/search",
    "crates/search2",
-    "crates/semantic_index",
-    "crates/semantic_index2",
    "crates/settings",
    "crates/settings2",
    "crates/snippet",
@@ -117,16 +107,14 @@ members = [
    "crates/theme2",
    "crates/theme_importer",
    "crates/theme_selector",
-    "crates/theme_selector2",
    "crates/ui2",
    "crates/util",
+    "crates/semantic_index",
    "crates/story",
    "crates/vim",
    "crates/vcs_menu",
-    "crates/vcs_menu2",
    "crates/workspace2",
    "crates/welcome",
-    "crates/welcome2",
    "crates/xtask",
    "crates/zed",
    "crates/zed2",
@@ -139,7 +127,6 @@ resolver = "2"
 [workspace.dependencies]
 anyhow = { version = "1.0.57" }
 async-trait = { version = "0.1" }
-async-compression = { version = "0.4", features = ["gzip", "futures-io"] }
 # TODO: Switch back to the published version of `ctor` once:
 #       1. A new version of `ctor` is published with this change: https://github.com/mmastrac/rust-ctor/pull/295
 #       2. We've confirmed it's fine to update to the latest version of `ctor` (we're currently on v0.1.20).
@@ -207,11 +194,9 @@ tree-sitter-yaml = { git = "https://github.com/zed-industries/tree-sitter-yaml",
 tree-sitter-lua = "0.0.14"
 tree-sitter-nix = { git = "https://github.com/nix-community/tree-sitter-nix", rev = "66e3e9ce9180ae08fc57372061006ef83f0abde7" }
 tree-sitter-nu = { git = "https://github.com/nushell/tree-sitter-nu", rev = "786689b0562b9799ce53e824cb45a1a2a04dc673"}
-tree-sitter-vue = {git = "https://github.com/zed-industries/tree-sitter-vue", rev = "6608d9d60c386f19d80af7d8132322fa11199c42"}
-tree-sitter-uiua = {git = "https://github.com/shnarazk/tree-sitter-uiua", rev = "9260f11be5900beda4ee6d1a24ab8ddfaf5a19b2"}
-
+tree-sitter-vue = {git = "https://github.com/zed-industries/tree-sitter-vue", rev = "9b6cb221ccb8d0b956fcb17e9a1efac2feefeb58"}
 [patch.crates-io]
-tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "b5f461a69bf3df7298b1903574d506179e6390b0" }
+tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "35a6052fbcafc5e5fc0f9415b8652be7dcaf7222" }
 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
@@ -223,12 +208,11 @@ core-graphics = { git = "https://github.com/servo/core-foundation-rs", rev = "07

 [profile.dev]
 split-debuginfo = "unpacked"
-debug = "limited"

 [profile.dev.package.taffy]
 opt-level = 3

 [profile.release]
-debug = "limited"
+debug = true
 lto = "thin"
 codegen-units = 1
--- a/Procfile.zed2
+++ b/Procfile.zed2
@@ -1,4 +0,0 @@
-web: cd ../zed.dev && PORT=3000 npm run dev
-collab: cd crates/collab2 && RUST_LOG=${RUST_LOG:-warn,collab=info} cargo run serve
-livekit: livekit-server --dev
-postgrest: postgrest crates/collab2/admin_api.conf
--- a/assets/icons/arrow_down.svg
+++ b/assets/icons/arrow_down.svg
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M8.00001 12L3.5 7.50001M8.00001 12L12.5 7.50001M8.00001 12L8.00001 3.00001" stroke="black" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
-</svg>
--- a/assets/icons/arrow_left.svg
+++ b/assets/icons/arrow_left.svg
@@ -1,3 +1,3 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M3.5 7.50001L8 3M3.5 7.50001L8 12M3.5 7.50001H12.5" stroke="black" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M3.125 6.99344L6.35938 3.63281M3.125 6.99344L6.35938 10.3672M3.125 6.99344H11" stroke="black" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
 </svg>
--- a/assets/icons/arrow_right.svg
+++ b/assets/icons/arrow_right.svg
@@ -1,3 +1,3 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M12.5 7.5L8 12M12.5 7.5L8 3M12.5 7.5L3.5 7.5" stroke="black" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M10.8906 7.00125L7.64062 3.64062M10.8906 7.00125L7.64062 10.375M10.8906 7.00125H3" stroke="black" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
 </svg>
--- a/assets/icons/arrow_up.svg
+++ b/assets/icons/arrow_up.svg
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M7.99999 3.00001L12.5 7.50001M7.99999 3.00001L3.49999 7.50001M7.99999 3.00001L7.99999 12" stroke="black" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
-</svg>
--- a/assets/icons/command.svg
+++ b/assets/icons/command.svg
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M11 3.625C11 2.86561 11.6156 2.25 12.375 2.25C13.1344 2.25 13.75 2.86561 13.75 3.625C13.75 4.38401 13.135 4.99939 12.3761 5C12.3758 5 12.3754 5 12.375 5H11V3.625ZM9.75 5V3.625C9.75 2.17525 10.9253 1 12.375 1C13.8247 1 15 2.17525 15 3.625C15 4.98872 13.9601 6.10955 12.63 6.23777V6.25H12.3766C12.376 6.25 12.3755 6.25 12.375 6.25H11V9.75H12.375C13.8247 9.75 15 10.9253 15 12.375C15 13.8247 13.8247 15 12.375 15C11.0113 15 9.89045 13.9601 9.76223 12.63H9.75V12.3773L9.75 12.375V11H6.25V12.375C6.25 13.8247 5.07475 15 3.625 15C2.17525 15 1 13.8247 1 12.375C1 11.0113 2.03991 9.89045 3.37 9.76223V9.75H3.62274L3.625 9.75H5L5 6.25H3.625C2.17525 6.25 1 5.07475 1 3.625C1 2.17525 2.17525 1 3.625 1C4.98872 1 6.10955 2.03991 6.23777 3.37H6.25L6.25 5L9.75 5ZM9.75 6.25L6.25 6.25L6.25 9.75H9.75V6.25ZM3.625 11H5V12.375C5 13.1344 4.38439 13.75 3.625 13.75C2.86561 13.75 2.25 13.1344 2.25 12.375C2.25 11.6162 2.86472 11.0009 3.62336 11L3.625 11ZM11 12.3766C11.0009 13.1353 11.6162 13.75 12.375 13.75C13.1344 13.75 13.75 13.1344 13.75 12.375C13.75 11.6156 13.1344 11 12.375 11H11V12.375L11 12.3766ZM3.625 5C2.86561 5 2.25 4.38439 2.25 3.625C2.25 2.86561 2.86561 2.25 3.625 2.25C4.38439 2.25 5 2.86561 5 3.625V5H3.625Z" fill="black"/>
-</svg>
--- a/assets/icons/control.svg
+++ b/assets/icons/control.svg
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M3.5 6.12488L7.64656 1.97853C7.84183 1.78328 8.1584 1.78329 8.35366 1.97854L12.5 6.12488" stroke="black" stroke-width="1.25" stroke-linecap="round"/>
-</svg>
--- a/assets/icons/copy.svg
+++ b/assets/icons/copy.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-copy"><rect width="14" height="14" x="8" y="8" rx="2" ry="2"/><path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"/></svg>
--- a/assets/icons/github.svg
+++ b/assets/icons/github.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-github"><path d="M15 22v-4a4.8 4.8 0 0 0-1-3.5c3 0 6-2 6-5.5.08-1.25-.27-2.48-1-3.5.28-1.15.28-2.35 0-3.5 0 0-1 0-3 1.5-2.64-.5-5.36-.5-8 0C6 2 5 2 5 2c-.3 1.15-.3 2.35 0 3.5A5.403 5.403 0 0 0 4 9c0 3.5 3 5.5 6 5.5-.39.49-.68 1.05-.85 1.65-.17.6-.22 1.23-.15 1.85v4"/><path d="M9 18c-4.51 2-5-2-7-2"/></svg>
--- a/assets/icons/maximize.svg
+++ b/assets/icons/maximize.svg
@@ -1 +1,4 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-maximize-2"><polyline points="15 3 21 3 21 9"/><polyline points="9 21 3 21 3 15"/><line x1="21" x2="14" y1="3" y2="10"/><line x1="3" x2="10" y1="21" y2="14"/></svg>
+<svg width="15" height="15" viewBox="0 0 15 15" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M9.5 1.5H13.5M13.5 1.5V5.5M13.5 1.5C12.1332 2.86683 10.3668 4.63317 9 6" stroke="white" stroke-linecap="round"/>
+<path d="M1.5 9.5V13.5M1.5 13.5L6 9M1.5 13.5H5.5" stroke="white" stroke-linecap="round"/>
+</svg>
--- a/assets/icons/menu.svg
+++ b/assets/icons/menu.svg
@@ -1 +1,3 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-menu"><line x1="4" x2="20" y1="12" y2="12"/><line x1="4" x2="20" y1="6" y2="6"/><line x1="4" x2="20" y1="18" y2="18"/></svg>
+<svg width="15" height="15" viewBox="0 0 15 15" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 3C1.22386 3 1 3.22386 1 3.5C1 3.77614 1.22386 4 1.5 4H13.5C13.7761 4 14 3.77614 14 3.5C14 3.22386 13.7761 3 13.5 3H1.5ZM1 7.5C1 7.22386 1.22386 7 1.5 7H13.5C13.7761 7 14 7.22386 14 7.5C14 7.77614 13.7761 8 13.5 8H1.5C1.22386 8 1 7.77614 1 7.5ZM1 11.5C1 11.2239 1.22386 11 1.5 11H13.5C13.7761 11 14 11.2239 14 11.5C14 11.7761 13.7761 12 13.5 12H1.5C1.22386 12 1 11.7761 1 11.5Z" fill="#CCCAC2"/>
+</svg>
--- a/assets/icons/minimize.svg
+++ b/assets/icons/minimize.svg
@@ -1 +1,4 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-minimize-2"><polyline points="4 14 10 14 10 20"/><polyline points="20 10 14 10 14 4"/><line x1="14" x2="21" y1="10" y2="3"/><line x1="3" x2="10" y1="21" y2="14"/></svg>
+<svg width="15" height="15" viewBox="0 0 15 15" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M13 6L9 6M9 6L9 2M9 6C10.3668 4.63316 12.1332 2.86683 13.5 1.5" stroke="white" stroke-linecap="round"/>
+<path d="M6 13L6 9M6 9L1.5 13.5M6 9L2 9" stroke="white" stroke-linecap="round"/>
+</svg>
--- a/assets/icons/option.svg
+++ b/assets/icons/option.svg
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M5.35606 1.005H1.62545C1.28002 1.005 1 1.28502 1 1.63044C1 1.97587 1.28002 2.25589 1.62545 2.25589L5.35606 2.25589C5.62311 2.25589 5.8607 2.42545 5.94752 2.67799L9.75029 13.7387C10.0108 14.4963 10.7235 15.005 11.5247 15.005H14.3746C14.72 15.005 15 14.725 15 14.3796C15 14.0341 14.72 13.7541 14.3746 13.7541H11.5247C11.2576 13.7541 11.02 13.5845 10.9332 13.332L7.13046 2.27128C6.86998 1.51366 6.15721 1.005 5.35606 1.005ZM14.3745 1.005H9.75125C9.40582 1.005 9.1258 1.28502 9.1258 1.63044C9.1258 1.97587 9.40582 2.25589 9.75125 2.25589L14.3745 2.25589C14.72 2.25589 15 1.97587 15 1.63044C15 1.28502 14.72 1.005 14.3745 1.005Z" fill="black"/>
-</svg>
--- a/assets/icons/quote.svg
+++ b/assets/icons/quote.svg
@@ -1 +1,8 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-text-quote"><path d="M17 6H3"/><path d="M21 12H8"/><path d="M21 18H8"/><path d="M3 12v6"/></svg>
+<svg width="15" height="15" viewBox="0 0 15 15" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    fill-rule="evenodd"
+    clip-rule="evenodd"
+    d="M9.42503 3.44136C10.0561 3.23654 10.7837 3.2402 11.3792 3.54623C12.7532 4.25224 13.3477 6.07191 12.7946 8C12.5465 8.8649 12.1102 9.70472 11.1861 10.5524C10.262 11.4 8.98034 11.9 8.38571 11.9C8.17269 11.9 8 11.7321 8 11.525C8 11.3179 8.17644 11.15 8.38571 11.15C9.06497 11.15 9.67189 10.7804 10.3906 10.236C10.9406 9.8193 11.3701 9.28633 11.608 8.82191C12.0628 7.93367 12.0782 6.68174 11.3433 6.34901C10.9904 6.73455 10.5295 6.95946 9.97725 6.95946C8.7773 6.95946 8.0701 5.99412 8.10051 5.12009C8.12957 4.28474 8.66032 3.68954 9.42503 3.44136ZM3.42503 3.44136C4.05614 3.23654 4.78366 3.2402 5.37923 3.54623C6.7532 4.25224 7.34766 6.07191 6.79462 8C6.54654 8.8649 6.11019 9.70472 5.1861 10.5524C4.26201 11.4 2.98034 11.9 2.38571 11.9C2.17269 11.9 2 11.7321 2 11.525C2 11.3179 2.17644 11.15 2.38571 11.15C3.06497 11.15 3.67189 10.7804 4.39058 10.236C4.94065 9.8193 5.37014 9.28633 5.60797 8.82191C6.06282 7.93367 6.07821 6.68174 5.3433 6.34901C4.99037 6.73455 4.52948 6.95946 3.97725 6.95946C2.7773 6.95946 2.0701 5.99412 2.10051 5.12009C2.12957 4.28474 2.66032 3.68954 3.42503 3.44136Z"
+    fill="currentColor"
+  />
+</svg>
--- a/assets/icons/return.svg
+++ b/assets/icons/return.svg
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M8.375 1.63C8.375 1.28482 8.65482 1.005 9 1.005H12.375C13.8247 1.005 15 2.18025 15 3.63V7.625C15 9.07474 13.8247 10.25 12.375 10.25H3.13388L6.07194 13.1881C6.31602 13.4321 6.31602 13.8279 6.07194 14.0719C5.82786 14.316 5.43214 14.316 5.18806 14.0719L1.18306 10.0669C0.938981 9.82286 0.938981 9.42714 1.18306 9.18306L5.18306 5.18306C5.42714 4.93898 5.82286 4.93898 6.06694 5.18306C6.31102 5.42714 6.31102 5.82286 6.06694 6.06694L3.13388 9H12.375C13.1344 9 13.75 8.38439 13.75 7.625V3.63C13.75 2.87061 13.1344 2.255 12.375 2.255H9C8.65482 2.255 8.375 1.97518 8.375 1.63Z" fill="black"/>
-</svg>
--- a/assets/icons/shift.svg
+++ b/assets/icons/shift.svg
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M2.46475 7.99652L7.85304 2.15921C7.93223 2.07342 8.06777 2.07341 8.14696 2.15921L13.5352 7.99652C13.7126 8.18869 13.5763 8.5 13.3148 8.5H10.5V13.7C10.5 13.8657 10.3657 14 10.2 14H5.8C5.63431 14 5.5 13.8657 5.5 13.7V8.5H2.6852C2.42367 8.5 2.28737 8.18869 2.46475 7.99652Z" stroke="black" stroke-width="1.25"/>
-</svg>
--- a/assets/icons/snip.svg
+++ b/assets/icons/snip.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-scissors"><circle cx="6" cy="6" r="3"/><path d="M8.12 8.12 12 12"/><path d="M20 4 8.12 15.88"/><circle cx="6" cy="18" r="3"/><path d="M14.8 14.8 20 20"/></svg>
--- a/assets/icons/split_message.svg
+++ b/assets/icons/split_message.svg
@@ -0,0 +1 @@
+<svg width="15" height="15" viewBox="0 0 15 15" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M7.81832 0.68179C7.64258 0.506054 7.35766 0.506054 7.18192 0.68179L5.18192 2.68179C5.00619 2.85753 5.00619 3.14245 5.18192 3.31819C5.35766 3.49392 5.64258 3.49392 5.81832 3.31819L7.05012 2.08638L7.05012 5.50023C7.05012 5.74876 7.25159 5.95023 7.50012 5.95023C7.74865 5.95023 7.95012 5.74876 7.95012 5.50023L7.95012 2.08638L9.18192 3.31819C9.35766 3.49392 9.64258 3.49392 9.81832 3.31819C9.99406 3.14245 9.99406 2.85753 9.81832 2.68179L7.81832 0.68179ZM7.95012 12.9136V9.50023C7.95012 9.2517 7.74865 9.05023 7.50012 9.05023C7.25159 9.05023 7.05012 9.2517 7.05012 9.50023V12.9136L5.81832 11.6818C5.64258 11.5061 5.35766 11.5061 5.18192 11.6818C5.00619 11.8575 5.00619 12.1424 5.18192 12.3182L7.18192 14.3182C7.26632 14.4026 7.38077 14.45 7.50012 14.45C7.61947 14.45 7.73393 14.4026 7.81832 14.3182L9.81832 12.3182C9.99406 12.1424 9.99406 11.8575 9.81832 11.6818C9.64258 11.5061 9.35766 11.5061 9.18192 11.6818L7.95012 12.9136ZM1.49994 7.00017C1.2238 7.00017 0.999939 7.22403 0.999939 7.50017C0.999939 7.77631 1.2238 8.00017 1.49994 8.00017L13.4999 8.00017C13.7761 8.00017 13.9999 7.77631 13.9999 7.50017C13.9999 7.22403 13.7761 7.00017 13.4999 7.00017L1.49994 7.00017Z" fill="currentColor" fill-rule="evenodd" clip-rule="evenodd"></path></svg>
--- a/assets/keymaps/default.json
+++ b/assets/keymaps/default.json
@@ -17,9 +17,18 @@
      "cmd-enter": "menu::SecondaryConfirm",
      "escape": "menu::Cancel",
      "ctrl-c": "menu::Cancel",
+      "cmd-{": "pane::ActivatePrevItem",
+      "cmd-}": "pane::ActivateNextItem",
+      "alt-cmd-left": "pane::ActivatePrevItem",
+      "alt-cmd-right": "pane::ActivateNextItem",
+      "cmd-w": "pane::CloseActiveItem",
+      "alt-cmd-t": "pane::CloseInactiveItems",
+      "ctrl-alt-cmd-w": "workspace::CloseInactiveTabsAndPanes",
+      "cmd-k u": "pane::CloseCleanItems",
+      "cmd-k cmd-w": "pane::CloseAllItems",
      "cmd-shift-w": "workspace::CloseWindow",
-      "shift-escape": "workspace::ToggleZoom",
-      "cmd-o": "workspace::Open",
+      "cmd-s": "workspace::Save",
+      "cmd-shift-s": "workspace::SaveAs",
      "cmd-=": "zed::IncreaseBufferFontSize",
      "cmd-+": "zed::IncreaseBufferFontSize",
      "cmd--": "zed::DecreaseBufferFontSize",
@@ -29,7 +38,15 @@
      "cmd-h": "zed::Hide",
      "alt-cmd-h": "zed::HideOthers",
      "cmd-m": "zed::Minimize",
-      "ctrl-cmd-f": "zed::ToggleFullScreen"
+      "ctrl-cmd-f": "zed::ToggleFullScreen",
+      "cmd-n": "workspace::NewFile",
+      "cmd-shift-n": "workspace::NewWindow",
+      "cmd-o": "workspace::Open",
+      "alt-cmd-o": "projects::OpenRecent",
+      "alt-cmd-b": "branches::OpenRecent",
+      "ctrl-~": "workspace::NewTerminal",
+      "ctrl-`": "terminal_panel::ToggleFocus",
+      "shift-escape": "workspace::ToggleZoom"
    }
  },
  {
@@ -267,15 +284,6 @@
  {
    "context": "Pane",
    "bindings": {
-      "cmd-{": "pane::ActivatePrevItem",
-      "cmd-}": "pane::ActivateNextItem",
-      "alt-cmd-left": "pane::ActivatePrevItem",
-      "alt-cmd-right": "pane::ActivateNextItem",
-      "cmd-w": "pane::CloseActiveItem",
-      "alt-cmd-t": "pane::CloseInactiveItems",
-      "ctrl-alt-cmd-w": "workspace::CloseInactiveTabsAndPanes",
-      "cmd-k u": "pane::CloseCleanItems",
-      "cmd-k cmd-w": "pane::CloseAllItems",
      "cmd-f": "project_search::ToggleFocus",
      "cmd-g": "search::SelectNextMatch",
      "cmd-shift-g": "search::SelectPrevMatch",
@@ -381,14 +389,6 @@
  {
    "context": "Workspace",
    "bindings": {
-      "alt-cmd-o": "projects::OpenRecent",
-      "alt-cmd-b": "branches::OpenRecent",
-      "ctrl-~": "workspace::NewTerminal",
-      "cmd-s": "workspace::Save",
-      "cmd-shift-s": "workspace::SaveAs",
-      "cmd-n": "workspace::NewFile",
-      "cmd-shift-n": "workspace::NewWindow",
-      "ctrl-`": "terminal_panel::ToggleFocus",
      "cmd-1": ["workspace::ActivatePane", 0],
      "cmd-2": ["workspace::ActivatePane", 1],
      "cmd-3": ["workspace::ActivatePane", 2],
@@ -530,17 +530,12 @@
      "alt-cmd-shift-c": "project_panel::CopyRelativePath",
      "f2": "project_panel::Rename",
      "enter": "project_panel::Rename",
+      "space": "project_panel::Open",
      "backspace": "project_panel::Delete",
      "alt-cmd-r": "project_panel::RevealInFinder",
      "alt-shift-f": "project_panel::NewSearchInDirectory"
    }
  },
-  {
-    "context": "ProjectPanel && not_editing",
-    "bindings": {
-      "space": "project_panel::Open"
-    }
-  },
  {
    "context": "CollabPanel && not_editing",
    "bindings": {
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -143,11 +143,7 @@
    // Whether to show the git status in the project panel.
    "git_status": true,
    // Amount of indentation for nested items.
-    "indent_size": 20,
-    // Whether to reveal it in the project panel automatically,
-    // when a corresponding project entry becomes active.
-    // Gitignored entries are never auto revealed.
-    "auto_reveal_entries": true
+    "indent_size": 20
  },
  "collaboration_panel": {
    // Whether to show the collaboration panel button in the status bar.
--- a/assets/themes/src/vscode/palenight/palenight-mild-contrast.json
+++ b/assets/themes/src/vscode/palenight/palenight-mild-contrast.json
--- a/assets/themes/src/vscode/palenight/palenight-operator.json
+++ b/assets/themes/src/vscode/palenight/palenight-operator.json
--- a/assets/themes/src/vscode/palenight/palenight.json
+++ b/assets/themes/src/vscode/palenight/palenight.json
--- a/assets/themes/src/vscode/rose-pine/family.json
+++ b/assets/themes/src/vscode/rose-pine/family.json
@@ -17,8 +17,5 @@
      "file_name": "rose-pine-dawn.json",
      "appearance": "light"
    }
-  ],
-  "syntax": {
-    "function": ["entity.name"]
-  }
+  ]
 }
--- a/assets/themes/src/vscode/rose-pine/rose-pine-dawn.json
+++ b/assets/themes/src/vscode/rose-pine/rose-pine-dawn.json
--- a/assets/themes/src/vscode/rose-pine/rose-pine-moon.json
+++ b/assets/themes/src/vscode/rose-pine/rose-pine-moon.json
--- a/assets/themes/src/vscode/rose-pine/rose-pine.json
+++ b/assets/themes/src/vscode/rose-pine/rose-pine.json
--- a/crates/activity_indicator2/Cargo.toml
+++ b/crates/activity_indicator2/Cargo.toml
@@ -1,28 +0,0 @@
-[package]
-name = "activity_indicator2"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[lib]
-path = "src/activity_indicator.rs"
-doctest = false
-
-[dependencies]
-auto_update = { path = "../auto_update2", package = "auto_update2" }
-editor = { path = "../editor2", package = "editor2" }
-language = { path = "../language2", package = "language2" }
-gpui = { path = "../gpui2", package = "gpui2" }
-project = { path = "../project2", package = "project2" }
-settings = { path = "../settings2", package = "settings2" }
-ui = { path = "../ui2", package = "ui2" }
-util = { path = "../util" }
-theme = { path = "../theme2", package = "theme2" }
-workspace = { path = "../workspace2", package = "workspace2" }
-
-anyhow.workspace = true
-futures.workspace = true
-smallvec.workspace = true
-
-[dev-dependencies]
-editor = { path = "../editor2", package = "editor2", features = ["test-support"] }
--- a/crates/activity_indicator2/src/activity_indicator.rs
+++ b/crates/activity_indicator2/src/activity_indicator.rs
@@ -1,333 +0,0 @@
-use auto_update::{AutoUpdateStatus, AutoUpdater, DismissErrorMessage};
-use editor::Editor;
-use futures::StreamExt;
-use gpui::{
-    actions, svg, AppContext, CursorStyle, Div, EventEmitter, InteractiveElement as _, Model,
-    ParentElement as _, Render, SharedString, Stateful, StatefulInteractiveElement, Styled, View,
-    ViewContext, VisualContext as _,
-};
-use language::{LanguageRegistry, LanguageServerBinaryStatus};
-use project::{LanguageServerProgress, Project};
-use smallvec::SmallVec;
-use std::{cmp::Reverse, fmt::Write, sync::Arc};
-use ui::h_stack;
-use util::ResultExt;
-use workspace::{item::ItemHandle, StatusItemView, Workspace};
-
-actions!(activity_indicator, [ShowErrorMessage]);
-
-const DOWNLOAD_ICON: &str = "icons/download.svg";
-const WARNING_ICON: &str = "icons/warning.svg";
-
-pub enum Event {
-    ShowError { lsp_name: Arc<str>, error: String },
-}
-
-pub struct ActivityIndicator {
-    statuses: Vec<LspStatus>,
-    project: Model<Project>,
-    auto_updater: Option<Model<AutoUpdater>>,
-}
-
-struct LspStatus {
-    name: Arc<str>,
-    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,
-    on_click: Option<Arc<dyn Fn(&mut ActivityIndicator, &mut ViewContext<ActivityIndicator>)>>,
-}
-
-impl ActivityIndicator {
-    pub fn new(
-        workspace: &mut Workspace,
-        languages: Arc<LanguageRegistry>,
-        cx: &mut ViewContext<Workspace>,
-    ) -> View<ActivityIndicator> {
-        let project = workspace.project().clone();
-        let auto_updater = AutoUpdater::get(cx);
-        let this = cx.build_view(|cx: &mut ViewContext<Self>| {
-            let mut status_events = languages.language_server_binary_statuses();
-            cx.spawn(|this, mut cx| async move {
-                while let Some((language, event)) = status_events.next().await {
-                    this.update(&mut cx, |this, cx| {
-                        this.statuses.retain(|s| s.name != language.name());
-                        this.statuses.push(LspStatus {
-                            name: language.name(),
-                            status: event,
-                        });
-                        cx.notify();
-                    })?;
-                }
-                anyhow::Ok(())
-            })
-            .detach();
-            cx.observe(&project, |_, _, cx| cx.notify()).detach();
-
-            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(),
-                project: project.clone(),
-                auto_updater,
-            }
-        });
-
-        cx.subscribe(&this, move |workspace, _, event, cx| match event {
-            Event::ShowError { lsp_name, error } => {
-                if let Some(buffer) = project
-                    .update(cx, |project, cx| project.create_buffer(error, None, cx))
-                    .log_err()
-                {
-                    buffer.update(cx, |buffer, cx| {
-                        buffer.edit(
-                            [(0..0, format!("Language server error: {}\n\n", lsp_name))],
-                            None,
-                            cx,
-                        );
-                    });
-                    workspace.add_item(
-                        Box::new(cx.build_view(|cx| {
-                            Editor::for_buffer(buffer, Some(project.clone()), cx)
-                        })),
-                        cx,
-                    );
-                }
-            }
-        })
-        .detach();
-        this
-    }
-
-    fn show_error_message(&mut self, _: &ShowErrorMessage, cx: &mut ViewContext<Self>) {
-        self.statuses.retain(|status| {
-            if let LanguageServerBinaryStatus::Failed { error } = &status.status {
-                cx.emit(Event::ShowError {
-                    lsp_name: status.name.clone(),
-                    error: error.clone(),
-                });
-                false
-            } else {
-                true
-            }
-        });
-
-        cx.notify();
-    }
-
-    fn dismiss_error_message(&mut self, _: &DismissErrorMessage, cx: &mut ViewContext<Self>) {
-        if let Some(updater) = &self.auto_updater {
-            updater.update(cx, |updater, cx| {
-                updater.dismiss_error(cx);
-            });
-        }
-        cx.notify();
-    }
-
-    fn pending_language_server_work<'a>(
-        &self,
-        cx: &'a AppContext,
-    ) -> impl Iterator<Item = PendingWork<'a>> {
-        self.project
-            .read(cx)
-            .language_server_statuses()
-            .rev()
-            .filter_map(|status| {
-                if status.pending_work.is_empty() {
-                    None
-                } else {
-                    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,
-                        })
-                        .collect::<SmallVec<[_; 4]>>();
-                    pending_work.sort_by_key(|work| Reverse(work.progress.last_update_at));
-                    Some(pending_work)
-                }
-            })
-            .flatten()
-    }
-
-    fn content_to_render(&mut self, cx: &mut ViewContext<Self>) -> Content {
-        // 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();
-
-            message.push_str(": ");
-            if let Some(progress_message) = progress.message.as_ref() {
-                message.push_str(progress_message);
-            } else {
-                message.push_str(progress_token);
-            }
-
-            if let Some(percentage) = progress.percentage {
-                write!(&mut message, " ({}%)", percentage).unwrap();
-            }
-
-            let additional_work_count = pending_work.count();
-            if additional_work_count > 0 {
-                write!(&mut message, " + {} more", additional_work_count).unwrap();
-            }
-
-            return Content {
-                icon: None,
-                message,
-                on_click: None,
-            };
-        }
-
-        // Show any language server installation info.
-        let mut downloading = SmallVec::<[_; 3]>::new();
-        let mut checking_for_update = SmallVec::<[_; 3]>::new();
-        let mut failed = SmallVec::<[_; 3]>::new();
-        for status in &self.statuses {
-            let name = status.name.clone();
-            match status.status {
-                LanguageServerBinaryStatus::CheckingForUpdate => checking_for_update.push(name),
-                LanguageServerBinaryStatus::Downloading => downloading.push(name),
-                LanguageServerBinaryStatus::Failed { .. } => failed.push(name),
-                LanguageServerBinaryStatus::Downloaded | LanguageServerBinaryStatus::Cached => {}
-            }
-        }
-
-        if !downloading.is_empty() {
-            return Content {
-                icon: Some(DOWNLOAD_ICON),
-                message: format!(
-                    "Downloading {} language server{}...",
-                    downloading.join(", "),
-                    if downloading.len() > 1 { "s" } else { "" }
-                ),
-                on_click: None,
-            };
-        } else if !checking_for_update.is_empty() {
-            return Content {
-                icon: Some(DOWNLOAD_ICON),
-                message: format!(
-                    "Checking for updates to {} language server{}...",
-                    checking_for_update.join(", "),
-                    if checking_for_update.len() > 1 {
-                        "s"
-                    } else {
-                        ""
-                    }
-                ),
-                on_click: None,
-            };
-        } else if !failed.is_empty() {
-            return Content {
-                icon: Some(WARNING_ICON),
-                message: format!(
-                    "Failed to download {} language server{}. Click to show error.",
-                    failed.join(", "),
-                    if failed.len() > 1 { "s" } else { "" }
-                ),
-                on_click: Some(Arc::new(|this, cx| {
-                    this.show_error_message(&Default::default(), cx)
-                })),
-            };
-        }
-
-        // 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(),
-                    on_click: None,
-                },
-                AutoUpdateStatus::Downloading => Content {
-                    icon: Some(DOWNLOAD_ICON),
-                    message: "Downloading Zed update…".to_string(),
-                    on_click: None,
-                },
-                AutoUpdateStatus::Installing => Content {
-                    icon: Some(DOWNLOAD_ICON),
-                    message: "Installing Zed update…".to_string(),
-                    on_click: None,
-                },
-                AutoUpdateStatus::Updated => Content {
-                    icon: None,
-                    message: "Click to restart and update Zed".to_string(),
-                    on_click: Some(Arc::new(|_, cx| {
-                        workspace::restart(&Default::default(), cx)
-                    })),
-                },
-                AutoUpdateStatus::Errored => Content {
-                    icon: Some(WARNING_ICON),
-                    message: "Auto update failed".to_string(),
-                    on_click: Some(Arc::new(|this, cx| {
-                        this.dismiss_error_message(&Default::default(), cx)
-                    })),
-                },
-                AutoUpdateStatus::Idle => Default::default(),
-            };
-        }
-
-        // todo!(show active tasks)
-        // if let Some(most_recent_active_task) = cx.active_labeled_tasks().last() {
-        //     return Content {
-        //         icon: None,
-        //         message: most_recent_active_task.to_string(),
-        //         on_click: None,
-        //     };
-        // }
-
-        Default::default()
-    }
-}
-
-impl EventEmitter<Event> for ActivityIndicator {}
-
-impl Render for ActivityIndicator {
-    type Element = Stateful<Div>;
-
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-        let content = self.content_to_render(cx);
-
-        let mut result = h_stack()
-            .id("activity-indicator")
-            .on_action(cx.listener(Self::show_error_message))
-            .on_action(cx.listener(Self::dismiss_error_message));
-
-        if let Some(on_click) = content.on_click {
-            result = result
-                .cursor(CursorStyle::PointingHand)
-                .on_click(cx.listener(move |this, _, cx| {
-                    on_click(this, cx);
-                }))
-        }
-
-        result
-            .children(content.icon.map(|icon| svg().path(icon)))
-            .child(SharedString::from(content.message))
-    }
-}
-
-impl StatusItemView for ActivityIndicator {
-    fn set_active_pane_item(&mut self, _: Option<&dyn ItemHandle>, _: &mut ViewContext<Self>) {}
-}
--- a/crates/ai2/src/auth.rs
+++ b/crates/ai2/src/auth.rs
@@ -7,7 +7,7 @@ pub enum ProviderCredential {
    NotNeeded,
 }

-pub trait CredentialProvider: Send + Sync {
+pub trait CredentialProvider {
    fn has_credentials(&self) -> bool;
    fn retrieve_credentials(&self, cx: &mut AppContext) -> ProviderCredential;
    fn save_credentials(&self, cx: &mut AppContext, credential: ProviderCredential);
--- a/crates/ai2/src/providers/open_ai/completion.rs
+++ b/crates/ai2/src/providers/open_ai/completion.rs
@@ -104,7 +104,7 @@ pub struct OpenAIResponseStreamEvent {

 pub async fn stream_completion(
    credential: ProviderCredential,
-    executor: BackgroundExecutor,
+    executor: Arc<BackgroundExecutor>,
    request: Box<dyn CompletionRequest>,
 ) -> Result<impl Stream<Item = Result<OpenAIResponseStreamEvent>>> {
    let api_key = match credential {
@@ -197,11 +197,11 @@ pub async fn stream_completion(
 pub struct OpenAICompletionProvider {
    model: OpenAILanguageModel,
    credential: Arc<RwLock<ProviderCredential>>,
-    executor: BackgroundExecutor,
+    executor: Arc<BackgroundExecutor>,
 }

 impl OpenAICompletionProvider {
-    pub fn new(model_name: &str, executor: BackgroundExecutor) -> Self {
+    pub fn new(model_name: &str, executor: Arc<BackgroundExecutor>) -> Self {
        let model = OpenAILanguageModel::load(model_name);
        let credential = Arc::new(RwLock::new(ProviderCredential::NoCredentials));
        Self {
--- a/crates/ai2/src/providers/open_ai/embedding.rs
+++ b/crates/ai2/src/providers/open_ai/embedding.rs
@@ -35,7 +35,7 @@ pub struct OpenAIEmbeddingProvider {
    model: OpenAILanguageModel,
    credential: Arc<RwLock<ProviderCredential>>,
    pub client: Arc<dyn HttpClient>,
-    pub executor: BackgroundExecutor,
+    pub executor: Arc<BackgroundExecutor>,
    rate_limit_count_rx: watch::Receiver<Option<Instant>>,
    rate_limit_count_tx: Arc<Mutex<watch::Sender<Option<Instant>>>>,
 }
@@ -66,7 +66,7 @@ struct OpenAIEmbeddingUsage {
 }

 impl OpenAIEmbeddingProvider {
-    pub fn new(client: Arc<dyn HttpClient>, executor: BackgroundExecutor) -> Self {
+    pub fn new(client: Arc<dyn HttpClient>, executor: Arc<BackgroundExecutor>) -> Self {
        let (rate_limit_count_tx, rate_limit_count_rx) = watch::channel_with(None);
        let rate_limit_count_tx = Arc::new(Mutex::new(rate_limit_count_tx));

--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -1218,31 +1218,6 @@ impl View for AssistantPanel {
        let style = &theme.assistant;
        if let Some(api_key_editor) = self.api_key_editor.as_ref() {
            Flex::column()
-                .with_child(
-                    Text::new(
-                        "To use the assistant panel or inline assistant, you need to add your OpenAI api key.",
-                        style.api_key_prompt.text.clone(),
-                    ),
-                )
-                .with_child(
-                    Text::new(
-                        " - Having a subscription for another service like GitHub Copilot won't work.",
-                        style.api_key_prompt.text.clone(),
-                    ),
-                )
-                .with_child(
-                    Text::new(
-                        " - You can create a api key at: platform.openai.com/api-keys",
-                        style.api_key_prompt.text.clone(),
-                    ),
-                )
-                .with_child(
-                    Text::new(
-                        " ",
-                        style.api_key_prompt.text.clone(),
-                    )
-                    .aligned(),
-                )
                .with_child(
                    Text::new(
                        "Paste your OpenAI API key and press Enter to use the assistant",
@@ -1256,20 +1231,6 @@ impl View for AssistantPanel {
                        .with_style(style.api_key_editor.container)
                        .aligned(),
                )
-                .with_child(
-                    Text::new(
-                        " ",
-                        style.api_key_prompt.text.clone(),
-                    )
-                    .aligned(),
-                )
-                .with_child(
-                    Text::new(
-                        "Click on the Z button in the status bar to close this panel.",
-                        style.api_key_prompt.text.clone(),
-                    )
-                    .aligned(),
-                )
                .contained()
                .with_style(style.api_key_prompt.container)
                .aligned()
--- a/crates/assistant2/Cargo.toml
+++ b/crates/assistant2/Cargo.toml
@@ -1,54 +0,0 @@
-[package]
-name = "assistant2"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[lib]
-path = "src/assistant.rs"
-doctest = false
-
-[dependencies]
-ai = { package = "ai2", path = "../ai2" }
-client = { package = "client2", path = "../client2" }
-collections = { path = "../collections"}
-editor = { package = "editor2", path = "../editor2" }
-fs = { package = "fs2", path = "../fs2" }
-gpui = { package = "gpui2", path = "../gpui2" }
-language = { package = "language2", path = "../language2" }
-menu = { package = "menu2", path = "../menu2" }
-multi_buffer = { package = "multi_buffer2", path = "../multi_buffer2" }
-project = { package = "project2", path = "../project2" }
-search = { package = "search2", path = "../search2" }
-semantic_index = { package = "semantic_index2", path = "../semantic_index2" }
-settings = { package = "settings2", path = "../settings2" }
-theme = { package = "theme2", path = "../theme2" }
-ui = { package = "ui2", path = "../ui2" }
-util = { path = "../util" }
-workspace = { package = "workspace2", path = "../workspace2" }
-
-uuid.workspace = true
-log.workspace = true
-anyhow.workspace = true
-chrono = { version = "0.4", features = ["serde"] }
-futures.workspace = true
-indoc.workspace = true
-isahc.workspace = true
-ordered-float.workspace = true
-parking_lot.workspace = true
-regex.workspace = true
-schemars.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-smol.workspace = true
-tiktoken-rs.workspace = true
-
-[dev-dependencies]
-ai = { package = "ai2", path = "../ai2", features = ["test-support"]}
-editor = { package = "editor2", path = "../editor2", features = ["test-support"] }
-project = { package = "project2", path = "../project2", features = ["test-support"] }
-
-ctor.workspace = true
-env_logger.workspace = true
-log.workspace = true
-rand.workspace = true
--- a/crates/assistant2/README.zmd
+++ b/crates/assistant2/README.zmd
@@ -1,63 +0,0 @@
-> Hello, I'm Nathan Sobo.
-I'm currently your sole creator and the leader of Zed Industries.
-Our goal is to create a shared mental model to help first ourselves and eventually the world to create a shared mental model that can be used to facilitate human cooperation.
-
-< Hello, Nathan! Welcome back to Zed. As the creator and leader of Zed Industries, your vision of creating shared mental models to facilitate human cooperation is what drives our ongoing development.
-
-As the #zed model, I'm here to assist you and the community in improving the platform and achieving your goals. Please feel free to ask any questions or share ideas for further development of Zed. Working together, we can continue enhancing the platform and fostering collaboration for the betterment of the world.
-
-> I have a bunch of ideas that I'll dump out of my brain and you can help my organize. Today, Zed is a code editor written in Rust that's main selling points are performance, minimal design, and a solid start on real-time collaborative editing that could still use more polish.
-
-We've decided that our next milestone will be open-sourcing Zed on the Zed platform.
-
-< Nathan, it's exciting to hear that you have more ideas to enhance Zed! Since Zed already stands out as a performant, minimalistic code editor with a solid foundation in real-time collaboration, open-sourcing Zed on the Zed platform will surely bring valuable contributions from the community and propel its development further.
-
-Let's organize your ideas and create a plan for your next milestone. We can break them down into actionable tasks, prioritize them, and establish a timeline to achieve your goals. Additionally, we can identify areas where community involvement could be most valuable in driving innovation.
-
-Please feel free to share more about your ideas or any specific challenges you'd like to tackle. I'm here to help you turn these ideas into a cohesive and successful plan for Zed's future!
-
-@nathan> #zed, can you describe the conversation UI as you currently understand it.
-
-< Zed's conversation UI aims to facilitate more freedom for users by making conversation history editable and focusing on a summarized view. Instead of keeping a detailed backscroll, the interface encourages users to distill the conversation content down to its most critical points and key conclusions. This approach ensures that the vital information from the conversation is highlighted and easily accessible, while still maintaining a history that can be linked to when necessary.
-
-Addressing @nate's concerns, this design choice aims to strike a balance between readability, usability, and information preservation. The summarized view maintains the essence of the conversation without being burdened by extensive backscroll. Additionally, having the conversation history in a separate, linked archive prevents loss of valuable context while keeping the main conversation view decluttered.
-
-@nathan> What details around the conversation view are worth exploring?
-
-< @nathan, there are several aspects of the conversation view that are worth exploring and refining:
-
-1. Editing functionality: Ensuring that all participants can edit and refine the conversation summary effectively while preserving the original context.
-2. Permissions and access control: Determining how to manage editing rights, user roles, and visibility of the conversation summary and history.
-3. Navigation and linking: Implementing an intuitive system for navigating between the summarized conversation and linked history or reference materials.
-4. Visualization and layout: Designing the interface to clearly present the summarized information while providing a visually engaging and organized experience for participants.
-5. Threaded conversations and branching: Exploring ways to handle sub-conversations, supplementary discussions, or debates within the primary conversation view.
-
-Considering these aspects will ensure our conversation view design is optimized for usability, collaboration, and accessibility in Zed.
-
-@nathan> @nate, which of these would you like to explore?
-
-@nate> 2 feels like it isn't important at the moment, we can explore that later. Let's start with 4, which I think will lead us to discussion 3 and 5.
-
-#zed share your thoughts on the points we need to consider to design a layout and visualization for a conversation view between you (#zed) and multuple peoople, or between multiple people and multiple bots (you and other bots).
-
-@nathan> Agreed. I'm interested in threading I think more than anything. Or 4 yeah. I think we need to scope the threading conversation. Also, asking #zed to propose the solution... not sure it will be that effective but it's worth a try...
-
-#zed describe a hypothetical conversation UI that meets the description.
-
-< @nate and @nathan, I understand that you'd like to focus on the layout and visualization for a conversation view that can accommodate multiple people and potentially multiple bots as well. Here's a proposal for a conversation UI that meets the requirements:
-
-1. Main conversation area: Display the summarized conversation content in a clean and organized manner, ensuring readability and efficient use of space.
-
-2. Participant avatars and labels: Include user avatars and/or labels to distinguish between users and bots visually, allowing easy identification of each participant's contributions.
-
-3. Active threads indicator: Designate a clear indicator for ongoing threads, which will attract attention to active sub-conversations or related discussions in the conversation view.
-
-4. Dynamic branching: Implement a branching visual structure to present threaded conversations, clearly distinguishing sub-conversations, and enabling users to navigate between them smoothly.
-
-5. Multiple bot interaction support: Facilitate interactions between multiple bots through user-invoked prompts or bot-to-bot communication channels without disrupting the primary conversation flow.
-
-6. Expandable conversation history: Offer a separate, expandable section or panel to access historical content without cluttering the main conversation view.
-
-7. Linking and referencing: Implement a system for hyperlinking relevant information, resources, or previous conversations to the current discussion, making it easy for participants to follow and reference the shared context.
-
-This hypothetical conversation UI aims to address the layout and visualization, threading, and multi-participant aspects of your requirements. Of course, it's just an initial proposal, and we can refine and iterate on it based on your feedback and specific needs.
--- a/crates/assistant2/features.zmd
+++ b/crates/assistant2/features.zmd
@@ -1,3 +0,0 @@
-Push content to a deeper layer.
-A context can have multiple sublayers.
-You can enable or disable arbitrary sublayers at arbitrary nesting depths when viewing the document.
--- a/crates/assistant2/src/assistant.rs
+++ b/crates/assistant2/src/assistant.rs
@@ -1,129 +0,0 @@
-pub mod assistant_panel;
-mod assistant_settings;
-mod codegen;
-mod prompts;
-mod streaming_diff;
-
-use ai::providers::open_ai::Role;
-use anyhow::Result;
-pub use assistant_panel::AssistantPanel;
-use assistant_settings::OpenAIModel;
-use chrono::{DateTime, Local};
-use collections::HashMap;
-use fs::Fs;
-use futures::StreamExt;
-use gpui::{actions, AppContext, SharedString};
-use regex::Regex;
-use serde::{Deserialize, Serialize};
-use std::{cmp::Reverse, ffi::OsStr, path::PathBuf, sync::Arc};
-use util::paths::CONVERSATIONS_DIR;
-
-actions!(
-    assistant,
-    [
-        NewConversation,
-        Assist,
-        Split,
-        CycleMessageRole,
-        QuoteSelection,
-        ToggleFocus,
-        ResetKey,
-        InlineAssist,
-        ToggleIncludeConversation,
-        ToggleRetrieveContext,
-    ]
-);
-
-#[derive(
-    Copy, Clone, Debug, Default, Eq, PartialEq, PartialOrd, Ord, Hash, Serialize, Deserialize,
-)]
-struct MessageId(usize);
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-struct MessageMetadata {
-    role: Role,
-    sent_at: DateTime<Local>,
-    status: MessageStatus,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-enum MessageStatus {
-    Pending,
-    Done,
-    Error(SharedString),
-}
-
-#[derive(Serialize, Deserialize)]
-struct SavedMessage {
-    id: MessageId,
-    start: usize,
-}
-
-#[derive(Serialize, Deserialize)]
-struct SavedConversation {
-    id: Option<String>,
-    zed: String,
-    version: String,
-    text: String,
-    messages: Vec<SavedMessage>,
-    message_metadata: HashMap<MessageId, MessageMetadata>,
-    summary: String,
-    model: OpenAIModel,
-}
-
-impl SavedConversation {
-    const VERSION: &'static str = "0.1.0";
-}
-
-struct SavedConversationMetadata {
-    title: String,
-    path: PathBuf,
-    mtime: chrono::DateTime<chrono::Local>,
-}
-
-impl SavedConversationMetadata {
-    pub async fn list(fs: Arc<dyn Fs>) -> Result<Vec<Self>> {
-        fs.create_dir(&CONVERSATIONS_DIR).await?;
-
-        let mut paths = fs.read_dir(&CONVERSATIONS_DIR).await?;
-        let mut conversations = Vec::<SavedConversationMetadata>::new();
-        while let Some(path) = paths.next().await {
-            let path = path?;
-            if path.extension() != Some(OsStr::new("json")) {
-                continue;
-            }
-
-            let pattern = r" - \d+.zed.json$";
-            let re = Regex::new(pattern).unwrap();
-
-            let metadata = fs.metadata(&path).await?;
-            if let Some((file_name, metadata)) = path
-                .file_name()
-                .and_then(|name| name.to_str())
-                .zip(metadata)
-            {
-                let title = re.replace(file_name, "");
-                conversations.push(Self {
-                    title: title.into_owned(),
-                    path,
-                    mtime: metadata.mtime.into(),
-                });
-            }
-        }
-        conversations.sort_unstable_by_key(|conversation| Reverse(conversation.mtime));
-
-        Ok(conversations)
-    }
-}
-
-pub fn init(cx: &mut AppContext) {
-    assistant_panel::init(cx);
-}
-
-#[cfg(test)]
-#[ctor::ctor]
-fn init_logger() {
-    if std::env::var("RUST_LOG").is_ok() {
-        env_logger::init();
-    }
-}
--- a/crates/assistant2/src/assistant_panel.rs
+++ b/crates/assistant2/src/assistant_panel.rs
--- a/crates/assistant2/src/assistant_settings.rs
+++ b/crates/assistant2/src/assistant_settings.rs
@@ -1,80 +0,0 @@
-use anyhow;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use settings::Settings;
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
-pub enum OpenAIModel {
-    #[serde(rename = "gpt-3.5-turbo-0613")]
-    ThreePointFiveTurbo,
-    #[serde(rename = "gpt-4-0613")]
-    Four,
-    #[serde(rename = "gpt-4-1106-preview")]
-    FourTurbo,
-}
-
-impl OpenAIModel {
-    pub fn full_name(&self) -> &'static str {
-        match self {
-            OpenAIModel::ThreePointFiveTurbo => "gpt-3.5-turbo-0613",
-            OpenAIModel::Four => "gpt-4-0613",
-            OpenAIModel::FourTurbo => "gpt-4-1106-preview",
-        }
-    }
-
-    pub fn short_name(&self) -> &'static str {
-        match self {
-            OpenAIModel::ThreePointFiveTurbo => "gpt-3.5-turbo",
-            OpenAIModel::Four => "gpt-4",
-            OpenAIModel::FourTurbo => "gpt-4-turbo",
-        }
-    }
-
-    pub fn cycle(&self) -> Self {
-        match self {
-            OpenAIModel::ThreePointFiveTurbo => OpenAIModel::Four,
-            OpenAIModel::Four => OpenAIModel::FourTurbo,
-            OpenAIModel::FourTurbo => OpenAIModel::ThreePointFiveTurbo,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-#[serde(rename_all = "snake_case")]
-pub enum AssistantDockPosition {
-    Left,
-    Right,
-    Bottom,
-}
-
-#[derive(Deserialize, Debug)]
-pub struct AssistantSettings {
-    pub button: bool,
-    pub dock: AssistantDockPosition,
-    pub default_width: f32,
-    pub default_height: f32,
-    pub default_open_ai_model: OpenAIModel,
-}
-
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
-pub struct AssistantSettingsContent {
-    pub button: Option<bool>,
-    pub dock: Option<AssistantDockPosition>,
-    pub default_width: Option<f32>,
-    pub default_height: Option<f32>,
-    pub default_open_ai_model: Option<OpenAIModel>,
-}
-
-impl Settings for AssistantSettings {
-    const KEY: Option<&'static str> = Some("assistant");
-
-    type FileContent = AssistantSettingsContent;
-
-    fn load(
-        default_value: &Self::FileContent,
-        user_values: &[&Self::FileContent],
-        _: &mut gpui::AppContext,
-    ) -> anyhow::Result<Self> {
-        Self::load_via_json_merge(default_value, user_values)
-    }
-}
--- a/crates/assistant2/src/codegen.rs
+++ b/crates/assistant2/src/codegen.rs
@@ -1,688 +0,0 @@
-use crate::streaming_diff::{Hunk, StreamingDiff};
-use ai::completion::{CompletionProvider, CompletionRequest};
-use anyhow::Result;
-use editor::{Anchor, MultiBuffer, MultiBufferSnapshot, ToOffset, ToPoint};
-use futures::{channel::mpsc, SinkExt, Stream, StreamExt};
-use gpui::{EventEmitter, Model, ModelContext, Task};
-use language::{Rope, TransactionId};
-use multi_buffer;
-use std::{cmp, future, ops::Range, sync::Arc};
-
-pub enum Event {
-    Finished,
-    Undone,
-}
-
-#[derive(Clone)]
-pub enum CodegenKind {
-    Transform { range: Range<Anchor> },
-    Generate { position: Anchor },
-}
-
-pub struct Codegen {
-    provider: Arc<dyn CompletionProvider>,
-    buffer: Model<MultiBuffer>,
-    snapshot: MultiBufferSnapshot,
-    kind: CodegenKind,
-    last_equal_ranges: Vec<Range<Anchor>>,
-    transaction_id: Option<TransactionId>,
-    error: Option<anyhow::Error>,
-    generation: Task<()>,
-    idle: bool,
-    _subscription: gpui::Subscription,
-}
-
-impl EventEmitter<Event> for Codegen {}
-
-impl Codegen {
-    pub fn new(
-        buffer: Model<MultiBuffer>,
-        kind: CodegenKind,
-        provider: Arc<dyn CompletionProvider>,
-        cx: &mut ModelContext<Self>,
-    ) -> Self {
-        let snapshot = buffer.read(cx).snapshot(cx);
-        Self {
-            provider,
-            buffer: buffer.clone(),
-            snapshot,
-            kind,
-            last_equal_ranges: Default::default(),
-            transaction_id: Default::default(),
-            error: Default::default(),
-            idle: true,
-            generation: Task::ready(()),
-            _subscription: cx.subscribe(&buffer, Self::handle_buffer_event),
-        }
-    }
-
-    fn handle_buffer_event(
-        &mut self,
-        _buffer: Model<MultiBuffer>,
-        event: &multi_buffer::Event,
-        cx: &mut ModelContext<Self>,
-    ) {
-        if let multi_buffer::Event::TransactionUndone { transaction_id } = event {
-            if self.transaction_id == Some(*transaction_id) {
-                self.transaction_id = None;
-                self.generation = Task::ready(());
-                cx.emit(Event::Undone);
-            }
-        }
-    }
-
-    pub fn range(&self) -> Range<Anchor> {
-        match &self.kind {
-            CodegenKind::Transform { range } => range.clone(),
-            CodegenKind::Generate { position } => position.bias_left(&self.snapshot)..*position,
-        }
-    }
-
-    pub fn kind(&self) -> &CodegenKind {
-        &self.kind
-    }
-
-    pub fn last_equal_ranges(&self) -> &[Range<Anchor>] {
-        &self.last_equal_ranges
-    }
-
-    pub fn idle(&self) -> bool {
-        self.idle
-    }
-
-    pub fn error(&self) -> Option<&anyhow::Error> {
-        self.error.as_ref()
-    }
-
-    pub fn start(&mut self, prompt: Box<dyn CompletionRequest>, cx: &mut ModelContext<Self>) {
-        let range = self.range();
-        let snapshot = self.snapshot.clone();
-        let selected_text = snapshot
-            .text_for_range(range.start..range.end)
-            .collect::<Rope>();
-
-        let selection_start = range.start.to_point(&snapshot);
-        let suggested_line_indent = snapshot
-            .suggested_indents(selection_start.row..selection_start.row + 1, cx)
-            .into_values()
-            .next()
-            .unwrap_or_else(|| snapshot.indent_size_for_line(selection_start.row));
-
-        let response = self.provider.complete(prompt);
-        self.generation = cx.spawn(|this, mut cx| {
-            async move {
-                let generate = async {
-                    let mut edit_start = range.start.to_offset(&snapshot);
-
-                    let (mut hunks_tx, mut hunks_rx) = mpsc::channel(1);
-                    let diff = cx.background_executor().spawn(async move {
-                        let chunks = strip_invalid_spans_from_codeblock(response.await?);
-                        futures::pin_mut!(chunks);
-                        let mut diff = StreamingDiff::new(selected_text.to_string());
-
-                        let mut new_text = String::new();
-                        let mut base_indent = None;
-                        let mut line_indent = None;
-                        let mut first_line = true;
-
-                        while let Some(chunk) = chunks.next().await {
-                            let chunk = chunk?;
-
-                            let mut lines = chunk.split('\n').peekable();
-                            while let Some(line) = lines.next() {
-                                new_text.push_str(line);
-                                if line_indent.is_none() {
-                                    if let Some(non_whitespace_ch_ix) =
-                                        new_text.find(|ch: char| !ch.is_whitespace())
-                                    {
-                                        line_indent = Some(non_whitespace_ch_ix);
-                                        base_indent = base_indent.or(line_indent);
-
-                                        let line_indent = line_indent.unwrap();
-                                        let base_indent = base_indent.unwrap();
-                                        let indent_delta = line_indent as i32 - base_indent as i32;
-                                        let mut corrected_indent_len = cmp::max(
-                                            0,
-                                            suggested_line_indent.len as i32 + indent_delta,
-                                        )
-                                            as usize;
-                                        if first_line {
-                                            corrected_indent_len = corrected_indent_len
-                                                .saturating_sub(selection_start.column as usize);
-                                        }
-
-                                        let indent_char = suggested_line_indent.char();
-                                        let mut indent_buffer = [0; 4];
-                                        let indent_str =
-                                            indent_char.encode_utf8(&mut indent_buffer);
-                                        new_text.replace_range(
-                                            ..line_indent,
-                                            &indent_str.repeat(corrected_indent_len),
-                                        );
-                                    }
-                                }
-
-                                if line_indent.is_some() {
-                                    hunks_tx.send(diff.push_new(&new_text)).await?;
-                                    new_text.clear();
-                                }
-
-                                if lines.peek().is_some() {
-                                    hunks_tx.send(diff.push_new("\n")).await?;
-                                    line_indent = None;
-                                    first_line = false;
-                                }
-                            }
-                        }
-                        hunks_tx.send(diff.push_new(&new_text)).await?;
-                        hunks_tx.send(diff.finish()).await?;
-
-                        anyhow::Ok(())
-                    });
-
-                    while let Some(hunks) = hunks_rx.next().await {
-                        this.update(&mut cx, |this, cx| {
-                            this.last_equal_ranges.clear();
-
-                            let transaction = this.buffer.update(cx, |buffer, cx| {
-                                // Avoid grouping assistant edits with user edits.
-                                buffer.finalize_last_transaction(cx);
-
-                                buffer.start_transaction(cx);
-                                buffer.edit(
-                                    hunks.into_iter().filter_map(|hunk| match hunk {
-                                        Hunk::Insert { text } => {
-                                            let edit_start = snapshot.anchor_after(edit_start);
-                                            Some((edit_start..edit_start, text))
-                                        }
-                                        Hunk::Remove { len } => {
-                                            let edit_end = edit_start + len;
-                                            let edit_range = snapshot.anchor_after(edit_start)
-                                                ..snapshot.anchor_before(edit_end);
-                                            edit_start = edit_end;
-                                            Some((edit_range, String::new()))
-                                        }
-                                        Hunk::Keep { len } => {
-                                            let edit_end = edit_start + len;
-                                            let edit_range = snapshot.anchor_after(edit_start)
-                                                ..snapshot.anchor_before(edit_end);
-                                            edit_start = edit_end;
-                                            this.last_equal_ranges.push(edit_range);
-                                            None
-                                        }
-                                    }),
-                                    None,
-                                    cx,
-                                );
-
-                                buffer.end_transaction(cx)
-                            });
-
-                            if let Some(transaction) = transaction {
-                                if let Some(first_transaction) = this.transaction_id {
-                                    // Group all assistant edits into the first transaction.
-                                    this.buffer.update(cx, |buffer, cx| {
-                                        buffer.merge_transactions(
-                                            transaction,
-                                            first_transaction,
-                                            cx,
-                                        )
-                                    });
-                                } else {
-                                    this.transaction_id = Some(transaction);
-                                    this.buffer.update(cx, |buffer, cx| {
-                                        buffer.finalize_last_transaction(cx)
-                                    });
-                                }
-                            }
-
-                            cx.notify();
-                        })?;
-                    }
-
-                    diff.await?;
-                    anyhow::Ok(())
-                };
-
-                let result = generate.await;
-                this.update(&mut cx, |this, cx| {
-                    this.last_equal_ranges.clear();
-                    this.idle = true;
-                    if let Err(error) = result {
-                        this.error = Some(error);
-                    }
-                    cx.emit(Event::Finished);
-                    cx.notify();
-                })
-                .ok();
-            }
-        });
-        self.error.take();
-        self.idle = false;
-        cx.notify();
-    }
-
-    pub fn undo(&mut self, cx: &mut ModelContext<Self>) {
-        if let Some(transaction_id) = self.transaction_id {
-            self.buffer
-                .update(cx, |buffer, cx| buffer.undo_transaction(transaction_id, cx));
-        }
-    }
-}
-
-fn strip_invalid_spans_from_codeblock(
-    stream: impl Stream<Item = Result<String>>,
-) -> impl Stream<Item = Result<String>> {
-    let mut first_line = true;
-    let mut buffer = String::new();
-    let mut starts_with_markdown_codeblock = false;
-    let mut includes_start_or_end_span = false;
-    stream.filter_map(move |chunk| {
-        let chunk = match chunk {
-            Ok(chunk) => chunk,
-            Err(err) => return future::ready(Some(Err(err))),
-        };
-        buffer.push_str(&chunk);
-
-        if buffer.len() > "<|S|".len() && buffer.starts_with("<|S|") {
-            includes_start_or_end_span = true;
-
-            buffer = buffer
-                .strip_prefix("<|S|>")
-                .or_else(|| buffer.strip_prefix("<|S|"))
-                .unwrap_or(&buffer)
-                .to_string();
-        } else if buffer.ends_with("|E|>") {
-            includes_start_or_end_span = true;
-        } else if buffer.starts_with("<|")
-            || buffer.starts_with("<|S")
-            || buffer.starts_with("<|S|")
-            || buffer.ends_with("|")
-            || buffer.ends_with("|E")
-            || buffer.ends_with("|E|")
-        {
-            return future::ready(None);
-        }
-
-        if first_line {
-            if buffer == "" || buffer == "`" || buffer == "``" {
-                return future::ready(None);
-            } else if buffer.starts_with("```") {
-                starts_with_markdown_codeblock = true;
-                if let Some(newline_ix) = buffer.find('\n') {
-                    buffer.replace_range(..newline_ix + 1, "");
-                    first_line = false;
-                } else {
-                    return future::ready(None);
-                }
-            }
-        }
-
-        let mut text = buffer.to_string();
-        if starts_with_markdown_codeblock {
-            text = text
-                .strip_suffix("\n```\n")
-                .or_else(|| text.strip_suffix("\n```"))
-                .or_else(|| text.strip_suffix("\n``"))
-                .or_else(|| text.strip_suffix("\n`"))
-                .or_else(|| text.strip_suffix('\n'))
-                .unwrap_or(&text)
-                .to_string();
-        }
-
-        if includes_start_or_end_span {
-            text = text
-                .strip_suffix("|E|>")
-                .or_else(|| text.strip_suffix("E|>"))
-                .or_else(|| text.strip_prefix("|>"))
-                .or_else(|| text.strip_prefix(">"))
-                .unwrap_or(&text)
-                .to_string();
-        };
-
-        if text.contains('\n') {
-            first_line = false;
-        }
-
-        let remainder = buffer.split_off(text.len());
-        let result = if buffer.is_empty() {
-            None
-        } else {
-            Some(Ok(buffer.clone()))
-        };
-
-        buffer = remainder;
-        future::ready(result)
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use super::*;
-    use ai::test::FakeCompletionProvider;
-    use futures::stream::{self};
-    use gpui::{Context, TestAppContext};
-    use indoc::indoc;
-    use language::{language_settings, tree_sitter_rust, Buffer, Language, LanguageConfig, Point};
-    use rand::prelude::*;
-    use serde::Serialize;
-    use settings::SettingsStore;
-
-    #[derive(Serialize)]
-    pub struct DummyCompletionRequest {
-        pub name: String,
-    }
-
-    impl CompletionRequest for DummyCompletionRequest {
-        fn data(&self) -> serde_json::Result<String> {
-            serde_json::to_string(self)
-        }
-    }
-
-    #[gpui::test(iterations = 10)]
-    async fn test_transform_autoindent(cx: &mut TestAppContext, mut rng: StdRng) {
-        cx.set_global(cx.update(SettingsStore::test));
-        cx.update(language_settings::init);
-
-        let text = indoc! {"
-            fn main() {
-                let x = 0;
-                for _ in 0..10 {
-                    x += 1;
-                }
-            }
-        "};
-        let buffer =
-            cx.build_model(|cx| Buffer::new(0, 0, text).with_language(Arc::new(rust_lang()), cx));
-        let buffer = cx.build_model(|cx| MultiBuffer::singleton(buffer, cx));
-        let range = buffer.read_with(cx, |buffer, cx| {
-            let snapshot = buffer.snapshot(cx);
-            snapshot.anchor_before(Point::new(1, 0))..snapshot.anchor_after(Point::new(4, 5))
-        });
-        let provider = Arc::new(FakeCompletionProvider::new());
-        let codegen = cx.build_model(|cx| {
-            Codegen::new(
-                buffer.clone(),
-                CodegenKind::Transform { range },
-                provider.clone(),
-                cx,
-            )
-        });
-
-        let request = Box::new(DummyCompletionRequest {
-            name: "test".to_string(),
-        });
-        codegen.update(cx, |codegen, cx| codegen.start(request, cx));
-
-        let mut new_text = concat!(
-            "       let mut x = 0;\n",
-            "       while x < 10 {\n",
-            "           x += 1;\n",
-            "       }",
-        );
-        while !new_text.is_empty() {
-            let max_len = cmp::min(new_text.len(), 10);
-            let len = rng.gen_range(1..=max_len);
-            let (chunk, suffix) = new_text.split_at(len);
-            println!("CHUNK: {:?}", &chunk);
-            provider.send_completion(chunk);
-            new_text = suffix;
-            cx.background_executor.run_until_parked();
-        }
-        provider.finish_completion();
-        cx.background_executor.run_until_parked();
-
-        assert_eq!(
-            buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx).text()),
-            indoc! {"
-                fn main() {
-                    let mut x = 0;
-                    while x < 10 {
-                        x += 1;
-                    }
-                }
-            "}
-        );
-    }
-
-    #[gpui::test(iterations = 10)]
-    async fn test_autoindent_when_generating_past_indentation(
-        cx: &mut TestAppContext,
-        mut rng: StdRng,
-    ) {
-        cx.set_global(cx.update(SettingsStore::test));
-        cx.update(language_settings::init);
-
-        let text = indoc! {"
-            fn main() {
-                le
-            }
-        "};
-        let buffer =
-            cx.build_model(|cx| Buffer::new(0, 0, text).with_language(Arc::new(rust_lang()), cx));
-        let buffer = cx.build_model(|cx| MultiBuffer::singleton(buffer, cx));
-        let position = buffer.read_with(cx, |buffer, cx| {
-            let snapshot = buffer.snapshot(cx);
-            snapshot.anchor_before(Point::new(1, 6))
-        });
-        let provider = Arc::new(FakeCompletionProvider::new());
-        let codegen = cx.build_model(|cx| {
-            Codegen::new(
-                buffer.clone(),
-                CodegenKind::Generate { position },
-                provider.clone(),
-                cx,
-            )
-        });
-
-        let request = Box::new(DummyCompletionRequest {
-            name: "test".to_string(),
-        });
-        codegen.update(cx, |codegen, cx| codegen.start(request, cx));
-
-        let mut new_text = concat!(
-            "t mut x = 0;\n",
-            "while x < 10 {\n",
-            "    x += 1;\n",
-            "}", //
-        );
-        while !new_text.is_empty() {
-            let max_len = cmp::min(new_text.len(), 10);
-            let len = rng.gen_range(1..=max_len);
-            let (chunk, suffix) = new_text.split_at(len);
-            provider.send_completion(chunk);
-            new_text = suffix;
-            cx.background_executor.run_until_parked();
-        }
-        provider.finish_completion();
-        cx.background_executor.run_until_parked();
-
-        assert_eq!(
-            buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx).text()),
-            indoc! {"
-                fn main() {
-                    let mut x = 0;
-                    while x < 10 {
-                        x += 1;
-                    }
-                }
-            "}
-        );
-    }
-
-    #[gpui::test(iterations = 10)]
-    async fn test_autoindent_when_generating_before_indentation(
-        cx: &mut TestAppContext,
-        mut rng: StdRng,
-    ) {
-        cx.set_global(cx.update(SettingsStore::test));
-        cx.update(language_settings::init);
-
-        let text = concat!(
-            "fn main() {\n",
-            "  \n",
-            "}\n" //
-        );
-        let buffer =
-            cx.build_model(|cx| Buffer::new(0, 0, text).with_language(Arc::new(rust_lang()), cx));
-        let buffer = cx.build_model(|cx| MultiBuffer::singleton(buffer, cx));
-        let position = buffer.read_with(cx, |buffer, cx| {
-            let snapshot = buffer.snapshot(cx);
-            snapshot.anchor_before(Point::new(1, 2))
-        });
-        let provider = Arc::new(FakeCompletionProvider::new());
-        let codegen = cx.build_model(|cx| {
-            Codegen::new(
-                buffer.clone(),
-                CodegenKind::Generate { position },
-                provider.clone(),
-                cx,
-            )
-        });
-
-        let request = Box::new(DummyCompletionRequest {
-            name: "test".to_string(),
-        });
-        codegen.update(cx, |codegen, cx| codegen.start(request, cx));
-
-        let mut new_text = concat!(
-            "let mut x = 0;\n",
-            "while x < 10 {\n",
-            "    x += 1;\n",
-            "}", //
-        );
-        while !new_text.is_empty() {
-            let max_len = cmp::min(new_text.len(), 10);
-            let len = rng.gen_range(1..=max_len);
-            let (chunk, suffix) = new_text.split_at(len);
-            println!("{:?}", &chunk);
-            provider.send_completion(chunk);
-            new_text = suffix;
-            cx.background_executor.run_until_parked();
-        }
-        provider.finish_completion();
-        cx.background_executor.run_until_parked();
-
-        assert_eq!(
-            buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx).text()),
-            indoc! {"
-                fn main() {
-                    let mut x = 0;
-                    while x < 10 {
-                        x += 1;
-                    }
-                }
-            "}
-        );
-    }
-
-    #[gpui::test]
-    async fn test_strip_invalid_spans_from_codeblock() {
-        assert_eq!(
-            strip_invalid_spans_from_codeblock(chunks("Lorem ipsum dolor", 2))
-                .map(|chunk| chunk.unwrap())
-                .collect::<String>()
-                .await,
-            "Lorem ipsum dolor"
-        );
-        assert_eq!(
-            strip_invalid_spans_from_codeblock(chunks("```\nLorem ipsum dolor", 2))
-                .map(|chunk| chunk.unwrap())
-                .collect::<String>()
-                .await,
-            "Lorem ipsum dolor"
-        );
-        assert_eq!(
-            strip_invalid_spans_from_codeblock(chunks("```\nLorem ipsum dolor\n```", 2))
-                .map(|chunk| chunk.unwrap())
-                .collect::<String>()
-                .await,
-            "Lorem ipsum dolor"
-        );
-        assert_eq!(
-            strip_invalid_spans_from_codeblock(chunks("```\nLorem ipsum dolor\n```\n", 2))
-                .map(|chunk| chunk.unwrap())
-                .collect::<String>()
-                .await,
-            "Lorem ipsum dolor"
-        );
-        assert_eq!(
-            strip_invalid_spans_from_codeblock(chunks(
-                "```html\n```js\nLorem ipsum dolor\n```\n```",
-                2
-            ))
-            .map(|chunk| chunk.unwrap())
-            .collect::<String>()
-            .await,
-            "```js\nLorem ipsum dolor\n```"
-        );
-        assert_eq!(
-            strip_invalid_spans_from_codeblock(chunks("``\nLorem ipsum dolor\n```", 2))
-                .map(|chunk| chunk.unwrap())
-                .collect::<String>()
-                .await,
-            "``\nLorem ipsum dolor\n```"
-        );
-        assert_eq!(
-            strip_invalid_spans_from_codeblock(chunks("<|S|Lorem ipsum|E|>", 2))
-                .map(|chunk| chunk.unwrap())
-                .collect::<String>()
-                .await,
-            "Lorem ipsum"
-        );
-
-        assert_eq!(
-            strip_invalid_spans_from_codeblock(chunks("<|S|>Lorem ipsum", 2))
-                .map(|chunk| chunk.unwrap())
-                .collect::<String>()
-                .await,
-            "Lorem ipsum"
-        );
-
-        assert_eq!(
-            strip_invalid_spans_from_codeblock(chunks("```\n<|S|>Lorem ipsum\n```", 2))
-                .map(|chunk| chunk.unwrap())
-                .collect::<String>()
-                .await,
-            "Lorem ipsum"
-        );
-        assert_eq!(
-            strip_invalid_spans_from_codeblock(chunks("```\n<|S|Lorem ipsum|E|>\n```", 2))
-                .map(|chunk| chunk.unwrap())
-                .collect::<String>()
-                .await,
-            "Lorem ipsum"
-        );
-        fn chunks(text: &str, size: usize) -> impl Stream<Item = Result<String>> {
-            stream::iter(
-                text.chars()
-                    .collect::<Vec<_>>()
-                    .chunks(size)
-                    .map(|chunk| Ok(chunk.iter().collect::<String>()))
-                    .collect::<Vec<_>>(),
-            )
-        }
-    }
-
-    fn rust_lang() -> Language {
-        Language::new(
-            LanguageConfig {
-                name: "Rust".into(),
-                path_suffixes: vec!["rs".to_string()],
-                ..Default::default()
-            },
-            Some(tree_sitter_rust::language()),
-        )
-        .with_indents_query(
-            r#"
-            (call_expression) @indent
-            (field_expression) @indent
-            (_ "(" ")" @end) @indent
-            (_ "{" "}" @end) @indent
-            "#,
-        )
-        .unwrap()
-    }
-}
--- a/crates/assistant2/src/prompts.rs
+++ b/crates/assistant2/src/prompts.rs
@@ -1,389 +0,0 @@
-use ai::models::LanguageModel;
-use ai::prompts::base::{PromptArguments, PromptChain, PromptPriority, PromptTemplate};
-use ai::prompts::file_context::FileContext;
-use ai::prompts::generate::GenerateInlineContent;
-use ai::prompts::preamble::EngineerPreamble;
-use ai::prompts::repository_context::{PromptCodeSnippet, RepositoryContext};
-use ai::providers::open_ai::OpenAILanguageModel;
-use language::{BufferSnapshot, OffsetRangeExt, ToOffset};
-use std::cmp::{self, Reverse};
-use std::ops::Range;
-use std::sync::Arc;
-
-#[allow(dead_code)]
-fn summarize(buffer: &BufferSnapshot, selected_range: Range<impl ToOffset>) -> String {
-    #[derive(Debug)]
-    struct Match {
-        collapse: Range<usize>,
-        keep: Vec<Range<usize>>,
-    }
-
-    let selected_range = selected_range.to_offset(buffer);
-    let mut ts_matches = buffer.matches(0..buffer.len(), |grammar| {
-        Some(&grammar.embedding_config.as_ref()?.query)
-    });
-    let configs = ts_matches
-        .grammars()
-        .iter()
-        .map(|g| g.embedding_config.as_ref().unwrap())
-        .collect::<Vec<_>>();
-    let mut matches = Vec::new();
-    while let Some(mat) = ts_matches.peek() {
-        let config = &configs[mat.grammar_index];
-        if let Some(collapse) = mat.captures.iter().find_map(|cap| {
-            if Some(cap.index) == config.collapse_capture_ix {
-                Some(cap.node.byte_range())
-            } else {
-                None
-            }
-        }) {
-            let mut keep = Vec::new();
-            for capture in mat.captures.iter() {
-                if Some(capture.index) == config.keep_capture_ix {
-                    keep.push(capture.node.byte_range());
-                } else {
-                    continue;
-                }
-            }
-            ts_matches.advance();
-            matches.push(Match { collapse, keep });
-        } else {
-            ts_matches.advance();
-        }
-    }
-    matches.sort_unstable_by_key(|mat| (mat.collapse.start, Reverse(mat.collapse.end)));
-    let mut matches = matches.into_iter().peekable();
-
-    let mut summary = String::new();
-    let mut offset = 0;
-    let mut flushed_selection = false;
-    while let Some(mat) = matches.next() {
-        // Keep extending the collapsed range if the next match surrounds
-        // the current one.
-        while let Some(next_mat) = matches.peek() {
-            if mat.collapse.start <= next_mat.collapse.start
-                && mat.collapse.end >= next_mat.collapse.end
-            {
-                matches.next().unwrap();
-            } else {
-                break;
-            }
-        }
-
-        if offset > mat.collapse.start {
-            // Skip collapsed nodes that have already been summarized.
-            offset = cmp::max(offset, mat.collapse.end);
-            continue;
-        }
-
-        if offset <= selected_range.start && selected_range.start <= mat.collapse.end {
-            if !flushed_selection {
-                // The collapsed node ends after the selection starts, so we'll flush the selection first.
-                summary.extend(buffer.text_for_range(offset..selected_range.start));
-                summary.push_str("<|S|");
-                if selected_range.end == selected_range.start {
-                    summary.push_str(">");
-                } else {
-                    summary.extend(buffer.text_for_range(selected_range.clone()));
-                    summary.push_str("|E|>");
-                }
-                offset = selected_range.end;
-                flushed_selection = true;
-            }
-
-            // If the selection intersects the collapsed node, we won't collapse it.
-            if selected_range.end >= mat.collapse.start {
-                continue;
-            }
-        }
-
-        summary.extend(buffer.text_for_range(offset..mat.collapse.start));
-        for keep in mat.keep {
-            summary.extend(buffer.text_for_range(keep));
-        }
-        offset = mat.collapse.end;
-    }
-
-    // Flush selection if we haven't already done so.
-    if !flushed_selection && offset <= selected_range.start {
-        summary.extend(buffer.text_for_range(offset..selected_range.start));
-        summary.push_str("<|S|");
-        if selected_range.end == selected_range.start {
-            summary.push_str(">");
-        } else {
-            summary.extend(buffer.text_for_range(selected_range.clone()));
-            summary.push_str("|E|>");
-        }
-        offset = selected_range.end;
-    }
-
-    summary.extend(buffer.text_for_range(offset..buffer.len()));
-    summary
-}
-
-pub fn generate_content_prompt(
-    user_prompt: String,
-    language_name: Option<&str>,
-    buffer: BufferSnapshot,
-    range: Range<usize>,
-    search_results: Vec<PromptCodeSnippet>,
-    model: &str,
-    project_name: Option<String>,
-) -> anyhow::Result<String> {
-    // Using new Prompt Templates
-    let openai_model: Arc<dyn LanguageModel> = Arc::new(OpenAILanguageModel::load(model));
-    let lang_name = if let Some(language_name) = language_name {
-        Some(language_name.to_string())
-    } else {
-        None
-    };
-
-    let args = PromptArguments {
-        model: openai_model,
-        language_name: lang_name.clone(),
-        project_name,
-        snippets: search_results.clone(),
-        reserved_tokens: 1000,
-        buffer: Some(buffer),
-        selected_range: Some(range),
-        user_prompt: Some(user_prompt.clone()),
-    };
-
-    let templates: Vec<(PromptPriority, Box<dyn PromptTemplate>)> = vec![
-        (PromptPriority::Mandatory, Box::new(EngineerPreamble {})),
-        (
-            PromptPriority::Ordered { order: 1 },
-            Box::new(RepositoryContext {}),
-        ),
-        (
-            PromptPriority::Ordered { order: 0 },
-            Box::new(FileContext {}),
-        ),
-        (
-            PromptPriority::Mandatory,
-            Box::new(GenerateInlineContent {}),
-        ),
-    ];
-    let chain = PromptChain::new(args, templates);
-    let (prompt, _) = chain.generate(true)?;
-
-    anyhow::Ok(prompt)
-}
-
-#[cfg(test)]
-pub(crate) mod tests {
-
-    use super::*;
-    use std::sync::Arc;
-
-    use gpui::{AppContext, Context};
-    use indoc::indoc;
-    use language::{language_settings, tree_sitter_rust, Buffer, Language, LanguageConfig, Point};
-    use settings::SettingsStore;
-
-    pub(crate) fn rust_lang() -> Language {
-        Language::new(
-            LanguageConfig {
-                name: "Rust".into(),
-                path_suffixes: vec!["rs".to_string()],
-                ..Default::default()
-            },
-            Some(tree_sitter_rust::language()),
-        )
-        .with_embedding_query(
-            r#"
-            (
-                [(line_comment) (attribute_item)]* @context
-                .
-                [
-                    (struct_item
-                        name: (_) @name)
-
-                    (enum_item
-                        name: (_) @name)
-
-                    (impl_item
-                        trait: (_)? @name
-                        "for"? @name
-                        type: (_) @name)
-
-                    (trait_item
-                        name: (_) @name)
-
-                    (function_item
-                        name: (_) @name
-                        body: (block
-                            "{" @keep
-                            "}" @keep) @collapse)
-
-                    (macro_definition
-                        name: (_) @name)
-                    ] @item
-                )
-            "#,
-        )
-        .unwrap()
-    }
-
-    #[gpui::test]
-    fn test_outline_for_prompt(cx: &mut AppContext) {
-        let settings_store = SettingsStore::test(cx);
-        cx.set_global(settings_store);
-        language_settings::init(cx);
-        let text = indoc! {"
-            struct X {
-                a: usize,
-                b: usize,
-            }
-
-            impl X {
-
-                fn new() -> Self {
-                    let a = 1;
-                    let b = 2;
-                    Self { a, b }
-                }
-
-                pub fn a(&self, param: bool) -> usize {
-                    self.a
-                }
-
-                pub fn b(&self) -> usize {
-                    self.b
-                }
-            }
-        "};
-        let buffer =
-            cx.build_model(|cx| Buffer::new(0, 0, text).with_language(Arc::new(rust_lang()), cx));
-        let snapshot = buffer.read(cx).snapshot();
-
-        assert_eq!(
-            summarize(&snapshot, Point::new(1, 4)..Point::new(1, 4)),
-            indoc! {"
-                struct X {
-                    <|S|>a: usize,
-                    b: usize,
-                }
-
-                impl X {
-
-                    fn new() -> Self {}
-
-                    pub fn a(&self, param: bool) -> usize {}
-
-                    pub fn b(&self) -> usize {}
-                }
-            "}
-        );
-
-        assert_eq!(
-            summarize(&snapshot, Point::new(8, 12)..Point::new(8, 14)),
-            indoc! {"
-                struct X {
-                    a: usize,
-                    b: usize,
-                }
-
-                impl X {
-
-                    fn new() -> Self {
-                        let <|S|a |E|>= 1;
-                        let b = 2;
-                        Self { a, b }
-                    }
-
-                    pub fn a(&self, param: bool) -> usize {}
-
-                    pub fn b(&self) -> usize {}
-                }
-            "}
-        );
-
-        assert_eq!(
-            summarize(&snapshot, Point::new(6, 0)..Point::new(6, 0)),
-            indoc! {"
-                struct X {
-                    a: usize,
-                    b: usize,
-                }
-
-                impl X {
-                <|S|>
-                    fn new() -> Self {}
-
-                    pub fn a(&self, param: bool) -> usize {}
-
-                    pub fn b(&self) -> usize {}
-                }
-            "}
-        );
-
-        assert_eq!(
-            summarize(&snapshot, Point::new(21, 0)..Point::new(21, 0)),
-            indoc! {"
-                struct X {
-                    a: usize,
-                    b: usize,
-                }
-
-                impl X {
-
-                    fn new() -> Self {}
-
-                    pub fn a(&self, param: bool) -> usize {}
-
-                    pub fn b(&self) -> usize {}
-                }
-                <|S|>"}
-        );
-
-        // Ensure nested functions get collapsed properly.
-        let text = indoc! {"
-            struct X {
-                a: usize,
-                b: usize,
-            }
-
-            impl X {
-
-                fn new() -> Self {
-                    let a = 1;
-                    let b = 2;
-                    Self { a, b }
-                }
-
-                pub fn a(&self, param: bool) -> usize {
-                    let a = 30;
-                    fn nested() -> usize {
-                        3
-                    }
-                    self.a + nested()
-                }
-
-                pub fn b(&self) -> usize {
-                    self.b
-                }
-            }
-        "};
-        buffer.update(cx, |buffer, cx| buffer.set_text(text, cx));
-        let snapshot = buffer.read(cx).snapshot();
-        assert_eq!(
-            summarize(&snapshot, Point::new(0, 0)..Point::new(0, 0)),
-            indoc! {"
-                <|S|>struct X {
-                    a: usize,
-                    b: usize,
-                }
-
-                impl X {
-
-                    fn new() -> Self {}
-
-                    pub fn a(&self, param: bool) -> usize {}
-
-                    pub fn b(&self) -> usize {}
-                }
-            "}
-        );
-    }
-}
--- a/crates/assistant2/src/streaming_diff.rs
+++ b/crates/assistant2/src/streaming_diff.rs
@@ -1,293 +0,0 @@
-use collections::HashMap;
-use ordered_float::OrderedFloat;
-use std::{
-    cmp,
-    fmt::{self, Debug},
-    ops::Range,
-};
-
-struct Matrix {
-    cells: Vec<f64>,
-    rows: usize,
-    cols: usize,
-}
-
-impl Matrix {
-    fn new() -> Self {
-        Self {
-            cells: Vec::new(),
-            rows: 0,
-            cols: 0,
-        }
-    }
-
-    fn resize(&mut self, rows: usize, cols: usize) {
-        self.cells.resize(rows * cols, 0.);
-        self.rows = rows;
-        self.cols = cols;
-    }
-
-    fn get(&self, row: usize, col: usize) -> f64 {
-        if row >= self.rows {
-            panic!("row out of bounds")
-        }
-
-        if col >= self.cols {
-            panic!("col out of bounds")
-        }
-        self.cells[col * self.rows + row]
-    }
-
-    fn set(&mut self, row: usize, col: usize, value: f64) {
-        if row >= self.rows {
-            panic!("row out of bounds")
-        }
-
-        if col >= self.cols {
-            panic!("col out of bounds")
-        }
-
-        self.cells[col * self.rows + row] = value;
-    }
-}
-
-impl Debug for Matrix {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f)?;
-        for i in 0..self.rows {
-            for j in 0..self.cols {
-                write!(f, "{:5}", self.get(i, j))?;
-            }
-            writeln!(f)?;
-        }
-        Ok(())
-    }
-}
-
-#[derive(Debug)]
-pub enum Hunk {
-    Insert { text: String },
-    Remove { len: usize },
-    Keep { len: usize },
-}
-
-pub struct StreamingDiff {
-    old: Vec<char>,
-    new: Vec<char>,
-    scores: Matrix,
-    old_text_ix: usize,
-    new_text_ix: usize,
-    equal_runs: HashMap<(usize, usize), u32>,
-}
-
-impl StreamingDiff {
-    const INSERTION_SCORE: f64 = -1.;
-    const DELETION_SCORE: f64 = -20.;
-    const EQUALITY_BASE: f64 = 1.8;
-    const MAX_EQUALITY_EXPONENT: i32 = 16;
-
-    pub fn new(old: String) -> Self {
-        let old = old.chars().collect::<Vec<_>>();
-        let mut scores = Matrix::new();
-        scores.resize(old.len() + 1, 1);
-        for i in 0..=old.len() {
-            scores.set(i, 0, i as f64 * Self::DELETION_SCORE);
-        }
-        Self {
-            old,
-            new: Vec::new(),
-            scores,
-            old_text_ix: 0,
-            new_text_ix: 0,
-            equal_runs: Default::default(),
-        }
-    }
-
-    pub fn push_new(&mut self, text: &str) -> Vec<Hunk> {
-        self.new.extend(text.chars());
-        self.scores.resize(self.old.len() + 1, self.new.len() + 1);
-
-        for j in self.new_text_ix + 1..=self.new.len() {
-            self.scores.set(0, j, j as f64 * Self::INSERTION_SCORE);
-            for i in 1..=self.old.len() {
-                let insertion_score = self.scores.get(i, j - 1) + Self::INSERTION_SCORE;
-                let deletion_score = self.scores.get(i - 1, j) + Self::DELETION_SCORE;
-                let equality_score = if self.old[i - 1] == self.new[j - 1] {
-                    let mut equal_run = self.equal_runs.get(&(i - 1, j - 1)).copied().unwrap_or(0);
-                    equal_run += 1;
-                    self.equal_runs.insert((i, j), equal_run);
-
-                    let exponent = cmp::min(equal_run as i32 / 4, Self::MAX_EQUALITY_EXPONENT);
-                    self.scores.get(i - 1, j - 1) + Self::EQUALITY_BASE.powi(exponent)
-                } else {
-                    f64::NEG_INFINITY
-                };
-
-                let score = insertion_score.max(deletion_score).max(equality_score);
-                self.scores.set(i, j, score);
-            }
-        }
-
-        let mut max_score = f64::NEG_INFINITY;
-        let mut next_old_text_ix = self.old_text_ix;
-        let next_new_text_ix = self.new.len();
-        for i in self.old_text_ix..=self.old.len() {
-            let score = self.scores.get(i, next_new_text_ix);
-            if score > max_score {
-                max_score = score;
-                next_old_text_ix = i;
-            }
-        }
-
-        let hunks = self.backtrack(next_old_text_ix, next_new_text_ix);
-        self.old_text_ix = next_old_text_ix;
-        self.new_text_ix = next_new_text_ix;
-        hunks
-    }
-
-    fn backtrack(&self, old_text_ix: usize, new_text_ix: usize) -> Vec<Hunk> {
-        let mut pending_insert: Option<Range<usize>> = None;
-        let mut hunks = Vec::new();
-        let mut i = old_text_ix;
-        let mut j = new_text_ix;
-        while (i, j) != (self.old_text_ix, self.new_text_ix) {
-            let insertion_score = if j > self.new_text_ix {
-                Some((i, j - 1))
-            } else {
-                None
-            };
-            let deletion_score = if i > self.old_text_ix {
-                Some((i - 1, j))
-            } else {
-                None
-            };
-            let equality_score = if i > self.old_text_ix && j > self.new_text_ix {
-                if self.old[i - 1] == self.new[j - 1] {
-                    Some((i - 1, j - 1))
-                } else {
-                    None
-                }
-            } else {
-                None
-            };
-
-            let (prev_i, prev_j) = [insertion_score, deletion_score, equality_score]
-                .iter()
-                .max_by_key(|cell| cell.map(|(i, j)| OrderedFloat(self.scores.get(i, j))))
-                .unwrap()
-                .unwrap();
-
-            if prev_i == i && prev_j == j - 1 {
-                if let Some(pending_insert) = pending_insert.as_mut() {
-                    pending_insert.start = prev_j;
-                } else {
-                    pending_insert = Some(prev_j..j);
-                }
-            } else {
-                if let Some(range) = pending_insert.take() {
-                    hunks.push(Hunk::Insert {
-                        text: self.new[range].iter().collect(),
-                    });
-                }
-
-                let char_len = self.old[i - 1].len_utf8();
-                if prev_i == i - 1 && prev_j == j {
-                    if let Some(Hunk::Remove { len }) = hunks.last_mut() {
-                        *len += char_len;
-                    } else {
-                        hunks.push(Hunk::Remove { len: char_len })
-                    }
-                } else {
-                    if let Some(Hunk::Keep { len }) = hunks.last_mut() {
-                        *len += char_len;
-                    } else {
-                        hunks.push(Hunk::Keep { len: char_len })
-                    }
-                }
-            }
-
-            i = prev_i;
-            j = prev_j;
-        }
-
-        if let Some(range) = pending_insert.take() {
-            hunks.push(Hunk::Insert {
-                text: self.new[range].iter().collect(),
-            });
-        }
-
-        hunks.reverse();
-        hunks
-    }
-
-    pub fn finish(self) -> Vec<Hunk> {
-        self.backtrack(self.old.len(), self.new.len())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::env;
-
-    use super::*;
-    use rand::prelude::*;
-
-    #[gpui::test(iterations = 100)]
-    fn test_random_diffs(mut rng: StdRng) {
-        let old_text_len = env::var("OLD_TEXT_LEN")
-            .map(|i| i.parse().expect("invalid `OLD_TEXT_LEN` variable"))
-            .unwrap_or(10);
-        let new_text_len = env::var("NEW_TEXT_LEN")
-            .map(|i| i.parse().expect("invalid `NEW_TEXT_LEN` variable"))
-            .unwrap_or(10);
-
-        let old = util::RandomCharIter::new(&mut rng)
-            .take(old_text_len)
-            .collect::<String>();
-        log::info!("old text: {:?}", old);
-
-        let mut diff = StreamingDiff::new(old.clone());
-        let mut hunks = Vec::new();
-        let mut new_len = 0;
-        let mut new = String::new();
-        while new_len < new_text_len {
-            let new_chunk_len = rng.gen_range(1..=new_text_len - new_len);
-            let new_chunk = util::RandomCharIter::new(&mut rng)
-                .take(new_len)
-                .collect::<String>();
-            log::info!("new chunk: {:?}", new_chunk);
-            new_len += new_chunk_len;
-            new.push_str(&new_chunk);
-            let new_hunks = diff.push_new(&new_chunk);
-            log::info!("hunks: {:?}", new_hunks);
-            hunks.extend(new_hunks);
-        }
-        let final_hunks = diff.finish();
-        log::info!("final hunks: {:?}", final_hunks);
-        hunks.extend(final_hunks);
-
-        log::info!("new text: {:?}", new);
-        let mut old_ix = 0;
-        let mut new_ix = 0;
-        let mut patched = String::new();
-        for hunk in hunks {
-            match hunk {
-                Hunk::Keep { len } => {
-                    assert_eq!(&old[old_ix..old_ix + len], &new[new_ix..new_ix + len]);
-                    patched.push_str(&old[old_ix..old_ix + len]);
-                    old_ix += len;
-                    new_ix += len;
-                }
-                Hunk::Remove { len } => {
-                    old_ix += len;
-                }
-                Hunk::Insert { text } => {
-                    assert_eq!(text, &new[new_ix..new_ix + text.len()]);
-                    patched.push_str(&text);
-                    new_ix += text.len();
-                }
-            }
-        }
-        assert_eq!(patched, new);
-    }
-}
--- a/crates/auto_update2/src/auto_update.rs
+++ b/crates/auto_update2/src/auto_update.rs
@@ -6,17 +6,15 @@ use db::kvp::KEY_VALUE_STORE;
 use db::RELEASE_CHANNEL;
 use gpui::{
    actions, AppContext, AsyncAppContext, Context as _, Model, ModelContext, SemanticVersion, Task,
-    ViewContext, VisualContext, WindowContext,
+    ViewContext, VisualContext,
 };
 use isahc::AsyncBody;
-
 use serde::Deserialize;
 use serde_derive::Serialize;
 use smol::io::AsyncReadExt;

 use settings::{Settings, SettingsStore};
 use smol::{fs::File, process::Command};
-
 use std::{ffi::OsString, sync::Arc, time::Duration};
 use update_notification::UpdateNotification;
 use util::channel::{AppCommitSha, ReleaseChannel};
@@ -26,7 +24,13 @@ use workspace::Workspace;
 const SHOULD_SHOW_UPDATE_NOTIFICATION_KEY: &str = "auto-updater-should-show-updated-notification";
 const POLL_INTERVAL: Duration = Duration::from_secs(60 * 60);

-actions!(auto_update, [Check, DismissErrorMessage, ViewReleaseNotes]);
+//todo!(remove CheckThatAutoUpdaterWorks)
+actions!(
+    Check,
+    DismissErrorMessage,
+    ViewReleaseNotes,
+    CheckThatAutoUpdaterWorks
+);

 #[derive(Serialize)]
 struct UpdateRequestBody {
@@ -80,20 +84,20 @@ impl Settings for AutoUpdateSetting {
 pub fn init(http_client: Arc<dyn HttpClient>, server_url: String, cx: &mut AppContext) {
    AutoUpdateSetting::register(cx);

-    cx.observe_new_views(|workspace: &mut Workspace, _cx| {
-        workspace.register_action(|_, action: &Check, cx| check(action, cx));
-
-        workspace.register_action(|_, action, cx| view_release_notes(action, cx));
-
-        // @nate - code to trigger update notification on launch
-        // todo!("remove this when Nate is done")
-        // workspace.show_notification(0, _cx, |cx| {
-        //     cx.build_view(|_| UpdateNotification::new(SemanticVersion::from_str("1.1.1").unwrap()))
-        // });
+    cx.observe_new_views(|wokrspace: &mut Workspace, _cx| {
+        wokrspace
+            .register_action(|_, action: &Check, cx| check(action, cx))
+            .register_action(|_, _action: &CheckThatAutoUpdaterWorks, cx| {
+                let prompt = cx.prompt(gpui::PromptLevel::Info, "It does!", &["Ok"]);
+                cx.spawn(|_, _cx| async move {
+                    prompt.await.ok();
+                })
+                .detach();
+            });
    })
    .detach();

-    if let Some(version) = ZED_APP_VERSION.or_else(|| cx.app_metadata().app_version) {
+    if let Some(version) = *ZED_APP_VERSION {
        let auto_updater = cx.build_model(|cx| {
            let updater = AutoUpdater::new(version, http_client, server_url);

@@ -115,22 +119,19 @@ pub fn init(http_client: Arc<dyn HttpClient>, server_url: String, cx: &mut AppCo
            updater
        });
        cx.set_global(Some(auto_updater));
+        //todo!(action)
+        // cx.add_global_action(view_release_notes);
+        // cx.add_action(UpdateNotification::dismiss);
    }
 }

-pub fn check(_: &Check, cx: &mut WindowContext) {
+pub fn check(_: &Check, cx: &mut AppContext) {
    if let Some(updater) = AutoUpdater::get(cx) {
        updater.update(cx, |updater, cx| updater.poll(cx));
-    } else {
-        drop(cx.prompt(
-            gpui::PromptLevel::Info,
-            "Auto-updates disabled for non-bundled app.",
-            &["Ok"],
-        ));
    }
 }

-pub fn view_release_notes(_: &ViewReleaseNotes, cx: &mut AppContext) {
+fn _view_release_notes(_: &ViewReleaseNotes, cx: &mut AppContext) {
    if let Some(auto_updater) = AutoUpdater::get(cx) {
        let auto_updater = auto_updater.read(cx);
        let server_url = &auto_updater.server_url;
--- a/crates/auto_update2/src/update_notification.rs
+++ b/crates/auto_update2/src/update_notification.rs
@@ -1,58 +1,87 @@
-use gpui::{
-    div, DismissEvent, Div, EventEmitter, InteractiveElement, ParentElement, Render,
-    SemanticVersion, StatefulInteractiveElement, Styled, ViewContext,
-};
+use gpui::{div, Div, EventEmitter, ParentElement, Render, SemanticVersion, ViewContext};
 use menu::Cancel;
-use util::channel::ReleaseChannel;
-use workspace::ui::{h_stack, v_stack, Icon, IconElement, Label, StyledExt};
+use workspace::notifications::NotificationEvent;

 pub struct UpdateNotification {
-    version: SemanticVersion,
+    _version: SemanticVersion,
 }

-impl EventEmitter<DismissEvent> for UpdateNotification {}
+impl EventEmitter<NotificationEvent> for UpdateNotification {}

 impl Render for UpdateNotification {
-    type Element = Div;
+    type Output = Div;

-    fn render(&mut self, cx: &mut gpui::ViewContext<Self>) -> Self::Element {
-        let app_name = cx.global::<ReleaseChannel>().display_name();
+    fn render(&mut self, _cx: &mut gpui::ViewContext<Self>) -> Self::Output {
+        div().child("Updated zed!")
+        // let theme = theme::current(cx).clone();
+        // let theme = &theme.update_notification;

-        v_stack()
-            .on_action(cx.listener(UpdateNotification::dismiss))
-            .elevation_3(cx)
-            .p_4()
-            .child(
-                h_stack()
-                    .justify_between()
-                    .child(Label::new(format!(
-                        "Updated to {app_name} {}",
-                        self.version
-                    )))
-                    .child(
-                        div()
-                            .id("cancel")
-                            .child(IconElement::new(Icon::Close))
-                            .cursor_pointer()
-                            .on_click(cx.listener(|this, _, cx| this.dismiss(&menu::Cancel, cx))),
-                    ),
-            )
-            .child(
-                div()
-                    .id("notes")
-                    .child(Label::new("View the release notes"))
-                    .cursor_pointer()
-                    .on_click(|_, cx| crate::view_release_notes(&Default::default(), cx)),
-            )
+        // let app_name = cx.global::<ReleaseChannel>().display_name();
+
+        // MouseEventHandler::new::<ViewReleaseNotes, _>(0, cx, |state, cx| {
+        //     Flex::column()
+        //         .with_child(
+        //             Flex::row()
+        //                 .with_child(
+        //                     Text::new(
+        //                         format!("Updated to {app_name} {}", self.version),
+        //                         theme.message.text.clone(),
+        //                     )
+        //                     .contained()
+        //                     .with_style(theme.message.container)
+        //                     .aligned()
+        //                     .top()
+        //                     .left()
+        //                     .flex(1., true),
+        //                 )
+        //                 .with_child(
+        //                     MouseEventHandler::new::<Cancel, _>(0, cx, |state, _| {
+        //                         let style = theme.dismiss_button.style_for(state);
+        //                         Svg::new("icons/x.svg")
+        //                             .with_color(style.color)
+        //                             .constrained()
+        //                             .with_width(style.icon_width)
+        //                             .aligned()
+        //                             .contained()
+        //                             .with_style(style.container)
+        //                             .constrained()
+        //                             .with_width(style.button_width)
+        //                             .with_height(style.button_width)
+        //                     })
+        //                     .with_padding(Padding::uniform(5.))
+        //                     .on_click(MouseButton::Left, move |_, this, cx| {
+        //                         this.dismiss(&Default::default(), cx)
+        //                     })
+        //                     .aligned()
+        //                     .constrained()
+        //                     .with_height(cx.font_cache().line_height(theme.message.text.font_size))
+        //                     .aligned()
+        //                     .top()
+        //                     .flex_float(),
+        //                 ),
+        //         )
+        //         .with_child({
+        //             let style = theme.action_message.style_for(state);
+        //             Text::new("View the release notes", style.text.clone())
+        //                 .contained()
+        //                 .with_style(style.container)
+        //         })
+        //         .contained()
+        // })
+        // .with_cursor_style(CursorStyle::PointingHand)
+        // .on_click(MouseButton::Left, |_, _, cx| {
+        //     crate::view_release_notes(&Default::default(), cx)
+        // })
+        // .into_any_named("update notification")
    }
 }

 impl UpdateNotification {
    pub fn new(version: SemanticVersion) -> Self {
-        Self { version }
+        Self { _version: version }
    }

-    pub fn dismiss(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {
-        cx.emit(DismissEvent);
+    pub fn _dismiss(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {
+        cx.emit(NotificationEvent::Dismiss);
    }
 }
--- a/crates/breadcrumbs2/Cargo.toml
+++ b/crates/breadcrumbs2/Cargo.toml
@@ -1,28 +0,0 @@
-[package]
-name = "breadcrumbs2"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[lib]
-path = "src/breadcrumbs.rs"
-doctest = false
-
-[dependencies]
-collections = { path = "../collections" }
-editor = { package = "editor2", path = "../editor2" }
-gpui = { package = "gpui2", path = "../gpui2" }
-ui = { package = "ui2", path = "../ui2" }
-language = { package = "language2", path = "../language2" }
-project = { package = "project2", path = "../project2" }
-search = { package = "search2", path = "../search2" }
-settings = { package = "settings2", path = "../settings2" }
-theme = { package = "theme2", path = "../theme2" }
-workspace = { package = "workspace2", path = "../workspace2" }
-outline = { package = "outline2", path = "../outline2" }
-itertools = "0.10"
-
-[dev-dependencies]
-editor = { package = "editor2", path = "../editor2", features = ["test-support"] }
-gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
-workspace = { package = "workspace2", path = "../workspace2", features = ["test-support"] }
--- a/crates/breadcrumbs2/src/breadcrumbs.rs
+++ b/crates/breadcrumbs2/src/breadcrumbs.rs
@@ -1,127 +0,0 @@
-use editor::Editor;
-use gpui::{
-    Div, Element, EventEmitter, IntoElement, ParentElement, Render, StyledText, Subscription,
-    ViewContext,
-};
-use itertools::Itertools;
-use theme::ActiveTheme;
-use ui::{prelude::*, ButtonLike, ButtonStyle, Label, Tooltip};
-use workspace::{
-    item::{ItemEvent, ItemHandle},
-    ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView,
-};
-
-pub enum Event {
-    UpdateLocation,
-}
-
-pub struct Breadcrumbs {
-    pane_focused: bool,
-    active_item: Option<Box<dyn ItemHandle>>,
-    subscription: Option<Subscription>,
-}
-
-impl Breadcrumbs {
-    pub fn new() -> Self {
-        Self {
-            pane_focused: false,
-            active_item: Default::default(),
-            subscription: Default::default(),
-        }
-    }
-}
-
-impl EventEmitter<Event> for Breadcrumbs {}
-impl EventEmitter<ToolbarItemEvent> for Breadcrumbs {}
-
-impl Render for Breadcrumbs {
-    type Element = Div;
-
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-        let element = h_stack().text_ui();
-
-        let Some(active_item) = &self
-            .active_item
-            .as_ref()
-            .filter(|item| item.downcast::<editor::Editor>().is_some())
-        else {
-            return element;
-        };
-
-        let Some(segments) = active_item.breadcrumbs(cx.theme(), cx) else {
-            return element;
-        };
-
-        let highlighted_segments = segments.into_iter().map(|segment| {
-            StyledText::new(segment.text)
-                .with_highlights(&cx.text_style(), segment.highlights.unwrap_or_default())
-                .into_any()
-        });
-        let breadcrumbs = Itertools::intersperse_with(highlighted_segments, || {
-            Label::new("›").into_any_element()
-        });
-
-        let editor = active_item
-            .downcast::<Editor>()
-            .map(|editor| editor.downgrade());
-
-        element.child(
-            ButtonLike::new("toggle outline view")
-                .style(ButtonStyle::Subtle)
-                .child(h_stack().gap_1().children(breadcrumbs))
-                .on_click(move |_, cx| {
-                    if let Some(editor) = editor.as_ref().and_then(|editor| editor.upgrade()) {
-                        outline::toggle(editor, &outline::Toggle, cx)
-                    }
-                })
-                .tooltip(|cx| Tooltip::for_action("Show symbol outline", &outline::Toggle, cx)),
-        )
-    }
-}
-
-impl ToolbarItemView for Breadcrumbs {
-    fn set_active_pane_item(
-        &mut self,
-        active_pane_item: Option<&dyn ItemHandle>,
-        cx: &mut ViewContext<Self>,
-    ) -> ToolbarItemLocation {
-        cx.notify();
-        self.active_item = None;
-        if let Some(item) = active_pane_item {
-            let this = cx.view().downgrade();
-            self.subscription = Some(item.subscribe_to_item_events(
-                cx,
-                Box::new(move |event, cx| {
-                    if let ItemEvent::UpdateBreadcrumbs = event {
-                        this.update(cx, |_, cx| {
-                            cx.emit(Event::UpdateLocation);
-                            cx.notify();
-                        })
-                        .ok();
-                    }
-                }),
-            ));
-            self.active_item = Some(item.boxed_clone());
-            item.breadcrumb_location(cx)
-        } else {
-            ToolbarItemLocation::Hidden
-        }
-    }
-
-    // fn location_for_event(
-    //     &self,
-    //     _: &Event,
-    //     current_location: ToolbarItemLocation,
-    //     cx: &AppContext,
-    // ) -> ToolbarItemLocation {
-    //     if let Some(active_item) = self.active_item.as_ref() {
-    //         active_item.breadcrumb_location(cx)
-    //     } else {
-    //         current_location
-    //     }
-    // }
-
-    fn pane_focus_update(&mut self, pane_focused: bool, _: &mut ViewContext<Self>) {
-        self.pane_focused = pane_focused;
-    }
-}
--- a/crates/call2/Cargo.toml
+++ b/crates/call2/Cargo.toml
@@ -35,13 +35,11 @@ util = { path = "../util" }
 anyhow.workspace = true
 async-broadcast = "0.4"
 futures.workspace = true
-image = "0.23"
 postage.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 serde_derive.workspace = true
-smallvec.workspace = true

 [dev-dependencies]
 client = { package = "client2", path = "../client2", features = ["test-support"] }
--- a/crates/call2/src/call2.rs
+++ b/crates/call2/src/call2.rs
@@ -464,7 +464,7 @@ impl ActiveCall {
        &self.pending_invites
    }

-    pub fn report_call_event(&self, operation: &'static str, cx: &mut AppContext) {
+    pub fn report_call_event(&self, operation: &'static str, cx: &AppContext) {
        if let Some(room) = self.room() {
            let room = room.read(cx);
            report_call_event_for_room(operation, room.id(), room.channel_id(), &self.client, cx);
@@ -477,7 +477,7 @@ pub fn report_call_event_for_room(
    room_id: u64,
    channel_id: Option<u64>,
    client: &Arc<Client>,
-    cx: &mut AppContext,
+    cx: &AppContext,
 ) {
    let telemetry = client.telemetry();
    let telemetry_settings = *TelemetrySettings::get_global(cx);
--- a/crates/call2/src/participant.rs
+++ b/crates/call2/src/participant.rs
@@ -4,7 +4,7 @@ use client::{proto, User};
 use collections::HashMap;
 use gpui::WeakModel;
 pub use live_kit_client::Frame;
-pub use live_kit_client::{RemoteAudioTrack, RemoteVideoTrack};
+use live_kit_client::{RemoteAudioTrack, RemoteVideoTrack};
 use project::Project;
 use std::sync::Arc;

--- a/crates/call2/src/room.rs
+++ b/crates/call2/src/room.rs
@@ -21,7 +21,7 @@ use live_kit_client::{
 };
 use postage::{sink::Sink, stream::Stream, watch};
 use project::Project;
-use settings::Settings as _;
+use settings::Settings;
 use std::{future::Future, mem, sync::Arc, time::Duration};
 use util::{post_inc, ResultExt, TryFutureExt};

@@ -1267,6 +1267,7 @@ impl Room {
                    .ok_or_else(|| anyhow!("live-kit was not initialized"))?
                    .await
            };
+
            let publication = publish_track.await;
            this.upgrade()
                .ok_or_else(|| anyhow!("room was dropped"))?
--- a/crates/channel2/src/channel_store.rs
+++ b/crates/channel2/src/channel_store.rs
@@ -8,8 +8,7 @@ use collections::{hash_map, HashMap, HashSet};
 use db::RELEASE_CHANNEL;
 use futures::{channel::mpsc, future::Shared, Future, FutureExt, StreamExt};
 use gpui::{
-    AppContext, AsyncAppContext, Context, EventEmitter, Model, ModelContext, SharedString, Task,
-    WeakModel,
+    AppContext, AsyncAppContext, Context, EventEmitter, Model, ModelContext, Task, WeakModel,
 };
 use rpc::{
    proto::{self, ChannelVisibility},
@@ -47,7 +46,7 @@ pub struct ChannelStore {
 #[derive(Clone, Debug, PartialEq)]
 pub struct Channel {
    pub id: ChannelId,
-    pub name: SharedString,
+    pub name: String,
    pub visibility: proto::ChannelVisibility,
    pub role: proto::ChannelRole,
    pub unseen_note_version: Option<(u64, clock::Global)>,
@@ -896,16 +895,14 @@ impl ChannelStore {
                .channel_invitations
                .binary_search_by_key(&channel.id, |c| c.id)
            {
-                Ok(ix) => {
-                    Arc::make_mut(&mut self.channel_invitations[ix]).name = channel.name.into()
-                }
+                Ok(ix) => Arc::make_mut(&mut self.channel_invitations[ix]).name = channel.name,
                Err(ix) => self.channel_invitations.insert(
                    ix,
                    Arc::new(Channel {
                        id: channel.id,
                        visibility: channel.visibility(),
                        role: channel.role(),
-                        name: channel.name.into(),
+                        name: channel.name,
                        unseen_note_version: None,
                        unseen_message_id: None,
                        parent_path: channel.parent_path,
--- a/crates/channel2/src/channel_store/channel_index.rs
+++ b/crates/channel2/src/channel_store/channel_index.rs
@@ -104,7 +104,7 @@ impl<'a> ChannelPathsInsertGuard<'a> {

            existing_channel.visibility = channel_proto.visibility();
            existing_channel.role = channel_proto.role();
-            existing_channel.name = channel_proto.name.into();
+            existing_channel.name = channel_proto.name;
        } else {
            self.channels_by_id.insert(
                channel_proto.id,
@@ -112,7 +112,7 @@ impl<'a> ChannelPathsInsertGuard<'a> {
                    id: channel_proto.id,
                    visibility: channel_proto.visibility(),
                    role: channel_proto.role(),
-                    name: channel_proto.name.into(),
+                    name: channel_proto.name,
                    unseen_note_version: None,
                    unseen_message_id: None,
                    parent_path: channel_proto.parent_path,
@@ -146,11 +146,11 @@ fn channel_path_sorting_key<'a>(
    let (parent_path, name) = channels_by_id
        .get(&id)
        .map_or((&[] as &[_], None), |channel| {
-            (channel.parent_path.as_slice(), Some(channel.name.as_ref()))
+            (channel.parent_path.as_slice(), Some(channel.name.as_str()))
        });
    parent_path
        .iter()
-        .filter_map(|id| Some(channels_by_id.get(id)?.name.as_ref()))
+        .filter_map(|id| Some(channels_by_id.get(id)?.name.as_str()))
        .chain(name)
 }

--- a/crates/channel2/src/channel_store_tests.rs
+++ b/crates/channel2/src/channel_store_tests.rs
@@ -345,7 +345,7 @@ async fn test_channel_messages(cx: &mut TestAppContext) {
 fn init_test(cx: &mut AppContext) -> Model<ChannelStore> {
    let http = FakeHttpClient::with_404_response();
    let client = Client::new(http.clone(), cx);
-    let user_store = cx.build_model(|cx| UserStore::new(client.clone(), cx));
+    let user_store = cx.build_model(|cx| UserStore::new(client.clone(), http, cx));

    let settings_store = SettingsStore::test(cx);
    cx.set_global(settings_store);
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -346,7 +346,7 @@ impl<T: Entity> Drop for PendingEntitySubscription<T> {
    }
 }

-#[derive(Debug, Copy, Clone)]
+#[derive(Copy, Clone)]
 pub struct TelemetrySettings {
    pub diagnostics: bool,
    pub metrics: bool,
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -109,10 +109,6 @@ pub enum ClickhouseEvent {
        virtual_memory_in_bytes: u64,
        milliseconds_since_first_event: i64,
    },
-    App {
-        operation: &'static str,
-        milliseconds_since_first_event: i64,
-    },
 }

 #[cfg(debug_assertions)]
@@ -172,8 +168,13 @@ impl Telemetry {
        let mut state = self.state.lock();
        state.installation_id = installation_id.map(|id| id.into());
        state.session_id = Some(session_id.into());
+        let has_clickhouse_events = !state.clickhouse_events_queue.is_empty();
        drop(state);

+        if has_clickhouse_events {
+            self.flush_clickhouse_events();
+        }
+
        let this = self.clone();
        cx.spawn(|mut cx| async move {
            // Avoiding calling `System::new_all()`, as there have been crashes related to it
@@ -255,7 +256,7 @@ impl Telemetry {
            milliseconds_since_first_event: self.milliseconds_since_first_event(),
        };

-        self.report_clickhouse_event(event, telemetry_settings, false)
+        self.report_clickhouse_event(event, telemetry_settings)
    }

    pub fn report_copilot_event(
@@ -272,7 +273,7 @@ impl Telemetry {
            milliseconds_since_first_event: self.milliseconds_since_first_event(),
        };

-        self.report_clickhouse_event(event, telemetry_settings, false)
+        self.report_clickhouse_event(event, telemetry_settings)
    }

    pub fn report_assistant_event(
@@ -289,7 +290,7 @@ impl Telemetry {
            milliseconds_since_first_event: self.milliseconds_since_first_event(),
        };

-        self.report_clickhouse_event(event, telemetry_settings, false)
+        self.report_clickhouse_event(event, telemetry_settings)
    }

    pub fn report_call_event(
@@ -306,7 +307,7 @@ impl Telemetry {
            milliseconds_since_first_event: self.milliseconds_since_first_event(),
        };

-        self.report_clickhouse_event(event, telemetry_settings, false)
+        self.report_clickhouse_event(event, telemetry_settings)
    }

    pub fn report_cpu_event(
@@ -321,7 +322,7 @@ impl Telemetry {
            milliseconds_since_first_event: self.milliseconds_since_first_event(),
        };

-        self.report_clickhouse_event(event, telemetry_settings, false)
+        self.report_clickhouse_event(event, telemetry_settings)
    }

    pub fn report_memory_event(
@@ -336,21 +337,7 @@ impl Telemetry {
            milliseconds_since_first_event: self.milliseconds_since_first_event(),
        };

-        self.report_clickhouse_event(event, telemetry_settings, false)
-    }
-
-    // app_events are called at app open and app close, so flush is set to immediately send
-    pub fn report_app_event(
-        self: &Arc<Self>,
-        telemetry_settings: TelemetrySettings,
-        operation: &'static str,
-    ) {
-        let event = ClickhouseEvent::App {
-            operation,
-            milliseconds_since_first_event: self.milliseconds_since_first_event(),
-        };
-
-        self.report_clickhouse_event(event, telemetry_settings, true)
+        self.report_clickhouse_event(event, telemetry_settings)
    }

    fn milliseconds_since_first_event(&self) -> i64 {
@@ -371,7 +358,6 @@ impl Telemetry {
        self: &Arc<Self>,
        event: ClickhouseEvent,
        telemetry_settings: TelemetrySettings,
-        immediate_flush: bool,
    ) {
        if !telemetry_settings.metrics {
            return;
@@ -384,7 +370,7 @@ impl Telemetry {
            .push(ClickhouseEventWrapper { signed_in, event });

        if state.installation_id.is_some() {
-            if immediate_flush || state.clickhouse_events_queue.len() >= MAX_QUEUE_LEN {
+            if state.clickhouse_events_queue.len() >= MAX_QUEUE_LEN {
                drop(state);
                self.flush_clickhouse_events();
            } else {
--- a/crates/client2/src/client2.rs
+++ b/crates/client2/src/client2.rs
@@ -11,8 +11,8 @@ use async_tungstenite::tungstenite::{
    http::{Request, StatusCode},
 };
 use futures::{
-    channel::oneshot, future::LocalBoxFuture, AsyncReadExt, FutureExt, SinkExt, StreamExt,
-    TryFutureExt as _, TryStreamExt,
+    future::LocalBoxFuture, AsyncReadExt, FutureExt, SinkExt, StreamExt, TryFutureExt as _,
+    TryStreamExt,
 };
 use gpui::{
    actions, serde_json, AnyModel, AnyWeakModel, AppContext, AsyncAppContext, Model,
@@ -70,7 +70,7 @@ 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, Reconnect]);
+actions!(SignIn, SignOut, Reconnect);

 pub fn init_settings(cx: &mut AppContext) {
    TelemetrySettings::register(cx);
@@ -382,7 +382,7 @@ impl settings::Settings for TelemetrySettings {
 }

 impl Client {
-    pub fn new(http: Arc<dyn HttpClient>, cx: &mut AppContext) -> Arc<Self> {
+    pub fn new(http: Arc<dyn HttpClient>, cx: &AppContext) -> Arc<Self> {
        Arc::new(Self {
            id: AtomicU64::new(0),
            peer: Peer::new(0),
@@ -551,6 +551,7 @@ impl Client {
        F: 'static + Future<Output = Result<()>>,
    {
        let message_type_id = TypeId::of::<M>();
+
        let mut state = self.state.write();
        state
            .models_by_message_type
@@ -693,8 +694,8 @@ impl Client {
        }
    }

-    pub fn has_keychain_credentials(&self, cx: &AsyncAppContext) -> bool {
-        read_credentials_from_keychain(cx).is_some()
+    pub async fn has_keychain_credentials(&self, cx: &AsyncAppContext) -> bool {
+        read_credentials_from_keychain(cx).await.is_some()
    }

    #[async_recursion(?Send)]
@@ -725,7 +726,7 @@ impl Client {
        let mut read_from_keychain = false;
        let mut credentials = self.state.read().credentials.clone();
        if credentials.is_none() && try_keychain {
-            credentials = read_credentials_from_keychain(cx);
+            credentials = read_credentials_from_keychain(cx).await;
            read_from_keychain = credentials.is_some();
        }
        if credentials.is_none() {
@@ -1020,116 +1021,91 @@ impl Client {
    ) -> Task<Result<Credentials>> {
        let http = self.http.clone();
        cx.spawn(|cx| async move {
-            let background = cx.background_executor().clone();
+            // Generate a pair of asymmetric encryption keys. The public key will be used by the
+            // zed server to encrypt the user's access token, so that it can'be intercepted by
+            // any other app running on the user's device.
+            let (public_key, private_key) =
+                rpc::auth::keypair().expect("failed to generate keypair for auth");
+            let public_key_string =
+                String::try_from(public_key).expect("failed to serialize public key for auth");

-            let (open_url_tx, open_url_rx) = oneshot::channel::<String>();
-            cx.update(|cx| {
-                cx.spawn(move |cx| async move {
-                    let url = open_url_rx.await?;
-                    cx.update(|cx| cx.open_url(&url))
-                })
-                .detach_and_log_err(cx);
-            })
-            .log_err();
+            if let Some((login, token)) = IMPERSONATE_LOGIN.as_ref().zip(ADMIN_API_TOKEN.as_ref()) {
+                return Self::authenticate_as_admin(http, login.clone(), token.clone()).await;
+            }

-            let credentials = background
-                .clone()
-                .spawn(async move {
-                    // Generate a pair of asymmetric encryption keys. The public key will be used by the
-                    // zed server to encrypt the user's access token, so that it can'be intercepted by
-                    // any other app running on the user's device.
-                    let (public_key, private_key) =
-                        rpc::auth::keypair().expect("failed to generate keypair for auth");
-                    let public_key_string = String::try_from(public_key)
-                        .expect("failed to serialize public key for auth");
+            // Start an HTTP server to receive the redirect from Zed's sign-in page.
+            let server = tiny_http::Server::http("127.0.0.1:0").expect("failed to find open port");
+            let port = server.server_addr().port();

-                    if let Some((login, token)) =
-                        IMPERSONATE_LOGIN.as_ref().zip(ADMIN_API_TOKEN.as_ref())
-                    {
-                        return Self::authenticate_as_admin(http, login.clone(), token.clone())
-                            .await;
-                    }
+            // Open the Zed sign-in page in the user's browser, with query parameters that indicate
+            // that the user is signing in from a Zed app running on the same device.
+            let mut url = format!(
+                "{}/native_app_signin?native_app_port={}&native_app_public_key={}",
+                *ZED_SERVER_URL, port, public_key_string
+            );

-                    // Start an HTTP server to receive the redirect from Zed's sign-in page.
-                    let server =
-                        tiny_http::Server::http("127.0.0.1:0").expect("failed to find open port");
-                    let port = server.server_addr().port();
+            if let Some(impersonate_login) = IMPERSONATE_LOGIN.as_ref() {
+                log::info!("impersonating user @{}", impersonate_login);
+                write!(&mut url, "&impersonate={}", impersonate_login).unwrap();
+            }

-                    // Open the Zed sign-in page in the user's browser, with query parameters that indicate
-                    // that the user is signing in from a Zed app running on the same device.
-                    let mut url = format!(
-                        "{}/native_app_signin?native_app_port={}&native_app_public_key={}",
-                        *ZED_SERVER_URL, port, public_key_string
-                    );
+            cx.update(|cx| cx.open_url(&url))?;

-                    if let Some(impersonate_login) = IMPERSONATE_LOGIN.as_ref() {
-                        log::info!("impersonating user @{}", impersonate_login);
-                        write!(&mut url, "&impersonate={}", impersonate_login).unwrap();
-                    }
-
-                    open_url_tx.send(url).log_err();
-
-                    // Receive the HTTP request from the user's browser. Retrieve the user id and encrypted
-                    // access token from the query params.
-                    //
-                    // TODO - Avoid ever starting more than one HTTP server. Maybe switch to using a
-                    // custom URL scheme instead of this local HTTP server.
-                    let (user_id, access_token) = background
-                        .spawn(async move {
-                            for _ in 0..100 {
-                                if let Some(req) = server.recv_timeout(Duration::from_secs(1))? {
-                                    let path = req.url();
-                                    let mut user_id = None;
-                                    let mut access_token = None;
-                                    let url = Url::parse(&format!("http://example.com{}", path))
-                                        .context("failed to parse login notification url")?;
-                                    for (key, value) in url.query_pairs() {
-                                        if key == "access_token" {
-                                            access_token = Some(value.to_string());
-                                        } else if key == "user_id" {
-                                            user_id = Some(value.to_string());
-                                        }
-                                    }
-
-                                    let post_auth_url =
-                                        format!("{}/native_app_signin_succeeded", *ZED_SERVER_URL);
-                                    req.respond(
-                                        tiny_http::Response::empty(302).with_header(
-                                            tiny_http::Header::from_bytes(
-                                                &b"Location"[..],
-                                                post_auth_url.as_bytes(),
-                                            )
-                                            .unwrap(),
-                                        ),
-                                    )
-                                    .context("failed to respond to login http request")?;
-                                    return Ok((
-                                        user_id
-                                            .ok_or_else(|| anyhow!("missing user_id parameter"))?,
-                                        access_token.ok_or_else(|| {
-                                            anyhow!("missing access_token parameter")
-                                        })?,
-                                    ));
+            // Receive the HTTP request from the user's browser. Retrieve the user id and encrypted
+            // access token from the query params.
+            //
+            // TODO - Avoid ever starting more than one HTTP server. Maybe switch to using a
+            // custom URL scheme instead of this local HTTP server.
+            let (user_id, access_token) = cx
+                .spawn(|_| async move {
+                    for _ in 0..100 {
+                        if let Some(req) = server.recv_timeout(Duration::from_secs(1))? {
+                            let path = req.url();
+                            let mut user_id = None;
+                            let mut access_token = None;
+                            let url = Url::parse(&format!("http://example.com{}", path))
+                                .context("failed to parse login notification url")?;
+                            for (key, value) in url.query_pairs() {
+                                if key == "access_token" {
+                                    access_token = Some(value.to_string());
+                                } else if key == "user_id" {
+                                    user_id = Some(value.to_string());
                                }
                            }

-                            Err(anyhow!("didn't receive login redirect"))
-                        })
-                        .await?;
+                            let post_auth_url =
+                                format!("{}/native_app_signin_succeeded", *ZED_SERVER_URL);
+                            req.respond(
+                                tiny_http::Response::empty(302).with_header(
+                                    tiny_http::Header::from_bytes(
+                                        &b"Location"[..],
+                                        post_auth_url.as_bytes(),
+                                    )
+                                    .unwrap(),
+                                ),
+                            )
+                            .context("failed to respond to login http request")?;
+                            return Ok((
+                                user_id.ok_or_else(|| anyhow!("missing user_id parameter"))?,
+                                access_token
+                                    .ok_or_else(|| anyhow!("missing access_token parameter"))?,
+                            ));
+                        }
+                    }

-                    let access_token = private_key
-                        .decrypt_string(&access_token)
-                        .context("failed to decrypt access token")?;
-
-                    Ok(Credentials {
-                        user_id: user_id.parse()?,
-                        access_token,
-                    })
+                    Err(anyhow!("didn't receive login redirect"))
                })
                .await?;

+            let access_token = private_key
+                .decrypt_string(&access_token)
+                .context("failed to decrypt access token")?;
            cx.update(|cx| cx.activate(true))?;
-            Ok(credentials)
+
+            Ok(Credentials {
+                user_id: user_id.parse()?,
+                access_token,
+            })
        })
    }

@@ -1349,7 +1325,7 @@ impl Client {
    }
 }

-fn read_credentials_from_keychain(cx: &AsyncAppContext) -> Option<Credentials> {
+async fn read_credentials_from_keychain(cx: &AsyncAppContext) -> Option<Credentials> {
    if IMPERSONATE_LOGIN.is_some() {
        return None;
    }
--- a/crates/client2/src/telemetry.rs
+++ b/crates/client2/src/telemetry.rs
@@ -1,6 +1,5 @@
 use crate::{TelemetrySettings, ZED_SECRET_CLIENT_TOKEN, ZED_SERVER_URL};
 use chrono::{DateTime, Utc};
-use futures::Future;
 use gpui::{serde_json, AppContext, AppMetadata, BackgroundExecutor, Task};
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
@@ -108,10 +107,6 @@ pub enum ClickhouseEvent {
        virtual_memory_in_bytes: u64,
        milliseconds_since_first_event: i64,
    },
-    App {
-        operation: &'static str,
-        milliseconds_since_first_event: i64,
-    },
 }

 #[cfg(debug_assertions)]
@@ -127,13 +122,12 @@ const DEBOUNCE_INTERVAL: Duration = Duration::from_secs(1);
 const DEBOUNCE_INTERVAL: Duration = Duration::from_secs(30);

 impl Telemetry {
-    pub fn new(client: Arc<dyn HttpClient>, cx: &mut AppContext) -> Arc<Self> {
+    pub fn new(client: Arc<dyn HttpClient>, cx: &AppContext) -> Arc<Self> {
        let release_channel = if cx.has_global::<ReleaseChannel>() {
            Some(cx.global::<ReleaseChannel>().display_name())
        } else {
            None
        };
-
        // TODO: Replace all hardware stuff with nested SystemSpecs json
        let this = Arc::new(Self {
            http_client: client,
@@ -153,30 +147,9 @@ impl Telemetry {
            }),
        });

-        // We should only ever have one instance of Telemetry, leak the subscription to keep it alive
-        // rather than store in TelemetryState, complicating spawn as subscriptions are not Send
-        std::mem::forget(cx.on_app_quit({
-            let this = this.clone();
-            move |cx| this.shutdown_telemetry(cx)
-        }));
-
        this
    }

-    #[cfg(any(test, feature = "test-support"))]
-    fn shutdown_telemetry(self: &Arc<Self>, _: &mut AppContext) -> impl Future<Output = ()> {
-        Task::ready(())
-    }
-
-    // Skip calling this function in tests.
-    // TestAppContext ends up calling this function on shutdown and it panics when trying to find the TelemetrySettings
-    #[cfg(not(any(test, feature = "test-support")))]
-    fn shutdown_telemetry(self: &Arc<Self>, cx: &mut AppContext) -> impl Future<Output = ()> {
-        let telemetry_settings = TelemetrySettings::get_global(cx).clone();
-        self.report_app_event(telemetry_settings, "close");
-        Task::ready(())
-    }
-
    pub fn log_file_path(&self) -> Option<PathBuf> {
        Some(self.state.lock().log_file.as_ref()?.path().to_path_buf())
    }
@@ -190,8 +163,13 @@ impl Telemetry {
        let mut state = self.state.lock();
        state.installation_id = installation_id.map(|id| id.into());
        state.session_id = Some(session_id.into());
+        let has_clickhouse_events = !state.clickhouse_events_queue.is_empty();
        drop(state);

+        if has_clickhouse_events {
+            self.flush_clickhouse_events();
+        }
+
        let this = self.clone();
        cx.spawn(|cx| async move {
            // Avoiding calling `System::new_all()`, as there have been crashes related to it
@@ -279,7 +257,7 @@ impl Telemetry {
            milliseconds_since_first_event: self.milliseconds_since_first_event(),
        };

-        self.report_clickhouse_event(event, telemetry_settings, false)
+        self.report_clickhouse_event(event, telemetry_settings)
    }

    pub fn report_copilot_event(
@@ -296,7 +274,7 @@ impl Telemetry {
            milliseconds_since_first_event: self.milliseconds_since_first_event(),
        };

-        self.report_clickhouse_event(event, telemetry_settings, false)
+        self.report_clickhouse_event(event, telemetry_settings)
    }

    pub fn report_assistant_event(
@@ -313,7 +291,7 @@ impl Telemetry {
            milliseconds_since_first_event: self.milliseconds_since_first_event(),
        };

-        self.report_clickhouse_event(event, telemetry_settings, false)
+        self.report_clickhouse_event(event, telemetry_settings)
    }

    pub fn report_call_event(
@@ -330,7 +308,7 @@ impl Telemetry {
            milliseconds_since_first_event: self.milliseconds_since_first_event(),
        };

-        self.report_clickhouse_event(event, telemetry_settings, false)
+        self.report_clickhouse_event(event, telemetry_settings)
    }

    pub fn report_cpu_event(
@@ -345,7 +323,7 @@ impl Telemetry {
            milliseconds_since_first_event: self.milliseconds_since_first_event(),
        };

-        self.report_clickhouse_event(event, telemetry_settings, false)
+        self.report_clickhouse_event(event, telemetry_settings)
    }

    pub fn report_memory_event(
@@ -360,21 +338,7 @@ impl Telemetry {
            milliseconds_since_first_event: self.milliseconds_since_first_event(),
        };

-        self.report_clickhouse_event(event, telemetry_settings, false)
-    }
-
-    // app_events are called at app open and app close, so flush is set to immediately send
-    pub fn report_app_event(
-        self: &Arc<Self>,
-        telemetry_settings: TelemetrySettings,
-        operation: &'static str,
-    ) {
-        let event = ClickhouseEvent::App {
-            operation,
-            milliseconds_since_first_event: self.milliseconds_since_first_event(),
-        };
-
-        self.report_clickhouse_event(event, telemetry_settings, true)
+        self.report_clickhouse_event(event, telemetry_settings)
    }

    fn milliseconds_since_first_event(&self) -> i64 {
@@ -395,7 +359,6 @@ impl Telemetry {
        self: &Arc<Self>,
        event: ClickhouseEvent,
        telemetry_settings: TelemetrySettings,
-        immediate_flush: bool,
    ) {
        if !telemetry_settings.metrics {
            return;
@@ -408,7 +371,7 @@ impl Telemetry {
            .push(ClickhouseEventWrapper { signed_in, event });

        if state.installation_id.is_some() {
-            if immediate_flush || state.clickhouse_events_queue.len() >= MAX_QUEUE_LEN {
+            if state.clickhouse_events_queue.len() >= MAX_QUEUE_LEN {
                drop(state);
                self.flush_clickhouse_events();
            } else {
--- a/crates/client2/src/test.rs
+++ b/crates/client2/src/test.rs
@@ -8,6 +8,7 @@ use rpc::{
    ConnectionId, Peer, Receipt, TypedEnvelope,
 };
 use std::sync::Arc;
+use util::http::FakeHttpClient;

 pub struct FakeServer {
    peer: Arc<Peer>,
@@ -194,7 +195,8 @@ impl FakeServer {
        client: Arc<Client>,
        cx: &mut TestAppContext,
    ) -> Model<UserStore> {
-        let user_store = cx.build_model(|cx| UserStore::new(client, cx));
+        let http_client = FakeHttpClient::with_404_response();
+        let user_store = cx.build_model(|cx| UserStore::new(client, http_client, cx));
        assert_eq!(
            self.receive::<proto::GetUsers>()
                .await
--- a/crates/client2/src/user.rs
+++ b/crates/client2/src/user.rs
@@ -2,12 +2,13 @@ use super::{proto, Client, Status, TypedEnvelope};
 use anyhow::{anyhow, Context, Result};
 use collections::{hash_map::Entry, HashMap, HashSet};
 use feature_flags::FeatureFlagAppExt;
-use futures::{channel::mpsc, Future, StreamExt};
-use gpui::{AsyncAppContext, EventEmitter, Model, ModelContext, SharedString, Task};
+use futures::{channel::mpsc, future, AsyncReadExt, Future, StreamExt};
+use gpui::{AsyncAppContext, EventEmitter, ImageData, Model, ModelContext, Task};
 use postage::{sink::Sink, watch};
 use rpc::proto::{RequestMessage, UsersResponse};
 use std::sync::{Arc, Weak};
 use text::ReplicaId;
+use util::http::HttpClient;
 use util::TryFutureExt as _;

 pub type UserId = u64;
@@ -19,7 +20,7 @@ pub struct ParticipantIndex(pub u32);
 pub struct User {
    pub id: UserId,
    pub github_login: String,
-    pub avatar_uri: SharedString,
+    pub avatar: Option<Arc<ImageData>>,
 }

 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -75,6 +76,7 @@ pub struct UserStore {
    pending_contact_requests: HashMap<u64, usize>,
    invite_info: Option<InviteInfo>,
    client: Weak<Client>,
+    http: Arc<dyn HttpClient>,
    _maintain_contacts: Task<()>,
    _maintain_current_user: Task<Result<()>>,
 }
@@ -110,7 +112,11 @@ enum UpdateContacts {
 }

 impl UserStore {
-    pub fn new(client: Arc<Client>, cx: &mut ModelContext<Self>) -> Self {
+    pub fn new(
+        client: Arc<Client>,
+        http: Arc<dyn HttpClient>,
+        cx: &mut ModelContext<Self>,
+    ) -> Self {
        let (mut current_user_tx, current_user_rx) = watch::channel();
        let (update_contacts_tx, mut update_contacts_rx) = mpsc::unbounded();
        let rpc_subscriptions = vec![
@@ -128,6 +134,7 @@ impl UserStore {
            invite_info: None,
            client: Arc::downgrade(&client),
            update_contacts_tx,
+            http,
            _maintain_contacts: cx.spawn(|this, mut cx| async move {
                let _subscriptions = rpc_subscriptions;
                while let Some(message) = update_contacts_rx.next().await {
@@ -438,12 +445,6 @@ impl UserStore {
        self.perform_contact_request(user_id, proto::RemoveContact { user_id }, cx)
    }

-    pub fn has_incoming_contact_request(&self, user_id: u64) -> bool {
-        self.incoming_contact_requests
-            .iter()
-            .any(|user| user.id == user_id)
-    }
-
    pub fn respond_to_contact_request(
        &mut self,
        requester_id: u64,
@@ -615,14 +616,17 @@ impl UserStore {
        cx: &mut ModelContext<Self>,
    ) -> Task<Result<Vec<Arc<User>>>> {
        let client = self.client.clone();
+        let http = self.http.clone();
        cx.spawn(|this, mut cx| async move {
            if let Some(rpc) = client.upgrade() {
                let response = rpc.request(request).await.context("error loading users")?;
-                let users = response
-                    .users
-                    .into_iter()
-                    .map(|user| User::new(user))
-                    .collect::<Vec<_>>();
+                let users = future::join_all(
+                    response
+                        .users
+                        .into_iter()
+                        .map(|user| User::new(user, http.as_ref())),
+                )
+                .await;

                this.update(&mut cx, |this, _| {
                    for user in &users {
@@ -655,11 +659,11 @@ impl UserStore {
 }

 impl User {
-    fn new(message: proto::User) -> Arc<Self> {
+    async fn new(message: proto::User, http: &dyn HttpClient) -> Arc<Self> {
        Arc::new(User {
            id: message.id,
            github_login: message.github_login,
-            avatar_uri: message.avatar_url.into(),
+            avatar: fetch_avatar(http, &message.avatar_url).warn_on_err().await,
        })
    }
 }
@@ -692,3 +696,25 @@ impl Collaborator {
        })
    }
 }
+
+// todo!("we probably don't need this now that we fetch")
+async fn fetch_avatar(http: &dyn HttpClient, url: &str) -> Result<Arc<ImageData>> {
+    let mut response = http
+        .get(url, Default::default(), true)
+        .await
+        .map_err(|e| anyhow!("failed to send user avatar request: {}", e))?;
+
+    if !response.status().is_success() {
+        return Err(anyhow!("avatar request failed {:?}", response.status()));
+    }
+
+    let mut body = Vec::new();
+    response
+        .body_mut()
+        .read_to_end(&mut body)
+        .await
+        .map_err(|e| anyhow!("failed to read user avatar response body: {}", e))?;
+    let format = image::guess_format(&body)?;
+    let image = image::load_from_memory_with_format(&body, format)?.into_bgra8();
+    Ok(Arc::new(ImageData::new(image)))
+}
--- 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.31.0"
+version = "0.28.0"
 publish = false

 [[bin]]
--- a/crates/collab/src/api.rs
+++ b/crates/collab/src/api.rs
@@ -116,14 +116,12 @@ struct CreateUserResponse {
 #[derive(Debug, Deserialize)]
 struct Panic {
    version: String,
-    release_channel: String,
-    backtrace_hash: String,
    text: String,
 }

 #[instrument(skip(panic))]
 async fn trace_panic(panic: Json<Panic>) -> Result<()> {
-    tracing::error!(version = %panic.version, release_channel = %panic.release_channel, backtrace_hash = %panic.backtrace_hash, text = %panic.text, "panic report");
+    tracing::error!(version = %panic.version, text = %panic.text, "panic report");
    Ok(())
 }

--- a/crates/collab/src/db/queries/channels.rs
+++ b/crates/collab/src/db/queries/channels.rs
@@ -1220,13 +1220,6 @@ impl Database {
                self.check_user_is_channel_admin(&new_parent, admin_id, &*tx)
                    .await?;

-                if new_parent
-                    .ancestors_including_self()
-                    .any(|id| id == channel.id)
-                {
-                    Err(anyhow!("cannot move a channel into one of its descendants"))?;
-                }
-
                new_parent_path = new_parent.path();
                new_parent_channel = Some(new_parent);
            } else {
--- a/crates/collab/src/db/tests/channel_tests.rs
+++ b/crates/collab/src/db/tests/channel_tests.rs
@@ -450,20 +450,6 @@ async fn test_db_channel_moving_bugs(db: &Arc<Database>) {
            (livestreaming_id, &[projects_id]),
        ],
    );
-
-    // Can't move a channel into its ancestor
-    db.move_channel(projects_id, Some(livestreaming_id), user_id)
-        .await
-        .unwrap_err();
-    let result = db.get_channels_for_user(user_id).await.unwrap();
-    assert_channel_tree(
-        result.channels,
-        &[
-            (zed_id, &[]),
-            (projects_id, &[]),
-            (livestreaming_id, &[projects_id]),
-        ],
-    );
 }

 test_both_dbs!(
--- a/crates/collab/src/tests/following_tests.rs
+++ b/crates/collab/src/tests/following_tests.rs
@@ -4,10 +4,8 @@ use collab_ui::notifications::project_shared_notification::ProjectSharedNotifica
 use editor::{Editor, ExcerptRange, MultiBuffer};
 use gpui::{executor::Deterministic, geometry::vector::vec2f, TestAppContext, ViewHandle};
 use live_kit_client::MacOSDisplay;
-use project::project_settings::ProjectSettings;
 use rpc::proto::PeerId;
 use serde_json::json;
-use settings::SettingsStore;
 use std::{borrow::Cow, sync::Arc};
 use workspace::{
    dock::{test::TestPanel, DockPosition},
@@ -1604,141 +1602,6 @@ async fn test_following_across_workspaces(
    });
 }

-#[gpui::test]
-async fn test_following_into_excluded_file(
-    deterministic: Arc<Deterministic>,
-    mut cx_a: &mut TestAppContext,
-    mut 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;
-    for cx in [&mut cx_a, &mut cx_b] {
-        cx.update(|cx| {
-            cx.update_global::<SettingsStore, _, _>(|store, cx| {
-                store.update_user_settings::<ProjectSettings>(cx, |project_settings| {
-                    project_settings.file_scan_exclusions = Some(vec!["**/.git".to_string()]);
-                });
-            });
-        });
-    }
-    server
-        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
-        .await;
-    let active_call_a = cx_a.read(ActiveCall::global);
-    let active_call_b = cx_b.read(ActiveCall::global);
-
-    cx_a.update(editor::init);
-    cx_b.update(editor::init);
-
-    client_a
-        .fs()
-        .insert_tree(
-            "/a",
-            json!({
-                ".git": {
-                    "COMMIT_EDITMSG": "write your commit message here",
-                },
-                "1.txt": "one\none\none",
-                "2.txt": "two\ntwo\ntwo",
-                "3.txt": "three\nthree\nthree",
-            }),
-        )
-        .await;
-    let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
-    active_call_a
-        .update(cx_a, |call, cx| call.set_location(Some(&project_a), cx))
-        .await
-        .unwrap();
-
-    let project_id = active_call_a
-        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
-        .await
-        .unwrap();
-    let project_b = client_b.build_remote_project(project_id, cx_b).await;
-    active_call_b
-        .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
-        .await
-        .unwrap();
-
-    let window_a = client_a.build_workspace(&project_a, cx_a);
-    let workspace_a = window_a.root(cx_a);
-    let peer_id_a = client_a.peer_id().unwrap();
-    let window_b = client_b.build_workspace(&project_b, cx_b);
-    let workspace_b = window_b.root(cx_b);
-
-    // Client A opens editors for a regular file and an excluded file.
-    let editor_for_regular = workspace_a
-        .update(cx_a, |workspace, cx| {
-            workspace.open_path((worktree_id, "1.txt"), None, true, cx)
-        })
-        .await
-        .unwrap()
-        .downcast::<Editor>()
-        .unwrap();
-    let editor_for_excluded_a = workspace_a
-        .update(cx_a, |workspace, cx| {
-            workspace.open_path((worktree_id, ".git/COMMIT_EDITMSG"), None, true, cx)
-        })
-        .await
-        .unwrap()
-        .downcast::<Editor>()
-        .unwrap();
-
-    // Client A updates their selections in those editors
-    editor_for_regular.update(cx_a, |editor, cx| {
-        editor.handle_input("a", cx);
-        editor.handle_input("b", cx);
-        editor.handle_input("c", cx);
-        editor.select_left(&Default::default(), cx);
-        assert_eq!(editor.selections.ranges(cx), vec![3..2]);
-    });
-    editor_for_excluded_a.update(cx_a, |editor, cx| {
-        editor.select_all(&Default::default(), cx);
-        editor.handle_input("new commit message", cx);
-        editor.select_left(&Default::default(), cx);
-        assert_eq!(editor.selections.ranges(cx), vec![18..17]);
-    });
-
-    // When client B starts following client A, currently visible file is replicated
-    workspace_b
-        .update(cx_b, |workspace, cx| {
-            workspace.follow(peer_id_a, cx).unwrap()
-        })
-        .await
-        .unwrap();
-
-    let editor_for_excluded_b = workspace_b.read_with(cx_b, |workspace, cx| {
-        workspace
-            .active_item(cx)
-            .unwrap()
-            .downcast::<Editor>()
-            .unwrap()
-    });
-    assert_eq!(
-        cx_b.read(|cx| editor_for_excluded_b.project_path(cx)),
-        Some((worktree_id, ".git/COMMIT_EDITMSG").into())
-    );
-    assert_eq!(
-        editor_for_excluded_b.read_with(cx_b, |editor, cx| editor.selections.ranges(cx)),
-        vec![18..17]
-    );
-
-    // Changes from B to the excluded file are replicated in A's editor
-    editor_for_excluded_b.update(cx_b, |editor, cx| {
-        editor.handle_input("\nCo-Authored-By: B <b@b.b>", cx);
-    });
-    deterministic.run_until_parked();
-    editor_for_excluded_a.update(cx_a, |editor, cx| {
-        assert_eq!(
-            editor.text(cx),
-            "new commit messag\nCo-Authored-By: B <b@b.b>"
-        );
-    });
-}
-
 fn visible_push_notifications(
    cx: &mut TestAppContext,
 ) -> Vec<gpui::ViewHandle<ProjectSharedNotification>> {
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -2981,10 +2981,11 @@ async fn test_fs_operations(

    let entry = project_b
        .update(cx_b, |project, cx| {
-            project.create_entry((worktree_id, "c.txt"), false, cx)
+            project
+                .create_entry((worktree_id, "c.txt"), false, cx)
+                .unwrap()
        })
        .await
-        .unwrap()
        .unwrap();
    worktree_a.read_with(cx_a, |worktree, _| {
        assert_eq!(
@@ -3009,6 +3010,7 @@ async fn test_fs_operations(
        .update(cx_b, |project, cx| {
            project.rename_entry(entry.id, Path::new("d.txt"), cx)
        })
+        .unwrap()
        .await
        .unwrap();
    worktree_a.read_with(cx_a, |worktree, _| {
@@ -3032,10 +3034,11 @@ async fn test_fs_operations(

    let dir_entry = project_b
        .update(cx_b, |project, cx| {
-            project.create_entry((worktree_id, "DIR"), true, cx)
+            project
+                .create_entry((worktree_id, "DIR"), true, cx)
+                .unwrap()
        })
        .await
-        .unwrap()
        .unwrap();
    worktree_a.read_with(cx_a, |worktree, _| {
        assert_eq!(
@@ -3058,19 +3061,25 @@ async fn test_fs_operations(

    project_b
        .update(cx_b, |project, cx| {
-            project.create_entry((worktree_id, "DIR/e.txt"), false, cx)
+            project
+                .create_entry((worktree_id, "DIR/e.txt"), false, cx)
+                .unwrap()
        })
        .await
        .unwrap();
    project_b
        .update(cx_b, |project, cx| {
-            project.create_entry((worktree_id, "DIR/SUBDIR"), true, cx)
+            project
+                .create_entry((worktree_id, "DIR/SUBDIR"), true, cx)
+                .unwrap()
        })
        .await
        .unwrap();
    project_b
        .update(cx_b, |project, cx| {
-            project.create_entry((worktree_id, "DIR/SUBDIR/f.txt"), false, cx)
+            project
+                .create_entry((worktree_id, "DIR/SUBDIR/f.txt"), false, cx)
+                .unwrap()
        })
        .await
        .unwrap();
@@ -3111,7 +3120,9 @@ async fn test_fs_operations(

    project_b
        .update(cx_b, |project, cx| {
-            project.copy_entry(entry.id, Path::new("f.txt"), cx)
+            project
+                .copy_entry(entry.id, Path::new("f.txt"), cx)
+                .unwrap()
        })
        .await
        .unwrap();
@@ -3930,7 +3941,7 @@ async fn test_collaborating_with_diagnostics(
    // Ensure client B observes the new diagnostics.
    project_b.read_with(cx_b, |project, cx| {
        assert_eq!(
-            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
+            project.diagnostic_summaries(cx).collect::<Vec<_>>(),
            &[(
                ProjectPath {
                    worktree_id,
@@ -3950,14 +3961,14 @@ async fn test_collaborating_with_diagnostics(
    let project_c = client_c.build_remote_project(project_id, cx_c).await;
    let project_c_diagnostic_summaries =
        Rc::new(RefCell::new(project_c.read_with(cx_c, |project, cx| {
-            project.diagnostic_summaries(false, cx).collect::<Vec<_>>()
+            project.diagnostic_summaries(cx).collect::<Vec<_>>()
        })));
    project_c.update(cx_c, |_, cx| {
        let summaries = project_c_diagnostic_summaries.clone();
        cx.subscribe(&project_c, {
            move |p, _, event, cx| {
                if let project::Event::DiskBasedDiagnosticsFinished { .. } = event {
-                    *summaries.borrow_mut() = p.diagnostic_summaries(false, cx).collect();
+                    *summaries.borrow_mut() = p.diagnostic_summaries(cx).collect();
                }
            }
        })
@@ -4007,7 +4018,7 @@ async fn test_collaborating_with_diagnostics(
    deterministic.run_until_parked();
    project_b.read_with(cx_b, |project, cx| {
        assert_eq!(
-            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
+            project.diagnostic_summaries(cx).collect::<Vec<_>>(),
            [(
                ProjectPath {
                    worktree_id,
@@ -4023,7 +4034,7 @@ async fn test_collaborating_with_diagnostics(
    });
    project_c.read_with(cx_c, |project, cx| {
        assert_eq!(
-            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
+            project.diagnostic_summaries(cx).collect::<Vec<_>>(),
            [(
                ProjectPath {
                    worktree_id,
@@ -4086,22 +4097,13 @@ async fn test_collaborating_with_diagnostics(
    );
    deterministic.run_until_parked();
    project_a.read_with(cx_a, |project, cx| {
-        assert_eq!(
-            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
-            []
-        )
+        assert_eq!(project.diagnostic_summaries(cx).collect::<Vec<_>>(), [])
    });
    project_b.read_with(cx_b, |project, cx| {
-        assert_eq!(
-            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
-            []
-        )
+        assert_eq!(project.diagnostic_summaries(cx).collect::<Vec<_>>(), [])
    });
    project_c.read_with(cx_c, |project, cx| {
-        assert_eq!(
-            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
-            []
-        )
+        assert_eq!(project.diagnostic_summaries(cx).collect::<Vec<_>>(), [])
    });
 }

--- a/crates/collab/src/tests/random_project_collaboration_tests.rs
+++ b/crates/collab/src/tests/random_project_collaboration_tests.rs
@@ -665,6 +665,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                ensure_project_shared(&project, client, cx).await;
                project
                    .update(cx, |p, cx| p.create_entry(project_path, is_dir, cx))
+                    .unwrap()
                    .await?;
            }

--- a/crates/collab2/Cargo.toml
+++ b/crates/collab2/Cargo.toml
@@ -10,7 +10,7 @@ publish = false
 name = "collab2"

 [[bin]]
-name = "seed2"
+name = "seed"
 required-features = ["seed-support"]

 [dependencies]
@@ -81,7 +81,7 @@ settings = { package = "settings2", path = "../settings2", features = ["test-sup
 theme = { package = "theme2", path = "../theme2" }
 workspace = { package = "workspace2", path = "../workspace2", features = ["test-support"] }

-collab_ui = { path = "../collab_ui2", package = "collab_ui2", features = ["test-support"] }
+collab_ui = { path = "../collab_ui", features = ["test-support"] }

 async-trait.workspace = true
 pretty_assertions.workspace = true
--- a/crates/collab2/src/api.rs
+++ b/crates/collab2/src/api.rs
@@ -116,14 +116,12 @@ struct CreateUserResponse {
 #[derive(Debug, Deserialize)]
 struct Panic {
    version: String,
-    release_channel: String,
-    backtrace_hash: String,
    text: String,
 }

 #[instrument(skip(panic))]
 async fn trace_panic(panic: Json<Panic>) -> Result<()> {
-    tracing::error!(version = %panic.version, release_channel = %panic.release_channel, backtrace_hash = %panic.backtrace_hash, text = %panic.text, "panic report");
+    tracing::error!(version = %panic.version, text = %panic.text, "panic report");
    Ok(())
 }

--- a/crates/collab2/src/bin/dotenv2.rs
+++ b/crates/collab2/src/bin/dotenv2.rs
--- a/crates/collab2/src/bin/seed2.rs
+++ b/crates/collab2/src/bin/seed2.rs
--- a/crates/collab2/src/db/queries/channels.rs
+++ b/crates/collab2/src/db/queries/channels.rs
@@ -1220,13 +1220,6 @@ impl Database {
                self.check_user_is_channel_admin(&new_parent, admin_id, &*tx)
                    .await?;

-                if new_parent
-                    .ancestors_including_self()
-                    .any(|id| id == channel.id)
-                {
-                    Err(anyhow!("cannot move a channel into one of its descendants"))?;
-                }
-
                new_parent_path = new_parent.path();
                new_parent_channel = Some(new_parent);
            } else {
--- a/crates/collab2/src/db/tests/channel_tests.rs
+++ b/crates/collab2/src/db/tests/channel_tests.rs
@@ -420,6 +420,8 @@ async fn test_db_channel_moving_bugs(db: &Arc<Database>) {
        .await
        .unwrap();

+    // Dag is: zed - projects - livestreaming
+
    // Move to same parent should be a no-op
    assert!(db
        .move_channel(projects_id, Some(zed_id), user_id)
@@ -448,20 +450,6 @@ async fn test_db_channel_moving_bugs(db: &Arc<Database>) {
            (livestreaming_id, &[projects_id]),
        ],
    );
-
-    // Can't move a channel into its ancestor
-    db.move_channel(projects_id, Some(livestreaming_id), user_id)
-        .await
-        .unwrap_err();
-    let result = db.get_channels_for_user(user_id).await.unwrap();
-    assert_channel_tree(
-        result.channels,
-        &[
-            (zed_id, &[]),
-            (projects_id, &[]),
-            (livestreaming_id, &[projects_id]),
-        ],
-    );
 }

 test_both_dbs!(
--- a/crates/collab2/src/tests/channel_buffer_tests.rs
+++ b/crates/collab2/src/tests/channel_buffer_tests.rs
--- a/crates/collab2/src/tests/channel_tests.rs
+++ b/crates/collab2/src/tests/channel_tests.rs
@@ -7,7 +7,7 @@ use call::ActiveCall;
 use channel::{ChannelId, ChannelMembership, ChannelStore};
 use client::User;
 use futures::future::try_join_all;
-use gpui::{BackgroundExecutor, Model, SharedString, TestAppContext};
+use gpui::{BackgroundExecutor, Model, TestAppContext};
 use rpc::{
    proto::{self, ChannelRole},
    RECEIVE_TIMEOUT,
@@ -46,13 +46,13 @@ async fn test_core_channels(
        &[
            ExpectedChannel {
                id: channel_a_id,
-                name: "channel-a".into(),
+                name: "channel-a".to_string(),
                depth: 0,
                role: ChannelRole::Admin,
            },
            ExpectedChannel {
                id: channel_b_id,
-                name: "channel-b".into(),
+                name: "channel-b".to_string(),
                depth: 1,
                role: ChannelRole::Admin,
            },
@@ -92,7 +92,7 @@ async fn test_core_channels(
        cx_b,
        &[ExpectedChannel {
            id: channel_a_id,
-            name: "channel-a".into(),
+            name: "channel-a".to_string(),
            depth: 0,
            role: ChannelRole::Member,
        }],
@@ -140,13 +140,13 @@ async fn test_core_channels(
        &[
            ExpectedChannel {
                id: channel_a_id,
-                name: "channel-a".into(),
+                name: "channel-a".to_string(),
                role: ChannelRole::Member,
                depth: 0,
            },
            ExpectedChannel {
                id: channel_b_id,
-                name: "channel-b".into(),
+                name: "channel-b".to_string(),
                role: ChannelRole::Member,
                depth: 1,
            },
@@ -168,19 +168,19 @@ async fn test_core_channels(
        &[
            ExpectedChannel {
                id: channel_a_id,
-                name: "channel-a".into(),
+                name: "channel-a".to_string(),
                role: ChannelRole::Member,
                depth: 0,
            },
            ExpectedChannel {
                id: channel_b_id,
-                name: "channel-b".into(),
+                name: "channel-b".to_string(),
                role: ChannelRole::Member,
                depth: 1,
            },
            ExpectedChannel {
                id: channel_c_id,
-                name: "channel-c".into(),
+                name: "channel-c".to_string(),
                role: ChannelRole::Member,
                depth: 2,
            },
@@ -211,19 +211,19 @@ async fn test_core_channels(
        &[
            ExpectedChannel {
                id: channel_a_id,
-                name: "channel-a".into(),
+                name: "channel-a".to_string(),
                depth: 0,
                role: ChannelRole::Admin,
            },
            ExpectedChannel {
                id: channel_b_id,
-                name: "channel-b".into(),
+                name: "channel-b".to_string(),
                depth: 1,
                role: ChannelRole::Admin,
            },
            ExpectedChannel {
                id: channel_c_id,
-                name: "channel-c".into(),
+                name: "channel-c".to_string(),
                depth: 2,
                role: ChannelRole::Admin,
            },
@@ -245,7 +245,7 @@ async fn test_core_channels(
        cx_a,
        &[ExpectedChannel {
            id: channel_a_id,
-            name: "channel-a".into(),
+            name: "channel-a".to_string(),
            depth: 0,
            role: ChannelRole::Admin,
        }],
@@ -255,7 +255,7 @@ async fn test_core_channels(
        cx_b,
        &[ExpectedChannel {
            id: channel_a_id,
-            name: "channel-a".into(),
+            name: "channel-a".to_string(),
            depth: 0,
            role: ChannelRole::Admin,
        }],
@@ -278,7 +278,7 @@ async fn test_core_channels(
        cx_a,
        &[ExpectedChannel {
            id: channel_a_id,
-            name: "channel-a".into(),
+            name: "channel-a".to_string(),
            depth: 0,
            role: ChannelRole::Admin,
        }],
@@ -309,7 +309,7 @@ async fn test_core_channels(
        cx_a,
        &[ExpectedChannel {
            id: channel_a_id,
-            name: "channel-a-renamed".into(),
+            name: "channel-a-renamed".to_string(),
            depth: 0,
            role: ChannelRole::Admin,
        }],
@@ -418,7 +418,7 @@ async fn test_channel_room(
        cx_b,
        &[ExpectedChannel {
            id: zed_id,
-            name: "zed".into(),
+            name: "zed".to_string(),
            depth: 0,
            role: ChannelRole::Member,
        }],
@@ -680,7 +680,7 @@ async fn test_permissions_update_while_invited(
        &[ExpectedChannel {
            depth: 0,
            id: rust_id,
-            name: "rust".into(),
+            name: "rust".to_string(),
            role: ChannelRole::Member,
        }],
    );
@@ -708,7 +708,7 @@ async fn test_permissions_update_while_invited(
        &[ExpectedChannel {
            depth: 0,
            id: rust_id,
-            name: "rust".into(),
+            name: "rust".to_string(),
            role: ChannelRole::Member,
        }],
    );
@@ -747,7 +747,7 @@ async fn test_channel_rename(
        &[ExpectedChannel {
            depth: 0,
            id: rust_id,
-            name: "rust-archive".into(),
+            name: "rust-archive".to_string(),
            role: ChannelRole::Admin,
        }],
    );
@@ -759,7 +759,7 @@ async fn test_channel_rename(
        &[ExpectedChannel {
            depth: 0,
            id: rust_id,
-            name: "rust-archive".into(),
+            name: "rust-archive".to_string(),
            role: ChannelRole::Member,
        }],
    );
@@ -888,7 +888,7 @@ async fn test_lost_channel_creation(
        &[ExpectedChannel {
            depth: 0,
            id: channel_id,
-            name: "x".into(),
+            name: "x".to_string(),
            role: ChannelRole::Member,
        }],
    );
@@ -912,13 +912,13 @@ async fn test_lost_channel_creation(
            ExpectedChannel {
                depth: 0,
                id: channel_id,
-                name: "x".into(),
+                name: "x".to_string(),
                role: ChannelRole::Admin,
            },
            ExpectedChannel {
                depth: 1,
                id: subchannel_id,
-                name: "subchannel".into(),
+                name: "subchannel".to_string(),
                role: ChannelRole::Admin,
            },
        ],
@@ -943,13 +943,13 @@ async fn test_lost_channel_creation(
            ExpectedChannel {
                depth: 0,
                id: channel_id,
-                name: "x".into(),
+                name: "x".to_string(),
                role: ChannelRole::Member,
            },
            ExpectedChannel {
                depth: 1,
                id: subchannel_id,
-                name: "subchannel".into(),
+                name: "subchannel".to_string(),
                role: ChannelRole::Member,
            },
        ],
@@ -1221,13 +1221,13 @@ async fn test_channel_membership_notifications(
            ExpectedChannel {
                depth: 0,
                id: zed_channel,
-                name: "zed".into(),
+                name: "zed".to_string(),
                role: ChannelRole::Guest,
            },
            ExpectedChannel {
                depth: 1,
                id: vim_channel,
-                name: "vim".into(),
+                name: "vim".to_string(),
                role: ChannelRole::Member,
            },
        ],
@@ -1250,13 +1250,13 @@ async fn test_channel_membership_notifications(
            ExpectedChannel {
                depth: 0,
                id: zed_channel,
-                name: "zed".into(),
+                name: "zed".to_string(),
                role: ChannelRole::Guest,
            },
            ExpectedChannel {
                depth: 1,
                id: vim_channel,
-                name: "vim".into(),
+                name: "vim".to_string(),
                role: ChannelRole::Guest,
            },
        ],
@@ -1476,7 +1476,7 @@ async fn test_channel_moving(
 struct ExpectedChannel {
    depth: usize,
    id: ChannelId,
-    name: SharedString,
+    name: String,
    role: ChannelRole,
 }

@@ -1515,7 +1515,7 @@ fn assert_channels(
                .ordered_channels()
                .map(|(depth, channel)| ExpectedChannel {
                    depth,
-                    name: channel.name.clone().into(),
+                    name: channel.name.clone(),
                    id: channel.id,
                    role: channel.role,
                })
--- a/crates/collab2/src/tests/following_tests.rs
+++ b/crates/collab2/src/tests/following_tests.rs
@@ -4,12 +4,10 @@
 // use call::ActiveCall;
 // use collab_ui::notifications::project_shared_notification::ProjectSharedNotification;
 // use editor::{Editor, ExcerptRange, MultiBuffer};
-// use gpui::{point, BackgroundExecutor, TestAppContext, View, VisualTestContext, WindowContext};
+// use gpui::{BackgroundExecutor, TestAppContext, View};
 // use live_kit_client::MacOSDisplay;
-// use project::project_settings::ProjectSettings;
 // use rpc::proto::PeerId;
 // use serde_json::json;
-// use settings::SettingsStore;
 // use std::borrow::Cow;
 // use workspace::{
 //     dock::{test::TestPanel, DockPosition},
@@ -26,7 +24,7 @@
 //     cx_c: &mut TestAppContext,
 //     cx_d: &mut TestAppContext,
 // ) {
-//     let mut server = TestServer::start(executor.clone()).await;
+//     let mut server = TestServer::start(&executor).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;
@@ -73,22 +71,12 @@
 //         .unwrap();

 //     let window_a = client_a.build_workspace(&project_a, cx_a);
-//     let workspace_a = window_a.root(cx_a).unwrap();
+//     let workspace_a = window_a.root(cx_a);
 //     let window_b = client_b.build_workspace(&project_b, cx_b);
-//     let workspace_b = window_b.root(cx_b).unwrap();
-
-//     todo!("could be wrong")
-//     let mut cx_a = VisualTestContext::from_window(*window_a, cx_a);
-//     let cx_a = &mut cx_a;
-//     let mut cx_b = VisualTestContext::from_window(*window_b, cx_b);
-//     let cx_b = &mut cx_b;
-//     let mut cx_c = VisualTestContext::from_window(*window_c, cx_c);
-//     let cx_c = &mut cx_c;
-//     let mut cx_d = VisualTestContext::from_window(*window_d, cx_d);
-//     let cx_d = &mut cx_d;
+//     let workspace_b = window_b.root(cx_b);

 //     // Client A opens some editors.
-//     let pane_a = workspace_a.update(cx_a, |workspace, _| workspace.active_pane().clone());
+//     let pane_a = workspace_a.read_with(cx_a, |workspace, _| workspace.active_pane().clone());
 //     let editor_a1 = workspace_a
 //         .update(cx_a, |workspace, cx| {
 //             workspace.open_path((worktree_id, "1.txt"), None, true, cx)
@@ -144,8 +132,8 @@
 //         .await
 //         .unwrap();

-//     cx_c.executor().run_until_parked();
-//     let editor_b2 = workspace_b.update(cx_b, |workspace, cx| {
+//     cx_c.foreground().run_until_parked();
+//     let editor_b2 = workspace_b.read_with(cx_b, |workspace, cx| {
 //         workspace
 //             .active_item(cx)
 //             .unwrap()
@@ -157,19 +145,19 @@
 //         Some((worktree_id, "2.txt").into())
 //     );
 //     assert_eq!(
-//         editor_b2.update(cx_b, |editor, cx| editor.selections.ranges(cx)),
+//         editor_b2.read_with(cx_b, |editor, cx| editor.selections.ranges(cx)),
 //         vec![2..1]
 //     );
 //     assert_eq!(
-//         editor_b1.update(cx_b, |editor, cx| editor.selections.ranges(cx)),
+//         editor_b1.read_with(cx_b, |editor, cx| editor.selections.ranges(cx)),
 //         vec![3..2]
 //     );

-//     cx_c.executor().run_until_parked();
+//     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 window_c = client_c.build_workspace(&project_c, cx_c);
-//     let workspace_c = window_c.root(cx_c).unwrap();
+//     let workspace_c = window_c.root(cx_c);
 //     active_call_c
 //         .update(cx_c, |call, cx| call.set_location(Some(&project_c), cx))
 //         .await
@@ -184,13 +172,10 @@
 //         .await
 //         .unwrap();

-//     cx_d.executor().run_until_parked();
+//     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)
-//         .root(cx_d)
-//         .unwrap();
+//     let workspace_d = client_d.build_workspace(&project_d, cx_d).root(cx_d);
 //     active_call_d
 //         .update(cx_d, |call, cx| call.set_location(Some(&project_d), cx))
 //         .await
@@ -198,7 +183,7 @@
 //     drop(project_d);

 //     // All clients see that clients B and C are following client A.
-//     cx_c.executor().run_until_parked();
+//     cx_c.foreground().run_until_parked();
 //     for (name, cx) in [("A", &cx_a), ("B", &cx_b), ("C", &cx_c), ("D", &cx_d)] {
 //         assert_eq!(
 //             followers_by_leader(project_id, cx),
@@ -213,7 +198,7 @@
 //     });

 //     // All clients see that clients B is following client A.
-//     cx_c.executor().run_until_parked();
+//     cx_c.foreground().run_until_parked();
 //     for (name, cx) in [("A", &cx_a), ("B", &cx_b), ("C", &cx_c), ("D", &cx_d)] {
 //         assert_eq!(
 //             followers_by_leader(project_id, cx),
@@ -231,7 +216,7 @@
 //         .unwrap();

 //     // All clients see that clients B and C are following client A.
-//     cx_c.executor().run_until_parked();
+//     cx_c.foreground().run_until_parked();
 //     for (name, cx) in [("A", &cx_a), ("B", &cx_b), ("C", &cx_c), ("D", &cx_d)] {
 //         assert_eq!(
 //             followers_by_leader(project_id, cx),
@@ -255,7 +240,7 @@
 //         .unwrap();

 //     // All clients see that D is following C
-//     cx_d.executor().run_until_parked();
+//     cx_d.foreground().run_until_parked();
 //     for (name, cx) in [("A", &cx_a), ("B", &cx_b), ("C", &cx_c), ("D", &cx_d)] {
 //         assert_eq!(
 //             followers_by_leader(project_id, cx),
@@ -272,7 +257,7 @@
 //     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.executor().run_until_parked();
+//     cx_c.foreground().run_until_parked();
 //     for (name, cx) in [("A", &cx_a), ("B", &cx_b), ("C", &cx_c), ("D", &cx_d)] {
 //         assert_eq!(
 //             followers_by_leader(project_id, cx),
@@ -286,15 +271,12 @@
 //         workspace.activate_item(&editor_a1, cx)
 //     });
 //     executor.run_until_parked();
-//     workspace_b.update(cx_b, |workspace, cx| {
-//         assert_eq!(
-//             workspace.active_item(cx).unwrap().item_id(),
-//             editor_b1.item_id()
-//         );
+//     workspace_b.read_with(cx_b, |workspace, cx| {
+//         assert_eq!(workspace.active_item(cx).unwrap().id(), editor_b1.id());
 //     });

 //     // When client A opens a multibuffer, client B does so as well.
-//     let multibuffer_a = cx_a.build_model(|cx| {
+//     let multibuffer_a = cx_a.add_model(|cx| {
 //         let buffer_a1 = project_a.update(cx, |project, cx| {
 //             project
 //                 .get_open_buffer(&(worktree_id, "1.txt").into(), cx)
@@ -326,12 +308,12 @@
 //     });
 //     let multibuffer_editor_a = workspace_a.update(cx_a, |workspace, cx| {
 //         let editor =
-//             cx.build_view(|cx| Editor::for_multibuffer(multibuffer_a, Some(project_a.clone()), cx));
+//             cx.add_view(|cx| Editor::for_multibuffer(multibuffer_a, Some(project_a.clone()), cx));
 //         workspace.add_item(Box::new(editor.clone()), cx);
 //         editor
 //     });
 //     executor.run_until_parked();
-//     let multibuffer_editor_b = workspace_b.update(cx_b, |workspace, cx| {
+//     let multibuffer_editor_b = workspace_b.read_with(cx_b, |workspace, cx| {
 //         workspace
 //             .active_item(cx)
 //             .unwrap()
@@ -339,8 +321,8 @@
 //             .unwrap()
 //     });
 //     assert_eq!(
-//         multibuffer_editor_a.update(cx_a, |editor, cx| editor.text(cx)),
-//         multibuffer_editor_b.update(cx_b, |editor, cx| editor.text(cx)),
+//         multibuffer_editor_a.read_with(cx_a, |editor, cx| editor.text(cx)),
+//         multibuffer_editor_b.read_with(cx_b, |editor, cx| editor.text(cx)),
 //     );

 //     // When client A navigates back and forth, client B does so as well.
@@ -351,11 +333,8 @@
 //         .await
 //         .unwrap();
 //     executor.run_until_parked();
-//     workspace_b.update(cx_b, |workspace, cx| {
-//         assert_eq!(
-//             workspace.active_item(cx).unwrap().item_id(),
-//             editor_b1.item_id()
-//         );
+//     workspace_b.read_with(cx_b, |workspace, cx| {
+//         assert_eq!(workspace.active_item(cx).unwrap().id(), editor_b1.id());
 //     });

 //     workspace_a
@@ -365,11 +344,8 @@
 //         .await
 //         .unwrap();
 //     executor.run_until_parked();
-//     workspace_b.update(cx_b, |workspace, cx| {
-//         assert_eq!(
-//             workspace.active_item(cx).unwrap().item_id(),
-//             editor_b2.item_id()
-//         );
+//     workspace_b.read_with(cx_b, |workspace, cx| {
+//         assert_eq!(workspace.active_item(cx).unwrap().id(), editor_b2.id());
 //     });

 //     workspace_a
@@ -379,11 +355,8 @@
 //         .await
 //         .unwrap();
 //     executor.run_until_parked();
-//     workspace_b.update(cx_b, |workspace, cx| {
-//         assert_eq!(
-//             workspace.active_item(cx).unwrap().item_id(),
-//             editor_b1.item_id()
-//         );
+//     workspace_b.read_with(cx_b, |workspace, cx| {
+//         assert_eq!(workspace.active_item(cx).unwrap().id(), editor_b1.id());
 //     });

 //     // Changes to client A's editor are reflected on client B.
@@ -391,20 +364,20 @@
 //         editor.change_selections(None, cx, |s| s.select_ranges([1..1, 2..2]));
 //     });
 //     executor.run_until_parked();
-//     editor_b1.update(cx_b, |editor, cx| {
+//     editor_b1.read_with(cx_b, |editor, cx| {
 //         assert_eq!(editor.selections.ranges(cx), &[1..1, 2..2]);
 //     });

 //     editor_a1.update(cx_a, |editor, cx| editor.set_text("TWO", cx));
 //     executor.run_until_parked();
-//     editor_b1.update(cx_b, |editor, cx| assert_eq!(editor.text(cx), "TWO"));
+//     editor_b1.read_with(cx_b, |editor, cx| assert_eq!(editor.text(cx), "TWO"));

 //     editor_a1.update(cx_a, |editor, cx| {
 //         editor.change_selections(None, cx, |s| s.select_ranges([3..3]));
-//         editor.set_scroll_position(point(0., 100.), cx);
+//         editor.set_scroll_position(vec2f(0., 100.), cx);
 //     });
 //     executor.run_until_parked();
-//     editor_b1.update(cx_b, |editor, cx| {
+//     editor_b1.read_with(cx_b, |editor, cx| {
 //         assert_eq!(editor.selections.ranges(cx), &[3..3]);
 //     });

@@ -417,11 +390,11 @@
 //     });
 //     executor.run_until_parked();
 //     assert_eq!(
-//         workspace_b.update(cx_b, |workspace, cx| workspace
+//         workspace_b.read_with(cx_b, |workspace, cx| workspace
 //             .active_item(cx)
 //             .unwrap()
-//             .item_id()),
-//         editor_b1.item_id()
+//             .id()),
+//         editor_b1.id()
 //     );

 //     // Client A starts following client B.
@@ -432,15 +405,15 @@
 //         .await
 //         .unwrap();
 //     assert_eq!(
-//         workspace_a.update(cx_a, |workspace, _| workspace.leader_for_pane(&pane_a)),
+//         workspace_a.read_with(cx_a, |workspace, _| workspace.leader_for_pane(&pane_a)),
 //         Some(peer_id_b)
 //     );
 //     assert_eq!(
-//         workspace_a.update(cx_a, |workspace, cx| workspace
+//         workspace_a.read_with(cx_a, |workspace, cx| workspace
 //             .active_item(cx)
 //             .unwrap()
-//             .item_id()),
-//         editor_a1.item_id()
+//             .id()),
+//         editor_a1.id()
 //     );

 //     // Client B activates an external window, which causes a new screen-sharing item to be added to the pane.
@@ -459,7 +432,7 @@
 //         .await
 //         .unwrap();
 //     executor.run_until_parked();
-//     let shared_screen = workspace_a.update(cx_a, |workspace, cx| {
+//     let shared_screen = workspace_a.read_with(cx_a, |workspace, cx| {
 //         workspace
 //             .active_item(cx)
 //             .expect("no active item")
@@ -473,11 +446,8 @@
 //         .await
 //         .unwrap();
 //     executor.run_until_parked();
-//     workspace_a.update(cx_a, |workspace, cx| {
-//         assert_eq!(
-//             workspace.active_item(cx).unwrap().item_id(),
-//             editor_a1.item_id()
-//         )
+//     workspace_a.read_with(cx_a, |workspace, cx| {
+//         assert_eq!(workspace.active_item(cx).unwrap().id(), editor_a1.id())
 //     });

 //     // Client B activates a multibuffer that was created by following client A. Client A returns to that multibuffer.
@@ -485,26 +455,26 @@
 //         workspace.activate_item(&multibuffer_editor_b, cx)
 //     });
 //     executor.run_until_parked();
-//     workspace_a.update(cx_a, |workspace, cx| {
+//     workspace_a.read_with(cx_a, |workspace, cx| {
 //         assert_eq!(
-//             workspace.active_item(cx).unwrap().item_id(),
-//             multibuffer_editor_a.item_id()
+//             workspace.active_item(cx).unwrap().id(),
+//             multibuffer_editor_a.id()
 //         )
 //     });

 //     // Client B activates a panel, and the previously-opened screen-sharing item gets activated.
-//     let panel = window_b.build_view(cx_b, |_| TestPanel::new(DockPosition::Left));
+//     let panel = window_b.add_view(cx_b, |_| TestPanel::new(DockPosition::Left));
 //     workspace_b.update(cx_b, |workspace, cx| {
 //         workspace.add_panel(panel, cx);
 //         workspace.toggle_panel_focus::<TestPanel>(cx);
 //     });
 //     executor.run_until_parked();
 //     assert_eq!(
-//         workspace_a.update(cx_a, |workspace, cx| workspace
+//         workspace_a.read_with(cx_a, |workspace, cx| workspace
 //             .active_item(cx)
 //             .unwrap()
-//             .item_id()),
-//         shared_screen.item_id()
+//             .id()),
+//         shared_screen.id()
 //     );

 //     // Toggling the focus back to the pane causes client A to return to the multibuffer.
@@ -512,16 +482,16 @@
 //         workspace.toggle_panel_focus::<TestPanel>(cx);
 //     });
 //     executor.run_until_parked();
-//     workspace_a.update(cx_a, |workspace, cx| {
+//     workspace_a.read_with(cx_a, |workspace, cx| {
 //         assert_eq!(
-//             workspace.active_item(cx).unwrap().item_id(),
-//             multibuffer_editor_a.item_id()
+//             workspace.active_item(cx).unwrap().id(),
+//             multibuffer_editor_a.id()
 //         )
 //     });

 //     // Client B activates an item that doesn't implement following,
 //     // so the previously-opened screen-sharing item gets activated.
-//     let unfollowable_item = window_b.build_view(cx_b, |_| TestItem::new());
+//     let unfollowable_item = window_b.add_view(cx_b, |_| TestItem::new());
 //     workspace_b.update(cx_b, |workspace, cx| {
 //         workspace.active_pane().update(cx, |pane, cx| {
 //             pane.add_item(Box::new(unfollowable_item), true, true, None, cx)
@@ -529,18 +499,18 @@
 //     });
 //     executor.run_until_parked();
 //     assert_eq!(
-//         workspace_a.update(cx_a, |workspace, cx| workspace
+//         workspace_a.read_with(cx_a, |workspace, cx| workspace
 //             .active_item(cx)
 //             .unwrap()
-//             .item_id()),
-//         shared_screen.item_id()
+//             .id()),
+//         shared_screen.id()
 //     );

 //     // Following interrupts when client B disconnects.
 //     client_b.disconnect(&cx_b.to_async());
 //     executor.advance_clock(RECONNECT_TIMEOUT);
 //     assert_eq!(
-//         workspace_a.update(cx_a, |workspace, _| workspace.leader_for_pane(&pane_a)),
+//         workspace_a.read_with(cx_a, |workspace, _| workspace.leader_for_pane(&pane_a)),
 //         None
 //     );
 // }
@@ -551,7 +521,7 @@
 //     cx_a: &mut TestAppContext,
 //     cx_b: &mut TestAppContext,
 // ) {
-//     let mut server = TestServer::start(executor.clone()).await;
+//     let mut server = TestServer::start(&executor).await;
 //     let client_a = server.create_client(cx_a, "user_a").await;
 //     let client_b = server.create_client(cx_b, "user_b").await;
 //     server
@@ -590,19 +560,13 @@
 //         .await
 //         .unwrap();

-//     let workspace_a = client_a
-//         .build_workspace(&project_a, cx_a)
-//         .root(cx_a)
-//         .unwrap();
-//     let pane_a = workspace_a.update(cx_a, |workspace, _| workspace.active_pane().clone());
+//     let workspace_a = client_a.build_workspace(&project_a, cx_a).root(cx_a);
+//     let pane_a = workspace_a.read_with(cx_a, |workspace, _| workspace.active_pane().clone());

-//     let workspace_b = client_b
-//         .build_workspace(&project_b, cx_b)
-//         .root(cx_b)
-//         .unwrap();
-//     let pane_b = workspace_b.update(cx_b, |workspace, _| workspace.active_pane().clone());
+//     let workspace_b = client_b.build_workspace(&project_b, cx_b).root(cx_b);
+//     let pane_b = workspace_b.read_with(cx_b, |workspace, _| workspace.active_pane().clone());

-//     let client_b_id = project_a.update(cx_a, |project, _| {
+//     let client_b_id = project_a.read_with(cx_a, |project, _| {
 //         project.collaborators().values().next().unwrap().peer_id
 //     });

@@ -620,7 +584,7 @@
 //         .await
 //         .unwrap();

-//     let pane_paths = |pane: &View<workspace::Pane>, cx: &mut TestAppContext| {
+//     let pane_paths = |pane: &ViewHandle<workspace::Pane>, cx: &mut TestAppContext| {
 //         pane.update(cx, |pane, cx| {
 //             pane.items()
 //                 .map(|item| {
@@ -678,7 +642,7 @@
 //     cx_a: &mut TestAppContext,
 //     cx_b: &mut TestAppContext,
 // ) {
-//     let mut server = TestServer::start(executor.clone()).await;
+//     let mut server = TestServer::start(&executor).await;
 //     let client_a = server.create_client(cx_a, "user_a").await;
 //     let client_b = server.create_client(cx_b, "user_b").await;
 //     server
@@ -721,10 +685,7 @@
 //         .unwrap();

 //     // Client A opens a file.
-//     let workspace_a = client_a
-//         .build_workspace(&project_a, cx_a)
-//         .root(cx_a)
-//         .unwrap();
+//     let workspace_a = client_a.build_workspace(&project_a, cx_a).root(cx_a);
 //     workspace_a
 //         .update(cx_a, |workspace, cx| {
 //             workspace.open_path((worktree_id, "1.txt"), None, true, cx)
@@ -735,10 +696,7 @@
 //         .unwrap();

 //     // Client B opens a different file.
-//     let workspace_b = client_b
-//         .build_workspace(&project_b, cx_b)
-//         .root(cx_b)
-//         .unwrap();
+//     let workspace_b = client_b.build_workspace(&project_b, cx_b).root(cx_b);
 //     workspace_b
 //         .update(cx_b, |workspace, cx| {
 //             workspace.open_path((worktree_id, "2.txt"), None, true, cx)
@@ -1209,7 +1167,7 @@
 //     cx_b: &mut TestAppContext,
 // ) {
 //     // 2 clients connect to a server.
-//     let mut server = TestServer::start(executor.clone()).await;
+//     let mut server = TestServer::start(&executor).await;
 //     let client_a = server.create_client(cx_a, "user_a").await;
 //     let client_b = server.create_client(cx_b, "user_b").await;
 //     server
@@ -1249,17 +1207,8 @@
 //         .await
 //         .unwrap();

-//     todo!("could be wrong")
-//     let mut cx_a = VisualTestContext::from_window(*window_a, cx_a);
-//     let cx_a = &mut cx_a;
-//     let mut cx_b = VisualTestContext::from_window(*window_b, cx_b);
-//     let cx_b = &mut cx_b;
-
 //     // Client A opens some editors.
-//     let workspace_a = client_a
-//         .build_workspace(&project_a, cx_a)
-//         .root(cx_a)
-//         .unwrap();
+//     let workspace_a = client_a.build_workspace(&project_a, cx_a).root(cx_a);
 //     let _editor_a1 = workspace_a
 //         .update(cx_a, |workspace, cx| {
 //             workspace.open_path((worktree_id, "1.txt"), None, true, cx)
@@ -1270,12 +1219,9 @@
 //         .unwrap();

 //     // Client B starts following client A.
-//     let workspace_b = client_b
-//         .build_workspace(&project_b, cx_b)
-//         .root(cx_b)
-//         .unwrap();
-//     let pane_b = workspace_b.update(cx_b, |workspace, _| workspace.active_pane().clone());
-//     let leader_id = project_b.update(cx_b, |project, _| {
+//     let workspace_b = client_b.build_workspace(&project_b, cx_b).root(cx_b);
+//     let pane_b = workspace_b.read_with(cx_b, |workspace, _| workspace.active_pane().clone());
+//     let leader_id = project_b.read_with(cx_b, |project, _| {
 //         project.collaborators().values().next().unwrap().peer_id
 //     });
 //     workspace_b
@@ -1285,10 +1231,10 @@
 //         .await
 //         .unwrap();
 //     assert_eq!(
-//         workspace_b.update(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
+//         workspace_b.read_with(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
 //         Some(leader_id)
 //     );
-//     let editor_b2 = workspace_b.update(cx_b, |workspace, cx| {
+//     let editor_b2 = workspace_b.read_with(cx_b, |workspace, cx| {
 //         workspace
 //             .active_item(cx)
 //             .unwrap()
@@ -1299,7 +1245,7 @@
 //     // When client B moves, it automatically stops following client A.
 //     editor_b2.update(cx_b, |editor, cx| editor.move_right(&editor::MoveRight, cx));
 //     assert_eq!(
-//         workspace_b.update(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
+//         workspace_b.read_with(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
 //         None
 //     );

@@ -1310,14 +1256,14 @@
 //         .await
 //         .unwrap();
 //     assert_eq!(
-//         workspace_b.update(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
+//         workspace_b.read_with(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
 //         Some(leader_id)
 //     );

 //     // When client B edits, it automatically stops following client A.
 //     editor_b2.update(cx_b, |editor, cx| editor.insert("X", cx));
 //     assert_eq!(
-//         workspace_b.update(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
+//         workspace_b.read_with(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
 //         None
 //     );

@@ -1328,16 +1274,16 @@
 //         .await
 //         .unwrap();
 //     assert_eq!(
-//         workspace_b.update(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
+//         workspace_b.read_with(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
 //         Some(leader_id)
 //     );

 //     // When client B scrolls, it automatically stops following client A.
 //     editor_b2.update(cx_b, |editor, cx| {
-//         editor.set_scroll_position(point(0., 3.), cx)
+//         editor.set_scroll_position(vec2f(0., 3.), cx)
 //     });
 //     assert_eq!(
-//         workspace_b.update(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
+//         workspace_b.read_with(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
 //         None
 //     );

@@ -1348,7 +1294,7 @@
 //         .await
 //         .unwrap();
 //     assert_eq!(
-//         workspace_b.update(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
+//         workspace_b.read_with(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
 //         Some(leader_id)
 //     );

@@ -1357,13 +1303,13 @@
 //         workspace.split_and_clone(pane_b.clone(), SplitDirection::Right, cx)
 //     });
 //     assert_eq!(
-//         workspace_b.update(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
+//         workspace_b.read_with(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
 //         Some(leader_id)
 //     );

 //     workspace_b.update(cx_b, |workspace, cx| workspace.activate_next_pane(cx));
 //     assert_eq!(
-//         workspace_b.update(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
+//         workspace_b.read_with(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
 //         Some(leader_id)
 //     );

@@ -1375,7 +1321,7 @@
 //         .await
 //         .unwrap();
 //     assert_eq!(
-//         workspace_b.update(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
+//         workspace_b.read_with(cx_b, |workspace, _| workspace.leader_for_pane(&pane_b)),
 //         None
 //     );
 // }
@@ -1386,7 +1332,7 @@
 //     cx_a: &mut TestAppContext,
 //     cx_b: &mut TestAppContext,
 // ) {
-//     let mut server = TestServer::start(executor.clone()).await;
+//     let mut server = TestServer::start(&executor).await;
 //     let client_a = server.create_client(cx_a, "user_a").await;
 //     let client_b = server.create_client(cx_b, "user_b").await;
 //     server
@@ -1399,26 +1345,20 @@

 //     client_a.fs().insert_tree("/a", json!({})).await;
 //     let (project_a, _) = client_a.build_local_project("/a", cx_a).await;
-//     let workspace_a = client_a
-//         .build_workspace(&project_a, cx_a)
-//         .root(cx_a)
-//         .unwrap();
+//     let workspace_a = client_a.build_workspace(&project_a, cx_a).root(cx_a);
 //     let project_id = active_call_a
 //         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
 //         .await
 //         .unwrap();

 //     let project_b = client_b.build_remote_project(project_id, cx_b).await;
-//     let workspace_b = client_b
-//         .build_workspace(&project_b, cx_b)
-//         .root(cx_b)
-//         .unwrap();
+//     let workspace_b = client_b.build_workspace(&project_b, cx_b).root(cx_b);

 //     executor.run_until_parked();
-//     let client_a_id = project_b.update(cx_b, |project, _| {
+//     let client_a_id = project_b.read_with(cx_b, |project, _| {
 //         project.collaborators().values().next().unwrap().peer_id
 //     });
-//     let client_b_id = project_a.update(cx_a, |project, _| {
+//     let client_b_id = project_a.read_with(cx_a, |project, _| {
 //         project.collaborators().values().next().unwrap().peer_id
 //     });

@@ -1430,13 +1370,13 @@
 //     });

 //     futures::try_join!(a_follow_b, b_follow_a).unwrap();
-//     workspace_a.update(cx_a, |workspace, _| {
+//     workspace_a.read_with(cx_a, |workspace, _| {
 //         assert_eq!(
 //             workspace.leader_for_pane(workspace.active_pane()),
 //             Some(client_b_id)
 //         );
 //     });
-//     workspace_b.update(cx_b, |workspace, _| {
+//     workspace_b.read_with(cx_b, |workspace, _| {
 //         assert_eq!(
 //             workspace.leader_for_pane(workspace.active_pane()),
 //             Some(client_a_id)
@@ -1458,7 +1398,7 @@
 //     // b opens a different file in project 2, a follows b
 //     // b opens a different file in project 1, a cannot follow b
 //     // b shares the project, a joins the project and follows b
-//     let mut server = TestServer::start(executor.clone()).await;
+//     let mut server = TestServer::start(&executor).await;
 //     let client_a = server.create_client(cx_a, "user_a").await;
 //     let client_b = server.create_client(cx_b, "user_b").await;
 //     cx_a.update(editor::init);
@@ -1495,14 +1435,8 @@
 //     let (project_a, worktree_id_a) = client_a.build_local_project("/a", cx_a).await;
 //     let (project_b, worktree_id_b) = client_b.build_local_project("/b", cx_b).await;

-//     let workspace_a = client_a
-//         .build_workspace(&project_a, cx_a)
-//         .root(cx_a)
-//         .unwrap();
-//     let workspace_b = client_b
-//         .build_workspace(&project_b, cx_b)
-//         .root(cx_b)
-//         .unwrap();
+//     let workspace_a = client_a.build_workspace(&project_a, cx_a).root(cx_a);
+//     let workspace_b = client_b.build_workspace(&project_b, cx_b).root(cx_b);

 //     cx_a.update(|cx| collab_ui::init(&client_a.app_state, cx));
 //     cx_b.update(|cx| collab_ui::init(&client_b.app_state, cx));
@@ -1521,12 +1455,6 @@
 //         .await
 //         .unwrap();

-//     todo!("could be wrong")
-//     let mut cx_a = VisualTestContext::from_window(*window_a, cx_a);
-//     let cx_a = &mut cx_a;
-//     let mut cx_b = VisualTestContext::from_window(*window_b, cx_b);
-//     let cx_b = &mut cx_b;
-
 //     workspace_a
 //         .update(cx_a, |workspace, cx| {
 //             workspace.open_path((worktree_id_a, "w.rs"), None, true, cx)
@@ -1548,12 +1476,11 @@
 //     let workspace_b_project_a = cx_b
 //         .windows()
 //         .iter()
-//         .max_by_key(|window| window.item_id())
+//         .max_by_key(|window| window.id())
 //         .unwrap()
 //         .downcast::<Workspace>()
 //         .unwrap()
-//         .root(cx_b)
-//         .unwrap();
+//         .root(cx_b);

 //     // assert that b is following a in project a in w.rs
 //     workspace_b_project_a.update(cx_b, |workspace, cx| {
@@ -1607,7 +1534,7 @@
 //             workspace.leader_for_pane(workspace.active_pane())
 //         );
 //         let item = workspace.active_pane().read(cx).active_item().unwrap();
-//         assert_eq!(item.tab_description(0, cx).unwrap(), "x.rs".into());
+//         assert_eq!(item.tab_description(0, cx).unwrap(), Cow::Borrowed("x.rs"));
 //     });

 //     // b moves to y.rs in b's project, a is still following but can't yet see
@@ -1651,12 +1578,11 @@
 //     let workspace_a_project_b = cx_a
 //         .windows()
 //         .iter()
-//         .max_by_key(|window| window.item_id())
+//         .max_by_key(|window| window.id())
 //         .unwrap()
 //         .downcast::<Workspace>()
 //         .unwrap()
-//         .root(cx_a)
-//         .unwrap();
+//         .root(cx_a);

 //     workspace_a_project_b.update(cx_a, |workspace, cx| {
 //         assert_eq!(workspace.project().read(cx).remote_id(), Some(project_b_id));
@@ -1670,151 +1596,12 @@
 //     });
 // }

-// #[gpui::test]
-// async fn test_following_into_excluded_file(
-//     executor: BackgroundExecutor,
-//     mut cx_a: &mut TestAppContext,
-//     mut cx_b: &mut TestAppContext,
-// ) {
-//     let mut server = TestServer::start(executor.clone()).await;
-//     let client_a = server.create_client(cx_a, "user_a").await;
-//     let client_b = server.create_client(cx_b, "user_b").await;
-//     for cx in [&mut cx_a, &mut cx_b] {
-//         cx.update(|cx| {
-//             cx.update_global::<SettingsStore, _>(|store, cx| {
-//                 store.update_user_settings::<ProjectSettings>(cx, |project_settings| {
-//                     project_settings.file_scan_exclusions = Some(vec!["**/.git".to_string()]);
-//                 });
-//             });
-//         });
-//     }
-//     server
-//         .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
-//         .await;
-//     let active_call_a = cx_a.read(ActiveCall::global);
-//     let active_call_b = cx_b.read(ActiveCall::global);
-
-//     cx_a.update(editor::init);
-//     cx_b.update(editor::init);
-
-//     client_a
-//         .fs()
-//         .insert_tree(
-//             "/a",
-//             json!({
-//                 ".git": {
-//                     "COMMIT_EDITMSG": "write your commit message here",
-//                 },
-//                 "1.txt": "one\none\none",
-//                 "2.txt": "two\ntwo\ntwo",
-//                 "3.txt": "three\nthree\nthree",
-//             }),
-//         )
-//         .await;
-//     let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
-//     active_call_a
-//         .update(cx_a, |call, cx| call.set_location(Some(&project_a), cx))
-//         .await
-//         .unwrap();
-
-//     let project_id = active_call_a
-//         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
-//         .await
-//         .unwrap();
-//     let project_b = client_b.build_remote_project(project_id, cx_b).await;
-//     active_call_b
-//         .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
-//         .await
-//         .unwrap();
-
-//     let window_a = client_a.build_workspace(&project_a, cx_a);
-//     let workspace_a = window_a.root(cx_a).unwrap();
-//     let peer_id_a = client_a.peer_id().unwrap();
-//     let window_b = client_b.build_workspace(&project_b, cx_b);
-//     let workspace_b = window_b.root(cx_b).unwrap();
-
-//     todo!("could be wrong")
-//     let mut cx_a = VisualTestContext::from_window(*window_a, cx_a);
-//     let cx_a = &mut cx_a;
-//     let mut cx_b = VisualTestContext::from_window(*window_b, cx_b);
-//     let cx_b = &mut cx_b;
-
-//     // Client A opens editors for a regular file and an excluded file.
-//     let editor_for_regular = workspace_a
-//         .update(cx_a, |workspace, cx| {
-//             workspace.open_path((worktree_id, "1.txt"), None, true, cx)
-//         })
-//         .await
-//         .unwrap()
-//         .downcast::<Editor>()
-//         .unwrap();
-//     let editor_for_excluded_a = workspace_a
-//         .update(cx_a, |workspace, cx| {
-//             workspace.open_path((worktree_id, ".git/COMMIT_EDITMSG"), None, true, cx)
-//         })
-//         .await
-//         .unwrap()
-//         .downcast::<Editor>()
-//         .unwrap();
-
-//     // Client A updates their selections in those editors
-//     editor_for_regular.update(cx_a, |editor, cx| {
-//         editor.handle_input("a", cx);
-//         editor.handle_input("b", cx);
-//         editor.handle_input("c", cx);
-//         editor.select_left(&Default::default(), cx);
-//         assert_eq!(editor.selections.ranges(cx), vec![3..2]);
-//     });
-//     editor_for_excluded_a.update(cx_a, |editor, cx| {
-//         editor.select_all(&Default::default(), cx);
-//         editor.handle_input("new commit message", cx);
-//         editor.select_left(&Default::default(), cx);
-//         assert_eq!(editor.selections.ranges(cx), vec![18..17]);
-//     });
-
-//     // When client B starts following client A, currently visible file is replicated
-//     workspace_b
-//         .update(cx_b, |workspace, cx| {
-//             workspace.follow(peer_id_a, cx).unwrap()
-//         })
-//         .await
-//         .unwrap();
-
-//     let editor_for_excluded_b = workspace_b.update(cx_b, |workspace, cx| {
-//         workspace
-//             .active_item(cx)
-//             .unwrap()
-//             .downcast::<Editor>()
-//             .unwrap()
-//     });
-//     assert_eq!(
-//         cx_b.read(|cx| editor_for_excluded_b.project_path(cx)),
-//         Some((worktree_id, ".git/COMMIT_EDITMSG").into())
-//     );
-//     assert_eq!(
-//         editor_for_excluded_b.update(cx_b, |editor, cx| editor.selections.ranges(cx)),
-//         vec![18..17]
-//     );
-
-//     // Changes from B to the excluded file are replicated in A's editor
-//     editor_for_excluded_b.update(cx_b, |editor, cx| {
-//         editor.handle_input("\nCo-Authored-By: B <b@b.b>", cx);
-//     });
-//     executor.run_until_parked();
-//     editor_for_excluded_a.update(cx_a, |editor, cx| {
-//         assert_eq!(
-//             editor.text(cx),
-//             "new commit messag\nCo-Authored-By: B <b@b.b>"
-//         );
-//     });
-// }
-
 // fn visible_push_notifications(
 //     cx: &mut TestAppContext,
-// ) -> Vec<gpui::View<ProjectSharedNotification>> {
+// ) -> Vec<gpui::ViewHandle<ProjectSharedNotification>> {
 //     let mut ret = Vec::new();
 //     for window in cx.windows() {
-//         window.update(cx, |window| {
+//         window.read_with(cx, |window| {
 //             if let Some(handle) = window
 //                 .root_view()
 //                 .clone()
@@ -1858,8 +1645,8 @@
 //     })
 // }

-// fn pane_summaries(workspace: &View<Workspace>, cx: &mut WindowContext<'_>) -> Vec<PaneSummary> {
-//     workspace.update(cx, |workspace, cx| {
+// fn pane_summaries(workspace: &ViewHandle<Workspace>, cx: &mut TestAppContext) -> Vec<PaneSummary> {
+//     workspace.read_with(cx, |workspace, cx| {
 //         let active_pane = workspace.active_pane();
 //         workspace
 //             .panes()
--- a/crates/collab2/src/tests/integration_tests.rs
+++ b/crates/collab2/src/tests/integration_tests.rs
@@ -1823,7 +1823,7 @@ async fn test_active_call_events(
            owner: Arc::new(User {
                id: client_a.user_id().unwrap(),
                github_login: "user_a".to_string(),
-                avatar_uri: "avatar_a".into(),
+                avatar: None,
            }),
            project_id: project_a_id,
            worktree_root_names: vec!["a".to_string()],
@@ -1841,7 +1841,7 @@ async fn test_active_call_events(
            owner: Arc::new(User {
                id: client_b.user_id().unwrap(),
                github_login: "user_b".to_string(),
-                avatar_uri: "avatar_b".into(),
+                avatar: None,
            }),
            project_id: project_b_id,
            worktree_root_names: vec!["b".to_string()]
@@ -2781,10 +2781,11 @@ async fn test_fs_operations(

    let entry = project_b
        .update(cx_b, |project, cx| {
-            project.create_entry((worktree_id, "c.txt"), false, cx)
+            project
+                .create_entry((worktree_id, "c.txt"), false, cx)
+                .unwrap()
        })
        .await
-        .unwrap()
        .unwrap();

    worktree_a.read_with(cx_a, |worktree, _| {
@@ -2811,8 +2812,8 @@ async fn test_fs_operations(
        .update(cx_b, |project, cx| {
            project.rename_entry(entry.id, Path::new("d.txt"), cx)
        })
-        .await
        .unwrap()
+        .await
        .unwrap();

    worktree_a.read_with(cx_a, |worktree, _| {
@@ -2837,10 +2838,11 @@ async fn test_fs_operations(

    let dir_entry = project_b
        .update(cx_b, |project, cx| {
-            project.create_entry((worktree_id, "DIR"), true, cx)
+            project
+                .create_entry((worktree_id, "DIR"), true, cx)
+                .unwrap()
        })
        .await
-        .unwrap()
        .unwrap();

    worktree_a.read_with(cx_a, |worktree, _| {
@@ -2865,24 +2867,27 @@ async fn test_fs_operations(

    project_b
        .update(cx_b, |project, cx| {
-            project.create_entry((worktree_id, "DIR/e.txt"), false, cx)
+            project
+                .create_entry((worktree_id, "DIR/e.txt"), false, cx)
+                .unwrap()
        })
        .await
-        .unwrap()
        .unwrap();
    project_b
        .update(cx_b, |project, cx| {
-            project.create_entry((worktree_id, "DIR/SUBDIR"), true, cx)
+            project
+                .create_entry((worktree_id, "DIR/SUBDIR"), true, cx)
+                .unwrap()
        })
        .await
-        .unwrap()
        .unwrap();
    project_b
        .update(cx_b, |project, cx| {
-            project.create_entry((worktree_id, "DIR/SUBDIR/f.txt"), false, cx)
+            project
+                .create_entry((worktree_id, "DIR/SUBDIR/f.txt"), false, cx)
+                .unwrap()
        })
        .await
-        .unwrap()
        .unwrap();

    worktree_a.read_with(cx_a, |worktree, _| {
@@ -2923,10 +2928,11 @@ async fn test_fs_operations(

    project_b
        .update(cx_b, |project, cx| {
-            project.copy_entry(entry.id, Path::new("f.txt"), cx)
+            project
+                .copy_entry(entry.id, Path::new("f.txt"), cx)
+                .unwrap()
        })
        .await
-        .unwrap()
        .unwrap();

    worktree_a.read_with(cx_a, |worktree, _| {
@@ -3679,7 +3685,7 @@ async fn test_collaborating_with_diagnostics(

    project_b.read_with(cx_b, |project, cx| {
        assert_eq!(
-            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
+            project.diagnostic_summaries(cx).collect::<Vec<_>>(),
            &[(
                ProjectPath {
                    worktree_id,
@@ -3699,14 +3705,14 @@ async fn test_collaborating_with_diagnostics(
    let project_c = client_c.build_remote_project(project_id, cx_c).await;
    let project_c_diagnostic_summaries =
        Rc::new(RefCell::new(project_c.read_with(cx_c, |project, cx| {
-            project.diagnostic_summaries(false, cx).collect::<Vec<_>>()
+            project.diagnostic_summaries(cx).collect::<Vec<_>>()
        })));
    project_c.update(cx_c, |_, cx| {
        let summaries = project_c_diagnostic_summaries.clone();
        cx.subscribe(&project_c, {
            move |p, _, event, cx| {
                if let project::Event::DiskBasedDiagnosticsFinished { .. } = event {
-                    *summaries.borrow_mut() = p.diagnostic_summaries(false, cx).collect();
+                    *summaries.borrow_mut() = p.diagnostic_summaries(cx).collect();
                }
            }
        })
@@ -3757,7 +3763,7 @@ async fn test_collaborating_with_diagnostics(

    project_b.read_with(cx_b, |project, cx| {
        assert_eq!(
-            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
+            project.diagnostic_summaries(cx).collect::<Vec<_>>(),
            [(
                ProjectPath {
                    worktree_id,
@@ -3774,7 +3780,7 @@ async fn test_collaborating_with_diagnostics(

    project_c.read_with(cx_c, |project, cx| {
        assert_eq!(
-            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
+            project.diagnostic_summaries(cx).collect::<Vec<_>>(),
            [(
                ProjectPath {
                    worktree_id,
@@ -3835,24 +3841,15 @@ async fn test_collaborating_with_diagnostics(
    executor.run_until_parked();

    project_a.read_with(cx_a, |project, cx| {
-        assert_eq!(
-            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
-            []
-        )
+        assert_eq!(project.diagnostic_summaries(cx).collect::<Vec<_>>(), [])
    });

    project_b.read_with(cx_b, |project, cx| {
-        assert_eq!(
-            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
-            []
-        )
+        assert_eq!(project.diagnostic_summaries(cx).collect::<Vec<_>>(), [])
    });

    project_c.read_with(cx_c, |project, cx| {
-        assert_eq!(
-            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
-            []
-        )
+        assert_eq!(project.diagnostic_summaries(cx).collect::<Vec<_>>(), [])
    });
 }

--- a/crates/collab2/src/tests/random_channel_buffer_tests.rs
+++ b/crates/collab2/src/tests/random_channel_buffer_tests.rs
@@ -3,7 +3,7 @@ use crate::db::ChannelRole;
 use super::{run_randomized_test, RandomizedTest, TestClient, TestError, TestServer, UserTestPlan};
 use anyhow::Result;
 use async_trait::async_trait;
-use gpui::{BackgroundExecutor, SharedString, TestAppContext};
+use gpui::{BackgroundExecutor, TestAppContext};
 use rand::prelude::*;
 use serde_derive::{Deserialize, Serialize};
 use std::{
@@ -30,13 +30,13 @@ struct RandomChannelBufferTest;
 #[derive(Clone, Serialize, Deserialize)]
 enum ChannelBufferOperation {
    JoinChannelNotes {
-        channel_name: SharedString,
+        channel_name: String,
    },
    LeaveChannelNotes {
-        channel_name: SharedString,
+        channel_name: String,
    },
    EditChannelNotes {
-        channel_name: SharedString,
+        channel_name: String,
        edits: Vec<(Range<usize>, Arc<str>)>,
    },
    Noop,
--- a/crates/collab2/src/tests/random_project_collaboration_tests.rs
+++ b/crates/collab2/src/tests/random_project_collaboration_tests.rs
@@ -665,6 +665,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                ensure_project_shared(&project, client, cx).await;
                project
                    .update(cx, |p, cx| p.create_entry(project_path, is_dir, cx))
+                    .unwrap()
                    .await?;
            }

--- a/crates/collab2/src/tests/test_server.rs
+++ b/crates/collab2/src/tests/test_server.rs
@@ -13,7 +13,7 @@ use client::{
 use collections::{HashMap, HashSet};
 use fs::FakeFs;
 use futures::{channel::oneshot, StreamExt as _};
-use gpui::{BackgroundExecutor, Context, Model, TestAppContext, View, VisualTestContext};
+use gpui::{BackgroundExecutor, Context, Model, TestAppContext, WindowHandle};
 use language::LanguageRegistry;
 use node_runtime::FakeNodeRuntime;

@@ -149,7 +149,7 @@ impl TestServer {
                .user_id
        };
        let client_name = name.to_string();
-        let mut client = cx.update(|cx| Client::new(http.clone(), cx));
+        let mut client = cx.read(|cx| Client::new(http.clone(), cx));
        let server = self.server.clone();
        let db = self.app_state.db.clone();
        let connection_killers = self.connection_killers.clone();
@@ -209,7 +209,7 @@ impl TestServer {
            });

        let fs = FakeFs::new(cx.executor());
-        let user_store = cx.build_model(|cx| UserStore::new(client.clone(), cx));
+        let user_store = cx.build_model(|cx| UserStore::new(client.clone(), http, cx));
        let workspace_store = cx.build_model(|cx| WorkspaceStore::new(client.clone(), cx));
        let mut language_registry = LanguageRegistry::test();
        language_registry.set_executor(cx.executor());
@@ -602,12 +602,14 @@ impl TestClient {
        .unwrap()
    }

-    pub fn build_workspace<'a>(
-        &'a self,
+    //todo(workspace)
+    #[allow(dead_code)]
+    pub fn build_workspace(
+        &self,
        project: &Model<Project>,
-        cx: &'a mut TestAppContext,
-    ) -> (View<Workspace>, &'a mut VisualTestContext) {
-        cx.add_window_view(|cx| Workspace::new(0, project.clone(), self.app_state.clone(), cx))
+        cx: &mut TestAppContext,
+    ) -> WindowHandle<Workspace> {
+        cx.add_window(|cx| Workspace::new(0, project.clone(), self.app_state.clone(), cx))
    }
 }

--- a/crates/collab_ui2/Cargo.toml
+++ b/crates/collab_ui2/Cargo.toml
@@ -22,7 +22,7 @@ test-support = [
 ]

 [dependencies]
-auto_update = { package = "auto_update2", path = "../auto_update2" }
+# auto_update = { path = "../auto_update" }
 db = { package = "db2", path = "../db2" }
 call = { package = "call2", path = "../call2" }
 client = { package = "client2", path = "../client2" }
@@ -32,7 +32,7 @@ collections = { path = "../collections" }
 # context_menu = { path = "../context_menu" }
 # drag_and_drop = { path = "../drag_and_drop" }
 editor = { package="editor2", path = "../editor2" }
-feedback = { package = "feedback2", path = "../feedback2" }
+#feedback = { path = "../feedback" }
 fuzzy = { package = "fuzzy2", path = "../fuzzy2" }
 gpui = { package = "gpui2", path = "../gpui2" }
 language = { package = "language2", path = "../language2" }
@@ -41,13 +41,13 @@ notifications = { package = "notifications2",  path = "../notifications2" }
 rich_text = { package = "rich_text2", path = "../rich_text2" }
 picker = { package = "picker2", path = "../picker2" }
 project = { package = "project2", path = "../project2" }
-recent_projects = { package = "recent_projects2", path = "../recent_projects2" }
+# recent_projects = { path = "../recent_projects" }
 rpc = { package ="rpc2",  path = "../rpc2" }
 settings = { package = "settings2", path = "../settings2" }
 feature_flags = { package = "feature_flags2", path = "../feature_flags2"}
 theme = { package = "theme2", path = "../theme2" }
-theme_selector = { package = "theme_selector2", path = "../theme_selector2" }
-vcs_menu = { package = "vcs_menu2", path = "../vcs_menu2" }
+# theme_selector = { path = "../theme_selector" }
+# vcs_menu = { path = "../vcs_menu" }
 ui = { package = "ui2", path = "../ui2" }
 util = { path = "../util" }
 workspace = { package = "workspace2", path = "../workspace2" }
--- a/crates/collab_ui2/src/channel_view.rs
+++ b/crates/collab_ui2/src/channel_view.rs
@@ -1,450 +1,454 @@
-use anyhow::Result;
-use call::report_call_event_for_channel;
-use channel::{Channel, ChannelBuffer, ChannelBufferEvent, ChannelId, ChannelStore};
-use client::{
-    proto::{self, PeerId},
-    Collaborator, ParticipantIndex,
-};
-use collections::HashMap;
-use editor::{CollaborationHub, Editor, EditorEvent};
-use gpui::{
-    actions, AnyElement, AnyView, AppContext, Entity as _, EventEmitter, FocusableView,
-    IntoElement as _, Model, Pixels, Point, Render, Subscription, Task, View, ViewContext,
-    VisualContext as _, WindowContext,
-};
-use project::Project;
-use std::{
-    any::{Any, TypeId},
-    sync::Arc,
-};
-use ui::{prelude::*, Label};
-use util::ResultExt;
-use workspace::{
-    item::{FollowableItem, Item, ItemEvent, ItemHandle},
-    register_followable_item,
-    searchable::SearchableItemHandle,
-    ItemNavHistory, Pane, SaveIntent, ViewId, Workspace, WorkspaceId,
-};
+// use anyhow::{anyhow, Result};
+// use call::report_call_event_for_channel;
+// use channel::{Channel, ChannelBuffer, ChannelBufferEvent, ChannelId, ChannelStore};
+// use client::{
+//     proto::{self, PeerId},
+//     Collaborator, ParticipantIndex,
+// };
+// use collections::HashMap;
+// use editor::{CollaborationHub, Editor};
+// use gpui::{
+//     actions,
+//     elements::{ChildView, Label},
+//     geometry::vector::Vector2F,
+//     AnyElement, AnyViewHandle, AppContext, Element, Entity, ModelHandle, Subscription, Task, View,
+//     ViewContext, ViewHandle,
+// };
+// use project::Project;
+// use smallvec::SmallVec;
+// use std::{
+//     any::{Any, TypeId},
+//     sync::Arc,
+// };
+// use util::ResultExt;
+// use workspace::{
+//     item::{FollowableItem, Item, ItemEvent, ItemHandle},
+//     register_followable_item,
+//     searchable::SearchableItemHandle,
+//     ItemNavHistory, Pane, SaveIntent, ViewId, Workspace, WorkspaceId,
+// };

-actions!(collab, [Deploy]);
+// actions!(channel_view, [Deploy]);

-pub fn init(cx: &mut AppContext) {
-    register_followable_item::<ChannelView>(cx)
-}
+// pub fn init(cx: &mut AppContext) {
+//     register_followable_item::<ChannelView>(cx)
+// }

-pub struct ChannelView {
-    pub editor: View<Editor>,
-    project: Model<Project>,
-    channel_store: Model<ChannelStore>,
-    channel_buffer: Model<ChannelBuffer>,
-    remote_id: Option<ViewId>,
-    _editor_event_subscription: Subscription,
-}
+// pub struct ChannelView {
+//     pub editor: ViewHandle<Editor>,
+//     project: ModelHandle<Project>,
+//     channel_store: ModelHandle<ChannelStore>,
+//     channel_buffer: ModelHandle<ChannelBuffer>,
+//     remote_id: Option<ViewId>,
+//     _editor_event_subscription: Subscription,
+// }

-impl ChannelView {
-    pub fn open(
-        channel_id: ChannelId,
-        workspace: View<Workspace>,
-        cx: &mut WindowContext,
-    ) -> Task<Result<View<Self>>> {
-        let pane = workspace.read(cx).active_pane().clone();
-        let channel_view = Self::open_in_pane(channel_id, pane.clone(), workspace.clone(), cx);
-        cx.spawn(|mut cx| async move {
-            let channel_view = channel_view.await?;
-            pane.update(&mut cx, |pane, cx| {
-                report_call_event_for_channel(
-                    "open channel notes",
-                    channel_id,
-                    &workspace.read(cx).app_state().client,
-                    cx,
-                );
-                pane.add_item(Box::new(channel_view.clone()), true, true, None, cx);
-            })?;
-            anyhow::Ok(channel_view)
-        })
-    }
+// impl ChannelView {
+//     pub fn open(
+//         channel_id: ChannelId,
+//         workspace: ViewHandle<Workspace>,
+//         cx: &mut AppContext,
+//     ) -> Task<Result<ViewHandle<Self>>> {
+//         let pane = workspace.read(cx).active_pane().clone();
+//         let channel_view = Self::open_in_pane(channel_id, pane.clone(), workspace.clone(), cx);
+//         cx.spawn(|mut cx| async move {
+//             let channel_view = channel_view.await?;
+//             pane.update(&mut cx, |pane, cx| {
+//                 report_call_event_for_channel(
+//                     "open channel notes",
+//                     channel_id,
+//                     &workspace.read(cx).app_state().client,
+//                     cx,
+//                 );
+//                 pane.add_item(Box::new(channel_view.clone()), true, true, None, cx);
+//             });
+//             anyhow::Ok(channel_view)
+//         })
+//     }

-    pub fn open_in_pane(
-        channel_id: ChannelId,
-        pane: View<Pane>,
-        workspace: View<Workspace>,
-        cx: &mut WindowContext,
-    ) -> Task<Result<View<Self>>> {
-        let workspace = workspace.read(cx);
-        let project = workspace.project().to_owned();
-        let channel_store = ChannelStore::global(cx);
-        let language_registry = workspace.app_state().languages.clone();
-        let markdown = language_registry.language_for_name("Markdown");
-        let channel_buffer =
-            channel_store.update(cx, |store, cx| store.open_channel_buffer(channel_id, cx));
+//     pub fn open_in_pane(
+//         channel_id: ChannelId,
+//         pane: ViewHandle<Pane>,
+//         workspace: ViewHandle<Workspace>,
+//         cx: &mut AppContext,
+//     ) -> Task<Result<ViewHandle<Self>>> {
+//         let workspace = workspace.read(cx);
+//         let project = workspace.project().to_owned();
+//         let channel_store = ChannelStore::global(cx);
+//         let language_registry = workspace.app_state().languages.clone();
+//         let markdown = language_registry.language_for_name("Markdown");
+//         let channel_buffer =
+//             channel_store.update(cx, |store, cx| store.open_channel_buffer(channel_id, cx));

-        cx.spawn(|mut cx| async move {
-            let channel_buffer = channel_buffer.await?;
-            let markdown = markdown.await.log_err();
+//         cx.spawn(|mut cx| async move {
+//             let channel_buffer = channel_buffer.await?;
+//             let markdown = markdown.await.log_err();

-            channel_buffer.update(&mut cx, |buffer, cx| {
-                buffer.buffer().update(cx, |buffer, cx| {
-                    buffer.set_language_registry(language_registry);
-                    if let Some(markdown) = markdown {
-                        buffer.set_language(Some(markdown), cx);
-                    }
-                })
-            })?;
+//             channel_buffer.update(&mut cx, |buffer, cx| {
+//                 buffer.buffer().update(cx, |buffer, cx| {
+//                     buffer.set_language_registry(language_registry);
+//                     if let Some(markdown) = markdown {
+//                         buffer.set_language(Some(markdown), cx);
+//                     }
+//                 })
+//             });

-            pane.update(&mut cx, |pane, cx| {
-                let buffer_id = channel_buffer.read(cx).remote_id(cx);
+//             pane.update(&mut cx, |pane, cx| {
+//                 let buffer_id = channel_buffer.read(cx).remote_id(cx);

-                let existing_view = pane
-                    .items_of_type::<Self>()
-                    .find(|view| view.read(cx).channel_buffer.read(cx).remote_id(cx) == buffer_id);
+//                 let existing_view = pane
+//                     .items_of_type::<Self>()
+//                     .find(|view| view.read(cx).channel_buffer.read(cx).remote_id(cx) == buffer_id);

-                // If this channel buffer is already open in this pane, just return it.
-                if let Some(existing_view) = existing_view.clone() {
-                    if existing_view.read(cx).channel_buffer == channel_buffer {
-                        return existing_view;
-                    }
-                }
+//                 // If this channel buffer is already open in this pane, just return it.
+//                 if let Some(existing_view) = existing_view.clone() {
+//                     if existing_view.read(cx).channel_buffer == channel_buffer {
+//                         return existing_view;
+//                     }
+//                 }

-                let view = cx.build_view(|cx| {
-                    let mut this = Self::new(project, channel_store, channel_buffer, cx);
-                    this.acknowledge_buffer_version(cx);
-                    this
-                });
+//                 let view = cx.add_view(|cx| {
+//                     let mut this = Self::new(project, channel_store, channel_buffer, cx);
+//                     this.acknowledge_buffer_version(cx);
+//                     this
+//                 });

-                // If the pane contained a disconnected view for this channel buffer,
-                // replace that.
-                if let Some(existing_item) = existing_view {
-                    if let Some(ix) = pane.index_for_item(&existing_item) {
-                        pane.close_item_by_id(existing_item.entity_id(), SaveIntent::Skip, cx)
-                            .detach();
-                        pane.add_item(Box::new(view.clone()), true, true, Some(ix), cx);
-                    }
-                }
+//                 // If the pane contained a disconnected view for this channel buffer,
+//                 // replace that.
+//                 if let Some(existing_item) = existing_view {
+//                     if let Some(ix) = pane.index_for_item(&existing_item) {
+//                         pane.close_item_by_id(existing_item.id(), SaveIntent::Skip, cx)
+//                             .detach();
+//                         pane.add_item(Box::new(view.clone()), true, true, Some(ix), cx);
+//                     }
+//                 }

-                view
-            })
-        })
-    }
+//                 view
+//             })
+//             .ok_or_else(|| anyhow!("pane was dropped"))
+//         })
+//     }

-    pub fn new(
-        project: Model<Project>,
-        channel_store: Model<ChannelStore>,
-        channel_buffer: Model<ChannelBuffer>,
-        cx: &mut ViewContext<Self>,
-    ) -> Self {
-        let buffer = channel_buffer.read(cx).buffer();
-        let editor = cx.build_view(|cx| {
-            let mut editor = Editor::for_buffer(buffer, None, cx);
-            editor.set_collaboration_hub(Box::new(ChannelBufferCollaborationHub(
-                channel_buffer.clone(),
-            )));
-            editor.set_read_only(
-                !channel_buffer
-                    .read(cx)
-                    .channel(cx)
-                    .is_some_and(|c| c.can_edit_notes()),
-            );
-            editor
-        });
-        let _editor_event_subscription =
-            cx.subscribe(&editor, |_, _, e: &EditorEvent, cx| cx.emit(e.clone()));
+//     pub fn new(
+//         project: ModelHandle<Project>,
+//         channel_store: ModelHandle<ChannelStore>,
+//         channel_buffer: ModelHandle<ChannelBuffer>,
+//         cx: &mut ViewContext<Self>,
+//     ) -> Self {
+//         let buffer = channel_buffer.read(cx).buffer();
+//         let editor = cx.add_view(|cx| {
+//             let mut editor = Editor::for_buffer(buffer, None, cx);
+//             editor.set_collaboration_hub(Box::new(ChannelBufferCollaborationHub(
+//                 channel_buffer.clone(),
+//             )));
+//             editor.set_read_only(
+//                 !channel_buffer
+//                     .read(cx)
+//                     .channel(cx)
+//                     .is_some_and(|c| c.can_edit_notes()),
+//             );
+//             editor
+//         });
+//         let _editor_event_subscription = cx.subscribe(&editor, |_, _, e, cx| cx.emit(e.clone()));

-        cx.subscribe(&channel_buffer, Self::handle_channel_buffer_event)
-            .detach();
+//         cx.subscribe(&channel_buffer, Self::handle_channel_buffer_event)
+//             .detach();

-        Self {
-            editor,
-            project,
-            channel_store,
-            channel_buffer,
-            remote_id: None,
-            _editor_event_subscription,
-        }
-    }
+//         Self {
+//             editor,
+//             project,
+//             channel_store,
+//             channel_buffer,
+//             remote_id: None,
+//             _editor_event_subscription,
+//         }
+//     }

-    pub fn channel(&self, cx: &AppContext) -> Option<Arc<Channel>> {
-        self.channel_buffer.read(cx).channel(cx)
-    }
+//     pub fn channel(&self, cx: &AppContext) -> Option<Arc<Channel>> {
+//         self.channel_buffer.read(cx).channel(cx)
+//     }

-    fn handle_channel_buffer_event(
-        &mut self,
-        _: Model<ChannelBuffer>,
-        event: &ChannelBufferEvent,
-        cx: &mut ViewContext<Self>,
-    ) {
-        match event {
-            ChannelBufferEvent::Disconnected => self.editor.update(cx, |editor, cx| {
-                editor.set_read_only(true);
-                cx.notify();
-            }),
-            ChannelBufferEvent::ChannelChanged => {
-                self.editor.update(cx, |editor, cx| {
-                    editor.set_read_only(!self.channel(cx).is_some_and(|c| c.can_edit_notes()));
-                    cx.emit(editor::EditorEvent::TitleChanged);
-                    cx.notify()
-                });
-            }
-            ChannelBufferEvent::BufferEdited => {
-                if self.editor.read(cx).is_focused(cx) {
-                    self.acknowledge_buffer_version(cx);
-                } else {
-                    self.channel_store.update(cx, |store, cx| {
-                        let channel_buffer = self.channel_buffer.read(cx);
-                        store.notes_changed(
-                            channel_buffer.channel_id,
-                            channel_buffer.epoch(),
-                            &channel_buffer.buffer().read(cx).version(),
-                            cx,
-                        )
-                    });
-                }
-            }
-            ChannelBufferEvent::CollaboratorsChanged => {}
-        }
-    }
+//     fn handle_channel_buffer_event(
+//         &mut self,
+//         _: ModelHandle<ChannelBuffer>,
+//         event: &ChannelBufferEvent,
+//         cx: &mut ViewContext<Self>,
+//     ) {
+//         match event {
+//             ChannelBufferEvent::Disconnected => self.editor.update(cx, |editor, cx| {
+//                 editor.set_read_only(true);
+//                 cx.notify();
+//             }),
+//             ChannelBufferEvent::ChannelChanged => {
+//                 self.editor.update(cx, |editor, cx| {
+//                     editor.set_read_only(!self.channel(cx).is_some_and(|c| c.can_edit_notes()));
+//                     cx.emit(editor::Event::TitleChanged);
+//                     cx.notify()
+//                 });
+//             }
+//             ChannelBufferEvent::BufferEdited => {
+//                 if cx.is_self_focused() || self.editor.is_focused(cx) {
+//                     self.acknowledge_buffer_version(cx);
+//                 } else {
+//                     self.channel_store.update(cx, |store, cx| {
+//                         let channel_buffer = self.channel_buffer.read(cx);
+//                         store.notes_changed(
+//                             channel_buffer.channel_id,
+//                             channel_buffer.epoch(),
+//                             &channel_buffer.buffer().read(cx).version(),
+//                             cx,
+//                         )
+//                     });
+//                 }
+//             }
+//             ChannelBufferEvent::CollaboratorsChanged => {}
+//         }
+//     }

-    fn acknowledge_buffer_version(&mut self, cx: &mut ViewContext<ChannelView>) {
-        self.channel_store.update(cx, |store, cx| {
-            let channel_buffer = self.channel_buffer.read(cx);
-            store.acknowledge_notes_version(
-                channel_buffer.channel_id,
-                channel_buffer.epoch(),
-                &channel_buffer.buffer().read(cx).version(),
-                cx,
-            )
-        });
-        self.channel_buffer.update(cx, |buffer, cx| {
-            buffer.acknowledge_buffer_version(cx);
-        });
-    }
-}
+//     fn acknowledge_buffer_version(&mut self, cx: &mut ViewContext<'_, '_, ChannelView>) {
+//         self.channel_store.update(cx, |store, cx| {
+//             let channel_buffer = self.channel_buffer.read(cx);
+//             store.acknowledge_notes_version(
+//                 channel_buffer.channel_id,
+//                 channel_buffer.epoch(),
+//                 &channel_buffer.buffer().read(cx).version(),
+//                 cx,
+//             )
+//         });
+//         self.channel_buffer.update(cx, |buffer, cx| {
+//             buffer.acknowledge_buffer_version(cx);
+//         });
+//     }
+// }

-impl EventEmitter<EditorEvent> for ChannelView {}
+// impl Entity for ChannelView {
+//     type Event = editor::Event;
+// }

-impl Render for ChannelView {
-    type Element = AnyView;
+// impl View for ChannelView {
+//     fn ui_name() -> &'static str {
+//         "ChannelView"
+//     }

-    fn render(&mut self, _cx: &mut ViewContext<Self>) -> Self::Element {
-        self.editor.clone().into()
-    }
-}
+//     fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+//         ChildView::new(self.editor.as_any(), cx).into_any()
+//     }

-impl FocusableView for ChannelView {
-    fn focus_handle(&self, cx: &AppContext) -> gpui::FocusHandle {
-        self.editor.read(cx).focus_handle(cx)
-    }
-}
+//     fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+//         if cx.is_self_focused() {
+//             self.acknowledge_buffer_version(cx);
+//             cx.focus(self.editor.as_any())
+//         }
+//     }
+// }

-impl Item for ChannelView {
-    type Event = EditorEvent;
+// impl Item for ChannelView {
+//     fn act_as_type<'a>(
+//         &'a self,
+//         type_id: TypeId,
+//         self_handle: &'a ViewHandle<Self>,
+//         _: &'a AppContext,
+//     ) -> Option<&'a AnyViewHandle> {
+//         if type_id == TypeId::of::<Self>() {
+//             Some(self_handle)
+//         } else if type_id == TypeId::of::<Editor>() {
+//             Some(&self.editor)
+//         } else {
+//             None
+//         }
+//     }

-    fn act_as_type<'a>(
-        &'a self,
-        type_id: TypeId,
-        self_handle: &'a View<Self>,
-        _: &'a AppContext,
-    ) -> Option<AnyView> {
-        if type_id == TypeId::of::<Self>() {
-            Some(self_handle.to_any())
-        } else if type_id == TypeId::of::<Editor>() {
-            Some(self.editor.to_any())
-        } else {
-            None
-        }
-    }
+//     fn tab_content<V: 'static>(
+//         &self,
+//         _: Option<usize>,
+//         style: &theme::Tab,
+//         cx: &gpui::AppContext,
+//     ) -> AnyElement<V> {
+//         let label = if let Some(channel) = self.channel(cx) {
+//             match (
+//                 channel.can_edit_notes(),
+//                 self.channel_buffer.read(cx).is_connected(),
+//             ) {
+//                 (true, true) => format!("#{}", channel.name),
+//                 (false, true) => format!("#{} (read-only)", channel.name),
+//                 (_, false) => format!("#{} (disconnected)", channel.name),
+//             }
+//         } else {
+//             format!("channel notes (disconnected)")
+//         };
+//         Label::new(label, style.label.to_owned()).into_any()
+//     }

-    fn tab_content(&self, _: Option<usize>, selected: bool, cx: &WindowContext) -> AnyElement {
-        let label = if let Some(channel) = self.channel(cx) {
-            match (
-                channel.can_edit_notes(),
-                self.channel_buffer.read(cx).is_connected(),
-            ) {
-                (true, true) => format!("#{}", channel.name),
-                (false, true) => format!("#{} (read-only)", channel.name),
-                (_, false) => format!("#{} (disconnected)", channel.name),
-            }
-        } else {
-            format!("channel notes (disconnected)")
-        };
-        Label::new(label)
-            .color(if selected {
-                Color::Default
-            } else {
-                Color::Muted
-            })
-            .into_any_element()
-    }
+//     fn clone_on_split(&self, _: WorkspaceId, cx: &mut ViewContext<Self>) -> Option<Self> {
+//         Some(Self::new(
+//             self.project.clone(),
+//             self.channel_store.clone(),
+//             self.channel_buffer.clone(),
+//             cx,
+//         ))
+//     }

-    fn clone_on_split(&self, _: WorkspaceId, cx: &mut ViewContext<Self>) -> Option<View<Self>> {
-        Some(cx.build_view(|cx| {
-            Self::new(
-                self.project.clone(),
-                self.channel_store.clone(),
-                self.channel_buffer.clone(),
-                cx,
-            )
-        }))
-    }
+//     fn is_singleton(&self, _cx: &AppContext) -> bool {
+//         false
+//     }

-    fn is_singleton(&self, _cx: &AppContext) -> bool {
-        false
-    }
+//     fn navigate(&mut self, data: Box<dyn Any>, cx: &mut ViewContext<Self>) -> bool {
+//         self.editor
+//             .update(cx, |editor, cx| editor.navigate(data, cx))
+//     }

-    fn navigate(&mut self, data: Box<dyn Any>, cx: &mut ViewContext<Self>) -> bool {
-        self.editor
-            .update(cx, |editor, cx| editor.navigate(data, cx))
-    }
+//     fn deactivated(&mut self, cx: &mut ViewContext<Self>) {
+//         self.editor
+//             .update(cx, |editor, cx| Item::deactivated(editor, cx))
+//     }

-    fn deactivated(&mut self, cx: &mut ViewContext<Self>) {
-        self.editor
-            .update(cx, |editor, cx| Item::deactivated(editor, cx))
-    }
+//     fn set_nav_history(&mut self, history: ItemNavHistory, cx: &mut ViewContext<Self>) {
+//         self.editor
+//             .update(cx, |editor, cx| Item::set_nav_history(editor, history, cx))
+//     }

-    fn set_nav_history(&mut self, history: ItemNavHistory, cx: &mut ViewContext<Self>) {
-        self.editor
-            .update(cx, |editor, cx| Item::set_nav_history(editor, history, cx))
-    }
+//     fn as_searchable(&self, _: &ViewHandle<Self>) -> Option<Box<dyn SearchableItemHandle>> {
+//         Some(Box::new(self.editor.clone()))
+//     }

-    fn as_searchable(&self, _: &View<Self>) -> Option<Box<dyn SearchableItemHandle>> {
-        Some(Box::new(self.editor.clone()))
-    }
+//     fn show_toolbar(&self) -> bool {
+//         true
+//     }

-    fn show_toolbar(&self) -> bool {
-        true
-    }
+//     fn pixel_position_of_cursor(&self, cx: &AppContext) -> Option<Vector2F> {
+//         self.editor.read(cx).pixel_position_of_cursor(cx)
+//     }

-    fn pixel_position_of_cursor(&self, cx: &AppContext) -> Option<Point<Pixels>> {
-        self.editor.read(cx).pixel_position_of_cursor(cx)
-    }
+//     fn to_item_events(event: &Self::Event) -> SmallVec<[ItemEvent; 2]> {
+//         editor::Editor::to_item_events(event)
+//     }
+// }

-    fn to_item_events(event: &EditorEvent, f: impl FnMut(ItemEvent)) {
-        Editor::to_item_events(event, f)
-    }
-}
+// impl FollowableItem for ChannelView {
+//     fn remote_id(&self) -> Option<workspace::ViewId> {
+//         self.remote_id
+//     }

-impl FollowableItem for ChannelView {
-    fn remote_id(&self) -> Option<workspace::ViewId> {
-        self.remote_id
-    }
+//     fn to_state_proto(&self, cx: &AppContext) -> Option<proto::view::Variant> {
+//         let channel_buffer = self.channel_buffer.read(cx);
+//         if !channel_buffer.is_connected() {
+//             return None;
+//         }

-    fn to_state_proto(&self, cx: &WindowContext) -> Option<proto::view::Variant> {
-        let channel_buffer = self.channel_buffer.read(cx);
-        if !channel_buffer.is_connected() {
-            return None;
-        }
+//         Some(proto::view::Variant::ChannelView(
+//             proto::view::ChannelView {
+//                 channel_id: channel_buffer.channel_id,
+//                 editor: if let Some(proto::view::Variant::Editor(proto)) =
+//                     self.editor.read(cx).to_state_proto(cx)
+//                 {
+//                     Some(proto)
+//                 } else {
+//                     None
+//                 },
+//             },
+//         ))
+//     }

-        Some(proto::view::Variant::ChannelView(
-            proto::view::ChannelView {
-                channel_id: channel_buffer.channel_id,
-                editor: if let Some(proto::view::Variant::Editor(proto)) =
-                    self.editor.read(cx).to_state_proto(cx)
-                {
-                    Some(proto)
-                } else {
-                    None
-                },
-            },
-        ))
-    }
+//     fn from_state_proto(
+//         pane: ViewHandle<workspace::Pane>,
+//         workspace: ViewHandle<workspace::Workspace>,
+//         remote_id: workspace::ViewId,
+//         state: &mut Option<proto::view::Variant>,
+//         cx: &mut AppContext,
+//     ) -> Option<gpui::Task<anyhow::Result<ViewHandle<Self>>>> {
+//         let Some(proto::view::Variant::ChannelView(_)) = state else {
+//             return None;
+//         };
+//         let Some(proto::view::Variant::ChannelView(state)) = state.take() else {
+//             unreachable!()
+//         };

-    fn from_state_proto(
-        pane: View<workspace::Pane>,
-        workspace: View<workspace::Workspace>,
-        remote_id: workspace::ViewId,
-        state: &mut Option<proto::view::Variant>,
-        cx: &mut WindowContext,
-    ) -> Option<gpui::Task<anyhow::Result<View<Self>>>> {
-        let Some(proto::view::Variant::ChannelView(_)) = state else {
-            return None;
-        };
-        let Some(proto::view::Variant::ChannelView(state)) = state.take() else {
-            unreachable!()
-        };
+//         let open = ChannelView::open_in_pane(state.channel_id, pane, workspace, cx);

-        let open = ChannelView::open_in_pane(state.channel_id, pane, workspace, cx);
+//         Some(cx.spawn(|mut cx| async move {
+//             let this = open.await?;

-        Some(cx.spawn(|mut cx| async move {
-            let this = open.await?;
+//             let task = this
+//                 .update(&mut cx, |this, cx| {
+//                     this.remote_id = Some(remote_id);

-            let task = this.update(&mut cx, |this, cx| {
-                this.remote_id = Some(remote_id);
+//                     if let Some(state) = state.editor {
+//                         Some(this.editor.update(cx, |editor, cx| {
+//                             editor.apply_update_proto(
+//                                 &this.project,
+//                                 proto::update_view::Variant::Editor(proto::update_view::Editor {
+//                                     selections: state.selections,
+//                                     pending_selection: state.pending_selection,
+//                                     scroll_top_anchor: state.scroll_top_anchor,
+//                                     scroll_x: state.scroll_x,
+//                                     scroll_y: state.scroll_y,
+//                                     ..Default::default()
+//                                 }),
+//                                 cx,
+//                             )
+//                         }))
+//                     } else {
+//                         None
+//                     }
+//                 })
+//                 .ok_or_else(|| anyhow!("window was closed"))?;

-                if let Some(state) = state.editor {
-                    Some(this.editor.update(cx, |editor, cx| {
-                        editor.apply_update_proto(
-                            &this.project,
-                            proto::update_view::Variant::Editor(proto::update_view::Editor {
-                                selections: state.selections,
-                                pending_selection: state.pending_selection,
-                                scroll_top_anchor: state.scroll_top_anchor,
-                                scroll_x: state.scroll_x,
-                                scroll_y: state.scroll_y,
-                                ..Default::default()
-                            }),
-                            cx,
-                        )
-                    }))
-                } else {
-                    None
-                }
-            })?;
+//             if let Some(task) = task {
+//                 task.await?;
+//             }

-            if let Some(task) = task {
-                task.await?;
-            }
+//             Ok(this)
+//         }))
+//     }

-            Ok(this)
-        }))
-    }
+//     fn add_event_to_update_proto(
+//         &self,
+//         event: &Self::Event,
+//         update: &mut Option<proto::update_view::Variant>,
+//         cx: &AppContext,
+//     ) -> bool {
+//         self.editor
+//             .read(cx)
+//             .add_event_to_update_proto(event, update, cx)
+//     }

-    fn add_event_to_update_proto(
-        &self,
-        event: &EditorEvent,
-        update: &mut Option<proto::update_view::Variant>,
-        cx: &WindowContext,
-    ) -> bool {
-        self.editor
-            .read(cx)
-            .add_event_to_update_proto(event, update, cx)
-    }
+//     fn apply_update_proto(
+//         &mut self,
+//         project: &ModelHandle<Project>,
+//         message: proto::update_view::Variant,
+//         cx: &mut ViewContext<Self>,
+//     ) -> gpui::Task<anyhow::Result<()>> {
+//         self.editor.update(cx, |editor, cx| {
+//             editor.apply_update_proto(project, message, cx)
+//         })
+//     }

-    fn apply_update_proto(
-        &mut self,
-        project: &Model<Project>,
-        message: proto::update_view::Variant,
-        cx: &mut ViewContext<Self>,
-    ) -> gpui::Task<anyhow::Result<()>> {
-        self.editor.update(cx, |editor, cx| {
-            editor.apply_update_proto(project, message, cx)
-        })
-    }
+//     fn set_leader_peer_id(&mut self, leader_peer_id: Option<PeerId>, cx: &mut ViewContext<Self>) {
+//         self.editor.update(cx, |editor, cx| {
+//             editor.set_leader_peer_id(leader_peer_id, cx)
+//         })
+//     }

-    fn set_leader_peer_id(&mut self, leader_peer_id: Option<PeerId>, cx: &mut ViewContext<Self>) {
-        self.editor.update(cx, |editor, cx| {
-            editor.set_leader_peer_id(leader_peer_id, cx)
-        })
-    }
+//     fn should_unfollow_on_event(event: &Self::Event, cx: &AppContext) -> bool {
+//         Editor::should_unfollow_on_event(event, cx)
+//     }

-    fn is_project_item(&self, _cx: &WindowContext) -> bool {
-        false
-    }
+//     fn is_project_item(&self, _cx: &AppContext) -> bool {
+//         false
+//     }
+// }

-    fn to_follow_event(event: &Self::Event) -> Option<workspace::item::FollowEvent> {
-        Editor::to_follow_event(event)
-    }
-}
+// struct ChannelBufferCollaborationHub(ModelHandle<ChannelBuffer>);

-struct ChannelBufferCollaborationHub(Model<ChannelBuffer>);
+// impl CollaborationHub for ChannelBufferCollaborationHub {
+//     fn collaborators<'a>(&self, cx: &'a AppContext) -> &'a HashMap<PeerId, Collaborator> {
+//         self.0.read(cx).collaborators()
+//     }

-impl CollaborationHub for ChannelBufferCollaborationHub {
-    fn collaborators<'a>(&self, cx: &'a AppContext) -> &'a HashMap<PeerId, Collaborator> {
-        self.0.read(cx).collaborators()
-    }
-
-    fn user_participant_indices<'a>(
-        &self,
-        cx: &'a AppContext,
-    ) -> &'a HashMap<u64, ParticipantIndex> {
-        self.0.read(cx).user_store().read(cx).participant_indices()
-    }
-}
+//     fn user_participant_indices<'a>(
+//         &self,
+//         cx: &'a AppContext,
+//     ) -> &'a HashMap<u64, ParticipantIndex> {
+//         self.0.read(cx).user_store().read(cx).participant_indices()
+//     }
+// }
--- a/crates/collab_ui2/src/chat_panel.rs
+++ b/crates/collab_ui2/src/chat_panel.rs
--- a/crates/collab_ui2/src/chat_panel/message_editor.rs
+++ b/crates/collab_ui2/src/chat_panel/message_editor.rs
@@ -3,14 +3,13 @@ use client::UserId;
 use collections::HashMap;
 use editor::{AnchorRangeExt, Editor};
 use gpui::{
-    AnyView, AsyncWindowContext, FocusableView, Model, Render, SharedString, Task, View,
-    ViewContext, WeakView,
+    elements::ChildView, AnyElement, AsyncAppContext, Element, Entity, ModelHandle, Task, View,
+    ViewContext, ViewHandle, WeakViewHandle,
 };
 use language::{language_settings::SoftWrap, Buffer, BufferSnapshot, LanguageRegistry};
 use lazy_static::lazy_static;
 use project::search::SearchQuery;
 use std::{sync::Arc, time::Duration};
-use workspace::item::ItemHandle;

 const MENTIONS_DEBOUNCE_INTERVAL: Duration = Duration::from_millis(50);

@@ -20,8 +19,8 @@ lazy_static! {
 }

 pub struct MessageEditor {
-    pub editor: View<Editor>,
-    channel_store: Model<ChannelStore>,
+    pub editor: ViewHandle<Editor>,
+    channel_store: ModelHandle<ChannelStore>,
    users: HashMap<String, UserId>,
    mentions: Vec<UserId>,
    mentions_task: Option<Task<()>>,
@@ -31,8 +30,8 @@ pub struct MessageEditor {
 impl MessageEditor {
    pub fn new(
        language_registry: Arc<LanguageRegistry>,
-        channel_store: Model<ChannelStore>,
-        editor: View<Editor>,
+        channel_store: ModelHandle<ChannelStore>,
+        editor: ViewHandle<Editor>,
        cx: &mut ViewContext<Self>,
    ) -> Self {
        editor.update(cx, |editor, cx| {
@@ -49,13 +48,15 @@ impl MessageEditor {
        cx.subscribe(&buffer, Self::on_buffer_event).detach();

        let markdown = language_registry.language_for_name("Markdown");
-        cx.spawn(|_, mut cx| async move {
-            let markdown = markdown.await?;
-            buffer.update(&mut cx, |buffer, cx| {
-                buffer.set_language(Some(markdown), cx)
+        cx.app_context()
+            .spawn(|mut cx| async move {
+                let markdown = markdown.await?;
+                buffer.update(&mut cx, |buffer, cx| {
+                    buffer.set_language(Some(markdown), cx)
+                });
+                anyhow::Ok(())
            })
-        })
-        .detach_and_log_err(cx);
+            .detach_and_log_err(cx);

        Self {
            editor,
@@ -70,7 +71,7 @@ impl MessageEditor {
    pub fn set_channel(
        &mut self,
        channel_id: u64,
-        channel_name: Option<SharedString>,
+        channel_name: Option<String>,
        cx: &mut ViewContext<Self>,
    ) {
        self.editor.update(cx, |editor, cx| {
@@ -131,28 +132,26 @@ impl MessageEditor {

    fn on_buffer_event(
        &mut self,
-        buffer: Model<Buffer>,
+        buffer: ModelHandle<Buffer>,
        event: &language::Event,
        cx: &mut ViewContext<Self>,
    ) {
        if let language::Event::Reparsed | language::Event::Edited = event {
            let buffer = buffer.read(cx).snapshot();
            self.mentions_task = Some(cx.spawn(|this, cx| async move {
-                cx.background_executor()
-                    .timer(MENTIONS_DEBOUNCE_INTERVAL)
-                    .await;
+                cx.background().timer(MENTIONS_DEBOUNCE_INTERVAL).await;
                Self::find_mentions(this, buffer, cx).await;
            }));
        }
    }

    async fn find_mentions(
-        this: WeakView<MessageEditor>,
+        this: WeakViewHandle<MessageEditor>,
        buffer: BufferSnapshot,
-        mut cx: AsyncWindowContext,
+        mut cx: AsyncAppContext,
    ) {
        let (buffer, ranges) = cx
-            .background_executor()
+            .background()
            .spawn(async move {
                let ranges = MENTIONS_SEARCH.search(&buffer, None).await;
                (buffer, ranges)
@@ -181,7 +180,11 @@ impl MessageEditor {
                }

                editor.clear_highlights::<Self>(cx);
-                editor.highlight_text::<Self>(anchor_ranges, gpui::red().into(), cx)
+                editor.highlight_text::<Self>(
+                    anchor_ranges,
+                    theme::current(cx).chat_panel.rich_text.mention_highlight,
+                    cx,
+                )
            });

            this.mentions = mentioned_user_ids;
@@ -189,17 +192,21 @@ impl MessageEditor {
        })
        .ok();
    }
-
-    pub(crate) fn focus_handle(&self, cx: &gpui::AppContext) -> gpui::FocusHandle {
-        self.editor.read(cx).focus_handle(cx)
-    }
 }

-impl Render for MessageEditor {
-    type Element = AnyView;
+impl Entity for MessageEditor {
+    type Event = ();
+}

-    fn render(&mut self, _cx: &mut ViewContext<Self>) -> Self::Element {
-        self.editor.to_any()
+impl View for MessageEditor {
+    fn render(&mut self, cx: &mut ViewContext<'_, '_, Self>) -> AnyElement<Self> {
+        ChildView::new(&self.editor, cx).into_any()
+    }
+
+    fn focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
+        if cx.is_self_focused() {
+            cx.focus(&self.editor);
+        }
    }
 }

@@ -207,7 +214,7 @@ impl Render for MessageEditor {
 mod tests {
    use super::*;
    use client::{Client, User, UserStore};
-    use gpui::{Context as _, TestAppContext, VisualContext as _};
+    use gpui::{TestAppContext, WindowHandle};
    use language::{Language, LanguageConfig};
    use rpc::proto;
    use settings::SettingsStore;
@@ -215,17 +222,8 @@ mod tests {

    #[gpui::test]
    async fn test_message_editor(cx: &mut TestAppContext) {
-        let language_registry = init_test(cx);
-
-        let (editor, cx) = cx.add_window_view(|cx| {
-            MessageEditor::new(
-                language_registry,
-                ChannelStore::global(cx),
-                cx.build_view(|cx| Editor::auto_height(4, cx)),
-                cx,
-            )
-        });
-        cx.executor().run_until_parked();
+        let editor = init_test(cx);
+        let editor = editor.root(cx);

        editor.update(cx, |editor, cx| {
            editor.set_members(
@@ -234,7 +232,7 @@ mod tests {
                        user: Arc::new(User {
                            github_login: "a-b".into(),
                            id: 101,
-                            avatar_uri: "avatar_a-b".into(),
+                            avatar: None,
                        }),
                        kind: proto::channel_member::Kind::Member,
                        role: proto::ChannelRole::Member,
@@ -243,7 +241,7 @@ mod tests {
                        user: Arc::new(User {
                            github_login: "C_D".into(),
                            id: 102,
-                            avatar_uri: "avatar_C_D".into(),
+                            avatar: None,
                        }),
                        kind: proto::channel_member::Kind::Member,
                        role: proto::ChannelRole::Member,
@@ -257,7 +255,7 @@ mod tests {
            });
        });

-        cx.executor().advance_clock(MENTIONS_DEBOUNCE_INTERVAL);
+        cx.foreground().advance_clock(MENTIONS_DEBOUNCE_INTERVAL);

        editor.update(cx, |editor, cx| {
            let (text, ranges) = marked_text_ranges("Hello, «@a-b»! Have you met «@C_D»?", false);
@@ -271,14 +269,15 @@ mod tests {
        });
    }

-    fn init_test(cx: &mut TestAppContext) -> Arc<LanguageRegistry> {
+    fn init_test(cx: &mut TestAppContext) -> WindowHandle<MessageEditor> {
+        cx.foreground().forbid_parking();
+
        cx.update(|cx| {
            let http = FakeHttpClient::with_404_response();
            let client = Client::new(http.clone(), cx);
-            let user_store = cx.build_model(|cx| UserStore::new(client.clone(), cx));
-            let settings = SettingsStore::test(cx);
-            cx.set_global(settings);
-            theme::init(theme::LoadThemes::JustBase, cx);
+            let user_store = cx.add_model(|cx| UserStore::new(client.clone(), http, cx));
+            cx.set_global(SettingsStore::test(cx));
+            theme::init((), cx);
            language::init(cx);
            editor::init(cx);
            client::init(&client, cx);
@@ -293,6 +292,16 @@ mod tests {
            },
            Some(tree_sitter_markdown::language()),
        )));
-        language_registry
+
+        let editor = cx.add_window(|cx| {
+            MessageEditor::new(
+                language_registry,
+                ChannelStore::global(cx),
+                cx.add_view(|cx| Editor::auto_height(4, None, cx)),
+                cx,
+            )
+        });
+        cx.foreground().run_until_parked();
+        editor
    }
 }
--- a/crates/collab_ui2/src/collab_panel.rs
+++ b/crates/collab_ui2/src/collab_panel.rs
--- a/crates/collab_ui2/src/collab_panel/channel_modal.rs
+++ b/crates/collab_ui2/src/collab_panel/channel_modal.rs
@@ -3,17 +3,19 @@ use client::{
    proto::{self, ChannelRole, ChannelVisibility},
    User, UserId, UserStore,
 };
+use context_menu::{ContextMenu, ContextMenuItem};
 use fuzzy::{match_strings, StringMatchCandidate};
 use gpui::{
-    actions, div, overlay, AppContext, ClipboardItem, DismissEvent, Div, EventEmitter,
-    FocusableView, Model, ParentElement, Render, Styled, Subscription, Task, View, ViewContext,
-    VisualContext, WeakView,
+    actions,
+    elements::*,
+    platform::{CursorStyle, MouseButton},
+    AppContext, ClipboardItem, Entity, ModelHandle, MouseState, Task, View, ViewContext,
+    ViewHandle,
 };
-use picker::{Picker, PickerDelegate};
+use picker::{Picker, PickerDelegate, PickerEvent};
 use std::sync::Arc;
-use ui::{prelude::*, Avatar, Checkbox, ContextMenu, ListItem};
 use util::TryFutureExt;
-use workspace::ModalView;
+use workspace::Modal;

 actions!(
    channel_modal,
@@ -25,27 +27,34 @@ actions!(
    ]
 );

+pub fn init(cx: &mut AppContext) {
+    Picker::<ChannelModalDelegate>::init(cx);
+    cx.add_action(ChannelModal::toggle_mode);
+    cx.add_action(ChannelModal::toggle_member_admin);
+    cx.add_action(ChannelModal::remove_member);
+    cx.add_action(ChannelModal::dismiss);
+}
+
 pub struct ChannelModal {
-    picker: View<Picker<ChannelModalDelegate>>,
-    channel_store: Model<ChannelStore>,
+    picker: ViewHandle<Picker<ChannelModalDelegate>>,
+    channel_store: ModelHandle<ChannelStore>,
    channel_id: ChannelId,
+    has_focus: bool,
 }

 impl ChannelModal {
    pub fn new(
-        user_store: Model<UserStore>,
-        channel_store: Model<ChannelStore>,
+        user_store: ModelHandle<UserStore>,
+        channel_store: ModelHandle<ChannelStore>,
        channel_id: ChannelId,
        mode: Mode,
        members: Vec<ChannelMembership>,
        cx: &mut ViewContext<Self>,
    ) -> Self {
        cx.observe(&channel_store, |_, _, cx| cx.notify()).detach();
-        let channel_modal = cx.view().downgrade();
-        let picker = cx.build_view(|cx| {
+        let picker = cx.add_view(|cx| {
            Picker::new(
                ChannelModalDelegate {
-                    channel_modal,
                    matching_users: Vec::new(),
                    matching_member_indices: Vec::new(),
                    selected_index: 0,
@@ -53,24 +62,33 @@ impl ChannelModal {
                    channel_store: channel_store.clone(),
                    channel_id,
                    match_candidates: Vec::new(),
-                    context_menu: None,
                    members,
                    mode,
+                    context_menu: cx.add_view(|cx| {
+                        let mut menu = ContextMenu::new(cx.view_id(), cx);
+                        menu.set_position_mode(OverlayPositionMode::Local);
+                        menu
+                    }),
                },
                cx,
            )
-            .modal(false)
+            .with_theme(|theme| theme.collab_panel.tabbed_modal.picker.clone())
        });

+        cx.subscribe(&picker, |_, _, e, cx| cx.emit(*e)).detach();
+
+        let has_focus = picker.read(cx).has_focus();
+
        Self {
            picker,
            channel_store,
            channel_id,
+            has_focus,
        }
    }

    fn toggle_mode(&mut self, _: &ToggleMode, cx: &mut ViewContext<Self>) {
-        let mode = match self.picker.read(cx).delegate.mode {
+        let mode = match self.picker.read(cx).delegate().mode {
            Mode::ManageMembers => Mode::InviteMembers,
            Mode::InviteMembers => Mode::ManageMembers,
        };
@@ -85,20 +103,20 @@ impl ChannelModal {
                let mut members = channel_store
                    .update(&mut cx, |channel_store, cx| {
                        channel_store.get_channel_member_details(channel_id, cx)
-                    })?
+                    })
                    .await?;

                members.sort_by(|a, b| a.sort_key().cmp(&b.sort_key()));

                this.update(&mut cx, |this, cx| {
                    this.picker
-                        .update(cx, |picker, _| picker.delegate.members = members);
+                        .update(cx, |picker, _| picker.delegate_mut().members = members);
                })?;
            }

            this.update(&mut cx, |this, cx| {
                this.picker.update(cx, |picker, cx| {
-                    let delegate = &mut picker.delegate;
+                    let delegate = picker.delegate_mut();
                    delegate.mode = mode;
                    delegate.selected_index = 0;
                    picker.set_query("", cx);
@@ -111,120 +129,204 @@ impl ChannelModal {
        .detach();
    }

-    fn set_channel_visiblity(&mut self, selection: &Selection, cx: &mut ViewContext<Self>) {
-        self.channel_store.update(cx, |channel_store, cx| {
-            channel_store
-                .set_channel_visibility(
-                    self.channel_id,
-                    match selection {
-                        Selection::Unselected => ChannelVisibility::Members,
-                        Selection::Selected => ChannelVisibility::Public,
-                        Selection::Indeterminate => return,
-                    },
-                    cx,
-                )
-                .detach_and_log_err(cx)
+    fn toggle_member_admin(&mut self, _: &ToggleMemberAdmin, cx: &mut ViewContext<Self>) {
+        self.picker.update(cx, |picker, cx| {
+            picker.delegate_mut().toggle_selected_member_admin(cx);
+        })
+    }
+
+    fn remove_member(&mut self, _: &RemoveMember, cx: &mut ViewContext<Self>) {
+        self.picker.update(cx, |picker, cx| {
+            picker.delegate_mut().remove_selected_member(cx);
        });
    }

    fn dismiss(&mut self, _: &menu::Cancel, cx: &mut ViewContext<Self>) {
-        cx.emit(DismissEvent);
+        cx.emit(PickerEvent::Dismiss);
    }
 }

-impl EventEmitter<DismissEvent> for ChannelModal {}
-impl ModalView for ChannelModal {}
-
-impl FocusableView for ChannelModal {
-    fn focus_handle(&self, cx: &AppContext) -> gpui::FocusHandle {
-        self.picker.focus_handle(cx)
-    }
+impl Entity for ChannelModal {
+    type Event = PickerEvent;
 }

-impl Render for ChannelModal {
-    type Element = Div;
+impl View for ChannelModal {
+    fn ui_name() -> &'static str {
+        "ChannelModal"
+    }

-    fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-        let channel_store = self.channel_store.read(cx);
-        let Some(channel) = channel_store.channel_for_id(self.channel_id) else {
-            return div();
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+        let theme = &theme::current(cx).collab_panel.tabbed_modal;
+
+        let mode = self.picker.read(cx).delegate().mode;
+        let Some(channel) = self.channel_store.read(cx).channel_for_id(self.channel_id) else {
+            return Empty::new().into_any();
        };
-        let channel_name = channel.name.clone();
-        let channel_id = channel.id;
-        let visibility = channel.visibility;
-        let mode = self.picker.read(cx).delegate.mode;

-        v_stack()
-            .key_context("ChannelModal")
-            .on_action(cx.listener(Self::toggle_mode))
-            .on_action(cx.listener(Self::dismiss))
-            .elevation_3(cx)
-            .w(rems(34.))
-            .child(
-                v_stack()
-                    .px_2()
-                    .py_1()
-                    .rounded_t(px(8.))
-                    .bg(cx.theme().colors().element_background)
-                    .child(IconElement::new(Icon::Hash).size(IconSize::Medium))
-                    .child(Label::new(channel_name))
-                    .child(
-                        h_stack()
-                            .w_full()
-                            .justify_between()
-                            .child(
-                                h_stack()
-                                    .gap_2()
-                                    .child(
-                                        Checkbox::new(
-                                            "is-public",
-                                            if visibility == ChannelVisibility::Public {
-                                                ui::Selection::Selected
-                                            } else {
-                                                ui::Selection::Unselected
-                                            },
-                                        )
-                                        .on_click(cx.listener(Self::set_channel_visiblity)),
+        enum InviteMembers {}
+        enum ManageMembers {}
+
+        fn render_mode_button<T: 'static>(
+            mode: Mode,
+            text: &'static str,
+            current_mode: Mode,
+            theme: &theme::TabbedModal,
+            cx: &mut ViewContext<ChannelModal>,
+        ) -> AnyElement<ChannelModal> {
+            let active = mode == current_mode;
+            MouseEventHandler::new::<T, _>(0, cx, move |state, _| {
+                let contained_text = theme.tab_button.style_for(active, state);
+                Label::new(text, contained_text.text.clone())
+                    .contained()
+                    .with_style(contained_text.container.clone())
+            })
+            .on_click(MouseButton::Left, move |_, this, cx| {
+                if !active {
+                    this.set_mode(mode, cx);
+                }
+            })
+            .with_cursor_style(CursorStyle::PointingHand)
+            .into_any()
+        }
+
+        fn render_visibility(
+            channel_id: ChannelId,
+            visibility: ChannelVisibility,
+            theme: &theme::TabbedModal,
+            cx: &mut ViewContext<ChannelModal>,
+        ) -> AnyElement<ChannelModal> {
+            enum TogglePublic {}
+
+            if visibility == ChannelVisibility::Members {
+                return Flex::row()
+                    .with_child(
+                        MouseEventHandler::new::<TogglePublic, _>(0, cx, move |state, _| {
+                            let style = theme.visibility_toggle.style_for(state);
+                            Label::new(format!("{}", "Public access: OFF"), style.text.clone())
+                                .contained()
+                                .with_style(style.container.clone())
+                        })
+                        .on_click(MouseButton::Left, move |_, this, cx| {
+                            this.channel_store
+                                .update(cx, |channel_store, cx| {
+                                    channel_store.set_channel_visibility(
+                                        channel_id,
+                                        ChannelVisibility::Public,
+                                        cx,
                                    )
-                                    .child(Label::new("Public")),
-                            )
-                            .children(if visibility == ChannelVisibility::Public {
-                                Some(Button::new("copy-link", "Copy Link").on_click(cx.listener(
-                                    move |this, _, cx| {
-                                        if let Some(channel) =
-                                            this.channel_store.read(cx).channel_for_id(channel_id)
-                                        {
-                                            let item = ClipboardItem::new(channel.link());
-                                            cx.write_to_clipboard(item);
-                                        }
-                                    },
-                                )))
-                            } else {
-                                None
-                            }),
+                                })
+                                .detach_and_log_err(cx);
+                        })
+                        .with_cursor_style(CursorStyle::PointingHand),
                    )
-                    .child(
-                        div()
-                            .w_full()
-                            .flex()
-                            .flex_row()
-                            .child(
-                                Button::new("manage-members", "Manage Members")
-                                    .selected(mode == Mode::ManageMembers)
-                                    .on_click(cx.listener(|this, _, cx| {
-                                        this.set_mode(Mode::ManageMembers, cx);
-                                    })),
-                            )
-                            .child(
-                                Button::new("invite-members", "Invite Members")
-                                    .selected(mode == Mode::InviteMembers)
-                                    .on_click(cx.listener(|this, _, cx| {
-                                        this.set_mode(Mode::InviteMembers, cx);
-                                    })),
-                            ),
-                    ),
+                    .into_any();
+            }
+
+            Flex::row()
+                .with_child(
+                    MouseEventHandler::new::<TogglePublic, _>(0, cx, move |state, _| {
+                        let style = theme.visibility_toggle.style_for(state);
+                        Label::new(format!("{}", "Public access: ON"), style.text.clone())
+                            .contained()
+                            .with_style(style.container.clone())
+                    })
+                    .on_click(MouseButton::Left, move |_, this, cx| {
+                        this.channel_store
+                            .update(cx, |channel_store, cx| {
+                                channel_store.set_channel_visibility(
+                                    channel_id,
+                                    ChannelVisibility::Members,
+                                    cx,
+                                )
+                            })
+                            .detach_and_log_err(cx);
+                    })
+                    .with_cursor_style(CursorStyle::PointingHand),
+                )
+                .with_spacing(14.0)
+                .with_child(
+                    MouseEventHandler::new::<TogglePublic, _>(1, cx, move |state, _| {
+                        let style = theme.channel_link.style_for(state);
+                        Label::new(format!("{}", "copy link"), style.text.clone())
+                            .contained()
+                            .with_style(style.container.clone())
+                    })
+                    .on_click(MouseButton::Left, move |_, this, cx| {
+                        if let Some(channel) =
+                            this.channel_store.read(cx).channel_for_id(channel_id)
+                        {
+                            let item = ClipboardItem::new(channel.link());
+                            cx.write_to_clipboard(item);
+                        }
+                    })
+                    .with_cursor_style(CursorStyle::PointingHand),
+                )
+                .into_any()
+        }
+
+        Flex::column()
+            .with_child(
+                Flex::column()
+                    .with_child(
+                        Label::new(format!("#{}", channel.name), theme.title.text.clone())
+                            .contained()
+                            .with_style(theme.title.container.clone()),
+                    )
+                    .with_child(render_visibility(channel.id, channel.visibility, theme, cx))
+                    .with_child(Flex::row().with_children([
+                        render_mode_button::<InviteMembers>(
+                            Mode::InviteMembers,
+                            "Invite members",
+                            mode,
+                            theme,
+                            cx,
+                        ),
+                        render_mode_button::<ManageMembers>(
+                            Mode::ManageMembers,
+                            "Manage members",
+                            mode,
+                            theme,
+                            cx,
+                        ),
+                    ]))
+                    .expanded()
+                    .contained()
+                    .with_style(theme.header),
            )
-            .child(self.picker.clone())
+            .with_child(
+                ChildView::new(&self.picker, cx)
+                    .contained()
+                    .with_style(theme.body),
+            )
+            .constrained()
+            .with_max_height(theme.max_height)
+            .with_max_width(theme.max_width)
+            .contained()
+            .with_style(theme.modal)
+            .into_any()
+    }
+
+    fn focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
+        self.has_focus = true;
+        if cx.is_self_focused() {
+            cx.focus(&self.picker)
+        }
+    }
+
+    fn focus_out(&mut self, _: gpui::AnyViewHandle, _: &mut ViewContext<Self>) {
+        self.has_focus = false;
+    }
+}
+
+impl Modal for ChannelModal {
+    fn has_focus(&self) -> bool {
+        self.has_focus
+    }
+
+    fn dismiss_on_event(event: &Self::Event) -> bool {
+        match event {
+            PickerEvent::Dismiss => true,
+        }
    }
 }

@@ -235,22 +337,19 @@ pub enum Mode {
 }

 pub struct ChannelModalDelegate {
-    channel_modal: WeakView<ChannelModal>,
    matching_users: Vec<Arc<User>>,
    matching_member_indices: Vec<usize>,
-    user_store: Model<UserStore>,
-    channel_store: Model<ChannelStore>,
+    user_store: ModelHandle<UserStore>,
+    channel_store: ModelHandle<ChannelStore>,
    channel_id: ChannelId,
    selected_index: usize,
    mode: Mode,
    match_candidates: Vec<StringMatchCandidate>,
    members: Vec<ChannelMembership>,
-    context_menu: Option<(View<ContextMenu>, Subscription)>,
+    context_menu: ViewHandle<ContextMenu>,
 }

 impl PickerDelegate for ChannelModalDelegate {
-    type ListItem = ListItem;
-
    fn placeholder_text(&self) -> Arc<str> {
        "Search collaborator by username...".into()
    }
@@ -283,19 +382,19 @@ impl PickerDelegate for ChannelModalDelegate {
                        }
                    }));

-                let matches = cx.background_executor().block(match_strings(
+                let matches = cx.background().block(match_strings(
                    &self.match_candidates,
                    &query,
                    true,
                    usize::MAX,
                    &Default::default(),
-                    cx.background_executor().clone(),
+                    cx.background().clone(),
                ));

                cx.spawn(|picker, mut cx| async move {
                    picker
                        .update(&mut cx, |picker, cx| {
-                            let delegate = &mut picker.delegate;
+                            let delegate = picker.delegate_mut();
                            delegate.matching_member_indices.clear();
                            delegate
                                .matching_member_indices
@@ -313,7 +412,8 @@ impl PickerDelegate for ChannelModalDelegate {
                    async {
                        let users = search_users.await?;
                        picker.update(&mut cx, |picker, cx| {
-                            picker.delegate.matching_users = users;
+                            let delegate = picker.delegate_mut();
+                            delegate.matching_users = users;
                            cx.notify();
                        })?;
                        anyhow::Ok(())
@@ -329,11 +429,11 @@ impl PickerDelegate for ChannelModalDelegate {
        if let Some((selected_user, role)) = self.user_at_index(self.selected_index) {
            match self.mode {
                Mode::ManageMembers => {
-                    self.show_context_menu(selected_user, role.unwrap_or(ChannelRole::Member), cx)
+                    self.show_context_menu(role.unwrap_or(ChannelRole::Member), cx)
                }
                Mode::InviteMembers => match self.member_status(selected_user.id, cx) {
                    Some(proto::channel_member::Kind::Invitee) => {
-                        self.remove_member(selected_user.id, cx);
+                        self.remove_selected_member(cx);
                    }
                    Some(proto::channel_member::Kind::AncestorMember) | None => {
                        self.invite_member(selected_user, cx)
@@ -345,69 +445,138 @@ impl PickerDelegate for ChannelModalDelegate {
    }

    fn dismissed(&mut self, cx: &mut ViewContext<Picker<Self>>) {
-        if self.context_menu.is_none() {
-            self.channel_modal
-                .update(cx, |_, cx| {
-                    cx.emit(DismissEvent);
-                })
-                .ok();
-        }
+        cx.emit(PickerEvent::Dismiss);
    }

    fn render_match(
        &self,
        ix: usize,
+        mouse_state: &mut MouseState,
        selected: bool,
-        cx: &mut ViewContext<Picker<Self>>,
-    ) -> Option<Self::ListItem> {
-        let (user, role) = self.user_at_index(ix)?;
+        cx: &gpui::AppContext,
+    ) -> AnyElement<Picker<Self>> {
+        let full_theme = &theme::current(cx);
+        let theme = &full_theme.collab_panel.channel_modal;
+        let tabbed_modal = &full_theme.collab_panel.tabbed_modal;
+        let (user, role) = self.user_at_index(ix).unwrap();
        let request_status = self.member_status(user.id, cx);

-        Some(
-            ListItem::new(ix)
-                .inset(true)
-                .selected(selected)
-                .start_slot(Avatar::new(user.avatar_uri.clone()))
-                .child(Label::new(user.github_login.clone()))
-                .end_slot(h_stack().gap_2().map(|slot| {
-                    match self.mode {
-                        Mode::ManageMembers => slot
-                            .children(
-                                if request_status == Some(proto::channel_member::Kind::Invitee) {
-                                    Some(Label::new("Invited"))
-                                } else {
-                                    None
-                                },
-                            )
-                            .children(match role {
-                                Some(ChannelRole::Admin) => Some(Label::new("Admin")),
-                                Some(ChannelRole::Guest) => Some(Label::new("Guest")),
-                                _ => None,
-                            })
-                            .child(IconButton::new("ellipsis", Icon::Ellipsis))
-                            .children(
-                                if let (Some((menu, _)), true) = (&self.context_menu, selected) {
-                                    Some(
-                                        overlay()
-                                            .anchor(gpui::AnchorCorner::TopLeft)
-                                            .child(menu.clone()),
-                                    )
-                                } else {
-                                    None
-                                },
-                            ),
-                        Mode::InviteMembers => match request_status {
-                            Some(proto::channel_member::Kind::Invitee) => {
-                                slot.children(Some(Label::new("Invited")))
-                            }
-                            Some(proto::channel_member::Kind::Member) => {
-                                slot.children(Some(Label::new("Member")))
-                            }
-                            _ => slot,
-                        },
-                    }
-                })),
-        )
+        let style = tabbed_modal
+            .picker
+            .item
+            .in_state(selected)
+            .style_for(mouse_state);
+
+        let in_manage = matches!(self.mode, Mode::ManageMembers);
+
+        let mut result = Flex::row()
+            .with_children(user.avatar.clone().map(|avatar| {
+                Image::from_data(avatar)
+                    .with_style(theme.contact_avatar)
+                    .aligned()
+                    .left()
+            }))
+            .with_child(
+                Label::new(user.github_login.clone(), style.label.clone())
+                    .contained()
+                    .with_style(theme.contact_username)
+                    .aligned()
+                    .left(),
+            )
+            .with_children({
+                (in_manage && request_status == Some(proto::channel_member::Kind::Invitee)).then(
+                    || {
+                        Label::new("Invited", theme.member_tag.text.clone())
+                            .contained()
+                            .with_style(theme.member_tag.container)
+                            .aligned()
+                            .left()
+                    },
+                )
+            })
+            .with_children(if in_manage && role == Some(ChannelRole::Admin) {
+                Some(
+                    Label::new("Admin", theme.member_tag.text.clone())
+                        .contained()
+                        .with_style(theme.member_tag.container)
+                        .aligned()
+                        .left(),
+                )
+            } else if in_manage && role == Some(ChannelRole::Guest) {
+                Some(
+                    Label::new("Guest", theme.member_tag.text.clone())
+                        .contained()
+                        .with_style(theme.member_tag.container)
+                        .aligned()
+                        .left(),
+                )
+            } else {
+                None
+            })
+            .with_children({
+                let svg = match self.mode {
+                    Mode::ManageMembers => Some(
+                        Svg::new("icons/ellipsis.svg")
+                            .with_color(theme.member_icon.color)
+                            .constrained()
+                            .with_width(theme.member_icon.icon_width)
+                            .aligned()
+                            .constrained()
+                            .with_width(theme.member_icon.button_width)
+                            .with_height(theme.member_icon.button_width)
+                            .contained()
+                            .with_style(theme.member_icon.container),
+                    ),
+                    Mode::InviteMembers => match request_status {
+                        Some(proto::channel_member::Kind::Member) => Some(
+                            Svg::new("icons/check.svg")
+                                .with_color(theme.member_icon.color)
+                                .constrained()
+                                .with_width(theme.member_icon.icon_width)
+                                .aligned()
+                                .constrained()
+                                .with_width(theme.member_icon.button_width)
+                                .with_height(theme.member_icon.button_width)
+                                .contained()
+                                .with_style(theme.member_icon.container),
+                        ),
+                        Some(proto::channel_member::Kind::Invitee) => Some(
+                            Svg::new("icons/check.svg")
+                                .with_color(theme.invitee_icon.color)
+                                .constrained()
+                                .with_width(theme.invitee_icon.icon_width)
+                                .aligned()
+                                .constrained()
+                                .with_width(theme.invitee_icon.button_width)
+                                .with_height(theme.invitee_icon.button_width)
+                                .contained()
+                                .with_style(theme.invitee_icon.container),
+                        ),
+                        Some(proto::channel_member::Kind::AncestorMember) | None => None,
+                    },
+                };
+
+                svg.map(|svg| svg.aligned().flex_float().into_any())
+            })
+            .contained()
+            .with_style(style.container)
+            .constrained()
+            .with_height(tabbed_modal.row_height)
+            .into_any();
+
+        if selected {
+            result = Stack::new()
+                .with_child(result)
+                .with_child(
+                    ChildView::new(&self.context_menu, cx)
+                        .aligned()
+                        .top()
+                        .right(),
+                )
+                .into_any();
+        }
+
+        result
    }
 }

@@ -441,20 +610,21 @@ impl ChannelModalDelegate {
        }
    }

-    fn set_user_role(
-        &mut self,
-        user_id: UserId,
-        new_role: ChannelRole,
-        cx: &mut ViewContext<Picker<Self>>,
-    ) -> Option<()> {
+    fn toggle_selected_member_admin(&mut self, cx: &mut ViewContext<Picker<Self>>) -> Option<()> {
+        let (user, role) = self.user_at_index(self.selected_index)?;
+        let new_role = if role == Some(ChannelRole::Admin) {
+            ChannelRole::Member
+        } else {
+            ChannelRole::Admin
+        };
        let update = self.channel_store.update(cx, |store, cx| {
-            store.set_member_role(self.channel_id, user_id, new_role, cx)
+            store.set_member_role(self.channel_id, user.id, new_role, cx)
        });
        cx.spawn(|picker, mut cx| async move {
            update.await?;
            picker.update(&mut cx, |picker, cx| {
-                let this = &mut picker.delegate;
-                if let Some(member) = this.members.iter_mut().find(|m| m.user.id == user_id) {
+                let this = picker.delegate_mut();
+                if let Some(member) = this.members.iter_mut().find(|m| m.user.id == user.id) {
                    member.role = new_role;
                }
                cx.focus_self();
@@ -465,14 +635,16 @@ impl ChannelModalDelegate {
        Some(())
    }

-    fn remove_member(&mut self, user_id: UserId, cx: &mut ViewContext<Picker<Self>>) -> Option<()> {
+    fn remove_selected_member(&mut self, cx: &mut ViewContext<Picker<Self>>) -> Option<()> {
+        let (user, _) = self.user_at_index(self.selected_index)?;
+        let user_id = user.id;
        let update = self.channel_store.update(cx, |store, cx| {
            store.remove_member(self.channel_id, user_id, cx)
        });
        cx.spawn(|picker, mut cx| async move {
            update.await?;
            picker.update(&mut cx, |picker, cx| {
-                let this = &mut picker.delegate;
+                let this = picker.delegate_mut();
                if let Some(ix) = this.members.iter_mut().position(|m| m.user.id == user_id) {
                    this.members.remove(ix);
                    this.matching_member_indices.retain_mut(|member_ix| {
@@ -489,7 +661,7 @@ impl ChannelModalDelegate {
                    .selected_index
                    .min(this.matching_member_indices.len().saturating_sub(1));

-                picker.focus(cx);
+                cx.focus_self();
                cx.notify();
            })
        })
@@ -511,7 +683,7 @@ impl ChannelModalDelegate {
                    kind: proto::channel_member::Kind::Invitee,
                    role: ChannelRole::Member,
                };
-                let members = &mut this.delegate.members;
+                let members = &mut this.delegate_mut().members;
                match members.binary_search_by_key(&new_member.sort_key(), |k| k.sort_key()) {
                    Ok(ix) | Err(ix) => members.insert(ix, new_member),
                }
@@ -522,55 +694,24 @@ impl ChannelModalDelegate {
        .detach_and_log_err(cx);
    }

-    fn show_context_menu(
-        &mut self,
-        user: Arc<User>,
-        role: ChannelRole,
-        cx: &mut ViewContext<Picker<Self>>,
-    ) {
-        let user_id = user.id;
-        let picker = cx.view().clone();
-        let context_menu = ContextMenu::build(cx, |mut menu, _cx| {
-            menu = menu.entry("Remove Member", {
-                let picker = picker.clone();
-                move |cx| {
-                    picker.update(cx, |picker, cx| {
-                        picker.delegate.remove_member(user_id, cx);
-                    })
-                }
-            });
-
-            let picker = picker.clone();
-            match role {
-                ChannelRole::Admin => {
-                    menu = menu.entry("Revoke Admin", move |cx| {
-                        picker.update(cx, |picker, cx| {
-                            picker
-                                .delegate
-                                .set_user_role(user_id, ChannelRole::Member, cx);
-                        })
-                    });
-                }
-                ChannelRole::Member => {
-                    menu = menu.entry("Make Admin", move |cx| {
-                        picker.update(cx, |picker, cx| {
-                            picker
-                                .delegate
-                                .set_user_role(user_id, ChannelRole::Admin, cx);
-                        })
-                    });
-                }
-                _ => {}
-            };
-
-            menu
-        });
-        cx.focus_view(&context_menu);
-        let subscription = cx.subscribe(&context_menu, |picker, _, _: &DismissEvent, cx| {
-            picker.delegate.context_menu = None;
-            picker.focus(cx);
-            cx.notify();
-        });
-        self.context_menu = Some((context_menu, subscription));
+    fn show_context_menu(&mut self, role: ChannelRole, cx: &mut ViewContext<Picker<Self>>) {
+        self.context_menu.update(cx, |context_menu, cx| {
+            context_menu.show(
+                Default::default(),
+                AnchorCorner::TopRight,
+                vec![
+                    ContextMenuItem::action("Remove", RemoveMember),
+                    ContextMenuItem::action(
+                        if role == ChannelRole::Admin {
+                            "Make non-admin"
+                        } else {
+                            "Make admin"
+                        },
+                        ToggleMemberAdmin,
+                    ),
+                ],
+                cx,
+            )
+        })
    }
 }
--- a/crates/collab_ui2/src/collab_panel/contact_finder.rs
+++ b/crates/collab_ui2/src/collab_panel/contact_finder.rs
@@ -1,32 +1,42 @@
-#![allow(unused)]
 use client::{ContactRequestStatus, User, UserStore};
 use gpui::{
-    div, img, svg, AnyElement, AppContext, DismissEvent, Div, Entity, EventEmitter, FocusHandle,
-    FocusableView, Img, IntoElement, Model, ParentElement as _, Render, Styled, Task, View,
-    ViewContext, VisualContext, WeakView,
+    elements::*, AppContext, Entity, ModelHandle, MouseState, Task, View, ViewContext, ViewHandle,
 };
-use picker::{Picker, PickerDelegate};
+use picker::{Picker, PickerDelegate, PickerEvent};
 use std::sync::Arc;
-use theme::ActiveTheme as _;
-use ui::{prelude::*, Avatar, ListItem};
-use util::{ResultExt as _, TryFutureExt};
-use workspace::ModalView;
+use util::TryFutureExt;
+use workspace::Modal;
+
+pub fn init(cx: &mut AppContext) {
+    Picker::<ContactFinderDelegate>::init(cx);
+    cx.add_action(ContactFinder::dismiss)
+}

 pub struct ContactFinder {
-    picker: View<Picker<ContactFinderDelegate>>,
+    picker: ViewHandle<Picker<ContactFinderDelegate>>,
+    has_focus: bool,
 }

 impl ContactFinder {
-    pub fn new(user_store: Model<UserStore>, cx: &mut ViewContext<Self>) -> Self {
-        let delegate = ContactFinderDelegate {
-            parent: cx.view().downgrade(),
-            user_store,
-            potential_contacts: Arc::from([]),
-            selected_index: 0,
-        };
-        let picker = cx.build_view(|cx| Picker::new(delegate, cx).modal(false));
+    pub fn new(user_store: ModelHandle<UserStore>, cx: &mut ViewContext<Self>) -> Self {
+        let picker = cx.add_view(|cx| {
+            Picker::new(
+                ContactFinderDelegate {
+                    user_store,
+                    potential_contacts: Arc::from([]),
+                    selected_index: 0,
+                },
+                cx,
+            )
+            .with_theme(|theme| theme.collab_panel.tabbed_modal.picker.clone())
+        });

-        Self { picker }
+        cx.subscribe(&picker, |_, _, e, cx| cx.emit(*e)).detach();
+
+        Self {
+            picker,
+            has_focus: false,
+        }
    }

    pub fn set_query(&mut self, query: String, cx: &mut ViewContext<Self>) {
@@ -34,47 +44,101 @@ impl ContactFinder {
            picker.set_query(query, cx);
        });
    }
+
+    fn dismiss(&mut self, _: &menu::Cancel, cx: &mut ViewContext<Self>) {
+        cx.emit(PickerEvent::Dismiss);
+    }
 }

-impl Render for ContactFinder {
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-        v_stack()
-            .elevation_3(cx)
-            .child(
-                v_stack()
-                    .px_2()
-                    .py_1()
-                    .bg(cx.theme().colors().element_background)
-                    // HACK: Prevent the background color from overflowing the parent container.
-                    .rounded_t(px(8.))
-                    .child(Label::new("Contacts"))
-                    .child(h_stack().child(Label::new("Invite new contacts"))),
-            )
-            .child(self.picker.clone())
-            .w(rems(34.))
+impl Entity for ContactFinder {
+    type Event = PickerEvent;
+}
+
+impl View for ContactFinder {
+    fn ui_name() -> &'static str {
+        "ContactFinder"
    }

-    type Element = Div;
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+        let full_theme = &theme::current(cx);
+        let theme = &full_theme.collab_panel.tabbed_modal;
+
+        fn render_mode_button(
+            text: &'static str,
+            theme: &theme::TabbedModal,
+            _cx: &mut ViewContext<ContactFinder>,
+        ) -> AnyElement<ContactFinder> {
+            let contained_text = &theme.tab_button.active_state().default;
+            Label::new(text, contained_text.text.clone())
+                .contained()
+                .with_style(contained_text.container.clone())
+                .into_any()
+        }
+
+        Flex::column()
+            .with_child(
+                Flex::column()
+                    .with_child(
+                        Label::new("Contacts", theme.title.text.clone())
+                            .contained()
+                            .with_style(theme.title.container.clone()),
+                    )
+                    .with_child(Flex::row().with_children([render_mode_button(
+                        "Invite new contacts",
+                        &theme,
+                        cx,
+                    )]))
+                    .expanded()
+                    .contained()
+                    .with_style(theme.header),
+            )
+            .with_child(
+                ChildView::new(&self.picker, cx)
+                    .contained()
+                    .with_style(theme.body),
+            )
+            .constrained()
+            .with_max_height(theme.max_height)
+            .with_max_width(theme.max_width)
+            .contained()
+            .with_style(theme.modal)
+            .into_any()
+    }
+
+    fn focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
+        self.has_focus = true;
+        if cx.is_self_focused() {
+            cx.focus(&self.picker)
+        }
+    }
+
+    fn focus_out(&mut self, _: gpui::AnyViewHandle, _: &mut ViewContext<Self>) {
+        self.has_focus = false;
+    }
+}
+
+impl Modal for ContactFinder {
+    fn has_focus(&self) -> bool {
+        self.has_focus
+    }
+
+    fn dismiss_on_event(event: &Self::Event) -> bool {
+        match event {
+            PickerEvent::Dismiss => true,
+        }
+    }
 }

 pub struct ContactFinderDelegate {
-    parent: WeakView<ContactFinder>,
    potential_contacts: Arc<[Arc<User>]>,
-    user_store: Model<UserStore>,
+    user_store: ModelHandle<UserStore>,
    selected_index: usize,
 }

-impl EventEmitter<DismissEvent> for ContactFinder {}
-impl ModalView for ContactFinder {}
-
-impl FocusableView for ContactFinder {
-    fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
-        self.picker.focus_handle(cx)
-    }
-}
-
 impl PickerDelegate for ContactFinderDelegate {
-    type ListItem = ListItem;
+    fn placeholder_text(&self) -> Arc<str> {
+        "Search collaborator by username...".into()
+    }

    fn match_count(&self) -> usize {
        self.potential_contacts.len()
@@ -88,10 +152,6 @@ impl PickerDelegate for ContactFinderDelegate {
        self.selected_index = ix;
    }

-    fn placeholder_text(&self) -> Arc<str> {
-        "Search collaborator by username...".into()
-    }
-
    fn update_matches(&mut self, query: String, cx: &mut ViewContext<Picker<Self>>) -> Task<()> {
        let search_users = self
            .user_store
@@ -101,7 +161,7 @@ impl PickerDelegate for ContactFinderDelegate {
            async {
                let potential_contacts = search_users.await?;
                picker.update(&mut cx, |picker, cx| {
-                    picker.delegate.potential_contacts = potential_contacts.into();
+                    picker.delegate_mut().potential_contacts = potential_contacts.into();
                    cx.notify();
                })?;
                anyhow::Ok(())
@@ -131,17 +191,19 @@ impl PickerDelegate for ContactFinderDelegate {
    }

    fn dismissed(&mut self, cx: &mut ViewContext<Picker<Self>>) {
-        self.parent
-            .update(cx, |_, cx| cx.emit(DismissEvent))
-            .log_err();
+        cx.emit(PickerEvent::Dismiss);
    }

    fn render_match(
        &self,
        ix: usize,
+        mouse_state: &mut MouseState,
        selected: bool,
-        cx: &mut ViewContext<Picker<Self>>,
-    ) -> Option<Self::ListItem> {
+        cx: &gpui::AppContext,
+    ) -> AnyElement<Picker<Self>> {
+        let full_theme = &theme::current(cx);
+        let theme = &full_theme.collab_panel.contact_finder;
+        let tabbed_modal = &full_theme.collab_panel.tabbed_modal;
        let user = &self.potential_contacts[ix];
        let request_status = self.user_store.read(cx).contact_request_status(user);

@@ -152,15 +214,48 @@ impl PickerDelegate for ContactFinderDelegate {
            ContactRequestStatus::RequestSent => Some("icons/x.svg"),
            ContactRequestStatus::RequestAccepted => None,
        };
-        Some(
-            ListItem::new(ix)
-                .inset(true)
-                .selected(selected)
-                .start_slot(Avatar::new(user.avatar_uri.clone()))
-                .child(Label::new(user.github_login.clone()))
-                .end_slot::<IconElement>(
-                    icon_path.map(|icon_path| IconElement::from_path(icon_path)),
-                ),
-        )
+        let button_style = if self.user_store.read(cx).is_contact_request_pending(user) {
+            &theme.disabled_contact_button
+        } else {
+            &theme.contact_button
+        };
+        let style = tabbed_modal
+            .picker
+            .item
+            .in_state(selected)
+            .style_for(mouse_state);
+        Flex::row()
+            .with_children(user.avatar.clone().map(|avatar| {
+                Image::from_data(avatar)
+                    .with_style(theme.contact_avatar)
+                    .aligned()
+                    .left()
+            }))
+            .with_child(
+                Label::new(user.github_login.clone(), style.label.clone())
+                    .contained()
+                    .with_style(theme.contact_username)
+                    .aligned()
+                    .left(),
+            )
+            .with_children(icon_path.map(|icon_path| {
+                Svg::new(icon_path)
+                    .with_color(button_style.color)
+                    .constrained()
+                    .with_width(button_style.icon_width)
+                    .aligned()
+                    .contained()
+                    .with_style(button_style.container)
+                    .constrained()
+                    .with_width(button_style.button_width)
+                    .with_height(button_style.button_width)
+                    .aligned()
+                    .flex_float()
+            }))
+            .contained()
+            .with_style(style.container)
+            .constrained()
+            .with_height(tabbed_modal.row_height)
+            .into_any()
    }
 }
--- a/crates/collab_ui2/src/collab_titlebar_item.rs
+++ b/crates/collab_ui2/src/collab_titlebar_item.rs
--- a/crates/collab_ui2/src/collab_ui.rs
+++ b/crates/collab_ui2/src/collab_ui.rs
@@ -7,132 +7,119 @@ pub mod notification_panel;
 pub mod notifications;
 mod panel_settings;

-use std::{rc::Rc, sync::Arc};
+use std::sync::Arc;

-use call::{report_call_event_for_room, ActiveCall, Room};
 pub use collab_panel::CollabPanel;
 pub use collab_titlebar_item::CollabTitlebarItem;
-use feature_flags::{ChannelsAlpha, FeatureFlagAppExt};
-use gpui::{
-    actions, point, AppContext, GlobalPixels, Pixels, PlatformDisplay, Size, Task, WindowBounds,
-    WindowKind, WindowOptions,
-};
+use gpui::AppContext;
 pub use panel_settings::{
    ChatPanelSettings, CollaborationPanelSettings, NotificationPanelSettings,
 };
 use settings::Settings;
-use util::ResultExt;
 use workspace::AppState;

-actions!(
-    collab,
-    [ToggleScreenSharing, ToggleMute, ToggleDeafen, LeaveCall]
-);
+// actions!(
+//     collab,
+//     [ToggleScreenSharing, ToggleMute, ToggleDeafen, LeaveCall]
+// );

-pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
+pub fn init(_app_state: &Arc<AppState>, cx: &mut AppContext) {
    CollaborationPanelSettings::register(cx);
    ChatPanelSettings::register(cx);
    NotificationPanelSettings::register(cx);

-    vcs_menu::init(cx);
+    // vcs_menu::init(cx);
    collab_titlebar_item::init(cx);
    collab_panel::init(cx);
-    channel_view::init(cx);
-    chat_panel::init(cx);
-    notification_panel::init(cx);
-    notifications::init(&app_state, cx);
+    // chat_panel::init(cx);
+    // notifications::init(&app_state, cx);

    // cx.add_global_action(toggle_screen_sharing);
    // cx.add_global_action(toggle_mute);
    // cx.add_global_action(toggle_deafen);
 }

-pub fn toggle_screen_sharing(_: &ToggleScreenSharing, cx: &mut AppContext) {
-    let call = ActiveCall::global(cx).read(cx);
-    if let Some(room) = call.room().cloned() {
-        let client = call.client();
-        let toggle_screen_sharing = room.update(cx, |room, cx| {
-            if room.is_screen_sharing() {
-                report_call_event_for_room(
-                    "disable screen share",
-                    room.id(),
-                    room.channel_id(),
-                    &client,
-                    cx,
-                );
-                Task::ready(room.unshare_screen(cx))
-            } else {
-                report_call_event_for_room(
-                    "enable screen share",
-                    room.id(),
-                    room.channel_id(),
-                    &client,
-                    cx,
-                );
-                room.share_screen(cx)
-            }
-        });
-        toggle_screen_sharing.detach_and_log_err(cx);
-    }
-}
+// pub fn toggle_screen_sharing(_: &ToggleScreenSharing, cx: &mut AppContext) {
+//     let call = ActiveCall::global(cx).read(cx);
+//     if let Some(room) = call.room().cloned() {
+//         let client = call.client();
+//         let toggle_screen_sharing = room.update(cx, |room, cx| {
+//             if room.is_screen_sharing() {
+//                 report_call_event_for_room(
+//                     "disable screen share",
+//                     room.id(),
+//                     room.channel_id(),
+//                     &client,
+//                     cx,
+//                 );
+//                 Task::ready(room.unshare_screen(cx))
+//             } else {
+//                 report_call_event_for_room(
+//                     "enable screen share",
+//                     room.id(),
+//                     room.channel_id(),
+//                     &client,
+//                     cx,
+//                 );
+//                 room.share_screen(cx)
+//             }
+//         });
+//         toggle_screen_sharing.detach_and_log_err(cx);
+//     }
+// }

-pub fn toggle_mute(_: &ToggleMute, cx: &mut AppContext) {
-    let call = ActiveCall::global(cx).read(cx);
-    if let Some(room) = call.room().cloned() {
-        let client = call.client();
-        room.update(cx, |room, cx| {
-            let operation = if room.is_muted(cx) {
-                "enable microphone"
-            } else {
-                "disable microphone"
-            };
-            report_call_event_for_room(operation, room.id(), room.channel_id(), &client, cx);
+// pub fn toggle_mute(_: &ToggleMute, cx: &mut AppContext) {
+//     let call = ActiveCall::global(cx).read(cx);
+//     if let Some(room) = call.room().cloned() {
+//         let client = call.client();
+//         room.update(cx, |room, cx| {
+//             let operation = if room.is_muted(cx) {
+//                 "enable microphone"
+//             } else {
+//                 "disable microphone"
+//             };
+//             report_call_event_for_room(operation, room.id(), room.channel_id(), &client, cx);

-            room.toggle_mute(cx)
-        })
-        .map(|task| task.detach_and_log_err(cx))
-        .log_err();
-    }
-}
+//             room.toggle_mute(cx)
+//         })
+//         .map(|task| task.detach_and_log_err(cx))
+//         .log_err();
+//     }
+// }

-pub fn toggle_deafen(_: &ToggleDeafen, cx: &mut AppContext) {
-    if let Some(room) = ActiveCall::global(cx).read(cx).room().cloned() {
-        room.update(cx, Room::toggle_deafen)
-            .map(|task| task.detach_and_log_err(cx))
-            .log_err();
-    }
-}
+// pub fn toggle_deafen(_: &ToggleDeafen, cx: &mut AppContext) {
+//     if let Some(room) = ActiveCall::global(cx).read(cx).room().cloned() {
+//         room.update(cx, Room::toggle_deafen)
+//             .map(|task| task.detach_and_log_err(cx))
+//             .log_err();
+//     }
+// }

-fn notification_window_options(
-    screen: Rc<dyn PlatformDisplay>,
-    window_size: Size<Pixels>,
-) -> WindowOptions {
-    let notification_margin_width = GlobalPixels::from(16.);
-    let notification_margin_height = GlobalPixels::from(-0.) - GlobalPixels::from(48.);
+// fn notification_window_options(
+//     screen: Rc<dyn Screen>,
+//     window_size: Vector2F,
+// ) -> WindowOptions<'static> {
+//     const NOTIFICATION_PADDING: f32 = 16.;

-    let screen_bounds = screen.bounds();
-    let size: Size<GlobalPixels> = window_size.into();
-
-    // todo!() use content bounds instead of screen.bounds and get rid of magics in point's 2nd argument.
-    let bounds = gpui::Bounds::<GlobalPixels> {
-        origin: screen_bounds.upper_right()
-            - point(
-                size.width + notification_margin_width,
-                notification_margin_height,
-            ),
-        size: window_size.into(),
-    };
-    WindowOptions {
-        bounds: WindowBounds::Fixed(bounds),
-        titlebar: None,
-        center: false,
-        focus: false,
-        show: true,
-        kind: WindowKind::PopUp,
-        is_movable: false,
-        display_id: Some(screen.id()),
-    }
-}
+//     let screen_bounds = screen.content_bounds();
+//     WindowOptions {
+//         bounds: WindowBounds::Fixed(RectF::new(
+//             screen_bounds.upper_right()
+//                 + vec2f(
+//                     -NOTIFICATION_PADDING - window_size.x(),
+//                     NOTIFICATION_PADDING,
+//                 ),
+//             window_size,
+//         )),
+//         titlebar: None,
+//         center: false,
+//         focus: false,
+//         show: true,
+//         kind: WindowKind::PopUp,
+//         is_movable: false,
+//         screen: Some(screen),
+//     }
+// }

 // fn render_avatar<T: 'static>(
 //     avatar: Option<Arc<ImageData>>,
@@ -162,6 +149,6 @@ fn notification_window_options(
 //         .into_any()
 // }

-fn is_channels_feature_enabled(cx: &gpui::WindowContext<'_>) -> bool {
-    cx.is_staff() || cx.has_flag::<ChannelsAlpha>()
-}
+// fn is_channels_feature_enabled(cx: &gpui::WindowContext<'_>) -> bool {
+//     cx.is_staff() || cx.has_flag::<ChannelsAlpha>()
+// }
--- a/crates/collab_ui2/src/face_pile.rs
+++ b/crates/collab_ui2/src/face_pile.rs
@@ -1,32 +1,113 @@
-use gpui::{
-    div, AnyElement, Div, ElementId, IntoElement, ParentElement, RenderOnce, Styled, WindowContext,
-};
-use smallvec::SmallVec;
+// use std::ops::Range;

-#[derive(Default, IntoElement)]
-pub struct FacePile {
-    pub faces: SmallVec<[AnyElement; 2]>,
-}
+// use gpui::{
+//     geometry::{
+//         rect::RectF,
+//         vector::{vec2f, Vector2F},
+//     },
+//     json::ToJson,
+//     serde_json::{self, json},
+//     AnyElement, Axis, Element, View, ViewContext,
+// };

-impl RenderOnce for FacePile {
-    type Rendered = Div;
+// pub(crate) struct FacePile<V: View> {
+//     overlap: f32,
+//     faces: Vec<AnyElement<V>>,
+// }

-    fn render(self, _: &mut WindowContext) -> Self::Rendered {
-        let player_count = self.faces.len();
-        let player_list = self.faces.into_iter().enumerate().map(|(ix, player)| {
-            let isnt_last = ix < player_count - 1;
+// impl<V: View> FacePile<V> {
+//     pub fn new(overlap: f32) -> Self {
+//         Self {
+//             overlap,
+//             faces: Vec::new(),
+//         }
+//     }
+// }

-            div()
-                .z_index((player_count - ix) as u8)
-                .when(isnt_last, |div| div.neg_mr_1())
-                .child(player)
-        });
-        div().p_1().flex().items_center().children(player_list)
-    }
-}
+// impl<V: View> Element<V> for FacePile<V> {
+//     type LayoutState = ();
+//     type PaintState = ();

-impl ParentElement for FacePile {
-    fn children_mut(&mut self) -> &mut SmallVec<[AnyElement; 2]> {
-        &mut self.faces
-    }
-}
+//     fn layout(
+//         &mut self,
+//         constraint: gpui::SizeConstraint,
+//         view: &mut V,
+//         cx: &mut ViewContext<V>,
+//     ) -> (Vector2F, Self::LayoutState) {
+//         debug_assert!(constraint.max_along(Axis::Horizontal) == f32::INFINITY);
+
+//         let mut width = 0.;
+//         let mut max_height = 0.;
+//         for face in &mut self.faces {
+//             let layout = face.layout(constraint, view, cx);
+//             width += layout.x();
+//             max_height = f32::max(max_height, layout.y());
+//         }
+//         width -= self.overlap * self.faces.len().saturating_sub(1) as f32;
+
+//         (
+//             Vector2F::new(width, max_height.clamp(1., constraint.max.y())),
+//             (),
+//         )
+//     }
+
+//     fn paint(
+//         &mut self,
+//         bounds: RectF,
+//         visible_bounds: RectF,
+//         _layout: &mut Self::LayoutState,
+//         view: &mut V,
+//         cx: &mut ViewContext<V>,
+//     ) -> 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();
+//             let origin_y = origin_y + (bounds.height() - size.y()) / 2.0;
+
+//             cx.scene().push_layer(None);
+//             face.paint(vec2f(origin_x, origin_y), visible_bounds, view, cx);
+//             cx.scene().pop_layer();
+//             origin_x += self.overlap;
+//         }
+
+//         ()
+//     }
+
+//     fn rect_for_text_range(
+//         &self,
+//         _: Range<usize>,
+//         _: RectF,
+//         _: RectF,
+//         _: &Self::LayoutState,
+//         _: &Self::PaintState,
+//         _: &V,
+//         _: &ViewContext<V>,
+//     ) -> Option<RectF> {
+//         None
+//     }
+
+//     fn debug(
+//         &self,
+//         bounds: RectF,
+//         _: &Self::LayoutState,
+//         _: &Self::PaintState,
+//         _: &V,
+//         _: &ViewContext<V>,
+//     ) -> serde_json::Value {
+//         json!({
+//             "type": "FacePile",
+//             "bounds": bounds.to_json()
+//         })
+//     }
+// }
+
+// impl<V: View> Extend<AnyElement<V>> for FacePile<V> {
+//     fn extend<T: IntoIterator<Item = AnyElement<V>>>(&mut self, children: T) {
+//         self.faces.extend(children);
+//     }
+// }
--- a/crates/collab_ui2/src/notification_panel.rs
+++ b/crates/collab_ui2/src/notification_panel.rs
--- a/crates/collab_ui2/src/notifications.rs
+++ b/crates/collab_ui2/src/notifications.rs
@@ -1,11 +1,11 @@
-use gpui::AppContext;
-use std::sync::Arc;
-use workspace::AppState;
+// use gpui::AppContext;
+// use std::sync::Arc;
+// use workspace::AppState;

-pub mod incoming_call_notification;
-pub mod project_shared_notification;
+// pub mod incoming_call_notification;
+// pub mod project_shared_notification;

-pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
-    incoming_call_notification::init(app_state, cx);
-    project_shared_notification::init(app_state, cx);
-}
+// pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
+//     incoming_call_notification::init(app_state, cx);
+//     project_shared_notification::init(app_state, cx);
+// }
--- a/crates/collab_ui2/src/notifications/incoming_call_notification.rs
+++ b/crates/collab_ui2/src/notifications/incoming_call_notification.rs
@@ -1,13 +1,14 @@
 use crate::notification_window_options;
 use call::{ActiveCall, IncomingCall};
+use client::proto;
 use futures::StreamExt;
 use gpui::{
-    div, px, red, AppContext, Div, Element, ParentElement, Render, RenderOnce, Styled, ViewContext,
-    VisualContext as _, WindowHandle,
+    elements::*,
+    geometry::vector::vec2f,
+    platform::{CursorStyle, MouseButton},
+    AnyElement, AppContext, Entity, View, ViewContext, WindowHandle,
 };
 use std::sync::{Arc, Weak};
-use ui::prelude::*;
-use ui::{h_stack, v_stack, Avatar, Button, Label};
 use util::ResultExt;
 use workspace::AppState;

@@ -18,33 +19,21 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
        let mut notification_windows: Vec<WindowHandle<IncomingCallNotification>> = Vec::new();
        while let Some(incoming_call) = incoming_call.next().await {
            for window in notification_windows.drain(..) {
-                window
-                    .update(&mut cx, |_, cx| {
-                        // todo!()
-                        cx.remove_window();
-                    })
-                    .log_err();
+                window.remove(&mut cx);
            }

            if let Some(incoming_call) = incoming_call {
-                let unique_screens = cx.update(|cx| cx.displays()).unwrap();
-                let window_size = gpui::Size {
-                    width: px(380.),
-                    height: px(64.),
-                };
+                let window_size = cx.read(|cx| {
+                    let theme = &theme::current(cx).incoming_call_notification;
+                    vec2f(theme.window_width, theme.window_height)
+                });

-                for screen in unique_screens {
-                    let options = notification_window_options(screen, window_size);
+                for screen in cx.platform().screens() {
                    let window = cx
-                        .open_window(options, |cx| {
-                            cx.build_view(|_| {
-                                IncomingCallNotification::new(
-                                    incoming_call.clone(),
-                                    app_state.clone(),
-                                )
-                            })
-                        })
-                        .unwrap();
+                        .add_window(notification_window_options(screen, window_size), |_| {
+                            IncomingCallNotification::new(incoming_call.clone(), app_state.clone())
+                        });
+
                    notification_windows.push(window);
                }
            }
@@ -58,90 +47,167 @@ struct RespondToCall {
    accept: bool,
 }

-struct IncomingCallNotificationState {
+pub struct IncomingCallNotification {
    call: IncomingCall,
    app_state: Weak<AppState>,
 }

-pub struct IncomingCallNotification {
-    state: Arc<IncomingCallNotificationState>,
-}
-impl IncomingCallNotificationState {
+impl IncomingCallNotification {
    pub fn new(call: IncomingCall, app_state: Weak<AppState>) -> Self {
        Self { call, app_state }
    }

-    fn respond(&self, accept: bool, cx: &mut AppContext) {
+    fn respond(&mut self, accept: bool, cx: &mut ViewContext<Self>) {
        let active_call = ActiveCall::global(cx);
        if accept {
            let join = active_call.update(cx, |active_call, cx| active_call.accept_incoming(cx));
            let caller_user_id = self.call.calling_user.id;
            let initial_project_id = self.call.initial_project.as_ref().map(|project| project.id);
            let app_state = self.app_state.clone();
-            let cx: &mut AppContext = cx;
-            cx.spawn(|cx| async move {
-                join.await?;
-                if let Some(project_id) = initial_project_id {
-                    cx.update(|cx| {
-                        if let Some(app_state) = app_state.upgrade() {
-                            workspace::join_remote_project(
-                                project_id,
-                                caller_user_id,
-                                app_state,
-                                cx,
-                            )
-                            .detach_and_log_err(cx);
-                        }
-                    })
-                    .log_err();
-                }
-                anyhow::Ok(())
-            })
-            .detach_and_log_err(cx);
+            cx.app_context()
+                .spawn(|mut cx| async move {
+                    join.await?;
+                    if let Some(project_id) = initial_project_id {
+                        cx.update(|cx| {
+                            if let Some(app_state) = app_state.upgrade() {
+                                workspace::join_remote_project(
+                                    project_id,
+                                    caller_user_id,
+                                    app_state,
+                                    cx,
+                                )
+                                .detach_and_log_err(cx);
+                            }
+                        });
+                    }
+                    anyhow::Ok(())
+                })
+                .detach_and_log_err(cx);
        } else {
            active_call.update(cx, |active_call, cx| {
                active_call.decline_incoming(cx).log_err();
            });
        }
    }
-}

-impl IncomingCallNotification {
-    pub fn new(call: IncomingCall, app_state: Weak<AppState>) -> Self {
-        Self {
-            state: Arc::new(IncomingCallNotificationState::new(call, app_state)),
-        }
-    }
-    fn render_caller(&self, cx: &mut ViewContext<Self>) -> impl Element {
-        h_stack()
-            .child(Avatar::new(self.state.call.calling_user.avatar_uri.clone()))
-            .child(
-                v_stack()
-                    .child(Label::new(format!(
-                        "{} is sharing a project in Zed",
-                        self.state.call.calling_user.github_login
-                    )))
-                    .child(self.render_buttons(cx)),
+    fn render_caller(&self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+        let theme = &theme::current(cx).incoming_call_notification;
+        let default_project = proto::ParticipantProject::default();
+        let initial_project = self
+            .call
+            .initial_project
+            .as_ref()
+            .unwrap_or(&default_project);
+        Flex::row()
+            .with_children(self.call.calling_user.avatar.clone().map(|avatar| {
+                Image::from_data(avatar)
+                    .with_style(theme.caller_avatar)
+                    .aligned()
+            }))
+            .with_child(
+                Flex::column()
+                    .with_child(
+                        Label::new(
+                            self.call.calling_user.github_login.clone(),
+                            theme.caller_username.text.clone(),
+                        )
+                        .contained()
+                        .with_style(theme.caller_username.container),
+                    )
+                    .with_child(
+                        Label::new(
+                            format!(
+                                "is sharing a project in Zed{}",
+                                if initial_project.worktree_root_names.is_empty() {
+                                    ""
+                                } else {
+                                    ":"
+                                }
+                            ),
+                            theme.caller_message.text.clone(),
+                        )
+                        .contained()
+                        .with_style(theme.caller_message.container),
+                    )
+                    .with_children(if initial_project.worktree_root_names.is_empty() {
+                        None
+                    } else {
+                        Some(
+                            Label::new(
+                                initial_project.worktree_root_names.join(", "),
+                                theme.worktree_roots.text.clone(),
+                            )
+                            .contained()
+                            .with_style(theme.worktree_roots.container),
+                        )
+                    })
+                    .contained()
+                    .with_style(theme.caller_metadata)
+                    .aligned(),
            )
+            .contained()
+            .with_style(theme.caller_container)
+            .flex(1., true)
+            .into_any()
    }

-    fn render_buttons(&self, cx: &mut ViewContext<Self>) -> impl Element {
-        h_stack()
-            .child(Button::new("accept", "Accept").render(cx).on_click({
-                let state = self.state.clone();
-                move |_, cx| state.respond(true, cx)
-            }))
-            .child(Button::new("decline", "Decline").render(cx).on_click({
-                let state = self.state.clone();
-                move |_, cx| state.respond(false, cx)
-            }))
+    fn render_buttons(&self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+        enum Accept {}
+        enum Decline {}
+
+        let theme = theme::current(cx);
+        Flex::column()
+            .with_child(
+                MouseEventHandler::new::<Accept, _>(0, cx, |_, _| {
+                    let theme = &theme.incoming_call_notification;
+                    Label::new("Accept", theme.accept_button.text.clone())
+                        .aligned()
+                        .contained()
+                        .with_style(theme.accept_button.container)
+                })
+                .with_cursor_style(CursorStyle::PointingHand)
+                .on_click(MouseButton::Left, |_, this, cx| {
+                    this.respond(true, cx);
+                })
+                .flex(1., true),
+            )
+            .with_child(
+                MouseEventHandler::new::<Decline, _>(0, cx, |_, _| {
+                    let theme = &theme.incoming_call_notification;
+                    Label::new("Decline", theme.decline_button.text.clone())
+                        .aligned()
+                        .contained()
+                        .with_style(theme.decline_button.container)
+                })
+                .with_cursor_style(CursorStyle::PointingHand)
+                .on_click(MouseButton::Left, |_, this, cx| {
+                    this.respond(false, cx);
+                })
+                .flex(1., true),
+            )
+            .constrained()
+            .with_width(theme.incoming_call_notification.button_width)
+            .into_any()
    }
 }

-impl Render for IncomingCallNotification {
-    type Element = Div;
+impl Entity for IncomingCallNotification {
+    type Event = ();
+}

-    fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-        div().bg(red()).flex_none().child(self.render_caller(cx))
+impl View for IncomingCallNotification {
+    fn ui_name() -> &'static str {
+        "IncomingCallNotification"
+    }
+
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+        let background = theme::current(cx).incoming_call_notification.background;
+        Flex::row()
+            .with_child(self.render_caller(cx))
+            .with_child(self.render_buttons(cx))
+            .contained()
+            .with_background_color(background)
+            .expanded()
+            .into_any()
    }
 }
--- a/crates/collab_ui2/src/notifications/project_shared_notification.rs
+++ b/crates/collab_ui2/src/notifications/project_shared_notification.rs
@@ -3,12 +3,12 @@ use call::{room, ActiveCall};
 use client::User;
 use collections::HashMap;
 use gpui::{
-    img, px, AppContext, Div, ParentElement, Render, Size, Styled, ViewContext, VisualContext,
+    elements::*,
+    geometry::vector::vec2f,
+    platform::{CursorStyle, MouseButton},
+    AppContext, Entity, View, ViewContext,
 };
-use settings::Settings;
 use std::sync::{Arc, Weak};
-use theme::ThemeSettings;
-use ui::{h_stack, prelude::*, v_stack, Button, Label};
 use workspace::AppState;

 pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
@@ -21,54 +21,38 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
            project_id,
            worktree_root_names,
        } => {
-            let window_size = Size {
-                width: px(400.),
-                height: px(96.),
-            };
+            let theme = &theme::current(cx).project_shared_notification;
+            let window_size = vec2f(theme.window_width, theme.window_height);

-            for screen in cx.displays() {
-                let options = notification_window_options(screen, window_size);
-                let window = cx.open_window(options, |cx| {
-                    cx.build_view(|_| {
+            for screen in cx.platform().screens() {
+                let window =
+                    cx.add_window(notification_window_options(screen, window_size), |_| {
                        ProjectSharedNotification::new(
                            owner.clone(),
                            *project_id,
                            worktree_root_names.clone(),
                            app_state.clone(),
                        )
-                    })
-                });
+                    });
                notification_windows
                    .entry(*project_id)
                    .or_insert(Vec::new())
                    .push(window);
            }
        }
-
        room::Event::RemoteProjectUnshared { project_id }
        | room::Event::RemoteProjectJoined { project_id }
        | room::Event::RemoteProjectInvitationDiscarded { project_id } => {
            if let Some(windows) = notification_windows.remove(&project_id) {
                for window in windows {
-                    window
-                        .update(cx, |_, cx| {
-                            // todo!()
-                            cx.remove_window();
-                        })
-                        .ok();
+                    window.remove(cx);
                }
            }
        }
-
        room::Event::Left => {
            for (_, windows) in notification_windows.drain() {
                for window in windows {
-                    window
-                        .update(cx, |_, cx| {
-                            // todo!()
-                            cx.remove_window();
-                        })
-                        .ok();
+                    window.remove(cx);
                }
            }
        }
@@ -117,70 +101,117 @@ impl ProjectSharedNotification {
            });
        }
    }
-}

-impl Render for ProjectSharedNotification {
-    type Element = Div;
-
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
-        // TODO: Is there a better place for us to initialize the font?
-        let (ui_font, ui_font_size) = {
-            let theme_settings = ThemeSettings::get_global(cx);
-            (
-                theme_settings.ui_font.family.clone(),
-                theme_settings.ui_font_size.clone(),
-            )
-        };
-
-        cx.set_rem_size(ui_font_size);
-
-        h_stack()
-            .font(ui_font)
-            .text_ui()
-            .justify_between()
-            .size_full()
-            .elevation_3(cx)
-            .p_2()
-            .gap_2()
-            .child(
-                h_stack()
-                    .gap_2()
-                    .child(
-                        img(self.owner.avatar_uri.clone())
-                            .w_16()
-                            .h_16()
-                            .rounded_full(),
+    fn render_owner(&self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+        let theme = &theme::current(cx).project_shared_notification;
+        Flex::row()
+            .with_children(self.owner.avatar.clone().map(|avatar| {
+                Image::from_data(avatar)
+                    .with_style(theme.owner_avatar)
+                    .aligned()
+            }))
+            .with_child(
+                Flex::column()
+                    .with_child(
+                        Label::new(
+                            self.owner.github_login.clone(),
+                            theme.owner_username.text.clone(),
+                        )
+                        .contained()
+                        .with_style(theme.owner_username.container),
                    )
-                    .child(
-                        v_stack()
-                            .child(Label::new(self.owner.github_login.clone()))
-                            .child(Label::new(format!(
+                    .with_child(
+                        Label::new(
+                            format!(
                                "is sharing a project in Zed{}",
                                if self.worktree_root_names.is_empty() {
                                    ""
                                } else {
                                    ":"
                                }
-                            )))
-                            .children(if self.worktree_root_names.is_empty() {
-                                None
-                            } else {
-                                Some(Label::new(self.worktree_root_names.join(", ")))
-                            }),
-                    ),
+                            ),
+                            theme.message.text.clone(),
+                        )
+                        .contained()
+                        .with_style(theme.message.container),
+                    )
+                    .with_children(if self.worktree_root_names.is_empty() {
+                        None
+                    } else {
+                        Some(
+                            Label::new(
+                                self.worktree_root_names.join(", "),
+                                theme.worktree_roots.text.clone(),
+                            )
+                            .contained()
+                            .with_style(theme.worktree_roots.container),
+                        )
+                    })
+                    .contained()
+                    .with_style(theme.owner_metadata)
+                    .aligned(),
            )
-            .child(
-                v_stack()
-                    .child(Button::new("open", "Open").on_click(cx.listener(
-                        move |this, _event, cx| {
-                            this.join(cx);
-                        },
-                    )))
-                    .child(Button::new("dismiss", "Dismiss").on_click(cx.listener(
-                        move |this, _event, cx| {
-                            this.dismiss(cx);
-                        },
-                    ))),
+            .contained()
+            .with_style(theme.owner_container)
+            .flex(1., true)
+            .into_any()
+    }
+
+    fn render_buttons(&self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+        enum Open {}
+        enum Dismiss {}
+
+        let theme = theme::current(cx);
+        Flex::column()
+            .with_child(
+                MouseEventHandler::new::<Open, _>(0, cx, |_, _| {
+                    let theme = &theme.project_shared_notification;
+                    Label::new("Open", theme.open_button.text.clone())
+                        .aligned()
+                        .contained()
+                        .with_style(theme.open_button.container)
+                })
+                .with_cursor_style(CursorStyle::PointingHand)
+                .on_click(MouseButton::Left, move |_, this, cx| this.join(cx))
+                .flex(1., true),
            )
+            .with_child(
+                MouseEventHandler::new::<Dismiss, _>(0, cx, |_, _| {
+                    let theme = &theme.project_shared_notification;
+                    Label::new("Dismiss", theme.dismiss_button.text.clone())
+                        .aligned()
+                        .contained()
+                        .with_style(theme.dismiss_button.container)
+                })
+                .with_cursor_style(CursorStyle::PointingHand)
+                .on_click(MouseButton::Left, |_, this, cx| {
+                    this.dismiss(cx);
+                })
+                .flex(1., true),
+            )
+            .constrained()
+            .with_width(theme.project_shared_notification.button_width)
+            .into_any()
+    }
+}
+
+impl Entity for ProjectSharedNotification {
+    type Event = ();
+}
+
+impl View for ProjectSharedNotification {
+    fn ui_name() -> &'static str {
+        "ProjectSharedNotification"
+    }
+
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> gpui::AnyElement<Self> {
+        let background = theme::current(cx).project_shared_notification.background;
+        Flex::row()
+            .with_child(self.render_owner(cx))
+            .with_child(self.render_buttons(cx))
+            .contained()
+            .with_background_color(background)
+            .expanded()
+            .into_any()
    }
 }
--- a/crates/collections/Cargo.toml
+++ b/crates/collections/Cargo.toml
@@ -9,7 +9,7 @@ path = "src/collections.rs"
 doctest = false

 [features]
-test-support = []
+test-support = ["seahash"]

 [dependencies]
-rustc-hash = "1.1"
+seahash = { version = "4.1", optional = true }
--- a/crates/collections/src/collections.rs
+++ b/crates/collections/src/collections.rs
@@ -1,8 +1,21 @@
 #[cfg(feature = "test-support")]
-pub type HashMap<K, V> = FxHashMap<K, V>;
+#[derive(Clone, Default)]
+pub struct DeterministicState;

 #[cfg(feature = "test-support")]
-pub type HashSet<T> = FxHashSet<T>;
+impl std::hash::BuildHasher for DeterministicState {
+    type Hasher = seahash::SeaHasher;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        seahash::SeaHasher::new()
+    }
+}
+
+#[cfg(feature = "test-support")]
+pub type HashMap<K, V> = std::collections::HashMap<K, V, DeterministicState>;
+
+#[cfg(feature = "test-support")]
+pub type HashSet<T> = std::collections::HashSet<T, DeterministicState>;

 #[cfg(not(feature = "test-support"))]
 pub type HashMap<K, V> = std::collections::HashMap<K, V>;
@@ -10,14 +23,11 @@ pub type HashMap<K, V> = std::collections::HashMap<K, V>;
 #[cfg(not(feature = "test-support"))]
 pub type HashSet<T> = std::collections::HashSet<T>;

-pub use rustc_hash::{FxHashMap, FxHashSet};
-use std::any::TypeId;
 pub use std::collections::*;

 // NEW TYPES

 #[derive(Default)]
 pub struct CommandPaletteFilter {
-    pub hidden_namespaces: HashSet<&'static str>,
-    pub hidden_action_types: HashSet<TypeId>,
+    pub filtered_namespaces: HashSet<&'static str>,
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Nathan Sobo	4013cf9229	One more doc	2023-11-22 13:32:08 -07:00
Nathan Sobo	ed92f7a037	More docs	2023-11-22 13:03:31 -07:00
Nathan Sobo	d3576ddd0e	Write some docs	2023-11-22 12:57:47 -07:00
Nathan Sobo	6dcbb9a05d	Further refine element traits	2023-11-22 12:39:55 -07:00
Nathan Sobo	5158508d0a	Add RenderOnceStateful	2023-11-22 12:16:27 -07:00
				`@@ -1 +0,0 @@`
				`<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-copy"><rect width="14" height="14" x="8" y="8" rx="2" ry="2"/><path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"/></svg>`
				`@@ -1 +0,0 @@`
				<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-github"><path d="M15 22v-4a4.8 4.8 0 0 0-1-3.5c3 0 6-2 6-5.5.08-1.25-.27-2.48-1-3.5.28-1.15.28-2.35 0-3.5 0 0-1 0-3 1.5-2.64-.5-5.36-.5-8 0C6 2 5 2 5 2c-.3 1.15-.3 2.35 0 3.5A5.403 5.403 0 0 0 4 9c0 3.5 3 5.5 6 5.5-.39.49-.68 1.05-.85 1.65-.17.6-.22 1.23-.15 1.85v4"/><path d="M9 18c-4.51 2-5-2-7-2"/></svg>
				`@@ -0,0 +1 @@`
				<svg width="15" height="15" viewBox="0 0 15 15" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M7.81832 0.68179C7.64258 0.506054 7.35766 0.506054 7.18192 0.68179L5.18192 2.68179C5.00619 2.85753 5.00619 3.14245 5.18192 3.31819C5.35766 3.49392 5.64258 3.49392 5.81832 3.31819L7.05012 2.08638L7.05012 5.50023C7.05012 5.74876 7.25159 5.95023 7.50012 5.95023C7.74865 5.95023 7.95012 5.74876 7.95012 5.50023L7.95012 2.08638L9.18192 3.31819C9.35766 3.49392 9.64258 3.49392 9.81832 3.31819C9.99406 3.14245 9.99406 2.85753 9.81832 2.68179L7.81832 0.68179ZM7.95012 12.9136V9.50023C7.95012 9.2517 7.74865 9.05023 7.50012 9.05023C7.25159 9.05023 7.05012 9.2517 7.05012 9.50023V12.9136L5.81832 11.6818C5.64258 11.5061 5.35766 11.5061 5.18192 11.6818C5.00619 11.8575 5.00619 12.1424 5.18192 12.3182L7.18192 14.3182C7.26632 14.4026 7.38077 14.45 7.50012 14.45C7.61947 14.45 7.73393 14.4026 7.81832 14.3182L9.81832 12.3182C9.99406 12.1424 9.99406 11.8575 9.81832 11.6818C9.64258 11.5061 9.35766 11.5061 9.18192 11.6818L7.95012 12.9136ZM1.49994 7.00017C1.2238 7.00017 0.999939 7.22403 0.999939 7.50017C0.999939 7.77631 1.2238 8.00017 1.49994 8.00017L13.4999 8.00017C13.7761 8.00017 13.9999 7.77631 13.9999 7.50017C13.9999 7.22403 13.7761 7.00017 13.4999 7.00017L1.49994 7.00017Z" fill="currentColor" fill-rule="evenodd" clip-rule="evenodd"></path></svg>