clean up

.gitignore

@@ -19,8 +19,8 @@ dist/
 
 # Useless stuffs
 .DS_Store
+# Added by goreleaser init:
+.intentionally-empty-file.o
 
 .cargo/
 vendor/
-wasm/
-node_modules/

Cargo.toml

@@ -19,17 +19,17 @@ gpui_tokio = { git = "https://github.com/zed-industries/zed" }
 reqwest_client = { git = "https://github.com/zed-industries/zed" }
 
 # Nostr
-nostr-lmdb = { git = "https://github.com/rust-nostr/nostr" }
-nostr-memory = { git = "https://github.com/rust-nostr/nostr" }
-nostr-blossom = { git = "https://github.com/rust-nostr/nostr" }
-nostr-gossip-memory = { git = "https://github.com/rust-nostr/nostr" }
-nostr-connect = { git = "https://github.com/rust-nostr/nostr" }
-nostr-sdk = { git = "https://github.com/rust-nostr/nostr" }
-nostr = { git = "https://github.com/rust-nostr/nostr", features = [ "nip59", "nip49", "nip44" ] }
+nostr-lmdb = { git = "https://github.com/rust-nostr/nostr", branch = "send-bound" }
+nostr-memory = { git = "https://github.com/rust-nostr/nostr", branch = "send-bound" }
+nostr-blossom = { git = "https://github.com/rust-nostr/nostr", branch = "send-bound" }
+nostr-gossip-memory = { git = "https://github.com/rust-nostr/nostr", branch = "send-bound" }
+nostr-connect = { git = "https://github.com/rust-nostr/nostr", branch = "send-bound" }
+nostr-sdk = { git = "https://github.com/rust-nostr/nostr", branch = "send-bound" }
+nostr = { git = "https://github.com/rust-nostr/nostr", features = [ "nip59", "nip49", "nip44" ], branch = "send-bound" }
 
 # Others
 anyhow = "1.0.44"
-chrono = { version = "0.4.38", features = ["wasmbind"] }
+chrono = "0.4.38"
 futures = "0.3"
 itertools = "0.13.0"
 log = "0.4"
@@ -42,9 +42,8 @@ schemars = "1"
 smallvec = "1.14.0"
 smol = "2"
 webbrowser = "1.0.4"
-tracing-subscriber = { version = "0.3.18", features = ["fmt"] }
+tracing-subscriber = { version = "0.3.18", features = ["fmt", "env-filter"] }
 errno = { version = "0.3.14", default-features = false }
-instant = "0.1"
 
 [patch.crates-io]
 # Use stacker's psm version which may have better WASM support

Cargo.toml-E

@@ -1,62 +0,0 @@
-[workspace]
-resolver = "2"
-members = ["crates/*", "desktop", "web"]
-default-members = ["desktop"]
-
-[workspace.package]
-version = "1.0.0-beta5"
-edition = "2024"
-publish = false
-
-[workspace.dependencies]
-# GPUI
-gpui = { git = "https://github.com/zed-industries/zed" }
-gpui_platform = { git = "https://github.com/zed-industries/zed", features = ["font-kit", "x11", "wayland"] }
-gpui_linux = { git = "https://github.com/zed-industries/zed" }
-gpui_windows = { git = "https://github.com/zed-industries/zed" }
-gpui_macos = { git = "https://github.com/zed-industries/zed" }
-gpui_tokio = { git = "https://github.com/zed-industries/zed" }
-reqwest_client = { git = "https://github.com/zed-industries/zed" }
-
-# Nostr
-nostr-lmdb = { git = "https://github.com/rust-nostr/nostr" }
-nostr-memory = { git = "https://github.com/rust-nostr/nostr" }
-nostr-blossom = { git = "https://github.com/rust-nostr/nostr" }
-nostr-gossip-memory = { git = "https://github.com/rust-nostr/nostr" }
-nostr-connect = { git = "https://github.com/rust-nostr/nostr" }
-nostr-sdk = { git = "https://github.com/rust-nostr/nostr" }
-nostr = { git = "https://github.com/rust-nostr/nostr", features = [ "nip59", "nip49", "nip44" ] }
-
-# Others
-anyhow = "1.0.44"
-chrono = { version = "0.4.38", features = ["wasmbind"] }
-futures = "0.3"
-itertools = "0.13.0"
-log = "0.4"
-oneshot = "0.1.10"
-flume = { version = "0.11.1", default-features = false, features = ["async", "select"] }
-rust-embed = { version = "8.5", features = ["include-exclude"] }
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-schemars = "1"
-smallvec = "1.14.0"
-smol = "2"
-webbrowser = "1.0.4"
-tracing-subscriber = { version = "0.3.18", features = ["fmt"] }
-errno = { version = "0.3.14", default-features = false }
-instant = "0.1"
-
-[patch.crates-io]
-# Use stacker's psm version which may have better WASM support
-psm = { git = "https://github.com/rust-lang/stacker", branch = "master" }
-
-[profile.release]
-strip = true
-opt-level = "z"
-lto = true
-codegen-units = 1
-panic = "abort"
-
-[profile.profiling]
-inherits = "release"
-debug = true

README.md

@@ -1,5 +1,125 @@
+![Coop](/docs/coop.png)
+
+<p>
+    <a href="https://github.com/reyakov/coop/actions/workflows/rust.yml">
+      <img alt="Actions" src="https://github.com/reyakov/coop/actions/workflows/rust.yml/badge.svg">
+    </a>
+    <img alt="GitHub repo size" src="https://img.shields.io/github/repo-size/reyakov/coop">
+    <img alt="GitHub issues" src="https://img.shields.io/github/issues-raw/reyakov/coop">
+    <img alt="GitHub pull requests" src="https://img.shields.io/github/issues-pr/reyakov/coop">
+</p>
+
 Coop is a simple, fast, and reliable nostr client for secure messaging across all platforms.
 
+### Screenshots
+
+<p float="left">
+  <img src="/docs/mac_01.png" width="250" />
+  <img src="/docs/mac_02.png" width="250" />
+  <img src="/docs/mac_03.png" width="250" />
+  <img src="/docs/mac_04.png" width="250" />
+  <img src="/docs/mac_05.png" width="250" />
+  <img src="/docs/mac_06.png" width="250" />
+  <img src="/docs/mac_07.png" width="250" />
+  <img src="/docs/mac_08.png" width="250" />
+  <img src="/docs/mac_09.png" width="250" />
+  <img src="/docs/linux_01.png" width="250" />
+  <img src="/docs/linux_02.png" width="250" />
+  <img src="/docs/linux_03.png" width="250" />
+  <img src="/docs/linux_04.png" width="250" />
+  <img src="/docs/linux_05.png" width="250" />
+</p>
+
+### Installation
+
+To install Coop, follow these steps:
+
+1. **Download the Latest Release**:
+
+   - Visit the [Coop Releases page on GitHub](https://github.com/reyakov/coop/releases).
+   - Download the package that matches your operating system (Windows, macOS, or Linux).
+
+2. **Install**:
+
+   - **Windows**: Run the downloaded `.exe` installer and follow the on-screen instructions.
+   - **macOS**: Open the downloaded `.dmg` file and drag Coop to your Applications folder.
+   - **Linux**: Run the downloaded `.flatpak` or `.snap` installer and follow the on-screen instructions.
+
+3. **Run Coop**:
+   - Launch Coop from your Applications folder (macOS) or by double-clicking the executable (Windows/Linux).
+
+For more detailed instructions, refer to the [Release Notes](#) on GitHub.
+
+### Developing Coop
+
+Coop is built using Rust and GPUI. All Nostr related stuffs handled by [Rust Nostr SDK](https://github.com/rust-nostr/nostr)
+
+#### Prerequisites
+
+- **Rust Toolchain**: Ensure you have Rust installed. If not, you can install it using [rustup](https://rustup.rs/).
+- **Cargo**: Rust's package manager, which comes bundled with the Rust installation.
+- **Git**: To clone the repository and manage version control.
+
+#### Setting Up the Development Environment
+
+1. Clone the repository:
+
+   ```bash
+   git clone https://github.com/reyakov/coop.git
+   cd coop
+   ```
+
+2.1 Install Linux dependencies:
+
+   ```bash
+   ./script/linux
+   ```
+
+2.2 Install FreeBSD dependencies:
+
+   ```bash
+   ./script/freebsd
+   ```
+
+3. Install Rust dependencies:
+
+   ```bash
+   cargo build
+   ```
+
+4. Run the app:
+   ```bash
+   cargo run
+   ```
+
+#### Building for Production
+
+To build Coop for production, use the following command:
+
+```bash
+cargo build --release
+```
+
+This will generate an optimized binary in the `target/release` directory.
+
+#### Contributing Code
+
+If you'd like to contribute to Coop, please follow these steps:
+
+1. Fork the repository.
+2. Create a new branch for your feature or bugfix.
+3. Make your changes and ensure all tests pass.
+4. Submit a pull request with a detailed description of your changes.
+
+For more information, see the [Contributing](#contributing) section.
+
+#### Additional Resources
+
+- [Rust Nostr](https://github.com/rust-nostr/nostr/)
+- [GPUI](https://www.gpui.rs/)
+- [GPUI Components](https://github.com/longbridge/gpui-component/)
+- [Coop Issue Tracker](https://github.com/reyakov/coop/issues/)
+
 ### License
 
 Copyright (C) 2025 Ren Amamiya & other Coop contributors

crates/auto_update/Cargo.toml

@@ -5,8 +5,17 @@ edition.workspace = true
 publish.workspace = true
 
 [dependencies]
-gpui.workspace = true
-instant.workspace = true
-log.workspace = true
+common = { path = "../common" }
 
-gpui-updater = { git = "https://github.com/AprilNEA/gpui-updater", tag = "v0.0.6", features = ["gpui"] }
+gpui.workspace = true
+anyhow.workspace = true
+log.workspace = true
+smallvec.workspace = true
+serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
+
+semver = "1.0.27"
+tempfile = "3.23.0"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+smol.workspace = true

crates/auto_update/src/lib.rs

@@ -1,9 +1,24 @@
 #![cfg(not(target_arch = "wasm32"))]
 
-use gpui::{App, AppContext, Context, Entity, Global, SharedString, Subscription, Window};
-use gpui_updater::{EngineConfig, GitHubSource, UpdateStatus, Updater, Version};
-use instant::{Duration, Instant};
+use std::ffi::OsString;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::Duration;
 
+use anyhow::{Context as AnyhowContext, Error, anyhow};
+use gpui::http_client::{AsyncBody, HttpClient};
+use gpui::{
+    App, AppContext, AsyncApp, BackgroundExecutor, Context, Entity, Global, Subscription, Task,
+    Window,
+};
+use semver::Version;
+use serde::Deserialize;
+use smallvec::{SmallVec, smallvec};
+use smol::fs::File;
+use smol::io::AsyncReadExt;
+use smol::process::Command;
+
+const GITHUB_API_URL: &str = "https://api.github.com";
 const COOP_UPDATE_EXPLANATION: &str = "COOP_UPDATE_EXPLANATION";
 
 fn get_github_repo_owner() -> String {
@@ -15,15 +30,12 @@ fn get_github_repo_name() -> String {
 }
 
 fn is_flatpak_installation() -> bool {
+    // Check if app is installed via Flatpak
     std::env::var("FLATPAK_ID").is_ok() || std::env::var(COOP_UPDATE_EXPLANATION).is_ok()
 }
 
-/// Initialize the auto-update system.
-///
-/// Skips initialization when running as a Flatpak (updates are handled by the
-/// Flatpak distribution channel). Otherwise creates the global [`AutoUpdater`]
-/// entity and schedules a check for updates after a 2-minute delay.
 pub fn init(window: &mut Window, cx: &mut App) {
+    // Skip auto-update initialization if installed via Flatpak
     if is_flatpak_installation() {
         log::info!("Skipping auto-update initialization: App is installed via Flatpak");
         return;
@@ -36,145 +48,516 @@ struct GlobalAutoUpdater(Entity<AutoUpdater>);
 
 impl Global for GlobalAutoUpdater {}
 
-/// Observable auto-update status — re-exported from [`gpui_updater::UpdateStatus`].
-pub use gpui_updater::UpdateStatus as AutoUpdateStatus;
+#[cfg(not(target_os = "windows"))]
+struct InstallerDir(tempfile::TempDir);
 
-/// The global auto-updater entity.
-///
-/// Wraps [`gpui_updater::Updater`] with Coop-specific configuration
-/// (GitHub repo, Flatpak detection, delayed auto-check).
-///
-/// Retrieve the global instance via [`AutoUpdater::global`].
+#[cfg(not(target_os = "windows"))]
+impl InstallerDir {
+    async fn new() -> Result<Self, Error> {
+        Ok(Self(
+            tempfile::Builder::new()
+                .prefix("coop-auto-update")
+                .tempdir()?,
+        ))
+    }
+
+    fn path(&self) -> &Path {
+        self.0.path()
+    }
+}
+
+#[cfg(target_os = "windows")]
+struct InstallerDir(PathBuf);
+
+#[cfg(target_os = "windows")]
+impl InstallerDir {
+    async fn new() -> Result<Self, Error> {
+        let installer_dir = std::env::current_exe()?
+            .parent()
+            .context("No parent dir for Coop.exe")?
+            .join("updates");
+
+        if smol::fs::metadata(&installer_dir).await.is_ok() {
+            smol::fs::remove_dir_all(&installer_dir).await?;
+        }
+
+        smol::fs::create_dir(&installer_dir).await?;
+
+        Ok(Self(installer_dir))
+    }
+
+    fn path(&self) -> &Path {
+        self.0.as_path()
+    }
+}
+
+struct MacOsUnmounter<'a> {
+    mount_path: PathBuf,
+    background_executor: &'a BackgroundExecutor,
+}
+
+impl Drop for MacOsUnmounter<'_> {
+    fn drop(&mut self) {
+        let mount_path = std::mem::take(&mut self.mount_path);
+
+        self.background_executor
+            .spawn(async move {
+                let unmount_output = Command::new("hdiutil")
+                    .args(["detach", "-force"])
+                    .arg(&mount_path)
+                    .output()
+                    .await;
+
+                match unmount_output {
+                    Ok(output) if output.status.success() => {
+                        log::info!("Successfully unmounted the disk image");
+                    }
+                    Ok(output) => {
+                        log::error!(
+                            "Failed to unmount disk image: {:?}",
+                            String::from_utf8_lossy(&output.stderr)
+                        );
+                    }
+                    Err(error) => {
+                        log::error!("Error while trying to unmount disk image: {:?}", error);
+                    }
+                }
+            })
+            .detach();
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum AutoUpdateStatus {
+    Idle,
+    Checking,
+    Checked { download_url: String },
+    Installing,
+    Updated,
+    Errored { msg: Box<String> },
+}
+
+impl AsRef<AutoUpdateStatus> for AutoUpdateStatus {
+    fn as_ref(&self) -> &AutoUpdateStatus {
+        self
+    }
+}
+
+impl AutoUpdateStatus {
+    pub fn is_updating(&self) -> bool {
+        matches!(self, Self::Checked { .. } | Self::Installing)
+    }
+
+    pub fn is_updated(&self) -> bool {
+        matches!(self, Self::Updated)
+    }
+
+    pub fn checked(download_url: String) -> Self {
+        Self::Checked { download_url }
+    }
+
+    pub fn error(e: String) -> Self {
+        Self::Errored { msg: Box::new(e) }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct GitHubRelease {
+    pub tag_name: String,
+    pub assets: Vec<GitHubAsset>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct GitHubAsset {
+    pub name: String,
+    pub browser_download_url: String,
+}
+
+#[derive(Debug)]
 pub struct AutoUpdater {
-    /// The underlying gpui-updater entity that does the heavy lifting.
-    pub updater: Entity<Updater>,
-    /// Currently running app version.
+    /// Current status of the auto updater
+    pub status: AutoUpdateStatus,
+
+    /// Current version of the application
     pub version: Version,
-    /// Keeps the observer subscription alive.
-    _subscription: Subscription,
-    /// When the last error was recorded, so we can reset to idle after 5s.
-    error_time: Option<Instant>,
+
+    /// Event subscriptions
+    _subscriptions: SmallVec<[Subscription; 1]>,
+
+    /// Background tasks
+    tasks: Vec<Task<Result<(), Error>>>,
 }
 
 impl AutoUpdater {
-    /// Retrieve the global auto updater instance.
+    /// Retrieve the global auto updater instance
     pub fn global(cx: &App) -> Entity<Self> {
         cx.global::<GlobalAutoUpdater>().0.clone()
     }
 
+    /// Set the global auto updater instance
     fn set_global(state: Entity<Self>, cx: &mut App) {
         cx.set_global(GlobalAutoUpdater(state));
     }
 
     fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let version = Version::parse(env!("CARGO_PKG_VERSION")).unwrap();
+        let mut subscriptions = smallvec![];
 
-        let repo_owner = get_github_repo_owner();
-        let repo_name = get_github_repo_name();
-
-        let source =
-            GitHubSource::new(&repo_owner, &repo_name).asset_contains(match std::env::consts::OS {
-                "macos" => "macos",
-                "linux" => "linux",
-                _ => "",
-            });
-
-        let updater: Entity<Updater> =
-            cx.new(|cx| Updater::new(source, EngineConfig::new(version.clone()), cx));
-
-        // When an update becomes available, automatically download and install it.
-        let subscription = cx.observe(&updater, |this: &mut AutoUpdater, _updater, cx| {
-            let status = this.updater.read(cx).status().clone();
-
-            if matches!(status, UpdateStatus::Available(_)) {
-                this.updater.update(cx, |updater, cx| {
-                    updater.download_and_install(cx);
-                });
+        subscriptions.push(
+            // Observe the status
+            cx.observe_self(|this, cx| {
+                if let AutoUpdateStatus::Checked { download_url } = this.status.clone() {
+                    this.download_and_install(&download_url, cx);
                 }
+            }),
+        );
 
-            if matches!(status, UpdateStatus::Errored(_)) {
-                this.error_time = Some(Instant::now());
-                cx.spawn(async move |this, cx| {
-                    cx.background_executor().timer(Duration::from_secs(5)).await;
-                    this.update(cx, |_this, cx| cx.notify()).ok();
-                })
-                .detach();
-            } else {
-                this.error_time = None;
-            }
-
-            cx.notify();
-        });
-
-        // Schedule an auto-check after a 2-minute delay (deferred to run at the
-        // end of the current frame so the window is fully set up).
-        cx.defer_in(window, |_this, _window, cx| {
-            let duration = Duration::from_secs(120);
-            cx.spawn(async move |this, cx| {
-                cx.background_executor().timer(duration).await;
-                this.update(cx, |this, cx| {
-                    this.updater.update(cx, |updater, cx| {
-                        updater.check(cx);
-                    });
-                })
-                .ok();
-            })
-            .detach();
+        // Run at the end of current cycle
+        cx.defer_in(window, |this, _window, cx| {
+            this.check(cx);
         });
 
         Self {
-            updater,
+            status: AutoUpdateStatus::Idle,
             version,
-            _subscription: subscription,
-            error_time: None,
+            tasks: vec![],
+            _subscriptions: subscriptions,
         }
     }
 
-    pub fn idle(&self, cx: &App) -> bool {
-        let status = self.updater.read(cx).status();
-        if status == &UpdateStatus::Idle {
-            return true;
-        }
-        if matches!(status, UpdateStatus::Errored(_))
-            && self
-                .error_time
-                .is_some_and(|t| t.elapsed() >= Duration::from_secs(5))
-        {
-            return true;
-        }
-        false
+    fn set_status(&mut self, status: AutoUpdateStatus, cx: &mut Context<Self>) {
+        self.status = status;
+        cx.notify();
     }
 
-    pub fn status(&self, cx: &App) -> SharedString {
-        let status = self.updater.read(cx).status();
+    fn check(&mut self, cx: &mut Context<Self>) {
+        let version = self.version.clone();
+        let duration = Duration::from_secs(120);
+        let task = self.check_for_updates(version, cx);
 
-        match status {
-            UpdateStatus::Idle => "Up to date".into(),
-            UpdateStatus::Checking => "Checking for updates…".into(),
-            UpdateStatus::UpToDate => "Up to date".into(),
-            UpdateStatus::Available(version) => format!("Version {version} available").into(),
-            UpdateStatus::Downloading { downloaded, total } => {
-                let total_mb = total.map(|t| t as f64 / 1_048_576.0);
-                let downloaded_mb = *downloaded as f64 / 1_048_576.0;
-                match total_mb {
-                    Some(t) => format!("Downloading {downloaded_mb:.1} / {t:.1} MB").into(),
-                    None => format!("Downloading {downloaded_mb:.1} MB").into(),
+        // Check for updates after 2 minutes
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            cx.background_executor().timer(duration).await;
+
+            // Update the status to checking
+            this.update(cx, |this, cx| {
+                this.set_status(AutoUpdateStatus::Checking, cx);
+            })?;
+
+            match task.await {
+                Ok(download_url) => {
+                    // Update the status to checked with download URL
+                    this.update(cx, |this, cx| {
+                        this.set_status(AutoUpdateStatus::checked(download_url), cx);
+                    })?;
+                }
+                Err(e) => {
+                    log::warn!("Failed to check for updates: {e}");
+                    this.update(cx, |this, cx| {
+                        this.set_status(AutoUpdateStatus::Idle, cx);
+                    })?;
                 }
             }
-            UpdateStatus::Installing => "Installing update…".into(),
-            UpdateStatus::Staged(version) => {
-                format!("Version {version} ready — restart to apply").into()
+
+            Ok(())
+        }));
     }
-            UpdateStatus::Errored(msg) => {
-                if self
-                    .error_time
-                    .is_some_and(|t| t.elapsed() >= Duration::from_secs(5))
-                {
-                    "Up to date".into()
+
+    fn check_for_updates(&self, version: Version, cx: &App) -> Task<Result<String, Error>> {
+        let http_client = cx.http_client();
+        let repo_owner = get_github_repo_owner();
+        let repo_name = get_github_repo_name();
+
+        cx.background_spawn(async move {
+            let url = format!(
+                "{}/repos/{}/{}/releases/latest",
+                GITHUB_API_URL, repo_owner, repo_name
+            );
+
+            let async_body = AsyncBody::default();
+            let mut body = Vec::new();
+            let mut response = http_client.get(&url, async_body, false).await?;
+
+            // Read the response body into a vector
+            response.body_mut().read_to_end(&mut body).await?;
+
+            if !response.status().is_success() {
+                return Err(anyhow!("GitHub API returned error: {}", response.status()));
+            }
+
+            // Parse the response body as JSON
+            let release: GitHubRelease = serde_json::from_slice(&body)?;
+
+            // Parse version from tag (remove 'v' prefix if present)
+            let tag_version = release.tag_name.trim_start_matches('v');
+            let new_version = Version::parse(tag_version).context(format!(
+                "Failed to parse version from tag: {}",
+                release.tag_name
+            ))?;
+
+            if new_version > version {
+                // Find the appropriate asset for the current platform
+                let current_os = std::env::consts::OS;
+                let asset_name = match current_os {
+                    "macos" => "Coop.dmg",
+                    "linux" => "coop.tar.gz",
+                    "windows" => "Coop.exe",
+                    _ => return Err(anyhow!("Unsupported OS: {}", current_os)),
+                };
+
+                let download_url = release
+                    .assets
+                    .iter()
+                    .find(|asset| asset.name == asset_name)
+                    .map(|asset| asset.browser_download_url.clone())
+                    .context(format!(
+                        "No {} asset found in release {}",
+                        asset_name, release.tag_name
+                    ))?;
+
+                Ok(download_url)
             } else {
-                    format!("Update failed: {msg}").into()
+                Err(anyhow!(
+                    "No update available. Current: {}, Latest: {}",
+                    version,
+                    new_version
+                ))
+            }
+        })
+    }
+
+    fn download_and_install(&mut self, download_url: &str, cx: &mut Context<Self>) {
+        let http_client = cx.http_client();
+        let download_url = download_url.to_string();
+
+        let task: Task<Result<(InstallerDir, PathBuf), Error>> = cx.background_spawn(async move {
+            let installer_dir = InstallerDir::new().await?;
+            let target_path = Self::target_path(&installer_dir).await?;
+
+            // Download the release
+            download(&download_url, &target_path, http_client).await?;
+
+            Ok((installer_dir, target_path))
+        });
+
+        self.tasks.push(
+            // Install the new release
+            cx.spawn(async move |this, cx| {
+                this.update(cx, |this, cx| {
+                    this.set_status(AutoUpdateStatus::Installing, cx);
+                })?;
+
+                match task.await {
+                    Ok((installer_dir, target_path)) => {
+                        if Self::install(installer_dir, target_path, cx).await.is_ok() {
+                            // Update the status to updated
+                            this.update(cx, |this, cx| {
+                                this.set_status(AutoUpdateStatus::Updated, cx);
+                            })?;
+                        }
+                    }
+                    Err(e) => {
+                        // Update the status to error including the error message
+                        this.update(cx, |this, cx| {
+                            this.set_status(AutoUpdateStatus::error(e.to_string()), cx);
+                        })?;
+                    }
+                }
+
+                Ok(())
+            }),
+        );
+    }
+
+    async fn target_path(installer_dir: &InstallerDir) -> Result<PathBuf, Error> {
+        let filename = match std::env::consts::OS {
+            "macos" => anyhow::Ok("Coop.dmg"),
+            "linux" => Ok("coop.tar.gz"),
+            "windows" => Ok("Coop.exe"),
+            unsupported_os => anyhow::bail!("not supported: {unsupported_os}"),
+        }?;
+
+        Ok(installer_dir.path().join(filename))
+    }
+
+    async fn install(
+        installer_dir: InstallerDir,
+        target_path: PathBuf,
+        cx: &AsyncApp,
+    ) -> Result<(), Error> {
+        match std::env::consts::OS {
+            "macos" => install_release_macos(&installer_dir, target_path, cx).await,
+            "linux" => install_release_linux(&installer_dir, target_path, cx).await,
+            "windows" => install_release_windows(target_path).await,
+            unsupported_os => anyhow::bail!("Not supported: {unsupported_os}"),
         }
     }
 }
+
+async fn download(
+    url: &str,
+    target_path: &std::path::Path,
+    client: Arc<dyn HttpClient>,
+) -> Result<(), Error> {
+    let body = AsyncBody::default();
+    let mut target_file = File::create(&target_path).await?;
+    let mut response = client.get(url, body, true).await?;
+
+    // Copy the response body to the target file
+    smol::io::copy(response.body_mut(), &mut target_file).await?;
+
+    Ok(())
+}
+
+async fn install_release_macos(
+    temp_dir: &InstallerDir,
+    downloaded_dmg: PathBuf,
+    cx: &AsyncApp,
+) -> Result<(), Error> {
+    let running_app_path = cx.update(|cx| cx.app_path())?;
+    let running_app_filename = running_app_path
+        .file_name()
+        .with_context(|| format!("invalid running app path {running_app_path:?}"))?;
+
+    let mount_path = temp_dir.path().join("Coop");
+    let mut mounted_app_path: OsString = mount_path.join(running_app_filename).into();
+
+    mounted_app_path.push("/");
+
+    let output = Command::new("hdiutil")
+        .args(["attach", "-nobrowse"])
+        .arg(&downloaded_dmg)
+        .arg("-mountroot")
+        .arg(temp_dir.path())
+        .output()
+        .await?;
+
+    anyhow::ensure!(
+        output.status.success(),
+        "failed to mount: {:?}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    // Create an MacOsUnmounter that will be dropped (and thus unmount the disk) when this function exits
+    let _unmounter = MacOsUnmounter {
+        mount_path: mount_path.clone(),
+        background_executor: cx.background_executor(),
+    };
+
+    let output = Command::new("rsync")
+        .args(["-av", "--delete"])
+        .arg(&mounted_app_path)
+        .arg(&running_app_path)
+        .output()
+        .await?;
+
+    anyhow::ensure!(
+        output.status.success(),
+        "failed to copy app: {:?}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    Ok(())
+}
+
+async fn install_release_linux(
+    temp_dir: &InstallerDir,
+    downloaded_tar_gz: PathBuf,
+    cx: &AsyncApp,
+) -> Result<(), Error> {
+    let running_app_path = cx.update(|cx| cx.app_path())?;
+
+    // Extract the tar.gz file
+    let extracted = temp_dir.path().join("coop");
+    smol::fs::create_dir_all(&extracted)
+        .await
+        .context("failed to create directory to extract update")?;
+
+    let output = Command::new("tar")
+        .arg("-xzf")
+        .arg(&downloaded_tar_gz)
+        .arg("-C")
+        .arg(&extracted)
+        .output()
+        .await?;
+
+    anyhow::ensure!(
+        output.status.success(),
+        "failed to extract {:?} to {:?}: {:?}",
+        downloaded_tar_gz,
+        extracted,
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    // Find the extracted app directory
+    let mut entries = smol::fs::read_dir(&extracted).await?;
+    let mut app_dir = None;
+
+    use smol::stream::StreamExt;
+
+    while let Some(entry) = entries.next().await {
+        let entry = entry?;
+        let path = entry.path();
+        if path.is_dir() {
+            app_dir = Some(path);
+            break;
         }
     }
+
+    let from = app_dir.context("No app directory found in archive")?;
+
+    // Copy to the current installation directory
+    let output = Command::new("rsync")
+        .args(["-av", "--delete"])
+        .arg(&from)
+        .arg(
+            running_app_path
+                .parent()
+                .context("No parent directory for app")?,
+        )
+        .output()
+        .await?;
+
+    anyhow::ensure!(
+        output.status.success(),
+        "failed to copy app from {:?} to {:?}: {:?}",
+        from,
+        running_app_path.parent(),
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    Ok(())
+}
+
+async fn install_release_windows(downloaded_installer: PathBuf) -> Result<(), Error> {
+    //const CREATE_NO_WINDOW: u32 = 0x08000000;
+
+    let system_root = std::env::var("SYSTEMROOT");
+    let powershell_path = system_root.as_ref().map_or_else(
+        |_| "powershell.exe".to_string(),
+        |p| format!("{p}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe"),
+    );
+
+    let mut installer_path = std::ffi::OsString::new();
+    installer_path.push("\"");
+    installer_path.push(&downloaded_installer);
+    installer_path.push("\"");
+
+    let output = Command::new(powershell_path)
+        //.creation_flags(CREATE_NO_WINDOW)
+        .args(["-NoProfile", "-WindowStyle", "Hidden"])
+        .args(["Start-Process"])
+        .arg(installer_path)
+        .arg("-ArgumentList")
+        .args(["/P", "/R"])
+        .output()
+        .await?;
+
+    anyhow::ensure!(
+        output.status.success(),
+        "failed to start installer: {:?}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    Ok(())
+}

crates/browser-signer-proxy/Cargo.toml

@@ -1,19 +0,0 @@
-[package]
-name = "browser-signer-proxy"
-version = "0.1.0"
-edition.workspace = true
-description = "Nostr browser signer (NIP-07) proxy using smol async runtime"
-license = "MIT"
-repository = "https://github.com/nostrdevkit/nostr"
-publish = false
-
-[dependencies]
-atomic-destructor = "0.2"
-event-listener = "5"
-nostr.workspace = true
-opaquerr = "0.1"
-serde.workspace = true
-serde_json.workspace = true
-smol.workspace = true
-tracing = { version = "0.1", features = ["std"] }
-uuid = { version = "1.23", features = ["serde", "v4"] }

crates/browser-signer-proxy/README.md

@@ -1,55 +0,0 @@
-# browser-signer-proxy
-
-Proxy to use Nostr Browser signer ([NIP-07](https://github.com/nostr-protocol/nips/blob/master/07.md)) in native applications.
-
-This is a re-implementation of [`nostr-browser-signer-proxy`](https://github.com/nostrdevkit/nostr/tree/master/signer/nostr-browser-signer-proxy)
-using the [`smol`](https://github.com/smol-rs/smol) async runtime instead of tokio.
-
-## Description
-
-This crate provides a local HTTP proxy that communicates with a NIP-07 browser extension
-(e.g., Alby, nos2x) running in a browser tab. Native applications can use this proxy to
-request public keys, sign events, and perform NIP-04/NIP-44 encryption/decryption through
-the browser extension.
-
-The HTTP server is implemented with a minimal, dependency-free approach using `smol::net::TcpListener`
-and manual HTTP/1.1 parsing — avoiding heavy HTTP framework dependencies entirely.
-
-## Usage
-
-```rust
-use browser_signer_proxy::prelude::*;
-
-async fn example() -> Result<(), Error> {
-    // Create the proxy with default options (localhost:7400)
-    let proxy = BrowserSignerProxy::new(BrowserSignerProxyOptions::default());
-
-    // Open the proxy URL in a browser
-    webbrowser::open(&proxy.url())?;
-
-    // Start the proxy server
-    proxy.start().await?;
-
-    // Use it as an async Nostr signer
-    let public_key = proxy.get_public_key_async().await?;
-    println!("Connected with public key: {public_key}");
-
-    Ok(())
-}
-```
-
-## Differences from the tokio-based version
-
-| Feature | tokio (original) | smol (this crate) |
-|---|---|---|
-| Async runtime | `tokio` | `smol` |
-| HTTP server | `hyper` | `smol::net::TcpListener` + manual HTTP/1.1 |
-| Mutex | `tokio::sync::Mutex` | `smol::lock::Mutex` |
-| Shutdown signal | `tokio::sync::Notify` | `event_listener::Event` |
-| Request-response channel | `tokio::sync::oneshot` | `smol::channel::bounded(1)` |
-| Timeout | `tokio::time::timeout` | `smol::future::or` + `smol::Timer` |
-| Task spawning | `tokio::spawn` | `smol::spawn` |
-
-## License
-
-This project is distributed under the MIT software license.

crates/browser-signer-proxy/index.html

@@ -1,185 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Coop — Web Signer Proxy</title>
-    <link rel="preconnect" href="https://fonts.googleapis.com">
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-    <link href="https://fonts.googleapis.com/css2?family=Nunito:wght@800;900&display=swap" rel="stylesheet">
-    <style>
-        :root {
-            --brand: #F8FF37;
-            --ink: #111111;
-            --ink-soft: #333333;
-            --muted: #666666;
-            --paper: #FFFFFF;
-            --edge: rgba(17, 17, 17, 0.14);
-            --radius-sm: 1rem;
-            --radius-md: 1.5rem;
-            --radius-lg: 2.5rem;
-            --green: #2E8B57;
-            --red: #D32F2F;
-        }
-
-        * {
-            box-sizing: border-box;
-        }
-
-        html, body {
-            margin: 0;
-            min-height: 100%;
-        }
-
-        body {
-            font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
-            color: var(--ink);
-            background: var(--brand);
-            -webkit-font-smoothing: antialiased;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            min-height: 100vh;
-            padding: 2rem;
-        }
-
-        .card {
-            background: var(--paper);
-            border-radius: var(--radius-md);
-            padding: 2.5rem;
-            max-width: 440px;
-            width: 100%;
-            box-shadow: 0 8px 0 rgba(17, 17, 17, 0.12), 0 2px 20px rgba(17, 17, 17, 0.06);
-        }
-
-        .logo {
-            display: flex;
-            align-items: center;
-            gap: 0.6rem;
-            margin-bottom: 1.75rem;
-        }
-
-        .logo__mark {
-            width: 2.5rem;
-            height: 2.5rem;
-            background: var(--ink);
-            border-radius: var(--radius-sm);
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            font-family: "Nunito", system-ui, sans-serif;
-            font-weight: 900;
-            font-size: 1.2rem;
-            color: var(--brand);
-            letter-spacing: -0.02em;
-        }
-
-        .logo__text {
-            font-family: "Nunito", system-ui, sans-serif;
-            font-weight: 900;
-            font-size: 1.3rem;
-            letter-spacing: -0.02em;
-        }
-
-        .heading {
-            font-family: "Nunito", system-ui, sans-serif;
-            font-weight: 900;
-            font-size: 1.6rem;
-            letter-spacing: -0.03em;
-            line-height: 1.15;
-            margin: 0 0 0.6rem;
-        }
-
-        .subtitle {
-            font-size: 0.95rem;
-            color: var(--ink-soft);
-            margin: 0 0 1.75rem;
-            line-height: 1.5;
-        }
-
-        .status {
-            display: flex;
-            align-items: center;
-            gap: 0.75rem;
-            padding: 1rem 1.25rem;
-            border-radius: var(--radius-sm);
-            font-weight: 600;
-            font-size: 0.95rem;
-            transition: background 300ms ease, color 300ms ease;
-        }
-
-        .status--checking {
-            background: rgba(17, 17, 17, 0.05);
-            color: var(--muted);
-        }
-
-        .status--connected {
-            background: rgba(46, 139, 87, 0.1);
-            color: var(--green);
-        }
-
-        .status--error {
-            background: rgba(211, 47, 47, 0.08);
-            color: var(--red);
-        }
-
-        .status__dot {
-            width: 0.7rem;
-            height: 0.7rem;
-            border-radius: 50%;
-            flex-shrink: 0;
-        }
-
-        .status--checking .status__dot {
-            background: var(--muted);
-            animation: pulse 1.2s ease-in-out infinite;
-        }
-
-        .status--connected .status__dot {
-            background: var(--green);
-        }
-
-        .status--error .status__dot {
-            background: var(--red);
-        }
-
-        @keyframes pulse {
-            0%, 100% { opacity: 0.4; transform: scale(0.85); }
-            50%      { opacity: 1;   transform: scale(1); }
-        }
-
-        .hint {
-            margin-top: 1.5rem;
-            padding-top: 1.25rem;
-            border-top: 1px solid var(--edge);
-            font-size: 0.8rem;
-            color: var(--muted);
-            line-height: 1.5;
-        }
-
-        .hint strong {
-            color: var(--ink-soft);
-        }
-    </style>
-</head>
-<body>
-    <div class="card">
-        <h1 class="heading">Web Signer</h1>
-
-        <p class="subtitle">
-            This page connects the app to your Nostr Web Signer extension so you can sign in and use Coop securely.
-        </p>
-
-        <div id="nip07-status" class="status status--checking">
-            <div class="status__dot"></div>
-            <span id="nip07-status-text">Checking extension…</span>
-        </div>
-
-        <div class="hint">
-            <strong>Keep this tab open</strong> while using the app — it automatically handles sign-in requests in the background.
-        </div>
-    </div>
-
-    <script src="proxy.js"></script>
-</body>
-</html>

crates/browser-signer-proxy/proxy.js

@@ -1,156 +0,0 @@
-let isPolling = false;
-
-async function pollForRequests() {
-    if (isPolling) return;
-    isPolling = true;
-
-    try {
-        const response = await fetch('/api/pending');
-        const data = await response.json();
-
-        console.log('Polled for requests, got:', data);
-
-        // Process any new requests
-        if (data.requests && data.requests.length > 0) {
-            console.log(`Processing ${data.requests.length} requests`);
-            for (const request of data.requests) {
-                await handleNip07Request(request);
-            }
-        }
-    } catch (error) {
-        console.error('Polling error:', error);
-        updateStatus('Error: ' + error.message, 'error');
-    }
-
-    isPolling = false;
-}
-
-async function handleNip07Request(request) {
-    console.log('Handling request:', request);
-
-    try {
-        let result;
-
-        if (!window.nostr) {
-            throw new Error('NIP-07 extension not available');
-        }
-
-        switch (request.method) {
-            case 'get_public_key':
-                console.log('Calling nostr.getPublicKey()');
-                result = await window.nostr.getPublicKey();
-                console.log('Got public key:', result);
-                break;
-
-            case 'sign_event':
-                console.log('Calling nostr.signEvent() with:', request.params);
-                result = await window.nostr.signEvent(request.params);
-                console.log('Got signed event:', result);
-                break;
-
-            case 'nip04_encrypt':
-                console.log('Calling nostr.nip04.encrypt()');
-                result = await window.nostr.nip04.encrypt(
-                    request.params.public_key,
-                    request.params.content
-                );
-                break;
-
-            case 'nip04_decrypt':
-                console.log('Calling nostr.nip04.decrypt()');
-                result = await window.nostr.nip04.decrypt(
-                    request.params.public_key,
-                    request.params.content
-                );
-                break;
-
-            case 'nip44_encrypt':
-                console.log('Calling nostr.nip44.encrypt()');
-                result = await window.nostr.nip44.encrypt(
-                    request.params.public_key,
-                    request.params.content
-                );
-                break;
-
-            case 'nip44_decrypt':
-                console.log('Calling nostr.nip44.decrypt()');
-                result = await window.nostr.nip44.decrypt(
-                    request.params.public_key,
-                    request.params.content
-                );
-                break;
-
-
-            default:
-                throw new Error(`Unknown method: ${request.method}`);
-        }
-
-        // Send response back to server
-        const responsePayload = {
-            id: request.id,
-            result: result,
-            error: null
-        };
-
-        console.log('Sending response:', responsePayload);
-
-        await fetch('/api/response', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(responsePayload)
-        });
-
-        console.log('Response sent successfully');
-        updateStatus('Request processed successfully', 'connected');
-
-    } catch (error) {
-        console.error('Error handling request:', error);
-
-        // Send error response back to server
-        const errorPayload = {
-            id: request.id,
-            result: null,
-            error: error.message
-        };
-
-        console.log('Sending error response:', errorPayload);
-
-        await fetch('/api/response', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(errorPayload)
-        });
-
-        updateStatus('Error: ' + error.message, 'error');
-    }
-}
-
-function updateStatus(message, state) {
-    const container = document.getElementById('nip07-status');
-    const textEl = document.getElementById('nip07-status-text');
-    if (container && textEl) {
-        container.className = 'status status--' + state;
-        textEl.textContent = message;
-    }
-}
-
-// Start polling when page loads
-window.addEventListener('load', () => {
-    console.log('NIP-07 Proxy loaded');
-
-    // Check if NIP-07 extension is available
-    if (window.nostr) {
-        console.log('NIP-07 extension detected');
-        updateStatus('Connected — ready', 'connected');
-    } else {
-        console.log('NIP-07 extension not found');
-        updateStatus('No NIP-07 extension found', 'error');
-    }
-
-    // Start polling every 500 ms
-    setInterval(pollForRequests, 500);
-});

crates/browser-signer-proxy/src/error.rs

@@ -1,51 +0,0 @@
-// Copyright (c) 2022-2023 Yuki Kishimoto
-// Copyright (c) 2023-2025 Rust Nostr Developers
-// Distributed under the MIT software license
-
-//! Error types for the browser signer proxy.
-
-opaquerr::define_kind! {
-    /// Nostr browser signer proxy error kind.
-    pub ErrorKind {
-        /// Nostr protocol error.
-        Protocol => "nostr protocol error",
-        /// I/O error.
-        IO => "I/O error",
-        /// JSON error.
-        Json => "JSON error",
-        /// The operation timed out.
-        Timeout => "timeout",
-        /// The operation cannot be completed in the current state.
-        State => "invalid state",
-        /// Anything not covered by the stable categories above.
-        Other => "other error",
-    }
-}
-
-opaquerr::define_error! {
-    /// Nostr browser signer proxy error.
-    pub Error(ErrorKind)
-
-    from {
-        nostr::error::Error => ErrorKind::Protocol,
-        std::io::Error => ErrorKind::IO,
-        serde_json::Error => ErrorKind::Json,
-    }
-}
-
-impl Error {
-    pub(crate) fn generic<S>(message: S) -> Self
-    where
-        S: Into<String>,
-    {
-        Self::new(ErrorKind::Other, message.into())
-    }
-
-    pub(crate) fn timeout() -> Self {
-        Self::simple(ErrorKind::Timeout)
-    }
-
-    pub(crate) fn shutdown() -> Self {
-        Self::with_static_message(ErrorKind::State, "server is shutdown")
-    }
-}

crates/browser-signer-proxy/src/lib.rs

@@ -1,764 +0,0 @@
-use std::collections::HashMap;
-use std::future::Future;
-use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4};
-use std::pin::Pin;
-use std::sync::Arc;
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
-
-use atomic_destructor::{AtomicDestroyer, AtomicDestructor};
-use event_listener::Event as ShutdownEvent;
-use nostr::prelude::*;
-use serde::de::DeserializeOwned;
-use serde::{Deserialize, Serialize, Serializer};
-use serde_json::{Value, json};
-use smol::channel;
-use smol::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
-use smol::lock::Mutex;
-use smol::net::{TcpListener, TcpStream};
-use uuid::Uuid;
-
-mod error;
-pub mod prelude;
-
-pub use self::error::Error;
-
-const DEFAULT_HTML: &str = include_str!("../index.html");
-const JS: &str = include_str!("../proxy.js");
-
-type PendingResponseMap = HashMap<Uuid, channel::Sender<Result<Value, String>>>;
-
-#[derive(Debug, Deserialize)]
-struct Message {
-    id: Uuid,
-    error: Option<String>,
-    result: Option<Value>,
-}
-
-impl Message {
-    fn into_result(self) -> Result<Value, String> {
-        if let Some(error) = self.error {
-            Err(error)
-        } else {
-            Ok(self.result.unwrap_or(Value::Null))
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-enum RequestMethod {
-    GetPublicKey,
-    SignEvent,
-    Nip04Encrypt,
-    Nip04Decrypt,
-    Nip44Encrypt,
-    Nip44Decrypt,
-}
-
-impl RequestMethod {
-    fn as_str(&self) -> &str {
-        match self {
-            Self::GetPublicKey => "get_public_key",
-            Self::SignEvent => "sign_event",
-            Self::Nip04Encrypt => "nip04_encrypt",
-            Self::Nip04Decrypt => "nip04_decrypt",
-            Self::Nip44Encrypt => "nip44_encrypt",
-            Self::Nip44Decrypt => "nip44_decrypt",
-        }
-    }
-}
-
-impl Serialize for RequestMethod {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(self.as_str())
-    }
-}
-
-#[derive(Debug, Clone, Serialize)]
-struct RequestData {
-    id: Uuid,
-    method: RequestMethod,
-    params: Value,
-}
-
-impl RequestData {
-    #[inline]
-    fn new(method: RequestMethod, params: Value) -> Self {
-        Self {
-            id: Uuid::new_v4(),
-            method,
-            params,
-        }
-    }
-}
-
-#[derive(Serialize)]
-struct Requests<'a> {
-    requests: &'a [RequestData],
-}
-
-impl<'a> Requests<'a> {
-    #[inline]
-    fn new(requests: &'a [RequestData]) -> Self {
-        Self { requests }
-    }
-
-    #[inline]
-    fn len(&self) -> usize {
-        self.requests.len()
-    }
-}
-
-/// Params for NIP-04 and NIP-44 encryption/decryption
-#[derive(Serialize)]
-struct CryptoParams<'a> {
-    public_key: &'a PublicKey,
-    content: &'a str,
-}
-
-impl<'a> CryptoParams<'a> {
-    #[inline]
-    fn new(public_key: &'a PublicKey, content: &'a str) -> Self {
-        Self {
-            public_key,
-            content,
-        }
-    }
-}
-
-#[derive(Debug)]
-struct ProxyState {
-    /// Requests waiting to be picked up by browser
-    pub outgoing_requests: Mutex<Vec<RequestData>>,
-    /// Map of request ID to response sender
-    pub pending_responses: Mutex<PendingResponseMap>,
-    /// Last time the client asked for the pending requests
-    pub last_pending_request: Arc<AtomicU64>,
-}
-
-/// Configuration options for [`BrowserSignerProxy`].
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct BrowserSignerProxyOptions {
-    /// Request timeout for the signer extension. Default is 30 seconds.
-    pub timeout: Duration,
-    /// Proxy server IP address and port. Default is `127.0.0.1:7400`.
-    pub addr: SocketAddr,
-    /// Custom HTML page.
-    // NOTE: not `Option` to move it between threads without reference counter
-    pub custom_html: &'static str,
-}
-
-#[derive(Debug, Clone)]
-struct InnerBrowserSignerProxy {
-    /// Configuration options for the proxy
-    options: BrowserSignerProxyOptions,
-    /// Internal state of the proxy including request queues
-    state: Arc<ProxyState>,
-    /// Notification trigger for graceful shutdown
-    shutdown: Arc<ShutdownEvent>,
-    /// Flag to indicate if the server is shutdown
-    is_shutdown: Arc<AtomicBool>,
-    /// Flag indicating if the server is started
-    is_started: Arc<AtomicBool>,
-}
-
-impl AtomicDestroyer for InnerBrowserSignerProxy {
-    fn on_destroy(&self) {
-        self.shutdown();
-    }
-}
-
-impl InnerBrowserSignerProxy {
-    #[inline]
-    fn is_shutdown(&self) -> bool {
-        self.is_shutdown.load(Ordering::SeqCst)
-    }
-
-    fn shutdown(&self) {
-        // Mark the server as shutdown
-        self.is_shutdown.store(true, Ordering::SeqCst);
-
-        // Notify all waiters that the proxy is shutting down
-        self.shutdown.notify(usize::MAX);
-    }
-}
-
-/// Nostr Browser Signer Proxy
-///
-/// Proxy to use Nostr Browser signer (NIP-07) in native applications.
-#[derive(Debug, Clone)]
-pub struct BrowserSignerProxy {
-    inner: AtomicDestructor<InnerBrowserSignerProxy>,
-}
-
-impl Default for BrowserSignerProxyOptions {
-    fn default() -> Self {
-        Self {
-            timeout: Duration::from_secs(30),
-            // 7 for NIP-07 and 400 because the NIP title is 40 bytes :)
-            addr: SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::LOCALHOST, 7400)),
-            custom_html: "",
-        }
-    }
-}
-
-impl BrowserSignerProxyOptions {
-    /// Sets the timeout duration.
-    pub const fn timeout(mut self, timeout: Duration) -> Self {
-        self.timeout = timeout;
-        self
-    }
-
-    /// Sets the IP address.
-    pub const fn ip_addr(mut self, new_ip: IpAddr) -> Self {
-        self.addr = SocketAddr::new(new_ip, self.addr.port());
-        self
-    }
-
-    /// Sets the port number.
-    pub const fn port(mut self, new_port: u16) -> Self {
-        self.addr = SocketAddr::new(self.addr.ip(), new_port);
-        self
-    }
-
-    /// Sets a custom html page.
-    ///
-    /// The page must include `/proxy.js` script (`<script src="/proxy.js"></script>`)
-    /// which will handle communication with the server and update the element
-    /// with id `nip07-proxy-status` with the status.
-    pub const fn custom_html_page(mut self, custom_html: &'static str) -> Self {
-        self.custom_html = custom_html;
-        self
-    }
-}
-
-impl BrowserSignerProxy {
-    /// Construct a new browser signer proxy
-    pub fn new(options: BrowserSignerProxyOptions) -> Self {
-        let state = ProxyState {
-            outgoing_requests: Mutex::new(Vec::new()),
-            pending_responses: Mutex::new(HashMap::new()),
-            last_pending_request: Arc::new(AtomicU64::new(0)),
-        };
-
-        Self {
-            inner: AtomicDestructor::new(InnerBrowserSignerProxy {
-                options,
-                state: Arc::new(state),
-                shutdown: Arc::new(ShutdownEvent::new()),
-                is_shutdown: Arc::new(AtomicBool::new(false)),
-                is_started: Arc::new(AtomicBool::new(false)),
-            }),
-        }
-    }
-
-    /// Indicates whether the server is currently running.
-    #[inline]
-    pub fn is_started(&self) -> bool {
-        self.inner.is_started.load(Ordering::SeqCst)
-    }
-
-    /// Checks if there is an open browser tab ready to respond to requests by
-    /// verifying the time since the last pending request.
-    #[inline]
-    pub fn is_session_active(&self) -> bool {
-        current_time() - self.inner.state.last_pending_request.load(Ordering::SeqCst) < 2
-    }
-
-    /// Get the signer proxy webpage URL
-    #[inline]
-    pub fn url(&self) -> String {
-        format!("http://{}", self.inner.options.addr)
-    }
-
-    /// Start the proxy server.
-    ///
-    /// If this is not called explicitly, the server will be automatically
-    /// started on the first interaction with the signer.
-    pub async fn start(&self) -> Result<(), Error> {
-        // Ensure is not shutdown
-        if self.inner.is_shutdown() {
-            return Err(Error::shutdown());
-        }
-
-        // Mark the proxy as started and check if was already started
-        let is_started: bool = self.inner.is_started.swap(true, Ordering::SeqCst);
-
-        // Immediately return if already started
-        if is_started {
-            return Ok(());
-        }
-
-        let listener: TcpListener = match TcpListener::bind(self.inner.options.addr).await {
-            Ok(listener) => listener,
-            Err(e) => {
-                // Undo the started flag if binding fails
-                self.inner.is_started.store(false, Ordering::SeqCst);
-                return Err(Error::from(e));
-            }
-        };
-
-        let addr: SocketAddr = self.inner.options.addr;
-        let state: Arc<ProxyState> = self.inner.state.clone();
-        let custom_html: &'static str = self.inner.options.custom_html;
-        let shutdown: Arc<ShutdownEvent> = self.inner.shutdown.clone();
-
-        smol::spawn(async move {
-            tracing::info!("Starting proxy server on {addr}");
-
-            loop {
-                // Race between accepting a new connection and shutdown signal
-                let shutdown_listener = shutdown.listen();
-
-                enum AcceptEvent {
-                    Connection(Result<(TcpStream, SocketAddr), std::io::Error>),
-                    Shutdown,
-                }
-
-                let event = smol::future::or(
-                    async { AcceptEvent::Connection(listener.accept().await) },
-                    async {
-                        shutdown_listener.await;
-                        AcceptEvent::Shutdown
-                    },
-                )
-                .await;
-
-                match event {
-                    AcceptEvent::Connection(Ok((stream, _))) => {
-                        let state: Arc<ProxyState> = state.clone();
-                        let shutdown: Arc<ShutdownEvent> = shutdown.clone();
-
-                        smol::spawn(async move {
-                            let shutdown_listener = shutdown.listen();
-
-                            smol::future::or(
-                                async {
-                                    handle_connection(stream, state, custom_html).await;
-                                },
-                                async {
-                                    shutdown_listener.await;
-                                    tracing::debug!(
-                                        "Closing connection, proxy server is shutting down."
-                                    );
-                                },
-                            )
-                            .await;
-                        })
-                        .detach();
-                    }
-                    AcceptEvent::Connection(Err(e)) => {
-                        tracing::error!("Failed to accept connection: {e}");
-                    }
-                    AcceptEvent::Shutdown => break,
-                }
-            }
-
-            tracing::info!("Proxy server shut down.");
-        })
-        .detach();
-
-        Ok(())
-    }
-
-    #[inline]
-    async fn store_pending_response(&self, id: Uuid, tx: channel::Sender<Result<Value, String>>) {
-        let mut pending_responses = self.inner.state.pending_responses.lock().await;
-        pending_responses.insert(id, tx);
-    }
-
-    #[inline]
-    async fn store_outgoing_request(&self, request: RequestData) {
-        let mut outgoing_requests = self.inner.state.outgoing_requests.lock().await;
-        outgoing_requests.push(request);
-    }
-
-    async fn request<T>(&self, method: RequestMethod, params: Value) -> Result<T, Error>
-    where
-        T: DeserializeOwned,
-    {
-        // Start the proxy if not already started
-        self.start().await?;
-
-        // Construct the request
-        let request: RequestData = RequestData::new(method, params);
-
-        // Create a bounded channel of size 1 as a oneshot replacement
-        let (tx, rx) = channel::bounded::<Result<Value, String>>(1);
-
-        // Store the response sender
-        self.store_pending_response(request.id, tx).await;
-
-        // Add to outgoing requests queue
-        self.store_outgoing_request(request).await;
-
-        // Wait for response with timeout
-        let response = race_timeout(self.inner.options.timeout, rx.recv()).await;
-
-        match response {
-            Ok(Ok(res)) => Ok(serde_json::from_value(res)?),
-            Ok(Err(error)) => Err(Error::generic(error)),
-            Err(TimeoutError) => Err(Error::timeout()),
-        }
-    }
-
-    #[inline]
-    async fn _get_public_key(&self) -> Result<PublicKey, Error> {
-        self.request(RequestMethod::GetPublicKey, json!({})).await
-    }
-
-    #[inline]
-    async fn _sign_event(&self, event: UnsignedEvent) -> Result<Event, Error> {
-        let event: Event = self
-            .request(RequestMethod::SignEvent, serde_json::to_value(event)?)
-            .await?;
-        event.verify()?;
-        Ok(event)
-    }
-
-    #[inline]
-    async fn _nip04_encrypt(&self, public_key: &PublicKey, content: &str) -> Result<String, Error> {
-        let params = CryptoParams::new(public_key, content);
-        self.request(RequestMethod::Nip04Encrypt, serde_json::to_value(params)?)
-            .await
-    }
-
-    #[inline]
-    async fn _nip04_decrypt(&self, public_key: &PublicKey, content: &str) -> Result<String, Error> {
-        let params = CryptoParams::new(public_key, content);
-        self.request(RequestMethod::Nip04Decrypt, serde_json::to_value(params)?)
-            .await
-    }
-
-    #[inline]
-    async fn _nip44_encrypt(&self, public_key: &PublicKey, content: &str) -> Result<String, Error> {
-        let params = CryptoParams::new(public_key, content);
-        self.request(RequestMethod::Nip44Encrypt, serde_json::to_value(params)?)
-            .await
-    }
-
-    #[inline]
-    async fn _nip44_decrypt(&self, public_key: &PublicKey, content: &str) -> Result<String, Error> {
-        let params = CryptoParams::new(public_key, content);
-        self.request(RequestMethod::Nip44Decrypt, serde_json::to_value(params)?)
-            .await
-    }
-}
-
-impl AsyncGetPublicKey for BrowserSignerProxy {
-    type Error = Error;
-
-    #[inline]
-    fn get_public_key_async(
-        &self,
-    ) -> Pin<Box<dyn Future<Output = Result<PublicKey, Self::Error>> + Send + '_>> {
-        Box::pin(async move { self._get_public_key().await })
-    }
-}
-
-impl AsyncSignEvent for BrowserSignerProxy {
-    type Error = Error;
-
-    #[inline]
-    fn sign_event_async(
-        &self,
-        unsigned: UnsignedEvent,
-    ) -> Pin<Box<dyn Future<Output = Result<Event, Self::Error>> + Send + '_>> {
-        Box::pin(async move { self._sign_event(unsigned).await })
-    }
-}
-
-impl AsyncNip04 for BrowserSignerProxy {
-    type Error = Error;
-
-    fn nip04_encrypt_async<'a>(
-        &'a self,
-        public_key: &'a PublicKey,
-        content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'a>> {
-        Box::pin(async move { self._nip04_encrypt(public_key, content).await })
-    }
-
-    fn nip04_decrypt_async<'a>(
-        &'a self,
-        public_key: &'a PublicKey,
-        encrypted_content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'a>> {
-        Box::pin(async move { self._nip04_decrypt(public_key, encrypted_content).await })
-    }
-}
-
-impl AsyncNip44 for BrowserSignerProxy {
-    type Error = Error;
-
-    fn nip44_encrypt_async<'a>(
-        &'a self,
-        public_key: &'a PublicKey,
-        content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'a>> {
-        Box::pin(async move { self._nip44_encrypt(public_key, content).await })
-    }
-
-    fn nip44_decrypt_async<'a>(
-        &'a self,
-        public_key: &'a PublicKey,
-        payload: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'a>> {
-        Box::pin(async move { self._nip44_decrypt(public_key, payload).await })
-    }
-}
-
-// ── Minimal HTTP server ──────────────────────────────────────────────────
-
-/// Handle a single HTTP connection.
-async fn handle_connection(stream: TcpStream, state: Arc<ProxyState>, custom_html: &'static str) {
-    let mut reader = BufReader::new(stream);
-
-    // Read the request line
-    let mut request_line = String::new();
-    if reader.read_line(&mut request_line).await.is_err() {
-        return;
-    }
-    let request_line = request_line.trim_end().to_string();
-
-    // Parse method, path, and HTTP version from request line
-    let parts: Vec<&str> = request_line.split_whitespace().collect();
-    if parts.len() < 2 {
-        send_response(&mut reader, 400, "Bad Request", "", "").await;
-        return;
-    }
-    let method = parts[0].to_uppercase();
-    let path = parts[1].to_string();
-
-    // Read headers until empty line
-    let mut headers = Vec::new();
-    let mut content_length: usize = 0;
-    loop {
-        let mut line = String::new();
-        if reader.read_line(&mut line).await.is_err() {
-            return;
-        }
-        let line = line.trim_end().to_string();
-        if line.is_empty() {
-            break;
-        }
-        if let Some(value) = line.strip_prefix("content-length:") {
-            content_length = value.trim().parse().unwrap_or(0);
-        } else if let Some(value) = line.strip_prefix("Content-Length:") {
-            content_length = value.trim().parse().unwrap_or(0);
-        }
-        headers.push(line);
-    }
-
-    match (method.as_str(), path.as_str()) {
-        // Serve the HTML proxy page
-        ("GET", "/") => {
-            let html = if custom_html.is_empty() {
-                DEFAULT_HTML
-            } else {
-                custom_html
-            };
-            send_response(&mut reader, 200, "OK", "text/html", html).await;
-        }
-        // Serve the JS proxy script
-        ("GET", "/proxy.js") => {
-            send_response(&mut reader, 200, "OK", "application/javascript", JS).await;
-        }
-        // Browser polls this endpoint to get pending requests
-        ("GET", "/api/pending") => {
-            state
-                .last_pending_request
-                .store(current_time(), Ordering::SeqCst);
-
-            let mut outgoing = state.outgoing_requests.lock().await;
-
-            let requests = Requests::new(&outgoing);
-            let json = match serde_json::to_string(&requests) {
-                Ok(j) => j,
-                Err(e) => {
-                    tracing::error!("Failed to serialize pending requests: {e}");
-                    send_response(&mut reader, 500, "Internal Server Error", "", "").await;
-                    return;
-                }
-            };
-
-            tracing::debug!("Sending {} pending requests to browser", requests.len());
-
-            // Clear the outgoing requests after sending them
-            outgoing.clear();
-
-            send_response_cors_json(&mut reader, 200, "OK", &json).await;
-        }
-        // Receive response from browser extension
-        ("POST", "/api/response") => {
-            let mut body_bytes = vec![0u8; content_length];
-            if content_length > 0 && reader.read_exact(&mut body_bytes).await.is_err() {
-                send_response(&mut reader, 400, "Bad Request", "", "").await;
-                return;
-            }
-
-            let message: Message = match serde_json::from_slice(&body_bytes) {
-                Ok(json) => json,
-                Err(e) => {
-                    tracing::error!("Failed to parse response body: {e}");
-                    send_response(&mut reader, 400, "Invalid JSON", "", "").await;
-                    return;
-                }
-            };
-
-            tracing::debug!("Received response from browser: {message:?}");
-
-            let id: Uuid = message.id;
-            let mut pending = state.pending_responses.lock().await;
-
-            match pending.remove(&id) {
-                Some(sender) => {
-                    // Use try_send since we already hold the lock
-                    let _ = sender.try_send(message.into_result());
-                    tracing::info!("Forwarded response for request {id}");
-                }
-                None => tracing::warn!("No pending request found for {id}"),
-            }
-
-            send_response_cors(&mut reader, 200, "OK", "text/plain", "OK").await;
-        }
-        // CORS preflight
-        ("OPTIONS", _) => {
-            let response = "HTTP/1.1 200 OK\r\n\
-                Access-Control-Allow-Origin: *\r\n\
-                Access-Control-Allow-Methods: GET, POST, OPTIONS\r\n\
-                Access-Control-Allow-Headers: Content-Type\r\n\
-                Content-Length: 0\r\n\
-                Connection: close\r\n\
-                \r\n";
-            let _ = reader.get_mut().write_all(response.as_bytes()).await;
-            let _ = reader.get_mut().flush().await;
-        }
-        // 404 - not found
-        _ => {
-            send_response(&mut reader, 404, "Not Found", "", "").await;
-        }
-    }
-}
-
-/// Write an HTTP response to the stream.
-async fn send_response(
-    stream: &mut (impl AsyncWriteExt + Unpin),
-    status: u16,
-    status_text: &str,
-    content_type: &str,
-    body: &str,
-) {
-    let mut response = format!("HTTP/1.1 {status} {status_text}\r\n");
-
-    if !content_type.is_empty() {
-        response.push_str(&format!("Content-Type: {content_type}\r\n"));
-    }
-
-    response.push_str(&format!("Content-Length: {}\r\n", body.len()));
-    response.push_str("Access-Control-Allow-Origin: *\r\n");
-    response.push_str("Connection: close\r\n");
-    response.push_str("\r\n");
-    response.push_str(body);
-
-    let _ = stream.write_all(response.as_bytes()).await;
-    let _ = stream.flush().await;
-}
-
-/// Write a response with CORS headers and JSON content type.
-async fn send_response_cors_json(
-    stream: &mut (impl AsyncWriteExt + Unpin),
-    status: u16,
-    status_text: &str,
-    body: &str,
-) {
-    let mut response = format!("HTTP/1.1 {status} {status_text}\r\n");
-    response.push_str("Content-Type: application/json\r\n");
-    response.push_str(&format!("Content-Length: {}\r\n", body.len()));
-    response.push_str("Access-Control-Allow-Origin: *\r\n");
-    response.push_str("Connection: close\r\n");
-    response.push_str("\r\n");
-    response.push_str(body);
-
-    let _ = stream.write_all(response.as_bytes()).await;
-    let _ = stream.flush().await;
-}
-
-/// Write a response with CORS headers.
-async fn send_response_cors(
-    stream: &mut (impl AsyncWriteExt + Unpin),
-    status: u16,
-    status_text: &str,
-    content_type: &str,
-    body: &str,
-) {
-    let mut response = format!("HTTP/1.1 {status} {status_text}\r\n");
-
-    if !content_type.is_empty() {
-        response.push_str(&format!("Content-Type: {content_type}\r\n"));
-    }
-
-    response.push_str(&format!("Content-Length: {}\r\n", body.len()));
-    response.push_str("Access-Control-Allow-Origin: *\r\n");
-    response.push_str("Connection: close\r\n");
-    response.push_str("\r\n");
-    response.push_str(body);
-
-    let _ = stream.write_all(response.as_bytes()).await;
-    let _ = stream.flush().await;
-}
-
-// ── Timeout helper ───────────────────────────────────────────────────────
-
-/// An error indicating that an operation timed out.
-#[derive(Debug)]
-struct TimeoutError;
-
-/// Races a channel receive against a duration.
-///
-/// Returns the channel value on success, or [`TimeoutError`] if the duration
-/// elapses first or the channel is closed.
-async fn race_timeout<T>(
-    duration: Duration,
-    recv: impl Future<Output = Result<T, channel::RecvError>>,
-) -> Result<T, TimeoutError> {
-    enum Event<T> {
-        Value(T),
-        ChannelClosed,
-        Timeout,
-    }
-
-    let event = smol::future::or(
-        async {
-            match recv.await {
-                Ok(value) => Event::Value(value),
-                Err(_) => Event::ChannelClosed,
-            }
-        },
-        async {
-            smol::Timer::after(duration).await;
-            Event::Timeout
-        },
-    )
-    .await;
-
-    match event {
-        Event::Value(value) => Ok(value),
-        Event::ChannelClosed | Event::Timeout => Err(TimeoutError),
-    }
-}
-
-// ── Utility ──────────────────────────────────────────────────────────────
-
-/// Gets the current time in seconds since the Unix epoch (1970-01-01). If the
-/// time is before the epoch, returns 0.
-#[inline]
-fn current_time() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_secs())
-        .unwrap_or_default()
-}

crates/browser-signer-proxy/src/prelude.rs

@@ -1,14 +0,0 @@
-// Copyright (c) 2022-2023 Yuki Kishimoto
-// Copyright (c) 2023-2025 Rust Nostr Developers
-// Distributed under the MIT software license
-
-//! Prelude
-
-#![allow(unknown_lints)]
-#![allow(ambiguous_glob_reexports)]
-#![doc(hidden)]
-
-pub use nostr::prelude::*;
-
-pub use crate::error::{Error, ErrorKind};
-pub use crate::*;

crates/chat/Cargo.toml

@@ -13,7 +13,6 @@ settings = { path = "../settings" }
 
 gpui.workspace = true
 nostr-sdk.workspace = true
-instant.workspace = true
 
 anyhow.workspace = true
 itertools.workspace = true
@@ -21,7 +20,6 @@ smallvec.workspace = true
 log.workspace = true
 flume.workspace = true
 
-futures.workspace = true
 fuzzy-matcher = "0.3.7"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

crates/chat/src/lib.rs

@@ -1,9 +1,13 @@
 use std::cmp::Reverse;
-use std::collections::{BTreeSet, HashMap, HashSet, hash_map};
+use std::collections::{BTreeSet, HashMap, HashSet};
+use std::hash::{DefaultHasher, Hash, Hasher};
+use std::sync::Arc;
+#[cfg(target_arch = "wasm32")]
+use std::sync::RwLock;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, LazyLock, RwLock};
+use std::time::Duration;
 
-use anyhow::{Error, anyhow};
+use anyhow::{Context as AnyhowContext, Error, anyhow};
 use common::EventExt;
 use fuzzy_matcher::FuzzyMatcher;
 use fuzzy_matcher::skim::SkimMatcherV2;
@@ -11,9 +15,10 @@ use gpui::{
     App, AppContext, Context, Entity, EventEmitter, Global, SharedString, Subscription, Task,
     WeakEntity, Window,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use smallvec::{SmallVec, smallvec};
+#[cfg(not(target_arch = "wasm32"))]
+use smol::lock::RwLock;
 use state::{DEVICE_GIFTWRAP, NostrRegistry, USER_GIFTWRAP, UniversalSigner};
 
 mod message;
@@ -22,9 +27,6 @@ mod room;
 pub use message::*;
 pub use room::*;
 
-/// A static keypair used only for signing locally-cached rumor events.
-static LOCAL_KEYS: LazyLock<Keys> = LazyLock::new(Keys::generate);
-
 pub fn init(window: &mut Window, cx: &mut App) {
     ChatRegistry::set_global(cx.new(|cx| ChatRegistry::new(window, cx)), cx);
 }
@@ -80,19 +82,16 @@ pub struct ChatRegistry {
     /// Chat rooms
     rooms: Vec<Entity<Room>>,
 
-    /// O(1) room lookup by room ID
-    room_index: HashMap<u64, Entity<Room>>,
-
     /// Events that failed to unwrap for any reason
-    trash: Entity<BTreeSet<FailedMessage>>,
+    trashes: Entity<BTreeSet<FailedMessage>>,
 
     /// Tracking events seen on which relays in the current session
-    seen: Arc<RwLock<HashMap<EventId, HashSet<RelayUrl>>>>,
+    seens: Arc<RwLock<HashMap<EventId, HashSet<RelayUrl>>>>,
 
     /// Mapping of unwrapped event ids to their gift wrap event ids
     event_map: Arc<RwLock<HashMap<EventId, EventId>>>,
 
-    /// True while the initial event backlog is still loading
+    /// Tracking the status of unwrapping gift wrap events.
     tracking: Arc<AtomicBool>,
 
     /// Channel for sending signals to the UI.
@@ -104,37 +103,10 @@ pub struct ChatRegistry {
     /// Async tasks
     tasks: SmallVec<[Task<Result<(), Error>>; 2]>,
 
-    /// Notification listener task (cancelled on signer change)
-    notification_listener: Option<Task<Result<(), Error>>>,
-
-    /// Signal consumer task (cancelled on signer change)
-    signal_consumer: Option<Task<Result<(), Error>>>,
-
-    /// Fuzzy matcher for room search (cached; intentionally excluded from Debug)
-    #[allow(dead_code)]
-    matcher: CachedMatcher,
-
     /// Subscriptions
     _subscriptions: SmallVec<[Subscription; 2]>,
 }
 
-/// Wrapper to provide Debug for SkimMatcherV2
-struct CachedMatcher(SkimMatcherV2);
-
-impl std::fmt::Debug for CachedMatcher {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str("CachedMatcher { .. }")
-    }
-}
-
-impl std::ops::Deref for CachedMatcher {
-    type Target = SkimMatcherV2;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
 impl EventEmitter<ChatEvent> for ChatRegistry {}
 
 impl ChatRegistry {
@@ -168,40 +140,35 @@ impl ChatRegistry {
 
         // Run at the end of the current cycle
         cx.defer_in(window, |this, _window, cx| {
+            this.tracking(cx);
             this.get_rooms(cx);
         });
 
         Self {
             rooms: vec![],
-            room_index: HashMap::new(),
-            trash: cx.new(|_| BTreeSet::default()),
-            seen: Arc::new(RwLock::new(HashMap::default())),
+            trashes: cx.new(|_| BTreeSet::default()),
+            seens: Arc::new(RwLock::new(HashMap::default())),
             event_map: Arc::new(RwLock::new(HashMap::default())),
-            tracking: Arc::new(AtomicBool::new(true)),
-            matcher: CachedMatcher(SkimMatcherV2::default()),
+            tracking: Arc::new(AtomicBool::new(false)),
             signal_rx: rx,
             signal_tx: tx,
             tasks: smallvec![],
-            notification_listener: None,
-            signal_consumer: None,
             _subscriptions: subscriptions,
         }
     }
 
     /// Handle nostr notifications
     fn handle_notifications(&mut self, cx: &mut Context<Self>) {
-        // Cancel previous notification tasks before spawning new ones
-        self.notification_listener = None;
-        self.signal_consumer = None;
-
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
 
-        let seen = self.seen.clone();
+        let tracking = self.tracking.clone();
+        let seens = self.seens.clone();
         let event_map = self.event_map.clone();
-        let trash = self.trash.downgrade();
+        let trashes = self.trashes.downgrade();
 
+        let initialized_at = Timestamp::now();
         let sub_id1 = SubscriptionId::new(DEVICE_GIFTWRAP);
         let sub_id2 = SubscriptionId::new(USER_GIFTWRAP);
 
@@ -209,22 +176,19 @@ impl ChatRegistry {
         let tx = self.signal_tx.clone();
         let rx = self.signal_rx.clone();
 
-        self.notification_listener = Some(cx.background_spawn(async move {
+        self.tasks.push(cx.background_spawn(async move {
             let mut notifications = client.notifications();
             let mut processed_events = HashSet::new();
-            const MAX_PROCESSED: usize = 10_000;
 
             while let Some(notification) = notifications.next().await {
                 let ClientNotification::Message { message, relay_url } = notification else {
+                    // Skip non-message notifications
                     continue;
                 };
 
                 match *message {
                     RelayMessage::Event { event, .. } => {
-                        // Prune the dedup set before it grows unbounded
-                        if processed_events.len() >= MAX_PROCESSED {
-                            processed_events.clear();
-                        }
+                        // De-duplicate events by their ID
                         if !processed_events.insert(event.id) {
                             continue;
                         }
@@ -232,6 +196,7 @@ impl ChatRegistry {
                         // Handle msg relays event to determine when the app is ready to subscribe
                         if event.kind == Kind::InboxRelays {
                             let current_user = signer.get_public_key_async().await?;
+                            // Emit the inbox ready signal
                             if event.pubkey == current_user {
                                 tx.send_async(Signal::InboxReady).await?;
                             }
@@ -244,30 +209,33 @@ impl ChatRegistry {
 
                         // Keep track of which relays have seen this event
                         {
-                            let mut seen = seen.write().unwrap();
-                            seen.entry(event.id).or_default().insert(relay_url);
+                            let mut seens = seens.write().await;
+                            seens.entry(event.id).or_default().insert(relay_url);
                         }
 
                         // Extract the rumor from the gift wrap event
                         match extract_rumor(&client, &signer, event.as_ref()).await {
                             Ok(rumor) => {
-                                let Some(rumor_id) = rumor.id else {
-                                    log::error!("Rumor missing id after ensure_id");
-                                    continue;
-                                };
+                                // Map the rumor id to the gift wrap event id for later lookup
                                 {
-                                    let mut event_map = event_map.write().unwrap();
-                                    event_map.insert(rumor_id, event.id);
+                                    let mut event_map = event_map.write().await;
+                                    event_map.insert(rumor.id.unwrap(), event.id);
                                 }
 
+                                // Check if the rumor has a recipient
                                 if rumor.tags.is_empty() {
                                     let signal = Signal::error(&event, "Recipient is missing");
                                     tx.send_async(signal).await?;
                                 }
 
-                                // Emit message for both new and backlog events
+                                // Check if the rumor was created after the chat was initialized (for detecting new messages)
+                                if rumor.created_at >= initialized_at {
                                     let signal = Signal::message(event.id, rumor);
                                     tx.send_async(signal).await?;
+                                } else {
+                                    // Mark the chat still processing new messages
+                                    tracking.store(true, Ordering::Release);
+                                }
                             }
                             Err(e) => {
                                 let reason = format!("Failed to extract rumor: {e}");
@@ -288,7 +256,7 @@ impl ChatRegistry {
             Ok(())
         }));
 
-        self.signal_consumer = Some(cx.spawn(async move |this, cx| {
+        self.tasks.push(cx.spawn(async move |this, cx| {
             while let Ok(message) = rx.recv_async().await {
                 match message {
                     Signal::Message(message) => {
@@ -302,17 +270,13 @@ impl ChatRegistry {
                         })?;
                     }
                     Signal::Eose => {
-                        this.update(cx, |this, _cx| {
-                            this.tracking.store(false, Ordering::Release);
-                        })?;
-
                         this.update(cx, |this, cx| {
                             this.get_rooms(cx);
                         })?;
                     }
-                    Signal::Error(failed) => {
-                        trash.update(cx, |this, cx| {
-                            this.insert(failed);
+                    Signal::Error(trash) => {
+                        trashes.update(cx, |this, cx| {
+                            this.insert(trash);
                             cx.notify();
                         })?;
                     }
@@ -323,6 +287,25 @@ impl ChatRegistry {
         }));
     }
 
+    /// Tracking the status of unwrapping gift wrap events.
+    fn tracking(&mut self, cx: &mut Context<Self>) {
+        let status = self.tracking.clone();
+        let tx = self.signal_tx.clone();
+
+        self.tasks.push(cx.spawn(async move |_, cx| {
+            let loop_duration = Duration::from_secs(15);
+            loop {
+                if status.load(Ordering::Acquire) {
+                    _ = status.compare_exchange(true, false, Ordering::Release, Ordering::Relaxed);
+                    _ = tx.send_async(Signal::Eose).await;
+                } else {
+                    _ = tx.send_async(Signal::Eose).await;
+                }
+                cx.background_executor().timer(loop_duration).await;
+            }
+        }));
+    }
+
     /// Get all necessary metadata from relays for current user
     pub fn get_metadata(&mut self, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
@@ -332,43 +315,55 @@ impl ChatRegistry {
             return;
         };
 
-        self.tasks.push(cx.spawn(async move |this, cx| {
-            // Subscribe to metadata from relays
+        self.tasks.push(cx.background_spawn(async move {
             let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
 
+            // Construct filter for msg relays
             let msg_relays = Filter::new()
                 .kind(Kind::InboxRelays)
                 .author(public_key)
                 .limit(1);
 
+            // Construct filter for contact list
             let contact_list = Filter::new()
                 .kind(Kind::ContactList)
                 .author(public_key)
                 .limit(1);
 
-            _ = client
+            // Subscribe
+            client
                 .subscribe(vec![msg_relays, contact_list])
                 .close_on(opts)
-                .await;
+                .await?;
 
-            // Give relays time to respond
+            Ok(())
+        }));
+
+        let client = nostr.read(cx).client();
+
+        // Spawn a task to verify user inbox relays after 5 seconds
+        self.tasks.push(cx.spawn(async move |this, cx| {
             cx.background_executor().timer(Duration::from_secs(5)).await;
 
-            // Verify inbox relays were received
+            if !cx
+                .background_spawn(async move {
+                    // Construct inbox relays filter
                     let filter = Filter::new()
                         .kind(Kind::InboxRelays)
                         .author(public_key)
                         .limit(1);
 
-            let found = client
+                    // Check the latest inbox relays event in database
+                    client
                         .database()
                         .query(filter)
                         .await
                         .unwrap_or_default()
                         .first_owned()
-                .is_some();
-
-            if !found {
+                        .is_some()
+                })
+                .await
+            {
                 this.update(cx, |_this, cx| {
                     cx.emit(ChatEvent::InboxRelayNotFound);
                 })?;
@@ -384,15 +379,16 @@ impl ChatRegistry {
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
 
-        self.tasks.push(cx.spawn(async move |this, cx| {
         let task: Task<Result<(), Error>> = cx.background_spawn(async move {
             let public_key = signer.get_public_key_async().await?;
 
+            // Construct inbox relays filter
             let filter = Filter::new()
                 .kind(Kind::InboxRelays)
                 .author(public_key)
                 .limit(1);
 
+            // Get the latest inbox relays event in database
             let event = client
                 .database()
                 .query(filter)
@@ -400,14 +396,19 @@ impl ChatRegistry {
                 .first_owned()
                 .ok_or(anyhow::anyhow!("No inbox relays found"))?;
 
+            // Extract relay list from event
             let relays: Vec<RelayUrl> = nip17::extract_relay_list(&event).collect();
+
+            // Ensure relay connections
             for url in relays.iter() {
                 client.add_relay(url).and_connect().await?;
             }
 
+            // Construct gift wrap event filter
             let filter = Filter::new().kind(Kind::GiftWrap).pubkey(public_key);
-                let id = SubscriptionId::new(USER_GIFTWRAP);
+            let id = SubscriptionId::new(format!("{}-msg", public_key.to_hex()));
 
+            // Construct target for subscription
             let target: HashMap<RelayUrl, Filter> = relays
                 .into_iter()
                 .map(|relay| (relay, filter.clone()))
@@ -418,18 +419,18 @@ impl ChatRegistry {
             Ok(())
         });
 
+        self.tasks.push(cx.spawn(async move |this, cx| {
             if let Err(e) = task.await {
                 this.update(cx, |_this, cx| {
                     cx.emit(ChatEvent::Error(e.to_string()));
                 })?;
             }
-
             Ok(())
         }));
     }
 
-    /// Reload the chat registry, fetching messages and contact list from relays.
-    pub fn reload(&mut self, cx: &mut Context<Self>) {
+    /// Refresh the chat registry, fetching messages and contact list from relays.
+    pub fn refresh(&mut self, cx: &mut Context<Self>) {
         self.reset(cx);
         self.get_metadata(cx);
         self.get_rooms(cx);
@@ -440,9 +441,12 @@ impl ChatRegistry {
         self.tracking.load(Ordering::Acquire)
     }
 
-    /// Get a weak reference to a room by its ID
-    pub fn room(&self, id: &u64, _cx: &App) -> Option<WeakEntity<Room>> {
-        self.room_index.get(id).map(|room| room.downgrade())
+    /// Get a weak reference to a room by its ID.
+    pub fn room(&self, id: &u64, cx: &App) -> Option<WeakEntity<Room>> {
+        self.rooms
+            .iter()
+            .find(|this| &this.read(cx).id == id)
+            .map(|this| this.downgrade())
     }
 
     /// Get all rooms based on the filter.
@@ -464,38 +468,35 @@ impl ChatRegistry {
 
     /// Count the number of messages seen by a given relay.
     pub fn count_messages(&self, relay_url: &RelayUrl) -> usize {
-        self.seen
-            .read()
-            .unwrap()
+        self.seens
+            .read_blocking()
             .values()
-            .filter(|s| s.contains(relay_url))
+            .filter(|seen| seen.contains(relay_url))
             .count()
     }
 
     /// Count the number of trash messages.
     pub fn count_trash_messages(&self, cx: &App) -> usize {
-        self.trash.read(cx).len()
+        self.trashes.read(cx).len()
     }
 
     /// Get the trash messages entity.
-    pub fn trash(&self) -> Entity<BTreeSet<FailedMessage>> {
-        self.trash.clone()
+    pub fn trashes(&self) -> Entity<BTreeSet<FailedMessage>> {
+        self.trashes.clone()
     }
 
     /// Get the relays that have seen a given rumor id.
     pub fn rumor_seen_on(&self, id: &EventId) -> Option<HashSet<RelayUrl>> {
         self.event_map
-            .read()
-            .unwrap()
+            .read_blocking()
             .get(id)
             .map(|id| self.seen_on(id))
     }
 
     /// Get the relays that have seen a given gift wrap id.
     pub fn seen_on(&self, id: &EventId) -> HashSet<RelayUrl> {
-        self.seen
-            .read()
-            .unwrap()
+        self.seens
+            .read_blocking()
             .get(id)
             .cloned()
             .unwrap_or_default()
@@ -504,67 +505,60 @@ impl ChatRegistry {
     /// Add a new room to the start of list.
     pub fn add_room<I>(&mut self, room: I, cx: &mut Context<Self>)
     where
-        I: Into<Room>,
+        I: Into<Room> + 'static,
     {
         let nostr = NostrRegistry::global(cx);
+
         let Some(public_key) = nostr.read(cx).current_user() else {
             return;
         };
 
+        cx.spawn(async move |this, cx| {
             let room: Room = room.into().organize(&public_key);
-        let room_id = room.id;
-        let entity = cx.new(|_| room);
-
-        self.room_index.insert(room_id, entity.clone());
-        self.rooms.insert(0, entity);
 
+            this.update(cx, |this, cx| {
+                this.rooms.insert(0, cx.new(|_| room));
                 cx.emit(ChatEvent::Ping);
                 cx.notify();
+            })
+            .ok()
+        })
+        .detach();
     }
 
     /// Emit an open room event.
     ///
     /// If the room is new, add it to the registry.
-    pub fn emit_room(&mut self, room: &Entity<Room>, window: &mut Window, cx: &mut Context<Self>) {
+    pub fn emit_room(&mut self, room: &Entity<Room>, cx: &mut Context<Self>) {
         // Get the room's ID.
         let id = room.read(cx).id;
 
-        // If the room is new, add it to the registry and index.
-        if let hash_map::Entry::Vacant(e) = self.room_index.entry(id) {
-            let entity = room.to_owned();
-            e.insert(entity.clone());
-            self.rooms.insert(0, entity);
+        // If the room is new, add it to the registry.
+        if !self.rooms.iter().any(|r| r.read(cx).id == id) {
+            self.rooms.insert(0, room.to_owned());
         }
 
-        // Emit the open room event deferred to avoid re-entrant reads
-        cx.defer_in(window, move |_this, _window, cx| {
+        // Emit the open room event.
         cx.emit(ChatEvent::OpenRoom(id));
-        });
     }
 
     /// Close a room.
-    pub fn close_room(&mut self, id: u64, window: &mut Window, cx: &mut Context<Self>) {
-        if self.room_index.contains_key(&id) {
-            self.room_index.remove(&id);
-            self.rooms.retain(|r| r.read(cx).id != id);
-            cx.defer_in(window, move |_this, _window, cx| {
+    pub fn close_room(&mut self, id: u64, cx: &mut Context<Self>) {
+        if self.rooms.iter().any(|r| r.read(cx).id == id) {
             cx.emit(ChatEvent::CloseRoom(id));
-            });
         }
     }
 
-    /// Sort rooms by their created at. Only notifies if order changed.
+    /// Sort rooms by their created at.
     pub fn sort(&mut self, cx: &mut Context<Self>) {
-        let before: Vec<_> = self.rooms.iter().map(|ev| ev.read(cx).id).collect();
         self.rooms.sort_by_key(|ev| Reverse(ev.read(cx).created_at));
-        let after: Vec<_> = self.rooms.iter().map(|ev| ev.read(cx).id).collect();
-        if before != after {
         cx.notify();
     }
-    }
 
     /// Finding rooms based on a query.
     pub fn find(&self, query: &str, cx: &App) -> Vec<Entity<Room>> {
+        let matcher = SkimMatcherV2::default();
+
         if let Ok(public_key) = PublicKey::parse(query) {
             self.rooms
                 .iter()
@@ -575,7 +569,7 @@ impl ChatRegistry {
             self.rooms
                 .iter()
                 .filter(|room| {
-                    self.matcher
+                    matcher
                         .fuzzy_match(room.read(cx).display_name(cx).as_ref(), query)
                         .is_some()
                 })
@@ -587,8 +581,7 @@ impl ChatRegistry {
     /// Reset the registry.
     pub fn reset(&mut self, cx: &mut Context<Self>) {
         self.rooms.clear();
-        self.room_index.clear();
-        self.trash.update(cx, |this, cx| {
+        self.trashes.update(cx, |this, cx| {
             this.clear();
             cx.notify();
         });
@@ -615,9 +608,7 @@ impl ChatRegistry {
                 });
             } else {
                 let new_room_id = new_room.id;
-                let entity = cx.new(|_| new_room);
-                self.room_index.insert(new_room_id, entity.clone());
-                self.rooms.push(entity);
+                self.rooms.push(cx.new(|_| new_room));
 
                 let new_index = self.rooms.len();
                 room_map.insert(new_room_id, new_index);
@@ -627,7 +618,13 @@ impl ChatRegistry {
 
     /// Load all rooms from the database.
     pub fn get_rooms(&mut self, cx: &mut Context<Self>) {
-        let task = self.get_rooms_task(cx);
+        let nostr = NostrRegistry::global(cx);
+
+        let Some(public_key) = nostr.read(cx).current_user() else {
+            return;
+        };
+
+        let task = self.get_rooms_from_database(public_key, cx);
 
         self.tasks.push(cx.spawn(async move |this, cx| {
             match task.await {
@@ -638,9 +635,7 @@ impl ChatRegistry {
                     })?;
                 }
                 Err(e) => {
-                    this.update(cx, |_, cx| {
-                        cx.emit(ChatEvent::Error(e.to_string()));
-                    })?;
+                    log::error!("Failed to load rooms: {}", e);
                 }
             };
 
@@ -649,53 +644,77 @@ impl ChatRegistry {
     }
 
     /// Create a task to load rooms from the database
-    fn get_rooms_task(&self, cx: &App) -> Task<Result<HashSet<Room>, Error>> {
+    fn get_rooms_from_database(
+        &self,
+        public_key: PublicKey,
+        cx: &App,
+    ) -> Task<Result<HashSet<Room>, Error>> {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let signer = nostr.read(cx).signer();
 
         cx.background_spawn(async move {
-            let public_key = signer.get_public_key_async().await?;
+            // Get contacts
             let contacts = client
                 .database()
                 .contacts_public_keys(public_key)
                 .await
                 .unwrap_or_default();
 
-            let filter = Filter::new()
+            // Construct authored filter
+            let authored_filter = Filter::new()
                 .kind(Kind::ApplicationSpecificData)
-                .custom_tag(SingleLetterTag::lowercase(Alphabet::K), "14");
+                .custom_tag(SingleLetterTag::lowercase(Alphabet::A), public_key);
 
-            let events = client.database().query(filter).await?;
+            // Get all authored events
+            let authored = client.database().query(authored_filter).await?;
+
+            // Construct addressed filter
+            let addressed_filter = Filter::new()
+                .kind(Kind::ApplicationSpecificData)
+                .custom_tag(SingleLetterTag::lowercase(Alphabet::P), public_key);
+
+            // Get all addressed events
+            let addressed = client.database().query(addressed_filter).await?;
+
+            // Merge authored and addressed events
+            let events = authored.merge(addressed);
+
+            // Collect results
+            let mut rooms: HashSet<Room> = HashSet::new();
             let mut grouped: HashMap<u64, Vec<UnsignedEvent>> = HashMap::new();
 
+            // Process each event and group by room hash
             for raw in events.into_iter() {
                 if let Ok(rumor) = UnsignedEvent::from_json(&raw.content)
-                    && rumor.tags.public_keys().next().is_some()
+                    && rumor.tags.public_keys().peekable().peek().is_some()
                 {
-                    if rumor.pubkey != public_key
-                        && !rumor.tags.public_keys().any(|k| k == public_key)
-                    {
-                        continue;
-                    }
                     grouped.entry(rumor.uniq_id()).or_default().push(rumor);
                 }
             }
 
-            let mut rooms = HashSet::with_capacity(grouped.len());
+            for (_id, mut messages) in grouped.into_iter() {
+                messages.sort_by_key(|m| Reverse(m.created_at));
 
-            for (_id, messages) in grouped.into_iter() {
-                let latest = messages.iter().max_by_key(|m| m.created_at).unwrap();
-                let room = Room::from(latest).organize(&public_key);
+                // Always use the latest message
+                let Some(latest) = messages.first() else {
+                    continue;
+                };
 
+                // Construct the room from the latest message.
+                //
+                // Call `.organize` to ensure the current user is at the end of the list.
+                let mut room = Room::from(latest).organize(&public_key);
+
+                // Check if the user has responded to the room
                 let user_sent = messages.iter().any(|m| m.pubkey == public_key);
+
+                // Check if public keys are from the user's contacts
                 let is_contact = room.members.iter().any(|k| contacts.contains(k));
 
-                let room = if user_sent || is_contact {
-                    room.kind(RoomKind::Ongoing)
-                } else {
-                    room
-                };
+                // Set the room's kind based on status
+                if user_sent || is_contact {
+                    room = room.kind(RoomKind::Ongoing);
+                }
 
                 rooms.insert(room);
             }
@@ -715,7 +734,7 @@ impl ChatRegistry {
             return;
         };
 
-        match self.room_index.get(&message.room).cloned() {
+        match self.rooms.iter().find(|e| e.read(cx).id == message.room) {
             Some(room) => {
                 room.update(cx, |this, cx| {
                     if this.kind == RoomKind::Request && message.rumor.pubkey == public_key {
@@ -756,14 +775,9 @@ async fn extract_rumor(
     }
 
     // Try to unwrap with the available signer
-    let unwrapped = try_unwrap_with(signer, gift_wrap).await?;
+    let unwrapped = try_unwrap(signer, gift_wrap).await?;
     let mut rumor = unwrapped.rumor;
 
-    // Verify rumor author matches the seal sender (as per mobile implementation)
-    if rumor.pubkey != unwrapped.sender {
-        return Err(anyhow!("Rumor author does not match seal sender"));
-    }
-
     // Generate event id for the rumor if it doesn't have one
     rumor.ensure_id();
 
@@ -775,6 +789,25 @@ async fn extract_rumor(
     Ok(rumor)
 }
 
+/// Helper method to try unwrapping with different signers
+async fn try_unwrap(signer: &UniversalSigner, gift_wrap: &Event) -> Result<UnwrappedGift, Error> {
+    /*
+    *  // Try with the device signer first
+    if let Some(signer) = signer.get_encryption_signer().await {
+        log::info!("trying with encryption key");
+        if let Ok(unwrapped) = try_unwrap_with(gift_wrap, &signer).await {
+            return Ok(unwrapped);
+        }
+    }
+
+    // Fallback to the user's signer
+    let user_signer = signer.get().await;
+    */
+    let unwrapped = try_unwrap_with(signer, gift_wrap).await?;
+
+    Ok(unwrapped)
+}
+
 /// Attempts to unwrap a gift wrap event with a given signer.
 async fn try_unwrap_with(
     signer: &UniversalSigner,
@@ -787,7 +820,7 @@ async fn try_unwrap_with(
 
     // Verify the sealed event
     let seal: Event = Event::from_json(seal)?;
-    seal.verify()?;
+    seal.verify_with_ctx(&SECP256K1)?;
 
     // Get the rumor event
     let rumor = signer
@@ -804,20 +837,39 @@ async fn try_unwrap_with(
 
 /// Stores an unwrapped event in local database with reference to original
 async fn set_rumor(client: &Client, id: EventId, rumor: &UnsignedEvent) -> Result<(), Error> {
-    let room_id = rumor.uniq_id().to_string();
+    let rumor_id = rumor.id.context("Rumor is missing an event id")?;
+    let author = rumor.pubkey;
+    let conversation = conversation_id(rumor);
 
-    let tags = vec![
-        Tag::identifier(id),
-        Tag::public_key(rumor.pubkey),
-        Tag::custom("r", [room_id]),
-        Tag::custom("k", ["14"]),
-    ];
+    let mut tags = rumor.tags.clone().to_vec();
 
-    let event = EventBuilder::new(Kind::ApplicationSpecificData, rumor.as_json())
+    // Add a unique identifier
+    tags.push(Tag::identifier(id));
+
+    // Add a reference to the rumor's author
+    tags.push(Tag::custom("a", [author]));
+
+    // Add a conversation id
+    tags.push(Tag::custom("c", [conversation.to_string()]));
+
+    // Add a reference to the rumor's id
+    tags.push(Tag::event(rumor_id));
+
+    // Add references to the rumor's participants
+    for receiver in rumor.tags.public_keys() {
+        tags.push(Tag::custom("P", [receiver]));
+    }
+
+    // Convert rumor to json
+    let content = rumor.as_json();
+
+    // Construct the event
+    let event = EventBuilder::new(Kind::ApplicationSpecificData, content)
         .tags(tags)
-        .finalize_async(&*LOCAL_KEYS)
+        .finalize_async(&Keys::generate())
         .await?;
 
+    // Save the event to the database
     client.database().save_event(&event).await?;
 
     Ok(())
@@ -825,7 +877,10 @@ async fn set_rumor(client: &Client, id: EventId, rumor: &UnsignedEvent) -> Resul
 
 /// Retrieves a previously unwrapped event from local database
 async fn get_rumor(client: &Client, gift_wrap: EventId) -> Result<UnsignedEvent, Error> {
-    let filter = Filter::new().identifier(gift_wrap).limit(1);
+    let filter = Filter::new()
+        .kind(Kind::ApplicationSpecificData)
+        .identifier(gift_wrap)
+        .limit(1);
 
     if let Some(event) = client.database().query(filter).await?.first_owned() {
         UnsignedEvent::from_json(event.content).map_err(|e| anyhow!(e))
@@ -833,3 +888,15 @@ async fn get_rumor(client: &Client, gift_wrap: EventId) -> Result<UnsignedEvent,
         Err(anyhow!("Event is not cached yet."))
     }
 }
+
+/// Get the conversation ID for a given rumor (message).
+fn conversation_id(rumor: &UnsignedEvent) -> u64 {
+    let mut hasher = DefaultHasher::new();
+    let mut pubkeys: Vec<PublicKey> = rumor.tags.public_keys().collect();
+    pubkeys.push(rumor.pubkey);
+    pubkeys.sort();
+    pubkeys.dedup();
+    pubkeys.hash(&mut hasher);
+
+    hasher.finish()
+}

crates/chat/src/room.rs

@@ -1,11 +1,11 @@
 use std::cmp::Ordering;
 use std::hash::{Hash, Hasher};
+use std::time::Duration;
 
 use anyhow::{Error, anyhow};
 use common::EventExt;
 use device::DeviceRegistry;
 use gpui::{App, AppContext, Context, EventEmitter, SharedString, Task};
-use instant::Duration;
 use itertools::Itertools;
 use nostr_sdk::prelude::*;
 use person::{Person, PersonRegistry};
@@ -271,8 +271,8 @@ impl Room {
     }
 
     /// Returns the members of the room
-    pub fn members(&self) -> &[PublicKey] {
-        &self.members
+    pub fn members(&self) -> Vec<PublicKey> {
+        self.members.clone()
     }
 
     /// Checks if the room has more than two members (group)
@@ -356,18 +356,14 @@ impl Room {
     pub fn connect(&self, cx: &App) -> Task<Result<(), Error>> {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let members = self.members().to_vec();
+        let members = self.members();
 
         cx.background_spawn(async move {
             let opts = SubscribeAutoCloseOptions::default()
                 .exit_policy(ReqExitPolicy::ExitOnEOSE)
                 .timeout(Some(Duration::from_secs(TIMEOUT)));
 
-            let tasks: Vec<_> = members
-                .into_iter()
-                .map(|public_key| {
-                    let client = client.clone();
-                    async move {
+            for public_key in members.into_iter() {
                 let inbox = Filter::new()
                     .author(public_key)
                     .kind(Kind::InboxRelays)
@@ -378,16 +374,11 @@ impl Room {
                     .kind(Kind::Custom(10044))
                     .limit(1);
 
+                // Subscribe to the target
                 client
                     .subscribe(vec![inbox, announcement])
                     .close_on(opts)
-                            .await
-                    }
-                })
-                .collect();
-
-            for result in futures::future::join_all(tasks).await {
-                result?;
+                    .await?;
             }
 
             Ok(())
@@ -398,12 +389,12 @@ impl Room {
     pub fn get_messages(&self, cx: &App) -> Task<Result<Vec<UnsignedEvent>, Error>> {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let room_id = self.id.to_string();
+        let conversation_id = self.id.to_string();
 
         cx.background_spawn(async move {
             let filter = Filter::new()
                 .kind(Kind::ApplicationSpecificData)
-                .custom_tag(SingleLetterTag::lowercase(Alphabet::R), room_id);
+                .custom_tag(SingleLetterTag::lowercase(Alphabet::C), conversation_id);
 
             let messages = client
                 .database()
@@ -411,6 +402,10 @@ impl Room {
                 .await?
                 .into_iter()
                 .filter_map(|event| UnsignedEvent::from_json(&event.content).ok())
+                .filter(|event| {
+                    // Only process private direct messages and file messages
+                    event.kind == Kind::PrivateDirectMessage || event.kind == Kind::Custom(15)
+                })
                 .sorted_by_key(|message| message.created_at)
                 .collect();
 
@@ -419,23 +414,12 @@ impl Room {
     }
 
     // Construct a rumor event for direct message
-    pub fn rumor<S, I>(
-        &self,
-        content: S,
-        replies: I,
-        reaction: bool,
-        cx: &App,
-    ) -> Option<UnsignedEvent>
+    pub fn rumor<S, I>(&self, content: S, replies: I, cx: &App) -> Option<UnsignedEvent>
     where
         S: Into<String>,
         I: IntoIterator<Item = EventId>,
     {
-        let kind = if reaction {
-            Kind::Reaction
-        } else {
-            Kind::PrivateDirectMessage
-        };
-
+        let kind = Kind::PrivateDirectMessage;
         let content: String = content.into();
         let replies: Vec<EventId> = replies.into_iter().collect();
 
@@ -445,6 +429,14 @@ impl Room {
         // Get current user's public key
         let sender = nostr.read(cx).current_user()?;
 
+        // Get all members, excluding the sender
+        let members: Vec<Person> = self
+            .members
+            .iter()
+            .filter(|public_key| public_key != &&sender)
+            .map(|member| persons.read(cx).get(member, cx))
+            .collect();
+
         // Construct event's tags
         let mut tags = vec![];
 
@@ -458,9 +450,8 @@ impl Room {
             tags.push(Tag::event(id))
         }
 
-        // Add all receiver tags (no intermediate allocation)
-        for public_key in self.members.iter().filter(|pk| *pk != &sender) {
-            let member = persons.read(cx).get(public_key, cx);
+        // Add all receiver tags
+        for member in members.into_iter() {
             tags.push(
                 Nip01Tag::PublicKey {
                     public_key: member.public_key(),
@@ -482,30 +473,6 @@ impl Room {
         Some(event)
     }
 
-    /// Select the appropriate signer based on signer kind and available keys.
-    fn select_signer(
-        signer_kind: &SignerKind,
-        has_announcement: bool,
-        encryption_signer: &Option<UniversalSigner>,
-        user_signer: &UniversalSigner,
-    ) -> UniversalSigner {
-        match signer_kind {
-            SignerKind::Auto => {
-                if has_announcement {
-                    encryption_signer
-                        .clone()
-                        .unwrap_or_else(|| user_signer.clone())
-                } else {
-                    user_signer.clone()
-                }
-            }
-            SignerKind::Encryption => encryption_signer
-                .clone()
-                .expect("encryption signer must be set"),
-            SignerKind::User => user_signer.clone(),
-        }
-    }
-
     /// Send rumor event to all members's messaging relays
     pub fn send(&self, rumor: UnsignedEvent, cx: &App) -> Option<Task<Vec<SendReport>>> {
         let config = self.config.clone();
@@ -558,12 +525,23 @@ impl Room {
                 }
 
                 // Determine the signer to use
-                let signer = Self::select_signer(
-                    signer_kind,
-                    announcement.is_some(),
-                    &encryption_signer,
-                    &user_signer,
-                );
+                let signer = match signer_kind {
+                    SignerKind::Auto => {
+                        if announcement.is_some()
+                            && let Some(encryption_signer) = encryption_signer.clone()
+                        {
+                            // Safe to unwrap due to earlier checks
+                            encryption_signer
+                        } else {
+                            user_signer.clone()
+                        }
+                    }
+                    SignerKind::Encryption => {
+                        // Safe to unwrap due to earlier checks
+                        encryption_signer.as_ref().unwrap().clone()
+                    }
+                    SignerKind::User => user_signer.clone(),
+                };
 
                 // Send the gift wrap event and collect the report
                 match send_gift_wrap(&client, &signer, &member, &rumor, signer_kind).await {
@@ -583,12 +561,23 @@ impl Room {
                 let public_key = sender.public_key();
 
                 // Determine the signer to use
-                let signer = Self::select_signer(
-                    signer_kind,
-                    sender.announcement().is_some(),
-                    &encryption_signer,
-                    &user_signer,
-                );
+                let signer = match signer_kind {
+                    SignerKind::Auto => {
+                        if sender.announcement().is_some()
+                            && let Some(encryption_signer) = encryption_signer.clone()
+                        {
+                            // Safe to unwrap due to earlier checks
+                            encryption_signer
+                        } else {
+                            user_signer.clone()
+                        }
+                    }
+                    SignerKind::Encryption => {
+                        // Safe to unwrap due to earlier checks
+                        encryption_signer.as_ref().unwrap().clone()
+                    }
+                    SignerKind::User => user_signer.clone(),
+                };
 
                 match send_gift_wrap(&client, &signer, &sender, &rumor, signer_kind).await {
                     Ok(report) => reports.push(report),

crates/chat_ui/Cargo.toml

@@ -19,11 +19,11 @@ anyhow.workspace = true
 itertools.workspace = true
 smallvec.workspace = true
 flume.workspace = true
-futures.workspace = true
 log.workspace = true
 serde.workspace = true
 
 linkify = "0.10.0"
 pulldown-cmark = "0.13.1"
-regex = "1"
 
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+smol.workspace = true

crates/chat_ui/src/lib.rs

@@ -1,26 +1,27 @@
-use std::collections::{BTreeMap, HashMap, HashSet};
-use std::sync::{Arc, LazyLock, RwLock};
+use std::collections::{BTreeMap, BTreeSet, HashSet};
+use std::sync::Arc;
+#[cfg(target_arch = "wasm32")]
+use std::sync::RwLock;
 
 pub use actions::*;
 use anyhow::{Context as AnyhowContext, Error};
 use chat::{ChatRegistry, Message, Room, RoomEvent, SendReport, SendStatus};
 use common::{TimestampExt, coop_cache};
-use futures::lock::Mutex;
 use gpui::prelude::FluentBuilder;
 use gpui::{
     AnyElement, App, AppContext, ClipboardItem, Context, Entity, EventEmitter, FocusHandle,
     Focusable, InteractiveElement, IntoElement, ListAlignment, ListOffset, ListState, MouseButton,
     ObjectFit, ParentElement, PathPromptOptions, Render, SharedString, SharedUri,
-    StatefulInteractiveElement, Styled, StyledImage, Subscription, SystemNotification,
-    SystemNotificationAction, Task, WeakEntity, Window, div, img, list, px, red, relative, svg,
-    white,
+    StatefulInteractiveElement, Styled, StyledImage, Subscription, Task, WeakEntity, Window, div,
+    img, list, px, red, relative, svg, white,
 };
 use itertools::Itertools;
 use nostr_sdk::prelude::*;
 use person::{Person, PersonRegistry};
-use regex::Regex;
 use settings::{AppSettings, SignerKind};
 use smallvec::{SmallVec, smallvec};
+#[cfg(not(target_arch = "wasm32"))]
+use smol::lock::RwLock;
 use state::{NostrRegistry, upload};
 use theme::ActiveTheme;
 use ui::avatar::Avatar;
@@ -37,14 +38,6 @@ use ui::{
 
 use crate::text::RenderedText;
 
-const REACTION_EMOJIS: &[&str] = &["👍", "👎", "😄", "🎉", "😕", "❤️", "🚀", "👀"];
-const COMPACT_REACTION_EMOJIS: &[&str] = &["👍", "❤️", "👀"];
-
-/// Regex matching strings that consist entirely of emoji characters,
-/// zero-width joiners, variation selectors, and keycap combiners.
-static EMOJI_RE: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"^[\p{Emoji}\u{200D}\u{FE0F}\u{20E3}]+$").unwrap());
-
 mod actions;
 mod text;
 
@@ -63,20 +56,14 @@ pub struct ChatPanel {
     /// Message list state
     list_state: ListState,
 
-    /// All messages (sorted by created_at)
-    messages: Vec<Message>,
-
-    /// O(1) message lookup by EventId
-    message_index: HashMap<EventId, usize>,
-
-    /// All reactions
-    reactions: BTreeMap<EventId, Vec<(SharedString, PublicKey)>>,
+    /// All messages
+    messages: BTreeSet<Message>,
 
     /// Mapping message ids to their rendered texts
     rendered_texts_by_id: BTreeMap<EventId, RenderedText>,
 
     /// Mapping message (rumor event) ids to their reports
-    reports_by_id: Arc<RwLock<BTreeMap<EventId, Vec<SendReport>>>>,
+    reports_by_id: Entity<BTreeMap<EventId, Vec<SendReport>>>,
 
     /// Chat input state
     input: Entity<InputState>,
@@ -88,7 +75,7 @@ pub struct ChatPanel {
     subject_bar: Entity<bool>,
 
     /// Sent message ids
-    sent_ids: Arc<Mutex<Vec<EventId>>>,
+    sent_ids: Arc<RwLock<Vec<EventId>>>,
 
     /// Replies to
     replies_to: Entity<HashSet<EventId>>,
@@ -111,10 +98,10 @@ impl ChatPanel {
         // Define attachments and replies_to entities
         let attachments = cx.new(|_| vec![]);
         let replies_to = cx.new(|_| HashSet::new());
-        let reports_by_id = Arc::new(RwLock::new(BTreeMap::new()));
+        let reports_by_id = cx.new(|_| BTreeMap::new());
 
         // Define list of messages
-        let messages = Vec::new();
+        let messages = BTreeSet::default();
         let list_state = ListState::new(messages.len(), ListAlignment::Bottom, px(1024.));
 
         // Get room id and name
@@ -176,8 +163,6 @@ impl ChatPanel {
             focus_handle: cx.focus_handle(),
             id,
             messages,
-            message_index: HashMap::new(),
-            reactions: BTreeMap::new(),
             room,
             list_state,
             input,
@@ -187,7 +172,7 @@ impl ChatPanel {
             attachments,
             rendered_texts_by_id: BTreeMap::new(),
             reports_by_id,
-            sent_ids: Arc::new(Mutex::new(Vec::new())),
+            sent_ids: Arc::new(RwLock::new(Vec::new())),
             uploading: false,
             subscriptions,
             tasks: vec![],
@@ -207,7 +192,7 @@ impl ChatPanel {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
         let sent_ids = self.sent_ids.clone();
-        let reports = self.reports_by_id.clone();
+        let reports = self.reports_by_id.downgrade();
 
         let (tx, rx) = flume::bounded::<Arc<SendStatus>>(256);
 
@@ -222,7 +207,7 @@ impl ChatPanel {
                         message,
                     } = *message
                 {
-                    let sent_ids = sent_ids.lock().await;
+                    let sent_ids = sent_ids.read().await;
 
                     if sent_ids.contains(&event_id) {
                         let status = if status {
@@ -238,37 +223,30 @@ impl ChatPanel {
             Ok(())
         }));
 
-        self.tasks.push(cx.spawn(async move |this, cx| {
+        self.tasks.push(cx.spawn(async move |_this, cx| {
             while let Ok(status) = rx.recv_async().await {
-                {
-                    let mut map = reports.write().unwrap();
-                    let status_id = match &*status {
-                        SendStatus::Ok { id, .. } => *id,
-                        SendStatus::Failed { id, .. } => *id,
-                    };
-
-                    // Find the matching report and update it (exit early on first match)
-                    'outer: for reports_list in map.values_mut() {
-                        for report in reports_list.iter_mut() {
+                reports.update(cx, |this, cx| {
+                    for reports in this.values_mut() {
+                        for report in reports.iter_mut() {
                             let Some(output) = report.output.as_mut() else {
                                 continue;
                             };
-                            if *output.id() != status_id {
-                                continue;
-                            }
                             match &*status {
-                                SendStatus::Ok { relay, .. } => {
+                                SendStatus::Ok { id, relay } => {
+                                    if output.id() == id {
                                         output.success.insert(relay.clone(), EventSendStatus::Sent);
                                     }
-                                SendStatus::Failed { relay, message, .. } => {
+                                }
+                                SendStatus::Failed { id, relay, message } => {
+                                    if output.id() == id {
                                         output.failed.insert(relay.clone(), message.clone());
                                     }
                                 }
-                            break 'outer;
+                            }
+                            cx.notify();
                         }
                     }
-                }
-                this.update(cx, |_, cx| cx.notify()).ok();
+                })?;
             }
             Ok(())
         }));
@@ -276,45 +254,23 @@ impl ChatPanel {
 
     /// Subscribe to room events
     fn subscribe_room_events(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        let Some(room) = self.room.upgrade() else {
-            return;
-        };
-
+        if let Some(room) = self.room.upgrade() {
             self.subscriptions.push(cx.subscribe_in(
                 &room,
                 window,
                 move |this, _room, event, window, cx| {
                     match event {
                         RoomEvent::Incoming(message) => {
-                        if message.rumor.kind == Kind::Reaction {
-                            this.insert_reaction(&message.rumor, cx);
-                        } else {
                             this.insert_message(message, false, cx);
-
-                            if !window.is_window_active() {
-                                cx.show_system_notification(SystemNotification {
-                                    tag: "message".into(),
-                                    title: "New Message".into(),
-                                    body: "You have a new message.".into(),
-                                    actions: vec![SystemNotificationAction {
-                                        id: "open".into(),
-                                        label: "Open".into(),
-                                    }],
-                                });
-                            }
-                        }
                         }
                         RoomEvent::Reload => {
-                        // Defer to avoid re-entrant read on Room while
-                        // emit_refresh holds a write lock (via refresh_rooms).
-                        cx.defer_in(window, |this, window, cx| {
                             this.get_messages(window, cx);
-                        });
                         }
                     };
                 },
             ));
         }
+    }
 
     /// Load all messages belonging to this room
     fn get_messages(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
@@ -373,107 +329,85 @@ impl ChatPanel {
         // Get the message which includes all attachments
         let content = self.get_input_value(cx);
 
-        // Get the replies to this message
-        let replies: Vec<EventId> = self.replies_to.read(cx).iter().copied().collect();
-
         // Return if message is empty
         if content.trim().is_empty() {
             window.push_notification("Cannot send an empty message", cx);
             return;
         }
 
-        // If replying to exactly one message with only a valid emoji,
-        // send as a reaction instead of a text message
-        if replies.len() == 1 && EMOJI_RE.is_match(&content) && self.attachments.read(cx).is_empty()
-        {
-            for reply in &replies {
-                self.send_reaction(&content, reply, window, cx);
-            }
-            self.clear(window, cx);
-            return;
-        }
-
-        self.send_message(&content, replies, false, window, cx);
-    }
-
-    fn send_reaction(
-        &mut self,
-        emoji: &str,
-        target: &EventId,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        // Return if emoji is empty
-        if emoji.trim().is_empty() {
-            window.push_notification("Cannot send an empty reaction", cx);
-            return;
-        }
-
-        self.send_message(emoji, vec![*target], true, window, cx);
+        self.send_message(&content, window, cx);
     }
 
     /// Send a message to all members of the chat
-    fn send_message(
-        &mut self,
-        value: &str,
-        replies: Vec<EventId>,
-        reaction: bool,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
+    fn send_message(&mut self, value: &str, window: &mut Window, cx: &mut Context<Self>) {
         if value.trim().is_empty() {
             window.push_notification("Cannot send an empty message", cx);
             return;
         }
 
+        // Get room entity
         let room = self.room.clone();
+
+        // Get content and replies
+        let replies: Vec<EventId> = self.replies_to.read(cx).iter().copied().collect();
         let content = value.to_string();
-        let sent_ids = self.sent_ids.clone();
 
-        // Upgrade room and create rumor + send task in a single read lock
-        let Some(room_entity) = room.upgrade() else {
-            return;
-        };
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            let room = room.upgrade().context("Room is not available")?;
 
-        // Create rumor and send task
-        let (rumor, send_task) = match room_entity.read_with(cx, |room, cx| {
-            let rumor = room.rumor(content.clone(), replies.clone(), reaction, cx)?;
-            let send_task = room.send(rumor.clone(), cx)?;
-            Some((rumor, send_task))
-        }) {
-            Some(pair) => pair,
+            this.update_in(cx, |this, window, cx| {
+                match room.read(cx).rumor(content, replies, cx) {
+                    Some(rumor) => {
+                        this.insert_message(&rumor, true, cx);
+                        this.send_and_wait(rumor, window, cx);
+                        this.clear(window, cx);
+                    }
                     None => {
                         window.push_notification("Failed to create message", cx);
-                return;
                     }
-        };
+                }
+            })?;
 
-        let id = rumor.id.expect("rumor must have an id");
-
-        // Insert optimistic message and clear input
-        if rumor.kind != Kind::Reaction {
-            self.insert_message(&rumor, true, cx);
-            self.clear(window, cx);
-        } else {
-            self.insert_reaction(&rumor, cx);
+            Ok(())
+        }));
     }
 
-        // Update reports
+    /// Send message in the background and wait for the response
+    fn send_and_wait(&mut self, rumor: UnsignedEvent, window: &mut Window, cx: &mut Context<Self>) {
+        let sent_ids = self.sent_ids.clone();
+
+        // This can't fail, because we already ensured that the ID is set
+        let id = rumor.id.unwrap();
+
+        // Add empty reports
         self.insert_reports(id, vec![], cx);
 
-        // Spawn a single task to await the send and update reports
-        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
-            let outputs = send_task.await;
+        // Upgrade room reference
+        let Some(room) = self.room.upgrade() else {
+            return;
+        };
 
-            let mut sent_ids = sent_ids.lock().await;
+        // Get the send message task
+        let Some(task) = room.read(cx).send(rumor, cx) else {
+            window.push_notification("Failed to send message", cx);
+            return;
+        };
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            // Send and get reports
+            let outputs = task.await;
+
+            // Add sent IDs to the list
+            let mut sent_ids = sent_ids.write().await;
             sent_ids.extend(outputs.iter().filter_map(|output| output.gift_wrap_id));
 
+            // Update the state
             this.update(cx, |this, cx| {
                 this.insert_reports(id, outputs, cx);
             })?;
 
             Ok(())
-        }));
+        }))
     }
 
     /// Clear the input field, attachments, and replies
@@ -495,13 +429,10 @@ impl ChatPanel {
 
     /// Insert reports
     fn insert_reports(&mut self, id: EventId, reports: Vec<SendReport>, cx: &mut Context<Self>) {
-        self.reports_by_id
-            .write()
-            .unwrap()
-            .entry(id)
-            .or_default()
-            .extend(reports);
+        self.reports_by_id.update(cx, |this, cx| {
+            this.entry(id).or_default().extend(reports);
             cx.notify();
+        });
     }
 
     /// Insert a message into the chat panel
@@ -510,14 +441,9 @@ impl ChatPanel {
         E: Into<Message>,
     {
         let old_len = self.messages.len();
-        let msg: Message = m.into();
 
-        if let Err(pos) = self.messages.binary_search(&msg) {
-            self.messages.insert(pos, msg);
-            // Rebuild message index after insertion (indices from pos to end shift)
-            for (i, message) in self.messages.iter().enumerate().skip(pos) {
-                self.message_index.insert(message.id, i);
-            }
+        // Extend the messages list with the new events
+        if self.messages.insert(m.into()) {
             self.list_state.splice(old_len..old_len, 1);
 
             if scroll {
@@ -534,56 +460,24 @@ impl ChatPanel {
     /// Convert and insert a vector of nostr events into the chat panel
     fn insert_messages(&mut self, events: &[UnsignedEvent], cx: &mut Context<Self>) {
         for event in events.iter() {
-            if event.kind == Kind::Reaction {
-                self.insert_reaction(event, cx);
-                continue;
-            }
             // Bulk inserting messages, so no need to scroll to the latest message
             self.insert_message(event, false, cx);
         }
     }
 
-    /// Insert a reaction into the chat panel
-    fn insert_reaction(&mut self, event: &UnsignedEvent, cx: &mut Context<Self>) {
-        if event.kind != Kind::Reaction {
-            return;
-        }
-
-        for id in event.tags.event_ids() {
-            self.reactions
-                .entry(id)
-                .or_default()
-                .push((SharedString::from(&event.content), event.pubkey));
-        }
-
-        cx.notify();
-    }
-
     /// Check if a message has any reports
-    fn has_reports(&self, id: &EventId) -> bool {
-        self.reports_by_id.read().unwrap().contains_key(id)
+    fn has_reports(&self, id: &EventId, cx: &App) -> bool {
+        self.reports_by_id.read(cx).get(id).is_some()
     }
 
-    /// Clone reports for a message (used for modal display, not called during render)
-    fn sent_reports(&self, id: &EventId) -> Option<Vec<SendReport>> {
-        self.reports_by_id.read().unwrap().get(id).cloned()
+    /// Get all sent reports for a message by its ID
+    fn sent_reports(&self, id: &EventId, cx: &App) -> Option<Vec<SendReport>> {
+        self.reports_by_id.read(cx).get(id).cloned()
     }
 
-    /// Get a message by its ID (O(1) lookup)
+    /// Get a message by its ID
     fn message(&self, id: &EventId) -> Option<&Message> {
-        self.message_index
-            .get(id)
-            .and_then(|&ix| self.messages.get(ix))
-    }
-
-    /// Get a reaction by its target ID (returns reference, no allocation)
-    fn reaction(&self, id: &EventId) -> &[(SharedString, PublicKey)] {
-        self.reactions.get(id).map(|v| v.as_slice()).unwrap_or(&[])
-    }
-
-    /// Check if a message has any reactions
-    fn has_reaction(&self, id: &EventId) -> bool {
-        self.reactions.contains_key(id)
+        self.messages.iter().find(|msg| &msg.id == id)
     }
 
     /// Scroll to a message by its ID
@@ -698,10 +592,7 @@ impl ChatPanel {
     fn on_command(&mut self, command: &Command, window: &mut Window, cx: &mut Context<Self>) {
         match command {
             Command::Insert(content) => {
-                self.input.update(cx, |this, cx| {
-                    let new_value = format!("{} {}", this.value(), content);
-                    this.set_value(new_value, window, cx);
-                });
+                self.send_message(content, window, cx);
             }
             Command::ChangeSubject(subject) => {
                 if self
@@ -905,8 +796,10 @@ impl ChatPanel {
             return true;
         }
 
-        if let Some(previous) = self.messages.get(ix - 1)
-            && let Some(current) = self.messages.get(ix)
+        let mut iter = self.messages.iter();
+
+        if let Some(previous) = iter.nth(ix - 1)
+            && let Some(current) = iter.next()
         {
             if current.author != previous.author {
                 return true;
@@ -929,7 +822,7 @@ impl ChatPanel {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> AnyElement {
-        if let Some(message) = self.messages.get(ix) {
+        if let Some(message) = self.messages.iter().nth(ix) {
             let persons = PersonRegistry::global(cx);
             let show_author = self.is_group_start(ix);
             let text = self
@@ -960,8 +853,7 @@ impl ChatPanel {
 
         let replies = message.replies_to.as_slice();
         let has_replies = !replies.is_empty();
-        let has_reactions = self.has_reaction(&id);
-        let has_reports = self.has_reports(&id);
+        let has_reports = self.has_reports(&id, cx);
 
         // Hide avatar setting
         let hide_avatar = AppSettings::get_hide_avatar(cx);
@@ -1006,7 +898,12 @@ impl ChatPanel {
                                         .gap_2()
                                         .text_sm()
                                         .text_color(cx.theme().text_placeholder)
-                                        .child(div().font_semibold().child(author.name()))
+                                        .child(
+                                            div()
+                                                .font_semibold()
+                                                .text_color(cx.theme().text)
+                                                .child(author.name()),
+                                        )
                                         .child(message.created_at.to_human_time())
                                         .when(has_reports, |this| {
                                             this.child(self.render_sent_reports(&id, cx))
@@ -1017,10 +914,7 @@ impl ChatPanel {
                                 this.children(self.render_message_replies(replies, cx))
                             })
                             .child(rendered_text)
-                            .child(self.render_media(&message.media, cx))
-                            .when(has_reactions, |this| {
-                                this.child(self.render_reactions(&id, cx))
-                            }),
+                            .child(self.render_media(&message.media, cx)),
                     ),
             )
             .child(
@@ -1115,9 +1009,13 @@ impl ChatPanel {
                     .w_full()
                     .px_2()
                     .border_l_2()
-                    .border_color(cx.theme().element_active)
+                    .border_color(cx.theme().element_selected)
                     .text_sm()
-                    .child(div().font_semibold().child(author.name()))
+                    .child(
+                        div()
+                            .text_color(cx.theme().text_accent)
+                            .child(author.name()),
+                    )
                     .child(
                         div()
                             .w_full()
@@ -1138,45 +1036,8 @@ impl ChatPanel {
         items
     }
 
-    fn render_reactions(&self, id: &EventId, cx: &App) -> impl IntoElement {
-        let current_user = NostrRegistry::global(cx).read(cx).current_user();
-        let reactions = self.reaction(id);
-
-        // Group reactions by emoji and collect authors for each
-        let mut grouped: BTreeMap<SharedString, Vec<PublicKey>> = BTreeMap::new();
-        for (emoji, author) in reactions {
-            grouped.entry(emoji.clone()).or_default().push(*author);
-        }
-
-        h_flex()
-            .mt_2()
-            .gap_1()
-            .children(grouped.into_iter().map(|(emoji, authors)| {
-                let count = authors.len();
-                let has_reacted = current_user
-                    .map(|pk| authors.contains(&pk))
-                    .unwrap_or(false);
-
-                h_flex()
-                    .gap_2()
-                    .py_0p5()
-                    .px_1()
-                    .rounded(cx.theme().radius)
-                    .text_xs()
-                    .border_1()
-                    .when(has_reacted, |this| {
-                        this.text_color(cx.theme().secondary_foreground)
-                            .bg(cx.theme().secondary_background)
-                            .border_color(cx.theme().secondary_active)
-                    })
-                    .when(!has_reacted, |this| this.border_color(cx.theme().border))
-                    .child(emoji)
-                    .child(SharedString::from(count.to_string()))
-            }))
-    }
-
     fn render_sent_reports(&self, id: &EventId, cx: &App) -> impl IntoElement {
-        let reports = self.sent_reports(id);
+        let reports = self.sent_reports(id, cx);
 
         let pending = reports
             .as_ref()
@@ -1350,29 +1211,6 @@ impl ChatPanel {
             .border_1()
             .border_color(cx.theme().border)
             .bg(cx.theme().background)
-            .children({
-                let mut items = vec![];
-
-                for emoji in COMPACT_REACTION_EMOJIS {
-                    items.push(
-                        Button::new(*emoji)
-                            .label(*emoji)
-                            .tooltip(*emoji)
-                            .small()
-                            .ghost()
-                            .on_click({
-                                let emoji = *emoji;
-                                let id = *id;
-                                cx.listener(move |this, _event, window, cx| {
-                                    this.send_reaction(emoji, &id, window, cx);
-                                })
-                            }),
-                    );
-                }
-
-                items
-            })
-            .child(div().flex_shrink_0().h_4().w_px().bg(cx.theme().border))
             .child(
                 Button::new("reply")
                     .icon(IconName::Reply)
@@ -1486,7 +1324,7 @@ impl ChatPanel {
                                 .gap_1()
                                 .text_xs()
                                 .text_color(cx.theme().text_muted)
-                                .child("Replying to:")
+                                .child(SharedString::from("Replying to:"))
                                 .child(
                                     div()
                                         .text_color(cx.theme().text_accent)
@@ -1583,10 +1421,15 @@ impl ChatPanel {
             .ghost()
             .large()
             .dropdown_menu_with_anchor(gpui::Anchor::BottomLeft, move |this, _window, _cx| {
-                let menu = this.horizontal();
-                REACTION_EMOJIS.iter().fold(menu, |this, emoji| {
-                    this.menu(*emoji, Box::new(Command::Insert(emoji)))
-                })
+                this.horizontal()
+                    .menu("👍", Box::new(Command::Insert("👍")))
+                    .menu("👎", Box::new(Command::Insert("👎")))
+                    .menu("😄", Box::new(Command::Insert("😄")))
+                    .menu("🎉", Box::new(Command::Insert("🎉")))
+                    .menu("😕", Box::new(Command::Insert("😕")))
+                    .menu("❤️", Box::new(Command::Insert("❤️")))
+                    .menu("🚀", Box::new(Command::Insert("🚀")))
+                    .menu("👀", Box::new(Command::Insert("👀")))
             })
     }
 }
@@ -1653,7 +1496,12 @@ impl Render for ChatPanel {
                         .gap_2()
                         .border_b_1()
                         .border_color(cx.theme().border)
-                        .child(Input::new(&self.subject_input).text_sm().small())
+                        .child(
+                            Input::new(&self.subject_input)
+                                .text_sm()
+                                .small()
+                                .bordered(false),
+                        )
                         .child(
                             Button::new("change")
                                 .icon(IconName::CheckCircle)

crates/common/Cargo.toml

@@ -7,7 +7,6 @@ publish.workspace = true
 [dependencies]
 gpui.workspace = true
 nostr.workspace = true
-instant.workspace = true
 nostr-sdk.workspace = true
 
 itertools.workspace = true

crates/common/src/debounced_delay.rs

@@ -1,5 +1,5 @@
 use std::marker::PhantomData;
-use instant::Duration;
+use std::time::Duration;
 
 use futures::channel::oneshot;
 use futures::FutureExt;

crates/device/Cargo.toml

@@ -14,7 +14,6 @@ settings = { path = "../settings" }
 
 gpui.workspace = true
 nostr-sdk.workspace = true
-instant.workspace = true
 anyhow.workspace = true
 smallvec.workspace = true
 log.workspace = true

crates/device/src/lib.rs

@@ -4,7 +4,7 @@ use std::path::PathBuf;
 use std::rc::Rc;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
-use instant::Duration;
+use std::time::Duration;
 
 use anyhow::{Context as AnyhowContext, Error, anyhow};
 use gpui::{
@@ -92,6 +92,7 @@ impl DeviceRegistry {
     fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let nostr = NostrRegistry::global(cx);
         let settings = AppSettings::global(cx);
+        let nip4e_enabled = settings.read(cx).is_nip4e_enabled(cx);
 
         let signer = cx.new(|_| None);
         let mut subscriptions = smallvec![];
@@ -108,7 +109,7 @@ impl DeviceRegistry {
         subscriptions.push(
             // Observe the user signer
             cx.subscribe(&nostr, move |this, _nostr, event, cx| {
-                if event.signer_changed() && settings.read(cx).is_nip4e_enabled(cx) {
+                if event.signer_changed() && nip4e_enabled {
                     this.get_announcement(cx);
                 }
             }),
@@ -225,11 +226,6 @@ impl DeviceRegistry {
             let keys = get_keys(&client, &signer).await?;
             let content = keys.secret_key().to_bech32()?;
 
-            if cfg!(target_arch = "wasm32") {
-                return Err(anyhow!("Not supported"));
-            }
-
-            #[cfg(not(target_arch = "wasm32"))]
             smol::fs::write(path, &content).await?;
 
             Ok(())
@@ -262,19 +258,27 @@ impl DeviceRegistry {
         }));
 
         let announcement_existed = self.announcement_existed.clone();
+        let executor = cx.background_executor().clone();
 
         self.tasks.push(cx.spawn(async move |this, cx| {
+            if !cx
+                .background_spawn(async move {
                     // Wait for 5 seconds
-            cx.background_executor().timer(Duration::from_secs(5)).await;
+                    executor.timer(Duration::from_secs(5)).await;
 
                     // Then check if the msg relays have been found
-            if announcement_existed.load(Ordering::Acquire) {
-                return Ok(());
+                    if !announcement_existed.load(Ordering::Acquire) {
+                        return true;
                     }
 
+                    false
+                })
+                .await
+            {
                 this.update(cx, |_this, cx| {
                     cx.emit(DeviceEvent::NotSet);
                 })?;
+            }
 
             Ok(())
         }));
@@ -400,10 +404,11 @@ impl DeviceRegistry {
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
 
-        let app_keys_task = get_or_init_app_keys(cx);
+        let Ok(app_keys) = get_or_init_app_keys(cx) else {
+            return;
+        };
 
         let task: Task<Result<Option<Event>, Error>> = cx.background_spawn(async move {
-            let app_keys = app_keys_task.await?;
             let app_pubkey = app_keys.public_key();
             let public_key = signer.get_public_key_async().await?;
 
@@ -484,10 +489,11 @@ impl DeviceRegistry {
 
     /// Parse the approval event to get encryption key then set it
     fn extract_encryption(&mut self, event: Event, cx: &mut Context<Self>) {
-        let app_keys_task = get_or_init_app_keys(cx);
+        let Ok(app_keys) = get_or_init_app_keys(cx) else {
+            return;
+        };
 
         let task: Task<Result<Keys, Error>> = cx.background_spawn(async move {
-            let app_keys = app_keys_task.await?;
             let master = event
                 .tags
                 .iter()
@@ -567,7 +573,7 @@ impl DeviceRegistry {
             Ok(())
         });
 
-        self.tasks.push(cx.spawn_in(window, async move |_this, cx| {
+        cx.spawn_in(window, async move |_this, cx| {
             match task.await {
                 Ok(_) => {
                     cx.update(|window, cx| {
@@ -585,9 +591,8 @@ impl DeviceRegistry {
                     .ok();
                 }
             };
-
-            Ok(())
-        }));
+        })
+        .detach();
     }
 
     /// Handle encryption request
@@ -710,34 +715,33 @@ impl DeviceRegistry {
 
 struct DeviceNotification;
 
-/// Get or create new app keys (async, returns a task)
-fn get_or_init_app_keys(cx: &App) -> Task<Result<Keys, Error>> {
+/// Get or create new app keys
+fn get_or_init_app_keys(cx: &App) -> Result<Keys, Error> {
     let read = cx.read_credentials(CLIENT_NAME);
-
-    cx.spawn(async move |cx| {
-        if let Ok(Some((_, secret))) = read.await
-            && let Ok(keys) = SecretKey::from_slice(&secret).map(Keys::new)
-        {
-            return Ok(keys);
+    let stored_keys: Option<Keys> = cx.foreground_executor().block_on(async move {
+        if let Ok(Some((_, secret))) = read.await {
+            SecretKey::from_slice(&secret).map(Keys::new).ok()
+        } else {
+            None
         }
+    });
 
-        // No stored keys found or invalid — generate new ones
+    if let Some(keys) = stored_keys {
+        Ok(keys)
+    } else {
         let keys = Keys::generate();
         let user = keys.public_key().to_hex();
         let secret = keys.secret_key().to_secret_bytes();
-
-        cx.update(|cx| {
         let write = cx.write_credentials(CLIENT_NAME, &user, &secret);
-            cx.background_spawn(async move {
+
+        cx.foreground_executor().block_on(async move {
             if let Err(e) = write.await {
                 log::error!("Keyring not available or panic: {e}")
             }
-            })
-            .detach();
         });
 
         Ok(keys)
-    })
+    }
 }
 
 /// Encrypt and store device keys in the local database.

crates/person/Cargo.toml

@@ -10,8 +10,8 @@ state = { path = "../state" }
 
 gpui.workspace = true
 nostr-sdk.workspace = true
-instant.workspace = true
 anyhow.workspace = true
 smallvec.workspace = true
 flume.workspace = true
 log.workspace = true
+urlencoding = "2.1.3"

crates/person/src/lib.rs

@@ -1,10 +1,11 @@
+use std::cell::RefCell;
 use std::collections::{HashMap, HashSet};
-use std::sync::RwLock;
+use std::rc::Rc;
+use std::time::Duration;
 
 use anyhow::{Error, anyhow};
 use common::EventExt;
 use gpui::{App, AppContext, Context, Entity, Global, Task, Window};
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use smallvec::{SmallVec, smallvec};
 use state::{Announcement, BOOTSTRAP_RELAYS, NostrRegistry, TIMEOUT};
@@ -23,9 +24,9 @@ impl Global for GlobalPersonRegistry {}
 
 #[derive(Debug, Clone)]
 enum Dispatch {
-    Person(Person),
-    Announcement(Event),
-    Relays(Event),
+    Person(Box<Person>),
+    Announcement(Box<Event>),
+    Relays(Box<Event>),
 }
 
 /// Person Registry
@@ -35,7 +36,7 @@ pub struct PersonRegistry {
     persons: HashMap<PublicKey, Entity<Person>>,
 
     /// Set of public keys that have been seen
-    seen: RwLock<HashSet<PublicKey>>,
+    seens: Rc<RefCell<HashSet<PublicKey>>>,
 
     /// Sender for requesting metadata
     sender: flume::Sender<PublicKey>,
@@ -62,26 +63,40 @@ impl PersonRegistry {
 
         // Channel for communication between nostr and gpui
         let (tx, rx) = flume::bounded::<Dispatch>(100);
-        let (metadata_tx, metadata_rx) = flume::unbounded::<PublicKey>();
+        let (mta_tx, mta_rx) = flume::unbounded::<PublicKey>();
 
         let mut tasks = smallvec![];
 
-        let client2 = client.clone();
-        tasks.push(cx.background_spawn(async move {
-            Self::handle_notifications(&client2, &tx).await;
-        }));
+        tasks.push(
+            // Handle nostr notifications
+            cx.background_spawn({
+                let client = client.clone();
 
-        let client3 = client.clone();
-        tasks.push(cx.background_spawn(async move {
-            Self::handle_requests(&client3, &metadata_rx).await;
-        }));
+                async move {
+                    Self::handle_notifications(&client, &tx).await;
+                }
+            }),
+        );
 
-        tasks.push(cx.spawn(async move |this, cx| {
+        tasks.push(
+            // Handle metadata requests
+            cx.background_spawn({
+                let client = client.clone();
+
+                async move {
+                    Self::handle_requests(&client, &mta_rx).await;
+                }
+            }),
+        );
+
+        tasks.push(
+            // Update GPUI state
+            cx.spawn(async move |this, cx| {
                 while let Ok(event) = rx.recv_async().await {
                     this.update(cx, |this, cx| {
                         match event {
                             Dispatch::Person(person) => {
-                            this.insert(person, cx);
+                                this.insert(*person, cx);
                             }
                             Dispatch::Announcement(event) => {
                                 this.set_announcement(&event, cx);
@@ -93,7 +108,8 @@ impl PersonRegistry {
                     })
                     .ok();
                 }
-        }));
+            }),
+        );
 
         // Load all user profiles from the database
         cx.defer_in(window, |this, _window, cx| {
@@ -102,8 +118,8 @@ impl PersonRegistry {
 
         Self {
             persons: HashMap::new(),
-            seen: RwLock::new(HashSet::new()),
-            sender: metadata_tx,
+            seens: Rc::new(RefCell::new(HashSet::new())),
+            sender: mta_tx,
             tasks,
         }
     }
@@ -129,25 +145,24 @@ impl PersonRegistry {
                     Kind::Metadata => {
                         let metadata = Metadata::from_json(&event.content).unwrap_or_default();
                         let person = Person::new(event.pubkey, metadata);
-                        if tx.send_async(Dispatch::Person(person)).await.is_err() {
-                            log::warn!("PersonRegistry channel closed, dropping metadata event");
-                        }
+                        let val = Box::new(person);
+                        // Send
+                        tx.send_async(Dispatch::Person(val)).await.ok();
                     }
                     Kind::ContactList => {
                         let public_keys = event.extract_public_keys();
-                        if let Err(e) = get_metadata(client, public_keys).await {
-                            log::warn!("Failed to get metadata for contact list: {e}");
-                        }
+                        // Get metadata for all public keys
+                        get_metadata(client, public_keys).await.ok();
                     }
                     Kind::InboxRelays => {
-                        tx.send_async(Dispatch::Relays(event.into_owned()))
-                            .await
-                            .ok();
+                        let val = Box::new(event.into_owned());
+                        // Send
+                        tx.send_async(Dispatch::Relays(val)).await.ok();
                     }
                     Kind::Custom(10044) => {
-                        tx.send_async(Dispatch::Announcement(event.into_owned()))
-                            .await
-                            .ok();
+                        let val = Box::new(event.into_owned());
+                        // Send
+                        tx.send_async(Dispatch::Announcement(val)).await.ok();
                     }
                     _ => {}
                 }
@@ -167,17 +182,13 @@ impl PersonRegistry {
                 Ok(Some(public_key)) => {
                     batch.insert(public_key);
                     // Process the batch if it's full
-                    if batch.len() >= 20
-                        && let Err(e) = get_metadata(client, std::mem::take(&mut batch)).await
-                    {
-                        log::warn!("Failed to get metadata batch: {e}");
+                    if batch.len() >= 20 {
+                        get_metadata(client, std::mem::take(&mut batch)).await.ok();
                     }
                 }
                 _ => {
-                    if !batch.is_empty()
-                        && let Err(e) = get_metadata(client, std::mem::take(&mut batch)).await
-                    {
-                        log::warn!("Failed to get metadata batch: {e}");
+                    if !batch.is_empty() {
+                        get_metadata(client, std::mem::take(&mut batch)).await.ok();
                     }
                 }
             }
@@ -206,7 +217,7 @@ impl PersonRegistry {
         self.tasks.push(cx.spawn(async move |this, cx| {
             if let Ok(persons) = task.await {
                 this.update(cx, |this, cx| {
-                    this.bulk_insert(persons, cx);
+                    this.bulk_inserts(persons, cx);
                 })
                 .ok();
             }
@@ -245,7 +256,7 @@ impl PersonRegistry {
     }
 
     /// Insert batch of persons
-    fn bulk_insert(&mut self, persons: Vec<Person>, cx: &mut Context<Self>) {
+    fn bulk_inserts(&mut self, persons: Vec<Person>, cx: &mut Context<Self>) {
         for person in persons.into_iter() {
             let public_key = person.public_key();
             self.persons
@@ -279,14 +290,15 @@ impl PersonRegistry {
         }
 
         let public_key = *public_key;
+        let mut seen = self.seens.borrow_mut();
 
-        if self.seen.write().unwrap().insert(public_key) {
+        if seen.insert(public_key) {
             let sender = self.sender.clone();
 
             // Spawn background task to request metadata
             cx.background_spawn(async move {
                 if let Err(e) = sender.send_async(public_key).await {
-                    log::warn!("Failed to send public key for metadata request: {e}");
+                    log::warn!("Failed to send public key for metadata request: {}", e);
                 }
             })
             .detach();

crates/person/src/person.rs

@@ -5,6 +5,8 @@ use gpui::SharedString;
 use nostr_sdk::prelude::*;
 use state::Announcement;
 
+const IMAGE_RESIZER: &str = "https://wsrv.nl";
+
 /// Person
 #[derive(Debug, Clone)]
 pub struct Person {
@@ -109,7 +111,13 @@ impl Person {
             .picture
             .as_ref()
             .filter(|picture| !picture.is_empty())
-            .map(|picture| picture.into())
+            .map(|picture| {
+                let encoded_picture = urlencoding::encode(picture);
+                let url = format!(
+                    "{IMAGE_RESIZER}/?url={encoded_picture}&w=100&h=100&fit=cover&mask=circle&n=-1"
+                );
+                url.into()
+            })
             .unwrap_or_else(|| "brand/avatar.png".into())
     }
 

crates/settings/src/lib.rs

@@ -1,3 +1,4 @@
+use std::fmt::Display;
 use std::rc::Rc;
 
 use anyhow::{Error, anyhow};
@@ -41,10 +42,28 @@ setting_accessors! {
     pub hide_avatar: bool,
     pub screening: bool,
     pub nip4e: bool,
+    pub auth_mode: AuthMode,
     pub trusted_relays: Vec<String>,
     pub file_server: Url,
 }
 
+/// Authentication mode
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
+pub enum AuthMode {
+    #[default]
+    Auto,
+    Manual,
+}
+
+impl Display for AuthMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            AuthMode::Auto => write!(f, "Auto"),
+            AuthMode::Manual => write!(f, "Ask every time"),
+        }
+    }
+}
+
 /// Signer kind
 #[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub enum SignerKind {
@@ -122,6 +141,9 @@ pub struct Settings {
     /// Enable decoupling encryption key
     pub nip4e: bool,
 
+    /// Authentication mode
+    pub auth_mode: AuthMode,
+
     /// Trusted relays; Coop will automatically authenticate with these relays
     pub trusted_relays: Vec<String>,
 
@@ -137,6 +159,7 @@ impl Default for Settings {
             hide_avatar: false,
             screening: true,
             nip4e: false,
+            auth_mode: AuthMode::default(),
             trusted_relays: vec![],
             file_server: Url::parse("https://blossom.band/").unwrap(),
         }

crates/state/Cargo.toml

@@ -14,7 +14,6 @@ nostr-blossom.workspace = true
 nostr-connect.workspace = true
 
 gpui.workspace = true
-instant.workspace = true
 flume.workspace = true
 futures.workspace = true
 log.workspace = true
@@ -28,7 +27,6 @@ mime_guess = "2.0.4"
 nostr-memory.workspace = true
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-browser-signer-proxy = { path = "../browser-signer-proxy" }
 nostr-lmdb.workspace = true
 smol.workspace = true
 gpui_tokio.workspace = true

crates/state/src/constants.rs

@@ -39,15 +39,14 @@ pub const NOSTR_CONNECT_RELAY: &str = "wss://relay.nip46.com";
 pub const WOT_RELAYS: [&str; 1] = ["wss://relay.vertexlab.io"];
 
 /// Default search relays
-pub const INDEXER_RELAYS: [&str; 2] = ["wss://indexer.coracle.social", "wss://user.kindpag.es"];
+pub const INDEXER_RELAYS: [&str; 1] = ["wss://indexer.coracle.social"];
 
 /// Default search relays
 pub const SEARCH_RELAYS: [&str; 2] = ["wss://antiprimal.net", "wss://search.nos.today"];
 
 /// Default bootstrap relays
-pub const BOOTSTRAP_RELAYS: [&str; 4] = [
+pub const BOOTSTRAP_RELAYS: [&str; 3] = [
     "wss://relay.ditto.pub",
     "wss://relay.primal.net",
-    "wss://relay.nostr.net",
-    "wss://profiles.nostr1.com",
+    "wss://user.kindpag.es",
 ];

crates/state/src/lib.rs

@@ -1,12 +1,9 @@
 use std::collections::HashMap;
+use std::time::Duration;
 
 use anyhow::{Error, anyhow};
-#[cfg(not(target_arch = "wasm32"))]
-use browser_signer_proxy::prelude::*;
 use common::config_dir;
 use gpui::{App, AppContext, Context, Entity, EventEmitter, Global, Task, Window};
-use gpui_tokio::Tokio;
-use instant::Duration;
 use nostr_connect::prelude::*;
 use nostr_gossip_memory::prelude::*;
 #[cfg(not(target_arch = "wasm32"))]
@@ -27,7 +24,7 @@ pub use nip4e::*;
 pub use nip05::*;
 pub use signer::{CoopAuthUrlHandler, UniversalSigner};
 
-pub fn init(window: &mut Window, cx: &mut App, cli_key: Option<SecretKey>) {
+pub fn init(window: &mut Window, cx: &mut App) {
     // rustls uses the `aws_lc_rs` provider by default
     // This only errors if the default provider has already
     // been installed. We can ignore this `Result`.
@@ -40,7 +37,7 @@ pub fn init(window: &mut Window, cx: &mut App, cli_key: Option<SecretKey>) {
     #[cfg(not(target_arch = "wasm32"))]
     gpui_tokio::init(cx);
 
-    NostrRegistry::set_global(cx.new(|cx| NostrRegistry::new(window, cx, cli_key)), cx);
+    NostrRegistry::set_global(cx.new(|cx| NostrRegistry::new(window, cx)), cx);
 }
 
 struct GlobalNostrRegistry(Entity<NostrRegistry>);
@@ -61,16 +58,16 @@ pub enum StateEvent {
 }
 
 impl StateEvent {
-    pub fn signer_changed(&self) -> bool {
-        matches!(self, StateEvent::SignerChanged)
-    }
-
     pub fn error<T>(error: T) -> Self
     where
         T: Into<String>,
     {
         Self::Error(error.into())
     }
+
+    pub fn signer_changed(&self) -> bool {
+        matches!(self, StateEvent::SignerChanged)
+    }
 }
 
 /// Nostr Registry
@@ -103,7 +100,7 @@ impl NostrRegistry {
     }
 
     /// Create a new nostr instance
-    fn new(window: &mut Window, cx: &mut Context<Self>, cli_key: Option<SecretKey>) -> Self {
+    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let signer = UniversalSigner::new(Keys::generate());
         let authenticator = SignerAuthenticator::new(signer.clone());
 
@@ -133,16 +130,7 @@ impl NostrRegistry {
         // Connect to bootstrap relays after the window is ready
         cx.defer_in(window, |this, _window, cx| {
             this.connect_bootstrap_relays(cx);
-
-            if cfg!(target_arch = "wasm32") {
-                cx.emit(StateEvent::NoSigner);
-            } else if let Some(secret) = cli_key {
-                // Use CLI-provided key -- same path as get_user_credential
-                let keys = Keys::new(secret);
-                this.set_signer(keys, cx);
-            } else {
             this.get_user_credential(cx);
-            }
         });
 
         Self {
@@ -176,7 +164,7 @@ impl NostrRegistry {
         <T as AsyncSignEvent>::Error: std::error::Error + Send + Sync + 'static,
         <T as AsyncNip44>::Error: std::error::Error + Send + Sync + 'static,
     {
-        let task = cx.spawn(async move |this, cx| {
+        cx.spawn(async move |this, cx| {
             match new_signer.get_public_key_async().await {
                 Ok(public_key) => {
                     this.update(cx, |this, cx| {
@@ -193,9 +181,9 @@ impl NostrRegistry {
                 }
             };
 
-            Ok(())
-        });
-        self.tasks.push(task);
+            Ok::<(), anyhow::Error>(())
+        })
+        .detach();
     }
 
     /// Connect to the bootstrapping relays
@@ -265,11 +253,6 @@ impl NostrRegistry {
                             this.set_signer(signer, cx);
                             cx.notify();
                         })?;
-                    } else if content == "proxy" {
-                        #[cfg(not(target_arch = "wasm32"))]
-                        this.update(cx, |this, cx| {
-                            this.connect_proxy(cx);
-                        })?;
                     }
                 }
                 _ => {
@@ -285,10 +268,6 @@ impl NostrRegistry {
 
     /// Get the master key that used for Nostr Connect
     pub fn get_master_key(&self, cx: &App) -> Task<Keys> {
-        if cfg!(target_arch = "wasm32") {
-            return cx.background_spawn(async move { Keys::generate() });
-        }
-
         let task = cx.read_credentials(MASTER_KEYRING);
 
         cx.spawn(async move |cx| {
@@ -315,81 +294,6 @@ impl NostrRegistry {
         })
     }
 
-    /// Start the browser proxy
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn connect_proxy(&mut self, cx: &mut Context<Self>) {
-        let proxy = BrowserSignerProxy::new(BrowserSignerProxyOptions::default());
-        let (tx, rx) = flume::bounded::<String>(1);
-
-        self.tasks.push(Tokio::spawn_result(cx, {
-            let proxy = proxy.clone();
-            async move {
-                // Start the proxy and get the web url
-                proxy.start().await?;
-                // Notify GPUI
-                let url = proxy.url();
-                tx.send(url).ok();
-                Ok(())
-            }
-        }));
-
-        self.tasks.push(Tokio::spawn_result(cx, {
-            let proxy = proxy.clone();
-            async move {
-                loop {
-                    if proxy.is_session_active() {
-                        break;
-                    }
-                    smol::Timer::after(Duration::from_secs(1)).await;
-                }
-                Ok(())
-            }
-        }));
-
-        self.tasks.push(cx.spawn({
-            let proxy = proxy.clone();
-            async move |this, cx| {
-                while let Ok(url) = rx.recv_async().await {
-                    this.update(cx, |this, cx| {
-                        let save = cx.write_credentials(USER_KEYRING, "proxy", b"proxy");
-                        cx.background_spawn(async move { save.await.ok() }).detach();
-                        cx.open_url(&url);
-                        this.set_signer(proxy.clone(), cx);
-                    })?;
-                }
-                Ok(())
-            }
-        }));
-
-        // Monitor the session, if the browser disconnects, notify user to reconnect
-        self.tasks.push(cx.spawn({
-            let proxy = proxy.clone();
-            let executor = cx.background_executor().clone();
-            async move |this, cx| {
-                // Wait for the signer to be confirmed (timeout is 30s)
-                executor.timer(Duration::from_secs(30)).await;
-
-                loop {
-                    executor.timer(Duration::from_secs(5)).await;
-                    if !proxy.is_session_active() {
-                        _ = this.update(cx, |this, cx| {
-                            // Only notify if this proxy is still the active signer
-                            if this.current_user.is_some() {
-                                this.signer.swap_inner(Keys::generate());
-                                this.current_user = None;
-                                cx.emit(StateEvent::NoSigner);
-                                cx.notify();
-                            }
-                        });
-                        break;
-                    }
-                }
-
-                Ok(())
-            }
-        }));
-    }
-
     /// Get the public key of a NIP-05 address
     pub fn query_address(&self, addr: Nip05Address, cx: &App) -> Task<Result<PublicKey, Error>> {
         let client = self.client();

crates/state/src/nip05.rs

@@ -4,7 +4,6 @@ use anyhow::Error;
 use futures::io::AsyncReadExt;
 use gpui::http_client::{AsyncBody, HttpClient};
 use nostr_sdk::prelude::*;
-use serde_json::Value;
 
 #[allow(async_fn_in_trait)]
 pub trait NostrAddress {

crates/theme/src/colors.rs

@@ -112,7 +112,7 @@ impl ThemeColors {
             elevated_surface_background: neutral().light().step_3(),
             panel_background: neutral().light().step_1(),
             overlay: neutral().light_alpha().step_3(),
-            title_bar: neutral().light().step_2(),
+            title_bar: neutral().light().step_3(),
             title_bar_inactive: neutral().light().step_1(),
             window_border: hsl(240.0, 5.9, 78.0),
 
@@ -198,7 +198,7 @@ impl ThemeColors {
             elevated_surface_background: neutral().dark().step_3(),
             panel_background: neutral().dark().step_1(),
             overlay: neutral().dark_alpha().step_3(),
-            title_bar: neutral().dark().step_2(),
+            title_bar: neutral().dark().step_3(),
             title_bar_inactive: neutral().dark().step_1(),
             window_border: hsl(240.0, 3.7, 28.0),
 

crates/theme/src/lib.rs

@@ -34,7 +34,7 @@ pub const CLIENT_SIDE_DECORATION_BORDER: Pixels = px(1.0);
 pub const TITLEBAR_HEIGHT: Pixels = px(36.0);
 
 /// Defines workspace tabbar height
-pub const TABBAR_HEIGHT: Pixels = px(44.0);
+pub const TABBAR_HEIGHT: Pixels = px(28.0);
 
 /// Defines default sidebar width
 pub const SIDEBAR_WIDTH: Pixels = px(240.);

crates/ui/Cargo.toml

@@ -9,7 +9,6 @@ common = { path = "../common" }
 theme = { path = "../theme" }
 
 gpui.workspace = true
-instant.workspace = true
 serde.workspace = true
 smallvec.workspace = true
 anyhow.workspace = true

crates/ui/src/avatar.rs

@@ -1,8 +1,8 @@
 use gpui::prelude::FluentBuilder;
 use gpui::{
     AbsoluteLength, App, Div, Hsla, ImageSource, Img, InteractiveElement, Interactivity,
-    IntoElement, ObjectFit, ParentElement, RenderOnce, StyleRefinement, Styled, StyledImage,
-    Window, div, img, px,
+    IntoElement, ParentElement, RenderOnce, StyleRefinement, Styled, StyledImage, Window, div, img,
+    px,
 };
 use theme::ActiveTheme;
 
@@ -26,7 +26,9 @@ pub(super) fn avatar_size(size: Size) -> AbsoluteLength {
 /// ```
 /// use ui::{Avatar};
 ///
-/// Avatar::new("path/to/image.png").grayscale(true).border_color(gpui::red());
+/// Avatar::new("path/to/image.png")
+///     .grayscale(true)
+///     .border_color(gpui::red());
 /// ```
 #[derive(IntoElement)]
 pub struct Avatar {
@@ -128,7 +130,7 @@ impl RenderOnce for Avatar {
                 self.image
                     .size(image_size)
                     .rounded_full()
-                    .object_fit(ObjectFit::Cover)
+                    .object_fit(gpui::ObjectFit::Fill)
                     .bg(cx.theme().ghost_element_background)
                     .with_fallback(move || {
                         img("brand/avatar.png")

crates/ui/src/checkbox.rs

@@ -1,5 +1,5 @@
 use std::rc::Rc;
-use instant::Duration;
+use std::time::Duration;
 
 use gpui::prelude::FluentBuilder as _;
 use gpui::{

crates/ui/src/dock/dock.rs

@@ -214,8 +214,6 @@ impl Dock {
     pub fn set_open(&mut self, open: bool, window: &mut Window, cx: &mut Context<Self>) {
         self.open = open;
         let item = self.panel.clone();
-        // Use defer_in (not window.defer) so the callback is cancelled
-        // if this Dock entity is dropped before the deferred frame runs.
         cx.defer_in(window, move |_, window, cx| {
             item.set_collapsed(!open, window, cx);
         });

crates/ui/src/dock/mod.rs

@@ -2,10 +2,11 @@ use std::sync::Arc;
 
 use gpui::prelude::FluentBuilder;
 use gpui::{
-    AnyElement, AnyView, App, AppContext, Axis, Bounds, Context, Edges, Entity, EntityId,
-    EventEmitter, Focusable, InteractiveElement as _, IntoElement, ParentElement as _, Pixels,
-    Render, SharedString, Styled, Subscription, WeakEntity, Window, actions, div, px,
+    AnyElement, AnyView, App, AppContext, Axis, Bounds, Context, Decorations, Edges, Entity,
+    EntityId, EventEmitter, Focusable, InteractiveElement as _, IntoElement, ParentElement as _,
+    Pixels, Render, SharedString, Styled, Subscription, WeakEntity, Window, actions, div, px,
 };
+use theme::CLIENT_SIDE_DECORATION_ROUNDING;
 
 use crate::ElementExt;
 
@@ -109,8 +110,15 @@ impl DockItem {
         window: &mut Window,
         cx: &mut App,
     ) -> Self {
+        let mut items = items;
+
         let stack_panel = cx.new(|cx| {
             let mut stack_panel = StackPanel::new(axis, window, cx);
+            for (i, item) in items.iter_mut().enumerate() {
+                let view = item.view();
+                let size = sizes.get(i).copied().flatten();
+                stack_panel.add_panel(view.clone(), size, dock_area.clone(), window, cx)
+            }
 
             for (i, item) in items.iter().enumerate() {
                 let view = item.view();
@@ -737,22 +745,34 @@ impl EventEmitter<DockEvent> for DockArea {}
 impl Render for DockArea {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let view = cx.entity().clone();
+        let decorations = window.window_decorations();
 
         div()
             .id("dock-area")
             .relative()
             .size_full()
+            .overflow_hidden()
             .on_prepaint(move |bounds, _, cx| view.update(cx, |r, _| r.bounds = bounds))
             .map(|this| {
                 if let Some(zoom_view) = self.zoom_view.clone() {
-                    this.child(zoom_view)
+                    this.map(|this| match decorations {
+                        Decorations::Server => this,
+                        Decorations::Client { tiling } => this
+                            .when(!(tiling.top || tiling.right), |div| {
+                                div.rounded_br(CLIENT_SIDE_DECORATION_ROUNDING)
+                            })
+                            .when(!(tiling.top || tiling.left), |div| {
+                                div.rounded_bl(CLIENT_SIDE_DECORATION_ROUNDING)
+                            }),
+                    })
+                    .child(zoom_view)
                 } else {
                     // render dock
                     this.child(
                         div()
                             .flex()
                             .flex_row()
-                            .size_full()
+                            .h_full()
                             // Left dock
                             .when_some(self.left_dock.clone(), |this, dock| {
                                 this.child(div().flex().flex_none().child(dock))
@@ -763,8 +783,14 @@ impl Render for DockArea {
                                     .flex()
                                     .flex_1()
                                     .flex_col()
+                                    .overflow_hidden()
                                     // Top center
-                                    .child(div().flex_1().child(self.render_items(window, cx)))
+                                    .child(
+                                        div()
+                                            .flex_1()
+                                            .overflow_hidden()
+                                            .child(self.render_items(window, cx)),
+                                    )
                                     // Bottom Dock
                                     .when_some(self.bottom_dock.clone(), |this, dock| {
                                         this.child(dock)

crates/ui/src/dock/stack_panel.rs

@@ -1,12 +1,13 @@
 use std::sync::Arc;
 
+use gpui::prelude::FluentBuilder;
 use gpui::{
     App, AppContext, Axis, Context, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable,
     IntoElement, ParentElement, Pixels, Render, SharedString, Styled, Subscription, WeakEntity,
     Window,
 };
 use smallvec::SmallVec;
-use theme::{AxisExt as _, Placement};
+use theme::{ActiveTheme, AxisExt as _, CLIENT_SIDE_DECORATION_ROUNDING, Placement};
 
 use super::{DockArea, PanelEvent};
 use crate::dock::panel::{Panel, PanelView};
@@ -368,12 +369,18 @@ impl Focusable for StackPanel {
 }
 
 impl EventEmitter<PanelEvent> for StackPanel {}
-
 impl EventEmitter<DismissEvent> for StackPanel {}
 
 impl Render for StackPanel {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        h_flex().size_full().overflow_hidden().child(
+        h_flex()
+            .size_full()
+            .overflow_hidden()
+            .bg(cx.theme().panel_background)
+            .when(cx.theme().platform.is_linux(), |this| {
+                this.rounded_br(CLIENT_SIDE_DECORATION_ROUNDING)
+            })
+            .child(
                 ResizablePanelGroup::new("stack-panel-group")
                     .with_state(&self.state)
                     .axis(self.axis)

crates/ui/src/dock/tab_panel.rs

@@ -7,7 +7,7 @@ use gpui::{
     ParentElement, Pixels, Render, ScrollHandle, SharedString, StatefulInteractiveElement, Styled,
     WeakEntity, Window, div, px, rems,
 };
-use theme::{ActiveTheme, AxisExt, Placement, TABBAR_HEIGHT};
+use theme::{ActiveTheme, AxisExt, CLIENT_SIDE_DECORATION_ROUNDING, Placement, TABBAR_HEIGHT};
 
 use crate::button::{Button, ButtonVariants as _};
 use crate::dock::dock::DockPlacement;
@@ -51,7 +51,7 @@ impl Render for DragPanel {
             .overflow_hidden()
             .whitespace_nowrap()
             .rounded(cx.theme().radius)
-            .text_sm()
+            .text_xs()
             .text_color(cx.theme().text)
             .text_ellipsis()
             .when(cx.theme().shadow, |this| this.shadow_xs())
@@ -312,7 +312,6 @@ impl TabPanel {
 
         cx.emit(PanelEvent::ZoomOut);
         cx.emit(PanelEvent::LayoutChanged);
-        cx.notify();
     }
 
     fn detach_panel(
@@ -322,22 +321,10 @@ impl TabPanel {
         cx: &mut Context<Self>,
     ) {
         let panel_view = panel.view();
-        let removed_ix = self.panels.iter().position(|p| p.view() == panel_view);
         self.panels.retain(|p| p.view() != panel_view);
 
         if self.active_ix >= self.panels.len() {
             self.set_active_ix(self.panels.len().saturating_sub(1), window, cx)
-        } else if let Some(removed_ix) = removed_ix {
-            if removed_ix < self.active_ix {
-                self.active_ix = self.active_ix.saturating_sub(1);
-            } else if removed_ix == self.active_ix {
-                // The active panel was removed and another panel shifted into
-                // its position. Activate the new panel at the same index.
-                if let Some(new_active) = self.panels.get(self.active_ix) {
-                    new_active.set_active(true, cx);
-                }
-                self.focus_active_panel(window, cx);
-            }
         }
     }
 
@@ -580,7 +567,6 @@ impl TabPanel {
         let left_dock_button = self.render_dock_toggle_button(DockPlacement::Left, window, cx);
         let bottom_dock_button = self.render_dock_toggle_button(DockPlacement::Bottom, window, cx);
         let right_dock_button = self.render_dock_toggle_button(DockPlacement::Right, window, cx);
-
         let has_extend_dock_button = left_dock_button.is_some() || bottom_dock_button.is_some();
         let tabs_count = self.panels.len();
         let is_bottom_dock = bottom_dock_button.is_some();
@@ -600,7 +586,6 @@ impl TabPanel {
                 .py_2()
                 .pl_3()
                 .pr_2()
-                .rounded_t(cx.theme().radius_lg)
                 .bg(cx.theme().panel_background)
                 .when(left_dock_button.is_some(), |this| this.pl_2())
                 .when(right_dock_button.is_some(), |this| this.pr_2())
@@ -626,7 +611,7 @@ impl TabPanel {
                             div()
                                 .w_full()
                                 .text_ellipsis()
-                                .text_sm()
+                                .text_xs()
                                 .child(panel.title(cx)),
                         )
                         .when(state.draggable, |this| {
@@ -656,14 +641,17 @@ impl TabPanel {
         TabBar::new("tab-bar")
             .track_scroll(&self.tab_bar_scroll_handle)
             .h(TABBAR_HEIGHT)
-            .bg(cx.theme().panel_background)
-            .rounded_t(cx.theme().radius_lg)
             .when(has_extend_dock_button, |this| {
                 this.prefix(
                     h_flex()
                         .items_center()
                         .top_0()
                         .right(-px(1.))
+                        .border_r_1()
+                        .border_b_1()
+                        .h_full()
+                        .border_color(cx.theme().border)
+                        .bg(cx.theme().tab_background)
                         .pl_0p5()
                         .pr_1()
                         .children(left_dock_button)
@@ -700,7 +688,6 @@ impl TabPanel {
                                 .on_click(cx.listener({
                                     let panel = panel.clone();
                                     move |view, _ev, window, cx| {
-                                        cx.stop_propagation();
                                         view.remove_panel(&panel, window, cx);
                                     }
                                 })),
@@ -793,8 +780,12 @@ impl TabPanel {
                         .top_0()
                         .right_0()
                         .h_full()
+                        .border_l_1()
+                        .border_b_1()
                         .px_0p5()
                         .gap_1()
+                        .border_color(cx.theme().border)
+                        .bg(cx.theme().tab_background)
                         .child(self.render_toolbar(state, window, cx))
                         .when_some(right_dock_button, |this, btn| this.child(btn)),
                 )
@@ -824,8 +815,10 @@ impl TabPanel {
             .child(
                 div()
                     .size_full()
-                    .rounded_b(cx.theme().radius_lg)
                     .bg(cx.theme().panel_background)
+                    .when(cx.theme().platform.is_linux(), |this| {
+                        this.rounded_b(CLIENT_SIDE_DECORATION_ROUNDING)
+                    })
                     .overflow_hidden()
                     .child(
                         active_panel
@@ -1147,24 +1140,17 @@ impl Render for TabPanel {
             state.closable = false;
         }
 
-        div()
+        v_flex()
             .when(!self.collapsed, |this| {
                 this.on_action(cx.listener(Self::on_action_toggle_zoom))
                     .on_action(cx.listener(Self::on_action_close_panel))
             })
             .id("tab-panel")
+            .tab_group()
             .track_focus(&focus_handle)
             .size_full()
-            .p_1()
             .overflow_hidden()
-            .child(
-                v_flex()
-                    .rounded(cx.theme().radius_lg)
-                    .when(cx.theme().shadow, |this| this.shadow_xs())
-                    .size_full()
-                    .tab_group()
             .child(self.render_title_bar(&state, window, cx))
-                    .child(self.render_active_panel(&state, window, cx)),
-            )
+            .child(self.render_active_panel(&state, window, cx))
     }
 }

crates/ui/src/history.rs

@@ -1,5 +1,5 @@
 use std::fmt::Debug;
-use instant::{Duration, Instant};
+use std::time::{Duration, Instant};
 
 /// A HistoryItem represents a single change in the history.
 /// It must implement Clone and PartialEq to be used in the History.

crates/ui/src/indicator.rs

@@ -1,4 +1,4 @@
-use instant::Duration;
+use std::time::Duration;
 
 use gpui::prelude::FluentBuilder as _;
 use gpui::{

crates/ui/src/input/blink_cursor.rs

@@ -1,4 +1,4 @@
-use instant::Duration;
+use std::time::Duration;
 
 use gpui::{Context, Pixels, Task, px};
 

crates/ui/src/input/input.rs

@@ -35,6 +35,8 @@ pub struct Input {
     cleanable: bool,
     mask_toggle: bool,
     disabled: bool,
+    bordered: bool,
+    focus_bordered: bool,
     tab_index: isize,
     selected: bool,
 }
@@ -71,6 +73,8 @@ impl Input {
             cleanable: false,
             mask_toggle: false,
             disabled: false,
+            bordered: true,
+            focus_bordered: true,
             tab_index: 0,
             selected: false,
         }
@@ -104,6 +108,18 @@ impl Input {
         self
     }
 
+    /// Set the bordered for the input, default: true
+    pub fn bordered(mut self, bordered: bool) -> Self {
+        self.bordered = bordered;
+        self
+    }
+
+    /// Set focus border for the input, default is true.
+    pub fn focus_bordered(mut self, bordered: bool) -> Self {
+        self.focus_bordered = bordered;
+        self
+    }
+
     /// Set whether to show the clear button when the input field is not empty, default is false.
     pub fn cleanable(mut self, cleanable: bool) -> Self {
         self.cleanable = cleanable;
@@ -316,6 +332,11 @@ impl RenderOnce for Input {
                 this.bg(bg)
                     .when(self.disabled, |this| this.opacity(0.5))
                     .rounded(cx.theme().radius)
+                    .when(self.bordered, |this| {
+                        this.border_color(cx.theme().border)
+                            .border_1()
+                            .when(cx.theme().shadow, |this| this.shadow_xs())
+                    })
             })
             .items_center()
             .gap(gap_x)

crates/ui/src/input/state.rs

@@ -383,7 +383,7 @@ impl InputState {
     pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let focus_handle = cx.focus_handle().tab_stop(true);
         let blink_cursor = cx.new(|_| BlinkCursor::new());
-        let history = History::new().group_interval(instant::Duration::from_secs(1));
+        let history = History::new().group_interval(std::time::Duration::from_secs(1));
 
         let _subscriptions = vec![
             // Observe the blink cursor to repaint the view when it changes.

crates/ui/src/list/list.rs

@@ -1,4 +1,5 @@
 use std::ops::Range;
+use std::time::Duration;
 
 use gpui::prelude::FluentBuilder;
 use gpui::{
@@ -8,7 +9,6 @@ use gpui::{
     SharedString, StatefulInteractiveElement, StyleRefinement, Styled, Subscription, Task,
     UniformListScrollHandle, Window, div, px, size, uniform_list,
 };
-use instant::Duration;
 use theme::ActiveTheme;
 
 use crate::actions::{Cancel, Confirm, SelectDown, SelectUp};

crates/ui/src/modal.rs

@@ -1,4 +1,5 @@
 use std::rc::Rc;
+use std::time::Duration;
 
 use gpui::prelude::FluentBuilder;
 use gpui::{
@@ -6,7 +7,6 @@ use gpui::{
     InteractiveElement, IntoElement, KeyBinding, MouseButton, ParentElement, Pixels, Point,
     RenderOnce, SharedString, StyleRefinement, Styled, Window, anchored, div, hsla, point, px,
 };
-use instant::Duration;
 use theme::ActiveTheme;
 
 use crate::actions::{Cancel, Confirm};
@@ -359,8 +359,8 @@ impl RenderOnce for Modal {
         let y = self.margin_top.unwrap_or(view_size.height / 10.) + offset_top;
         let x = bounds.center().x - self.width / 2.;
 
-        let mut padding_right = px(16.);
-        let mut padding_left = px(16.);
+        let mut padding_right = px(8.);
+        let mut padding_left = px(8.);
 
         if let Some(pl) = self.style.padding.left {
             padding_left = pl.to_pixels(self.width.into(), window.rem_size());
@@ -452,8 +452,8 @@ impl RenderOnce for Modal {
                             .when_some(self.max_width, |this, w| this.max_w(w))
                             .child(
                                 div()
-                                    .px_4()
-                                    .h_8()
+                                    .px_2()
+                                    .h_4()
                                     .w_full()
                                     .flex()
                                     .items_center()

crates/ui/src/notification.rs

@@ -1,7 +1,7 @@
 use std::any::TypeId;
 use std::collections::{HashMap, VecDeque};
 use std::rc::Rc;
-use instant::Duration;
+use std::time::Duration;
 
 use gpui::prelude::FluentBuilder;
 use gpui::{

crates/ui/src/resizable/resize_handle.rs

@@ -117,7 +117,7 @@ impl<T: 'static, E: 'static + Render> Element for ResizeHandle<T, E> {
                 cx.theme().border
             };
 
-            let mut ele = div()
+            let mut el = div()
                 .id(self.id.clone())
                 .occlude()
                 .absolute()
@@ -160,15 +160,16 @@ impl<T: 'static, E: 'static + Render> Element for ResizeHandle<T, E> {
                 })
                 .child(
                     div()
+                        .bg(bg_color)
                         .group_hover("handle", |this| this.bg(bg_color))
                         .when(axis.is_horizontal(), |this| this.h_full().w(HANDLE_SIZE))
                         .when(axis.is_vertical(), |this| this.w_full().h(HANDLE_SIZE)),
                 )
                 .into_any_element();
 
-            let layout_id = ele.request_layout(window, cx);
+            let layout_id = el.request_layout(window, cx);
 
-            ((layout_id, ele), state)
+            ((layout_id, el), state)
         })
     }
 

crates/ui/src/scroll/scrollbar.rs

@@ -2,6 +2,7 @@ use std::cell::Cell;
 use std::ops::Deref;
 use std::panic::Location;
 use std::rc::Rc;
+use std::time::{Duration, Instant};
 
 use gpui::{
     Anchor, App, Axis, BorderStyle, Bounds, ContentMask, CursorStyle, Edges, Element, ElementId,
@@ -10,7 +11,6 @@ use gpui::{
     Position, ScrollHandle, ScrollWheelEvent, Size, Style, UniformListScrollHandle, Window, fill,
     point, px, relative, size,
 };
-use instant::{Duration, Instant};
 use theme::{ActiveTheme, AxisExt, ScrollbarMode};
 
 /// The width of the scrollbar (THUMB_ACTIVE_INSET * 2 + THUMB_ACTIVE_WIDTH)
@@ -157,7 +157,7 @@ impl ScrollbarStateInner {
         let mut state = *self;
         state.hovered_axis = axis;
         if axis.is_some() {
-            state.last_scroll_time = Some(instant::Instant::now());
+            state.last_scroll_time = Some(std::time::Instant::now());
         }
         state
     }
@@ -166,7 +166,7 @@ impl ScrollbarStateInner {
         let mut state = *self;
         state.hovered_on_thumb = axis;
         if self.is_scrollbar_visible() && axis.is_some() {
-            state.last_scroll_time = Some(instant::Instant::now());
+            state.last_scroll_time = Some(std::time::Instant::now());
         }
         state
     }

crates/ui/src/skeleton.rs

@@ -1,4 +1,4 @@
-use instant::Duration;
+use std::time::Duration;
 
 use gpui::{
     bounce, div, ease_in_out, Animation, AnimationExt, IntoElement, RenderOnce, StyleRefinement,

crates/ui/src/styled.rs

@@ -14,7 +14,7 @@ pub fn v_flex() -> Div {
 
 /// Returns a `Div` as divider.
 pub fn divider(cx: &App) -> Div {
-    div().my_1().w_full().h_px().bg(cx.theme().border_variant)
+    div().my_2().w_full().h_px().bg(cx.theme().border_variant)
 }
 
 macro_rules! font_weight {
@@ -87,7 +87,7 @@ pub trait StyledExt: Styled + Sized {
             .border_1()
             .border_color(cx.theme().border)
             .shadow_md()
-            .rounded(cx.theme().radius_lg)
+            .rounded(cx.theme().radius)
     }
 }
 

crates/ui/src/switch.rs

@@ -1,6 +1,6 @@
 use std::cell::RefCell;
 use std::rc::Rc;
-use instant::Duration;
+use std::time::Duration;
 
 use gpui::prelude::FluentBuilder as _;
 use gpui::{

crates/ui/src/tab/mod.rs

@@ -2,15 +2,396 @@ use std::rc::Rc;
 
 use gpui::prelude::FluentBuilder as _;
 use gpui::{
-    AnyElement, App, ClickEvent, Div, InteractiveElement, IntoElement, MouseButton, ParentElement,
-    RenderOnce, SharedString, StatefulInteractiveElement, Styled, Window, div, px, relative,
+    AnyElement, App, ClickEvent, Div, Edges, Hsla, InteractiveElement, IntoElement, MouseButton,
+    ParentElement, Pixels, RenderOnce, SharedString, StatefulInteractiveElement, Styled, Window,
+    div, px, relative,
 };
-use theme::{ActiveTheme, TABBAR_HEIGHT};
+use theme::ActiveTheme;
 
-use crate::{Icon, IconName, Selectable, h_flex};
+use crate::{Icon, IconName, Selectable, Sizable, Size, StyledExt, h_flex};
 
 pub mod tab_bar;
 
+/// Tab variants.
+#[derive(Debug, Clone, Default, Copy, PartialEq, Eq, Hash)]
+pub enum TabVariant {
+    #[default]
+    Tab,
+    Outline,
+    Pill,
+    Segmented,
+    Underline,
+}
+
+impl TabVariant {
+    fn height(&self, size: Size) -> Pixels {
+        match size {
+            Size::XSmall => match self {
+                TabVariant::Underline => px(26.),
+                _ => px(20.),
+            },
+            Size::Small => match self {
+                TabVariant::Underline => px(30.),
+                _ => px(24.),
+            },
+            Size::Large => match self {
+                TabVariant::Underline => px(44.),
+                _ => px(36.),
+            },
+            _ => match self {
+                TabVariant::Underline => px(36.),
+                _ => px(32.),
+            },
+        }
+    }
+
+    fn inner_height(&self, size: Size) -> Pixels {
+        match size {
+            Size::XSmall => match self {
+                TabVariant::Tab | TabVariant::Outline | TabVariant::Pill => px(18.),
+                TabVariant::Segmented => px(16.),
+                TabVariant::Underline => px(20.),
+            },
+            Size::Small => match self {
+                TabVariant::Tab | TabVariant::Outline | TabVariant::Pill => px(22.),
+                TabVariant::Segmented => px(18.),
+                TabVariant::Underline => px(22.),
+            },
+            Size::Large => match self {
+                TabVariant::Tab | TabVariant::Outline | TabVariant::Pill => px(36.),
+                TabVariant::Segmented => px(28.),
+                TabVariant::Underline => px(32.),
+            },
+            _ => match self {
+                TabVariant::Tab => px(30.),
+                TabVariant::Outline | TabVariant::Pill => px(26.),
+                TabVariant::Segmented => px(24.),
+                TabVariant::Underline => px(26.),
+            },
+        }
+    }
+
+    /// Default px(12) to match panel px_3, See [`crate::dock::TabPanel`]
+    fn inner_paddings(&self, size: Size) -> Edges<Pixels> {
+        let mut padding_x = match size {
+            Size::XSmall => px(8.),
+            Size::Small => px(10.),
+            Size::Large => px(16.),
+            _ => px(12.),
+        };
+
+        if matches!(self, TabVariant::Underline) {
+            padding_x = px(0.);
+        }
+
+        Edges {
+            left: padding_x,
+            right: padding_x,
+            ..Default::default()
+        }
+    }
+
+    fn inner_margins(&self, size: Size) -> Edges<Pixels> {
+        match size {
+            Size::XSmall => match self {
+                TabVariant::Underline => Edges {
+                    top: px(1.),
+                    bottom: px(2.),
+                    ..Default::default()
+                },
+                _ => Edges::all(px(0.)),
+            },
+            Size::Small => match self {
+                TabVariant::Underline => Edges {
+                    top: px(2.),
+                    bottom: px(3.),
+                    ..Default::default()
+                },
+                _ => Edges::all(px(0.)),
+            },
+            Size::Large => match self {
+                TabVariant::Underline => Edges {
+                    top: px(5.),
+                    bottom: px(6.),
+                    ..Default::default()
+                },
+                _ => Edges::all(px(0.)),
+            },
+            _ => match self {
+                TabVariant::Underline => Edges {
+                    top: px(3.),
+                    bottom: px(4.),
+                    ..Default::default()
+                },
+                _ => Edges::all(px(0.)),
+            },
+        }
+    }
+
+    fn normal(&self, cx: &App) -> TabStyle {
+        match self {
+            TabVariant::Tab => TabStyle {
+                fg: cx.theme().tab_foreground,
+                bg: gpui::transparent_black(),
+                borders: Edges {
+                    left: px(1.),
+                    right: px(1.),
+                    ..Default::default()
+                },
+                border_color: gpui::transparent_black(),
+                ..Default::default()
+            },
+            TabVariant::Outline => TabStyle {
+                fg: cx.theme().tab_foreground,
+                bg: gpui::transparent_black(),
+                borders: Edges::all(px(1.)),
+                border_color: cx.theme().border,
+                ..Default::default()
+            },
+            TabVariant::Pill => TabStyle {
+                fg: cx.theme().text,
+                bg: gpui::transparent_black(),
+                ..Default::default()
+            },
+            TabVariant::Segmented => TabStyle {
+                fg: cx.theme().tab_foreground,
+                bg: gpui::transparent_black(),
+                ..Default::default()
+            },
+            TabVariant::Underline => TabStyle {
+                fg: cx.theme().tab_foreground,
+                bg: gpui::transparent_black(),
+                inner_bg: gpui::transparent_black(),
+                borders: Edges {
+                    bottom: px(2.),
+                    ..Default::default()
+                },
+                border_color: gpui::transparent_black(),
+                ..Default::default()
+            },
+        }
+    }
+
+    fn hovered(&self, selected: bool, cx: &App) -> TabStyle {
+        match self {
+            TabVariant::Tab => TabStyle {
+                fg: cx.theme().tab_foreground,
+                bg: gpui::transparent_black(),
+                borders: Edges {
+                    left: px(1.),
+                    right: px(1.),
+                    ..Default::default()
+                },
+                border_color: gpui::transparent_black(),
+                ..Default::default()
+            },
+            TabVariant::Outline => TabStyle {
+                fg: cx.theme().secondary_foreground,
+                bg: cx.theme().secondary_hover,
+                borders: Edges::all(px(1.)),
+                border_color: cx.theme().border,
+                ..Default::default()
+            },
+            TabVariant::Pill => TabStyle {
+                fg: cx.theme().secondary_foreground,
+                bg: cx.theme().secondary_background,
+                ..Default::default()
+            },
+            TabVariant::Segmented => TabStyle {
+                fg: cx.theme().tab_foreground,
+                bg: gpui::transparent_black(),
+                inner_bg: if selected {
+                    cx.theme().background
+                } else {
+                    gpui::transparent_black()
+                },
+                ..Default::default()
+            },
+            TabVariant::Underline => TabStyle {
+                fg: cx.theme().tab_foreground,
+                bg: gpui::transparent_black(),
+                inner_bg: gpui::transparent_black(),
+                borders: Edges {
+                    bottom: px(2.),
+                    ..Default::default()
+                },
+                border_color: gpui::transparent_black(),
+                ..Default::default()
+            },
+        }
+    }
+
+    fn selected(&self, cx: &App) -> TabStyle {
+        match self {
+            TabVariant::Tab => TabStyle {
+                fg: cx.theme().tab_active_foreground,
+                bg: cx.theme().tab_active_background,
+                borders: Edges {
+                    left: px(1.),
+                    right: px(1.),
+                    ..Default::default()
+                },
+                border_color: cx.theme().border,
+                ..Default::default()
+            },
+            TabVariant::Outline => TabStyle {
+                fg: cx.theme().text_accent,
+                bg: gpui::transparent_black(),
+                borders: Edges::all(px(1.)),
+                border_color: cx.theme().element_active,
+                ..Default::default()
+            },
+            TabVariant::Pill => TabStyle {
+                fg: cx.theme().element_foreground,
+                bg: cx.theme().element_background,
+                ..Default::default()
+            },
+            TabVariant::Segmented => TabStyle {
+                fg: cx.theme().tab_active_foreground,
+                bg: gpui::transparent_black(),
+                inner_bg: cx.theme().background,
+                shadow: true,
+                ..Default::default()
+            },
+            TabVariant::Underline => TabStyle {
+                fg: cx.theme().tab_active_foreground,
+                bg: gpui::transparent_black(),
+                borders: Edges {
+                    bottom: px(2.),
+                    ..Default::default()
+                },
+                border_color: cx.theme().element_active,
+                ..Default::default()
+            },
+        }
+    }
+
+    fn disabled(&self, selected: bool, cx: &App) -> TabStyle {
+        match self {
+            TabVariant::Tab => TabStyle {
+                fg: cx.theme().text_muted,
+                bg: gpui::transparent_black(),
+                border_color: if selected {
+                    cx.theme().border
+                } else {
+                    gpui::transparent_black()
+                },
+                borders: Edges {
+                    left: px(1.),
+                    right: px(1.),
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+            TabVariant::Outline => TabStyle {
+                fg: cx.theme().text_muted,
+                bg: gpui::transparent_black(),
+                borders: Edges::all(px(1.)),
+                border_color: if selected {
+                    cx.theme().element_active
+                } else {
+                    cx.theme().border
+                },
+                ..Default::default()
+            },
+            TabVariant::Pill => TabStyle {
+                fg: if selected {
+                    cx.theme().element_foreground.opacity(0.5)
+                } else {
+                    cx.theme().text_muted
+                },
+                bg: if selected {
+                    cx.theme().element_background.opacity(0.5)
+                } else {
+                    gpui::transparent_black()
+                },
+                ..Default::default()
+            },
+            TabVariant::Segmented => TabStyle {
+                fg: cx.theme().text_muted,
+                bg: cx.theme().tab_background,
+                inner_bg: if selected {
+                    cx.theme().background
+                } else {
+                    gpui::transparent_black()
+                },
+                ..Default::default()
+            },
+            TabVariant::Underline => TabStyle {
+                fg: cx.theme().text_muted,
+                bg: gpui::transparent_black(),
+                border_color: if selected {
+                    cx.theme().border
+                } else {
+                    gpui::transparent_black()
+                },
+                borders: Edges {
+                    bottom: px(2.),
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+        }
+    }
+
+    pub(super) fn tab_bar_radius(&self, size: Size, cx: &App) -> Pixels {
+        if *self != TabVariant::Segmented {
+            return px(0.);
+        }
+
+        match size {
+            Size::XSmall | Size::Small => cx.theme().radius,
+            Size::Large => cx.theme().radius_lg,
+            _ => cx.theme().radius_lg,
+        }
+    }
+
+    fn radius(&self, size: Size, cx: &App) -> Pixels {
+        match self {
+            TabVariant::Outline | TabVariant::Pill => px(99.),
+            TabVariant::Segmented => match size {
+                Size::XSmall | Size::Small => cx.theme().radius,
+                Size::Large => cx.theme().radius_lg,
+                _ => cx.theme().radius_lg,
+            },
+            _ => px(0.),
+        }
+    }
+
+    fn inner_radius(&self, size: Size, cx: &App) -> Pixels {
+        match self {
+            TabVariant::Segmented => match size {
+                Size::Large => self.tab_bar_radius(size, cx) - px(3.),
+                _ => self.tab_bar_radius(size, cx) - px(2.),
+            },
+            _ => px(0.),
+        }
+    }
+}
+
+#[allow(dead_code)]
+struct TabStyle {
+    borders: Edges<Pixels>,
+    border_color: Hsla,
+    bg: Hsla,
+    fg: Hsla,
+    shadow: bool,
+    inner_bg: Hsla,
+}
+
+impl Default for TabStyle {
+    fn default() -> Self {
+        TabStyle {
+            borders: Edges::all(px(0.)),
+            border_color: gpui::transparent_white(),
+            bg: gpui::transparent_white(),
+            fg: gpui::transparent_white(),
+            shadow: false,
+            inner_bg: gpui::transparent_white(),
+        }
+    }
+}
+
 #[allow(clippy::type_complexity)]
 /// A Tab element for the [`super::TabBar`].
 #[derive(IntoElement)]
@@ -23,6 +404,8 @@ pub struct Tab {
     pub(super) tab_bar_prefix: Option<bool>,
     suffix: Option<AnyElement>,
     children: Vec<AnyElement>,
+    variant: TabVariant,
+    size: Size,
     pub(super) disabled: bool,
     pub(super) selected: bool,
     on_click: Option<Rc<dyn Fn(&ClickEvent, &mut Window, &mut App) + 'static>>,
@@ -71,6 +454,8 @@ impl Default for Tab {
             selected: false,
             prefix: None,
             suffix: None,
+            variant: TabVariant::default(),
+            size: Size::default(),
             on_click: None,
         }
     }
@@ -94,6 +479,36 @@ impl Tab {
         self
     }
 
+    /// Set Tab Variant.
+    pub fn with_variant(mut self, variant: TabVariant) -> Self {
+        self.variant = variant;
+        self
+    }
+
+    /// Use Pill variant.
+    pub fn pill(mut self) -> Self {
+        self.variant = TabVariant::Pill;
+        self
+    }
+
+    /// Use outline variant.
+    pub fn outline(mut self) -> Self {
+        self.variant = TabVariant::Outline;
+        self
+    }
+
+    /// Use Segmented variant.
+    pub fn segmented(mut self) -> Self {
+        self.variant = TabVariant::Segmented;
+        self
+    }
+
+    /// Use Underline variant.
+    pub fn underline(mut self) -> Self {
+        self.variant = TabVariant::Underline;
+        self
+    }
+
     /// Set the left side of the tab
     pub fn prefix(mut self, prefix: impl IntoElement) -> Self {
         self.prefix = Some(prefix.into_any_element());
@@ -165,16 +580,42 @@ impl Styled for Tab {
     }
 }
 
+impl Sizable for Tab {
+    fn with_size(mut self, size: impl Into<Size>) -> Self {
+        self.size = size.into();
+        self
+    }
+}
+
 impl RenderOnce for Tab {
     fn render(self, _: &mut Window, cx: &mut App) -> impl IntoElement {
-        let fg = if self.disabled {
-            cx.theme().text_muted
-        } else if self.selected {
-            cx.theme().tab_active_foreground
+        let mut tab_style = if self.selected {
+            self.variant.selected(cx)
         } else {
-            cx.theme().tab_foreground
+            self.variant.normal(cx)
         };
 
+        let mut hover_style = self.variant.hovered(self.selected, cx);
+
+        if self.disabled {
+            tab_style = self.variant.disabled(self.selected, cx);
+            hover_style = self.variant.disabled(self.selected, cx);
+        }
+
+        let tab_bar_prefix = self.tab_bar_prefix.unwrap_or_default();
+
+        if !tab_bar_prefix && self.ix == 0 && self.variant == TabVariant::Tab {
+            tab_style.borders.left = px(0.);
+            hover_style.borders.left = px(0.);
+        }
+
+        let radius = self.variant.radius(self.size, cx);
+        let inner_radius = self.variant.inner_radius(self.size, cx);
+        let inner_paddings = self.variant.inner_paddings(self.size);
+        let inner_margins = self.variant.inner_margins(self.size);
+        let inner_height = self.variant.inner_height(self.size);
+        let height = self.variant.height(self.size);
+
         self.base
             .id(self.ix)
             .flex()
@@ -182,37 +623,74 @@ impl RenderOnce for Tab {
             .gap_1()
             .items_center()
             .flex_shrink_0()
-            .h(TABBAR_HEIGHT)
-            .relative()
+            .h(height)
             .overflow_hidden()
-            .text_color(fg)
-            .text_sm()
+            .text_color(tab_style.fg)
+            .map(|this| match self.size {
+                Size::XSmall => this.text_xs(),
+                Size::Large => this.text_base(),
+                _ => this.text_sm(),
+            })
+            .bg(tab_style.bg)
+            .border_l(tab_style.borders.left)
+            .border_r(tab_style.borders.right)
+            .border_t(tab_style.borders.top)
+            .border_b(tab_style.borders.bottom)
+            .border_color(tab_style.border_color)
+            .rounded(radius)
+            .when(!self.selected && !self.disabled, |this| {
+                this.hover(|this| {
+                    this.text_color(hover_style.fg)
+                        .bg(hover_style.bg)
+                        .border_l(hover_style.borders.left)
+                        .border_r(hover_style.borders.right)
+                        .border_t(hover_style.borders.top)
+                        .border_b(hover_style.borders.bottom)
+                        .border_color(hover_style.border_color)
+                        .rounded(radius)
+                })
+            })
             .when_some(self.prefix, |this, prefix| this.child(prefix))
             .child(
                 h_flex()
                     .flex_1()
-                    .h(px(30.))
+                    .h(inner_height)
                     .line_height(relative(1.))
                     .whitespace_nowrap()
                     .items_center()
                     .justify_center()
                     .overflow_hidden()
+                    .margins(inner_margins)
                     .flex_shrink_0()
-                    .px_3()
                     .map(|this| match self.icon {
-                        Some(icon) => this.w(px(38.)).child(icon.size_4()),
+                        Some(icon) => {
+                            this.w(inner_height * 1.25)
+                                .child(icon.map(|this| match self.size {
+                                    Size::XSmall => this.size_2p5(),
+                                    Size::Small => this.size_3p5(),
+                                    Size::Large => this.size_4(),
+                                    _ => this.size_4(),
+                                }))
+                        }
                         None => this
+                            .paddings(inner_paddings)
                             .map(|this| match self.label {
                                 Some(label) => this.child(label),
                                 None => this,
                             })
                             .children(self.children),
-                    }),
+                    })
+                    .bg(tab_style.inner_bg)
+                    .rounded(inner_radius)
+                    .when(tab_style.shadow, |this| this.shadow_xs())
+                    .hover(|this| this.bg(hover_style.inner_bg).rounded(inner_radius)),
             )
             .when_some(self.suffix, |this, suffix| {
                 this.child(div().pr_2().child(suffix))
             })
-            .on_mouse_down(MouseButton::Left, |_ev, _window, cx| {
+            .on_mouse_down(MouseButton::Left, |_, _, cx| {
+                // Stop propagation behavior, for works on TitleBar.
+                // https://github.com/longbridge/gpui-component/issues/1836
                 cx.stop_propagation();
             })
             .when(!self.disabled, |this| {
@@ -220,21 +698,5 @@ impl RenderOnce for Tab {
                     this.on_click(move |event, window, cx| on_click(event, window, cx))
                 })
             })
-            .child(
-                div()
-                    .absolute()
-                    .bottom_0()
-                    .left_0()
-                    .right_0()
-                    .h_0p5()
-                    .when(self.selected && !self.disabled, |this| {
-                        this.bg(cx.theme().element_active)
-                    })
-                    .when(!self.selected && !self.disabled, |this| {
-                        this.invisible().group_hover("", |this| {
-                            this.visible().bg(cx.theme().secondary_background)
-                        })
-                    }),
-            )
     }
 }

crates/ui/src/tab/tab_bar.rs

@@ -2,17 +2,19 @@ use std::rc::Rc;
 
 use gpui::prelude::FluentBuilder as _;
 use gpui::{
-    Anchor, AnyElement, App, Div, ElementId, InteractiveElement, IntoElement, ParentElement,
+    Anchor, AnyElement, App, Div, Edges, ElementId, InteractiveElement, IntoElement, ParentElement,
     RenderOnce, ScrollHandle, Stateful, StatefulInteractiveElement as _, StyleRefinement, Styled,
     Window, div, px,
 };
 use smallvec::SmallVec;
+use theme::ActiveTheme;
 
-use super::Tab;
+use super::{Tab, TabVariant};
 use crate::button::{Button, ButtonVariants as _};
 use crate::menu::{DropdownMenu as _, PopupMenuItem};
-use crate::{IconName, Selectable, Sizable, StyledExt, h_flex};
+use crate::{IconName, Selectable, Sizable, Size, StyledExt, h_flex};
 
+#[allow(clippy::type_complexity)]
 /// A TabBar element that contains multiple [`Tab`] items.
 #[derive(IntoElement)]
 pub struct TabBar {
@@ -24,8 +26,9 @@ pub struct TabBar {
     children: SmallVec<[Tab; 2]>,
     last_empty_space: AnyElement,
     selected_index: Option<usize>,
+    variant: TabVariant,
+    size: Size,
     menu: bool,
-    #[allow(clippy::type_complexity)]
     on_click: Option<Rc<dyn Fn(&usize, &mut Window, &mut App) + 'static>>,
 }
 
@@ -39,6 +42,8 @@ impl TabBar {
             scroll_handle: None,
             prefix: None,
             suffix: None,
+            variant: TabVariant::default(),
+            size: Size::default(),
             last_empty_space: div().w_3().into_any_element(),
             selected_index: None,
             on_click: None,
@@ -46,6 +51,36 @@ impl TabBar {
         }
     }
 
+    /// Set the Tab variant, all children will inherit the variant.
+    pub fn with_variant(mut self, variant: TabVariant) -> Self {
+        self.variant = variant;
+        self
+    }
+
+    /// Set the Tab variant to Pill, all children will inherit the variant.
+    pub fn pill(mut self) -> Self {
+        self.variant = TabVariant::Pill;
+        self
+    }
+
+    /// Set the Tab variant to Outline, all children will inherit the variant.
+    pub fn outline(mut self) -> Self {
+        self.variant = TabVariant::Outline;
+        self
+    }
+
+    /// Set the Tab variant to Segmented, all children will inherit the variant.
+    pub fn segmented(mut self) -> Self {
+        self.variant = TabVariant::Segmented;
+        self
+    }
+
+    /// Set the Tab variant to Underline, all children will inherit the variant.
+    pub fn underline(mut self) -> Self {
+        self.variant = TabVariant::Underline;
+        self
+    }
+
     /// Set whether to show the menu button when tabs overflow, default is false.
     pub fn menu(mut self, menu: bool) -> Self {
         self.menu = menu;
@@ -70,13 +105,13 @@ impl TabBar {
         self
     }
 
-    /// Add children of the TabBar.
+    /// Add children of the TabBar, all children will inherit the variant.
     pub fn children(mut self, children: impl IntoIterator<Item = impl Into<Tab>>) -> Self {
         self.children.extend(children.into_iter().map(Into::into));
         self
     }
 
-    /// Add child of the TabBar.
+    /// Add child of the TabBar, tab will inherit the variant.
     pub fn child(mut self, child: impl Into<Tab>) -> Self {
         self.children.push(child.into());
         self
@@ -112,8 +147,60 @@ impl Styled for TabBar {
     }
 }
 
+impl Sizable for TabBar {
+    fn with_size(mut self, size: impl Into<Size>) -> Self {
+        self.size = size.into();
+        self
+    }
+}
+
 impl RenderOnce for TabBar {
-    fn render(self, _: &mut Window, _cx: &mut App) -> impl IntoElement {
+    fn render(self, _: &mut Window, cx: &mut App) -> impl IntoElement {
+        let default_gap = match self.size {
+            Size::Small | Size::XSmall => px(8.),
+            Size::Large => px(16.),
+            _ => px(12.),
+        };
+        let (bg, paddings, gap) = match self.variant {
+            TabVariant::Tab => {
+                let padding = Edges::all(px(0.));
+                (cx.theme().tab_background, padding, px(0.))
+            }
+            TabVariant::Outline => {
+                let padding = Edges::all(px(0.));
+                (gpui::transparent_black(), padding, default_gap)
+            }
+            TabVariant::Pill => {
+                let padding = Edges::all(px(0.));
+                (gpui::transparent_black(), padding, px(4.))
+            }
+            TabVariant::Segmented => {
+                let padding_x = match self.size {
+                    Size::XSmall => px(2.),
+                    Size::Small => px(3.),
+                    _ => px(4.),
+                };
+                let padding = Edges {
+                    left: padding_x,
+                    right: padding_x,
+                    ..Default::default()
+                };
+
+                (cx.theme().tab_background, padding, px(2.))
+            }
+            TabVariant::Underline => {
+                // This gap is same as the tab inner_paddings
+                let gap = match self.size {
+                    Size::XSmall => px(10.),
+                    Size::Small => px(12.),
+                    Size::Large => px(20.),
+                    _ => px(16.),
+                };
+
+                (gpui::transparent_black(), Edges::all(px(0.)), gap)
+            }
+        };
+
         let mut item_labels = Vec::new();
         let selected_index = self.selected_index;
         let on_click = self.on_click.clone();
@@ -123,6 +210,25 @@ impl RenderOnce for TabBar {
             .relative()
             .flex()
             .items_center()
+            .bg(bg)
+            .text_color(cx.theme().tab_foreground)
+            .when(
+                self.variant == TabVariant::Underline || self.variant == TabVariant::Tab,
+                |this| {
+                    this.child(
+                        div()
+                            .id("border-b")
+                            .absolute()
+                            .left_0()
+                            .bottom_0()
+                            .size_full()
+                            .border_b_1()
+                            .border_color(cx.theme().border),
+                    )
+                },
+            )
+            .rounded(self.variant.tab_bar_radius(self.size, cx))
+            .paddings(paddings)
             .refine_style(&self.style)
             .when_some(self.prefix, |this, prefix| this.child(prefix))
             .child(
@@ -133,13 +239,15 @@ impl RenderOnce for TabBar {
                     .when_some(self.scroll_handle, |this, scroll_handle| {
                         this.track_scroll(&scroll_handle)
                     })
-                    .gap(px(0.))
+                    .gap(gap)
                     .children(self.children.into_iter().enumerate().map(|(ix, child)| {
                         item_labels.push((child.label.clone(), child.disabled));
                         let tab_bar_prefix = child.tab_bar_prefix.unwrap_or(true);
                         child
                             .ix(ix)
                             .tab_bar_prefix(tab_bar_prefix)
+                            .with_variant(self.variant)
+                            .with_size(self.size)
                             .when_some(self.selected_index, |this, selected_ix| {
                                 this.selected(selected_ix == ix)
                             })

crates/ui/src/title_bar.rs

@@ -283,6 +283,8 @@ impl RenderOnce for TitleBar {
                         this.px_2()
                     }
                 })
+                .border_b_1()
+                .border_color(cx.theme().border)
                 .bg(cx.theme().title_bar)
                 .refine_style(&self.style)
                 .when(is_linux, |this| {

crates/workspace/Cargo.toml

@@ -14,13 +14,10 @@ chat = { path = "../chat" }
 chat_ui = { path = "../chat_ui" }
 settings = { path = "../settings" }
 person = { path = "../person" }
-auto_update = { path = "../auto_update" }
 
 gpui.workspace = true
 nostr-sdk.workspace = true
-instant.workspace = true
 nostr-connect.workspace = true
-browser-signer-proxy = { path = "../browser-signer-proxy" }
 
 anyhow.workspace = true
 serde.workspace = true

crates/workspace/src/dialogs/import.rs

@@ -1,16 +1,17 @@
+use std::time::Duration;
+
 use anyhow::{Error, anyhow};
 use gpui::prelude::FluentBuilder;
 use gpui::{
     AppContext, Context, Entity, IntoElement, ParentElement, Render, SharedString, Styled,
     Subscription, Task, Window, div,
 };
-use instant::Duration;
 use nostr_connect::prelude::*;
 use state::{CoopAuthUrlHandler, NostrRegistry, USER_KEYRING};
 use theme::ActiveTheme;
 use ui::button::{Button, ButtonVariants};
 use ui::input::{Input, InputEvent, InputState};
-use ui::{Disableable, StyledExt, WindowExtension, divider, v_flex};
+use ui::{Disableable, StyledExt, WindowExtension, v_flex};
 
 #[derive(Debug)]
 pub struct ImportIdentity {
@@ -35,7 +36,7 @@ pub struct ImportIdentity {
 
 impl ImportIdentity {
     pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let key_input = cx.new(|cx| InputState::new(window, cx).placeholder("nsec or bunker://"));
+        let key_input = cx.new(|cx| InputState::new(window, cx));
         let pass_input = cx.new(|cx| InputState::new(window, cx).masked(true));
         let error = cx.new(|_| None);
 
@@ -134,6 +135,7 @@ impl ImportIdentity {
                     })?;
                 }
             }
+
             Ok(())
         }));
     }
@@ -144,7 +146,7 @@ impl ImportIdentity {
         let password = uri.to_string();
         let save = cx.write_credentials(USER_KEYRING, "bunker", password.as_bytes());
 
-        self.tasks.push(cx.spawn_in(window, async move |_this, cx| {
+        cx.spawn_in(window, async move |_this, cx| {
             let keys = master_keys.await;
             let timeout = Duration::from_secs(30);
 
@@ -160,16 +162,9 @@ impl ImportIdentity {
                 cx.notify();
             });
 
-            Ok(())
-        }));
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    fn proxy(&mut self, cx: &mut Context<Self>) {
-        let nostr = NostrRegistry::global(cx);
-        nostr.update(cx, |this, cx| {
-            this.connect_proxy(cx);
-        });
+            Ok::<(), anyhow::Error>(())
+        })
+        .detach();
     }
 
     fn set_loading(&mut self, status: bool, cx: &mut Context<Self>) {
@@ -207,20 +202,13 @@ impl ImportIdentity {
 
 impl Render for ImportIdentity {
     fn render(&mut self, _window: &mut gpui::Window, cx: &mut Context<Self>) -> impl IntoElement {
-        const BUNKER_WARN: &str = "Nostr Connect will usually take more time to get all your messages. Please keep your session open until you see all your messages.";
-        const KEY_WARN: &str = "Coop won't store your identity key on the local device. You need to re-login again in the next session. You can use Nostr Connect for persistent login.";
+        const MSG: &str = "Coop won't store your identity key on the local device. You need to re-login again in the next session. You can use Nostr Connect for persistent login.";
 
-        let is_wasm = cfg!(target_arch = "wasm32");
         let require_password = self.key_input.read(cx).value().starts_with("ncryptsec1");
         let key_warning = self.key_input.read(cx).value().starts_with("nsec1") || require_password;
-        let bunker_warning = self.key_input.read(cx).value().starts_with("bunker://");
 
         v_flex()
             .size_full()
-            .gap_4()
-            .text_sm()
-            .child(
-                v_flex()
             .gap_2()
             .child(
                 v_flex()
@@ -238,47 +226,26 @@ impl Render for ImportIdentity {
                         .child(Input::new(&self.pass_input)),
                 )
             })
-                    .when(bunker_warning, |this| {
-                        this.child(
-                            div()
-                                .text_xs()
-                                .text_color(cx.theme().text_warning)
-                                .child(div().child(BUNKER_WARN)),
-                        )
-                    })
             .when(key_warning, |this| {
                 this.child(
                     div()
+                        .v_flex()
                         .text_xs()
                         .text_color(cx.theme().text_warning)
-                                .child(div().child(KEY_WARN)),
-                        )
-                    }),
+                        .child(div().font_semibold().child("Warning"))
+                        .child(div().child(MSG)),
                 )
+            })
             .child(
                 Button::new("login")
                     .label("Continue")
                     .primary()
-                    .font_semibold()
                     .loading(self.loading)
                     .disabled(self.loading)
-                    .on_click(cx.listener(move |this, _ev, window, cx| {
+                    .on_click(cx.listener(move |this, _, window, cx| {
                         this.login(window, cx);
                     })),
             )
-            .child(divider(cx))
-            .when(!is_wasm, |this| {
-                this.child(
-                    Button::new("proxy")
-                        .label("Connect via Web Extension (Experimental)")
-                        .ghost_alt()
-                        .loading(self.loading)
-                        .disabled(self.loading)
-                        .on_click(cx.listener(move |this, _ev, _window, cx| {
-                            this.proxy(cx);
-                        })),
-                )
-            })
             .when_some(self.error.read(cx).as_ref(), |this, error| {
                 this.child(
                     div()

crates/workspace/src/dialogs/restore.rs

@@ -1,4 +1,4 @@
-use instant::Duration;
+use std::time::Duration;
 
 use anyhow::Error;
 use device::DeviceRegistry;

crates/workspace/src/dialogs/screening.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::time::Duration;
 
 use anyhow::Error;
 use common::TimestampExt;
@@ -7,7 +8,6 @@ use gpui::{
     App, AppContext, Context, Div, Entity, InteractiveElement, IntoElement, ParentElement, Render,
     SharedString, Styled, Subscription, Task, Window, div, px, relative, uniform_list,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use person::{Person, PersonRegistry, shorten_pubkey};
 use smallvec::{SmallVec, smallvec};
@@ -16,7 +16,7 @@ use theme::ActiveTheme;
 use ui::avatar::Avatar;
 use ui::button::{Button, ButtonVariants};
 use ui::indicator::Indicator;
-use ui::{Disableable, Icon, IconName, Sizable, StyledExt, WindowExtension, h_flex, v_flex};
+use ui::{Icon, IconName, Sizable, StyledExt, WindowExtension, h_flex, v_flex};
 
 pub fn init(public_key: PublicKey, window: &mut Window, cx: &mut App) -> Entity<Screening> {
     cx.new(|cx| Screening::new(public_key, window, cx))
@@ -55,7 +55,7 @@ impl Screening {
             window.close_all_modals(cx);
         }));
 
-        cx.defer_in(window, |this, _window, cx| {
+        cx.defer_in(window, move |this, _window, cx| {
             this.check_contact(cx);
             this.check_wot(cx);
             this.check_last_activity(cx);
@@ -234,8 +234,7 @@ impl Screening {
             }
             .to_tag();
 
-            let event = EventBuilder::new(Kind::Reporting, "")
-                .tag(tag)
+            let event = EventBuilder::report(vec![tag], "")
                 .finalize_async(&signer)
                 .await?;
 
@@ -263,7 +262,7 @@ impl Screening {
             let contacts = contacts.clone();
             let total = contacts.len();
 
-            this.title("Mutual contacts").child(
+            this.title(SharedString::from("Mutual contacts")).child(
                 v_flex().gap_1().pb_2().child(
                     uniform_list("contacts", total, move |range, _window, cx| {
                         let persons = PersonRegistry::global(cx);
@@ -342,7 +341,7 @@ impl Render for Screening {
                             .h_7()
                             .justify_center()
                             .rounded_full()
-                            .bg(cx.theme().elevated_surface_background)
+                            .bg(cx.theme().surface_background)
                             .text_sm()
                             .truncate()
                             .text_ellipsis()
@@ -355,8 +354,7 @@ impl Render for Screening {
                             .gap_1()
                             .child(
                                 Button::new("njump")
-                                    .icon(IconName::Link)
-                                    .label("njump.me")
+                                    .label("View on njump.me")
                                     .secondary()
                                     .small()
                                     .rounded()
@@ -387,7 +385,10 @@ impl Render for Screening {
                             .text_sm()
                             .child(status_badge(Some(self.followed), cx))
                             .child(
-                                v_flex().text_sm().child("Contact").child(
+                                v_flex()
+                                    .text_sm()
+                                    .child(SharedString::from("Contact"))
+                                    .child(
                                         div()
                                             .line_clamp(1)
                                             .text_color(cx.theme().text_muted)
@@ -413,7 +414,7 @@ impl Render for Screening {
                                     .child(
                                         h_flex()
                                             .gap_0p5()
-                                            .child("Activity on Public Relays")
+                                            .child(SharedString::from("Activity on Public Relays"))
                                             .child(
                                                 Button::new("active")
                                                     .icon(IconName::Info)
@@ -482,8 +483,25 @@ impl Render for Screening {
                             .gap_2()
                             .child(status_badge(Some(mutuals > 0), cx))
                             .child(
-                                h_flex()
+                                v_flex()
                                     .text_sm()
+                                    .child(
+                                        h_flex()
+                                            .gap_0p5()
+                                            .child(SharedString::from("Mutual contacts"))
+                                            .child(
+                                                Button::new("mutuals")
+                                                    .icon(IconName::Info)
+                                                    .xsmall()
+                                                    .ghost()
+                                                    .rounded()
+                                                    .on_click(cx.listener(
+                                                        move |this, _, window, cx| {
+                                                            this.mutual_contacts(window, cx);
+                                                        },
+                                                    )),
+                                            ),
+                                    )
                                     .child(
                                         div()
                                             .line_clamp(1)
@@ -495,17 +513,6 @@ impl Render for Screening {
                                                     SharedString::from(NO_MUTUAL)
                                                 }
                                             }),
-                                    )
-                                    .child(
-                                        Button::new("mutuals")
-                                            .icon(IconName::Info)
-                                            .xsmall()
-                                            .ghost()
-                                            .rounded()
-                                            .disabled(mutuals == 0)
-                                            .on_click(cx.listener(move |this, _, window, cx| {
-                                                this.mutual_contacts(window, cx);
-                                            })),
                                     ),
                             ),
                     ),

crates/workspace/src/dialogs/settings.rs

@@ -3,7 +3,7 @@ use gpui::{
     App, AppContext, Context, Entity, IntoElement, ParentElement, Render, SharedString, Styled,
     Window, div, px,
 };
-use settings::AppSettings;
+use settings::{AppSettings, AuthMode};
 use theme::{ActiveTheme, Theme, ThemeMode};
 use ui::button::{Button, ButtonVariants};
 use ui::group_box::{GroupBox, GroupBoxVariants};
@@ -60,11 +60,13 @@ impl Render for Preferences {
         const AVATAR: &str = "Hide all avatar pictures to improve performance.";
         const MODE: &str = "Use the selected light or dark theme, or to follow the OS.";
         const NIP4E: &str = "Use a dedicated key to encrypt and decrypt messages.";
+        const AUTH: &str = "Choose the authentication behavior for relays.";
         const RESET: &str = "Reset the theme to the default one.";
 
         let screening = AppSettings::get_screening(cx);
         let hide_avatar = AppSettings::get_hide_avatar(cx);
         let nip4e = AppSettings::get_nip4e(cx);
+        let auth_mode = AppSettings::get_auth_mode(cx);
         let theme_mode = AppSettings::get_theme_mode(cx);
 
         v_flex()
@@ -91,6 +93,52 @@ impl Render for Preferences {
                             .on_click(move |_, _window, cx| {
                                 AppSettings::update_hide_avatar(!hide_avatar, cx);
                             }),
+                    )
+                    .child(
+                        h_flex()
+                            .gap_3()
+                            .justify_between()
+                            .child(
+                                v_flex()
+                                    .child(
+                                        div()
+                                            .text_sm()
+                                            .child(SharedString::from("Relay authentication")),
+                                    )
+                                    .child(
+                                        div()
+                                            .text_xs()
+                                            .text_color(cx.theme().text_muted)
+                                            .child(SharedString::from(AUTH)),
+                                    ),
+                            )
+                            .child(
+                                Button::new("auth")
+                                    .label(auth_mode.to_string())
+                                    .ghost_alt()
+                                    .small()
+                                    .dropdown_menu(|this, _window, _cx| {
+                                        this.min_w(px(256.))
+                                            .item(
+                                                PopupMenuItem::new("Auto authentication").on_click(
+                                                    |_ev, _window, cx| {
+                                                        AppSettings::update_auth_mode(
+                                                            AuthMode::Auto,
+                                                            cx,
+                                                        );
+                                                    },
+                                                ),
+                                            )
+                                            .item(PopupMenuItem::new("Ask every time").on_click(
+                                                |_ev, _window, cx| {
+                                                    AppSettings::update_auth_mode(
+                                                        AuthMode::Manual,
+                                                        cx,
+                                                    );
+                                                },
+                                            ))
+                                    }),
+                            ),
                     ),
             )
             .child(

crates/workspace/src/lib.rs

@@ -1,15 +1,14 @@
 use std::sync::Arc;
 
 use ::settings::AppSettings;
-use anyhow::Error;
-use auto_update::AutoUpdater;
 use chat::{ChatEvent, ChatRegistry};
 use common::{CoopImageCache, download_dir};
 use device::{DeviceEvent, DeviceRegistry};
 use gpui::prelude::FluentBuilder;
 use gpui::{
     Action, App, AppContext, Axis, Context, Entity, InteractiveElement, IntoElement, ParentElement,
-    Render, SharedString, Styled, Subscription, Task, Window, div, image_cache, px,
+    Render, SharedString, StatefulInteractiveElement, Styled, Subscription, Window, div,
+    image_cache, px, relative,
 };
 use nostr_sdk::prelude::*;
 use person::{PersonRegistry, shorten_pubkey};
@@ -27,8 +26,7 @@ use ui::{Icon, IconName, Root, Sizable, TitleBar, WindowExtension, h_flex, v_fle
 use crate::dialogs::import::ImportIdentity;
 use crate::dialogs::restore::RestoreEncryption;
 use crate::dialogs::settings;
-use crate::panels::{backup, contact_list, greeter, messaging_relays, profile, relay_list};
-use crate::sidebar::Sidebar;
+use crate::panels::{backup, contact_list, greeter, messaging_relays, profile, relay_list, trash};
 
 mod dialogs;
 mod panels;
@@ -45,12 +43,13 @@ struct MsgRelayNotification;
 #[action(namespace = workspace, no_json)]
 enum Command {
     ToggleTheme,
-    Update,
+
     RefreshMessagingRelays,
     BackupEncryption,
     ImportEncryption,
     RefreshEncryption,
     ResetEncryption,
+
     ShowRelayList,
     ShowMessaging,
     ShowProfile,
@@ -60,16 +59,12 @@ enum Command {
 }
 
 pub struct Workspace {
-    sidebar: Entity<Sidebar>,
     /// App's Dock Area
     dock: Entity<DockArea>,
 
     /// App's Image Cache
     image_cache: Entity<CoopImageCache>,
 
-    /// Async tasks
-    tasks: Vec<Task<Result<(), Error>>>,
-
     /// Event subscriptions
     _subscriptions: SmallVec<[Subscription; 6]>,
 }
@@ -80,12 +75,20 @@ impl Workspace {
         let device = DeviceRegistry::global(cx);
         let nostr = NostrRegistry::global(cx);
 
-        let sidebar = cx.new(|cx| Sidebar::new(window, cx));
         let dock = cx.new(|cx| DockArea::new(window, cx));
         let image_cache = CoopImageCache::new(IMAGE_CACHE_SIZE, cx);
 
         let mut subscriptions = smallvec![];
 
+        subscriptions.push(
+            // Observe sign in state changes
+            cx.observe_in(&nostr, window, move |this, nostr, window, cx| {
+                if nostr.read(cx).current_user().is_some() {
+                    this.set_center_layout(window, cx);
+                }
+            }),
+        );
+
         subscriptions.push(
             // Observe system appearance and update theme
             cx.observe_window_appearance(window, |_this, window, cx| {
@@ -98,7 +101,11 @@ impl Workspace {
             cx.subscribe_in(&nostr, window, move |this, _state, event, window, cx| {
                 match event {
                     StateEvent::SignerChanged => {
+                        this.set_center_layout(window, cx);
+
+                        cx.defer_in(window, |_this, window, cx| {
                             window.close_all_modals(cx);
+                        });
                     }
                     StateEvent::NoSigner => {
                         this.import_identity(window, cx);
@@ -219,22 +226,25 @@ impl Workspace {
             }),
         );
 
-        cx.defer_in(window, |this, window, cx| {
-            let dock = this.dock.downgrade();
-            let greeter = Arc::new(greeter::init(window, cx));
-            let tabs = DockItem::tabs(vec![greeter], None, &dock, window, cx);
-            let center = DockItem::split(Axis::Vertical, vec![tabs], &dock, window, cx);
+        subscriptions.push(
+            // Observe the chat registry
+            cx.observe(&chat, move |this, chat, cx| {
+                let ids = this.panel_ids(cx);
 
-            this.dock.update(cx, |this, cx| {
-                this.set_center(center, window, cx);
+                chat.update(cx, |this, cx| {
+                    this.refresh_rooms(&ids, cx);
                 });
+            }),
+        );
+
+        // Set the layout at the end of cycle
+        cx.defer_in(window, |this, window, cx| {
+            this.set_layout(window, cx);
         });
 
         Self {
-            sidebar,
             dock,
             image_cache,
-            tasks: vec![],
             _subscriptions: subscriptions,
         }
     }
@@ -255,6 +265,40 @@ impl Workspace {
         }
     }
 
+    /// Get all panel ids
+    fn panel_ids(&self, cx: &App) -> Vec<u64> {
+        self.dock
+            .read(cx)
+            .items
+            .panel_ids(cx)
+            .into_iter()
+            .filter_map(|panel| panel.parse::<u64>().ok())
+            .collect()
+    }
+
+    /// Set the dock layout
+    fn set_layout(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let left = DockItem::panel(Arc::new(sidebar::init(window, cx)));
+
+        // Update the dock layout with sidebar on the left
+        self.dock.update(cx, |this, cx| {
+            this.set_left_dock(left, Some(SIDEBAR_WIDTH), true, window, cx);
+        });
+    }
+
+    /// Set the center dock layout
+    fn set_center_layout(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let dock = self.dock.downgrade();
+        let greeter = Arc::new(greeter::init(window, cx));
+        let tabs = DockItem::tabs(vec![greeter], None, &dock, window, cx);
+        let center = DockItem::split(Axis::Vertical, vec![tabs], &dock, window, cx);
+
+        // Update the layout with center dock
+        self.dock.update(cx, |this, cx| {
+            this.set_center(center, window, cx);
+        });
+    }
+
     /// Handle command events
     fn on_command(&mut self, command: &Command, window: &mut Window, cx: &mut Context<Self>) {
         match command {
@@ -276,7 +320,7 @@ impl Workspace {
                     self.dock.update(cx, |this, cx| {
                         this.add_panel(
                             Arc::new(profile::init(public_key, window, cx)),
-                            DockPlacement::Left,
+                            DockPlacement::Right,
                             window,
                             cx,
                         );
@@ -287,7 +331,7 @@ impl Workspace {
                 self.dock.update(cx, |this, cx| {
                     this.add_panel(
                         Arc::new(contact_list::init(window, cx)),
-                        DockPlacement::Left,
+                        DockPlacement::Right,
                         window,
                         cx,
                     );
@@ -297,7 +341,7 @@ impl Workspace {
                 self.dock.update(cx, |this, cx| {
                     this.add_panel(
                         Arc::new(backup::init(window, cx)),
-                        DockPlacement::Left,
+                        DockPlacement::Right,
                         window,
                         cx,
                     );
@@ -307,7 +351,7 @@ impl Workspace {
                 self.dock.update(cx, |this, cx| {
                     this.add_panel(
                         Arc::new(messaging_relays::init(window, cx)),
-                        DockPlacement::Left,
+                        DockPlacement::Right,
                         window,
                         cx,
                     );
@@ -317,7 +361,7 @@ impl Workspace {
                 let chat = ChatRegistry::global(cx);
                 // Trigger a refresh of the chat registry
                 chat.update(cx, |this, cx| {
-                    this.reload(cx);
+                    this.refresh(cx);
                 });
             }
             Command::ShowRelayList => {
@@ -346,7 +390,7 @@ impl Workspace {
                 let device = DeviceRegistry::global(cx).downgrade();
                 let save_dialog = cx.prompt_for_new_path(download_dir(), Some("encryption.txt"));
 
-                self.tasks.push(cx.spawn_in(window, async move |_this, cx| {
+                cx.spawn_in(window, async move |_this, cx| {
                     // Get the output path from the save dialog
                     let output_path = match save_dialog.await {
                         Ok(Ok(Some(path))) => path,
@@ -373,20 +417,13 @@ impl Workspace {
                         cx.open_with_system(output_path.as_path());
                     })?;
 
-                    Ok(())
-                }));
+                    Ok::<_, anyhow::Error>(())
+                })
+                .detach();
             }
             Command::ImportEncryption => {
                 self.import_encryption(window, cx);
             }
-            Command::Update => {
-                let auto_updater = AutoUpdater::global(cx);
-                auto_updater.update(cx, |this, cx| {
-                    this.updater.update(cx, |updater, cx| {
-                        updater.check(cx);
-                    });
-                });
-            }
         }
     }
 
@@ -442,11 +479,10 @@ impl Workspace {
         let import = cx.new(|cx| ImportIdentity::new(window, cx));
 
         window.open_modal(cx, move |this, _window, _cx| {
-            this.width(px(450.))
+            this.width(px(420.))
                 .show_close(false)
                 .overlay_closable(false)
-                .keyboard(false)
-                .title("Onboarding")
+                .title("Import Identity")
                 .child(import.clone())
         });
     }
@@ -594,11 +630,6 @@ impl Workspace {
                                     Box::new(Command::ToggleTheme),
                                 )
                                 .separator()
-                                .menu_with_icon(
-                                    "Check for Updates",
-                                    IconName::Device,
-                                    Box::new(Command::Update),
-                                )
                                 .menu_with_icon(
                                     "Settings",
                                     IconName::Settings,
@@ -610,9 +641,10 @@ impl Workspace {
     }
 
     fn titlebar_right(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
-        let updater = AutoUpdater::global(cx);
         let chat = ChatRegistry::global(cx);
-        let nip4e_enabled = AppSettings::get_nip4e(cx);
+        let trash_messages = chat.read(cx).count_trash_messages(cx);
+
+        let is_nip4e_enabled = AppSettings::get_nip4e(cx);
         let nostr = NostrRegistry::global(cx);
 
         let Some(public_key) = nostr.read(cx).current_user() else {
@@ -622,16 +654,43 @@ impl Workspace {
         let persons = PersonRegistry::global(cx);
         let profile = persons.read(cx).get(&public_key, cx);
         let announcement = profile.announcement();
-        let updater_idle = updater.read(cx).idle(cx);
 
         h_flex()
             .when(!cx.theme().platform.is_mac(), |this| this.pr_2())
             .gap_2()
-            .when(!updater_idle, |this| {
-                let status = updater.read(cx).status(cx);
-                this.child(div().text_xs().italic().child(status))
+            .when(trash_messages > 0, |this| {
+                this.child(
+                    h_flex()
+                        .id("trash-messages")
+                        .h_6()
+                        .px_1()
+                        .gap_1()
+                        .rounded(cx.theme().radius)
+                        .hover(|this| this.bg(cx.theme().ghost_element_hover))
+                        .child(
+                            Icon::new(IconName::Warning)
+                                .small()
+                                .text_color(cx.theme().text_danger),
+                        )
+                        .child(
+                            div()
+                                .text_xs()
+                                .line_height(relative(1.))
+                                .child(format!("{trash_messages}")),
+                        )
+                        .on_click(move |_ev, window, cx| {
+                            cx.stop_propagation();
+                            // Add the trash panel to the center workspace
+                            Self::add_panel(
+                                trash::init(window, cx),
+                                DockPlacement::Center,
+                                window,
+                                cx,
+                            );
+                        }),
+                )
             })
-            .when(nip4e_enabled, |this| {
+            .when(is_nip4e_enabled, |this| {
                 this.child(
                     Button::new("key")
                         .icon(IconName::UserKey)
@@ -723,7 +782,17 @@ impl Workspace {
                                     .w_full()
                                     .text_sm()
                                     .justify_between()
-                                    .child(url.clone())
+                                    .child(
+                                        h_flex()
+                                            .gap_2()
+                                            .child(
+                                                div()
+                                                    .size_1p5()
+                                                    .rounded_full()
+                                                    .bg(cx.theme().icon_accent),
+                                            )
+                                            .child(url.clone()),
+                                    )
                                     .child(
                                         div()
                                             .text_xs()
@@ -735,6 +804,11 @@ impl Workspace {
 
                         // Footer
                         menu.separator()
+                            .menu_with_icon(
+                                "Reload",
+                                IconName::Refresh,
+                                Box::new(Command::RefreshMessagingRelays),
+                            )
                             .menu_with_icon(
                                 "Manage gossip relays",
                                 IconName::Relay,
@@ -742,15 +816,9 @@ impl Workspace {
                             )
                             .menu_with_icon(
                                 "Manage messaging relays",
-                                IconName::Relay,
+                                IconName::Settings,
                                 Box::new(Command::ShowMessaging),
                             )
-                            .separator()
-                            .menu_with_icon(
-                                "Reload",
-                                IconName::Refresh,
-                                Box::new(Command::RefreshMessagingRelays),
-                            )
                     }),
             )
     }
@@ -762,7 +830,7 @@ impl Render for Workspace {
         let notification_layer = Root::render_notification_layer(window, cx);
 
         div()
-            .id("workspace")
+            .id(SharedString::from("workspace"))
             .on_action(cx.listener(Self::on_command))
             .relative()
             .size_full()
@@ -779,20 +847,9 @@ impl Render for Workspace {
                                     .child(self.titlebar_left(cx))
                                     .child(self.titlebar_right(cx)),
                             )
-                            // Main
-                            .child(
-                                h_flex()
-                                    .size_full()
-                                    .child(
-                                        div()
-                                            .flex_shrink_0()
-                                            .h_full()
-                                            .w(SIDEBAR_WIDTH)
-                                            .child(self.sidebar.clone()),
-                                    )
+                            // Dock
                             .child(self.dock.clone()),
                     ),
-                    ),
             )
             // Notifications
             .children(notification_layer)

crates/workspace/src/panels/backup.rs

@@ -1,9 +1,10 @@
+use std::time::Duration;
+
 use anyhow::Error;
 use gpui::{
     AnyElement, App, AppContext, ClipboardItem, Context, Entity, EventEmitter, FocusHandle,
     Focusable, IntoElement, ParentElement, Render, SharedString, Styled, Task, Window, div,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use state::USER_KEYRING;
 use theme::ActiveTheme;
@@ -154,7 +155,12 @@ impl Render for BackupPanel {
                                     .text_color(cx.theme().text_muted)
                                     .child(SharedString::from("Public Key:")),
                             )
-                            .child(Input::new(&self.npub_input).small().disabled(true)),
+                            .child(
+                                Input::new(&self.npub_input)
+                                    .small()
+                                    .bordered(false)
+                                    .disabled(true),
+                            ),
                     )
                     .child(
                         v_flex()
@@ -167,7 +173,12 @@ impl Render for BackupPanel {
                                     .text_color(cx.theme().text_muted)
                                     .child(SharedString::from("Secret Key:")),
                             )
-                            .child(Input::new(&self.nsec_input).small().disabled(true)),
+                            .child(
+                                Input::new(&self.nsec_input)
+                                    .small()
+                                    .bordered(false)
+                                    .disabled(true),
+                            ),
                     )
                     .child(
                         Button::new("copy")

crates/workspace/src/panels/contact_list.rs

@@ -1,4 +1,5 @@
 use std::collections::HashSet;
+use std::time::Duration;
 
 use anyhow::Error;
 use gpui::prelude::FluentBuilder;
@@ -7,7 +8,6 @@ use gpui::{
     InteractiveElement, IntoElement, ParentElement, Render, SharedString, Styled, Subscription,
     Task, TextAlign, Window, div, rems,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use person::PersonRegistry;
 use smallvec::{SmallVec, smallvec};
@@ -17,7 +17,6 @@ use ui::avatar::Avatar;
 use ui::button::{Button, ButtonVariants};
 use ui::dock::{Panel, PanelEvent};
 use ui::input::{Input, InputEvent, InputState};
-use ui::scroll::ScrollableElement;
 use ui::{Disableable, IconName, Sizable, StyledExt, WindowExtension, h_flex, v_flex};
 
 pub fn init(window: &mut Window, cx: &mut App) -> Entity<ContactListPanel> {
@@ -221,7 +220,8 @@ impl ContactListPanel {
                     .px_2()
                     .justify_between()
                     .rounded(cx.theme().radius)
-                    .hover(|this| this.bg(cx.theme().ghost_element_hover))
+                    .bg(cx.theme().secondary_background)
+                    .text_color(cx.theme().secondary_foreground)
                     .child(
                         h_flex()
                             .gap_2()
@@ -283,12 +283,7 @@ impl Focusable for ContactListPanel {
 
 impl Render for ContactListPanel {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        v_flex()
-            .p_3()
-            .gap_3()
-            .w_full()
-            .overflow_y_scrollbar()
-            .child(
+        v_flex().p_3().gap_3().w_full().child(
             v_flex()
                 .gap_2()
                 .flex_1()
@@ -299,7 +294,7 @@ impl Render for ContactListPanel {
                         .text_xs()
                         .font_semibold()
                         .text_color(cx.theme().text_muted)
-                            .child("New contact:"),
+                        .child(SharedString::from("New contact:")),
                 )
                 .child(
                     v_flex()
@@ -308,7 +303,12 @@ impl Render for ContactListPanel {
                             h_flex()
                                 .gap_1()
                                 .w_full()
-                                    .child(Input::new(&self.input).small().cleanable(true))
+                                .child(
+                                    Input::new(&self.input)
+                                        .small()
+                                        .bordered(false)
+                                        .cleanable(true),
+                                )
                                 .child(
                                     Button::new("add")
                                         .icon(IconName::Plus)
@@ -348,6 +348,7 @@ impl Render for ContactListPanel {
                         .icon(IconName::CheckCircle)
                         .label("Update")
                         .primary()
+                        .small()
                         .font_semibold()
                         .loading(self.updating)
                         .disabled(self.updating)

crates/workspace/src/panels/greeter.rs

@@ -1,7 +1,6 @@
-use anyhow::Error;
 use gpui::{
     AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle, Focusable,
-    IntoElement, ParentElement, Render, SharedString, Styled, Task, Window, div, svg,
+    IntoElement, ParentElement, Render, SharedString, Styled, Window, div, svg,
 };
 use state::NostrRegistry;
 use theme::ActiveTheme;
@@ -9,8 +8,8 @@ use ui::button::{Button, ButtonVariants};
 use ui::dock::{DockPlacement, Panel, PanelEvent};
 use ui::{Icon, IconName, Sizable, StyledExt, h_flex, v_flex};
 
+use crate::Workspace;
 use crate::panels::profile;
-use crate::{Command, Workspace};
 
 pub fn init(window: &mut Window, cx: &mut App) -> Entity<GreeterPanel> {
     cx.new(|cx| GreeterPanel::new(window, cx))
@@ -19,7 +18,6 @@ pub fn init(window: &mut Window, cx: &mut App) -> Entity<GreeterPanel> {
 pub struct GreeterPanel {
     name: SharedString,
     focus_handle: FocusHandle,
-    tasks: Vec<Task<Result<(), Error>>>,
 }
 
 impl GreeterPanel {
@@ -27,7 +25,6 @@ impl GreeterPanel {
         Self {
             name: "Onboarding".into(),
             focus_handle: cx.focus_handle(),
-            tasks: vec![],
         }
     }
 
@@ -35,7 +32,7 @@ impl GreeterPanel {
         let nostr = NostrRegistry::global(cx);
 
         if let Some(public_key) = nostr.read(cx).current_user() {
-            self.tasks.push(cx.spawn_in(window, async move |_this, cx| {
+            cx.spawn_in(window, async move |_this, cx| {
                 cx.update(|window, cx| {
                     Workspace::add_panel(
                         profile::init(public_key, window, cx),
@@ -45,9 +42,8 @@ impl GreeterPanel {
                     );
                 })
                 .ok();
-
-                Ok(())
-            }));
+            })
+            .detach();
         }
     }
 }
@@ -146,20 +142,17 @@ impl Render for GreeterPanel {
                                             .ghost()
                                             .small()
                                             .justify_start()
-                                            .on_click(cx.listener(move |this, _, window, cx| {
+                                            .on_click(cx.listener(move |this, _ev, window, cx| {
                                                 this.add_profile_panel(window, cx)
                                             })),
                                     )
                                     .child(
-                                        Button::new("theme")
-                                            .icon(Icon::new(IconName::Moon))
-                                            .label("Change theme")
+                                        Button::new("invite")
+                                            .icon(Icon::new(IconName::Invite))
+                                            .label("Invite friends")
                                             .ghost()
                                             .small()
-                                            .justify_start()
-                                            .on_click(cx.listener(move |_, _, _, cx| {
-                                                cx.dispatch_action(&Command::ToggleTheme);
-                                            })),
+                                            .justify_start(),
                                     ),
                             ),
                     ),

crates/workspace/src/panels/messaging_relays.rs

@@ -1,4 +1,5 @@
 use std::collections::HashSet;
+use std::time::Duration;
 
 use anyhow::{Error, anyhow};
 use gpui::prelude::FluentBuilder;
@@ -7,7 +8,6 @@ use gpui::{
     InteractiveElement, IntoElement, ParentElement, Render, SharedString, Styled, Subscription,
     Task, TextAlign, Window, div, rems,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use smallvec::{SmallVec, smallvec};
 use state::NostrRegistry;
@@ -320,7 +320,12 @@ impl Render for MessagingRelayPanel {
                                 h_flex()
                                     .gap_1()
                                     .w_full()
-                                    .child(Input::new(&self.input).small().cleanable(true))
+                                    .child(
+                                        Input::new(&self.input)
+                                            .small()
+                                            .bordered(false)
+                                            .cleanable(true),
+                                    )
                                     .child(
                                         Button::new("add")
                                             .icon(IconName::Plus)
@@ -360,6 +365,7 @@ impl Render for MessagingRelayPanel {
                             .icon(IconName::CheckCircle)
                             .label("Update")
                             .primary()
+                            .small()
                             .font_semibold()
                             .loading(self.updating)
                             .disabled(self.updating)

crates/workspace/src/panels/mod.rs

@@ -4,3 +4,4 @@ pub mod greeter;
 pub mod messaging_relays;
 pub mod profile;
 pub mod relay_list;
+pub mod trash;

crates/workspace/src/panels/profile.rs

@@ -1,4 +1,5 @@
 use std::str::FromStr;
+use std::time::Duration;
 
 use anyhow::{Context as AnyhowContext, Error};
 use gpui::{
@@ -6,7 +7,6 @@ use gpui::{
     Focusable, IntoElement, ParentElement, PathPromptOptions, Render, SharedString, Styled, Task,
     Window, div,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use person::{Person, PersonRegistry, shorten_pubkey};
 use settings::AppSettings;
@@ -132,7 +132,7 @@ impl ProfilePanel {
         cx.notify();
 
         if status {
-            self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            cx.spawn_in(window, async move |this, cx| {
                 cx.background_executor().timer(Duration::from_secs(2)).await;
 
                 // Reset the copied state after a delay
@@ -143,9 +143,8 @@ impl ProfilePanel {
                     .ok();
                 })
                 .ok();
-
-                Ok(())
-            }));
+            })
+            .detach();
         }
     }
 
@@ -353,7 +352,7 @@ impl Render for ProfilePanel {
                             .text_color(cx.theme().text_muted)
                             .child(SharedString::from("What should people call you?")),
                     )
-                    .child(Input::new(&self.name_input).small()),
+                    .child(Input::new(&self.name_input).bordered(false).small()),
             )
             .child(
                 v_flex()
@@ -364,7 +363,7 @@ impl Render for ProfilePanel {
                             .text_color(cx.theme().text_muted)
                             .child(SharedString::from("A short introduction about you:")),
                     )
-                    .child(Input::new(&self.bio_input).small()),
+                    .child(Input::new(&self.bio_input).bordered(false).small()),
             )
             .child(
                 v_flex()
@@ -375,7 +374,7 @@ impl Render for ProfilePanel {
                             .text_color(cx.theme().text_muted)
                             .child(SharedString::from("Website:")),
                     )
-                    .child(Input::new(&self.website_input).small()),
+                    .child(Input::new(&self.website_input).bordered(false).small()),
             )
             .child(
                 v_flex()
@@ -419,6 +418,7 @@ impl Render for ProfilePanel {
                     .icon(IconName::CheckCircle)
                     .label("Update")
                     .primary()
+                    .small()
                     .font_semibold()
                     .loading(self.updating)
                     .disabled(self.updating)

crates/workspace/src/panels/relay_list.rs

@@ -1,4 +1,5 @@
 use std::collections::HashSet;
+use std::time::Duration;
 
 use anyhow::{Error, anyhow};
 use gpui::prelude::FluentBuilder;
@@ -7,7 +8,6 @@ use gpui::{
     InteractiveElement, IntoElement, ParentElement, Render, SharedString, Styled, Subscription,
     Task, TextAlign, Window, div, px, rems,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use serde::Deserialize;
 use smallvec::{SmallVec, smallvec};
@@ -216,7 +216,7 @@ impl RelayListPanel {
         self.set_updating(true, cx);
 
         let task: Task<Result<(), Error>> = cx.background_spawn(async move {
-            let event = nip65::RelayList::new(relays)
+            let event = EventBuilder::relay_list(relays)
                 .finalize_async(&signer)
                 .await?;
 
@@ -371,7 +371,12 @@ impl Render for RelayListPanel {
                                 h_flex()
                                     .gap_1()
                                     .w_full()
-                                    .child(Input::new(&self.input).small().cleanable(true))
+                                    .child(
+                                        Input::new(&self.input)
+                                            .small()
+                                            .bordered(false)
+                                            .cleanable(true),
+                                    )
                                     .child(
                                         Button::new("metadata")
                                             .map(|this| {
@@ -429,6 +434,7 @@ impl Render for RelayListPanel {
                             .icon(IconName::CheckCircle)
                             .label("Update")
                             .primary()
+                            .small()
                             .font_semibold()
                             .loading(self.updating)
                             .disabled(self.updating)

crates/workspace/src/panels/trash.rs

@@ -0,0 +1,152 @@
+use chat::ChatRegistry;
+use gpui::{
+    AnyElement, App, AppContext, ClipboardItem, Context, Entity, EventEmitter, FocusHandle,
+    Focusable, InteractiveElement, IntoElement, ListAlignment, ListState, ParentElement, Render,
+    SharedString, Styled, Window, div, list, px, relative,
+};
+use theme::ActiveTheme;
+use ui::button::{Button, ButtonVariants};
+use ui::dock::{Panel, PanelEvent};
+use ui::scroll::Scrollbar;
+use ui::{Icon, IconName, Sizable, h_flex, v_flex};
+
+pub fn init(window: &mut Window, cx: &mut App) -> Entity<TrashPanel> {
+    cx.new(|cx| TrashPanel::new(window, cx))
+}
+
+pub struct TrashPanel {
+    name: SharedString,
+    focus_handle: FocusHandle,
+
+    /// List state for messages
+    list_state: ListState,
+}
+
+impl TrashPanel {
+    fn new(_window: &mut Window, cx: &mut App) -> Self {
+        let chat = ChatRegistry::global(cx);
+        let count = chat.read(cx).count_trash_messages(cx);
+        let list_state = ListState::new(count, ListAlignment::Bottom, px(1024.));
+
+        Self {
+            name: "Trash".into(),
+            focus_handle: cx.focus_handle(),
+            list_state,
+        }
+    }
+
+    fn copy(&self, ix: usize, cx: &App) {
+        let chat = ChatRegistry::global(cx);
+        let trashes = chat.read(cx).trashes();
+
+        if let Some(message) = trashes.read(cx).iter().nth(ix) {
+            let item = ClipboardItem::new_string(message.raw_event.to_string());
+            cx.write_to_clipboard(item);
+        }
+    }
+
+    fn render_list_item(
+        &mut self,
+        ix: usize,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let chat = ChatRegistry::global(cx);
+        let trashes = chat.read(cx).trashes();
+
+        if let Some(message) = trashes.read(cx).iter().nth(ix) {
+            v_flex()
+                .id(ix)
+                .p_2()
+                .w_full()
+                .child(
+                    v_flex()
+                        .p_2()
+                        .w_full()
+                        .gap_1()
+                        .rounded(cx.theme().radius_lg)
+                        .bg(cx.theme().surface_background)
+                        .text_sm()
+                        .child(
+                            div()
+                                .text_color(cx.theme().text_danger)
+                                .child(message.reason.clone()),
+                        )
+                        .child(
+                            h_flex()
+                                .h_10()
+                                .w_full()
+                                .px_2()
+                                .justify_between()
+                                .bg(cx.theme().elevated_surface_background)
+                                .border_1()
+                                .border_color(cx.theme().border)
+                                .rounded(cx.theme().radius)
+                                .child(
+                                    div()
+                                        .truncate()
+                                        .text_ellipsis()
+                                        .text_xs()
+                                        .line_height(relative(1.))
+                                        .child(message.raw_event.clone()),
+                                )
+                                .child(
+                                    Button::new(format!("copy-{ix}"))
+                                        .icon(IconName::Copy)
+                                        .ghost()
+                                        .small()
+                                        .on_click(cx.listener(move |this, _ev, _window, cx| {
+                                            this.copy(ix, cx);
+                                        })),
+                                ),
+                        ),
+                )
+                .into_any_element()
+        } else {
+            div().id(ix).into_any_element()
+        }
+    }
+}
+
+impl Panel for TrashPanel {
+    fn panel_id(&self) -> SharedString {
+        self.name.clone()
+    }
+
+    fn title(&self, _cx: &App) -> AnyElement {
+        h_flex()
+            .gap_1()
+            .text_sm()
+            .child(Icon::new(IconName::Warning).small())
+            .child("Errors")
+            .into_any_element()
+    }
+}
+
+impl EventEmitter<PanelEvent> for TrashPanel {}
+
+impl Focusable for TrashPanel {
+    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for TrashPanel {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex().size_full().relative().child(
+            v_flex()
+                .flex_1()
+                .relative()
+                .child(
+                    list(
+                        self.list_state.clone(),
+                        cx.processor(move |this, ix, window, cx| {
+                            this.render_list_item(ix, window, cx)
+                        }),
+                    )
+                    .size_full(),
+                )
+                .child(Scrollbar::vertical(&self.list_state)),
+        )
+    }
+}

crates/workspace/src/sidebar/entry.rs

@@ -164,7 +164,9 @@ impl RenderOnce for RoomEntry {
                                 )
                                 .on_cancel(move |_event, window, cx| {
                                     window.dispatch_action(Box::new(ClosePanel), cx);
-                                    true
+                                    // Prevent closing the modal on click
+                                    // modal will be automatically closed after closing panel
+                                    false
                                 })
                         });
                     }

crates/workspace/src/sidebar/mod.rs

@@ -1,5 +1,6 @@
 use std::collections::HashSet;
 use std::ops::Range;
+use std::time::Duration;
 
 use anyhow::Error;
 use chat::{ChatEvent, ChatRegistry, Room, RoomKind};
@@ -11,12 +12,11 @@ use gpui::{
     ParentElement, Render, SharedString, Styled, Subscription, Task, UniformListScrollHandle,
     Window, div, uniform_list,
 };
-use instant::Duration;
 use nostr_sdk::prelude::*;
 use person::PersonRegistry;
 use smallvec::{SmallVec, smallvec};
 use state::{FIND_DELAY, IMAGE_CACHE_SIZE, NostrRegistry};
-use theme::{ActiveTheme, SIDEBAR_WIDTH};
+use theme::{ActiveTheme, SIDEBAR_WIDTH, TABBAR_HEIGHT};
 use ui::button::{Button, ButtonVariants};
 use ui::dock::{Panel, PanelEvent};
 use ui::indicator::Indicator;
@@ -29,8 +29,13 @@ mod entry;
 
 const INPUT_PLACEHOLDER: &str = "Find or start a conversation";
 
+pub fn init(window: &mut Window, cx: &mut App) -> Entity<Sidebar> {
+    cx.new(|cx| Sidebar::new(window, cx))
+}
+
 /// Sidebar.
 pub struct Sidebar {
+    name: SharedString,
     focus_handle: FocusHandle,
     scroll_handle: UniformListScrollHandle,
 
@@ -75,7 +80,7 @@ pub struct Sidebar {
 }
 
 impl Sidebar {
-    pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let chat = ChatRegistry::global(cx);
         let filter = cx.new(|_| RoomKind::Ongoing);
         let contact_list = cx.new(|_| None);
@@ -130,6 +135,7 @@ impl Sidebar {
         );
 
         Self {
+            name: "Sidebar".into(),
             focus_handle: cx.focus_handle(),
             scroll_handle: UniformListScrollHandle::new(),
             find_input,
@@ -329,7 +335,7 @@ impl Sidebar {
                         .organize(&public_key)
                         .kind(RoomKind::Ongoing)
                 });
-                this.emit_room(&room, _window, cx);
+                this.emit_room(&room, cx);
             })?;
 
             // Reset the find panel
@@ -354,14 +360,6 @@ impl Sidebar {
             cx.notify();
         });
         self.new_requests = false;
-
-        // Reset search state when switching to inbox/requests
-        self.reset(window, cx);
-
-        // Clear the find input value
-        self.find_input.update(cx, |this, cx| {
-            this.set_value("", window, cx);
-        });
     }
 
     fn render_list_items(
@@ -381,9 +379,9 @@ impl Sidebar {
                 let room = item.read(cx);
                 let room_clone = item.clone();
                 let public_key = room.display_member(cx).public_key();
-                let handler = cx.listener(move |_this, _ev, window, cx| {
+                let handler = cx.listener(move |_this, _ev, _window, cx| {
                     ChatRegistry::global(cx).update(cx, |s, cx| {
-                        s.emit_room(&room_clone, window, cx);
+                        s.emit_room(&room_clone, cx);
                     });
                 });
 
@@ -476,7 +474,7 @@ impl Sidebar {
 
 impl Panel for Sidebar {
     fn panel_id(&self) -> SharedString {
-        "Sidebar".into()
+        self.name.clone()
     }
 }
 
@@ -490,11 +488,8 @@ impl Focusable for Sidebar {
 
 impl Render for Sidebar {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let nostr = NostrRegistry::global(cx);
         let chat = ChatRegistry::global(cx);
-        let logged_in = nostr.read(cx).current_user().is_some();
-        let loading = chat.read(cx).loading() && logged_in;
-
+        let loading = chat.read(cx).loading();
         let total_rooms = chat.read(cx).count(self.filter.read(cx), cx);
 
         // Whether the find panel should be shown
@@ -512,11 +507,17 @@ impl Render for Sidebar {
             .size_full()
             .gap_2()
             .child(
-                h_flex().px_2().py_1().child(
+                h_flex()
+                    .h(TABBAR_HEIGHT)
+                    .border_b_1()
+                    .border_color(cx.theme().border)
+                    .bg(cx.theme().tab_background)
+                    .child(
                         Input::new(&self.find_input)
+                            .appearance(false)
+                            .bordered(false)
                             .small()
                             .text_xs()
-                        .disabled(loading)
                             .when(!self.find_input.read(cx).loading, |this| {
                                 this.suffix(
                                     Button::new("find-icon")
@@ -538,6 +539,7 @@ impl Render for Sidebar {
                             Button::new("search-results")
                                 .icon(IconName::Search)
                                 .tooltip("All search results")
+                                .small()
                                 .ghost_alt()
                                 .font_semibold()
                                 .flex_1()
@@ -553,8 +555,9 @@ impl Render for Sidebar {
                                     this.icon(IconName::Inbox)
                                 }
                             })
-                            .when(!show_find_panel, |this| this.label("Inbox").small())
+                            .when(!show_find_panel, |this| this.label("Inbox"))
                             .tooltip("All ongoing conversations")
+                            .small()
                             .ghost_alt()
                             .font_semibold()
                             .flex_1()
@@ -574,8 +577,9 @@ impl Render for Sidebar {
                                     this.icon(IconName::Fistbump)
                                 }
                             })
-                            .when(!show_find_panel, |this| this.label("Requests").small())
+                            .when(!show_find_panel, |this| this.label("Requests"))
                             .tooltip("Incoming new conversations")
+                            .small()
                             .ghost_alt()
                             .font_semibold()
                             .flex_1()
@@ -604,13 +608,17 @@ impl Render for Sidebar {
                             .items_center()
                             .justify_center()
                             .text_center()
-                            .child(div().text_sm().font_semibold().child("No conversations"))
                             .child(
                                 div()
-                                    .text_xs()
-                                    .text_color(cx.theme().text_muted)
-                                    .child("Start a conversation with someone to get started."),
+                                    .text_sm()
+                                    .font_semibold()
+                                    .child(SharedString::from("No conversations")),
+                            )
+                            .child(div().text_xs().text_color(cx.theme().text_muted).child(
+                                SharedString::from(
+                                    "Start a conversation with someone to get started.",
                                 ),
+                            )),
                     ),
                 )
             })
@@ -635,7 +643,7 @@ impl Render for Sidebar {
                                                 .font_semibold()
                                                 .text_color(cx.theme().text_muted)
                                                 .child(Icon::new(IconName::ChevronDown))
-                                                .child("Results"),
+                                                .child(SharedString::from("Results")),
                                         )
                                         .child(
                                             uniform_list(
@@ -662,7 +670,7 @@ impl Render for Sidebar {
                                                 .font_semibold()
                                                 .text_color(cx.theme().text_muted)
                                                 .child(Icon::new(IconName::ChevronDown).small())
-                                                .child("Contacts"),
+                                                .child(SharedString::from("Suggestions")),
                                         )
                                         .child(
                                             uniform_list(
@@ -699,17 +707,17 @@ impl Render for Sidebar {
                 this.child(
                     div()
                         .absolute()
-                        .bottom_2()
+                        .bottom_0()
                         .left_0()
                         .h_9()
                         .w_full()
-                        .px_4()
+                        .px_2()
                         .child(
                             Button::new("create")
                                 .label(button_label)
                                 .primary()
-                                .rounded()
-                                .shadow_md()
+                                .small()
+                                .shadow_lg()
                                 .on_click(cx.listener(move |this, _ev, window, cx| {
                                     this.create_room(window, cx);
                                 })),
@@ -732,13 +740,15 @@ impl Render for Sidebar {
                                 .h_9()
                                 .justify_center()
                                 .bg(cx.theme().background.opacity(0.85))
-                                .when(cx.theme().shadow, |this| this.shadow_md())
+                                .border_color(cx.theme().border_disabled)
+                                .border_1()
+                                .when(cx.theme().shadow, |this| this.shadow_xs())
                                 .rounded_full()
                                 .text_xs()
                                 .font_semibold()
                                 .text_color(cx.theme().text_muted)
                                 .child(Indicator::new().small().color(cx.theme().icon_accent))
-                                .child("Getting messages..."),
+                                .child(SharedString::from("Getting messages...")),
                         ),
                 )
             })

desktop/Cargo.toml

@@ -48,4 +48,3 @@ reqwest_client.workspace = true
 
 log.workspace = true
 tracing-subscriber.workspace = true
-nostr-sdk.workspace = true

desktop/Cargo.toml-E

@@ -1,51 +0,0 @@
-[package]
-name = "coop"
-version.workspace = true
-edition.workspace = true
-publish.workspace = true
-
-[[bin]]
-name = "coop"
-path = "src/main.rs"
-
-[package.metadata.packager]
-name = "Coop"
-product-name = "Coop"
-description = "Chat Freely, Stay Private on Nostr"
-identifier = "su.reya.coop"
-category = "SocialNetworking"
-version = "1.0.0-beta5"
-out-dir = "../dist"
-before-packaging-command = "cargo build --release"
-resources = ["Cargo.toml", "src"]
-icons = [
-    "resources/32x32.png",
-    "resources/128x128.png",
-    "resources/128x128@2x.png",
-    "resources/icon.icns",
-    "resources/icon.ico",
-]
-
-[dependencies]
-assets = { path = "../crates/assets" }
-workspace = { path = "../crates/workspace" }
-ui = { path = "../crates/ui" }
-theme = { path = "../crates/theme" }
-common = { path = "../crates/common" }
-state = { path = "../crates/state" }
-device = { path = "../crates/device" }
-chat = { path = "../crates/chat" }
-settings = { path = "../crates/settings" }
-auto_update = { path = "../crates/auto_update" }
-person = { path = "../crates/person" }
-
-gpui.workspace = true
-gpui_platform.workspace = true
-gpui_linux.workspace = true
-gpui_windows.workspace = true
-gpui_macos.workspace = true
-reqwest_client.workspace = true
-
-log.workspace = true
-tracing-subscriber.workspace = true
-nostr-sdk.workspace = true

desktop/src/main.rs

@@ -7,7 +7,6 @@ use gpui::{
     actions, point, px, size,
 };
 use gpui_platform::application;
-use nostr_sdk::prelude::SecretKey;
 use state::{APP_ID, CLIENT_NAME};
 use ui::Root;
 
@@ -17,14 +16,6 @@ fn main() {
     // Initialize logging
     tracing_subscriber::fmt::init();
 
-    // Parse CLI arguments for --sec <nsec1>
-    let cli_key = parse_cli_key();
-    if let Err(ref e) = cli_key {
-        eprintln!("Failed to parse --sec argument: {e}");
-        std::process::exit(1);
-    }
-    let cli_key = cli_key.unwrap();
-
     // Run application
     application()
         .with_assets(Assets)
@@ -33,9 +24,6 @@ fn main() {
             // Load embedded fonts in assets/fonts
             load_embedded_fonts(cx);
 
-            // Set app identity
-            cx.set_app_identity(APP_ID, CLIENT_NAME);
-
             // Register the `quit` function
             cx.on_action(quit);
 
@@ -55,7 +43,7 @@ fn main() {
             }]);
 
             // Set up the window bounds
-            let bounds = Bounds::centered(None, size(px(960.0), px(720.0)), cx);
+            let bounds = Bounds::centered(None, size(px(920.0), px(700.0)), cx);
 
             // Set up the window options
             let opts = WindowOptions {
@@ -74,6 +62,10 @@ fn main() {
 
             // Open a window with default options
             cx.open_window(opts, |window, cx| {
+                // Bring the app to the foreground
+                cx.activate(true);
+
+                cx.new(|cx| {
                     // Initialize components
                     ui::init(cx);
 
@@ -84,7 +76,7 @@ fn main() {
                     settings::init(window, cx);
 
                     // Initialize the nostr client
-                state::init(window, cx, cli_key);
+                    state::init(window, cx);
 
                     // Initialize person registry
                     person::init(window, cx);
@@ -100,13 +92,11 @@ fn main() {
                     // Initialize auto update
                     auto_update::init(window, cx);
 
-                // Root view
-                cx.new(|cx| Root::new(workspace::init(window, cx).into(), window, cx))
+                    // Root Entity
+                    Root::new(workspace::init(window, cx).into(), window, cx)
+                })
             })
             .expect("Failed to open window. Please restart the application.");
-
-            // Bring the app to the foreground
-            cx.activate(true);
         });
 }
 
@@ -134,25 +124,6 @@ fn load_embedded_fonts(cx: &App) {
         .unwrap();
 }
 
-fn parse_cli_key() -> Result<Option<SecretKey>, String> {
-    let args: Vec<String> = std::env::args().collect();
-    let mut i = 0;
-    while i < args.len() {
-        if args[i] == "--sec" {
-            if i + 1 < args.len() {
-                let nsec = &args[i + 1];
-                return SecretKey::parse(nsec)
-                    .map(Some)
-                    .map_err(|e| format!("Invalid nsec key '{nsec}': {e}"));
-            } else {
-                return Err("--sec requires a value (nsec1...)".to_string());
-            }
-        }
-        i += 1;
-    }
-    Ok(None)
-}
-
 fn quit(_ev: &Quit, cx: &mut App) {
     log::info!("Gracefully quitting the application . . .");
     cx.quit();

web/Cargo.toml

@@ -4,9 +4,6 @@ version.workspace = true
 edition.workspace = true
 publish.workspace = true
 
-[lib]
-crate-type = ["cdylib", "rlib"]
-
 [dependencies]
 workspace = { path = "../crates/workspace" }
 assets = { path = "../crates/assets" }
@@ -24,15 +21,14 @@ gpui_platform.workspace = true
 gpui_web = { git = "https://github.com/zed-industries/zed" }
 
 log.workspace = true
-instant = { workspace = true, features = ["wasm-bindgen"] }
 
 console_error_panic_hook = "0.1"
 tracing-wasm = "0.2"
 console_log = "1.0"
 wasm-bindgen = "0.2"
-universal-time = { git = "https://github.com/shadowylab/universal-time" }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom_0_2 = { package = "getrandom", version = "0.2", features = ["js"] }
 getrandom_0_3 = { package = "getrandom", version = "0.3", features = ["wasm_js"] }
 getrandom_0_4 = { package = "getrandom", version = "0.4", features = ["wasm_js"] }
+tokio = { version = "1", default-features = false, features = ["sync", "macros", "io-util", "rt", "time"] }

web/Makefile

@@ -38,7 +38,7 @@ preview: ## Preview production build
 clean: ## Clean build artifacts
 	@echo "Cleaning build artifacts..."
 	@rm -rf www/dist
-	@rm -rf www/wasm/*.js www/wasm/*.wasm
+	@rm -rf www/src/wasm/*.js www/src/wasm/*.wasm
 	@cargo clean
 
 watch-wasm: ## Watch Rust code changes and auto-rebuild WASM

web/script/build-wasm.sh

@@ -23,12 +23,7 @@ fi
 # macOS: ensure LLVM from Homebrew is available
 if [[ "$(uname)" == "Darwin" ]]; then
     echo -e "${GREEN}Detected macOS, setting up LLVM...${NC}"
-    if brew list llvm &>/dev/null; then
-        echo -e "${GREEN}LLVM already installed, skipping install${NC}"
-    else
-        echo -e "${YELLOW}LLVM not found, installing via Homebrew...${NC}"
     brew install llvm
-    fi
     LLVM_PATH=$(brew --prefix llvm)
     export AR="${LLVM_PATH}/bin/llvm-ar"
     export CC="${LLVM_PATH}/bin/clang"
@@ -38,8 +33,6 @@ fi
 # Step 1: Build WASM
 echo -e "${GREEN}Step 1: Building WASM...${NC}"
 cd "$PROJECT_ROOT"
-export CARGO_TARGET_DIR="$PROJECT_ROOT/target"
-RUSTFLAGS='-C target-feature=+bulk-memory -C link-arg=--max-memory=4294967296' \
 cargo build --target wasm32-unknown-unknown $RELEASE_FLAG
 
 # Determine the build directory
@@ -50,7 +43,8 @@ else
 fi
 
 # WASM file is in workspace target directory
-WASM_PATH="$PROJECT_ROOT/target/wasm32-unknown-unknown/$BUILD_MODE/coop_web.wasm"
+WORKSPACE_ROOT="$PROJECT_ROOT/../.."
+WASM_PATH="$WORKSPACE_ROOT/target/wasm32-unknown-unknown/$BUILD_MODE/coop_web.wasm"
 
 # Check if WASM file exists
 if [[ ! -f "$WASM_PATH" ]]; then
@@ -61,7 +55,7 @@ fi
 # Step 2: Generate JavaScript bindings
 echo -e "${GREEN}Step 2: Generating JavaScript bindings...${NC}"
 wasm-bindgen "$WASM_PATH" \
-    --out-dir "$PROJECT_ROOT/www/wasm" \
+    --out-dir "$PROJECT_ROOT/www/src/wasm" \
     --target web \
     --no-typescript
 

web/src/lib.rs

@@ -1,24 +1,7 @@
 use gpui::*;
 use ui::Root;
-use universal_time::{Instant, MonotonicClock, SystemTime, WallClock, define_time_provider};
 use wasm_bindgen::prelude::*;
 
-struct CustomTimeProvider;
-
-impl WallClock for CustomTimeProvider {
-    fn system_time(&self) -> SystemTime {
-        SystemTime::from_unix_duration(instant::Duration::from_secs(0))
-    }
-}
-
-impl MonotonicClock for CustomTimeProvider {
-    fn instant(&self) -> Instant {
-        Instant::from_ticks(instant::Duration::from_secs(0))
-    }
-}
-
-define_time_provider!(CustomTimeProvider);
-
 #[wasm_bindgen]
 pub fn run() -> Result<(), JsValue> {
     console_error_panic_hook::set_once();
@@ -32,23 +15,9 @@ pub fn run() -> Result<(), JsValue> {
     #[cfg(target_family = "wasm")]
     gpui_platform::web_init();
 
-    #[cfg(not(target_family = "wasm"))]
-    let app = gpui_platform::application();
-
-    #[cfg(target_family = "wasm")]
-    let app = {
-        let app = gpui_platform::single_threaded_web();
-
-        // Temporary fix: intentionally leak the `Rc<AppCell>` to keep the application alive
-        struct WasmApplication(std::rc::Rc<AppCell>);
-        let wasm_app = unsafe { std::mem::transmute::<Application, WasmApplication>(app) };
-        std::mem::forget(wasm_app.0.clone());
-        unsafe { std::mem::transmute::<WasmApplication, Application>(wasm_app) }
-    };
-
-    app.run(|cx| {
-        // Open the root window
+    gpui_platform::application().run(|cx| {
         cx.open_window(WindowOptions::default(), |window, cx| {
+            cx.new(|cx| {
                 // Initialize components
                 ui::init(cx);
 
@@ -59,7 +28,7 @@ pub fn run() -> Result<(), JsValue> {
                 settings::init(window, cx);
 
                 // Initialize the nostr client
-            state::init(window, cx, None);
+                state::init(window, cx);
 
                 // Initialize person registry
                 person::init(window, cx);
@@ -72,11 +41,11 @@ pub fn run() -> Result<(), JsValue> {
                 // Initialize app registry
                 chat::init(window, cx);
 
-            // Root view
-            cx.new(|cx| Root::new(workspace::init(window, cx).into(), window, cx))
+                // Root Entity
+                Root::new(workspace::init(window, cx).into(), window, cx)
+            })
         })
         .expect("Failed to open window. Please restart the application.");
-
         cx.activate(true);
     });
 

web/src/www/vite.config.js

@@ -1,4 +1,5 @@
 import { defineConfig } from "vite";
+import wasm from "vite-plugin-wasm";
 import { viteStaticCopy } from "vite-plugin-static-copy";
 import path from "path";
 import { fileURLToPath } from "url";
@@ -7,6 +8,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 export default defineConfig({
   plugins: [
+    wasm(),
     viteStaticCopy({
       targets: [
         {

web/www/deno.lock

@@ -1,396 +0,0 @@
-{
-  "version": "5",
-  "specifiers": {
-    "npm:vite-plugin-static-copy@^3.2.0": "3.4.0_vite@8.1.5",
-    "npm:vite-plugin-wasm@^3.3.0": "3.6.0_vite@8.1.5",
-    "npm:vite@8": "8.1.5"
-  },
-  "npm": {
-    "@emnapi/core@1.11.1": {
-      "integrity": "sha512-RSvbQmHzdKzNsLYa/wHrbc3KN4sYLKAdPZxqiM2HATqv/SBk2/ENSHpvXGaLOMcsAyz0poEGqkmmKYG3OWiJEQ==",
-      "dependencies": [
-        "@emnapi/wasi-threads",
-        "tslib"
-      ]
-    },
-    "@emnapi/runtime@1.11.1": {
-      "integrity": "sha512-vgj7R3y3Wgx24IQaGPA/R6YFXLHVMOZ0uVEyIQPaWs+rd1AzfEMXlAC22FYwO1XkKR6NPsq7mUandH8oIRdZFw==",
-      "dependencies": [
-        "tslib"
-      ]
-    },
-    "@emnapi/wasi-threads@1.2.2": {
-      "integrity": "sha512-c95qOXkHdydNKhscBTebqEC1CVAZpyqOfVfBzQ1qgzyl3gfeldUjIggDbIZgDKsHLgnsM+igH7TJ/eAasaVuMA==",
-      "dependencies": [
-        "tslib"
-      ]
-    },
-    "@napi-rs/wasm-runtime@1.1.6_@emnapi+core@1.11.1_@emnapi+runtime@1.11.1": {
-      "integrity": "sha512-ZLv/JdUfkvOy9eCnnBaGfiO+XimbjebAeO+MRQqD/B+FR1tnRN0tpKSJHRbE8sFfS6aqsXZ67TQjfwfsxULVbg==",
-      "dependencies": [
-        "@emnapi/core",
-        "@emnapi/runtime",
-        "@tybys/wasm-util"
-      ]
-    },
-    "@oxc-project/types@0.139.0": {
-      "integrity": "sha512-r9gHphtCs+1M7J0pw6Sn/hh/Wpa/iQrOOkrNAlVLF/gHq+/CJmHIWKKUUhdWjcD6CIa8idarspCsASiXCXvFUw=="
-    },
-    "@rolldown/binding-android-arm64@1.1.5": {
-      "integrity": "sha512-lZg8fqIv2v7FF237bwMgzGZEJvGL79/s5knJ/i6FmsGF4XXlzccZ4jb+TrFIxtSSxFtIpdsgrPZeMk1I9AFcyQ==",
-      "os": ["android"],
-      "cpu": ["arm64"]
-    },
-    "@rolldown/binding-darwin-arm64@1.1.5": {
-      "integrity": "sha512-51Bnx9pNiMRKSUNtBfySkNJ9vMU9Hh3I1ozDd6gyPPYzaXCfnptUcEZxXGYFn+ul2dtcMUiqGR1Yai2K10uoTw==",
-      "os": ["darwin"],
-      "cpu": ["arm64"]
-    },
-    "@rolldown/binding-darwin-x64@1.1.5": {
-      "integrity": "sha512-Tm+gbfC0aHu1tBA/JvKQh32S0K6YgCHkiAF4/W6xX0K0RmNuc94VeK419dJoE65R5aRxmo+noZQSWrAMF6yb6g==",
-      "os": ["darwin"],
-      "cpu": ["x64"]
-    },
-    "@rolldown/binding-freebsd-x64@1.1.5": {
-      "integrity": "sha512-JMzDKCCXq93YccG5gz3hvOs1oXRKAf0XYpfOS88e+wZrC8Iugj6j68867vrYZkvpDDpKn/KoKORThmchMpF6TA==",
-      "os": ["freebsd"],
-      "cpu": ["x64"]
-    },
-    "@rolldown/binding-linux-arm-gnueabihf@1.1.5": {
-      "integrity": "sha512-uML21j2K5TfPGutKxub+M+nLjZIrWjXQ5Grx4lCe/nimTj9B4L63zHpjXLl4y0L3mcm2htEQIb06oCG/szerNw==",
-      "os": ["linux"],
-      "cpu": ["arm"]
-    },
-    "@rolldown/binding-linux-arm64-gnu@1.1.5": {
-      "integrity": "sha512-navSiuTMogvnQoZoM/v+l3ZWo50/NTwSHSzheABx/RCnmUPaKwq9qSo4Br2OYRs21+Fz8uFqITZM3H4opOB0/Q==",
-      "os": ["linux"],
-      "cpu": ["arm64"]
-    },
-    "@rolldown/binding-linux-arm64-musl@1.1.5": {
-      "integrity": "sha512-lAryqH7IteztmCXQXk0etKj4wBQ7Gx5S6LjKhsgp9zb8I5bsuvU/2llH1hDQcjsFeqIsovMVN339/8pUDDBXxA==",
-      "os": ["linux"],
-      "cpu": ["arm64"]
-    },
-    "@rolldown/binding-linux-ppc64-gnu@1.1.5": {
-      "integrity": "sha512-fsK/sNBnxzBlL4O1JNrZakVQxPspqpED5dLtNsZS9oOKmtSpdNIzxH2kkol5HYTWJN47sE20ztMJPxfZ89qGOg==",
-      "os": ["linux"],
-      "cpu": ["ppc64"]
-    },
-    "@rolldown/binding-linux-s390x-gnu@1.1.5": {
-      "integrity": "sha512-gLYb4BIadlfTOYT5gO503n8zQjXflgzpD0FcyKh0Mzx3rqCZKnHoJWV9xe1KXUJ5lx2JfcSHr/mhzS0PC/McAA==",
-      "os": ["linux"],
-      "cpu": ["s390x"]
-    },
-    "@rolldown/binding-linux-x64-gnu@1.1.5": {
-      "integrity": "sha512-FjcpEKUyJygHgs1o50VYNvkt5+7Le/VEdYt0AkRpkL33MnyQfwr8l5mXwMmfmTbyMPr5vJLC+8/Gd9gXnwU1QQ==",
-      "os": ["linux"],
-      "cpu": ["x64"]
-    },
-    "@rolldown/binding-linux-x64-musl@1.1.5": {
-      "integrity": "sha512-Me+PfPI2TMeOQk0gYWfLQZtTktrmzbr8cDboqX83XKc7UrgAi55gF+2dUkWdxd19n55Essp2yeca+O9N5rBxHg==",
-      "os": ["linux"],
-      "cpu": ["x64"]
-    },
-    "@rolldown/binding-openharmony-arm64@1.1.5": {
-      "integrity": "sha512-yc5WrLzXks6zCQfn9Oxr8pORKyl/pF+QjHmW/Qx3qu0oyrrNC+y2JLTU1E2rcWYAmzlnqngWXHQjy51VzW70Vw==",
-      "os": ["openharmony"],
-      "cpu": ["arm64"]
-    },
-    "@rolldown/binding-wasm32-wasi@1.1.5": {
-      "integrity": "sha512-VbQGPX2b4r48TAMIM2cjgluIM1HYutm4pcTEJsle7iEP7sB1dFqtPLBVbdLAZCxy1txCcPxf4QFf4v8uvltPqA==",
-      "dependencies": [
-        "@emnapi/core",
-        "@emnapi/runtime",
-        "@napi-rs/wasm-runtime"
-      ],
-      "cpu": ["wasm32"]
-    },
-    "@rolldown/binding-win32-arm64-msvc@1.1.5": {
-      "integrity": "sha512-gHv82k63z4qpV5+Q1y/12KrK0ltWBukVDI8nZcbT7Tt/ZlOIVwppazneq0F93oDxTo3IgAMEDIoQh3E2n6mVsw==",
-      "os": ["win32"],
-      "cpu": ["arm64"]
-    },
-    "@rolldown/binding-win32-x64-msvc@1.1.5": {
-      "integrity": "sha512-tTZuDBPw85tEN5PQi1pnEBzDy0Z49HtScLAbD5t6hyeU92A95pRWaSMw1GZZi/RwgSgUIl0xrSlXIT/9QzvYSA==",
-      "os": ["win32"],
-      "cpu": ["x64"]
-    },
-    "@rolldown/pluginutils@1.0.1": {
-      "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw=="
-    },
-    "@tybys/wasm-util@0.10.3": {
-      "integrity": "sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg==",
-      "dependencies": [
-        "tslib"
-      ]
-    },
-    "anymatch@3.1.3": {
-      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
-      "dependencies": [
-        "normalize-path",
-        "picomatch@2.3.2"
-      ]
-    },
-    "binary-extensions@2.3.0": {
-      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw=="
-    },
-    "braces@3.0.3": {
-      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
-      "dependencies": [
-        "fill-range"
-      ]
-    },
-    "chokidar@3.6.0": {
-      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
-      "dependencies": [
-        "anymatch",
-        "braces",
-        "glob-parent",
-        "is-binary-path",
-        "is-glob",
-        "normalize-path",
-        "readdirp"
-      ],
-      "optionalDependencies": [
-        "fsevents"
-      ]
-    },
-    "detect-libc@2.1.2": {
-      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="
-    },
-    "fdir@6.5.0_picomatch@4.0.5": {
-      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
-      "dependencies": [
-        "picomatch@4.0.5"
-      ],
-      "optionalPeers": [
-        "picomatch@4.0.5"
-      ]
-    },
-    "fill-range@7.1.1": {
-      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
-      "dependencies": [
-        "to-regex-range"
-      ]
-    },
-    "fsevents@2.3.3": {
-      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
-      "os": ["darwin"],
-      "scripts": true
-    },
-    "glob-parent@5.1.2": {
-      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
-      "dependencies": [
-        "is-glob"
-      ]
-    },
-    "is-binary-path@2.1.0": {
-      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
-      "dependencies": [
-        "binary-extensions"
-      ]
-    },
-    "is-extglob@2.1.1": {
-      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="
-    },
-    "is-glob@4.0.3": {
-      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
-      "dependencies": [
-        "is-extglob"
-      ]
-    },
-    "is-number@7.0.0": {
-      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="
-    },
-    "lightningcss-android-arm64@1.33.0": {
-      "integrity": "sha512-gEpRTalKdosp4Bb8qWtc2iOgE5SeIHlpS1up9bFq2wAyYhl1UdTObYiHe98zEM9SQvSoqQZ1IQD0JNpg3Ml5pg==",
-      "os": ["android"],
-      "cpu": ["arm64"]
-    },
-    "lightningcss-darwin-arm64@1.33.0": {
-      "integrity": "sha512-Sciaz8eenNTKn9b3t7+xr0ipTp9YxKQY4npwQ3mrRuL0BAVHBLyZxofhaKBAVtzmtRZ/zTyo0/to4B1uWG/Djg==",
-      "os": ["darwin"],
-      "cpu": ["arm64"]
-    },
-    "lightningcss-darwin-x64@1.33.0": {
-      "integrity": "sha512-Z5UPAxzrjlWNNyGy6i65cJzzvgJ5D3T6wMvs+gWpY9d7qRhANrxqAp6LhxIgZhWEw18RfJTGcRxjuLIBr+m8XQ==",
-      "os": ["darwin"],
-      "cpu": ["x64"]
-    },
-    "lightningcss-freebsd-x64@1.33.0": {
-      "integrity": "sha512-QQM/Ti/hQajJwCY+RiWuCZ9sdtI/XQk7nDK5vC8kkdwixezOlDgvDx7+RT+QjK6FcFT4MpsuoBnHIo/O3StRRg==",
-      "os": ["freebsd"],
-      "cpu": ["x64"]
-    },
-    "lightningcss-linux-arm-gnueabihf@1.33.0": {
-      "integrity": "sha512-N7FVBe6iS24MlM6R/4RBTxGhQheZGs7tiQ9U32UtF75NzP5Q7xWPRqLBCKxlRQRk3rY1jCIPLzx7WzOhuUIRLQ==",
-      "os": ["linux"],
-      "cpu": ["arm"]
-    },
-    "lightningcss-linux-arm64-gnu@1.33.0": {
-      "integrity": "sha512-j2v/itmy4HlNxlc6voKXYgBqNi0Ng2LShg4z7GufpEgs05P+2suBVyi9I6YHq5uoVFx9ETin3eCEhLVyXGQnKg==",
-      "os": ["linux"],
-      "cpu": ["arm64"]
-    },
-    "lightningcss-linux-arm64-musl@1.33.0": {
-      "integrity": "sha512-yiO5ROMuYQgXbC60yjZU5CYSFZGKXL0HFATXt9mHJn1+zW55oCtMI9NfcVhYLMFDL7gV7oBPon/EmMMGg2OvtQ==",
-      "os": ["linux"],
-      "cpu": ["arm64"]
-    },
-    "lightningcss-linux-x64-gnu@1.33.0": {
-      "integrity": "sha512-ar+Ju7LmcN0Jo4FpL4hpFybwNG9/3A/Br5KW2n2jyODg3MEZXaDYADdemoNS+BDNfMgKvylJLj4S5tyRActuAg==",
-      "os": ["linux"],
-      "cpu": ["x64"]
-    },
-    "lightningcss-linux-x64-musl@1.33.0": {
-      "integrity": "sha512-RYiYbkokw0trfKqqzfF55lginwEPrD3OJDfTuJzFs1MK6iFnDenaz1fqLLtX4ITG3OktJQXOeTaw1awrBAlZPw==",
-      "os": ["linux"],
-      "cpu": ["x64"]
-    },
-    "lightningcss-win32-arm64-msvc@1.33.0": {
-      "integrity": "sha512-1K+MPfLSFVpphzpdbfkhlWk6wBrTObBzS2T6db10PNOZgR9GoVsAWzwNyuhUYYbTp23j+4RrncfujZ4uAzXvwA==",
-      "os": ["win32"],
-      "cpu": ["arm64"]
-    },
-    "lightningcss-win32-x64-msvc@1.33.0": {
-      "integrity": "sha512-OlEICDx/Xl0FqSp4bry8zFnCvGpig3Gl4gCquvYwHuqJKEC1+n9NgDniFvqHGmMv1ZkqDJrDqKKSykTDX+ehuA==",
-      "os": ["win32"],
-      "cpu": ["x64"]
-    },
-    "lightningcss@1.33.0": {
-      "integrity": "sha512-WkUDrojuJs0xkgGf2udWxa3yGBRxPtxUkB79i6aCZLRgc7PM8fZe9TosfPDcvEpQZbuFASnHYmRLBLUbmLOIIA==",
-      "dependencies": [
-        "detect-libc"
-      ],
-      "optionalDependencies": [
-        "lightningcss-android-arm64",
-        "lightningcss-darwin-arm64",
-        "lightningcss-darwin-x64",
-        "lightningcss-freebsd-x64",
-        "lightningcss-linux-arm-gnueabihf",
-        "lightningcss-linux-arm64-gnu",
-        "lightningcss-linux-arm64-musl",
-        "lightningcss-linux-x64-gnu",
-        "lightningcss-linux-x64-musl",
-        "lightningcss-win32-arm64-msvc",
-        "lightningcss-win32-x64-msvc"
-      ]
-    },
-    "nanoid@3.3.16": {
-      "integrity": "sha512-bzlKTyNJ7+LdGIIwy8ijFpIqEQIvafahV7eYykJ8Cvh42EdJeODoJ6gUJXpQJvej1BddH8OqTXZNE/KfbWAu8Q==",
-      "bin": true
-    },
-    "normalize-path@3.0.0": {
-      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA=="
-    },
-    "p-map@7.0.6": {
-      "integrity": "sha512-I4Prw6ivkd6p8PiYR1tXASOAOBzIJwu0TB7fqaX0c/8c3QAehNYmX57EijyGGGBt3c/BIowGwV03RVBtXvHEVg=="
-    },
-    "picocolors@1.1.1": {
-      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="
-    },
-    "picomatch@2.3.2": {
-      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="
-    },
-    "picomatch@4.0.5": {
-      "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A=="
-    },
-    "postcss@8.5.23": {
-      "integrity": "sha512-g50586zr4bZmwFiTlflMu8E0bDTb5I5gertgwAKmsdUlTQIhZtunzUlD1WSzwcVWPoAVpsrA6vlfCD7oXvRwgg==",
-      "dependencies": [
-        "nanoid",
-        "picocolors",
-        "source-map-js"
-      ]
-    },
-    "readdirp@3.6.0": {
-      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
-      "dependencies": [
-        "picomatch@2.3.2"
-      ]
-    },
-    "rolldown@1.1.5": {
-      "integrity": "sha512-t9z29cJjXf/vxQ8dyhCSpt6H6aSwHTk8cT5I3iy6SMXuFpk5mB6PL6XfC8PCwrPTx93udwKUm9HRteAlTGBLiA==",
-      "dependencies": [
-        "@oxc-project/types",
-        "@rolldown/pluginutils"
-      ],
-      "optionalDependencies": [
-        "@rolldown/binding-android-arm64",
-        "@rolldown/binding-darwin-arm64",
-        "@rolldown/binding-darwin-x64",
-        "@rolldown/binding-freebsd-x64",
-        "@rolldown/binding-linux-arm-gnueabihf",
-        "@rolldown/binding-linux-arm64-gnu",
-        "@rolldown/binding-linux-arm64-musl",
-        "@rolldown/binding-linux-ppc64-gnu",
-        "@rolldown/binding-linux-s390x-gnu",
-        "@rolldown/binding-linux-x64-gnu",
-        "@rolldown/binding-linux-x64-musl",
-        "@rolldown/binding-openharmony-arm64",
-        "@rolldown/binding-wasm32-wasi",
-        "@rolldown/binding-win32-arm64-msvc",
-        "@rolldown/binding-win32-x64-msvc"
-      ],
-      "bin": true
-    },
-    "source-map-js@1.2.1": {
-      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="
-    },
-    "tinyglobby@0.2.17": {
-      "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
-      "dependencies": [
-        "fdir",
-        "picomatch@4.0.5"
-      ]
-    },
-    "to-regex-range@5.0.1": {
-      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
-      "dependencies": [
-        "is-number"
-      ]
-    },
-    "tslib@2.8.1": {
-      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="
-    },
-    "vite-plugin-static-copy@3.4.0_vite@8.1.5": {
-      "integrity": "sha512-ekryzCw0ouAOE8tw4RvVL/dfqguXzumsV3FBKoKso4MQ1MUUrUXtl5RI4KpJQUNGqFEsg9kxl4EvDl02YtA9VQ==",
-      "dependencies": [
-        "chokidar",
-        "p-map",
-        "picocolors",
-        "tinyglobby",
-        "vite"
-      ]
-    },
-    "vite-plugin-wasm@3.6.0_vite@8.1.5": {
-      "integrity": "sha512-mL/QPziiIA4RAA6DkaZZzOstdwbW5jO4Vz7Zenj0wieKWBlNvIvX5L5ljum9lcUX0ShNfBgCNLKTjNkRVVqcsw==",
-      "dependencies": [
-        "vite"
-      ]
-    },
-    "vite@8.1.5": {
-      "integrity": "sha512-7ULLwsCdYx/nRyrpiEwvqb5TFHrMVZyBt+rg/OAXT7rgj/z+DtTDyKFeLAdDkubDVDKD8jOsndmy7m55XcfUsw==",
-      "dependencies": [
-        "lightningcss",
-        "picomatch@4.0.5",
-        "postcss",
-        "rolldown",
-        "tinyglobby"
-      ],
-      "optionalDependencies": [
-        "fsevents"
-      ],
-      "bin": true
-    }
-  },
-  "workspace": {
-    "packageJson": {
-      "dependencies": [
-        "npm:vite-plugin-static-copy@^3.2.0",
-        "npm:vite-plugin-wasm@^3.3.0",
-        "npm:vite@8"
-      ]
-    }
-  }
-}