show owner avatar in repo row

Reviewed-on: #33

.github/workflows/release.yml

@@ -0,0 +1,173 @@
+name: Build and Release
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build:
+    name: Build ${{ matrix.platform }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: windows-x64
+            os: windows-latest
+            target: x86_64-pc-windows-msvc
+          - platform: windows-arm64
+            os: windows-11-arm
+            target: aarch64-pc-windows-msvc
+          - platform: macos-x64
+            os: macos-15-intel
+            target: x86_64-apple-darwin
+          - platform: macos-arm64
+            os: macos-latest
+            target: aarch64-apple-darwin
+          - platform: linux-x64
+            os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+          - platform: linux-arm64
+            os: ubuntu-24.04-arm
+            target: aarch64-unknown-linux-gnu
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      # Windows and macOS builds using cargo-packager
+      - name: Build with cargo-packager (Windows/macOS)
+        if: runner.os != 'Linux'
+        working-directory: desktop
+        run: |
+          cargo install cargo-packager --locked
+          cargo packager --release
+
+      - name: Upload Windows/macOS artifacts
+        if: runner.os != 'Linux'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.platform }}-artifacts
+          path: |
+            dist/*.dmg
+            dist/*.msi
+            dist/*.exe
+          if-no-files-found: error
+
+      # Linux builds using custom scripts
+      - name: Install Linux build dependencies
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y flatpak flatpak-builder snapd squashfs-tools jq gettext-base
+
+      - name: Install Snapcraft
+        if: runner.os == 'Linux'
+        run: sudo snap install snapcraft --classic
+
+      - name: Make scripts executable
+        if: runner.os == 'Linux'
+        run: |
+          chmod +x script/get-crate-version
+          chmod +x script/linux
+          chmod +x script/bundle-snap
+          chmod +x script/bundle-linux
+          chmod +x script/flatpak/deps
+          chmod +x script/flatpak/bundle-flatpak
+
+      - name: Install required dependencies
+        if: runner.os == 'Linux'
+        run: ./script/linux
+
+      # Build the release tarball on every Linux architecture
+      - name: Build release tarball
+        if: runner.os == 'Linux'
+        run: ./script/bundle-linux
+
+      # Only build Flatpak and Snap for x86_64 (most common use case)
+      - name: Build Flatpak
+        if: runner.os == 'Linux' && matrix.target == 'x86_64-unknown-linux-gnu'
+        run: |
+          ./script/flatpak/deps
+          ./script/flatpak/bundle-flatpak
+
+      - name: Build Snap
+        if: runner.os == 'Linux' && matrix.target == 'x86_64-unknown-linux-gnu'
+        run: |
+          VERSION=$(script/get-crate-version signed)
+          ./script/bundle-snap $VERSION
+
+      - name: Collect Linux artifacts
+        if: runner.os == 'Linux'
+        working-directory: ${{ github.workspace }}
+        run: |
+          mkdir -p linux-artifacts
+          # Copy the tarball created by bundle-linux
+          find target/release -name "*.tar.gz" -exec cp {} linux-artifacts/ \;
+          # Find and copy flatpak files (if they exist)
+          find . -name "*.flatpak" -exec cp {} linux-artifacts/ \; || true
+          # Find and copy snap files (if they exist)
+          find . -name "*.snap" -exec cp {} linux-artifacts/ \; || true
+          ls -la linux-artifacts/
+
+      - name: Upload Linux artifacts
+        if: runner.os == 'Linux'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.platform }}-artifacts
+          path: linux-artifacts/**/*
+          if-no-files-found: error
+
+  release:
+    name: Create Release
+    needs: build
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v') || github.event_name == 'workflow_dispatch'
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Make get-crate-version executable
+        run: chmod +x script/get-crate-version
+
+      - name: Get version
+        id: version
+        run: |
+          VERSION=$(script/get-crate-version signed)
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+          echo "tag=v$VERSION" >> $GITHUB_OUTPUT
+
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+
+      - name: Display artifacts structure
+        run: |
+          echo "Artifacts structure:"
+          find artifacts -type f -exec ls -la {} \;
+
+      - name: Create draft release
+        id: create_release
+        uses: akkuman/gitea-release-action@v1
+        with:
+          server_url: "https://git.reya.info/"
+          repository: "reya/signed"
+          token: ${{ secrets.GITEA_TOKEN }}
+          draft: true
+          prerelease: false
+          files: |
+            artifacts/**/*
+
+      - name: Output release info
+        run: |
+          echo "Created draft release: ${{ steps.create_release.outputs.url }}"
+          echo "Release ID: ${{ steps.create_release.outputs.id }}"

.github/workflows/rust.yml

@@ -0,0 +1,32 @@
+name: Rust
+
+on:
+  push:
+    branches: ["**"]
+  pull_request:
+    branches: ["m**"]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        rustup: [stable]
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Linux build dependencies
+        run: chmod +x ./script/linux && ./script/linux
+        if: matrix.os == 'ubuntu-latest'
+
+      - name: Build
+        run: cargo build --verbose
+
+      - name: Run tests
+        run: cargo test --verbose

.gitignore

@@ -1 +1,20 @@
-/target
+# Generated by Cargo
+# will have compiled files and executables
+debug/
+target/
+dist/
+
+# Snap and Flatpak local build output
+/snap
+/info.reya.signed.json
+/linux-artifacts
+
+# Vendored dependencies + cargo config generated by script/prepare-flathub
+.cargo/
+vendor/
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
+# macOS
+.DS_Store

AGENTS.md

@@ -0,0 +1,162 @@
+# 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.
+* Keep doc comments and comments simple, one line, straightforward, and unbloated.
+* Prefer implementing functionality in existing files unless it is a new logical component. Avoid creating many small files.
+* Prefer `impl` blocks over standalone functions: place functionality as methods or associated functions on the relevant type, extending the type's existing `impl` block instead of creating a duplicate one in another file.
+* Do not wrap clients or SDK dependencies in project structs or pass-through helper functions, call their methods directly where needed. Extract a helper only when it holds real logic that is used in more than one place.
+* Bind a global store handle to a local before using it (`let state = GlobalState::global(cx);` then `state.update(...)`) instead of chaining on `CheckoutsStore::global(cx)` inline.
+* 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)`.
+
+Prefer keeping a task in a field over `.detach()` when the work belongs to a view or store. A detached task outlives the view that started it (for example, a repository panel the user has closed), while a task stored in a field is cancelled when that struct drops. A finished `Task` held in a container is not reaped by GPUI - it stays alive until its handle is dropped - so if the container can accumulate many runs, either drop the finished handles before pushing a new one, or hold a single `Option<Task<_>>` and replace it.
+
+## 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.
+
+GPUI also tracks the entities a window reads while rendering. When an entity notifies, every view that read that entity during the previous frame is rerendered automatically.
+
+* A view that reads an entity in render (e.g. `state.read(cx).profile(...)`) does not need `cx.observe(&entity, ...)` to pick up its changes - the read itself is the dependency. Reserve `cx.observe` and `cx.subscribe` for when the view must run logic in response to a change (rebuild derived state, re-query, dedupe), not to trigger a re-render.
+* Notify the narrowest entity holding the change. Notifying a global store rerenders every view that ever read it; notifying a per-panel entity rerenders only the panels reading it.
+* This works with cached panels (`panel.cached(...)`): a cached subtree repaints when the view it belongs to is invalidated.
+
+## 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
+```

CHANGELOG.md

@@ -0,0 +1,90 @@
+# Changelog
+
+## v0.2.0 - 2026/10/21
+
+### Added
+
+- Follow the operating system's native theme on macOS, Windows and Linux (KDE, GNOME), applying the OS colors, fonts, radii and accessibility preferences.
+- Add an identity import dialog, importing an existing identity by pasting its `nsec` secret key (encrypted with a new passphrase), NIP-49 `ncryptsec` (unlocked with its passphrase), or `bunker://` NIP-46 URI
+- Add a dropdown menu on the signed-in user button in the sidebar
+- Add sign-out feature, confirmed by an alert dialog before deleting the stored session credential
+- Add a quit action, bound to `secondary-q` (cmd on macOS, ctrl on others)
+- Allow choosing the default branch when publishing a repository
+- Detect when local commits are not on Nostr yet, showing an unsynced count badge on sidebar repository rows and a Sync now banner on the repository view
+- Add a step-by-step push checklist while publishing and syncing a repository
+- Add a `Reset remote to local` action that republishes the mirror and deletes grasp refs the mirror does not have
+
+### Changed
+
+- Use the built-in light/dark syntax highlighting palette instead of the Signed palette bundled in `signed.json` when the native theme is active
+- Increase the default theme corner radii from 2 to 4 and large radii from 6 to 8
+- Surface backend errors as error notifications in the workspace instead of silently dropping them
+- Break ties in repository activity lists by event id, so same-second events order deterministically
+- Restructure the backend around domain types: git operations behind a `Repo` type, the grasp push pipeline behind `GraspPush`, nostr connectivity behind `NostrBackend`, and shared helpers consolidated into `utils`
+- Fetch the logged-in user's grasp list, code follows, followed repositories, contacts, profile metadata, mute list, and blossom servers via gossip at login instead of the bootstrap relays
+- Connect to grasp relays and load the inbox only after the user's grasp list event arrives
+- Refresh the checkouts store only when the checkouts settings change
+- Restructure the core crate into focused modules for announcements, pull requests, git events, inbox, and upstream state
+- Publish nostr events directly through the client with relay acceptance required, removing the grasp push helper and its per-server retry loop so failures surface immediately
+- Poll the repository sync drift check every 180 seconds instead of 60
+- Track sync status per view instead of globally
+- Merge the `PixelAvatar` into the `Avatar` component. Seed user pixel avatars from the public key instead of the display name, so avatars stay stable when a user renames
+
+### Fixed
+
+- Fix the repository view refreshing its mirror from the network while a push is in progress, so the refresh no longer races the push
+- Fix opening a repository failing with a `destination already exists` error when two loads raced to clone its mirror, clones are now serialized and later loads reuse the finished clone
+- Fix a repository never opening again after an interrupted clone left an unusable mirror directory behind, which is now removed and re-cloned
+- Fix signing in with a `bunker://` URI silently generating a new identity instead of erroring when its master key cannot be parsed
+- Fix repository sync failing with `state event in purgatory ... doesn't match push` when grasp servers hold branches or tags the local repository lacks
+- Fix sync failing with `could not fetch refs/tags/...^{}` on repositories with annotated tags, where the peel entries `git ls-remote` reports for annotated tags were mistaken for missing refs
+
+### Removed
+
+- Remove the light/dark theme pickers and the font size, corner radius, focus ring and shadow settings from the settings dialog; colors and geometry now come from the native theme
+- Remove dead code: the unused `login`/`logout` family, the unwired `SyncProgress` pipeline, `merge_pull_request`, inbox mark-read/archive APIs and the wasm32-only code paths
+
+## v0.2.0-alpha - 2026/09/27
+
+### Added
+
+- Show an avatar in each panel's tab, using the repository owner's profile picture when set and a pixel avatar otherwise
+- Add a Tab Bar setting to hide the previous/next tab buttons, hidden by default
+- Add an Event Fetching Strategy setting, fetching a repository's activity from its announced relays only (Curated) or from every maintainer's relays as well (Uncensored, the default)
+
+### Changed
+
+- Migrate the GPUI foundation to the published `gpui-pre` crates and GPUI Kit 0.6, off the zed and gpui-component git pins
+- Use the pixel avatar as the single fallback for a missing picture, sized and rounded to match the other avatars
+- Redesign the dock tab bar, using muted grey active tab, added close buttons, double-click to zoom, and removed panel toolbar
+- Connect to bootstrap relays on demand instead of at startup
+- Fetch profile metadata in batches of 100 authors, applying every requested profile in a single database query
+- Prefetch the 500 most recent profiles at startup instead of 200
+
+### Fixed
+
+- Render every avatar at one consistent size, where a surrounding border had shrunk pictures by two pixels and the pixel avatar ignored an explicit size
+- Date repositories from their repository state event, so the explore list and open repository views show the latest push instead of the announcement date
+- Fix background tasks outliving their view, so a closed repository panel or pull request view stops fetching and publishing on its own
+
+### Removed
+
+- Remove cover note support, the kind-1624 GitWorkshop and `ngit` extension outside the NIP-34
+
+## v0.1.0-alpha - 2026/09/14
+
+Initial alpha release.
+
+### Added
+
+- Create and unlock a passphrase-protected Nostr identity
+- Browse and search NIP-34 repositories with All, Popular and Recent filters
+- Scan local Git repositories and detect their NIP-34 and GRASP bindings
+- Create, publish, clone and open repositories
+- Repository view with files, commit history, branches and tags
+- Colour-coded commit diffs
+- Issues and pull requests with discussions
+- Send patches and push branches
+- Inbox for repository activity
+- Settings for appearance, theme, GRASP servers and repository scan paths
+- Release and packaging infrastructure

Cargo.toml

@@ -4,38 +4,35 @@ members = ["crates/*", "desktop"]
 default-members = ["desktop"]
 
 [workspace.package]
-version = "1.0.0"
+version = "0.2.0"
 edition = "2024"
 publish = false
 
 [workspace.dependencies]
-# GPUI
-gpui = { git = "https://github.com/zed-industries/zed" }
-gpui_platform = { git = "https://github.com/zed-industries/zed", features = ["font-kit", "x11", "wayland"] }
-gpui_linux = { git = "https://github.com/zed-industries/zed" }
-gpui_windows = { git = "https://github.com/zed-industries/zed" }
-gpui_macos = { git = "https://github.com/zed-industries/zed" }
-gpui_tokio = { git = "https://github.com/zed-industries/zed" }
-reqwest_client = { git = "https://github.com/zed-industries/zed" }
+gpui = { package = "gpui-pre", version = "0.3.8" }
+gpui_platform = { package = "gpui-pre-platform", version = "0.3.8", features = ["font-kit", "x11", "wayland"] }
+reqwest_client = { package = "gpui-pre-reqwest-client", version = "0.3.8" }
 
-# `tree-sitter-languages` enables syntax highlighting for the TextView
-# code preview (fenced code blocks are highlighted with tree-sitter).
-gpui-component = { git = "https://github.com/longbridge/gpui-component", features = ["tree-sitter-languages"] }
-gpui-base = { git = "https://github.com/longbridge/gpui-component" }
+# GPUI Kit; exact pins keep the graph on the gpui-pre 0.3.8 closure that
+# native-theme-gpui 0.6.1 is verified against (0.7.3 and 0.8 pin 0.3.9).
+gpui-component = { version = "=0.7.1", features = ["tree-sitter-languages"] }
+gpui-base = "=0.7.1"
+
+native-theme = { version = "0.6.1", features = ["watch"] }
+native-theme-gpui = { version = "0.6.1", default-features = false, features = ["system-fonts"] }
 
 dock = { path = "crates/dock" }
+settings = { path = "crates/settings" }
 
 nostr = { git = "https://github.com/rust-nostr/nostr", features = ["nip59", "nip49", "nip44", "os-rng"] }
 nostr-lmdb = { git = "https://github.com/rust-nostr/nostr" }
-nostr-memory = { git = "https://github.com/rust-nostr/nostr" }
 nostr-blossom = { git = "https://github.com/rust-nostr/nostr" }
 nostr-gossip-memory = { git = "https://github.com/rust-nostr/nostr" }
 nostr-connect = { git = "https://github.com/rust-nostr/nostr" }
 nostr-sdk = { git = "https://github.com/rust-nostr/nostr" }
 
-gix = { version = "0.86", default-features = false, features = ["sha1", "blocking-network-client", "blocking-http-transport-reqwest-rust-tls", "worktree-mutation"] }
+gix = { version = "0.88", default-features = false, features = ["sha1", "blocking-network-client", "blocking-http-transport-reqwest-rust-tls", "worktree-mutation", "status"] }
 
-chrono = { version = "0.4.38", features = ["wasmbind"] }
 smol = "2"
 futures = "0.3"
 flume = { version = "0.11.1", default-features = false, features = ["async", "select"] }
@@ -51,16 +48,12 @@ tracing = "0.1"
 errno = { version = "0.3.14", default-features = false }
 instant = "0.1"
 
-[patch.crates-io]
-# Use stacker's psm version which may have better WASM support
-psm = { git = "https://github.com/rust-lang/stacker", branch = "master" }
-
 [profile.release]
 strip = true
 opt-level = "z"
 lto = true
 codegen-units = 1
-panic = "abort"
+panic = "unwind"
 
 [profile.profiling]
 inherits = "release"

crates/assets/Cargo.toml

@@ -8,7 +8,6 @@ publish.workspace = true
 gpui.workspace = true
 gpui-component.workspace = true
 anyhow.workspace = true
-log.workspace = true
 rust-embed.workspace = true
 
 [dev-dependencies]

crates/assets/assets/icons/chevron-down.svg

@@ -1 +1,3 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none"><path d="M20 9L13.4142 15.5858C12.6332 16.3668 11.3669 16.3668 10.5858 15.5858L4 9" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M5.75 9.5L12 15.75L18.25 9.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

crates/assets/assets/icons/circle-plus.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M16.2426 12.0005H7.75736M12 16.2431V7.75781M21.25 12C21.25 17.1086 17.1086 21.25 12 21.25C6.89137 21.25 2.75 17.1086 2.75 12C2.75 6.89137 6.89137 2.75 12 2.75C17.1086 2.75 21.25 6.89137 21.25 12Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+</svg>

crates/assets/assets/icons/git-commit.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<circle cx="12" cy="12" r="5.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/><path d="M6.5 12H1.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/><path d="M22.25 12H17.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+</svg>

crates/assets/assets/icons/git-file.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M20.255 17.05V10.35C20.255 9.78995 20.255 9.50992 20.146 9.29601C20.0501 9.10785 19.8972 8.95487 19.709 8.85899C19.4951 8.75 19.2151 8.75 18.655 8.75H5.35C4.78995 8.75 4.50992 8.75 4.29601 8.85899C4.10785 8.95487 3.95487 9.10785 3.85899 9.29601C3.75 9.50992 3.75 9.78995 3.75 10.35V17.05C3.75 18.1701 3.75 18.7302 3.96799 19.158C4.15973 19.5343 4.46569 19.8403 4.84202 20.032C5.26984 20.25 5.82989 20.25 6.95 20.25H17.055C18.1751 20.25 18.7352 20.25 19.163 20.032C19.5393 19.8403 19.8453 19.5343 20.037 19.158C20.255 18.7302 20.255 18.1701 20.255 17.05Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M5.75 8V3.75C5.75 3.19772 6.19772 2.75 6.75 2.75H9.67157C10.202 2.75 10.7107 2.96071 11.0858 3.33579L12.2071 4.45711C12.3946 4.64464 12.649 4.75 12.9142 4.75H17.25C17.8023 4.75 18.25 5.19772 18.25 5.75V8" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M7.75 12.75L11.75 12.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

crates/assets/assets/icons/git-issue-done.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M21.25 12C21.25 17.1086 17.1086 21.25 12 21.25C6.89137 21.25 2.75 17.1086 2.75 12C2.75 6.89137 6.89137 2.75 12 2.75C17.1086 2.75 21.25 6.89137 21.25 12Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="3 4"/>
+</svg>

crates/assets/assets/icons/grid.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M3.75 5.75C3.75 4.64543 4.64543 3.75 5.75 3.75H8.25C9.35457 3.75 10.25 4.64543 10.25 5.75V8.25C10.25 9.35457 9.35457 10.25 8.25 10.25H5.75C4.64543 10.25 3.75 9.35457 3.75 8.25V5.75Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M3.75 15.75C3.75 14.6454 4.64543 13.75 5.75 13.75H8.25C9.35457 13.75 10.25 14.6454 10.25 15.75V18.25C10.25 19.3546 9.35457 20.25 8.25 20.25H5.75C4.64543 20.25 3.75 19.3546 3.75 18.25V15.75Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M13.75 17C13.75 15.2051 15.2051 13.75 17 13.75C18.7949 13.75 20.25 15.2051 20.25 17C20.25 18.7949 18.7949 20.25 17 20.25C15.2051 20.25 13.75 18.7949 13.75 17Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M13.75 5.75C13.75 4.64543 14.6454 3.75 15.75 3.75H18.25C19.3546 3.75 20.25 4.64543 20.25 5.75V8.25C20.25 9.35457 19.3546 10.25 18.25 10.25H15.75C14.6454 10.25 13.75 9.35457 13.75 8.25V5.75Z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

crates/assets/assets/icons/init.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M18.5 19.0615C20.6627 18.4544 22.25 16.4502 22.25 14.0714C22.25 11.2114 19.9555 8.89286 17.125 8.89286C16.5661 8.89286 16.0281 8.98326 15.5245 9.15037C14.4289 6.56294 11.8865 4.75 8.925 4.75C4.96236 4.75 1.75 7.99594 1.75 12C1.75 14.7508 3.26609 17.1437 5.5 18.3722M14.5 16.25L12 13.75L9.5 16.25M12 20V14.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

crates/assets/assets/icons/markdown.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M21.25 6.75C21.25 5.64543 20.3546 4.75 19.25 4.75H4.75C3.64543 4.75 2.75 5.64543 2.75 6.75V17.25C2.75 18.3546 3.64543 19.25 4.75 19.25H19.25C20.3546 19.25 21.25 18.3546 21.25 17.25V6.75Z" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M6.75 14.25V9.75L9 12L11.25 9.75V14.25" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M15.75 9.75V14.25L14 12.5" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M15.75 14.25L17.5 12.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

crates/assets/assets/icons/panel-bottom-open.svg

@@ -1 +1,3 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-panel-bottom-open"><rect width="18" height="18" x="3" y="3" rx="2"/><path d="M3 15h18"/><path d="m9 10 3-3 3 3"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M19.25 4C20.7688 4 22 5.23122 22 6.75V17.25C22 18.7688 20.7688 20 19.25 20H4.75C3.23122 20 2 18.7688 2 17.25V6.75C2 5.23122 3.23122 4 4.75 4H19.25ZM6.75 14.5C6.33579 14.5 6 14.8358 6 15.25C6 15.6642 6.33579 16 6.75 16H17.25C17.6642 16 18 15.6642 18 15.25C18 14.8358 17.6642 14.5 17.25 14.5H6.75Z" fill="currentColor"/>
+</svg>

crates/assets/assets/icons/panel-bottom.svg

@@ -1 +1,3 @@
-<svg viewBox="0 0 24 24" fill="currentColor" xmlns="http://www.w3.org/2000/svg"><path d="M21 3C21.5523 3 22 3.44772 22 4V20C22 20.5523 21.5523 21 21 21H3C2.44772 21 2 20.5523 2 20V4C2 3.44772 2.44772 3 3 3H21ZM4 16V19H20V16H4ZM4 14H20V5H4V14Z"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M2.75 6.75C2.75 5.64543 3.64543 4.75 4.75 4.75H19.25C20.3546 4.75 21.25 5.64543 21.25 6.75V17.25C21.25 18.3546 20.3546 19.25 19.25 19.25H4.75C3.64543 19.25 2.75 18.3546 2.75 17.25V6.75Z" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M17.25 15.25L6.75 15.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

crates/assets/assets/icons/plus.svg

@@ -1 +1,3 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none"><path d="M12 5.25V12M12 12V18.75M12 12H5.25M12 12H18.75" stroke="black" stroke-width="1.5" stroke-linecap="round"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M12 5.25V12M12 12V18.75M12 12H5.25M12 12H18.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+</svg>

crates/assets/assets/icons/recent.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M12 7.75V12L15.5 15.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M2.75 4.75V8.75H6.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M3.25 15.0833C4.52169 18.676 7.95303 21.25 11.9864 21.25C17.1026 21.25 21.25 17.1086 21.25 12C21.25 6.89137 17.1026 2.75 11.9864 2.75C8.14808 2.75 4.85497 5.08106 3.44947 8.40278" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

crates/assets/assets/icons/refresh.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M13 21C13.5523 21 14 20.5523 14 20C14 19.4477 13.5523 19 13 19C12.4477 19 12 19.4477 12 20C12 20.5523 12.4477 21 13 21Z" fill="currentColor"/><path d="M21 11C21 10.4477 20.5523 9.99999 20 9.99999C19.4477 9.99999 19 10.4477 19 11C19 11.5523 19.4477 12 20 12C20.5523 12 21 11.5523 21 11Z" fill="currentColor"/><path d="M19.9295 14.2679C20.4078 14.5441 20.5716 15.1557 20.2955 15.634C20.0193 16.1123 19.4078 16.2761 18.9295 16C18.4512 15.7238 18.2873 15.1123 18.5634 14.634C18.8396 14.1557 19.4512 13.9918 19.9295 14.2679Z" fill="currentColor"/><path d="M17.3676 19.2942C17.8459 19.0181 18.0098 18.4065 17.7336 17.9282C17.4575 17.4499 16.8459 17.286 16.3676 17.5621C15.8893 17.8383 15.7254 18.4499 16.0016 18.9282C16.2777 19.4065 16.8893 19.5703 17.3676 19.2942Z" fill="currentColor"/><path d="M18.9269 7.99998C18.4487 8.27612 17.8371 8.11225 17.5609 7.63396C17.2848 7.15566 17.4487 6.54407 17.9269 6.26793C18.4052 5.99179 19.0168 6.15566 19.293 6.63396C19.5691 7.11225 19.4052 7.72384 18.9269 7.99998Z" fill="currentColor"/><path d="M9.25 14.75V20.25H3.75" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/><path d="M15.2493 4.41452C14.2521 3.98683 13.1537 3.75 12 3.75C7.44365 3.75 3.75 7.44365 3.75 12C3.75 15.498 5.92698 18.4875 9 19.6876" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

crates/assets/assets/icons/settings.svg

@@ -1 +1,3 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none"><path d="M19.2479 6.923L12.9979 3.32455C12.3802 2.96888 11.6198 2.96888 11.0021 3.32455L4.75208 6.92297C4.13211 7.27992 3.75 7.94083 3.75 8.65622V15.3439C3.75 16.0593 4.13213 16.7202 4.75213 17.0772L11.0021 20.6754C11.6198 21.031 12.3802 21.031 12.9979 20.6753L19.2479 17.0769C19.8679 16.7199 20.25 16.059 20.25 15.3436V8.65625C20.25 7.94086 19.8679 7.27995 19.2479 6.923Z" stroke="black" stroke-width="1.5" stroke-linecap="square"/><path d="M15.25 12C15.25 13.7949 13.7949 15.25 12 15.25C10.2051 15.25 8.75 13.7949 8.75 12C8.75 10.2051 10.2051 8.75 12 8.75C13.7949 8.75 15.25 10.2051 15.25 12Z" stroke="black" stroke-width="1.5" stroke-linecap="square"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M7.878 5.21415L7.17474 5.05186C6.58003 4.91462 5.95657 5.09343 5.525 5.525C5.09343 5.95657 4.91462 6.58003 5.05186 7.17474L5.21415 7.878C5.40122 8.6886 5.06696 9.53036 4.37477 9.99182L3.51965 10.5619C3.03881 10.8825 2.75 11.4221 2.75 12C2.75 12.5779 3.03881 13.1175 3.51965 13.4381L4.37477 14.0082C5.06696 14.4696 5.40122 15.3114 5.21415 16.122L5.05186 16.8253C4.91462 17.42 5.09343 18.0434 5.525 18.475C5.95657 18.9066 6.58003 19.0854 7.17474 18.9481L7.878 18.7858C8.6886 18.5988 9.53036 18.933 9.99182 19.6252L10.5619 20.4804C10.8825 20.9612 11.4221 21.25 12 21.25C12.5779 21.25 13.1175 20.9612 13.4381 20.4804L14.0082 19.6252C14.4696 18.933 15.3114 18.5988 16.122 18.7858L16.8253 18.9481C17.42 19.0854 18.0434 18.9066 18.475 18.475C18.9066 18.0434 19.0854 17.42 18.9481 16.8253L18.7858 16.122C18.5988 15.3114 18.933 14.4696 19.6252 14.0082L20.4804 13.4381C20.9612 13.1175 21.25 12.5779 21.25 12C21.25 11.4221 20.9612 10.8825 20.4804 10.5619L19.6252 9.99182C18.933 9.53036 18.5988 8.6886 18.7858 7.878L18.9481 7.17473C19.0854 6.58003 18.9066 5.95657 18.475 5.525C18.0434 5.09343 17.42 4.91462 16.8253 5.05186L16.122 5.21415C15.3114 5.40122 14.4696 5.06696 14.0082 4.37477L13.4381 3.51965C13.1175 3.03881 12.5779 2.75 12 2.75C11.4221 2.75 10.8825 3.03881 10.5619 3.51965L9.99182 4.37477C9.53036 5.06696 8.6886 5.40122 7.878 5.21415Z" stroke="currentColor" stroke-width="1.5" stroke-linejoin="round"/><path d="M14.75 12C14.75 13.5188 13.5188 14.75 12 14.75C10.4812 14.75 9.25 13.5188 9.25 12C9.25 10.4812 10.4812 9.25 12 9.25C13.5188 9.25 14.75 10.4812 14.75 12Z" stroke="currentColor" stroke-width="1.5" stroke-linejoin="round"/>
+</svg>

crates/assets/assets/icons/share.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M9.00003 10.4286L14 7.57141M9.00003 13.5714L14 16.4286M20.25 6C20.25 7.79493 18.7949 9.25 17 9.25C15.2051 9.25 13.75 7.79493 13.75 6C13.75 4.20507 15.2051 2.75 17 2.75C18.7949 2.75 20.25 4.20507 20.25 6ZM20.25 18C20.25 19.7949 18.7949 21.25 17 21.25C15.2051 21.25 13.75 19.7949 13.75 18C13.75 16.2051 15.2051 14.75 17 14.75C18.7949 14.75 20.25 16.2051 20.25 18ZM9.25 12C9.25 13.7949 7.79493 15.25 6 15.25C4.20507 15.25 2.75 13.7949 2.75 12C2.75 10.2051 4.20507 8.75 6 8.75C7.79493 8.75 9.25 10.2051 9.25 12Z" stroke="currentColor" stroke-width="1.5"/>
+</svg>

crates/assets/assets/icons/trending.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+<path d="M15.75 6.75H21.25V12.25M20.7361 7.275L14.4142 13.5878C13.633 14.3679 12.3675 14.3675 11.5868 13.5868L10.4142 12.4142C9.63316 11.6332 8.36684 11.6332 7.58579 12.4142L2.75 17.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

crates/assets/assets/themes/signed.json

@@ -2,572 +2,429 @@
   "$schema": "https://github.com/longbridge/gpui-component/raw/refs/heads/main/.theme-schema.json",
   "name": "Signed",
   "author": "Signed",
-  "url": "https://git.reya.su/reya/signed",
   "themes": [
     {
+      "is_default": true,
       "name": "Signed Light",
       "mode": "light",
       "colors": {
-        "accent.background": "#F4F4F5",
-        "accent.foreground": "#18181B",
+        "accent.background": "#F0F0F0",
+        "accent.foreground": "#202020",
         "accordion.background": "#FFFFFF",
         "background": "#FFFFFF",
         "border": "#E4E4E7",
-        "button.background": "#FFFFFF",
-        "button.active.background": "#E4E4E7",
-        "button.foreground": "#18181B",
-        "button.hover.background": "#F4F4F5",
-        "button.danger.background": "#DC2626",
-        "button.danger.active.background": "#B91C1C",
-        "button.danger.foreground": "#FFFFFF",
-        "button.danger.hover.background": "#EF4444",
-        "button.info.background": "#0284C7",
-        "button.info.active.background": "#0369A1",
-        "button.info.foreground": "#FFFFFF",
-        "button.info.hover.background": "#0EA5E9",
-        "button.primary.background": "#C6FF4D",
-        "button.primary.active.background": "#65A30D",
-        "button.primary.foreground": "#0B0F0C",
-        "button.primary.hover.background": "#B2EC3C",
-        "button.secondary.background": "#F4F4F5",
-        "button.secondary.active.background": "#D4D4D8",
-        "button.secondary.foreground": "#18181B",
-        "button.secondary.hover.background": "#E4E4E7",
-        "button.success.background": "#2FBF71",
-        "button.success.active.background": "#1F9A58",
-        "button.success.foreground": "#0B0F0C",
-        "button.success.hover.background": "#2AB568",
-        "button.warning.background": "#D97706",
-        "button.warning.active.background": "#B45309",
-        "button.warning.foreground": "#FFFFFF",
-        "button.warning.hover.background": "#F59E0B",
-        "group_box.background": "#F4F4F5",
-        "group_box.foreground": "#18181B",
-        "group_box.title.foreground": "#18181B",
-        "caret": "#18181B",
-        "chart.1": "#65A30D",
-        "chart.2": "#2FBF71",
-        "chart.3": "#3F6212",
-        "chart.4": "#7A8B5F",
-        "chart.5": "#A1A1AA",
-        "chart_bullish": "#2FBF71",
-        "chart_bearish": "#DC2626",
-        "danger.background": "#DC2626",
-        "danger.active.background": "#B91C1C",
-        "danger.foreground": "#FFFFFF",
-        "danger.hover.background": "#EF4444",
-        "description_list.label.background": "#F4F4F5",
-        "description_list.label.foreground": "#71717A",
+        "caret": "#202020",
+        "chart.1": "#93C5FD",
+        "chart.2": "#3B82F6",
+        "chart.3": "#2563EB",
+        "chart.4": "#1D4ED8",
+        "chart.5": "#1E40AF",
+        "chart_bullish": "green-600",
+        "chart_bearish": "red-600",
+        "danger.background": "red-500",
+        "danger.foreground": "neutral-50",
+        "description_list.label.foreground": "#202020",
         "drag.border": "#65A30D",
-        "drop_target.background": "#65A30D33",
+        "drop_target.background": "#C6FF4D40",
         "foreground": "#18181B",
-        "info.background": "#0284C7",
-        "info.active.background": "#0369A1",
-        "info.foreground": "#FFFFFF",
-        "info.hover.background": "#0EA5E9",
-        "input.border": "#D4D4D8",
-        "link": "#65A30D",
+        "group_box.background": "#F0F0F0",
+        "group_box.foreground": "#202020",
+        "info.background": "cyan-500",
+        "info.foreground": "neutral-50",
+        "input.border": "#E4E4E7",
+        "link": "#3F6212",
         "link.active": "#3F6212",
-        "link.hover": "#4A7A0B",
+        "link.hover": "#65A30D",
         "list.background": "#FFFFFF",
-        "list.active.background": "#C6FF4D40",
-        "list.active.border": "#65A30D80",
-        "list.even.background": "#FAFAFA",
-        "list.head.background": "#FAFAFA",
-        "list.hover.background": "#F4F4F5",
-        "muted.background": "#F4F4F5",
-        "muted.foreground": "#71717A",
+        "list.active.background": "#C6FF4D33",
+        "list.active.border": "#65A30D",
+        "list.even.background": "#F9F9F9",
+        "list.head.background": "#F9F9F9",
+        "list.hover.background": "#F0F0F0",
+        "muted.background": "#F9F9F9",
+        "muted.foreground": "#646464",
+        "overlay": "#0000000D",
         "popover.background": "#FFFFFF",
         "popover.foreground": "#18181B",
         "primary.background": "#C6FF4D",
         "primary.active.background": "#65A30D",
-        "primary.foreground": "#0B0F0C",
-        "primary.hover.background": "#B2EC3C",
-        "progress.bar.background": "#65A30D",
-        "ring": "#65A30D",
-        "scrollbar.background": "#FFFFFF00",
-        "scrollbar.thumb.background": "#A1A1AA99",
-        "scrollbar.thumb.hover.background": "#A1A1AA",
-        "secondary.background": "#F4F4F5",
-        "secondary.active.background": "#D4D4D8",
-        "secondary.foreground": "#18181B",
-        "secondary.hover.background": "#E4E4E7",
-        "selection.background": "#C6FF4D59",
-        "sidebar.background": "#FAFAFA",
-        "sidebar.accent.background": "#C6FF4D40",
-        "sidebar.accent.foreground": "#65A30D",
-        "sidebar.border": "#E4E4E7",
-        "sidebar.foreground": "#18181B",
-        "sidebar.primary.background": "#F4F4F5",
-        "sidebar.primary.foreground": "#18181B",
-        "skeleton.background": "#E4E4E7",
-        "slider.background": "#E4E4E7",
-        "slider.thumb.background": "#65A30D",
+        "primary.active.foreground": "#F7FEE7",
+        "primary.foreground": "#1A2E05",
+        "primary.hover.background": "#B7F03E",
+        "progress.bar.background": "#18181B",
+        "ring": "#BBBBBB",
+        "scrollbar.background": "#F9F9F900",
+        "scrollbar.thumb.background": "#BBBBBBE6",
+        "scrollbar.thumb.hover.background": "#BBBBBB",
+        "secondary.background": "#F0F0F0",
+        "secondary.active.background": "#E0E0E0",
+        "secondary.foreground": "#202020",
+        "secondary.hover.background": "#E8E8E8",
+        "selection.background": "#55A0FC",
+        "sidebar.background": "#F9F9F9",
+        "sidebar.accent.background": "#F0F0F0",
+        "sidebar.accent.foreground": "#202020",
+        "sidebar.border": "#E8E8E8",
+        "sidebar.foreground": "#202020",
+        "sidebar.primary.background": "#C6FF4D",
+        "sidebar.primary.foreground": "#1A2E05",
+        "skeleton.background": "#F0F0F0",
+        "slider.background": "#18181B",
+        "slider.thumb.background": "#FFFFFF",
+        "status_bar.background": "#F9F9F9",
+        "status_bar.border": "#E8E8E8",
         "success.background": "#2FBF71",
-        "success.active.background": "#1F9A58",
-        "success.foreground": "#0B0F0C",
-        "success.hover.background": "#2AB568",
-        "switch.background": "#D4D4D8",
+        "success.foreground": "#052E16",
+        "switch.background": "#CECECE",
         "switch.thumb.background": "#FFFFFF",
-        "tab.background": "#F4F4F5",
-        "tab.active.background": "#EBFFC1",
-        "tab.active.foreground": "#3F6212",
-        "tab.foreground": "#71717A",
-        "tab_bar.background": "#F4F4F5",
-        "tab_bar.segmented.background": "#E4E4E7",
+        "tab.background": "#E8E8E8",
+        "tab.active.background": "#F5F5F5",
+        "tab.active.foreground": "#18181B",
+        "tab.foreground": "#646464",
+        "tab_bar.background": "#F0F0F0",
+        "tab_bar.segmented.background": "#F0F0F0",
         "table.background": "#FFFFFF",
-        "table.active.background": "#C6FF4D40",
-        "table.active.border": "#65A30D80",
-        "table.even.background": "#FAFAFA",
-        "table.head.background": "#FAFAFA",
-        "table.head.foreground": "#71717A",
-        "table.foot.background": "#FAFAFA",
-        "table.foot.foreground": "#71717A",
-        "table.hover.background": "#F4F4F5",
-        "table.row.border": "#E4E4E7",
-        "title_bar.background": "#FAFAFA",
-        "title_bar.border": "#E4E4E7",
-        "status_bar.background": "#FAFAFA",
-        "status_bar.border": "#E4E4E7",
-        "tiles.background": "#FFFFFF",
-        "warning.background": "#D97706",
-        "warning.active.background": "#B45309",
-        "warning.foreground": "#FFFFFF",
-        "warning.hover.background": "#F59E0B",
-        "overlay": "#0000004D",
-        "window.border": "#E4E4E7",
-        "base.red": "#DC2626",
+        "table.active.background": "#C6FF4D33",
+        "table.active.border": "#65A30D",
+        "table.even.background": "#F9F9F9",
+        "table.head.background": "#F9F9F9",
+        "table.head.foreground": "#838383",
+        "table.hover.background": "#F0F0F0",
+        "table.row.border": "#E8E8E8B3",
+        "tiles.background": "#F9F9F9",
+        "title_bar.background": "#F9F9F9",
+        "title_bar.border": "#E8E8E8",
+        "warning.background": "yellow-500",
+        "warning.foreground": "neutral-50",
+        "window.border": "#E8E8E8",
+        "base.red": "red-600",
+        "base.red.light": "red-400",
         "base.green": "#16A34A",
-        "base.yellow": "#CA8A04",
-        "base.blue": "#2563EB",
-        "base.magenta": "#9333EA",
-        "base.cyan": "#0891B2"
+        "base.green.light": "green-400",
+        "base.blue": "blue-600",
+        "base.blue.light": "blue-400",
+        "base.yellow": "yellow-600",
+        "base.yellow.light": "yellow-400",
+        "base.magenta": "purple-600",
+        "base.magenta.light": "purple-400",
+        "base.cyan": "cyan-600",
+        "base.cyan.light": "cyan-400"
       },
       "highlight": {
-        "editor.background": "#FFFFFF",
-        "editor.foreground": "#383A42",
-        "editor.active_line.background": "#F2F3F4",
-        "editor.line_number": "#A0A1A7",
-        "editor.active_line_number": "#383A42",
-        "editor.invisible": "#A0A1A766",
-        "conflict": "#DC2626",
-        "created": "#16A34A",
-        "deleted": "#DC2626",
-        "error": "#DC2626",
-        "error.background": "#FEF2F2",
-        "error.border": "#F87171",
-        "hidden": "#A0A1A7",
-        "hint": "#A626A4",
-        "hint.background": "#FAF5FF",
-        "hint.border": "#C4B5FD",
-        "ignored": "#A0A1A7",
-        "info": "#4078F2",
-        "info.background": "#EFF6FF",
-        "info.border": "#93C5FD",
-        "modified": "#C18401",
-        "modified.background": "#FFFBEB",
-        "predictive": "#A0A1A7",
-        "renamed": "#A626A4",
-        "success": "#16A34A",
-        "success.background": "#F0FDF4",
-        "unreachable": "#A0A1A7",
-        "warning": "#C18401",
-        "warning.background": "#FFFBEB",
-        "warning.border": "#FCD34D",
+        "editor.foreground": "#000000",
+        "editor.background": "#ffffff",
+        "editor.active_line.background": "#F5F5F5",
+        "editor.line_number": "#929292",
+        "editor.active_line_number": "#000000",
+        "editor.invisible": "#73737366",
+        "conflict": "#C5060B",
+        "created": "#1642FF",
+        "hidden": "#6D6D6D",
+        "hint": "#9e5dff",
+        "modified": "#9e7008",
+        "predictive": "#A4ABB6",
+        "warning": "#C99401",
         "syntax": {
           "attribute": {
-            "color": "#986801"
+            "color": "#957931"
           },
           "boolean": {
-            "color": "#986801"
+            "color": "#C5060B"
           },
           "comment": {
-            "color": "#A0A1A7",
-            "font_style": "italic"
+            "color": "#007fff"
           },
           "comment.doc": {
-            "color": "#A0A1A7",
-            "font_style": "italic"
+            "color": "#007fff"
           },
           "constant": {
-            "color": "#986801"
+            "color": "#C5060B"
           },
           "constructor": {
-            "color": "#4078F2"
+            "color": "#0433ff"
           },
           "embedded": {
-            "color": "#C18401"
+            "color": "#333333"
+          },
+          "emphasis": {
+            "font_style": "italic"
+          },
+          "emphasis.strong": {
+            "font_weight": 700
           },
           "function": {
-            "color": "#4078F2"
+            "color": "#0000A2"
           },
           "keyword": {
-            "color": "#A626A4"
-          },
-          "label": {
-            "color": "#4078F2"
+            "color": "#0433ff"
           },
           "link_text": {
-            "color": "#4078F2",
-            "font_style": "underline"
+            "color": "#0000A2",
+            "font_style": "normal"
           },
           "link_uri": {
-            "color": "#4078F2",
+            "color": "#6A7293",
             "font_style": "italic"
           },
           "number": {
-            "color": "#986801"
-          },
-          "operator": {
-            "color": "#383A42"
-          },
-          "preproc": {
-            "color": "#C18401"
-          },
-          "property": {
-            "color": "#E45649"
-          },
-          "punctuation": {
-            "color": "#383A42"
-          },
-          "punctuation.bracket": {
-            "color": "#383A42"
-          },
-          "punctuation.delimiter": {
-            "color": "#383A42"
-          },
-          "punctuation.list_marker": {
-            "color": "#986801"
-          },
-          "punctuation.special": {
-            "color": "#A626A4"
+            "color": "#0433ff"
           },
           "string": {
-            "color": "#50A14F"
+            "color": "#036A07"
           },
           "string.escape": {
-            "color": "#A626A4"
+            "color": "#036A07"
           },
           "string.regex": {
-            "color": "#50A14F"
+            "color": "#036A07"
           },
           "string.special": {
-            "color": "#50A14F"
+            "color": "#d21f07"
           },
           "string.special.symbol": {
-            "color": "#986801"
+            "color": "#d21f07"
           },
           "tag": {
-            "color": "#E45649"
-          },
-          "tag.doctype": {
-            "color": "#A0A1A7"
-          },
-          "text.code.span": {
-            "color": "#383A42"
+            "color": "#0433ff"
           },
           "text.literal": {
-            "color": "#50A14F"
+            "color": "#6F42C1"
+          },
+          "text.code.span": {
+            "color": "#6F42C1"
           },
           "title": {
-            "color": "#E45649",
-            "font_weight": 700
+            "color": "#0433FF"
           },
           "type": {
-            "color": "#0184BC"
+            "color": "#6f42c1"
+          },
+          "property": {
+            "color": "#333333"
           },
           "variable": {
-            "color": "#383A42"
+            "color": "#333333"
           },
           "variable.special": {
-            "color": "#E45649"
-          },
-          "variant": {
-            "color": "#0184BC"
+            "color": "#C5060B"
           }
         }
       }
     },
     {
+      "is_default": true,
       "name": "Signed Dark",
       "mode": "dark",
       "colors": {
-        "accent.background": "#18181B",
-        "accent.foreground": "#FAFAFA",
+        "accent.background": "#222222",
+        "accent.foreground": "#EEEEEE",
         "accordion.background": "#0A0A0A",
         "background": "#0A0A0A",
         "border": "#27272A",
-        "button.background": "#18181B",
-        "button.active.background": "#3F3F46",
-        "button.foreground": "#FAFAFA",
-        "button.hover.background": "#27272A",
-        "button.danger.background": "#EF4444",
-        "button.danger.active.background": "#DC2626",
-        "button.danger.foreground": "#FFFFFF",
-        "button.danger.hover.background": "#F87171",
-        "button.info.background": "#0EA5E9",
-        "button.info.active.background": "#0284C7",
-        "button.info.foreground": "#FFFFFF",
-        "button.info.hover.background": "#38BDF8",
-        "button.primary.background": "#C6FF4D",
-        "button.primary.active.background": "#65A30D",
-        "button.primary.foreground": "#0B0F0C",
-        "button.primary.hover.background": "#B2EC3C",
-        "button.secondary.background": "#18181B",
-        "button.secondary.active.background": "#3F3F46",
-        "button.secondary.foreground": "#FAFAFA",
-        "button.secondary.hover.background": "#27272A",
-        "button.success.background": "#2FBF71",
-        "button.success.active.background": "#24A35D",
-        "button.success.foreground": "#0B0F0C",
-        "button.success.hover.background": "#2AB568",
-        "button.warning.background": "#F59E0B",
-        "button.warning.active.background": "#D97706",
-        "button.warning.foreground": "#18181B",
-        "button.warning.hover.background": "#FBBF24",
-        "group_box.background": "#18181B",
-        "group_box.foreground": "#FAFAFA",
-        "group_box.title.foreground": "#FAFAFA",
-        "caret": "#FAFAFA",
-        "chart.1": "#C6FF4D",
-        "chart.2": "#A6E22E",
-        "chart.3": "#2FBF71",
-        "chart.4": "#7A8B5F",
-        "chart.5": "#A1A1AA",
-        "chart_bullish": "#2FBF71",
-        "chart_bearish": "#EF4444",
-        "danger.background": "#EF4444",
-        "danger.active.background": "#DC2626",
-        "danger.foreground": "#FFFFFF",
-        "danger.hover.background": "#F87171",
-        "description_list.label.background": "#18181B",
-        "description_list.label.foreground": "#A1A1AA",
+        "caret": "#EEEEEE",
+        "chart.1": "#93C5FD",
+        "chart.2": "#3B82F6",
+        "chart.3": "#2563EB",
+        "chart.4": "#1D4ED8",
+        "chart.5": "#1E40AF",
+        "chart_bullish": "green-600",
+        "chart_bearish": "red-600",
+        "danger.background": "red-400",
+        "danger.foreground": "red-600",
+        "description_list.label.background": "#191919",
+        "description_list.label.foreground": "#EEEEEE",
         "drag.border": "#C6FF4D",
-        "drop_target.background": "#C6FF4D33",
+        "drop_target.background": "#C6FF4D2E",
         "foreground": "#FAFAFA",
-        "info.background": "#0EA5E9",
-        "info.active.background": "#0284C7",
-        "info.foreground": "#FFFFFF",
-        "info.hover.background": "#38BDF8",
-        "input.border": "#3F3F46",
-        "link": "#C6FF4D",
-        "link.active": "#A6E22E",
-        "link.hover": "#B2EC3C",
+        "group_box.background": "#191919",
+        "group_box.foreground": "#EEEEEE",
+        "info.background": "cyan-400",
+        "info.foreground": "cyan-600",
+        "input.border": "#2F2F2F",
+        "link": "#A3E635",
+        "link.active": "#A3E635",
+        "link.hover": "#C6FF4D",
         "list.background": "#0A0A0A",
-        "list.active.background": "#C6FF4D40",
-        "list.active.border": "#C6FF4D80",
-        "list.even.background": "#18181B",
-        "list.head.background": "#18181B",
-        "list.hover.background": "#27272A",
-        "muted.background": "#18181B",
-        "muted.foreground": "#A1A1AA",
-        "popover.background": "#18181B",
+        "list.active.background": "#C6FF4D33",
+        "list.active.border": "#C6FF4D",
+        "list.even.background": "#191919",
+        "list.head.background": "#191919",
+        "list.hover.background": "#222222",
+        "muted.background": "#191919",
+        "muted.foreground": "#B4B4B4",
+        "overlay": "#00000033",
+        "popover.background": "#0A0A0A",
         "popover.foreground": "#FAFAFA",
         "primary.background": "#C6FF4D",
         "primary.active.background": "#65A30D",
-        "primary.foreground": "#0B0F0C",
-        "primary.hover.background": "#B2EC3C",
-        "progress.bar.background": "#C6FF4D",
-        "ring": "#C6FF4D",
-        "scrollbar.background": "#0A0A0A00",
-        "scrollbar.thumb.background": "#3F3F46",
-        "scrollbar.thumb.hover.background": "#52525B",
-        "secondary.background": "#18181B",
-        "secondary.active.background": "#3F3F46",
-        "secondary.foreground": "#FAFAFA",
-        "secondary.hover.background": "#27272A",
-        "selection.background": "#C6FF4D59",
-        "sidebar.background": "#0A0A0A",
-        "sidebar.accent.background": "#C6FF4D40",
-        "sidebar.accent.foreground": "#C6FF4D",
-        "sidebar.border": "#27272A",
-        "sidebar.foreground": "#FAFAFA",
-        "sidebar.primary.background": "#18181B",
-        "sidebar.primary.foreground": "#FAFAFA",
-        "skeleton.background": "#27272A",
-        "slider.background": "#27272A",
-        "slider.thumb.background": "#C6FF4D",
+        "primary.active.foreground": "#F7FEE7",
+        "primary.foreground": "#1A2E05",
+        "primary.hover.background": "#D6FF7A",
+        "progress.bar.background": "#FAFAFA",
+        "ring": "#606060",
+        "scrollbar.background": "#19191900",
+        "scrollbar.thumb.background": "#606060E6",
+        "scrollbar.thumb.hover.background": "#606060",
+        "secondary.background": "#222222",
+        "secondary.active.background": "#313131",
+        "secondary.foreground": "#EEEEEE",
+        "secondary.hover.background": "#2A2A2A",
+        "selection.background": "#1D4ED8",
+        "sidebar.background": "#111111",
+        "sidebar.accent.background": "#222222",
+        "sidebar.accent.foreground": "#EEEEEE",
+        "sidebar.border": "#2A2A2A",
+        "sidebar.foreground": "#EEEEEE",
+        "sidebar.primary.background": "#C6FF4D",
+        "sidebar.primary.foreground": "#1A2E05",
+        "skeleton.background": "#222222",
+        "slider.background": "#FAFAFA",
+        "slider.thumb.background": "#0A0A0A",
+        "status_bar.background": "#191919",
+        "status_bar.border": "#2A2A2A",
         "success.background": "#2FBF71",
-        "success.active.background": "#24A35D",
-        "success.foreground": "#0B0F0C",
-        "success.hover.background": "#2AB568",
-        "switch.background": "#3F3F46",
-        "switch.thumb.background": "#FAFAFA",
-        "tab.background": "#18181B",
-        "tab.active.background": "#19200A",
-        "tab.active.foreground": "#C6FF4D",
-        "tab.foreground": "#A1A1AA",
-        "tab_bar.background": "#18181B",
-        "tab_bar.segmented.background": "#27272A",
+        "success.foreground": "#052E16",
+        "switch.background": "#484848",
+        "switch.thumb.background": "#0A0A0A",
+        "tab.background": "#2E2E2E",
+        "tab.active.background": "#2A2A2A",
+        "tab.active.foreground": "#FAFAFA",
+        "tab.foreground": "#B4B4B4",
+        "tab_bar.background": "#191919",
+        "tab_bar.segmented.background": "#191919",
         "table.background": "#0A0A0A",
-        "table.active.background": "#C6FF4D40",
-        "table.active.border": "#C6FF4D80",
-        "table.even.background": "#18181B",
-        "table.head.background": "#18181B",
-        "table.head.foreground": "#A1A1AA",
-        "table.foot.background": "#18181B",
-        "table.foot.foreground": "#A1A1AA",
-        "table.hover.background": "#27272A",
-        "table.row.border": "#27272A",
-        "title_bar.background": "#18181B",
-        "title_bar.border": "#27272A",
-        "status_bar.background": "#18181B",
-        "status_bar.border": "#27272A",
-        "tiles.background": "#0A0A0A",
-        "warning.background": "#F59E0B",
-        "warning.active.background": "#D97706",
-        "warning.foreground": "#18181B",
-        "warning.hover.background": "#FBBF24",
-        "overlay": "#00000080",
-        "window.border": "#27272A",
-        "base.red": "#EF4444",
+        "table.active.background": "#C6FF4D33",
+        "table.active.border": "#C6FF4D",
+        "table.even.background": "#191919",
+        "table.head.background": "#191919",
+        "table.head.foreground": "#7B7B7B",
+        "table.hover.background": "#222222",
+        "table.row.border": "#2A2A2AB3",
+        "tiles.background": "#191919",
+        "title_bar.background": "#191919",
+        "title_bar.border": "#2A2A2A",
+        "warning.background": "yellow-400",
+        "warning.foreground": "yellow-600",
+        "window.border": "#2A2A2A",
+        "base.red": "red-400",
+        "base.red.light": "red-300",
         "base.green": "#22C55E",
-        "base.yellow": "#EAB308",
-        "base.blue": "#3B82F6",
-        "base.magenta": "#A855F7",
-        "base.cyan": "#06B6D4"
+        "base.green.light": "green-300",
+        "base.blue": "blue-400",
+        "base.blue.light": "blue-300",
+        "base.yellow": "yellow-400",
+        "base.yellow.light": "yellow-300",
+        "base.magenta": "purple-400",
+        "base.magenta.light": "purple-300",
+        "base.cyan": "cyan-400",
+        "base.cyan.light": "cyan-300"
       },
       "highlight": {
-        "editor.background": "#0A0A0A",
-        "editor.foreground": "#ABB2BF",
-        "editor.active_line.background": "#18181B",
-        "editor.line_number": "#71717A",
-        "editor.active_line_number": "#FAFAFA",
-        "editor.invisible": "#71717A66",
-        "conflict": "#E06C75",
-        "created": "#98C379",
-        "deleted": "#E06C75",
-        "error": "#E06C75",
-        "error.background": "#3A1D1D",
-        "error.border": "#E06C75",
-        "hidden": "#5C6370",
-        "hint": "#C678DD",
-        "hint.background": "#2E2740",
-        "hint.border": "#C678DD",
-        "ignored": "#5C6370",
-        "info": "#61AFEF",
-        "info.background": "#1D2E3A",
-        "info.border": "#61AFEF",
-        "modified": "#E5C07B",
-        "modified.background": "#3A320E",
-        "predictive": "#5C6370",
-        "renamed": "#C678DD",
-        "success": "#98C379",
-        "success.background": "#1D3A2E",
-        "unreachable": "#5C6370",
-        "warning": "#E5C07B",
-        "warning.background": "#3A320E",
-        "warning.border": "#E5C07B",
+        "editor.foreground": "#CACCCA",
+        "editor.background": "#0a0a0a",
+        "editor.active_line.background": "#171717",
+        "editor.line_number": "#8F8F8F",
+        "editor.active_line_number": "#DDDDDD",
+        "editor.invisible": "#73737366",
+        "conflict": "#D2602D",
+        "created": "#3f72e2",
+        "created.background": "#0C4619",
+        "deleted.background": "#46190C",
+        "error.background": "#46190C",
+        "error.border": "#E44A4F",
+        "hidden": "#9E9E9E",
+        "hint": "#b283f8",
+        "hint.background": "#250c4b",
+        "hint.border": "#3f0891",
+        "info.background": "#0059D1",
+        "info.border": "#0059D1",
+        "modified": "#B0A878",
+        "modified.background": "#3A310E",
+        "predictive": "#5D5945",
+        "success.background": "#0C4619",
+        "warning.background": "#3A310E",
+        "warning.border": "#7B6508",
         "syntax": {
           "attribute": {
-            "color": "#D19A66"
+            "color": "#7FAEF9"
           },
           "boolean": {
-            "color": "#D19A66"
+            "color": "#CC9E00"
           },
           "comment": {
-            "color": "#5C6370",
-            "font_style": "italic"
+            "color": "#9D9D9D"
           },
           "comment.doc": {
-            "color": "#5C6370",
-            "font_style": "italic"
+            "color": "#9D9D9D"
           },
           "constant": {
-            "color": "#D19A66"
+            "color": "#CC9E00"
           },
           "constructor": {
-            "color": "#E5C07B"
+            "color": "#CBA6F7"
           },
           "embedded": {
-            "color": "#98C379"
+            "color": "#CACCCA"
+          },
+          "emphasis": {
+            "font_style": "italic"
+          },
+          "emphasis.strong": {
+            "font_weight": 700
           },
           "function": {
-            "color": "#61AFEF"
+            "color": "#B3C5F3"
           },
           "keyword": {
-            "color": "#C678DD"
-          },
-          "label": {
-            "color": "#61AFEF"
+            "color": "#87B1F6"
           },
           "link_text": {
-            "color": "#61AFEF",
-            "font_style": "underline"
+            "color": "#419CFF",
+            "font_style": "normal"
           },
           "link_uri": {
-            "color": "#61AFEF",
+            "color": "#7faef9",
             "font_style": "italic"
           },
           "number": {
-            "color": "#D19A66"
-          },
-          "operator": {
-            "color": "#56B6C2"
-          },
-          "preproc": {
-            "color": "#E5C07B"
-          },
-          "property": {
-            "color": "#E06C75"
-          },
-          "punctuation": {
-            "color": "#ABB2BF"
-          },
-          "punctuation.bracket": {
-            "color": "#ABB2BF"
-          },
-          "punctuation.delimiter": {
-            "color": "#ABB2BF"
-          },
-          "punctuation.list_marker": {
-            "color": "#98C379"
-          },
-          "punctuation.special": {
-            "color": "#ABB2BF"
+            "color": "#CC9E00"
           },
           "string": {
-            "color": "#98C379"
+            "color": "#A3E09F"
           },
           "string.escape": {
-            "color": "#56B6C2"
+            "color": "#68DC7C"
           },
           "string.regex": {
-            "color": "#E06C75"
+            "color": "#68DC7C"
           },
           "string.special": {
-            "color": "#98C379"
+            "color": "#A3E09F"
           },
           "string.special.symbol": {
-            "color": "#D19A66"
+            "color": "#A3E09F"
           },
           "tag": {
-            "color": "#E06C75"
-          },
-          "tag.doctype": {
-            "color": "#5C6370"
-          },
-          "text.code.span": {
-            "color": "#ABB2BF"
+            "color": "#419CFF"
           },
           "text.literal": {
-            "color": "#98C379"
+            "color": "#A3E09F"
+          },
+          "text.code.span": {
+            "color": "#A3E09F"
           },
           "title": {
-            "color": "#61AFEF",
-            "font_weight": 700
+            "color": "#CC9E00",
+            "font_weight": 600
           },
           "type": {
-            "color": "#E5C07B"
+            "color": "#CBA6F7"
           },
-          "variable": {
-            "color": "#E06C75"
+          "property": {
+            "color": "#BCC4E0"
           },
           "variable.special": {
-            "color": "#D19A66"
-          },
-          "variant": {
-            "color": "#E5C07B"
+            "color": "#419CFF"
           }
         }
       }

crates/assets/src/lib.rs

@@ -1,5 +1,5 @@
 use anyhow::Context;
-use gpui::{App, AssetSource, Result, SharedString};
+use gpui::{AssetSource, Result, SharedString};
 use gpui_component::IconNamed;
 use rust_embed::RustEmbed;
 
@@ -7,6 +7,8 @@ use rust_embed::RustEmbed;
 #[folder = "assets"]
 #[include = "icons/**/*.svg"]
 #[include = "themes/**/*.json"]
+#[include = "backgrounds/**/*.jpg"]
+#[include = "backgrounds/**/*.png"]
 #[exclude = "*.DS_Store"]
 pub struct Assets;
 
@@ -31,50 +33,28 @@ impl AssetSource for Assets {
 }
 
 impl Assets {
-    /// Returns the embedded theme files as `(file name, JSON content)` pairs,
-    /// e.g. `("signed.json", ...)`. The content is a `ThemeSet` that can be
-    /// loaded into the [`ThemeRegistry`](gpui_component::ThemeRegistry).
     pub fn themes(&self) -> Vec<(String, String)> {
         Self::iter()
             .filter(|path| path.starts_with("themes/"))
             .filter_map(|path| {
                 let data = Self::get(path.as_ref())?;
                 let name = path.strip_prefix("themes/").unwrap_or(path.as_ref());
-                // Debug builds read files from disk (owned), release builds
-                // embed them in the binary (borrowed).
-                let content = match data.data {
-                    std::borrow::Cow::Borrowed(bytes) => {
-                        std::str::from_utf8(bytes).ok()?.to_owned()
-                    }
-                    std::borrow::Cow::Owned(bytes) => String::from_utf8(bytes).ok()?,
-                };
+                let content = std::str::from_utf8(data.data.as_ref()).ok()?.to_owned();
                 Some((name.to_owned(), content))
             })
             .collect()
     }
-
-    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)
-    }
 }
 
 pub enum CustomIconName {
+    CirclePlus,
     Unlock,
     Filter,
     GlobalOn,
     GlobalOff,
+    GitFile,
+    GitCommit,
+    GitIssueDone,
     GitIssueOpen,
     GitIssueClosed,
     GitIssueOngoing,
@@ -85,15 +65,26 @@ pub enum CustomIconName {
     GitClone,
     GitBranch,
     Tag,
+    Markdown,
+    Share,
+    Trending,
+    Recent,
+    Refresh,
+    Grid,
+    Init,
 }
 
 impl IconNamed for CustomIconName {
     fn path(self) -> gpui::SharedString {
         match self {
+            CustomIconName::CirclePlus => "icons/circle-plus.svg",
             CustomIconName::Unlock => "icons/unlock.svg",
             CustomIconName::Filter => "icons/filter.svg",
             CustomIconName::GlobalOn => "icons/global-on.svg",
             CustomIconName::GlobalOff => "icons/global-off.svg",
+            CustomIconName::GitCommit => "icons/git-commit.svg",
+            CustomIconName::GitFile => "icons/git-file.svg",
+            CustomIconName::GitIssueDone => "icons/git-issue-done.svg",
             CustomIconName::GitIssueOpen => "icons/git-issue-open.svg",
             CustomIconName::GitIssueClosed => "icons/git-issue-close.svg",
             CustomIconName::GitIssueOngoing => "icons/git-issue-ongoing.svg",
@@ -104,65 +95,14 @@ impl IconNamed for CustomIconName {
             CustomIconName::GitClone => "icons/git-clone.svg",
             CustomIconName::GitBranch => "icons/git-branch.svg",
             CustomIconName::Tag => "icons/tag.svg",
+            CustomIconName::Markdown => "icons/markdown.svg",
+            CustomIconName::Share => "icons/share.svg",
+            CustomIconName::Trending => "icons/trending.svg",
+            CustomIconName::Refresh => "icons/refresh.svg",
+            CustomIconName::Recent => "icons/recent.svg",
+            CustomIconName::Grid => "icons/grid.svg",
+            CustomIconName::Init => "icons/init.svg",
         }
         .into()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn signed_theme_set() -> gpui_component::ThemeSet {
-        let themes = Assets.themes();
-        assert_eq!(themes.len(), 1, "expected exactly one embedded theme file");
-        let (name, content) = &themes[0];
-        assert_eq!(name, "signed.json");
-        serde_json::from_str(content).expect("theme file must be a valid ThemeSet")
-    }
-
-    #[test]
-    fn signed_theme_set_parses() {
-        let set = signed_theme_set();
-        let names: Vec<&str> = set.themes.iter().map(|t| t.name.as_ref()).collect();
-        assert_eq!(names, vec!["Signed Light", "Signed Dark"]);
-    }
-
-    #[test]
-    fn signed_theme_palette_applies() {
-        let set = signed_theme_set();
-        let parse = |hex: &str| gpui_component::try_parse_color(hex).unwrap();
-        for config in &set.themes {
-            let mut theme = gpui_component::Theme::default();
-            theme.apply_config(&std::rc::Rc::new(config.clone()));
-
-            assert_eq!(theme.mode, config.mode);
-            // The resolved colors must match the brand palette.
-            assert_eq!(theme.primary, parse("#C6FF4D")); // nostr-lime
-            assert_eq!(theme.success, parse("#2FBF71")); // merge
-            assert_eq!(theme.primary_active, parse("#65A30D")); // lime-600
-
-            if config.mode.is_dark() {
-                // Dark theme chrome is neutral, mirroring the light theme.
-                assert_eq!(theme.background, parse("#0A0A0A")); // neutral-950
-                assert_eq!(theme.border, parse("#27272A")); // neutral-800
-                assert_eq!(theme.green, parse("#22C55E")); // green-500
-            } else {
-                // Light theme chrome is neutral; lime is a brand accent only.
-                assert_eq!(theme.background, parse("#FFFFFF"));
-                assert_eq!(theme.foreground, parse("#18181B"));
-                assert_eq!(theme.border, parse("#E4E4E7"));
-                assert_eq!(theme.green, parse("#16A34A"));
-            }
-            // Active tab: a paler lime on light, a dim moss on dark — each
-            // paired with readable, contrasting text.
-            if config.mode.is_dark() {
-                assert_eq!(theme.tab_active, parse("#19200A")); // dim lime
-                assert_eq!(theme.tab_active_foreground, parse("#C6FF4D")); // nostr-lime
-            } else {
-                assert_eq!(theme.tab_active, parse("#EBFFC1")); // pale nostr-lime
-                assert_eq!(theme.tab_active_foreground, parse("#3F6212")); // deep-lime
-            }
-        }
-    }
-}

crates/dock/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dock"
-description = "Dock (DockArea / Dock / Panel) components vendored from gpui-component."
+description = "The Signed dock skin over gpui-component's upstream dock (gpui_base::dock engine + renderer traits)."
 version.workspace = true
 edition.workspace = true
 publish.workspace = true
@@ -9,12 +9,8 @@ publish.workspace = true
 gpui.workspace = true
 gpui-component.workspace = true
 gpui-base.workspace = true
-
-anyhow.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-itertools = "0.13.0"
-smallvec = "1"
+settings = { path = "../settings" }
+signed_ui = { path = "../signed_ui" }
 
 [dev-dependencies]
 gpui = { workspace = true, features = ["test-support"] }

crates/dock/src/dock.rs

@@ -1,429 +0,0 @@
-use std::ops::Deref;
-use std::sync::Arc;
-
-use gpui::prelude::FluentBuilder as _;
-use gpui::{
-    App, AppContext, Axis, Context, Element, Empty, Entity, IntoElement, MouseMoveEvent,
-    MouseUpEvent, ParentElement as _, Pixels, Point, Render, Style, StyleRefinement, Styled as _,
-    WeakEntity, Window, div, px,
-};
-use gpui_component::{Side, StyledExt};
-use serde::{Deserialize, Serialize};
-
-use super::{DockArea, DockEvent, DockItem, PanelView, TabPanel};
-use crate::resize_handle::{PANEL_MIN_SIZE, resize_handle};
-
-#[derive(Clone)]
-struct ResizePanel;
-
-impl Render for ResizePanel {
-    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        Empty
-    }
-}
-
-/// Where to place a panel.
-///
-/// The [`DockArea`] has a fixed left dock and a center area. `Left` targets
-/// the left dock; `Center` adds a tab to the center; `Right` and `Bottom`
-/// split the center so the new panel lands on the given side of the existing
-/// center content.
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
-pub enum DockPlacement {
-    #[serde(rename = "center")]
-    Center,
-    #[serde(rename = "left")]
-    Left,
-    #[serde(rename = "bottom")]
-    Bottom,
-    #[serde(rename = "right")]
-    Right,
-}
-
-impl DockPlacement {
-    /// The split axis used when the placement splits the center area.
-    pub(crate) fn axis(&self) -> Axis {
-        match self {
-            Self::Left | Self::Right => Axis::Horizontal,
-            Self::Bottom => Axis::Vertical,
-            Self::Center => unreachable!(),
-        }
-    }
-
-    pub fn is_left(&self) -> bool {
-        matches!(self, Self::Left)
-    }
-}
-
-/// The Dock is a fixed container that places at the left side of the window.
-///
-/// This is unlike Panel, it can't be move or add any other panel.
-pub struct Dock {
-    pub(super) placement: DockPlacement,
-    dock_area: WeakEntity<DockArea>,
-    pub(crate) panel: DockItem,
-    /// The width of the dock.
-    pub(super) size: Pixels,
-    pub(super) open: bool,
-    /// Whether the Dock is collapsible, default: true
-    pub(super) collapsible: bool,
-
-    // Runtime state
-    /// Whether the Dock is resizing
-    resizing: bool,
-}
-
-impl Dock {
-    pub(crate) fn new(
-        dock_area: WeakEntity<DockArea>,
-        placement: DockPlacement,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        let panel = cx.new(|cx| {
-            let mut tab = TabPanel::new(None, dock_area.clone(), window, cx);
-            tab.closable = false;
-            tab
-        });
-
-        let panel = DockItem::Tabs {
-            size: None,
-            items: Vec::new(),
-            active_ix: 0,
-            view: panel.clone(),
-        };
-
-        Self::subscribe_panel_events(dock_area.clone(), &panel, window, cx);
-
-        Self {
-            placement,
-            dock_area,
-            panel,
-            open: true,
-            collapsible: true,
-            size: px(200.0),
-            resizing: false,
-        }
-    }
-
-    pub fn left(
-        dock_area: WeakEntity<DockArea>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        Self::new(dock_area, DockPlacement::Left, window, cx)
-    }
-
-    /// Update the Dock to be collapsible or not.
-    ///
-    /// And if the Dock is not collapsible, it will be open.
-    pub fn set_collapsible(&mut self, collapsible: bool, _: &mut Window, cx: &mut Context<Self>) {
-        self.collapsible = collapsible;
-        if !collapsible {
-            self.open = true
-        }
-        cx.notify();
-    }
-
-    pub(super) fn from_state(
-        dock_area: WeakEntity<DockArea>,
-        placement: DockPlacement,
-        size: Pixels,
-        panel: DockItem,
-        open: bool,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        Self::subscribe_panel_events(dock_area.clone(), &panel, window, cx);
-
-        if !open {
-            match panel.clone() {
-                DockItem::Tabs { view, .. } => {
-                    view.update(cx, |panel, cx| {
-                        panel.set_collapsed(true, window, cx);
-                    });
-                }
-                DockItem::Split { items, .. } => {
-                    for item in items {
-                        item.set_collapsed(true, window, cx);
-                    }
-                }
-                _ => {}
-            }
-        }
-
-        Self {
-            placement,
-            dock_area,
-            panel,
-            open,
-            size,
-            collapsible: true,
-            resizing: false,
-        }
-    }
-
-    fn subscribe_panel_events(
-        dock_area: WeakEntity<DockArea>,
-        panel: &DockItem,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        match panel {
-            DockItem::Tabs { view, .. } => {
-                window.defer(cx, {
-                    let view = view.clone();
-                    move |window, cx| {
-                        _ = dock_area.update(cx, |this, cx| {
-                            this.subscribe_panel(&view, window, cx);
-                        });
-                    }
-                });
-            }
-            DockItem::Split { items, view, .. } => {
-                for item in items {
-                    Self::subscribe_panel_events(dock_area.clone(), item, window, cx);
-                }
-                window.defer(cx, {
-                    let view = view.clone();
-                    move |window, cx| {
-                        _ = dock_area.update(cx, |this, cx| {
-                            this.subscribe_panel(&view, window, cx);
-                        });
-                    }
-                });
-            }
-            DockItem::Panel { .. } => {
-                // Not supported
-            }
-        }
-    }
-
-    pub fn set_panel(&mut self, panel: DockItem, _: &mut Window, cx: &mut Context<Self>) {
-        self.panel = panel;
-        cx.notify();
-    }
-
-    pub fn panel(&self) -> &DockItem {
-        &self.panel
-    }
-
-    pub fn is_open(&self) -> bool {
-        self.open
-    }
-
-    pub fn toggle_open(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        self.set_open(!self.open, window, cx);
-    }
-
-    /// Returns the size of the Dock, the size is means the width or height of
-    /// the Dock, if the placement is left or right, the size is width,
-    /// otherwise the size is height.
-    pub fn size(&self) -> Pixels {
-        self.size
-    }
-
-    /// Set the size of the Dock.
-    pub fn set_size(&mut self, size: Pixels, _: &mut Window, cx: &mut Context<Self>) {
-        self.size = size.max(PANEL_MIN_SIZE);
-        cx.notify();
-    }
-
-    /// Set the open state of the Dock.
-    pub fn set_open(&mut self, open: bool, window: &mut Window, cx: &mut Context<Self>) {
-        self.open = open;
-        let item = self.panel.clone();
-        cx.defer_in(window, move |_, window, cx| {
-            item.set_collapsed(!open, window, cx);
-        });
-        cx.notify();
-    }
-
-    /// Add item to the Dock.
-    pub fn add_panel(
-        &mut self,
-        panel: Arc<dyn PanelView>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.panel.add_panel(panel, &self.dock_area, window, cx);
-        cx.notify();
-    }
-
-    /// Remove item from the Dock.
-    pub fn remove_panel(
-        &mut self,
-        panel: Arc<dyn PanelView>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.panel.remove_panel(panel, window, cx);
-        cx.notify();
-    }
-
-    fn render_resize_handle(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let axis = self.placement.axis();
-        let view = cx.entity().clone();
-
-        resize_handle("resize-handle", axis)
-            .when(self.placement == DockPlacement::Left, |this| {
-                this.placement(Side::Left)
-            })
-            .on_drag(ResizePanel {}, move |info, _, _, cx| {
-                cx.stop_propagation();
-                view.update(cx, |view, _| {
-                    view.resizing = true;
-                });
-                cx.new(|_| info.deref().clone())
-            })
-    }
-
-    fn resize(
-        &mut self,
-        mouse_position: Point<Pixels>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        if !self.resizing {
-            return;
-        }
-
-        if !self.open {
-            self.set_open(true, window, cx);
-        }
-
-        let dock_area = self
-            .dock_area
-            .upgrade()
-            .expect("DockArea is missing")
-            .read(cx);
-        let area_bounds = dock_area.bounds;
-
-        let size = mouse_position.x - area_bounds.left();
-        let max_size = (area_bounds.size.width - PANEL_MIN_SIZE).max(PANEL_MIN_SIZE);
-        self.size = size.clamp(PANEL_MIN_SIZE, max_size);
-
-        cx.notify();
-    }
-
-    fn done_resizing(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
-        if !self.resizing {
-            return;
-        }
-        self.resizing = false;
-
-        // Dragging the dock's resize handle finished, bubble a layout change
-        // so subscribers can persist the new dock size.
-        _ = self.dock_area.update(cx, |_, cx| {
-            cx.emit(DockEvent::LayoutChanged);
-        });
-    }
-}
-
-impl Render for Dock {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl gpui::IntoElement {
-        if !self.open {
-            return div();
-        }
-
-        let cache_style = StyleRefinement::default().absolute().size_full();
-
-        div()
-            .relative()
-            .overflow_hidden()
-            .h_flex()
-            .h_full()
-            .w(self.size)
-            .map(|this| match &self.panel {
-                DockItem::Split { view, .. } => this.child(view.clone()),
-                DockItem::Tabs { view, .. } => this.child(view.clone()),
-                DockItem::Panel { view, .. } => this.child(view.clone().view().cached(cache_style)),
-            })
-            .child(self.render_resize_handle(window, cx))
-            .child(DockElement {
-                view: cx.entity().clone(),
-            })
-    }
-}
-
-struct DockElement {
-    view: Entity<Dock>,
-}
-
-impl IntoElement for DockElement {
-    type Element = Self;
-
-    fn into_element(self) -> Self::Element {
-        self
-    }
-}
-
-impl Element for DockElement {
-    type PrepaintState = ();
-    type RequestLayoutState = ();
-
-    fn id(&self) -> Option<gpui::ElementId> {
-        None
-    }
-
-    fn source_location(&self) -> Option<&'static std::panic::Location<'static>> {
-        None
-    }
-
-    fn request_layout(
-        &mut self,
-        _: Option<&gpui::GlobalElementId>,
-        _: Option<&gpui::InspectorElementId>,
-        window: &mut gpui::Window,
-        cx: &mut App,
-    ) -> (gpui::LayoutId, Self::RequestLayoutState) {
-        (window.request_layout(Style::default(), None, cx), ())
-    }
-
-    fn prepaint(
-        &mut self,
-        _: Option<&gpui::GlobalElementId>,
-        _: Option<&gpui::InspectorElementId>,
-        _: gpui::Bounds<Pixels>,
-        _: &mut Self::RequestLayoutState,
-        _window: &mut gpui::Window,
-        _cx: &mut App,
-    ) -> Self::PrepaintState {
-    }
-
-    fn paint(
-        &mut self,
-        _: Option<&gpui::GlobalElementId>,
-        _: Option<&gpui::InspectorElementId>,
-        _: gpui::Bounds<Pixels>,
-        _: &mut Self::RequestLayoutState,
-        _: &mut Self::PrepaintState,
-        window: &mut gpui::Window,
-        cx: &mut App,
-    ) {
-        window.on_mouse_event({
-            let view = self.view.clone();
-            let resizing = view.read(cx).resizing;
-            move |e: &MouseMoveEvent, phase, window, cx| {
-                if !resizing {
-                    return;
-                }
-                if !phase.bubble() {
-                    return;
-                }
-
-                view.update(cx, |view, cx| view.resize(e.position, window, cx))
-            }
-        });
-
-        // When any mouse up, stop dragging
-        window.on_mouse_event({
-            let view = self.view.clone();
-            move |_: &MouseUpEvent, phase, window, cx| {
-                if phase.bubble() {
-                    view.update(cx, |view, cx| view.done_resizing(window, cx));
-                }
-            }
-        })
-    }
-}

crates/dock/src/dock_area.rs

@@ -0,0 +1,276 @@
+use std::cell::Cell;
+use std::ops::Deref as _;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use gpui::prelude::FluentBuilder as _;
+use gpui::{
+    AnyElement, App, AppContext as _, Axis, Context, Div, Element, Empty, InteractiveElement as _,
+    IntoElement, MouseMoveEvent, MouseUpEvent, ParentElement as _, Pixels, Render, Stateful, Style,
+    Styled as _, WeakEntity, Window, div, px,
+};
+use gpui_base::dock::{
+    DockArea, DockAreaRenderer, DockContext, DockEvent, DockPlacement, NodeId, PanelState,
+    PanelView, TabGroupRenderer,
+};
+use gpui_base::{HandleEdge, resize_handle};
+use gpui_component::ActiveTheme as _;
+
+use crate::invalid_panel::InvalidPanel;
+use crate::panel_handle;
+use crate::tab_panel::SignedTabGroupSkin;
+
+/// State the skin shares with its per-container renderers.
+pub(crate) struct SkinShared {
+    area: WeakEntity<DockArea>,
+    toggle_button_visible: Cell<bool>,
+    /// The dock whose resize handle is being dragged, if any. Only one can be.
+    resizing_dock: Cell<Option<DockPlacement>>,
+}
+
+impl SkinShared {
+    pub(crate) fn area(&self) -> &WeakEntity<DockArea> {
+        &self.area
+    }
+
+    pub(crate) fn is_toggle_button_visible(&self) -> bool {
+        self.toggle_button_visible.get()
+    }
+
+    pub(crate) fn resizing_dock(&self) -> &Cell<Option<DockPlacement>> {
+        &self.resizing_dock
+    }
+}
+
+/// The Signed appearance for a [`DockArea`].
+/// Install it in the constructor, the only place the area's weak handle is available.
+///
+/// ```ignore
+/// let dock = cx.new(|cx| {
+///     let skin = SignedDockSkin::new(cx);
+///     DockArea::new("dock", Some(1), window, cx).with_renderer(skin)
+/// });
+/// ```
+pub struct SignedDockSkin {
+    shared: Rc<SkinShared>,
+}
+
+impl SignedDockSkin {
+    pub fn new(cx: &mut Context<DockArea>) -> Rc<Self> {
+        Rc::new(Self {
+            shared: Rc::new(SkinShared {
+                area: cx.weak_entity(),
+                toggle_button_visible: Cell::new(true),
+                resizing_dock: Cell::new(None),
+            }),
+        })
+    }
+
+    pub(crate) fn shared(&self) -> &Rc<SkinShared> {
+        &self.shared
+    }
+}
+
+/// Payload a dock's resize handle drags.
+///
+/// It draws nothing, the handle element is the visible affordance.
+#[derive(Clone)]
+struct ResizePanel;
+
+impl Render for ResizePanel {
+    fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
+        Empty
+    }
+}
+
+impl DockAreaRenderer for SignedDockSkin {
+    fn frame(&self, _: &mut Window, _: &mut App) -> Stateful<Div> {
+        div()
+            .id("dock-area")
+            .relative()
+            .size_full()
+            .overflow_hidden()
+            .flex()
+            .flex_row()
+    }
+
+    fn center_frame(&self, _: &mut Window, _: &mut App) -> Stateful<Div> {
+        div()
+            .id("dock-area-center")
+            .flex()
+            .flex_1()
+            .flex_col()
+            .overflow_hidden()
+    }
+
+    fn split_frame(&self, node: NodeId, _: Axis, _: &mut Window, cx: &mut App) -> Stateful<Div> {
+        // `size_full` and `flex_1` stop the frame collapsing in an unsizing parent.
+        div()
+            .id(("dock-split-frame", node.as_u64()))
+            .size_full()
+            .flex_1()
+            .min_h(px(0.))
+            .overflow_hidden()
+            .bg(cx.theme().tokens.tab_bar)
+    }
+
+    fn render_dock(
+        &self,
+        dock: &DockContext,
+        content: AnyElement,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> AnyElement {
+        div()
+            .flex()
+            .size_full()
+            .relative()
+            .child(content)
+            .child(self.render_resize_handle(dock, window, cx))
+            .child(DockResizeTracker {
+                dock: dock.clone(),
+                shared: self.shared().clone(),
+            })
+            .into_any_element()
+    }
+
+    /// Placeholder for a panel this build cannot construct.
+    /// It dumps the state it was handed, so the layout survives a load and save.
+    fn build_placeholder(
+        &self,
+        state: &PanelState,
+        _: &mut Window,
+        cx: &mut App,
+    ) -> Option<Arc<dyn PanelView>> {
+        let state = state.clone();
+        Some(panel_handle(cx.new(|cx| {
+            InvalidPanel::new(state.panel_name.clone(), state, cx)
+        })))
+    }
+
+    fn tab_group_renderer(&self) -> Rc<dyn TabGroupRenderer> {
+        Rc::new(SignedTabGroupSkin::new(self.shared().clone()))
+    }
+}
+
+impl SignedDockSkin {
+    fn render_resize_handle(
+        &self,
+        dock: &DockContext,
+        _: &mut Window,
+        _: &mut App,
+    ) -> impl IntoElement {
+        let placement = dock.placement();
+        let shared = self.shared().clone();
+
+        resize_handle("resize-handle", placement.axis())
+            .when(placement.is_left(), |this| {
+                this.inside(HandleEdge::Trailing)
+            })
+            .when(placement.is_right() || placement.is_bottom(), |this| {
+                this.inside(HandleEdge::Leading)
+            })
+            .on_drag(ResizePanel, move |info, _, _, cx| {
+                cx.stop_propagation();
+                shared.resizing_dock().set(Some(placement));
+                cx.new(|_| info.deref().clone())
+            })
+    }
+}
+
+/// Turns the window's mouse stream into dock resizing.
+/// It draws nothing, the `paint` hook is the only window listener registration point.
+struct DockResizeTracker {
+    dock: DockContext,
+    shared: Rc<SkinShared>,
+}
+
+impl IntoElement for DockResizeTracker {
+    type Element = Self;
+
+    fn into_element(self) -> Self::Element {
+        self
+    }
+}
+
+impl Element for DockResizeTracker {
+    type PrepaintState = ();
+    type RequestLayoutState = ();
+
+    fn id(&self) -> Option<gpui::ElementId> {
+        None
+    }
+
+    fn source_location(&self) -> Option<&'static std::panic::Location<'static>> {
+        None
+    }
+
+    fn request_layout(
+        &mut self,
+        _: Option<&gpui::GlobalElementId>,
+        _: Option<&gpui::InspectorElementId>,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> (gpui::LayoutId, Self::RequestLayoutState) {
+        (window.request_layout(Style::default(), None, cx), ())
+    }
+
+    fn prepaint(
+        &mut self,
+        _: Option<&gpui::GlobalElementId>,
+        _: Option<&gpui::InspectorElementId>,
+        _: gpui::Bounds<Pixels>,
+        _: &mut Self::RequestLayoutState,
+        _: &mut Window,
+        _: &mut App,
+    ) -> Self::PrepaintState {
+    }
+
+    fn paint(
+        &mut self,
+        _: Option<&gpui::GlobalElementId>,
+        _: Option<&gpui::InspectorElementId>,
+        _: gpui::Bounds<Pixels>,
+        _: &mut Self::RequestLayoutState,
+        _: &mut Self::PrepaintState,
+        window: &mut Window,
+        _: &mut App,
+    ) {
+        let placement = self.dock.placement();
+
+        window.on_mouse_event({
+            let dock = self.dock.clone();
+            let shared = self.shared.clone();
+            move |event: &MouseMoveEvent, phase, window, cx| {
+                if !phase.bubble() || shared.resizing_dock().get() != Some(placement) {
+                    return;
+                }
+                // Dragging a closed dock's handle reopens it.
+                // Read the live state, the snapshot in `dock` would toggle it shut again.
+                let open = shared
+                    .area()
+                    .upgrade()
+                    .is_some_and(|area| area.read(cx).is_dock_open(placement));
+                if !open {
+                    dock.toggle(window, cx);
+                }
+                dock.resize_to(event.position, window, cx);
+            }
+        });
+
+        window.on_mouse_event({
+            let shared = self.shared.clone();
+            move |_: &MouseUpEvent, phase, _, cx| {
+                if !phase.bubble() || shared.resizing_dock().get() != Some(placement) {
+                    return;
+                }
+                shared.resizing_dock().set(None);
+                // The size lives on the dock, not the layout tree.
+                // Nothing else tells a subscriber to persist it.
+                _ = shared
+                    .area()
+                    .update(cx, |_, cx| cx.emit(DockEvent::LayoutChanged));
+            }
+        });
+    }
+}

crates/dock/src/fixtures/layout.json

@@ -1,205 +0,0 @@
-{
-  "center": {
-    "panel_name": "StackPanel",
-    "children": [
-      {
-        "panel_name": "TabPanel",
-        "children": [
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "ButtonStory"
-              }
-            }
-          },
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "InputStory"
-              }
-            }
-          },
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "TextStory"
-              }
-            }
-          },
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "SelectStory"
-              }
-            }
-          },
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "DialogStory"
-              }
-            }
-          },
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "SwitchStory"
-              }
-            }
-          },
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "ProgressStory"
-              }
-            }
-          },
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "DataTableStory"
-              }
-            }
-          },
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "ImageStory"
-              }
-            }
-          },
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "IconStory"
-              }
-            }
-          },
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "TooltipStory"
-              }
-            }
-          },
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "ProgressStory"
-              }
-            }
-          },
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "CalendarStory"
-              }
-            }
-          },
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "ResizableStory"
-              }
-            }
-          },
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "ScrollbarStory"
-              }
-            }
-          }
-        ],
-        "info": {
-          "tabs": {
-            "active_index": 0
-          }
-        }
-      },
-      {
-        "panel_name": "TabPanel",
-        "children": [
-          {
-            "panel_name": "StoryContainer",
-            "children": [],
-            "info": {
-              "panel": {
-                "story_klass": "PopupStory"
-              }
-            }
-          }
-        ],
-        "info": {
-          "tabs": {
-            "active_index": 0
-          }
-        }
-      }
-    ],
-    "info": {
-      "stack": {
-        "sizes": [
-          704.0,
-          263.0
-        ],
-        "axis": 1
-      }
-    }
-  },
-  "left_dock": {
-    "panel": {
-      "panel_name": "TabPanel",
-      "children": [
-        {
-          "panel_name": "StoryContainer",
-          "children": [],
-          "info": {
-            "panel": {
-              "story_klass": "ListStory"
-            }
-          }
-        }
-      ],
-      "info": {
-        "tabs": {
-          "active_index": 0
-        }
-      }
-    },
-    "placement": "left",
-    "size": 350.0,
-    "open": true,
-    "resizeable": true
-  }
-}

crates/dock/src/invalid_panel.rs

@@ -1,11 +1,14 @@
 use gpui::{
-    App, EventEmitter, FocusHandle, Focusable, ParentElement as _, Render, SharedString,
-    Styled as _, Window,
+    App, Context, EventEmitter, FocusHandle, Focusable, IntoElement, ParentElement as _, Render,
+    SharedString, Styled as _, Window, div,
 };
+use gpui_base::dock::{PanelEvent, PanelState};
 use gpui_component::ActiveTheme as _;
 
-use super::{Panel, PanelEvent, PanelState};
+use crate::Panel;
 
+/// Stands in for a panel this build cannot construct.
+/// It returns the state it was handed, so the layout survives a load and save.
 pub(crate) struct InvalidPanel {
     name: SharedString,
     focus_handle: FocusHandle,
@@ -13,36 +16,42 @@ pub(crate) struct InvalidPanel {
 }
 
 impl InvalidPanel {
-    pub(crate) fn new(name: &str, state: PanelState, _: &mut Window, cx: &mut App) -> Self {
+    pub(crate) fn new(
+        name: impl Into<SharedString>,
+        state: PanelState,
+        cx: &mut Context<Self>,
+    ) -> Self {
         Self {
             focus_handle: cx.focus_handle(),
-            name: SharedString::from(name.to_owned()),
+            name: name.into(),
             old_state: state,
         }
     }
 }
-impl Panel for InvalidPanel {
+
+impl gpui_base::dock::Panel for InvalidPanel {
     fn panel_name(&self) -> &'static str {
         "InvalidPanel"
     }
 
-    fn dump(&self, _cx: &App) -> super::PanelState {
+    fn dump(&self, _: &App) -> PanelState {
         self.old_state.clone()
     }
 }
+
+impl Panel for InvalidPanel {}
+
 impl EventEmitter<PanelEvent> for InvalidPanel {}
+
 impl Focusable for InvalidPanel {
     fn focus_handle(&self, _: &App) -> FocusHandle {
         self.focus_handle.clone()
     }
 }
+
 impl Render for InvalidPanel {
-    fn render(
-        &mut self,
-        _: &mut gpui::Window,
-        cx: &mut gpui::Context<Self>,
-    ) -> impl gpui::IntoElement {
-        gpui::div()
+    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        div()
             .size_full()
             .my_6()
             .flex()

crates/dock/src/panel.rs

@@ -1,361 +0,0 @@
-use std::collections::HashMap;
-use std::sync::Arc;
-
-use gpui::{
-    AnyElement, AnyView, App, AppContext as _, Context, Entity, EntityId, EventEmitter,
-    FocusHandle, Focusable, Global, IntoElement, Render, SharedString, WeakEntity, Window,
-};
-use gpui_component::button::Button;
-use gpui_component::menu::PopupMenu;
-
-use super::{DockArea, PanelInfo, PanelState, TabPanel};
-use crate::invalid_panel::InvalidPanel;
-use crate::t;
-
-pub enum PanelEvent {
-    ZoomIn,
-    ZoomOut,
-    LayoutChanged,
-}
-
-#[derive(Clone, Copy, Default)]
-pub enum PanelControl {
-    Both,
-    #[default]
-    Menu,
-    Toolbar,
-}
-
-impl PanelControl {
-    #[inline]
-    pub fn toolbar_visible(&self) -> bool {
-        matches!(self, PanelControl::Both | PanelControl::Toolbar)
-    }
-
-    #[inline]
-    pub fn menu_visible(&self) -> bool {
-        matches!(self, PanelControl::Both | PanelControl::Menu)
-    }
-}
-
-/// The Panel trait used to define the panel.
-#[allow(unused_variables)]
-pub trait Panel: EventEmitter<PanelEvent> + Render + Focusable {
-    /// The name of the panel used to serialize, deserialize and identify the panel.
-    ///
-    /// This is used to identify the panel when deserializing the panel.
-    /// Once you have defined a panel name, this must not be changed.
-    fn panel_name(&self) -> &'static str;
-
-    /// The name of the tab of the panel, default is `None`.
-    ///
-    /// Used to display in the already collapsed tab panel.
-    fn tab_name(&self, cx: &App) -> Option<SharedString> {
-        None
-    }
-
-    /// The title of the panel
-    fn title(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        t("Dock.Unnamed")
-    }
-
-    /// The suffix of the panel title, default is `None`.
-    ///
-    /// This is used to add a suffix element to the panel title.
-    fn title_suffix(
-        &mut self,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Option<impl IntoElement> {
-        None::<gpui::Div>
-    }
-
-    /// Whether the panel can be closed, default is `true`.
-    ///
-    /// This method called in Panel render, we should make sure it is fast.
-    fn closable(&self, cx: &App) -> bool {
-        true
-    }
-
-    /// Return `PanelControl` if the panel is zoomable, default is `PanelControl::Menu`.
-    ///
-    /// This method called in Panel render, we should make sure it is fast.
-    fn zoomable(&self, cx: &App) -> Option<PanelControl> {
-        Some(PanelControl::Menu)
-    }
-
-    /// Return false to hide panel, true to show panel, default is `true`.
-    ///
-    /// This method called in Panel render, we should make sure it is fast.
-    fn visible(&self, cx: &App) -> bool {
-        true
-    }
-
-    /// Set active state of the panel.
-    ///
-    /// Called with the frame-end net state when this panel becomes (or stops
-    /// being) the displayed tab of its tab group: exactly one notification
-    /// per edge, delivered on the next tick after the change — never
-    /// same-value repeats nor false→true flips within one frame.
-    ///
-    /// A panel removed from its group is NOT told `false`; [`Panel::on_removed`]
-    /// is the deactivation signal. A hidden panel occupying `active_ix` still
-    /// receives `true` even though rendering falls back to the first visible
-    /// panel, and panels inside a bare `DockItem::Panel` (no tab group) are
-    /// outside this contract.
-    fn set_active(&mut self, active: bool, window: &mut Window, cx: &mut Context<Self>) {}
-
-    /// Set zoomed state of the panel.
-    ///
-    /// This method will be called when the panel is zoomed or unzoomed.
-    ///
-    /// Only current Panel will touch this method.
-    fn set_zoomed(&mut self, zoomed: bool, window: &mut Window, cx: &mut Context<Self>) {}
-
-    /// When this Panel is added to a TabPanel, this will be called.
-    fn on_added_to(
-        &mut self,
-        tab_panel: WeakEntity<TabPanel>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-    }
-
-    /// When this Panel is removed from a TabPanel, this will be called.
-    fn on_removed(&mut self, window: &mut Window, cx: &mut Context<Self>) {}
-
-    /// The addition dropdown menu of the panel, default is `None`.
-    fn dropdown_menu(
-        &mut self,
-        this: PopupMenu,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> PopupMenu {
-        this
-    }
-
-    /// The addition toolbar buttons of the panel used to show in the right of the title bar, default is `None`.
-    fn toolbar_buttons(
-        &mut self,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Option<Vec<Button>> {
-        None
-    }
-
-    /// Dump the panel, used to serialize the panel.
-    fn dump(&self, cx: &App) -> PanelState {
-        PanelState::new(self)
-    }
-
-    /// Whether the panel has inner padding when the panel is in the tabs layout, default is `true`.
-    fn inner_padding(&self, cx: &App) -> bool {
-        true
-    }
-}
-
-/// The PanelView trait used to define the panel view.
-#[allow(unused_variables)]
-pub trait PanelView: 'static + Send + Sync {
-    fn panel_name(&self, cx: &App) -> &'static str;
-    fn panel_id(&self, cx: &App) -> EntityId;
-    fn tab_name(&self, cx: &App) -> Option<SharedString>;
-    fn title(&self, window: &mut Window, cx: &mut App) -> AnyElement;
-    fn title_suffix(&self, window: &mut Window, cx: &mut App) -> Option<AnyElement>;
-    fn closable(&self, cx: &App) -> bool;
-    fn zoomable(&self, cx: &App) -> Option<PanelControl>;
-    fn visible(&self, cx: &App) -> bool;
-    fn set_active(&self, active: bool, window: &mut Window, cx: &mut App);
-    fn set_zoomed(&self, zoomed: bool, window: &mut Window, cx: &mut App);
-    fn on_added_to(&self, tab_panel: WeakEntity<TabPanel>, window: &mut Window, cx: &mut App);
-    fn on_removed(&self, window: &mut Window, cx: &mut App);
-    fn dropdown_menu(&self, menu: PopupMenu, window: &mut Window, cx: &mut App) -> PopupMenu;
-    fn toolbar_buttons(&self, window: &mut Window, cx: &mut App) -> Option<Vec<Button>>;
-    fn view(&self) -> AnyView;
-    fn focus_handle(&self, cx: &App) -> FocusHandle;
-    fn dump(&self, cx: &App) -> PanelState;
-    fn inner_padding(&self, cx: &App) -> bool;
-}
-
-impl<T: Panel> PanelView for Entity<T> {
-    fn panel_name(&self, cx: &App) -> &'static str {
-        self.read(cx).panel_name()
-    }
-
-    fn panel_id(&self, _: &App) -> EntityId {
-        self.entity_id()
-    }
-
-    fn tab_name(&self, cx: &App) -> Option<SharedString> {
-        self.read(cx).tab_name(cx)
-    }
-
-    fn title(&self, window: &mut Window, cx: &mut App) -> AnyElement {
-        self.update(cx, |this, cx| this.title(window, cx).into_any_element())
-    }
-
-    fn title_suffix(&self, window: &mut Window, cx: &mut App) -> Option<AnyElement> {
-        self.update(cx, |this, cx| {
-            this.title_suffix(window, cx)
-                .map(|el| el.into_any_element())
-        })
-    }
-
-    fn closable(&self, cx: &App) -> bool {
-        self.read(cx).closable(cx)
-    }
-
-    fn zoomable(&self, cx: &App) -> Option<PanelControl> {
-        self.read(cx).zoomable(cx)
-    }
-
-    fn visible(&self, cx: &App) -> bool {
-        self.read(cx).visible(cx)
-    }
-
-    fn set_active(&self, active: bool, window: &mut Window, cx: &mut App) {
-        self.update(cx, |this, cx| {
-            this.set_active(active, window, cx);
-        })
-    }
-
-    fn set_zoomed(&self, zoomed: bool, window: &mut Window, cx: &mut App) {
-        self.update(cx, |this, cx| {
-            this.set_zoomed(zoomed, window, cx);
-        })
-    }
-
-    fn on_added_to(&self, tab_panel: WeakEntity<TabPanel>, window: &mut Window, cx: &mut App) {
-        self.update(cx, |this, cx| this.on_added_to(tab_panel, window, cx));
-    }
-
-    fn on_removed(&self, window: &mut Window, cx: &mut App) {
-        self.update(cx, |this, cx| this.on_removed(window, cx));
-    }
-
-    fn dropdown_menu(&self, menu: PopupMenu, window: &mut Window, cx: &mut App) -> PopupMenu {
-        self.update(cx, |this, cx| this.dropdown_menu(menu, window, cx))
-    }
-
-    fn toolbar_buttons(&self, window: &mut Window, cx: &mut App) -> Option<Vec<Button>> {
-        self.update(cx, |this, cx| this.toolbar_buttons(window, cx))
-    }
-
-    fn view(&self) -> AnyView {
-        self.clone().into()
-    }
-
-    fn focus_handle(&self, cx: &App) -> FocusHandle {
-        self.read(cx).focus_handle(cx)
-    }
-
-    fn dump(&self, cx: &App) -> PanelState {
-        self.read(cx).dump(cx)
-    }
-
-    fn inner_padding(&self, cx: &App) -> bool {
-        self.read(cx).inner_padding(cx)
-    }
-}
-
-impl From<&dyn PanelView> for AnyView {
-    fn from(handle: &dyn PanelView) -> Self {
-        handle.view()
-    }
-}
-
-impl<T: Panel> From<&dyn PanelView> for Entity<T> {
-    fn from(value: &dyn PanelView) -> Self {
-        value.view().downcast::<T>().unwrap()
-    }
-}
-
-impl PartialEq for dyn PanelView {
-    fn eq(&self, other: &Self) -> bool {
-        self.view() == other.view()
-    }
-}
-
-/// The deserializer used by [`PanelRegistry`] to rebuild a panel from its
-/// persisted [`PanelState`].
-type PanelBuilder = dyn Fn(
-    WeakEntity<DockArea>,
-    &PanelState,
-    &PanelInfo,
-    &mut Window,
-    &mut App,
-) -> Box<dyn PanelView>;
-
-pub struct PanelRegistry {
-    pub(super) items: HashMap<String, Arc<PanelBuilder>>,
-}
-impl PanelRegistry {
-    /// Initialize the panel registry.
-    pub(crate) fn init(cx: &mut App) {
-        if cx.try_global::<PanelRegistry>().is_none() {
-            cx.set_global(PanelRegistry::new());
-        }
-    }
-
-    pub fn new() -> Self {
-        Self {
-            items: HashMap::new(),
-        }
-    }
-
-    pub fn global(cx: &App) -> &Self {
-        cx.global::<PanelRegistry>()
-    }
-
-    pub fn global_mut(cx: &mut App) -> &mut Self {
-        cx.global_mut::<PanelRegistry>()
-    }
-
-    /// Build a panel by name.
-    ///
-    /// If not registered, return InvalidPanel.
-    pub fn build_panel(
-        panel_name: &str,
-        dock_area: WeakEntity<DockArea>,
-        panel_state: &PanelState,
-        panel_info: &PanelInfo,
-        window: &mut Window,
-        cx: &mut App,
-    ) -> Box<dyn PanelView> {
-        if let Some(view) = Self::global(cx)
-            .items
-            .get(panel_name)
-            .cloned()
-            .map(|f| f(dock_area, panel_state, panel_info, window, cx))
-        {
-            view
-        } else {
-            // Show an invalid panel if the panel is not registered.
-            Box::new(cx.new(|cx| InvalidPanel::new(panel_name, panel_state.clone(), window, cx)))
-        }
-    }
-}
-impl Default for PanelRegistry {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl Global for PanelRegistry {}
-
-/// Register the Panel init by panel_name to global registry.
-pub fn register_panel<F>(cx: &mut App, panel_name: &str, deserialize: F)
-where
-    F: Fn(
-            WeakEntity<DockArea>,
-            &PanelState,
-            &PanelInfo,
-            &mut Window,
-            &mut App,
-        ) -> Box<dyn PanelView>
-        + 'static,
-{
-    PanelRegistry::init(cx);
-    PanelRegistry::global_mut(cx)
-        .items
-        .insert(panel_name.to_string(), Arc::new(deserialize));
-}

crates/dock/src/resize_handle.rs

@@ -1,232 +0,0 @@
-//! Vendored from `gpui-base`'s private `resizable::resize_handle` module
-//! (v0.5.2, rev 9e3a29dcbdebc318632bf68203f26c33e9f0e902). gpui-component
-//! keeps this and [`PANEL_MIN_SIZE`] crate-private, so the dock crate carries
-//! its own copy.
-
-use std::cell::Cell;
-use std::rc::Rc;
-
-use gpui::prelude::FluentBuilder as _;
-use gpui::{
-    AnyElement, App, Axis, Element, ElementId, Entity, GlobalElementId, InteractiveElement,
-    IntoElement, MouseDownEvent, MouseUpEvent, ParentElement as _, Pixels, Point, Render,
-    StatefulInteractiveElement, Styled as _, Window, div, px,
-};
-use gpui_component::{ActiveTheme as _, AxisExt as _, Side};
-
-pub(crate) const PANEL_MIN_SIZE: Pixels = px(100.);
-pub(crate) const HANDLE_PADDING: Pixels = px(4.);
-pub(crate) const HANDLE_SIZE: Pixels = px(1.);
-
-/// Create a resize handle for a resizable panel.
-#[doc(hidden)]
-pub fn resize_handle<T: 'static, E: 'static + Render>(
-    id: impl Into<ElementId>,
-    axis: Axis,
-) -> ResizeHandle<T, E> {
-    ResizeHandle::new(id, axis)
-}
-
-type DragHandler<E> = dyn Fn(&Point<Pixels>, &mut Window, &mut App) -> Entity<E>;
-
-#[doc(hidden)]
-pub struct ResizeHandle<T: 'static, E: 'static + Render> {
-    id: ElementId,
-    axis: Axis,
-    drag_value: Option<Rc<T>>,
-    placement: Option<Side>,
-    on_drag: Option<Rc<DragHandler<E>>>,
-}
-
-impl<T: 'static, E: 'static + Render> ResizeHandle<T, E> {
-    fn new(id: impl Into<ElementId>, axis: Axis) -> Self {
-        let id = id.into();
-        Self {
-            id: id.clone(),
-            on_drag: None,
-            drag_value: None,
-            placement: None,
-            axis,
-        }
-    }
-
-    pub fn on_drag(
-        mut self,
-        value: T,
-        f: impl Fn(Rc<T>, &Point<Pixels>, &mut Window, &mut App) -> Entity<E> + 'static,
-    ) -> Self {
-        let value = Rc::new(value);
-        self.drag_value = Some(value.clone());
-        self.on_drag = Some(Rc::new(move |p, window, cx| {
-            f(value.clone(), p, window, cx)
-        }));
-        self
-    }
-
-    pub fn placement(mut self, placement: Side) -> Self {
-        self.placement = Some(placement);
-        self
-    }
-}
-
-#[derive(Default, Debug, Clone)]
-struct ResizeHandleState {
-    active: Cell<bool>,
-}
-
-impl ResizeHandleState {
-    fn set_active(&self, active: bool) {
-        self.active.set(active);
-    }
-
-    fn is_active(&self) -> bool {
-        self.active.get()
-    }
-}
-
-impl<T: 'static, E: 'static + Render> IntoElement for ResizeHandle<T, E> {
-    type Element = ResizeHandle<T, E>;
-
-    fn into_element(self) -> Self::Element {
-        self
-    }
-}
-
-impl<T: 'static, E: 'static + Render> Element for ResizeHandle<T, E> {
-    type PrepaintState = ();
-    type RequestLayoutState = AnyElement;
-
-    fn id(&self) -> Option<ElementId> {
-        Some(self.id.clone())
-    }
-
-    fn source_location(&self) -> Option<&'static std::panic::Location<'static>> {
-        None
-    }
-
-    fn request_layout(
-        &mut self,
-        id: Option<&GlobalElementId>,
-        _: Option<&gpui::InspectorElementId>,
-        window: &mut Window,
-        cx: &mut App,
-    ) -> (gpui::LayoutId, Self::RequestLayoutState) {
-        let neg_offset = -HANDLE_PADDING;
-        let axis = self.axis;
-
-        window.with_element_state(id.unwrap(), |state: Option<ResizeHandleState>, window| {
-            let state = state.unwrap_or_default();
-
-            let bg_color = if state.is_active() {
-                cx.theme().drag_border
-            } else {
-                cx.theme().border
-            };
-
-            let mut el = div()
-                .id(self.id.clone())
-                .occlude()
-                .absolute()
-                .flex_shrink_0()
-                .group("handle")
-                .when_some(self.on_drag.clone(), |this, on_drag| {
-                    this.on_drag(
-                        self.drag_value.clone().unwrap(),
-                        move |_, position, window, cx| on_drag(&position, window, cx),
-                    )
-                })
-                .map(|this| match self.placement {
-                    Some(Side::Left) => {
-                        // Special for Left Dock
-                        //  FIXME: Improve this to let the scroll bar have px(HANDLE_PADDING)
-                        this.cursor_col_resize()
-                            .top_0()
-                            .right(px(1.))
-                            .h_full()
-                            .w(HANDLE_SIZE)
-                            .pl(HANDLE_PADDING)
-                    }
-                    _ => this
-                        .when(axis.is_horizontal(), |this| {
-                            this.cursor_col_resize()
-                                .top_0()
-                                .left(neg_offset)
-                                .h_full()
-                                .w(HANDLE_SIZE)
-                                .px(HANDLE_PADDING)
-                        })
-                        .when(axis.is_vertical(), |this| {
-                            this.cursor_row_resize()
-                                .top(neg_offset)
-                                .left_0()
-                                .w_full()
-                                .h(HANDLE_SIZE)
-                                .py(HANDLE_PADDING)
-                        }),
-                })
-                .child(
-                    div()
-                        .bg(bg_color)
-                        .group_hover("handle", |this| this.bg(bg_color))
-                        .when(axis.is_horizontal(), |this| this.h_full().w(HANDLE_SIZE))
-                        .when(axis.is_vertical(), |this| this.w_full().h(HANDLE_SIZE)),
-                )
-                .into_any_element();
-
-            let layout_id = el.request_layout(window, cx);
-
-            ((layout_id, el), state)
-        })
-    }
-
-    fn prepaint(
-        &mut self,
-        _: Option<&GlobalElementId>,
-        _: Option<&gpui::InspectorElementId>,
-        _: gpui::Bounds<Pixels>,
-        request_layout: &mut Self::RequestLayoutState,
-        window: &mut Window,
-        cx: &mut App,
-    ) -> Self::PrepaintState {
-        request_layout.prepaint(window, cx);
-    }
-
-    fn paint(
-        &mut self,
-        id: Option<&GlobalElementId>,
-        _: Option<&gpui::InspectorElementId>,
-        bounds: gpui::Bounds<Pixels>,
-        request_layout: &mut Self::RequestLayoutState,
-        _: &mut Self::PrepaintState,
-        window: &mut Window,
-        cx: &mut App,
-    ) {
-        request_layout.paint(window, cx);
-
-        window.with_element_state(id.unwrap(), |state: Option<ResizeHandleState>, window| {
-            let state = state.unwrap_or_default();
-
-            window.on_mouse_event({
-                let state = state.clone();
-                move |ev: &MouseDownEvent, phase, window, _| {
-                    if bounds.contains(&ev.position) && phase.bubble() {
-                        state.set_active(true);
-                        window.refresh();
-                    }
-                }
-            });
-
-            window.on_mouse_event({
-                let state = state.clone();
-                move |_: &MouseUpEvent, _, window, _| {
-                    if state.is_active() {
-                        state.set_active(false);
-                        window.refresh();
-                    }
-                }
-            });
-
-            ((), state)
-        });
-    }
-}

crates/dock/src/stack_panel.rs

@@ -1,397 +0,0 @@
-use std::sync::Arc;
-
-use gpui::{
-    App, AppContext as _, Axis, Context, DismissEvent, Entity, EventEmitter, FocusHandle,
-    Focusable, IntoElement, ParentElement, Pixels, Render, Styled, Subscription, WeakEntity,
-    Window,
-};
-use gpui_component::{
-    ActiveTheme, Placement, ResizablePanelEvent, ResizablePanelGroup, ResizableState, h_flex,
-    resizable_panel,
-};
-use smallvec::SmallVec;
-
-use super::{DockArea, Panel, PanelEvent, PanelState, PanelView, TabPanel};
-use crate::PanelInfo;
-use crate::resize_handle::PANEL_MIN_SIZE;
-
-pub struct StackPanel {
-    pub(super) parent: Option<WeakEntity<StackPanel>>,
-    pub(super) axis: Axis,
-    focus_handle: FocusHandle,
-    pub(crate) panels: SmallVec<[Arc<dyn PanelView>; 2]>,
-    state: Entity<ResizableState>,
-    _subscriptions: Vec<Subscription>,
-}
-
-impl Panel for StackPanel {
-    fn panel_name(&self) -> &'static str {
-        "StackPanel"
-    }
-
-    fn title(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        "StackPanel"
-    }
-
-    fn set_active(&mut self, active: bool, window: &mut Window, cx: &mut Context<Self>) {
-        for panel in &self.panels {
-            panel.set_active(active, window, cx);
-        }
-    }
-
-    fn dump(&self, cx: &App) -> PanelState {
-        let sizes = self.state.read(cx).sizes().clone();
-        let mut state = PanelState::new(self);
-        state.info = PanelInfo::stack(sizes, self.axis);
-        for panel in &self.panels {
-            state.add_child(panel.dump(cx));
-        }
-
-        state
-    }
-}
-
-impl StackPanel {
-    pub fn new(axis: Axis, _: &mut Window, cx: &mut Context<Self>) -> Self {
-        let state = cx.new(|_| ResizableState::default());
-
-        let _subscriptions = vec![
-            // Bubble up the resize event.
-            cx.subscribe(&state, |_, _, _: &ResizablePanelEvent, cx| {
-                cx.emit(PanelEvent::LayoutChanged)
-            }),
-        ];
-
-        Self {
-            axis,
-            parent: None,
-            focus_handle: cx.focus_handle(),
-            panels: SmallVec::new(),
-            state,
-            _subscriptions,
-        }
-    }
-
-    /// The first level of the stack panel is root, will not have a parent.
-    fn is_root(&self) -> bool {
-        self.parent.is_none()
-    }
-
-    /// Return true if self or parent only have last panel.
-    pub(super) fn is_last_panel(&self, cx: &App) -> bool {
-        if self.panels.len() > 1 {
-            return false;
-        }
-
-        if let Some(parent) = &self.parent
-            && let Some(parent) = parent.upgrade()
-        {
-            return parent.read(cx).is_last_panel(cx);
-        }
-
-        true
-    }
-
-    pub(super) fn panels_len(&self) -> usize {
-        self.panels.len()
-    }
-
-    /// Return the index of the panel.
-    pub(crate) fn index_of_panel(&self, panel: Arc<dyn PanelView>) -> Option<usize> {
-        self.panels.iter().position(|p| p == &panel)
-    }
-
-    fn assert_panel_is_valid(&self, panel: &Arc<dyn PanelView>) {
-        assert!(
-            panel.view().downcast::<TabPanel>().is_ok()
-                || panel.view().downcast::<StackPanel>().is_ok(),
-            "Panel must be a `TabPanel` or `StackPanel`"
-        );
-    }
-
-    /// Add a panel at the end of the stack.
-    ///
-    /// If `size` is `None`, the panel will be given the average size of all panels in the stack.
-    ///
-    /// The `panel` must be a [`TabPanel`] or [`StackPanel`].
-    pub fn add_panel(
-        &mut self,
-        panel: Arc<dyn PanelView>,
-        size: Option<Pixels>,
-        dock_area: WeakEntity<DockArea>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.insert_panel(panel, self.panels.len(), size, dock_area, window, cx);
-    }
-
-    /// Add a panel at the [`Placement`].
-    ///
-    /// The `panel` must be a [`TabPanel`] or [`StackPanel`].
-    pub fn add_panel_at(
-        &mut self,
-        panel: Arc<dyn PanelView>,
-        placement: Placement,
-        size: Option<Pixels>,
-        dock_area: WeakEntity<DockArea>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.insert_panel_at(
-            panel,
-            self.panels_len(),
-            placement,
-            size,
-            dock_area,
-            window,
-            cx,
-        );
-    }
-
-    /// Insert a panel at the index.
-    ///
-    /// The `panel` must be a [`TabPanel`] or [`StackPanel`].
-    #[allow(clippy::too_many_arguments)]
-    pub fn insert_panel_at(
-        &mut self,
-        panel: Arc<dyn PanelView>,
-        ix: usize,
-        placement: Placement,
-        size: Option<Pixels>,
-        dock_area: WeakEntity<DockArea>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        match placement {
-            Placement::Top | Placement::Left => {
-                self.insert_panel_before(panel, ix, size, dock_area, window, cx)
-            }
-            Placement::Right | Placement::Bottom => {
-                self.insert_panel_after(panel, ix, size, dock_area, window, cx)
-            }
-        }
-    }
-
-    /// Insert a panel at the index.
-    ///
-    /// The `panel` must be a [`TabPanel`] or [`StackPanel`].
-    pub fn insert_panel_before(
-        &mut self,
-        panel: Arc<dyn PanelView>,
-        ix: usize,
-        size: Option<Pixels>,
-        dock_area: WeakEntity<DockArea>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.insert_panel(panel, ix, size, dock_area, window, cx);
-    }
-
-    /// Insert a panel after the index.
-    ///
-    /// The `panel` must be a [`TabPanel`] or [`StackPanel`].
-    pub fn insert_panel_after(
-        &mut self,
-        panel: Arc<dyn PanelView>,
-        ix: usize,
-        size: Option<Pixels>,
-        dock_area: WeakEntity<DockArea>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.insert_panel(panel, ix + 1, size, dock_area, window, cx);
-    }
-
-    fn insert_panel(
-        &mut self,
-        panel: Arc<dyn PanelView>,
-        ix: usize,
-        size: Option<Pixels>,
-        dock_area: WeakEntity<DockArea>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.assert_panel_is_valid(&panel);
-
-        // If the panel is already in the stack, return.
-        if self.index_of_panel(panel.clone()).is_some() {
-            return;
-        }
-
-        let view = cx.entity().clone();
-        window.defer(cx, {
-            let panel = panel.clone();
-
-            move |window, cx| {
-                // If the panel is a TabPanel, set its parent to this.
-                if let Ok(tab_panel) = panel.view().downcast::<TabPanel>() {
-                    tab_panel.update(cx, |tab_panel, _| tab_panel.set_parent(view.downgrade()));
-                } else if let Ok(stack_panel) = panel.view().downcast::<Self>() {
-                    stack_panel.update(cx, |stack_panel, _| {
-                        stack_panel.parent = Some(view.downgrade())
-                    });
-                }
-
-                // Subscribe to the panel's layout change event.
-                _ = dock_area.update(cx, |this, cx| {
-                    if let Ok(tab_panel) = panel.view().downcast::<TabPanel>() {
-                        this.subscribe_panel(&tab_panel, window, cx);
-                    } else if let Ok(stack_panel) = panel.view().downcast::<Self>() {
-                        this.subscribe_panel(&stack_panel, window, cx);
-                    }
-                });
-            }
-        });
-
-        let ix = if ix > self.panels.len() {
-            self.panels.len()
-        } else {
-            ix
-        };
-
-        // Get avg size of all panels to insert new panel, if size is None.
-        let size = match size {
-            Some(size) => size,
-            None => {
-                let state = self.state.read(cx);
-                (state.container_size() / (state.sizes().len() + 1) as f32).max(PANEL_MIN_SIZE)
-            }
-        };
-
-        self.panels.insert(ix, panel.clone());
-        self.state.update(cx, |state, cx| {
-            state.insert_panel(Some(size), Some(ix), cx);
-        });
-        cx.emit(PanelEvent::LayoutChanged);
-        cx.notify();
-    }
-
-    /// Remove panel from the stack.
-    ///
-    /// If `ix` is not found, do nothing.
-    pub fn remove_panel(
-        &mut self,
-        panel: Arc<dyn PanelView>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let Some(ix) = self.index_of_panel(panel.clone()) else {
-            return;
-        };
-
-        self.panels.remove(ix);
-        self.state.update(cx, |state, cx| {
-            state.remove_panel(ix, cx);
-        });
-
-        cx.emit(PanelEvent::LayoutChanged);
-        self.remove_self_if_empty(window, cx);
-    }
-
-    /// Replace the old panel with the new panel at same index.
-    pub(super) fn replace_panel(
-        &mut self,
-        old_panel: Arc<dyn PanelView>,
-        new_panel: Entity<StackPanel>,
-        _: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        if let Some(ix) = self.index_of_panel(old_panel.clone()) {
-            self.panels[ix] = Arc::new(new_panel.clone());
-
-            self.state.update(cx, |state, cx| {
-                state.reset_panel(ix, cx);
-            });
-            cx.emit(PanelEvent::LayoutChanged);
-        }
-    }
-
-    /// If children is empty, remove self from parent view.
-    pub(crate) fn remove_self_if_empty(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        if self.is_root() {
-            return;
-        }
-
-        if !self.panels.is_empty() {
-            return;
-        }
-
-        let view = cx.entity().clone();
-        if let Some(parent) = self.parent.as_ref() {
-            _ = parent.update(cx, |parent, cx| {
-                parent.remove_panel(Arc::new(view.clone()), window, cx);
-            });
-        }
-
-        cx.emit(PanelEvent::LayoutChanged);
-        cx.notify();
-    }
-
-    /// Find the first top left in the stack.
-    pub(super) fn left_top_tab_panel(
-        &self,
-        check_parent: bool,
-        cx: &App,
-    ) -> Option<Entity<TabPanel>> {
-        if check_parent
-            && let Some(parent) = self.parent.as_ref().and_then(|parent| parent.upgrade())
-            && let Some(panel) = parent.read(cx).left_top_tab_panel(true, cx)
-        {
-            return Some(panel);
-        }
-
-        let first_panel = self.panels.first();
-        if let Some(view) = first_panel {
-            if let Ok(tab_panel) = view.view().downcast::<TabPanel>() {
-                Some(tab_panel)
-            } else if let Ok(stack_panel) = view.view().downcast::<StackPanel>() {
-                stack_panel.read(cx).left_top_tab_panel(false, cx)
-            } else {
-                None
-            }
-        } else {
-            None
-        }
-    }
-
-    /// Remove all panels from the stack.
-    pub(super) fn remove_all_panels(&mut self, _: &mut Window, cx: &mut Context<Self>) {
-        self.panels.clear();
-        self.state.update(cx, |state, cx| {
-            state.clear();
-            cx.notify();
-        });
-    }
-
-    /// Change the axis of the stack panel.
-    pub(super) fn set_axis(&mut self, axis: Axis, _: &mut Window, cx: &mut Context<Self>) {
-        self.axis = axis;
-        cx.notify();
-    }
-}
-
-impl Focusable for StackPanel {
-    fn focus_handle(&self, _cx: &App) -> FocusHandle {
-        self.focus_handle.clone()
-    }
-}
-impl EventEmitter<PanelEvent> for StackPanel {}
-impl EventEmitter<DismissEvent> for StackPanel {}
-impl Render for StackPanel {
-    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        h_flex()
-            .size_full()
-            .overflow_hidden()
-            .bg(cx.theme().tokens.tab_bar)
-            .child(
-                ResizablePanelGroup::new("stack-panel-group")
-                    .with_state(&self.state)
-                    .axis(self.axis)
-                    .children(self.panels.clone().into_iter().map(|panel| {
-                        resizable_panel()
-                            .child(panel.view())
-                            .visible(panel.visible(cx))
-                    })),
-            )
-    }
-}

crates/dock/src/state.rs

@@ -1,233 +0,0 @@
-use gpui::{App, AppContext, Axis, Entity, Pixels, WeakEntity, Window};
-use itertools::Itertools as _;
-use serde::{Deserialize, Serialize};
-
-use super::{Dock, DockArea, DockItem, DockPlacement, Panel, PanelRegistry};
-
-/// Used to serialize and deserialize the DockArea
-#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq)]
-pub struct DockAreaState {
-    /// The version is used to mark this persisted state is compatible with the current version
-    /// For example, some times we many totally changed the structure of the Panel,
-    /// then we can compare the version to decide whether we can use the state or ignore.
-    #[serde(default)]
-    pub version: Option<usize>,
-    pub center: PanelState,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub left_dock: Option<DockState>,
-}
-
-/// Used to serialize and deserialize the Dock
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct DockState {
-    panel: PanelState,
-    placement: DockPlacement,
-    size: Pixels,
-    open: bool,
-}
-
-impl DockState {
-    pub fn new(dock: Entity<Dock>, cx: &App) -> Self {
-        let dock = dock.read(cx);
-
-        Self {
-            placement: dock.placement,
-            size: dock.size,
-            open: dock.open,
-            panel: dock.panel.view().dump(cx),
-        }
-    }
-
-    /// Convert the DockState to Dock
-    pub fn to_dock(
-        &self,
-        dock_area: WeakEntity<DockArea>,
-        window: &mut Window,
-        cx: &mut App,
-    ) -> Entity<Dock> {
-        let item = self.panel.to_item(dock_area.clone(), window, cx);
-        cx.new(|cx| {
-            Dock::from_state(
-                dock_area.clone(),
-                self.placement,
-                self.size,
-                item,
-                self.open,
-                window,
-                cx,
-            )
-        })
-    }
-}
-
-/// Used to serialize and deserialize the DockerItem
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct PanelState {
-    pub panel_name: String,
-    pub children: Vec<PanelState>,
-    pub info: PanelInfo,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum PanelInfo {
-    #[serde(rename = "stack")]
-    Stack {
-        sizes: Vec<Pixels>,
-        axis: usize, // 0 for horizontal, 1 for vertical
-    },
-    #[serde(rename = "tabs")]
-    Tabs { active_index: usize },
-    #[serde(rename = "panel")]
-    Panel(serde_json::Value),
-}
-
-impl PanelInfo {
-    pub fn stack(sizes: Vec<Pixels>, axis: Axis) -> Self {
-        Self::Stack {
-            sizes,
-            axis: if axis == Axis::Horizontal { 0 } else { 1 },
-        }
-    }
-
-    pub fn tabs(active_index: usize) -> Self {
-        Self::Tabs { active_index }
-    }
-
-    pub fn panel(info: serde_json::Value) -> Self {
-        Self::Panel(info)
-    }
-
-    pub fn axis(&self) -> Option<Axis> {
-        match self {
-            Self::Stack { axis, .. } => Some(if *axis == 0 {
-                Axis::Horizontal
-            } else {
-                Axis::Vertical
-            }),
-            _ => None,
-        }
-    }
-
-    pub fn sizes(&self) -> Option<&Vec<Pixels>> {
-        match self {
-            Self::Stack { sizes, .. } => Some(sizes),
-            _ => None,
-        }
-    }
-
-    pub fn active_index(&self) -> Option<usize> {
-        match self {
-            Self::Tabs { active_index } => Some(*active_index),
-            _ => None,
-        }
-    }
-}
-
-impl Default for PanelState {
-    fn default() -> Self {
-        Self {
-            panel_name: "".to_string(),
-            children: Vec::new(),
-            info: PanelInfo::Panel(serde_json::Value::Null),
-        }
-    }
-}
-
-impl PanelState {
-    pub fn new<P: Panel>(panel: &P) -> Self {
-        Self {
-            panel_name: panel.panel_name().to_string(),
-            ..Default::default()
-        }
-    }
-
-    pub fn add_child(&mut self, panel: PanelState) {
-        self.children.push(panel);
-    }
-
-    pub fn to_item(
-        &self,
-        dock_area: WeakEntity<DockArea>,
-        window: &mut Window,
-        cx: &mut App,
-    ) -> DockItem {
-        let info = self.info.clone();
-
-        let items: Vec<DockItem> = self
-            .children
-            .iter()
-            .map(|child| child.to_item(dock_area.clone(), window, cx))
-            .collect();
-
-        match info {
-            PanelInfo::Stack { sizes, axis } => {
-                let axis = if axis == 0 {
-                    Axis::Horizontal
-                } else {
-                    Axis::Vertical
-                };
-                let sizes = sizes.iter().map(|s| Some(*s)).collect_vec();
-                DockItem::split_with_sizes(axis, items, sizes, &dock_area, window, cx)
-            }
-            PanelInfo::Tabs { active_index } => {
-                if items.len() == 1 {
-                    return items[0].clone();
-                }
-
-                let items = items
-                    .iter()
-                    .flat_map(|item| match item {
-                        DockItem::Tabs { items, .. } => items.clone(),
-                        _ => {
-                            // ignore invalid panels in tabs
-                            vec![]
-                        }
-                    })
-                    .collect_vec();
-
-                DockItem::tabs(items, &dock_area, window, cx).active_index(active_index, cx)
-            }
-            PanelInfo::Panel(_) => {
-                let view = PanelRegistry::build_panel(
-                    &self.panel_name,
-                    dock_area.clone(),
-                    self,
-                    &info,
-                    window,
-                    cx,
-                );
-                DockItem::tabs(vec![view.into()], &dock_area, window, cx)
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use gpui::px;
-
-    use super::*;
-    #[test]
-    fn test_deserialize_item_state() {
-        let json = include_str!("fixtures/layout.json");
-        let state: DockAreaState = serde_json::from_str(json).unwrap();
-        assert_eq!(state.version, None);
-        assert_eq!(state.center.panel_name, "StackPanel");
-        assert_eq!(state.center.children.len(), 2);
-        assert_eq!(state.center.children[0].panel_name, "TabPanel");
-        assert_eq!(state.center.children[1].children.len(), 1);
-        assert_eq!(
-            state.center.children[1].children[0].panel_name,
-            "StoryContainer"
-        );
-        assert_eq!(state.center.children[1].panel_name, "TabPanel");
-
-        let left_dock = state.left_dock.unwrap();
-        assert!(left_dock.open);
-        assert_eq!(left_dock.size, px(350.0));
-        assert_eq!(left_dock.placement, DockPlacement::Left);
-        assert_eq!(left_dock.panel.panel_name, "TabPanel");
-        assert_eq!(left_dock.panel.children.len(), 1);
-        assert_eq!(left_dock.panel.children[0].panel_name, "StoryContainer");
-    }
-}

crates/dock/src/tab_bar.rs

@@ -1,469 +0,0 @@
-use std::sync::Arc;
-
-use gpui::prelude::FluentBuilder;
-use gpui::{
-    AnyElement, App, AppContext, ElementId, Entity, InteractiveElement as _, IntoElement,
-    ParentElement as _, RenderOnce, ScrollHandle, StatefulInteractiveElement, Styled as _, Window,
-    div, px,
-};
-use gpui_base::{InteractiveElementExt, Tab, Tabs};
-use gpui_component::{ActiveTheme, ElementExt, h_flex};
-
-use super::{AnyDrag, DragPanel, PanelView, TabPanel};
-use crate::TAB_BAR_HEIGHT;
-
-/// The dock's custom tab bar, built on gpui-base's unstyled [`Tab`]/[`Tabs`].
-///
-/// The dock owns the pill presentation; the layout mirrors gpui-component's
-/// `TabBar`: a prefix (dock toggle / tab navigation), a scrollable tab strip
-/// with a trailing drop target, then a suffix (panel toolbar).
-///
-/// Tabs are draggable to move panels between groups and double as drop
-/// targets, so panel-level events are forwarded to the owning [`TabPanel`].
-#[derive(IntoElement)]
-pub(crate) struct TabBar {
-    id: ElementId,
-    panels: Vec<Arc<dyn PanelView>>,
-    active_panel: Option<Arc<dyn PanelView>>,
-    collapsed: bool,
-    draggable: bool,
-    droppable: bool,
-    tab_panel: Entity<TabPanel>,
-    scroll_handle: ScrollHandle,
-    prefix: Option<AnyElement>,
-    suffix: Option<AnyElement>,
-    empty_space: Option<AnyElement>,
-}
-
-impl TabBar {
-    pub(crate) fn new(id: impl Into<ElementId>, tab_panel: Entity<TabPanel>) -> Self {
-        Self {
-            id: id.into(),
-            panels: Vec::new(),
-            active_panel: None,
-            collapsed: false,
-            draggable: false,
-            droppable: false,
-            tab_panel,
-            scroll_handle: ScrollHandle::new(),
-            prefix: None,
-            suffix: None,
-            empty_space: None,
-        }
-    }
-
-    /// The panels to show as tabs, in strip order.
-    pub(crate) fn panels(mut self, panels: Vec<Arc<dyn PanelView>>) -> Self {
-        self.panels = panels;
-        self
-    }
-
-    /// The currently active panel; its tab is rendered as the filled pill.
-    pub(crate) fn active_panel(mut self, active_panel: Option<Arc<dyn PanelView>>) -> Self {
-        self.active_panel = active_panel;
-        self
-    }
-
-    /// Collapsed tab panels render no suffix or trailing drop target, and
-    /// their tabs lose the active style and all interactions.
-    pub(crate) fn collapsed(mut self, collapsed: bool) -> Self {
-        self.collapsed = collapsed;
-        self
-    }
-
-    /// Whether the tabs can start a panel drag.
-    pub(crate) fn draggable(mut self, draggable: bool) -> Self {
-        self.draggable = draggable;
-        self
-    }
-
-    /// Whether the tabs and trailing space accept drops.
-    pub(crate) fn droppable(mut self, droppable: bool) -> Self {
-        self.droppable = droppable;
-        self
-    }
-
-    /// Track the strip's scroll state with the given handle, so callers can
-    /// scroll a tab into view with [`ScrollHandle::scroll_to_item`].
-    pub(crate) fn scroll_handle(mut self, scroll_handle: &ScrollHandle) -> Self {
-        self.scroll_handle = scroll_handle.clone();
-        self
-    }
-
-    /// Element shown before the tab strip.
-    pub(crate) fn prefix(mut self, prefix: impl IntoElement) -> Self {
-        self.prefix = Some(prefix.into_any_element());
-        self
-    }
-
-    /// Element shown after the tab strip.
-    pub(crate) fn suffix(mut self, suffix: impl IntoElement) -> Self {
-        self.suffix = Some(suffix.into_any_element());
-        self
-    }
-
-    /// Replace the trailing empty space (the drop target after the last tab).
-    #[cfg(test)]
-    pub(crate) fn empty_space(mut self, empty_space: impl IntoElement) -> Self {
-        self.empty_space = Some(empty_space.into_any_element());
-        self
-    }
-
-    fn render_tab(
-        &self,
-        ix: usize,
-        panel: Arc<dyn PanelView>,
-        active: bool,
-        window: &mut Window,
-        cx: &mut App,
-    ) -> Tab {
-        // While collapsed, tabs lose the active style and all interactions.
-        let droppable = self.collapsed;
-        let tab_panel = self.tab_panel.clone();
-
-        // The `ix` element id keeps each tab's identity stable across renders.
-        Tab::new(ix)
-            .h_6()
-            .px_3()
-            .text_sm()
-            .whitespace_nowrap()
-            .flex()
-            .items_center()
-            .justify_center()
-            .gap_1()
-            .flex_shrink_0()
-            .overflow_hidden()
-            .rounded(cx.theme().radius)
-            .text_color(cx.theme().foreground)
-            .map(|this| {
-                if let Some(tab_name) = panel.tab_name(cx) {
-                    this.child(tab_name)
-                } else {
-                    this.child(panel.title(window, cx))
-                }
-            })
-            // Pill presentation: the selected tab is the filled pill, the
-            // rest are transparent until hovered.
-            .styles(|styles| {
-                styles.selected(|style| {
-                    style
-                        .text_color(cx.theme().tab_active_foreground)
-                        .bg(cx.theme().tab_active)
-                })
-            })
-            .hover(|this| {
-                if active {
-                    this
-                } else {
-                    this.text_color(cx.theme().secondary_foreground)
-                        .bg(cx.theme().secondary_hover)
-                }
-            })
-            .selected(active)
-            .on_click(move |_, window, cx| {
-                tab_panel.update(cx, |view, cx| view.set_active_ix(ix, window, cx));
-            })
-            .when(!droppable, |this| {
-                this.when(self.draggable, |this| {
-                    this.on_drag(
-                        DragPanel::new(panel.clone(), self.tab_panel.clone()),
-                        |drag, offset, _, cx| {
-                            cx.stop_propagation();
-                            drag.drag_offset.set(offset);
-                            cx.new(|_| drag.clone())
-                        },
-                    )
-                })
-                .when(self.droppable, |this| {
-                    this.drag_over::<DragPanel>(|this, _, _, cx| {
-                        this.rounded_l_none()
-                            .border_l_2()
-                            .border_r_0()
-                            .border_color(cx.theme().drag_border)
-                    })
-                    .on_drop({
-                        let tab_panel = self.tab_panel.clone();
-                        move |drag: &DragPanel, window, cx| {
-                            tab_panel.update(cx, |view, cx| {
-                                view.will_split_placement = None;
-                                view.on_drop(drag, Some(ix), true, window, cx);
-                            });
-                        }
-                    })
-                    .drag_over::<AnyDrag>(|this, _, _, cx| {
-                        this.rounded_l_none()
-                            .border_l_2()
-                            .border_r_0()
-                            .border_color(cx.theme().drag_border)
-                    })
-                    .on_drop({
-                        let tab_panel = self.tab_panel.clone();
-                        move |item: &AnyDrag, _, cx| {
-                            tab_panel.update(cx, |view, cx| {
-                                view.will_split_placement = None;
-                                view.emit_drag_drop(item, None, cx);
-                            });
-                        }
-                    })
-                })
-            })
-    }
-
-    fn render_empty_space(&self) -> AnyElement {
-        let tabs_count = self.panels.len();
-
-        // The strip after the last tab is a drop target for panels and
-        // host-owned drag items. Its left edge (right after the last tab)
-        // marks the start of the title-bar drag overlay.
-        let mut empty = div()
-            .id("tab-bar-empty-space")
-            .h_full()
-            .flex_grow_1()
-            .min_w_16()
-            .on_prepaint({
-                let view = self.tab_panel.clone();
-                move |bounds, _, cx| {
-                    view.update(cx, |this, cx| {
-                        if this.title_bar_strip_bounds != Some(bounds) {
-                            this.title_bar_strip_bounds = Some(bounds);
-                            cx.notify();
-                        }
-                    });
-                }
-            });
-
-        if self.droppable {
-            empty = empty
-                .drag_over::<DragPanel>(|this, _, _, cx| this.bg(cx.theme().tokens.drop_target))
-                .on_drop({
-                    let view = self.tab_panel.clone();
-                    move |drag: &DragPanel, window, cx| {
-                        view.update(cx, |this, cx| {
-                            this.will_split_placement = None;
-
-                            // Dropping a panel from this same tab group onto
-                            // the strip moves it after the last tab.
-                            let ix = if drag.tab_panel == cx.entity() {
-                                Some(tabs_count - 1)
-                            } else {
-                                None
-                            };
-
-                            this.on_drop(drag, ix, false, window, cx);
-                        });
-                    }
-                })
-                .drag_over::<AnyDrag>(|this, _, _, cx| this.bg(cx.theme().tokens.drop_target))
-                .on_drop({
-                    let view = self.tab_panel.clone();
-                    move |item: &AnyDrag, _, cx| {
-                        view.update(cx, |this, cx| {
-                            this.will_split_placement = None;
-                            this.emit_drag_drop(item, None, cx);
-                        });
-                    }
-                });
-        }
-
-        empty.into_any_element()
-    }
-}
-
-impl RenderOnce for TabBar {
-    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let tabs: Vec<_> = self
-            .panels
-            .iter()
-            .enumerate()
-            .filter_map(|(ix, panel)| {
-                let mut active = self.active_panel.as_ref() == Some(panel);
-                if !panel.visible(cx) {
-                    return None;
-                }
-                // Always not show active tab style, if the panel is collapsed
-                if self.collapsed {
-                    active = false;
-                }
-                Some(self.render_tab(ix, panel.clone(), active, window, cx))
-            })
-            .collect();
-
-        let empty_space = match self.empty_space {
-            Some(empty_space) => empty_space,
-            None => self.render_empty_space(),
-        };
-
-        Tabs::new(self.id)
-            .px(px(-1.))
-            .h(TAB_BAR_HEIGHT)
-            .flex()
-            .items_center()
-            .text_color(cx.theme().tab_foreground)
-            .when_some(self.prefix, |this, prefix| this.child(prefix))
-            .child(
-                h_flex().id("tabs").flex_1().overflow_x_hidden().child(
-                    h_flex()
-                        .id("tabs-inner")
-                        .relative()
-                        .gap(px(4.))
-                        .overflow_x_scroll()
-                        .lock_scroll_axis()
-                        .track_scroll(&self.scroll_handle)
-                        .children(tabs)
-                        .when(!self.collapsed, |this| this.child(empty_space)),
-                ),
-            )
-            .when_some(self.suffix, |this, suffix| {
-                this.when(!self.collapsed, |this| this.child(suffix))
-            })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::atomic::{AtomicBool, Ordering};
-
-    use gpui::{
-        Context, Entity, MouseButton, Render, TestAppContext, VisualTestContext, WindowOptions,
-        div, px, size,
-    };
-    use gpui_component::{Root, Theme, v_flex};
-
-    use super::*;
-    use crate::DockArea;
-    use crate::tab_panel::title_bar_drag_handlers;
-
-    #[derive(Default)]
-    struct ProbeFlags {
-        empty_down: AtomicBool,
-        empty_click: AtomicBool,
-        control_down: AtomicBool,
-        control_click: AtomicBool,
-    }
-
-    struct ProbeView {
-        flags: Entity<ProbeFlags>,
-        tab_panel: Entity<TabPanel>,
-    }
-
-    impl Render for ProbeView {
-        fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-            let flags = self.flags.clone();
-
-            let empty = title_bar_drag_handlers(
-                div()
-                    .id("empty-space")
-                    .h(TAB_BAR_HEIGHT)
-                    .flex_grow_1()
-                    .min_w_16(),
-                window,
-                cx,
-            )
-            .debug_selector(|| "empty-space".into())
-            .on_mouse_down(MouseButton::Left, {
-                let flags = flags.clone();
-                move |_, _, cx| flags.update(cx, |f, _| f.empty_down.store(true, Ordering::SeqCst))
-            })
-            .on_click({
-                let flags = flags.clone();
-                move |_, _, cx| flags.update(cx, |f, _| f.empty_click.store(true, Ordering::SeqCst))
-            });
-
-            let control =
-                title_bar_drag_handlers(div().id("control-space").h_8().flex_grow_1(), window, cx)
-                    .debug_selector(|| "control-space".into())
-                    .on_mouse_down(MouseButton::Left, {
-                        let flags = flags.clone();
-                        move |_, _, cx| {
-                            flags.update(cx, |f, _| f.control_down.store(true, Ordering::SeqCst))
-                        }
-                    })
-                    .on_click({
-                        let flags = flags.clone();
-                        move |_, _, cx| {
-                            flags.update(cx, |f, _| f.control_click.store(true, Ordering::SeqCst))
-                        }
-                    });
-
-            v_flex()
-                .size_full()
-                .child(TabBar::new("probe-bar", self.tab_panel.clone()).empty_space(empty))
-                .child(control)
-        }
-    }
-
-    /// Diagnostic: verify that the tab bar's trailing empty space receives
-    /// mouse events when wrapped by `title_bar_drag_handlers`, i.e. the
-    /// strip's scroll containers do not swallow them.
-    #[gpui::test]
-    fn tab_bar_empty_space_receives_events(cx: &mut TestAppContext) {
-        let (flags, handle) = cx.update(|cx| {
-            cx.set_global(Theme::default());
-            let flags = cx.new(|_| ProbeFlags::default());
-            let handle = cx.open_window(
-                WindowOptions {
-                    window_bounds: Some(gpui::WindowBounds::Windowed(gpui::Bounds {
-                        origin: gpui::Point::default(),
-                        size: size(px(800.), px(100.)),
-                    })),
-                    ..Default::default()
-                },
-                |window, cx| {
-                    let flags = flags.clone();
-                    let dock_area = cx.new(|cx| DockArea::new("probe-dock", None, window, cx));
-                    let tab_panel =
-                        cx.new(|cx| TabPanel::new(None, dock_area.downgrade(), window, cx));
-                    let content = cx.new(|_| ProbeView { flags, tab_panel });
-                    cx.new(|cx| Root::new(content, window, cx))
-                },
-            );
-            (flags, handle.unwrap())
-        });
-        let mut cx = VisualTestContext::from_window(handle.into(), cx);
-
-        cx.run_until_parked();
-        cx.update(|window, cx| {
-            _ = window.draw(cx);
-        });
-
-        let empty_bounds = cx
-            .debug_bounds("empty-space")
-            .expect("empty-space must be laid out");
-        let control_bounds = cx
-            .debug_bounds("control-space")
-            .expect("control-space must be laid out");
-        let empty_center = empty_bounds.center();
-        let control_center = control_bounds.center();
-
-        // Control: a plain div with the same handlers, outside the tab bar.
-        cx.simulate_click(control_center, Default::default());
-        // Target: the tab bar's empty-space strip.
-        cx.simulate_click(empty_center, Default::default());
-
-        let (empty_down, empty_click, control_down, control_click) = cx.read(|cx| {
-            let flags = flags.read(cx);
-            (
-                flags.empty_down.load(Ordering::SeqCst),
-                flags.empty_click.load(Ordering::SeqCst),
-                flags.control_down.load(Ordering::SeqCst),
-                flags.control_click.load(Ordering::SeqCst),
-            )
-        });
-        assert!(
-            control_down,
-            "control mouse_down must fire at {control_center:?}"
-        );
-        assert!(
-            control_click,
-            "control click must fire at {control_center:?}"
-        );
-        assert!(
-            empty_down,
-            "empty-space mouse_down must fire at {empty_center:?}"
-        );
-        assert!(
-            empty_click,
-            "empty-space click must fire at {empty_center:?}"
-        );
-    }
-}

crates/dock/src/window_controls.rs

@@ -7,7 +7,6 @@ use gpui_component::{ActiveTheme, Icon, IconName, Sizable as _, h_flex};
 
 use crate::TAB_BAR_HEIGHT;
 
-/// The standard width of a window control button.
 const CONTROL_WIDTH: f32 = 34.;
 
 #[derive(IntoElement, Clone)]
@@ -147,8 +146,7 @@ pub(crate) fn window_controls(window: &mut Window, cx: &mut App) -> impl IntoEle
         .items_center()
         .flex_shrink_0()
         .h_full()
-        // Like native windows apps, the controls span the title bar but never
-        // grow past the tab bar height.
+        // The controls span the title bar but never grow past the tab bar height.
         .when(cfg!(target_os = "windows"), |this| {
             this.max_h(TAB_BAR_HEIGHT)
         })

crates/dock/tests/render_smoke.rs

@@ -0,0 +1,92 @@
+use dock::{BasePanel, Panel, SignedDockSkin, panel_handle};
+use gpui::{
+    App, AppContext, Context, Empty, EventEmitter, FocusHandle, Focusable, IntoElement, Render,
+    TestAppContext, Window,
+};
+use gpui_base::dock::{DockArea, DockLayout, DockPlacement, PanelEvent};
+
+struct Probe {
+    focus_handle: FocusHandle,
+}
+
+impl Probe {
+    fn new(cx: &mut Context<Self>) -> Self {
+        Self {
+            focus_handle: cx.focus_handle(),
+        }
+    }
+}
+
+impl BasePanel for Probe {
+    fn panel_name(&self) -> &'static str {
+        "Probe"
+    }
+}
+
+impl Panel for Probe {
+    fn title(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
+        "Probe"
+    }
+}
+
+impl EventEmitter<PanelEvent> for Probe {}
+
+impl Focusable for Probe {
+    fn focus_handle(&self, _: &App) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for Probe {
+    fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
+        Empty
+    }
+}
+
+#[gpui::test]
+fn the_first_frame_renders_the_area_and_its_docks(cx: &mut TestAppContext) {
+    cx.update(|cx| {
+        gpui_component::init(cx);
+    });
+    let (area, cx) = cx.add_window_view(|window, cx| {
+        let skin = SignedDockSkin::new(cx);
+        DockArea::new("test", None, window, cx).with_renderer(skin)
+    });
+
+    let bottom = cx.update(|_, cx| cx.new(Probe::new));
+    cx.update(|window, cx| {
+        let left = cx.new(Probe::new);
+        let center = cx.new(Probe::new);
+
+        area.update(cx, |area, cx| {
+            area.set_dock(
+                DockPlacement::Left,
+                DockLayout::tabs().panel_view(panel_handle(left), cx),
+                window,
+                cx,
+            );
+            area.set_center(
+                DockLayout::tabs().panel_view(panel_handle(center), cx),
+                window,
+                cx,
+            );
+            area.set_dock(
+                DockPlacement::Bottom,
+                DockLayout::tabs().panel_view(panel_handle(bottom.clone()), cx),
+                window,
+                cx,
+            );
+        });
+    });
+
+    // The first frame walks every render hook, all of which read the dock area.
+    cx.update(|window, cx| window.draw(cx).clear(cx));
+
+    // Emptying a dock leaves an empty group, its render must also be safe.
+    cx.update(|window, cx| {
+        area.update(cx, |area, cx| {
+            area.remove_panel(bottom, window, cx);
+        });
+    });
+    cx.update(|window, cx| window.draw(cx).clear(cx));
+}

crates/metadata/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "metadata"
+version.workspace = true
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+signed_state = { path = "../signed_state" }
+utils = { path = "../utils" }
+
+nostr-sdk.workspace = true
+flume.workspace = true
+futures.workspace = true
+anyhow.workspace = true
+gpui.workspace = true
+log.workspace = true

crates/metadata/src/lib.rs

@@ -0,0 +1,9 @@
+mod profile;
+
+use gpui::{App, AppContext};
+pub use profile::{Profile, ProfileDirectory, ProfileEvent, ProfileStore};
+
+/// Initialize the global profile store.
+pub fn init(cx: &mut App) {
+    ProfileStore::set_global(cx.new(ProfileStore::new), cx);
+}

crates/metadata/src/profile.rs

@@ -0,0 +1,374 @@
+use std::cell::RefCell;
+use std::collections::{HashMap, HashSet};
+use std::time::{Duration, Instant};
+
+use flume::Sender;
+use gpui::{
+    App, AppContext, Context, Entity, EventEmitter, Global, SharedString, Subscription, Task,
+};
+use nostr_sdk::prelude::*;
+use signed_state::{Backend, BackendEvent, sync_bootstrap_only};
+use utils::shorten_pubkey;
+
+const BATCH_TIMEOUT: Duration = Duration::from_millis(500);
+const REQUEST_CHUNK: usize = 100;
+
+#[derive(Debug, Clone)]
+pub struct Profile {
+    public_key: PublicKey,
+    metadata: Metadata,
+}
+
+impl Profile {
+    pub fn new(public_key: PublicKey, metadata: Metadata) -> Self {
+        Self {
+            public_key,
+            metadata,
+        }
+    }
+
+    pub fn public_key(&self) -> PublicKey {
+        self.public_key
+    }
+
+    pub fn metadata(&self) -> &Metadata {
+        &self.metadata
+    }
+
+    // Falls back to `name`, then a shortened npub.
+    pub fn name(&self) -> SharedString {
+        if let Some(display_name) = self.metadata.display_name.as_ref()
+            && !display_name.is_empty()
+        {
+            return SharedString::from(display_name.trim().to_owned());
+        }
+
+        if let Some(name) = self.metadata.name.as_ref()
+            && !name.is_empty()
+        {
+            return SharedString::from(name.trim().to_owned());
+        }
+
+        SharedString::from(shorten_pubkey(self.public_key))
+    }
+
+    pub fn picture(&self) -> Option<SharedString> {
+        self.metadata
+            .picture
+            .as_ref()
+            .filter(|p| !p.is_empty())
+            .map(|p| SharedString::from(p.clone()))
+    }
+
+    /// The newest profile per author from metadata events.
+    fn latest_profiles(events: impl IntoIterator<Item = Event>) -> Vec<Self> {
+        let mut latest: HashMap<PublicKey, (Timestamp, Metadata)> = HashMap::new();
+
+        for event in events {
+            match latest.get(&event.pubkey) {
+                Some((created_at, _)) if *created_at >= event.created_at => {}
+                _ => {
+                    let metadata = Metadata::from_json(&event.content).unwrap_or_default();
+                    latest.insert(event.pubkey, (event.created_at, metadata));
+                }
+            }
+        }
+
+        latest
+            .into_iter()
+            .map(|(public_key, (_, metadata))| Profile::new(public_key, metadata))
+            .collect()
+    }
+}
+
+/// Metadata for these authors may have changed in the local database.
+#[derive(Debug, Clone)]
+pub enum ProfileEvent {
+    Updated(Vec<PublicKey>),
+}
+
+/// Batches metadata requests into relay syncs feeding the local database.
+pub struct ProfileStore {
+    in_flight: RefCell<HashSet<PublicKey>>,
+    sender: Sender<PublicKey>,
+    _task: Task<Result<(), anyhow::Error>>,
+    _subscription: Subscription,
+}
+
+struct GlobalProfileStore(Entity<ProfileStore>);
+
+impl Global for GlobalProfileStore {}
+
+impl EventEmitter<ProfileEvent> for ProfileStore {}
+
+impl ProfileStore {
+    pub(crate) fn global(cx: &App) -> Entity<Self> {
+        cx.global::<GlobalProfileStore>().0.clone()
+    }
+
+    pub(crate) fn set_global(entity: Entity<Self>, cx: &mut App) {
+        cx.set_global(GlobalProfileStore(entity));
+    }
+
+    pub(crate) fn new(cx: &mut Context<Self>) -> Self {
+        let backend = Backend::global(cx);
+        let client = backend.read(cx).client();
+
+        let (sender, receiver) = flume::unbounded::<PublicKey>();
+
+        let subscription = cx.subscribe(&backend, |this, _backend, event, cx| {
+            if let BackendEvent::ProfileUpdates(authors) = event {
+                this.emit_updated(authors.clone(), cx);
+            }
+        });
+
+        let task = cx.spawn(async move |this, cx| {
+            let mut batch: HashSet<PublicKey> = HashSet::new();
+
+            loop {
+                match receiver.recv_async().await {
+                    Ok(public_key) => {
+                        batch.insert(public_key);
+                    }
+                    Err(_) => return Ok(()),
+                }
+
+                // The channel has no async timeout, race the receive against a timer.
+                let deadline = Instant::now() + BATCH_TIMEOUT;
+
+                loop {
+                    let now = Instant::now();
+
+                    if now >= deadline {
+                        break;
+                    }
+
+                    let timer = cx.background_executor().timer(deadline - now);
+                    futures::pin_mut!(timer);
+
+                    let recv = receiver.recv_async();
+                    futures::pin_mut!(recv);
+
+                    match futures::future::select(recv, timer).await {
+                        futures::future::Either::Left((Ok(public_key), _)) => {
+                            batch.insert(public_key);
+                        }
+                        futures::future::Either::Left((Err(_), _)) => return Ok(()),
+                        futures::future::Either::Right(_) => break,
+                    }
+                }
+
+                let authors: Vec<PublicKey> = batch.drain().collect();
+
+                for chunk in authors.chunks(REQUEST_CHUNK) {
+                    let opts = SyncOptions::default();
+                    let filter = Filter::new()
+                        .kind(Kind::Metadata)
+                        .authors(chunk.iter().copied());
+
+                    if let Err(e) = sync_bootstrap_only(&client, filter, opts).await {
+                        log::warn!("profile fetch failed: {e}");
+                    }
+                }
+
+                // Emit even when the sync failed, the database may hold newer data.
+                this.update(cx, |this, cx| {
+                    this.emit_updated(authors, cx);
+                })?;
+            }
+        });
+
+        Self {
+            in_flight: RefCell::new(HashSet::new()),
+            sender,
+            _task: task,
+            _subscription: subscription,
+        }
+    }
+
+    /// Queue a batched relay sync for keys without one in flight.
+    pub fn fetch(&self, keys: impl IntoIterator<Item = PublicKey>) {
+        let mut queue = Vec::new();
+        {
+            let mut in_flight = self.in_flight.borrow_mut();
+
+            for key in keys {
+                if in_flight.insert(key) {
+                    queue.push(key);
+                }
+            }
+        }
+        for public_key in queue {
+            if let Err(e) = self.sender.send(public_key) {
+                log::warn!("failed to queue profile fetch: {e}");
+            }
+        }
+    }
+
+    // Releases the in-flight keys so future fetches can be queued again.
+    fn emit_updated(&mut self, authors: Vec<PublicKey>, cx: &mut Context<Self>) {
+        if authors.is_empty() {
+            return;
+        }
+
+        {
+            let mut in_flight = self.in_flight.borrow_mut();
+            for author in &authors {
+                in_flight.remove(author);
+            }
+        }
+
+        cx.emit(ProfileEvent::Updated(authors));
+    }
+}
+
+/// Profile cache bound to one panel or screen.
+pub struct ProfileDirectory {
+    profiles: HashMap<PublicKey, Profile>,
+    pending: RefCell<HashSet<PublicKey>>,
+    tasks: Vec<Task<()>>,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl ProfileDirectory {
+    pub fn new(cx: &mut App) -> Entity<Self> {
+        let store = ProfileStore::global(cx);
+
+        cx.new(|cx| {
+            let subscription =
+                cx.subscribe(&store, |this: &mut Self, _store, event, cx| match event {
+                    ProfileEvent::Updated(authors) => this.refresh(authors, cx),
+                });
+
+            Self {
+                profiles: HashMap::new(),
+                pending: RefCell::new(HashSet::new()),
+                tasks: Vec::new(),
+                _subscriptions: vec![subscription],
+            }
+        })
+    }
+
+    /// Resolve keys from the local database, queue the rest for a relay sync.
+    pub fn track<K>(&mut self, keys: K, cx: &mut Context<Self>)
+    where
+        K: IntoIterator<Item = PublicKey>,
+    {
+        let missing: Vec<PublicKey> = keys
+            .into_iter()
+            .filter(|key| {
+                !self.profiles.contains_key(key)
+                    && !self.with_pending(|pending| pending.contains(key))
+            })
+            .collect();
+
+        if missing.is_empty() {
+            return;
+        }
+
+        self.load(missing, true, cx);
+    }
+
+    /// The profile for a key, or a placeholder that queues a relay sync.
+    pub fn profile(&self, public_key: &PublicKey, cx: &App) -> Profile {
+        if let Some(profile) = self.profiles.get(public_key) {
+            return profile.clone();
+        }
+
+        if self.with_pending(|pending| pending.insert(*public_key)) {
+            let store = ProfileStore::global(cx);
+            store.read(cx).fetch([*public_key]);
+        }
+
+        Profile::new(*public_key, Metadata::default())
+    }
+
+    /// Refreshes profiles for keys that are already tracked.
+    fn refresh(&mut self, authors: &[PublicKey], cx: &mut Context<Self>) {
+        let tracked: Vec<PublicKey> = authors
+            .iter()
+            .copied()
+            .filter(|key| {
+                self.profiles.contains_key(key)
+                    || self.with_pending(|pending| pending.contains(key))
+            })
+            .collect();
+
+        if tracked.is_empty() {
+            return;
+        }
+
+        self.load(tracked, false, cx);
+    }
+
+    /// Loads profiles from the local database, queueing a relay sync for any missing keys.
+    fn load(&mut self, keys: Vec<PublicKey>, queue_sync: bool, cx: &mut Context<Self>) {
+        // Accept events that arrive while the database query is running.
+        self.with_pending(|pending| {
+            pending.extend(keys.iter().copied());
+        });
+
+        let backend = Backend::global(cx);
+        let client = backend.read(cx).client();
+        let query_keys = keys.clone();
+
+        let work = cx.background_spawn(async move {
+            let authors = query_keys.iter().copied();
+            let filter = Filter::new().kind(Kind::Metadata).authors(authors);
+            let events = client.database().query(filter).await?;
+
+            Ok::<_, anyhow::Error>(Profile::latest_profiles(events))
+        });
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
+            let loaded = work.await;
+
+            this.update(cx, |this, cx| {
+                let remaining = match loaded {
+                    Ok(profiles) => {
+                        let found: HashSet<PublicKey> =
+                            profiles.iter().map(Profile::public_key).collect();
+                        this.insert_loaded(profiles, cx);
+                        keys.into_iter()
+                            .filter(|key| !found.contains(key))
+                            .collect()
+                    }
+                    Err(e) => {
+                        log::warn!("failed to load profiles from the database: {e}");
+                        keys
+                    }
+                };
+
+                if queue_sync && !remaining.is_empty() {
+                    let store = ProfileStore::global(cx);
+                    store.read(cx).fetch(remaining);
+                }
+            })
+            .ok();
+        }));
+    }
+
+    // Inserts database results, replacing anything loaded earlier.
+    fn insert_loaded(&mut self, profiles: Vec<Profile>, cx: &mut Context<Self>) {
+        let mut inserted = false;
+
+        for profile in profiles {
+            let public_key = profile.public_key();
+            self.profiles.insert(public_key, profile);
+            self.with_pending(|pending| pending.remove(&public_key));
+            inserted = true;
+        }
+
+        if inserted {
+            cx.notify();
+        }
+    }
+
+    fn with_pending<R, T>(&self, then: T) -> R
+    where
+        T: FnOnce(&mut HashSet<PublicKey>) -> R,
+    {
+        let mut pending = self.pending.borrow_mut();
+        then(&mut pending)
+    }
+}

crates/paths/src/lib.rs

@@ -1,23 +1,16 @@
-//! Paths to locations used by Signed.
-//!
-//! Follows the same pattern as Zed's `paths` crate: platform-correct base
-//! directories, resolved once and cached, with an optional custom data dir
-//! override for portable/dev installs.
-
 use std::path::PathBuf;
 use std::sync::OnceLock;
 
-/// The application name, used to derive platform-specific data, config and
-/// cache directory paths.
+/// The application name.
+///
+/// It derives the platform-specific data, config and cache directory paths.
 pub const APP_NAME: &str = "Signed";
 
-/// Lowercased form of [`APP_NAME`], for use in XDG-style paths on
-/// Linux/FreeBSD and the macOS `~/.config` fallback.
+/// Lowercased form of [`APP_NAME`].
+///
+/// Used in XDG-style paths on Linux and FreeBSD, and the macOS `~/.config` fallback.
 pub const APP_NAME_LOWERCASE: &str = "signed";
 
-/// A custom data directory override, set only by [`set_custom_data_dir`].
-static CUSTOM_DATA_DIR: OnceLock<PathBuf> = OnceLock::new();
-
 /// The resolved data directory.
 /// On macOS, this is `~/Library/Application Support/Signed`.
 /// On Linux/FreeBSD, this is `$XDG_DATA_HOME/signed`.
@@ -30,38 +23,27 @@ static CURRENT_DATA_DIR: OnceLock<PathBuf> = OnceLock::new();
 /// On Windows, this is `%APPDATA%\Signed`.
 static CONFIG_DIR: OnceLock<PathBuf> = OnceLock::new();
 
-/// Returns the current user's home directory.
-pub fn home_dir() -> PathBuf {
+fn home_dir() -> PathBuf {
     dirs::home_dir().expect("failed to determine home directory")
 }
 
-/// Sets a custom directory for all user data, overriding the default data
-/// directory. Must be called before any other path operation. The directory
-/// is created if it doesn't exist and canonicalized to an absolute path.
+/// Returns the current user's Desktop folder.
 ///
-/// # Panics
-///
-/// Panics if called after [`data_dir`] or [`config_dir`] was initialized, or
-/// if the directory cannot be created/canonicalized.
-pub fn set_custom_data_dir(dir: &str) -> &'static PathBuf {
-    if CURRENT_DATA_DIR.get().is_some() || CONFIG_DIR.get().is_some() {
-        panic!("set_custom_data_dir called after data_dir or config_dir was initialized");
-    }
-
-    CUSTOM_DATA_DIR.get_or_init(|| {
-        let path = PathBuf::from(dir);
-        std::fs::create_dir_all(&path).expect("failed to create custom data directory");
-        path.canonicalize()
-            .expect("failed to canonicalize custom data directory")
-    })
+/// Falls back to the home directory or an empty path when it cannot be determined.
+pub fn desktop_dir() -> PathBuf {
+    dirs::desktop_dir().unwrap_or_else(|| dirs::home_dir().unwrap_or_default())
 }
 
-/// Returns the path to the configuration directory.
-pub fn config_dir() -> &'static PathBuf {
+/// Returns the current user's Documents folder.
+///
+/// Falls back to the home directory or an empty path when it cannot be determined.
+pub fn documents_dir() -> PathBuf {
+    dirs::document_dir().unwrap_or_else(|| dirs::home_dir().unwrap_or_default())
+}
+
+fn config_dir() -> &'static PathBuf {
     CONFIG_DIR.get_or_init(|| {
-        if let Some(custom_dir) = CUSTOM_DATA_DIR.get() {
-            custom_dir.join("config")
-        } else if cfg!(target_os = "windows") {
+        if cfg!(target_os = "windows") {
             dirs::config_dir()
                 .expect("failed to determine RoamingAppData directory")
                 .join(APP_NAME)
@@ -78,12 +60,9 @@ pub fn config_dir() -> &'static PathBuf {
     })
 }
 
-/// Returns the path to the data directory.
-pub fn data_dir() -> &'static PathBuf {
+fn data_dir() -> &'static PathBuf {
     CURRENT_DATA_DIR.get_or_init(|| {
-        if let Some(custom_dir) = CUSTOM_DATA_DIR.get() {
-            custom_dir.clone()
-        } else if cfg!(target_os = "macos") {
+        if cfg!(target_os = "macos") {
             home_dir()
                 .join("Library/Application Support")
                 .join(APP_NAME)
@@ -104,63 +83,23 @@ pub fn data_dir() -> &'static PathBuf {
     })
 }
 
-/// Returns the path to the cache directory.
-pub fn cache_dir() -> &'static PathBuf {
-    static CACHE_DIR: OnceLock<PathBuf> = OnceLock::new();
-    CACHE_DIR.get_or_init(|| {
-        if cfg!(target_os = "macos") {
-            dirs::cache_dir()
-                .expect("failed to determine caches directory")
-                .join(APP_NAME)
-        } else if cfg!(target_os = "windows") {
-            dirs::cache_dir()
-                .expect("failed to determine LocalAppData directory")
-                .join(APP_NAME)
-        } else if cfg!(any(target_os = "linux", target_os = "freebsd")) {
-            if let Ok(flatpak_xdg_cache) = std::env::var("FLATPAK_XDG_CACHE_HOME") {
-                flatpak_xdg_cache.into()
-            } else {
-                dirs::cache_dir().expect("failed to determine XDG_CACHE_HOME directory")
-            }
-            .join(APP_NAME_LOWERCASE)
-        } else {
-            home_dir().join(".cache").join(APP_NAME_LOWERCASE)
-        }
-    })
-}
-
-/// Returns the path to the logs directory.
-pub fn logs_dir() -> &'static PathBuf {
-    static LOGS_DIR: OnceLock<PathBuf> = OnceLock::new();
-    LOGS_DIR.get_or_init(|| {
-        if cfg!(target_os = "macos") {
-            home_dir().join("Library/Logs").join(APP_NAME)
-        } else {
-            data_dir().join("logs")
-        }
-    })
-}
-
-/// Returns the path to the nostr database directory (LMDB).
+/// Returns the path to the nostr database directory, LMDB.
 pub fn nostr_dir() -> &'static PathBuf {
     static NOSTR_DIR: OnceLock<PathBuf> = OnceLock::new();
     NOSTR_DIR.get_or_init(|| data_dir().join("nostr"))
 }
 
-/// Returns the path to the local git clone cache (grasp mirrors).
+/// Returns the path to the local git clone cache, the grasp mirrors.
+///
+/// The mirrors are disposable and re-cloned from their grasp server on
+/// demand, so the cache lives in the OS temp directory for the system to
+/// reclaim.
 pub fn repos_dir() -> &'static PathBuf {
     static REPOS_DIR: OnceLock<PathBuf> = OnceLock::new();
-    REPOS_DIR.get_or_init(|| data_dir().join("repos"))
+    REPOS_DIR.get_or_init(|| std::env::temp_dir().join(APP_NAME_LOWERCASE).join("repos"))
 }
 
-/// Returns the path to the `settings.json` file.
 pub fn settings_file() -> &'static PathBuf {
     static SETTINGS_FILE: OnceLock<PathBuf> = OnceLock::new();
     SETTINGS_FILE.get_or_init(|| config_dir().join("settings.json"))
 }
-
-/// Returns the path to the `keymap.json` file.
-pub fn keymap_file() -> &'static PathBuf {
-    static KEYMAP_FILE: OnceLock<PathBuf> = OnceLock::new();
-    KEYMAP_FILE.get_or_init(|| config_dir().join("keymap.json"))
-}

crates/settings/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "settings"
+description = "Persisted application settings for Signed."
+version.workspace = true
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+paths = { path = "../paths" }
+
+gpui.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+anyhow.workspace = true
+log.workspace = true
+
+[dev-dependencies]
+gpui = { workspace = true, features = ["test-support"] }

crates/settings/src/lib.rs

@@ -0,0 +1,5 @@
+mod settings;
+mod store;
+
+pub use settings::*;
+pub use store::*;

crates/settings/src/settings.rs

@@ -0,0 +1,207 @@
+use std::path::PathBuf;
+
+use serde::{Deserialize, Serialize};
+
+/// The default grasp servers, offered while the user has not published a grasp list.
+pub const DEFAULT_GRASP_SERVERS: [&str; 3] = [
+    "wss://relay.ngit.dev",
+    "wss://gitnostr.com",
+    "wss://git.shakespeare.diy",
+];
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum AppearanceMode {
+    #[default]
+    System,
+    Light,
+    Dark,
+}
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum EventFetchingStrategy {
+    /// Only the relays declared in the repository announcement.
+    Curated,
+    /// Repository relays plus every maintainer's NIP-65 relays.
+    #[default]
+    Uncensored,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct ThemeSettings {
+    /// Name of the light theme in the theme registry.
+    pub light_theme: String,
+    /// Name of the dark theme in the theme registry.
+    pub dark_theme: String,
+    /// The base font size in pixels.
+    pub font_size: f32,
+    /// The monospace font size in pixels.
+    pub mono_font_size: f32,
+    /// Corner radius for general elements in pixels.
+    pub radius: f32,
+    /// Corner radius for large elements, dialogs and notifications, in pixels.
+    pub radius_lg: f32,
+    /// Whether focused controls draw a ring outside their border.
+    pub focus_ring: bool,
+    /// Whether to apply a shadow to elements.
+    pub shadow: bool,
+}
+
+impl Default for ThemeSettings {
+    fn default() -> Self {
+        Self {
+            light_theme: "Signed Light".into(),
+            dark_theme: "Signed Dark".into(),
+            font_size: 16.0,
+            mono_font_size: 13.0,
+            radius: 4.0,
+            radius_lg: 8.0,
+            focus_ring: false,
+            shadow: false,
+        }
+    }
+}
+
+/// Tab bar chrome.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct TabBarSettings {
+    /// Hide the previous and next tab buttons.
+    pub hide_navigation_buttons: bool,
+}
+
+impl Default for TabBarSettings {
+    fn default() -> Self {
+        Self {
+            hide_navigation_buttons: true,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct GraspServersSettings {
+    /// Servers offered while the user has not published a grasp list, kind `10317`.
+    pub default_servers: Vec<String>,
+}
+
+impl Default for GraspServersSettings {
+    fn default() -> Self {
+        Self {
+            default_servers: DEFAULT_GRASP_SERVERS
+                .iter()
+                .map(|server| (*server).to_owned())
+                .collect(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct LocalReposSettings {
+    /// The directories scanned for local git repositories,
+    /// Defaults:
+    ///
+    /// - `~/Desktop`
+    /// - `~/Documents`
+    pub scan_paths: Vec<PathBuf>,
+}
+
+impl Default for LocalReposSettings {
+    fn default() -> Self {
+        Self {
+            scan_paths: vec![paths::desktop_dir(), paths::documents_dir()],
+        }
+    }
+}
+
+/// A remembered association between a local checkout folder and an announced repository,
+/// recorded when the user clones a repository or picks a folder in the New PR panel.
+///
+/// The panel can then prefill the folder later without asking again.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
+#[serde(default)]
+pub struct CheckoutRecord {
+    pub path: PathBuf,
+    /// Repository address as a string, `30617:<pubkey>:<id>`.
+    pub addr: String,
+    /// Unix seconds of the last use, for freshest-first ordering.
+    pub last_used: u64,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct CheckoutsSettings {
+    /// The latest use of a path and repo pair replaces the older record.
+    pub records: Vec<CheckoutRecord>,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct CreateRepositorySettings {
+    /// The folder the create-repository dialog defaults to, the user's Desktop when unset.
+    pub default_folder: Option<PathBuf>,
+}
+
+/// The complete set of persisted application settings.
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct Settings {
+    pub appearance: AppearanceMode,
+    pub event_fetching: EventFetchingStrategy,
+    pub theme: ThemeSettings,
+    pub tab_bar: TabBarSettings,
+    pub grasp_servers: GraspServersSettings,
+    pub local_repos: LocalReposSettings,
+    pub checkouts: CheckoutsSettings,
+    pub create_repository: CreateRepositorySettings,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn json_roundtrip_preserves_everything() {
+        let settings = Settings {
+            appearance: AppearanceMode::Dark,
+            event_fetching: EventFetchingStrategy::Curated,
+            theme: ThemeSettings {
+                radius: 8.0,
+                ..Default::default()
+            },
+            create_repository: CreateRepositorySettings {
+                default_folder: Some(PathBuf::from("/tmp/repos")),
+            },
+            ..Default::default()
+        };
+
+        let json = serde_json::to_string(&settings).unwrap();
+        let parsed: Settings = serde_json::from_str(&json).unwrap();
+        assert_eq!(parsed, settings);
+    }
+
+    #[test]
+    fn partial_json_merges_with_defaults() {
+        let settings: Settings =
+            serde_json::from_str(r#"{"appearance": "dark", "theme": {"radius": 4.0}}"#).unwrap();
+        assert_eq!(settings.appearance, AppearanceMode::Dark);
+        assert_eq!(settings.theme.radius, 4.0);
+        // Unset fields fall back to their defaults, including the fetching strategy.
+        assert_eq!(settings.event_fetching, EventFetchingStrategy::Uncensored);
+        // The rest of the theme and the other groups keep their defaults.
+        assert_eq!(settings.theme.light_theme, "Signed Light");
+        assert_eq!(settings.grasp_servers, GraspServersSettings::default());
+        assert_eq!(settings.create_repository.default_folder, None);
+    }
+
+    #[test]
+    fn event_fetching_uses_snake_case() {
+        let json = serde_json::to_string(&EventFetchingStrategy::Curated).unwrap();
+        assert_eq!(json, r#""curated""#);
+        let parsed: EventFetchingStrategy = serde_json::from_str(r#""uncensored""#).unwrap();
+        assert_eq!(parsed, EventFetchingStrategy::Uncensored);
+    }
+}

crates/settings/src/store.rs

@@ -0,0 +1,156 @@
+use std::path::{Path, PathBuf};
+
+use anyhow::Result;
+use gpui::{App, Context, Entity, Global};
+
+use crate::Settings;
+
+struct GlobalSettingsStore(Entity<SettingsStore>);
+
+impl Global for GlobalSettingsStore {}
+
+/// The application settings,
+/// loaded from disk at startup and saved whenever they change.
+///
+/// Installed as a global by the app so any part of the UI can read and edit them.
+pub struct SettingsStore {
+    path: PathBuf,
+    settings: Settings,
+}
+
+impl SettingsStore {
+    /// Retrieve the global settings store, created at startup by the app.
+    pub fn global(cx: &App) -> Entity<Self> {
+        cx.global::<GlobalSettingsStore>().0.clone()
+    }
+
+    /// Retrieve the global settings store if one has been installed.
+    pub fn try_global(cx: &App) -> Option<Entity<Self>> {
+        cx.try_global::<GlobalSettingsStore>()
+            .map(|store| store.0.clone())
+    }
+
+    pub fn set_global(entity: Entity<Self>, cx: &mut App) {
+        cx.set_global(GlobalSettingsStore(entity));
+    }
+
+    /// Load the settings from `path`,
+    /// falls back to defaults when the file is missing or unreadable.
+    ///
+    /// Missing keys merge with the defaults,
+    /// older settings files keep working as new settings are added.
+    pub fn new(path: impl AsRef<Path>, _cx: &mut Context<Self>) -> Self {
+        Self {
+            path: path.as_ref().to_path_buf(),
+            settings: Self::load(path.as_ref()),
+        }
+    }
+
+    /// A snapshot of the current settings.
+    pub fn settings(&self) -> &Settings {
+        &self.settings
+    }
+
+    /// Mutate the settings, persist them to disk, and notify observers.
+    pub fn edit(&mut self, f: impl FnOnce(&mut Settings), cx: &mut Context<Self>) {
+        f(&mut self.settings);
+        if let Err(err) = self.save() {
+            log::error!(
+                "failed to save settings to {}: {err:#}",
+                self.path.display()
+            );
+        }
+        cx.notify();
+    }
+
+    /// Read the settings file, merging any missing fields with the defaults.
+    fn load(path: &Path) -> Settings {
+        match std::fs::read_to_string(path) {
+            Ok(contents) => match serde_json::from_str::<Settings>(&contents) {
+                Ok(settings) => settings,
+                Err(err) => {
+                    log::error!(
+                        "failed to parse settings file {}: {err}; using defaults",
+                        path.display()
+                    );
+                    Settings::default()
+                }
+            },
+            Err(err) if err.kind() == std::io::ErrorKind::NotFound => Settings::default(),
+            Err(err) => {
+                log::error!(
+                    "failed to read settings file {}: {err}; using defaults",
+                    path.display()
+                );
+                Settings::default()
+            }
+        }
+    }
+
+    /// Write the settings to disk, replacing the file atomically.
+    fn save(&self) -> Result<()> {
+        if let Some(parent) = self.path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        let json = serde_json::to_string_pretty(&self.settings)?;
+        let tmp = self.path.with_extension("json.tmp");
+        std::fs::write(&tmp, json)?;
+        // `rename` cannot replace an existing file on Windows.
+        if cfg!(target_os = "windows") && self.path.exists() {
+            std::fs::remove_file(&self.path)?;
+        }
+        std::fs::rename(&tmp, &self.path)?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    use super::*;
+
+    static TEST_FILE_COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+    /// A unique, temporary settings path for one test.
+    fn temp_settings_path() -> PathBuf {
+        let n = TEST_FILE_COUNTER.fetch_add(1, Ordering::SeqCst);
+        std::env::temp_dir().join(format!(
+            "signed-settings-test-{}-{n}.json",
+            std::process::id()
+        ))
+    }
+
+    fn cleanup(path: &Path) {
+        let _ = std::fs::remove_file(path);
+        let _ = std::fs::remove_file(path.with_extension("json.tmp"));
+    }
+
+    #[test]
+    fn missing_file_loads_defaults() {
+        let path = temp_settings_path();
+        cleanup(&path);
+
+        let settings = SettingsStore::load(&path);
+        assert_eq!(settings, Settings::default());
+        cleanup(&path);
+    }
+
+    #[test]
+    fn save_and_load_roundtrip() {
+        let path = temp_settings_path();
+        cleanup(&path);
+
+        let mut expected = Settings::default();
+        expected.create_repository.default_folder = Some(PathBuf::from("/tmp/repos"));
+
+        let store = SettingsStore {
+            path: path.clone(),
+            settings: expected.clone(),
+        };
+        store.save().unwrap();
+
+        assert_eq!(SettingsStore::load(&path), expected);
+        cleanup(&path);
+    }
+}

crates/signed_core/Cargo.toml

@@ -5,5 +5,6 @@ edition.workspace = true
 publish.workspace = true
 
 [dependencies]
-gpui.workspace = true
 nostr.workspace = true
+serde.workspace = true
+utils = { path = "../utils" }

crates/signed_core/src/addr.rs

@@ -1,13 +1,98 @@
+use std::fmt;
+use std::str::FromStr;
+
 use nostr::prelude::*;
+use serde::{Deserialize, Serialize};
 
-/// Address of a NIP-34 repository announcement: `30617:<owner-pubkey>:<repo-id>`.
-///
-/// The Rust Nostr SDK's [`Coordinate`] already provides parsing, formatting
-/// and hashing for this; the alias keeps the repository-specific vocabulary
-/// while reusing the SDK type.
-pub type RepoAddr = Coordinate;
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct RepoAddr(Coordinate);
 
-/// Build the address of a NIP-34 repository announcement.
-pub fn repo_addr(owner: PublicKey, id: impl Into<String>) -> RepoAddr {
-    Coordinate::new(Kind::GitRepoAnnouncement, owner).identifier(id)
+impl RepoAddr {
+    pub fn new(owner: PublicKey, identifier: impl Into<String>) -> Self {
+        Self(Coordinate::new(Kind::GitRepoAnnouncement, owner).identifier(identifier))
+    }
+
+    pub fn identifier_from_name(name: &str) -> String {
+        name.chars()
+            .map(|c| {
+                if c.is_ascii_alphanumeric() || c == '/' {
+                    c
+                } else {
+                    '-'
+                }
+            })
+            .collect()
+    }
+
+    pub fn kind(&self) -> Kind {
+        self.0.kind
+    }
+
+    pub fn public_key(&self) -> PublicKey {
+        self.0.public_key
+    }
+
+    pub fn identifier(&self) -> &str {
+        &self.0.identifier
+    }
+
+    pub fn coordinate(&self) -> &Coordinate {
+        &self.0
+    }
+
+    pub fn announcement_filter(&self) -> Filter {
+        Filter::new()
+            .kind(Kind::GitRepoAnnouncement)
+            .author(self.public_key())
+            .identifier(self.identifier())
+    }
+
+    pub fn state_filter(&self) -> Filter {
+        Filter::new()
+            .kind(Kind::RepoState)
+            .author(self.public_key())
+            .identifier(self.identifier())
+    }
+
+    pub fn activity_filter(&self) -> Filter {
+        Filter::new()
+            .kinds(crate::filters::ACTIVITY_KINDS)
+            .coordinate(&self.0)
+    }
+
+    pub fn deletion_filters(&self) -> Vec<Filter> {
+        vec![
+            Filter::new()
+                .kinds([Kind::EventDeletion, Kind::RequestToVanish])
+                .author(self.public_key()),
+            Filter::new().kind(Kind::EventDeletion).coordinate(&self.0),
+        ]
+    }
+}
+
+impl fmt::Display for RepoAddr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.0, f)
+    }
+}
+
+impl FromStr for RepoAddr {
+    type Err = <Coordinate as FromStr>::Err;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Coordinate::from_str(s).map(RepoAddr)
+    }
+}
+
+impl From<Coordinate> for RepoAddr {
+    fn from(coordinate: Coordinate) -> Self {
+        RepoAddr(coordinate)
+    }
+}
+
+impl From<RepoAddr> for Coordinate {
+    fn from(addr: RepoAddr) -> Self {
+        addr.0
+    }
 }

crates/signed_core/src/announcement.rs

@@ -0,0 +1,492 @@
+use std::collections::HashSet;
+
+use nostr::prelude::*;
+
+use crate::RepoAddr;
+use crate::upstream::Upstream;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Announcement {
+    pub event_id: EventId,
+    pub id: String,
+    pub owner: PublicKey,
+    pub created_at: Timestamp,
+    pub name: Option<String>,
+    pub description: Option<String>,
+    pub web: Vec<Url>,
+    pub clone: Vec<Url>,
+    pub relays: Vec<RelayUrl>,
+    pub euc: Option<String>,
+    pub maintainers: Vec<PublicKey>,
+    pub upstream: Option<Upstream>,
+    pub hashtags: Vec<String>,
+}
+
+impl Announcement {
+    /// Lists forks of the base, the user's own first.
+    pub fn forks_in<'a>(
+        announcements: &'a [Announcement],
+        base: &RepoAddr,
+        base_euc: Option<&str>,
+        user: Option<PublicKey>,
+    ) -> Vec<&'a Announcement> {
+        let (mut own, mut others) = (Vec::new(), Vec::new());
+        for announcement in announcements {
+            if announcement.clone.is_empty() || !announcement.is_fork_of(base, base_euc) {
+                continue;
+            }
+            if Some(announcement.owner) == user {
+                own.push(announcement);
+            } else {
+                others.push(announcement);
+            }
+        }
+        own.into_iter().chain(others).collect()
+    }
+
+    /// Parses a kind 30617 event, rejecting other kinds and missing `d` tags.
+    pub fn from_event(event: &Event) -> Option<Self> {
+        if event.kind != Kind::GitRepoAnnouncement {
+            return None;
+        }
+
+        let id = event.tags.identifier()?;
+
+        let mut hashtags: Vec<String> = Vec::new();
+        hashtags.extend(event.tags.hashtags().map(|t| t.to_string()));
+
+        let mut name: Option<String> = None;
+        let mut description: Option<String> = None;
+        let mut web: Vec<Url> = Vec::new();
+        let mut clone: Vec<Url> = Vec::new();
+        let mut relays: Vec<RelayUrl> = Vec::new();
+        let mut euc: Option<String> = None;
+        let mut maintainers: Vec<PublicKey> = Vec::new();
+        let mut upstream: Option<Upstream> = None;
+
+        for tag in event.tags.iter() {
+            match Nip34Tag::parse(tag.as_slice()) {
+                Ok(Nip34Tag::Name(value)) => name = Some(value),
+                Ok(Nip34Tag::Description(value)) => description = Some(value),
+                Ok(Nip34Tag::Web(urls)) => web.extend(urls),
+                Ok(Nip34Tag::Clone(urls)) => clone.extend(urls),
+                Ok(Nip34Tag::Relays(urls)) => relays.extend(urls),
+                Ok(Nip34Tag::EarliestUniqueCommitId(commit)) => euc = Some(commit.to_string()),
+                Ok(Nip34Tag::Maintainers(keys)) => maintainers.extend(keys),
+                _ => {}
+            }
+
+            if upstream.is_none() && tag.kind() == "u" {
+                let values = tag.as_slice();
+                let raw = values.get(1).map(String::as_str).unwrap_or_default();
+                if !raw.is_empty() {
+                    upstream = Some(Upstream::parse(raw));
+                }
+            }
+        }
+
+        Some(Self {
+            event_id: event.id,
+            owner: event.pubkey,
+            created_at: event.created_at,
+            id,
+            name,
+            description,
+            web,
+            clone,
+            relays,
+            euc,
+            maintainers,
+            upstream,
+            hashtags,
+        })
+    }
+
+    /// Returns the owner and identifier as a repository address.
+    pub fn addr(&self) -> RepoAddr {
+        RepoAddr::new(self.owner, self.id.clone())
+    }
+
+    /// Returns the name, defaulting to "Untitled".
+    pub fn name(&self) -> String {
+        self.name.clone().unwrap_or("Untitled".into())
+    }
+
+    /// Matches a `u` tag pointing at the base or a shared earliest unique commit.
+    pub fn is_fork_of(&self, base: &RepoAddr, base_euc: Option<&str>) -> bool {
+        if self.addr() == *base {
+            return false;
+        }
+        if self.upstream.as_ref().and_then(|u| u.addr.as_ref()) == Some(base) {
+            return true;
+        }
+        base_euc.is_some_and(|euc| self.euc.as_deref() == Some(euc))
+    }
+
+    /// Returns the description, defaulting to "No description".
+    pub fn description(&self) -> String {
+        self.description
+            .clone()
+            .unwrap_or("No description".to_string())
+    }
+
+    /// Adds the owner to the maintainers unless a `u` tag marks this a subordinate fork.
+    pub fn effective_maintainers(&self) -> Vec<PublicKey> {
+        let mut maintainers = self.maintainers.clone();
+        if self.upstream.is_none() && !maintainers.contains(&self.owner) {
+            maintainers.push(self.owner);
+        }
+        maintainers
+    }
+
+    /// Returns deduplicated `git clone` commands for the advertised URLs.
+    pub fn clone_urls(&self) -> Vec<String> {
+        let mut seen = HashSet::new();
+        self.clone
+            .iter()
+            .map(|url| format!("git clone {url}"))
+            .filter(|command| seen.insert(command.clone()))
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const MAINTAINER_HEX: &str = "68d81165918100b7da43fc28f7d1fc12554466e1115886b9e7bb326f65ec4272";
+
+    /// Returns the test signer keys.
+    fn keys() -> Keys {
+        Keys::new(
+            SecretKey::from_hex("0000000000000000000000000000000000000000000000000000000000000001")
+                .expect("valid secret key"),
+        )
+    }
+
+    /// Builds a signed repo announcement event from raw tags.
+    fn announcement_event(tags: &[&[&str]]) -> Event {
+        let tags: Vec<Tag> = tags
+            .iter()
+            .map(|t| Tag::parse(t.to_vec()).expect("valid tag"))
+            .collect();
+
+        EventBuilder::new(Kind::GitRepoAnnouncement, "")
+            .tags(tags)
+            .finalize(&keys())
+            .expect("signed event")
+    }
+
+    /// Parses an event carrying every supported tag.
+    #[test]
+    fn parses_full_announcement() {
+        let event = announcement_event(&[
+            &["d", "my-repo"],
+            &["name", "My Repo"],
+            &["description", "A test repository"],
+            &["web", "https://example.com/repo"],
+            &["clone", "https://example.com/repo.git"],
+            &["relays", "wss://relay.example.com"],
+            &["r", "aa231c4c6a5777dc89b42207b499891a344add5c", "euc"],
+            &["maintainers", MAINTAINER_HEX],
+            &["t", "rust"],
+            &["t", "nostr"],
+        ]);
+
+        let announcement = Announcement::from_event(&event).expect("parses");
+
+        assert_eq!(announcement.owner, keys().public_key());
+        assert_eq!(announcement.id, "my-repo");
+        assert_eq!(announcement.name.as_deref(), Some("My Repo"));
+        assert_eq!(
+            announcement.description.as_deref(),
+            Some("A test repository")
+        );
+        assert_eq!(
+            announcement.web,
+            vec![Url::parse("https://example.com/repo").unwrap()]
+        );
+        assert_eq!(
+            announcement.clone,
+            vec![Url::parse("https://example.com/repo.git").unwrap()]
+        );
+        assert_eq!(
+            announcement.relays,
+            vec![RelayUrl::parse("wss://relay.example.com").unwrap()]
+        );
+        assert_eq!(
+            announcement.euc.as_deref(),
+            Some("aa231c4c6a5777dc89b42207b499891a344add5c")
+        );
+        assert_eq!(
+            announcement.maintainers,
+            vec![PublicKey::from_hex(MAINTAINER_HEX).expect("valid pubkey")]
+        );
+        assert_eq!(announcement.hashtags, vec!["rust", "nostr"]);
+    }
+
+    /// Skips malformed clone, relay, and maintainer values.
+    #[test]
+    fn drops_malformed_values() {
+        let event = announcement_event(&[
+            &["d", "my-repo"],
+            &["clone", "not a url"],
+            &["relays", "wss://good.example.com"],
+            &["maintainers", "not-a-pubkey"],
+        ]);
+
+        let announcement = Announcement::from_event(&event).expect("parses");
+
+        assert!(announcement.clone.is_empty());
+        assert_eq!(
+            announcement.relays,
+            vec![RelayUrl::parse("wss://good.example.com").unwrap()]
+        );
+        assert!(announcement.maintainers.is_empty());
+    }
+
+    /// Parses the `u` tag into an upstream coordinate.
+    #[test]
+    fn parses_upstream_tag() {
+        let event = announcement_event(&[
+            &["d", "my-fork"],
+            &[
+                "u",
+                "30617:68d81165918100b7da43fc28f7d1fc12554466e1115886b9e7bb326f65ec4272:upstream|https://example.com/upstream.git",
+                "wss://relay.example.com",
+            ],
+        ]);
+
+        let announcement = Announcement::from_event(&event).expect("parses");
+        let upstream = announcement.upstream.expect("parses the u tag");
+
+        assert_eq!(
+            upstream.addr,
+            Some(RepoAddr::new(
+                PublicKey::from_hex(MAINTAINER_HEX).expect("valid pubkey"),
+                "upstream"
+            ))
+        );
+        assert_eq!(
+            upstream.raw,
+            "30617:68d81165918100b7da43fc28f7d1fc12554466e1115886b9e7bb326f65ec4272:upstream|https://example.com/upstream.git"
+        );
+        assert_eq!(
+            upstream.display().to_string(),
+            "30617:68d81165918100b7da43fc28f7d1fc12554466e1115886b9e7bb326f65ec4272:upstream"
+        );
+    }
+
+    /// Matches a fork through its `u` tag coordinate.
+    #[test]
+    fn is_fork_of_matches_the_u_tag_coordinate() {
+        let base = RepoAddr::new(
+            PublicKey::from_hex(MAINTAINER_HEX).expect("valid pubkey"),
+            "upstream",
+        );
+        let event = announcement_event(&[&["d", "my-fork"], &["u", &base.to_string()]]);
+        let fork = Announcement::from_event(&event).expect("parses");
+
+        assert!(fork.is_fork_of(&base, None));
+    }
+
+    /// Matches forks sharing the base's earliest unique commit.
+    #[test]
+    fn is_fork_of_matches_a_shared_euc() {
+        let euc = "aa231c4c6a5777dc89b42207b499891a344add5c";
+        let base_event = announcement_event(&[&["d", "upstream"], &["r", euc, "euc"]]);
+        let base = Announcement::from_event(&base_event).expect("parses");
+        let base_addr = base.addr();
+
+        let fork_event = announcement_event(&[&["d", "mirror"], &["r", euc, "euc"]]);
+        let fork = Announcement::from_event(&fork_event).expect("parses");
+        assert!(fork.is_fork_of(&base_addr, base.euc.as_deref()));
+
+        let other_event = announcement_event(&[
+            &["d", "other"],
+            &["r", "bb231c4c6a5777dc89b42207b499891a344add5c", "euc"],
+        ]);
+        let other = Announcement::from_event(&other_event).expect("parses");
+        assert!(!other.is_fork_of(&base_addr, base.euc.as_deref()));
+
+        assert!(!fork.is_fork_of(&base_addr, None));
+    }
+
+    /// Matches permanent forks whose `u` tag points at the base despite a diverged EUC.
+    #[test]
+    fn is_fork_of_matches_permanent_forks_with_a_diverged_euc() {
+        let base = RepoAddr::new(
+            PublicKey::from_hex(MAINTAINER_HEX).expect("valid pubkey"),
+            "upstream",
+        );
+        let base_euc = "aa231c4c6a5777dc89b42207b499891a344add5c";
+        let event = announcement_event(&[
+            &["d", "my-fork"],
+            &["u", &base.to_string()],
+            &["r", "cc231c4c6a5777dc89b42207b499891a344add5c", "euc"],
+        ]);
+        let fork = Announcement::from_event(&event).expect("parses");
+
+        assert!(fork.is_fork_of(&base, Some(base_euc)));
+    }
+
+    /// Includes the owner among maintainers for primary repositories.
+    #[test]
+    fn effective_maintainers_include_owner_for_primary_repos() {
+        let event = announcement_event(&[&["d", "my-repo"], &["maintainers", MAINTAINER_HEX]]);
+
+        let announcement = Announcement::from_event(&event).expect("parses");
+        let maintainers = announcement.effective_maintainers();
+
+        assert_eq!(maintainers.len(), 2);
+        assert!(maintainers.contains(&announcement.owner));
+        assert!(maintainers.contains(&PublicKey::from_hex(MAINTAINER_HEX).expect("valid pubkey")));
+    }
+
+    /// Excludes the owner from maintainers for subordinate forks.
+    #[test]
+    fn effective_maintainers_exclude_owner_for_subordinate_forks() {
+        let event = announcement_event(&[
+            &["d", "my-fork"],
+            &["u", "30617:abc:upstream|https://example.com/upstream.git"],
+            &["maintainers", MAINTAINER_HEX],
+        ]);
+
+        let announcement = Announcement::from_event(&event).expect("parses");
+        let maintainers = announcement.effective_maintainers();
+
+        assert!(!maintainers.contains(&announcement.owner));
+        assert_eq!(
+            maintainers,
+            vec![PublicKey::from_hex(MAINTAINER_HEX).expect("valid pubkey")]
+        );
+    }
+
+    const OWNER_KEYS: [&str; 3] = [
+        "0000000000000000000000000000000000000000000000000000000000000001",
+        "0000000000000000000000000000000000000000000000000000000000000002",
+        "0000000000000000000000000000000000000000000000000000000000000003",
+    ];
+
+    /// Builds an announcement event signed by the given owner key.
+    fn owned_announcement_event(owner: &str, tags: &[&[&str]]) -> Event {
+        let keys = Keys::new(SecretKey::from_hex(owner).expect("valid secret key"));
+        let tags: Vec<Tag> = tags
+            .iter()
+            .map(|t| Tag::parse(t.to_vec()).expect("valid tag"))
+            .collect();
+        EventBuilder::new(Kind::GitRepoAnnouncement, "")
+            .tags(tags)
+            .finalize(&keys)
+            .expect("signed event")
+    }
+
+    /// Builds one announcement owned by the owner key at the given index.
+    fn owned_announcements(owner_ix: usize, tags: &[&[&str]]) -> Vec<Announcement> {
+        vec![
+            Announcement::from_event(&owned_announcement_event(OWNER_KEYS[owner_ix], tags))
+                .expect("parses"),
+        ]
+    }
+
+    /// Places the user's own forks before everyone else's.
+    #[test]
+    fn fork_candidates_orders_own_forks_first() {
+        let euc = "aa231c4c6a5777dc89b42207b499891a344add5c";
+        let clone = "https://grasp.example/npub1x/my-fork.git";
+
+        let base_addr = RepoAddr::new(
+            PublicKey::from_hex(OWNER_KEYS[0]).expect("pubkey"),
+            "upstream",
+        );
+        let all = vec![
+            owned_announcements(
+                2,
+                &[
+                    &["d", "other-project"],
+                    &["r", "bb231c4c6a5777dc89b42207b499891a344add5c", "euc"],
+                ],
+            )
+            .pop()
+            .unwrap(),
+            owned_announcements(
+                1,
+                &[&["d", "my-fork"], &["r", euc, "euc"], &["clone", clone]],
+            )
+            .pop()
+            .unwrap(),
+            owned_announcements(
+                2,
+                &[
+                    &["d", "their-fork"],
+                    &["u", &base_addr.to_string()],
+                    &["clone", clone],
+                ],
+            )
+            .pop()
+            .unwrap(),
+        ];
+
+        let user = PublicKey::from_hex(OWNER_KEYS[1]).expect("pubkey");
+        let forks = Announcement::forks_in(&all, &base_addr, Some(euc), Some(user));
+
+        let ids: Vec<&str> = forks.iter().map(|a| a.id.as_str()).collect();
+        assert_eq!(ids, vec!["my-fork", "their-fork"]);
+    }
+
+    /// Excludes the base itself, unrelated repos, and repos without clone URLs.
+    #[test]
+    fn fork_candidates_excludes_base_unrelated_and_unfetchable() {
+        let euc = "aa231c4c6a5777dc89b42207b499891a344add5c";
+        let base_owner = PublicKey::from_hex(OWNER_KEYS[0]).expect("pubkey");
+        let base_addr = RepoAddr::new(base_owner, "upstream");
+
+        let mut all = vec![
+            owned_announcements(0, &[&["d", "upstream"], &["r", euc, "euc"]])
+                .pop()
+                .unwrap(),
+            owned_announcements(1, &[&["d", "no-clone-fork"], &["r", euc, "euc"]])
+                .pop()
+                .unwrap(),
+            owned_announcements(
+                2,
+                &[
+                    &["d", "other"],
+                    &["r", "cc231c4c6a5777dc89b42207b499891a344add5c", "euc"],
+                ],
+            )
+            .pop()
+            .unwrap(),
+            owned_announcements(
+                2,
+                &[
+                    &["d", "mirror"],
+                    &["r", euc, "euc"],
+                    &["clone", "https://grasp.example/x/mirror.git"],
+                ],
+            )
+            .pop()
+            .unwrap(),
+        ];
+
+        let forks = Announcement::forks_in(&all, &base_addr, Some(euc), Some(base_owner));
+        assert_eq!(forks.len(), 1);
+        assert_eq!(forks[0].id, "mirror");
+
+        all.push(
+            owned_announcements(
+                2,
+                &[
+                    &["d", "u-fork"],
+                    &["u", &base_addr.to_string()],
+                    &["clone", "https://grasp.example/x/u-fork.git"],
+                ],
+            )
+            .pop()
+            .unwrap(),
+        );
+        let forks = Announcement::forks_in(&all, &base_addr, None, Some(base_owner));
+        let ids: Vec<&str> = forks.iter().map(|a| a.id.as_str()).collect();
+        assert_eq!(ids, vec!["u-fork"]);
+    }
+}

crates/signed_core/src/clone_url.rs

@@ -1,116 +0,0 @@
-use nostr::prelude::*;
-
-use crate::RepoAddr;
-
-/// Target of a `nostr://` clone URL (NIP-34 "Nostr Clone URL format").
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum CloneTarget {
-    /// `nostr://<naddr1...>` — direct repository address.
-    Addr(RepoAddr),
-    /// `nostr://<npub|nip05>/[relay-hint/]<identifier>`
-    UserRepo {
-        /// `npub1...` or a NIP-05 identifier.
-        user: String,
-        relay_hint: Option<RelayUrl>,
-        /// `d` tag identifier of the repository.
-        identifier: String,
-    },
-}
-
-/// Parse a `nostr://` clone URL. Returns `None` for other URL schemes.
-pub fn parse_clone_url(url: &str) -> Option<CloneTarget> {
-    let rest = url.strip_prefix("nostr://")?;
-    let mut parts = rest.split('/');
-
-    let first = parts.next()?;
-    let second = parts.next()?;
-    let third = parts.next();
-
-    if first.starts_with("naddr1") {
-        let coordinate = Nip19Coordinate::from_bech32(first).ok()?;
-        return Some(CloneTarget::Addr(coordinate.coordinate));
-    }
-
-    let (relay_hint, identifier) = match third {
-        Some(id) => (
-            RelayUrl::parse(&percent_decode(second)).ok(),
-            percent_decode(id),
-        ),
-        None => (None, percent_decode(second)),
-    };
-
-    Some(CloneTarget::UserRepo {
-        user: first.to_owned(),
-        relay_hint,
-        identifier,
-    })
-}
-
-fn percent_decode(input: &str) -> String {
-    let bytes = input.as_bytes();
-    let mut out = Vec::with_capacity(bytes.len());
-    let mut i = 0;
-    while i < bytes.len() {
-        if bytes[i] == b'%' && i + 2 < bytes.len() {
-            let hex = &input[i + 1..i + 3];
-            if let Ok(v) = u8::from_str_radix(hex, 16) {
-                out.push(v);
-                i += 3;
-                continue;
-            }
-        }
-        out.push(bytes[i]);
-        i += 1;
-    }
-    String::from_utf8_lossy(&out).into_owned()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn parses_user_repo_without_relay() {
-        let target = parse_clone_url(
-            "nostr://npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/ngit",
-        )
-        .unwrap();
-        assert_eq!(
-            target,
-            CloneTarget::UserRepo {
-                user: "npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr".to_owned(),
-                relay_hint: None,
-                identifier: "ngit".to_owned(),
-            }
-        );
-    }
-
-    #[test]
-    fn parses_user_repo_with_relay_hint() {
-        let target = parse_clone_url("nostr://danconwaydev.com/relay.ngit.dev/ngit").unwrap();
-        assert_eq!(
-            target,
-            CloneTarget::UserRepo {
-                user: "danconwaydev.com".to_owned(),
-                relay_hint: RelayUrl::parse("relay.ngit.dev").ok(),
-                identifier: "ngit".to_owned(),
-            }
-        );
-    }
-
-    #[test]
-    fn decodes_percent_encoded_parts() {
-        let target = parse_clone_url(
-            "nostr://danconwaydev.com/ws%3A%2F%2Flocalhost%3A7334/my-local-only-repo",
-        )
-        .unwrap();
-        assert_eq!(
-            target,
-            CloneTarget::UserRepo {
-                user: "danconwaydev.com".to_owned(),
-                relay_hint: RelayUrl::parse("ws://localhost:7334").ok(),
-                identifier: "my-local-only-repo".to_owned(),
-            }
-        );
-    }
-}

crates/signed_core/src/deletions.rs

@@ -2,24 +2,18 @@ use std::collections::HashSet;
 
 use nostr::prelude::*;
 
-/// NIP-09 deletion requests and NIP-62 vanish requests, used to hide
-/// deleted events before they reach the UI.
-///
-/// Built from the kind-5 / kind-62 events stored in the local database;
-/// pass any event through [`Deletions::is_deleted`] before displaying it.
 pub struct Deletions {
-    /// `(deleted event id, expected author)` from `e` tags of kind-5 events.
     ids: HashSet<(EventId, PublicKey)>,
-    /// `(coordinate, expected author, cutoff)` from `a` tags of kind-5 events.
-    /// All versions of the addressable event up to `cutoff` are deleted.
     coords: Vec<(Coordinate, PublicKey, Timestamp)>,
-    /// `(author, cutoff)` from kind-62 vanish requests.
     vanished: Vec<(PublicKey, Timestamp)>,
 }
 
 impl Deletions {
-    /// Build the deletion index from raw kind-5 and kind-62 events.
-    pub fn from_events(events: impl IntoIterator<Item = Event>) -> Self {
+    /// Builds a [`Deletions`] instance from a collection of events.
+    pub fn from_events<E>(events: E) -> Self
+    where
+        E: IntoIterator<Item = Event>,
+    {
         let mut ids = HashSet::new();
         let mut coords = Vec::new();
         let mut vanished = Vec::new();
@@ -34,8 +28,6 @@ impl Deletions {
                         .map(|c| (c, event.pubkey, event.created_at)),
                 );
             } else if event.kind == Kind::RequestToVanish {
-                // Client-side we can't verify which relay the request targeted,
-                // so any vanish request is honored for the author's events.
                 vanished.push((event.pubkey, event.created_at));
             }
         }
@@ -47,11 +39,7 @@ impl Deletions {
         }
     }
 
-    /// Whether the event is covered by a valid deletion or vanish request.
-    ///
-    /// A request is only valid when its author matches the deleted event's
-    /// author (NIP-09); addressable events are deleted up to the request's
-    /// `created_at`.
+    /// Returns whether the given event is deleted.
     pub fn is_deleted(&self, event: &Event) -> bool {
         if self
             .vanished

crates/signed_core/src/filters.rs

@@ -1,9 +1,9 @@
+use std::time::Duration;
+
 use nostr::prelude::*;
 
-use crate::RepoAddr;
-
-/// Kinds that make up the activity of a repository.
-pub const ACTIVITY_KINDS: [Kind; 8] = [
+pub const ACTIVITY_KINDS: [Kind; 9] = [
+    Kind::Comment,
     Kind::GitPatch,
     Kind::GitPullRequest,
     Kind::GitPullRequestUpdate,
@@ -14,81 +14,215 @@ pub const ACTIVITY_KINDS: [Kind; 8] = [
     Kind::GitStatusDraft,
 ];
 
-/// Latest announcement event for a repository.
-pub fn announcement(addr: &RepoAddr) -> Filter {
-    Filter::new()
-        .kind(Kind::GitRepoAnnouncement)
-        .author(addr.public_key)
-        .identifier(addr.identifier.clone())
+const NOTIFICATION_KINDS: [Kind; 8] = [
+    Kind::GitIssue,
+    Kind::GitPullRequest,
+    Kind::GitPatch,
+    Kind::GitPullRequestUpdate,
+    Kind::GitStatusOpen,
+    Kind::GitStatusApplied,
+    Kind::GitStatusClosed,
+    Kind::GitStatusDraft,
+];
+
+const GIT_ROOT_KINDS: [Kind; 4] = [
+    Kind::GitIssue,
+    Kind::GitPatch,
+    Kind::GitPullRequest,
+    Kind::GitRepoAnnouncement,
+];
+
+pub fn is_repo_kind(kind: Kind) -> bool {
+    kind == Kind::GitRepoAnnouncement
+        || kind == Kind::RepoState
+        || kind == Kind::EventDeletion
+        || kind == Kind::RequestToVanish
+        || ACTIVITY_KINDS.contains(&kind)
 }
 
-/// Latest state event (refs / HEAD) for a repository.
-pub fn state(addr: &RepoAddr) -> Filter {
-    Filter::new()
-        .kind(Kind::RepoState)
-        .author(addr.public_key)
-        .identifier(addr.identifier.clone())
+fn tag_kind(event: &Event, name: &str) -> Option<Kind> {
+    event
+        .tags
+        .iter()
+        .find(|tag| tag.kind() == name)
+        .and_then(|tag| tag.content())
+        .and_then(|value| value.parse::<Kind>().ok())
 }
 
-/// All NIP-34 activity addressed to a repository (`#a` tag).
-///
-/// Note: the `a` tag on status events is optional per NIP-34, so statuses
-/// published without it won't be matched here.
-pub fn activity(addr: &RepoAddr) -> Filter {
-    Filter::new().kinds(ACTIVITY_KINDS).coordinate(addr)
-}
+pub struct Filters;
 
-/// Status events (`1630..=1633`) referencing a specific root event (`#e` tag).
-pub fn statuses_for(root: EventId) -> Filter {
-    Filter::new()
-        .kinds([
-            Kind::GitStatusOpen,
-            Kind::GitStatusApplied,
-            Kind::GitStatusClosed,
-            Kind::GitStatusDraft,
-        ])
-        .event(root)
-}
+impl Filters {
+    const DELETIONS_LOOKBACK: Duration = Duration::from_secs(3 * 365 * 86_400);
 
-/// A user's grasp list (kind `10317`).
-pub fn grasp_list(public_key: PublicKey) -> Filter {
-    Filter::new()
-        .kind(Kind::GitUserGraspList)
-        .author(public_key)
-}
+    pub fn statuses_for(roots: impl IntoIterator<Item = EventId>) -> Filter {
+        Filter::new()
+            .kinds([
+                Kind::GitStatusOpen,
+                Kind::GitStatusApplied,
+                Kind::GitStatusClosed,
+                Kind::GitStatusDraft,
+            ])
+            .events(roots)
+    }
 
-/// All repositories announced by an author.
-pub fn announcements_by(public_key: PublicKey) -> Filter {
-    Filter::new()
-        .kind(Kind::GitRepoAnnouncement)
-        .author(public_key)
-}
+    pub fn grasp_list(public_key: PublicKey) -> Filter {
+        Filter::new()
+            .kind(Kind::GitUserGraspList)
+            .author(public_key)
+    }
 
-/// All repository announcements (for global discovery).
-///
-/// Unbounded: intended for negentropy sync, which reconciles sets
-/// efficiently regardless of size. Local database queries with this
-/// filter are served by LMDB, so they stay fast as the database grows.
-pub fn all_announcements() -> Filter {
-    Filter::new().kind(Kind::GitRepoAnnouncement)
-}
+    /// NIP-51: code (people who produce NIP-34 events) follow list
+    pub fn git_authors(public_key: PublicKey) -> Filter {
+        Filter::new().kind(Kind::Custom(10017)).author(public_key)
+    }
 
-/// All deletion-related events (NIP-09 kind `5`, NIP-62 kind `62`).
-///
-/// Unbounded, like [`all_announcements`]: deletion requests must be known
-/// before any other event can be shown.
-pub fn deletions() -> Filter {
-    Filter::new().kinds([Kind::EventDeletion, Kind::RequestToVanish])
-}
+    /// NIP-51: NIP-34 followed repositories
+    pub fn git_repos(public_key: PublicKey) -> Filter {
+        Filter::new().kind(Kind::Custom(10018)).author(public_key)
+    }
 
-/// Deletion events relevant to a single repository: requests authored by
-/// the repository owner and requests addressed to the repository
-/// coordinate (`#a` tag).
-pub fn deletions_for_repo(addr: &RepoAddr) -> Vec<Filter> {
-    vec![
+    /// Replaceable events, so the latest of each kind is all we need.
+    pub fn user_metadata(public_key: PublicKey) -> Vec<Filter> {
+        vec![
+            Self::grasp_list(public_key).limit(1),
+            Self::git_authors(public_key).limit(1),
+            Self::git_repos(public_key).limit(1),
+            Filter::new()
+                .kind(Kind::ContactList)
+                .author(public_key)
+                .limit(1),
+            Filter::new()
+                .kind(Kind::Metadata)
+                .author(public_key)
+                .limit(1),
+            Filter::new()
+                .kind(Kind::MuteList)
+                .author(public_key)
+                .limit(1),
+            Filter::new()
+                .kind(Kind::BlossomServerList)
+                .author(public_key)
+                .limit(1),
+        ]
+    }
+
+    pub fn comments_for(roots: impl IntoIterator<Item = EventId>) -> Vec<Filter> {
+        let roots: Vec<String> = roots.into_iter().map(|id| id.to_hex()).collect();
+
+        if roots.is_empty() {
+            return Vec::new();
+        }
+
+        vec![
+            Filter::new()
+                .kind(Kind::Comment)
+                .custom_tags(SingleLetterTag::UPPERCASE_E, roots.clone()),
+            Filter::new()
+                .kind(Kind::Comment)
+                .custom_tags(SingleLetterTag::LOWERCASE_E, roots),
+        ]
+    }
+
+    fn notification_comments(me: PublicKey) -> Filter {
+        Filter::new()
+            .kind(Kind::Comment)
+            .custom_tags(SingleLetterTag::UPPERCASE_P, [me.to_hex()])
+            .custom_tags(SingleLetterTag::UPPERCASE_K, ["1621", "1617", "1618"])
+    }
+
+    pub fn notifications(me: PublicKey) -> Vec<Filter> {
+        vec![
+            Self::notification_comments(me),
+            Filter::new().kinds(NOTIFICATION_KINDS).pubkey(me),
+        ]
+    }
+
+    pub fn authored_activity(me: PublicKey) -> Filter {
+        Filter::new().kinds(ACTIVITY_KINDS).author(me)
+    }
+
+    pub fn all_announcements() -> Filter {
+        Filter::new().kind(Kind::GitRepoAnnouncement)
+    }
+
+    pub fn all_states() -> Filter {
+        Filter::new().kind(Kind::RepoState)
+    }
+
+    fn deletions_since() -> Timestamp {
+        let now = Timestamp::now().as_secs();
+        Timestamp::from_secs(now - now % 86_400) - Self::DELETIONS_LOOKBACK
+    }
+
+    pub fn deletions() -> Filter {
         Filter::new()
             .kinds([Kind::EventDeletion, Kind::RequestToVanish])
-            .author(addr.public_key),
-        Filter::new().kind(Kind::EventDeletion).coordinate(addr),
-    ]
+            .since(Self::deletions_since())
+    }
+}
+
+pub(crate) fn is_git_comment(event: &Event) -> bool {
+    event.kind == Kind::Comment
+        && tag_kind(event, "K").is_some_and(|kind| GIT_ROOT_KINDS.contains(&kind))
+}
+
+pub(crate) fn is_git_status(event: &Event) -> bool {
+    tag_kind(event, "k").is_some_and(|kind| GIT_ROOT_KINDS.contains(&kind))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::GitEvent;
+
+    fn keys(seed: u8) -> Keys {
+        let mut hex = "00000000000000000000000000000000000000000000000000000000000000".to_string();
+        hex.push_str(&format!("{seed:02x}"));
+        Keys::new(SecretKey::from_hex(&hex).expect("valid secret key"))
+    }
+
+    fn signed(author: &Keys, kind: Kind, tags: Vec<Tag>) -> Event {
+        EventBuilder::new(kind, "")
+            .tags(tags)
+            .finalize(author)
+            .expect("signed event")
+    }
+
+    fn kind_tag(name: &str, kind: Kind) -> Tag {
+        Tag::parse([name, &kind.as_u16().to_string()]).expect("valid kind tag")
+    }
+
+    #[test]
+    fn comment_activity_depends_on_the_uppercase_k_tag() {
+        let on_git = signed(&keys(1), Kind::Comment, vec![kind_tag("K", Kind::GitIssue)]);
+        let on_repo = signed(
+            &keys(1),
+            Kind::Comment,
+            vec![kind_tag("K", Kind::GitRepoAnnouncement)],
+        );
+        let on_note = signed(&keys(1), Kind::Comment, vec![kind_tag("K", Kind::TextNote)]);
+
+        assert!(on_git.is_git_activity());
+        assert!(on_repo.is_git_activity());
+        assert!(!on_note.is_git_activity());
+        assert!(!signed(&keys(1), Kind::Comment, Vec::new()).is_git_activity());
+    }
+
+    #[test]
+    fn status_activity_depends_on_the_lowercase_k_tag() {
+        let status = signed(
+            &keys(1),
+            Kind::GitStatusClosed,
+            vec![kind_tag("k", Kind::GitPullRequest)],
+        );
+        let unrelated = signed(
+            &keys(1),
+            Kind::GitStatusClosed,
+            vec![kind_tag("k", Kind::Metadata)],
+        );
+
+        assert!(status.is_git_activity());
+        assert!(!unrelated.is_git_activity());
+        assert!(!signed(&keys(1), Kind::GitStatusClosed, Vec::new()).is_git_activity());
+    }
 }

crates/signed_core/src/git_event.rs

@@ -0,0 +1,145 @@
+use nostr::prelude::*;
+
+pub trait GitEvent {
+    /// Returns the NIP-34 subject or the first non-empty content line.
+    fn activity_subject(&self) -> String;
+
+    /// Returns the current commit id.
+    fn current_commit(&self) -> Option<String>;
+
+    /// Returns the merge base commit id.
+    fn merge_base(&self) -> Option<String>;
+
+    /// Returns the advertised clone URLs.
+    fn clone_urls(&self) -> Option<Vec<Url>>;
+
+    /// Returns the branch name.
+    fn branch_name(&self) -> Option<String>;
+
+    /// Returns whether the event is git activity.
+    fn is_git_activity(&self) -> bool;
+
+    /// Returns whether an `e` or `E` tag points at the root event.
+    fn references_root(&self, root: &EventId) -> bool;
+}
+
+impl GitEvent for Event {
+    /// Reads the subject tag, then the first content line, then "Untitled".
+    fn activity_subject(&self) -> String {
+        let subject = self
+            .tags
+            .iter()
+            .find_map(|tag| match Nip34Tag::parse(tag.as_slice()) {
+                Ok(Nip34Tag::Subject(subject)) => Some(subject),
+                _ => None,
+            });
+
+        subject
+            .or_else(|| {
+                self.content
+                    .lines()
+                    .map(str::trim)
+                    .find(|line| !line.is_empty())
+                    .map(|value| value.to_string())
+            })
+            .unwrap_or("Untitled".to_string())
+    }
+
+    /// Reads the `commit` tag.
+    fn current_commit(&self) -> Option<String> {
+        self.tags
+            .iter()
+            .find_map(|tag| match Nip34Tag::parse(tag.as_slice()) {
+                Ok(Nip34Tag::CurrentCommit(commit)) => Some(commit.to_string()),
+                _ => None,
+            })
+    }
+
+    /// Reads the `merge-base` tag.
+    fn merge_base(&self) -> Option<String> {
+        self.tags
+            .iter()
+            .find_map(|tag| match Nip34Tag::parse(tag.as_slice()) {
+                Ok(Nip34Tag::MergeBase(commit)) => Some(commit.to_string()),
+                _ => None,
+            })
+    }
+
+    /// Reads the `clone` tag.
+    fn clone_urls(&self) -> Option<Vec<Url>> {
+        self.tags
+            .iter()
+            .find_map(|tag| match Nip34Tag::parse(tag.as_slice()) {
+                Ok(Nip34Tag::Clone(urls)) => Some(urls),
+                _ => None,
+            })
+    }
+
+    /// Reads the `branch-name` tag.
+    fn branch_name(&self) -> Option<String> {
+        self.tags
+            .iter()
+            .find_map(|tag| match Nip34Tag::parse(tag.as_slice()) {
+                Ok(Nip34Tag::BranchName(name)) => Some(name),
+                _ => None,
+            })
+    }
+
+    /// Classifies git issue, patch, pull request, comment, and status kinds.
+    fn is_git_activity(&self) -> bool {
+        match self.kind {
+            Kind::GitIssue | Kind::GitPatch | Kind::GitPullRequest => true,
+            Kind::Comment => crate::filters::is_git_comment(self),
+            Kind::GitStatusOpen
+            | Kind::GitStatusApplied
+            | Kind::GitStatusClosed
+            | Kind::GitStatusDraft => crate::filters::is_git_status(self),
+            _ => false,
+        }
+    }
+
+    /// Compares `e` and `E` tag contents against the root id.
+    fn references_root(&self, root: &EventId) -> bool {
+        let root = root.to_hex();
+        self.tags
+            .iter()
+            .any(|tag| matches!(tag.kind(), "e" | "E") && tag.content() == Some(root.as_str()))
+    }
+}
+
+impl<T: GitEvent + ?Sized> GitEvent for &T {
+    /// Delegates to the referenced event.
+    fn activity_subject(&self) -> String {
+        (*self).activity_subject()
+    }
+
+    /// Delegates to the referenced event.
+    fn current_commit(&self) -> Option<String> {
+        (*self).current_commit()
+    }
+
+    /// Delegates to the referenced event.
+    fn merge_base(&self) -> Option<String> {
+        (*self).merge_base()
+    }
+
+    /// Delegates to the referenced event.
+    fn clone_urls(&self) -> Option<Vec<Url>> {
+        (*self).clone_urls()
+    }
+
+    /// Delegates to the referenced event.
+    fn branch_name(&self) -> Option<String> {
+        (*self).branch_name()
+    }
+
+    /// Delegates to the referenced event.
+    fn is_git_activity(&self) -> bool {
+        (*self).is_git_activity()
+    }
+
+    /// Delegates to the referenced event.
+    fn references_root(&self, root: &EventId) -> bool {
+        (*self).references_root(root)
+    }
+}

crates/signed_core/src/inbox/group.rs

@@ -0,0 +1,172 @@
+use std::collections::HashMap;
+
+use nostr::prelude::*;
+use utils::sort_newest_first;
+
+use super::{InboxItem, InboxReadState, ThreadResolver};
+use crate::RepoAddr;
+
+/// Groups events into inbox threads, merging the user's own events.
+pub fn group<E, O, L>(
+    events: E,
+    own: O,
+    me: PublicKey,
+    state: &InboxReadState,
+    lookup: &L,
+) -> Vec<InboxItem>
+where
+    E: IntoIterator<Item = Event>,
+    O: IntoIterator<Item = Event>,
+    L: Fn(EventId) -> Option<Event>,
+{
+    let resolver = ThreadResolver::new(lookup);
+    let mut groups: HashMap<EventId, Vec<Event>> = HashMap::new();
+    for event in events {
+        if event.pubkey == me {
+            continue;
+        }
+        let Some(root) = resolver.notification_root(&event) else {
+            continue;
+        };
+        groups.entry(root).or_default().push(event);
+    }
+
+    let mut own_groups: HashMap<EventId, Vec<Event>> = HashMap::new();
+    for event in own {
+        let root = resolver.notification_root(&event).unwrap_or(event.id);
+        own_groups.entry(root).or_default().push(event);
+    }
+
+    let mut roots: Vec<EventId> = groups.keys().chain(own_groups.keys()).copied().collect();
+    roots.sort();
+    roots.dedup();
+
+    let mut items: Vec<InboxItem> = roots
+        .into_iter()
+        .map(|root| {
+            let mut events = groups.remove(&root).unwrap_or_default();
+            let mut own_events = own_groups.remove(&root).unwrap_or_default();
+            sort_newest_first(&mut events);
+            sort_newest_first(&mut own_events);
+
+            let root_event = lookup(root);
+
+            let mut item = InboxItem {
+                root,
+                address: root_event
+                    .as_ref()
+                    .and_then(|event| event.tags.coordinates().next())
+                    .map(RepoAddr::from),
+                root_event,
+                events,
+                own_events,
+                unread_ids: Vec::new(),
+                archived: false,
+            };
+            item.apply_state(state);
+            item
+        })
+        .collect();
+
+    items.sort_by(|a, b| {
+        b.latest_activity()
+            .cmp(&a.latest_activity())
+            .then_with(|| b.root.to_hex().cmp(&a.root.to_hex()))
+    });
+
+    items
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Derives deterministic signer keys from a seed byte.
+    fn keys(seed: u8) -> Keys {
+        let mut hex = "00000000000000000000000000000000000000000000000000000000000000".to_string();
+        hex.push_str(&format!("{seed:02x}"));
+        Keys::new(SecretKey::from_hex(&hex).expect("valid secret key"))
+    }
+
+    /// Builds a signed event with a fixed timestamp.
+    fn signed(author: &Keys, kind: Kind, tags: Vec<Tag>, created_at: u64) -> Event {
+        EventBuilder::new(kind, "")
+            .tags(tags)
+            .custom_created_at(Timestamp::from_secs(created_at))
+            .finalize(author)
+            .expect("signed event")
+    }
+
+    /// Builds an uppercase `E` tag for the event.
+    fn uppercase_e_tag(event: &Event) -> Tag {
+        Tag::parse(["E", &event.id.to_hex()]).expect("valid E tag")
+    }
+
+    /// Builds an event lookup closure over a slice.
+    fn lookup(events: &[Event]) -> impl Fn(EventId) -> Option<Event> + '_ {
+        move |id| events.iter().find(|event| event.id == id).cloned()
+    }
+
+    /// Builds a git issue event with a subject tag.
+    fn titled_issue(author: &Keys, title: &str, at: u64) -> Event {
+        signed(
+            author,
+            Kind::GitIssue,
+            vec![Tag::parse(["subject", title]).expect("valid subject tag")],
+            at,
+        )
+    }
+
+    /// Merges the user's own events into the matching thread.
+    #[test]
+    fn group_merges_own_events_into_the_matching_thread() {
+        let me = keys(1);
+        let issue = titled_issue(&me, "Add retry logic", 100);
+        let mine = signed(
+            &me,
+            Kind::Comment,
+            vec![
+                uppercase_e_tag(&issue),
+                Tag::parse(["K", "1621"]).expect("K tag"),
+            ],
+            150,
+        );
+        let reply = signed(
+            &keys(2),
+            Kind::Comment,
+            vec![
+                uppercase_e_tag(&issue),
+                Tag::parse(["K", "1621"]).expect("K tag"),
+            ],
+            200,
+        );
+
+        let context = [issue.clone(), mine.clone(), reply.clone()];
+        let items = group(
+            [reply.clone()],
+            [issue.clone(), mine.clone()],
+            me.public_key(),
+            &InboxReadState::default(),
+            &lookup(&context),
+        );
+
+        assert_eq!(items.len(), 1);
+        assert_eq!(items[0].root, issue.id);
+        assert_eq!(
+            items[0].root_event.as_ref().map(|event| event.id),
+            Some(issue.id)
+        );
+        assert_eq!(items[0].kind(), Some(Kind::GitIssue));
+        assert_eq!(items[0].title(), "Add retry logic");
+        assert_eq!(items[0].events, vec![reply.clone()]);
+        assert_eq!(items[0].own_events, vec![mine.clone(), issue.clone()]);
+        assert_eq!(
+            items[0]
+                .timeline(5)
+                .iter()
+                .map(|event| event.id)
+                .collect::<Vec<_>>(),
+            vec![issue.id, mine.id, reply.id]
+        );
+    }
+}

crates/signed_core/src/inbox/item.rs

@@ -0,0 +1,99 @@
+use std::collections::HashSet;
+
+use nostr::prelude::*;
+
+use super::InboxReadState;
+use crate::{GitEvent, RepoAddr};
+
+#[derive(Debug, Clone)]
+pub struct InboxItem {
+    pub root: EventId,
+    pub root_event: Option<Event>,
+    pub address: Option<RepoAddr>,
+    pub events: Vec<Event>,
+    pub own_events: Vec<Event>,
+    pub unread_ids: Vec<EventId>,
+    pub archived: bool,
+}
+
+impl InboxItem {
+    /// Returns the thread title from the root, own events, or events.
+    pub fn title(&self) -> String {
+        self.root_event
+            .as_ref()
+            .or_else(|| self.own_events.first())
+            .or_else(|| self.events.first())
+            .map(|event| event.activity_subject())
+            .unwrap_or_else(|| "Untitled".to_string())
+    }
+
+    /// Returns the kind of the thread's primary event.
+    pub fn kind(&self) -> Option<Kind> {
+        self.root_event
+            .as_ref()
+            .or_else(|| self.own_events.first())
+            .or_else(|| self.events.first())
+            .map(|event| event.kind)
+    }
+
+    /// Returns the newest timestamp among the root, own, and other events.
+    pub fn latest_activity(&self) -> Timestamp {
+        self.root_event
+            .as_ref()
+            .into_iter()
+            .chain(self.own_events.first())
+            .chain(self.events.first())
+            .map(|event| event.created_at)
+            .max()
+            .unwrap_or_default()
+    }
+
+    /// Builds a chronological timeline capped at `limit` events, root first.
+    pub fn timeline(&self, limit: usize) -> Vec<Event> {
+        let mut seen: HashSet<EventId> = HashSet::new();
+        let mut events: Vec<Event> = Vec::new();
+
+        if let Some(root) = &self.root_event {
+            seen.insert(root.id);
+            events.push(root.clone());
+        }
+
+        let mut rest: Vec<Event> = self
+            .own_events
+            .iter()
+            .chain(self.events.iter())
+            .filter(|event| seen.insert(event.id))
+            .cloned()
+            .collect();
+
+        rest.sort_by(|a, b| {
+            b.created_at
+                .cmp(&a.created_at)
+                .then_with(|| b.id.to_hex().cmp(&a.id.to_hex()))
+        });
+        rest.truncate(limit.saturating_sub(events.len()));
+        events.extend(rest);
+
+        events.sort_by_key(|event| event.created_at);
+        events
+    }
+
+    /// Returns whether the thread has unread events and is not archived.
+    pub fn is_unread(&self) -> bool {
+        !self.archived && !self.unread_ids.is_empty()
+    }
+
+    /// Recomputes unread ids and the archived flag from the read state.
+    pub fn apply_state(&mut self, state: &InboxReadState) {
+        self.unread_ids = self
+            .events
+            .iter()
+            .rev()
+            .filter(|event| !state.is_read(event))
+            .map(|event| event.id)
+            .collect();
+
+        self.archived =
+            !self.events.is_empty() && self.events.iter().all(|event| state.is_archived(event));
+    }
+}

crates/signed_core/src/inbox/mod.rs

@@ -0,0 +1,9 @@
+mod group;
+mod item;
+mod read_state;
+mod resolver;
+
+pub use group::group;
+pub use item::InboxItem;
+pub use read_state::InboxReadState;
+pub use resolver::ThreadResolver;

crates/signed_core/src/inbox/read_state.rs

@@ -0,0 +1,109 @@
+use std::collections::{HashMap, HashSet};
+use std::time::Duration;
+
+use nostr::prelude::*;
+use serde::{Deserialize, Serialize};
+
+const ADVANCE_WINDOW: Duration = Duration::from_secs(3 * 24 * 60 * 60);
+const MARK_ALL_WINDOW: Duration = Duration::from_secs(10 * 24 * 60 * 60);
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct InboxReadState {
+    #[serde(default)]
+    pub read_before: Timestamp,
+    #[serde(default)]
+    pub read_ids: HashSet<EventId>,
+    #[serde(default)]
+    pub archived_before: Timestamp,
+    #[serde(default)]
+    pub archived_ids: HashSet<EventId>,
+}
+
+impl InboxReadState {
+    /// Returns whether the event falls under the read high-water mark or id set.
+    pub fn is_read(&self, event: &Event) -> bool {
+        event.created_at <= self.read_before || self.read_ids.contains(&event.id)
+    }
+
+    /// Returns whether the event falls under the archived high-water mark or id set.
+    pub fn is_archived(&self, event: &Event) -> bool {
+        event.created_at <= self.archived_before || self.archived_ids.contains(&event.id)
+    }
+
+    /// Records the event as read when it is past the current cutoff.
+    pub fn mark_read(&mut self, event: &Event) {
+        if event.created_at > self.read_before {
+            self.read_ids.insert(event.id);
+        }
+    }
+
+    /// Records the event as archived when it is past the current cutoff.
+    pub fn mark_archived(&mut self, event: &Event) {
+        if event.created_at > self.archived_before {
+            self.archived_ids.insert(event.id);
+        }
+    }
+
+    /// Marks all events from other authors within the window as read.
+    pub fn mark_all_read(&mut self, all: &[Event], me: PublicKey, now: Timestamp) {
+        let cutoff = now - MARK_ALL_WINDOW;
+        self.read_before = cutoff;
+        self.read_ids = all
+            .iter()
+            .filter(|event| event.pubkey != me && event.created_at > cutoff)
+            .map(|event| event.id)
+            .collect();
+    }
+
+    /// Advances the read cutoff as far as possible, then prunes the id set.
+    pub fn advance_read(&mut self, all: &[Event], me: PublicKey, now: Timestamp) {
+        let cutoff = advance_cutoff(all, me, now, self.read_before, |event| self.is_read(event));
+        self.read_before = cutoff;
+        prune_ids(&mut self.read_ids, all, cutoff);
+    }
+
+    /// Advances the archived cutoff as far as possible, then prunes the id set.
+    pub fn advance_archived(&mut self, all: &[Event], me: PublicKey, now: Timestamp) {
+        let cutoff = advance_cutoff(all, me, now, self.archived_before, |event| {
+            self.is_archived(event)
+        });
+        self.archived_before = cutoff;
+        prune_ids(&mut self.archived_ids, all, cutoff);
+    }
+}
+
+/// Computes the newest cutoff that leaves unmarked events uncovered.
+fn advance_cutoff<M>(
+    all: &[Event],
+    me: PublicKey,
+    now: Timestamp,
+    current: Timestamp,
+    is_marked: M,
+) -> Timestamp
+where
+    M: Fn(&Event) -> bool,
+{
+    let fallback = now - ADVANCE_WINDOW;
+
+    let oldest = all
+        .iter()
+        .filter(|event| event.pubkey != me && !is_marked(event))
+        .map(|event| event.created_at)
+        .min();
+
+    let candidate = match oldest {
+        Some(at) if at < fallback => at - 1,
+        _ => fallback,
+    };
+
+    candidate.max(current)
+}
+
+/// Drops ids whose events predate the cutoff.
+fn prune_ids(ids: &mut HashSet<EventId>, all: &[Event], cutoff: Timestamp) {
+    let created_at: HashMap<EventId, Timestamp> = all
+        .iter()
+        .map(|event| (event.id, event.created_at))
+        .collect();
+    ids.retain(|id| created_at.get(id).is_some_and(|at| *at >= cutoff));
+}

crates/signed_core/src/inbox/resolver.rs

@@ -0,0 +1,249 @@
+use std::collections::HashSet;
+
+use nostr::prelude::*;
+
+pub struct ThreadResolver<'a, L: ?Sized> {
+    lookup: &'a L,
+}
+
+impl<'a, L> ThreadResolver<'a, L>
+where
+    L: Fn(EventId) -> Option<Event> + ?Sized,
+{
+    /// Creates a resolver over the given event lookup.
+    pub fn new(lookup: &'a L) -> Self {
+        Self { lookup }
+    }
+
+    /// Maps a git event kind to the thread root it notifies about.
+    pub fn notification_root(&self, event: &Event) -> Option<EventId> {
+        match event.kind {
+            Kind::GitIssue | Kind::GitPullRequest => Some(event.id),
+            Kind::GitPatch => Some(match self.first_e_id(event) {
+                Some(parent) => self.resolve_thread_root(parent),
+                None => event.id,
+            }),
+            Kind::Comment => match nip22::extract_root(event) {
+                Some(CommentTarget::Event { id, .. }) => Some(self.resolve_thread_root(id)),
+                _ => None,
+            },
+            Kind::GitPullRequestUpdate => self
+                .first_uppercase_e_id(event)
+                .map(|root| self.resolve_thread_root(root)),
+            Kind::GitStatusOpen
+            | Kind::GitStatusApplied
+            | Kind::GitStatusClosed
+            | Kind::GitStatusDraft => self
+                .nip10_root_id(event)
+                .map(|root| self.resolve_thread_root(root)),
+            _ => None,
+        }
+    }
+
+    /// Follows parent pointers until a git issue or pull request root is reached.
+    pub fn resolve_thread_root(&self, id: EventId) -> EventId {
+        let mut seen = HashSet::new();
+        let mut root = id;
+
+        loop {
+            if !seen.insert(root) {
+                return id;
+            }
+
+            let Some(event) = (self.lookup)(root) else {
+                return root;
+            };
+
+            if matches!(event.kind, Kind::GitIssue | Kind::GitPullRequest) {
+                return root;
+            }
+
+            match self.parent_id(&event) {
+                Some(parent) => root = parent,
+                None => return root,
+            }
+        }
+    }
+
+    /// Mirrors gitworkshop's `getParentId` parent resolution.
+    fn parent_id(&self, event: &Event) -> Option<EventId> {
+        for marker in ["reply", "root"] {
+            if let Some(id) = event
+                .tags
+                .iter()
+                .find_map(|tag| self.e_tag_with_marker(tag, marker))
+            {
+                return Some(id);
+            }
+        }
+
+        if let Some(id) = event.tags.iter().find_map(|tag| {
+            if tag.kind() != "e" {
+                return None;
+            }
+
+            let slice = tag.as_slice();
+            let is_mention = slice.len() == 4 && slice[3] == "mention";
+
+            if is_mention {
+                return None;
+            }
+
+            tag.content()
+                .and_then(|content| EventId::from_hex(content).ok())
+        }) {
+            return Some(id);
+        }
+
+        self.first_uppercase_e_id(event)
+    }
+
+    /// Reads the NIP-10 `root` marker, falling back to the first `e` tag.
+    fn nip10_root_id(&self, event: &Event) -> Option<EventId> {
+        event
+            .tags
+            .iter()
+            .find_map(|tag| self.e_tag_with_marker(tag, "root"))
+            .or_else(|| self.first_e_id(event))
+    }
+
+    /// Reads the first lowercase `e` tag id.
+    fn first_e_id(&self, event: &Event) -> Option<EventId> {
+        self.first_tag_id(event, "e")
+    }
+
+    /// Reads the first uppercase `E` tag id.
+    fn first_uppercase_e_id(&self, event: &Event) -> Option<EventId> {
+        self.first_tag_id(event, "E")
+    }
+
+    /// Reads the first event id from tags of the given kind.
+    fn first_tag_id(&self, event: &Event, name: &str) -> Option<EventId> {
+        event.tags.iter().find_map(|tag| {
+            if tag.kind() != name {
+                return None;
+            }
+            tag.content()
+                .and_then(|content| EventId::from_hex(content).ok())
+        })
+    }
+
+    /// Parses a four-value `e` tag carrying the given marker.
+    fn e_tag_with_marker(&self, tag: &Tag, marker: &str) -> Option<EventId> {
+        let slice = tag.as_slice();
+        if tag.kind() != "e" || slice.len() != 4 || slice[3] != marker {
+            return None;
+        }
+        tag.content()
+            .and_then(|content| EventId::from_hex(content).ok())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Derives deterministic signer keys from a seed byte.
+    fn keys(seed: u8) -> Keys {
+        let mut hex = "00000000000000000000000000000000000000000000000000000000000000".to_string();
+        hex.push_str(&format!("{seed:02x}"));
+        Keys::new(SecretKey::from_hex(&hex).expect("valid secret key"))
+    }
+
+    /// Builds a signed event with a fixed timestamp.
+    fn signed(author: &Keys, kind: Kind, tags: Vec<Tag>, created_at: u64) -> Event {
+        EventBuilder::new(kind, "")
+            .tags(tags)
+            .custom_created_at(Timestamp::from_secs(created_at))
+            .finalize(author)
+            .expect("signed event")
+    }
+
+    /// Builds a plain lowercase `e` tag for the event.
+    fn e_tag(event: &Event) -> Tag {
+        Tag::parse(["e", &event.id.to_hex()]).expect("valid e tag")
+    }
+
+    /// Builds a four-value `e` tag with the given marker.
+    fn marked_e_tag(event: &Event, marker: &str) -> Tag {
+        Tag::parse(["e", &event.id.to_hex(), "wss://relay.example.com", marker])
+            .expect("valid e tag")
+    }
+
+    /// Builds an uppercase `E` tag for the event.
+    fn uppercase_e_tag(event: &Event) -> Tag {
+        Tag::parse(["E", &event.id.to_hex()]).expect("valid E tag")
+    }
+
+    /// Builds an event lookup closure over a slice.
+    fn lookup(events: &[Event]) -> impl Fn(EventId) -> Option<Event> + '_ {
+        move |id| events.iter().find(|event| event.id == id).cloned()
+    }
+
+    /// Builds a git issue event.
+    fn issue(author: &Keys, at: u64) -> Event {
+        signed(author, Kind::GitIssue, Vec::new(), at)
+    }
+
+    /// Resolves a comment to its uppercase `E` root.
+    #[test]
+    fn comment_resolves_to_its_uppercase_root() {
+        let issue = issue(&keys(1), 100);
+        let comment = signed(
+            &keys(2),
+            Kind::Comment,
+            vec![
+                uppercase_e_tag(&issue),
+                Tag::parse(["K", "1621"]).expect("valid K tag"),
+            ],
+            200,
+        );
+        let events = [issue.clone(), comment.clone()];
+        assert_eq!(
+            ThreadResolver::new(&lookup(&events)).notification_root(&comment),
+            Some(issue.id)
+        );
+    }
+
+    /// Resolves a child patch to its root patch.
+    #[test]
+    fn child_patch_resolves_to_the_root_patch() {
+        let root_patch = signed(&keys(1), Kind::GitPatch, Vec::new(), 100);
+        let child_patch = signed(&keys(1), Kind::GitPatch, vec![e_tag(&root_patch)], 200);
+        let events = [root_patch.clone(), child_patch.clone()];
+        assert_eq!(
+            ThreadResolver::new(&lookup(&events)).notification_root(&child_patch),
+            Some(root_patch.id)
+        );
+    }
+
+    /// Resolves a status through its `root` marker tag.
+    #[test]
+    fn status_resolves_via_the_root_marker() {
+        let issue = issue(&keys(1), 100);
+        let status = signed(
+            &keys(2),
+            Kind::GitStatusClosed,
+            vec![marked_e_tag(&issue, "root")],
+            200,
+        );
+        let events = [issue.clone(), status.clone()];
+        assert_eq!(
+            ThreadResolver::new(&lookup(&events)).notification_root(&status),
+            Some(issue.id)
+        );
+    }
+
+    /// Follows a nested comment chain to the issue root.
+    #[test]
+    fn nested_comment_chain_follows_to_the_root() {
+        let issue = issue(&keys(1), 100);
+        let reply = signed(&keys(2), Kind::Comment, vec![uppercase_e_tag(&issue)], 200);
+        let nested = signed(&keys(3), Kind::Comment, vec![uppercase_e_tag(&reply)], 300);
+        let events = [issue.clone(), reply, nested.clone()];
+        assert_eq!(
+            ThreadResolver::new(&lookup(&events)).notification_root(&nested),
+            Some(issue.id)
+        );
+    }
+}

crates/signed_core/src/lib.rs

@@ -1,14 +1,19 @@
 pub mod addr;
-pub mod clone_url;
+pub mod announcement;
 pub mod deletions;
 pub mod filters;
-pub mod model;
-pub mod state;
+pub mod git_event;
+pub mod inbox;
+pub mod pull_request;
 pub mod status;
+pub mod upstream;
 
-pub use addr::{RepoAddr, repo_addr};
-pub use clone_url::{CloneTarget, parse_clone_url};
+pub use addr::RepoAddr;
+pub use announcement::Announcement;
 pub use deletions::Deletions;
-pub use model::{activity_subject, Announcement};
-pub use state::parse_state;
-pub use status::{RepoStatus, references_root, resolve_status};
+pub use filters::Filters;
+pub use git_event::GitEvent;
+pub use inbox::{InboxItem, InboxReadState, ThreadResolver};
+pub use pull_request::PullRequest;
+pub use status::RepoStatus;
+pub use upstream::Upstream;

crates/signed_core/src/model.rs

@@ -1,233 +0,0 @@
-use gpui::SharedString;
-use nostr::prelude::*;
-
-/// Parsed NIP-34 repository announcement (plain data, ready for the UI).
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Announcement {
-    /// Repository ID (`d` tag).
-    pub id: String,
-    /// Author of the announcement event.
-    pub owner: PublicKey,
-    /// When the announcement was published (for latest-wins resolution).
-    pub created_at: Timestamp,
-    pub name: Option<SharedString>,
-    pub description: Option<SharedString>,
-    /// Webpage URLs for browsing.
-    pub web: Vec<Url>,
-    /// URLs for `git clone`.
-    pub clone: Vec<Url>,
-    /// Relays the repository monitors for patches and issues.
-    pub relays: Vec<RelayUrl>,
-    /// Earliest unique commit ID (`r` tag with `euc` marker).
-    pub euc: Option<String>,
-    /// Other recognized maintainers.
-    pub maintainers: Vec<PublicKey>,
-    /// Hashtags labelling the repository (`t` tags).
-    pub hashtags: Vec<String>,
-}
-
-/// Subject of a NIP-34 issue or pull request event: the `subject` tag,
-/// falling back to the first non-empty line of the content.
-pub fn activity_subject(event: &Event) -> SharedString {
-    let subject = event
-        .tags
-        .iter()
-        .find_map(|tag| match Nip34Tag::parse(tag.as_slice()) {
-            Ok(Nip34Tag::Subject(subject)) => Some(subject),
-            _ => None,
-        });
-
-    subject
-        .map(SharedString::from)
-        .or_else(|| {
-            event
-                .content
-                .lines()
-                .map(str::trim)
-                .find(|line| !line.is_empty())
-                .map(SharedString::from)
-        })
-        .unwrap_or(SharedString::from("Untitled"))
-}
-
-impl Announcement {
-    /// Parse a kind `30617` event. Returns `None` if the kind is wrong or the `d` tag is missing.
-    pub fn from_event(event: &Event) -> Option<Self> {
-        if event.kind != Kind::GitRepoAnnouncement {
-            return None;
-        }
-
-        let id = event.tags.identifier()?;
-
-        let mut hashtags: Vec<String> = Vec::new();
-        hashtags.extend(event.tags.hashtags().map(|t| t.to_string()));
-
-        let mut name: Option<SharedString> = None;
-        let mut description: Option<SharedString> = None;
-        let mut web: Vec<Url> = Vec::new();
-        let mut clone: Vec<Url> = Vec::new();
-        let mut relays: Vec<RelayUrl> = Vec::new();
-        let mut euc: Option<String> = None;
-        let mut maintainers: Vec<PublicKey> = Vec::new();
-
-        for tag in event.tags.iter() {
-            match Nip34Tag::parse(tag.as_slice()) {
-                Ok(Nip34Tag::Name(value)) => name = Some(value.into()),
-                Ok(Nip34Tag::Description(value)) => description = Some(value.into()),
-                Ok(Nip34Tag::Web(urls)) => web.extend(urls),
-                Ok(Nip34Tag::Clone(urls)) => clone.extend(urls),
-                Ok(Nip34Tag::Relays(urls)) => relays.extend(urls),
-                Ok(Nip34Tag::EarliestUniqueCommitId(commit)) => euc = Some(commit.to_string()),
-                Ok(Nip34Tag::Maintainers(keys)) => maintainers.extend(keys),
-                _ => {}
-            }
-        }
-
-        Some(Self {
-            owner: event.pubkey,
-            created_at: event.created_at,
-            id,
-            name,
-            description,
-            web,
-            clone,
-            relays,
-            euc,
-            maintainers,
-            hashtags,
-        })
-    }
-
-    /// The repository address of this announcement.
-    pub fn addr(&self) -> crate::RepoAddr {
-        crate::repo_addr(self.owner, self.id.clone())
-    }
-
-    /// The description of the repository, or a default if none is provided.
-    pub fn description(&self) -> SharedString {
-        self.description
-            .clone()
-            .unwrap_or(SharedString::from("No description"))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const MAINTAINER_HEX: &str = "68d81165918100b7da43fc28f7d1fc12554466e1115886b9e7bb326f65ec4272";
-
-    fn keys() -> Keys {
-        Keys::new(
-            SecretKey::from_hex("0000000000000000000000000000000000000000000000000000000000000001")
-                .expect("valid secret key"),
-        )
-    }
-
-    /// Build a signed kind `30617` event from raw tag values.
-    fn announcement_event(tags: &[&[&str]]) -> Event {
-        let tags: Vec<Tag> = tags
-            .iter()
-            .map(|t| Tag::parse(t.to_vec()).expect("valid tag"))
-            .collect();
-
-        EventBuilder::new(Kind::GitRepoAnnouncement, "")
-            .tags(tags)
-            .finalize(&keys())
-            .expect("signed event")
-    }
-
-    #[test]
-    fn parses_full_announcement() {
-        let event = announcement_event(&[
-            &["d", "my-repo"],
-            &["name", "My Repo"],
-            &["description", "A test repository"],
-            &["web", "https://example.com/repo"],
-            &["clone", "https://example.com/repo.git"],
-            &["relays", "wss://relay.example.com"],
-            &["r", "aa231c4c6a5777dc89b42207b499891a344add5c", "euc"],
-            &["maintainers", MAINTAINER_HEX],
-            &["t", "rust"],
-            &["t", "nostr"],
-        ]);
-
-        let announcement = Announcement::from_event(&event).expect("parses");
-
-        assert_eq!(announcement.owner, keys().public_key());
-        assert_eq!(announcement.id, "my-repo");
-        assert_eq!(announcement.name.as_deref(), Some("My Repo"));
-        assert_eq!(
-            announcement.description.as_deref(),
-            Some("A test repository")
-        );
-        assert_eq!(
-            announcement.web,
-            vec![Url::parse("https://example.com/repo").unwrap()]
-        );
-        assert_eq!(
-            announcement.clone,
-            vec![Url::parse("https://example.com/repo.git").unwrap()]
-        );
-        assert_eq!(
-            announcement.relays,
-            vec![RelayUrl::parse("wss://relay.example.com").unwrap()]
-        );
-        assert_eq!(
-            announcement.euc.as_deref(),
-            Some("aa231c4c6a5777dc89b42207b499891a344add5c")
-        );
-        assert_eq!(
-            announcement.maintainers,
-            vec![PublicKey::from_hex(MAINTAINER_HEX).expect("valid pubkey")]
-        );
-        assert_eq!(announcement.hashtags, vec!["rust", "nostr"]);
-    }
-
-    #[test]
-    fn requires_d_tag() {
-        let event = announcement_event(&[&["name", "No id"]]);
-
-        assert!(Announcement::from_event(&event).is_none());
-    }
-
-    #[test]
-    fn ignores_other_kinds() {
-        let event = EventBuilder::new(Kind::GitIssue, "")
-            .finalize(&keys())
-            .expect("signed event");
-
-        assert!(Announcement::from_event(&event).is_none());
-    }
-
-    #[test]
-    fn drops_malformed_values() {
-        let event = announcement_event(&[
-            &["d", "my-repo"],
-            &["clone", "not a url"],
-            &["relays", "wss://good.example.com"],
-            &["maintainers", "not-a-pubkey"],
-        ]);
-
-        let announcement = Announcement::from_event(&event).expect("parses");
-
-        // An invalid URL keeps the whole clone tag from being parsed.
-        assert!(announcement.clone.is_empty());
-        assert_eq!(
-            announcement.relays,
-            vec![RelayUrl::parse("wss://good.example.com").unwrap()]
-        );
-        assert!(announcement.maintainers.is_empty());
-    }
-
-    #[test]
-    fn ignores_unknown_tags() {
-        let event = announcement_event(&[&["d", "my-repo"], &["t", "label"], &["subject", "n/a"]]);
-
-        let announcement = Announcement::from_event(&event).expect("parses");
-
-        assert_eq!(announcement.id, "my-repo");
-        assert!(announcement.name.is_none());
-        assert!(announcement.web.is_empty());
-    }
-}

crates/signed_core/src/pull_request.rs

@@ -0,0 +1,279 @@
+use nostr::prelude::*;
+
+use crate::git_event::GitEvent;
+
+pub struct PullRequest<'a>(pub &'a Event);
+
+impl<'a> PullRequest<'a> {
+    /// Wraps a pull request root event.
+    pub fn new(event: &'a Event) -> Self {
+        Self(event)
+    }
+
+    /// Returns the ordered patch series, found via the root reference or the tip commit.
+    pub fn patches(&self, patches: impl IntoIterator<Item = &'a Event>) -> Vec<&'a Event> {
+        let pr = self.0;
+        let patches: Vec<&'a Event> = patches.into_iter().collect();
+
+        if let Some(root_id) = pr.tags.event_ids().next()
+            && let Some(root) = patches.iter().find(|patch| patch.id == root_id)
+        {
+            return Self::forward_series(root, &patches);
+        }
+
+        let Some(tip) = pr.current_commit() else {
+            return Vec::new();
+        };
+        let Some(last) = patches
+            .iter()
+            .filter(|patch| Self::patch_produces_commit(patch, &tip))
+            .max_by_key(|patch| patch.created_at)
+            .copied()
+        else {
+            return Vec::new();
+        };
+
+        let mut series = vec![last];
+        loop {
+            let Some(prev_id) = series.last().unwrap().tags.event_ids().next() else {
+                break;
+            };
+            let Some(prev) = patches
+                .iter()
+                .find(|patch| patch.id == prev_id && !series.contains(patch))
+                .copied()
+            else {
+                break;
+            };
+            series.push(prev);
+        }
+        series.reverse();
+        series
+    }
+
+    /// Joins the patch series with newlines, falling back to the event content.
+    pub fn patch(&self, patches: impl IntoIterator<Item = &'a Event>) -> String {
+        let pr = self.0;
+        let patches: Vec<&'a Event> = patches.into_iter().collect();
+        let series = self.patches(patches.iter().copied());
+        if series.is_empty() {
+            return pr.content.clone();
+        }
+        series
+            .iter()
+            .map(|patch| patch.content.as_str())
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+
+    /// Returns the root author's newest update, since only the author may move the tip.
+    pub fn latest_update(
+        events: impl Iterator<Item = &'a Event>,
+        root: &Event,
+    ) -> Option<&'a Event> {
+        let root_hex = root.id.to_hex();
+        events
+            .filter(|e| e.kind == Kind::GitPullRequestUpdate)
+            .filter(|e| e.pubkey == root.pubkey)
+            .filter(|e| {
+                e.tags
+                    .iter()
+                    .any(|t| t.kind() == "E" && t.content() == Some(root_hex.as_str()))
+            })
+            .max_by_key(|e| e.created_at)
+    }
+
+    /// Walks reply links outward from the root patch, taking the newest child first.
+    fn forward_series(root: &'a Event, patches: &[&'a Event]) -> Vec<&'a Event> {
+        let mut series = vec![root];
+        loop {
+            let next = patches
+                .iter()
+                .filter(|patch| !series.contains(patch))
+                .filter(|patch| {
+                    patch
+                        .tags
+                        .event_ids()
+                        .any(|id| id == series.last().unwrap().id)
+                })
+                .max_by_key(|patch| patch.created_at);
+            let Some(next) = next else {
+                break;
+            };
+            series.push(next);
+        }
+        series
+    }
+
+    /// Checks the commit against the patch's `c` and `r` tags.
+    fn patch_produces_commit(patch: &Event, commit: &str) -> bool {
+        patch
+            .tags
+            .iter()
+            .any(|tag| match Nip34Tag::parse(tag.as_slice()) {
+                Ok(Nip34Tag::Commit(c) | Nip34Tag::Reference(c)) => c.to_string() == commit,
+                _ => false,
+            })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Returns the test signer keys.
+    fn keys() -> Keys {
+        Keys::new(
+            SecretKey::from_hex("0000000000000000000000000000000000000000000000000000000000000001")
+                .expect("valid secret key"),
+        )
+    }
+
+    /// Builds a signed pull request event.
+    fn pr_event(content: &str, tags: Vec<Tag>) -> Event {
+        EventBuilder::new(Kind::GitPullRequest, content)
+            .tags(tags)
+            .finalize(&keys())
+            .expect("signed event")
+    }
+
+    /// Builds a signed patch event with a fixed timestamp.
+    fn patch_event(content: &str, tags: Vec<Tag>, created_at: u64) -> Event {
+        EventBuilder::new(Kind::GitPatch, content)
+            .tags(tags)
+            .custom_created_at(Timestamp::from(created_at))
+            .finalize(&keys())
+            .expect("signed event")
+    }
+
+    /// Joins the full patch series into one diff.
+    #[test]
+    fn pull_request_patch_joins_the_whole_patch_set() {
+        let root = patch_event("patch-one", vec![], 100);
+        let second = patch_event("patch-two", vec![Tag::event(root.id)], 200);
+        let pr = pr_event("description", vec![Tag::event(root.id)]);
+
+        assert_eq!(
+            PullRequest::new(&pr).patch([&root, &second]),
+            "patch-one\npatch-two"
+        );
+        assert_eq!(
+            PullRequest::new(&pr).patches([&root, &second]),
+            vec![&root, &second]
+        );
+    }
+
+    /// Orders patches by walking the reply chain.
+    #[test]
+    fn pull_request_patches_walks_the_reply_chain_in_order() {
+        let root = patch_event("patch-one", vec![], 100);
+        let second = patch_event("patch-two", vec![Tag::event(root.id)], 200);
+        let third = patch_event("patch-three", vec![Tag::event(second.id)], 300);
+        let pr = pr_event("description", vec![Tag::event(root.id)]);
+
+        let series = PullRequest::new(&pr).patches([&third, &root, &second]);
+        assert_eq!(
+            series
+                .iter()
+                .map(|p| p.content.as_str())
+                .collect::<Vec<_>>(),
+            vec!["patch-one", "patch-two", "patch-three"]
+        );
+    }
+
+    /// Finds the patch series through the declared tip commit.
+    #[test]
+    fn pull_request_patches_finds_the_set_via_the_tip_commit() {
+        let root = patch_event("patch-one", vec![], 100);
+        let tip = "1111111111111111111111111111111111111111";
+        let last = patch_event(
+            "patch-two",
+            vec![
+                Tag::event(root.id),
+                Tag::parse(["r", tip]).expect("valid tag"),
+            ],
+            200,
+        );
+        let pr = pr_event(
+            "description",
+            vec![Tag::parse(["c", tip]).expect("valid tag")],
+        );
+
+        let series = PullRequest::new(&pr).patches([&root, &last]);
+        assert_eq!(
+            series
+                .iter()
+                .map(|p| p.content.as_str())
+                .collect::<Vec<_>>(),
+            vec!["patch-one", "patch-two"]
+        );
+    }
+
+    const COMMIT_HEX: &str = "1111111111111111111111111111111111111111";
+    const OTHER_ROOT_HEX: &str = "2222222222222222222222222222222222222222";
+
+    /// Builds a signed event with a fixed timestamp.
+    fn signed_at(kind: Kind, tags: Vec<Tag>, created_at: u64) -> Event {
+        EventBuilder::new(kind, "")
+            .tags(tags)
+            .custom_created_at(Timestamp::from(created_at))
+            .finalize(&keys())
+            .expect("signed event")
+    }
+
+    /// Builds the pull request root used by the update tests.
+    fn pr_root() -> Event {
+        signed_at(
+            Kind::GitPullRequest,
+            vec![
+                Tag::parse(["c", COMMIT_HEX]).expect("valid tag"),
+                Tag::parse(["branch-name", "feature/x"]).expect("valid tag"),
+            ],
+            100,
+        )
+    }
+
+    /// Picks the newest update targeting the root.
+    #[test]
+    fn latest_update_picks_newest_revision_of_the_root() {
+        let root = pr_root();
+        let root_hex = root.id.to_hex();
+
+        let revision = |created_at: u64| {
+            signed_at(
+                Kind::GitPullRequestUpdate,
+                vec![Tag::parse(["E", &root_hex]).expect("valid tag")],
+                created_at,
+            )
+        };
+        let unrelated = signed_at(
+            Kind::GitPullRequestUpdate,
+            vec![Tag::parse(["E", OTHER_ROOT_HEX]).expect("valid tag")],
+            999,
+        );
+
+        let events = [unrelated, revision(200), root.clone(), revision(300)];
+        let latest = PullRequest::latest_update(events.iter(), &root).expect("an update");
+
+        assert_eq!(latest.created_at.as_secs(), 300);
+        assert_eq!(latest.kind, Kind::GitPullRequestUpdate);
+    }
+
+    /// Ignores updates from authors other than the root owner.
+    #[test]
+    fn latest_update_ignores_other_authors() {
+        let root = pr_root();
+        let root_hex = root.id.to_hex();
+        let other = Keys::new(
+            SecretKey::from_hex("0000000000000000000000000000000000000000000000000000000000000002")
+                .expect("valid secret key"),
+        );
+        let stranger = EventBuilder::new(Kind::GitPullRequestUpdate, "")
+            .tags([Tag::parse(["E", &root_hex]).expect("valid tag")])
+            .custom_created_at(Timestamp::from(999))
+            .finalize(&other)
+            .expect("signed event");
+
+        assert!(PullRequest::latest_update([&stranger, &root].into_iter(), &root).is_none());
+    }
+}

crates/signed_core/src/state.rs

@@ -1,95 +0,0 @@
-use nostr::prelude::*;
-
-/// Parse a kind `30618` repository state event into refs and HEAD.
-///
-/// `refs` are `(refname, commit-id)` pairs; `head` is the branch pointed to
-/// by the `HEAD` tag, if any.
-pub fn parse_state(event: &Event) -> (Vec<(String, String)>, Option<String>) {
-    let mut refs = Vec::new();
-    let mut head = None;
-
-    for tag in event.tags.iter() {
-        match Nip34Tag::parse(tag.as_slice()) {
-            Ok(Nip34Tag::Head(branch)) => head = Some(branch),
-            Ok(Nip34Tag::RefHead { branch, commit }) => {
-                refs.push((format!("refs/heads/{branch}"), commit.to_string()));
-            }
-            Ok(Nip34Tag::RefTag { name, commit }) => {
-                refs.push((format!("refs/tags/{name}"), commit.to_string()));
-            }
-            _ => {}
-        }
-    }
-
-    (refs, head)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const COMMIT_A: &str = "aa231c4c6a5777dc89b42207b499891a344add5c";
-    const COMMIT_B: &str = "59429cfc6cb35b0a1ddace73b5a5c5ed57b8f5ca";
-
-    fn keys() -> Keys {
-        Keys::new(
-            SecretKey::from_hex("0000000000000000000000000000000000000000000000000000000000000001")
-                .expect("valid secret key"),
-        )
-    }
-
-    /// Build a signed kind `30618` event from raw tag values.
-    fn state_event(tags: &[&[&str]]) -> Event {
-        let tags: Vec<Tag> = tags
-            .iter()
-            .map(|t| Tag::parse(t.to_vec()).expect("valid tag"))
-            .collect();
-
-        EventBuilder::new(Kind::RepoState, "")
-            .tags(tags)
-            .finalize(&keys())
-            .expect("signed event")
-    }
-
-    #[test]
-    fn parses_heads_and_tags() {
-        let event = state_event(&[
-            &["HEAD", "ref: refs/heads/main"],
-            &["refs/heads/main", COMMIT_A],
-            &["refs/heads/dev", COMMIT_B],
-            &["refs/tags/v1.0", COMMIT_A],
-        ]);
-
-        let (refs, head) = parse_state(&event);
-
-        assert_eq!(head.as_deref(), Some("main"));
-        assert_eq!(
-            refs,
-            vec![
-                ("refs/heads/main".to_owned(), COMMIT_A.to_owned()),
-                ("refs/heads/dev".to_owned(), COMMIT_B.to_owned()),
-                ("refs/tags/v1.0".to_owned(), COMMIT_A.to_owned()),
-            ]
-        );
-    }
-
-    #[test]
-    fn head_without_prefix_is_ignored() {
-        let event = state_event(&[&["HEAD", "main"]]);
-
-        let (refs, head) = parse_state(&event);
-
-        assert!(refs.is_empty());
-        assert!(head.is_none());
-    }
-
-    #[test]
-    fn ignores_non_state_tags() {
-        let event = state_event(&[&["d", "my-repo"], &["name", "ignored"]]);
-
-        let (refs, head) = parse_state(&event);
-
-        assert!(refs.is_empty());
-        assert!(head.is_none());
-    }
-}

crates/signed_core/src/status.rs

@@ -1,6 +1,5 @@
 use nostr::prelude::*;
 
-/// Status of a root patch, pull request or issue (kinds `1630..=1633`).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum RepoStatus {
     Open,
@@ -28,36 +27,29 @@ impl RepoStatus {
             Self::Draft => Kind::GitStatusDraft,
         }
     }
-}
 
-/// Check whether a status event references the given root event via an `e` tag.
-pub fn references_root(event: &Event, root: &EventId) -> bool {
-    event.tags.event_ids().any(|id| id == *root)
-}
-
-/// Resolve the status of a root event per NIP-34:
-/// the most recent status event from the root author or a maintainer wins.
-/// Defaults to [`RepoStatus::Open`].
-pub fn resolve_status<'a, I>(
-    status_events: I,
-    root_author: &PublicKey,
-    maintainers: &[PublicKey],
-) -> RepoStatus
-where
-    I: IntoIterator<Item = &'a Event>,
-{
-    status_events
-        .into_iter()
-        .filter(|e| RepoStatus::from_kind(e.kind).is_some())
-        .filter(|e| &e.pubkey == root_author || maintainers.contains(&e.pubkey))
-        .max_by_key(|e| e.created_at)
-        .and_then(|e| RepoStatus::from_kind(e.kind))
-        .unwrap_or(RepoStatus::Open)
+    pub fn resolve<'a, I>(
+        status_events: I,
+        root_author: &PublicKey,
+        maintainers: &[PublicKey],
+    ) -> Self
+    where
+        I: IntoIterator<Item = &'a Event>,
+    {
+        status_events
+            .into_iter()
+            .filter(|e| RepoStatus::from_kind(e.kind).is_some())
+            .filter(|e| &e.pubkey == root_author || maintainers.contains(&e.pubkey))
+            .max_by_key(|e| e.created_at)
+            .and_then(|e| RepoStatus::from_kind(e.kind))
+            .unwrap_or(RepoStatus::Open)
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::GitEvent;
 
     const ROOT_ID_HEX: &str = "1111111111111111111111111111111111111111111111111111111111111111";
     const OTHER_ID_HEX: &str = "2222222222222222222222222222222222222222222222222222222222222222";
@@ -70,7 +62,6 @@ mod tests {
         EventId::from_hex(ROOT_ID_HEX).expect("valid event id")
     }
 
-    /// Build a signed status event with a controlled `created_at`.
     fn status_event(author: &Keys, kind: Kind, root: EventId, created_at: u64) -> Event {
         EventBuilder::new(kind, "")
             .tags([Tag::event(root)])
@@ -89,41 +80,8 @@ mod tests {
             ))
             .expect("signed event");
 
-        assert!(references_root(&event, &root));
-        assert!(!references_root(
-            &event,
-            &EventId::from_hex(OTHER_ID_HEX).expect("valid id")
-        ));
-    }
-
-    #[test]
-    fn references_root_false_without_e_tags() {
-        let event = EventBuilder::new(Kind::GitStatusOpen, "")
-            .finalize(&keys_from_hex(
-                "0000000000000000000000000000000000000000000000000000000000000001",
-            ))
-            .expect("signed event");
-
-        assert!(!references_root(&event, &root_event_id()));
-    }
-
-    #[test]
-    fn defaults_to_open_without_status_events() {
-        let owner =
-            keys_from_hex("0000000000000000000000000000000000000000000000000000000000000001");
-        let maintainer =
-            keys_from_hex("0000000000000000000000000000000000000000000000000000000000000002");
-
-        let statuses: Vec<Event> = Vec::new();
-
-        assert_eq!(
-            resolve_status(
-                statuses.iter(),
-                &owner.public_key(),
-                &[maintainer.public_key()]
-            ),
-            RepoStatus::Open
-        );
+        assert!(event.references_root(&root));
+        assert!(!event.references_root(&EventId::from_hex(OTHER_ID_HEX).expect("valid id")));
     }
 
     #[test]
@@ -140,7 +98,7 @@ mod tests {
         ];
 
         assert_eq!(
-            resolve_status(
+            RepoStatus::resolve(
                 statuses.iter(),
                 &owner.public_key(),
                 &[maintainer.public_key()]
@@ -165,7 +123,7 @@ mod tests {
         ];
 
         assert_eq!(
-            resolve_status(
+            RepoStatus::resolve(
                 statuses.iter(),
                 &owner.public_key(),
                 &[maintainer.public_key()]
@@ -173,18 +131,4 @@ mod tests {
             RepoStatus::Draft
         );
     }
-
-    #[test]
-    fn ignores_non_status_kinds() {
-        let owner =
-            keys_from_hex("0000000000000000000000000000000000000000000000000000000000000001");
-        let root = root_event_id();
-
-        let statuses = [status_event(&owner, Kind::GitIssue, root, 100)];
-
-        assert_eq!(
-            resolve_status(statuses.iter(), &owner.public_key(), &[]),
-            RepoStatus::Open
-        );
-    }
 }

crates/signed_core/src/upstream.rs

@@ -0,0 +1,33 @@
+use nostr::prelude::*;
+
+use crate::RepoAddr;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Upstream {
+    pub raw: String,
+    pub addr: Option<RepoAddr>,
+}
+
+impl Upstream {
+    /// Parses a raw `u` tag value, extracting the coordinate when present.
+    pub(crate) fn parse(raw: &str) -> Self {
+        let coordinate = raw.split('|').next().unwrap_or(raw);
+        let addr = coordinate
+            .parse::<Coordinate>()
+            .ok()
+            .filter(|coordinate| coordinate.kind == Kind::GitRepoAnnouncement)
+            .map(RepoAddr::from);
+        Self {
+            raw: raw.to_owned(),
+            addr,
+        }
+    }
+
+    /// Shows the coordinate when parsed, otherwise the raw value.
+    pub fn display(&self) -> String {
+        match &self.addr {
+            Some(addr) => addr.to_string(),
+            None => self.raw.clone(),
+        }
+    }
+}

crates/signed_git/Cargo.toml

@@ -8,8 +8,15 @@ publish.workspace = true
 signed_core = { path = "../signed_core" }
 
 nostr.workspace = true
-gix = { workspace = true, features = ["revision", "blob-diff"] }
+serde.workspace = true
+serde_json.workspace = true
+log.workspace = true
 anyhow.workspace = true
+gix = { workspace = true, features = ["revision", "blob-diff"] }
+gix-worktree = "0.57"
+gix-worktree-state = "0.35"
+diffy = "0.5"
+ignore = "0.4"
 
 [dev-dependencies]
 tempfile = "3"

crates/signed_git/src/cache.rs

@@ -0,0 +1,114 @@
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex, PoisonError};
+
+use anyhow::Result;
+use signed_core::{Announcement, RepoAddr};
+
+use crate::repo::Repo;
+
+#[derive(Debug, Clone)]
+pub struct GitCache {
+    root: PathBuf,
+    clone_locks: Arc<Mutex<HashMap<PathBuf, Arc<Mutex<()>>>>>,
+}
+
+impl GitCache {
+    /// Creates a cache rooted at `root`.
+    pub fn new(root: PathBuf) -> Self {
+        Self {
+            root,
+            clone_locks: Arc::default(),
+        }
+    }
+
+    /// Returns the cache root directory.
+    pub fn root(&self) -> &Path {
+        &self.root
+    }
+
+    /// Returns the cache path for a repository address.
+    pub fn repo_path(&self, addr: &RepoAddr) -> PathBuf {
+        self.root
+            .join(addr.public_key().to_hex())
+            .join(Self::sanitize_path_component(addr.identifier()))
+    }
+
+    /// Opens the cached repository, or `None` when it is not cloned yet.
+    pub fn open(&self, addr: &RepoAddr) -> Result<Option<Repo>> {
+        let path = self.repo_path(addr);
+        match gix::open(&path) {
+            Ok(repo) => Ok(Some(Repo::new(repo))),
+            Err(e) if e.is_not_found() => Ok(None),
+            Err(e) => Err(e.into()),
+        }
+    }
+
+    /// Returns the clone lock for `path`, creating it on first use.
+    fn clone_lock(&self, path: &Path) -> Arc<Mutex<()>> {
+        let mut locks = self
+            .clone_locks
+            .lock()
+            .unwrap_or_else(PoisonError::into_inner);
+        Arc::clone(locks.entry(path.to_path_buf()).or_default())
+    }
+
+    /// Returns the cached repository, cloning from one of `clone_urls` on first use.
+    pub fn ensure_clone<U: AsRef<str>>(&self, addr: &RepoAddr, clone_urls: &[U]) -> Result<Repo> {
+        let path = self.repo_path(addr);
+
+        // Lock the clone lock for this path to prevent concurrent clones.
+        let clone_lock = self.clone_lock(&path);
+        let _clone_guard = clone_lock.lock().unwrap_or_else(PoisonError::into_inner);
+
+        // Refreshes the cached repository if it is already cloned, or clones it from one of `clone_urls` otherwise.
+        if let Ok(Some(repo)) = self.open(addr) {
+            if let Err(error) = repo.fetch() {
+                log::warn!("failed to refresh the cached repository: {error:#}");
+            }
+            return Ok(repo);
+        }
+
+        // Create the parent directory if it does not exist.
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+
+        // Remove the cached clone if it exists but is unusable.
+        if path.exists() {
+            log::warn!("removing unusable cached clone at {}", path.display());
+            std::fs::remove_dir_all(&path)?;
+        }
+
+        Repo::clone(clone_urls, &path)
+    }
+
+    /// Maps untrusted relay content onto a safe single path component.
+    pub fn sanitize_path_component(id: &str) -> String {
+        let sanitized: String = id
+            .chars()
+            .map(|c| {
+                if c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '.') {
+                    c
+                } else {
+                    '_'
+                }
+            })
+            .collect();
+
+        if sanitized == "." || sanitized == ".." {
+            return "_".to_owned();
+        }
+
+        sanitized
+    }
+
+    /// Returns the `owner/identifier` namespace used for fork checkouts.
+    pub fn fork_namespace(announcement: &Announcement) -> String {
+        format!(
+            "{}/{}",
+            announcement.owner.to_hex(),
+            Self::sanitize_path_component(&announcement.id)
+        )
+    }
+}

crates/signed_git/src/diff.rs

@@ -0,0 +1,237 @@
+use gix::diff::blob::unified_diff::{ConsumeHunk, DiffLineKind as GixLineKind, HunkHeader};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DiffLineKind {
+    Context,
+    Addition,
+    Deletion,
+}
+
+#[derive(Debug, Clone)]
+pub struct DiffLine {
+    pub kind: DiffLineKind,
+    pub old: Option<u32>,
+    pub new: Option<u32>,
+    pub text: String,
+}
+
+impl DiffLine {
+    /// Creates a diff line with its kind, optional line numbers, and text.
+    pub fn new(kind: DiffLineKind, old: Option<u32>, new: Option<u32>, text: String) -> Self {
+        Self {
+            kind,
+            old,
+            new,
+            text,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct DiffHunk {
+    pub old_start: u32,
+    pub old_lines: u32,
+    pub new_start: u32,
+    pub new_lines: u32,
+    pub lines: Vec<DiffLine>,
+}
+
+impl DiffHunk {
+    /// Creates a hunk spanning the given old and new ranges.
+    pub fn new(
+        old_start: u32,
+        old_lines: u32,
+        new_start: u32,
+        new_lines: u32,
+        lines: Vec<DiffLine>,
+    ) -> Self {
+        Self {
+            old_start,
+            old_lines,
+            new_start,
+            new_lines,
+            lines,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DiffStatus {
+    Added,
+    Modified,
+    Deleted,
+    Renamed,
+    Copied,
+}
+
+#[derive(Debug, Clone)]
+pub struct FileDiff {
+    pub path: String,
+    pub old_path: Option<String>,
+    pub status: DiffStatus,
+    pub insertions: usize,
+    pub deletions: usize,
+    pub binary: bool,
+    pub hunks: Vec<DiffHunk>,
+}
+
+impl FileDiff {
+    /// Creates a file diff; `old_path` is the rename or copy source and `binary` files have no hunks.
+    pub fn new(
+        path: String,
+        old_path: Option<String>,
+        status: DiffStatus,
+        insertions: usize,
+        deletions: usize,
+        binary: bool,
+        hunks: Vec<DiffHunk>,
+    ) -> Self {
+        Self {
+            path,
+            old_path,
+            status,
+            insertions,
+            deletions,
+            binary,
+            hunks,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct CommitDiff {
+    pub files: Vec<FileDiff>,
+}
+
+impl CommitDiff {
+    /// Creates a commit diff from its files.
+    pub fn new(files: Vec<FileDiff>) -> Self {
+        Self { files }
+    }
+}
+
+pub(crate) struct HunkBuilder {
+    old_start: u32,
+    old_lines: u32,
+    new_start: u32,
+    new_lines: u32,
+    old: u32,
+    new: u32,
+    lines: Vec<DiffLine>,
+    insertions: usize,
+    deletions: usize,
+}
+
+impl HunkBuilder {
+    /// Starts a hunk spanning the given old and new ranges.
+    pub(crate) fn new(old_start: u32, old_lines: u32, new_start: u32, new_lines: u32) -> Self {
+        Self {
+            old_start,
+            old_lines,
+            new_start,
+            new_lines,
+            old: old_start,
+            new: new_start,
+            lines: Vec::new(),
+            insertions: 0,
+            deletions: 0,
+        }
+    }
+
+    /// Appends a line, numbering it and counting insertions and deletions.
+    pub(crate) fn push(&mut self, kind: DiffLineKind, text: impl Into<String>) {
+        let (old_no, new_no) = match kind {
+            DiffLineKind::Context => {
+                let numbers = (Some(self.old), Some(self.new));
+                self.old += 1;
+                self.new += 1;
+                numbers
+            }
+            DiffLineKind::Addition => {
+                self.insertions += 1;
+                let number = Some(self.new);
+                self.new += 1;
+                (None, number)
+            }
+            DiffLineKind::Deletion => {
+                self.deletions += 1;
+                let number = Some(self.old);
+                self.old += 1;
+                (number, None)
+            }
+        };
+
+        self.lines
+            .push(DiffLine::new(kind, old_no, new_no, text.into()));
+    }
+
+    /// Finishes the hunk and returns it with its insertion and deletion counts.
+    pub(crate) fn finish(self) -> (DiffHunk, usize, usize) {
+        let hunk = DiffHunk::new(
+            self.old_start,
+            self.old_lines,
+            self.new_start,
+            self.new_lines,
+            self.lines,
+        );
+        (hunk, self.insertions, self.deletions)
+    }
+}
+
+pub(crate) struct HunkCollector<'a> {
+    hunks: &'a mut Vec<DiffHunk>,
+    insertions: &'a mut usize,
+    deletions: &'a mut usize,
+}
+
+impl<'a> HunkCollector<'a> {
+    /// Collects hunks into `hunks` while counting `insertions` and `deletions`.
+    pub(crate) fn new(
+        hunks: &'a mut Vec<DiffHunk>,
+        insertions: &'a mut usize,
+        deletions: &'a mut usize,
+    ) -> Self {
+        Self {
+            hunks,
+            insertions,
+            deletions,
+        }
+    }
+}
+
+impl ConsumeHunk for HunkCollector<'_> {
+    type Out = ();
+
+    /// Consumes one hunk, tracking line numbers and insertion/deletion counts.
+    fn consume_hunk(
+        &mut self,
+        header: HunkHeader,
+        lines: &[(GixLineKind, &[u8])],
+    ) -> std::io::Result<()> {
+        let mut builder = HunkBuilder::new(
+            header.before_hunk_start,
+            header.before_hunk_len,
+            header.after_hunk_start,
+            header.after_hunk_len,
+        );
+
+        for (kind, content) in lines {
+            let kind = match kind {
+                GixLineKind::Context => DiffLineKind::Context,
+                GixLineKind::Remove => DiffLineKind::Deletion,
+                GixLineKind::Add => DiffLineKind::Addition,
+            };
+            builder.push(kind, String::from_utf8_lossy(content).into_owned());
+        }
+
+        let (hunk, insertions, deletions) = builder.finish();
+        *self.insertions += insertions;
+        *self.deletions += deletions;
+        self.hunks.push(hunk);
+
+        Ok(())
+    }
+
+    /// Marks the end of the unified diff stream.
+    fn finish(self) {}
+}

crates/signed_git/src/history.rs

@@ -0,0 +1,77 @@
+pub const MAX_LISTED_COMMITS: usize = 20_000;
+
+pub struct CommitList {
+    pub total: usize,
+    pub commits: Vec<FileCommit>,
+}
+
+impl CommitList {
+    /// Creates a list holding `total` commits of which `commits` are materialized.
+    pub fn new(total: usize, commits: Vec<FileCommit>) -> Self {
+        Self { total, commits }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct FileCommit {
+    pub id: String,
+    pub summary: String,
+    pub description: Option<String>,
+    pub author: String,
+    pub time: i64,
+}
+
+impl FileCommit {
+    /// Creates a commit entry from its id, message parts, author, and timestamp.
+    pub fn new(
+        id: String,
+        summary: String,
+        description: Option<String>,
+        author: String,
+        time: i64,
+    ) -> Self {
+        Self {
+            id,
+            summary,
+            description,
+            author,
+            time,
+        }
+    }
+
+    /// Converts a gix commit including its message body.
+    pub(crate) fn from_commit(commit: &gix::Commit<'_>) -> anyhow::Result<Self> {
+        Self::from_commit_with_description(commit, true)
+    }
+
+    /// Converts a gix commit, skipping the message body since lists never show it.
+    pub(crate) fn from_commit_summary(commit: &gix::Commit<'_>) -> anyhow::Result<Self> {
+        Self::from_commit_with_description(commit, false)
+    }
+
+    /// Converts a gix commit, optionally skipping the message body.
+    fn from_commit_with_description(
+        commit: &gix::Commit<'_>,
+        include_description: bool,
+    ) -> anyhow::Result<Self> {
+        use crate::GixResultExt as _;
+
+        let author = commit.author().into_anyhow()?;
+        let message = commit.message().into_anyhow()?;
+
+        Ok(FileCommit::new(
+            commit.id().shorten_or_id().to_string(),
+            String::from_utf8_lossy(message.title).trim().to_string(),
+            if include_description {
+                message
+                    .body
+                    .map(|body| String::from_utf8_lossy(body).trim().to_string())
+                    .filter(|body| !body.is_empty())
+            } else {
+                None
+            },
+            String::from_utf8_lossy(author.name).trim().to_string(),
+            author.time().into_anyhow()?.seconds,
+        ))
+    }
+}

crates/signed_git/src/nip34.rs

@@ -0,0 +1,63 @@
+use nostr::prelude::*;
+
+#[derive(serde::Deserialize)]
+pub(crate) struct Nip34Json {
+    pub(crate) identifier: Option<String>,
+    pub(crate) owner: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Nip34Kind {
+    Initialized,
+    Cloned,
+    ToolingOnly,
+}
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct GraspSignals {
+    pub nip34_json: bool,
+    pub nip34_excluded: bool,
+    pub nostr_repo_config: bool,
+    pub nostr_remote: bool,
+    pub grasp_remote: bool,
+    pub nip34_grasp_remote: bool,
+    pub nip34_state_refs: bool,
+    pub nostr_cache: bool,
+    pub nostr_aux_config: bool,
+    pub maintainers_yaml: bool,
+}
+
+impl GraspSignals {
+    /// Returns whether any Nostr tooling marker was found.
+    pub fn any(&self) -> bool {
+        *self != Self::default()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Nip34Binding {
+    pub kind: Nip34Kind,
+    pub signals: GraspSignals,
+    pub owner: Option<PublicKey>,
+    pub identifier: Option<String>,
+    pub grasp_urls: Vec<String>,
+}
+
+impl Nip34Binding {
+    /// Creates a binding from its kind, detected signals, and recovered coordinates.
+    pub fn new(
+        kind: Nip34Kind,
+        signals: GraspSignals,
+        owner: Option<PublicKey>,
+        identifier: Option<String>,
+        grasp_urls: Vec<String>,
+    ) -> Self {
+        Self {
+            kind,
+            signals,
+            owner,
+            identifier,
+            grasp_urls,
+        }
+    }
+}

crates/signed_git/src/patch.rs

@@ -0,0 +1,238 @@
+use anyhow::Result;
+use diffy::patch_set::{FileOperation, FilePatch, ParseOptions, PatchSet};
+use diffy::{Hunk, Line};
+
+use crate::diff::{CommitDiff, DiffHunk, DiffLineKind, DiffStatus, FileDiff, HunkBuilder};
+use crate::history::FileCommit;
+
+pub struct PatchParser;
+
+impl PatchParser {
+    /// Splits an mbox series into the raw text of each message.
+    pub fn split_patch_series(patch: &str) -> Vec<&str> {
+        Self::envelopes(patch)
+            .into_iter()
+            .map(|message| message.text)
+            .collect()
+    }
+
+    /// Parses a git diff into file diffs, returning an empty diff without one.
+    pub fn patch_diffs(patch: &str) -> Result<CommitDiff> {
+        if !patch.lines().any(|line| line.starts_with("diff --git ")) {
+            return Ok(CommitDiff::new(Vec::new()));
+        }
+
+        let mut files = Vec::new();
+
+        for file in PatchSet::parse(patch, ParseOptions::gitdiff()) {
+            files.push(Self::file_diff(file?));
+        }
+
+        Ok(CommitDiff::new(files))
+    }
+
+    /// Lists the commits represented by the mbox messages that carry an id.
+    pub fn patch_commits(patch: &str) -> Vec<FileCommit> {
+        Self::envelopes(patch)
+            .into_iter()
+            .filter(|message| !message.id.is_empty())
+            .map(|message| {
+                FileCommit::new(
+                    message.id.to_string(),
+                    message
+                        .header("Subject")
+                        .map(Self::strip_patch_prefix)
+                        .unwrap_or_default(),
+                    None,
+                    message
+                        .header("From")
+                        .map(Self::name_from_address)
+                        .unwrap_or_default(),
+                    message
+                        .header("Date")
+                        .and_then(|value| gix::date::parse(value.trim(), None).ok())
+                        .map(|time| time.seconds)
+                        .unwrap_or(0),
+                )
+            })
+            .collect()
+    }
+
+    /// Splits `patch` on `From <40-hex> <date>` envelopes, falling back to one message.
+    fn envelopes(patch: &str) -> Vec<Envelope<'_>> {
+        let mut messages: Vec<Envelope<'_>> = Vec::new();
+        let mut current: Option<(usize, &str, Vec<&str>)> = None;
+        let mut headers_closed = false;
+
+        let mut offset = 0usize;
+        for line in patch.lines() {
+            let line_start = offset;
+            offset += line.len() + 1;
+
+            let is_envelope = line
+                .strip_prefix("From ")
+                .and_then(|rest| rest.split_whitespace().next())
+                .is_some_and(|id| id.len() == 40);
+
+            if is_envelope {
+                if let Some((start, id, headers)) = current.take() {
+                    messages.push(Envelope::new(&patch[start..], id, headers));
+                }
+
+                let id = line
+                    .strip_prefix("From ")
+                    .and_then(|rest| rest.split_whitespace().next())
+                    .unwrap_or("");
+
+                current = Some((line_start, id, Vec::new()));
+                headers_closed = false;
+                continue;
+            }
+
+            if let Some((_, _, headers)) = &mut current {
+                if headers_closed {
+                    continue;
+                }
+                if line.is_empty() {
+                    headers_closed = true;
+                } else {
+                    headers.push(line);
+                }
+            }
+        }
+
+        if let Some((start, id, headers)) = current.take() {
+            messages.push(Envelope::new(&patch[start..], id, headers));
+        }
+
+        if messages.is_empty() {
+            messages.push(Envelope::new(patch, "", Vec::new()));
+        }
+
+        messages
+    }
+
+    /// Extracts the display name from a `From` header value.
+    fn name_from_address(from: &str) -> String {
+        match from.trim().find('<') {
+            Some(ix) => from[..ix].trim().to_string(),
+            None => from.trim().to_string(),
+        }
+    }
+
+    /// Strips mailing list prefixes like `[PATCH]` or `[RFC PATCH 1/2]`.
+    fn strip_patch_prefix(subject: &str) -> String {
+        let trimmed = subject.trim();
+        let Some(rest) = trimmed.strip_prefix('[') else {
+            return trimmed.to_string();
+        };
+        let Some(end) = rest.find(']') else {
+            return trimmed.to_string();
+        };
+        if rest[..end].to_ascii_lowercase().contains("patch") {
+            rest[end + 1..].trim().to_string()
+        } else {
+            trimmed.to_string()
+        }
+    }
+
+    /// Converts one parsed file patch, keeping rename and copy paths unstripped.
+    fn file_diff(file: FilePatch<'_, str>) -> FileDiff {
+        let stripped;
+        let operation = match file.operation() {
+            operation @ (FileOperation::Rename { .. } | FileOperation::Copy { .. }) => operation,
+            operation => {
+                stripped = operation.strip_prefix(1);
+                &stripped
+            }
+        };
+
+        let (path, old_path, status) = match operation {
+            FileOperation::Create(path) => (path.as_ref(), None, DiffStatus::Added),
+            FileOperation::Delete(path) => (path.as_ref(), None, DiffStatus::Deleted),
+            FileOperation::Modify { modified, .. } => {
+                (modified.as_ref(), None, DiffStatus::Modified)
+            }
+            FileOperation::Rename { from, to } => {
+                (to.as_ref(), Some(from.as_ref()), DiffStatus::Renamed)
+            }
+            FileOperation::Copy { from, to } => {
+                (to.as_ref(), Some(from.as_ref()), DiffStatus::Copied)
+            }
+        };
+
+        let mut insertions = 0usize;
+        let mut deletions = 0usize;
+        let mut hunks = Vec::new();
+
+        let patch = file.patch();
+
+        if let Some(text) = patch.as_text() {
+            for hunk in text.hunks() {
+                let (hunk, hunk_insertions, hunk_deletions) = Self::hunk_diff(hunk);
+                insertions += hunk_insertions;
+                deletions += hunk_deletions;
+                hunks.push(hunk);
+            }
+        }
+
+        FileDiff::new(
+            path.to_owned(),
+            old_path.map(str::to_owned),
+            status,
+            insertions,
+            deletions,
+            patch.is_binary(),
+            hunks,
+        )
+    }
+
+    /// Converts a diffy hunk into a `DiffHunk` with its insertion and deletion counts.
+    fn hunk_diff(hunk: &Hunk<'_, str>) -> (DiffHunk, usize, usize) {
+        let old_range = hunk.old_range();
+        let new_range = hunk.new_range();
+
+        let mut builder = HunkBuilder::new(
+            old_range.start() as u32,
+            old_range.len() as u32,
+            new_range.start() as u32,
+            new_range.len() as u32,
+        );
+
+        for line in hunk.lines() {
+            let (kind, text) = match line {
+                Line::Context(text) => (DiffLineKind::Context, *text),
+                Line::Delete(text) => (DiffLineKind::Deletion, *text),
+                Line::Insert(text) => (DiffLineKind::Addition, *text),
+            };
+
+            let text = text.strip_suffix('\n').unwrap_or(text);
+            let text = text.strip_suffix('\r').unwrap_or(text);
+            builder.push(kind, text.to_owned());
+        }
+
+        builder.finish()
+    }
+}
+
+struct Envelope<'a> {
+    text: &'a str,
+    id: &'a str,
+    headers: Vec<&'a str>,
+}
+
+impl<'a> Envelope<'a> {
+    /// Creates an envelope from its text, commit id, and header lines.
+    fn new(text: &'a str, id: &'a str, headers: Vec<&'a str>) -> Self {
+        Self { text, id, headers }
+    }
+
+    /// Returns the first header line matching `name: `.
+    fn header(&self, name: &str) -> Option<&str> {
+        let prefix = format!("{name}: ");
+        self.headers
+            .iter()
+            .find(|line| line.starts_with(&prefix))
+            .map(|line| &line[prefix.len()..])
+    }
+}

crates/signed_git/src/scan.rs

@@ -0,0 +1,82 @@
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+
+use ignore::WalkBuilder;
+
+use crate::nip34::Nip34Binding;
+use crate::repo::Repo;
+
+const SCAN_MAX_DEPTH: usize = 12;
+
+#[derive(Debug, Clone)]
+pub struct LocalRepo {
+    pub path: PathBuf,
+    pub nip34: Option<Nip34Binding>,
+}
+
+impl LocalRepo {
+    /// Creates a local repository entry from its path and optional NIP-34 binding.
+    pub fn new(path: PathBuf, nip34: Option<Nip34Binding>) -> Self {
+        Self { path, nip34 }
+    }
+}
+
+/// Finds git repositories under `root` up to `SCAN_MAX_DEPTH` deep, without descending into them.
+pub fn find_git_repos(root: &Path) -> Vec<LocalRepo> {
+    let Ok(root) = root.canonicalize() else {
+        return Vec::new();
+    };
+
+    let found = Arc::new(Mutex::new(Vec::<PathBuf>::new()));
+
+    let walker = WalkBuilder::new(&root)
+        .max_depth(Some(SCAN_MAX_DEPTH))
+        .require_git(false)
+        .filter_entry({
+            let found = found.clone();
+            move |entry| {
+                let Some(kind) = entry.file_type() else {
+                    return true;
+                };
+                if !kind.is_dir() {
+                    return true;
+                }
+
+                let dir = entry.path();
+                let Ok(repo) = gix::discover(dir) else {
+                    return true;
+                };
+
+                let Some(workdir) = repo.workdir() else {
+                    return false;
+                };
+
+                if workdir != dir {
+                    return true;
+                }
+
+                match found.lock() {
+                    Ok(mut repos) => repos.push(dir.to_path_buf()),
+                    Err(poisoned) => poisoned.into_inner().push(dir.to_path_buf()),
+                }
+                false
+            }
+        })
+        .build();
+
+    for _ in walker {}
+
+    let mut repos = match found.lock() {
+        Ok(mut repos) => std::mem::take(&mut *repos),
+        Err(poisoned) => std::mem::take(&mut *poisoned.into_inner()),
+    };
+    repos.sort();
+
+    repos
+        .into_iter()
+        .map(|path| {
+            let nip34 = Repo::open(&path).ok().and_then(|repo| repo.nip34_binding());
+            LocalRepo::new(path, nip34)
+        })
+        .collect()
+}

crates/signed_git/src/sync.rs

@@ -0,0 +1,38 @@
+use std::collections::BTreeMap;
+
+/// How a single branch compares between local and Nostr.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum RefSync {
+    InSync,
+    LocalAhead { ahead: usize },
+    RemoteAhead { behind: usize },
+    Diverged { ahead: usize, behind: usize },
+    LocalOnly,
+    RemoteOnly,
+}
+
+/// Branch comparison between a local repository and its Nostr state.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RepoSyncStatus {
+    /// Branch short name and its classification.
+    pub refs: Vec<(String, RefSync)>,
+    pub ahead_total: usize,
+    pub behind_total: usize,
+}
+
+impl RepoSyncStatus {
+    /// True when every branch matches the Nostr state.
+    pub fn in_sync(&self) -> bool {
+        self.refs.iter().all(|(_, sync)| *sync == RefSync::InSync)
+    }
+
+    /// Maps branch short name to lowercase commit oid.
+    pub(crate) fn branches(refs: &[(String, String)]) -> BTreeMap<&str, String> {
+        refs.iter()
+            .filter_map(|(name, commit)| {
+                name.strip_prefix("refs/heads/")
+                    .map(|branch| (branch, commit.to_ascii_lowercase()))
+            })
+            .collect()
+    }
+}

crates/signed_git/src/tests.rs

@@ -0,0 +1,849 @@
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use nostr::prelude::Keys;
+use signed_core::RepoAddr;
+
+use super::*;
+
+#[test]
+fn blocks_parent_components() {
+    assert_eq!(GitCache::sanitize_path_component(".."), "_");
+    assert_eq!(GitCache::sanitize_path_component("."), "_");
+    assert_eq!(GitCache::sanitize_path_component("../.."), ".._..");
+    assert_eq!(GitCache::sanitize_path_component("a/../b"), "a_.._b");
+}
+
+#[test]
+fn concurrent_ensure_clone_succeeds_for_every_caller() {
+    let server = tempfile::tempdir().expect("tempdir");
+    let server_repo = bare_server(server.path(), "npub1test", "repo");
+
+    let (work_dir, work_repo) = fixture(&[("a.txt", b"one")]);
+    commit_all(&work_repo, "initial");
+    let work_dir = work_dir.path();
+
+    let base_url = format!("file://{}", server.path().display());
+    Repo::open(work_dir)
+        .expect("open")
+        .push_all(&base_url, "npub1test", "repo")
+        .expect("push");
+
+    let cache_dir = tempfile::tempdir().expect("tempdir");
+    let cache = GitCache::new(cache_dir.path().to_path_buf());
+    let addr = RepoAddr::new(Keys::generate().public_key(), "repo");
+    let clone_url = format!("file://{}", server_repo.display());
+
+    std::thread::scope(|scope| {
+        for _ in 0..4 {
+            scope.spawn(|| {
+                cache
+                    .ensure_clone(&addr, &[&clone_url])
+                    .expect("ensure_clone");
+            });
+        }
+    });
+
+    assert!(cache.open(&addr).expect("open").is_some());
+}
+
+#[test]
+fn ensure_clone_recovers_from_a_leftover_directory() {
+    let server = tempfile::tempdir().expect("tempdir");
+    let server_repo = bare_server(server.path(), "npub1test", "repo");
+
+    let (work_dir, work_repo) = fixture(&[("a.txt", b"one")]);
+    commit_all(&work_repo, "initial");
+    let work_dir = work_dir.path();
+
+    let base_url = format!("file://{}", server.path().display());
+    Repo::open(work_dir)
+        .expect("open")
+        .push_all(&base_url, "npub1test", "repo")
+        .expect("push");
+
+    let cache_dir = tempfile::tempdir().expect("tempdir");
+    let cache = GitCache::new(cache_dir.path().to_path_buf());
+    let addr = RepoAddr::new(Keys::generate().public_key(), "repo");
+    let clone_url = format!("file://{}", server_repo.display());
+
+    // Simulate the remains of an interrupted clone.
+    let leftover = cache.repo_path(&addr);
+    std::fs::create_dir_all(&leftover).expect("mkdir");
+
+    cache
+        .ensure_clone(&addr, &[&clone_url])
+        .expect("ensure_clone");
+
+    assert!(cache.open(&addr).expect("open").is_some());
+}
+
+#[test]
+fn root_commit_reports_the_first_ancestor() {
+    let (dir, repo) = fixture(&[("a.txt", b"one")]);
+    commit_all(&repo, "initial");
+
+    let dir = dir.path();
+    let root = repo.root_commit().expect("root").expect("commit");
+    assert_eq!(root.len(), 40);
+
+    std::fs::write(dir.join("b.txt"), b"two").expect("write");
+    commit_all(&repo, "second");
+    assert_eq!(
+        repo.root_commit().expect("root").as_deref(),
+        Some(root.as_str())
+    );
+}
+
+#[test]
+fn push_all_mirrors_branches_and_tags() {
+    let server = tempfile::tempdir().unwrap();
+    let server_repo = bare_server(server.path(), "npub1test", "my-repo");
+
+    let (dir, repo) = fixture(&[("a.txt", b"one")]);
+    commit_all(&repo, "initial");
+    let dir = dir.path();
+
+    git_run(dir, &["checkout", "-b", "feature"]);
+    std::fs::write(dir.join("b.txt"), b"two").expect("write");
+    commit_all(&repo, "feature work");
+    git_run(dir, &["checkout", "-"]);
+    git_run(dir, &["tag", "v1.0"]);
+
+    let base_url = format!("file://{}", server.path().display());
+    Repo::open(dir)
+        .expect("open")
+        .push_all(&base_url, "npub1test", "my-repo")
+        .expect("push");
+
+    let refs = git_in(&server_repo, &["show-ref"]).expect("server refs");
+    assert!(refs.contains("refs/heads/main"));
+    assert!(refs.contains("refs/heads/feature"));
+    assert!(refs.contains("refs/tags/v1.0"));
+}
+
+#[test]
+fn ls_remote_lists_branches_and_tags_only() {
+    let server = tempfile::tempdir().unwrap();
+    let server_repo = bare_server(server.path(), "npub1test", "my-repo");
+
+    let (dir, repo) = fixture(&[("a.txt", b"one")]);
+    commit_all(&repo, "initial");
+    let dir = dir.path();
+
+    git_run(dir, &["branch", "feature"]);
+    git_run(dir, &["tag", "v1"]);
+    git_run(dir, &["tag", "-a", "v2", "-m", "annotated"]);
+
+    let base_url = format!("file://{}", server.path().display());
+    let local = Repo::open(dir).expect("open");
+    local
+        .push_all(&base_url, "npub1test", "my-repo")
+        .expect("push");
+
+    // Refs outside heads and tags, and the HEAD symref line, are not listed.
+    let main = git_in(dir, &["rev-parse", "refs/heads/main"]).expect("main oid");
+    git_run(&server_repo, &["update-ref", "refs/nostr/abc", &main]);
+
+    let remote = local
+        .ls_remote(&format!("file://{}", server_repo.display()))
+        .expect("ls-remote");
+    let names: Vec<String> = remote.iter().map(|(name, _)| name.clone()).collect();
+
+    assert_eq!(
+        names,
+        vec![
+            "refs/heads/feature".to_owned(),
+            "refs/heads/main".to_owned(),
+            "refs/tags/v1".to_owned(),
+            "refs/tags/v2".to_owned(),
+        ]
+    );
+    assert_eq!(
+        remote
+            .iter()
+            .find(|(name, _)| name == "refs/heads/main")
+            .map(|(_, oid)| oid.as_str()),
+        Some(main.as_str())
+    );
+    // The annotated tag lists the tag object, matching the local ref state,
+    // without a peeled `^{}` duplicate.
+    let v2 = git_in(dir, &["rev-parse", "refs/tags/v2"]).expect("v2 oid");
+    assert_eq!(
+        remote
+            .iter()
+            .find(|(name, _)| name == "refs/tags/v2")
+            .map(|(_, oid)| oid.as_str()),
+        Some(v2.as_str())
+    );
+}
+
+#[test]
+fn push_all_force_updates_diverged_remote_branches() {
+    let server = tempfile::tempdir().unwrap();
+    let server_repo = bare_server(server.path(), "npub1test", "my-repo");
+
+    let (dir, repo) = fixture(&[("a.txt", b"one")]);
+    commit_all(&repo, "initial");
+    std::fs::write(dir.path().join("b.txt"), b"two").expect("write");
+    commit_all(&repo, "second");
+    let dir = dir.path();
+
+    let base_url = format!("file://{}", server.path().display());
+    let local = Repo::open(dir).expect("open");
+    local
+        .push_all(&base_url, "npub1test", "my-repo")
+        .expect("initial push");
+
+    // Diverge local main from the pushed state.
+    git_run(dir, &["reset", "-q", "--hard", "HEAD~1"]);
+    std::fs::write(dir.join("c.txt"), b"three").expect("write");
+    commit_all(&repo, "diverged");
+
+    local
+        .push_all(&base_url, "npub1test", "my-repo")
+        .expect("force push");
+
+    assert_eq!(
+        git_in(dir, &["rev-parse", "refs/heads/main"]).expect("local main"),
+        git_in(&server_repo, &["rev-parse", "refs/heads/main"]).expect("server main")
+    );
+}
+
+#[test]
+fn push_refspecs_deletes_server_refs_missing_locally() {
+    let server = tempfile::tempdir().unwrap();
+    let server_repo = bare_server(server.path(), "npub1test", "my-repo");
+
+    let (dir, repo) = fixture(&[("a.txt", b"one")]);
+    commit_all(&repo, "initial");
+    let dir = dir.path();
+
+    git_run(dir, &["branch", "feature"]);
+    git_run(dir, &["tag", "v1"]);
+
+    let base_url = format!("file://{}", server.path().display());
+    let local = Repo::open(dir).expect("open");
+    local
+        .push_all(&base_url, "npub1test", "my-repo")
+        .expect("initial push");
+
+    git_run(dir, &["branch", "-D", "feature"]);
+    git_run(dir, &["tag", "-d", "v1"]);
+
+    local
+        .push_refspecs(
+            &base_url,
+            "npub1test",
+            "my-repo",
+            &[
+                "+refs/heads/*:refs/heads/*",
+                "+refs/tags/*:refs/tags/*",
+                ":refs/heads/feature",
+                ":refs/tags/v1",
+            ],
+        )
+        .expect("push with deletions");
+
+    let refs = git_in(&server_repo, &["show-ref"]).expect("server refs");
+    assert!(refs.contains("refs/heads/main"));
+    assert!(!refs.contains("refs/heads/feature"));
+    assert!(!refs.contains("refs/tags/v1"));
+}
+
+#[test]
+fn fetch_refs_brings_server_only_branches_into_local() {
+    let server = tempfile::tempdir().unwrap();
+    bare_server(server.path(), "npub1test", "my-repo");
+
+    let (dir, repo) = fixture(&[("a.txt", b"one")]);
+    commit_all(&repo, "initial");
+    let dir = dir.path();
+    git_run(dir, &["branch", "feature"]);
+
+    let base_url = format!("file://{}", server.path().display());
+    Repo::open(dir)
+        .expect("open")
+        .push_all(&base_url, "npub1test", "my-repo")
+        .expect("push");
+    let feature = git_in(dir, &["rev-parse", "refs/heads/feature"]).expect("feature oid");
+
+    // A repository that never had the branch fetches it by name.
+    let (other_dir, _other_repo) = fixture(&[("unrelated.txt", b"x")]);
+    let other = Repo::open(other_dir.path()).expect("open other");
+    let server_url = format!("file://{}/npub1test/my-repo.git", server.path().display());
+    other
+        .fetch_refs(&[&server_url], "+refs/heads/feature:refs/heads/feature")
+        .expect("fetch ref");
+
+    assert_eq!(
+        git_in(other_dir.path(), &["rev-parse", "refs/heads/feature"]).expect("fetched feature"),
+        feature
+    );
+}
+
+#[test]
+fn ref_state_matches_the_git_cli_ref_listing() {
+    let (dir, repo) = fixture(&[("a.txt", b"one")]);
+    commit_all(&repo, "initial");
+    let dir = dir.path();
+
+    git_run(dir, &["branch", "browse-group"]);
+    git_run(dir, &["checkout", "-q", "-b", "new-search"]);
+    std::fs::write(dir.join("b.txt"), b"two").expect("write");
+    commit_all(&repo, "search work");
+    git_run(dir, &["checkout", "-q", "-"]);
+    git_run(dir, &["tag", "v1"]);
+
+    let listing = |repo: &Repo| {
+        let mut refs = repo.ref_state().expect("ref state").refs;
+        refs.sort();
+        refs
+    };
+
+    // Loose refs.
+    let loose = listing(&Repo::open(dir).expect("open"));
+
+    // Packed refs.
+    git_run(dir, &["pack-refs", "--all"]);
+    let packed = listing(&Repo::open(dir).expect("open"));
+
+    let output = git_run(
+        dir,
+        &[
+            "for-each-ref",
+            "--format=%(refname) %(objectname)",
+            "refs/heads",
+            "refs/tags",
+        ],
+    );
+    let mut cli = String::from_utf8_lossy(&output.stdout)
+        .lines()
+        .map(|line| {
+            let (name, oid) = line.split_once(' ').expect("for-each-ref format");
+            (name.to_owned(), oid.to_owned())
+        })
+        .collect::<Vec<_>>();
+    cli.sort();
+
+    assert_eq!(loose, cli);
+    assert_eq!(packed, cli);
+    assert!(
+        loose
+            .iter()
+            .any(|(name, _)| name == "refs/heads/new-search")
+    );
+    assert!(
+        loose
+            .iter()
+            .any(|(name, _)| name == "refs/heads/browse-group")
+    );
+}
+
+#[test]
+fn repo_ref_state_lists_branches_tags_and_head() {
+    let (_dir, repo) = fixture(&[("a.txt", b"hello")]);
+    commit_all(&repo, "initial");
+    let workdir = repo.workdir().expect("workdir").to_path_buf();
+
+    let state = repo.ref_state().expect("refs");
+
+    let branch = repo.current_branch().expect("on a branch");
+    assert_eq!(state.head.as_deref(), Some(branch.as_str()));
+    assert_eq!(state.refs.len(), 1);
+    assert_eq!(state.refs[0].0, format!("refs/heads/{branch}"));
+    assert_eq!(state.refs[0].1.len(), 40);
+
+    git_run(&workdir, &["branch", "feature"]);
+    git_run(&workdir, &["tag", "v1.0"]);
+
+    let state = repo.ref_state().expect("refs");
+    let mut expected: Vec<String> = vec![
+        format!("refs/heads/{branch}"),
+        "refs/heads/feature".to_owned(),
+        "refs/tags/v1.0".to_owned(),
+    ];
+    expected.sort();
+    assert_eq!(
+        state
+            .refs
+            .iter()
+            .map(|(name, _)| name.clone())
+            .collect::<Vec<_>>(),
+        expected
+    );
+
+    git_run(&workdir, &["checkout", "--detach"]);
+    let state = repo.ref_state().expect("refs");
+    assert!(state.head.is_none());
+    assert_eq!(state.refs.len(), 3);
+}
+
+/// Creates a repository fixture with the given files.
+fn fixture(files: &[(&str, &[u8])]) -> (tempfile::TempDir, Repo) {
+    let dir = tempfile::tempdir().expect("tempdir");
+    gix::init(&dir).expect("init");
+
+    for (rel, bytes) in files {
+        let path = dir.path().join(rel);
+        std::fs::create_dir_all(path.parent().expect("parent")).expect("mkdir");
+        std::fs::write(&path, bytes).expect("write");
+    }
+
+    let repo = Repo::open(dir.path()).expect("open");
+    (dir, repo)
+}
+
+/// Stages and commits every change in the repository.
+fn commit_all(repo: &Repo, message: &str) {
+    git_run(repo.workdir().expect("workdir"), &["add", "-A"]);
+    git_run(repo.workdir().expect("workdir"), &["commit", "-m", message]);
+}
+
+#[test]
+fn merge_base_finds_the_fork_point_and_reports_unrelated_history() {
+    let dir = tempfile::tempdir().expect("tempdir");
+    let path = dir.path().join("repo");
+    let initial = Repo::init(&path, "My Repo", "desc").expect("init");
+    let repo = Repo::open(&path).expect("open");
+
+    git_run(&path, &["checkout", "-b", "feature"]);
+    std::fs::write(path.join("feature.txt"), "feature\n").expect("write");
+    commit_all(&repo, "feature commit");
+    git_run(&path, &["checkout", "main"]);
+    std::fs::write(path.join("main.txt"), "main\n").expect("write");
+    commit_all(&repo, "mainline commit");
+
+    assert_eq!(
+        repo.merge_base("feature", "main")
+            .expect("merge base")
+            .as_deref(),
+        Some(initial.as_str())
+    );
+
+    git_run(&path, &["checkout", "--orphan", "orphan"]);
+    std::fs::write(path.join("orphan.txt"), "orphan\n").expect("write");
+    commit_all(&repo, "orphan commit");
+    assert_eq!(repo.merge_base("orphan", "main").expect("ok"), None);
+
+    assert!(repo.merge_base("orphan", "no-such-ref").is_err());
+}
+
+#[test]
+fn split_patch_series_splits_real_multi_commit_mboxes() {
+    let dir = tempfile::tempdir().expect("tempdir");
+    let path = dir.path().join("repo");
+    let initial = Repo::init(&path, "My Repo", "desc").expect("init");
+    let repo = Repo::open(&path).expect("open");
+
+    git_run(&path, &["checkout", "-b", "feature"]);
+    std::fs::write(path.join("one.txt"), "one\n").expect("write");
+    commit_all(&repo, "first commit");
+    std::fs::write(path.join("two.txt"), "two\n").expect("write");
+    commit_all(&repo, "second commit");
+
+    let series = repo
+        .format_patch_between(&initial, "feature")
+        .expect("series");
+    let parts = PatchParser::split_patch_series(&series);
+
+    assert_eq!(parts.len(), 2);
+    assert!(parts[0].contains("Subject: [PATCH 1/2] first commit"));
+    assert!(parts[1].contains("Subject: [PATCH 2/2] second commit"));
+    let first = parts[0].lines().next().expect("first header");
+    let second = parts[1].lines().next().expect("second header");
+    assert!(first.starts_with("From ") && first.len() >= 45);
+    assert_ne!(first, second);
+}
+
+#[test]
+fn head_commit_and_commits_since_track_applied_commits() {
+    let dir = tempfile::tempdir().expect("tempdir");
+    let path = dir.path().join("repo");
+    let initial = Repo::init(&path, "My Repo", "desc").expect("init");
+    let repo = Repo::open(&path).expect("open");
+
+    assert_eq!(repo.head().as_deref(), Some(initial.as_str()));
+    assert_eq!(
+        repo.commits_since(None).expect("commits"),
+        vec![initial.clone()]
+    );
+
+    std::fs::write(path.join("one.txt"), "one\n").expect("write");
+    commit_all(&repo, "first commit");
+    let first = repo.head().expect("on a branch");
+
+    std::fs::write(path.join("two.txt"), "two\n").expect("write");
+    commit_all(&repo, "second commit");
+    let second = repo.head().expect("on a branch");
+
+    assert_eq!(
+        repo.commits_since(Some(&initial)).expect("commits"),
+        vec![first.clone(), second.clone()]
+    );
+    assert_eq!(
+        repo.commits_since(Some(&first)).expect("commits"),
+        vec![second]
+    );
+}
+
+#[test]
+fn working_copy_cloned_from_the_mirror_matches_head_and_origin() {
+    let dir = tempfile::tempdir().expect("tempdir");
+    let mirror = dir.path().join("mirror");
+    let commit = Repo::init(&mirror, "My Repo", "Does things.").expect("init");
+    Repo::open(&mirror)
+        .expect("open")
+        .ensure_origin("https://gitnostr.com/npub1test/my-repo.git")
+        .expect("origin");
+
+    let destination = dir.path().join("folder").join("My_Repo");
+    std::fs::create_dir_all(destination.parent().unwrap()).expect("parent");
+    Repo::clone(&[format!("file://{}", mirror.display())], &destination).expect("clone");
+    Repo::open(&destination)
+        .expect("open")
+        .set_origin("https://gitnostr.com/npub1test/my-repo.git")
+        .expect("set origin");
+    let working = Repo::open(&destination).expect("open");
+
+    assert_eq!(
+        working.origin_url().expect("url").as_deref(),
+        Some("https://gitnostr.com/npub1test/my-repo.git")
+    );
+    assert_eq!(working.head().as_deref(), Some(commit.as_str()));
+    assert!(destination.join("README.md").is_file());
+}
+
+#[test]
+fn fast_forward_branches_moves_the_mirror_and_keeps_local_work() {
+    let dir = tempfile::tempdir().expect("tempdir");
+    bare_server(dir.path(), "npub1test", "repo");
+
+    let (work_dir, work_repo) = fixture(&[("a.txt", b"one")]);
+    commit_all(&work_repo, "initial");
+    let work = work_dir.path();
+    let base_url = format!("file://{}", dir.path().display());
+    work_repo
+        .push_all(&base_url, "npub1test", "repo")
+        .expect("push");
+
+    let mirror = dir.path().join("mirror");
+    git_run(
+        dir.path(),
+        &[
+            "clone",
+            "-q",
+            &format!("{base_url}/npub1test/repo.git"),
+            mirror.to_str().unwrap(),
+        ],
+    );
+    let initial = git_in(&mirror, &["rev-parse", "HEAD"]).expect("initial");
+    let repo = Repo::open(&mirror).expect("open");
+
+    std::fs::write(work.join("new.txt"), b"new\n").expect("write");
+    commit_all(&work_repo, "new commit");
+    work_repo
+        .push_all(&base_url, "npub1test", "repo")
+        .expect("push");
+    git_run(&mirror, &["fetch", "origin"]);
+    let remote = git_in(&mirror, &["rev-parse", "refs/remotes/origin/main"]).expect("remote");
+    assert_eq!(
+        git_in(&mirror, &["rev-parse", "HEAD"]).expect("local"),
+        initial
+    );
+    assert_ne!(remote, initial);
+
+    assert!(repo.fast_forward_branches().expect("ff"));
+    assert_eq!(
+        git_in(&mirror, &["rev-parse", "HEAD"]).expect("local"),
+        remote
+    );
+    assert!(mirror.join("new.txt").is_file());
+    assert!(!repo.fast_forward_branches().expect("idle"));
+
+    git_run(&mirror, &["checkout", "-b", "wip"]);
+    std::fs::write(mirror.join("wip.txt"), b"wip\n").expect("write");
+    commit_all(&repo, "local wip");
+    let wip = git_in(&mirror, &["rev-parse", "HEAD"]).expect("wip");
+    assert!(!repo.fast_forward_branches().expect("wip skipped"));
+    assert_eq!(
+        git_in(&mirror, &["rev-parse", "HEAD"]).expect("wip kept"),
+        wip
+    );
+}
+
+#[test]
+fn fetch_repo_refs_imports_heads_under_a_prefix() {
+    let dir = tempfile::tempdir().expect("tempdir");
+
+    let base_server = bare_server(dir.path(), "npub1base", "base");
+
+    let (upstream_dir, upstream_repo) = fixture(&[("a.txt", b"one")]);
+    commit_all(&upstream_repo, "initial");
+    let upstream_path = upstream_dir.path();
+    let initial = git_in(upstream_path, &["rev-parse", "HEAD"]).expect("initial");
+    upstream_repo
+        .push_all(
+            &format!("file://{}", dir.path().display()),
+            "npub1base",
+            "base",
+        )
+        .expect("push");
+
+    let base_url = format!("file://{}", base_server.display());
+    let mirror = dir.path().join("mirror");
+    git_run(
+        dir.path(),
+        &["clone", "-q", &base_url, mirror.to_str().unwrap()],
+    );
+    let mirror_repo = Repo::open(&mirror).expect("open");
+
+    let fork_work = dir.path().join("fork-work");
+    git_run(
+        dir.path(),
+        &["clone", "-q", &base_url, fork_work.to_str().unwrap()],
+    );
+    git_run(&fork_work, &["checkout", "-b", "feature"]);
+    std::fs::write(fork_work.join("feature.txt"), "feature\n").expect("write");
+    commit_all(&Repo::open(&fork_work).expect("open"), "feature commit");
+    let tip = git_in(&fork_work, &["rev-parse", "HEAD"]).expect("tip");
+
+    let fork_server = bare_server(dir.path(), "npub1fork", "fork");
+    Repo::open(&fork_work)
+        .expect("open")
+        .push_ref(
+            &format!("file://{}", fork_server.display()),
+            &tip,
+            "refs/heads/feature",
+        )
+        .expect("push");
+
+    let dead = format!("file://{}/missing.git", dir.path().display());
+    mirror_repo
+        .fetch_refs(
+            &[dead, format!("file://{}", fork_server.display())],
+            "+refs/heads/*:refs/fork/npub1fork/fork/*",
+        )
+        .expect("fetch");
+
+    assert_eq!(
+        mirror_repo
+            .refs_with_prefix("refs/fork/npub1fork/fork")
+            .expect("refs"),
+        vec!["refs/fork/npub1fork/fork/feature"]
+    );
+    assert_eq!(
+        mirror_repo
+            .refs_with_prefix("refs/heads/fork")
+            .expect("refs"),
+        Vec::<String>::new()
+    );
+
+    assert_eq!(
+        mirror_repo
+            .merge_base(
+                "refs/remotes/origin/main",
+                "refs/fork/npub1fork/fork/feature",
+            )
+            .expect("merge base")
+            .as_deref(),
+        Some(initial.as_str())
+    );
+    let patch = mirror_repo
+        .format_patch_between(&initial, "refs/fork/npub1fork/fork/feature")
+        .expect("patch");
+    assert!(patch.contains("Subject: [PATCH] feature commit"));
+    assert!(patch.contains("feature.txt"));
+
+    mirror_repo
+        .delete_refs_with_prefix("refs/fork/npub1fork/fork")
+        .expect("delete");
+    assert_eq!(
+        mirror_repo
+            .refs_with_prefix("refs/fork/npub1fork/fork")
+            .expect("refs"),
+        Vec::<String>::new()
+    );
+}
+
+/// Runs `git` in `dir`, failing the test on a non-zero exit.
+fn git_run(dir: &Path, args: &[&str]) -> std::process::Output {
+    let output = Command::new("git")
+        .current_dir(dir)
+        .env("GIT_AUTHOR_NAME", "Test Author")
+        .env("GIT_AUTHOR_EMAIL", "test@example.com")
+        .env("GIT_COMMITTER_NAME", "Test Author")
+        .env("GIT_COMMITTER_EMAIL", "test@example.com")
+        .env("GIT_EDITOR", "true")
+        .args(args)
+        .output()
+        .expect("spawn git");
+    assert!(output.status.success(), "git {args:?} failed");
+    output
+}
+
+#[test]
+fn find_git_repos_reports_the_outermost_repository() {
+    let root = tempfile::tempdir().expect("tempdir");
+    let repo_dir = root.path().join("project").join("sub");
+    std::fs::create_dir_all(&repo_dir).expect("mkdir");
+    git_run(&repo_dir, &["init", "-q"]);
+
+    let plain_dir = root.path().join("plain").join("deep");
+    std::fs::create_dir_all(&plain_dir).expect("mkdir");
+
+    let repos = find_git_repos(root.path());
+
+    assert_eq!(repos.len(), 1);
+    assert_eq!(repos[0].path, repo_dir.canonicalize().expect("canonical"));
+    assert!(repos[0].nip34.is_none());
+}
+
+#[test]
+fn find_git_repos_skips_repositories_nested_in_repositories() {
+    let root = tempfile::tempdir().expect("tempdir");
+    let outer = root.path().join("outer");
+    std::fs::create_dir_all(&outer).expect("mkdir");
+    git_run(&outer, &["init", "-q"]);
+
+    let nested = outer.join("nested");
+    std::fs::create_dir_all(&nested).expect("mkdir");
+    git_run(&nested, &["init", "-q"]);
+
+    let repos = find_git_repos(root.path());
+
+    assert_eq!(repos.len(), 1);
+    assert_eq!(repos[0].path, outer.canonicalize().expect("canonical"));
+}
+
+#[test]
+fn find_git_repos_ignores_a_repository_above_the_scan_root() {
+    let outer = tempfile::tempdir().expect("tempdir");
+    git_run(outer.path(), &["init", "-q"]);
+
+    let root = outer.path().join("scan");
+    std::fs::create_dir_all(&root).expect("mkdir");
+
+    assert!(find_git_repos(&root).is_empty());
+}
+
+/// Creates an empty bare server repository for push tests.
+fn bare_server(base: &Path, owner: &str, name: &str) -> PathBuf {
+    let repo = base.join(owner).join(format!("{name}.git"));
+    std::fs::create_dir_all(repo.parent().expect("parent")).expect("mkdir");
+    git_run(
+        base,
+        &["init", "--bare", "-q", repo.to_str().expect("utf8 path")],
+    );
+    repo
+}
+
+#[test]
+fn patch_commits_lists_every_patch_in_order() {
+    let patch = r#"From 1111111111111111111111111111111111111111 Mon Sep 17 00:00:00 2001
+From: Alice <alice@example.com>
+Date: Tue, 1 Aug 2023 10:00:00 +0200
+Subject: [PATCH 1/2] first
+
+body one
+---
+ a.txt | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/a.txt b/a.txt
+@@ -1 +1,2 @@
+ a
++b
+
+From 2222222222222222222222222222222222222222 Mon Sep 17 00:00:00 2001
+From: Bob <bob@example.com>
+Date: Wed, 2 Aug 2023 11:30:00 +0000
+Subject: [PATCH 2/2] second
+
+body two
+---
+ b.txt | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/b.txt b/b.txt
+@@ -1 +1,2 @@
+ x
++y
+"#;
+
+    let commits = PatchParser::patch_commits(patch);
+    assert_eq!(commits.len(), 2);
+
+    assert_eq!(commits[0].id, "1111111111111111111111111111111111111111");
+    assert_eq!(commits[0].summary, "first");
+    assert_eq!(commits[0].author, "Alice");
+    assert_eq!(commits[0].time, 1690876800);
+
+    assert_eq!(commits[1].id, "2222222222222222222222222222222222222222");
+    assert_eq!(commits[1].summary, "second");
+    assert_eq!(commits[1].author, "Bob");
+    assert_eq!(commits[1].time, 1690975800);
+}
+
+#[test]
+fn parses_real_format_patch_output() {
+    let (dir, repo) = fixture(&[
+        ("src/main.rs", b"fn main() {\n    println!(\"one\");\n}\n"),
+        ("my file.txt", b"hello\n"),
+        ("\u{8bf4}\u{660e}.md", "# \u{8bf4}\u{660e}\n".as_bytes()),
+        ("img.png", b"\x89PNG\r\n\x1a\n\x00binary"),
+    ]);
+    commit_all(&repo, "initial");
+
+    std::fs::write(
+        dir.path().join("src/main.rs"),
+        b"fn main() {\n    println!(\"two\");\n    println!(\"three\");\n}\n",
+    )
+    .expect("write");
+    std::fs::write(dir.path().join("my file.txt"), b"hello world\n").expect("write");
+    std::fs::write(
+        dir.path().join("\u{8bf4}\u{660e}.md"),
+        "# \u{8bf4}\u{660e}\nupdated\n",
+    )
+    .expect("write");
+    std::fs::remove_file(dir.path().join("img.png")).expect("remove");
+    std::fs::write(dir.path().join("new file.md"), b"# new\n").expect("write");
+    commit_all(&repo, "changes");
+
+    let output = git_run(dir.path(), &["format-patch", "-1", "--stdout"]);
+    let patch = String::from_utf8(output.stdout).expect("patch is utf-8");
+
+    let diff = PatchParser::patch_diffs(&patch).expect("parse real format-patch output");
+
+    let by_path = |path: &str| {
+        diff.files
+            .iter()
+            .find(|file| file.path == path)
+            .unwrap_or_else(|| panic!("missing file {path:?}"))
+    };
+
+    let file = by_path("my file.txt");
+    assert_eq!(file.status, DiffStatus::Modified);
+    assert_eq!(file.insertions, 1);
+
+    let file = by_path("\u{8bf4}\u{660e}.md");
+    assert_eq!(file.status, DiffStatus::Modified);
+    assert_eq!(file.insertions, 1);
+
+    let file = by_path("src/main.rs");
+    assert_eq!(file.status, DiffStatus::Modified);
+    assert_eq!(file.insertions, 2);
+    assert_eq!(file.deletions, 1);
+    assert!(!file.hunks.is_empty());
+
+    let file = by_path("new file.md");
+    assert_eq!(file.status, DiffStatus::Added);
+    assert_eq!(file.insertions, 1);
+
+    let file = by_path("img.png");
+    assert_eq!(file.status, DiffStatus::Deleted);
+    assert!(file.binary);
+    assert!(file.hunks.is_empty());
+    assert_eq!(file.insertions, 0);
+    assert_eq!(file.deletions, 0);
+}

crates/signed_git/src/worktree.rs

@@ -0,0 +1,36 @@
+use std::path::PathBuf;
+
+use crate::history::FileCommit;
+
+pub struct WorktreeSnapshot {
+    pub entries: Vec<PathBuf>,
+    pub readme_path: Option<PathBuf>,
+    pub readme: Option<Vec<u8>>,
+    pub current_branch: Option<String>,
+    pub head_commit: Option<FileCommit>,
+    pub branches: Vec<String>,
+    pub tags: Vec<String>,
+}
+
+impl WorktreeSnapshot {
+    /// Creates a snapshot of the worktree contents and ref state.
+    pub(crate) fn new(
+        entries: Vec<PathBuf>,
+        readme_path: Option<PathBuf>,
+        readme: Option<Vec<u8>>,
+        current_branch: Option<String>,
+        head_commit: Option<FileCommit>,
+        branches: Vec<String>,
+        tags: Vec<String>,
+    ) -> Self {
+        Self {
+            entries,
+            readme_path,
+            readme,
+            current_branch,
+            head_commit,
+            branches,
+            tags,
+        }
+    }
+}

crates/signed_nostr/Cargo.toml

@@ -5,18 +5,10 @@ edition.workspace = true
 publish.workspace = true
 
 [dependencies]
-signed_core = { path = "../signed_core" }
-
-nostr.workspace = true
 nostr-sdk.workspace = true
 nostr-connect.workspace = true
 nostr-gossip-memory.workspace = true
+nostr-lmdb.workspace = true
 
 anyhow.workspace = true
 webbrowser.workspace = true
-
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-nostr-memory.workspace = true
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-nostr-lmdb.workspace = true

crates/signed_nostr/src/backend.rs

@@ -1,56 +1,47 @@
-#[cfg(not(target_arch = "wasm32"))]
 use std::path::Path;
 use std::time::Duration;
 
 use anyhow::{Context, Result};
 use nostr_gossip_memory::prelude::*;
-#[cfg(not(target_arch = "wasm32"))]
 use nostr_lmdb::prelude::*;
-#[cfg(target_arch = "wasm32")]
-use nostr_memory::prelude::*;
 use nostr_sdk::prelude::*;
 
 use crate::signer::UniversalSigner;
 
-/// Open (or create) the LMDB database at `db_path` and build a client
-/// configured for Signed, together with a fresh signer.
-///
-/// The SDK manages its own internal tokio runtime; the returned client can be
-/// driven by GPUI's executors.
-#[cfg(not(target_arch = "wasm32"))]
-pub async fn new_backend(db_path: impl AsRef<Path>) -> Result<(Client, UniversalSigner)> {
-    let signer = UniversalSigner::new(Keys::generate());
-    let database = NostrLmdb::open(db_path)
-        .await
-        .context("failed to open nostr database")?;
-    Ok(with_database(signer, database))
+pub struct NostrBackend {
+    pub client: Client,
+    pub signer: UniversalSigner,
 }
 
-/// In-memory database on wasm (no LMDB available).
-#[cfg(target_arch = "wasm32")]
-pub fn new_backend() -> Result<(Client, UniversalSigner)> {
-    let signer = UniversalSigner::new(Keys::generate());
-    Ok(with_database(signer, MemoryDatabase::unbounded()))
-}
+impl NostrBackend {
+    pub async fn open(db_path: impl AsRef<Path>) -> Result<Self> {
+        let db_path = db_path.as_ref();
+        let signer = UniversalSigner::new(Keys::generate());
+        let database = NostrLmdb::open(db_path)
+            .await
+            .context("failed to open nostr database")?;
+        Ok(Self::with_database(signer, database))
+    }
 
-fn with_database<D>(signer: UniversalSigner, database: D) -> (Client, UniversalSigner)
-where
-    D: IntoNostrDatabase,
-{
-    let authenticator = SignerAuthenticator::new(signer.clone());
+    fn with_database<D>(signer: UniversalSigner, database: D) -> Self
+    where
+        D: IntoNostrDatabase,
+    {
+        let authenticator = SignerAuthenticator::new(signer.clone());
 
-    let client = ClientBuilder::default()
-        .database(database)
-        .authenticator(authenticator)
-        .gossip(NostrGossipMemory::unbounded())
-        .gossip_config(GossipConfig::default().no_background_refresh())
-        .connect_timeout(Duration::from_secs(10))
-        .verify_subscriptions(true)
-        .ban_relay_on_mismatch(true)
-        .sleep_when_idle(SleepWhenIdle::Enabled {
-            timeout: Duration::from_secs(600),
-        })
-        .build();
+        let client = ClientBuilder::default()
+            .database(database)
+            .authenticator(authenticator)
+            .gossip(NostrGossipMemory::unbounded())
+            .gossip_config(GossipConfig::default().no_background_refresh())
+            .connect_timeout(Duration::from_secs(10))
+            .verify_subscriptions(true)
+            .ban_relay_on_mismatch(true)
+            .sleep_when_idle(SleepWhenIdle::Enabled {
+                timeout: Duration::from_secs(600),
+            })
+            .build();
 
-    (client, signer)
+        Self { client, signer }
+    }
 }

crates/signed_nostr/src/lib.rs

@@ -2,6 +2,6 @@ mod backend;
 mod signer;
 mod update;
 
-pub use backend::new_backend;
+pub use backend::NostrBackend;
 pub use signer::{SignedAuthUrlHandler, UniversalSigner};
 pub use update::Update;

crates/signed_nostr/src/signer.rs

@@ -5,34 +5,9 @@ use std::pin::Pin;
 use std::sync::{Arc, RwLock};
 
 use nostr_connect::client::AuthUrlHandler;
+use nostr_sdk::error::Error as SignerError;
 use nostr_sdk::prelude::*;
 
-#[derive(Debug)]
-pub struct UniversalSignerError(Box<dyn Error + Send + Sync + 'static>);
-
-impl fmt::Display for UniversalSignerError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl Error for UniversalSignerError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        Some(&*self.0)
-    }
-}
-
-impl UniversalSignerError {
-    pub fn new<E>(err: E) -> Self
-    where
-        E: Error + Send + Sync + 'static,
-    {
-        UniversalSignerError(Box::new(err))
-    }
-}
-
-/// A type-erased signer whose inner signer can be swapped in-place
-/// (e.g. after login/logout). All clones see the swap.
 #[derive(Clone, Debug)]
 pub struct UniversalSigner {
     inner: Arc<RwLock<Arc<dyn InnerSigner>>>,
@@ -51,7 +26,6 @@ impl UniversalSigner {
         }
     }
 
-    /// Swap the inner signer in-place. All clones see the new signer.
     pub fn swap_inner<T>(&self, new_signer: T)
     where
         T: AsyncGetPublicKey + AsyncSignEvent + AsyncNip44 + 'static,
@@ -66,21 +40,21 @@ impl UniversalSigner {
 trait InnerSigner: fmt::Debug + Send + Sync + 'static {
     fn get_public_key_async(
         &self,
-    ) -> Pin<Box<dyn Future<Output = Result<PublicKey, UniversalSignerError>> + Send + '_>>;
+    ) -> Pin<Box<dyn Future<Output = Result<PublicKey, SignerError>> + Send + '_>>;
     fn sign_event_async(
         &self,
         unsigned: UnsignedEvent,
-    ) -> Pin<Box<dyn Future<Output = Result<Event, UniversalSignerError>> + Send + '_>>;
+    ) -> Pin<Box<dyn Future<Output = Result<Event, SignerError>> + Send + '_>>;
     fn nip44_encrypt_async<'a>(
         &'a self,
         public_key: &'a PublicKey,
         content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, UniversalSignerError>> + Send + 'a>>;
+    ) -> Pin<Box<dyn Future<Output = Result<String, SignerError>> + Send + 'a>>;
     fn nip44_decrypt_async<'a>(
         &'a self,
         public_key: &'a PublicKey,
         payload: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, UniversalSignerError>> + Send + 'a>>;
+    ) -> Pin<Box<dyn Future<Output = Result<String, SignerError>> + Send + 'a>>;
 }
 
 #[derive(Debug)]
@@ -95,22 +69,22 @@ where
 {
     fn get_public_key_async(
         &self,
-    ) -> Pin<Box<dyn Future<Output = Result<PublicKey, UniversalSignerError>> + Send + '_>> {
+    ) -> Pin<Box<dyn Future<Output = Result<PublicKey, SignerError>> + Send + '_>> {
         Box::pin(async move {
             AsyncGetPublicKey::get_public_key_async(&self.0)
                 .await
-                .map_err(UniversalSignerError::new)
+                .map_err(SignerError::other)
         })
     }
 
     fn sign_event_async(
         &self,
         unsigned: UnsignedEvent,
-    ) -> Pin<Box<dyn Future<Output = Result<Event, UniversalSignerError>> + Send + '_>> {
+    ) -> Pin<Box<dyn Future<Output = Result<Event, SignerError>> + Send + '_>> {
         Box::pin(async move {
             AsyncSignEvent::sign_event_async(&self.0, unsigned)
                 .await
-                .map_err(UniversalSignerError::new)
+                .map_err(SignerError::other)
         })
     }
 
@@ -118,11 +92,11 @@ where
         &'a self,
         public_key: &'a PublicKey,
         content: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, UniversalSignerError>> + Send + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Result<String, SignerError>> + Send + 'a>> {
         Box::pin(async move {
             AsyncNip44::nip44_encrypt_async(&self.0, public_key, content)
                 .await
-                .map_err(UniversalSignerError::new)
+                .map_err(SignerError::other)
         })
     }
 
@@ -130,17 +104,17 @@ where
         &'a self,
         public_key: &'a PublicKey,
         payload: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<String, UniversalSignerError>> + Send + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Result<String, SignerError>> + Send + 'a>> {
         Box::pin(async move {
             AsyncNip44::nip44_decrypt_async(&self.0, public_key, payload)
                 .await
-                .map_err(UniversalSignerError::new)
+                .map_err(SignerError::other)
         })
     }
 }
 
 impl AsyncGetPublicKey for UniversalSigner {
-    type Error = UniversalSignerError;
+    type Error = SignerError;
 
     fn get_public_key_async(
         &self,
@@ -151,7 +125,7 @@ impl AsyncGetPublicKey for UniversalSigner {
 }
 
 impl AsyncSignEvent for UniversalSigner {
-    type Error = UniversalSignerError;
+    type Error = SignerError;
 
     fn sign_event_async(
         &self,
@@ -163,7 +137,7 @@ impl AsyncSignEvent for UniversalSigner {
 }
 
 impl AsyncNip44 for UniversalSigner {
-    type Error = UniversalSignerError;
+    type Error = SignerError;
 
     fn nip44_encrypt_async<'a>(
         &'a self,
@@ -184,7 +158,6 @@ impl AsyncNip44 for UniversalSigner {
     }
 }
 
-/// Opens the NIP-46 auth URL in the default browser.
 #[derive(Debug, Clone)]
 pub struct SignedAuthUrlHandler;
 

crates/signed_nostr/src/update.rs

@@ -1,19 +1,13 @@
 use nostr_sdk::prelude::*;
 
-/// A lightweight "something changed" signal for the UI.
-///
-/// Heavy data stays in the database; consumers re-query on receipt.
 #[derive(Debug, Clone)]
 pub struct Update {
     pub kind: Kind,
-    /// First `a` tag value of the event, if any (e.g. the repository coordinate).
     pub coordinate: Option<Coordinate>,
     pub author: PublicKey,
-    pub event_id: EventId,
 }
 
 impl Update {
-    /// Build an update from a received event.
     pub fn from_event(event: &Event) -> Self {
         let coordinate = event.tags.coordinates().nth(0);
 
@@ -21,7 +15,6 @@ impl Update {
             kind: event.kind,
             coordinate,
             author: event.pubkey,
-            event_id: event.id,
         }
     }
 }

crates/signed_state/Cargo.toml

@@ -8,6 +8,7 @@ publish.workspace = true
 signed_core = { path = "../signed_core" }
 signed_git = { path = "../signed_git" }
 signed_nostr = { path = "../signed_nostr" }
+settings = { path = "../settings" }
 utils = { path = "../utils" }
 
 nostr.workspace = true
@@ -16,10 +17,16 @@ nostr-connect.workspace = true
 
 bitcoin_hashes = "1"
 
+gix.workspace = true
 gpui.workspace = true
 flume.workspace = true
+futures.workspace = true
 anyhow.workspace = true
 log.workspace = true
+serde_json.workspace = true
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 rustls = "0.23"
+
+[dev-dependencies]
+tempfile = "3"

crates/signed_state/src/bootstrap.rs

@@ -0,0 +1,87 @@
+use std::collections::HashMap;
+use std::time::Duration;
+
+use anyhow::Error;
+use nostr_connect::prelude::*;
+use nostr_sdk::client::SyncSummary;
+use nostr_sdk::prelude::*;
+use signed_core::Filters;
+
+pub const BOOTSTRAP_RELAYS: [&str; 2] = ["wss://relay.ditto.pub", "wss://index.ngit.dev"];
+pub const INDEXER_RELAYS: [&str; 2] = ["wss://indexer.coracle.social", "wss://user.kindpag.es"];
+
+pub(crate) async fn ensure_bootstrap_relays(client: &Client) -> Result<(), Error> {
+    for url in BOOTSTRAP_RELAYS {
+        client.add_relay(url).and_connect().await?;
+    }
+
+    for url in INDEXER_RELAYS {
+        client
+            .add_relay(url)
+            .capabilities(RelayCapabilities::DISCOVERY)
+            .and_connect()
+            .await?;
+    }
+
+    Ok(())
+}
+
+pub(crate) async fn subscribe_bootstrap_only(
+    client: &Client,
+    filters: Vec<Filter>,
+) -> Result<(), Error> {
+    ensure_bootstrap_relays(client).await?;
+
+    let opts = SubscribeAutoCloseOptions::default()
+        .exit_policy(ReqExitPolicy::ExitOnEOSE)
+        .timeout(Some(Duration::from_secs(10)));
+
+    let target: HashMap<&str, Vec<Filter>> = BOOTSTRAP_RELAYS
+        .iter()
+        .map(|relay| (*relay, filters.clone()))
+        .collect();
+
+    client.subscribe(target).close_on(opts).await?;
+
+    Ok(())
+}
+
+pub async fn sync_bootstrap_only(
+    client: &Client,
+    filter: Filter,
+    opts: SyncOptions,
+) -> Result<SyncSummary, Error> {
+    ensure_bootstrap_relays(client).await?;
+
+    let output = client
+        .sync(filter)
+        .with(BOOTSTRAP_RELAYS)
+        .opts(opts)
+        .await?;
+
+    Ok(output.value)
+}
+
+fn grasp_list_servers(event: &Event) -> Vec<RelayUrl> {
+    event
+        .tags
+        .iter()
+        .filter(|tag| tag.kind() == "g")
+        .filter_map(|tag| tag.content())
+        .filter_map(|url| RelayUrl::parse(url).ok())
+        .collect()
+}
+
+pub async fn user_grasp_list_servers(
+    client: &Client,
+    user: PublicKey,
+) -> Result<Vec<RelayUrl>, Error> {
+    let events: Vec<Event> = client
+        .database()
+        .query(Filters::grasp_list(user).limit(1))
+        .await?
+        .into_iter()
+        .collect();
+
+    Ok(events.first().map(grasp_list_servers).unwrap_or_default())
+}

crates/signed_state/src/checkouts.rs

@@ -0,0 +1,654 @@
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+
+use anyhow::Error;
+use gpui::{App, AppContext, Context, Entity, Global, Subscription};
+use nostr::prelude::*;
+use settings::{CheckoutRecord, CheckoutsSettings, SettingsStore};
+use signed_core::{Announcement, RepoAddr};
+use signed_git::Repo;
+use utils::same_repo_url;
+
+use crate::backend::{Backend, BackendEvent};
+use crate::git_store::Mirrors;
+use crate::local_repos::LocalReposStore;
+use crate::refresh::{RefreshGate, RefreshRequest};
+use crate::repos::RepoListStore;
+
+const REFRESH_DEBOUNCE: Duration = Duration::from_millis(300);
+const MAX_STATUS_CHECKOUTS: usize = 8;
+const LOCAL_POLL: Duration = Duration::from_secs(2);
+const STATUS_POLL: Duration = Duration::from_secs(15);
+const PUSH_POLL: Duration = Duration::from_secs(60);
+
+struct GlobalCheckoutsStore(Entity<CheckoutsStore>);
+
+impl Global for GlobalCheckoutsStore {}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CheckoutStatus {
+    pub path: PathBuf,
+    /// A detached checkout is idle and yields no status.
+    pub branch: String,
+    /// For tip-based PR dedupe.
+    pub head: String,
+    /// `refs/remotes/origin/<branch>`, else `origin/HEAD` for new branches.
+    pub base: String,
+    /// Zero-ahead checkouts are dropped, so always above zero.
+    pub ahead: u32,
+}
+
+struct Remembered {
+    path: PathBuf,
+    addr: RepoAddr,
+    last_used: u64,
+}
+
+impl Remembered {
+    fn resolve_associations<'a, A>(
+        remembered: &[Remembered],
+        scanned: &[(PathBuf, Option<String>, Option<String>)],
+        announcements: A,
+    ) -> HashMap<RepoAddr, Vec<PathBuf>>
+    where
+        A: IntoIterator<Item = &'a Announcement>,
+    {
+        let announcements: Vec<&Announcement> = announcements.into_iter().collect();
+        let mut out: HashMap<RepoAddr, Vec<PathBuf>> = HashMap::new();
+
+        let mut sorted: Vec<&Remembered> = remembered.iter().collect();
+        sorted.sort_by_key(|record| std::cmp::Reverse(record.last_used));
+        for record in sorted {
+            let paths = out.entry(record.addr.clone()).or_default();
+            if !paths.contains(&record.path) {
+                paths.push(record.path.clone());
+            }
+        }
+
+        for (path, origin, root) in scanned {
+            for announcement in &announcements {
+                let url_match = origin.as_deref().is_some_and(|origin| {
+                    announcement
+                        .clone
+                        .iter()
+                        .any(|url| same_repo_url(origin, url.as_str()))
+                });
+
+                let euc_match = root
+                    .as_deref()
+                    .is_some_and(|root| announcement.euc.as_deref() == Some(root));
+
+                if url_match || euc_match {
+                    let paths = out.entry(announcement.addr()).or_default();
+                    if !paths.contains(path) {
+                        paths.push(path.clone());
+                    }
+                }
+            }
+        }
+
+        out
+    }
+}
+
+pub struct CheckoutsStore {
+    by_repo: HashMap<RepoAddr, Vec<PathBuf>>,
+    statuses: HashMap<RepoAddr, Vec<CheckoutStatus>>,
+    status_requested: HashSet<RepoAddr>,
+    push_requested: HashSet<RepoAddr>,
+    push_statuses: HashMap<RepoAddr, Vec<CheckoutStatus>>,
+    requested_head: HashMap<RepoAddr, Option<String>>,
+    refresh: RefreshGate,
+    debounce_pending: bool,
+    local_pending: bool,
+    last_full_sync: Option<Instant>,
+    checkouts_settings: CheckoutsSettings,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl CheckoutsStore {
+    pub fn global(cx: &App) -> Entity<Self> {
+        cx.global::<GlobalCheckoutsStore>().0.clone()
+    }
+
+    pub(crate) fn set_global(entity: Entity<Self>, cx: &mut App) {
+        cx.set_global(GlobalCheckoutsStore(entity));
+    }
+
+    pub fn new(cx: &mut Context<Self>) -> Self {
+        let mut subscriptions = Vec::new();
+        let mut checkouts_settings = CheckoutsSettings::default();
+
+        if !cfg!(target_arch = "wasm32") {
+            let settings = SettingsStore::global(cx);
+            let local = LocalReposStore::global(cx);
+            let repos = RepoListStore::global(cx);
+            let backend = Backend::global(cx);
+
+            checkouts_settings = settings.read(cx).settings().checkouts.clone();
+
+            subscriptions.push(cx.observe(&settings, |this, settings, cx| {
+                let checkouts = settings.read(cx).settings().checkouts.clone();
+                if this.checkouts_settings == checkouts {
+                    return;
+                }
+                // Only edits to the checkouts section affect the derived state
+                this.checkouts_settings = checkouts;
+                this.refresh(cx);
+            }));
+
+            subscriptions.push(cx.observe(&local, |this, _local, cx| {
+                this.refresh(cx);
+            }));
+
+            subscriptions.push(cx.observe(&repos, |this, _repos, cx| {
+                this.refresh(cx);
+            }));
+
+            // Another identity's repositories must not keep the old statuses alive.
+            subscriptions.push(cx.subscribe(&backend, |this, _backend, event, cx| {
+                if matches!(event, BackendEvent::SignerChanged) {
+                    this.status_requested.clear();
+                    this.push_requested.clear();
+                    this.requested_head.clear();
+                    this.statuses.clear();
+                    this.push_statuses.clear();
+                    cx.notify();
+
+                    this.refresh(cx);
+                }
+            }));
+        }
+
+        if !cfg!(target_arch = "wasm32") {
+            let weak = cx.entity().downgrade();
+            cx.defer(move |cx| {
+                weak.update(cx, |this, cx| {
+                    this.refresh(cx);
+                })
+                .ok();
+            });
+        }
+
+        Self {
+            by_repo: HashMap::new(),
+            statuses: HashMap::new(),
+            status_requested: HashSet::new(),
+            push_requested: HashSet::new(),
+            push_statuses: HashMap::new(),
+            requested_head: HashMap::new(),
+            refresh: RefreshGate::default(),
+            debounce_pending: false,
+            local_pending: false,
+            last_full_sync: None,
+            checkouts_settings,
+            _subscriptions: subscriptions,
+        }
+    }
+
+    pub fn record(&mut self, path: PathBuf, addr: RepoAddr, cx: &mut Context<Self>) {
+        if cfg!(target_arch = "wasm32") {
+            return;
+        }
+
+        let settings = SettingsStore::global(cx);
+        let addr_str = addr.to_string();
+
+        let last_used = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .map(|d| d.as_secs())
+            .unwrap_or(0);
+
+        settings.update(cx, |settings, cx| {
+            settings.edit(
+                |s| {
+                    s.checkouts
+                        .records
+                        .retain(|r| !(r.path == path && r.addr == addr_str));
+                    s.checkouts.records.push(CheckoutRecord {
+                        path,
+                        addr: addr_str,
+                        last_used,
+                    });
+                },
+                cx,
+            );
+        });
+    }
+
+    pub fn associations_of(&self, addr: &RepoAddr) -> Vec<PathBuf> {
+        self.by_repo.get(addr).cloned().unwrap_or_default()
+    }
+
+    pub fn request_statuses(
+        &mut self,
+        addr: &RepoAddr,
+        announced_head: Option<String>,
+        cx: &mut Context<Self>,
+    ) {
+        self.status_requested.insert(addr.clone());
+        if announced_head != self.requested_head.get(addr).cloned().flatten() {
+            self.requested_head.insert(addr.clone(), announced_head);
+        }
+        self.refresh(cx);
+    }
+
+    pub fn ready_statuses_of(&self, addr: &RepoAddr) -> Vec<CheckoutStatus> {
+        self.statuses.get(addr).cloned().unwrap_or_default()
+    }
+
+    pub fn request_push_statuses(&mut self, addr: &RepoAddr, cx: &mut Context<Self>) {
+        self.push_requested.insert(addr.clone());
+        self.refresh(cx);
+    }
+
+    pub fn checkout_pushed(&mut self, addr: &RepoAddr, path: &Path, cx: &mut Context<Self>) {
+        let mut removed = false;
+
+        if let Some(statuses) = self.push_statuses.get_mut(addr) {
+            let before = statuses.len();
+            statuses.retain(|status| status.path.as_path() != path);
+            removed = statuses.len() != before;
+
+            if removed && statuses.is_empty() {
+                self.push_statuses.remove(addr);
+            }
+        }
+
+        if removed {
+            cx.notify();
+        }
+
+        self.request_push_statuses(addr, cx);
+    }
+
+    pub fn push_statuses_of(&self, addr: &RepoAddr) -> Vec<CheckoutStatus> {
+        self.push_statuses.get(addr).cloned().unwrap_or_default()
+    }
+
+    pub fn unpushed(&self, addr: &RepoAddr) -> usize {
+        self.push_statuses
+            .get(addr)
+            .map(|list| list.iter().map(|status| status.ahead as usize).sum())
+            .unwrap_or(0)
+    }
+
+    pub fn refresh(&mut self, cx: &mut Context<Self>) {
+        if self.debounce_pending || self.refresh.request() != RefreshRequest::Schedule {
+            return;
+        }
+
+        self.debounce_pending = true;
+
+        cx.spawn(async move |this, cx| {
+            cx.background_executor().timer(REFRESH_DEBOUNCE).await;
+            this.update(cx, |this, cx| {
+                this.run_refresh(cx);
+            })
+        })
+        .detach();
+    }
+
+    fn run_refresh(&mut self, cx: &mut Context<Self>) {
+        self.debounce_pending = false;
+        self.refresh.begin();
+
+        let records = {
+            let settings = SettingsStore::global(cx);
+            settings.read(cx).settings().checkouts.records.clone()
+        };
+
+        let remembered: Vec<Remembered> = records
+            .into_iter()
+            .filter_map(|record| {
+                let addr = record.addr.parse::<RepoAddr>().ok()?;
+                Some(Remembered {
+                    path: record.path,
+                    addr,
+                    last_used: record.last_used,
+                })
+            })
+            .collect();
+
+        let announcements = RepoListStore::global(cx).read(cx).announcements.clone();
+        let scanned = LocalReposStore::global(cx).read(cx).repos.clone();
+        let cache_root = Mirrors::root().canonicalize().ok();
+
+        let requested: Vec<(RepoAddr, Option<String>)> = self
+            .status_requested
+            .iter()
+            .map(|addr| {
+                (
+                    addr.clone(),
+                    self.requested_head.get(addr).cloned().flatten(),
+                )
+            })
+            .collect();
+
+        let push_requested: Vec<RepoAddr> = self.push_requested.iter().cloned().collect();
+        let poll = !self.status_requested.is_empty() || !self.push_requested.is_empty();
+
+        let work = cx.background_spawn(async move {
+            let mut facts: Vec<(PathBuf, Option<String>, Option<String>)> = Vec::new();
+            for scanned in scanned.iter() {
+                let path = &scanned.path;
+
+                // The browser's mirror clones are not user checkouts.
+                if cache_root
+                    .as_ref()
+                    .is_some_and(|root| path.starts_with(root))
+                {
+                    continue;
+                }
+
+                let origin = Repo::open(path)
+                    .and_then(|repo| repo.origin_url())
+                    .ok()
+                    .flatten();
+
+                let root = Repo::open(path)
+                    .and_then(|repo| repo.root_commit())
+                    .ok()
+                    .flatten();
+
+                facts.push((path.clone(), origin, root));
+            }
+
+            let associations =
+                Remembered::resolve_associations(&remembered, &facts, announcements.iter());
+
+            let associations: HashMap<RepoAddr, Vec<PathBuf>> = associations
+                .into_iter()
+                .map(|(addr, paths)| (addr, paths.into_iter().filter(|p| p.is_dir()).collect()))
+                .collect();
+
+            let (statuses, push_statuses) =
+                CheckoutsStore::compute_statuses(&associations, &requested, &push_requested, true);
+
+            Ok::<_, Error>((associations, statuses, push_statuses))
+        });
+
+        cx.spawn(async move |this, cx| {
+            let (associations, statuses, push_statuses) = match work.await {
+                Ok(results) => results,
+                Err(_) => {
+                    return this.update(cx, |this, cx| {
+                        this.refresh.abort();
+                        if poll {
+                            this.schedule_local_pass(cx);
+                        }
+                    });
+                }
+            };
+
+            let again = this.update(cx, |this, cx| {
+                let associations_changed = this.by_repo != associations;
+                let statuses_changed = this.statuses != statuses;
+                let push_statuses_changed = this.push_statuses != push_statuses;
+
+                this.by_repo = associations;
+                this.statuses = statuses;
+                this.push_statuses = push_statuses;
+
+                // Notify only when something actually changed.
+                if associations_changed || statuses_changed || push_statuses_changed {
+                    cx.notify();
+                }
+
+                this.last_full_sync = Some(Instant::now());
+                this.refresh.finish()
+            })?;
+
+            if again {
+                this.update(cx, |this, cx| {
+                    this.refresh(cx);
+                })?;
+            }
+
+            this.update(cx, |this, cx| {
+                if poll {
+                    this.schedule_local_pass(cx);
+                }
+            })?;
+
+            Ok(())
+        })
+        .detach();
+    }
+
+    fn schedule_local_pass(&mut self, cx: &mut Context<Self>) {
+        if self.local_pending {
+            return;
+        }
+        self.local_pending = true;
+
+        cx.spawn(async move |this, cx| {
+            cx.background_executor().timer(LOCAL_POLL).await;
+            this.update(cx, |this, cx| {
+                this.local_pending = false;
+                this.local_tick(cx);
+            })
+        })
+        .detach();
+    }
+
+    fn local_tick(&mut self, cx: &mut Context<Self>) {
+        if self.status_requested.is_empty() && self.push_requested.is_empty() {
+            return;
+        }
+
+        if self.refresh.running() || self.debounce_pending {
+            self.schedule_local_pass(cx);
+            return;
+        }
+
+        let cadence = if self.status_requested.is_empty() {
+            PUSH_POLL
+        } else {
+            STATUS_POLL
+        };
+
+        let full_due = self
+            .last_full_sync
+            .is_none_or(|sync| sync.elapsed() >= cadence);
+
+        if full_due {
+            self.last_full_sync = Some(Instant::now());
+            self.refresh(cx);
+        } else {
+            self.run_local_statuses(cx);
+        }
+
+        self.schedule_local_pass(cx);
+    }
+
+    fn run_local_statuses(&mut self, cx: &mut Context<Self>) {
+        let associations = self.by_repo.clone();
+
+        let requested: Vec<(RepoAddr, Option<String>)> = self
+            .status_requested
+            .iter()
+            .map(|addr| {
+                (
+                    addr.clone(),
+                    self.requested_head.get(addr).cloned().flatten(),
+                )
+            })
+            .collect();
+
+        let push_requested: Vec<RepoAddr> = self.push_requested.iter().cloned().collect();
+
+        let work = cx.background_spawn(async move {
+            let (statuses, push_statuses) =
+                CheckoutsStore::compute_statuses(&associations, &requested, &push_requested, false);
+            Ok::<_, Error>((statuses, push_statuses))
+        });
+
+        cx.spawn(async move |this, cx| {
+            let Ok((statuses, push_statuses)) = work.await else {
+                return Ok(());
+            };
+
+            this.update(cx, |this, cx| {
+                if this.refresh.running() || this.debounce_pending {
+                    return;
+                }
+
+                let statuses_changed = this.statuses != statuses;
+                let push_statuses_changed = this.push_statuses != push_statuses;
+
+                this.statuses = statuses;
+                this.push_statuses = push_statuses;
+
+                if statuses_changed || push_statuses_changed {
+                    cx.notify();
+                }
+            })?;
+
+            Ok::<(), anyhow::Error>(())
+        })
+        .detach();
+    }
+
+    fn checkout_status(path: &Path, announced_head: Option<&str>) -> Option<CheckoutStatus> {
+        let repo = Repo::try_open(path)?;
+        let branches = repo.branches().ok()?;
+
+        if branches.is_empty() || repo.is_dirty() {
+            return None;
+        }
+
+        let branch = repo.current_branch()?;
+        let head = repo.head()?;
+        let base = announced_head
+            .filter(|name| branches.iter().any(|b| b == name))
+            .map(str::to_owned)
+            .or_else(|| branches.iter().find(|b| *b == "main").cloned())
+            .or_else(|| branches.first().cloned())?;
+
+        if base == branch {
+            return None;
+        }
+
+        let ahead = repo.commits_ahead(&base, &branch);
+        (ahead > 0).then_some(CheckoutStatus {
+            path: path.to_path_buf(),
+            branch,
+            head,
+            base,
+            ahead,
+        })
+    }
+
+    /// Returns checkouts that are ahead of their remote tracking branch.
+    fn checkout_push_status(path: &Path, fetch: bool) -> Option<CheckoutStatus> {
+        let repo = Repo::try_open(path)?;
+        if repo.is_dirty() {
+            return None;
+        }
+
+        let branch = repo.current_branch()?;
+        let head = repo.head()?;
+        let origin = repo.origin_url().ok().flatten()?;
+
+        if fetch && let Err(e) = repo.fetch_refs(&[origin], "+refs/heads/*:refs/remotes/origin/*") {
+            log::warn!("failed to fetch refs for {path:?}: {e}");
+        }
+
+        let remote = format!("refs/remotes/origin/{branch}");
+
+        // If the branch is new and has no remote tracking branch, fall back to origin/HEAD.
+        let base = if repo.ref_exists(&remote) {
+            remote
+        } else if repo.ref_exists("refs/remotes/origin/HEAD") {
+            "refs/remotes/origin/HEAD".to_owned()
+        } else {
+            return None;
+        };
+
+        let ahead = repo.commits_ahead(&base, &branch);
+
+        (ahead > 0).then_some(CheckoutStatus {
+            path: path.to_path_buf(),
+            branch,
+            head,
+            base,
+            ahead,
+        })
+    }
+
+    fn compute_statuses(
+        associations: &HashMap<RepoAddr, Vec<PathBuf>>,
+        requested: &[(RepoAddr, Option<String>)],
+        push_requested: &[RepoAddr],
+        fetch: bool,
+    ) -> (
+        HashMap<RepoAddr, Vec<CheckoutStatus>>,
+        HashMap<RepoAddr, Vec<CheckoutStatus>>,
+    ) {
+        let mut statuses: HashMap<RepoAddr, Vec<CheckoutStatus>> = HashMap::new();
+        for (addr, announced_head) in requested {
+            let Some(paths) = associations.get(addr) else {
+                continue;
+            };
+
+            let list: Vec<CheckoutStatus> = paths
+                .iter()
+                .take(MAX_STATUS_CHECKOUTS)
+                .filter_map(|path| Self::checkout_status(path, announced_head.as_deref()))
+                .collect();
+
+            if !list.is_empty() {
+                statuses.insert(addr.clone(), list);
+            }
+        }
+
+        let mut push_statuses: HashMap<RepoAddr, Vec<CheckoutStatus>> = HashMap::new();
+        for addr in push_requested {
+            let Some(paths) = associations.get(addr) else {
+                continue;
+            };
+
+            let list: Vec<CheckoutStatus> = paths
+                .iter()
+                .take(MAX_STATUS_CHECKOUTS)
+                .filter_map(|path| Self::checkout_push_status(path, fetch))
+                .collect();
+
+            if !list.is_empty() {
+                push_statuses.insert(addr.clone(), list);
+            }
+        }
+
+        (statuses, push_statuses)
+    }
+
+    pub fn pr_proposes_checkout(
+        pr: &Event,
+        open: bool,
+        user: PublicKey,
+        checkout: &CheckoutStatus,
+    ) -> bool {
+        if pr.kind != Kind::GitPullRequest || !open || pr.pubkey != user {
+            return false;
+        }
+
+        let branch_matches = pr
+            .tags
+            .iter()
+            .find(|t| t.kind() == "branch-name")
+            .and_then(|t| t.content())
+            .is_some_and(|name| name == checkout.branch);
+
+        // A renamed branch falls back to the proposed tip commit.
+        let tip_matches = pr
+            .tags
+            .iter()
+            .find(|t| t.kind() == "c")
+            .and_then(|t| t.content())
+            .is_some_and(|tip| tip == checkout.head);
+
+        branch_matches || tip_matches
+    }
+}

crates/signed_state/src/git_store.rs

@@ -1,44 +1,41 @@
 use std::path::PathBuf;
+use std::sync::OnceLock;
 
-use gpui::{App, Global};
-use signed_git::GitCache;
+use anyhow::Result;
+use nostr::prelude::Url;
+use signed_core::RepoAddr;
+use signed_git::{GitCache, Repo};
 
-struct GlobalGitStore(GitCache);
+static GIT_CACHE: OnceLock<GitCache> = OnceLock::new();
 
-impl Global for GlobalGitStore {}
+pub struct Mirrors;
 
-/// Global access to the on-disk git clone cache (grasp mirrors).
-///
-/// Installed at startup via [`GitStore::set_global`]; see also
-/// [`signed_state::init`].
-#[derive(Debug, Clone)]
-pub struct GitStore(GitCache);
-
-impl GitStore {
-    /// Register the clone cache rooted at `root` as an app-wide global.
-    /// Replaces any previously installed store (see [`signed_state::init`], which
-    /// installs an empty one).
-    pub fn set_global(root: impl Into<PathBuf>, cx: &mut App) -> Self {
-        let store = Self::new(root);
-        cx.set_global(GlobalGitStore(store.0.clone()));
-        store
+impl Mirrors {
+    pub fn install(root: impl Into<PathBuf>) {
+        if GIT_CACHE.set(GitCache::new(root.into())).is_err() {
+            log::warn!("git cache root is already set, keeping the first one");
+        }
     }
 
-    /// The app-wide clone cache.
-    ///
-    /// # Panics
-    ///
-    /// Panics if [`GitStore::set_global`] was never called.
-    pub fn global(cx: &App) -> Self {
-        Self(cx.global::<GlobalGitStore>().0.clone())
+    fn cache() -> &'static GitCache {
+        GIT_CACHE
+            .get()
+            .expect("git cache is initialized by signed_state::init")
     }
 
-    fn new(root: impl Into<PathBuf>) -> Self {
-        Self(GitCache::new(root.into()))
+    pub(crate) fn root() -> PathBuf {
+        Self::cache().root().to_path_buf()
     }
 
-    /// Underlying clone cache.
-    pub fn cache(&self) -> &GitCache {
-        &self.0
+    pub fn path(addr: &RepoAddr) -> PathBuf {
+        Self::cache().repo_path(addr)
+    }
+
+    pub fn open(addr: &RepoAddr) -> Result<Option<Repo>> {
+        Self::cache().open(addr)
+    }
+
+    pub fn ensure(addr: &RepoAddr, clone_urls: &[Url]) -> Result<Repo> {
+        Self::cache().ensure_clone(addr, clone_urls)
     }
 }

crates/signed_state/src/inbox.rs

@@ -0,0 +1,230 @@
+use std::collections::{HashMap, HashSet};
+
+use anyhow::Error;
+use gpui::{AppContext, Context, Task};
+use nostr_sdk::prelude::*;
+use signed_core::{Deletions, Filters, GitEvent, InboxItem, InboxReadState, inbox};
+
+use crate::backend::Backend;
+
+#[derive(Default)]
+pub struct Inbox {
+    state: InboxReadState,
+    loaded: bool,
+}
+
+impl Inbox {
+    pub fn state(&self) -> &InboxReadState {
+        &self.state
+    }
+
+    pub fn is_loaded(&self) -> bool {
+        self.loaded
+    }
+
+    pub fn mark_all_read(&mut self, all: &[Event], me: PublicKey, cx: &mut Context<Self>) {
+        self.state.mark_all_read(all, me, Timestamp::now());
+        self.persist(cx);
+        cx.notify();
+    }
+
+    pub(crate) fn activate(&mut self, me: PublicKey, client: Client, cx: &mut Context<Self>) {
+        self.state = InboxReadState::default();
+        self.loaded = false;
+        cx.notify();
+
+        let backend = Backend::global(cx);
+        let work = cx.background_spawn(async move { Self::load_state(&client, me).await });
+
+        cx.spawn(async move |this, cx| {
+            let loaded = work.await;
+
+            this.update(cx, |this, cx| {
+                if backend.read(cx).current_user() != Some(me) {
+                    return;
+                }
+
+                match loaded {
+                    Ok(Some(state)) => this.state = state,
+                    Ok(None) => this.state = InboxReadState::default(),
+                    Err(error) => log::warn!("failed to load inbox state: {error}"),
+                }
+
+                this.loaded = true;
+                cx.notify();
+            })?;
+
+            Ok::<(), Error>(())
+        })
+        .detach();
+    }
+
+    pub(crate) fn reset(&mut self, cx: &mut Context<Self>) {
+        self.state = InboxReadState::default();
+        self.loaded = false;
+        cx.notify();
+    }
+
+    fn persist(&mut self, cx: &mut Context<Self>) {
+        let backend = Backend::global(cx);
+        let (me, client) = {
+            let backend = backend.read(cx);
+            (backend.current_user(), backend.client())
+        };
+
+        let Some(me) = me else {
+            return;
+        };
+
+        let state = self.state.clone();
+
+        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
+            if let Err(error) = Self::save_state(&client, me, &state).await {
+                log::warn!("failed to save inbox state: {error}");
+            }
+            Ok(())
+        });
+
+        task.detach();
+    }
+
+    pub async fn query(
+        client: &Client,
+        me: PublicKey,
+        state: &InboxReadState,
+    ) -> Result<(Vec<InboxItem>, usize), Error> {
+        let deletion_events = client.database().query(Filters::deletions()).await?;
+        let deletions = Deletions::from_events(deletion_events);
+
+        let (notification_events, mut by_id) =
+            Self::fetch_notifications(client, me, &deletions).await?;
+
+        let mut activity = Vec::new();
+        for event in client
+            .database()
+            .query(Filters::authored_activity(me))
+            .await?
+        {
+            if deletions.is_deleted(&event) || !event.is_git_activity() {
+                continue;
+            }
+            by_id.entry(event.id).or_insert_with(|| event.clone());
+            activity.push(event);
+        }
+
+        let items = inbox::group(notification_events, activity, me, state, &|id| {
+            by_id.get(&id).cloned()
+        });
+
+        let unread_count = items.iter().filter(|item| item.is_unread()).count();
+
+        Ok((items, unread_count))
+    }
+}
+
+impl Inbox {
+    fn inbox_state_d_tag(me: PublicKey) -> String {
+        format!("signed-inbox-state:{}", me.to_hex())
+    }
+
+    async fn load_state(client: &Client, me: PublicKey) -> Result<Option<InboxReadState>, Error> {
+        let filter = Filter::new()
+            .kind(Kind::ApplicationSpecificData)
+            .identifier(Self::inbox_state_d_tag(me));
+
+        let events = client.database().query(filter).await?;
+
+        let Some(event) = events.into_iter().max_by_key(|event| event.created_at) else {
+            return Ok(None);
+        };
+
+        match serde_json::from_str(&event.content) {
+            Ok(state) => Ok(Some(state)),
+            Err(error) => {
+                log::warn!("ignoring unreadable inbox state {}: {error}", event.id);
+                Ok(None)
+            }
+        }
+    }
+
+    // Signed with a random key: the state is local-only, authorship does not
+    // matter and no key material needs to be kept.
+    async fn save_state(
+        client: &Client,
+        me: PublicKey,
+        state: &InboxReadState,
+    ) -> Result<(), Error> {
+        let event = EventBuilder::new(Kind::ApplicationSpecificData, serde_json::to_string(state)?)
+            .tags([Tag::identifier(Self::inbox_state_d_tag(me))])
+            .finalize(&Keys::generate())?;
+
+        client.database().save_event(&event).await?;
+
+        Ok(())
+    }
+
+    async fn fetch_notifications(
+        client: &Client,
+        me: PublicKey,
+        deletions: &Deletions,
+    ) -> Result<(Vec<Event>, HashMap<EventId, Event>), Error> {
+        let mut notifications: Vec<Event> = Vec::new();
+        let mut by_id: HashMap<EventId, Event> = HashMap::new();
+
+        for filter in Filters::notifications(me) {
+            for event in client.database().query(filter).await? {
+                if deletions.is_deleted(&event) {
+                    continue;
+                }
+
+                if by_id.insert(event.id, event.clone()).is_none() {
+                    notifications.push(event);
+                }
+            }
+        }
+
+        let mut pending: Vec<EventId> = notifications
+            .iter()
+            .flat_map(Self::event_references)
+            .collect();
+
+        let mut seen: HashSet<EventId> = by_id.keys().copied().collect();
+
+        loop {
+            pending.retain(|id| seen.insert(*id));
+
+            if pending.is_empty() {
+                break;
+            }
+
+            let ancestors = client
+                .database()
+                .query(Filter::new().ids(pending.iter().copied()))
+                .await?;
+
+            let mut next = Vec::new();
+
+            for event in ancestors {
+                if deletions.is_deleted(&event) {
+                    continue;
+                }
+                next.extend(Self::event_references(&event).filter(|id| !seen.contains(id)));
+                by_id.entry(event.id).or_insert(event);
+            }
+
+            pending = next;
+        }
+
+        Ok((notifications, by_id))
+    }
+
+    fn event_references(event: &Event) -> impl Iterator<Item = EventId> + '_ {
+        event.tags.iter().filter_map(|tag| {
+            if tag.kind() != "e" && tag.kind() != "E" {
+                return None;
+            }
+            tag.content()
+                .and_then(|content| EventId::from_hex(content).ok())
+        })
+    }
+}

crates/signed_state/src/lib.rs

@@ -1,60 +1,56 @@
 mod backend;
+mod bootstrap;
+mod checkouts;
 mod git_store;
-mod profile;
+mod inbox;
+mod local_repos;
+mod patch_series;
+mod push;
+mod refresh;
 mod repo;
-mod repo_list;
+mod repos;
+mod state;
+mod sync_status;
 
 use std::path::{Path, PathBuf};
 
 pub use backend::{Backend, BackendEvent};
-pub use git_store::GitStore;
-use gpui::{App, AppContext, Entity};
+pub use bootstrap::{sync_bootstrap_only, user_grasp_list_servers};
+pub use checkouts::{CheckoutStatus, CheckoutsStore};
+pub use git_store::Mirrors;
+use gpui::{App, AppContext};
+pub use inbox::Inbox;
+pub use local_repos::{LocalReposStore, ResolvedLocalRepo};
 pub use nostr_sdk::prelude::Timestamp;
-pub use profile::{Profile, ProfileStore};
+pub use push::{GraspServer, PushOutcome};
+pub use refresh::{RefreshGate, RefreshRequest};
 pub use repo::RepoStore;
-pub use repo_list::RepoListStore;
-use signed_nostr::new_backend;
-pub use utils::shorten_pubkey;
+pub use repos::RepoListStore;
+pub use signed_git::{Nip34Binding, Nip34Kind};
+use signed_nostr::NostrBackend;
+pub use state::{GitPushMode, GitPushPolicy, GitRef, PushStep, PushStepStatus, SyncState};
+pub use sync_status::{CheckoutSyncStatus, SyncEvent, SyncStatusDirectory, SyncStatusStore};
 
-/// Initialize the backend and stores, and install them as globals. Call once
-/// at startup, before opening any window that uses the stores.
-#[cfg(not(target_arch = "wasm32"))]
-pub fn init(db_path: impl AsRef<Path>, cx: &mut App) -> Entity<Backend> {
-    // rustls uses the `aws_lc_rs` provider by default; ignore if already installed.
-    rustls::crypto::aws_lc_rs::default_provider()
-        .install_default()
-        .ok();
+pub fn init(
+    db_path: impl AsRef<Path>,
+    repos_root: impl Into<PathBuf>,
+    scan_paths: Vec<PathBuf>,
+    cx: &mut App,
+) {
+    // rustls uses the `aws_lc_rs` provider by default.
+    let _ = rustls::crypto::aws_lc_rs::default_provider().install_default();
 
-    let path = db_path.as_ref().to_path_buf();
-    let (client, signer) = cx.foreground_executor().block_on(async move {
-        new_backend(path)
-            .await
-            .expect("failed to initialize nostr backend")
-    });
+    let backend = cx
+        .foreground_executor()
+        .block_on(async move { NostrBackend::open(db_path.as_ref()).await });
+    let backend = backend.expect("failed to initialize nostr backend");
+    let (client, signer) = (backend.client, backend.signer);
 
-    let entity = cx.new(|cx| Backend::new(client, signer, cx));
-    Backend::set_global(entity.clone(), cx);
+    Mirrors::install(repos_root);
 
-    ProfileStore::set_global(cx.new(ProfileStore::new), cx);
-
-    // The clone cache is only meaningful on native platforms; the wasm
-    // build registers an empty store so `GitStore::global` still works.
-    GitStore::set_global(PathBuf::new(), cx);
-
-    entity
-}
-
-/// Initialize the backend with an in-memory database on wasm.
-#[cfg(target_arch = "wasm32")]
-pub fn init(cx: &mut App) -> Entity<Backend> {
-    let (client, signer) = new_backend().expect("failed to initialize nostr backend");
-
-    let entity = cx.new(|cx| Backend::new(client, signer, cx));
-    Backend::set_global(entity.clone(), cx);
-
-    ProfileStore::set_global(cx.new(ProfileStore::new), cx);
-
-    GitStore::set_global(PathBuf::new(), cx);
-
-    entity
+    Backend::set_global(cx.new(|cx| Backend::new(client, signer, cx)), cx);
+    RepoListStore::set_global(cx.new(RepoListStore::new), cx);
+    LocalReposStore::set_global(cx.new(|cx| LocalReposStore::new(scan_paths, cx)), cx);
+    CheckoutsStore::set_global(cx.new(CheckoutsStore::new), cx);
+    SyncStatusStore::set_global(cx.new(SyncStatusStore::new), cx);
 }

crates/signed_state/src/local_repos.rs

@@ -0,0 +1,229 @@
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use anyhow::Error;
+use gpui::{App, AppContext, Context, Entity, Global, SharedString, Task};
+use signed_core::{Announcement, RepoAddr};
+use signed_git::{LocalRepo, Nip34Binding, find_git_repos};
+
+struct GlobalLocalReposStore(Entity<LocalReposStore>);
+
+impl Global for GlobalLocalReposStore {}
+
+pub struct LocalReposStore {
+    pub roots: Arc<Vec<PathBuf>>,
+    pub repos: Arc<Vec<LocalRepo>>,
+    pub scanning: bool,
+    scan_dirty: bool,
+}
+
+impl LocalReposStore {
+    pub fn global(cx: &App) -> Entity<Self> {
+        cx.global::<GlobalLocalReposStore>().0.clone()
+    }
+
+    pub(crate) fn set_global(entity: Entity<Self>, cx: &mut App) {
+        cx.set_global(GlobalLocalReposStore(entity));
+    }
+
+    pub fn new(roots: Vec<PathBuf>, cx: &mut Context<Self>) -> Self {
+        let weak = cx.entity().downgrade();
+        cx.defer(move |cx| {
+            if let Err(error) = weak.update(cx, |this, cx| this.rescan(cx)) {
+                log::warn!("local repos store dropped before initial scan could run: {error}");
+            }
+        });
+
+        Self {
+            roots: Arc::new(roots),
+            repos: Arc::new(Vec::new()),
+            scanning: false,
+            scan_dirty: false,
+        }
+    }
+
+    pub fn remove(&mut self, path: &Path, cx: &mut Context<Self>) {
+        self.repos = Arc::new(
+            self.repos
+                .iter()
+                .filter(|repo| repo.path.as_path() != path)
+                .cloned()
+                .collect(),
+        );
+        cx.notify();
+    }
+
+    pub fn rescan(&mut self, cx: &mut Context<Self>) {
+        if self.scanning {
+            self.scan_dirty = true;
+            return;
+        }
+
+        if self.roots.is_empty() {
+            return;
+        }
+
+        self.scanning = true;
+        cx.notify();
+
+        let roots = self.roots.clone();
+
+        let work = cx.background_spawn(async move {
+            let mut repos = Vec::new();
+            for root in roots.iter() {
+                repos.extend(find_git_repos(root));
+            }
+            repos.sort_by(|a, b| a.path.cmp(&b.path));
+            repos.dedup_by(|a, b| a.path == b.path);
+            repos
+        });
+
+        let task: Task<Result<(), Error>> = cx.spawn(async move |this, cx| {
+            let repos = work.await;
+            let again = this.update(cx, |this, cx| {
+                this.repos = Arc::new(repos);
+                this.scanning = false;
+                cx.notify();
+
+                let dirty = this.scan_dirty;
+                this.scan_dirty = false;
+                dirty
+            })?;
+
+            if again {
+                this.update(cx, |this, cx| this.rescan(cx))?;
+            }
+
+            Ok(())
+        });
+
+        task.detach();
+    }
+}
+
+pub fn local_repo_addr(repo: &LocalRepo) -> Option<RepoAddr> {
+    let binding = repo.nip34.as_ref()?;
+    let owner = binding.owner?;
+    let identifier = binding.identifier.as_deref()?;
+
+    Some(RepoAddr::new(owner, identifier))
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct ResolvedLocalRepo {
+    pub path: PathBuf,
+    pub nip34: Option<Nip34Binding>,
+    pub announcement: Option<Announcement>,
+}
+
+impl ResolvedLocalRepo {
+    pub fn name(&self) -> SharedString {
+        self.path
+            .file_name()
+            .map(|name| SharedString::from(name.to_string_lossy().into_owned()))
+            .unwrap_or_else(|| SharedString::from("Untitled"))
+    }
+}
+
+impl LocalReposStore {
+    pub fn resolve(
+        repos: &[LocalRepo],
+        known: &[Announcement],
+        own: &[Announcement],
+    ) -> Vec<ResolvedLocalRepo> {
+        let shown: HashSet<RepoAddr> = own.iter().map(Announcement::addr).collect();
+
+        repos
+            .iter()
+            .filter_map(|repo| {
+                let addr = local_repo_addr(repo);
+
+                if let Some(addr) = &addr
+                    && shown.contains(addr)
+                {
+                    return None;
+                }
+
+                let announcement = addr
+                    .as_ref()
+                    .and_then(|addr| {
+                        known
+                            .iter()
+                            .find(|announcement| announcement.addr() == *addr)
+                    })
+                    .cloned();
+
+                Some(ResolvedLocalRepo {
+                    path: repo.path.clone(),
+                    nip34: repo.nip34.clone(),
+                    announcement,
+                })
+            })
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use nostr::prelude::*;
+    use signed_git::{GraspSignals, Nip34Kind};
+
+    use super::*;
+
+    const KEY: &str = "0000000000000000000000000000000000000000000000000000000000000001";
+    const OTHER_KEY: &str = "0000000000000000000000000000000000000000000000000000000000000002";
+
+    fn announcement(secret: &str, id: &str) -> Announcement {
+        let keys = Keys::new(SecretKey::from_hex(secret).expect("secret"));
+        let tag = Tag::parse(vec!["d", id]).expect("tag");
+        let event = EventBuilder::new(Kind::GitRepoAnnouncement, "")
+            .tags(vec![tag])
+            .finalize(&keys)
+            .expect("signed");
+
+        Announcement::from_event(&event).expect("parsed")
+    }
+
+    fn owner(secret: &str) -> PublicKey {
+        Keys::new(SecretKey::from_hex(secret).expect("secret")).public_key()
+    }
+
+    fn bound(secret: &str, id: &str) -> LocalRepo {
+        let binding = Nip34Binding {
+            kind: Nip34Kind::Initialized,
+            signals: GraspSignals {
+                nip34_json: true,
+                ..Default::default()
+            },
+            owner: Some(owner(secret)),
+            identifier: Some(id.to_owned()),
+            grasp_urls: Vec::new(),
+        };
+
+        LocalRepo {
+            path: PathBuf::from(id),
+            nip34: Some(binding),
+        }
+    }
+
+    #[test]
+    fn the_users_own_announcement_is_dropped() {
+        let own = announcement(KEY, "mine");
+        let repo = bound(KEY, "mine");
+
+        let own = std::slice::from_ref(&own);
+        assert!(LocalReposStore::resolve(&[repo], own, own).is_empty());
+    }
+
+    #[test]
+    fn another_owners_announcement_is_linked_and_kept() {
+        let known = announcement(OTHER_KEY, "theirs");
+        let repo = bound(OTHER_KEY, "theirs");
+
+        let resolved = LocalReposStore::resolve(&[repo], std::slice::from_ref(&known), &[]);
+
+        assert_eq!(resolved.len(), 1);
+        assert_eq!(resolved[0].announcement.as_ref(), Some(&known));
+    }
+}

crates/signed_state/src/patch_series.rs

@@ -0,0 +1,50 @@
+use bitcoin_hashes::sha1::Hash as Sha1Hash;
+use signed_git::PatchParser;
+
+/// NIP-34 suggests patches when each event is under 60kb.
+pub(crate) const MAX_PATCH_EVENT_BYTES: usize = 60 * 1024;
+
+pub(crate) struct PatchSeries {
+    pub(crate) parts: Vec<String>,
+}
+
+impl PatchSeries {
+    pub(crate) fn parse(patch: &str) -> Self {
+        Self {
+            parts: PatchParser::split_patch_series(patch)
+                .into_iter()
+                .map(str::to_owned)
+                .collect(),
+        }
+    }
+
+    /// Returns the length of the first part that exceeds the NIP-34 recommended size.
+    pub(crate) fn oversized_length(&self) -> Option<usize> {
+        self.parts
+            .iter()
+            .map(String::len)
+            .find(|length| *length > MAX_PATCH_EVENT_BYTES)
+    }
+
+    /// The last commit of the series, which is the tip of the branch.
+    pub(crate) fn tip_commit(&self) -> Option<Sha1Hash> {
+        self.parts
+            .last()
+            .and_then(|part| patch_current_commit(part))
+            .and_then(|hex| hex.parse::<Sha1Hash>().ok())
+    }
+
+    pub(crate) fn commit_of(&self, index: usize) -> Option<&str> {
+        self.parts
+            .get(index)
+            .and_then(|part| patch_current_commit(part))
+            .filter(|hex| hex.len() == 40)
+    }
+}
+
+/// The `From <commit>` header on the first line.
+fn patch_current_commit(patch: &str) -> Option<&str> {
+    let line = patch.lines().next()?;
+    let hex = line.strip_prefix("From ")?;
+    hex.split_whitespace().next().filter(|hex| hex.len() == 40)
+}

crates/signed_state/src/profile.rs

@@ -1,329 +0,0 @@
-use std::cell::RefCell;
-use std::collections::{HashMap, HashSet};
-use std::time::{Duration, Instant};
-
-use anyhow::Error;
-use flume::{Receiver, RecvTimeoutError, Sender};
-use gpui::{App, AppContext, Context, Entity, Global, SharedString, Subscription, Task};
-use nostr_sdk::prelude::*;
-use utils::shorten_pubkey;
-
-use crate::backend::{Backend, BackendEvent, sync_bootstrap_only};
-
-/// A user profile (kind `0` metadata), as plain data for the UI.
-#[derive(Debug, Clone)]
-pub struct Profile {
-    public_key: PublicKey,
-    metadata: Metadata,
-}
-
-impl Profile {
-    pub fn new(public_key: PublicKey, metadata: Metadata) -> Self {
-        Self {
-            public_key,
-            metadata,
-        }
-    }
-
-    pub fn public_key(&self) -> PublicKey {
-        self.public_key
-    }
-
-    pub fn metadata(&self) -> &Metadata {
-        &self.metadata
-    }
-
-    /// Display name, falling back to `name`, then a shortened npub.
-    pub fn name(&self) -> SharedString {
-        if let Some(display_name) = self.metadata.display_name.as_ref()
-            && !display_name.is_empty()
-        {
-            return SharedString::from(display_name.trim().to_owned());
-        }
-
-        if let Some(name) = self.metadata.name.as_ref()
-            && !name.is_empty()
-        {
-            return SharedString::from(name.trim().to_owned());
-        }
-
-        SharedString::from(shorten_pubkey(self.public_key, 4))
-    }
-
-    /// Avatar URL, if set.
-    pub fn picture(&self) -> Option<SharedString> {
-        self.metadata
-            .picture
-            .as_ref()
-            .filter(|p| !p.is_empty())
-            .map(|p| SharedString::from(p.clone()))
-    }
-}
-
-/// Message from the fetch task to the main thread.
-enum Dispatch {
-    /// A batched sync finished; re-read seen profiles from the database.
-    Synced,
-}
-
-/// How long to wait for more requests before firing a batched sync.
-const BATCH_TIMEOUT: Duration = Duration::from_millis(500);
-
-/// Global profile cache. Profiles are fetched in batches and kept as plain
-/// data; the whole store notifies on change.
-pub struct ProfileStore {
-    profiles: HashMap<PublicKey, Profile>,
-    /// Public keys we've already requested this session (main thread only).
-    seen: RefCell<HashSet<PublicKey>>,
-    /// Sender for queuing fetch requests, batched by a background task.
-    sender: Sender<PublicKey>,
-    tasks: Vec<Task<Result<(), Error>>>,
-    _subscription: Subscription,
-}
-
-struct GlobalProfileStore(Entity<ProfileStore>);
-
-impl Global for GlobalProfileStore {}
-
-impl ProfileStore {
-    /// Retrieve the global profile store.
-    pub fn global(cx: &App) -> Entity<Self> {
-        cx.global::<GlobalProfileStore>().0.clone()
-    }
-
-    pub(crate) fn set_global(entity: Entity<Self>, cx: &mut App) {
-        cx.set_global(GlobalProfileStore(entity));
-    }
-
-    pub(crate) fn new(cx: &mut Context<Self>) -> Self {
-        let backend = Backend::global(cx);
-
-        let subscription = cx.subscribe(&backend, |this, _backend, event, cx| match event {
-            BackendEvent::NostrUpdate(update) if update.kind == Kind::Metadata => {
-                this.apply_author(update.author, cx);
-            }
-            BackendEvent::Published(event) if event.kind == Kind::Metadata => {
-                let metadata = Metadata::from_json(&event.content).unwrap_or_default();
-                this.profiles
-                    .insert(event.pubkey, Profile::new(event.pubkey, metadata));
-                cx.notify();
-            }
-            _ => {}
-        });
-
-        // Fetch requests are queued on a channel and synced in batches by a
-        // background task.
-        let client = backend.read(cx).client();
-        let (sender, receiver) = flume::unbounded::<PublicKey>();
-        let (dispatch_tx, dispatch_rx) = flume::unbounded::<Dispatch>();
-
-        let mut tasks = Vec::new();
-
-        tasks.push(cx.background_spawn(async move {
-            Self::handle_requests(&client, &dispatch_tx, &receiver).await
-        }));
-
-        // Re-read seen profiles from the database after each batch sync.
-        tasks.push(cx.spawn(async move |this, cx| {
-            while let Ok(Dispatch::Synced) = dispatch_rx.recv_async().await {
-                this.update(cx, |this, cx| this.apply_seen(cx)).ok();
-            }
-            Ok(())
-        }));
-
-        let mut store = Self {
-            profiles: HashMap::new(),
-            seen: RefCell::new(HashSet::new()),
-            sender,
-            tasks,
-            _subscription: subscription,
-        };
-
-        store.load(cx);
-        store
-    }
-
-    /// Get a profile. Returns a placeholder (default metadata) and queues a
-    /// fetch if the profile isn't cached yet.
-    pub fn get(&self, public_key: &PublicKey) -> Profile {
-        if let Some(profile) = self.profiles.get(public_key) {
-            return profile.clone();
-        }
-
-        let public_key = *public_key;
-
-        if self.seen.borrow_mut().insert(public_key)
-            && let Err(e) = self.sender.send(public_key)
-        {
-            log::warn!("failed to queue profile fetch: {e}");
-        }
-
-        Profile::new(public_key, Metadata::default())
-    }
-
-    /// Load recently seen profiles from the local database.
-    fn load(&mut self, cx: &mut Context<Self>) {
-        let client = Backend::global(cx).read(cx).client();
-
-        let work = cx.background_spawn(async move {
-            let filter = Filter::new().kind(Kind::Metadata).limit(200);
-            let events = client.database().query(filter).await?;
-
-            // Parse off the main thread; only plain profiles cross back.
-            let profiles: Vec<Profile> = events
-                .into_iter()
-                .map(|event| {
-                    let metadata = Metadata::from_json(&event.content).unwrap_or_default();
-                    Profile::new(event.pubkey, metadata)
-                })
-                .collect();
-
-            Ok::<_, Error>(profiles)
-        });
-
-        self.tasks.push(cx.spawn(async move |this, cx| {
-            let profiles = work.await?;
-
-            this.update(cx, |this, cx| {
-                for profile in profiles {
-                    this.profiles.insert(profile.public_key(), profile);
-                }
-                cx.notify();
-            })?;
-
-            Ok(())
-        }));
-    }
-
-    /// Re-read the latest metadata of an author from the local database.
-    fn apply_author(&mut self, public_key: PublicKey, cx: &mut Context<Self>) {
-        let client = Backend::global(cx).read(cx).client();
-
-        let work = cx.background_spawn(async move {
-            let filter = Filter::new().kind(Kind::Metadata).author(public_key);
-            let events = client.database().query(filter).await?;
-
-            // Parse off the main thread; only the profile crosses back.
-            let profile = events
-                .into_iter()
-                .max_by_key(|e| e.created_at)
-                .map(|event| {
-                    let metadata = Metadata::from_json(event.content).unwrap_or_default();
-                    Profile::new(event.pubkey, metadata)
-                });
-
-            Ok::<_, Error>(profile)
-        });
-
-        self.tasks.push(cx.spawn(async move |this, cx| {
-            let profile = work.await?;
-
-            this.update(cx, |this, cx| {
-                if let Some(profile) = profile {
-                    this.profiles.insert(profile.public_key(), profile);
-                    cx.notify();
-                }
-            })?;
-
-            Ok(())
-        }));
-    }
-
-    /// Re-read the latest metadata of every requested author from the local
-    /// database (used after a sync, which produces no NostrUpdate events).
-    fn apply_seen(&mut self, cx: &mut Context<Self>) {
-        let authors: Vec<PublicKey> = self.seen.borrow().iter().copied().collect();
-
-        if authors.is_empty() {
-            return;
-        }
-
-        let client = Backend::global(cx).read(cx).client();
-
-        let work = cx.background_spawn(async move {
-            let filter = Filter::new().kind(Kind::Metadata).authors(authors);
-            let events = client.database().query(filter).await?;
-
-            // Pick the latest metadata per author off the main thread.
-            let mut latest: HashMap<PublicKey, (Timestamp, Metadata)> = HashMap::new();
-            for event in events {
-                match latest.get(&event.pubkey) {
-                    Some((ts, _)) if *ts >= event.created_at => {}
-                    _ => {
-                        latest.insert(
-                            event.pubkey,
-                            (
-                                event.created_at,
-                                Metadata::from_json(&event.content).unwrap_or_default(),
-                            ),
-                        );
-                    }
-                }
-            }
-
-            let profiles: Vec<Profile> = latest
-                .into_iter()
-                .map(|(public_key, (_, metadata))| Profile::new(public_key, metadata))
-                .collect();
-
-            Ok::<_, Error>(profiles)
-        });
-
-        self.tasks.push(cx.spawn(async move |this, cx| {
-            let profiles = work.await?;
-
-            this.update(cx, |this, cx| {
-                for profile in profiles {
-                    this.profiles.insert(profile.public_key(), profile);
-                }
-                cx.notify();
-            })?;
-
-            Ok(())
-        }));
-    }
-
-    /// Sync metadata for requested authors in batches, debounced to collect
-    /// requests. Runs on a background thread; results are dispatched to the
-    /// main thread, which re-reads the database.
-    async fn handle_requests(
-        client: &Client,
-        dispatch: &Sender<Dispatch>,
-        receiver: &Receiver<PublicKey>,
-    ) -> Result<(), Error> {
-        let mut batch: HashSet<PublicKey> = HashSet::new();
-
-        loop {
-            // Wait for the first request of a batch.
-            match receiver.recv_timeout(BATCH_TIMEOUT) {
-                Ok(public_key) => {
-                    batch.insert(public_key);
-                }
-                Err(RecvTimeoutError::Disconnected) => return Ok(()),
-                Err(RecvTimeoutError::Timeout) => continue,
-            };
-
-            // Collect everything that arrives within the debounce window.
-            let deadline = Instant::now() + BATCH_TIMEOUT;
-            while let Ok(public_key) = receiver.recv_deadline(deadline) {
-                batch.insert(public_key);
-            }
-
-            let filter = Filter::new()
-                .kind(Kind::Metadata)
-                .authors(batch.drain().collect::<Vec<PublicKey>>());
-
-            // Negentropy-sync with the bootstrap relays. Synced events are
-            // written to the database directly (no NostrUpdate), so re-apply
-            // from the database afterwards.
-            match sync_bootstrap_only(client, filter, SyncOptions::default()).await {
-                Ok(_) => {
-                    if dispatch.send(Dispatch::Synced).is_err() {
-                        log::warn!("profile dispatch channel closed, dropping sync result");
-                    }
-                }
-                Err(e) => log::warn!("profile sync failed: {e}"),
-            }
-        }
-    }
-}

crates/signed_state/src/push.rs

@@ -0,0 +1,114 @@
+use nostr::prelude::Url;
+use nostr_sdk::prelude::*;
+
+/// `ws://` grasp servers, like ngit, use `http(s)://<host>`.
+pub(crate) fn grasp_base_url(relay: &RelayUrl) -> Option<String> {
+    let parsed = Url::parse(relay.as_str()).ok()?;
+    let host = parsed.host_str()?;
+    let port = parsed
+        .port()
+        .map(|port| format!(":{port}"))
+        .unwrap_or_default();
+    let scheme = if relay.scheme().is_secure() {
+        "https"
+    } else {
+        "http"
+    };
+    Some(format!("{scheme}://{host}{port}"))
+}
+
+pub(crate) fn grasp_clone_url(relay: &RelayUrl, owner: &str, repo_id: &str) -> Option<Url> {
+    let base = grasp_base_url(relay)?;
+    Url::parse(&format!("{base}/{owner}/{repo_id}.git")).ok()
+}
+
+/// GRASP-06 contributor namespace URL of a pull request tip.
+pub(crate) fn grasp06_prs_url(base_url: &str, npub: &str, repo_id: &str) -> String {
+    format!("{base_url}/prs/{npub}/{repo_id}.git")
+}
+
+/// The author's GRASP-06 `/prs/` URLs come first.
+pub(crate) fn pr_clone_urls(prs_urls: Vec<Url>, base_clone_urls: Vec<Url>) -> Vec<Url> {
+    let mut seen = std::collections::HashSet::new();
+    let mut urls = Vec::new();
+    for url in prs_urls.into_iter().chain(base_clone_urls) {
+        if seen.insert(url.to_string()) {
+            urls.push(url);
+        }
+    }
+    urls
+}
+
+#[derive(Debug, Clone)]
+pub struct GraspServer {
+    relay: RelayUrl,
+    reason: Option<String>,
+}
+
+impl GraspServer {
+    pub(crate) fn ok(relay: RelayUrl) -> Self {
+        Self {
+            relay,
+            reason: None,
+        }
+    }
+
+    pub(crate) fn failed(relay: &RelayUrl, reason: impl Into<String>) -> Self {
+        Self {
+            relay: relay.to_owned(),
+            reason: Some(reason.into()),
+        }
+    }
+
+    pub fn relay(&self) -> &RelayUrl {
+        &self.relay
+    }
+
+    pub fn reason(&self) -> Option<&str> {
+        self.reason.as_deref()
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct PushOutcome {
+    pub servers: Vec<GraspServer>,
+    /// The newest state event a grasp relay accepted for this push.
+    pub state_event: Option<Event>,
+}
+
+impl PushOutcome {
+    pub fn accepted(&self) -> usize {
+        self.servers
+            .iter()
+            .filter(|server| server.reason.is_none())
+            .count()
+    }
+
+    fn failing(&self) -> impl Iterator<Item = &GraspServer> {
+        self.servers.iter().filter(|server| server.reason.is_some())
+    }
+
+    pub fn failure_summary(&self) -> String {
+        self.failing()
+            .map(|server| {
+                let reason =
+                    utils::flatten_whitespace(server.reason.as_deref().unwrap_or("unknown error"));
+                format!("{}: {reason}", server.relay)
+            })
+            .collect::<Vec<_>>()
+            .join("; ")
+    }
+
+    /// `None` when every server accepted the push or nothing was pushed.
+    pub fn partial_warning(&self) -> Option<String> {
+        let accepted = self.accepted();
+        if self.servers.is_empty() || accepted == self.servers.len() {
+            return None;
+        }
+        Some(format!(
+            "Pushed to {accepted} of {} grasp servers: {}. Republish to sync.",
+            self.servers.len(),
+            self.failure_summary()
+        ))
+    }
+}

crates/signed_state/src/refresh.rs

@@ -0,0 +1,40 @@
+#[derive(Debug, Default)]
+pub struct RefreshGate {
+    running: bool,
+    dirty: bool,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RefreshRequest {
+    Schedule,
+    Fold,
+}
+
+impl RefreshGate {
+    pub fn running(&self) -> bool {
+        self.running
+    }
+
+    pub fn request(&mut self) -> RefreshRequest {
+        if self.running {
+            self.dirty = true;
+            RefreshRequest::Fold
+        } else {
+            RefreshRequest::Schedule
+        }
+    }
+
+    pub fn begin(&mut self) {
+        self.running = true;
+    }
+
+    pub fn finish(&mut self) -> bool {
+        self.running = false;
+        std::mem::take(&mut self.dirty)
+    }
+
+    // Pending follow-up requests survive an abandoned run.
+    pub fn abort(&mut self) {
+        self.running = false;
+    }
+}