fix

.github/workflows/release.yml

@@ -152,23 +152,11 @@ jobs:
           echo "Artifacts structure:"
           find artifacts -type f -exec ls -la {} \;
 
-      - name: Generate SHA256SUMS
-        run: |
-          # One `<sha256>  <path>` line per artifact. The in-app updater reads
-          # this to verify a download before installing it, so it must be
-          # published alongside every release. Written outside the directory
-          # being hashed so the checksums file never includes itself.
-          find artifacts -type f ! -name SHA256SUMS -print0 \
-            | sort -z \
-            | xargs -0 sha256sum > SHA256SUMS.raw
-          mv SHA256SUMS.raw artifacts/SHA256SUMS
-          cat artifacts/SHA256SUMS
-
       - name: Create draft release
         id: create_release
         uses: akkuman/gitea-release-action@v1
         with:
-          server_url: "https://git.reya.info/"
+          server_url: "https://git.reya.su/"
           repository: "reya/coop"
           token: ${{ secrets.GITEA_TOKEN }}
           draft: true

AGENTS.md

@@ -1,150 +0,0 @@
-# Rust coding guidelines
-
-* Prioritize code correctness and clarity. Speed and efficiency are secondary priorities unless otherwise specified.
-* Do not write organizational or comments that summarize the code. Comments should only be written in order to explain "why" the code is written in some way in the case there is a reason that is tricky / non-obvious.
-* Prefer implementing functionality in existing files unless it is a new logical component. Avoid creating many small files.
-* Avoid using functions that panic like `unwrap()`, instead use mechanisms like `?` to propagate errors.
-* Be careful with operations like indexing which may panic if the indexes are out of bounds.
-* Never silently discard errors with `let _ =` on fallible operations. Always handle errors appropriately:
-  - Propagate errors with `?` when the calling function should handle them
-  - Use `.log_err()` or similar when you need to ignore errors but want visibility
-  - Use explicit error handling with `match` or `if let Err(...)` when you need custom logic
-  - Example: avoid `let _ = client.request(...).await?;` - use `client.request(...).await?;` instead
-* When implementing async operations that may fail, ensure errors propagate to the UI layer so users get meaningful feedback.
-* Avoid creative additions unless explicitly requested
-* Use full words for variable names (no abbreviations like "q" for "queue")
-* Use variable shadowing to scope clones in async contexts for clarity, minimizing the lifetime of borrowed references.
-  Example:
-  ```rust
-  executor.spawn({
-      let task_ran = task_ran.clone();
-      async move {
-          *task_ran.borrow_mut() = true;
-      }
-  });
-  ```
-
-# Timers in tests
-
-* In GPUI tests, prefer GPUI executor timers over `smol::Timer::after(...)` when you need timeouts, delays, or to drive `run_until_parked()`:
-  - Use `cx.background_executor().timer(duration).await` (or `cx.background_executor.timer(duration).await` in `TestAppContext`) so the work is scheduled on GPUI's dispatcher.
-  - Avoid `smol::Timer::after(...)` for test timeouts when you rely on `run_until_parked()`, because it may not be tracked by GPUI's scheduler and can lead to "nothing left to run" when pumping.
-
-# GPUI
-
-GPUI is a UI framework which also provides primitives for state and concurrency management.
-
-## Context
-
-Context types allow interaction with global state, windows, entities, and system services. They are typically passed to functions as the argument named `cx`. When a function takes callbacks they come after the `cx` parameter.
-
-* `App` is the root context type, providing access to global state and read and update of entities.
-* `Context<T>` is provided when updating an `Entity<T>`. This context dereferences into `App`, so functions which take `&App` can also take `&Context<T>`.
-* `AsyncApp` and `AsyncWindowContext` are provided by `cx.spawn` and `cx.spawn_in`. These can be held across await points.
-
-## `Window`
-
-`Window` provides access to the state of an application window. It is passed to functions as an argument named `window` and comes before `cx` when present. It is used for managing focus, dispatching actions, directly drawing, getting user input state, etc.
-
-## Entities
-
-An `Entity<T>` is a handle to state of type `T`. With `thing: Entity<T>`:
-
-* `thing.entity_id()` returns `EntityId`
-* `thing.downgrade()` returns `WeakEntity<T>`
-* `thing.read(cx: &App)` returns `&T`.
-* `thing.read_with(cx, |thing: &T, cx: &App| ...)` returns the closure's return value.
-* `thing.update(cx, |thing: &mut T, cx: &mut Context<T>| ...)` allows the closure to mutate the state, and provides a `Context<T>` for interacting with the entity. It returns the closure's return value.
-* `thing.update_in(cx, |thing: &mut T, window: &mut Window, cx: &mut Context<T>| ...)` takes a `AsyncWindowContext` or `VisualTestContext`. It's the same as `update` while also providing the `Window`.
-
-Within the closures, the inner `cx` provided to the closure must be used instead of the outer `cx` to avoid issues with multiple borrows.
-
-Trying to update an entity while it's already being updated must be avoided as this will cause a panic.
-
-`WeakEntity<T>` is a weak handle. It has `read_with`, `update`, and `update_in` methods that work the same, but always return an `anyhow::Result` so that they can fail if the entity no longer exists. This can be useful to avoid memory leaks - if entities have mutually recursive handles to each other they will never be dropped.
-
-## Concurrency
-
-All use of entities and UI rendering occurs on a single foreground thread.
-
-`cx.spawn(async move |cx| ...)` runs an async closure on the foreground thread. Within the closure, `cx` is `&mut AsyncApp`.
-
-When the outer cx is a `Context<T>`, the use of `spawn` instead looks like `cx.spawn(async move |this, cx| ...)`, where `this: WeakEntity<T>` and `cx: &mut AsyncApp`.
-
-To do work on other threads, `cx.background_spawn(async move { ... })` is used. Often this background task is awaited on by a foreground task which uses the results to update state.
-
-Both `cx.spawn` and `cx.background_spawn` return a `Task<R>`, which is a future that can be awaited upon. If this task is dropped, then its work is cancelled. To prevent this one of the following must be done:
-
-* Awaiting the task in some other async context.
-* Detaching the task via `task.detach()` or `task.detach_and_log_err(cx)`, allowing it to run indefinitely.
-* Storing the task in a field, if the work should be halted when the struct is dropped.
-
-A task which doesn't do anything but provide a value can be created with `Task::ready(value)`.
-
-## Elements
-
-The `Render` trait is used to render some state into an element tree that is laid out using flexbox layout. An `Entity<T>` where `T` implements `Render` is sometimes called a "view".
-
-Example:
-
-```
-struct TextWithBorder(SharedString);
-
-impl Render for TextWithBorder {
-    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        div().border_1().child(self.0.clone())
-    }
-}
-```
-
-Since `impl IntoElement for SharedString` exists, it can be used as an argument to `child`. `SharedString` is used to avoid copying strings, and is either an `&'static str` or `Arc<str>`.
-
-UI components that are constructed just to be turned into elements can instead implement the `RenderOnce` trait, which is similar to `Render`, but its `render` method takes ownership of `self` and receives `&mut App` instead of `&mut Context<Self>`. Types that implement this trait can use `#[derive(IntoElement)]` to use them directly as children.
-
-The style methods on elements are similar to those used by Tailwind CSS.
-
-If some attributes or children of an element tree are conditional, `.when(condition, |this| ...)` can be used to run the closure only when `condition` is true. Similarly, `.when_some(option, |this, value| ...)` runs the closure when the `Option` has a value.
-
-## Input events
-
-Input event handlers can be registered on an element via methods like `.on_click(|event, window, cx: &mut App| ...)`.
-
-Often event handlers will want to update the entity that's in the current `Context<T>`. The `cx.listener` method provides this - its use looks like `.on_click(cx.listener(|this: &mut T, event, window, cx: &mut Context<T>| ...)`.
-
-## Actions
-
-Actions are dispatched via user keyboard interaction or in code via `window.dispatch_action(SomeAction.boxed_clone(), cx)` or `focus_handle.dispatch_action(&SomeAction, window, cx)`.
-
-Actions with no data are defined with the `actions!(some_namespace, [SomeAction, AnotherAction])` macro call. Otherwise the `Action` derive macro is used. Doc comments on actions are displayed to the user.
-
-Action handlers can be registered on an element via the event handler `.on_action(|action, window, cx| ...)`. Like other event handlers, this is often used with `cx.listener`.
-
-## Notify
-
-When a view's state has changed in a way that may affect its rendering, it should call `cx.notify()`. This will cause the view to be rerendered. It will also cause any observe callbacks registered for the entity with `cx.observe` to be called.
-
-## Entity events
-
-While updating an entity (`cx: Context<T>`), it can emit an event using `cx.emit(event)`. Entities register which events they can emit by declaring `impl EventEmitter<EventType> for EntityType {}`.
-
-Other entities can then register a callback to handle these events by doing `cx.subscribe(other_entity, |this, other_entity, event, cx| ...)`. This will return a `Subscription` which deregisters the callback when dropped.  Typically `cx.subscribe` happens when creating a new entity and the subscriptions are stored in a `_subscriptions: Vec<Subscription>` field.
-
-# Pull request hygiene
-
-When an agent opens or updates a pull request, it must:
-
-- Use a clear, correctly capitalized, imperative PR title (for example, `fix crash in project panel`).
-- Avoid conventional commit prefixes in PR titles (`fix:`, `feat:`, `docs:`, etc.).
-- Avoid trailing punctuation in PR titles.
-- Optionally prefix the title with a crate name when one crate is the clear scope (for example, `workspace: add history view`).
-- Include a `Release Notes:` section as the final section in the PR body.
-- Use one bullet under `Release Notes:`:
-  - `- Added ...`, `- Fixed ...`, or `- Improved ...` for user-facing changes, or
-  - `- N/A` for docs-only and other non-user-facing changes.
-- Format release notes exactly with a blank line after the heading, for example:
-
-```
-Release Notes:
-
-- N/A
-```

Cargo.toml

@@ -4,7 +4,7 @@ members = ["crates/*", "desktop", "web"]
 default-members = ["desktop"]
 
 [workspace.package]
-version = "1.0.2"
+version = "1.0.0"
 edition = "2024"
 publish = false
 
@@ -27,11 +27,6 @@ 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" ] }
 
-# Crypto (NIP-17 encrypted file messages)
-aes-gcm = "0.10"
-sha2 = "0.10"
-data-encoding = "2"
-
 # Others
 anyhow = "1.0.44"
 chrono = { version = "0.4.38", features = ["wasmbind"] }
@@ -48,9 +43,7 @@ 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"
-ureq = { version = "3", default-features = false, features = ["rustls", "platform-verifier", "json"] }
 
 [patch.crates-io]
 # Use stacker's psm version which may have better WASM support

PLAN.md

@@ -1,560 +0,0 @@
-# Concord support — backend & API plan
-
-Concord is an encrypted community/channel protocol over Nostr: shared-key "Private Streams" (CORD-01), communities with a self-certifying owner id and three planes (CORD-02), public/private channels (CORD-03), an owner-rooted signed roster (CORD-04), invites (CORD-05), rekeys/refoundings (CORD-06) and disappearing messages (CORD-08).
-
-Scope of this plan: **backend + public Rust API**. No views, no widgets, no copy.
-
-## 1. Scope
-
-**In scope**
-
-- New `crates/concord` crate: derivations, stream codec, control/chat/guestbook planes, authority fold, ephemeral state, invites, rekeys, dissolution, storage, sync engine.
-- Public API for a future UI: `ConcordRegistry` + `Entity<Community>` / `Entity<Channel>` + events, mirroring the shape of `crates/chat`.
-- The minimum surgical edits to existing crates required for coexistence (see §11).
-
-**Out of scope**
-
-- Any UI work.
-- CORD-07 audio/video. Reserve `23313`, the `concord/voice-*` labels and the `voice` metadata flag so nothing else claims them, and implement nothing.
-- Pins (CORD-04 §7) ship in the last milestone; the design accounts for `vsk 11` early so the fold is not retrofitted.
-- Cross-client interop testing (Vector/Armada/Grimoire). Tracked as follow-up work, not blocking.
-
-## 2. Sources of truth
-
-| Doc | What we take from it |
-| --- | --- |
-| CORD-01 | Stream event shape, seal forms 20013/20014, encoding rules, binding, deletions |
-| CORD-02 | `community_id`, `community_root`, `control_root`, epochs, 3 planes, metadata, invites, Community List, dissolution |
-| CORD-03 | Channel keying, metadata, message kinds, `channel`/`epoch` binding, threads vs quotes |
-| CORD-04 | Editions, `vac`, the roster, permission bits, banlist, the three removals, pins |
-| CORD-05 | Bundle, link (naddr + fragment), relay dictionary, Invite List, Registry, Direct Invite |
-| CORD-06 | Rekey blobs, chunking, `prevcommit` continuity, Refounding, compaction, races |
-| CORD-08 | `message_expiration`, NIP-40 tagging, ingest/purge enforcement, timer notice 1740 |
-
-Appendix A (derivations) and Appendix B (kinds) of CORD-02 are **frozen**: every labeled byte and every kind number is part of the wire format. Treat both as constants with golden-vector tests.
-
-Reference implementations for cross-checking behaviour (not for copying code): Vector (`crates/vector-core/src/community/v2/*`), Armada, Grimoire.
-
-## 3. Reuse map — nostr-sdk APIs we build on
-
-Verified against the pinned revision (`nostr` 0.45.4 / `nostr-sdk` 0.45.2, git `b230cec`).
-
-| Concord need | Existing API |
-| --- | --- |
-| NIP-44 under a raw conversation key | `nostr::nips::nip44::v2::{ConversationKey, encrypt_to_bytes_with_nonce, decrypt_to_bytes}` |
-| NIP-44 conversation key for a keypair | `ConversationKey::derive(&SecretKey, &PublicKey)` (self-ECDH for streams) |
-| NIP-44 under a signer | `nip44::{encrypt, decrypt}` (already wrapped by `state::UniversalSigner`) |
-| Event id recomputation | `EventId::compute(pubkey, created_at, kind, tags, content)`, `UnsignedEvent::compute_id` |
-| Event (de)serialization | `Event::{from_json, as_json, verify}`, `UnsignedEvent::from_json` |
-| Building events | `EventBuilder::new(..).tags(..).custom_created_at(..)`, `FinalizeEvent::finalize(&Keys)` |
-| Tags | `Tag::{custom, identifier, public_key, expiration}`, `Tags`, `SingleLetterTag` |
-| Kinds | `Kind::GiftWrap` (1059), `Kind::Custom(21059|20013|20014|3308|…)`, `Kind::is_ephemeral` |
-| Publish | `Client::send_event(&event).to(relays).ack_policy(AckPolicy::none())` |
-| Subscribe | `Client::subscribe(target).with_id(..).close_on(..)`, `SubscribeAutoCloseOptions`, `ReqExitPolicy` |
-| Backfill | `Client::fetch_events(target)`, `Client::stream_events(target)` |
-| Local persistence | `Client::database()` → `query(Filter)`, `save_event(&Event)` |
-| Invite link parsing | `Nip19::from_bech32` → `Nip19::Coordinate(Nip19Coordinate)` |
-| Signer abstraction | `state::UniversalSigner` (`AsyncSignEvent` + `AsyncNip44`) |
-| Relay auth | `nostr_sdk::{Authenticator, SignerAuthenticator}` |
-
-**Not needed.** `secp256k1` (use `nostr::SecretKey::from_slice` + `Keys::new`), `base64` (use `data_encoding::BASE64`, already a workspace dep), `bech32` (NIP-19 is in the SDK), any new storage engine (the client's LMDB database is enough), any new HTTP client.
-
-**Add one dependency:** `hkdf = "0.12"` (already in `Cargo.lock` transitively). Add it to `[workspace.dependencies]` and to the new crate. `sha2` is already a workspace dep.
-
-## 4. Crate layout
-
-New crate `crates/concord`, picked up automatically by the `crates/*` workspace member glob.
-
-```
-crates/concord/
-  Cargo.toml
-  src/lib.rs        init, ConcordRegistry, ConcordEvent, signal bus, subscriptions, ingest pipeline
-  src/derive.rs     frozen HKDF / group_key / locators / commitments + golden vectors
-  src/stream.rs     CORD-01: seal + wrap + open (SealForm, OpenedStream), channel/epoch binding
-  src/edition.rs    CORD-04 §1: canonical signing bytes, edition hash, parse, fold
-  src/control.rs    control plane view, genesis, content types, roster fold, authority checks
-  src/guestbook.rs  CORD-02 §5: join/leave/kick/snapshot, coalesce, complete memberlist
-  src/chat.rs       CORD-03: channel plane — message/edit/delete/reaction builders + message view
-  src/invite.rs     CORD-05: bundle, link, registry, Invite List, Direct Invite
-  src/rekey.rs      CORD-06: blob codec, continuity, refounding, compaction, dissolution
-  src/store.rs      local persistence + opened-rumor cache + history queries
-```
-
-`Community` and `Channel` GPUI entities live in `src/lib.rs` next to the registry — they are the public surface, not a separate concern. Ten modules, each with real content; no single-fn files.
-
-Dependencies: `common`, `state`, `person`, `device`, `settings`, `gpui`, `nostr` (for `nip44` features), `nostr-sdk`, `hkdf`, `sha2`, `serde`, `serde_json`, `anyhow`, `flume`, `smallvec`, `itertools`, `futures`, `log`, `instant`. Everything under `cfg(not(target_arch = "wasm32"))` follows the `chat`/`state` split so the crate still builds for web.
-
-## 5. Core types
-
-```rust
-pub struct CommunityId([u8; 32]);   // sha256 commitment, never on the wire
-pub struct ChannelId([u8; 32]);
-pub struct Epoch(pub u64);
-
-/// A derived stream: signing keypair + the self-ECDH conversation key that
-/// encrypts the wraps. Memoised in a bounded process-wide cache.
-pub struct GroupKey { keys: Keys, conversation: ConversationKey }
-impl GroupKey {
-    pub fn pk(&self) -> PublicKey;
-    pub fn keys(&self) -> &Keys;
-    pub fn conversation(&self) -> &ConversationKey;
-}
-
-pub enum SealForm { Encrypted, Plaintext }
-
-pub struct OpenedStream {
-    pub rumor_id: EventId,
-    pub author: PublicKey,      // the seal's verified pubkey
-    pub seal_form: SealForm,
-    pub seal: Event,            // retained: compaction re-wraps plaintext seals verbatim
-    pub wrapper_id: EventId,
-    pub at_ms: u64,             // created_at * 1000 + ms tag
-    pub rumor: UnsignedEvent,
-}
-```
-
-Ordering everywhere uses `at_ms`, never `created_at`, and ties break on the lower inner rumor id.
-
-## 6. Frozen derivations (`derive.rs`)
-
-```rust
-fn build_info(label: &str, id: &[u8; 32], epoch: Option<u64>) -> Vec<u8>;   // label ‖ 0x00 ‖ id[32] ‖ epoch_be[8]?
-fn hkdf32(ikm: &[u8], info: &[u8]) -> [u8; 32];                            // HKDF-SHA256, zero-length salt, L = 32
-fn hkdf_to_secret_key(ikm: &[u8], info: &[u8]) -> SecretKey;                // A.3 scalar_normalize, counter from 0
-
-fn group_key(label: &str, secret: &[u8], id: &[u8; 32], epoch: Option<u64>) -> GroupKey;
-
-pub fn channel_group_key(secret: &[u8; 32], channel: &ChannelId, epoch: Epoch) -> GroupKey;
-pub fn control_group_key(root: &[u8; 32], id: &CommunityId, epoch: Epoch) -> GroupKey;      // read key
-pub fn control_signer_group_key(root: &[u8; 32], id: &CommunityId, epoch: Epoch) -> GroupKey; // write key
-pub fn guestbook_group_key(root: &[u8; 32], id: &CommunityId, epoch: Epoch) -> GroupKey;
-pub fn channel_rekey_group_key(root: &[u8; 32], channel: &ChannelId, epoch: Epoch) -> GroupKey;
-pub fn base_rekey_group_key(root: &[u8; 32], id: &CommunityId, epoch: Epoch) -> GroupKey;
-pub fn dissolved_group_key(id: &CommunityId) -> GroupKey;                                   // no epoch field
-
-pub fn community_id_of(owner_xonly: &[u8; 32], owner_salt: &[u8; 32]) -> CommunityId;        // plain SHA-256
-pub fn epoch_key_commitment(epoch: Epoch, key: &[u8; 32]) -> [u8; 32];                       // plain SHA-256
-pub fn grant_locator(id: &CommunityId, member: &[u8; 32]) -> [u8; 32];
-pub fn banlist_locator(id: &CommunityId) -> [u8; 32];
-pub fn pins_locator(id: &CommunityId, channel: &ChannelId) -> [u8; 32];
-pub fn invite_links_locator(id: &CommunityId, creator: &[u8; 32]) -> [u8; 32];
-pub fn recipient_locator(rotator: &[u8; 32], recipient: &[u8; 32], scope: &[u8; 32], epoch: Epoch) -> [u8; 32];
-pub fn invite_bundle_key(token: &[u8; 16]) -> [u8; 32];   // raw hkdf32 output; used as a NIP-44 conversation key
-```
-
-Rules that must be enforced by construction, not by convention:
-
-- Hex is lowercase everywhere; pubkeys are x-only hex, never bech32; tag numbers are decimal with no leading zeros (`"4"`, never `04`/`+4`).
-- The epoch field is *omitted*, not zeroed, for labels with no epoch (`concord/dissolved`, locators, `concord/community`).
-- `scalar_normalize` retries by appending a counter byte to the same `info`, starting at `0`.
-- Labels and commitments are append-only. A test asserts every label is unique and that the label table matches Appendix A.6 exactly.
-
-**Golden vectors.** `derive.rs` carries a `#[cfg(test)]` block pinning every derivation output, seeded from the independent Python vectors published by the Vector implementation (channel/control/control-signer/guestbook at epoch 0 and at `0x0102030405060708`, dissolved, all four locators, invite key, community id, epoch commitment). One vector is missing upstream — `pins_locator` — so we mint it from our own implementation and pin it, flagged in the test as self-referential. Changing any pinned value means the wire format changed.
-
-## 7. Stream codec (`stream.rs`)
-
-```rust
-pub const KIND_WRAP: u16 = 1059;
-pub const KIND_WRAP_EPHEMERAL: u16 = 21059;
-pub const KIND_SEAL_ENCRYPTED: u16 = 20013;
-pub const KIND_SEAL_PLAINTEXT: u16 = 20014;
-pub const NIP44_MAX_PLAINTEXT: usize = 65_535;
-
-pub fn seal_content(rumor: &UnsignedEvent, form: SealForm, group: &GroupKey) -> Result<String, StreamError>;
-pub fn build_seal(rumor: &UnsignedEvent, form: SealForm, group: &GroupKey, author: &Keys) -> Result<Event, StreamError>;
-pub fn wrap_seal(seal: &Event, group: &GroupKey, wrap_kind: u16, at: Timestamp, extra: &[Tag]) -> Result<(Event, Keys), StreamError>;
-
-pub fn open_wrap(wrap: &Event, group: &GroupKey) -> Result<OpenedStream, StreamError>;
-pub fn open_wrap_at(wrap: &Event, address: &PublicKey, conversation: &ConversationKey, verify_wrap_sig: bool) -> Result<OpenedStream, StreamError>;
-
-pub fn channel_binding_tags(channel: &ChannelId, epoch: Epoch) -> Vec<Tag>;
-pub fn check_channel_binding(rumor: &UnsignedEvent, channel: &ChannelId, epoch: Epoch) -> Result<(), StreamError>;
-pub fn build_rumor(kind: u16, author: PublicKey, content: &str, tags: Vec<Tag>, at_ms: u64) -> UnsignedEvent;  // appends ["ms", n]
-pub fn resolve_ms_strict(rumor: &UnsignedEvent) -> Result<u64, StreamError>;
-```
-
-Design points that are easy to get wrong:
-
-- The wrap is signed by the **stream key** with a random ephemeral `p` tag — NIP-59 reversed. `extra` is how the caller mirrors a NIP-40 expiration onto the wrap.
-- The seal is signed by the **real author** and carries `created_at` equal to the rumor's. It is never published bare.
-- Control plane **must** use the plaintext seal; chat, guestbook and rekey planes **must** use the encrypted one. Each plane asserts its own form at both ends.
-- The control plane is a write-restricted stream: the wrap key derives from `control_root` while the content is encrypted under the `community_root`-derived conversation key. `open_wrap_at` takes the two halves separately for this reason.
-- Open order: kind → address match → wrap signature (only when `verify_wrap_sig`) → NIP-44 open → seal kind → seal signature → rumor parse → `rumor.pubkey == seal.pubkey` → recompute the rumor id and reject a mismatch → strict `ms` resolve.
-- Enforce the 65 535-byte NIP-44 cap at every nesting layer before publishing.
-- Do not verify the wrap signature for ordinary planes: every reader holds the group key, so the signature proves nothing. It matters only for the restricted control plane and for rekeys.
-- The ephemeral wrap keypair is returned to the caller so a client may NIP-09-scrub its own wrap later.
-
-## 8. Planes, state and folds
-
-### 8.1 Editions and authority (`edition.rs`, `control.rs`)
-
-```rust
-pub const EDITION_LABEL: &[u8] = b"vector-community/v1/edition";   // frozen, cross-client
-
-pub fn edition_hash(entity: &[u8; 32], version: u64, prev: Option<&[u8; 32]>, content: &[u8]) -> [u8; 32];
-pub struct ParsedEdition { author: PublicKey, vsk: String, entity: [u8; 32], version: u64,
-                           prev: Option<[u8; 32]>, content: String, self_hash: [u8; 32] };
-pub fn parse_edition(rumor: &UnsignedEvent) -> Result<ParsedEdition, EditionError>;
-
-pub struct FoldResult { pub head: Option<usize>, pub gap: bool, pub anchored: bool }
-pub fn fold(editions: &[EditionMeta], floor: u64, floor_hash: Option<&[u8; 32]>) -> FoldResult;
-pub fn bootstrap_head(editions: &[EditionMeta], floor: u64) -> Option<usize>;
-```
-
-- Tag grammar: `["vsk", sub]`, `["eid", hex32]`, `["ev", decimal]`, `["ep", hex32]`, `["vac", eid, version, hash]`. Duplicates of any of the five reject the edition; `ev` must pass a decimal check before parsing.
-- Tie-break at equal version is the lower **inner rumor id**, never `created_at`.
-- `gap` is a safety signal: a tracking client (already holds the floor) fails closed for that entity and refetches; a bootstrapping client (floor 0) may accept the highest authority-verified head, which is what makes compaction re-wrapping work.
-- Entity coordinates are `vsk 0` → `community_id`, `1` → `role_id`, `2` → `channel_id`, `3` → `grant_locator`, `4` → `banlist_locator`, `8` → `invite_links_locator`, `11` → `pins_locator`. All derive from `community_id` only, so a refounding re-wraps heads verbatim.
-
-```rust
-pub const P_MANAGE_ROLES: u64 = 1 << 0;   // …bit table from CORD-04 §3, frozen; retired bits are burned
-pub struct CommunityRoles { roles: BTreeMap<[u8; 32], Role>, grants: BTreeMap<PublicKey, Grant> }
-impl CommunityRoles {
-    pub fn permissions_of(&self, member: &PublicKey) -> u64;   // union of role bits
-    pub fn position_of(&self, member: &PublicKey, owner: &PublicKey) -> u32;
-    pub fn is_authorized(&self, actor: &PublicKey, owner: &PublicKey, bit: u64) -> bool;
-    pub fn is_authorized_in(&self, actor: &PublicKey, owner: &PublicKey, channel: &ChannelId, bit: u64) -> bool;
-    pub fn outranks(&self, actor: &PublicKey, owner: &PublicKey, target_position: u32) -> bool;
-    pub fn can_act_on(&self, actor: &PublicKey, owner: &PublicKey, target: &PublicKey, bit: u64) -> bool;
-    pub fn is_staff(&self, member: &PublicKey, owner: &PublicKey) -> bool;   // the six control bits, CORD-04 §3
-}
-```
-
-Authority rules to encode once and test hard:
-
-- The owner is position 0, derived from `community_id`, and is never removable.
-- No edition may claim a `position` at or above its own signer's, including the owner: no Role may claim 0.
-- The actor must hold the required bit **and strictly outrank** the target. Equal cannot act on equal.
-- A `vac` citation is a sync floor, not a verdict: block until the cited Grant version is folded, verify its hash, then judge against the *current* roster.
-- A staff-making Grant carries `control_wrap`, a NIP-44 pairwise ciphertext of `epoch_be[8] ‖ control_root[32]`, and is adopted **only if it derives to the `control_pk` the member already holds** for the named epoch.
-- Banlist is one replaced entity; mutations carry a re-heal step (re-fold after publish, re-apply if the addition lost the tiebreak).
-
-### 8.2 Communities, channels, metadata
-
-`CommunityMetadata` carries `name` (≤ 64 bytes), `description` (≤ 10 000 bytes), `relays` (truncated on read and write to 5), `icon` and `banner` as encrypted-blob pointers (`{url, key, nonce, hash}`), `message_expiration`, and the optional `custom` object. `ChannelMetadata` carries `name`, `private`, optional `voice`, `deleted`, optional `custom`.
-
-Every content struct uses `#[serde(flatten)] extra: serde_json::Map<String, Value>` and round-trips unknown fields. A name edit by an older client must not wipe another client's `custom` keys. Round-trip discipline gets its own test.
-
-Channel keying follows CORD-03 §1: a public channel derives from `community_root` at the base epoch, a private one from its own random key at its own epoch. Public→private is a rekey at the next channel epoch (monotonic, never reset); private→public derives from the base again and the prior private history stays unreadable to later joiners.
-
-### 8.3 Guestbook and member list (`guestbook.rs`)
-
-```rust
-pub enum GuestbookEntry {
-    Join  { member: PublicKey, at_ms: u64, invited_by: Option<(String, String)> },
-    Leave { member: PublicKey, at_ms: u64 },
-    Kick  { actor: PublicKey, target: PublicKey, at_ms: u64, citation: Option<AuthorityCitation> },
-    Snapshot { refounder: PublicKey, members: Vec<PublicKey>, snapshot_id: [u8; 32], chunk: (u32, u32), at_ms: u64 },
-}
-
-pub fn coalesce(events: &[GuestbookEvent], now_ms: u64, snapshot_authority: Option<&PublicKey>,
-                can_kick: impl Fn(&PublicKey, &PublicKey, Option<&AuthorityCitation>) -> bool)
-    -> BTreeMap<PublicKey, MemberState>;
-
-pub fn complete_memberlist(coalesced: &BTreeMap<PublicKey, MemberState>,
-                           observed: &BTreeMap<PublicKey, u64>,          // author → newest ms published
-                           banned: &BTreeSet<PublicKey>, banned_at: &BTreeMap<PublicKey, u64>,
-                           refound: Option<&Refound>) -> BTreeSet<PublicKey>;
-```
-
-- Entries dated more than an hour ahead of local time are dropped. An `ms` outside `0..999` drops the entry rather than being interpreted.
-- Coalesce is per npub, one final state each, by millisecond time, ties on the lower inner rumor id.
-- A Kick counts only when its signer holds `KICK` and outranks the target.
-- A Snapshot counts only from the npub whose Refounding minted the epoch. There is deliberately no owner fallback.
-- The member list is `coalesced Joined ∪ observed authors − banlist`, and observation counts **forward only** (an author re-enters on activity newer than their latest Leave/Kick/Ban). A Grant holder with `ms == 0` is present by construction.
-
-### 8.4 Chat plane (`chat.rs`)
-
-```rust
-pub struct ChatMessage {
-    pub id: EventId,               // recomputed rumor id
-    pub author: PublicKey,
-    pub channel: ChannelId,
-    pub epoch: Epoch,
-    pub kind: Kind,                // 9 | 1111 | 3302 | 1740 | 15
-    pub content: String,
-    pub media: Vec<SharedUri>,
-    pub mentions: Vec<Mention>,
-    pub reply_to: Option<EventId>, // lowercase `e`/`q`
-    pub thread_root: Option<EventId>, // uppercase `E` for 1111
-    pub at_ms: u64,
-    pub expiration: Option<Timestamp>,
-    pub edited_at: Option<u64>,    // folded from 3302
-    pub deleted: bool,             // folded from 5
-    pub reactions: BTreeMap<PublicKey, String>,
-}
-```
-
-Sends funnel through one function so the rules cannot drift:
-
-```rust
-fn publish_chat(store, client, community, channel, epoch, group, rumor, at_ms, ephemeral) -> Task<Result<Output<EventId, EventSendStatus>, Error>>;
-```
-
-It builds the seal + wrap, mirrors the NIP-40 tag onto the wrap for durable kinds, publishes via `send_event(..).to(relays)`, retains the ephemeral wrap key for later NIP-09 scrubbing, and locally echoes its own wrap through the same ingest path so send-then-read works without waiting on a relay round-trip.
-
-Disappearing messages (CORD-08) live here: `message_expiration` is read from the folded metadata, `["expiration", created_at + t]` is attached to every durable Chat rumor and to the wrap, kinds 5 and 1740 are exempt, ingest refuses an already-expired rumor, a periodic sweep purges stored ones, and the kind 1740 timer notice renders only when its author holds `MANAGE_METADATA`.
-
-### 8.5 Invites (`invite.rs`)
-
-```rust
-pub struct CommunityInvite { community_id, owner, owner_salt, community_root, root_epoch,
-                             control_pk: Option<String>, channels: Vec<ChannelGrant>,
-                             relays: Vec<String>, name: String, icon: Option<ImageRef>,
-                             expires_at: Option<u64>, creator_npub: Option<String>, label: Option<String>,
-                             extra: Map<String, Value> }
-impl CommunityInvite { pub fn validate(&self) -> Result<(), InviteError>;   // recompute community_id
-                       pub fn expired(&self, now_ms: u64) -> bool; }
-
-pub fn build_bundle(token: &[u8; 16], link_signer: &Keys, invite: &CommunityInvite) -> Result<Event, InviteError>; // 33301, d = ""
-pub fn build_revocation(link_signer: &Keys) -> Result<Event, InviteError>;                                        // vsk 9
-pub fn parse_link(input: &str) -> Result<ParsedInviteLink, InviteError>;
-pub fn encode_fragment(relays: &[RelayUrl], token: &[u8; 16]) -> String;   // version byte 4, flags, ≤ 3 relays, base64url
-pub fn decode_fragment(fragment: &str) -> Result<(Vec<RelayUrl>, [u8; 16]), InviteError>;
-pub fn build_direct_invite(receiver: &PublicKey, invite: &CommunityInvite, signer: &UniversalSigner) -> Task<Result<Event, Error>>; // 3313 rumor → 13 seal → k-tagged 1059
-```
-
-The link rides `naddr` (`Nip19Coordinate` for kind 33301, link signer, empty `d`) in the path and the token + bootstrap relays in the fragment. A fragment is never sent to a server. The bundle is decrypted with `invite_bundle_key(token)`, and the joiner must recompute `community_id` from `owner` + `owner_salt`.
-
-Bounds before allocation: reject a bundle with more than 256 channels, truncate the relay list to 5, refuse an expired one.
-
-### 8.6 Rekeys and refoundings (`rekey.rs`)
-
-```rust
-pub enum RekeyScope { Channel(ChannelId), Base }
-pub fn encode_blob_plaintext(scope, epoch, new_root, control_pk, control_root) -> Vec<u8>;   // 72 | 104 | 136 bytes
-pub fn parse_blob_plaintext(bytes: &[u8], scope, epoch) -> Result<KeyDelivery, RekeyError>;
-pub fn build_rekey_rumor(rotator, scope, new_epoch, prev_epoch, prev_commit, blobs, chunk) -> UnsignedEvent;
-pub fn plan_refounding(fold, removed: &[PublicKey]) -> Result<Refounding, RekeyError>;
-pub fn compact(fold, epoch, new_control_root, ...) -> Vec<Event>;   // re-wrap heads verbatim, plaintext seals preserved
-```
-
-- The subscription for rekeys is precomputed from the *next* epoch's address, per private channel and once for the base.
-- A receiver accepts a key only after: locating its blob, decrypting with the rotator↔recipient conversation key, checking the bound `scope` and `epoch` inside the plaintext, and matching `prevcommit` against the key it currently holds.
-- Only after holding **all** `n` chunks of one `(rotator, newepoch, prevcommit)` set, with none containing its locator, may a client conclude it was removed.
-- Send cap 80 blobs per event, accept cap 120 (Vector's documented erratum: the CORD-01 double envelope pushes 120 blobs past a 64 KB relay limit). Record the reason in a comment so nobody "fixes" it back.
-- Compacted control heads are re-wrapped with their original signature intact, which is exactly why the control plane uses the plaintext seal.
-- Two concurrent refoundings converge on the lexicographically lowest new base key; the heal is down-only.
-- Authority: a channel rekey needs `MANAGE_CHANNELS`, a refounding needs `BAN`, and in both the rotator must strictly outrank every removed target. Holding a key is never authority.
-
-Dissolution (CORD-02 §9) also lives here: a chainless, owner-signed `vsk 10` tombstone at `dissolved_group_key(id)`, plaintext-sealed, and a verifier **must** refuse any tombstone whose `eid` is not the community's own id (including the all-zero placeholder — accepting it lets an owner's genuine tombstone for one community be re-wrapped at another of theirs and kill it permanently). On sight the community is sealed read-only: subscriptions halt, nothing new is honored, existing history stays readable, and a member's delete of their own message is still honored.
-
-## 9. Storage (`store.rs`)
-
-Three layers, no new storage engine:
-
-1. **Raw wraps** (kind 1059) are persisted automatically by the SDK's relay pool when a subscription or fetch matches a filter. Nothing to write.
-2. **Opened rumors** are cached locally as NIP-78 `Kind::ApplicationSpecificData` events signed by a session-local keypair, exactly like `chat::set_rumor`. Tags: `["d", rumor_id]` (replace key), `["c", channel_hex]`, `["p", author]`, `["k", kind]`, `["e", wrap_id]`, `["t", "concord"]`. Contents are the rumor JSON.
-   - The `c`/`t` keys deliberately differ from chat's `r` key so the two message namespaces can never collide in one database.
-   - The read path dedupes by rumor id and keeps the newest `created_at`, because the local signing key changes per session.
-3. **Community state** — one local document per community, `Kind::ApplicationSpecificData` with `["d", "concord/<community_id>"]`:
-
-```rust
-pub struct CommunityState {
-    pub id: CommunityId,
-    pub owner: PublicKey,
-    pub owner_salt: [u8; 32],
-    pub community_root: [u8; 32],
-    pub root_epoch: Epoch,
-    pub control_root: Option<[u8; 32]>,       // present iff the holder is staff
-    pub control_pks: BTreeMap<Epoch, PublicKey>,
-    pub channels: Vec<ChannelKeyRef>,          // id, key, epoch, name, private
-    pub epoch_keys: Vec<([u8; 32], Epoch, [u8; 32])>,  // (scope, epoch, key) — the history backfill index
-    pub relays: Vec<RelayUrl>,
-    pub heads: BTreeMap<[u8; 32], (u64, [u8; 32], EventId)>,  // entity → (version, self_hash, inner id)
-    pub guestbook: Vec<GuestbookEvent>,
-    pub observed: BTreeMap<PublicKey, u64>,
-    pub banned: BTreeSet<PublicKey>,
-    pub dissolved: bool,
-    pub added_at_ms: u64,
-}
-```
-
-Writes are debounced (a fold head changes on every edition); reads load once at init.
-
-**Decision, stated for the record:** this document stores raw community keys unencrypted in a plaintext local database. That matches the existing posture — `chat` already caches decrypted message rumors in the same LMDB. If that posture ever changes, the state document is the one to wrap with NIP-44-to-self, since it is the only local artifact holding keys.
-
-History queries:
-
-```rust
-pub async fn query_messages(&self, channel: &ChannelId, until: Option<Timestamp>, limit: usize) -> Result<Vec<Event>, Error>;
-pub async fn backfill(&self, plane_authors: &[PublicKey], relays: &[RelayUrl], until: Option<Timestamp>, limit: usize) -> Result<Vec<Event>, Error>;
-```
-
-`query_messages` reads the local cache (`Filter::new().kind(ApplicationSpecificData).custom_tag(LOWERCASE_C, channel_hex)`); `backfill` pages relays newest-first with `until`, deduplicating by wrap id and stepping past same-second walls.
-
-## 10. Sync engine and GPUI conventions
-
-`ConcordRegistry` mirrors `ChatRegistry`'s shape exactly: a foreground GPUI entity holding `Entity<Community>` handles, a `flume` signal bus, one background notification listener, one foreground consumer, and task slots that are cleared when the signer changes.
-
-**Subscription.** Community relays come from the folded metadata. `init`/`join` add them to the client (`client.add_relay(url).and_connect()`), then:
-
-```rust
-let filter = Filter::new()
-    .kinds([Kind::GiftWrap, Kind::Custom(KIND_WRAP_EPHEMERAL)])
-    .authors(plane_authors)          // guestbook, control signer, all held channel planes,
-                                     // rekey addresses for epoch + 1, dissolved address
-    .since(Timestamp::from_secs(now - FRESH_WINDOW))
-    .limit(0);                       // live tail only; history comes from backfill
-client.subscribe(target).with_id(SubscriptionId::new(CONCORD_SUB)).await?;
-```
-
-Targeted subscribe against the community relays, with a pool-wide subscribe as the fallback path. Rebuild idempotently whenever a plane's address changes (join, channel added, rekey folded).
-
-**Routing.** `dispatch` matches on the `subscription_id` carried in `RelayMessage::Event`, dedupes by wrap id (both subscriptions and several relays deliver the same wrap), then recognises the plane by **wrap author** against the derived addresses it holds — never by trial decryption. Recognition order: held channel planes → guestbook → control signer → rekey addresses → dissolved.
-
-**Ingest pipeline.** Unwrap, verify and fold all happen inside `cx.background_spawn`, never on the foreground thread: secp256k1 verification per edition and per seal is far too expensive for the UI thread.
-
-```rust
-enum Signal {
-    Chat { community: CommunityId, channel: ChannelId, message: Box<ChatMessage> },
-    Control { community: CommunityId, heads: Vec<EntityHead>, roster: Box<FoldedRoster> },
-    Guestbook { community: CommunityId, members: BTreeSet<PublicKey> },
-    Rekey { community: CommunityId, scope: RekeyScope, epoch: Epoch },
-    Dissolved(CommunityId),
-    Eose(SubscriptionId),
-    Error(ConcordError),
-}
-```
-
-The consumer is `cx.spawn(async move |this, cx| { while let Ok(signal) = rx.recv_async().await { this.update(cx, |this, cx| this.apply(signal, cx))?; } })`, which updates entities and calls `cx.notify()`.
-
-Rules taken from the project guidelines:
-
-- Crypto, folding, database queries and network I/O only in `cx.background_spawn`.
-- Foreground tasks are `cx.spawn` with `this.update(cx, ..)`; any entity update happens there, and the inner `cx` is always used.
-- Tasks are stored in fields (`tasks`, `listener`, `consumer`) so they are cancelled on signer change and dropped with the registry. `detach()` only for genuinely fire-and-forget work such as the local state save.
-- Long-running paging is bounded by explicit page and step caps, not by unbounded loops.
-- Every fallible path returns `Result` and surfaces through `ConcordEvent::Error`; nothing is silently swallowed.
-
-**Registry API.**
-
-```rust
-pub fn init(window: &mut Window, cx: &mut App);
-pub struct ConcordRegistry { /* … */ }
-impl ConcordRegistry {
-    pub fn global(cx: &App) -> Entity<Self>;
-    pub fn loading(&self) -> bool;
-    pub fn communities(&self) -> Vec<Entity<Community>>;
-    pub fn community(&self, id: &CommunityId, cx: &App) -> Option<WeakEntity<Community>>;
-    pub fn find(&self, query: &str, cx: &App) -> Vec<Entity<Community>>;
-
-    pub fn create(&mut self, params: CommunityParams, cx: &mut Context<Self>) -> Task<Result<CommunityId, Error>>;
-    pub fn join(&mut self, link: &str, cx: &mut Context<Self>) -> Task<Result<CommunityId, Error>>;
-    pub fn accept_direct_invite(&mut self, rumor: &UnsignedEvent, cx: &mut Context<Self>) -> Task<Result<CommunityId, Error>>;
-    pub fn leave(&mut self, id: &CommunityId, cx: &mut Context<Self>);
-    pub fn discard_invite(&mut self, id: &CommunityId, cx: &mut Context<Self>);
-    pub fn refresh(&mut self, id: &CommunityId, cx: &mut Context<Self>);
-    pub fn shutdown(&mut self, cx: &mut Context<Self>);   // halt subscriptions, keep our own state
-}
-```
-
-**Community API** (`Entity<Community>`, `EventEmitter<CommunityEvent>`):
-
-```rust
-pub fn id(&self) -> CommunityId;
-pub fn owner(&self) -> PublicKey;
-pub fn name(&self) -> SharedString;  pub fn description(&self) -> Option<SharedString>;
-pub fn icon(&self) -> Option<ImageRef>;
-pub fn relays(&self) -> Vec<RelayUrl>;
-pub fn epoch(&self) -> Epoch;
-pub fn dissolved(&self) -> bool;
-pub fn channels(&self) -> Vec<Entity<Channel>>;
-pub fn channel(&self, id: &ChannelId, cx: &App) -> Option<WeakEntity<Channel>>;
-pub fn members(&self) -> BTreeSet<PublicKey>;
-pub fn banned(&self) -> BTreeSet<PublicKey>;
-pub fn roles(&self) -> &CommunityRoles;
-pub fn permissions(&self, member: &PublicKey) -> u64;
-pub fn is_staff(&self, member: &PublicKey) -> bool;
-pub fn message_expiration(&self) -> Option<u64>;
-
-// authority actions — each returns a publish task and nothing optimistic
-pub fn set_metadata(&mut self, meta: CommunityMetadata, cx: &mut Context<Self>) -> Task<Result<(), Error>>;
-pub fn create_channel(&mut self, name: &str, private: bool, cx: &mut Context<Self>) -> Task<Result<ChannelId, Error>>;
-pub fn edit_channel(&mut self, id: &ChannelId, meta: ChannelMetadata, cx: &mut Context<Self>) -> Task<Result<(), Error>>;
-pub fn create_role(&mut self, role: Role, cx: &mut Context<Self>) -> Task<Result<(), Error>>;
-pub fn assign_roles(&mut self, member: &PublicKey, roles: &[[u8; 32]], cx: &mut Context<Self>) -> Task<Result<(), Error>>;
-pub fn ban(&mut self, members: &[PublicKey], cx: &mut Context<Self>) -> Task<Result<(), Error>>;
-pub fn unban(&mut self, members: &[PublicKey], cx: &mut Context<Self>) -> Task<Result<(), Error>>;
-pub fn kick(&mut self, member: &PublicKey, cx: &mut Context<Self>) -> Task<Result<(), Error>>;
-pub fn rekey_channel(&mut self, id: &ChannelId, removed: &[PublicKey], cx: &mut Context<Self>) -> Task<Result<(), Error>>;
-pub fn refound(&mut self, removed: &[PublicKey], cx: &mut Context<Self>) -> Task<Result<(), Error>>;
-pub fn dissolve(&mut self, cx: &mut Context<Self>) -> Task<Result<(), Error>>;
-pub fn create_invite(&mut self, params: InviteParams, cx: &mut Context<Self>) -> Task<Result<String, Error>>;
-pub fn revoke_invite(&mut self, token: &[u8; 16], cx: &mut Context<Self>) -> Task<Result<(), Error>>;
-pub fn direct_invite(&mut self, receiver: &PublicKey, cx: &mut Context<Self>) -> Task<Result<(), Error>>;
-pub fn save_community_list(&mut self, cx: &mut Context<Self>) -> Task<Result<(), Error>>;   // kind 13302, multi-device sync
-```
-
-**Channel API** (`Entity<Channel>`): `id`, `name`, `private`, `epoch`, `deleted`, plus
-
-```rust
-pub fn messages(&self, until: Option<Timestamp>, limit: usize, cx: &App) -> Task<Result<Vec<ChatMessage>, Error>>;
-pub fn send(&self, content: &str, reply_to: Option<EventId>, cx: &App) -> Task<Result<Output<EventId, EventSendStatus>, Error>>;
-pub fn send_file(&self, file: FileAttachment, reply_to: Option<EventId>, cx: &App) -> Task<Result<Output<EventId, EventSendStatus>, Error>>;
-pub fn edit(&self, id: EventId, content: &str, cx: &App) -> Task<Result<Output<EventId, EventSendStatus>, Error>>;
-pub fn delete(&self, id: EventId, cx: &App) -> Task<Result<Output<EventId, EventSendStatus>, Error>>;
-pub fn react(&self, id: EventId, emoji: &str, cx: &App) -> Task<Result<Output<EventId, EventSendStatus>, Error>>;
-pub fn typing(&self, cx: &App) -> Task<Result<(), Error>>;          // kind 23311, ephemeral
-pub fn pin(&self, id: EventId, cx: &App) -> Task<Result<(), Error>>; // vsk 11, PIN_MESSAGES
-```
-
-`CommunityEvent` and `ChannelEvent` mirror `ChatEvent`: one variant per thing the UI has to react to (`Updated`, `Members`, `Added`, `Removed`, `Dissolved`, `Error`, plus channel-level `Incoming`, `Reload`).
-
-## 11. Integration with existing crates
-
-1. **`crates/chat/src/lib.rs` — required fix.** `handle_notifications` currently treats *every* kind 1059 event as a NIP-17 wrap for the current user and pushes an unwrap failure into the trash. Concord wraps are kind 1059 with an ephemeral `p` tag, so they would flood the trash and leak error toasts. Route by `subscription_id` from `RelayMessage::Event` against `sub_id1`/`sub_id2`, and drop the `if rumor.tags.is_empty()` heuristic once the real recipient check is in place.
-2. **`desktop/src/main.rs` and `web/src/lib.rs`** — add `concord::init(window, cx)` after `chat::init(window, cx)`.
-3. **`Cargo.toml`** — add `hkdf = "0.12"` to `[workspace.dependencies]`; add the crate to `desktop` and `web` dependencies. No other workspace changes.
-4. **No changes** to `state`, `person`, `device`, `settings`, `common`, or `ui`.
-
-## 12. Security invariants to test, not to assume
-
-Each of these has burned a real implementation, or is a documented cross-client trap:
-
-- Recompute every rumor id and reject a claimed mismatch; never trust an embedded `id`.
-- Require `rumor.pubkey == seal.pubkey`.
-- Require the plaintext seal form on Control and the encrypted form on Chat/Guestbook/Rekey — a strict reader must drop a mis-sealed edition rather than fold a chain a later compaction would fork.
-- Check `channel` **and** `epoch` against the plane whose key opened the wrap; reject duplicates of either tag.
-- Reject duplicate `vsk`/`eid`/`ev`/`ep`/`vac` tags; require decimal-with-no-leading-zeros on every numeric tag.
-- Refuse a tombstone whose `eid` is not this community's id.
-- Adopt a `control_root` from a Grant only if it derives to the `control_pk` held for that epoch; adopt a rekey blob only if its bound plaintext matches the scope and epoch and its `prevcommit` matches the key currently held.
-- Never conclude removal from a partial rekey chunk set.
-- Drop guestbook entries more than an hour in the future; treat an out-of-range `ms` as malformed, not as an interpretation opportunity.
-- Never honour a Snapshot from anyone but the refounder of that epoch.
-- Refuse to write a Pin List from a list the writer could not read.
-- Enforce the NIP-44 65 535-byte cap at every layer before publishing, and the 5-relay / 256-channel / 50-membership / 100-roles / 64-roles-per-member / 500-banlist / 25-pin caps at their ingest and write points.
-- Lowercase hex only; x-only pubkeys only; no version tag anywhere.
-
-## 13. Milestones
-
-| # | Deliverable | Done when |
-| --- | --- | --- |
-| M0 | Crate skeleton, `derive.rs`, golden vectors, workspace wiring | `cargo test -p concord` pins every derivation from an independent vector set; all labels match Appendix A.6 |
-| M1 | `stream.rs` + `store.rs` | seal/wrap/open round-trips for both seal forms; malformed inputs rejected in the documented order; local cache reads back after a restart |
-| M2 | `edition.rs` + `control.rs` genesis | a community is created and published; its two genesis wraps open at a second client sharing the keys; edition hash matches the cross-client vector |
-| M3 | Control fold + roster + metadata/channels | fold tests for chains, gaps, downgrade refusal, fork tiebreak, compaction dangle; metadata and channel edits visible to a second client |
-| M4 | Chat plane | send/receive/edit/delete/reaction across two identities; history pages backwards across an epoch boundary; binding checks reject a foreign channel/epoch |
-| M5 | Guestbook + member list + moderation | join/leave/kick/ban converge to the same memberlist on both clients; every authority rule from §8.1 has a negative test |
-| M6 | Invites + Community List | link mint → fetch → join round-trips; revoked link refuses; direct invite lands in the recipient's giftwrap inbox via the `k` tag; a second device reconstructs membership from 13302 |
-| M7 | Rekeys + refounding + dissolution | a removed member stops reading after a rekey; continuity and race rules tested; a tombstone seals the community and a foreign-id tombstone is refused |
-| M8 | Pins + disappearing messages + hardening | pins verify from a keyless reader's view; expiry is refused at ingest and purged by the sweep; the audit of §12 is complete with a test per bullet |
-
-Ordering is deliberately dependency-first: each milestone is usable on its own, and nothing in M2+ depends on a later milestone.
-
-## 14. Open questions and risks
-
-1. **Community List kind.** CORD-02 §8 specifies `13302`, replaceable. Vector has retired it in favour of fragmented `33302`, because a replaceable kind holds one event per pubkey and so cannot shard past the NIP-44 size cap. We implement `13302` per spec, enforce the 50-membership cap and pre-publish size check, and treat `33302` as an interop follow-up. Confirm with Armada before writing the multi-device code.
-2. **NIP-42 for stream-authored REQs.** Relays that gate kind 1059 by author (for example `ditto-relay`'s `AUTH_KINDS`) need an AUTH event signed by that plane's derived key. `nostr-sdk`'s `Authenticator` is per-client and returns one identity, while a Concord client holds many plane keys — so this cannot be solved by swapping the authenticator. Options: contribute a per-REQ auth hook upstream, or accept that such relays are unsupported and prefer relays without the gate. Decide before M7; the default is "documented limitation" plus a relay-capability check.
-3. **`invite_bundle_key`.** Appendix A.6 says the label "yields the public-invite decrypt key" without stating whether that is the raw HKDF output used as a NIP-44 conversation key or the `conv_key` of a normalized keypair. The reference implementation uses the raw output. Pin a vector and verify against Armada early — this one decides whether links open at all.
-4. **Missing golden vector for `pins_locator`.** Upstream publishes none. Ours will be self-referential; flag it in the test.
-5. **Relay set.** Up to 5 recommended, and both reads and writes fan out across them. Coop's client is a gossip client with `no_background_refresh`, so community relays must be added explicitly and re-added on metadata change.
-6. **Local plaintext state.** §9 records the decision. Revisit only if the local database stops being treated as trusted.
-7. **Was a `community_id` ever hashed into a tag?** No — it must never appear on the wire. A lint-style test should assert it appears in no published event other than inside an invite bundle and a direct invite.
-
-## 15. Test strategy
-
-- **Unit, pure:** derivations against golden vectors, edition hash, fold, coalesce, memberlist, blob codec, caps and rejection paths. These need no GPUI context and should be exhaustive — they are where cross-client divergence is caught.
-- **Integration, GPUI:** `TestAppContext` with two registries sharing an in-memory database, driving wraps through the ingest path; timeouts and delays use `cx.background_executor().timer(..)` per the project guidelines, never `smol::Timer`.
-- **Round-trip:** every builder paired with its parser, asserting the parse produces the identical structure, including unknown-field round-tripping on all content types.
-- **Negative:** every bullet in §12 gets a test that constructs the hostile input and asserts the drop.

assets/icons/lock.svg

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
-<path d="M12 8.75003C11.1716 8.75003 10.5 9.4216 10.5 10.25C10.5 11.0785 11.1716 11.75 12 11.75C12.8284 11.75 13.5 11.0785 13.5 10.25C13.5 9.4216 12.8284 8.75003 12 8.75003ZM12 8.75003V14.75M20.25 11.9124V6.94155C20.25 6.08069 19.6991 5.31641 18.8825 5.04418L12.6325 2.96085C12.2219 2.824 11.7781 2.824 11.3675 2.96085L5.11754 5.04418C4.30086 5.31641 3.75 6.08069 3.75 6.94155V11.9124C3.75 16.8848 8 19.25 12 21.4079C16 19.25 20.25 16.8848 20.25 11.9124Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
-</svg>

assets/themes/aurora.json

@@ -2,7 +2,7 @@
   "id": "aurora",
   "name": "Aurora",
   "author": "Coop",
-  "url": "https://coopchat.xyz",
+  "url": "https://github.com/lumehq/coop",
   "light": {
     "background": "#fdfcfeff",
     "surface_background": "#f8f8ffff",

assets/themes/forest.json

@@ -2,7 +2,7 @@
   "id": "forest",
   "name": "Forest",
   "author": "Coop",
-  "url": "https://coopchat.xyz",
+  "url": "https://github.com/lumehq/coop",
   "light": {
     "background": "#fbfefcff",
     "surface_background": "#f4fbf6ff",

assets/themes/ocean.json

@@ -2,7 +2,7 @@
   "id": "ocean",
   "name": "Ocean",
   "author": "Coop",
-  "url": "https://coopchat.xyz",
+  "url": "https://github.com/lumehq/coop",
   "light": {
     "background": "#fafefeff",
     "surface_background": "#f2fbfaff",

crates/assets/Cargo.toml

@@ -8,4 +8,12 @@ publish.workspace = true
 gpui.workspace = true
 anyhow.workspace = true
 log.workspace = true
+
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
 rust-embed.workspace = true
+
+[target.'cfg(target_family = "wasm")'.dependencies]
+futures.workspace = true
+reqwest = { version = "0.12", default-features = false }
+wasm-bindgen-futures = "0.4"
+web-sys = { version = "0.3", features = ["Window", "Location"] }

crates/assets/build.rs

@@ -0,0 +1,58 @@
+//! Generates a compile-time manifest of the asset files served on wasm, so
+//! the web entrypoint can preload them before the first frame.
+//!
+//! `WASM_ASSETS` is emitted into `OUT_DIR` and included by
+//! `src/wasm_assets.rs` on wasm targets. Native builds keep using
+//! `rust-embed` and ignore it.
+
+use std::path::Path;
+use std::{env, fs};
+
+fn main() {
+    let manifest_dir = env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR not set by cargo");
+    let assets_dir = Path::new(&manifest_dir).join("../../assets");
+
+    let mut paths = Vec::new();
+    for dir in ["icons", "brand"] {
+        let dir_path = assets_dir.join(dir);
+        let entries = fs::read_dir(&dir_path).unwrap_or_else(|error| {
+            panic!(
+                "expected asset directory {} to exist: {error}",
+                dir_path.display()
+            )
+        });
+
+        for entry in entries {
+            let entry = entry.expect("failed to read asset directory entry");
+            if entry.file_type().is_ok_and(|t| t.is_file()) {
+                let name = entry.file_name().to_string_lossy().into_owned();
+                if !name.starts_with('.') {
+                    paths.push(format!("{dir}/{name}"));
+                }
+            }
+        }
+    }
+    paths.sort();
+
+    let manifest = format!(
+        "/// Asset files served by the wasm asset loader. Generated by build.rs.\npub const WASM_ASSETS: &[&str] = &[\n{}\n];\n",
+        paths
+            .iter()
+            .map(|path| format!("    \"{path}\","))
+            .collect::<Vec<_>>()
+            .join("\n")
+    );
+
+    let out_dir = env::var("OUT_DIR").expect("OUT_DIR not set by cargo");
+    fs::write(Path::new(&out_dir).join("wasm_assets.rs"), manifest)
+        .expect("failed to write wasm asset manifest");
+
+    // Rerun when the asset files change (adding/removing files updates the
+    // directory mtime).
+    for dir in ["icons", "brand"] {
+        if let Ok(canonical) = assets_dir.join(dir).canonicalize() {
+            println!("cargo:rerun-if-changed={}", canonical.display());
+        }
+    }
+    println!("cargo:rerun-if-changed=build.rs");
+}

crates/assets/src/lib.rs

@@ -1,51 +1,19 @@
-use anyhow::Context;
-use gpui::{App, AssetSource, Result, SharedString};
-use rust_embed::RustEmbed;
+//! Application assets for Coop.
+//!
+//! ## Platform differences
+//!
+//! - **Native (desktop)**: assets are embedded into the binary at compile time
+//!   with `rust-embed`.
+//! - **WASM (web)**: assets are downloaded on demand from `{endpoint}/assets/{path}`
+//!   and cached in memory. This keeps the WASM bundle size small.
 
-#[derive(RustEmbed)]
-#[folder = "../../assets"]
-#[include = "fonts/**/*"]
-#[include = "brand/**/*"]
-#[include = "icons/**/*"]
-#[include = "themes/**/*"]
-#[exclude = "*.DS_Store"]
-pub struct Assets;
+#[cfg(not(target_family = "wasm"))]
+mod native_assets;
 
-impl AssetSource for Assets {
-    fn load(&self, path: &str) -> Result<Option<std::borrow::Cow<'static, [u8]>>> {
-        Self::get(path)
-            .map(|f| Some(f.data))
-            .with_context(|| format!("loading asset at path {path:?}"))
-    }
+#[cfg(target_family = "wasm")]
+mod wasm_assets;
 
-    fn list(&self, path: &str) -> Result<Vec<SharedString>> {
-        Ok(Self::iter()
-            .filter_map(|p| {
-                if p.starts_with(path) {
-                    Some(p.into())
-                } else {
-                    None
-                }
-            })
-            .collect())
-    }
-}
-
-impl Assets {
-    /// Populate the [`TextSystem`] of the given [`AppContext`] with all `.ttf` fonts in the `fonts` directory.
-    pub fn load_fonts(&self, cx: &App) -> anyhow::Result<()> {
-        let font_paths = self.list("fonts")?;
-        let mut embedded_fonts = Vec::new();
-        for font_path in font_paths {
-            if font_path.ends_with(".ttf") {
-                let font_bytes = cx
-                    .asset_source()
-                    .load(&font_path)?
-                    .expect("Assets should never return None");
-                embedded_fonts.push(font_bytes);
-            }
-        }
-
-        cx.text_system().add_fonts(embedded_fonts)
-    }
-}
+#[cfg(not(target_family = "wasm"))]
+pub use native_assets::Assets;
+#[cfg(target_family = "wasm")]
+pub use wasm_assets::Assets;

crates/assets/src/native_assets.rs

@@ -0,0 +1,63 @@
+use std::borrow::Cow;
+
+use anyhow::Context;
+use gpui::{App, AssetSource, Result, SharedString};
+use rust_embed::RustEmbed;
+
+/// Native implementation using `rust-embed`: assets are embedded into the
+/// binary at compile time.
+#[derive(RustEmbed)]
+#[folder = "../../assets"]
+#[include = "fonts/**/*"]
+#[include = "brand/**/*"]
+#[include = "icons/**/*"]
+#[include = "themes/**/*"]
+#[exclude = "*.DS_Store"]
+pub struct Assets;
+
+impl Assets {
+    /// Create a new Assets instance. The endpoint parameter is ignored for
+    /// native builds.
+    pub fn new(_endpoint: impl Into<SharedString>) -> Self {
+        Self
+    }
+}
+
+impl AssetSource for Assets {
+    fn load(&self, path: &str) -> Result<Option<Cow<'static, [u8]>>> {
+        Self::get(path)
+            .map(|f| Some(f.data))
+            .with_context(|| format!("loading asset at path {path:?}"))
+    }
+
+    fn list(&self, path: &str) -> Result<Vec<SharedString>> {
+        Ok(Self::iter()
+            .filter_map(|p| {
+                if p.starts_with(path) {
+                    Some(p.into())
+                } else {
+                    None
+                }
+            })
+            .collect())
+    }
+}
+
+impl Assets {
+    /// Populate the [`TextSystem`] of the given [`AppContext`] with all `.ttf` fonts in the `fonts` directory.
+    pub fn load_fonts(&self, cx: &App) -> anyhow::Result<()> {
+        let font_paths = self.list("fonts")?;
+        let mut embedded_fonts = Vec::new();
+        for font_path in font_paths {
+            if font_path.ends_with(".ttf") {
+                let font_bytes = cx
+                    .asset_source()
+                    .load(&font_path)?
+                    .expect("Assets should never return None");
+                embedded_fonts.push(font_bytes);
+            }
+        }
+
+        cx.text_system().add_fonts(embedded_fonts)
+    }
+}

crates/assets/src/wasm_assets.rs

@@ -0,0 +1,176 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+
+use gpui::{AssetSource, Result, SharedString};
+use wasm_bindgen_futures::spawn_local;
+
+// Compile-time manifest of every asset file served on wasm (see build.rs).
+include!(concat!(env!("OUT_DIR"), "/wasm_assets.rs"));
+
+/// Path prefixes that the wasm loader serves. Fonts and themes are not
+/// downloaded on web: the web platform bundles its own fonts, and the theme
+/// registry falls back to the built-in default theme.
+const SERVED_PREFIXES: [&str; 2] = ["icons/", "brand/"];
+
+/// WASM implementation - download assets on demand.
+///
+/// Assets are fetched from `{endpoint}/assets/{path}` and cached in memory
+/// after the first successful download. This keeps the WASM bundle small
+/// while still providing the full asset set at runtime.
+pub struct Assets {
+    endpoint: SharedString,
+    cache: Arc<RwLock<HashMap<String, Vec<u8>>>>,
+    pending: Arc<RwLock<HashMap<String, bool>>>,
+}
+
+impl Assets {
+    /// Create a new Assets instance backed by the given endpoint.
+    ///
+    /// Assets are resolved as `{endpoint}/assets/{path}`. An empty endpoint
+    /// resolves against the current page origin (e.g. `/assets/icons/foo.svg`).
+    pub fn new(endpoint: impl Into<SharedString>) -> Self {
+        Self {
+            endpoint: endpoint.into(),
+            cache: Arc::new(RwLock::new(HashMap::new())),
+            pending: Arc::new(RwLock::new(HashMap::new())),
+        }
+    }
+
+    /// Absolute URL of the given asset path.
+    ///
+    /// `reqwest` requires absolute URLs, so a relative endpoint is resolved
+    /// against the current page origin.
+    fn asset_url(&self, path: &str) -> String {
+        let endpoint = if self.endpoint.is_empty() {
+            web_sys::window()
+                .and_then(|window| window.location().origin().ok())
+                .unwrap_or_default()
+        } else {
+            self.endpoint.to_string()
+        };
+        format!("{endpoint}/assets/{path}")
+    }
+
+    /// Download every asset in [`WASM_ASSETS`] into the cache, in parallel,
+    /// before the app starts.
+    ///
+    /// Preloading is required for two reasons:
+    /// - Assets loaded through GPUI's [`gpui::Asset`] machinery (e.g. `img()`)
+    ///   cache failed loads and never retry them.
+    /// - SVG painting only re-attempts an empty load on the next repaint, so
+    ///   an icon would stay invisible until the window happens to redraw.
+    pub async fn preload(&self) {
+        let downloads = WASM_ASSETS.iter().map(|path| async move {
+            let result = reqwest::get(self.asset_url(path)).await;
+            match result {
+                Ok(response) if response.status().is_success() => match response.bytes().await {
+                    Ok(bytes) => {
+                        if let Ok(mut cache) = self.cache.write() {
+                            cache.insert(path.to_string(), bytes.to_vec());
+                        }
+                    }
+                    Err(e) => {
+                        log::warn!("Failed to read asset {}: {}", path, e);
+                    }
+                },
+                Ok(response) => {
+                    log::warn!(
+                        "Failed to download asset {}: HTTP {}",
+                        path,
+                        response.status()
+                    );
+                }
+                Err(e) => {
+                    log::warn!("Failed to fetch asset {}: {}", path, e);
+                }
+            }
+        });
+        futures::future::join_all(downloads).await;
+    }
+}
+
+impl AssetSource for Assets {
+    fn load(&self, path: &str) -> Result<Option<Cow<'static, [u8]>>> {
+        if path.is_empty() {
+            return Ok(None);
+        }
+
+        // Only serve paths the web build actually ships.
+        if !SERVED_PREFIXES
+            .iter()
+            .any(|prefix| path.starts_with(prefix))
+        {
+            return Ok(None);
+        }
+
+        // Serve from the in-memory cache when available.
+        if let Ok(cache) = self.cache.read() {
+            if let Some(data) = cache.get(path) {
+                return Ok(Some(Cow::Owned(data.clone())));
+            }
+        }
+
+        // Kick off a single download per path; concurrent requests for the
+        // same path share it.
+        let is_pending = self
+            .pending
+            .read()
+            .map(|pending| pending.contains_key(path))
+            .unwrap_or(false);
+
+        if !is_pending {
+            if let Ok(mut pending) = self.pending.write() {
+                pending.insert(path.to_string(), true);
+            }
+
+            let url = self.asset_url(path);
+            let path_clone = path.to_string();
+            let cache = self.cache.clone();
+            let pending = self.pending.clone();
+
+            spawn_local(async move {
+                match reqwest::get(&url).await {
+                    Ok(response) if response.status().is_success() => {
+                        match response.bytes().await {
+                            Ok(bytes) => {
+                                if let Ok(mut cache) = cache.write() {
+                                    cache.insert(path_clone.clone(), bytes.to_vec());
+                                }
+                            }
+                            Err(e) => {
+                                log::warn!("Failed to read asset {}: {}", path_clone, e);
+                            }
+                        }
+                    }
+                    Ok(response) => {
+                        log::warn!(
+                            "Failed to download asset {}: HTTP {}",
+                            path_clone,
+                            response.status()
+                        );
+                    }
+                    Err(e) => {
+                        log::warn!("Failed to fetch asset {}: {}", path_clone, e);
+                    }
+                }
+
+                // Allow retrying failed downloads on subsequent requests.
+                if let Ok(mut pending) = pending.write() {
+                    pending.remove(&path_clone);
+                }
+            });
+        }
+
+        // The asset is not available yet. GPUI's SVG atlas does not cache
+        // empty loads, so the next repaint will call `load` again and find
+        // the asset in the cache once the download completes.
+        Ok(None)
+    }
+
+    fn list(&self, _path: &str) -> Result<Vec<SharedString>> {
+        // The asset manifest is not available at runtime on web; embedded
+        // directories are not listed.
+        Ok(Vec::new())
+    }
+}

crates/auto_update/Cargo.toml

@@ -8,8 +8,5 @@ publish.workspace = true
 gpui.workspace = true
 instant.workspace = true
 log.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-ureq.workspace = true
 
-gpui-updater-core = { git = "https://github.com/AprilNEA/gpui-updater" }
+gpui-updater = { git = "https://github.com/AprilNEA/gpui-updater", tag = "v0.0.6", features = ["gpui"] }

crates/auto_update/src/lib.rs

@@ -1,99 +1,62 @@
 #![cfg(not(target_arch = "wasm32"))]
 
-use std::sync::Arc;
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
-
-use gpui::{App, AppContext, Context, Entity, Global, SharedString, Task, Window};
-use gpui_updater_core::{EngineConfig, Release, UpdateEngine, UpdateStatus, Verification, Version};
-use instant::Duration;
-
-use crate::source::{AssetFilter, GiteaSource, asset_filter_for};
-
-mod source;
-
-pub use gpui_updater_core::UpdateStatus as AutoUpdateStatus;
-
-const GITEA_API_BASE: &str = "https://git.reya.info/api/v1";
-const GITEA_REPO_OWNER: &str = "reya";
-const GITEA_REPO_NAME: &str = "coop";
-
-/// Delay before the automatic check that runs on startup.
-const AUTO_CHECK_DELAY: Duration = Duration::from_secs(120);
-/// How long a failure stays visible before the status reverts to "Up to date".
-const ERROR_DISPLAY_DURATION: Duration = Duration::from_secs(5);
+use gpui::{App, AppContext, Context, Entity, Global, SharedString, Subscription, Window};
+use gpui_updater::{EngineConfig, GitHubSource, UpdateStatus, Updater, Version};
+use instant::{Duration, Instant};
 
 const COOP_UPDATE_EXPLANATION: &str = "COOP_UPDATE_EXPLANATION";
-const COOP_BUNDLE_TYPE: &str = "COOP_BUNDLE_TYPE";
 
-fn uses_managed_updates() -> bool {
-    // The Flatpak runtime exports `FLATPAK_ID` inside the sandbox.
-    std::env::var("FLATPAK_ID").is_ok()
-        // Allow opting out of in-app updates via an explicit environment variable.
-        || std::env::var(COOP_UPDATE_EXPLANATION).is_ok()
-        // The Snap package sets `COOP_BUNDLE_TYPE=snap` (see snapcraft.yaml.in).
-        || std::env::var(COOP_BUNDLE_TYPE).is_ok_and(|value| value == "snap")
+fn get_github_repo_owner() -> String {
+    std::env::var("COOP_GITHUB_REPO_OWNER").unwrap_or_else(|_| "reyakov".to_string())
+}
+
+fn get_github_repo_name() -> String {
+    std::env::var("COOP_GITHUB_REPO_NAME").unwrap_or_else(|_| "coop".to_string())
+}
+
+fn is_flatpak_installation() -> bool {
+    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) {
-    if uses_managed_updates() {
-        log::info!(
-            "Skipping auto-update initialization: updates are managed by the installed distribution channel (Flatpak/Snap)"
-        );
+    if is_flatpak_installation() {
+        log::info!("Skipping auto-update initialization: App is installed via Flatpak");
         return;
     }
 
-    let (os, arch) = (std::env::consts::OS, std::env::consts::ARCH);
-
-    let Some(filter) = asset_filter_for(os, arch) else {
-        log::info!(
-            "Skipping auto-update initialization: no installable release artifact is published for {os}/{arch}"
-        );
-        return;
-    };
-
-    let Ok(version) = Version::parse(env!("CARGO_PKG_VERSION")) else {
-        log::error!(
-            "Skipping auto-update initialization: crate version {:?} is not valid semver",
-            env!("CARGO_PKG_VERSION")
-        );
-        return;
-    };
-
-    AutoUpdater::set_global(
-        cx.new(|cx| AutoUpdater::new(window, version, filter, cx)),
-        cx,
-    );
+    AutoUpdater::set_global(cx.new(|cx| AutoUpdater::new(window, cx)), cx);
 }
 
 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;
+
+/// 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`].
 pub struct AutoUpdater {
-    /// The blocking engine, driven on the background executor.
-    engine: Arc<UpdateEngine<GiteaSource>>,
-    status: UpdateStatus,
-    /// The newer release found by the last successful check, if any.
-    available: Option<Release>,
+    /// The underlying gpui-updater entity that does the heavy lifting.
+    pub updater: Entity<Updater>,
     /// Currently running app version.
     pub version: Version,
-    /// The in-flight check or download, if any.
-    task: Option<Task<()>>,
+    /// 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>,
 }
 
 impl AutoUpdater {
-    /// Whether auto-update is available for this installation.
-    pub fn is_available(cx: &App) -> bool {
-        cx.try_global::<GlobalAutoUpdater>().is_some()
-    }
-
-    /// Retrieve the global auto updater instance, if one was initialized.
-    pub fn try_global(cx: &App) -> Option<Entity<Self>> {
-        cx.try_global::<GlobalAutoUpdater>()
-            .map(|global| global.0.clone())
-    }
-
     /// Retrieve the global auto updater instance.
     pub fn global(cx: &App) -> Entity<Self> {
         cx.global::<GlobalAutoUpdater>().0.clone()
@@ -103,49 +66,92 @@ impl AutoUpdater {
         cx.set_global(GlobalAutoUpdater(state));
     }
 
-    fn new(
-        window: &mut Window,
-        version: Version,
-        filter: AssetFilter,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        let source = GiteaSource::new(GITEA_API_BASE, GITEA_REPO_OWNER, GITEA_REPO_NAME, filter);
-        let config = EngineConfig::new(version.clone()).verification(Verification::Checksum);
-        let engine = Arc::new(UpdateEngine::new(source, config));
+    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+        let version = Version::parse(env!("CARGO_PKG_VERSION")).unwrap();
 
-        // Schedule an auto-check after a 2-minute delay
+        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);
+                });
+            }
+
+            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(AUTO_CHECK_DELAY).await;
-                this.update(cx, |this, cx| this.check(cx)).ok();
+                cx.background_executor().timer(duration).await;
+                this.update(cx, |this, cx| {
+                    this.updater.update(cx, |updater, cx| {
+                        updater.check(cx);
+                    });
+                })
+                .ok();
             })
             .detach();
         });
 
         Self {
-            engine,
-            status: UpdateStatus::Idle,
-            available: None,
+            updater,
             version,
-            task: None,
+            _subscription: subscription,
+            error_time: None,
         }
     }
 
-    /// Whether nothing is happening, so the UI can hide the status line.
-    pub fn idle(&self) -> bool {
-        matches!(self.status, UpdateStatus::Idle)
+    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
     }
 
-    /// Whether a verified update is installed and waiting for a restart.
-    pub fn staged(&self) -> bool {
-        matches!(self.status, UpdateStatus::Staged(_))
-    }
+    pub fn status(&self, cx: &App) -> SharedString {
+        let status = self.updater.read(cx).status();
 
-    /// A short, human-readable description of the current status.
-    pub fn status(&self) -> SharedString {
-        match &self.status {
-            UpdateStatus::Idle | UpdateStatus::UpToDate => "Up to date".into(),
+        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);
@@ -159,168 +165,16 @@ impl AutoUpdater {
             UpdateStatus::Staged(version) => {
                 format!("Version {version} ready — restart to apply").into()
             }
-            UpdateStatus::Errored(message) => format!("Update failed: {message}").into(),
-        }
-    }
-
-    /// Check the release host for a newer version, then download and install it.
-    pub fn check(&mut self, cx: &mut Context<Self>) {
-        if self.status.is_busy() {
-            return;
-        }
-        self.set_status(UpdateStatus::Checking, cx);
-
-        let engine = self.engine.clone();
-
-        self.task = Some(cx.spawn(async move |this, cx| {
-            let result = cx
-                .background_executor()
-                .spawn(async move { engine.check() })
-                .await;
-
-            this.update(cx, |this, cx| {
-                this.task = None;
-                match result {
-                    Ok(Some(release)) => {
-                        log::info!("Update {} is available", release.version);
-                        let version = release.version.clone();
-                        this.available = Some(release);
-                        this.set_status(UpdateStatus::Available(version), cx);
-                        this.download_and_install(cx);
-                    }
-                    Ok(None) => this.set_status(UpdateStatus::UpToDate, cx),
-                    Err(error) => {
-                        log::warn!("Update check failed: {error}");
-                        this.set_status(UpdateStatus::Errored(error.to_string()), cx);
-                    }
+            UpdateStatus::Errored(msg) => {
+                if self
+                    .error_time
+                    .is_some_and(|t| t.elapsed() >= Duration::from_secs(5))
+                {
+                    "Up to date".into()
+                } else {
+                    format!("Update failed: {msg}").into()
                 }
-            })
-            .ok();
-        }));
-    }
-
-    /// Download the available update, verify it, and swap it into place.
-    fn download_and_install(&mut self, cx: &mut Context<Self>) {
-        if self.status.is_busy() {
-            return;
-        }
-        let Some(release) = self.available.clone() else {
-            return;
-        };
-
-        let engine = self.engine.clone();
-        self.set_status(
-            UpdateStatus::Downloading {
-                downloaded: 0,
-                total: None,
-            },
-            cx,
-        );
-
-        self.task = Some(cx.spawn(async move |this, cx| {
-            let downloaded = Arc::new(AtomicU64::new(0));
-            let total = Arc::new(AtomicU64::new(0)); // 0 = unknown
-            let done = Arc::new(AtomicBool::new(false));
-
-            let download_task = {
-                let (engine, release) = (engine.clone(), release.clone());
-                let (downloaded, total, done) = (downloaded.clone(), total.clone(), done.clone());
-                cx.background_executor().spawn(async move {
-                    let result = engine.download(&release, |got, expected| {
-                        downloaded.store(got, Ordering::Relaxed);
-                        total.store(expected.unwrap_or(0), Ordering::Relaxed);
-                    });
-                    done.store(true, Ordering::Relaxed);
-                    result
-                })
-            };
-
-            loop {
-                let got = downloaded.load(Ordering::Relaxed);
-                let total = total.load(Ordering::Relaxed);
-                this.update(cx, |this, cx| {
-                    this.set_status(
-                        UpdateStatus::Downloading {
-                            downloaded: got,
-                            total: (total != 0).then_some(total),
-                        },
-                        cx,
-                    );
-                })
-                .ok();
-                if done.load(Ordering::Relaxed) {
-                    break;
-                }
-                cx.background_executor()
-                    .timer(Duration::from_millis(120))
-                    .await;
             }
-
-            let artifact = match download_task.await {
-                Ok(artifact) => artifact,
-                Err(error) => {
-                    log::warn!("Update download failed: {error}");
-                    this.update(cx, |this, cx| {
-                        this.task = None;
-                        this.set_status(UpdateStatus::Errored(error.to_string()), cx);
-                    })
-                    .ok();
-                    return;
-                }
-            };
-
-            let _ = this.update(cx, |this, cx| this.set_status(UpdateStatus::Installing, cx));
-
-            let installed = {
-                let engine = engine.clone();
-                cx.background_executor()
-                    .spawn(async move { engine.install(&artifact) })
-                    .await
-            };
-
-            this.update(cx, |this, cx| {
-                this.task = None;
-                match installed {
-                    Ok(installed) => {
-                        if let Some(path) = installed.restart_path {
-                            cx.set_restart_path(path);
-                        }
-                        let version = release.version.clone();
-                        this.set_status(UpdateStatus::Staged(version), cx);
-                    }
-                    Err(error) => {
-                        this.set_status(UpdateStatus::Errored(error.to_string()), cx);
-                    }
-                }
-            })
-            .ok();
-        }));
-    }
-
-    /// Relaunch into the staged update.
-    pub fn restart(&mut self, cx: &mut Context<Self>) {
-        if !self.staged() {
-            log::warn!("Ignoring restart request: no update is staged");
-            return;
         }
-        cx.restart();
-    }
-
-    fn set_status(&mut self, status: UpdateStatus, cx: &mut Context<Self>) {
-        let errored = matches!(status, UpdateStatus::Errored(_));
-        self.status = status;
-
-        if errored {
-            cx.spawn(async move |this, cx| {
-                cx.background_executor().timer(ERROR_DISPLAY_DURATION).await;
-                this.update(cx, |this, cx| {
-                    this.set_status(UpdateStatus::Idle, cx);
-                })
-                .ok();
-            })
-            .detach();
-        }
-
-        cx.notify();
     }
 }

crates/auto_update/src/source.rs

@@ -1,369 +0,0 @@
-use gpui_updater_core::{Asset, Error, Release, Result, UpdateSource, parse_tag};
-use serde::Deserialize;
-
-const CHECKSUMS_ASSET: &str = "SHA256SUMS";
-const RELEASE_PAGE_SIZE: usize = 20;
-
-/// Which published artifact belongs to a target platform.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct AssetFilter {
-    extension: &'static str,
-    arch: &'static str,
-}
-
-impl AssetFilter {
-    /// Whether `name` is the installable artifact for this target.
-    fn matches(&self, name: &str) -> bool {
-        let name = name.to_ascii_lowercase();
-        name.ends_with(self.extension) && name.contains(self.arch)
-    }
-}
-
-pub fn asset_filter_for(os: &str, arch: &str) -> Option<AssetFilter> {
-    let extension = match os {
-        "macos" => ".dmg",
-        "linux" => ".tar.gz",
-        _ => return None,
-    };
-
-    let arch = match (os, arch) {
-        // cargo-packager names the disk images `aarch64`/`x64`.
-        ("macos", "aarch64") => "aarch64",
-        ("macos", "x86_64") => "x64",
-        // `script/bundle-linux` names the tarballs `aarch64`/`x86_64`.
-        ("linux", "aarch64") => "aarch64",
-        ("linux", "x86_64") => "x86_64",
-        _ => return None,
-    };
-
-    Some(AssetFilter { extension, arch })
-}
-
-/// Reads releases from a Gitea repository's Releases.
-pub struct GiteaSource {
-    api_base: String,
-    owner: String,
-    repo: String,
-    filter: AssetFilter,
-}
-
-impl GiteaSource {
-    /// Build a source for `owner/repo` on the Gitea instance at `api_base`
-    /// (e.g. `https://git.reya.info/api/v1`).
-    pub fn new(
-        api_base: impl Into<String>,
-        owner: impl Into<String>,
-        repo: impl Into<String>,
-        filter: AssetFilter,
-    ) -> Self {
-        Self {
-            api_base: api_base.into().trim_end_matches('/').to_string(),
-            owner: owner.into(),
-            repo: repo.into(),
-            filter,
-        }
-    }
-
-    fn releases_url(&self) -> String {
-        format!(
-            "{}/repos/{}/{}/releases?limit={RELEASE_PAGE_SIZE}",
-            self.api_base, self.owner, self.repo
-        )
-    }
-}
-
-impl UpdateSource for GiteaSource {
-    fn fetch_latest(&self) -> Result<Release> {
-        let releases: Vec<GiteaRelease> = http::get_json(&self.releases_url())?;
-        let release = newest_published(&releases)
-            .ok_or_else(|| Error::Parse("repository has no published releases".to_string()))?;
-
-        let asset = release
-            .assets
-            .iter()
-            .find(|asset| self.filter.matches(&asset.name))
-            .ok_or(Error::NoMatchingAsset {
-                target_os: std::env::consts::OS,
-                target_arch: std::env::consts::ARCH,
-            })?;
-
-        // Resolve the published checksum so the engine can reject a truncated or substituted download.
-        let sha256 = release
-            .assets
-            .iter()
-            .find(|candidate| candidate.name.eq_ignore_ascii_case(CHECKSUMS_ASSET))
-            .map(|sums| http::get_string(&sums.browser_download_url))
-            .transpose()?
-            .and_then(|sums| sha256_for(&sums, &asset.name));
-
-        Ok(Release {
-            version: parse_tag(&release.tag_name)?,
-            notes: release
-                .body
-                .clone()
-                .filter(|body| !body.trim().is_empty())
-                .or_else(|| release.name.clone()),
-            asset: Asset {
-                name: asset.name.clone(),
-                url: asset.browser_download_url.clone(),
-                size: asset.size,
-            },
-            signature: None,
-            signature_url: None,
-            sha256,
-        })
-    }
-}
-
-fn newest_published(releases: &[GiteaRelease]) -> Option<&GiteaRelease> {
-    releases
-        .iter()
-        .filter(|release| !release.draft && !release.prerelease)
-        .filter_map(|release| {
-            parse_tag(&release.tag_name)
-                .ok()
-                .map(|version| (version, release))
-        })
-        .max_by(|(left, _), (right, _)| left.cmp(right))
-        .map(|(_, release)| release)
-}
-
-/// The SHA-256 recorded for `asset_name` in a `shasum`-style checksums file.
-fn sha256_for(sums: &str, asset_name: &str) -> Option<String> {
-    sums.lines().find_map(|line| {
-        let mut parts = line.split_whitespace();
-        let (hash, path) = (parts.next()?, parts.next()?);
-        let path = path.strip_prefix('*').unwrap_or(path);
-        let base = path.rsplit(['/', '\\']).next().unwrap_or(path);
-        (base == asset_name).then(|| hash.to_ascii_lowercase())
-    })
-}
-
-/// A release as returned by the Gitea API.
-#[derive(Debug, Deserialize)]
-struct GiteaRelease {
-    tag_name: String,
-    #[serde(default)]
-    name: Option<String>,
-    #[serde(default)]
-    body: Option<String>,
-    #[serde(default)]
-    draft: bool,
-    #[serde(default)]
-    prerelease: bool,
-    #[serde(default)]
-    assets: Vec<GiteaAsset>,
-}
-
-/// A release asset as returned by the Gitea API.
-#[derive(Debug, Deserialize)]
-struct GiteaAsset {
-    name: String,
-    browser_download_url: String,
-    #[serde(default)]
-    size: u64,
-}
-
-/// Blocking HTTP helpers for release metadata.
-mod http {
-    use std::time::Duration;
-
-    use gpui_updater_core::{Error, Result};
-    use serde::de::DeserializeOwned;
-    use ureq::Agent;
-    use ureq::tls::{RootCerts, TlsConfig};
-
-    const USER_AGENT: &str = concat!("coop-updater/", env!("CARGO_PKG_VERSION"));
-    const CONNECT_TIMEOUT: Duration = Duration::from_secs(15);
-    const RESPONSE_TIMEOUT: Duration = Duration::from_secs(30);
-
-    fn agent() -> Agent {
-        Agent::config_builder()
-            .user_agent(USER_AGENT)
-            .tls_config(
-                TlsConfig::builder()
-                    .root_certs(RootCerts::PlatformVerifier)
-                    .build(),
-            )
-            .timeout_resolve(Some(CONNECT_TIMEOUT))
-            .timeout_connect(Some(CONNECT_TIMEOUT))
-            .timeout_recv_response(Some(RESPONSE_TIMEOUT))
-            .build()
-            .into()
-    }
-
-    fn get_bytes(url: &str) -> Result<Vec<u8>> {
-        let mut response = agent().get(url).call().map_err(|error| match error {
-            ureq::Error::StatusCode(code) => Error::Http(format!("GET {url} -> {code}")),
-            other => Error::Http(other.to_string()),
-        })?;
-
-        response
-            .body_mut()
-            .read_to_vec()
-            .map_err(|error| Error::Http(format!("GET {url} -> {error}")))
-    }
-
-    pub(super) fn get_json<T: DeserializeOwned>(url: &str) -> Result<T> {
-        serde_json::from_slice(&get_bytes(url)?).map_err(|error| Error::Parse(error.to_string()))
-    }
-
-    pub(super) fn get_string(url: &str) -> Result<String> {
-        String::from_utf8(get_bytes(url)?).map_err(|error| Error::Parse(error.to_string()))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use gpui_updater_core::Version;
-
-    use super::*;
-
-    const PUBLISHED: &[&str] = &[
-        "Coop_1.0.1_aarch64.dmg",
-        "Coop_1.0.1_x64.dmg",
-        "coop-linux-aarch64.tar.gz",
-        "coop-linux-x86_64.tar.gz",
-        "coop_1.0.1_aarch64.snap",
-        "coop_1.0.1_arm64-setup.exe",
-        "coop_1.0.1_x64-setup.exe",
-        "coop_1.0.1_x86_64.snap",
-        "su.reya.coop_aarch64.flatpak",
-        "su.reya.coop_x86_64.flatpak",
-    ];
-
-    fn selected(os: &str, arch: &str) -> Option<&'static str> {
-        let filter = asset_filter_for(os, arch)?;
-        PUBLISHED.iter().copied().find(|name| filter.matches(name))
-    }
-
-    #[test]
-    fn picks_the_artifact_matching_os_and_architecture() {
-        assert_eq!(selected("macos", "aarch64"), Some("Coop_1.0.1_aarch64.dmg"));
-        assert_eq!(selected("macos", "x86_64"), Some("Coop_1.0.1_x64.dmg"));
-        assert_eq!(
-            selected("linux", "aarch64"),
-            Some("coop-linux-aarch64.tar.gz")
-        );
-        assert_eq!(
-            selected("linux", "x86_64"),
-            Some("coop-linux-x86_64.tar.gz")
-        );
-    }
-
-    #[test]
-    fn has_no_target_for_windows_or_unknown_platforms() {
-        assert_eq!(asset_filter_for("windows", "x86_64"), None);
-        assert_eq!(asset_filter_for("freebsd", "x86_64"), None);
-        assert_eq!(asset_filter_for("macos", "riscv64"), None);
-    }
-
-    #[test]
-    fn ignores_package_formats_and_sidecars_that_are_not_the_artifact() {
-        let macos = asset_filter_for("macos", "aarch64").unwrap();
-        assert!(!macos.matches("coop_1.0.1_aarch64.snap"));
-        assert!(!macos.matches("su.reya.coop_aarch64.flatpak"));
-        assert!(!macos.matches("Coop_1.0.1_aarch64.dmg.minisig"));
-
-        let linux = asset_filter_for("linux", "x86_64").unwrap();
-        assert!(!linux.matches("coop_1.0.1_x64-setup.exe"));
-        assert!(!linux.matches("coop_1.0.1_x86_64.snap"));
-    }
-
-    #[test]
-    fn reads_checksums_by_basename_ignoring_directory_prefix() {
-        let sums = "\
-abcdef  macos-arm64-artifacts/Coop_1.0.1_aarch64.dmg
-123456  *linux-x64-artifacts/coop-linux-x86_64.tar.gz
-789abc  SHA256SUMS
-";
-        assert_eq!(
-            sha256_for(sums, "Coop_1.0.1_aarch64.dmg").as_deref(),
-            Some("abcdef")
-        );
-        assert_eq!(
-            sha256_for(sums, "coop-linux-x86_64.tar.gz").as_deref(),
-            Some("123456")
-        );
-        assert_eq!(sha256_for(sums, "coop_1.0.1_x64-setup.exe"), None);
-    }
-
-    #[test]
-    fn newest_published_skips_drafts_prereleases_and_bad_tags() {
-        let releases: Vec<GiteaRelease> = serde_json::from_str(
-            r#"[
-                {
-                    "tag_name": "v1.0.2",
-                    "draft": true,
-                    "assets": []
-                },
-                {
-                    "tag_name": "v2.0.0-rc.1",
-                    "prerelease": true,
-                    "assets": []
-                },
-                {
-                    "tag_name": "nightly",
-                    "assets": []
-                },
-                {
-                    "tag_name": "v1.0.0",
-                    "assets": [
-                        {
-                            "name": "coop-linux-x86_64.tar.gz",
-                            "browser_download_url": "https://git.reya.info/reya/coop/releases/download/v1.0.0/coop-linux-x86_64.tar.gz",
-                            "size": 26160329
-                        }
-                    ]
-                },
-                {
-                    "tag_name": "v1.0.1",
-                    "name": "v1.0.1",
-                    "body": "Fixed app panic on flatpak installations",
-                    "assets": [
-                        {
-                            "name": "coop-linux-x86_64.tar.gz",
-                            "browser_download_url": "https://git.reya.info/reya/coop/releases/download/v1.0.1/coop-linux-x86_64.tar.gz",
-                            "size": 26160329
-                        }
-                    ]
-                }
-            ]"#,
-        )
-        .unwrap();
-
-        let newest = newest_published(&releases).unwrap();
-        assert_eq!(newest.tag_name, "v1.0.1");
-        assert_eq!(parse_tag(&newest.tag_name).unwrap().to_string(), "1.0.1");
-        assert_eq!(newest.assets.len(), 1);
-        assert_eq!(newest.assets[0].size, 26160329);
-    }
-
-    #[test]
-    #[ignore = "requires network access to the release host"]
-    fn live_release_source_resolves_the_running_platform() {
-        let filter = asset_filter_for(std::env::consts::OS, std::env::consts::ARCH)
-            .expect("this platform should be supported");
-        let source = GiteaSource::new("https://git.reya.info/api/v1", "reya", "coop", filter);
-
-        let release = source
-            .fetch_latest()
-            .expect("release lookup should succeed");
-
-        assert!(
-            release.version >= Version::new(1, 0, 0),
-            "unexpected version {}",
-            release.version
-        );
-        assert!(
-            source.filter.matches(&release.asset.name),
-            "unexpected artifact {}",
-            release.asset.name
-        );
-        assert!(
-            release.asset.url.starts_with("https://"),
-            "{} ",
-            release.asset.url
-        );
-    }
-}

crates/chat/src/lib.rs

@@ -21,7 +21,6 @@ mod room;
 
 pub use message::*;
 pub use room::*;
-pub use state::FileAttachment;
 
 /// A static keypair used only for signing locally-cached rumor events.
 static LOCAL_KEYS: LazyLock<Keys> = LazyLock::new(Keys::generate);
@@ -234,7 +233,7 @@ impl ChatRegistry {
                         if event.kind == Kind::InboxRelays {
                             let current_user = signer.get_public_key_async().await?;
                             if event.pubkey == current_user {
-                                tx.send_async(Signal::InboxReady).await?;
+                                tx.send_async(Signal::InboxReady).await.ok();
                             }
                         }
 
@@ -263,24 +262,24 @@ impl ChatRegistry {
 
                                 if rumor.tags.is_empty() {
                                     let signal = Signal::error(&event, "Recipient is missing");
-                                    tx.send_async(signal).await?;
+                                    tx.send_async(signal).await.ok();
                                 }
 
                                 // Emit message for both new and backlog events
                                 let signal = Signal::message(event.id, rumor);
-                                tx.send_async(signal).await?;
+                                tx.send_async(signal).await.ok();
                             }
                             Err(e) => {
                                 let reason = format!("Failed to extract rumor: {e}");
                                 let signal = Signal::error(event.as_ref(), reason);
-                                tx.send_async(signal).await?;
+                                tx.send_async(signal).await.ok();
                             }
                         }
                     }
                     RelayMessage::EndOfStoredEvents(id)
                         if (id.as_ref() == &sub_id1 || id.as_ref() == &sub_id2) =>
                     {
-                        tx.send_async(Signal::Eose).await?;
+                        tx.send_async(Signal::Eose).await.ok();
                     }
                     _ => {}
                 }
@@ -291,33 +290,41 @@ impl ChatRegistry {
 
         self.signal_consumer = Some(cx.spawn(async move |this, cx| {
             while let Ok(message) = rx.recv_async().await {
-                match message {
-                    Signal::Message(message) => {
-                        this.update(cx, |this, cx| {
-                            this.new_message(message, cx);
-                        })?;
+                // `update_in` (rather than `update`) routes through a
+                // try-borrow: on wasm a task poll that lands while the app
+                // context is borrowed can't panic and kill this consumer
+                // (which would stall all message delivery).
+                this.update_in(cx, |this, _window, cx| {
+                    // Drain the whole queue in a single update so a burst of
+                    // events (e.g. history sync after login) collapses into
+                    // one repaint instead of one per message (important on
+                    // wasm, where everything runs on the main thread).
+                    let mut batch = vec![message];
+                    while let Ok(extra) = rx.try_recv() {
+                        batch.push(extra);
                     }
-                    Signal::InboxReady => {
-                        this.update(cx, |this, cx| {
-                            this.get_messages(cx);
-                        })?;
-                    }
-                    Signal::Eose => {
-                        this.update(cx, |this, _cx| {
-                            this.tracking.store(false, Ordering::Release);
-                        })?;
 
-                        this.update(cx, |this, cx| {
-                            this.get_rooms(cx);
-                        })?;
+                    for message in batch {
+                        match message {
+                            Signal::Message(message) => {
+                                this.new_message(message, cx);
+                            }
+                            Signal::InboxReady => {
+                                this.get_messages(cx);
+                            }
+                            Signal::Eose => {
+                                this.tracking.store(false, Ordering::Release);
+                                this.get_rooms(cx);
+                            }
+                            Signal::Error(failed) => {
+                                let _ = trash.update(cx, |this, cx| {
+                                    this.insert(failed);
+                                    cx.notify();
+                                });
+                            }
+                        };
                     }
-                    Signal::Error(failed) => {
-                        trash.update(cx, |this, cx| {
-                            this.insert(failed);
-                            cx.notify();
-                        })?;
-                    }
-                };
+                })?;
             }
 
             Ok(())
@@ -371,7 +378,7 @@ impl ChatRegistry {
                 .is_some();
 
             if !found {
-                this.update(cx, |_this, cx| {
+                this.update_in(cx, |_this, _window, cx| {
                     cx.emit(ChatEvent::InboxRelayNotFound);
                 })?;
             }
@@ -422,7 +429,7 @@ impl ChatRegistry {
             });
 
             if let Err(e) = task.await {
-                this.update(cx, |_this, cx| {
+                this.update_in(cx, |_this, _window, cx| {
                     cx.emit(ChatEvent::Error(e.to_string()));
                 })?;
             }
@@ -431,6 +438,7 @@ impl ChatRegistry {
         }));
     }
 
+    /// Get all messages for the provided signer
     /// Reload the chat registry, fetching messages and contact list from relays.
     pub fn reload(&mut self, cx: &mut Context<Self>) {
         self.reset(cx);
@@ -630,18 +638,18 @@ impl ChatRegistry {
 
     /// Load all rooms from the database.
     pub fn get_rooms(&mut self, cx: &mut Context<Self>) {
-        let task = self.query_chat_rooms(cx);
+        let task = self.get_rooms_task(cx);
 
         self.tasks.push(cx.spawn(async move |this, cx| {
             match task.await {
                 Ok(rooms) => {
-                    this.update(cx, |this, cx| {
+                    this.update_in(cx, |this, _window, cx| {
                         this.extend_rooms(rooms, cx);
                         this.sort(cx);
                     })?;
                 }
                 Err(e) => {
-                    this.update(cx, |_, cx| {
+                    this.update_in(cx, |_, _window, cx| {
                         cx.emit(ChatEvent::Error(e.to_string()));
                     })?;
                 }
@@ -651,8 +659,8 @@ impl ChatRegistry {
         }));
     }
 
-    /// Query the chat rooms from the database
-    fn query_chat_rooms(&self, cx: &App) -> Task<Result<HashSet<Room>, Error>> {
+    /// Create a task to load rooms from the database
+    fn get_rooms_task(&self, cx: &App) -> Task<Result<HashSet<Room>, Error>> {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
         let signer = nostr.read(cx).signer();
@@ -678,7 +686,7 @@ impl ChatRegistry {
 
             let filter = Filter::new()
                 .kind(Kind::ApplicationSpecificData)
-                .custom_tags(SingleLetterTag::LOWERCASE_K, ["7", "14", "15"]);
+                .custom_tag(SingleLetterTag::LOWERCASE_K, "14");
 
             let events = client.database().query(filter).await?;
             let mut grouped: HashMap<u64, Vec<UnsignedEvent>> = HashMap::new();
@@ -720,8 +728,8 @@ impl ChatRegistry {
 
     /// Parse a nostr event into a message and push it to the belonging room
     ///
-    /// - If the room doesn't exist, it will be created.
-    /// - Updates room ordering based on the most recent messages.
+    /// If the room doesn't exist, it will be created.
+    /// Updates room ordering based on the most recent messages.
     pub fn new_message(&mut self, message: NewMessage, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
 
@@ -824,7 +832,7 @@ async fn set_rumor(client: &Client, id: EventId, rumor: &UnsignedEvent) -> Resul
         Tag::identifier(id),
         Tag::public_key(rumor.pubkey),
         Tag::custom("r", [room_id]),
-        Tag::custom("k", [rumor.kind.to_string()]),
+        Tag::custom("k", ["14"]),
     ];
 
     let event = EventBuilder::new(Kind::ApplicationSpecificData, rumor.as_json())

crates/chat/src/message.rs

@@ -4,9 +4,6 @@ use std::ops::Range;
 use common::{EventExt, NostrParser, extract_and_remove_media_urls};
 use gpui::{SharedString, SharedUri};
 use nostr_sdk::prelude::*;
-use state::FileAttachment;
-
-pub const KIND_FILE_MESSAGE: Kind = Kind::Custom(15);
 
 /// Rendered message.
 #[derive(Debug, Clone)]
@@ -24,90 +21,61 @@ pub struct Message {
     pub mentions: Vec<Mention>,
     /// List of event of the message this message is a reply to
     pub replies_to: Vec<EventId>,
-    /// Encrypted file attachment
-    pub file: Option<FileAttachment>,
 }
 
 impl From<&Event> for Message {
     fn from(val: &Event) -> Self {
-        from_parts(
-            val.id,
-            val.pubkey,
-            val.created_at,
-            val.kind,
-            &val.content,
-            &val.tags,
-        )
+        let mentions = extract_mentions(&val.content);
+        let replies_to = extract_reply_ids(&val.tags);
+        let (media, string) = extract_and_remove_media_urls(&val.content);
+
+        Self {
+            id: val.id,
+            author: val.pubkey,
+            content: string,
+            media,
+            created_at: val.created_at,
+            mentions,
+            replies_to,
+        }
     }
 }
 
 impl From<&UnsignedEvent> for Message {
     fn from(val: &UnsignedEvent) -> Self {
-        from_parts(
+        let mentions = extract_mentions(&val.content);
+        let replies_to = extract_reply_ids(&val.tags);
+        let (media, string) = extract_and_remove_media_urls(&val.content);
+
+        Self {
             // Event ID must be known
-            val.id.unwrap(),
-            val.pubkey,
-            val.created_at,
-            val.kind,
-            &val.content,
-            &val.tags,
-        )
+            id: val.id.unwrap(),
+            author: val.pubkey,
+            content: string,
+            media,
+            created_at: val.created_at,
+            mentions,
+            replies_to,
+        }
     }
 }
 
 impl From<&NewMessage> for Message {
     fn from(val: &NewMessage) -> Self {
-        from_parts(
+        let mentions = extract_mentions(&val.rumor.content);
+        let replies_to = extract_reply_ids(&val.rumor.tags);
+        let (media, string) = extract_and_remove_media_urls(&val.rumor.content);
+
+        Self {
             // Event ID must be known
-            val.rumor.id.unwrap(),
-            val.rumor.pubkey,
-            val.rumor.created_at,
-            val.rumor.kind,
-            &val.rumor.content,
-            &val.rumor.tags,
-        )
-    }
-}
-
-fn from_parts(
-    id: EventId,
-    author: PublicKey,
-    created_at: Timestamp,
-    kind: Kind,
-    content: &str,
-    tags: &Tags,
-) -> Message {
-    let file = if kind == KIND_FILE_MESSAGE {
-        FileAttachment::from_tags(content, tags)
-    } else {
-        None
-    };
-    let has_file = file.is_some();
-
-    let replies_to = extract_reply_ids(tags);
-
-    // For file messages `.content` is the encrypted blob URL, not text or media
-    let mentions = if has_file {
-        Vec::new()
-    } else {
-        extract_mentions(content)
-    };
-
-    let (media, content) = if has_file {
-        (Vec::new(), String::new())
-    } else {
-        extract_and_remove_media_urls(content)
-    };
-
-    Message {
-        id,
-        author,
-        content,
-        media,
-        created_at,
-        mentions,
-        replies_to,
-        file,
+            id: val.rumor.id.unwrap(),
+            author: val.rumor.pubkey,
+            content: string,
+            media,
+            created_at: val.rumor.created_at,
+            mentions,
+            replies_to,
+        }
     }
 }
 
@@ -137,17 +105,6 @@ impl Hash for Message {
     }
 }
 
-impl Message {
-    /// Single-line representation for reply previews, notifications and copy.
-    pub fn preview(&self) -> SharedString {
-        if let Some(file) = &self.file {
-            return format!("[File] {}", file.display_name()).into();
-        }
-
-        self.content.clone().into()
-    }
-}
-
 /// New message.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct NewMessage {

crates/chat/src/room.rs

@@ -12,7 +12,7 @@ use person::{Person, PersonRegistry};
 use settings::{RoomConfig, SignerKind};
 use state::{NostrRegistry, TIMEOUT, UniversalSigner};
 
-use crate::{FileAttachment, KIND_FILE_MESSAGE, NewMessage};
+use crate::NewMessage;
 
 const NO_DEKEY: &str = "User hasn't set up a decoupled encryption key yet.";
 const USER_NO_DEKEY: &str = "You haven't set up a decoupled encryption key or it's not available.";
@@ -439,51 +439,11 @@ impl Room {
         let content: String = content.into();
         let replies: Vec<EventId> = replies.into_iter().collect();
 
-        // Get current user's public key
-        let nostr = NostrRegistry::global(cx);
-        let sender = nostr.read(cx).current_user()?;
-
-        // Construct a direct message rumor event
-        // WARNING: never sign and send this event to relays
-        let mut event = EventBuilder::new(kind, content)
-            .tags(self.conversation_tags(&replies, sender, cx))
-            .finalize_unsigned(sender);
-
-        // Ensure that the ID is set
-        event.ensure_id();
-
-        Some(event)
-    }
-
-    // Construct a rumor event for an encrypted file message (NIP-17 kind 15)
-    pub fn file_rumor<I>(&self, file: FileAttachment, replies: I, cx: &App) -> Option<UnsignedEvent>
-    where
-        I: IntoIterator<Item = EventId>,
-    {
-        let replies: Vec<EventId> = replies.into_iter().collect();
-
-        // Get current user's public key
-        let nostr = NostrRegistry::global(cx);
-        let sender = nostr.read(cx).current_user()?;
-
-        let mut tags = self.conversation_tags(&replies, sender, cx);
-        tags.extend(file.tags());
-
-        // Construct a file message rumor event
-        // WARNING: never sign and send this event to relays
-        let mut event = EventBuilder::new(KIND_FILE_MESSAGE, file.url.to_string())
-            .tags(tags)
-            .finalize_unsigned(sender);
-
-        // Ensure that the ID is set
-        event.ensure_id();
-
-        Some(event)
-    }
-
-    // Build the `subject` + reply `e` tags + receiver `p` tags (excluding `sender`)
-    fn conversation_tags(&self, replies: &[EventId], sender: PublicKey, cx: &App) -> Vec<Tag> {
         let persons = PersonRegistry::global(cx);
+        let nostr = NostrRegistry::global(cx);
+
+        // Get current user's public key
+        let sender = nostr.read(cx).current_user()?;
 
         // Construct event's tags
         let mut tags = vec![];
@@ -494,8 +454,8 @@ impl Room {
         }
 
         // Add all reply tags
-        for id in replies {
-            tags.push(Tag::event(*id))
+        for id in replies.into_iter() {
+            tags.push(Tag::event(id))
         }
 
         // Add all receiver tags (no intermediate allocation)
@@ -507,7 +467,16 @@ impl Room {
             }));
         }
 
-        tags
+        // Construct a direct message rumor event
+        // WARNING: never sign and send this event to relays
+        let mut event = EventBuilder::new(kind, content)
+            .tags(tags)
+            .finalize_unsigned(sender);
+
+        // Ensure that the ID is set
+        event.ensure_id();
+
+        Some(event)
     }
 
     /// Select the appropriate signer based on signer kind and available keys.
@@ -640,7 +609,7 @@ async fn send_gift_wrap(
     rumor: &UnsignedEvent,
     config: &SignerKind,
 ) -> Result<SendReport, Error> {
-    let k_tag = Tag::custom("k", [rumor.kind.to_string()]);
+    let k_tag = Tag::custom("k", vec!["14"]);
     let mut extra_tags = vec![k_tag];
 
     // Determine the receiver public key based on the config

crates/chat_ui/src/file.rs

@@ -1,32 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use chat::FileAttachment;
-use gpui::SharedString;
-use nostr_sdk::prelude::*;
-
-/// A file attachment that has been uploaded, but not sent yet.
-///
-/// The local `path` is kept around so the composer can preview
-/// the file without downloading and decrypting it again.
-pub(crate) struct PendingFile {
-    pub file: FileAttachment,
-    pub path: PathBuf,
-}
-
-/// State of the encrypted file attachment of a message
-pub(crate) enum DecryptedFile {
-    Loading,
-    Ready(PathBuf),
-    Failed(SharedString),
-}
-
-/// Result of an upload, either plain or encrypted
-pub(crate) enum Uploaded {
-    Url(Url),
-    File(FileAttachment, PathBuf),
-}
-
-/// A `file://` url for a decrypted file, so it can be opened by the OS
-pub(crate) fn file_url(path: &Path) -> String {
-    format!("file://{}", path.display())
-}

crates/chat_ui/src/lib.rs

@@ -1,11 +1,10 @@
 use std::collections::{BTreeMap, HashMap, HashSet};
-use std::path::PathBuf;
 use std::sync::{Arc, LazyLock, RwLock};
 
 pub use actions::*;
-use anyhow::Error;
+use anyhow::{Context as AnyhowContext, Error};
 use chat::{ChatRegistry, Message, Room, RoomEvent, SendReport, SendStatus};
-use common::TimestampExt;
+use common::{TimestampExt, coop_cache};
 use futures::lock::Mutex;
 use gpui::prelude::FluentBuilder;
 use gpui::{
@@ -13,8 +12,8 @@ use gpui::{
     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,
-    retain_all, svg, white,
+    SystemNotificationAction, Task, WeakEntity, Window, div, img, list, px, red, relative, svg,
+    white,
 };
 use itertools::Itertools;
 use nostr_sdk::prelude::*;
@@ -22,9 +21,7 @@ use person::{Person, PersonRegistry};
 use regex::Regex;
 use settings::{AppSettings, SignerKind};
 use smallvec::{SmallVec, smallvec};
-use state::{
-    FileAttachment, NostrRegistry, download_and_decrypt_to_file, upload, upload_encrypted,
-};
+use state::{NostrRegistry, upload};
 use theme::ActiveTheme;
 use ui::avatar::Avatar;
 use ui::button::{Button, ButtonVariants};
@@ -33,13 +30,11 @@ use ui::input::{Input, InputEvent, InputState};
 use ui::menu::DropdownMenu;
 use ui::notification::Notification;
 use ui::scroll::Scrollbar;
-use ui::tooltip::Tooltip;
 use ui::{
     Disableable, Icon, IconName, InteractiveElementExt, Sizable, StyledExt, WindowExtension,
     h_flex, v_flex,
 };
 
-use crate::file::*;
 use crate::text::RenderedText;
 
 const REACTION_EMOJIS: &[&str] = &["👍", "👎", "😄", "🎉", "😕", "❤️", "🚀", "👀"];
@@ -51,7 +46,6 @@ static EMOJI_RE: LazyLock<Regex> =
     LazyLock::new(|| Regex::new(r"^[\p{Emoji}\u{200D}\u{FE0F}\u{20E3}]+$").unwrap());
 
 mod actions;
-mod file;
 mod text;
 
 pub fn init(room: WeakEntity<Room>, window: &mut Window, cx: &mut App) -> Entity<ChatPanel> {
@@ -102,12 +96,6 @@ pub struct ChatPanel {
     /// Media Attachment
     attachments: Entity<Vec<Url>>,
 
-    /// Uploaded, encrypted file attachments which are not sent yet
-    encrypted_attachments: Entity<Vec<PendingFile>>,
-
-    /// Decrypted attachments of file messages, by message id
-    decrypted_files: HashMap<EventId, DecryptedFile>,
-
     /// Upload state
     uploading: bool,
 
@@ -122,7 +110,6 @@ impl ChatPanel {
     pub fn new(room: WeakEntity<Room>, window: &mut Window, cx: &mut Context<Self>) -> Self {
         // Define attachments and replies_to entities
         let attachments = cx.new(|_| vec![]);
-        let encrypted_attachments = cx.new(|_| vec![]);
         let replies_to = cx.new(|_| HashSet::new());
         let reports_by_id = Arc::new(RwLock::new(BTreeMap::new()));
 
@@ -198,8 +185,6 @@ impl ChatPanel {
             subject_bar,
             replies_to,
             attachments,
-            encrypted_attachments,
-            decrypted_files: HashMap::new(),
             rendered_texts_by_id: BTreeMap::new(),
             reports_by_id,
             sent_ids: Arc::new(Mutex::new(Vec::new())),
@@ -257,33 +242,44 @@ impl ChatPanel {
             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() {
-                            let Some(output) = report.output.as_mut() else {
-                                continue;
-                            };
-                            if *output.id() != status_id {
-                                continue;
-                            }
-                            match &*status {
-                                SendStatus::Ok { relay, .. } => {
-                                    output.success.insert(relay.clone(), EventSendStatus::Sent);
+                    // Drain the whole queue in a single update so bursts of
+                    // send statuses collapse into one repaint (important on
+                    // wasm, where everything runs on the main thread).
+                    let mut statuses = vec![status];
+                    while let Ok(extra) = rx.try_recv() {
+                        statuses.push(extra);
+                    }
+
+                    for status in statuses {
+                        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() {
+                                let Some(output) = report.output.as_mut() else {
+                                    continue;
+                                };
+                                if *output.id() != status_id {
+                                    continue;
                                 }
-                                SendStatus::Failed { relay, message, .. } => {
-                                    output.failed.insert(relay.clone(), message.clone());
+                                match &*status {
+                                    SendStatus::Ok { relay, .. } => {
+                                        output.success.insert(relay.clone(), EventSendStatus::Sent);
+                                    }
+                                    SendStatus::Failed { relay, message, .. } => {
+                                        output.failed.insert(relay.clone(), message.clone());
+                                    }
                                 }
+                                break 'outer;
                             }
-                            break 'outer;
                         }
                     }
                 }
-                this.update(cx, |_, cx| cx.notify()).ok();
+                this.update_in(cx, |_, _window, cx| cx.notify()).ok();
             }
             Ok(())
         }));
@@ -340,8 +336,10 @@ impl ChatPanel {
         self.tasks.push(cx.spawn(async move |this, cx| {
             let events = get_messages.await?;
 
-            // Update message list
-            this.update(cx, |this, cx| {
+            // Update message list. `update_in` (rather than `update`) routes
+            // through a try-borrow: on wasm a task poll that lands while the
+            // app context is borrowed can't panic and kill this task.
+            this.update_in(cx, |this, _window, cx| {
                 this.insert_messages(&events, cx);
             })?;
 
@@ -385,32 +383,21 @@ impl ChatPanel {
     }
 
     fn send_text_message(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        // Get the message which includes all plain attachments
+        // 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();
 
-        // Uploaded files are sent as encrypted file messages
-        let files: Vec<FileAttachment> = self
-            .encrypted_attachments
-            .read(cx)
-            .iter()
-            .map(|pending| pending.file.clone())
-            .collect();
-
-        // Return if there is nothing to send
-        if content.trim().is_empty() && files.is_empty() {
+        // 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()
-            && files.is_empty()
+        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);
@@ -419,15 +406,7 @@ impl ChatPanel {
             return;
         }
 
-        // Send the text part, including the plain attachment urls
-        if !content.trim().is_empty() {
-            self.send_message(&content, replies.clone(), false, window, cx);
-        }
-
-        // Send every file as its own encrypted file message
-        for file in files {
-            self.send_file(file, replies.clone(), window, cx);
-        }
+        self.send_message(&content, replies, false, window, cx);
     }
 
     fn send_reaction(
@@ -460,60 +439,30 @@ impl ChatPanel {
             return;
         }
 
-        // Upgrade room and create rumor + send task in a single read lock
-        let Some(room) = self.room.upgrade() else {
-            return;
-        };
-
-        let outcome = room.read_with(cx, |room, cx| {
-            let rumor = room.rumor(value, replies, reaction, cx)?;
-            let send_task = room.send(rumor.clone(), cx)?;
-
-            Some((rumor, send_task))
-        });
-
-        match outcome {
-            Some((rumor, send_task)) => self.dispatch(rumor, send_task, window, cx),
-            None => window.push_notification("Failed to create message", cx),
-        }
-    }
-
-    /// Send an encrypted file message (NIP-17 kind 15) to all members of the chat
-    fn send_file(
-        &mut self,
-        file: FileAttachment,
-        replies: Vec<EventId>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let Some(room) = self.room.upgrade() else {
-            return;
-        };
-
-        let outcome = room.read_with(cx, |room, cx| {
-            let rumor = room.file_rumor(file, replies, cx)?;
-            let send_task = room.send(rumor.clone(), cx)?;
-
-            Some((rumor, send_task))
-        });
-
-        match outcome {
-            Some((rumor, send_task)) => self.dispatch(rumor, send_task, window, cx),
-            None => window.push_notification("Failed to create message", cx),
-        }
-    }
-
-    /// Insert a rumor optimistically and track the send reports of its gift wraps
-    fn dispatch(
-        &mut self,
-        rumor: UnsignedEvent,
-        send_task: Task<Vec<SendReport>>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let id = rumor.id.expect("rumor must have an id");
+        let room = self.room.clone();
+        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;
+        };
+
+        // 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,
+            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);
@@ -532,7 +481,10 @@ impl ChatPanel {
             let mut sent_ids = sent_ids.lock().await;
             sent_ids.extend(outputs.iter().filter_map(|output| output.gift_wrap_id));
 
-            this.update(cx, |this, cx| {
+            // `update_in` (rather than `update`) routes through a try-borrow:
+            // on wasm a poll that lands while the app context is borrowed
+            // can't panic and kill this task.
+            this.update_in(cx, |this, _window, cx| {
                 this.insert_reports(id, outputs, cx);
             })?;
 
@@ -551,10 +503,6 @@ impl ChatPanel {
             this.clear();
             cx.notify();
         });
-        self.encrypted_attachments.update(cx, |this, cx| {
-            this.clear();
-            cx.notify();
-        });
         self.replies_to.update(cx, |this, cx| {
             this.clear();
             cx.notify();
@@ -672,7 +620,7 @@ impl ChatPanel {
         let Some(message) = self.message(id) else {
             return;
         };
-        let content = message.preview().to_string();
+        let content = message.content.to_string();
         let item = ClipboardItem::new_string(content);
 
         cx.write_to_clipboard(item);
@@ -698,9 +646,6 @@ impl ChatPanel {
         // Get the user's configured blossom server
         let server = AppSettings::get_file_server(cx);
 
-        // Encrypt attachments which are not part of a message being written
-        let encrypted = self.input.read(cx).value().trim().is_empty();
-
         // Ask user for file upload
         let path = cx.prompt_for_paths(PathPromptOptions {
             files: true,
@@ -710,95 +655,36 @@ impl ChatPanel {
         });
 
         self.tasks.push(cx.spawn_in(window, async move |this, cx| {
-            // Selecting no file means the prompt was cancelled
-            let Some(path) = path.await??.and_then(|mut paths| paths.pop()) else {
-                return Ok(());
-            };
-
-            this.update_in(cx, |this, window, cx| {
-                this.upload_file(server, path, encrypted, window, cx);
+            this.update_in(cx, |this, _window, cx| {
+                this.set_uploading(true, cx);
             })?;
 
-            Ok(())
-        }));
-    }
+            let mut paths = path.await??.context("Not found")?;
+            let path = paths.pop().context("No path")?;
 
-    /// Upload a file, encrypted when the attachment is the whole message
-    fn upload_file(
-        &mut self,
-        server: Url,
-        path: PathBuf,
-        encrypted: bool,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.set_uploading(true, cx);
-
-        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
-            let result = if encrypted {
-                upload_encrypted(server.clone(), path.clone(), cx)
-                    .await
-                    .map(|file| Uploaded::File(file, path.clone()))
-            } else {
-                upload(server.clone(), path.clone(), cx)
-                    .await
-                    .map(Uploaded::Url)
-            };
-
-            this.update_in(cx, |this, window, cx| {
-                this.set_uploading(false, cx);
-
-                match result {
-                    Ok(Uploaded::Url(url)) => this.add_attachment(url, cx),
-                    Ok(Uploaded::File(file, path)) => this.add_pending_file(file, path, cx),
-                    Err(e) if encrypted => {
-                        this.report_encrypted_upload_error(server, path, e, window, cx)
-                    }
-                    Err(e) => {
+            // Upload via blossom client
+            match upload(server, path, cx).await {
+                Ok(url) => {
+                    this.update_in(cx, |this, _window, cx| {
+                        this.add_attachment(url, cx);
+                        this.set_uploading(false, cx);
+                    })?;
+                }
+                Err(e) => {
+                    this.update_in(cx, |this, window, cx| {
+                        this.set_uploading(false, cx);
                         window.push_notification(
                             Notification::error(e.to_string()).autohide(false),
                             cx,
                         );
-                    }
+                    })?;
                 }
-            })?;
+            }
 
             Ok(())
         }));
     }
 
-    /// Report a failed encrypted upload, offering to retry it without encryption
-    fn report_encrypted_upload_error(
-        &mut self,
-        server: Url,
-        path: PathBuf,
-        error: Error,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let view = cx.entity().downgrade();
-
-        window.push_notification(
-            Notification::error(error.to_string())
-                .title("Encrypted upload failed")
-                .action(move |_this, _window, _cx| {
-                    let view = view.clone();
-                    let server = server.clone();
-                    let path = path.clone();
-
-                    Button::new("retry-without-encryption")
-                        .label("Upload without encryption")
-                        .on_click(move |_ev, window, cx| {
-                            view.update(cx, |this, cx| {
-                                this.upload_file(server.clone(), path.clone(), false, window, cx);
-                            })
-                            .ok();
-                        })
-                }),
-            cx,
-        );
-    }
-
     fn set_uploading(&mut self, uploading: bool, cx: &mut Context<Self>) {
         self.uploading = uploading;
         cx.notify();
@@ -820,88 +706,6 @@ impl ChatPanel {
         });
     }
 
-    fn add_pending_file(&mut self, file: FileAttachment, path: PathBuf, cx: &mut Context<Self>) {
-        self.encrypted_attachments.update(cx, |this, cx| {
-            this.push(PendingFile { file, path });
-            cx.notify();
-        });
-    }
-
-    fn remove_pending_file(&mut self, url: &Url, cx: &mut Context<Self>) {
-        self.encrypted_attachments.update(cx, |this, cx| {
-            if let Some(ix) = this.iter().position(|pending| &pending.file.url == url) {
-                this.remove(ix);
-                cx.notify();
-            }
-        });
-    }
-
-    /// Download and decrypt the attachment of a file message for preview
-    fn load_file(&mut self, id: EventId, file: FileAttachment, cx: &mut Context<Self>) {
-        self.decrypted_files.insert(id, DecryptedFile::Loading);
-
-        self.tasks.push(cx.spawn(async move |this, cx| {
-            let result = download_and_decrypt_to_file(&file, cx).await;
-
-            this.update(cx, |this, cx| {
-                match result {
-                    Ok(path) => {
-                        this.decrypted_files.insert(id, DecryptedFile::Ready(path));
-                    }
-                    Err(e) => {
-                        this.decrypted_files
-                            .insert(id, DecryptedFile::Failed(e.to_string().into()));
-                    }
-                }
-
-                cx.notify();
-            })?;
-
-            Ok(())
-        }));
-    }
-
-    /// Decrypt the attachment of a file message and open it with the OS
-    fn open_file(
-        &mut self,
-        id: EventId,
-        file: FileAttachment,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        match self.decrypted_files.get(&id) {
-            Some(DecryptedFile::Ready(path)) => {
-                cx.open_url(&file_url(path));
-                return;
-            }
-            Some(DecryptedFile::Loading) => return,
-            _ => {}
-        };
-
-        self.decrypted_files.insert(id, DecryptedFile::Loading);
-
-        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
-            let result = download_and_decrypt_to_file(&file, cx).await;
-
-            this.update_in(cx, |this, _window, cx| {
-                match result {
-                    Ok(path) => {
-                        cx.open_url(&file_url(&path));
-                        this.decrypted_files.insert(id, DecryptedFile::Ready(path));
-                    }
-                    Err(e) => {
-                        this.decrypted_files
-                            .insert(id, DecryptedFile::Failed(e.to_string().into()));
-                    }
-                }
-
-                cx.notify();
-            })?;
-
-            Ok(())
-        }));
-    }
-
     fn profile(&self, public_key: &PublicKey, cx: &App) -> Person {
         let persons = PersonRegistry::global(cx);
         persons.read(cx).get(public_key, cx)
@@ -1141,16 +945,6 @@ impl ChatPanel {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> AnyElement {
-        let file = self.messages.get(ix).and_then(|message| {
-            let file = message.file.clone()?;
-            (!self.decrypted_files.contains_key(&message.id) && file.is_image())
-                .then_some((message.id, file))
-        });
-
-        if let Some((id, file)) = file {
-            self.load_file(id, file, cx);
-        }
-
         if let Some(message) = self.messages.get(ix) {
             let persons = PersonRegistry::global(cx);
             let show_author = self.is_group_start(ix);
@@ -1158,7 +952,7 @@ impl ChatPanel {
                 .rendered_texts_by_id
                 .entry(message.id)
                 .or_insert_with(|| {
-                    RenderedText::new(&message.content, &message.mentions, &persons, true, cx)
+                    RenderedText::new(&message.content, &message.mentions, &persons, cx)
                 })
                 .element(ix.into(), window, cx);
 
@@ -1238,11 +1032,8 @@ impl ChatPanel {
                             .when(has_replies, |this| {
                                 this.children(self.render_message_replies(replies, cx))
                             })
-                            .when(message.file.is_none(), |this| this.child(rendered_text))
+                            .child(rendered_text)
                             .child(self.render_media(&message.media, cx))
-                            .when_some(message.file.as_ref(), |this, file| {
-                                this.child(self.render_message_file(&id, file, cx))
-                            })
                             .when(has_reactions, |this| {
                                 this.child(self.render_reactions(&id, cx))
                             }),
@@ -1348,7 +1139,7 @@ impl ChatPanel {
                             .w_full()
                             .text_ellipsis()
                             .line_clamp(1)
-                            .child(message.preview()),
+                            .child(SharedString::from(&message.content)),
                     )
                     .hover(|this| this.bg(cx.theme().elevated_surface_background))
                     .on_click({
@@ -1652,7 +1443,7 @@ impl ChatPanel {
                     .size_16()
                     .when(cx.theme().shadow, |this| this.shadow_lg())
                     .rounded(cx.theme().radius)
-                    .object_fit(ObjectFit::Cover),
+                    .object_fit(ObjectFit::ScaleDown),
             )
             .child(
                 div()
@@ -1689,159 +1480,6 @@ impl ChatPanel {
         items
     }
 
-    /// Render the encrypted file attachment of a message
-    fn render_message_file(
-        &self,
-        id: &EventId,
-        file: &FileAttachment,
-        cx: &Context<Self>,
-    ) -> AnyElement {
-        let state = self.decrypted_files.get(id);
-
-        if let Some(path) = state
-            .and_then(|state| match state {
-                DecryptedFile::Ready(path) => Some(path),
-                _ => None,
-            })
-            .filter(|_| file.is_image())
-        {
-            return div()
-                .child(
-                    img(path.clone())
-                        .border_1()
-                        .border_color(cx.theme().border_variant)
-                        .h(px(250.))
-                        .object_fit(ObjectFit::Cover)
-                        .rounded(cx.theme().radius),
-                )
-                .into_any_element();
-        }
-
-        let label = match state {
-            Some(DecryptedFile::Loading) => SharedString::from("Decrypting..."),
-            Some(DecryptedFile::Failed(error)) => error.clone(),
-            Some(DecryptedFile::Ready(_)) => SharedString::from("Click to open"),
-            None => SharedString::from("Click to decrypt"),
-        };
-
-        self.render_file_chip(id, file, label, cx)
-    }
-
-    /// Render an encrypted file as a chip which decrypts and opens it on click
-    fn render_file_chip(
-        &self,
-        id: &EventId,
-        file: &FileAttachment,
-        label: SharedString,
-        cx: &Context<Self>,
-    ) -> AnyElement {
-        h_flex()
-            .id(SharedString::from(format!("file-{id}")))
-            .self_start()
-            .items_start()
-            .min_w_0()
-            .gap_2()
-            .p_2()
-            .border_1()
-            .border_color(cx.theme().border_variant)
-            .rounded(cx.theme().radius)
-            .child(Icon::new(IconName::Lock).text_color(cx.theme().icon_accent))
-            .child(
-                v_flex()
-                    .min_w_0()
-                    .overflow_hidden()
-                    .text_sm()
-                    .child(div().line_height(relative(1.2)).child(file.display_name()))
-                    .child(
-                        div()
-                            .text_xs()
-                            .text_color(cx.theme().text_placeholder)
-                            .child(label),
-                    ),
-            )
-            .on_click({
-                let file = file.clone();
-                let id = *id;
-
-                cx.listener(move |this, _, window, cx| {
-                    this.open_file(id, file.clone(), window, cx);
-                })
-            })
-            .into_any_element()
-    }
-
-    /// Render an uploaded, encrypted file which is not sent yet
-    fn render_pending_file(&self, pending: &PendingFile, cx: &Context<Self>) -> impl IntoElement {
-        let file = &pending.file;
-        let label = file.display_name();
-
-        div()
-            .id(SharedString::from(file.url.to_string()))
-            .relative()
-            .w_16()
-            .tooltip(move |window, cx| Tooltip::new(label.clone(), window, cx).into())
-            .map(|this| {
-                if file.is_image() {
-                    this.child(
-                        img(pending.path.clone())
-                            .size_16()
-                            .when(cx.theme().shadow, |this| this.shadow_sm())
-                            .rounded(cx.theme().radius)
-                            .object_fit(ObjectFit::Cover),
-                    )
-                } else {
-                    this.child(
-                        div()
-                            .size_16()
-                            .flex()
-                            .items_center()
-                            .justify_center()
-                            .rounded(cx.theme().radius)
-                            .border_1()
-                            .border_color(cx.theme().border_variant)
-                            .bg(cx.theme().surface_background)
-                            .text_xs()
-                            .text_center()
-                            .child("Preview not available"),
-                    )
-                }
-            })
-            .child(
-                v_flex()
-                    .absolute()
-                    .top_neg_1()
-                    .right_neg_1()
-                    .size_4()
-                    .items_center()
-                    .justify_center()
-                    .rounded_full()
-                    .border_1()
-                    .border_color(cx.theme().border_variant)
-                    .bg(gpui::green())
-                    .child(Icon::new(IconName::Lock).size_2().text_color(gpui::white())),
-            )
-            .on_click({
-                let url = file.url.clone();
-                cx.listener(move |this, _, _, cx| {
-                    this.remove_pending_file(&url, cx);
-                })
-            })
-    }
-
-    fn render_pending_file_list(
-        &self,
-        _window: &Window,
-        cx: &Context<Self>,
-    ) -> impl IntoIterator<Item = impl IntoElement> {
-        let mut items = vec![];
-
-        for pending in self.encrypted_attachments.read(cx).iter() {
-            items.push(self.render_pending_file(pending, cx));
-        }
-
-        items
-    }
-
     fn render_reply(&self, id: &EventId, cx: &Context<Self>) -> impl IntoElement {
         if let Some(text) = self.message(id) {
             let persons = PersonRegistry::global(cx);
@@ -1890,7 +1528,7 @@ impl ChatPanel {
                         .text_sm()
                         .text_ellipsis()
                         .line_clamp(1)
-                        .child(text.preview()),
+                        .child(SharedString::from(&text.content)),
                 )
         } else {
             div()
@@ -2018,13 +1656,8 @@ impl Focusable for ChatPanel {
 
 impl Render for ChatPanel {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        const WARNING: &str = "Attachments added while typing are uploaded without encryption";
-
-        let is_typing = !self.input.read(cx).value().trim().is_empty();
-        let pending_attachments = !self.encrypted_attachments.read(cx).is_empty();
-
         v_flex()
-            .image_cache(retain_all(self.id.clone()))
+            .image_cache(coop_cache(self.id.clone(), 100))
             .on_action(cx.listener(Self::on_command))
             .size_full()
             .when(*self.subject_bar.read(cx), |this| {
@@ -2056,8 +1689,10 @@ impl Render for ChatPanel {
                     .map(|this| {
                         if self.messages.is_empty() {
                             this.child(
-                                h_flex()
+                                div()
                                     .size_full()
+                                    .flex()
+                                    .items_center()
                                     .justify_end()
                                     .child(self.render_announcement(cx)),
                             )
@@ -2082,17 +1717,7 @@ impl Render for ChatPanel {
                     .w_full()
                     .gap_1p5()
                     .children(self.render_attachment_list(window, cx))
-                    .children(self.render_pending_file_list(window, cx))
                     .children(self.render_reply_list(window, cx))
-                    .when(is_typing && pending_attachments, |this| {
-                        this.child(
-                            div()
-                                .px_1()
-                                .text_xs()
-                                .text_color(cx.theme().text_warning)
-                                .child(WARNING),
-                        )
-                    })
                     .child(
                         h_flex()
                             .items_end()

crates/chat_ui/src/text.rs

@@ -1,19 +1,17 @@
 use std::ops::Range;
-use std::sync::{Arc, LazyLock};
+use std::sync::Arc;
 
 use chat::Mention;
+use common::RangeExt;
 use gpui::{
     AnyElement, App, ElementId, Entity, FontStyle, FontWeight, HighlightStyle, InteractiveText,
     IntoElement, SharedString, StrikethroughStyle, StyledText, UnderlineStyle, Window,
 };
 use person::PersonRegistry;
-use regex::Regex;
 use theme::ActiveTheme;
 
-/// Matches `http://` and `https://` URLs. Only these are treated as clickable links.
-static WEB_URL: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)^https?://").unwrap());
-
 #[allow(clippy::enum_variant_names)]
+#[allow(dead_code)]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Highlight {
     Code,
@@ -41,61 +39,25 @@ impl RenderedText {
         content: &str,
         mentions: &[Mention],
         persons: &Entity<PersonRegistry>,
-        markdown: bool,
         cx: &App,
-    ) -> Self {
-        Self::render(content, mentions, markdown, |mention| {
-            format!("@{}", persons.read(cx).get(&mention.public_key, cx).name())
-        })
-    }
-
-    fn render(
-        content: &str,
-        mentions: &[Mention],
-        markdown: bool,
-        resolve_mention: impl Fn(&Mention) -> String,
     ) -> Self {
         let mut text = String::new();
         let mut highlights = Vec::new();
         let mut link_ranges = Vec::new();
         let mut link_urls = Vec::new();
 
-        render_text_mut(
+        render_plain_text_mut(
             content,
             mentions,
             &mut text,
             &mut highlights,
             &mut link_ranges,
             &mut link_urls,
-            markdown,
-            resolve_mention,
+            persons,
+            cx,
         );
 
-        // Trim trailing whitespace and adjust highlight and link ranges.
-        let trimmed_len = text.trim_end().len();
-
-        // Retain highlights and link ranges that are within the trimmed text.
-        if trimmed_len < text.len() {
-            highlights.retain_mut(|(range, _)| {
-                range.end = range.end.min(trimmed_len);
-                range.start < range.end
-            });
-
-            let mut ix = 0;
-
-            while ix < link_ranges.len() {
-                let range = &mut link_ranges[ix];
-                range.end = range.end.min(trimmed_len);
-                if range.start < range.end {
-                    ix += 1;
-                } else {
-                    link_ranges.remove(ix);
-                    link_urls.remove(ix);
-                }
-            }
-
-            text.truncate(trimmed_len);
-        }
+        text.truncate(text.trim_end().len());
 
         RenderedText {
             text: SharedString::from(text),
@@ -108,71 +70,55 @@ impl RenderedText {
     pub fn element(&self, id: ElementId, window: &Window, cx: &App) -> AnyElement {
         let code_background = cx.theme().elevated_surface_background;
         let color = cx.theme().text_accent;
-        let code_font = if cfg!(target_os = "macos") {
-            "Menlo"
-        } else if cfg!(target_os = "windows") {
-            "Consolas"
-        } else {
-            "monospace"
-        };
 
         InteractiveText::new(
             id,
-            StyledText::new(self.text.clone())
-                .with_default_highlights(
-                    &window.text_style(),
-                    self.highlights.iter().map(|(range, highlight)| {
-                        (
-                            range.clone(),
-                            match highlight {
-                                Highlight::Code => HighlightStyle {
-                                    background_color: Some(code_background),
-                                    ..Default::default()
-                                },
-                                Highlight::InlineCode(link) => {
-                                    if *link {
-                                        HighlightStyle {
-                                            background_color: Some(code_background),
-                                            underline: Some(UnderlineStyle {
-                                                thickness: 1.0.into(),
-                                                ..Default::default()
-                                            }),
+            StyledText::new(self.text.clone()).with_default_highlights(
+                &window.text_style(),
+                self.highlights.iter().map(|(range, highlight)| {
+                    (
+                        range.clone(),
+                        match highlight {
+                            Highlight::Code => HighlightStyle {
+                                background_color: Some(code_background),
+                                ..Default::default()
+                            },
+                            Highlight::InlineCode(link) => {
+                                if *link {
+                                    HighlightStyle {
+                                        background_color: Some(code_background),
+                                        underline: Some(UnderlineStyle {
+                                            thickness: 1.0.into(),
                                             ..Default::default()
-                                        }
-                                    } else {
-                                        HighlightStyle {
-                                            background_color: Some(code_background),
-                                            ..Default::default()
-                                        }
+                                        }),
+                                        ..Default::default()
+                                    }
+                                } else {
+                                    HighlightStyle {
+                                        background_color: Some(code_background),
+                                        ..Default::default()
                                     }
                                 }
-                                Highlight::Mention => HighlightStyle {
-                                    color: Some(color),
-                                    underline: Some(UnderlineStyle {
-                                        thickness: 1.0.into(),
-                                        ..Default::default()
-                                    }),
+                            }
+                            Highlight::Mention => HighlightStyle {
+                                color: Some(color),
+                                underline: Some(UnderlineStyle {
+                                    thickness: 1.0.into(),
                                     ..Default::default()
-                                },
-                                Highlight::Highlight(highlight) => *highlight,
+                                }),
+                                ..Default::default()
                             },
-                        )
-                    }),
-                )
-                .with_font_family_overrides(self.highlights.iter().filter_map(
-                    |(range, highlight)| match highlight {
-                        Highlight::Code | Highlight::InlineCode(_) => {
-                            Some((range.clone(), code_font.into()))
-                        }
-                        _ => None,
-                    },
-                )),
+                            Highlight::Highlight(highlight) => *highlight,
+                        },
+                    )
+                }),
+            ),
         )
         .on_click(self.link_ranges.clone(), {
             let link_urls = self.link_urls.clone();
             move |ix, _, cx| {
                 let url = &link_urls[ix];
-                if WEB_URL.is_match(url) {
+                if url.starts_with("http") {
                     cx.open_url(url);
                 }
             }
@@ -182,15 +128,15 @@ impl RenderedText {
 }
 
 #[allow(clippy::too_many_arguments)]
-fn render_text_mut(
+fn render_plain_text_mut(
     block: &str,
     mut mentions: &[Mention],
     text: &mut String,
     highlights: &mut Vec<(Range<usize>, Highlight)>,
     link_ranges: &mut Vec<Range<usize>>,
     link_urls: &mut Vec<String>,
-    markdown: bool,
-    resolve_mention: impl Fn(&Mention) -> String,
+    persons: &Entity<PersonRegistry>,
+    cx: &App,
 ) {
     use pulldown_cmark::{Event, Options, Parser, Tag, TagEnd};
 
@@ -199,58 +145,34 @@ fn render_text_mut(
     let mut strikethrough_depth = 0;
     let mut link_url = None;
     let mut list_stack = Vec::new();
-    let mut code_block = false;
 
-    // Only enable the extensions that make sense for chat messages. Notably this leaves
-    // out smart punctuation, tables, math and footnotes: they rewrite or swallow text.
-    let events: Box<dyn Iterator<Item = (Event<'_>, Range<usize>)> + '_> = if markdown {
-        Box::new(Parser::new_ext(block, Options::ENABLE_STRIKETHROUGH).into_offset_iter())
-    } else {
-        Box::new(std::iter::once((Event::Text(block.into()), 0..block.len())))
-    };
+    let mut options = Options::all();
+    options.remove(pulldown_cmark::Options::ENABLE_DEFINITION_LIST);
 
-    for (event, source_range) in events {
+    for (event, source_range) in Parser::new_ext(block, options).into_offset_iter() {
         let prev_len = text.len();
 
         match event {
             Event::Text(t) => {
-                if code_block {
-                    text.push_str(t.as_ref());
-                    highlights.push((prev_len..text.len(), Highlight::Code));
-                    continue;
-                }
-
+                // Process text with mention replacements
                 let t_str = t.as_ref();
                 let mut last_processed = 0;
 
                 while let Some(mention) = mentions.first() {
-                    if mention.range.start >= source_range.end {
+                    if !source_range.contains_inclusive(&mention.range) {
                         break;
                     }
 
-                    mentions = &mentions[1..];
-                    if mention.range.start < source_range.start
-                        || mention.range.end > source_range.end
-                    {
-                        continue;
-                    }
-
-                    let Some(token) = block.get(mention.range.clone()) else {
-                        continue;
-                    };
-
-                    let Some(offset) = t_str[last_processed..].find(token) else {
-                        continue;
-                    };
-
-                    let mention_start_in_text = last_processed + offset;
-                    let mention_end_in_text = mention_start_in_text + token.len();
+                    // Calculate positions within the current text
+                    let mention_start_in_text = mention.range.start - source_range.start;
+                    let mention_end_in_text = mention.range.end - source_range.start;
 
                     // Add text before this mention
                     if mention_start_in_text > last_processed {
                         let before_mention = &t_str[last_processed..mention_start_in_text];
                         process_text_segment(
                             before_mention,
+                            prev_len + last_processed,
                             bold_depth,
                             italic_depth,
                             strikethrough_depth,
@@ -263,7 +185,9 @@ fn render_text_mut(
                     }
 
                     // Process the mention replacement
-                    let replacement_text = resolve_mention(mention);
+                    let profile = persons.read(cx).get(&mention.public_key, cx);
+                    let replacement_text = format!("@{}", profile.name());
+
                     let replacement_start = text.len();
                     text.push_str(&replacement_text);
                     let replacement_end = text.len();
@@ -271,6 +195,7 @@ fn render_text_mut(
                     highlights.push((replacement_start..replacement_end, Highlight::Mention));
 
                     last_processed = mention_end_in_text;
+                    mentions = &mentions[1..];
                 }
 
                 // Add any remaining text after the last mention
@@ -278,6 +203,7 @@ fn render_text_mut(
                     let remaining_text = &t_str[last_processed..];
                     process_text_segment(
                         remaining_text,
+                        prev_len + last_processed,
                         bold_depth,
                         italic_depth,
                         strikethrough_depth,
@@ -308,14 +234,11 @@ fn render_text_mut(
                 }
                 Tag::CodeBlock(_kind) => {
                     new_paragraph(text, &mut list_stack);
-                    code_block = true;
                 }
                 Tag::Emphasis => italic_depth += 1,
                 Tag::Strong => bold_depth += 1,
                 Tag::Strikethrough => strikethrough_depth += 1,
-                Tag::Link { dest_url, .. } => {
-                    link_url = WEB_URL.is_match(&dest_url).then(|| dest_url.to_string());
-                }
+                Tag::Link { dest_url, .. } => link_url = Some(dest_url.to_string()),
                 Tag::List(number) => {
                     list_stack.push((number, false));
                 }
@@ -341,7 +264,6 @@ fn render_text_mut(
                 _ => {}
             },
             Event::End(tag) => match tag {
-                TagEnd::CodeBlock => code_block = false,
                 TagEnd::Heading(_) => bold_depth -= 1,
                 TagEnd::Emphasis => italic_depth -= 1,
                 TagEnd::Strong => bold_depth -= 1,
@@ -350,11 +272,6 @@ fn render_text_mut(
                 TagEnd::List(_) => drop(list_stack.pop()),
                 _ => {}
             },
-            Event::Html(t) | Event::InlineHtml(t) => text.push_str(t.as_ref()),
-            Event::Rule => {
-                new_paragraph(text, &mut list_stack);
-                text.push_str("────────\n");
-            }
             Event::HardBreak => text.push('\n'),
             Event::SoftBreak => text.push('\n'),
             _ => {}
@@ -365,6 +282,7 @@ fn render_text_mut(
 #[allow(clippy::too_many_arguments)]
 fn process_text_segment(
     segment: &str,
+    segment_start: usize,
     bold_depth: i32,
     italic_depth: i32,
     strikethrough_depth: i32,
@@ -389,8 +307,7 @@ fn process_text_segment(
         });
     }
 
-    // Ranges always refer to the rendered text, including replaced mentions.
-    let segment_start = text.len();
+    // Add the text
     text.push_str(segment);
     let text_end = text.len();
 
@@ -413,10 +330,7 @@ fn process_text_segment(
         finder.kinds(&[linkify::LinkKind::Url]);
         let mut last_link_pos = 0;
 
-        for link in finder
-            .links(segment)
-            .filter(|link| WEB_URL.is_match(link.as_str()))
-        {
+        for link in finder.links(segment) {
             let start = link.start();
             let end = link.end();
 
@@ -461,7 +375,6 @@ fn process_text_segment(
 
 fn new_paragraph(text: &mut String, list_stack: &mut [(Option<u64>, bool)]) {
     let mut is_subsequent_paragraph_of_list = false;
-
     if let Some((_, has_content)) = list_stack.last_mut() {
         if *has_content {
             is_subsequent_paragraph_of_list = true;
@@ -477,11 +390,9 @@ fn new_paragraph(text: &mut String, list_stack: &mut [(Option<u64>, bool)]) {
         }
         text.push('\n');
     }
-
     for _ in 0..list_stack.len().saturating_sub(1) {
         text.push_str("  ");
     }
-
     if is_subsequent_paragraph_of_list {
         text.push_str("  ");
     }

crates/common/src/caching.rs

@@ -0,0 +1,135 @@
+use std::collections::{HashMap, VecDeque};
+use std::mem::take;
+
+use futures::FutureExt;
+use gpui::{
+    App, AppContext, Asset, AssetLogger, ElementId, Entity, ImageAssetLoader, ImageCache,
+    ImageCacheItem, ImageCacheProvider, ImageSource, Resource, hash,
+};
+
+pub fn coop_cache(id: impl Into<ElementId>, max_items: usize) -> CoopImageCacheProvider {
+    CoopImageCacheProvider {
+        id: id.into(),
+        max_items,
+    }
+}
+
+pub struct CoopImageCacheProvider {
+    id: ElementId,
+    max_items: usize,
+}
+
+impl ImageCacheProvider for CoopImageCacheProvider {
+    fn provide(&mut self, window: &mut gpui::Window, cx: &mut App) -> gpui::AnyImageCache {
+        window
+            .with_global_id(self.id.clone(), |id, window| {
+                window.with_element_state(id, |cache, _| {
+                    let cache = cache.unwrap_or_else(|| CoopImageCache::new(self.max_items, cx));
+                    (cache.clone(), cache)
+                })
+            })
+            .into()
+    }
+}
+
+pub struct CoopImageCache {
+    max_items: usize,
+    usage_list: VecDeque<u64>,
+    cache: HashMap<u64, (ImageCacheItem, Resource)>,
+}
+
+impl CoopImageCache {
+    pub fn new(max_items: usize, cx: &mut App) -> Entity<Self> {
+        cx.new(|cx| {
+            log::info!("Creating CoopImageCache");
+            cx.on_release(|this: &mut Self, cx| {
+                for (ix, (mut image, resource)) in take(&mut this.cache) {
+                    if let Some(Ok(image)) = image.get() {
+                        log::info!("Dropping image {ix}");
+                        cx.drop_image(image, None);
+                    }
+                    ImageSource::Resource(resource).remove_asset(cx);
+                }
+            })
+            .detach();
+
+            CoopImageCache {
+                max_items,
+                usage_list: VecDeque::with_capacity(max_items),
+                cache: HashMap::with_capacity(max_items),
+            }
+        })
+    }
+}
+
+impl ImageCache for CoopImageCache {
+    fn load(
+        &mut self,
+        resource: &Resource,
+        window: &mut gpui::Window,
+        cx: &mut gpui::App,
+    ) -> Option<Result<std::sync::Arc<gpui::RenderImage>, gpui::ImageCacheError>> {
+        let hash = hash(resource);
+
+        if let Some(item) = self.cache.get_mut(&hash) {
+            let current_idx = self
+                .usage_list
+                .iter()
+                .position(|item| *item == hash)
+                .expect("cache has an item usage_list doesn't");
+
+            self.usage_list.remove(current_idx);
+            self.usage_list.push_front(hash);
+
+            return item.0.get();
+        }
+
+        let load_future = AssetLogger::<ImageAssetLoader>::load(resource.clone(), cx);
+        let task = cx.background_executor().spawn(load_future).shared();
+
+        if self.usage_list.len() >= self.max_items {
+            log::info!("Image cache is full, evicting oldest item");
+
+            if let Some(oldest) = self.usage_list.pop_back() {
+                let mut image = self
+                    .cache
+                    .remove(&oldest)
+                    .expect("usage_list has an item cache doesn't");
+
+                if let Some(Ok(image)) = image.0.get() {
+                    log::info!("requesting image to be dropped");
+                    cx.drop_image(image, Some(window));
+                }
+
+                ImageSource::Resource(image.1).remove_asset(cx);
+            }
+        }
+
+        self.cache.insert(
+            hash,
+            (
+                gpui::ImageCacheItem::Loading(task.clone()),
+                resource.clone(),
+            ),
+        );
+        self.usage_list.push_front(hash);
+
+        let entity = window.current_view();
+
+        window
+            .spawn(cx, async move |cx| {
+                let result = task.await;
+
+                if let Err(err) = result {
+                    log::error!("error loading image into cache: {:?}", err);
+                }
+
+                cx.on_next_frame(move |_, cx| {
+                    cx.notify(entity);
+                });
+            })
+            .detach();
+
+        None
+    }
+}

crates/common/src/lib.rs

@@ -1,3 +1,4 @@
+pub use caching::*;
 pub use debounced_delay::*;
 pub use display::*;
 pub use event::*;
@@ -6,6 +7,7 @@ pub use parser::*;
 pub use paths::*;
 pub use range::*;
 
+mod caching;
 mod debounced_delay;
 mod display;
 mod event;

crates/device/src/lib.rs

@@ -184,7 +184,7 @@ impl DeviceRegistry {
                     }
                     // New response event from the master device
                     Kind::Custom(4455) => {
-                        this.update(cx, |this, cx| {
+                        this.update_in(cx, |this, _window, cx| {
                             this.extract_encryption(event, cx);
                         })?;
                     }
@@ -272,7 +272,7 @@ impl DeviceRegistry {
                 return Ok(());
             }
 
-            this.update(cx, |_this, cx| {
+            this.update_in(cx, |_this, _window, cx| {
                 cx.emit(DeviceEvent::NotSet);
             })?;
 
@@ -287,13 +287,13 @@ impl DeviceRegistry {
         self.tasks.push(cx.spawn(async move |this, cx| {
             match task.await {
                 Ok(keys) => {
-                    this.update(cx, |this, cx| {
+                    this.update_in(cx, |this, _window, cx| {
                         this.set_signer(keys, cx);
                         this.wait_for_request(cx);
                     })?;
                 }
                 Err(e) => {
-                    this.update(cx, |_this, cx| {
+                    this.update_in(cx, |_this, _window, cx| {
                         cx.emit(DeviceEvent::error(e.to_string()));
                     })?;
                 }
@@ -358,12 +358,12 @@ impl DeviceRegistry {
 
         self.tasks.push(cx.spawn(async move |this, cx| {
             if let Ok(keys) = task.await {
-                this.update(cx, |this, cx| {
+                this.update_in(cx, |this, _window, cx| {
                     this.set_signer(keys, cx);
                     this.wait_for_request(cx);
                 })?;
             } else {
-                this.update(cx, |this, cx| {
+                this.update_in(cx, |this, _window, cx| {
                     this.request(cx);
                 })?;
             }
@@ -439,17 +439,17 @@ impl DeviceRegistry {
         self.tasks.push(cx.spawn(async move |this, cx| {
             match task.await {
                 Ok(Some(event)) => {
-                    this.update(cx, |this, cx| {
+                    this.update_in(cx, |this, _window, cx| {
                         this.extract_encryption(event, cx);
                     })?;
                 }
                 Ok(None) => {
-                    this.update(cx, |this, cx| {
+                    this.update_in(cx, |this, _window, cx| {
                         this.wait_for_approval(cx);
                     })?;
                 }
                 Err(e) => {
-                    this.update(cx, |_this, cx| {
+                    this.update_in(cx, |_this, _window, cx| {
                         cx.emit(DeviceEvent::error(e.to_string()));
                     })?;
                 }
@@ -508,12 +508,12 @@ impl DeviceRegistry {
         self.tasks.push(cx.spawn(async move |this, cx| {
             match task.await {
                 Ok(keys) => {
-                    this.update(cx, |this, cx| {
+                    this.update_in(cx, |this, _window, cx| {
                         this.set_signer(keys, cx);
                     })?;
                 }
                 Err(e) => {
-                    this.update(cx, |_this, cx| {
+                    this.update_in(cx, |_this, _window, cx| {
                         cx.emit(DeviceEvent::error(e.to_string()));
                     })?;
                 }

crates/person/Cargo.toml

@@ -15,3 +15,4 @@ anyhow.workspace = true
 smallvec.workspace = true
 flume.workspace = true
 log.workspace = true
+futures.workspace = true

crates/person/src/lib.rs

@@ -3,7 +3,8 @@ use std::sync::RwLock;
 
 use anyhow::{Error, anyhow};
 use common::EventExt;
-use gpui::{App, AppContext, Context, Entity, Global, Task, Window};
+use futures::FutureExt;
+use gpui::{App, AppContext, BackgroundExecutor, Context, Entity, Global, Task, Window};
 use instant::Duration;
 use nostr_sdk::prelude::*;
 use smallvec::{SmallVec, smallvec};
@@ -72,24 +73,40 @@ impl PersonRegistry {
         }));
 
         let client3 = client.clone();
+        let executor = cx.background_executor().clone();
         tasks.push(cx.background_spawn(async move {
-            Self::handle_requests(&client3, &metadata_rx).await;
+            Self::handle_requests(&client3, &metadata_rx, &executor).await;
         }));
 
         tasks.push(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);
-                        }
-                        Dispatch::Announcement(event) => {
-                            this.set_announcement(&event, cx);
-                        }
-                        Dispatch::Relays(event) => {
-                            this.set_messaging_relays(&event, cx);
-                        }
-                    };
+                // `update_in` (rather than `update`) routes through a
+                // try-borrow: on wasm a task poll that lands while the app
+                // context is borrowed can't panic and kill this consumer
+                // (which would stall the whole metadata pipeline).
+                this.update_in(cx, |this, _window, cx| {
+                    // Drain the whole queue in a single update so a burst of
+                    // events collapses into one repaint instead of one per
+                    // event (important on wasm, where everything runs on the
+                    // main thread).
+                    let mut dispatch = vec![event];
+                    while let Ok(extra) = rx.try_recv() {
+                        dispatch.push(extra);
+                    }
+
+                    for event in dispatch {
+                        match event {
+                            Dispatch::Person(person) => {
+                                this.insert(person, cx);
+                            }
+                            Dispatch::Announcement(event) => {
+                                this.set_announcement(&event, cx);
+                            }
+                            Dispatch::Relays(event) => {
+                                this.set_messaging_relays(&event, cx);
+                            }
+                        };
+                    }
                 })
                 .ok();
             }
@@ -156,30 +173,43 @@ impl PersonRegistry {
     }
 
     /// Handle request for metadata
-    async fn handle_requests(client: &Client, rx: &flume::Receiver<PublicKey>) {
+    ///
+    /// Requests are collected into batches and flushed when the batch is
+    /// full or the timeout expires.
+    ///
+    /// Note: `flume::Selector::wait_timeout` is intentionally not used here:
+    /// it relies on `std::time::Instant` and `thread::park_timeout`, which are
+    /// unavailable on `wasm32-unknown-unknown` (the former panics, the latter
+    /// is a no-op that would turn the wait into a busy loop on the main
+    /// thread).
+    async fn handle_requests(
+        client: &Client,
+        rx: &flume::Receiver<PublicKey>,
+        executor: &BackgroundExecutor,
+    ) {
         let mut batch: HashSet<PublicKey> = HashSet::new();
 
         loop {
-            match flume::Selector::new()
-                .recv(rx, |result| result.ok())
-                .wait_timeout(Duration::from_secs(TIMEOUT))
+            // Wait for the next request, or the batch timeout.
+            futures::select! {
+                result = rx.recv_async() => match result {
+                    Ok(public_key) => {
+                        batch.insert(public_key);
+                        // Keep collecting until the batch is full
+                        if batch.len() < 20 {
+                            continue;
+                        }
+                    }
+                    Err(_) => return,
+                },
+                _ = executor.timer(Duration::from_secs(TIMEOUT)).fuse() => {}
+            }
+
+            // Flush the batch
+            if !batch.is_empty()
+                && let Err(e) = get_metadata(client, std::mem::take(&mut batch)).await
             {
-                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.is_empty()
-                        && let Err(e) = get_metadata(client, std::mem::take(&mut batch)).await
-                    {
-                        log::warn!("Failed to get metadata batch: {e}");
-                    }
-                }
+                log::warn!("Failed to get metadata batch: {e}");
             }
         }
     }
@@ -205,7 +235,7 @@ impl PersonRegistry {
 
         self.tasks.push(cx.spawn(async move |this, cx| {
             if let Ok(persons) = task.await {
-                this.update(cx, |this, cx| {
+                this.update_in(cx, |this, _window, cx| {
                     this.bulk_insert(persons, cx);
                 })
                 .ok();

crates/person/src/person.rs

@@ -105,7 +105,7 @@ impl Person {
 
     /// Get profile avatar
     pub fn avatar(&self) -> SharedString {
-        self.metadata()
+        self.metadata
             .picture
             .as_ref()
             .filter(|picture| !picture.is_empty())
@@ -115,13 +115,13 @@ impl Person {
 
     /// Get profile name
     pub fn name(&self) -> SharedString {
-        if let Some(display_name) = self.metadata().display_name.as_ref()
+        if let Some(display_name) = self.metadata.display_name.as_ref()
             && !display_name.is_empty()
         {
             return SharedString::from(display_name.trim());
         }
 
-        if let Some(name) = self.metadata().name.as_ref()
+        if let Some(name) = self.metadata.name.as_ref()
             && !name.is_empty()
         {
             return SharedString::from(name.trim());

crates/settings/src/lib.rs

@@ -12,9 +12,6 @@ pub fn init(window: &mut Window, cx: &mut App) {
     AppSettings::set_global(cx.new(|cx| AppSettings::new(window, cx)), cx)
 }
 
-const DEFAULT_FILE_SERVER: &str = "https://nostr.download/";
-const LEGACY_FILE_SERVER: &str = "blossom.band";
-
 macro_rules! setting_accessors {
     ($(pub $field:ident: $type:ty),* $(,)?) => {
         impl AppSettings {
@@ -141,7 +138,7 @@ impl Default for Settings {
             screening: true,
             nip4e: false,
             trusted_relays: vec![],
-            file_server: Url::parse(DEFAULT_FILE_SERVER).unwrap(),
+            file_server: Url::parse("https://blossom.band/").unwrap(),
         }
     }
 }
@@ -220,12 +217,7 @@ impl AppSettings {
         });
 
         cx.spawn_in(window, async move |this, cx| {
-            let mut settings = task.await.unwrap_or(Settings::default());
-
-            // Move settings still pointed at the old default file server over to the new one
-            if settings.file_server.host_str() == Some(LEGACY_FILE_SERVER) {
-                settings.file_server = Url::parse(DEFAULT_FILE_SERVER).unwrap();
-            }
+            let settings = task.await.unwrap_or(Settings::default());
 
             // Update settings
             this.update_in(cx, |this, window, cx| {

crates/state/Cargo.toml

@@ -24,10 +24,6 @@ serde_json.workspace = true
 
 mime_guess = "2.0.4"
 
-aes-gcm.workspace = true
-sha2.workspace = true
-data-encoding.workspace = true
-
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 nostr-memory.workspace = true
 

crates/state/src/blossom.rs

@@ -4,52 +4,30 @@ use anyhow::{Error, anyhow};
 use gpui::AsyncApp;
 #[cfg(not(target_arch = "wasm32"))]
 use gpui_tokio::Tokio;
-#[cfg(not(target_arch = "wasm32"))]
 use mime_guess::from_path;
 use nostr_blossom::prelude::*;
 use nostr_sdk::prelude::*;
 
 #[cfg(not(target_arch = "wasm32"))]
-use crate::file::sha256_hex;
-
-/// Upload a blob to a blossom server and return its URL
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) async fn upload_blob(
-    server: &Url,
-    data: Vec<u8>,
-    content_type: &str,
-    sha256: &str,
-    cx: &AsyncApp,
-) -> Result<Url, Error> {
-    let client = BlossomClient::new(server.clone());
+pub async fn upload(server: Url, path: PathBuf, cx: &AsyncApp) -> Result<Url, Error> {
+    let content_type = from_path(&path).first_or_octet_stream().to_string();
+    let data = smol::fs::read(path).await?;
     let keys = Keys::generate();
-    let content_type = content_type.to_string();
-    let base = server.clone();
-    let hash = sha256.to_string();
+
+    // Construct the blossom client
+    let client = BlossomClient::new(server);
 
     Tokio::spawn(cx, async move {
-        match client
+        let blob = client
             .upload_blob(data, Some(content_type), None, Some(&keys))
-            .await
-        {
-            Ok(blob) => Ok(blob.url),
-            Err(e) if e.to_string().contains("201 Created") => Ok::<Url, Error>(base.join(&hash)?),
-            Err(e) => Err(anyhow!(e.to_string())),
-        }
+            .await?;
+
+        Ok(blob.url)
     })
     .await
     .map_err(|e| anyhow!("Upload error: {e}"))?
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-pub async fn upload(server: Url, path: PathBuf, cx: &AsyncApp) -> Result<Url, Error> {
-    let content_type = from_path(&path).first_or_octet_stream().to_string();
-    let data = smol::fs::read(&path).await?;
-    let sha256 = sha256_hex(&data);
-
-    upload_blob(&server, data, &content_type, &sha256, cx).await
-}
-
 #[cfg(target_arch = "wasm32")]
 pub async fn upload(_server: Url, _path: PathBuf, _cx: &AsyncApp) -> Result<Url, Error> {
     Err(anyhow!("File upload not supported on web"))

crates/state/src/constants.rs

@@ -14,6 +14,9 @@ pub const USER_KEYRING: &str = "Coop User Credential";
 /// Default timeout for subscription
 pub const TIMEOUT: u64 = 2;
 
+/// Default image cache size
+pub const IMAGE_CACHE_SIZE: usize = 20;
+
 /// Default delay for searching
 pub const FIND_DELAY: u64 = 600;
 

crates/state/src/file.rs

@@ -1,337 +0,0 @@
-use std::path::PathBuf;
-
-use aes_gcm::aead::consts::{U12, U16, U32};
-use aes_gcm::aead::{Aead, AeadCore, KeyInit, OsRng};
-use aes_gcm::aes::Aes256;
-use aes_gcm::{Aes256Gcm, AesGcm, Nonce};
-use anyhow::{Error, anyhow, bail};
-use data_encoding::HEXLOWER;
-use futures::AsyncReadExt;
-use gpui::http_client::AsyncBody;
-use gpui::{AsyncApp, SharedString};
-#[cfg(not(target_arch = "wasm32"))]
-use mime_guess::from_path;
-use nostr::nips::nip94::Sha256Hash;
-use nostr_sdk::prelude::*;
-use sha2::{Digest, Sha256};
-
-pub const ALGORITHM: &str = "aes-gcm";
-
-pub const MAX_FILE_SIZE: usize = 25 * 1024 * 1024;
-
-const TAG_SHA256: &str = "x";
-const TAG_ORIGINAL_SHA256: &str = "ox";
-const TAG_FILE_TYPE: &str = "file-type";
-const TAG_ALGORITHM: &str = "encryption-algorithm";
-const TAG_KEY: &str = "decryption-key";
-const TAG_NONCE: &str = "decryption-nonce";
-const TAG_SIZE: &str = "size";
-const TAG_DIM: &str = "dim";
-const TAG_ALT: &str = "alt";
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct EncryptedFile {
-    pub data: Vec<u8>,
-    pub key: String,
-    pub nonce: String,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct FileAttachment {
-    pub url: Url,
-    pub mime: String,
-    pub key: String,
-    pub nonce: String,
-    pub sha256: Option<String>,
-    pub original_sha256: Option<String>,
-    pub size: Option<u64>,
-    pub dim: Option<(u32, u32)>,
-    pub name: Option<String>,
-}
-
-impl FileAttachment {
-    pub fn tags(&self) -> Vec<Tag> {
-        let mut tags = vec![
-            Tag::custom(TAG_FILE_TYPE, [self.mime.clone()]),
-            Tag::custom(TAG_ALGORITHM, [ALGORITHM]),
-            Tag::custom(TAG_KEY, [self.key.clone()]),
-            Tag::custom(TAG_NONCE, [self.nonce.clone()]),
-        ];
-
-        if let Some(sha256) = &self.sha256 {
-            tags.push(Tag::custom(TAG_SHA256, [sha256.clone()]));
-        }
-
-        if let Some(original_sha256) = &self.original_sha256 {
-            tags.push(Tag::custom(TAG_ORIGINAL_SHA256, [original_sha256.clone()]));
-        }
-
-        if let Some(size) = self.size {
-            tags.push(Tag::custom(TAG_SIZE, [size.to_string()]));
-        }
-
-        if let Some((width, height)) = self.dim {
-            tags.push(Tag::custom(TAG_DIM, [format!("{width}x{height}")]));
-        }
-
-        if let Some(name) = &self.name {
-            tags.push(Tag::custom(TAG_ALT, [name.clone()]));
-        }
-
-        tags
-    }
-
-    pub fn from_tags(content: &str, tags: &Tags) -> Option<Self> {
-        if tag_value(tags, TAG_ALGORITHM)? != ALGORITHM {
-            return None;
-        }
-
-        Some(Self {
-            url: Url::parse(content).ok()?,
-            mime: tag_value(tags, TAG_FILE_TYPE)?.to_string(),
-            key: tag_value(tags, TAG_KEY)?.to_string(),
-            nonce: tag_value(tags, TAG_NONCE)?.to_string(),
-            sha256: tag_value(tags, TAG_SHA256).map(str::to_string),
-            original_sha256: tag_value(tags, TAG_ORIGINAL_SHA256).map(str::to_string),
-            size: tag_value(tags, TAG_SIZE).and_then(|size| size.parse().ok()),
-            dim: tag_value(tags, TAG_DIM).and_then(parse_dim),
-            name: tag_value(tags, TAG_ALT).map(str::to_string),
-        })
-    }
-
-    pub fn is_image(&self) -> bool {
-        self.mime.starts_with("image/")
-    }
-
-    pub fn display_name(&self) -> SharedString {
-        if let Some(name) = &self.name {
-            return name.clone().into();
-        }
-
-        match self.size {
-            Some(size) => format!("{} ({size} bytes)", self.mime).into(),
-            None => self.mime.clone().into(),
-        }
-    }
-}
-
-pub fn encrypt(data: &[u8]) -> Result<EncryptedFile, Error> {
-    let key = Aes256Gcm::generate_key(OsRng);
-    let nonce = AesGcm::<Aes256, U16>::generate_nonce(OsRng);
-    let cipher = AesGcm::<Aes256, U16>::new(&key);
-
-    let data = cipher
-        .encrypt(&nonce, data)
-        .map_err(|_| anyhow!("Failed to encrypt file"))?;
-
-    Ok(EncryptedFile {
-        data,
-        key: HEXLOWER.encode(key.as_slice()),
-        nonce: HEXLOWER.encode(nonce.as_slice()),
-    })
-}
-
-pub fn decrypt(data: &[u8], key: &str, nonce: &str) -> Result<Vec<u8>, Error> {
-    let key = decode(key, "decryption key")?;
-    let nonce = decode(nonce, "decryption nonce")?;
-
-    if key.len() != 32 {
-        bail!(
-            "Invalid decryption key length: expected 32 bytes, got {}",
-            key.len()
-        );
-    }
-
-    match nonce.len() {
-        12 => Aes256Gcm::new_from_slice(&key)
-            .map_err(|_| anyhow!("Invalid decryption key"))?
-            .decrypt(Nonce::<U12>::from_slice(&nonce), data)
-            .map_err(|_| anyhow!("Failed to decrypt file")),
-        16 => AesGcm::<Aes256, U16>::new_from_slice(&key)
-            .map_err(|_| anyhow!("Invalid decryption key"))?
-            .decrypt(Nonce::<U16>::from_slice(&nonce), data)
-            .map_err(|_| anyhow!("Failed to decrypt file")),
-        32 => AesGcm::<Aes256, U32>::new_from_slice(&key)
-            .map_err(|_| anyhow!("Invalid decryption key"))?
-            .decrypt(Nonce::<U32>::from_slice(&nonce), data)
-            .map_err(|_| anyhow!("Failed to decrypt file")),
-        len => bail!("Unsupported decryption nonce length: {len} bytes"),
-    }
-}
-
-pub fn sha256_hex(data: &[u8]) -> String {
-    let hash: [u8; 32] = Sha256::digest(data).into();
-
-    Sha256Hash::from_byte_array(hash).to_hex()
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-pub async fn upload_encrypted(
-    server: Url,
-    path: PathBuf,
-    cx: &AsyncApp,
-) -> Result<FileAttachment, Error> {
-    let mime = from_path(&path).first_or_octet_stream().to_string();
-    let name = path
-        .file_name()
-        .map(|name| name.to_string_lossy().into_owned());
-    let data = smol::fs::read(&path).await?;
-
-    let encrypted = encrypt(&data)?;
-    let sha256 = sha256_hex(&encrypted.data);
-    let original_sha256 = sha256_hex(&data);
-    let size = encrypted.data.len() as u64;
-    let base_url = server.to_string();
-
-    let url = crate::blossom::upload_blob(
-        &server,
-        encrypted.data,
-        "application/octet-stream",
-        &sha256,
-        cx,
-    )
-    .await
-    .map_err(|e| {
-        let message = e.to_string();
-
-        if !message.contains("415") {
-            return anyhow!(message);
-        }
-
-        anyhow!(
-            "{base_url} rejected the encrypted file. Encrypted attachments are uploaded as
-             opaque data, which this file server does not accept. Choose a different file
-             server in the settings."
-        )
-    })?;
-
-    Ok(FileAttachment {
-        url,
-        mime,
-        key: encrypted.key,
-        nonce: encrypted.nonce,
-        sha256: Some(sha256),
-        original_sha256: Some(original_sha256),
-        size: Some(size),
-        dim: None,
-        name,
-    })
-}
-
-#[cfg(target_arch = "wasm32")]
-pub async fn upload_encrypted(
-    _server: Url,
-    _path: PathBuf,
-    _cx: &AsyncApp,
-) -> Result<FileAttachment, Error> {
-    Err(anyhow!("File upload not supported on web"))
-}
-
-pub async fn download_and_decrypt(
-    url: &Url,
-    key: &str,
-    nonce: &str,
-    expected_sha256: Option<&str>,
-    cx: &AsyncApp,
-) -> Result<Vec<u8>, Error> {
-    let client = cx.update(|app| app.http_client());
-    let response = client.get(url.as_str(), AsyncBody::default(), true).await?;
-
-    if !response.status().is_success() {
-        bail!("Failed to download file: HTTP {}", response.status());
-    }
-
-    let mut data = Vec::new();
-    response
-        .into_body()
-        .take(MAX_FILE_SIZE as u64 + 1)
-        .read_to_end(&mut data)
-        .await?;
-
-    if data.len() > MAX_FILE_SIZE {
-        bail!("File is too large (max {MAX_FILE_SIZE} bytes)");
-    }
-
-    if let Some(expected) = expected_sha256
-        && !sha256_hex(&data).eq_ignore_ascii_case(expected)
-    {
-        bail!("File hash mismatch");
-    }
-
-    decrypt(&data, key, nonce)
-}
-
-/// Download and decrypt a file attachment into a temporary file.
-///
-/// The same attachment always maps to the same path, so callers can render the
-/// result directly (e.g. with `img`) without downloading it more than once.
-#[cfg(not(target_arch = "wasm32"))]
-pub async fn download_and_decrypt_to_file(
-    file: &FileAttachment,
-    cx: &AsyncApp,
-) -> Result<PathBuf, Error> {
-    let name = file
-        .sha256
-        .clone()
-        .unwrap_or_else(|| sha256_hex(file.url.as_str().as_bytes()));
-
-    let extension = mime_guess::get_mime_extensions_str(&file.mime)
-        .and_then(|extensions| extensions.first())
-        .copied()
-        .unwrap_or("bin");
-
-    let path = std::env::temp_dir()
-        .join("coop-files")
-        .join(format!("{name}.{extension}"));
-
-    if smol::fs::metadata(&path).await.is_ok() {
-        return Ok(path);
-    }
-
-    let data = download_and_decrypt(
-        &file.url,
-        &file.key,
-        &file.nonce,
-        file.sha256.as_deref(),
-        cx,
-    )
-    .await?;
-
-    let Some(parent) = path.parent() else {
-        bail!("Invalid file path");
-    };
-    smol::fs::create_dir_all(parent).await?;
-
-    // Write under a temporary name first, so an interrupted download is never reused
-    let partial = path.with_extension("download");
-    smol::fs::write(&partial, data).await?;
-    smol::fs::rename(&partial, &path).await?;
-
-    Ok(path)
-}
-
-#[cfg(target_arch = "wasm32")]
-pub async fn download_and_decrypt_to_file(
-    _file: &FileAttachment,
-    _cx: &AsyncApp,
-) -> Result<PathBuf, Error> {
-    Err(anyhow!("File download not supported on web"))
-}
-
-fn tag_value<'a>(tags: &'a Tags, name: &str) -> Option<&'a str> {
-    tags.iter()
-        .find(|tag| tag.kind() == name)
-        .and_then(|tag| tag.content())
-}
-
-fn parse_dim(value: &str) -> Option<(u32, u32)> {
-    let (width, height) = value.split_once('x')?;
-
-    Some((width.parse().ok()?, height.parse().ok()?))
-}
-
-fn decode(value: &str, label: &str) -> Result<Vec<u8>, Error> {
-    HEXLOWER
-        .decode(value.to_ascii_lowercase().as_bytes())
-        .map_err(|_| anyhow!("Invalid {label} encoding"))
-}

crates/state/src/lib.rs

@@ -3,8 +3,10 @@ use std::collections::HashMap;
 use anyhow::{Error, anyhow};
 #[cfg(not(target_arch = "wasm32"))]
 use browser_signer_proxy::prelude::*;
+#[cfg(not(target_arch = "wasm32"))]
 use common::config_dir;
 use gpui::{App, AppContext, Context, Entity, EventEmitter, Global, Task, Window};
+#[cfg(not(target_arch = "wasm32"))]
 use gpui_tokio::Tokio;
 use instant::Duration;
 use nostr_connect::prelude::*;
@@ -17,14 +19,12 @@ use nostr_sdk::prelude::*;
 
 mod blossom;
 mod constants;
-mod file;
 mod nip05;
 mod nip4e;
 mod signer;
 
 pub use blossom::*;
 pub use constants::*;
-pub use file::*;
 pub use nip4e::*;
 pub use nip05::*;
 pub use signer::{CoopAuthUrlHandler, UniversalSigner};
@@ -181,7 +181,7 @@ impl NostrRegistry {
         let task = cx.spawn(async move |this, cx| {
             match new_signer.get_public_key_async().await {
                 Ok(public_key) => {
-                    this.update(cx, |this, cx| {
+                    this.update_in(cx, |this, _window, cx| {
                         this.signer.swap_inner(new_signer);
                         this.current_user = Some(public_key);
                         cx.emit(StateEvent::SignerChanged);
@@ -189,7 +189,7 @@ impl NostrRegistry {
                     })?;
                 }
                 Err(e) => {
-                    this.update(cx, |_this, cx| {
+                    this.update_in(cx, |_this, _window, cx| {
                         cx.emit(StateEvent::error(e.to_string()));
                     })?;
                 }
@@ -226,7 +226,7 @@ impl NostrRegistry {
 
         self.tasks.push(cx.spawn(async move |this, cx| {
             if let Err(e) = task.await {
-                this.update(cx, |_this, cx| {
+                this.update_in(cx, |_this, _window, cx| {
                     cx.emit(StateEvent::error(e.to_string()));
                 })?;
             }
@@ -248,7 +248,7 @@ impl NostrRegistry {
                         let secret_key = SecretKey::parse(&content)?;
                         let keys = Keys::new(secret_key);
 
-                        this.update(cx, |this, cx| {
+                        this.update_in(cx, |this, _window, cx| {
                             this.set_signer(keys, cx);
                             cx.notify();
                         })?;
@@ -263,19 +263,19 @@ impl NostrRegistry {
                         // Handle auth url with the default browser
                         signer.auth_url_handler(CoopAuthUrlHandler);
 
-                        this.update(cx, |this, cx| {
+                        this.update_in(cx, |this, _window, cx| {
                             this.set_signer(signer, cx);
                             cx.notify();
                         })?;
                     } else if content == "proxy" {
                         #[cfg(not(target_arch = "wasm32"))]
-                        this.update(cx, |this, cx| {
+                        this.update_in(cx, |this, _window, cx| {
                             this.connect_proxy(cx);
                         })?;
                     }
                 }
                 _ => {
-                    this.update(cx, |_, cx| {
+                    this.update_in(cx, |_, _window, cx| {
                         cx.emit(StateEvent::NoSigner);
                     })?;
                 }
@@ -352,7 +352,7 @@ impl NostrRegistry {
             let proxy = proxy.clone();
             async move |this, cx| {
                 while let Ok(url) = rx.recv_async().await {
-                    this.update(cx, |this, cx| {
+                    this.update_in(cx, |this, _window, cx| {
                         let save = cx.write_credentials(USER_KEYRING, "proxy", b"proxy");
                         cx.background_spawn(async move { save.await.ok() }).detach();
                         cx.open_url(&url);
@@ -374,7 +374,7 @@ impl NostrRegistry {
                 loop {
                     executor.timer(Duration::from_secs(5)).await;
                     if !proxy.is_session_active() {
-                        _ = this.update(cx, |this, cx| {
+                        _ = this.update_in(cx, |this, _window, cx| {
                             // Only notify if this proxy is still the active signer
                             if this.current_user.is_some() {
                                 this.signer.swap_inner(Keys::generate());

crates/theme/src/theme.rs

@@ -64,7 +64,7 @@ impl Default for ThemeFamily {
             id: "coop".into(),
             name: "Coop Default Theme".into(),
             author: "Coop".into(),
-            url: "https://github.com/reyakov/coop".into(),
+            url: "https://github.com/lumehq/coop".into(),
             light: ThemeColors::light(),
             dark: ThemeColors::dark(),
         }
@@ -186,7 +186,7 @@ mod tests {
             "id": "test-theme",
             "name": "Test Theme",
             "author": "Coop",
-            "url": "https://github.com/reyakov/coop",
+            "url": "https://github.com/lumehq/coop",
             "light": {
                 "background": "#ffffff",
                 "surface_background": "#fafafa",

crates/ui/src/checkbox.rs

@@ -1,16 +1,16 @@
 use std::rc::Rc;
-use instant::Duration;
 
 use gpui::prelude::FluentBuilder as _;
 use gpui::{
-    div, px, relative, rems, svg, Animation, AnimationExt, AnyElement, App, Div, ElementId,
-    InteractiveElement, IntoElement, ParentElement, RenderOnce, SharedString,
-    StatefulInteractiveElement, StyleRefinement, Styled, Window,
+    Animation, AnimationExt, AnyElement, App, Div, ElementId, InteractiveElement, IntoElement,
+    ParentElement, RenderOnce, SharedString, StatefulInteractiveElement, StyleRefinement, Styled,
+    Window, div, px, relative, rems, svg,
 };
+use instant::Duration;
 use theme::ActiveTheme;
 
 use crate::icon::IconNamed;
-use crate::{v_flex, Disableable, IconName, Selectable, Sizable, Size, StyledExt as _};
+use crate::{Disableable, IconName, Selectable, Sizable, Size, StyledExt as _, v_flex};
 
 /// A Checkbox element.
 #[allow(clippy::type_complexity)]
@@ -172,10 +172,16 @@ pub(crate) fn checkbox_check_icon(
             if !disabled && checked != *toggle_state.read(cx) {
                 let duration = Duration::from_secs_f64(0.25);
                 cx.spawn({
-                    let toggle_state = toggle_state.clone();
+                    let toggle_state = toggle_state.downgrade();
                     async move |cx| {
                         cx.background_executor().timer(duration).await;
-                        toggle_state.update(cx, |this, _| *this = checked);
+                        // `update_in` (rather than `update`) routes through a
+                        // try-borrow: on wasm a task poll that lands while
+                        // the app context is borrowed can't panic and kill
+                        // this task.
+                        toggle_state
+                            .update_in(cx, |this, _window, _| *this = checked)
+                            .ok();
                     }
                 })
                 .detach();

crates/ui/src/icon.rs

@@ -46,7 +46,6 @@ pub enum IconName {
     InboxFill,
     Link,
     Loader,
-    Lock,
     Moon,
     Plus,
     PlusCircle,
@@ -119,7 +118,6 @@ impl IconNamed for IconName {
             Self::InboxFill => "icons/inbox-fill.svg",
             Self::Link => "icons/link.svg",
             Self::Loader => "icons/loader.svg",
-            Self::Lock => "icons/lock.svg",
             Self::Moon => "icons/moon.svg",
             Self::Plus => "icons/plus.svg",
             Self::PlusCircle => "icons/plus-circle.svg",

crates/ui/src/input/blink_cursor.rs

@@ -1,6 +1,5 @@
-use instant::Duration;
-
 use gpui::{Context, Pixels, Task, px};
+use instant::Duration;
 
 static INTERVAL: Duration = Duration::from_millis(500);
 static PAUSE_DELAY: Duration = Duration::from_millis(300);
@@ -63,9 +62,11 @@ impl BlinkCursor {
         let epoch = self.next_epoch();
         self._task = cx.spawn(async move |this, cx| {
             cx.background_executor().timer(INTERVAL).await;
-            if let Some(this) = this.upgrade() {
-                this.update(cx, |this, cx| this.blink(epoch, cx));
-            }
+            // `update_in` (rather than `update`) routes through a try-borrow:
+            // on wasm a task poll that lands while the app context is
+            // borrowed can't panic and kill this recurring task.
+            this.update_in(cx, |this, _window, cx| this.blink(epoch, cx))
+                .ok();
         });
     }
 
@@ -85,12 +86,11 @@ impl BlinkCursor {
         self._task = cx.spawn(async move |this, cx| {
             cx.background_executor().timer(PAUSE_DELAY).await;
 
-            if let Some(this) = this.upgrade() {
-                this.update(cx, |this, cx| {
-                    this.paused = false;
-                    this.blink(epoch, cx);
-                });
-            }
+            this.update_in(cx, |this, _window, cx| {
+                this.paused = false;
+                this.blink(epoch, cx);
+            })
+            .ok();
         });
     }
 }

crates/workspace/Cargo.toml

@@ -14,15 +14,16 @@ 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
 log.workspace = true
 smallvec.workspace = true
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+auto_update = { path = "../auto_update" }

crates/workspace/src/dialogs/import.rs

@@ -129,7 +129,7 @@ impl ImportIdentity {
                     })?;
                 }
                 Err(e) => {
-                    this.update(cx, |this, cx| {
+                    this.update_in(cx, |this, _window, cx| {
                         this.set_error(e.to_string(), cx);
                     })?;
                 }
@@ -172,6 +172,11 @@ impl ImportIdentity {
         });
     }
 
+    // The "Connect via Web Extension" button is hidden on wasm (`is_wasm`),
+    // so this stub is never invoked in the browser.
+    #[cfg(target_arch = "wasm32")]
+    fn proxy(&mut self, _cx: &mut Context<Self>) {}
+
     fn set_loading(&mut self, status: bool, cx: &mut Context<Self>) {
         self.loading = status;
         cx.notify();
@@ -193,7 +198,7 @@ impl ImportIdentity {
         self.tasks.push(cx.spawn(async move |this, cx| {
             cx.background_executor().timer(Duration::from_secs(3)).await;
 
-            this.update(cx, |this, cx| {
+            this.update_in(cx, |this, _window, cx| {
                 this.error.update(cx, |this, cx| {
                     *this = None;
                     cx.notify();

crates/workspace/src/dialogs/restore.rs

@@ -83,7 +83,7 @@ impl RestoreEncryption {
         self.tasks.push(cx.spawn(async move |this, cx| {
             cx.background_executor().timer(Duration::from_secs(3)).await;
 
-            this.update(cx, |this, cx| {
+            this.update_in(cx, |this, _window, cx| {
                 this.error.update(cx, |this, cx| {
                     *this = None;
                     cx.notify();

crates/workspace/src/dialogs/screening.rs

@@ -105,7 +105,7 @@ impl Screening {
         self.tasks.push(cx.spawn(async move |this, cx| {
             let result = task.await.unwrap_or(false);
 
-            this.update(cx, |this, cx| {
+            this.update_in(cx, |this, _window, cx| {
                 this.followed = result;
                 cx.notify();
             })
@@ -139,7 +139,7 @@ impl Screening {
         self.tasks.push(cx.spawn(async move |this, cx| {
             match task.await {
                 Ok(contacts) => {
-                    this.update(cx, |this, cx| {
+                    this.update_in(cx, |this, _window, cx| {
                         this.mutual_contacts = contacts;
                         cx.notify();
                     })
@@ -185,7 +185,7 @@ impl Screening {
         self.tasks.push(cx.spawn(async move |this, cx| {
             let result = task.await;
 
-            this.update(cx, |this, cx| {
+            this.update_in(cx, |this, _window, cx| {
                 this.last_active = result;
                 cx.notify();
             })
@@ -208,7 +208,7 @@ impl Screening {
         self.tasks.push(cx.spawn(async move |this, cx| {
             let result = task.await.unwrap_or(false);
 
-            this.update(cx, |this, cx| {
+            this.update_in(cx, |this, _window, cx| {
                 this.verified = result;
                 cx.notify();
             })

crates/workspace/src/lib.rs

@@ -2,20 +2,21 @@ use std::sync::Arc;
 
 use ::settings::AppSettings;
 use anyhow::Error;
+#[cfg(not(target_arch = "wasm32"))]
 use auto_update::AutoUpdater;
 use chat::{ChatEvent, ChatRegistry};
-use common::download_dir;
+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, px,
+    Render, SharedString, Styled, Subscription, Task, Window, div, image_cache, px,
 };
 use nostr_sdk::prelude::*;
 use person::{PersonRegistry, shorten_pubkey};
 use serde::Deserialize;
 use smallvec::{SmallVec, smallvec};
-use state::{NostrRegistry, StateEvent};
+use state::{IMAGE_CACHE_SIZE, NostrRegistry, StateEvent};
 use theme::{ActiveTheme, SIDEBAR_WIDTH, Theme, ThemeRegistry};
 use ui::avatar::Avatar;
 use ui::button::{Button, ButtonVariants};
@@ -64,6 +65,9 @@ pub struct Workspace {
     /// App's Dock Area
     dock: Entity<DockArea>,
 
+    /// App's Image Cache
+    image_cache: Entity<CoopImageCache>,
+
     /// Async tasks
     tasks: Vec<Task<Result<(), Error>>>,
 
@@ -79,6 +83,7 @@ impl Workspace {
 
         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![];
 
@@ -229,6 +234,7 @@ impl Workspace {
         Self {
             sidebar,
             dock,
+            image_cache,
             tasks: vec![],
             _subscriptions: subscriptions,
         }
@@ -374,11 +380,18 @@ impl Workspace {
             Command::ImportEncryption => {
                 self.import_encryption(window, cx);
             }
+            #[cfg(not(target_arch = "wasm32"))]
             Command::Update => {
-                if let Some(auto_updater) = AutoUpdater::try_global(cx) {
-                    auto_updater.update(cx, |this, cx| this.check(cx));
-                }
+                let auto_updater = AutoUpdater::global(cx);
+                auto_updater.update(cx, |this, cx| {
+                    this.updater.update(cx, |updater, cx| {
+                        updater.check(cx);
+                    });
+                });
             }
+            // Auto-update is a desktop-only feature; no-op in the browser.
+            #[cfg(target_arch = "wasm32")]
+            Command::Update => {}
         }
     }
 
@@ -551,11 +564,12 @@ impl Workspace {
                         .caret()
                         .compact()
                         .transparent()
-                        .dropdown_menu(move |this, _window, cx| {
+                        .dropdown_menu(move |this, _window, _cx| {
                             let avatar = avatar.clone();
                             let name = name.clone();
 
-                            this.min_w(px(256.))
+                            let menu = this
+                                .min_w(px(256.))
                                 .item(PopupMenuItem::element(move |_window, cx| {
                                     h_flex()
                                         .gap_1p5()
@@ -585,27 +599,27 @@ impl Workspace {
                                     IconName::Sun,
                                     Box::new(Command::ToggleTheme),
                                 )
-                                // Only offer in-app updates when auto-update is
-                                // enabled (managed channels update themselves).
-                                .when(AutoUpdater::is_available(cx), |this| {
-                                    this.separator().menu_with_icon(
-                                        "Check for Updates",
-                                        IconName::Device,
-                                        Box::new(Command::Update),
-                                    )
-                                })
-                                .menu_with_icon(
-                                    "Settings",
-                                    IconName::Settings,
-                                    Box::new(Command::ShowSettings),
-                                )
+                                .separator();
+
+                            // Auto-update is a desktop-only feature; there is no updater in the browser.
+                            #[cfg(not(target_arch = "wasm32"))]
+                            let menu = menu.menu_with_icon(
+                                "Check for Updates",
+                                IconName::Device,
+                                Box::new(Command::Update),
+                            );
+
+                            menu.menu_with_icon(
+                                "Settings",
+                                IconName::Settings,
+                                Box::new(Command::ShowSettings),
+                            )
                         }),
                 )
             })
     }
 
     fn titlebar_right(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
-        let auto_updater = AutoUpdater::try_global(cx);
         let chat = ChatRegistry::global(cx);
         let nip4e_enabled = AppSettings::get_nip4e(cx);
         let nostr = NostrRegistry::global(cx);
@@ -618,35 +632,22 @@ impl Workspace {
         let profile = persons.read(cx).get(&public_key, cx);
         let announcement = profile.announcement();
 
-        let updater_status = auto_updater.as_ref().and_then(|updater| {
-            let updater = updater.read(cx);
-            (!updater.idle()).then(|| updater.status())
-        });
-
-        let staged_update = auto_updater
-            .as_ref()
-            .is_some_and(|updater| updater.read(cx).staged());
-
-        h_flex()
+        let titlebar = h_flex()
             .when(!cx.theme().platform.is_mac(), |this| this.pr_2())
-            .gap_2()
-            .when_some(updater_status, |this, status| {
+            .gap_2();
+
+        // Auto-update is a desktop-only feature; there is no updater in the browser.
+        #[cfg(not(target_arch = "wasm32"))]
+        let titlebar = {
+            let updater = AutoUpdater::global(cx);
+            let updater_idle = updater.read(cx).idle(cx);
+            titlebar.when(!updater_idle, |this| {
+                let status = updater.read(cx).status(cx);
                 this.child(div().text_xs().italic().child(status))
             })
-            .when(staged_update, |this| {
-                this.child(
-                    Button::new("restart-to-update")
-                        .label("Restart to Update")
-                        .tooltip("Quit and relaunch into the installed update")
-                        .small()
-                        .ghost()
-                        .on_click(cx.listener(|_this, _event, _window, cx| {
-                            if let Some(auto_updater) = AutoUpdater::try_global(cx) {
-                                auto_updater.update(cx, |this, cx| this.restart(cx));
-                            }
-                        })),
-                )
-            })
+        };
+
+        titlebar
             .when(nip4e_enabled, |this| {
                 this.child(
                     Button::new("key")
@@ -783,26 +784,31 @@ impl Render for Workspace {
             .relative()
             .size_full()
             .child(
-                v_flex()
+                image_cache(self.image_cache.clone())
+                    .relative()
                     .size_full()
-                    // Title Bar
                     .child(
-                        TitleBar::new()
-                            .child(self.titlebar_left(cx))
-                            .child(self.titlebar_right(cx)),
-                    )
-                    // Main
-                    .child(
-                        h_flex()
+                        v_flex()
                             .size_full()
+                            // Title Bar
                             .child(
-                                div()
-                                    .flex_shrink_0()
-                                    .h_full()
-                                    .w(SIDEBAR_WIDTH)
-                                    .child(self.sidebar.clone()),
+                                TitleBar::new()
+                                    .child(self.titlebar_left(cx))
+                                    .child(self.titlebar_right(cx)),
                             )
-                            .child(self.dock.clone()),
+                            // Main
+                            .child(
+                                h_flex()
+                                    .size_full()
+                                    .child(
+                                        div()
+                                            .flex_shrink_0()
+                                            .h_full()
+                                            .w(SIDEBAR_WIDTH)
+                                            .child(self.sidebar.clone()),
+                                    )
+                                    .child(self.dock.clone()),
+                            ),
                     ),
             )
             // Notifications

crates/workspace/src/panels/backup.rs

@@ -97,7 +97,7 @@ impl BackupPanel {
             cx.background_executor().timer(Duration::from_secs(2)).await;
 
             // Clear the error message after a delay
-            this.update(cx, |this, cx| {
+            this.update_in(cx, |this, _window, cx| {
                 this.set_copied(false, cx);
             })?;
 

crates/workspace/src/panels/contact_list.rs

@@ -5,7 +5,7 @@ use gpui::prelude::FluentBuilder;
 use gpui::{
     AnyElement, App, AppContext, Context, Entity, EventEmitter, FocusHandle, Focusable,
     InteractiveElement, IntoElement, ParentElement, Render, SharedString, Styled, Subscription,
-    Task, TextAlign, Window, div, rems, retain_all,
+    Task, TextAlign, Window, div, rems,
 };
 use instant::Duration;
 use nostr_sdk::prelude::*;
@@ -108,8 +108,10 @@ impl ContactListPanel {
         self.tasks.push(cx.spawn_in(window, async move |this, cx| {
             let public_keys = task.await?;
 
-            // Update state
-            this.update(cx, |this, cx| {
+            // Update state. `update_in` (rather than `update`) routes through
+            // a try-borrow, so on wasm a poll that happens to land while the
+            // app context is borrowed can't panic and kill this task.
+            this.update_in(cx, |this, _window, cx| {
                 this.contacts.extend(public_keys);
                 cx.notify();
             })?;
@@ -148,8 +150,11 @@ impl ContactListPanel {
         self.tasks.push(cx.spawn_in(window, async move |this, cx| {
             cx.background_executor().timer(Duration::from_secs(2)).await;
 
-            // Clear the error message after a delay
-            this.update(cx, |this, cx| {
+            // Clear the error message after a delay. `update_in` (rather than
+            // `update`) routes through a try-borrow, so on wasm a poll that
+            // happens to land while the app context is borrowed can't panic
+            // and kill this task.
+            this.update_in(cx, |this, _window, cx| {
                 this.error = None;
                 cx.notify();
             })?;
@@ -297,7 +302,6 @@ impl Focusable for ContactListPanel {
 impl Render for ContactListPanel {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         v_flex()
-            .image_cache(retain_all("contact-list-panel"))
             .p_3()
             .gap_3()
             .w_full()

crates/workspace/src/panels/messaging_relays.rs

@@ -103,8 +103,10 @@ impl MessagingRelayPanel {
         self.tasks.push(cx.spawn_in(window, async move |this, cx| {
             let relays = task.await?;
 
-            // Update state
-            this.update(cx, |this, cx| {
+            // Update state. `update_in` (rather than `update`) routes through
+            // a try-borrow: on wasm a poll that lands while the app context
+            // is borrowed can't panic and kill this task.
+            this.update_in(cx, |this, _window, cx| {
                 this.relays.extend(relays);
                 cx.notify();
             })?;
@@ -148,8 +150,11 @@ impl MessagingRelayPanel {
         self.tasks.push(cx.spawn_in(window, async move |this, cx| {
             cx.background_executor().timer(Duration::from_secs(2)).await;
 
-            // Clear the error message after a delay
-            this.update(cx, |this, cx| {
+            // Clear the error message after a delay. `update_in` (rather than
+            // `update`) routes through a try-borrow: on wasm a poll that
+            // lands while the app context is borrowed can't panic and kill
+            // this task.
+            this.update_in(cx, |this, _window, cx| {
                 this.error = None;
                 cx.notify();
             })?;

crates/workspace/src/panels/profile.rs

@@ -1,10 +1,10 @@
 use std::str::FromStr;
 
-use anyhow::Error;
+use anyhow::{Context as AnyhowContext, Error};
 use gpui::{
     AnyElement, App, AppContext, ClipboardItem, Context, Entity, EventEmitter, FocusHandle,
     Focusable, IntoElement, ParentElement, PathPromptOptions, Render, SharedString, Styled, Task,
-    Window, div, retain_all,
+    Window, div,
 };
 use instant::Duration;
 use nostr_sdk::prelude::*;
@@ -167,15 +167,13 @@ impl ProfilePanel {
         });
 
         self.tasks.push(cx.spawn_in(window, async move |this, cx| {
-            // Selecting no file means the prompt was cancelled
-            let Some(path) = path.await??.and_then(|mut paths| paths.pop()) else {
-                return Ok(());
-            };
-
-            this.update(cx, |this, cx| {
+            this.update_in(cx, |this, _window, cx| {
                 this.set_uploading(true, cx);
             })?;
 
+            let mut paths = path.await??.context("Not found")?;
+            let path = paths.pop().context("No path")?;
+
             // Upload via blossom client
             match upload(server, path, cx).await {
                 Ok(url) => {
@@ -321,7 +319,6 @@ impl Render for ProfilePanel {
         let shorten_pkey = SharedString::from(shorten_pubkey(self.public_key, 8));
 
         v_flex()
-            .image_cache(retain_all("profile-panel"))
             .p_3()
             .gap_3()
             .w_full()

crates/workspace/src/panels/relay_list.rs

@@ -121,8 +121,10 @@ impl RelayListPanel {
         self.tasks.push(cx.spawn_in(window, async move |this, cx| {
             let relays = task.await?;
 
-            // Update state
-            this.update(cx, |this, cx| {
+            // Update state. `update_in` (rather than `update`) routes through
+            // a try-borrow: on wasm a poll that lands while the app context
+            // is borrowed can't panic and kill this task.
+            this.update_in(cx, |this, _window, cx| {
                 this.relays.extend(relays);
                 cx.notify();
             })?;
@@ -167,8 +169,11 @@ impl RelayListPanel {
         self.tasks.push(cx.spawn_in(window, async move |this, cx| {
             cx.background_executor().timer(Duration::from_secs(2)).await;
 
-            // Clear the error message after a delay
-            this.update(cx, |this, cx| {
+            // Clear the error message after a delay. `update_in` (rather than
+            // `update`) routes through a try-borrow: on wasm a poll that
+            // lands while the app context is borrowed can't panic and kill
+            // this task.
+            this.update_in(cx, |this, _window, cx| {
                 this.error = None;
                 cx.notify();
             })?;

crates/workspace/src/sidebar/mod.rs

@@ -3,19 +3,19 @@ use std::ops::Range;
 
 use anyhow::Error;
 use chat::{ChatEvent, ChatRegistry, Room, RoomKind};
-use common::{DebouncedDelay, TimestampExt};
+use common::{DebouncedDelay, TimestampExt, coop_cache};
 use entry::RoomEntry;
 use gpui::prelude::FluentBuilder;
 use gpui::{
     App, AppContext, Context, Entity, EventEmitter, FocusHandle, Focusable, IntoElement,
     ParentElement, Render, SharedString, Styled, Subscription, Task, UniformListScrollHandle,
-    Window, div, retain_all, uniform_list,
+    Window, div, uniform_list,
 };
 use instant::Duration;
 use nostr_sdk::prelude::*;
 use person::PersonRegistry;
 use smallvec::{SmallVec, smallvec};
-use state::{FIND_DELAY, NostrRegistry};
+use state::{FIND_DELAY, IMAGE_CACHE_SIZE, NostrRegistry};
 use theme::{ActiveTheme, SIDEBAR_WIDTH};
 use ui::button::{Button, ButtonVariants};
 use ui::dock::{Panel, PanelEvent};
@@ -178,7 +178,10 @@ impl Sidebar {
         self.tasks.push(cx.spawn_in(window, async move |this, cx| {
             match task.await {
                 Ok(contacts) => {
-                    this.update(cx, |this, cx| {
+                    // `update_in` (rather than `update`) routes through a
+                    // try-borrow: on wasm a poll that lands while the app
+                    // context is borrowed can't panic and kill this task.
+                    this.update_in(cx, |this, _window, cx| {
                         this.set_contact_list(contacts, cx);
                     })?;
                 }
@@ -521,7 +524,7 @@ impl Render for Sidebar {
         };
 
         v_flex()
-            .image_cache(retain_all("sidebar"))
+            .image_cache(coop_cache("sidebar", IMAGE_CACHE_SIZE))
             .size_full()
             .gap_2()
             .child(

desktop/Cargo.toml

@@ -14,7 +14,7 @@ product-name = "Coop"
 description = "Chat Freely, Stay Private on Nostr"
 identifier = "su.reya.coop"
 category = "SocialNetworking"
-version = "1.0.2"
+version = "1.0.0"
 out-dir = "../dist"
 before-packaging-command = "cargo build --release"
 resources = ["Cargo.toml", "src"]

desktop/resources/flatpak/coop.metainfo.xml.in

@@ -35,13 +35,13 @@
         <content_attribute id="social-audio">intense</content_attribute>
     </content_rating>
 
-    <url type="homepage">https://coopchat.xyz</url>
-    <url type="bugtracker">https://github.com/reyakov/coop/issues</url>
-    <url type="faq">https://github.com/reyakov/coop</url>
-    <url type="help">https://github.com/reyakov/coop/issues</url>
-    <url type="contact">reyakov@proton.me</url>
-    <url type="vcs-browser">https://github.com/reykov/coop</url>
-    <url type="contribute">https://github.com/reyakov/coop/blob/main/CONTRIBUTING.md</url>
+    <url type="homepage">https://reya.su/coop</url>
+    <url type="bugtracker">https://github.com/lumehq/coop/issues</url>
+    <url type="faq">https://github.com/lumehq/coop</url>
+    <url type="help">https://github.com/lumehq/coop/issues</url>
+    <url type="contact">https://reya.su/</url>
+    <url type="vcs-browser">https://github.com/lumehq/coop</url>
+    <url type="contribute">https://github.com/lumehq/coop/blob/main/CONTRIBUTING.md</url>
 
     <supports>
         <internet>yes</internet>

desktop/resources/snap/snapcraft.yaml.in

@@ -1,7 +1,3 @@
-# Snaps built by snapcraft without Snap Store credentials are unsigned and
-# cannot be installed without bypassing signature checks. Use:
-#   sudo snap install --dangerous ./coop_<version>_<arch>.snap
-# For signed installs (`snap install coop`), publish via the Snap Store.
 name: coop
 title: Coop
 base: core24
@@ -14,10 +10,10 @@ description: |
 grade: stable
 confinement: classic
 compression: lzo
-website: https://reya.info/coop
-source-code: https://git.reya.info/reya/coop
-issues: https://github.com/reyakov/coop/issues
-contact: https://coopchat.xyz
+website: https://reya.su/coop
+source-code: https://github.com/lumehq/coop
+issues: https://github.com/lumehq/coop/issues
+contact: https://reya.su
 
 parts:
   coop:

script/bundle-snap

@@ -35,7 +35,3 @@ SNAP_NAME="coop_${1}_${ARCH_SUFFIX}.snap"
 snapcraft --destructive-mode --output "$SNAP_NAME"
 
 echo "Created snap package: $SNAP_NAME"
-echo ""
-echo "This snap is unsigned (built without Snap Store credentials)."
-echo "To install it locally, use:"
-echo "  sudo snap install --dangerous ./$SNAP_NAME"

script/prepare-flathub

@@ -14,7 +14,7 @@ cd "$(dirname "$0")/.."
 # Configuration
 APP_ID="su.reya.coop"
 APP_NAME="Coop"
-REPO_URL="https://git.reya.info/reya/coop"
+REPO_URL="https://git.reya.su/reya/coop"
 BRANDING_LIGHT="#FFE629"
 BRANDING_DARK="#FFE629"
 
@@ -173,7 +173,7 @@ modules:
     sources:
       # Main source code - specific commit
       - type: git
-        url: https://git.reya.info/reya/coop.git
+        url: https://git.reya.su/reya/coop.git
         commit: "@COMMIT@"
         tag: "v@VERSION@"
 

script/release

@@ -29,29 +29,23 @@ fi
 # Function to update version in a Cargo.toml file
 update_version() {
     local file="$1"
-    local tmp="${file}.tmp"
+    local backup="${file}.bak"
 
-    # Portable in-place edit. `sed -i` behaves differently on GNU sed (Linux)
-    # and BSD sed (macOS): on macOS `sed -i -E` treats `-E` as the backup
-    # suffix instead of the extended-regex flag, leaving a stray
-    # `Cargo.toml-E` behind and never updating the file.
-    # Writing to a temp file and moving it over works on both implementations.
-    if sed -E "s/^[[:space:]]*version[[:space:]]*=[[:space:]]*\"[^\"]+\"/version = \"$NEW_VERSION\"/" "$file" > "$tmp" \
-        && mv "$tmp" "$file"; then
+    # Backup the original file
+    cp "$file" "$backup"
+
+    # More flexible regex that handles various version formats and whitespace
+    if sed -i -E "s/^[[:space:]]*version[[:space:]]*=[[:space:]]*\"[^\"]+\"/version = \"$NEW_VERSION\"/" "$file"; then
         echo "✓ Updated version to $NEW_VERSION in $file"
     else
         echo "Error: Failed to update version in $file"
-        # Remove any partial temp file; the original file is untouched
-        rm -f "$tmp"
+        # Restore original backup
+        mv "$backup" "$file"
         exit 1
     fi
 
-    # The substitution can silently match nothing (e.g. a `version.workspace` key),
-    # so verify the new version actually landed before moving on.
-    if ! grep -q "^[[:space:]]*version[[:space:]]*=[[:space:]]*\"$NEW_VERSION\"" "$file"; then
-        echo "Error: Version line not found/updated in $file"
-        exit 1
-    fi
+    # Remove the backup file
+    rm -f "$backup"
 }
 
 # Update both Cargo.toml files
@@ -59,78 +53,66 @@ echo "Updating versions..."
 update_version "$WORKSPACE_CARGO"
 update_version "$CRATE_CARGO"
 
+# Check git status before committing
+echo "Checking git status..."
+if git status --porcelain | grep -q .; then
+    echo "Current uncommitted changes:"
+    git status --short
+
+    # Ask user if they want to commit all changes or just version files
+    echo ""
+    echo "Do you want to:"
+    echo "1) Commit all current changes (including the version updates)"
+    echo "2) Commit only the version file changes"
+    echo "3) Abort the release"
+    read -p "Enter choice (1/2/3): " choice
+
+    case $choice in
+        1)
+            echo "Committing all changes..."
+            git add .
+            ;;
+        2)
+            echo "Committing only version file changes..."
+            git add "$WORKSPACE_CARGO" "$CRATE_CARGO"
+            ;;
+        3)
+            echo "Release aborted by user"
+            exit 0
+            ;;
+        *)
+            echo "Invalid choice. Release aborted."
+            exit 1
+            ;;
+    esac
+else
+    # Only version files were modified, add them specifically
+    echo "Only version files were modified, adding them for commit..."
+    git add "$WORKSPACE_CARGO" "$CRATE_CARGO"
+fi
+
+# Commit the changes
 COMMIT_MSG="chore: release version $NEW_VERSION"
 
-# When the requested version is already set there is nothing to bump or commit,
-# so the current commit is tagged as-is.
-if git diff --quiet -- "$WORKSPACE_CARGO" "$CRATE_CARGO"; then
-    echo "Version is already $NEW_VERSION, tagging the current commit"
+if git commit -m "$COMMIT_MSG"; then
+    echo "✓ Committed version changes"
 else
-    # Check git status before committing
-    echo "Checking git status..."
-    # The version files are always modified at this point, so only ask about other changes.
-    if [ -n "$(git status --porcelain -- . ":(exclude,top)$WORKSPACE_CARGO" ":(exclude,top)$CRATE_CARGO")" ]; then
-        echo "Current uncommitted changes:"
-        git status --short
+    echo "Error: Failed to commit version changes"
+    exit 1
+fi
 
-        # Ask user if they want to commit all changes or just version files
-        echo ""
-        echo "Do you want to:"
-        echo "1) Commit all current changes (including the version updates)"
-        echo "2) Commit only the version file changes"
-        echo "3) Abort the release"
-        read -p "Enter choice (1/2/3): " choice
-
-        case $choice in
-            1)
-                echo "Committing all changes..."
-                git add .
-                ;;
-            2)
-                echo "Committing only version file changes..."
-                git add "$WORKSPACE_CARGO" "$CRATE_CARGO"
-                ;;
-            3)
-                echo "Release aborted by user"
-                exit 0
-                ;;
-            *)
-                echo "Invalid choice. Release aborted."
-                exit 1
-                ;;
-        esac
-    else
-        # Only version files were modified, add them specifically
-        echo "Only version files were modified, adding them for commit..."
-        git add "$WORKSPACE_CARGO" "$CRATE_CARGO"
-    fi
-
-    # Commit the changes
-    if git commit -m "$COMMIT_MSG"; then
-        echo "✓ Committed version changes"
-    else
-        echo "Error: Failed to commit version changes"
-        exit 1
-    fi
-
-    # Push version changes to origin
-    echo "Pushing version changes to origin..."
-    if git push origin master; then
-        echo "✓ Successfully pushed version changes to origin"
-    else
-        echo "Error: Failed to push version changes to origin"
-        exit 1
-    fi
+# Push version changes to origin
+echo "Pushing version changes to origin..."
+if git push origin master; then
+    echo "✓ Successfully pushed version changes to origin"
+else
+    echo "Error: Failed to push version changes to origin"
+    exit 1
 fi
 
 # Create git tag
 TAG_NAME="v$NEW_VERSION"
 
-if git rev-parse -q --verify "refs/tags/$TAG_NAME" >/dev/null; then
-    echo "Error: tag $TAG_NAME already exists"
-    exit 1
-fi
-
 if git tag -a "$TAG_NAME" -m "$COMMIT_MSG"; then
     echo "✓ Created git tag: $TAG_NAME"
 else

script/try-snap

@@ -15,26 +15,11 @@ if [ "$#" -ne 1 ]; then
   exit 1
 fi
 
-# Get system architecture (same mapping as script/bundle-snap)
-ARCH=$(uname -m)
-case "$ARCH" in
-  x86_64) ARCH_SUFFIX="x86_64" ;;
-  aarch64) ARCH_SUFFIX="aarch64" ;;
-  *) echo "Unsupported architecture: $ARCH"; exit 1 ;;
-esac
-
-snap_file="coop_${1}_${ARCH_SUFFIX}.snap"
-if [ ! -f "$snap_file" ]; then
-  echo "Snap file not found: $snap_file"
-  echo "Build it first with: script/bundle-snap $1"
-  exit 1
-fi
-
 # Rerun as root
 [ "$UID" -eq 0 ] || exec sudo bash -e "$0" "$@"
 
 snap remove coop || true
 mkdir -p snap
 rm -rf snap/unpacked
-unsquashfs -dest snap/unpacked "$snap_file"
+unsquashfs -dest snap/unpacked "coop_$1_amd64.snap"
 snap try --classic snap/unpacked

web/Cargo.toml

@@ -30,6 +30,9 @@ console_error_panic_hook = "0.1"
 tracing-wasm = "0.2"
 console_log = "1.0"
 wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+js-sys = "0.3"
+web-sys = { version = "0.3", features = ["Window", "Performance", "console", "DomException"] }
 universal-time = { git = "https://github.com/shadowylab/universal-time" }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]

web/script/build-wasm.sh

@@ -36,6 +36,11 @@ if [[ "$(uname)" == "Darwin" ]]; then
 fi
 
 # Step 1: Build WASM
+#
+# Single-threaded build: `+bulk-memory` only. The multithreaded web backend
+# is disabled in `web/src/lib.rs` (gpui's wasm workers freeze their JS event
+# loop in `Atomics.wait`, which breaks nostr-sdk's spawn_local-driven client
+# and the WebSocket transport), so no atomics/shared-memory flags here.
 echo -e "${GREEN}Step 1: Building WASM...${NC}"
 cd "$PROJECT_ROOT"
 export CARGO_TARGET_DIR="$PROJECT_ROOT/target"

web/src/lib.rs

@@ -1,4 +1,8 @@
+use std::borrow::Cow;
+use std::cell::RefCell;
+
 use gpui::*;
+use theme::{Theme, ThemeMode};
 use ui::Root;
 use universal_time::{Instant, MonotonicClock, SystemTime, WallClock, define_time_provider};
 use wasm_bindgen::prelude::*;
@@ -7,22 +11,64 @@ struct CustomTimeProvider;
 
 impl WallClock for CustomTimeProvider {
     fn system_time(&self) -> SystemTime {
-        SystemTime::from_unix_duration(instant::Duration::from_secs(0))
+        // Browser wall clock: milliseconds since the Unix epoch.
+        let millis = js_sys::Date::now();
+        SystemTime::from_unix_duration(instant::Duration::from_millis(millis as u64))
     }
 }
 
 impl MonotonicClock for CustomTimeProvider {
     fn instant(&self) -> Instant {
-        Instant::from_ticks(instant::Duration::from_secs(0))
+        // `performance.now()` is monotonic; fall back to the wall clock if
+        // it's unavailable.
+        let millis = web_sys::window()
+            .and_then(|window| window.performance())
+            .map(|performance| performance.now())
+            .unwrap_or_else(js_sys::Date::now);
+        Instant::from_ticks(instant::Duration::from_millis(millis as u64))
     }
 }
 
 define_time_provider!(CustomTimeProvider);
 
-#[wasm_bindgen]
-pub fn run() -> Result<(), JsValue> {
-    console_error_panic_hook::set_once();
+thread_local! {
+    static APPLICATION: RefCell<Option<ApplicationHandle>> = const { RefCell::new(None) };
+}
 
+/// Applies a theme mode and restores the bundled web fonts.
+///
+/// `Theme::change` reapplies the theme config, which can carry its own font
+/// family; host system fonts are unavailable in wasm, so the bundled Inter
+/// fonts are put back afterwards.
+fn apply_theme(mode: ThemeMode, cx: &mut App) {
+    Theme::change(mode, None, cx);
+    Theme::global_mut(cx).font_family = "Inter".into();
+}
+
+/// Switches the app between light and dark after it is running.
+///
+/// The embedding page calls this to keep the app in sync with its own
+/// appearance.
+#[cfg(target_family = "wasm")]
+#[wasm_bindgen]
+pub fn set_theme(dark: bool) {
+    let mode = if dark {
+        ThemeMode::Dark
+    } else {
+        ThemeMode::Light
+    };
+    APPLICATION.with(|application| {
+        if let Some(handle) = application.borrow().as_ref() {
+            handle.update(|cx| {
+                apply_theme(mode, cx);
+                cx.refresh_windows();
+            });
+        }
+    });
+}
+
+#[wasm_bindgen]
+pub async fn run() -> Result<(), JsValue> {
     // Initialize logging to browser console
     console_log::init_with_level(log::Level::Info).expect("Failed to initialize logger");
 
@@ -32,21 +78,92 @@ pub fn run() -> Result<(), JsValue> {
     #[cfg(target_family = "wasm")]
     gpui_platform::web_init();
 
+    // Install the panic hook AFTER `web_init` (which sets the default
+    // `console_error_panic_hook`), so ours wins. It prints the entire
+    // JS/wasm stack as a single string: `console_error_panic_hook`'s default
+    // output is an `Error` object whose stack is collapsed in the console,
+    // and on wasm the frames below the panic machinery name the task that
+    // panicked (debug builds keep symbol names) — essential for diagnosing
+    // `RefCell already borrowed`.
+    #[cfg(target_family = "wasm")]
+    std::panic::set_hook(Box::new(|info| {
+        // Capture the JS stack (which includes the wasm frames with symbol
+        // names in debug builds) without constructing DOM objects.
+        let stack = js_sys::Reflect::get(&js_sys::Error::new(""), &"stack".into())
+            .ok()
+            .and_then(|v| v.as_string())
+            .unwrap_or_default();
+        web_sys::console::error_1(
+            &format!("{info}\n\n==== full stack ====\n{stack}\n=====================").into(),
+        );
+    }));
+
     #[cfg(not(target_family = "wasm"))]
     let app = gpui_platform::application();
 
     #[cfg(target_family = "wasm")]
     let app = {
-        let app = gpui_platform::single_threaded_web();
+        // Assets are not embedded in the WASM bundle; they are served from
+        // the `/assets/...` URL prefix (see `web/www/vite.config.js`) and
+        // downloaded by the `assets` crate.
+        let assets = assets::Assets::new("");
 
-        // 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) }
+        // Download every icon and brand asset before the first frame: brand
+        // images are loaded through GPUI's image cache, which does not retry
+        // failed loads, and pre-caching the icons lets them render
+        // immediately instead of waiting for a repaint.
+        assets.preload().await;
+
+        // NOTE: the multithreaded web backend (application_with_web_backend)
+        // cannot host this app's backend. gpui's wasm background workers
+        // block on `Atomics.wait` while idle, freezing their JS event loop,
+        // so `spawn_local`-driven tasks (nostr-sdk's client actor, the
+        // WebSocket transport) and fetch promises never make progress on a
+        // worker thread. Everything must run on the main thread.
+        gpui_platform::single_threaded_web().with_assets(assets)
     };
 
-    app.run(|cx| {
+    let launch = move |cx: &mut App| {
+        // Load the embedded Inter font stack for WASM, where host system
+        // fonts are unavailable. Inter is the app's UI font on Linux; the
+        // wasm build reuses it so the web app matches the desktop look.
+        let inter_regular =
+            Cow::Borrowed(include_bytes!("../../assets/fonts/Inter/Inter-Regular.ttf").as_slice());
+        let inter_italic =
+            Cow::Borrowed(include_bytes!("../../assets/fonts/Inter/Inter-Italic.ttf").as_slice());
+        let inter_medium =
+            Cow::Borrowed(include_bytes!("../../assets/fonts/Inter/Inter-Medium.ttf").as_slice());
+        let inter_medium_italic = Cow::Borrowed(
+            include_bytes!("../../assets/fonts/Inter/Inter-MediumItalic.ttf").as_slice(),
+        );
+        let inter_semibold =
+            Cow::Borrowed(include_bytes!("../../assets/fonts/Inter/Inter-SemiBold.ttf").as_slice());
+        let inter_semibold_italic = Cow::Borrowed(
+            include_bytes!("../../assets/fonts/Inter/Inter-SemiBoldItalic.ttf").as_slice(),
+        );
+        let inter_bold =
+            Cow::Borrowed(include_bytes!("../../assets/fonts/Inter/Inter-Bold.ttf").as_slice());
+        let inter_bold_italic = Cow::Borrowed(
+            include_bytes!("../../assets/fonts/Inter/Inter-BoldItalic.ttf").as_slice(),
+        );
+
+        cx.text_system()
+            .add_fonts(vec![
+                inter_regular,
+                inter_italic,
+                inter_medium,
+                inter_medium_italic,
+                inter_semibold,
+                inter_semibold_italic,
+                inter_bold,
+                inter_bold_italic,
+            ])
+            .expect("Failed to load fonts");
+
+        // Apply the system appearance before the first frame, so the app
+        // never flashes the default light theme.
+        apply_theme(cx.window_appearance().into(), cx);
+
         // Open the root window
         cx.open_window(WindowOptions::default(), |window, cx| {
             // Initialize components
@@ -78,7 +195,15 @@ pub fn run() -> Result<(), JsValue> {
         .expect("Failed to open window. Please restart the application.");
 
         cx.activate(true);
+    };
+
+    #[cfg(target_family = "wasm")]
+    APPLICATION.with(|application| {
+        *application.borrow_mut() = Some(app.run_embedded(launch));
     });
 
+    #[cfg(not(target_family = "wasm"))]
+    app.run(launch);
+
     Ok(())
 }

web/www/vite.config.js

@@ -10,7 +10,11 @@ export default defineConfig({
     viteStaticCopy({
       targets: [
         {
-          src: path.resolve(__dirname, "../../../assets/icons"),
+          src: path.resolve(__dirname, "../../assets/icons"),
+          dest: "assets",
+        },
+        {
+          src: path.resolve(__dirname, "../../assets/brand"),
           dest: "assets",
         },
       ],
@@ -19,9 +23,9 @@ export default defineConfig({
       name: "serve-assets",
       configureServer(server) {
         server.middlewares.use(
-          "/coop/assets",
+          "/assets",
           (req, res, next) => {
-            const assetsPath = path.resolve(__dirname, "../../../assets");
+            const assetsPath = path.resolve(__dirname, "../../assets");
             const filePath = path.join(
               assetsPath,
               req.url.replace("/assets", ""),