vim-global

.github/actions/run_tests_windows/action.yml

@@ -1,26 +0,0 @@
-name: "Run tests on Windows"
-description: "Runs the tests on Windows"
-
-inputs:
-  working-directory:
-    description: "The working directory"
-    required: true
-    default: "."
-
-runs:
-  using: "composite"
-  steps:
-    - name: Install Rust
-      shell: pwsh
-      working-directory: ${{ inputs.working-directory }}
-      run: cargo install cargo-nextest --locked
-
-    - name: Install Node
-      uses: actions/setup-node@1d0ff469b7ec7b3cb9d8673fde0c81c44821de2a # v4
-      with:
-        node-version: "18"
-
-    - name: Run tests
-      shell: pwsh
-      working-directory: ${{ inputs.working-directory }}
-      run: cargo nextest run --workspace --no-fail-fast

.github/workflows/ci.yml

@@ -135,7 +135,6 @@ jobs:
           cargo check -p gpui --features "macos-blade"
           cargo check -p workspace
           cargo build -p remote_server
-          cargo check -p gpui --examples
           script/check-rust-livekit-macos
 
       # Since the macOS runners are stateful, so we need to remove the config file to prevent potential bug.
@@ -182,7 +181,6 @@ jobs:
         run: |
           cargo build -p zed
           cargo check -p workspace
-          cargo check -p gpui --examples
 
       # Even the Linux runner is not stateful, in theory there is no need to do this cleanup.
       # But, to avoid potential issues in the future if we choose to use a stateful Linux runner and forget to add code
@@ -228,6 +226,7 @@ jobs:
         if: always()
         run: rm -rf ./../.cargo
 
+  # todo(windows): Actually run the tests
   windows_tests:
     timeout-minutes: 60
     name: (Windows) Run Clippy and tests
@@ -237,55 +236,33 @@ jobs:
       # more info here:- https://github.com/rust-lang/cargo/issues/13020
       - name: Enable longer pathnames for git
         run: git config --system core.longpaths true
-
       - name: Checkout repo
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           clean: false
 
-      - name: Create Dev Drive using ReFS
-        run: ./script/setup-dev-driver.ps1
-
-      # actions/checkout does not let us clone into anywhere outside ${{ github.workspace }}, so we have to copy the clone...
-      - name: Copy Git Repo to Dev Drive
-        run: |
-          Copy-Item -Path "${{ github.workspace }}" -Destination "${{ env.ZED_WORKSPACE }}" -Recurse
-
       - name: Cache dependencies
         uses: swatinem/rust-cache@f0deed1e0edfc6a9be95417288c0e1099b1eeec3 # v2
         with:
           save-if: ${{ github.ref == 'refs/heads/main' }}
-          workspaces: ${{ env.ZED_WORKSPACE }}
           cache-provider: "github"
 
       - name: Configure CI
         run: |
-          mkdir -p ${{ env.CARGO_HOME }} -ErrorAction Ignore
-          cp ./.cargo/ci-config.toml ${{ env.CARGO_HOME }}/config.toml
+          mkdir -p ./../.cargo
+          cp ./.cargo/ci-config.toml ./../.cargo/config.toml
 
       - name: cargo clippy
-        working-directory: ${{ env.ZED_WORKSPACE }}
         # Windows can't run shell scripts, so we need to use `cargo xtask`.
         run: cargo xtask clippy
 
-      - name: Run tests
-        uses: ./.github/actions/run_tests_windows
-        with:
-          working-directory: ${{ env.ZED_WORKSPACE }}
-
       - name: Build Zed
-        working-directory: ${{ env.ZED_WORKSPACE }}
         run: cargo build
 
-      - name: Check dev drive space
-        working-directory: ${{ env.ZED_WORKSPACE }}
-        # `setup-dev-driver.ps1` creates a 100GB drive, with CI taking up ~45GB of the drive.
-        run: ./script/exit-ci-if-dev-drive-is-full.ps1 95
-
       # Since the Windows runners are stateful, so we need to remove the config file to prevent potential bug.
       - name: Clean CI config file
         if: always()
-        run: Remove-Item -Path "${{ env.CARGO_HOME }}/config.toml"  -Force
+        run: Remove-Item -Path "./../.cargo" -Recurse -Force
 
   bundle-mac:
     timeout-minutes: 120

.github/workflows/deploy_cloudflare.yml

@@ -37,36 +37,29 @@ jobs:
           mdbook build ./docs --dest-dir=../target/deploy/docs/
 
       - name: Deploy Docs
-        uses: cloudflare/wrangler-action@392082e81ffbcb9ebdde27400634aa004b35ea37 # v3
+        uses: cloudflare/wrangler-action@7a5f8bbdfeedcde38e6777a50fe685f89259d4ca # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
           command: pages deploy target/deploy --project-name=docs
 
       - name: Deploy Install
-        uses: cloudflare/wrangler-action@392082e81ffbcb9ebdde27400634aa004b35ea37 # v3
+        uses: cloudflare/wrangler-action@7a5f8bbdfeedcde38e6777a50fe685f89259d4ca # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
           command: r2 object put -f script/install.sh zed-open-source-website-assets/install.sh
 
       - name: Deploy Docs Workers
-        uses: cloudflare/wrangler-action@392082e81ffbcb9ebdde27400634aa004b35ea37 # v3
+        uses: cloudflare/wrangler-action@7a5f8bbdfeedcde38e6777a50fe685f89259d4ca # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
           command: deploy .cloudflare/docs-proxy/src/worker.js
 
       - name: Deploy Install Workers
-        uses: cloudflare/wrangler-action@392082e81ffbcb9ebdde27400634aa004b35ea37 # v3
+        uses: cloudflare/wrangler-action@7a5f8bbdfeedcde38e6777a50fe685f89259d4ca # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
           command: deploy .cloudflare/docs-proxy/src/worker.js
-
-      - name: Preserve Wrangler logs
-        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08 # v4
-        if: always()
-        with:
-          name: wrangler_logs
-          path: /home/runner/.config/.wrangler/logs/

.github/workflows/docs.yml

@@ -24,13 +24,11 @@ jobs:
       - name: Prettier Check on /docs
         working-directory: ./docs
         run: |
-          pnpm dlx prettier@${PRETTIER_VERSION} . --check || {
+          pnpm dlx prettier . --check || {
             echo "To fix, run from the root of the zed repo:"
-            echo "  cd docs && pnpm dlx prettier@${PRETTIER_VERSION} . --write && cd .."
+            echo "  cd docs && pnpm dlx prettier . --write && cd .."
             false
           }
-        env:
-          PRETTIER_VERSION: 3.5.0
 
       - name: Check for Typos with Typos-CLI
         uses: crate-ci/typos@8e6a4285bcbde632c5d79900a7779746e8b7ea3f # v1.24.6

.gitignore

@@ -1,35 +1,35 @@
-**/*.db
-**/cargo-target
-**/target
-**/venv
-*.wasm
-*.xcodeproj
-.DS_Store
-.blob_store
-.build
-.envrc
-.flatpak-builder
-.idea
-.netrc
-.pytest_cache
-.swiftpm
-.swiftpm/config/registries.json
-.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
-.venv
-.vscode
-.wrangler
 /.direnv
-/assets/*licenses.*
-/crates/collab/seed.json
-/crates/theme/schemas/theme.json
-/crates/zed/resources/flatpak/flatpak-cargo-sources.json
-/dev.zed.Zed*.json
+.envrc
+.idea
+**/target
+**/cargo-target
+/zed.xcworkspace
+.DS_Store
 /plugins/bin
 /script/node_modules
-/zed.xcworkspace
-DerivedData/
+/crates/theme/schemas/theme.json
+/crates/collab/seed.json
+/crates/zed/resources/flatpak/flatpak-cargo-sources.json
+/dev.zed.Zed*.json
+/assets/*licenses.*
+**/venv
+.build
+*.wasm
 Packages
+*.xcodeproj
 xcuserdata/
+DerivedData/
+.swiftpm/config/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc
+.swiftpm
+**/*.db
+.pytest_cache
+.venv
+.blob_store
+.vscode
+.wrangler
+.flatpak-builder
 
 # Don't commit any secrets to the repo.
 .env.secret.toml

CONTRIBUTING.md

@@ -52,9 +52,3 @@ Zed is made up of several smaller crates - let's go over those you're most likel
 - [`rpc`](/crates/rpc) defines messages to be exchanged with collaboration server.
 - [`theme`](/crates/theme) defines the theme system and provides a default theme.
 - [`ui`](/crates/ui) is a collection of UI components and common patterns used throughout Zed.
-- [`cli`](/crates/cli) is the CLI crate which invokes the Zed binary.
-- [`zed`](/crates/zed) is where all things come together, and the `main` entry point for Zed.
-
-## Packaging Zed
-
-Check our [notes for packaging Zed](https://zed.dev/docs/development/linux#notes-for-packaging-zed).

Cargo.toml

@@ -26,15 +26,12 @@ members = [
     "crates/collections",
     "crates/command_palette",
     "crates/command_palette_hooks",
-    "crates/component",
-    "crates/component_preview",
     "crates/context_server",
     "crates/context_server_settings",
     "crates/copilot",
     "crates/db",
     "crates/deepseek",
     "crates/diagnostics",
-    "crates/buffer_diff",
     "crates/docs_preprocessor",
     "crates/editor",
     "crates/evals",
@@ -83,7 +80,6 @@ members = [
     "crates/markdown_preview",
     "crates/media",
     "crates/menu",
-    "crates/migrator",
     "crates/multi_buffer",
     "crates/node_runtime",
     "crates/notifications",
@@ -91,7 +87,6 @@ members = [
     "crates/open_ai",
     "crates/outline",
     "crates/outline_panel",
-    "crates/panel",
     "crates/paths",
     "crates/picker",
     "crates/prettier",
@@ -108,6 +103,7 @@ members = [
     "crates/remote_server",
     "crates/repl",
     "crates/reqwest_client",
+    "crates/reqwest_client",
     "crates/rich_text",
     "crates/rope",
     "crates/rpc",
@@ -148,7 +144,7 @@ members = [
     "crates/ui_input",
     "crates/ui_macros",
     "crates/util",
-    "crates/util_macros",
+    "crates/vcs_menu",
     "crates/vim",
     "crates/vim_mode_setting",
     "crates/welcome",
@@ -156,6 +152,7 @@ members = [
     "crates/worktree",
     "crates/zed",
     "crates/zed_actions",
+    "crates/zed_predict_onboarding",
     "crates/zeta",
 
     #
@@ -171,6 +168,7 @@ members = [
     "extensions/haskell",
     "extensions/html",
     "extensions/lua",
+    "extensions/php",
     "extensions/perplexity",
     "extensions/proto",
     "extensions/purescript",
@@ -227,15 +225,12 @@ collab_ui = { path = "crates/collab_ui" }
 collections = { path = "crates/collections" }
 command_palette = { path = "crates/command_palette" }
 command_palette_hooks = { path = "crates/command_palette_hooks" }
-component = { path = "crates/component" }
-component_preview = { path = "crates/component_preview" }
 context_server = { path = "crates/context_server" }
 context_server_settings = { path = "crates/context_server_settings" }
 copilot = { path = "crates/copilot" }
 db = { path = "crates/db" }
 deepseek = { path = "crates/deepseek" }
 diagnostics = { path = "crates/diagnostics" }
-buffer_diff = { path = "crates/buffer_diff" }
 editor = { path = "crates/editor" }
 extension = { path = "crates/extension" }
 extension_host = { path = "crates/extension_host" }
@@ -248,8 +243,8 @@ fs = { path = "crates/fs" }
 fsevent = { path = "crates/fsevent" }
 fuzzy = { path = "crates/fuzzy" }
 git = { path = "crates/git" }
-git_hosting_providers = { path = "crates/git_hosting_providers" }
 git_ui = { path = "crates/git_ui" }
+git_hosting_providers = { path = "crates/git_hosting_providers" }
 go_to_line = { path = "crates/go_to_line" }
 google_ai = { path = "crates/google_ai" }
 gpui = { path = "crates/gpui", default-features = false, features = [
@@ -282,7 +277,6 @@ markdown = { path = "crates/markdown" }
 markdown_preview = { path = "crates/markdown_preview" }
 media = { path = "crates/media" }
 menu = { path = "crates/menu" }
-migrator = { path = "crates/migrator" }
 multi_buffer = { path = "crates/multi_buffer" }
 node_runtime = { path = "crates/node_runtime" }
 notifications = { path = "crates/notifications" }
@@ -291,7 +285,6 @@ open_ai = { path = "crates/open_ai" }
 outline = { path = "crates/outline" }
 outline_panel = { path = "crates/outline_panel" }
 paths = { path = "crates/paths" }
-panel = { path = "crates/panel" }
 picker = { path = "crates/picker" }
 plugin = { path = "crates/plugin" }
 plugin_macros = { path = "crates/plugin_macros" }
@@ -347,7 +340,7 @@ ui = { path = "crates/ui" }
 ui_input = { path = "crates/ui_input" }
 ui_macros = { path = "crates/ui_macros" }
 util = { path = "crates/util" }
-util_macros = { path = "crates/util_macros" }
+vcs_menu = { path = "crates/vcs_menu" }
 vim = { path = "crates/vim" }
 vim_mode_setting = { path = "crates/vim_mode_setting" }
 welcome = { path = "crates/welcome" }
@@ -355,6 +348,7 @@ workspace = { path = "crates/workspace" }
 worktree = { path = "crates/worktree" }
 zed = { path = "crates/zed" }
 zed_actions = { path = "crates/zed_actions" }
+zed_predict_onboarding = { path = "crates/zed_predict_onboarding" }
 zeta = { path = "crates/zeta" }
 
 #
@@ -367,7 +361,7 @@ alacritty_terminal = { git = "https://github.com/alacritty/alacritty.git", rev =
 any_vec = "0.14"
 anyhow = "1.0.86"
 arrayvec = { version = "0.7.4", features = ["serde"] }
-ashpd = { version = "0.10", default-features = false, features = ["async-std"] }
+ashpd = { version = "0.10", default-features = false, features = ["async-std"]}
 async-compat = "0.2.1"
 async-compression = { version = "0.4", features = ["gzip", "futures-io"] }
 async-dispatcher = "0.1"
@@ -422,7 +416,6 @@ ignore = "0.4.22"
 image = "0.25.1"
 indexmap = { version = "2.7.0", features = ["serde"] }
 indoc = "2"
-inventory = "0.3.19"
 itertools = "0.14.0"
 jsonwebtoken = "9.3"
 jupyter-protocol = { version = "0.6.0" }
@@ -430,12 +423,7 @@ jupyter-websocket-client = { version = "0.9.0" }
 libc = "0.2"
 libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
 linkify = "0.10.0"
-linkme = "0.3.31"
-livekit = { git = "https://github.com/zed-industries/livekit-rust-sdks", rev = "811ceae29fabee455f110c56cd66b3f49a7e5003", features = [
-    "dispatcher",
-    "services-dispatcher",
-    "rustls-tls-native-roots",
-], default-features = false }
+livekit = { git = "https://github.com/zed-industries/livekit-rust-sdks", rev="060964da10574cd9bf06463a53bf6e0769c5c45e", features = ["dispatcher", "services-dispatcher", "rustls-tls-native-roots"], default-features = false }
 log = { version = "0.4.16", features = ["kv_unstable_serde", "serde"] }
 markup5ever_rcdom = "0.3.0"
 nanoid = "0.4"
@@ -455,13 +443,11 @@ pet-poetry = { git = "https://github.com/microsoft/python-environment-tools.git"
 pet-reporter = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "1abe5cec5ebfbe97ca71746a4cfc7fe89bddf8e0" }
 postage = { version = "0.5", features = ["futures-traits"] }
 pretty_assertions = { version = "1.3.0", features = ["unstable"] }
-proc-macro2 = "1.0.93"
 profiling = "1"
 prost = "0.9"
 prost-build = "0.9"
 prost-types = "0.9"
 pulldown-cmark = { version = "0.12.0", default-features = false }
-quote = "1.0.9"
 rand = "0.8.5"
 rayon = "1.8"
 regex = "1.5"
@@ -481,8 +467,8 @@ runtimelib = { version = "0.25.0", default-features = false, features = [
 rustc-demangle = "0.1.23"
 rust-embed = { version = "8.4", features = ["include-exclude"] }
 rustc-hash = "2.1.0"
-rustls = { version = "0.23.22" }
-rustls-platform-verifier = "0.5.0"
+rustls = "0.21.12"
+rustls-native-certs = "0.8.0"
 schemars = { version = "0.8", features = ["impl_json_schema", "indexmap2"] }
 semver = "1.0"
 serde = { version = "1.0", features = ["derive", "rc"] }
@@ -502,11 +488,9 @@ simplelog = "0.12.2"
 smallvec = { version = "1.6", features = ["union"] }
 smol = "2.0"
 sqlformat = "0.2"
-streaming-iterator = "0.1"
 strsim = "0.11"
 strum = { version = "0.26.0", features = ["derive"] }
 subtle = "2.5.0"
-syn = { version = "1.0.72", features = ["full", "extra-traits"] }
 sys-locale = "0.3.1"
 sysinfo = "0.31.0"
 take-until = "0.2.0"
@@ -524,14 +508,13 @@ tiny_http = "0.8"
 toml = "0.8"
 tokio = { version = "1" }
 tower-http = "0.4.4"
-tree-sitter = { version = "0.24", features = ["wasm"] }
+tree-sitter = { version = "0.23", features = ["wasm"] }
 tree-sitter-bash = "0.23"
 tree-sitter-c = "0.23"
 tree-sitter-cpp = "0.23"
 tree-sitter-css = "0.23"
 tree-sitter-elixir = "0.3"
 tree-sitter-embedded-template = "0.23.0"
-tree-sitter-gitcommit = {git  = "https://github.com/zed-industries/tree-sitter-git-commit", rev = "88309716a69dd13ab83443721ba6e0b491d37ee9"}
 tree-sitter-go = "0.23"
 tree-sitter-go-mod = { git = "https://github.com/camdencheek/tree-sitter-go-mod", rev = "6efb59652d30e0e9cd5f3b3a669afd6f1a926d3c", package = "tree-sitter-gomod" }
 tree-sitter-gowork = { git = "https://github.com/zed-industries/tree-sitter-go-work", rev = "acb0617bf7f4fda02c6217676cc64acb89536dc7" }
@@ -553,19 +536,18 @@ unicode-segmentation = "1.10"
 unicode-script = "0.5.7"
 url = "2.2"
 uuid = { version = "1.1.2", features = ["v4", "v5", "v7", "serde"] }
-wasmparser = "0.217"
-wasm-encoder = "0.217"
-wasmtime = { version = "25", default-features = false, features = [
+wasmparser = "0.215"
+wasm-encoder = "0.215"
+wasmtime = { version = "24", default-features = false, features = [
     "async",
     "demangle",
     "runtime",
     "cranelift",
     "component-model",
 ] }
-wasmtime-wasi = "25"
+wasmtime-wasi = "24"
 which = "6.0.0"
 wit-component = "0.201"
-zed_llm_client = "0.4"
 zstd = "0.11"
 metal = "0.31"
 
@@ -626,7 +608,6 @@ features = [
 # TODO livekit https://github.com/RustAudio/cpal/pull/891
 [patch.crates-io]
 cpal = { git = "https://github.com/zed-industries/cpal", rev = "fd8bc2fd39f1f5fdee5a0690656caff9a26d9d50" }
-real-async-tls = { git = "https://github.com/zed-industries/async-tls", rev = "1e759a4b5e370f87dc15e40756ac4f8815b61d9d", package = "async-tls"}
 
 [profile.dev]
 split-debuginfo = "unpacked"
@@ -680,6 +661,7 @@ telemetry_events = { codegen-units = 1 }
 theme_selector = { codegen-units = 1 }
 time_format = { codegen-units = 1 }
 ui_input = { codegen-units = 1 }
+vcs_menu = { codegen-units = 1 }
 zed_actions = { codegen-units = 1 }
 
 [profile.release]

LICENSE-AGPL

@@ -1,4 +1,4 @@
-Copyright 2022 - 2025 Zed Industries, Inc.
+Copyright 2022 - 2024 Zed Industries, Inc.
 
 
 

LICENSE-APACHE

@@ -1,4 +1,4 @@
-Copyright 2022 - 2025 Zed Industries, Inc.
+Copyright 2022 - 2024 Zed Industries, Inc.
 
 
    Licensed under the Apache License, Version 2.0 (the "License");

assets/icons/circle.svg

@@ -1 +0,0 @@
-<svg width="15" height="15" viewBox="0 0 15 15" fill="none" xmlns="http://www.w3.org/2000/svg"><circle cx="7.25" cy="7.25" r="3" fill="currentColor"></circle></svg>

assets/icons/file_icons/file_types.json

@@ -18,23 +18,18 @@
     "bash_logout": "terminal",
     "bash_profile": "terminal",
     "bashrc": "terminal",
-    "bicep": "bicep",
     "bmp": "image",
     "c": "c",
     "c++": "cpp",
     "cc": "cpp",
     "cjs": "javascript",
-    "cjsx": "react",
     "coffee": "coffeescript",
     "conf": "settings",
     "cpp": "cpp",
-    "cs": "csharp",
     "css": "css",
     "csv": "storage",
     "cxx": "cpp",
     "cts": "typescript",
-    "ctsx": "react",
-    "cue": "cue",
     "dart": "dart",
     "dat": "storage",
     "db": "storage",
@@ -69,7 +64,6 @@
     "gitattributes": "vcs",
     "gitignore": "vcs",
     "gitkeep": "vcs",
-    "gitlab-ci.yml": "gitlab",
     "gitmodules": "vcs",
     "TAG_EDITMSG": "vcs",
     "MERGE_MSG": "vcs",
@@ -92,8 +86,8 @@
     "hpp": "cpp",
     "hrl": "erlang",
     "hs": "haskell",
-    "htm": "html",
-    "html": "html",
+    "htm": "template",
+    "html": "template",
     "hxx": "cpp",
     "ib": "storage",
     "ico": "image",
@@ -107,7 +101,7 @@
     "jpeg": "image",
     "jpg": "image",
     "js": "javascript",
-    "json": "json",
+    "json": "storage",
     "jsonc": "storage",
     "jsx": "react",
     "jxl": "image",
@@ -117,18 +111,16 @@
     "lockb": "bun",
     "log": "log",
     "lua": "lua",
-    "luau": "luau",
     "m4a": "audio",
     "m4v": "video",
-    "markdown": "markdown",
-    "md": "markdown",
+    "markdown": "document",
+    "md": "document",
     "mdb": "storage",
     "mdf": "storage",
     "mdx": "document",
     "metadata": "code",
     "metal": "metal",
     "mjs": "javascript",
-    "mjsx": "react",
     "mka": "audio",
     "mkv": "video",
     "ml": "ocaml",
@@ -138,7 +130,6 @@
     "mp3": "audio",
     "mp4": "video",
     "mts": "typescript",
-    "mtsx": "react",
     "myd": "storage",
     "myi": "storage",
     "nim": "nim",
@@ -159,19 +150,8 @@
     "postcss": "css",
     "ppt": "document",
     "pptx": "document",
-    "prettier.config.cjs": "prettier",
-    "prettier.config.js": "prettier",
-    "prettier.config.mjs": "prettier",
     "prettierignore": "prettier",
     "prettierrc": "prettier",
-    "prettierrc.cjs": "prettier",
-    "prettierrc.js": "prettier",
-    "prettierrc.json": "prettier",
-    "prettierrc.json5": "prettier",
-    "prettierrc.mjs": "prettier",
-    "prettierrc.toml": "prettier",
-    "prettierrc.yaml": "prettier",
-    "prettierrc.yml": "prettier",
     "prisma": "prisma",
     "profile": "terminal",
     "ps1": "terminal",
@@ -193,21 +173,9 @@
     "scss": "sass",
     "sdf": "storage",
     "sh": "terminal",
-    "sol": "solidity",
     "sql": "storage",
     "sqlite": "storage",
-    "stylelint.config.cjs": "stylelint",
-    "stylelint.config.js": "stylelint",
-    "stylelint.config.mjs": "stylelint",
-    "stylelintignore": "stylelint",
-    "stylelintrc": "stylelint",
-    "stylelintrc.cjs": "stylelint",
-    "stylelintrc.js": "stylelint",
-    "stylelintrc.json": "stylelint",
-    "stylelintrc.mjs": "stylelint",
-    "stylelintrc.yaml": "stylelint",
-    "stylelintrc.yml": "stylelint",
-    "svelte": "svelte",
+    "svelte": "template",
     "svg": "image",
     "swift": "swift",
     "tcl": "tcl",

assets/icons/lock_outlined.svg

@@ -1,6 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M5 5C5 3.89543 5.89543 3 7 3H9C10.1046 3 11 3.89543 11 5V6H5V5Z" stroke="black" stroke-width="1.5"/>
-<path d="M8 9V11" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
-<circle cx="8" cy="9" r="1" fill="black"/>
-<rect x="3.75" y="5.75" width="8.5" height="7.5" rx="1.25" stroke="black" stroke-width="1.5" stroke-linejoin="round"/>
-</svg>

assets/icons/zed_predict_bg.svg

@@ -1,6 +1,6 @@
-<svg width="550" height="128" xmlns="http://www.w3.org/2000/svg">
+<svg width="420" height="128" xmlns="http://www.w3.org/2000/svg">
   <defs>
-    <pattern id="tilePattern" width="23" height="23" patternUnits="userSpaceOnUse">
+    <pattern id="tilePattern" width="22" height="22" patternUnits="userSpaceOnUse">
       <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
         <path d="M12 5L14 8L12 11" stroke="black" stroke-width="1.5"/>
         <path d="M10 6.5L11 8L10 9.5" stroke="black" stroke-width="1.5"/>

assets/icons/zed_predict_disabled.svg

@@ -1,6 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path opacity="0.6" fill-rule="evenodd" clip-rule="evenodd" d="M6.75 9.31247L8.25 10.5576V11.75H1.75V10.0803L4.49751 7.44273L5.65909 8.40693L3.73923 10.25H6.75V9.31247ZM8.25 5.85739V4.25H6.31358L8.25 5.85739ZM1.75 5.16209V7.1H3.25V6.4072L1.75 5.16209Z" fill="black"/>
-<path opacity="0.6" fill-rule="evenodd" clip-rule="evenodd" d="M10.9624 9.40853L11.9014 8L10.6241 6.08397L9.37598 6.91603L10.0986 8L9.80184 8.44518L10.9624 9.40853Z" fill="black"/>
-<path opacity="0.6" fill-rule="evenodd" clip-rule="evenodd" d="M12.8936 11.0116L14.9014 8L12.6241 4.58397L11.376 5.41603L13.0986 8L11.7331 10.0483L12.8936 11.0116Z" fill="black"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M14.1225 13.809C14.0341 13.9146 13.877 13.9289 13.7711 13.8409L1.19311 3.40021C1.08659 3.31178 1.07221 3.15362 1.16104 3.04743L1.87752 2.19101C1.96588 2.0854 2.123 2.07112 2.22895 2.15906L14.8069 12.5998C14.9134 12.6882 14.9278 12.8464 14.839 12.9526L14.1225 13.809Z" fill="black"/>
-</svg>

assets/icons/zed_predict_down.svg

@@ -1,5 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M15 9.33333L14.5 9.66667L12.5 11L10.5 9.66667L10 9.33333" stroke="black" stroke-width="1.5"/>
-<path d="M12.5 11V4.5" stroke="black" stroke-width="1.5"/>
-<path d="M7.5 8.9V11C5.43097 11 4.56903 11 2.5 11V10.4L7.5 5.6V5H2.5V7.1" stroke="black" stroke-width="1.5"/>
-</svg>

assets/icons/zed_predict_up.svg

@@ -1,5 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M10 6.66667L10.5 6.33333L12.5 5L14.5 6.33333L15 6.66667" stroke="black" stroke-width="1.5"/>
-<path d="M12.5 11V5" stroke="black" stroke-width="1.5"/>
-<path d="M7.5 8.9V11C5.43097 11 4.56903 11 2.5 11V10.4L7.5 5.6V5H2.5V7.1" stroke="black" stroke-width="1.5"/>
-</svg>

assets/keymaps/default-linux.json

@@ -31,8 +31,8 @@
       "ctrl-,": "zed::OpenSettings",
       "ctrl-q": "zed::Quit",
       "f11": "zed::ToggleFullScreen",
-      "ctrl-alt-z": "edit_prediction::RateCompletions",
-      "ctrl-shift-i": "edit_prediction::ToggleMenu"
+      "ctrl-alt-z": "zeta::RateCompletions",
+      "ctrl-shift-i": "inline_completion::ToggleMenu"
     }
   },
   {
@@ -122,8 +122,7 @@
       "ctrl-i": "editor::ShowSignatureHelp",
       "alt-g b": "editor::ToggleGitBlame",
       "menu": "editor::OpenContextMenu",
-      "shift-f10": "editor::OpenContextMenu",
-      "ctrl-shift-e": "editor::ToggleEditPrediction"
+      "shift-f10": "editor::OpenContextMenu"
     }
   },
   {
@@ -146,17 +145,17 @@
     }
   },
   {
-    "context": "Editor && mode == full && edit_prediction",
+    "context": "Editor && mode == full && inline_completion",
     "bindings": {
-      "alt-]": "editor::NextEditPrediction",
-      "alt-[": "editor::PreviousEditPrediction",
-      "alt-right": "editor::AcceptPartialEditPrediction"
+      "alt-]": "editor::NextInlineCompletion",
+      "alt-[": "editor::PreviousInlineCompletion",
+      "alt-right": "editor::AcceptPartialInlineCompletion"
     }
   },
   {
-    "context": "Editor && !edit_prediction",
+    "context": "Editor && !inline_completion",
     "bindings": {
-      "alt-\\": "editor::ShowEditPrediction"
+      "alt-\\": "editor::ShowInlineCompletion"
     }
   },
   {
@@ -204,8 +203,8 @@
       "enter": "search::SelectNextMatch",
       "shift-enter": "search::SelectPrevMatch",
       "alt-enter": "search::SelectAllMatches",
-      "find": "search::FocusSearch",
       "ctrl-f": "search::FocusSearch",
+      "find": "search::FocusSearch",
       "ctrl-h": "search::ToggleReplace",
       "ctrl-l": "search::ToggleSelection"
     }
@@ -275,8 +274,8 @@
       "ctrl-pagedown": "pane::ActivateNextItem",
       "ctrl-shift-pageup": "pane::SwapItemLeft",
       "ctrl-shift-pagedown": "pane::SwapItemRight",
-      "ctrl-f4": ["pane::CloseActiveItem", { "close_pinned": false }],
-      "ctrl-w": ["pane::CloseActiveItem", { "close_pinned": false }],
+      "ctrl-f4": "pane::CloseActiveItem",
+      "ctrl-w": "pane::CloseActiveItem",
       "alt-ctrl-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
       "alt-ctrl-shift-w": "workspace::CloseInactiveTabsAndPanes",
       "ctrl-k e": ["pane::CloseItemsToTheLeft", { "close_pinned": false }],
@@ -291,15 +290,15 @@
       "f3": "search::SelectNextMatch",
       "ctrl-alt-shift-g": "search::SelectPrevMatch",
       "shift-f3": "search::SelectPrevMatch",
-      "shift-find": "project_search::ToggleFocus",
       "ctrl-shift-f": "project_search::ToggleFocus",
+      "shift-find": "project_search::ToggleFocus",
       "ctrl-alt-shift-h": "search::ToggleReplace",
       "ctrl-alt-shift-l": "search::ToggleSelection",
       "alt-enter": "search::SelectAllMatches",
       "alt-c": "search::ToggleCaseSensitive",
       "alt-w": "search::ToggleWholeWord",
-      "alt-find": "project_search::ToggleFilters",
       "alt-ctrl-f": "project_search::ToggleFilters",
+      "alt-find": "project_search::ToggleFilters",
       "ctrl-alt-shift-r": "search::ToggleRegex",
       "ctrl-alt-shift-x": "search::ToggleRegex",
       "alt-r": "search::ToggleRegex",
@@ -349,15 +348,15 @@
       "ctrl-k ctrl-l": "editor::ToggleFold",
       "ctrl-k ctrl-[": "editor::FoldRecursive",
       "ctrl-k ctrl-]": "editor::UnfoldRecursive",
-      "ctrl-k ctrl-1": ["editor::FoldAtLevel", 1],
-      "ctrl-k ctrl-2": ["editor::FoldAtLevel", 2],
-      "ctrl-k ctrl-3": ["editor::FoldAtLevel", 3],
-      "ctrl-k ctrl-4": ["editor::FoldAtLevel", 4],
-      "ctrl-k ctrl-5": ["editor::FoldAtLevel", 5],
-      "ctrl-k ctrl-6": ["editor::FoldAtLevel", 6],
-      "ctrl-k ctrl-7": ["editor::FoldAtLevel", 7],
-      "ctrl-k ctrl-8": ["editor::FoldAtLevel", 8],
-      "ctrl-k ctrl-9": ["editor::FoldAtLevel", 9],
+      "ctrl-k ctrl-1": ["editor::FoldAtLevel", { "level": 1 }],
+      "ctrl-k ctrl-2": ["editor::FoldAtLevel", { "level": 2 }],
+      "ctrl-k ctrl-3": ["editor::FoldAtLevel", { "level": 3 }],
+      "ctrl-k ctrl-4": ["editor::FoldAtLevel", { "level": 4 }],
+      "ctrl-k ctrl-5": ["editor::FoldAtLevel", { "level": 5 }],
+      "ctrl-k ctrl-6": ["editor::FoldAtLevel", { "level": 6 }],
+      "ctrl-k ctrl-7": ["editor::FoldAtLevel", { "level": 7 }],
+      "ctrl-k ctrl-8": ["editor::FoldAtLevel", { "level": 8 }],
+      "ctrl-k ctrl-9": ["editor::FoldAtLevel", { "level": 9 }],
       "ctrl-k ctrl-0": "editor::FoldAll",
       "ctrl-k ctrl-j": "editor::UnfoldAll",
       "ctrl-space": "editor::ShowCompletions",
@@ -433,14 +432,14 @@
       "ctrl-alt-s": "workspace::SaveAll",
       "ctrl-k m": "language_selector::Toggle",
       "escape": "workspace::Unfollow",
-      "ctrl-k ctrl-left": "workspace::ActivatePaneLeft",
-      "ctrl-k ctrl-right": "workspace::ActivatePaneRight",
-      "ctrl-k ctrl-up": "workspace::ActivatePaneUp",
-      "ctrl-k ctrl-down": "workspace::ActivatePaneDown",
-      "ctrl-k shift-left": "workspace::SwapPaneLeft",
-      "ctrl-k shift-right": "workspace::SwapPaneRight",
-      "ctrl-k shift-up": "workspace::SwapPaneUp",
-      "ctrl-k shift-down": "workspace::SwapPaneDown",
+      "ctrl-k ctrl-left": ["workspace::ActivatePaneInDirection", "Left"],
+      "ctrl-k ctrl-right": ["workspace::ActivatePaneInDirection", "Right"],
+      "ctrl-k ctrl-up": ["workspace::ActivatePaneInDirection", "Up"],
+      "ctrl-k ctrl-down": ["workspace::ActivatePaneInDirection", "Down"],
+      "ctrl-k shift-left": ["workspace::SwapPaneInDirection", "Left"],
+      "ctrl-k shift-right": ["workspace::SwapPaneInDirection", "Right"],
+      "ctrl-k shift-up": ["workspace::SwapPaneInDirection", "Up"],
+      "ctrl-k shift-down": ["workspace::SwapPaneInDirection", "Down"],
       "ctrl-shift-x": "zed::Extensions",
       "ctrl-shift-r": "task::Rerun",
       "ctrl-alt-r": "task::Rerun",
@@ -454,8 +453,8 @@
   {
     "context": "ApplicationMenu",
     "bindings": {
-      "left": "app_menu::ActivateMenuLeft",
-      "right": "app_menu::ActivateMenuRight"
+      "left": ["app_menu::NavigateApplicationMenuInDirection", "Left"],
+      "right": ["app_menu::NavigateApplicationMenuInDirection", "Right"]
     }
   },
   // Bindings from Sublime Text
@@ -497,27 +496,17 @@
   },
   {
     "context": "Editor && showing_completions",
+    "use_key_equivalents": true,
     "bindings": {
       "enter": "editor::ConfirmCompletion",
       "tab": "editor::ComposeCompletion"
     }
   },
-  // Bindings for accepting edit predictions
-  //
-  // alt-l is provided as an alternative to tab/alt-tab. and will be displayed in the UI. This is
-  // because alt-tab may not be available, as it is often used for window switching.
   {
-    "context": "Editor && edit_prediction",
+    "context": "Editor && inline_completion && !showing_completions",
+    "use_key_equivalents": true,
     "bindings": {
-      "alt-tab": "editor::AcceptEditPrediction",
-      "alt-l": "editor::AcceptEditPrediction"
-    }
-  },
-  {
-    "context": "Editor && edit_prediction && !edit_prediction_requires_modifier",
-    "bindings": {
-      "tab": "editor::AcceptEditPrediction",
-      "alt-l": "editor::AcceptEditPrediction"
+      "tab": "editor::AcceptInlineCompletion"
     }
   },
   {
@@ -541,7 +530,8 @@
   {
     "bindings": {
       "ctrl-alt-shift-f": "workspace::FollowNextCollaborator",
-      "ctrl-alt-i": "zed::DebugElements"
+      "ctrl-alt-i": "zed::DebugElements",
+      "ctrl-:": "editor::ToggleInlayHints"
     }
   },
   {
@@ -559,8 +549,7 @@
       "ctrl-shift-e": "pane::RevealInProjectPanel",
       "ctrl-f8": "editor::GoToHunk",
       "ctrl-shift-f8": "editor::GoToPrevHunk",
-      "ctrl-enter": "assistant::InlineAssist",
-      "ctrl-:": "editor::ToggleInlayHints"
+      "ctrl-enter": "assistant::InlineAssist"
     }
   },
   {
@@ -606,12 +595,14 @@
   },
   {
     "context": "MessageEditor > Editor",
+    "use_key_equivalents": true,
     "bindings": {
       "enter": "assistant2::Chat"
     }
   },
   {
     "context": "ContextStrip",
+    "use_key_equivalents": true,
     "bindings": {
       "up": "assistant2::FocusUp",
       "right": "assistant2::FocusRight",
@@ -689,8 +680,8 @@
       "ctrl-delete": ["project_panel::Delete", { "skip_prompt": false }],
       "alt-ctrl-r": "project_panel::RevealInFileManager",
       "ctrl-shift-enter": "project_panel::OpenWithSystem",
-      "shift-find": "project_panel::NewSearchInDirectory",
       "ctrl-shift-f": "project_panel::NewSearchInDirectory",
+      "shift-find": "project_panel::NewSearchInDirectory",
       "shift-down": "menu::SelectNext",
       "shift-up": "menu::SelectPrev",
       "escape": "menu::Cancel"
@@ -704,32 +695,30 @@
   },
   {
     "context": "GitPanel && !CommitEditor",
+    "use_key_equivalents": true,
     "bindings": {
       "escape": "git_panel::Close"
     }
   },
   {
     "context": "GitPanel && ChangesList",
+    "use_key_equivalents": true,
     "bindings": {
       "up": "menu::SelectPrev",
       "down": "menu::SelectNext",
       "enter": "menu::Confirm",
       "space": "git::ToggleStaged",
       "ctrl-space": "git::StageAll",
-      "ctrl-shift-space": "git::UnstageAll",
-      "tab": "git_panel::FocusEditor",
-      "shift-tab": "git_panel::FocusEditor",
-      "escape": "git_panel::ToggleFocus"
+      "ctrl-shift-space": "git::UnstageAll"
     }
   },
   {
-    "context": "GitPanel > Editor",
+    "context": "GitPanel && CommitEditor > Editor",
+    "use_key_equivalents": true,
     "bindings": {
       "escape": "git_panel::FocusChanges",
-      "ctrl-enter": "git::Commit",
-      "tab": "git_panel::FocusChanges",
-      "shift-tab": "git_panel::FocusChanges",
-      "alt-up": "git_panel::FocusChanges"
+      "ctrl-enter": "git::CommitChanges",
+      "ctrl-shift-enter": "git::CommitAllChanges"
     }
   },
   {
@@ -837,6 +826,7 @@
   },
   {
     "context": "ZedPredictModal",
+    "use_key_equivalents": true,
     "bindings": {
       "escape": "menu::Cancel"
     }

assets/keymaps/default-macos.json

@@ -39,8 +39,8 @@
       "cmd-m": "zed::Minimize",
       "fn-f": "zed::ToggleFullScreen",
       "ctrl-cmd-f": "zed::ToggleFullScreen",
-      "ctrl-cmd-z": "edit_prediction::RateCompletions",
-      "ctrl-cmd-i": "edit_prediction::ToggleMenu"
+      "ctrl-shift-z": "zeta::RateCompletions",
+      "ctrl-shift-i": "inline_completion::ToggleMenu"
     }
   },
   {
@@ -132,8 +132,7 @@
       "cmd-alt-g b": "editor::ToggleGitBlame",
       "cmd-i": "editor::ShowSignatureHelp",
       "ctrl-f12": "editor::GoToDeclaration",
-      "alt-ctrl-f12": "editor::GoToDeclarationSplit",
-      "ctrl-cmd-e": "editor::ToggleEditPrediction"
+      "alt-ctrl-f12": "editor::GoToDeclarationSplit"
     }
   },
   {
@@ -156,19 +155,19 @@
     }
   },
   {
-    "context": "Editor && mode == full && edit_prediction",
+    "context": "Editor && mode == full && inline_completion",
     "use_key_equivalents": true,
     "bindings": {
-      "alt-tab": "editor::NextEditPrediction",
-      "alt-shift-tab": "editor::PreviousEditPrediction",
-      "ctrl-cmd-right": "editor::AcceptPartialEditPrediction"
+      "alt-tab": "editor::NextInlineCompletion",
+      "alt-shift-tab": "editor::PreviousInlineCompletion",
+      "ctrl-cmd-right": "editor::AcceptPartialInlineCompletion"
     }
   },
   {
-    "context": "Editor && !edit_prediction",
+    "context": "Editor && !inline_completion",
     "use_key_equivalents": true,
     "bindings": {
-      "alt-tab": "editor::ShowEditPrediction"
+      "alt-tab": "editor::ShowInlineCompletion"
     }
   },
   {
@@ -350,7 +349,7 @@
       "cmd-}": "pane::ActivateNextItem",
       "ctrl-shift-pageup": "pane::SwapItemLeft",
       "ctrl-shift-pagedown": "pane::SwapItemRight",
-      "cmd-w": ["pane::CloseActiveItem", { "close_pinned": false }],
+      "cmd-w": "pane::CloseActiveItem",
       "alt-cmd-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
       "ctrl-alt-cmd-w": "workspace::CloseInactiveTabsAndPanes",
       "cmd-k e": ["pane::CloseItemsToTheLeft", { "close_pinned": false }],
@@ -414,15 +413,15 @@
       "cmd-k cmd-l": "editor::ToggleFold",
       "cmd-k cmd-[": "editor::FoldRecursive",
       "cmd-k cmd-]": "editor::UnfoldRecursive",
-      "cmd-k cmd-1": ["editor::FoldAtLevel", 1],
-      "cmd-k cmd-2": ["editor::FoldAtLevel", 2],
-      "cmd-k cmd-3": ["editor::FoldAtLevel", 3],
-      "cmd-k cmd-4": ["editor::FoldAtLevel", 4],
-      "cmd-k cmd-5": ["editor::FoldAtLevel", 5],
-      "cmd-k cmd-6": ["editor::FoldAtLevel", 6],
-      "cmd-k cmd-7": ["editor::FoldAtLevel", 7],
-      "cmd-k cmd-8": ["editor::FoldAtLevel", 8],
-      "cmd-k cmd-9": ["editor::FoldAtLevel", 9],
+      "cmd-k cmd-1": ["editor::FoldAtLevel", { "level": 1 }],
+      "cmd-k cmd-2": ["editor::FoldAtLevel", { "level": 2 }],
+      "cmd-k cmd-3": ["editor::FoldAtLevel", { "level": 3 }],
+      "cmd-k cmd-4": ["editor::FoldAtLevel", { "level": 4 }],
+      "cmd-k cmd-5": ["editor::FoldAtLevel", { "level": 5 }],
+      "cmd-k cmd-6": ["editor::FoldAtLevel", { "level": 6 }],
+      "cmd-k cmd-7": ["editor::FoldAtLevel", { "level": 7 }],
+      "cmd-k cmd-8": ["editor::FoldAtLevel", { "level": 8 }],
+      "cmd-k cmd-9": ["editor::FoldAtLevel", { "level": 9 }],
       "cmd-k cmd-0": "editor::FoldAll",
       "cmd-k cmd-j": "editor::UnfoldAll",
       // Using `ctrl-space` in Zed requires disabling the macOS global shortcut.
@@ -510,14 +509,14 @@
       "cmd-alt-s": "workspace::SaveAll",
       "cmd-k m": "language_selector::Toggle",
       "escape": "workspace::Unfollow",
-      "cmd-k cmd-left": "workspace::ActivatePaneLeft",
-      "cmd-k cmd-right": "workspace::ActivatePaneRight",
-      "cmd-k cmd-up": "workspace::ActivatePaneUp",
-      "cmd-k cmd-down": "workspace::ActivatePaneDown",
-      "cmd-k shift-left": "workspace::SwapPaneLeft",
-      "cmd-k shift-right": "workspace::SwapPaneRight",
-      "cmd-k shift-up": "workspace::SwapPaneUp",
-      "cmd-k shift-down": "workspace::SwapPaneDown",
+      "cmd-k cmd-left": ["workspace::ActivatePaneInDirection", "Left"],
+      "cmd-k cmd-right": ["workspace::ActivatePaneInDirection", "Right"],
+      "cmd-k cmd-up": ["workspace::ActivatePaneInDirection", "Up"],
+      "cmd-k cmd-down": ["workspace::ActivatePaneInDirection", "Down"],
+      "cmd-k shift-left": ["workspace::SwapPaneInDirection", "Left"],
+      "cmd-k shift-right": ["workspace::SwapPaneInDirection", "Right"],
+      "cmd-k shift-up": ["workspace::SwapPaneInDirection", "Up"],
+      "cmd-k shift-down": ["workspace::SwapPaneInDirection", "Down"],
       "cmd-shift-x": "zed::Extensions"
     }
   },
@@ -581,16 +580,10 @@
     }
   },
   {
-    "context": "Editor && edit_prediction",
-    "bindings": {
-      "alt-tab": "editor::AcceptEditPrediction"
-    }
-  },
-  {
-    "context": "Editor && edit_prediction && !edit_prediction_requires_modifier",
+    "context": "Editor && inline_completion && !showing_completions",
     "use_key_equivalents": true,
     "bindings": {
-      "tab": "editor::AcceptEditPrediction"
+      "tab": "editor::AcceptInlineCompletion"
     }
   },
   {
@@ -619,7 +612,8 @@
       "ctrl-alt-cmd-f": "workspace::FollowNextCollaborator",
       // TODO: Move this to a dock open action
       "cmd-shift-c": "collab_panel::ToggleFocus",
-      "cmd-alt-i": "zed::DebugElements"
+      "cmd-alt-i": "zed::DebugElements",
+      "ctrl-:": "editor::ToggleInlayHints"
     }
   },
   {
@@ -632,8 +626,7 @@
       "cmd-shift-e": "pane::RevealInProjectPanel",
       "cmd-f8": "editor::GoToHunk",
       "cmd-shift-f8": "editor::GoToPrevHunk",
-      "ctrl-enter": "assistant::InlineAssist",
-      "ctrl-:": "editor::ToggleInlayHints"
+      "ctrl-enter": "assistant::InlineAssist"
     }
   },
   {
@@ -715,6 +708,13 @@
       "space": "project_panel::Open"
     }
   },
+  {
+    "context": "GitPanel && !CommitEditor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "escape": "git_panel::Close"
+    }
+  },
   {
     "context": "GitPanel && ChangesList",
     "use_key_equivalents": true,
@@ -727,21 +727,17 @@
       "space": "git::ToggleStaged",
       "cmd-shift-space": "git::StageAll",
       "ctrl-shift-space": "git::UnstageAll",
-      "alt-down": "git_panel::FocusEditor",
-      "tab": "git_panel::FocusEditor",
-      "shift-tab": "git_panel::FocusEditor",
-      "escape": "git_panel::ToggleFocus"
+      "alt-down": "git_panel::FocusEditor"
     }
   },
   {
-    "context": "GitPanel > Editor",
+    "context": "GitPanel && CommitEditor > Editor",
     "use_key_equivalents": true,
     "bindings": {
-      "enter": "editor::Newline",
-      "cmd-enter": "git::Commit",
-      "tab": "git_panel::FocusChanges",
-      "shift-tab": "git_panel::FocusChanges",
-      "alt-up": "git_panel::FocusChanges"
+      "alt-up": "git_panel::FocusChanges",
+      "escape": "git_panel::FocusChanges",
+      "cmd-enter": "git::CommitChanges",
+      "cmd-alt-enter": "git::CommitAllChanges"
     }
   },
   {

assets/keymaps/vim.json

@@ -2,8 +2,8 @@
   {
     "context": "VimControl && !menu",
     "bindings": {
-      "i": ["vim::PushObject", { "around": false }],
-      "a": ["vim::PushObject", { "around": true }],
+      "i": ["vim::PushOperator", { "Object": { "around": false } }],
+      "a": ["vim::PushOperator", { "Object": { "around": true } }],
       "left": "vim::Left",
       "h": "vim::Left",
       "backspace": "vim::Backspace",
@@ -54,10 +54,10 @@
       // "b": "vim::PreviousSubwordStart",
       // "e": "vim::NextSubwordEnd",
       // "g e": "vim::PreviousSubwordEnd",
-      "shift-w": ["vim::NextWordStart", { "ignore_punctuation": true }],
-      "shift-e": ["vim::NextWordEnd", { "ignore_punctuation": true }],
-      "shift-b": ["vim::PreviousWordStart", { "ignore_punctuation": true }],
-      "g shift-e": ["vim::PreviousWordEnd", { "ignore_punctuation": true }],
+      "shift-w": ["vim::NextWordStart", { "ignorePunctuation": true }],
+      "shift-e": ["vim::NextWordEnd", { "ignorePunctuation": true }],
+      "shift-b": ["vim::PreviousWordStart", { "ignorePunctuation": true }],
+      "g shift-e": ["vim::PreviousWordEnd", { "ignorePunctuation": true }],
       "/": "vim::Search",
       "g /": "pane::DeploySearch",
       "?": ["vim::Search", { "backwards": true }],
@@ -70,20 +70,20 @@
       "[ {": ["vim::UnmatchedBackward", { "char": "{" }],
       "] )": ["vim::UnmatchedForward", { "char": ")" }],
       "[ (": ["vim::UnmatchedBackward", { "char": "(" }],
-      "f": ["vim::PushFindForward", { "before": false }],
-      "t": ["vim::PushFindForward", { "before": true }],
-      "shift-f": ["vim::PushFindBackward", { "after": false }],
-      "shift-t": ["vim::PushFindBackward", { "after": true }],
-      "m": "vim::PushMark",
-      "'": ["vim::PushJump", { "line": true }],
-      "`": ["vim::PushJump", { "line": false }],
+      "f": ["vim::PushOperator", { "FindForward": { "before": false } }],
+      "t": ["vim::PushOperator", { "FindForward": { "before": true } }],
+      "shift-f": ["vim::PushOperator", { "FindBackward": { "after": false } }],
+      "shift-t": ["vim::PushOperator", { "FindBackward": { "after": true } }],
+      "m": ["vim::PushOperator", "Mark"],
+      "'": ["vim::PushOperator", { "Jump": { "line": true } }],
+      "`": ["vim::PushOperator", { "Jump": { "line": false } }],
       ";": "vim::RepeatFind",
       ",": "vim::RepeatFindReversed",
       "ctrl-o": "pane::GoBack",
       "ctrl-i": "pane::GoForward",
       "ctrl-]": "editor::GoToDefinition",
-      "escape": "vim::SwitchToNormalMode",
-      "ctrl-[": "vim::SwitchToNormalMode",
+      "escape": ["vim::SwitchMode", "Normal"],
+      "ctrl-[": ["vim::SwitchMode", "Normal"],
       "v": "vim::ToggleVisual",
       "shift-v": "vim::ToggleVisualLine",
       "ctrl-g": "vim::ShowLocation",
@@ -102,7 +102,6 @@
       "ctrl-e": "vim::LineDown",
       "ctrl-y": "vim::LineUp",
       // "g" commands
-      "g r": "vim::PushReplaceWithRegister",
       "g g": "vim::StartOfDocument",
       "g h": "editor::Hover",
       "g t": "pane::ActivateNextItem",
@@ -125,17 +124,17 @@
       "g .": "editor::ToggleCodeActions", // zed specific
       "g shift-a": "editor::FindAllReferences", // zed specific
       "g space": "editor::OpenExcerpts", // zed specific
-      "g *": ["vim::MoveToNext", { "partial_word": true }],
-      "g #": ["vim::MoveToPrev", { "partial_word": true }],
-      "g j": ["vim::Down", { "display_lines": true }],
-      "g down": ["vim::Down", { "display_lines": true }],
-      "g k": ["vim::Up", { "display_lines": true }],
-      "g up": ["vim::Up", { "display_lines": true }],
-      "g $": ["vim::EndOfLine", { "display_lines": true }],
-      "g end": ["vim::EndOfLine", { "display_lines": true }],
-      "g 0": ["vim::StartOfLine", { "display_lines": true }],
-      "g home": ["vim::StartOfLine", { "display_lines": true }],
-      "g ^": ["vim::FirstNonWhitespace", { "display_lines": true }],
+      "g *": ["vim::MoveToNext", { "partialWord": true }],
+      "g #": ["vim::MoveToPrev", { "partialWord": true }],
+      "g j": ["vim::Down", { "displayLines": true }],
+      "g down": ["vim::Down", { "displayLines": true }],
+      "g k": ["vim::Up", { "displayLines": true }],
+      "g up": ["vim::Up", { "displayLines": true }],
+      "g $": ["vim::EndOfLine", { "displayLines": true }],
+      "g end": ["vim::EndOfLine", { "displayLines": true }],
+      "g 0": ["vim::StartOfLine", { "displayLines": true }],
+      "g home": ["vim::StartOfLine", { "displayLines": true }],
+      "g ^": ["vim::FirstNonWhitespace", { "displayLines": true }],
       "g v": "vim::RestoreVisualSelection",
       "g ]": "editor::GoToDiagnostic",
       "g [": "editor::GoToPrevDiagnostic",
@@ -147,7 +146,7 @@
       "shift-l": "vim::WindowBottom",
       "q": "vim::ToggleRecord",
       "shift-q": "vim::ReplayLastRecording",
-      "@": "vim::PushReplayRegister",
+      "@": ["vim::PushOperator", "ReplayRegister"],
       // z commands
       "z enter": ["workspace::SendKeystrokes", "z t ^"],
       "z -": ["workspace::SendKeystrokes", "z b ^"],
@@ -166,8 +165,8 @@
       "z f": "editor::FoldSelectedRanges",
       "z shift-m": "editor::FoldAll",
       "z shift-r": "editor::UnfoldAll",
-      "shift-z shift-q": ["pane::CloseActiveItem", { "save_intent": "skip" }],
-      "shift-z shift-z": ["pane::CloseActiveItem", { "save_intent": "save_all" }],
+      "shift-z shift-q": ["pane::CloseActiveItem", { "saveIntent": "skip" }],
+      "shift-z shift-z": ["pane::CloseActiveItem", { "saveIntent": "saveAll" }],
       // Count support
       "1": ["vim::Number", 1],
       "2": ["vim::Number", 2],
@@ -194,13 +193,13 @@
       "escape": "editor::Cancel",
       ":": "command_palette::Toggle",
       ".": "vim::Repeat",
-      "c": "vim::PushChange",
+      "c": ["vim::PushOperator", "Change"],
       "shift-c": "vim::ChangeToEndOfLine",
-      "d": "vim::PushDelete",
+      "d": ["vim::PushOperator", "Delete"],
       "shift-d": "vim::DeleteToEndOfLine",
       "shift-j": "vim::JoinLines",
       "g shift-j": "vim::JoinLinesNoWhitespace",
-      "y": "vim::PushYank",
+      "y": ["vim::PushOperator", "Yank"],
       "shift-y": "vim::YankLine",
       "i": "vim::InsertBefore",
       "shift-i": "vim::InsertFirstNonWhitespace",
@@ -217,19 +216,19 @@
       "shift-p": ["vim::Paste", { "before": true }],
       "u": "vim::Undo",
       "ctrl-r": "vim::Redo",
-      "r": "vim::PushReplace",
+      "r": ["vim::PushOperator", "Replace"],
       "s": "vim::Substitute",
       "shift-s": "vim::SubstituteLine",
-      ">": "vim::PushIndent",
-      "<": "vim::PushOutdent",
-      "=": "vim::PushAutoIndent",
-      "!": "vim::PushShellCommand",
-      "g u": "vim::PushLowercase",
-      "g shift-u": "vim::PushUppercase",
-      "g ~": "vim::PushOppositeCase",
-      "\"": "vim::PushRegister",
-      "g w": "vim::PushRewrap",
-      "g q": "vim::PushRewrap",
+      ">": ["vim::PushOperator", "Indent"],
+      "<": ["vim::PushOperator", "Outdent"],
+      "=": ["vim::PushOperator", "AutoIndent"],
+      "!": ["vim::PushOperator", "ShellCommand"],
+      "g u": ["vim::PushOperator", "Lowercase"],
+      "g shift-u": ["vim::PushOperator", "Uppercase"],
+      "g ~": ["vim::PushOperator", "OppositeCase"],
+      "\"": ["vim::PushOperator", "Register"],
+      "g w": ["vim::PushOperator", "Rewrap"],
+      "g q": ["vim::PushOperator", "Rewrap"],
       "ctrl-pagedown": "pane::ActivateNextItem",
       "ctrl-pageup": "pane::ActivatePrevItem",
       "insert": "vim::InsertBefore",
@@ -240,7 +239,7 @@
       "[ d": "editor::GoToPrevDiagnostic",
       "] c": "editor::GoToHunk",
       "[ c": "editor::GoToPrevHunk",
-      "g c": "vim::PushToggleComments"
+      "g c": ["vim::PushOperator", "ToggleComments"]
     }
   },
   {
@@ -265,14 +264,14 @@
       "y": "vim::VisualYank",
       "shift-y": "vim::VisualYankLine",
       "p": "vim::Paste",
-      "shift-p": ["vim::Paste", { "preserve_clipboard": true }],
+      "shift-p": ["vim::Paste", { "preserveClipboard": true }],
       "c": "vim::Substitute",
       "s": "vim::Substitute",
       "shift-r": "vim::SubstituteLine",
       "shift-s": "vim::SubstituteLine",
       "~": "vim::ChangeCase",
-      "*": ["vim::MoveToNext", { "partial_word": true }],
-      "#": ["vim::MoveToPrev", { "partial_word": true }],
+      "*": ["vim::MoveToNext", { "partialWord": true }],
+      "#": ["vim::MoveToPrev", { "partialWord": true }],
       "ctrl-a": "vim::Increment",
       "ctrl-x": "vim::Decrement",
       "g ctrl-a": ["vim::Increment", { "step": true }],
@@ -283,19 +282,19 @@
       "g shift-a": "vim::VisualInsertEndOfLine",
       "shift-j": "vim::JoinLines",
       "g shift-j": "vim::JoinLinesNoWhitespace",
-      "r": "vim::PushReplace",
-      "ctrl-c": "vim::SwitchToNormalMode",
-      "ctrl-[": "vim::SwitchToNormalMode",
-      "escape": "vim::SwitchToNormalMode",
+      "r": ["vim::PushOperator", "Replace"],
+      "ctrl-c": ["vim::SwitchMode", "Normal"],
+      "ctrl-[": ["vim::SwitchMode", "Normal"],
+      "escape": ["vim::SwitchMode", "Normal"],
       ">": "vim::Indent",
       "<": "vim::Outdent",
       "=": "vim::AutoIndent",
       "!": "vim::ShellCommand",
-      "i": ["vim::PushObject", { "around": false }],
-      "a": ["vim::PushObject", { "around": true }],
+      "i": ["vim::PushOperator", { "Object": { "around": false } }],
+      "a": ["vim::PushOperator", { "Object": { "around": true } }],
       "g c": "vim::ToggleComments",
       "g q": "vim::Rewrap",
-      "\"": "vim::PushRegister",
+      "\"": ["vim::PushOperator", "Register"],
       // tree-sitter related commands
       "[ x": "editor::SelectLargerSyntaxNode",
       "] x": "editor::SelectSmallerSyntaxNode"
@@ -310,19 +309,19 @@
       "ctrl-x": null,
       "ctrl-x ctrl-o": "editor::ShowCompletions",
       "ctrl-x ctrl-a": "assistant::InlineAssist", // zed specific
-      "ctrl-x ctrl-c": "editor::ShowEditPrediction", // zed specific
+      "ctrl-x ctrl-c": "editor::ShowInlineCompletion", // zed specific
       "ctrl-x ctrl-l": "editor::ToggleCodeActions", // zed specific
       "ctrl-x ctrl-z": "editor::Cancel",
       "ctrl-w": "editor::DeleteToPreviousWordStart",
       "ctrl-u": "editor::DeleteToBeginningOfLine",
       "ctrl-t": "vim::Indent",
       "ctrl-d": "vim::Outdent",
-      "ctrl-k": ["vim::PushDigraph", {}],
-      "ctrl-v": ["vim::PushLiteral", {}],
+      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
+      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
       "ctrl-shift-v": "editor::Paste", // note: this is *very* similar to ctrl-v in vim, but ctrl-shift-v on linux is the typical shortcut for paste when ctrl-v is already in use.
-      "ctrl-q": ["vim::PushLiteral", {}],
-      "ctrl-shift-q": ["vim::PushLiteral", {}],
-      "ctrl-r": "vim::PushRegister",
+      "ctrl-q": ["vim::PushOperator", { "Literal": {} }],
+      "ctrl-shift-q": ["vim::PushOperator", { "Literal": {} }],
+      "ctrl-r": ["vim::PushOperator", "Register"],
       "insert": "vim::ToggleReplace",
       "ctrl-o": "vim::TemporaryNormal"
     }
@@ -357,11 +356,11 @@
       "ctrl-c": "vim::NormalBefore",
       "ctrl-[": "vim::NormalBefore",
       "escape": "vim::NormalBefore",
-      "ctrl-k": ["vim::PushDigraph", {}],
-      "ctrl-v": ["vim::PushLiteral", {}],
+      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
+      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
       "ctrl-shift-v": "editor::Paste", // note: this is *very* similar to ctrl-v in vim, but ctrl-shift-v on linux is the typical shortcut for paste when ctrl-v is already in use.
-      "ctrl-q": ["vim::PushLiteral", {}],
-      "ctrl-shift-q": ["vim::PushLiteral", {}],
+      "ctrl-q": ["vim::PushOperator", { "Literal": {} }],
+      "ctrl-shift-q": ["vim::PushOperator", { "Literal": {} }],
       "backspace": "vim::UndoReplace",
       "tab": "vim::Tab",
       "enter": "vim::Enter",
@@ -376,15 +375,9 @@
       "ctrl-c": "vim::ClearOperators",
       "ctrl-[": "vim::ClearOperators",
       "escape": "vim::ClearOperators",
-      "ctrl-k": ["vim::PushDigraph", {}],
-      "ctrl-v": ["vim::PushLiteral", {}],
-      "ctrl-q": ["vim::PushLiteral", {}]
-    }
-  },
-  {
-    "context": "Editor && vim_mode == waiting && (vim_operator == ys || vim_operator == cs)",
-    "bindings": {
-      "escape": "vim::SwitchToNormalMode"
+      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
+      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
+      "ctrl-q": ["vim::PushOperator", { "Literal": {} }]
     }
   },
   {
@@ -400,10 +393,10 @@
     "context": "vim_operator == a || vim_operator == i || vim_operator == cs",
     "bindings": {
       "w": "vim::Word",
-      "shift-w": ["vim::Word", { "ignore_punctuation": true }],
+      "shift-w": ["vim::Word", { "ignorePunctuation": true }],
       // Subword TextObject
       // "w": "vim::Subword",
-      // "shift-w": ["vim::Subword", { "ignore_punctuation": true }],
+      // "shift-w": ["vim::Subword", { "ignorePunctuation": true }],
       "t": "vim::Tag",
       "s": "vim::Sentence",
       "p": "vim::Paragraph",
@@ -426,10 +419,9 @@
       ">": "vim::AngleBrackets",
       "a": "vim::Argument",
       "i": "vim::IndentObj",
-      "shift-i": ["vim::IndentObj", { "include_below": true }],
+      "shift-i": ["vim::IndentObj", { "includeBelow": true }],
       "f": "vim::Method",
-      "c": "vim::Class",
-      "e": "vim::EntireFile"
+      "c": "vim::Class"
     }
   },
   {
@@ -437,14 +429,14 @@
     "bindings": {
       "c": "vim::CurrentLine",
       "d": "editor::Rename", // zed specific
-      "s": ["vim::PushChangeSurrounds", {}]
+      "s": ["vim::PushOperator", { "ChangeSurrounds": {} }]
     }
   },
   {
     "context": "vim_operator == d",
     "bindings": {
       "d": "vim::CurrentLine",
-      "s": "vim::PushDeleteSurrounds",
+      "s": ["vim::PushOperator", "DeleteSurrounds"],
       "o": "editor::ToggleSelectedDiffHunks", // "d o"
       "p": "editor::RevertSelectedHunks" // "d p"
     }
@@ -483,7 +475,7 @@
     "context": "vim_operator == y",
     "bindings": {
       "y": "vim::CurrentLine",
-      "s": ["vim::PushAddSurrounds", {}]
+      "s": ["vim::PushOperator", { "AddSurrounds": {} }]
     }
   },
   {
@@ -573,34 +565,34 @@
     }
   },
   {
-    "context": "GitPanel || ProjectPanel || CollabPanel || OutlinePanel || ChatPanel || VimControl || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView",
+    "context": "ProjectPanel || CollabPanel || OutlinePanel || ChatPanel || VimControl || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView",
     "bindings": {
       // window related commands (ctrl-w X)
       "ctrl-w": null,
-      "ctrl-w left": "workspace::ActivatePaneLeft",
-      "ctrl-w right": "workspace::ActivatePaneRight",
-      "ctrl-w up": "workspace::ActivatePaneUp",
-      "ctrl-w down": "workspace::ActivatePaneDown",
-      "ctrl-w ctrl-h": "workspace::ActivatePaneLeft",
-      "ctrl-w ctrl-l": "workspace::ActivatePaneRight",
-      "ctrl-w ctrl-k": "workspace::ActivatePaneUp",
-      "ctrl-w ctrl-j": "workspace::ActivatePaneDown",
-      "ctrl-w h": "workspace::ActivatePaneLeft",
-      "ctrl-w l": "workspace::ActivatePaneRight",
-      "ctrl-w k": "workspace::ActivatePaneUp",
-      "ctrl-w j": "workspace::ActivatePaneDown",
-      "ctrl-w shift-left": "workspace::SwapPaneLeft",
-      "ctrl-w shift-right": "workspace::SwapPaneRight",
-      "ctrl-w shift-up": "workspace::SwapPaneUp",
-      "ctrl-w shift-down": "workspace::SwapPaneDown",
-      "ctrl-w shift-h": "workspace::SwapPaneLeft",
-      "ctrl-w shift-l": "workspace::SwapPaneRight",
-      "ctrl-w shift-k": "workspace::SwapPaneUp",
-      "ctrl-w shift-j": "workspace::SwapPaneDown",
-      "ctrl-w >": "vim::ResizePaneRight",
-      "ctrl-w <": "vim::ResizePaneLeft",
-      "ctrl-w -": "vim::ResizePaneDown",
-      "ctrl-w +": "vim::ResizePaneUp",
+      "ctrl-w left": ["workspace::ActivatePaneInDirection", "Left"],
+      "ctrl-w right": ["workspace::ActivatePaneInDirection", "Right"],
+      "ctrl-w up": ["workspace::ActivatePaneInDirection", "Up"],
+      "ctrl-w down": ["workspace::ActivatePaneInDirection", "Down"],
+      "ctrl-w ctrl-h": ["workspace::ActivatePaneInDirection", "Left"],
+      "ctrl-w ctrl-l": ["workspace::ActivatePaneInDirection", "Right"],
+      "ctrl-w ctrl-k": ["workspace::ActivatePaneInDirection", "Up"],
+      "ctrl-w ctrl-j": ["workspace::ActivatePaneInDirection", "Down"],
+      "ctrl-w h": ["workspace::ActivatePaneInDirection", "Left"],
+      "ctrl-w l": ["workspace::ActivatePaneInDirection", "Right"],
+      "ctrl-w k": ["workspace::ActivatePaneInDirection", "Up"],
+      "ctrl-w j": ["workspace::ActivatePaneInDirection", "Down"],
+      "ctrl-w shift-left": ["workspace::SwapPaneInDirection", "Left"],
+      "ctrl-w shift-right": ["workspace::SwapPaneInDirection", "Right"],
+      "ctrl-w shift-up": ["workspace::SwapPaneInDirection", "Up"],
+      "ctrl-w shift-down": ["workspace::SwapPaneInDirection", "Down"],
+      "ctrl-w shift-h": ["workspace::SwapPaneInDirection", "Left"],
+      "ctrl-w shift-l": ["workspace::SwapPaneInDirection", "Right"],
+      "ctrl-w shift-k": ["workspace::SwapPaneInDirection", "Up"],
+      "ctrl-w shift-j": ["workspace::SwapPaneInDirection", "Down"],
+      "ctrl-w >": ["vim::ResizePane", "Widen"],
+      "ctrl-w <": ["vim::ResizePane", "Narrow"],
+      "ctrl-w -": ["vim::ResizePane", "Shorten"],
+      "ctrl-w +": ["vim::ResizePane", "Lengthen"],
       "ctrl-w _": "vim::MaximizePane",
       "ctrl-w =": "vim::ResetPaneSizes",
       "ctrl-w g t": "pane::ActivateNextItem",
@@ -618,12 +610,10 @@
       "ctrl-w shift-s": "pane::SplitHorizontal",
       "ctrl-w ctrl-s": "pane::SplitHorizontal",
       "ctrl-w s": "pane::SplitHorizontal",
-      "ctrl-w ctrl-c": "pane::CloseActiveItem",
-      "ctrl-w c": "pane::CloseActiveItem",
-      "ctrl-w ctrl-q": "pane::CloseActiveItem",
-      "ctrl-w q": "pane::CloseActiveItem",
-      "ctrl-w ctrl-a": "pane::CloseAllItems",
-      "ctrl-w a": "pane::CloseAllItems",
+      "ctrl-w ctrl-c": "pane::CloseAllItems",
+      "ctrl-w c": "pane::CloseAllItems",
+      "ctrl-w ctrl-q": "pane::CloseAllItems",
+      "ctrl-w q": "pane::CloseAllItems",
       "ctrl-w ctrl-o": "workspace::CloseInactiveTabsAndPanes",
       "ctrl-w o": "workspace::CloseInactiveTabsAndPanes",
       "ctrl-w ctrl-n": "workspace::NewFileSplitHorizontal",
@@ -631,7 +621,7 @@
     }
   },
   {
-    "context": "ChangesList || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView || Welcome",
+    "context": "EmptyPane || SharedScreen || MarkdownPreview || KeyContextView || Welcome",
     "bindings": {
       ":": "command_palette::Toggle",
       "g /": "pane::DeploySearch"
@@ -694,22 +684,5 @@
       "shift-x": "git::StageAll",
       "shift-u": "git::UnstageAll"
     }
-  },
-  {
-    "context": "Editor && edit_prediction && !edit_prediction_requires_modifier",
-    "bindings": {
-      // This is identical to the binding in the base keymap, but the vim bindings above to
-      // "vim::Tab" shadow it, so it needs to be bound again.
-      "tab": "editor::AcceptEditPrediction"
-    }
-  },
-  {
-    "context": "os != macos && Editor && edit_prediction",
-    "bindings": {
-      // alt-l is provided as an alternative to tab/alt-tab. and will be displayed in the UI. This
-      // is because alt-tab may not be available, as it is often used for window switching on Linux
-      // and Windows.
-      "alt-l": "editor::AcceptEditPrediction"
-    }
   }
 ]

assets/settings/default.json

@@ -24,8 +24,8 @@
   "base_keymap": "VSCode",
   // Features that can be globally enabled or disabled
   "features": {
-    // Which edit prediction provider to use.
-    "edit_prediction_provider": "copilot"
+    // Which inline completion provider to use.
+    "inline_completion_provider": "copilot"
   },
   // The name of a font to use for rendering text in the editor
   "buffer_font_family": "Zed Plex Mono",
@@ -93,13 +93,6 @@
     // workspace when the centered layout is used.
     "right_padding": 0.2
   },
-  // All settings related to the image viewer.
-  "image_viewer": {
-    // The unit for image file sizes.
-    // By default we're setting it to binary.
-    // The second option is decimal.
-    "unit": "binary"
-  },
   // The key to use for adding multiple cursors
   // Currently "alt" or "cmd_or_ctrl"  (also aliased as
   // "cmd" and "ctrl") are supported.
@@ -168,6 +161,9 @@
   /// Whether to show the signature help after completion or a bracket pair inserted.
   /// If `auto_signature_help` is enabled, this setting will be treated as enabled also.
   "show_signature_help_after_edits": false,
+  /// Whether to show the inline completions next to the completions provided by a language server.
+  /// Only has an effect if inline completion provider supports it.
+  "show_inline_completions_in_menu": true,
   // Whether to show wrap guides (vertical rulers) in the editor.
   // Setting this to true will show a guide at the 'preferred_line_length' value
   // if 'soft_wrap' is set to 'preferred_line_length', and will show any
@@ -200,12 +196,12 @@
   // Otherwise(when `true`), the closing characters are always skipped over and auto-removed
   // no matter how they were inserted.
   "always_treat_brackets_as_autoclosed": false,
-  // Controls whether edit predictions are shown immediately (true)
-  // or manually by triggering `editor::ShowEditPrediction` (false).
-  "show_edit_predictions": true,
-  // Controls whether edit predictions are shown in a given language scope.
+  // Controls whether inline completions are shown immediately (true)
+  // or manually by triggering `editor::ShowInlineCompletion` (false).
+  "show_inline_completions": true,
+  // Controls whether inline completions are shown in a given language scope.
   // Example: ["string", "comment"]
-  "edit_predictions_disabled_in": [],
+  "inline_completions_disabled_in": [],
   // Whether to show tabs and spaces in the editor.
   // This setting can take four values:
   //
@@ -652,15 +648,15 @@
     // There are 5 possible width values:
     //
     // 1. Small: This value is essentially a fixed width.
-    //    "modal_max_width": "small"
+    //    "modal_width": "small"
     // 2. Medium:
-    //    "modal_max_width": "medium"
+    //    "modal_width": "medium"
     // 3. Large:
-    //    "modal_max_width": "large"
+    //    "modal_width": "large"
     // 4. Extra Large:
-    //    "modal_max_width": "xlarge"
+    //    "modal_width": "xlarge"
     // 5. Fullscreen: This value removes any horizontal padding, as it consumes the whole viewport width.
-    //    "modal_max_width": "full"
+    //    "modal_width": "full"
     //
     // Default: small
     "modal_max_width": "small"
@@ -778,25 +774,9 @@
   // 2. Load direnv configuration through the shell hook, works for POSIX shells and fish.
   //      "load_direnv": "shell_hook"
   "load_direnv": "direct",
-  "edit_predictions": {
-    // A list of globs representing files that edit predictions should be disabled for.
-    // There's a sensible default list of globs already included.
-    // Any addition to this list will be merged with the default list.
-    "disabled_globs": [
-      "**/.env*",
-      "**/*.pem",
-      "**/*.key",
-      "**/*.cert",
-      "**/*.crt",
-      "**/secrets.yml"
-    ],
-    // When to show edit predictions previews in buffer.
-    // This setting takes two possible values:
-    // 1. Display inline when there are no language server completions available.
-    //     "mode": "eager_preview"
-    // 2. Display inline when holding modifier key (alt by default).
-    //     "mode": "auto"
-    "mode": "eager_preview"
+  "inline_completions": {
+    // A list of globs representing files that inline completions should be disabled for.
+    "disabled_globs": [".env"]
   },
   // Settings specific to journaling
   "journal": {

assets/themes/one/one.json

@@ -81,7 +81,7 @@
         "terminal.ansi.bright_green": "#4d6140ff",
         "terminal.ansi.dim_green": "#d1e0bfff",
         "terminal.ansi.yellow": "#dec184ff",
-        "terminal.ansi.bright_yellow": "#e5c07bff",
+        "terminal.ansi.bright_yellow": "#786441ff",
         "terminal.ansi.dim_yellow": "#f1dfc1ff",
         "terminal.ansi.blue": "#74ade8ff",
         "terminal.ansi.bright_blue": "#385378ff",
@@ -457,7 +457,7 @@
         "terminal.ansi.bright_green": "#b2cfa9ff",
         "terminal.ansi.dim_green": "#354d2eff",
         "terminal.ansi.yellow": "#dec184ff",
-        "terminal.ansi.bright_yellow": "#826221ff",
+        "terminal.ansi.bright_yellow": "#f1dfc1ff",
         "terminal.ansi.dim_yellow": "#786441ff",
         "terminal.ansi.blue": "#5c78e2ff",
         "terminal.ansi.bright_blue": "#b5baf2ff",

crates/anthropic/src/anthropic.rs

@@ -250,7 +250,7 @@ pub async fn stream_completion(
         .map(|output| output.0)
 }
 
-/// <https://docs.anthropic.com/en/api/rate-limits#response-headers>
+/// https://docs.anthropic.com/en/api/rate-limits#response-headers
 #[derive(Debug)]
 pub struct RateLimitInfo {
     pub requests_limit: usize,
@@ -626,7 +626,7 @@ pub struct ApiError {
 }
 
 /// An Anthropic API error code.
-/// <https://docs.anthropic.com/en/api/errors#http-errors>
+/// https://docs.anthropic.com/en/api/errors#http-errors
 #[derive(Debug, PartialEq, Eq, Clone, Copy, EnumString)]
 #[strum(serialize_all = "snake_case")]
 pub enum ApiErrorCode {

crates/anthropic/src/supported_countries.rs

@@ -3,7 +3,7 @@ use std::sync::LazyLock;
 
 /// Returns whether the given country code is supported by Anthropic.
 ///
-/// <https://www.anthropic.com/supported-countries>
+/// https://www.anthropic.com/supported-countries
 pub fn is_supported_country(country_code: &str) -> bool {
     SUPPORTED_COUNTRIES.contains(&country_code)
 }

crates/assistant/src/assistant_panel.rs

@@ -250,10 +250,10 @@ impl AssistantPanel {
                     )
                     .child(
                         PopoverMenu::new("assistant-panel-popover-menu")
-                            .trigger_with_tooltip(
+                            .trigger(
                                 IconButton::new("menu", IconName::EllipsisVertical)
-                                    .icon_size(IconSize::Small),
-                                Tooltip::text("Toggle Assistant Menu"),
+                                    .icon_size(IconSize::Small)
+                                    .tooltip(Tooltip::text("Toggle Assistant Menu")),
                             )
                             .menu(move |window, cx| {
                                 let zoom_label = if _pane.read(cx).is_zoomed() {

crates/assistant/src/inline_assistant.rs

@@ -1255,7 +1255,7 @@ impl InlineAssistant {
                     editor.scroll_manager.set_forbid_vertical_scroll(true);
                     editor.set_show_scrollbars(false, cx);
                     editor.set_read_only(true);
-                    editor.set_show_edit_predictions(Some(false), window, cx);
+                    editor.set_show_inline_completions(Some(false), window, cx);
                     editor.highlight_rows::<DeletedLines>(
                         Anchor::min()..Anchor::max(),
                         cx.theme().status().deleted_background,
@@ -1595,22 +1595,22 @@ impl Render for PromptEditor {
                         IconButton::new("context", IconName::SettingsAlt)
                             .shape(IconButtonShape::Square)
                             .icon_size(IconSize::Small)
-                            .icon_color(Color::Muted),
-                        move |window, cx| {
-                            Tooltip::with_meta(
-                                format!(
-                                    "Using {}",
-                                    LanguageModelRegistry::read_global(cx)
-                                        .active_model()
-                                        .map(|model| model.name().0)
-                                        .unwrap_or_else(|| "No model selected".into()),
-                                ),
-                                None,
-                                "Change Model",
-                                window,
-                                cx,
-                            )
-                        },
+                            .icon_color(Color::Muted)
+                            .tooltip(move |window, cx| {
+                                Tooltip::with_meta(
+                                    format!(
+                                        "Using {}",
+                                        LanguageModelRegistry::read_global(cx)
+                                            .active_model()
+                                            .map(|model| model.name().0)
+                                            .unwrap_or_else(|| "No model selected".into()),
+                                    ),
+                                    None,
+                                    "Change Model",
+                                    window,
+                                    cx,
+                                )
+                            }),
                     ))
                     .map(|el| {
                         let CodegenStatus::Error(error) = self.codegen.read(cx).status(cx) else {

crates/assistant/src/terminal_inline_assistant.rs

@@ -646,22 +646,22 @@ impl Render for PromptEditor {
                         IconButton::new("context", IconName::SettingsAlt)
                             .shape(IconButtonShape::Square)
                             .icon_size(IconSize::Small)
-                            .icon_color(Color::Muted),
-                        move |window, cx| {
-                            Tooltip::with_meta(
-                                format!(
-                                    "Using {}",
-                                    LanguageModelRegistry::read_global(cx)
-                                        .active_model()
-                                        .map(|model| model.name().0)
-                                        .unwrap_or_else(|| "No model selected".into()),
-                                ),
-                                None,
-                                "Change Model",
-                                window,
-                                cx,
-                            )
-                        },
+                            .icon_color(Color::Muted)
+                            .tooltip(move |window, cx| {
+                                Tooltip::with_meta(
+                                    format!(
+                                        "Using {}",
+                                        LanguageModelRegistry::read_global(cx)
+                                            .active_model()
+                                            .map(|model| model.name().0)
+                                            .unwrap_or_else(|| "No model selected".into()),
+                                    ),
+                                    None,
+                                    "Change Model",
+                                    window,
+                                    cx,
+                                )
+                            }),
                     ))
                     .children(
                         if let CodegenStatus::Error(error) = &self.codegen.read(cx).status {

crates/assistant2/src/assistant_model_selector.rs

@@ -74,16 +74,16 @@ impl Render for AssistantModelSelector {
                                 .color(Color::Muted)
                                 .size(IconSize::XSmall),
                         ),
-                ),
-            move |window, cx| {
-                Tooltip::for_action_in(
-                    "Change Model",
-                    &ToggleModelSelector,
-                    &focus_handle,
-                    window,
-                    cx,
                 )
-            },
+                .tooltip(move |window, cx| {
+                    Tooltip::for_action_in(
+                        "Change Model",
+                        &ToggleModelSelector,
+                        &focus_handle,
+                        window,
+                        cx,
+                    )
+                }),
         )
         .with_handle(self.menu_handle.clone())
     }

crates/assistant2/src/assistant_panel.rs

@@ -442,7 +442,7 @@ impl AssistantPanel {
 
     fn handle_assistant_configuration_event(
         &mut self,
-        _entity: &Entity<AssistantConfiguration>,
+        _model: &Entity<AssistantConfiguration>,
         event: &AssistantConfigurationEvent,
         window: &mut Window,
         cx: &mut Context<Self>,
@@ -660,11 +660,11 @@ impl AssistantPanel {
                     .gap(DynamicSpacing::Base02.rems(cx))
                     .child(
                         PopoverMenu::new("assistant-toolbar-new-popover-menu")
-                            .trigger_with_tooltip(
+                            .trigger(
                                 IconButton::new("new", IconName::Plus)
                                     .icon_size(IconSize::Small)
-                                    .style(ButtonStyle::Subtle),
-                                Tooltip::text("New…"),
+                                    .style(ButtonStyle::Subtle)
+                                    .tooltip(Tooltip::text("New…")),
                             )
                             .anchor(Corner::TopRight)
                             .with_handle(self.new_item_context_menu_handle.clone())
@@ -677,11 +677,11 @@ impl AssistantPanel {
                     )
                     .child(
                         PopoverMenu::new("assistant-toolbar-history-popover-menu")
-                            .trigger_with_tooltip(
+                            .trigger(
                                 IconButton::new("open-history", IconName::HistoryRerun)
                                     .icon_size(IconSize::Small)
-                                    .style(ButtonStyle::Subtle),
-                                Tooltip::text("History…"),
+                                    .style(ButtonStyle::Subtle)
+                                    .tooltip(Tooltip::text("History…")),
                             )
                             .anchor(Corner::TopRight)
                             .with_handle(self.open_history_context_menu_handle.clone())

crates/assistant2/src/context_store.rs

@@ -79,8 +79,8 @@ impl ContextStore {
                 project.open_buffer(project_path.clone(), cx)
             })?;
 
-            let buffer_entity = open_buffer_task.await?;
-            let buffer_id = this.update(&mut cx, |_, cx| buffer_entity.read(cx).remote_id())?;
+            let buffer_model = open_buffer_task.await?;
+            let buffer_id = this.update(&mut cx, |_, cx| buffer_model.read(cx).remote_id())?;
 
             let already_included = this.update(&mut cx, |this, _cx| {
                 match this.will_include_buffer(buffer_id, &project_path.path) {
@@ -98,10 +98,10 @@ impl ContextStore {
             }
 
             let (buffer_info, text_task) = this.update(&mut cx, |_, cx| {
-                let buffer = buffer_entity.read(cx);
+                let buffer = buffer_model.read(cx);
                 collect_buffer_info_and_text(
                     project_path.path.clone(),
-                    buffer_entity,
+                    buffer_model,
                     buffer,
                     cx.to_async(),
                 )
@@ -119,18 +119,18 @@ impl ContextStore {
 
     pub fn add_file_from_buffer(
         &mut self,
-        buffer_entity: Entity<Buffer>,
+        buffer_model: Entity<Buffer>,
         cx: &mut Context<Self>,
     ) -> Task<Result<()>> {
         cx.spawn(|this, mut cx| async move {
             let (buffer_info, text_task) = this.update(&mut cx, |_, cx| {
-                let buffer = buffer_entity.read(cx);
+                let buffer = buffer_model.read(cx);
                 let Some(file) = buffer.file() else {
                     return Err(anyhow!("Buffer has no path."));
                 };
                 Ok(collect_buffer_info_and_text(
                     file.path().clone(),
-                    buffer_entity,
+                    buffer_model,
                     buffer,
                     cx.to_async(),
                 ))
@@ -207,11 +207,11 @@ impl ContextStore {
             let mut buffer_infos = Vec::new();
             let mut text_tasks = Vec::new();
             this.update(&mut cx, |_, cx| {
-                for (path, buffer_entity) in files.into_iter().zip(buffers) {
-                    let buffer_entity = buffer_entity?;
-                    let buffer = buffer_entity.read(cx);
+                for (path, buffer_model) in files.into_iter().zip(buffers) {
+                    let buffer_model = buffer_model?;
+                    let buffer = buffer_model.read(cx);
                     let (buffer_info, text_task) =
-                        collect_buffer_info_and_text(path, buffer_entity, buffer, cx.to_async());
+                        collect_buffer_info_and_text(path, buffer_model, buffer, cx.to_async());
                     buffer_infos.push(buffer_info);
                     text_tasks.push(text_task);
                 }
@@ -429,7 +429,7 @@ pub enum FileInclusion {
 
 // ContextBuffer without text.
 struct BufferInfo {
-    buffer_entity: Entity<Buffer>,
+    buffer_model: Entity<Buffer>,
     id: BufferId,
     version: clock::Global,
 }
@@ -437,7 +437,7 @@ struct BufferInfo {
 fn make_context_buffer(info: BufferInfo, text: SharedString) -> ContextBuffer {
     ContextBuffer {
         id: info.id,
-        buffer: info.buffer_entity,
+        buffer: info.buffer_model,
         version: info.version,
         text,
     }
@@ -445,13 +445,13 @@ fn make_context_buffer(info: BufferInfo, text: SharedString) -> ContextBuffer {
 
 fn collect_buffer_info_and_text(
     path: Arc<Path>,
-    buffer_entity: Entity<Buffer>,
+    buffer_model: Entity<Buffer>,
     buffer: &Buffer,
     cx: AsyncApp,
 ) -> (BufferInfo, Task<SharedString>) {
     let buffer_info = BufferInfo {
         id: buffer.remote_id(),
-        buffer_entity,
+        buffer_model,
         version: buffer.version(),
     };
     // Important to collect version at the same time as content so that staleness logic is correct.

crates/assistant2/src/context_strip.rs

@@ -92,8 +92,8 @@ impl ContextStrip {
         let active_item = workspace.read(cx).active_item(cx)?;
 
         let editor = active_item.to_any().downcast::<Editor>().ok()?.read(cx);
-        let active_buffer_entity = editor.buffer().read(cx).as_singleton()?;
-        let active_buffer = active_buffer_entity.read(cx);
+        let active_buffer_model = editor.buffer().read(cx).as_singleton()?;
+        let active_buffer = active_buffer_model.read(cx);
 
         let path = active_buffer.file()?.path();
 
@@ -115,7 +115,7 @@ impl ContextStrip {
 
         Some(SuggestedContext::File {
             name,
-            buffer: active_buffer_entity.downgrade(),
+            buffer: active_buffer_model.downgrade(),
             icon_path,
         })
     }
@@ -393,9 +393,9 @@ impl Render for ContextStrip {
             .on_action(cx.listener(Self::remove_focused_context))
             .on_action(cx.listener(Self::accept_suggested_context))
             .on_children_prepainted({
-                let entity = cx.entity().downgrade();
+                let model = cx.entity().downgrade();
                 move |children_bounds, _window, cx| {
-                    entity
+                    model
                         .update(cx, |this, _| {
                             this.children_bounds = Some(children_bounds);
                         })
@@ -411,22 +411,22 @@ impl Render for ContextStrip {
 
                         Some(context_picker.clone())
                     })
-                    .trigger_with_tooltip(
+                    .trigger(
                         IconButton::new("add-context", IconName::Plus)
                             .icon_size(IconSize::Small)
-                            .style(ui::ButtonStyle::Filled),
-                        {
-                            let focus_handle = focus_handle.clone();
-                            move |window, cx| {
-                                Tooltip::for_action_in(
-                                    "Add Context",
-                                    &ToggleContextPicker,
-                                    &focus_handle,
-                                    window,
-                                    cx,
-                                )
-                            }
-                        },
+                            .style(ui::ButtonStyle::Filled)
+                            .tooltip({
+                                let focus_handle = focus_handle.clone();
+                                move |window, cx| {
+                                    Tooltip::for_action_in(
+                                        "Add Context",
+                                        &ToggleContextPicker,
+                                        &focus_handle,
+                                        window,
+                                        cx,
+                                    )
+                                }
+                            }),
                     )
                     .attach(gpui::Corner::TopLeft)
                     .anchor(gpui::Corner::BottomLeft)

crates/assistant2/src/inline_assistant.rs

@@ -1345,7 +1345,7 @@ impl InlineAssistant {
                     editor.scroll_manager.set_forbid_vertical_scroll(true);
                     editor.set_show_scrollbars(false, cx);
                     editor.set_read_only(true);
-                    editor.set_show_edit_predictions(Some(false), window, cx);
+                    editor.set_show_inline_completions(Some(false), window, cx);
                     editor.highlight_rows::<DeletedLines>(
                         Anchor::min()..Anchor::max(),
                         cx.theme().status().deleted_background,

crates/assistant2/src/message_editor.rs

@@ -12,7 +12,6 @@ use language_model_selector::LanguageModelSelector;
 use rope::Point;
 use settings::Settings;
 use std::time::Duration;
-use text::Bias;
 use theme::ThemeSettings;
 use ui::{
     prelude::*, ButtonLike, KeyBinding, PopoverMenu, PopoverMenuHandle, Switch, TintColor, Tooltip,
@@ -240,10 +239,7 @@ impl MessageEditor {
                     let snapshot = editor.buffer().read(cx).snapshot(cx);
                     let newest_cursor = editor.selections.newest::<Point>(cx).head();
                     if newest_cursor.column > 0 {
-                        let behind_cursor = snapshot.clip_point(
-                            Point::new(newest_cursor.row, newest_cursor.column - 1),
-                            Bias::Left,
-                        );
+                        let behind_cursor = Point::new(newest_cursor.row, newest_cursor.column - 1);
                         let char_behind_cursor = snapshot.chars_at(behind_cursor).next();
                         if char_behind_cursor == Some('@') {
                             self.inline_context_picker_menu_handle.show(window, cx);

crates/assistant_context_editor/src/context_editor.rs

@@ -459,7 +459,7 @@ impl ContextEditor {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        if self.editor.read(cx).has_visible_completions_menu() {
+        if self.editor.read(cx).has_active_completions_menu() {
             return;
         }
 
@@ -832,13 +832,12 @@ impl ContextEditor {
                 let render_block: RenderBlock = Arc::new({
                     let this = this.clone();
                     let patch_range = range.clone();
-                    move |cx: &mut BlockContext| {
+                    move |cx: &mut BlockContext<'_, '_>| {
                         let max_width = cx.max_width;
                         let gutter_width = cx.gutter_dimensions.full_width();
                         let block_id = cx.block_id;
                         let selected = cx.selected;
-                        let window = &mut cx.window;
-                        this.update(cx.app, |this, cx| {
+                        this.update_in(cx, |this, window, cx| {
                             this.render_patch_block(
                                 patch_range.clone(),
                                 max_width,
@@ -2359,8 +2358,8 @@ impl ContextEditor {
                 .icon(IconName::Plus)
                 .icon_size(IconSize::Small)
                 .icon_color(Color::Muted)
-                .icon_position(IconPosition::Start),
-            Tooltip::text("Type / to insert via keyboard"),
+                .icon_position(IconPosition::Start)
+                .tooltip(Tooltip::text("Type / to insert via keyboard")),
         )
     }
 
@@ -3323,10 +3322,10 @@ impl Render for ContextEditorToolbarItem {
                                         .color(Color::Muted)
                                         .size(IconSize::XSmall),
                                 ),
-                        ),
-                    move |window, cx| {
-                        Tooltip::for_action("Change Model", &ToggleModelSelector, window, cx)
-                    },
+                        )
+                        .tooltip(move |window, cx| {
+                            Tooltip::for_action("Change Model", &ToggleModelSelector, window, cx)
+                        }),
                 )
                 .with_handle(self.language_model_selector_menu_handle.clone()),
             )

crates/assistant_context_editor/src/context_store.rs

@@ -31,11 +31,11 @@ use std::{
 use util::{ResultExt, TryFutureExt};
 
 pub(crate) fn init(client: &AnyProtoClient) {
-    client.add_entity_message_handler(ContextStore::handle_advertise_contexts);
-    client.add_entity_request_handler(ContextStore::handle_open_context);
-    client.add_entity_request_handler(ContextStore::handle_create_context);
-    client.add_entity_message_handler(ContextStore::handle_update_context);
-    client.add_entity_request_handler(ContextStore::handle_synchronize_contexts);
+    client.add_model_message_handler(ContextStore::handle_advertise_contexts);
+    client.add_model_request_handler(ContextStore::handle_open_context);
+    client.add_model_request_handler(ContextStore::handle_create_context);
+    client.add_model_message_handler(ContextStore::handle_update_context);
+    client.add_model_request_handler(ContextStore::handle_synchronize_contexts);
 }
 
 #[derive(Clone)]
@@ -144,9 +144,11 @@ impl ContextStore {
                 this.handle_project_changed(project.clone(), cx);
                 this.synchronize_contexts(cx);
                 this.register_context_server_handlers(cx);
-                this.reload(cx).detach_and_log_err(cx);
                 this
             })?;
+            this.update(&mut cx, |this, cx| this.reload(cx))?
+                .await
+                .log_err();
 
             Ok(this)
         })
@@ -310,7 +312,7 @@ impl ContextStore {
                 .client
                 .subscribe_to_entity(remote_id)
                 .log_err()
-                .map(|subscription| subscription.set_entity(&cx.entity(), &mut cx.to_async()));
+                .map(|subscription| subscription.set_model(&cx.entity(), &mut cx.to_async()));
             self.advertise_contexts(cx);
         } else {
             self.client_subscription = None;

crates/assistant_context_editor/src/slash_command.rs

@@ -5,7 +5,7 @@ use assistant_slash_command::{AfterCompletion, SlashCommandLine, SlashCommandWor
 use editor::{CompletionProvider, Editor};
 use fuzzy::{match_strings, StringMatchCandidate};
 use gpui::{App, Context, Entity, Task, WeakEntity, Window};
-use language::{Anchor, Buffer, CompletionDocumentation, LanguageServerId, ToPoint};
+use language::{Anchor, Buffer, Documentation, LanguageServerId, ToPoint};
 use parking_lot::Mutex;
 use project::CompletionIntent;
 use rope::Point;
@@ -120,9 +120,7 @@ impl SlashCommandCompletionProvider {
                                 });
                         Some(project::Completion {
                             old_range: name_range.clone(),
-                            documentation: Some(CompletionDocumentation::SingleLine(
-                                command.description(),
-                            )),
+                            documentation: Some(Documentation::SingleLine(command.description())),
                             new_text,
                             label: command.label(cx),
                             server_id: LanguageServerId(0),

crates/assistant_context_editor/src/slash_command_picker.rs

@@ -1,22 +1,17 @@
 use std::sync::Arc;
 
 use assistant_slash_command::SlashCommandWorkingSet;
-use gpui::{AnyElement, AnyView, DismissEvent, SharedString, Task, WeakEntity};
+use gpui::{AnyElement, DismissEvent, SharedString, Task, WeakEntity};
 use picker::{Picker, PickerDelegate, PickerEditorPosition};
 use ui::{prelude::*, ListItem, ListItemSpacing, PopoverMenu, PopoverTrigger, Tooltip};
 
 use crate::context_editor::ContextEditor;
 
 #[derive(IntoElement)]
-pub(super) struct SlashCommandSelector<T, TT>
-where
-    T: PopoverTrigger + ButtonCommon,
-    TT: Fn(&mut Window, &mut App) -> AnyView + 'static,
-{
+pub(super) struct SlashCommandSelector<T: PopoverTrigger> {
     working_set: Arc<SlashCommandWorkingSet>,
     active_context_editor: WeakEntity<ContextEditor>,
     trigger: T,
-    tooltip: TT,
 }
 
 #[derive(Clone)]
@@ -53,22 +48,16 @@ pub(crate) struct SlashCommandDelegate {
     selected_index: usize,
 }
 
-impl<T, TT> SlashCommandSelector<T, TT>
-where
-    T: PopoverTrigger + ButtonCommon,
-    TT: Fn(&mut Window, &mut App) -> AnyView + 'static,
-{
+impl<T: PopoverTrigger> SlashCommandSelector<T> {
     pub(crate) fn new(
         working_set: Arc<SlashCommandWorkingSet>,
         active_context_editor: WeakEntity<ContextEditor>,
         trigger: T,
-        tooltip: TT,
     ) -> Self {
         SlashCommandSelector {
             working_set,
             active_context_editor,
             trigger,
-            tooltip,
         }
     }
 }
@@ -252,11 +241,7 @@ impl PickerDelegate for SlashCommandDelegate {
     }
 }
 
-impl<T, TT> RenderOnce for SlashCommandSelector<T, TT>
-where
-    T: PopoverTrigger + ButtonCommon,
-    TT: Fn(&mut Window, &mut App) -> AnyView + 'static,
-{
+impl<T: PopoverTrigger> RenderOnce for SlashCommandSelector<T> {
     fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
         let all_models = self
             .working_set
@@ -337,7 +322,7 @@ where
             .ok();
         PopoverMenu::new("model-switcher")
             .menu(move |_window, _cx| Some(picker_view.clone()))
-            .trigger_with_tooltip(self.trigger, self.tooltip)
+            .trigger(self.trigger)
             .attach(gpui::Corner::TopLeft)
             .anchor(gpui::Corner::BottomLeft)
             .offset(gpui::Point {

crates/assistant_settings/src/assistant_settings.rs

@@ -434,7 +434,7 @@ pub struct LegacyAssistantSettingsContent {
     pub default_open_ai_model: Option<OpenAiModel>,
     /// OpenAI API base URL to use when creating new chats.
     ///
-    /// Default: <https://api.openai.com/v1>
+    /// Default: https://api.openai.com/v1
     pub openai_api_url: Option<String>,
 }
 

crates/assistant_slash_commands/src/file_command.rs

@@ -323,14 +323,7 @@ fn collect_files(
                         )))?;
                         directory_stack.push(entry.path.clone());
                     } else {
-                        // todo(windows)
-                        // Potential bug: this assumes that the path separator is always `\` on Windows
-                        let entry_name = format!(
-                            "{}{}{}",
-                            prefix_paths,
-                            std::path::MAIN_SEPARATOR_STR,
-                            &filename
-                        );
+                        let entry_name = format!("{}/{}", prefix_paths, &filename);
                         events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
                             icon: IconName::Folder,
                             label: entry_name.clone().into(),
@@ -462,7 +455,6 @@ mod custom_path_matcher {
     use std::{fmt::Debug as _, path::Path};
 
     use globset::{Glob, GlobSet, GlobSetBuilder};
-    use util::paths::SanitizedPath;
 
     #[derive(Clone, Debug, Default)]
     pub struct PathMatcher {
@@ -489,7 +481,7 @@ mod custom_path_matcher {
         pub fn new(globs: &[String]) -> Result<Self, globset::Error> {
             let globs = globs
                 .into_iter()
-                .map(|glob| Glob::new(&SanitizedPath::from(glob).to_glob_string()))
+                .map(|glob| Glob::new(&glob))
                 .collect::<Result<Vec<_>, _>>()?;
             let sources = globs.iter().map(|glob| glob.glob().to_owned()).collect();
             let sources_with_trailing_slash = globs
@@ -515,9 +507,7 @@ mod custom_path_matcher {
                 .zip(self.sources_with_trailing_slash.iter())
                 .any(|(source, with_slash)| {
                     let as_bytes = other_path.as_os_str().as_encoded_bytes();
-                    // todo(windows)
-                    // Potential bug: this assumes that the path separator is always `\` on Windows
-                    let with_slash = if source.ends_with(std::path::MAIN_SEPARATOR_STR) {
+                    let with_slash = if source.ends_with("/") {
                         source.as_bytes()
                     } else {
                         with_slash.as_bytes()
@@ -579,7 +569,6 @@ mod test {
     use serde_json::json;
     use settings::SettingsStore;
     use smol::stream::StreamExt;
-    use util::{path, separator};
 
     use super::collect_files;
 
@@ -603,7 +592,7 @@ mod test {
         let fs = FakeFs::new(cx.executor());
 
         fs.insert_tree(
-            path!("/root"),
+            "/root",
             json!({
                 "dir": {
                     "subdir": {
@@ -618,7 +607,7 @@ mod test {
         )
         .await;
 
-        let project = Project::test(fs, [path!("/root").as_ref()], cx).await;
+        let project = Project::test(fs, ["/root".as_ref()], cx).await;
 
         let result_1 =
             cx.update(|cx| collect_files(project.clone(), &["root/dir".to_string()], cx));
@@ -626,7 +615,7 @@ mod test {
             .await
             .unwrap();
 
-        assert!(result_1.text.starts_with(separator!("root/dir")));
+        assert!(result_1.text.starts_with("root/dir"));
         // 4 files + 2 directories
         assert_eq!(result_1.sections.len(), 6);
 
@@ -642,7 +631,7 @@ mod test {
             cx.update(|cx| collect_files(project.clone(), &["root/dir*".to_string()], cx).boxed());
         let result = SlashCommandOutput::from_event_stream(result).await.unwrap();
 
-        assert!(result.text.starts_with(separator!("root/dir")));
+        assert!(result.text.starts_with("root/dir"));
         // 5 files + 2 directories
         assert_eq!(result.sections.len(), 7);
 
@@ -656,7 +645,7 @@ mod test {
         let fs = FakeFs::new(cx.executor());
 
         fs.insert_tree(
-            path!("/zed"),
+            "/zed",
             json!({
                 "assets": {
                     "dir1": {
@@ -681,7 +670,7 @@ mod test {
         )
         .await;
 
-        let project = Project::test(fs, [path!("/zed").as_ref()], cx).await;
+        let project = Project::test(fs, ["/zed".as_ref()], cx).await;
 
         let result =
             cx.update(|cx| collect_files(project.clone(), &["zed/assets/themes".to_string()], cx));
@@ -690,36 +679,27 @@ mod test {
             .unwrap();
 
         // Sanity check
-        assert!(result.text.starts_with(separator!("zed/assets/themes\n")));
+        assert!(result.text.starts_with("zed/assets/themes\n"));
         assert_eq!(result.sections.len(), 7);
 
         // Ensure that full file paths are included in the real output
-        assert!(result
-            .text
-            .contains(separator!("zed/assets/themes/andromeda/LICENSE")));
-        assert!(result
-            .text
-            .contains(separator!("zed/assets/themes/ayu/LICENSE")));
-        assert!(result
-            .text
-            .contains(separator!("zed/assets/themes/summercamp/LICENSE")));
+        assert!(result.text.contains("zed/assets/themes/andromeda/LICENSE"));
+        assert!(result.text.contains("zed/assets/themes/ayu/LICENSE"));
+        assert!(result.text.contains("zed/assets/themes/summercamp/LICENSE"));
 
         assert_eq!(result.sections[5].label, "summercamp");
 
         // Ensure that things are in descending order, with properly relativized paths
         assert_eq!(
             result.sections[0].label,
-            separator!("zed/assets/themes/andromeda/LICENSE")
+            "zed/assets/themes/andromeda/LICENSE"
         );
         assert_eq!(result.sections[1].label, "andromeda");
-        assert_eq!(
-            result.sections[2].label,
-            separator!("zed/assets/themes/ayu/LICENSE")
-        );
+        assert_eq!(result.sections[2].label, "zed/assets/themes/ayu/LICENSE");
         assert_eq!(result.sections[3].label, "ayu");
         assert_eq!(
             result.sections[4].label,
-            separator!("zed/assets/themes/summercamp/LICENSE")
+            "zed/assets/themes/summercamp/LICENSE"
         );
 
         // Ensure that the project lasts until after the last await
@@ -732,7 +712,7 @@ mod test {
         let fs = FakeFs::new(cx.executor());
 
         fs.insert_tree(
-            path!("/zed"),
+            "/zed",
             json!({
                 "assets": {
                     "themes": {
@@ -752,7 +732,7 @@ mod test {
         )
         .await;
 
-        let project = Project::test(fs, [path!("/zed").as_ref()], cx).await;
+        let project = Project::test(fs, ["/zed".as_ref()], cx).await;
 
         let result =
             cx.update(|cx| collect_files(project.clone(), &["zed/assets/themes".to_string()], cx));
@@ -760,29 +740,26 @@ mod test {
             .await
             .unwrap();
 
-        assert!(result.text.starts_with(separator!("zed/assets/themes\n")));
-        assert_eq!(
-            result.sections[0].label,
-            separator!("zed/assets/themes/LICENSE")
-        );
+        assert!(result.text.starts_with("zed/assets/themes\n"));
+        assert_eq!(result.sections[0].label, "zed/assets/themes/LICENSE");
         assert_eq!(
             result.sections[1].label,
-            separator!("zed/assets/themes/summercamp/LICENSE")
+            "zed/assets/themes/summercamp/LICENSE"
         );
         assert_eq!(
             result.sections[2].label,
-            separator!("zed/assets/themes/summercamp/subdir/LICENSE")
+            "zed/assets/themes/summercamp/subdir/LICENSE"
         );
         assert_eq!(
             result.sections[3].label,
-            separator!("zed/assets/themes/summercamp/subdir/subsubdir/LICENSE")
+            "zed/assets/themes/summercamp/subdir/subsubdir/LICENSE"
         );
         assert_eq!(result.sections[4].label, "subsubdir");
         assert_eq!(result.sections[5].label, "subdir");
         assert_eq!(result.sections[6].label, "summercamp");
-        assert_eq!(result.sections[7].label, separator!("zed/assets/themes"));
+        assert_eq!(result.sections[7].label, "zed/assets/themes");
 
-        assert_eq!(result.text, separator!("zed/assets/themes\n```zed/assets/themes/LICENSE\n1\n```\n\nsummercamp\n```zed/assets/themes/summercamp/LICENSE\n1\n```\n\nsubdir\n```zed/assets/themes/summercamp/subdir/LICENSE\n1\n```\n\nsubsubdir\n```zed/assets/themes/summercamp/subdir/subsubdir/LICENSE\n3\n```\n\n"));
+        assert_eq!(result.text, "zed/assets/themes\n```zed/assets/themes/LICENSE\n1\n```\n\nsummercamp\n```zed/assets/themes/summercamp/LICENSE\n1\n```\n\nsubdir\n```zed/assets/themes/summercamp/subdir/LICENSE\n1\n```\n\nsubsubdir\n```zed/assets/themes/summercamp/subdir/subsubdir/LICENSE\n3\n```\n\n");
 
         // Ensure that the project lasts until after the last await
         drop(project);

crates/auto_update_ui/src/auto_update_ui.rs

@@ -9,7 +9,7 @@ use release_channel::{AppVersion, ReleaseChannel};
 use serde::Deserialize;
 use smol::io::AsyncReadExt;
 use util::ResultExt as _;
-use workspace::notifications::{show_app_notification, NotificationId};
+use workspace::notifications::NotificationId;
 use workspace::Workspace;
 
 use crate::update_notification::UpdateNotification;
@@ -17,7 +17,6 @@ use crate::update_notification::UpdateNotification;
 actions!(auto_update, [ViewReleaseNotesLocally]);
 
 pub fn init(cx: &mut App) {
-    notify_if_app_was_updated(cx);
     cx.observe_new(|workspace: &mut Workspace, _window, _cx| {
         workspace.register_action(|workspace, _: &ViewReleaseNotesLocally, window, cx| {
             view_release_notes_locally(workspace, window, cx);
@@ -125,35 +124,31 @@ fn view_release_notes_locally(
         .detach();
 }
 
-/// Shows a notification across all workspaces if an update was previously automatically installed
-/// and this notification had not yet been shown.
-pub fn notify_if_app_was_updated(cx: &mut App) {
-    let Some(updater) = AutoUpdater::get(cx) else {
-        return;
-    };
+pub fn notify_of_any_new_update(window: &mut Window, cx: &mut Context<Workspace>) -> Option<()> {
+    let updater = AutoUpdater::get(cx)?;
     let version = updater.read(cx).current_version();
     let should_show_notification = updater.read(cx).should_show_update_notification(cx);
 
-    cx.spawn(|cx| async move {
+    cx.spawn_in(window, |workspace, mut cx| async move {
         let should_show_notification = should_show_notification.await?;
         if should_show_notification {
-            cx.update(|cx| {
-                show_app_notification(
+            workspace.update(&mut cx, |workspace, cx| {
+                let workspace_handle = workspace.weak_handle();
+                workspace.show_notification(
                     NotificationId::unique::<UpdateNotification>(),
                     cx,
-                    move |cx| {
-                        let workspace_handle = cx.entity().downgrade();
-                        cx.new(|_| UpdateNotification::new(version, workspace_handle))
-                    },
+                    |cx| cx.new(|_| UpdateNotification::new(version, workspace_handle)),
                 );
                 updater.update(cx, |updater, cx| {
                     updater
                         .set_should_show_update_notification(false, cx)
                         .detach_and_log_err(cx);
-                })
+                });
             })?;
         }
         anyhow::Ok(())
     })
     .detach();
+
+    None
 }

crates/buffer_diff/Cargo.toml

@@ -1,37 +0,0 @@
-[package]
-name = "buffer_diff"
-version = "0.1.0"
-edition.workspace = true
-publish.workspace = true
-license = "GPL-3.0-or-later"
-
-[lints]
-workspace = true
-
-[lib]
-path = "src/buffer_diff.rs"
-
-[features]
-test-support = []
-
-[dependencies]
-anyhow.workspace = true
-futures.workspace = true
-git2.workspace = true
-gpui.workspace = true
-language.workspace = true
-log.workspace = true
-rope.workspace = true
-sum_tree.workspace = true
-text.workspace = true
-util.workspace = true
-
-[dev-dependencies]
-ctor.workspace = true
-env_logger.workspace = true
-gpui = { workspace = true, features = ["test-support"] }
-pretty_assertions.workspace = true
-rand.workspace = true
-serde_json.workspace = true
-text = { workspace = true, features = ["test-support"] }
-unindent.workspace = true

crates/call/src/cross_platform/room.rs

@@ -532,10 +532,6 @@ impl Room {
         &self.local_participant
     }
 
-    pub fn local_participant_user(&self, cx: &App) -> Option<Arc<User>> {
-        self.user_store.read(cx).current_user()
-    }
-
     pub fn remote_participants(&self) -> &BTreeMap<u64, RemoteParticipant> {
         &self.remote_participants
     }

crates/call/src/macos/room.rs

@@ -588,10 +588,6 @@ impl Room {
         &self.local_participant
     }
 
-    pub fn local_participant_user(&self, cx: &App) -> Option<Arc<User>> {
-        self.user_store.read(cx).current_user()
-    }
-
     pub fn remote_participants(&self) -> &BTreeMap<u64, RemoteParticipant> {
         &self.remote_participants
     }

crates/channel/src/channel_buffer.rs

@@ -15,8 +15,8 @@ use util::ResultExt;
 pub const ACKNOWLEDGE_DEBOUNCE_INTERVAL: Duration = Duration::from_millis(250);
 
 pub(crate) fn init(client: &AnyProtoClient) {
-    client.add_entity_message_handler(ChannelBuffer::handle_update_channel_buffer);
-    client.add_entity_message_handler(ChannelBuffer::handle_update_channel_buffer_collaborators);
+    client.add_model_message_handler(ChannelBuffer::handle_update_channel_buffer);
+    client.add_model_message_handler(ChannelBuffer::handle_update_channel_buffer_collaborators);
 }
 
 pub struct ChannelBuffer {
@@ -81,7 +81,7 @@ impl ChannelBuffer {
                 collaborators: Default::default(),
                 acknowledge_task: None,
                 channel_id: channel.id,
-                subscription: Some(subscription.set_entity(&cx.entity(), &mut cx.to_async())),
+                subscription: Some(subscription.set_model(&cx.entity(), &mut cx.to_async())),
                 user_store,
                 channel_store,
             };

crates/channel/src/channel_chat.rs

@@ -95,9 +95,9 @@ pub enum ChannelChatEvent {
 
 impl EventEmitter<ChannelChatEvent> for ChannelChat {}
 pub fn init(client: &AnyProtoClient) {
-    client.add_entity_message_handler(ChannelChat::handle_message_sent);
-    client.add_entity_message_handler(ChannelChat::handle_message_removed);
-    client.add_entity_message_handler(ChannelChat::handle_message_updated);
+    client.add_model_message_handler(ChannelChat::handle_message_sent);
+    client.add_model_message_handler(ChannelChat::handle_message_removed);
+    client.add_model_message_handler(ChannelChat::handle_message_updated);
 }
 
 impl ChannelChat {
@@ -132,7 +132,7 @@ impl ChannelChat {
                 last_acknowledged_id: None,
                 rng: StdRng::from_entropy(),
                 first_loaded_message_id: None,
-                _subscription: subscription.set_entity(&cx.entity(), &mut cx.to_async()),
+                _subscription: subscription.set_model(&cx.entity(), &mut cx.to_async()),
             }
         })?;
         Self::handle_loaded_messages(

crates/channel/src/channel_store.rs

@@ -39,8 +39,8 @@ pub struct ChannelStore {
     channel_states: HashMap<ChannelId, ChannelState>,
     outgoing_invites: HashSet<(ChannelId, UserId)>,
     update_channels_tx: mpsc::UnboundedSender<proto::UpdateChannels>,
-    opened_buffers: HashMap<ChannelId, OpenEntityHandle<ChannelBuffer>>,
-    opened_chats: HashMap<ChannelId, OpenEntityHandle<ChannelChat>>,
+    opened_buffers: HashMap<ChannelId, OpenedModelHandle<ChannelBuffer>>,
+    opened_chats: HashMap<ChannelId, OpenedModelHandle<ChannelChat>>,
     client: Arc<Client>,
     did_subscribe: bool,
     user_store: Entity<UserStore>,
@@ -142,7 +142,7 @@ pub enum ChannelEvent {
 
 impl EventEmitter<ChannelEvent> for ChannelStore {}
 
-enum OpenEntityHandle<E> {
+enum OpenedModelHandle<E> {
     Open(WeakEntity<E>),
     Loading(Shared<Task<Result<Entity<E>, Arc<anyhow::Error>>>>),
 }
@@ -292,7 +292,7 @@ impl ChannelStore {
 
     pub fn has_open_channel_buffer(&self, channel_id: ChannelId, _cx: &App) -> bool {
         if let Some(buffer) = self.opened_buffers.get(&channel_id) {
-            if let OpenEntityHandle::Open(buffer) = buffer {
+            if let OpenedModelHandle::Open(buffer) = buffer {
                 return buffer.upgrade().is_some();
             }
         }
@@ -453,7 +453,7 @@ impl ChannelStore {
     fn open_channel_resource<T, F, Fut>(
         &mut self,
         channel_id: ChannelId,
-        get_map: fn(&mut Self) -> &mut HashMap<ChannelId, OpenEntityHandle<T>>,
+        get_map: fn(&mut Self) -> &mut HashMap<ChannelId, OpenedModelHandle<T>>,
         load: F,
         cx: &mut Context<Self>,
     ) -> Task<Result<Entity<T>>>
@@ -465,15 +465,15 @@ impl ChannelStore {
         let task = loop {
             match get_map(self).entry(channel_id) {
                 hash_map::Entry::Occupied(e) => match e.get() {
-                    OpenEntityHandle::Open(entity) => {
-                        if let Some(entity) = entity.upgrade() {
-                            break Task::ready(Ok(entity)).shared();
+                    OpenedModelHandle::Open(model) => {
+                        if let Some(model) = model.upgrade() {
+                            break Task::ready(Ok(model)).shared();
                         } else {
                             get_map(self).remove(&channel_id);
                             continue;
                         }
                     }
-                    OpenEntityHandle::Loading(task) => {
+                    OpenedModelHandle::Loading(task) => {
                         break task.clone();
                     }
                 },
@@ -490,7 +490,7 @@ impl ChannelStore {
                         })
                         .shared();
 
-                    e.insert(OpenEntityHandle::Loading(task.clone()));
+                    e.insert(OpenedModelHandle::Loading(task.clone()));
                     cx.spawn({
                         let task = task.clone();
                         move |this, mut cx| async move {
@@ -499,7 +499,7 @@ impl ChannelStore {
                                 Ok(model) => {
                                     get_map(this).insert(
                                         channel_id,
-                                        OpenEntityHandle::Open(model.downgrade()),
+                                        OpenedModelHandle::Open(model.downgrade()),
                                     );
                                 }
                                 Err(_) => {
@@ -900,7 +900,7 @@ impl ChannelStore {
         self.disconnect_channel_buffers_task.take();
 
         for chat in self.opened_chats.values() {
-            if let OpenEntityHandle::Open(chat) = chat {
+            if let OpenedModelHandle::Open(chat) = chat {
                 if let Some(chat) = chat.upgrade() {
                     chat.update(cx, |chat, cx| {
                         chat.rejoin(cx);
@@ -911,7 +911,7 @@ impl ChannelStore {
 
         let mut buffer_versions = Vec::new();
         for buffer in self.opened_buffers.values() {
-            if let OpenEntityHandle::Open(buffer) = buffer {
+            if let OpenedModelHandle::Open(buffer) = buffer {
                 if let Some(buffer) = buffer.upgrade() {
                     let channel_buffer = buffer.read(cx);
                     let buffer = channel_buffer.buffer().read(cx);
@@ -937,7 +937,7 @@ impl ChannelStore {
 
             this.update(&mut cx, |this, cx| {
                 this.opened_buffers.retain(|_, buffer| match buffer {
-                    OpenEntityHandle::Open(channel_buffer) => {
+                    OpenedModelHandle::Open(channel_buffer) => {
                         let Some(channel_buffer) = channel_buffer.upgrade() else {
                             return false;
                         };
@@ -998,7 +998,7 @@ impl ChannelStore {
                             false
                         })
                     }
-                    OpenEntityHandle::Loading(_) => true,
+                    OpenedModelHandle::Loading(_) => true,
                 });
             })
             .ok();
@@ -1018,7 +1018,7 @@ impl ChannelStore {
                 if let Some(this) = this.upgrade() {
                     this.update(&mut cx, |this, cx| {
                         for (_, buffer) in this.opened_buffers.drain() {
-                            if let OpenEntityHandle::Open(buffer) = buffer {
+                            if let OpenedModelHandle::Open(buffer) = buffer {
                                 if let Some(buffer) = buffer.upgrade() {
                                     buffer.update(cx, |buffer, cx| buffer.disconnect(cx));
                                 }
@@ -1082,7 +1082,7 @@ impl ChannelStore {
                     {
                         continue;
                     }
-                    if let Some(OpenEntityHandle::Open(buffer)) =
+                    if let Some(OpenedModelHandle::Open(buffer)) =
                         self.opened_buffers.remove(&channel_id)
                     {
                         if let Some(buffer) = buffer.upgrade() {
@@ -1098,7 +1098,7 @@ impl ChannelStore {
                 let channel_changed = index.insert(channel);
 
                 if channel_changed {
-                    if let Some(OpenEntityHandle::Open(buffer)) = self.opened_buffers.get(&id) {
+                    if let Some(OpenedModelHandle::Open(buffer)) = self.opened_buffers.get(&id) {
                         if let Some(buffer) = buffer.upgrade() {
                             buffer.update(cx, ChannelBuffer::channel_changed);
                         }

crates/cli/build.rs

@@ -1,5 +1,3 @@
-use std::process::Command;
-
 fn main() {
     if std::env::var("ZED_UPDATE_EXPLANATION").is_ok() {
         println!(r#"cargo:rustc-cfg=feature="no-bundled-uninstall""#);
@@ -10,18 +8,4 @@ fn main() {
         // Weakly link ScreenCaptureKit to ensure can be used on macOS 10.15+.
         println!("cargo:rustc-link-arg=-Wl,-weak_framework,ScreenCaptureKit");
     }
-
-    // Populate git sha environment variable if git is available
-    println!("cargo:rerun-if-changed=../../.git/logs/HEAD");
-    if let Some(output) = Command::new("git")
-        .args(["rev-parse", "HEAD"])
-        .output()
-        .ok()
-        .filter(|output| output.status.success())
-    {
-        let git_sha = String::from_utf8_lossy(&output.stdout);
-        let git_sha = git_sha.trim();
-
-        println!("cargo:rustc-env=ZED_COMMIT_SHA={git_sha}");
-    }
 }

crates/cli/src/main.rs

@@ -33,19 +33,7 @@ trait InstalledApp {
 #[command(
     name = "zed",
     disable_version_flag = true,
-    before_help = "The Zed CLI binary.
-This CLI is a separate binary that invokes Zed.
-
-Examples:
-    `zed`
-          Simply opens Zed
-    `zed --foreground`
-          Runs in foreground (shows all logs)
-    `zed path-to-your-project`
-          Open your project in Zed
-    `zed -n path-to-file `
-          Open file/folder in a new window",
-    after_help = "To read from stdin, append '-', e.g. 'ps axf | zed -'"
+    after_help = "To read from stdin, append '-' (e.g. 'ps axf | zed -')"
 )]
 struct Args {
     /// Wait for all of the given paths to be opened/closed before exiting.
@@ -57,9 +45,10 @@ struct Args {
     /// Create a new workspace
     #[arg(short, long, overrides_with = "add")]
     new: bool,
-    /// The paths to open in Zed (space-separated).
+    /// A sequence of space-separated paths that you want to open.
     ///
-    /// Use `path:line:column` syntax to open a file at the given line and column.
+    /// Use `path:line:row` syntax to open a file at a specific location.
+    /// Non-existing paths and directories will ignore `:line:row` suffix.
     paths_with_position: Vec<String>,
     /// Print Zed's version and the app path.
     #[arg(short, long)]
@@ -339,17 +328,13 @@ mod linux {
     impl InstalledApp for App {
         fn zed_version_string(&self) -> String {
             format!(
-                "Zed {}{}{} – {}",
+                "Zed {}{} – {}",
                 if *RELEASE_CHANNEL == "stable" {
                     "".to_string()
                 } else {
-                    format!("{} ", *RELEASE_CHANNEL)
+                    format!(" {} ", *RELEASE_CHANNEL)
                 },
                 option_env!("RELEASE_VERSION").unwrap_or_default(),
-                match option_env!("ZED_COMMIT_SHA") {
-                    Some(commit_sha) => format!(" {commit_sha} "),
-                    None => "".to_string(),
-                },
                 self.0.display(),
             )
         }

crates/client/Cargo.toml

@@ -33,6 +33,8 @@ postage.workspace = true
 rand.workspace = true
 release_channel.workspace = true
 rpc = { workspace = true, features = ["gpui"] }
+rustls-native-certs.workspace = true
+rustls.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true

crates/client/src/client.rs

@@ -379,7 +379,7 @@ pub struct PendingEntitySubscription<T: 'static> {
 }
 
 impl<T: 'static> PendingEntitySubscription<T> {
-    pub fn set_entity(mut self, entity: &Entity<T>, cx: &AsyncApp) -> Subscription {
+    pub fn set_model(mut self, model: &Entity<T>, cx: &AsyncApp) -> Subscription {
         self.consumed = true;
         let mut handlers = self.client.handler_set.lock();
         let id = (TypeId::of::<T>(), self.remote_id);
@@ -392,7 +392,7 @@ impl<T: 'static> PendingEntitySubscription<T> {
         handlers.entities_by_type_and_remote_id.insert(
             id,
             EntityMessageSubscriber::Entity {
-                handle: entity.downgrade().into(),
+                handle: model.downgrade().into(),
             },
         );
         drop(handlers);
@@ -686,8 +686,8 @@ impl Client {
         H: 'static + Sync + Fn(Entity<E>, TypedEnvelope<M>, AsyncApp) -> F + Send + Sync,
         F: 'static + Future<Output = Result<()>>,
     {
-        self.add_message_handler_impl(entity, move |entity, message, _, cx| {
-            handler(entity, message, cx)
+        self.add_message_handler_impl(entity, move |model, message, _, cx| {
+            handler(model, message, cx)
         })
     }
 
@@ -709,7 +709,7 @@ impl Client {
         let message_type_id = TypeId::of::<M>();
         let mut state = self.handler_set.lock();
         state
-            .entities_by_message_type
+            .models_by_message_type
             .insert(message_type_id, entity.into());
 
         let prev_handler = state.message_handlers.insert(
@@ -738,7 +738,7 @@ impl Client {
 
     pub fn add_request_handler<M, E, H, F>(
         self: &Arc<Self>,
-        entity: WeakEntity<E>,
+        model: WeakEntity<E>,
         handler: H,
     ) -> Subscription
     where
@@ -747,7 +747,7 @@ impl Client {
         H: 'static + Sync + Fn(Entity<E>, TypedEnvelope<M>, AsyncApp) -> F + Send + Sync,
         F: 'static + Future<Output = Result<M::Response>>,
     {
-        self.add_message_handler_impl(entity, move |handle, envelope, this, cx| {
+        self.add_message_handler_impl(model, move |handle, envelope, this, cx| {
             Self::respond_to_request(envelope.receipt(), handler(handle, envelope, cx), this)
         })
     }
@@ -1124,11 +1124,31 @@ impl Client {
 
             match url_scheme {
                 Https => {
+                    let client_config = {
+                        let mut root_store = rustls::RootCertStore::empty();
+
+                        let root_certs = rustls_native_certs::load_native_certs();
+                        for error in root_certs.errors {
+                            log::warn!("error loading native certs: {:?}", error);
+                        }
+                        root_store.add_parsable_certificates(
+                            &root_certs
+                                .certs
+                                .into_iter()
+                                .map(|cert| cert.as_ref().to_owned())
+                                .collect::<Vec<_>>(),
+                        );
+                        rustls::ClientConfig::builder()
+                            .with_safe_defaults()
+                            .with_root_certificates(root_store)
+                            .with_no_client_auth()
+                    };
+
                     let (stream, _) =
                         async_tungstenite::async_tls::client_async_tls_with_connector(
                             request,
                             stream,
-                            Some(http_client::tls_config().into()),
+                            Some(client_config.into()),
                         )
                         .await?;
                     Ok(Connection::new(
@@ -1928,9 +1948,9 @@ mod tests {
 
         let (done_tx1, done_rx1) = smol::channel::unbounded();
         let (done_tx2, done_rx2) = smol::channel::unbounded();
-        AnyProtoClient::from(client.clone()).add_entity_message_handler(
-            move |entity: Entity<TestEntity>, _: TypedEnvelope<proto::JoinProject>, mut cx| {
-                match entity.update(&mut cx, |entity, _| entity.id).unwrap() {
+        AnyProtoClient::from(client.clone()).add_model_message_handler(
+            move |model: Entity<TestModel>, _: TypedEnvelope<proto::JoinProject>, mut cx| {
+                match model.update(&mut cx, |model, _| model.id).unwrap() {
                     1 => done_tx1.try_send(()).unwrap(),
                     2 => done_tx2.try_send(()).unwrap(),
                     _ => unreachable!(),
@@ -1938,15 +1958,15 @@ mod tests {
                 async { Ok(()) }
             },
         );
-        let entity1 = cx.new(|_| TestEntity {
+        let model1 = cx.new(|_| TestModel {
             id: 1,
             subscription: None,
         });
-        let entity2 = cx.new(|_| TestEntity {
+        let model2 = cx.new(|_| TestModel {
             id: 2,
             subscription: None,
         });
-        let entity3 = cx.new(|_| TestEntity {
+        let model3 = cx.new(|_| TestModel {
             id: 3,
             subscription: None,
         });
@@ -1954,17 +1974,17 @@ mod tests {
         let _subscription1 = client
             .subscribe_to_entity(1)
             .unwrap()
-            .set_entity(&entity1, &mut cx.to_async());
+            .set_model(&model1, &mut cx.to_async());
         let _subscription2 = client
             .subscribe_to_entity(2)
             .unwrap()
-            .set_entity(&entity2, &mut cx.to_async());
+            .set_model(&model2, &mut cx.to_async());
         // Ensure dropping a subscription for the same entity type still allows receiving of
         // messages for other entity IDs of the same type.
         let subscription3 = client
             .subscribe_to_entity(3)
             .unwrap()
-            .set_entity(&entity3, &mut cx.to_async());
+            .set_model(&model3, &mut cx.to_async());
         drop(subscription3);
 
         server.send(proto::JoinProject { project_id: 1 });
@@ -1986,11 +2006,11 @@ mod tests {
         });
         let server = FakeServer::for_client(user_id, &client, cx).await;
 
-        let entity = cx.new(|_| TestEntity::default());
+        let model = cx.new(|_| TestModel::default());
         let (done_tx1, _done_rx1) = smol::channel::unbounded();
         let (done_tx2, done_rx2) = smol::channel::unbounded();
         let subscription1 = client.add_message_handler(
-            entity.downgrade(),
+            model.downgrade(),
             move |_, _: TypedEnvelope<proto::Ping>, _| {
                 done_tx1.try_send(()).unwrap();
                 async { Ok(()) }
@@ -1998,7 +2018,7 @@ mod tests {
         );
         drop(subscription1);
         let _subscription2 = client.add_message_handler(
-            entity.downgrade(),
+            model.downgrade(),
             move |_, _: TypedEnvelope<proto::Ping>, _| {
                 done_tx2.try_send(()).unwrap();
                 async { Ok(()) }
@@ -2021,27 +2041,27 @@ mod tests {
         });
         let server = FakeServer::for_client(user_id, &client, cx).await;
 
-        let entity = cx.new(|_| TestEntity::default());
+        let model = cx.new(|_| TestModel::default());
         let (done_tx, done_rx) = smol::channel::unbounded();
         let subscription = client.add_message_handler(
-            entity.clone().downgrade(),
-            move |entity: Entity<TestEntity>, _: TypedEnvelope<proto::Ping>, mut cx| {
-                entity
-                    .update(&mut cx, |entity, _| entity.subscription.take())
+            model.clone().downgrade(),
+            move |model: Entity<TestModel>, _: TypedEnvelope<proto::Ping>, mut cx| {
+                model
+                    .update(&mut cx, |model, _| model.subscription.take())
                     .unwrap();
                 done_tx.try_send(()).unwrap();
                 async { Ok(()) }
             },
         );
-        entity.update(cx, |entity, _| {
-            entity.subscription = Some(subscription);
+        model.update(cx, |model, _| {
+            model.subscription = Some(subscription);
         });
         server.send(proto::Ping {});
         done_rx.recv().await.unwrap();
     }
 
     #[derive(Default)]
-    struct TestEntity {
+    struct TestModel {
         id: usize,
         subscription: Option<Subscription>,
     }

crates/client/src/telemetry.rs

@@ -3,6 +3,7 @@ mod event_coalescer;
 use crate::TelemetrySettings;
 use anyhow::Result;
 use clock::SystemClock;
+use collections::{HashMap, HashSet};
 use futures::channel::mpsc;
 use futures::{Future, StreamExt};
 use gpui::{App, BackgroundExecutor, Task};
@@ -11,13 +12,14 @@ use parking_lot::Mutex;
 use release_channel::ReleaseChannel;
 use settings::{Settings, SettingsStore};
 use sha2::{Digest, Sha256};
-use std::collections::{HashMap, HashSet};
 use std::fs::File;
 use std::io::Write;
 use std::sync::LazyLock;
 use std::time::Instant;
 use std::{env, mem, path::PathBuf, sync::Arc, time::Duration};
-use telemetry_events::{AssistantEvent, AssistantPhase, Event, EventRequestBody, EventWrapper};
+use telemetry_events::{
+    AppEvent, AssistantEvent, AssistantPhase, EditEvent, Event, EventRequestBody, EventWrapper,
+};
 use util::{ResultExt, TryFutureExt};
 use worktree::{UpdatedEntriesSet, WorktreeId};
 
@@ -283,7 +285,7 @@ impl Telemetry {
     // 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>) -> impl Future<Output = ()> {
-        telemetry::event!("App Closed");
+        self.report_app_event("close".to_string());
         // TODO: close final edit period and make sure it's sent
         Task::ready(())
     }
@@ -353,23 +355,30 @@ impl Telemetry {
         );
     }
 
+    pub fn report_app_event(self: &Arc<Self>, operation: String) -> Event {
+        let event = Event::App(AppEvent { operation });
+
+        self.report_event(event.clone());
+
+        event
+    }
+
     pub fn log_edit_event(self: &Arc<Self>, environment: &'static str, is_via_ssh: bool) {
         let mut state = self.state.lock();
         let period_data = state.event_coalescer.log_event(environment);
         drop(state);
 
         if let Some((start, end, environment)) = period_data {
-            let duration = end
-                .saturating_duration_since(start)
-                .min(Duration::from_secs(60 * 60 * 24))
-                .as_millis() as i64;
+            let event = Event::Edit(EditEvent {
+                duration: end
+                    .saturating_duration_since(start)
+                    .min(Duration::from_secs(60 * 60 * 24))
+                    .as_millis() as i64,
+                environment: environment.to_string(),
+                is_via_ssh,
+            });
 
-            telemetry::event!(
-                "Editor Edited",
-                duration = duration,
-                environment = environment.to_string(),
-                is_via_ssh = is_via_ssh
-            );
+            self.report_event(event);
         }
     }
 
@@ -413,8 +422,9 @@ impl Telemetry {
                 .collect()
         };
 
+        // Done on purpose to avoid calling `self.state.lock()` multiple times
         for project_type_name in project_type_names {
-            telemetry::event!("Project Opened", project_type = project_type_name);
+            self.report_app_event(format!("open {} project", project_type_name));
         }
     }
 
@@ -580,7 +590,6 @@ mod tests {
     use clock::FakeSystemClock;
     use gpui::TestAppContext;
     use http_client::FakeHttpClient;
-    use telemetry_events::FlexibleEvent;
 
     #[gpui::test]
     fn test_telemetry_flush_on_max_queue_size(cx: &mut TestAppContext) {
@@ -600,17 +609,15 @@ mod tests {
             assert!(is_empty_state(&telemetry));
 
             let first_date_time = clock.utc_now();
-            let event_properties = HashMap::from_iter([(
-                "test_key".to_string(),
-                serde_json::Value::String("test_value".to_string()),
-            )]);
+            let operation = "test".to_string();
 
-            let event = FlexibleEvent {
-                event_type: "test".to_string(),
-                event_properties,
-            };
-
-            telemetry.report_event(Event::Flexible(event.clone()));
+            let event = telemetry.report_app_event(operation.clone());
+            assert_eq!(
+                event,
+                Event::App(AppEvent {
+                    operation: operation.clone(),
+                })
+            );
             assert_eq!(telemetry.state.lock().events_queue.len(), 1);
             assert!(telemetry.state.lock().flush_events_task.is_some());
             assert_eq!(
@@ -620,7 +627,13 @@ mod tests {
 
             clock.advance(Duration::from_millis(100));
 
-            telemetry.report_event(Event::Flexible(event.clone()));
+            let event = telemetry.report_app_event(operation.clone());
+            assert_eq!(
+                event,
+                Event::App(AppEvent {
+                    operation: operation.clone(),
+                })
+            );
             assert_eq!(telemetry.state.lock().events_queue.len(), 2);
             assert!(telemetry.state.lock().flush_events_task.is_some());
             assert_eq!(
@@ -630,7 +643,13 @@ mod tests {
 
             clock.advance(Duration::from_millis(100));
 
-            telemetry.report_event(Event::Flexible(event.clone()));
+            let event = telemetry.report_app_event(operation.clone());
+            assert_eq!(
+                event,
+                Event::App(AppEvent {
+                    operation: operation.clone(),
+                })
+            );
             assert_eq!(telemetry.state.lock().events_queue.len(), 3);
             assert!(telemetry.state.lock().flush_events_task.is_some());
             assert_eq!(
@@ -641,7 +660,14 @@ mod tests {
             clock.advance(Duration::from_millis(100));
 
             // Adding a 4th event should cause a flush
-            telemetry.report_event(Event::Flexible(event));
+            let event = telemetry.report_app_event(operation.clone());
+            assert_eq!(
+                event,
+                Event::App(AppEvent {
+                    operation: operation.clone(),
+                })
+            );
+
             assert!(is_empty_state(&telemetry));
         });
     }
@@ -664,19 +690,17 @@ mod tests {
             telemetry.start(system_id, installation_id, session_id, cx);
 
             assert!(is_empty_state(&telemetry));
+
             let first_date_time = clock.utc_now();
+            let operation = "test".to_string();
 
-            let event_properties = HashMap::from_iter([(
-                "test_key".to_string(),
-                serde_json::Value::String("test_value".to_string()),
-            )]);
-
-            let event = FlexibleEvent {
-                event_type: "test".to_string(),
-                event_properties,
-            };
-
-            telemetry.report_event(Event::Flexible(event));
+            let event = telemetry.report_app_event(operation.clone());
+            assert_eq!(
+                event,
+                Event::App(AppEvent {
+                    operation: operation.clone(),
+                })
+            );
             assert_eq!(telemetry.state.lock().events_queue.len(), 1);
             assert!(telemetry.state.lock().flush_events_task.is_some());
             assert_eq!(

crates/client/src/user.rs

@@ -201,8 +201,9 @@ impl UserStore {
 
                                 cx.update(|cx| {
                                     if let Some(info) = info {
-                                        let staff =
-                                            info.staff && !*feature_flags::ZED_DISABLE_STAFF;
+                                        let disable_staff = std::env::var("ZED_DISABLE_STAFF")
+                                            .map_or(false, |v| !v.is_empty() && v != "0");
+                                        let staff = info.staff && !disable_staff;
                                         cx.update_flags(staff, info.flags);
                                         client.telemetry.set_authenticated_user_info(
                                             Some(info.metrics_id.clone()),

crates/collab/Cargo.toml

@@ -33,7 +33,6 @@ clock.workspace = true
 collections.workspace = true
 dashmap.workspace = true
 derive_more.workspace = true
-buffer_diff.workspace = true
 envy = "0.4.2"
 futures.workspace = true
 google_ai.workspace = true
@@ -131,7 +130,7 @@ worktree = { workspace = true, features = ["test-support"] }
 livekit_client_macos = { workspace = true, features = ["test-support"] }
 
 [target.'cfg(not(target_os = "macos"))'.dev-dependencies]
-livekit_client =  { workspace = true, features = ["test-support"] }
+livekit_client =  {workspace = true, features = ["test-support"] }
 
 [package.metadata.cargo-machete]
 ignored = ["async-stripe"]

crates/collab/migrations.sqlite/20221109000000_test_schema.sql

@@ -100,8 +100,6 @@ CREATE TABLE "worktree_repositories" (
     "branch" VARCHAR,
     "scan_id" INTEGER NOT NULL,
     "is_deleted" BOOL NOT NULL,
-    "current_merge_conflicts" VARCHAR,
-    "branch_summary" VARCHAR,
     PRIMARY KEY(project_id, worktree_id, work_directory_id),
     FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE,
     FOREIGN KEY(project_id, worktree_id, work_directory_id) REFERENCES worktree_entries (project_id, worktree_id, id) ON DELETE CASCADE
@@ -403,15 +401,6 @@ CREATE TABLE extension_versions (
     schema_version INTEGER NOT NULL DEFAULT 0,
     wasm_api_version TEXT,
     download_count INTEGER NOT NULL DEFAULT 0,
-    provides_themes BOOLEAN NOT NULL DEFAULT FALSE,
-    provides_icon_themes BOOLEAN NOT NULL DEFAULT FALSE,
-    provides_languages BOOLEAN NOT NULL DEFAULT FALSE,
-    provides_grammars BOOLEAN NOT NULL DEFAULT FALSE,
-    provides_language_servers BOOLEAN NOT NULL DEFAULT FALSE,
-    provides_context_servers BOOLEAN NOT NULL DEFAULT FALSE,
-    provides_slash_commands BOOLEAN NOT NULL DEFAULT FALSE,
-    provides_indexed_docs_providers BOOLEAN NOT NULL DEFAULT FALSE,
-    provides_snippets BOOLEAN NOT NULL DEFAULT FALSE,
     PRIMARY KEY (extension_id, version)
 );
 
@@ -441,7 +430,6 @@ CREATE TABLE IF NOT EXISTS billing_customers (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     user_id INTEGER NOT NULL REFERENCES users(id),
-    has_overdue_invoices BOOLEAN NOT NULL DEFAULT FALSE,
     stripe_customer_id TEXT NOT NULL
 );
 

crates/collab/migrations/20250204224004_add_has_overdue_invoices_to_billing_customers.sql

@@ -1,2 +0,0 @@
-alter table billing_customers
-add column has_overdue_invoices bool not null default false;

crates/collab/migrations/20250205192813_add_provides_fields_to_extension_versions.sql

@@ -1,10 +0,0 @@
-alter table extension_versions
-add column provides_themes bool not null default false,
-add column provides_icon_themes bool not null default false,
-add column provides_languages bool not null default false,
-add column provides_grammars bool not null default false,
-add column provides_language_servers bool not null default false,
-add column provides_context_servers bool not null default false,
-add column provides_slash_commands bool not null default false,
-add column provides_indexed_docs_providers bool not null default false,
-add column provides_snippets bool not null default false;

crates/collab/migrations/20250205232017_add_conflicts_to_repositories.sql

@@ -1,2 +0,0 @@
-ALTER TABLE worktree_repositories
-ADD COLUMN current_merge_conflicts VARCHAR NULL;

crates/collab/migrations/20250210223746_add_branch_summary.sql

@@ -1,2 +0,0 @@
-ALTER TABLE worktree_repositories
-ADD COLUMN worktree_repositories VARCHAR NULL;

crates/collab/migrations/20250212060936_add_worktree_branch_summary.sql

@@ -1 +0,0 @@
-ALTER TABLE worktree_repositories ADD COLUMN branch_summary TEXT NULL;

crates/collab/src/api/billing.rs

@@ -249,31 +249,29 @@ async fn create_billing_subscription(
         ));
     }
 
-    let existing_billing_customer = app.db.get_billing_customer_by_user_id(user.id).await?;
-    if let Some(existing_billing_customer) = &existing_billing_customer {
-        if existing_billing_customer.has_overdue_invoices {
-            return Err(Error::http(
-                StatusCode::PAYMENT_REQUIRED,
-                "user has overdue invoices".into(),
-            ));
-        }
+    if app.db.has_overdue_billing_subscriptions(user.id).await? {
+        return Err(Error::http(
+            StatusCode::PAYMENT_REQUIRED,
+            "user has overdue billing subscriptions".into(),
+        ));
     }
 
-    let customer_id = if let Some(existing_customer) = existing_billing_customer {
-        CustomerId::from_str(&existing_customer.stripe_customer_id)
-            .context("failed to parse customer ID")?
-    } else {
-        let customer = Customer::create(
-            &stripe_client,
-            CreateCustomer {
-                email: user.email_address.as_deref(),
-                ..Default::default()
-            },
-        )
-        .await?;
+    let customer_id =
+        if let Some(existing_customer) = app.db.get_billing_customer_by_user_id(user.id).await? {
+            CustomerId::from_str(&existing_customer.stripe_customer_id)
+                .context("failed to parse customer ID")?
+        } else {
+            let customer = Customer::create(
+                &stripe_client,
+                CreateCustomer {
+                    email: user.email_address.as_deref(),
+                    ..Default::default()
+                },
+            )
+            .await?;
 
-        customer.id
-    };
+            customer.id
+        };
 
     let default_model = llm_db.model(rpc::LanguageModelProvider::Anthropic, "claude-3-5-sonnet")?;
     let stripe_model = stripe_billing.register_model(default_model).await?;
@@ -668,27 +666,6 @@ async fn handle_customer_subscription_event(
             .await?
             .ok_or_else(|| anyhow!("billing customer not found"))?;
 
-    let was_canceled_due_to_payment_failure = subscription.status == SubscriptionStatus::Canceled
-        && subscription
-            .cancellation_details
-            .as_ref()
-            .and_then(|details| details.reason)
-            .map_or(false, |reason| {
-                reason == CancellationDetailsReason::PaymentFailed
-            });
-
-    if was_canceled_due_to_payment_failure {
-        app.db
-            .update_billing_customer(
-                billing_customer.id,
-                &UpdateBillingCustomerParams {
-                    has_overdue_invoices: ActiveValue::set(true),
-                    ..Default::default()
-                },
-            )
-            .await?;
-    }
-
     if let Some(existing_subscription) = app
         .db
         .get_billing_subscription_by_stripe_subscription_id(&subscription.id)

crates/collab/src/api/events.rs

@@ -495,10 +495,6 @@ fn for_snowflake(
     body.events.into_iter().flat_map(move |event| {
         let timestamp =
             first_event_at + Duration::milliseconds(event.milliseconds_since_first_event);
-        // We will need to double check, but I believe all of the events that
-        // are being transformed here are now migrated over to use the
-        // telemetry::event! macro, as of this commit so this code can go away
-        // when we feel enough users have upgraded past this point.
         let (event_type, mut event_properties) = match &event.event {
             Event::Editor(e) => (
                 match e.operation.as_str() {
@@ -510,7 +506,7 @@ fn for_snowflake(
             ),
             Event::InlineCompletion(e) => (
                 format!(
-                    "Edit Prediction {}",
+                    "Inline Completion {}",
                     if e.suggestion_accepted {
                         "Accepted"
                     } else {
@@ -520,7 +516,7 @@ fn for_snowflake(
                 serde_json::to_value(e).unwrap(),
             ),
             Event::InlineCompletionRating(e) => (
-                "Edit Prediction Rated".to_string(),
+                "Inline Completion Rated".to_string(),
                 serde_json::to_value(e).unwrap(),
             ),
             Event::Call(e) => {

crates/collab/src/api/extensions.rs

@@ -9,11 +9,10 @@ use axum::{
     routing::get,
     Extension, Json, Router,
 };
-use collections::{BTreeSet, HashMap};
-use rpc::{ExtensionApiManifest, ExtensionProvides, GetExtensionsResponse};
+use collections::HashMap;
+use rpc::{ExtensionApiManifest, GetExtensionsResponse};
 use semantic_version::SemanticVersion;
 use serde::Deserialize;
-use std::str::FromStr;
 use std::{sync::Arc, time::Duration};
 use time::PrimitiveDateTime;
 use util::{maybe, ResultExt};
@@ -36,14 +35,6 @@ pub fn router() -> Router {
 #[derive(Debug, Deserialize)]
 struct GetExtensionsParams {
     filter: Option<String>,
-    /// A comma-delimited list of features that the extension must provide.
-    ///
-    /// For example:
-    /// - `themes`
-    /// - `themes,icon-themes`
-    /// - `languages,language-servers`
-    #[serde(default)]
-    provides: Option<String>,
     #[serde(default)]
     max_schema_version: i32,
 }
@@ -52,22 +43,9 @@ async fn get_extensions(
     Extension(app): Extension<Arc<AppState>>,
     Query(params): Query<GetExtensionsParams>,
 ) -> Result<Json<GetExtensionsResponse>> {
-    let provides_filter = params.provides.map(|provides| {
-        provides
-            .split(',')
-            .map(|value| value.trim())
-            .filter_map(|value| ExtensionProvides::from_str(value).ok())
-            .collect::<BTreeSet<_>>()
-    });
-
     let mut extensions = app
         .db
-        .get_extensions(
-            params.filter.as_deref(),
-            provides_filter.as_ref(),
-            params.max_schema_version,
-            500,
-        )
+        .get_extensions(params.filter.as_deref(), params.max_schema_version, 500)
         .await?;
 
     if let Some(filter) = params.filter.as_deref() {
@@ -413,7 +391,6 @@ async fn fetch_extension_manifest(
         repository: manifest.repository,
         schema_version: manifest.schema_version.unwrap_or(0),
         wasm_api_version: manifest.wasm_api_version,
-        provides: manifest.provides,
         published_at,
     })
 }

crates/collab/src/db.rs

@@ -6,11 +6,10 @@ pub mod tests;
 
 use crate::{executor::Executor, Error, Result};
 use anyhow::anyhow;
-use collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use collections::{BTreeMap, HashMap, HashSet};
 use dashmap::DashMap;
 use futures::StreamExt;
 use rand::{prelude::StdRng, Rng, SeedableRng};
-use rpc::ExtensionProvides;
 use rpc::{
     proto::{self},
     ConnectionId, ExtensionMetadata,
@@ -782,7 +781,6 @@ pub struct NewExtensionVersion {
     pub repository: String,
     pub schema_version: i32,
     pub wasm_api_version: Option<String>,
-    pub provides: BTreeSet<ExtensionProvides>,
     pub published_at: PrimitiveDateTime,
 }
 

crates/collab/src/db/queries/billing_customers.rs

@@ -10,7 +10,6 @@ pub struct CreateBillingCustomerParams {
 pub struct UpdateBillingCustomerParams {
     pub user_id: ActiveValue<UserId>,
     pub stripe_customer_id: ActiveValue<String>,
-    pub has_overdue_invoices: ActiveValue<bool>,
 }
 
 impl Database {
@@ -44,7 +43,6 @@ impl Database {
                 id: ActiveValue::set(id),
                 user_id: params.user_id.clone(),
                 stripe_customer_id: params.stripe_customer_id.clone(),
-                has_overdue_invoices: params.has_overdue_invoices.clone(),
                 ..Default::default()
             })
             .exec(&*tx)

crates/collab/src/db/queries/billing_subscriptions.rs

@@ -170,4 +170,40 @@ impl Database {
         })
         .await
     }
+
+    /// Returns whether the user has any overdue billing subscriptions.
+    pub async fn has_overdue_billing_subscriptions(&self, user_id: UserId) -> Result<bool> {
+        Ok(self.count_overdue_billing_subscriptions(user_id).await? > 0)
+    }
+
+    /// Returns the count of the overdue billing subscriptions for the user with the specified ID.
+    ///
+    /// This includes subscriptions:
+    /// - Whose status is `past_due`
+    /// - Whose status is `canceled` and the cancellation reason is `payment_failed`
+    pub async fn count_overdue_billing_subscriptions(&self, user_id: UserId) -> Result<usize> {
+        self.transaction(|tx| async move {
+            let past_due = billing_subscription::Column::StripeSubscriptionStatus
+                .eq(StripeSubscriptionStatus::PastDue);
+            let payment_failed = billing_subscription::Column::StripeSubscriptionStatus
+                .eq(StripeSubscriptionStatus::Canceled)
+                .and(
+                    billing_subscription::Column::StripeCancellationReason
+                        .eq(StripeCancellationReason::PaymentFailed),
+                );
+
+            let count = billing_subscription::Entity::find()
+                .inner_join(billing_customer::Entity)
+                .filter(
+                    billing_customer::Column::UserId
+                        .eq(user_id)
+                        .and(past_due.or(payment_failed)),
+                )
+                .count(&*tx)
+                .await?;
+
+            Ok(count as usize)
+        })
+        .await
+    }
 }

crates/collab/src/db/queries/extensions.rs

@@ -10,7 +10,6 @@ impl Database {
     pub async fn get_extensions(
         &self,
         filter: Option<&str>,
-        provides_filter: Option<&BTreeSet<ExtensionProvides>>,
         max_schema_version: i32,
         limit: usize,
     ) -> Result<Vec<ExtensionMetadata>> {
@@ -27,10 +26,6 @@ impl Database {
                 condition = condition.add(Expr::cust_with_expr("name ILIKE $1", fuzzy_name_filter));
             }
 
-            if let Some(provides_filter) = provides_filter {
-                condition = apply_provides_filter(condition, provides_filter);
-            }
-
             self.get_extensions_where(condition, Some(limit as u64), &tx)
                 .await
         })
@@ -287,39 +282,6 @@ impl Database {
                         description: ActiveValue::Set(version.description.clone()),
                         schema_version: ActiveValue::Set(version.schema_version),
                         wasm_api_version: ActiveValue::Set(version.wasm_api_version.clone()),
-                        provides_themes: ActiveValue::Set(
-                            version.provides.contains(&ExtensionProvides::Themes),
-                        ),
-                        provides_icon_themes: ActiveValue::Set(
-                            version.provides.contains(&ExtensionProvides::IconThemes),
-                        ),
-                        provides_languages: ActiveValue::Set(
-                            version.provides.contains(&ExtensionProvides::Languages),
-                        ),
-                        provides_grammars: ActiveValue::Set(
-                            version.provides.contains(&ExtensionProvides::Grammars),
-                        ),
-                        provides_language_servers: ActiveValue::Set(
-                            version
-                                .provides
-                                .contains(&ExtensionProvides::LanguageServers),
-                        ),
-                        provides_context_servers: ActiveValue::Set(
-                            version
-                                .provides
-                                .contains(&ExtensionProvides::ContextServers),
-                        ),
-                        provides_slash_commands: ActiveValue::Set(
-                            version.provides.contains(&ExtensionProvides::SlashCommands),
-                        ),
-                        provides_indexed_docs_providers: ActiveValue::Set(
-                            version
-                                .provides
-                                .contains(&ExtensionProvides::IndexedDocsProviders),
-                        ),
-                        provides_snippets: ActiveValue::Set(
-                            version.provides.contains(&ExtensionProvides::Snippets),
-                        ),
                         download_count: ActiveValue::NotSet,
                     }
                 }))
@@ -390,55 +352,10 @@ impl Database {
     }
 }
 
-fn apply_provides_filter(
-    mut condition: Condition,
-    provides_filter: &BTreeSet<ExtensionProvides>,
-) -> Condition {
-    if provides_filter.contains(&ExtensionProvides::Themes) {
-        condition = condition.add(extension_version::Column::ProvidesThemes.eq(true));
-    }
-
-    if provides_filter.contains(&ExtensionProvides::IconThemes) {
-        condition = condition.add(extension_version::Column::ProvidesIconThemes.eq(true));
-    }
-
-    if provides_filter.contains(&ExtensionProvides::Languages) {
-        condition = condition.add(extension_version::Column::ProvidesLanguages.eq(true));
-    }
-
-    if provides_filter.contains(&ExtensionProvides::Grammars) {
-        condition = condition.add(extension_version::Column::ProvidesGrammars.eq(true));
-    }
-
-    if provides_filter.contains(&ExtensionProvides::LanguageServers) {
-        condition = condition.add(extension_version::Column::ProvidesLanguageServers.eq(true));
-    }
-
-    if provides_filter.contains(&ExtensionProvides::ContextServers) {
-        condition = condition.add(extension_version::Column::ProvidesContextServers.eq(true));
-    }
-
-    if provides_filter.contains(&ExtensionProvides::SlashCommands) {
-        condition = condition.add(extension_version::Column::ProvidesSlashCommands.eq(true));
-    }
-
-    if provides_filter.contains(&ExtensionProvides::IndexedDocsProviders) {
-        condition = condition.add(extension_version::Column::ProvidesIndexedDocsProviders.eq(true));
-    }
-
-    if provides_filter.contains(&ExtensionProvides::Snippets) {
-        condition = condition.add(extension_version::Column::ProvidesSnippets.eq(true));
-    }
-
-    condition
-}
-
 fn metadata_from_extension_and_version(
     extension: extension::Model,
     version: extension_version::Model,
 ) -> ExtensionMetadata {
-    let provides = version.provides();
-
     ExtensionMetadata {
         id: extension.external_id.into(),
         manifest: rpc::ExtensionApiManifest {
@@ -453,7 +370,6 @@ fn metadata_from_extension_and_version(
             repository: version.repository,
             schema_version: Some(version.schema_version),
             wasm_api_version: version.wasm_api_version,
-            provides,
         },
 
         published_at: convert_time_to_chrono(version.published_at),

crates/collab/src/db/queries/projects.rs

@@ -326,26 +326,13 @@ impl Database {
 
             if !update.updated_repositories.is_empty() {
                 worktree_repository::Entity::insert_many(update.updated_repositories.iter().map(
-                    |repository| {
-                        worktree_repository::ActiveModel {
-                            project_id: ActiveValue::set(project_id),
-                            worktree_id: ActiveValue::set(worktree_id),
-                            work_directory_id: ActiveValue::set(
-                                repository.work_directory_id as i64,
-                            ),
-                            scan_id: ActiveValue::set(update.scan_id as i64),
-                            branch: ActiveValue::set(repository.branch.clone()),
-                            is_deleted: ActiveValue::set(false),
-                            branch_summary: ActiveValue::Set(
-                                repository
-                                    .branch_summary
-                                    .as_ref()
-                                    .map(|summary| serde_json::to_string(summary).unwrap()),
-                            ),
-                            current_merge_conflicts: ActiveValue::Set(Some(
-                                serde_json::to_string(&repository.current_merge_conflicts).unwrap(),
-                            )),
-                        }
+                    |repository| worktree_repository::ActiveModel {
+                        project_id: ActiveValue::set(project_id),
+                        worktree_id: ActiveValue::set(worktree_id),
+                        work_directory_id: ActiveValue::set(repository.work_directory_id as i64),
+                        scan_id: ActiveValue::set(update.scan_id as i64),
+                        branch: ActiveValue::set(repository.branch.clone()),
+                        is_deleted: ActiveValue::set(false),
                     },
                 ))
                 .on_conflict(
@@ -357,8 +344,6 @@ impl Database {
                     .update_columns([
                         worktree_repository::Column::ScanId,
                         worktree_repository::Column::Branch,
-                        worktree_repository::Column::BranchSummary,
-                        worktree_repository::Column::CurrentMergeConflicts,
                     ])
                     .to_owned(),
                 )
@@ -784,20 +769,6 @@ impl Database {
                         updated_statuses.push(db_status_to_proto(status_entry)?);
                     }
 
-                    let current_merge_conflicts = db_repository_entry
-                        .current_merge_conflicts
-                        .as_ref()
-                        .map(|conflicts| serde_json::from_str(&conflicts))
-                        .transpose()?
-                        .unwrap_or_default();
-
-                    let branch_summary = db_repository_entry
-                        .branch_summary
-                        .as_ref()
-                        .map(|branch_summary| serde_json::from_str(&branch_summary))
-                        .transpose()?
-                        .unwrap_or_default();
-
                     worktree.repository_entries.insert(
                         db_repository_entry.work_directory_id as u64,
                         proto::RepositoryEntry {
@@ -805,8 +776,6 @@ impl Database {
                             branch: db_repository_entry.branch,
                             updated_statuses,
                             removed_statuses: Vec::new(),
-                            current_merge_conflicts,
-                            branch_summary,
                         },
                     );
                 }

crates/collab/src/db/queries/rooms.rs

@@ -736,27 +736,11 @@ impl Database {
                             }
                         }
 
-                        let current_merge_conflicts = db_repository
-                            .current_merge_conflicts
-                            .as_ref()
-                            .map(|conflicts| serde_json::from_str(&conflicts))
-                            .transpose()?
-                            .unwrap_or_default();
-
-                        let branch_summary = db_repository
-                            .branch_summary
-                            .as_ref()
-                            .map(|branch_summary| serde_json::from_str(&branch_summary))
-                            .transpose()?
-                            .unwrap_or_default();
-
                         worktree.updated_repositories.push(proto::RepositoryEntry {
                             work_directory_id: db_repository.work_directory_id as u64,
                             branch: db_repository.branch,
                             updated_statuses,
                             removed_statuses,
-                            current_merge_conflicts,
-                            branch_summary,
                         });
                     }
                 }

crates/collab/src/db/queries/users.rs

@@ -133,23 +133,26 @@ impl Database {
         initial_channel_id: Option<ChannelId>,
         tx: &DatabaseTransaction,
     ) -> Result<User> {
-        if let Some(existing_user) = self
-            .get_user_by_github_user_id_or_github_login(github_user_id, github_login, tx)
+        if let Some(user_by_github_user_id) = user::Entity::find()
+            .filter(user::Column::GithubUserId.eq(github_user_id))
+            .one(tx)
             .await?
         {
-            let mut existing_user = existing_user.into_active_model();
-            existing_user.github_login = ActiveValue::set(github_login.into());
-            existing_user.github_user_created_at = ActiveValue::set(Some(github_user_created_at));
-
-            if let Some(github_email) = github_email {
-                existing_user.email_address = ActiveValue::set(Some(github_email.into()));
-            }
-
-            if let Some(github_name) = github_name {
-                existing_user.name = ActiveValue::set(Some(github_name.into()));
-            }
-
-            Ok(existing_user.update(tx).await?)
+            let mut user_by_github_user_id = user_by_github_user_id.into_active_model();
+            user_by_github_user_id.github_login = ActiveValue::set(github_login.into());
+            user_by_github_user_id.github_user_created_at =
+                ActiveValue::set(Some(github_user_created_at));
+            Ok(user_by_github_user_id.update(tx).await?)
+        } else if let Some(user_by_github_login) = user::Entity::find()
+            .filter(user::Column::GithubLogin.eq(github_login))
+            .one(tx)
+            .await?
+        {
+            let mut user_by_github_login = user_by_github_login.into_active_model();
+            user_by_github_login.github_user_id = ActiveValue::set(github_user_id);
+            user_by_github_login.github_user_created_at =
+                ActiveValue::set(Some(github_user_created_at));
+            Ok(user_by_github_login.update(tx).await?)
         } else {
             let user = user::Entity::insert(user::ActiveModel {
                 email_address: ActiveValue::set(github_email.map(|email| email.into())),
@@ -180,34 +183,6 @@ impl Database {
         }
     }
 
-    /// Tries to retrieve a user, first by their GitHub user ID, and then by their GitHub login.
-    ///
-    /// Returns `None` if a user is not found with this GitHub user ID or GitHub login.
-    pub async fn get_user_by_github_user_id_or_github_login(
-        &self,
-        github_user_id: i32,
-        github_login: &str,
-        tx: &DatabaseTransaction,
-    ) -> Result<Option<User>> {
-        if let Some(user_by_github_user_id) = user::Entity::find()
-            .filter(user::Column::GithubUserId.eq(github_user_id))
-            .one(tx)
-            .await?
-        {
-            return Ok(Some(user_by_github_user_id));
-        }
-
-        if let Some(user_by_github_login) = user::Entity::find()
-            .filter(user::Column::GithubLogin.eq(github_login))
-            .one(tx)
-            .await?
-        {
-            return Ok(Some(user_by_github_login));
-        }
-
-        Ok(None)
-    }
-
     /// get_all_users returns the next page of users. To get more call again with
     /// the same limit and the page incremented by 1.
     pub async fn get_all_users(&self, page: u32, limit: u32) -> Result<Vec<User>> {

crates/collab/src/db/tables/billing_customer.rs

@@ -9,7 +9,6 @@ pub struct Model {
     pub id: BillingCustomerId,
     pub user_id: UserId,
     pub stripe_customer_id: String,
-    pub has_overdue_invoices: bool,
     pub created_at: DateTime,
 }
 

crates/collab/src/db/tables/extension_version.rs

@@ -1,6 +1,4 @@
 use crate::db::ExtensionId;
-use collections::BTreeSet;
-use rpc::ExtensionProvides;
 use sea_orm::entity::prelude::*;
 use time::PrimitiveDateTime;
 
@@ -18,58 +16,6 @@ pub struct Model {
     pub schema_version: i32,
     pub wasm_api_version: Option<String>,
     pub download_count: i64,
-    pub provides_themes: bool,
-    pub provides_icon_themes: bool,
-    pub provides_languages: bool,
-    pub provides_grammars: bool,
-    pub provides_language_servers: bool,
-    pub provides_context_servers: bool,
-    pub provides_slash_commands: bool,
-    pub provides_indexed_docs_providers: bool,
-    pub provides_snippets: bool,
-}
-
-impl Model {
-    pub fn provides(&self) -> BTreeSet<ExtensionProvides> {
-        let mut provides = BTreeSet::default();
-        if self.provides_themes {
-            provides.insert(ExtensionProvides::Themes);
-        }
-
-        if self.provides_icon_themes {
-            provides.insert(ExtensionProvides::IconThemes);
-        }
-
-        if self.provides_languages {
-            provides.insert(ExtensionProvides::Languages);
-        }
-
-        if self.provides_grammars {
-            provides.insert(ExtensionProvides::Grammars);
-        }
-
-        if self.provides_language_servers {
-            provides.insert(ExtensionProvides::LanguageServers);
-        }
-
-        if self.provides_context_servers {
-            provides.insert(ExtensionProvides::ContextServers);
-        }
-
-        if self.provides_slash_commands {
-            provides.insert(ExtensionProvides::SlashCommands);
-        }
-
-        if self.provides_indexed_docs_providers {
-            provides.insert(ExtensionProvides::IndexedDocsProviders);
-        }
-
-        if self.provides_snippets {
-            provides.insert(ExtensionProvides::Snippets);
-        }
-
-        provides
-    }
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

crates/collab/src/db/tables/worktree_repository.rs

@@ -13,10 +13,6 @@ pub struct Model {
     pub scan_id: i64,
     pub branch: Option<String>,
     pub is_deleted: bool,
-    // JSON array typed string
-    pub current_merge_conflicts: Option<String>,
-    // A JSON object representing the current Branch values
-    pub branch_summary: Option<String>,
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

crates/collab/src/db/tests/billing_subscription_tests.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use crate::db::billing_subscription::StripeSubscriptionStatus;
+use crate::db::billing_subscription::{StripeCancellationReason, StripeSubscriptionStatus};
 use crate::db::tests::new_test_user;
 use crate::db::{CreateBillingCustomerParams, CreateBillingSubscriptionParams};
 use crate::test_both_dbs;
@@ -88,3 +88,113 @@ async fn test_get_active_billing_subscriptions(db: &Arc<Database>) {
         assert_eq!(subscription_count, 0);
     }
 }
+
+test_both_dbs!(
+    test_count_overdue_billing_subscriptions,
+    test_count_overdue_billing_subscriptions_postgres,
+    test_count_overdue_billing_subscriptions_sqlite
+);
+
+async fn test_count_overdue_billing_subscriptions(db: &Arc<Database>) {
+    // A user with no subscription has no overdue billing subscriptions.
+    {
+        let user_id = new_test_user(db, "no-subscription-user@example.com").await;
+        let subscription_count = db
+            .count_overdue_billing_subscriptions(user_id)
+            .await
+            .unwrap();
+
+        assert_eq!(subscription_count, 0);
+    }
+
+    // A user with a past-due subscription has an overdue billing subscription.
+    {
+        let user_id = new_test_user(db, "past-due-user@example.com").await;
+        let customer = db
+            .create_billing_customer(&CreateBillingCustomerParams {
+                user_id,
+                stripe_customer_id: "cus_past_due_user".into(),
+            })
+            .await
+            .unwrap();
+        assert_eq!(customer.stripe_customer_id, "cus_past_due_user".to_string());
+
+        db.create_billing_subscription(&CreateBillingSubscriptionParams {
+            billing_customer_id: customer.id,
+            stripe_subscription_id: "sub_past_due_user".into(),
+            stripe_subscription_status: StripeSubscriptionStatus::PastDue,
+            stripe_cancellation_reason: None,
+        })
+        .await
+        .unwrap();
+
+        let subscription_count = db
+            .count_overdue_billing_subscriptions(user_id)
+            .await
+            .unwrap();
+        assert_eq!(subscription_count, 1);
+    }
+
+    // A user with a canceled subscription with a reason of `payment_failed` has an overdue billing subscription.
+    {
+        let user_id =
+            new_test_user(db, "canceled-subscription-payment-failed-user@example.com").await;
+        let customer = db
+            .create_billing_customer(&CreateBillingCustomerParams {
+                user_id,
+                stripe_customer_id: "cus_canceled_subscription_payment_failed_user".into(),
+            })
+            .await
+            .unwrap();
+        assert_eq!(
+            customer.stripe_customer_id,
+            "cus_canceled_subscription_payment_failed_user".to_string()
+        );
+
+        db.create_billing_subscription(&CreateBillingSubscriptionParams {
+            billing_customer_id: customer.id,
+            stripe_subscription_id: "sub_canceled_subscription_payment_failed_user".into(),
+            stripe_subscription_status: StripeSubscriptionStatus::Canceled,
+            stripe_cancellation_reason: Some(StripeCancellationReason::PaymentFailed),
+        })
+        .await
+        .unwrap();
+
+        let subscription_count = db
+            .count_overdue_billing_subscriptions(user_id)
+            .await
+            .unwrap();
+        assert_eq!(subscription_count, 1);
+    }
+
+    // A user with a canceled subscription with a reason of `cancellation_requested` has no overdue billing subscriptions.
+    {
+        let user_id = new_test_user(db, "canceled-subscription-user@example.com").await;
+        let customer = db
+            .create_billing_customer(&CreateBillingCustomerParams {
+                user_id,
+                stripe_customer_id: "cus_canceled_subscription_user".into(),
+            })
+            .await
+            .unwrap();
+        assert_eq!(
+            customer.stripe_customer_id,
+            "cus_canceled_subscription_user".to_string()
+        );
+
+        db.create_billing_subscription(&CreateBillingSubscriptionParams {
+            billing_customer_id: customer.id,
+            stripe_subscription_id: "sub_canceled_subscription_user".into(),
+            stripe_subscription_status: StripeSubscriptionStatus::Canceled,
+            stripe_cancellation_reason: Some(StripeCancellationReason::CancellationRequested),
+        })
+        .await
+        .unwrap();
+
+        let subscription_count = db
+            .count_overdue_billing_subscriptions(user_id)
+            .await
+            .unwrap();
+        assert_eq!(subscription_count, 0);
+    }
+}

crates/collab/src/db/tests/extension_tests.rs

@@ -1,14 +1,10 @@
-use std::collections::BTreeSet;
-use std::sync::Arc;
-
-use rpc::ExtensionProvides;
-
 use super::Database;
 use crate::db::ExtensionVersionConstraints;
 use crate::{
     db::{queries::extensions::convert_time_to_chrono, ExtensionMetadata, NewExtensionVersion},
     test_both_dbs,
 };
+use std::sync::Arc;
 
 test_both_dbs!(
     test_extensions,
@@ -20,7 +16,7 @@ async fn test_extensions(db: &Arc<Database>) {
     let versions = db.get_known_extension_versions().await.unwrap();
     assert!(versions.is_empty());
 
-    let extensions = db.get_extensions(None, None, 1, 5).await.unwrap();
+    let extensions = db.get_extensions(None, 1, 5).await.unwrap();
     assert!(extensions.is_empty());
 
     let t0 = time::OffsetDateTime::from_unix_timestamp_nanos(0).unwrap();
@@ -41,7 +37,6 @@ async fn test_extensions(db: &Arc<Database>) {
                         repository: "ext1/repo".into(),
                         schema_version: 1,
                         wasm_api_version: None,
-                        provides: BTreeSet::default(),
                         published_at: t0,
                     },
                     NewExtensionVersion {
@@ -52,7 +47,6 @@ async fn test_extensions(db: &Arc<Database>) {
                         repository: "ext1/repo".into(),
                         schema_version: 1,
                         wasm_api_version: None,
-                        provides: BTreeSet::default(),
                         published_at: t0,
                     },
                 ],
@@ -67,7 +61,6 @@ async fn test_extensions(db: &Arc<Database>) {
                     repository: "ext2/repo".into(),
                     schema_version: 0,
                     wasm_api_version: None,
-                    provides: BTreeSet::default(),
                     published_at: t0,
                 }],
             ),
@@ -90,7 +83,7 @@ async fn test_extensions(db: &Arc<Database>) {
     );
 
     // The latest version of each extension is returned.
-    let extensions = db.get_extensions(None, None, 1, 5).await.unwrap();
+    let extensions = db.get_extensions(None, 1, 5).await.unwrap();
     assert_eq!(
         extensions,
         &[
@@ -104,7 +97,6 @@ async fn test_extensions(db: &Arc<Database>) {
                     repository: "ext1/repo".into(),
                     schema_version: Some(1),
                     wasm_api_version: None,
-                    provides: BTreeSet::default(),
                 },
                 published_at: t0_chrono,
                 download_count: 0,
@@ -119,7 +111,6 @@ async fn test_extensions(db: &Arc<Database>) {
                     repository: "ext2/repo".into(),
                     schema_version: Some(0),
                     wasm_api_version: None,
-                    provides: BTreeSet::default(),
                 },
                 published_at: t0_chrono,
                 download_count: 0
@@ -128,7 +119,7 @@ async fn test_extensions(db: &Arc<Database>) {
     );
 
     // Extensions with too new of a schema version are excluded.
-    let extensions = db.get_extensions(None, None, 0, 5).await.unwrap();
+    let extensions = db.get_extensions(None, 0, 5).await.unwrap();
     assert_eq!(
         extensions,
         &[ExtensionMetadata {
@@ -141,7 +132,6 @@ async fn test_extensions(db: &Arc<Database>) {
                 repository: "ext2/repo".into(),
                 schema_version: Some(0),
                 wasm_api_version: None,
-                provides: BTreeSet::default(),
             },
             published_at: t0_chrono,
             download_count: 0
@@ -168,7 +158,7 @@ async fn test_extensions(db: &Arc<Database>) {
         .unwrap());
 
     // Extensions are returned in descending order of total downloads.
-    let extensions = db.get_extensions(None, None, 1, 5).await.unwrap();
+    let extensions = db.get_extensions(None, 1, 5).await.unwrap();
     assert_eq!(
         extensions,
         &[
@@ -182,7 +172,6 @@ async fn test_extensions(db: &Arc<Database>) {
                     repository: "ext2/repo".into(),
                     schema_version: Some(0),
                     wasm_api_version: None,
-                    provides: BTreeSet::default(),
                 },
                 published_at: t0_chrono,
                 download_count: 7
@@ -197,7 +186,6 @@ async fn test_extensions(db: &Arc<Database>) {
                     repository: "ext1/repo".into(),
                     schema_version: Some(1),
                     wasm_api_version: None,
-                    provides: BTreeSet::default(),
                 },
                 published_at: t0_chrono,
                 download_count: 5,
@@ -219,7 +207,6 @@ async fn test_extensions(db: &Arc<Database>) {
                     repository: "ext1/repo".into(),
                     schema_version: 1,
                     wasm_api_version: None,
-                    provides: BTreeSet::default(),
                     published_at: t0,
                 }],
             ),
@@ -233,7 +220,6 @@ async fn test_extensions(db: &Arc<Database>) {
                     repository: "ext2/repo".into(),
                     schema_version: 0,
                     wasm_api_version: None,
-                    provides: BTreeSet::default(),
                     published_at: t0,
                 }],
             ),
@@ -258,7 +244,7 @@ async fn test_extensions(db: &Arc<Database>) {
         .collect()
     );
 
-    let extensions = db.get_extensions(None, None, 1, 5).await.unwrap();
+    let extensions = db.get_extensions(None, 1, 5).await.unwrap();
     assert_eq!(
         extensions,
         &[
@@ -272,7 +258,6 @@ async fn test_extensions(db: &Arc<Database>) {
                     repository: "ext2/repo".into(),
                     schema_version: Some(0),
                     wasm_api_version: None,
-                    provides: BTreeSet::default(),
                 },
                 published_at: t0_chrono,
                 download_count: 7
@@ -287,7 +272,6 @@ async fn test_extensions(db: &Arc<Database>) {
                     repository: "ext1/repo".into(),
                     schema_version: Some(1),
                     wasm_api_version: None,
-                    provides: BTreeSet::default(),
                 },
                 published_at: t0_chrono,
                 download_count: 5,
@@ -306,7 +290,7 @@ async fn test_extensions_by_id(db: &Arc<Database>) {
     let versions = db.get_known_extension_versions().await.unwrap();
     assert!(versions.is_empty());
 
-    let extensions = db.get_extensions(None, None, 1, 5).await.unwrap();
+    let extensions = db.get_extensions(None, 1, 5).await.unwrap();
     assert!(extensions.is_empty());
 
     let t0 = time::OffsetDateTime::from_unix_timestamp_nanos(0).unwrap();
@@ -327,10 +311,6 @@ async fn test_extensions_by_id(db: &Arc<Database>) {
                         repository: "ext1/repo".into(),
                         schema_version: 1,
                         wasm_api_version: Some("0.0.4".into()),
-                        provides: BTreeSet::from_iter([
-                            ExtensionProvides::Grammars,
-                            ExtensionProvides::Languages,
-                        ]),
                         published_at: t0,
                     },
                     NewExtensionVersion {
@@ -341,11 +321,6 @@ async fn test_extensions_by_id(db: &Arc<Database>) {
                         repository: "ext1/repo".into(),
                         schema_version: 1,
                         wasm_api_version: Some("0.0.4".into()),
-                        provides: BTreeSet::from_iter([
-                            ExtensionProvides::Grammars,
-                            ExtensionProvides::Languages,
-                            ExtensionProvides::LanguageServers,
-                        ]),
                         published_at: t0,
                     },
                     NewExtensionVersion {
@@ -356,11 +331,6 @@ async fn test_extensions_by_id(db: &Arc<Database>) {
                         repository: "ext1/repo".into(),
                         schema_version: 1,
                         wasm_api_version: Some("0.0.5".into()),
-                        provides: BTreeSet::from_iter([
-                            ExtensionProvides::Grammars,
-                            ExtensionProvides::Languages,
-                            ExtensionProvides::LanguageServers,
-                        ]),
                         published_at: t0,
                     },
                 ],
@@ -375,7 +345,6 @@ async fn test_extensions_by_id(db: &Arc<Database>) {
                     repository: "ext2/repo".into(),
                     schema_version: 0,
                     wasm_api_version: None,
-                    provides: BTreeSet::default(),
                     published_at: t0,
                 }],
             ),
@@ -409,11 +378,6 @@ async fn test_extensions_by_id(db: &Arc<Database>) {
                 repository: "ext1/repo".into(),
                 schema_version: Some(1),
                 wasm_api_version: Some("0.0.4".into()),
-                provides: BTreeSet::from_iter([
-                    ExtensionProvides::Grammars,
-                    ExtensionProvides::Languages,
-                    ExtensionProvides::LanguageServers,
-                ]),
             },
             published_at: t0_chrono,
             download_count: 0,

crates/collab/src/rpc.rs

@@ -309,8 +309,7 @@ impl Server {
             .add_request_handler(forward_read_only_project_request::<proto::ResolveInlayHint>)
             .add_request_handler(forward_read_only_project_request::<proto::OpenBufferByPath>)
             .add_request_handler(forward_read_only_project_request::<proto::GitBranches>)
-            .add_request_handler(forward_read_only_project_request::<proto::OpenUnstagedDiff>)
-            .add_request_handler(forward_read_only_project_request::<proto::OpenUncommittedDiff>)
+            .add_request_handler(forward_read_only_project_request::<proto::GetStagedText>)
             .add_request_handler(
                 forward_mutating_project_request::<proto::RegisterBufferWithLanguageServers>,
             )
@@ -349,7 +348,7 @@ impl Server {
             .add_message_handler(broadcast_project_message_from_host::<proto::UpdateBufferFile>)
             .add_message_handler(broadcast_project_message_from_host::<proto::BufferReloaded>)
             .add_message_handler(broadcast_project_message_from_host::<proto::BufferSaved>)
-            .add_message_handler(broadcast_project_message_from_host::<proto::UpdateDiffBases>)
+            .add_message_handler(broadcast_project_message_from_host::<proto::UpdateDiffBase>)
             .add_request_handler(get_users)
             .add_request_handler(fuzzy_search_users)
             .add_request_handler(request_contact)
@@ -395,10 +394,6 @@ impl Server {
             .add_request_handler(forward_mutating_project_request::<proto::Stage>)
             .add_request_handler(forward_mutating_project_request::<proto::Unstage>)
             .add_request_handler(forward_mutating_project_request::<proto::Commit>)
-            .add_request_handler(forward_read_only_project_request::<proto::GitShow>)
-            .add_request_handler(forward_read_only_project_request::<proto::GitReset>)
-            .add_request_handler(forward_mutating_project_request::<proto::SetIndexText>)
-            .add_request_handler(forward_mutating_project_request::<proto::OpenCommitMessageBuffer>)
             .add_message_handler(broadcast_project_message_from_host::<proto::AdvertiseContexts>)
             .add_message_handler(update_context)
             .add_request_handler({

crates/collab/src/tests/channel_buffer_tests.rs

@@ -342,7 +342,7 @@ async fn test_multiple_handles_to_channel_buffer(
         future::try_join3(channel_buffer_1, channel_buffer_2, channel_buffer_3)
             .await
             .unwrap();
-    let channel_buffer_entity_id = channel_buffer.entity_id();
+    let channel_buffer_model_id = channel_buffer.entity_id();
     assert_eq!(channel_buffer, channel_buffer_2);
     assert_eq!(channel_buffer, channel_buffer_3);
 
@@ -366,7 +366,7 @@ async fn test_multiple_handles_to_channel_buffer(
         .update(cx_a, |store, cx| store.open_channel_buffer(channel_id, cx))
         .await
         .unwrap();
-    assert_ne!(channel_buffer.entity_id(), channel_buffer_entity_id);
+    assert_ne!(channel_buffer.entity_id(), channel_buffer_model_id);
     channel_buffer.update(cx_a, |buffer, cx| {
         buffer.buffer().update(cx, |buffer, _| {
             assert_eq!(buffer.text(), "hello");

crates/collab/src/tests/editor_tests.rs

@@ -1991,9 +1991,10 @@ async fn test_git_blame_is_forwarded(cx_a: &mut TestAppContext, cx_b: &mut TestA
         .collect(),
         remote_url: Some("git@github.com:zed-industries/zed.git".to_string()),
     };
-    client_a
-        .fs()
-        .set_blame_for_repo(Path::new("/my-repo/.git"), vec![("file.txt".into(), blame)]);
+    client_a.fs().set_blame_for_repo(
+        Path::new("/my-repo/.git"),
+        vec![(Path::new("file.txt"), blame)],
+    );
 
     let (project_a, worktree_id) = client_a.build_local_project("/my-repo", cx_a).await;
     let project_id = active_call_a

crates/collab/src/tests/integration_tests.rs

@@ -8,7 +8,6 @@ use crate::{
 use anyhow::{anyhow, Result};
 use assistant_context_editor::ContextStore;
 use assistant_slash_command::SlashCommandWorkingSet;
-use buffer_diff::{assert_hunks, DiffHunkSecondaryStatus, DiffHunkStatus};
 use call::{room, ActiveCall, ParticipantLocation, Room};
 use client::{User, RECEIVE_TIMEOUT};
 use collections::{HashMap, HashSet};
@@ -2559,27 +2558,13 @@ async fn test_git_diff_base_change(
 
     let project_remote = client_b.join_remote_project(project_id, cx_b).await;
 
-    let staged_text = "
+    let diff_base = "
         one
         three
     "
     .unindent();
 
-    let committed_text = "
-        one
-        TWO
-        three
-    "
-    .unindent();
-
-    let new_committed_text = "
-        one
-        TWO_HUNDRED
-        three
-    "
-    .unindent();
-
-    let new_staged_text = "
+    let new_diff_base = "
         one
         two
     "
@@ -2587,11 +2572,7 @@ async fn test_git_diff_base_change(
 
     client_a.fs().set_index_for_repo(
         Path::new("/dir/.git"),
-        &[("a.txt".into(), staged_text.clone())],
-    );
-    client_a.fs().set_head_for_repo(
-        Path::new("/dir/.git"),
-        &[("a.txt".into(), committed_text.clone())],
+        &[(Path::new("a.txt"), diff_base.clone())],
     );
 
     // Create the buffer
@@ -2599,26 +2580,26 @@ async fn test_git_diff_base_change(
         .update(cx_a, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
         .await
         .unwrap();
-    let local_unstaged_diff_a = project_local
+    let change_set_local_a = project_local
         .update(cx_a, |p, cx| {
-            p.open_unstaged_diff(buffer_local_a.clone(), cx)
+            p.open_unstaged_changes(buffer_local_a.clone(), cx)
         })
         .await
         .unwrap();
 
     // Wait for it to catch up to the new diff
     executor.run_until_parked();
-    local_unstaged_diff_a.read_with(cx_a, |diff, cx| {
+    change_set_local_a.read_with(cx_a, |change_set, cx| {
         let buffer = buffer_local_a.read(cx);
         assert_eq!(
-            diff.base_text_string().as_deref(),
-            Some(staged_text.as_str())
+            change_set.base_text_string().as_deref(),
+            Some(diff_base.as_str())
         );
-        assert_hunks(
-            diff.hunks_in_row_range(0..4, buffer, cx),
+        git::diff::assert_hunks(
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &diff.base_text_string().unwrap(),
-            &[(1..2, "", "two\n", DiffHunkStatus::added())],
+            &diff_base,
+            &[(1..2, "", "two\n")],
         );
     });
 
@@ -2627,123 +2608,73 @@ async fn test_git_diff_base_change(
         .update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
         .await
         .unwrap();
-    let remote_unstaged_diff_a = project_remote
+    let change_set_remote_a = project_remote
         .update(cx_b, |p, cx| {
-            p.open_unstaged_diff(buffer_remote_a.clone(), cx)
+            p.open_unstaged_changes(buffer_remote_a.clone(), cx)
         })
         .await
         .unwrap();
 
     // Wait remote buffer to catch up to the new diff
     executor.run_until_parked();
-    remote_unstaged_diff_a.read_with(cx_b, |diff, cx| {
+    change_set_remote_a.read_with(cx_b, |change_set, cx| {
         let buffer = buffer_remote_a.read(cx);
         assert_eq!(
-            diff.base_text_string().as_deref(),
-            Some(staged_text.as_str())
+            change_set.base_text_string().as_deref(),
+            Some(diff_base.as_str())
         );
-        assert_hunks(
-            diff.hunks_in_row_range(0..4, buffer, cx),
+        git::diff::assert_hunks(
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &diff.base_text_string().unwrap(),
-            &[(1..2, "", "two\n", DiffHunkStatus::added())],
+            &diff_base,
+            &[(1..2, "", "two\n")],
         );
     });
 
-    // Open uncommitted changes on the guest, without opening them on the host first
-    let remote_uncommitted_diff_a = project_remote
-        .update(cx_b, |p, cx| {
-            p.open_uncommitted_diff(buffer_remote_a.clone(), cx)
-        })
-        .await
-        .unwrap();
-    executor.run_until_parked();
-    remote_uncommitted_diff_a.read_with(cx_b, |diff, cx| {
-        let buffer = buffer_remote_a.read(cx);
-        assert_eq!(
-            diff.base_text_string().as_deref(),
-            Some(committed_text.as_str())
-        );
-        assert_hunks(
-            diff.hunks_in_row_range(0..4, buffer, cx),
-            buffer,
-            &diff.base_text_string().unwrap(),
-            &[(
-                1..2,
-                "TWO\n",
-                "two\n",
-                DiffHunkStatus::Modified(DiffHunkSecondaryStatus::HasSecondaryHunk),
-            )],
-        );
-    });
-
-    // Update the index text of the open buffer
+    // Update the staged text of the open buffer
     client_a.fs().set_index_for_repo(
         Path::new("/dir/.git"),
-        &[("a.txt".into(), new_staged_text.clone())],
-    );
-    client_a.fs().set_head_for_repo(
-        Path::new("/dir/.git"),
-        &[("a.txt".into(), new_committed_text.clone())],
+        &[(Path::new("a.txt"), new_diff_base.clone())],
     );
 
     // Wait for buffer_local_a to receive it
     executor.run_until_parked();
-    local_unstaged_diff_a.read_with(cx_a, |diff, cx| {
+    change_set_local_a.read_with(cx_a, |change_set, cx| {
         let buffer = buffer_local_a.read(cx);
         assert_eq!(
-            diff.base_text_string().as_deref(),
-            Some(new_staged_text.as_str())
+            change_set.base_text_string().as_deref(),
+            Some(new_diff_base.as_str())
         );
-        assert_hunks(
-            diff.hunks_in_row_range(0..4, buffer, cx),
+        git::diff::assert_hunks(
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &diff.base_text_string().unwrap(),
-            &[(2..3, "", "three\n", DiffHunkStatus::added())],
+            &new_diff_base,
+            &[(2..3, "", "three\n")],
         );
     });
 
-    remote_unstaged_diff_a.read_with(cx_b, |diff, cx| {
+    change_set_remote_a.read_with(cx_b, |change_set, cx| {
         let buffer = buffer_remote_a.read(cx);
         assert_eq!(
-            diff.base_text_string().as_deref(),
-            Some(new_staged_text.as_str())
+            change_set.base_text_string().as_deref(),
+            Some(new_diff_base.as_str())
         );
-        assert_hunks(
-            diff.hunks_in_row_range(0..4, buffer, cx),
+        git::diff::assert_hunks(
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &diff.base_text_string().unwrap(),
-            &[(2..3, "", "three\n", DiffHunkStatus::added())],
-        );
-    });
-
-    remote_uncommitted_diff_a.read_with(cx_b, |diff, cx| {
-        let buffer = buffer_remote_a.read(cx);
-        assert_eq!(
-            diff.base_text_string().as_deref(),
-            Some(new_committed_text.as_str())
-        );
-        assert_hunks(
-            diff.hunks_in_row_range(0..4, buffer, cx),
-            buffer,
-            &diff.base_text_string().unwrap(),
-            &[(
-                1..2,
-                "TWO_HUNDRED\n",
-                "two\n",
-                DiffHunkStatus::Modified(DiffHunkSecondaryStatus::OverlapsWithSecondaryHunk),
-            )],
+            &new_diff_base,
+            &[(2..3, "", "three\n")],
         );
     });
 
     // Nested git dir
-    let staged_text = "
+    let diff_base = "
         one
         three
     "
     .unindent();
 
-    let new_staged_text = "
+    let new_diff_base = "
         one
         two
     "
@@ -2751,7 +2682,7 @@ async fn test_git_diff_base_change(
 
     client_a.fs().set_index_for_repo(
         Path::new("/dir/sub/.git"),
-        &[("b.txt".into(), staged_text.clone())],
+        &[(Path::new("b.txt"), diff_base.clone())],
     );
 
     // Create the buffer
@@ -2759,26 +2690,26 @@ async fn test_git_diff_base_change(
         .update(cx_a, |p, cx| p.open_buffer((worktree_id, "sub/b.txt"), cx))
         .await
         .unwrap();
-    let local_unstaged_diff_b = project_local
+    let change_set_local_b = project_local
         .update(cx_a, |p, cx| {
-            p.open_unstaged_diff(buffer_local_b.clone(), cx)
+            p.open_unstaged_changes(buffer_local_b.clone(), cx)
         })
         .await
         .unwrap();
 
     // Wait for it to catch up to the new diff
     executor.run_until_parked();
-    local_unstaged_diff_b.read_with(cx_a, |diff, cx| {
+    change_set_local_b.read_with(cx_a, |change_set, cx| {
         let buffer = buffer_local_b.read(cx);
         assert_eq!(
-            diff.base_text_string().as_deref(),
-            Some(staged_text.as_str())
+            change_set.base_text_string().as_deref(),
+            Some(diff_base.as_str())
         );
-        assert_hunks(
-            diff.hunks_in_row_range(0..4, buffer, cx),
+        git::diff::assert_hunks(
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &diff.base_text_string().unwrap(),
-            &[(1..2, "", "two\n", DiffHunkStatus::added())],
+            &diff_base,
+            &[(1..2, "", "two\n")],
         );
     });
 
@@ -2787,61 +2718,61 @@ async fn test_git_diff_base_change(
         .update(cx_b, |p, cx| p.open_buffer((worktree_id, "sub/b.txt"), cx))
         .await
         .unwrap();
-    let remote_unstaged_diff_b = project_remote
+    let change_set_remote_b = project_remote
         .update(cx_b, |p, cx| {
-            p.open_unstaged_diff(buffer_remote_b.clone(), cx)
+            p.open_unstaged_changes(buffer_remote_b.clone(), cx)
         })
         .await
         .unwrap();
 
     executor.run_until_parked();
-    remote_unstaged_diff_b.read_with(cx_b, |diff, cx| {
+    change_set_remote_b.read_with(cx_b, |change_set, cx| {
         let buffer = buffer_remote_b.read(cx);
         assert_eq!(
-            diff.base_text_string().as_deref(),
-            Some(staged_text.as_str())
+            change_set.base_text_string().as_deref(),
+            Some(diff_base.as_str())
         );
-        assert_hunks(
-            diff.hunks_in_row_range(0..4, buffer, cx),
+        git::diff::assert_hunks(
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &staged_text,
-            &[(1..2, "", "two\n", DiffHunkStatus::added())],
+            &diff_base,
+            &[(1..2, "", "two\n")],
         );
     });
 
-    // Updatet the staged text
+    // Update the staged text
     client_a.fs().set_index_for_repo(
         Path::new("/dir/sub/.git"),
-        &[("b.txt".into(), new_staged_text.clone())],
+        &[(Path::new("b.txt"), new_diff_base.clone())],
     );
 
     // Wait for buffer_local_b to receive it
     executor.run_until_parked();
-    local_unstaged_diff_b.read_with(cx_a, |diff, cx| {
+    change_set_local_b.read_with(cx_a, |change_set, cx| {
         let buffer = buffer_local_b.read(cx);
         assert_eq!(
-            diff.base_text_string().as_deref(),
-            Some(new_staged_text.as_str())
+            change_set.base_text_string().as_deref(),
+            Some(new_diff_base.as_str())
         );
-        assert_hunks(
-            diff.hunks_in_row_range(0..4, buffer, cx),
+        git::diff::assert_hunks(
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &new_staged_text,
-            &[(2..3, "", "three\n", DiffHunkStatus::added())],
+            &new_diff_base,
+            &[(2..3, "", "three\n")],
         );
     });
 
-    remote_unstaged_diff_b.read_with(cx_b, |diff, cx| {
+    change_set_remote_b.read_with(cx_b, |change_set, cx| {
         let buffer = buffer_remote_b.read(cx);
         assert_eq!(
-            diff.base_text_string().as_deref(),
-            Some(new_staged_text.as_str())
+            change_set.base_text_string().as_deref(),
+            Some(new_diff_base.as_str())
         );
-        assert_hunks(
-            diff.hunks_in_row_range(0..4, buffer, cx),
+        git::diff::assert_hunks(
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &new_staged_text,
-            &[(2..3, "", "three\n", DiffHunkStatus::added())],
+            &new_diff_base,
+            &[(2..3, "", "three\n")],
         );
     });
 }
@@ -2895,10 +2826,7 @@ async fn test_git_branch_name(
         assert_eq!(worktrees.len(), 1);
         let worktree = worktrees[0].clone();
         let root_entry = worktree.read(cx).snapshot().root_git_entry().unwrap();
-        assert_eq!(
-            root_entry.branch().map(|branch| branch.name.to_string()),
-            branch_name
-        );
+        assert_eq!(root_entry.branch(), branch_name.map(Into::into));
     }
 
     // Smoke test branch reading
@@ -6786,7 +6714,7 @@ async fn test_remote_git_branches(
         })
     });
 
-    assert_eq!(host_branch.name, branches[2]);
+    assert_eq!(host_branch.as_ref(), branches[2]);
 
     // Also try creating a new branch
     cx_b.update(|cx| {
@@ -6807,5 +6735,5 @@ async fn test_remote_git_branches(
         })
     });
 
-    assert_eq!(host_branch.name, "totally-new-branch");
+    assert_eq!(host_branch.as_ref(), "totally-new-branch");
 }

crates/collab/src/tests/random_project_collaboration_tests.rs

@@ -953,8 +953,8 @@ impl RandomizedTest for ProjectCollaborationTest {
 
                     let dot_git_dir = repo_path.join(".git");
                     let contents = contents
-                        .into_iter()
-                        .map(|(path, contents)| (path.into(), contents))
+                        .iter()
+                        .map(|(path, contents)| (path.as_path(), contents.clone()))
                         .collect::<Vec<_>>();
                     if client.fs().metadata(&dot_git_dir).await?.is_none() {
                         client.fs().create_dir(&dot_git_dir).await?;
@@ -1339,7 +1339,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                         project
                             .buffer_store()
                             .read(cx)
-                            .get_unstaged_diff(host_buffer.read(cx).remote_id(), cx)
+                            .get_unstaged_changes(host_buffer.read(cx).remote_id())
                             .unwrap()
                             .read(cx)
                             .base_text_string()
@@ -1348,7 +1348,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                         project
                             .buffer_store()
                             .read(cx)
-                            .get_unstaged_diff(guest_buffer.read(cx).remote_id(), cx)
+                            .get_unstaged_changes(guest_buffer.read(cx).remote_id())
                             .unwrap()
                             .read(cx)
                             .base_text_string()

crates/collab/src/tests/remote_editing_collaboration_tests.rs

@@ -314,7 +314,7 @@ async fn test_ssh_collaboration_git_branches(
         })
     });
 
-    assert_eq!(server_branch.name, branches[2]);
+    assert_eq!(server_branch.as_ref(), branches[2]);
 
     // Also try creating a new branch
     cx_b.update(|cx| {
@@ -337,7 +337,7 @@ async fn test_ssh_collaboration_git_branches(
         })
     });
 
-    assert_eq!(server_branch.name, "totally-new-branch");
+    assert_eq!(server_branch.as_ref(), "totally-new-branch");
 }
 
 #[gpui::test]

crates/collab/src/tests/test_server.rs

@@ -849,10 +849,10 @@ impl TestClient {
     ) -> (Entity<Workspace>, &'a mut VisualTestContext) {
         let window = cx.update(|cx| cx.active_window().unwrap().downcast::<Workspace>().unwrap());
 
-        let entity = window.root(cx).unwrap();
+        let model = window.root(cx).unwrap();
         let cx = VisualTestContext::from_window(*window.deref(), cx).as_mut();
         // it might be nice to try and cleanup these at the end of each test.
-        (entity, cx)
+        (model, cx)
     }
 }
 
@@ -861,9 +861,9 @@ pub fn open_channel_notes(
     cx: &mut VisualTestContext,
 ) -> Task<anyhow::Result<Entity<ChannelView>>> {
     let window = cx.update(|_, cx| cx.active_window().unwrap().downcast::<Workspace>().unwrap());
-    let entity = window.root(cx).unwrap();
+    let model = window.root(cx).unwrap();
 
-    cx.update(|window, cx| ChannelView::open(channel_id, None, entity.clone(), window, cx))
+    cx.update(|window, cx| ChannelView::open(channel_id, None, model.clone(), window, cx))
 }
 
 impl Drop for TestClient {

crates/collab_ui/src/channel_view.rs

@@ -461,7 +461,7 @@ impl Item for ChannelView {
             .child(
                 Label::new(channel_name)
                     .color(params.text_color())
-                    .when(params.preview, |this| this.italic()),
+                    .italic(params.preview),
             )
             .when_some(status, |element, status| {
                 element.child(

crates/collab_ui/src/chat_panel.rs

@@ -97,14 +97,14 @@ impl ChatPanel {
         });
 
         cx.new(|cx| {
-            let entity = cx.entity().downgrade();
+            let model = cx.entity().downgrade();
             let message_list = ListState::new(
                 0,
                 gpui::ListAlignment::Bottom,
                 px(1000.),
                 move |ix, window, cx| {
-                    if let Some(entity) = entity.upgrade() {
-                        entity.update(cx, |this: &mut Self, cx| {
+                    if let Some(model) = model.upgrade() {
+                        model.update(cx, |this: &mut Self, cx| {
                             this.render_message(ix, window, cx).into_any_element()
                         })
                     } else {

crates/collab_ui/src/collab_panel.rs

@@ -239,14 +239,14 @@ impl CollabPanel {
             )
             .detach();
 
-            let entity = cx.entity().downgrade();
+            let model = cx.entity().downgrade();
             let list_state = ListState::new(
                 0,
                 gpui::ListAlignment::Top,
                 px(1000.),
                 move |ix, window, cx| {
-                    if let Some(entity) = entity.upgrade() {
-                        entity.update(cx, |this, cx| this.render_list_entry(ix, window, cx))
+                    if let Some(model) = model.upgrade() {
+                        model.update(cx, |this, cx| this.render_list_entry(ix, window, cx))
                     } else {
                         div().into_any()
                     }

crates/collab_ui/src/notification_panel.rs

@@ -110,13 +110,13 @@ impl NotificationPanel {
             })
             .detach();
 
-            let entity = cx.entity().downgrade();
+            let model = cx.entity().downgrade();
             let notification_list =
                 ListState::new(0, ListAlignment::Top, px(1000.), move |ix, window, cx| {
-                    entity
+                    model
                         .upgrade()
-                        .and_then(|entity| {
-                            entity.update(cx, |this, cx| this.render_notification(ix, window, cx))
+                        .and_then(|model| {
+                            model.update(cx, |this, cx| this.render_notification(ix, window, cx))
                         })
                         .unwrap_or_else(|| div().into_any())
                 });
@@ -323,9 +323,9 @@ impl NotificationPanel {
                                             .justify_end()
                                             .child(Button::new("decline", "Decline").on_click({
                                                 let notification = notification.clone();
-                                                let entity = cx.entity().clone();
+                                                let model = cx.entity().clone();
                                                 move |_, _, cx| {
-                                                    entity.update(cx, |this, cx| {
+                                                    model.update(cx, |this, cx| {
                                                         this.respond_to_notification(
                                                             notification.clone(),
                                                             false,
@@ -336,9 +336,9 @@ impl NotificationPanel {
                                             }))
                                             .child(Button::new("accept", "Accept").on_click({
                                                 let notification = notification.clone();
-                                                let entity = cx.entity().clone();
+                                                let model = cx.entity().clone();
                                                 move |_, _, cx| {
-                                                    entity.update(cx, |this, cx| {
+                                                    model.update(cx, |this, cx| {
                                                         this.respond_to_notification(
                                                             notification.clone(),
                                                             true,

crates/command_palette/src/command_palette.rs

@@ -198,29 +198,26 @@ impl CommandPaletteDelegate {
     ) {
         self.updating_matches.take();
 
-        let mut intercept_results = CommandPaletteInterceptor::try_global(cx)
-            .map(|interceptor| interceptor.intercept(&query, cx))
-            .unwrap_or_default();
+        let mut intercept_result = CommandPaletteInterceptor::try_global(cx)
+            .and_then(|interceptor| interceptor.intercept(&query, cx));
 
         if parse_zed_link(&query, cx).is_some() {
-            intercept_results = vec![CommandInterceptResult {
+            intercept_result = Some(CommandInterceptResult {
                 action: OpenZedUrl { url: query.clone() }.boxed_clone(),
                 string: query.clone(),
                 positions: vec![],
-            }]
+            })
         }
 
-        let mut new_matches = Vec::new();
-
-        for CommandInterceptResult {
+        if let Some(CommandInterceptResult {
             action,
             string,
             positions,
-        } in intercept_results
+        }) = intercept_result
         {
             if let Some(idx) = matches
                 .iter()
-                .position(|m| commands[m.candidate_id].action.partial_eq(&*action))
+                .position(|m| commands[m.candidate_id].action.type_id() == action.type_id())
             {
                 matches.remove(idx);
             }
@@ -228,16 +225,18 @@ impl CommandPaletteDelegate {
                 name: string.clone(),
                 action,
             });
-            new_matches.push(StringMatch {
-                candidate_id: commands.len() - 1,
-                string,
-                positions,
-                score: 0.0,
-            })
+            matches.insert(
+                0,
+                StringMatch {
+                    candidate_id: commands.len() - 1,
+                    string,
+                    positions,
+                    score: 0.0,
+                },
+            )
         }
-        new_matches.append(&mut matches);
         self.commands = commands;
-        self.matches = new_matches;
+        self.matches = matches;
         if self.matches.is_empty() {
             self.selected_ix = 0;
         } else {

crates/command_palette_hooks/src/command_palette_hooks.rs

@@ -108,7 +108,7 @@ pub struct CommandInterceptResult {
 /// An interceptor for the command palette.
 #[derive(Default)]
 pub struct CommandPaletteInterceptor(
-    Option<Box<dyn Fn(&str, &App) -> Vec<CommandInterceptResult>>>,
+    Option<Box<dyn Fn(&str, &App) -> Option<CommandInterceptResult>>>,
 );
 
 #[derive(Default)]
@@ -132,12 +132,10 @@ impl CommandPaletteInterceptor {
     }
 
     /// Intercepts the given query from the command palette.
-    pub fn intercept(&self, query: &str, cx: &App) -> Vec<CommandInterceptResult> {
-        if let Some(handler) = self.0.as_ref() {
-            (handler)(query, cx)
-        } else {
-            Vec::new()
-        }
+    pub fn intercept(&self, query: &str, cx: &App) -> Option<CommandInterceptResult> {
+        let handler = self.0.as_ref()?;
+
+        (handler)(query, cx)
     }
 
     /// Clears the global interceptor.
@@ -148,7 +146,7 @@ impl CommandPaletteInterceptor {
     /// Sets the global interceptor.
     ///
     /// This will override the previous interceptor, if it exists.
-    pub fn set(&mut self, handler: Box<dyn Fn(&str, &App) -> Vec<CommandInterceptResult>>) {
+    pub fn set(&mut self, handler: Box<dyn Fn(&str, &App) -> Option<CommandInterceptResult>>) {
         self.0 = Some(handler);
     }
 }

crates/component/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "component"
-version = "0.1.0"
-edition.workspace = true
-publish.workspace = true
-license = "GPL-3.0-or-later"
-
-[lints]
-workspace = true
-
-[lib]
-path = "src/component.rs"
-
-[dependencies]
-collections.workspace = true
-gpui.workspace = true
-linkme.workspace = true
-once_cell = "1.20.3"
-parking_lot.workspace = true
-theme.workspace = true
-
-[features]
-default = []

crates/component/src/component.rs

@@ -1,327 +0,0 @@
-use std::ops::{Deref, DerefMut};
-
-use collections::HashMap;
-use gpui::{div, prelude::*, px, AnyElement, App, IntoElement, RenderOnce, SharedString, Window};
-use linkme::distributed_slice;
-use once_cell::sync::Lazy;
-use parking_lot::RwLock;
-use theme::ActiveTheme;
-
-pub trait Component {
-    fn scope() -> Option<&'static str>;
-    fn name() -> &'static str {
-        std::any::type_name::<Self>()
-    }
-    fn description() -> Option<&'static str> {
-        None
-    }
-}
-
-pub trait ComponentPreview: Component {
-    fn preview(_window: &mut Window, _cx: &App) -> AnyElement;
-}
-
-#[distributed_slice]
-pub static __ALL_COMPONENTS: [fn()] = [..];
-
-#[distributed_slice]
-pub static __ALL_PREVIEWS: [fn()] = [..];
-
-pub static COMPONENT_DATA: Lazy<RwLock<ComponentRegistry>> =
-    Lazy::new(|| RwLock::new(ComponentRegistry::new()));
-
-pub struct ComponentRegistry {
-    components: Vec<(Option<&'static str>, &'static str, Option<&'static str>)>,
-    previews: HashMap<&'static str, fn(&mut Window, &App) -> AnyElement>,
-}
-
-impl ComponentRegistry {
-    fn new() -> Self {
-        ComponentRegistry {
-            components: Vec::new(),
-            previews: HashMap::default(),
-        }
-    }
-}
-
-pub fn init() {
-    let component_fns: Vec<_> = __ALL_COMPONENTS.iter().cloned().collect();
-    let preview_fns: Vec<_> = __ALL_PREVIEWS.iter().cloned().collect();
-
-    for f in component_fns {
-        f();
-    }
-    for f in preview_fns {
-        f();
-    }
-}
-
-pub fn register_component<T: Component>() {
-    let component_data = (T::scope(), T::name(), T::description());
-    COMPONENT_DATA.write().components.push(component_data);
-}
-
-pub fn register_preview<T: ComponentPreview>() {
-    let preview_data = (T::name(), T::preview as fn(&mut Window, &App) -> AnyElement);
-    COMPONENT_DATA
-        .write()
-        .previews
-        .insert(preview_data.0, preview_data.1);
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ComponentId(pub &'static str);
-
-#[derive(Clone)]
-pub struct ComponentMetadata {
-    name: SharedString,
-    scope: Option<SharedString>,
-    description: Option<SharedString>,
-    preview: Option<fn(&mut Window, &App) -> AnyElement>,
-}
-
-impl ComponentMetadata {
-    pub fn name(&self) -> SharedString {
-        self.name.clone()
-    }
-
-    pub fn scope(&self) -> Option<SharedString> {
-        self.scope.clone()
-    }
-
-    pub fn description(&self) -> Option<SharedString> {
-        self.description.clone()
-    }
-
-    pub fn preview(&self) -> Option<fn(&mut Window, &App) -> AnyElement> {
-        self.preview
-    }
-}
-
-pub struct AllComponents(pub HashMap<ComponentId, ComponentMetadata>);
-
-impl AllComponents {
-    pub fn new() -> Self {
-        AllComponents(HashMap::default())
-    }
-
-    /// Returns all components with previews
-    pub fn all_previews(&self) -> Vec<&ComponentMetadata> {
-        self.0.values().filter(|c| c.preview.is_some()).collect()
-    }
-
-    /// Returns all components with previews sorted by name
-    pub fn all_previews_sorted(&self) -> Vec<ComponentMetadata> {
-        let mut previews: Vec<ComponentMetadata> =
-            self.all_previews().into_iter().cloned().collect();
-        previews.sort_by_key(|a| a.name());
-        previews
-    }
-
-    /// Returns all components
-    pub fn all(&self) -> Vec<&ComponentMetadata> {
-        self.0.values().collect()
-    }
-
-    /// Returns all components sorted by name
-    pub fn all_sorted(&self) -> Vec<ComponentMetadata> {
-        let mut components: Vec<ComponentMetadata> = self.all().into_iter().cloned().collect();
-        components.sort_by_key(|a| a.name());
-        components
-    }
-}
-
-impl Deref for AllComponents {
-    type Target = HashMap<ComponentId, ComponentMetadata>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl DerefMut for AllComponents {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
-pub fn components() -> AllComponents {
-    let data = COMPONENT_DATA.read();
-    let mut all_components = AllComponents::new();
-
-    for &(scope, name, description) in &data.components {
-        let scope = scope.map(Into::into);
-        let preview = data.previews.get(name).cloned();
-        all_components.insert(
-            ComponentId(name),
-            ComponentMetadata {
-                name: name.into(),
-                scope,
-                description: description.map(Into::into),
-                preview,
-            },
-        );
-    }
-
-    all_components
-}
-
-/// Which side of the preview to show labels on
-#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ExampleLabelSide {
-    /// Left side
-    Left,
-    /// Right side
-    Right,
-    #[default]
-    /// Top side
-    Top,
-    /// Bottom side
-    Bottom,
-}
-
-/// A single example of a component.
-#[derive(IntoElement)]
-pub struct ComponentExample {
-    variant_name: SharedString,
-    element: AnyElement,
-    label_side: ExampleLabelSide,
-    grow: bool,
-}
-
-impl RenderOnce for ComponentExample {
-    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let base = div().flex();
-
-        let base = match self.label_side {
-            ExampleLabelSide::Right => base.flex_row(),
-            ExampleLabelSide::Left => base.flex_row_reverse(),
-            ExampleLabelSide::Bottom => base.flex_col(),
-            ExampleLabelSide::Top => base.flex_col_reverse(),
-        };
-
-        base.gap_1()
-            .p_2()
-            .text_sm()
-            .text_color(cx.theme().colors().text)
-            .when(self.grow, |this| this.flex_1())
-            .child(self.element)
-            .child(self.variant_name)
-            .into_any_element()
-    }
-}
-
-impl ComponentExample {
-    /// Create a new example with the given variant name and example value.
-    pub fn new(variant_name: impl Into<SharedString>, element: AnyElement) -> Self {
-        Self {
-            variant_name: variant_name.into(),
-            element,
-            label_side: ExampleLabelSide::default(),
-            grow: false,
-        }
-    }
-
-    /// Set the example to grow to fill the available horizontal space.
-    pub fn grow(mut self) -> Self {
-        self.grow = true;
-        self
-    }
-}
-
-/// A group of component examples.
-#[derive(IntoElement)]
-pub struct ComponentExampleGroup {
-    pub title: Option<SharedString>,
-    pub examples: Vec<ComponentExample>,
-    pub grow: bool,
-}
-
-impl RenderOnce for ComponentExampleGroup {
-    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        div()
-            .flex_col()
-            .text_sm()
-            .text_color(cx.theme().colors().text_muted)
-            .when(self.grow, |this| this.w_full().flex_1())
-            .when_some(self.title, |this, title| {
-                this.gap_4().pb_5().child(
-                    div()
-                        .flex()
-                        .items_center()
-                        .gap_3()
-                        .child(div().h_px().w_4().bg(cx.theme().colors().border_variant))
-                        .child(
-                            div()
-                                .flex_none()
-                                .text_size(px(10.))
-                                .child(title.to_uppercase()),
-                        )
-                        .child(
-                            div()
-                                .h_px()
-                                .w_full()
-                                .flex_1()
-                                .bg(cx.theme().colors().border),
-                        ),
-                )
-            })
-            .child(
-                div()
-                    .flex()
-                    .items_start()
-                    .w_full()
-                    .gap_8()
-                    .children(self.examples)
-                    .into_any_element(),
-            )
-            .into_any_element()
-    }
-}
-
-impl ComponentExampleGroup {
-    /// Create a new group of examples with the given title.
-    pub fn new(examples: Vec<ComponentExample>) -> Self {
-        Self {
-            title: None,
-            examples,
-            grow: false,
-        }
-    }
-
-    /// Create a new group of examples with the given title.
-    pub fn with_title(title: impl Into<SharedString>, examples: Vec<ComponentExample>) -> Self {
-        Self {
-            title: Some(title.into()),
-            examples,
-            grow: false,
-        }
-    }
-
-    /// Set the group to grow to fill the available horizontal space.
-    pub fn grow(mut self) -> Self {
-        self.grow = true;
-        self
-    }
-}
-
-/// Create a single example
-pub fn single_example(
-    variant_name: impl Into<SharedString>,
-    example: AnyElement,
-) -> ComponentExample {
-    ComponentExample::new(variant_name, example)
-}
-
-/// Create a group of examples without a title
-pub fn example_group(examples: Vec<ComponentExample>) -> ComponentExampleGroup {
-    ComponentExampleGroup::new(examples)
-}
-
-/// Create a group of examples with a title
-pub fn example_group_with_title(
-    title: impl Into<SharedString>,
-    examples: Vec<ComponentExample>,
-) -> ComponentExampleGroup {
-    ComponentExampleGroup::with_title(title, examples)
-}

crates/component_preview/Cargo.toml

@@ -1,21 +0,0 @@
-[package]
-name = "component_preview"
-version = "0.1.0"
-edition.workspace = true
-publish.workspace = true
-license = "GPL-3.0-or-later"
-
-[lints]
-workspace = true
-
-[lib]
-path = "src/component_preview.rs"
-
-[features]
-default = []
-
-[dependencies]
-component.workspace = true
-gpui.workspace = true
-ui.workspace = true
-workspace.workspace = true

crates/component_preview/LICENSE-GPL

@@ -1 +0,0 @@
-../../LICENSE-GPL

crates/component_preview/src/component_preview.rs

@@ -1,190 +0,0 @@
-//! # Component Preview
-//!
-//! A view for exploring Zed components.
-
-use component::{components, ComponentMetadata};
-use gpui::{prelude::*, App, EventEmitter, FocusHandle, Focusable, Window};
-use ui::prelude::*;
-
-use workspace::{item::ItemEvent, Item, Workspace, WorkspaceId};
-
-pub fn init(cx: &mut App) {
-    cx.observe_new(|workspace: &mut Workspace, _, _cx| {
-        workspace.register_action(
-            |workspace, _: &workspace::OpenComponentPreview, window, cx| {
-                let component_preview = cx.new(ComponentPreview::new);
-                workspace.add_item_to_active_pane(
-                    Box::new(component_preview),
-                    None,
-                    true,
-                    window,
-                    cx,
-                )
-            },
-        );
-    })
-    .detach();
-}
-
-struct ComponentPreview {
-    focus_handle: FocusHandle,
-}
-
-impl ComponentPreview {
-    pub fn new(cx: &mut Context<Self>) -> Self {
-        Self {
-            focus_handle: cx.focus_handle(),
-        }
-    }
-
-    fn render_sidebar(&self, _window: &Window, _cx: &Context<Self>) -> impl IntoElement {
-        let components = components().all_sorted();
-        let sorted_components = components.clone();
-
-        v_flex()
-            .max_w_48()
-            .gap_px()
-            .p_1()
-            .children(
-                sorted_components
-                    .into_iter()
-                    .map(|component| self.render_sidebar_entry(&component, _cx)),
-            )
-            .child(
-                Label::new("These will be clickable once the layout is moved to a gpui::List.")
-                    .color(Color::Muted)
-                    .size(LabelSize::XSmall)
-                    .italic(),
-            )
-    }
-
-    fn render_sidebar_entry(
-        &self,
-        component: &ComponentMetadata,
-        _cx: &Context<Self>,
-    ) -> impl IntoElement {
-        h_flex()
-            .w_40()
-            .px_1p5()
-            .py_0p5()
-            .text_sm()
-            .child(component.name().clone())
-    }
-
-    fn render_preview(
-        &self,
-        component: &ComponentMetadata,
-        window: &mut Window,
-        cx: &Context<Self>,
-    ) -> impl IntoElement {
-        let name = component.name();
-        let scope = component.scope();
-
-        let description = component.description();
-
-        v_flex()
-            .border_b_1()
-            .border_color(cx.theme().colors().border)
-            .w_full()
-            .gap_3()
-            .py_6()
-            .child(
-                v_flex()
-                    .gap_1()
-                    .child(
-                        h_flex()
-                            .gap_1()
-                            .text_2xl()
-                            .child(div().child(name))
-                            .when_some(scope, |this, scope| {
-                                this.child(div().opacity(0.5).child(format!("({})", scope)))
-                            }),
-                    )
-                    .when_some(description, |this, description| {
-                        this.child(
-                            div()
-                                .text_ui_sm(cx)
-                                .text_color(cx.theme().colors().text_muted)
-                                .max_w(px(600.0))
-                                .child(description),
-                        )
-                    }),
-            )
-            .when_some(component.preview(), |this, preview| {
-                this.child(preview(window, cx))
-            })
-            .into_any_element()
-    }
-
-    fn render_previews(&self, window: &mut Window, cx: &Context<Self>) -> impl IntoElement {
-        v_flex()
-            .id("component-previews")
-            .size_full()
-            .overflow_y_scroll()
-            .p_4()
-            .gap_4()
-            .children(
-                components()
-                    .all_previews_sorted()
-                    .iter()
-                    .map(|component| self.render_preview(component, window, cx)),
-            )
-    }
-}
-
-impl Render for ComponentPreview {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<'_, Self>) -> impl IntoElement {
-        h_flex()
-            .id("component-preview")
-            .key_context("ComponentPreview")
-            .items_start()
-            .overflow_hidden()
-            .size_full()
-            .max_h_full()
-            .track_focus(&self.focus_handle)
-            .px_2()
-            .bg(cx.theme().colors().editor_background)
-            .child(self.render_sidebar(window, cx))
-            .child(self.render_previews(window, cx))
-    }
-}
-
-impl EventEmitter<ItemEvent> for ComponentPreview {}
-
-impl Focusable for ComponentPreview {
-    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
-        self.focus_handle.clone()
-    }
-}
-
-impl Item for ComponentPreview {
-    type Event = ItemEvent;
-
-    fn tab_content_text(&self, _window: &Window, _cx: &App) -> Option<SharedString> {
-        Some("Component Preview".into())
-    }
-
-    fn telemetry_event_text(&self) -> Option<&'static str> {
-        None
-    }
-
-    fn show_toolbar(&self) -> bool {
-        false
-    }
-
-    fn clone_on_split(
-        &self,
-        _workspace_id: Option<WorkspaceId>,
-        _window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Option<gpui::Entity<Self>>
-    where
-        Self: Sized,
-    {
-        Some(cx.new(Self::new))
-    }
-
-    fn to_item_events(event: &Self::Event, mut f: impl FnMut(workspace::item::ItemEvent)) {
-        f(*event)
-    }
-}

crates/copilot/Cargo.toml

@@ -59,20 +59,20 @@ workspace.workspace = true
 async-std = { version = "1.12.0", features = ["unstable"] }
 
 [dev-dependencies]
-client = { workspace = true, features = ["test-support"] }
+indoc.workspace = true
+serde_json.workspace = true
 clock = { workspace = true, features = ["test-support"] }
+client = { workspace = true, features = ["test-support"] }
 collections = { workspace = true, features = ["test-support"] }
 editor = { workspace = true, features = ["test-support"] }
 fs = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, features = ["test-support"] }
 http_client = { workspace = true, features = ["test-support"] }
-indoc.workspace = true
 language = { workspace = true, features = ["test-support"] }
 lsp = { workspace = true, features = ["test-support"] }
 node_runtime = { workspace = true, features = ["test-support"] }
 project = { workspace = true, features = ["test-support"] }
 rpc = { workspace = true, features = ["test-support"] }
-serde_json.workspace = true
 settings = { workspace = true, features = ["test-support"] }
 theme = { workspace = true, features = ["test-support"] }
 util = { workspace = true, features = ["test-support"] }

crates/copilot/src/copilot.rs

@@ -17,7 +17,7 @@ use gpui::{
 use http_client::github::get_release_by_tag_name;
 use http_client::HttpClient;
 use language::{
-    language_settings::{all_language_settings, language_settings, EditPredictionProvider},
+    language_settings::{all_language_settings, language_settings, InlineCompletionProvider},
     point_from_lsp, point_to_lsp, Anchor, Bias, Buffer, BufferSnapshot, Language, PointUtf16,
     ToPointUtf16,
 };
@@ -368,8 +368,8 @@ impl Copilot {
         let server_id = self.server_id;
         let http = self.http.clone();
         let node_runtime = self.node_runtime.clone();
-        if all_language_settings(None, cx).edit_predictions.provider
-            == EditPredictionProvider::Copilot
+        if all_language_settings(None, cx).inline_completions.provider
+            == InlineCompletionProvider::Copilot
         {
             if matches!(self.server, CopilotServer::Disabled) {
                 let start_task = cx
@@ -1061,7 +1061,6 @@ async fn get_copilot_lsp(http: Arc<dyn HttpClient>) -> anyhow::Result<PathBuf> {
 mod tests {
     use super::*;
     use gpui::TestAppContext;
-    use util::path;
 
     #[gpui::test(iterations = 10)]
     async fn test_buffer_management(cx: &mut TestAppContext) {
@@ -1124,7 +1123,7 @@ mod tests {
         buffer_1.update(cx, |buffer, cx| {
             buffer.file_updated(
                 Arc::new(File {
-                    abs_path: path!("/root/child/buffer-1").into(),
+                    abs_path: "/root/child/buffer-1".into(),
                     path: Path::new("child/buffer-1").into(),
                 }),
                 cx,
@@ -1137,7 +1136,7 @@ mod tests {
                 text_document: lsp::TextDocumentIdentifier::new(buffer_1_uri),
             }
         );
-        let buffer_1_uri = lsp::Url::from_file_path(path!("/root/child/buffer-1")).unwrap();
+        let buffer_1_uri = lsp::Url::from_file_path("/root/child/buffer-1").unwrap();
         assert_eq!(
             lsp.receive_notification::<lsp::notification::DidOpenTextDocument>()
                 .await,

crates/copilot/src/copilot_chat.rs

@@ -36,8 +36,8 @@ pub enum Model {
     Gpt3_5Turbo,
     #[serde(alias = "o1", rename = "o1")]
     O1,
-    #[serde(alias = "o1-mini", rename = "o3-mini")]
-    O3Mini,
+    #[serde(alias = "o1-mini", rename = "o1-mini")]
+    O1Mini,
     #[serde(alias = "claude-3-5-sonnet", rename = "claude-3.5-sonnet")]
     Claude3_5Sonnet,
 }
@@ -46,7 +46,7 @@ impl Model {
     pub fn uses_streaming(&self) -> bool {
         match self {
             Self::Gpt4o | Self::Gpt4 | Self::Gpt3_5Turbo | Self::Claude3_5Sonnet => true,
-            Self::O3Mini | Self::O1 => false,
+            Self::O1Mini | Self::O1 => false,
         }
     }
 
@@ -56,7 +56,7 @@ impl Model {
             "gpt-4" => Ok(Self::Gpt4),
             "gpt-3.5-turbo" => Ok(Self::Gpt3_5Turbo),
             "o1" => Ok(Self::O1),
-            "o3-mini" => Ok(Self::O3Mini),
+            "o1-mini" => Ok(Self::O1Mini),
             "claude-3-5-sonnet" => Ok(Self::Claude3_5Sonnet),
             _ => Err(anyhow!("Invalid model id: {}", id)),
         }
@@ -67,7 +67,7 @@ impl Model {
             Self::Gpt3_5Turbo => "gpt-3.5-turbo",
             Self::Gpt4 => "gpt-4",
             Self::Gpt4o => "gpt-4o",
-            Self::O3Mini => "o3-mini",
+            Self::O1Mini => "o1-mini",
             Self::O1 => "o1",
             Self::Claude3_5Sonnet => "claude-3-5-sonnet",
         }
@@ -78,7 +78,7 @@ impl Model {
             Self::Gpt3_5Turbo => "GPT-3.5",
             Self::Gpt4 => "GPT-4",
             Self::Gpt4o => "GPT-4o",
-            Self::O3Mini => "o3-mini",
+            Self::O1Mini => "o1-mini",
             Self::O1 => "o1",
             Self::Claude3_5Sonnet => "Claude 3.5 Sonnet",
         }
@@ -89,7 +89,7 @@ impl Model {
             Self::Gpt4o => 64000,
             Self::Gpt4 => 32768,
             Self::Gpt3_5Turbo => 12288,
-            Self::O3Mini => 20000,
+            Self::O1Mini => 20000,
             Self::O1 => 20000,
             Self::Claude3_5Sonnet => 200_000,
         }

crates/copilot/src/copilot_completion_provider.rs

@@ -1,9 +1,11 @@
 use crate::{Completion, Copilot};
 use anyhow::Result;
 use gpui::{App, Context, Entity, EntityId, Task};
-use inline_completion::{Direction, EditPredictionProvider, InlineCompletion};
-use language::{language_settings::AllLanguageSettings, Buffer, OffsetRangeExt, ToOffset};
-use project::Project;
+use inline_completion::{Direction, InlineCompletion, InlineCompletionProvider};
+use language::{
+    language_settings::{all_language_settings, AllLanguageSettings},
+    Buffer, OffsetRangeExt, ToOffset,
+};
 use settings::Settings;
 use std::{path::Path, time::Duration};
 
@@ -48,7 +50,7 @@ impl CopilotCompletionProvider {
     }
 }
 
-impl EditPredictionProvider for CopilotCompletionProvider {
+impl InlineCompletionProvider for CopilotCompletionProvider {
     fn name() -> &'static str {
         "copilot"
     }
@@ -61,22 +63,33 @@ impl EditPredictionProvider for CopilotCompletionProvider {
         false
     }
 
+    fn show_completions_in_normal_mode() -> bool {
+        false
+    }
+
     fn is_refreshing(&self) -> bool {
         self.pending_refresh.is_some()
     }
 
     fn is_enabled(
         &self,
-        _buffer: &Entity<Buffer>,
-        _cursor_position: language::Anchor,
+        buffer: &Entity<Buffer>,
+        cursor_position: language::Anchor,
         cx: &App,
     ) -> bool {
-        self.copilot.read(cx).status().is_authorized()
+        if !self.copilot.read(cx).status().is_authorized() {
+            return false;
+        }
+
+        let buffer = buffer.read(cx);
+        let file = buffer.file();
+        let language = buffer.language_at(cursor_position);
+        let settings = all_language_settings(file, cx);
+        settings.inline_completions_enabled(language.as_ref(), file.map(|f| f.path().as_ref()), cx)
     }
 
     fn refresh(
         &mut self,
-        _project: Option<Entity<Project>>,
         buffer: Entity<Buffer>,
         cursor_position: language::Anchor,
         debounce: bool,
@@ -192,7 +205,7 @@ impl EditPredictionProvider for CopilotCompletionProvider {
     fn discard(&mut self, cx: &mut Context<Self>) {
         let settings = AllLanguageSettings::get_global(cx);
 
-        let copilot_enabled = settings.show_inline_completions(None, cx);
+        let copilot_enabled = settings.inline_completions_enabled(None, None, cx);
 
         if !copilot_enabled {
             return;
@@ -242,7 +255,6 @@ impl EditPredictionProvider for CopilotCompletionProvider {
             } else {
                 let position = cursor_position.bias_right(buffer);
                 Some(InlineCompletion {
-                    id: None,
                     edits: vec![(position..position, completion_text.into())],
                     edit_preview: None,
                 })
@@ -278,10 +290,7 @@ mod tests {
     use serde_json::json;
     use settings::SettingsStore;
     use std::future::Future;
-    use util::{
-        path,
-        test::{marked_text_ranges_by, TextRangeMarker},
-    };
+    use util::test::{marked_text_ranges_by, TextRangeMarker};
 
     #[gpui::test(iterations = 10)]
     async fn test_copilot(executor: BackgroundExecutor, cx: &mut TestAppContext) {
@@ -302,7 +311,7 @@ mod tests {
         .await;
         let copilot_provider = cx.new(|_| CopilotCompletionProvider::new(copilot));
         cx.update_editor(|editor, window, cx| {
-            editor.set_edit_prediction_provider(Some(copilot_provider), window, cx)
+            editor.set_inline_completion_provider(Some(copilot_provider), window, cx)
         });
 
         cx.set_state(indoc! {"
@@ -332,6 +341,7 @@ mod tests {
         executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
         cx.update_editor(|editor, window, cx| {
             assert!(editor.context_menu_visible());
+            assert!(!editor.context_menu_contains_inline_completion());
             assert!(!editor.has_active_inline_completion());
             // Since we have both, the copilot suggestion is not shown inline
             assert_eq!(editor.text(cx), "one.\ntwo\nthree\n");
@@ -384,11 +394,12 @@ mod tests {
             assert_eq!(editor.text(cx), "one.\ntwo\nthree\n");
         });
 
-        // Ensure existing edit prediction is interpolated when inserting again.
+        // Ensure existing inline completion is interpolated when inserting again.
         cx.simulate_keystroke("c");
         executor.run_until_parked();
         cx.update_editor(|editor, _, cx| {
             assert!(!editor.context_menu_visible());
+            assert!(!editor.context_menu_contains_inline_completion());
             assert!(editor.has_active_inline_completion());
             assert_eq!(editor.display_text(cx), "one.copilot1\ntwo\nthree\n");
             assert_eq!(editor.text(cx), "one.c\ntwo\nthree\n");
@@ -408,6 +419,7 @@ mod tests {
         cx.update_editor(|editor, window, cx| {
             assert!(!editor.context_menu_visible());
             assert!(editor.has_active_inline_completion());
+            assert!(!editor.context_menu_contains_inline_completion());
             assert_eq!(editor.display_text(cx), "one.copilot2\ntwo\nthree\n");
             assert_eq!(editor.text(cx), "one.c\ntwo\nthree\n");
 
@@ -437,8 +449,8 @@ mod tests {
             assert_eq!(editor.display_text(cx), "one.copilot2\ntwo\nthree\n");
             assert_eq!(editor.text(cx), "one.co\ntwo\nthree\n");
 
-            // AcceptEditPrediction when there is an active suggestion inserts it.
-            editor.accept_edit_prediction(&Default::default(), window, cx);
+            // AcceptInlineCompletion when there is an active suggestion inserts it.
+            editor.accept_inline_completion(&Default::default(), window, cx);
             assert!(!editor.has_active_inline_completion());
             assert_eq!(editor.display_text(cx), "one.copilot2\ntwo\nthree\n");
             assert_eq!(editor.text(cx), "one.copilot2\ntwo\nthree\n");
@@ -483,7 +495,7 @@ mod tests {
         );
 
         cx.update_editor(|editor, window, cx| {
-            editor.next_edit_prediction(&Default::default(), window, cx)
+            editor.next_inline_completion(&Default::default(), window, cx)
         });
         executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
         cx.update_editor(|editor, window, cx| {
@@ -497,8 +509,8 @@ mod tests {
             assert_eq!(editor.text(cx), "fn foo() {\n    \n}");
             assert_eq!(editor.display_text(cx), "fn foo() {\n    let x = 4;\n}");
 
-            // Using AcceptEditPrediction again accepts the suggestion.
-            editor.accept_edit_prediction(&Default::default(), window, cx);
+            // Using AcceptInlineCompletion again accepts the suggestion.
+            editor.accept_inline_completion(&Default::default(), window, cx);
             assert!(!editor.has_active_inline_completion());
             assert_eq!(editor.text(cx), "fn foo() {\n    let x = 4;\n}");
             assert_eq!(editor.display_text(cx), "fn foo() {\n    let x = 4;\n}");
@@ -527,7 +539,7 @@ mod tests {
         .await;
         let copilot_provider = cx.new(|_| CopilotCompletionProvider::new(copilot));
         cx.update_editor(|editor, window, cx| {
-            editor.set_edit_prediction_provider(Some(copilot_provider), window, cx)
+            editor.set_inline_completion_provider(Some(copilot_provider), window, cx)
         });
 
         // Setup the editor with a completion request.
@@ -651,7 +663,7 @@ mod tests {
         .await;
         let copilot_provider = cx.new(|_| CopilotCompletionProvider::new(copilot));
         cx.update_editor(|editor, window, cx| {
-            editor.set_edit_prediction_provider(Some(copilot_provider), window, cx)
+            editor.set_inline_completion_provider(Some(copilot_provider), window, cx)
         });
 
         cx.set_state(indoc! {"
@@ -670,7 +682,7 @@ mod tests {
             vec![],
         );
         cx.update_editor(|editor, window, cx| {
-            editor.next_edit_prediction(&Default::default(), window, cx)
+            editor.next_inline_completion(&Default::default(), window, cx)
         });
         executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
         cx.update_editor(|editor, window, cx| {
@@ -741,7 +753,7 @@ mod tests {
         let copilot_provider = cx.new(|_| CopilotCompletionProvider::new(copilot));
         editor
             .update(cx, |editor, window, cx| {
-                editor.set_edit_prediction_provider(Some(copilot_provider), window, cx)
+                editor.set_inline_completion_provider(Some(copilot_provider), window, cx)
             })
             .unwrap();
 
@@ -759,7 +771,7 @@ mod tests {
             editor.change_selections(None, window, cx, |s| {
                 s.select_ranges([Point::new(1, 5)..Point::new(1, 5)])
             });
-            editor.next_edit_prediction(&Default::default(), window, cx);
+            editor.next_inline_completion(&Default::default(), window, cx);
         });
         executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
         _ = editor.update(cx, |editor, _, cx| {
@@ -835,7 +847,7 @@ mod tests {
         .await;
         let copilot_provider = cx.new(|_| CopilotCompletionProvider::new(copilot));
         cx.update_editor(|editor, window, cx| {
-            editor.set_edit_prediction_provider(Some(copilot_provider), window, cx)
+            editor.set_inline_completion_provider(Some(copilot_provider), window, cx)
         });
 
         cx.set_state(indoc! {"
@@ -863,7 +875,7 @@ mod tests {
             vec![],
         );
         cx.update_editor(|editor, window, cx| {
-            editor.next_edit_prediction(&Default::default(), window, cx)
+            editor.next_inline_completion(&Default::default(), window, cx)
         });
         executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
         cx.update_editor(|editor, _, cx| {
@@ -922,6 +934,7 @@ mod tests {
         executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
         cx.update_editor(|editor, _, cx| {
             assert!(editor.context_menu_visible());
+            assert!(!editor.context_menu_contains_inline_completion());
             assert!(!editor.has_active_inline_completion(),);
             assert_eq!(editor.text(cx), "one\ntwo.\nthree\n");
         });
@@ -931,7 +944,7 @@ mod tests {
     async fn test_copilot_disabled_globs(executor: BackgroundExecutor, cx: &mut TestAppContext) {
         init_test(cx, |settings| {
             settings
-                .edit_predictions
+                .inline_completions
                 .get_or_insert(Default::default())
                 .disabled_globs = Some(vec![".env*".to_string()]);
         });
@@ -940,24 +953,24 @@ mod tests {
 
         let fs = FakeFs::new(cx.executor());
         fs.insert_tree(
-            path!("/test"),
+            "/test",
             json!({
                 ".env": "SECRET=something\n",
                 "README.md": "hello\nworld\nhow\nare\nyou\ntoday"
             }),
         )
         .await;
-        let project = Project::test(fs, [path!("/test").as_ref()], cx).await;
+        let project = Project::test(fs, ["/test".as_ref()], cx).await;
 
         let private_buffer = project
             .update(cx, |project, cx| {
-                project.open_local_buffer(path!("/test/.env"), cx)
+                project.open_local_buffer("/test/.env", cx)
             })
             .await
             .unwrap();
         let public_buffer = project
             .update(cx, |project, cx| {
-                project.open_local_buffer(path!("/test/README.md"), cx)
+                project.open_local_buffer("/test/README.md", cx)
             })
             .await
             .unwrap();
@@ -993,7 +1006,7 @@ mod tests {
         let copilot_provider = cx.new(|_| CopilotCompletionProvider::new(copilot));
         editor
             .update(cx, |editor, window, cx| {
-                editor.set_edit_prediction_provider(Some(copilot_provider), window, cx)
+                editor.set_inline_completion_provider(Some(copilot_provider), window, cx)
             })
             .unwrap();
 

crates/diagnostics/src/diagnostics.rs

@@ -750,7 +750,7 @@ impl Item for ProjectDiagnosticsEditor {
     }
 
     fn telemetry_event_text(&self) -> Option<&'static str> {
-        Some("Project Diagnostics Opened")
+        Some("project diagnostics")
     }
 
     fn for_each_project_item(
@@ -933,7 +933,7 @@ fn diagnostic_header_renderer(diagnostic: Diagnostic) -> RenderBlock {
                             .when_some(diagnostic.code.as_ref(), |stack, code| {
                                 stack.child(
                                     div()
-                                        .child(SharedString::from(format!("({code:?})")))
+                                        .child(SharedString::from(format!("({code})")))
                                         .text_color(color.text_muted),
                                 )
                             }),

crates/diagnostics/src/diagnostics_tests.rs

@@ -18,7 +18,7 @@ use std::{
     path::{Path, PathBuf},
 };
 use unindent::Unindent as _;
-use util::{path, post_inc, RandomCharIter};
+use util::{post_inc, RandomCharIter};
 
 #[ctor::ctor]
 fn init_logger() {
@@ -33,7 +33,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
 
     let fs = FakeFs::new(cx.executor());
     fs.insert_tree(
-        path!("/test"),
+        "/test",
         json!({
             "consts.rs": "
                 const a: i32 = 'a';
@@ -59,7 +59,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
     .await;
 
     let language_server_id = LanguageServerId(0);
-    let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;
+    let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await;
     let lsp_store = project.read_with(cx, |project, _| project.lsp_store());
     let window = cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx));
     let cx = &mut VisualTestContext::from_window(*window, cx);
@@ -70,7 +70,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
         lsp_store
             .update_diagnostic_entries(
                 language_server_id,
-                PathBuf::from(path!("/test/main.rs")),
+                PathBuf::from("/test/main.rs"),
                 None,
                 vec![
                     DiagnosticEntry {
@@ -150,7 +150,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
     });
 
     // Open the project diagnostics view while there are already diagnostics.
-    let diagnostics = window.build_entity(cx, |window, cx| {
+    let diagnostics = window.build_model(cx, |window, cx| {
         ProjectDiagnosticsEditor::new_with_context(
             1,
             true,
@@ -234,7 +234,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
         lsp_store
             .update_diagnostic_entries(
                 language_server_id,
-                PathBuf::from(path!("/test/consts.rs")),
+                PathBuf::from("/test/consts.rs"),
                 None,
                 vec![DiagnosticEntry {
                     range: Unclipped(PointUtf16::new(0, 15))..Unclipped(PointUtf16::new(0, 15)),
@@ -341,7 +341,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
         lsp_store
             .update_diagnostic_entries(
                 language_server_id,
-                PathBuf::from(path!("/test/consts.rs")),
+                PathBuf::from("/test/consts.rs"),
                 None,
                 vec![
                     DiagnosticEntry {
@@ -464,7 +464,7 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
 
     let fs = FakeFs::new(cx.executor());
     fs.insert_tree(
-        path!("/test"),
+        "/test",
         json!({
             "main.js": "
                 a();
@@ -479,13 +479,13 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
 
     let server_id_1 = LanguageServerId(100);
     let server_id_2 = LanguageServerId(101);
-    let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;
+    let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await;
     let lsp_store = project.read_with(cx, |project, _| project.lsp_store());
     let window = cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx));
     let cx = &mut VisualTestContext::from_window(*window, cx);
     let workspace = window.root(cx).unwrap();
 
-    let diagnostics = window.build_entity(cx, |window, cx| {
+    let diagnostics = window.build_model(cx, |window, cx| {
         ProjectDiagnosticsEditor::new_with_context(
             1,
             true,
@@ -504,7 +504,7 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
         lsp_store
             .update_diagnostic_entries(
                 server_id_1,
-                PathBuf::from(path!("/test/main.js")),
+                PathBuf::from("/test/main.js"),
                 None,
                 vec![DiagnosticEntry {
                     range: Unclipped(PointUtf16::new(0, 0))..Unclipped(PointUtf16::new(0, 1)),
@@ -557,7 +557,7 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
         lsp_store
             .update_diagnostic_entries(
                 server_id_2,
-                PathBuf::from(path!("/test/main.js")),
+                PathBuf::from("/test/main.js"),
                 None,
                 vec![DiagnosticEntry {
                     range: Unclipped(PointUtf16::new(1, 0))..Unclipped(PointUtf16::new(1, 1)),
@@ -619,7 +619,7 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
         lsp_store
             .update_diagnostic_entries(
                 server_id_1,
-                PathBuf::from(path!("/test/main.js")),
+                PathBuf::from("/test/main.js"),
                 None,
                 vec![DiagnosticEntry {
                     range: Unclipped(PointUtf16::new(2, 0))..Unclipped(PointUtf16::new(2, 1)),
@@ -638,7 +638,7 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
         lsp_store
             .update_diagnostic_entries(
                 server_id_2,
-                PathBuf::from(path!("/test/main.rs")),
+                PathBuf::from("/test/main.rs"),
                 None,
                 vec![],
                 cx,
@@ -689,7 +689,7 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
         lsp_store
             .update_diagnostic_entries(
                 server_id_2,
-                PathBuf::from(path!("/test/main.js")),
+                PathBuf::from("/test/main.js"),
                 None,
                 vec![DiagnosticEntry {
                     range: Unclipped(PointUtf16::new(3, 0))..Unclipped(PointUtf16::new(3, 1)),
@@ -755,15 +755,15 @@ async fn test_random_diagnostics(cx: &mut TestAppContext, mut rng: StdRng) {
         .unwrap_or(10);
 
     let fs = FakeFs::new(cx.executor());
-    fs.insert_tree(path!("/test"), json!({})).await;
+    fs.insert_tree("/test", json!({})).await;
 
-    let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;
+    let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await;
     let lsp_store = project.read_with(cx, |project, _| project.lsp_store());
     let window = cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx));
     let cx = &mut VisualTestContext::from_window(*window, cx);
     let workspace = window.root(cx).unwrap();
 
-    let mutated_diagnostics = window.build_entity(cx, |window, cx| {
+    let mutated_diagnostics = window.build_model(cx, |window, cx| {
         ProjectDiagnosticsEditor::new_with_context(
             1,
             true,
@@ -817,7 +817,7 @@ async fn test_random_diagnostics(cx: &mut TestAppContext, mut rng: StdRng) {
                         // insert a set of diagnostics for a new path
                         _ => {
                             let path: PathBuf =
-                                format!(path!("/test/{}.rs"), post_inc(&mut next_filename)).into();
+                                format!("/test/{}.rs", post_inc(&mut next_filename)).into();
                             let len = rng.gen_range(128..256);
                             let content =
                                 RandomCharIter::new(&mut rng).take(len).collect::<String>();
@@ -870,7 +870,7 @@ async fn test_random_diagnostics(cx: &mut TestAppContext, mut rng: StdRng) {
     cx.run_until_parked();
 
     log::info!("constructing reference diagnostics view");
-    let reference_diagnostics = window.build_entity(cx, |window, cx| {
+    let reference_diagnostics = window.build_model(cx, |window, cx| {
         ProjectDiagnosticsEditor::new_with_context(
             1,
             true,
@@ -891,7 +891,7 @@ async fn test_random_diagnostics(cx: &mut TestAppContext, mut rng: StdRng) {
         for diagnostic in diagnostics {
             let found_excerpt = reference_excerpts.iter().any(|info| {
                 let row_range = info.range.context.start.row..info.range.context.end.row;
-                info.path == path.strip_prefix(path!("/test")).unwrap()
+                info.path == path.strip_prefix("/test").unwrap()
                     && info.language_server == language_server_id
                     && row_range.contains(&diagnostic.range.start.0.row)
             });

crates/diagnostics/src/items.rs

@@ -86,6 +86,9 @@ impl Render for DiagnosticIndicator {
 
         h_flex()
             .gap_2()
+            .pl_1()
+            .border_l_1()
+            .border_color(cx.theme().colors().border)
             .child(
                 ButtonLike::new("diagnostic-indicator")
                     .child(diagnostic_indicator)
@@ -157,7 +160,7 @@ impl DiagnosticIndicator {
             (buffer, cursor_position)
         });
         let new_diagnostic = buffer
-            .diagnostics_in_range::<usize>(cursor_position..cursor_position)
+            .diagnostics_in_range::<_, usize>(cursor_position..cursor_position)
             .filter(|entry| !entry.range.is_empty())
             .min_by_key(|entry| (entry.diagnostic.severity, entry.range.len()))
             .map(|entry| entry.diagnostic);