chore(release): 2.4.0

feat(core,fuse,gui): find photos that look alike
The duplicate finder gains an Exact / Similar switch. Similar asks the daemon for PhotoSimilar, which starts a background pass that hashes the thumbnail of every shot not hashed yet and replies at once with the sets found so far and how far hashing has got. The dialog shows a progress bar and asks again until the pass is done, then lists the sets. The pass takes thumbnails from the server only: a photo without one is skipped for the run instead of downloaded whole, and the dialog says how many photos could not be compared. Decoding and hashing are spread over the machine's cores. Every similar photo starts ticked Keep, since photos that look alike can be different shots. A similar photo stands for its whole shot, so one not kept goes to Trash with the rest of its shot.
2026-11-04 00:47:00 +01:00 · 2026-09-28 09:16:54 +02:00 · 2026-09-28 09:16:54 +02:00 · 2026-09-28 09:16:54 +02:00 · 2026-09-28 01:42:04 +00:00 · 2026-09-28 03:12:57 +02:00
143 changed files with 102203 additions and 3444 deletions
@@ -0,0 +1,101 @@
+name: AUR
+
+on:
+  # The -git package computes its pkgver from git at build time, so a new commit
+  # upstream needs no AUR push. Only a changed -git recipe is published.
+  push:
+    branches: [main]
+    paths:
+      - 'packaging/aur/proton-drive-for-linux-git/**'
+  # Called by release.yml once the GitHub release and its assets exist.
+  workflow_call:
+    inputs:
+      version:
+        required: true
+        type: string
+    secrets:
+      AUR_SSH_PRIVATE_KEY:
+        required: true
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Release to publish, such as 2.1.0. Leave empty to publish only the -git package.'
+        required: false
+        type: string
+
+permissions:
+  contents: write
+
+concurrency:
+  group: aur
+  cancel-in-progress: false
+
+jobs:
+  publish:
+    name: Publish AUR packages
+    runs-on: ubuntu-24.04
+    container: archlinux:base-devel
+    env:
+      # makepkg refuses to run as root, so the packaging steps run as `builder`.
+      HOME: /home/builder
+      VERSION: ${{ inputs.version }}
+
+    steps:
+      - name: Install packaging tools
+        run: pacman -Syu --noconfirm --needed git openssh pacman-contrib
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          # The updated recipes are committed back to main, not to the tag.
+          ref: main
+
+      - name: Create build user
+        run: |
+          useradd --create-home builder
+          chown -R builder: "$GITHUB_WORKSPACE"
+
+      - name: Configure AUR access
+        env:
+          AUR_SSH_PRIVATE_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
+        run: |
+          install -d -m700 -o builder -g builder "$HOME/.ssh"
+          printf '%s\n' "$AUR_SSH_PRIVATE_KEY" > "$HOME/.ssh/aur"
+          cat > "$HOME/.ssh/config" <<'EOF'
+          Host aur.archlinux.org
+            IdentityFile ~/.ssh/aur
+            User aur
+          EOF
+          # Pin the host key to the fingerprint published on aur.archlinux.org.
+          ssh-keyscan -t ed25519 aur.archlinux.org > "$HOME/.ssh/known_hosts"
+          ssh-keygen -lf "$HOME/.ssh/known_hosts" | grep -q 'SHA256:RFzBCUItH9LZS0cKB5UE6ceAYhBD5C8GeOBip8Z11+4'
+          chown -R builder: "$HOME/.ssh"
+          chmod 600 "$HOME/.ssh/aur"
+          runuser -u builder -- git config --global user.name 'Nils Pukropp'
+          runuser -u builder -- git config --global user.email 'contact@narl.io'
+
+      - name: Update release packages
+        if: env.VERSION != ''
+        run: runuser -u builder -- packaging/aur/update.sh "${VERSION#v}"
+
+      - name: Refresh the -git metadata
+        if: env.VERSION == ''
+        working-directory: packaging/aur/proton-drive-for-linux-git
+        run: runuser -u builder -- sh -c 'makepkg --printsrcinfo > .SRCINFO'
+
+      - name: Publish to the AUR
+        run: |
+          if [ -n "$VERSION" ]; then
+            runuser -u builder -- packaging/aur/push.sh
+          else
+            runuser -u builder -- packaging/aur/push.sh proton-drive-for-linux-git
+          fi
+
+      - name: Commit the updated recipes to main
+        if: env.VERSION != ''
+        run: |
+          runuser -u builder -- git add packaging/aur
+          if ! runuser -u builder -- git diff --cached --quiet; then
+            runuser -u builder -- git commit -m "chore(aur): update packages to ${VERSION#v}"
+            runuser -u builder -- git push origin HEAD:main
+          fi
@@ -31,6 +31,7 @@ jobs:
            libsecret-1-dev \
            libdbus-1-dev \
            desktop-file-utils \
+            gettext \
            rpm

      - name: Set up Rust
@@ -84,6 +85,7 @@ jobs:
          cp target/release/pdfs-tray dist/binaries/
          cp target/release/pdfs-app dist/binaries/
          cp target/release/pdfs-prompt dist/binaries/
+          po/build.sh dist/binaries/locale
          
          # Create tarball
          tar -czf proton-drive-linux-${{ env.VERSION }}-x86_64.tar.gz -C dist/binaries .
@@ -110,6 +112,7 @@ jobs:
          cp packaging/io.narl.proton-drive-linux.svg deb/usr/share/icons/hicolor/scalable/apps/
          cp packaging/proton-drive.service deb/usr/lib/systemd/user/
          cp LICENSE deb/usr/share/licenses/proton-drive-linux/
+          po/build.sh deb/usr/share/locale

          # Calculate Installed-Size in KB for the control file
          INSTALLED_SIZE=$(du -sk deb | cut -f1)
@@ -199,3 +202,13 @@ jobs:
          prerelease: false
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  aur:
+    name: Publish AUR packages
+    needs: build-release
+    if: startsWith(github.ref, 'refs/tags/')
+    uses: ./.github/workflows/aur.yml
+    with:
+      version: ${{ github.ref_name }}
+    secrets:
+      AUR_SSH_PRIVATE_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
@@ -467,6 +467,12 @@ dependencies = [
 "digest 0.10.7",
 ]

+[[package]]
+name = "block"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a"
+
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
@@ -1814,6 +1820,26 @@ dependencies = [
 "wasm-bindgen",
 ]

+[[package]]
+name = "gettext-rs"
+version = "0.7.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d5857dc1b7f0fee86961de833f434e29494d72af102ce5355738c0664222bdf"
+dependencies = [
+ "gettext-sys",
+ "locale_config",
+]
+
+[[package]]
+name = "gettext-sys"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ea859ab0dd7e70ff823032b3e077d03d39c965d68c6c10775add60e999d8ee9"
+dependencies = [
+ "cc",
+ "temp-dir",
+]
+
 [[package]]
 name = "ghash"
 version = "0.5.1"
@@ -2829,6 +2855,19 @@ version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae"

+[[package]]
+name = "locale_config"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d2c35b16f4483f6c26f0e4e9550717a2f6575bcd6f12a53ff0c490a94a6934"
+dependencies = [
+ "lazy_static",
+ "objc",
+ "objc-foundation",
+ "regex",
+ "winapi",
+]
+
 [[package]]
 name = "lock_api"
 version = "0.4.14"
@@ -2868,6 +2907,15 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4050469837a6ff301cd14c1f8f24f88549e6d548f24f64e2148eb0f72cebc51f"

+[[package]]
+name = "malloc_buf"
+version = "0.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "matchers"
 version = "0.2.0"
@@ -3189,6 +3237,35 @@ dependencies = [
 "syn 2.0.119",
 ]

+[[package]]
+name = "objc"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1"
+dependencies = [
+ "malloc_buf",
+]
+
+[[package]]
+name = "objc-foundation"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1add1b659e36c9607c7aab864a76c7a4c2760cd0cd2e120f3fb8b952c7e22bf9"
+dependencies = [
+ "block",
+ "objc",
+ "objc_id",
+]
+
+[[package]]
+name = "objc_id"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c92d4ddb4bd7b50d730c215ff871754d0da6b2178849f8a2a2ab69712d0c073b"
+dependencies = [
+ "objc",
+]
+
 [[package]]
 name = "ocb3"
 version = "0.1.0"
@@ -3312,6 +3389,31 @@ dependencies = [
 "system-deps 9.0.0",
 ]

+[[package]]
+name = "pangocairo"
+version = "0.22.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd199a0fef965b3ebda91a929a1ab5e7729538882c68e8de38e1904d2e094757"
+dependencies = [
+ "cairo-rs",
+ "glib",
+ "pango",
+ "pangocairo-sys",
+]
+
+[[package]]
+name = "pangocairo-sys"
+version = "0.22.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a649a616d67ae68539bc85f00fb45d36fba742ed20fc20e6712a15d8ee52bd3f"
+dependencies = [
+ "cairo-sys-rs",
+ "glib-sys",
+ "libc",
+ "pango-sys",
+ "system-deps 9.0.0",
+]
+
 [[package]]
 name = "parking"
 version = "2.2.1"
@@ -3372,7 +3474,7 @@ checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"

 [[package]]
 name = "pdfs-cli"
-version = "1.11.0"
+version = "2.4.0"
 dependencies = [
 "anyhow",
 "clap",
@@ -3387,7 +3489,7 @@ dependencies = [

 [[package]]
 name = "pdfs-core"
-version = "1.11.0"
+version = "2.4.0"
 dependencies = [
 "async-trait",
 "dbus-secret-service-keyring-store",
@@ -3411,7 +3513,7 @@ dependencies = [

 [[package]]
 name = "pdfs-fuse"
-version = "1.11.0"
+version = "2.4.0"
 dependencies = [
 "base64 0.23.1",
 "fuser",
@@ -3431,15 +3533,18 @@ dependencies = [

 [[package]]
 name = "pdfs-gui"
-version = "1.11.0"
+version = "2.4.0"
 dependencies = [
 "anyhow",
 "async-channel",
+ "gettext-rs",
 "gtk4",
 "kamadak-exif",
 "ksni",
 "libadwaita",
+ "pangocairo",
 "pdfs-core",
+ "reqwest",
 "serde",
 "serde_json",
 "tokio",
@@ -3668,9 +3773,9 @@ dependencies = [

 [[package]]
 name = "proton-drive-rs"
-version = "0.6.5"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46cbe05623d9b73bd48b1473f42d43180142b2ee676b1cb9e9a06b562c60ba26"
+checksum = "d0f6996724e51e99f03d2843828de9477afc39baa764403cb69490cabc1c4d93"
 dependencies = [
 "async-trait",
 "base64 0.23.1",
@@ -3695,9 +3800,9 @@ dependencies = [

 [[package]]
 name = "proton-sdk"
-version = "0.6.5"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7310d93bed440dfe4fd60306923f6a491901ee0d618b65ace4e5e22ff0387c1f"
+checksum = "91cc25654133bd5714407a1df0996eaf214a6e8e0bb95d8139bc42e7cee31c34"
 dependencies = [
 "aes-gcm 0.11.1",
 "async-trait",
@@ -4055,6 +4160,18 @@ dependencies = [
 "syn 3.0.5",
 ]

+[[package]]
+name = "regex"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
 [[package]]
 name = "regex-automata"
 version = "0.4.18"
@@ -4796,6 +4913,12 @@ version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"

+[[package]]
+name = "temp-dir"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83176759e9416cf81ee66cb6508dbfe9c96f20b8b56265a39917551c23c70964"
+
 [[package]]
 name = "tempfile"
 version = "3.27.0"
@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/pdfs-core", "crates/pdfs-fuse", "crates/pdfs-cli", "crates/pdfs-gui"]

 [workspace.package]
-version = "1.11.0"
+version = "2.4.0"
 edition = "2024"
 license = "MIT"
 authors = ["Nils Pukropp <contact@narl.io>"]
@@ -15,8 +15,8 @@ keywords = ["proton", "drive", "fuse", "sync", "linux"]
 categories = ["filesystem", "command-line-utilities"]

 [workspace.dependencies]
-proton-sdk = { version = "0.6.5" }
-proton-drive-rs = { version = "0.6.5" }
+proton-sdk = { version = "0.7.0" }
+proton-drive-rs = { version = "0.7.0" }

 # Internal crates.
 pdfs-core = { path = "crates/pdfs-core" }
@@ -32,8 +32,8 @@ sudo apt install ./proton-drive-linux_*.deb
 # Fedora
 sudo dnf install ./proton-drive-linux-*.rpm

-# Arch Linux
-cd packaging && makepkg -fi
+# Arch Linux (AUR)
+paru -S proton-drive-for-linux        # or -git / -bin
 ```

 Packages for each release are attached to the [latest
@@ -55,7 +55,7 @@ pdfs-app            # the desktop app
 - [Prerequisites](#prerequisites) · [Building](#building-from-source) · [Packages](#installation--packages) · [Releases](#automated-releases-cicd)

 **Documentation:** [Architecture](docs/ARCHITECTURE.md) · [Testing](docs/TESTING.md) ·
-[Recovery](docs/RECOVERY.md) · [Development](docs/DEVELOPMENT.md) ·
+[Recovery](docs/RECOVERY.md) · [Development](docs/DEVELOPMENT.md) · [Translating](docs/TRANSLATING.md) ·
 [Known issues](docs/BUGS.md) · [Changelog](docs/CHANGELOG.md) ·
 [Contributing](CONTRIBUTING.md) · [Security policy](SECURITY.md)

@@ -75,6 +75,7 @@ pdfs-app            # the desktop app
 - **File Version History**: Every revision Proton Drive still holds for a file, from the browser's details pane (**Versions**) or `pdfs versions list|restore|save|rm`. Restoring is server-side — no re-upload — and an old version can be written out to a local file without touching the live one.
 - **Photo Favourites**: Star a photo in the lightbox, filter the gallery to favourites, or use `pdfs favorite <uid>` / `pdfs photos --favorites`.
 - **Photo Albums**: Browse your albums — including the ones shared with you — from the Albums view of the Photos page, or with `pdfs albums` / `pdfs album <uid>`. Album contents open in the same gallery as the timeline.
+- **Places**: The Places view of the Photos page groups photos by the town they were taken in, using the location stored with each photo, as cards or on a world map. Towns are looked up offline in [GeoNames](https://www.geonames.org/) data (CC BY 4.0), and the map is drawn offline from [Natural Earth](https://www.naturalearthdata.com/) land outlines and country borders (public domain). Each town is marked with one of its photos, and zoomed in, every photo sits where it was taken. A street map from [OpenFreeMap](https://openfreemap.org/) (© [OpenStreetMap](https://www.openstreetmap.org/copyright) contributors) can be turned on under Appearance; it is off by default because the tile server learns which parts of the world you look at. Install `iso-codes` for country names in your language.
 - **Human Verification (CAPTCHA) Recovery**: Detects sign-in gates (VPN/new IP challenges) and launches an embedded `WebKitWebView` dialog to safely complete the challenge, transparently retrying authentication with the earned token.
 - **Selective Sync (`.pdfsignore`)**: Keep build trees, dependency directories, and editor leftovers out of synced folders using gitignore-style rules.
 - **Data-Safe Offline Writes**: Durable scratch/staging files and a transactional pending queue preserve acknowledged writes across network failures and restarts.
@@ -348,11 +349,15 @@ Version 1.0 strengthens the boundaries around local-only data and destructive re
    <td align="center" width="50%"><img src="images/shared_with_me.png" alt="Shared with me" width="100%"><br><sub><b>Shared with me</b></sub></td>
  </tr>
  <tr>
-    <td align="center" width="50%"><img src="images/computers.png" alt="Local Backups (Computers)" width="100%"><br><sub><b>Local Backups (Computers)</b></sub></td>
+    <td align="center" width="50%"><img src="images/restore_devices.png" alt="Local Backups (Computers)" width="100%"><br><sub><b>Local Backups (Computers)</b></sub></td>
    <td align="center" width="50%"><img src="images/photos.png" alt="Photos Timeline" width="100%"><br><sub><b>Photos Timeline</b></sub></td>
  </tr>
  <tr>
-    <td align="center" width="50%"><img src="images/prompt.png" alt="Search Launcher Prompt" width="100%"><br><sub><b>Search Launcher Prompt</b></sub></td>
+    <td align="center" width="50%"><img src="images/prompt_gtk.png" alt="Search Launcher Prompt (GTK)" width="100%"><br><sub><b>Search Launcher Prompt (GTK)</b></sub></td>
+    <td align="center" width="50%"><img src="images/prompt_fzf.png" alt="Search Launcher Prompt (fzf)" width="100%"><br><sub><b>Search Launcher Prompt (fzf)</b></sub></td>
+  </tr>
+  <tr>
+    <td align="center" width="50%"><img src="images/activity.png" alt="Activity" width="100%"><br><sub><b>Activity</b></sub></td>
    <td align="center" width="50%"><img src="images/settings.png" alt="Settings" width="100%"><br><sub><b>Settings</b></sub></td>
  </tr>
 </table>
@@ -431,8 +436,24 @@ Install the debian package via `dpkg` or `apt`:
 sudo apt install ./proton-drive-linux_*.deb
 ```

-### 2. Arch Linux
-A local `PKGBUILD` is available under the `packaging/` directory. You can build and install it using:
+### 2. Arch Linux (AUR)
+Three AUR packages cover the usual choices; they conflict with each other, so
+install one:
+
+| Package | Contents |
+| --- | --- |
+| [`proton-drive-for-linux`](https://aur.archlinux.org/packages/proton-drive-for-linux) | builds the latest tagged release from source |
+| [`proton-drive-for-linux-git`](https://aur.archlinux.org/packages/proton-drive-for-linux-git) | builds `main` from git |
+| [`proton-drive-for-linux-bin`](https://aur.archlinux.org/packages/proton-drive-for-linux-bin) | installs the release binaries, no compile |
+
+```bash
+paru -S proton-drive-for-linux        # or any AUR helper
+```
+
+The package sources live in `packaging/aur/`; see
+[`packaging/aur/README.md`](packaging/aur/README.md) for how they are updated and
+published. A local `PKGBUILD` that compiles the working tree in place is still
+available for development builds:
 ```bash
 cd packaging && makepkg -fi
 ```
@@ -483,6 +504,10 @@ Bug reports, packaging fixes, and patches are welcome — see [CONTRIBUTING.md](
 the workflow and the quality gates CI enforces, and [SECURITY.md](SECURITY.md) for reporting a
 vulnerability privately.

+The app, tray and search prompt are available in English, German, Spanish, French, Italian, Dutch,
+Polish and Brazilian Portuguese. [docs/TRANSLATING.md](docs/TRANSLATING.md) explains how to improve
+a translation or add a language.
+
 ## License

 Released under the [MIT License](LICENSE).
@@ -13,8 +13,9 @@ use pdfs_core::auth;
 use pdfs_core::cache::ContentCache;
 use pdfs_core::config::AppDirs;
 use pdfs_core::control::{
-    ErrorKind, MountKind, RefreshScope, Request as CtlRequest, Response as CtlResponse,
-    RestoreItem as CtlRestoreItem, ShareEntryKind, SyncPhase, pending_summary,
+    ConflictKeep, ErrorKind, MountKind, RefreshScope, Request as CtlRequest,
+    Response as CtlResponse, RestoreItem as CtlRestoreItem, ShareEntryKind, SyncPhase,
+    pending_summary,
 };
 use pdfs_core::db::Db;
 use pdfs_core::service;
@@ -145,11 +146,11 @@ enum Command {
        /// Skip this many photos from the start of the timeline.
        #[arg(long, default_value_t = 0)]
        offset: usize,
-        /// List only favourited photos.
+        /// List only favorited photos.
        #[arg(long)]
        favorites: bool,
    },
-    /// Add or remove a photo's favourite mark.
+    /// Add or remove a photo's favorite mark.
    Favorite {
        /// Photo node uid in `volume~link` form (from `pdfs photos`).
        uid: String,
@@ -187,7 +188,7 @@ enum Command {
    /// and rewrites them at the right time.
    ///
    /// Proton cannot edit a sealed capture time, so a rewrite means re-uploading
-    /// the photo and trashing the original — favourites and albums are carried
+    /// the photo and trashing the original — favorites and albums are carried
    /// across, and the original goes to Proton's trash, not away. Run it with
    /// `--dry-run` first.
    RedatePhotos {
@@ -229,6 +230,43 @@ enum Command {
        #[arg(long, default_value_t = 0)]
        offset: usize,
    },
+    /// Create a photo album and print its uid.
+    NewAlbum {
+        /// Album name.
+        name: String,
+    },
+    /// Rename a photo album.
+    RenameAlbum {
+        /// Album node uid in `volume~link` form (from `pdfs albums`).
+        uid: String,
+        /// New name.
+        name: String,
+    },
+    /// Delete a photo album. Its photos stay in the timeline.
+    DeleteAlbum {
+        /// Album node uid in `volume~link` form (from `pdfs albums`).
+        uid: String,
+        /// Also delete photos that exist only in this album (saved from a
+        /// shared album); without it the server refuses to delete such an album.
+        #[arg(long)]
+        with_photos: bool,
+    },
+    /// Add photos to an album.
+    AddToAlbum {
+        /// Album node uid in `volume~link` form (from `pdfs albums`).
+        uid: String,
+        /// Photo node uids (from `pdfs photos`).
+        #[arg(required = true)]
+        photos: Vec<String>,
+    },
+    /// Take photos out of an album. They stay in the timeline.
+    RemoveFromAlbum {
+        /// Album node uid in `volume~link` form (from `pdfs albums`).
+        uid: String,
+        /// Photo node uids (from `pdfs album <uid>`).
+        #[arg(required = true)]
+        photos: Vec<String>,
+    },
    /// Download a photo by uid (`volume~link`) and print its cached path.
    OpenPhoto {
        /// Photo node uid in `volume~link` form (from `pdfs photos`).
@@ -241,6 +279,9 @@ enum Command {
        /// Max hits to return.
        #[arg(long, default_value_t = 50)]
        limit: usize,
+        /// Only search below this folder (under the mountpoint).
+        #[arg(long = "in", value_name = "FOLDER")]
+        scope: Option<PathBuf>,
    },
    /// Rename a file or folder via the running daemon.
    Rename {
@@ -327,6 +368,11 @@ enum Command {
        #[command(subcommand)]
        action: SyncCmd,
    },
+    /// List `(sync-conflict …)` copies, or resolve one.
+    Conflicts {
+        #[command(subcommand)]
+        action: Option<ConflictCmd>,
+    },
    /// Share a file or folder with Proton and/or external email addresses.
    Share {
        /// File/folder path, inside the mountpoint or relative to it.
@@ -357,14 +403,18 @@ enum Command {
        /// New role: viewer, editor or admin.
        role: String,
    },
-    /// Remove a member or pending invitation from a node's share.
+    /// Stop sharing a node, or remove one member or pending invitation.
+    ///
+    /// With only a path, removes the public link, every invitation and every
+    /// member. With an id and kind (from `pdfs members`), removes that entry.
    Unshare {
        /// File/folder path, inside the mountpoint or relative to it.
        path: PathBuf,
        /// Entry id (membership or invitation id), from `pdfs members`.
-        id: String,
+        #[arg(requires = "kind")]
+        id: Option<String>,
        /// Entry kind: member, proton or external.
-        kind: ShareKindArg,
+        kind: Option<ShareKindArg>,
    },
    /// Inspect and restore a file's earlier versions.
    Versions {
@@ -521,6 +571,22 @@ enum DeviceCmd {
    },
 }

+#[derive(Subcommand)]
+enum ConflictCmd {
+    /// Decide which side of a conflict to keep. Whatever is removed goes to Trash.
+    Resolve {
+        /// The conflict copy, absolute or relative to the mountpoint.
+        path: PathBuf,
+        /// `original` trashes the copy; `copy` trashes the original and gives the
+        /// copy its name; `both` renames the copy to `--name`.
+        #[arg(long, value_parser = ["original", "copy", "both"])]
+        keep: String,
+        /// New name for the copy with `--keep both`.
+        #[arg(long, required_if_eq("keep", "both"))]
+        name: Option<String>,
+    },
+}
+
 #[derive(Subcommand)]
 enum SyncCmd {
    /// Add a local folder to this machine's device and upload its contents.
@@ -543,6 +609,38 @@ enum SyncCmd {
        /// Optional synced-folder id; omit to reconcile every folder.
        id: Option<i64>,
    },
+    /// Pause syncing: queued uploads and mirror folders wait, reads keep working.
+    Pause {
+        /// End the pause by itself after this long, e.g. `30m`, `1h`, `2d`.
+        /// Omit to pause until `pdfs sync resume`.
+        #[arg(long = "for", value_parser = parse_pause_duration, conflicts_with = "folder")]
+        duration: Option<u64>,
+        /// Pause only this mirror folder (id from `sync list`) until resumed.
+        #[arg(long)]
+        folder: Option<i64>,
+    },
+    /// Resume syncing after `pdfs sync pause`.
+    Resume {
+        /// Resume only this folder, paused with `sync pause --folder`.
+        #[arg(long)]
+        folder: Option<i64>,
+    },
+    /// Cap upload and download speed, or show the caps with no options.
+    Limit {
+        /// Upload cap per second, e.g. `500K` or `2M`; `0` removes it.
+        #[arg(long, value_parser = parse_rate)]
+        up: Option<u64>,
+        /// Download cap per second, e.g. `500K` or `2M`; `0` removes it.
+        #[arg(long, value_parser = parse_rate)]
+        down: Option<u64>,
+    },
+    /// List uploads and changes not yet on Proton Drive.
+    Queue,
+    /// Retry a queued operation now (by id from `sync queue`), or every failed one.
+    Retry {
+        /// Queue id; omit to retry every failed operation.
+        id: Option<i64>,
+    },
    /// Switch a folder between full-copy sync and on-demand (FUSE, no local storage).
    Mode {
        /// Synced-folder id (from `sync list`).
@@ -557,6 +655,10 @@ enum SyncCmd {
        /// Accept every proposed local path without asking.
        #[arg(long)]
        yes: bool,
+        /// Restore another computer's folders instead, by device uid (from
+        /// `pdfs devices list`).
+        #[arg(long)]
+        device: Option<String>,
    },
 }

@@ -675,8 +777,28 @@ fn main() -> Result<()> {
        Command::ImportStatus => cmd_import_status(),
        Command::CancelImport => cmd_cancel_import(),
        Command::Album { uid, limit, offset } => cmd_album(uid, limit, offset),
+        Command::NewAlbum { name } => cmd_new_album(name),
+        Command::RenameAlbum { uid, name } => {
+            ok_or_bail(control_request(CtlRequest::RenameAlbum { uid, name })?)
+        }
+        Command::DeleteAlbum { uid, with_photos } => {
+            ok_or_bail(control_request(CtlRequest::DeleteAlbum {
+                uid,
+                delete_photos: with_photos,
+            })?)
+        }
+        Command::AddToAlbum { uid, photos } => {
+            cmd_album_change(CtlRequest::AddToAlbum { uid, photos }, "added")
+        }
+        Command::RemoveFromAlbum { uid, photos } => {
+            cmd_album_change(CtlRequest::RemoveFromAlbum { uid, photos }, "removed")
+        }
        Command::OpenPhoto { uid } => cmd_open_photo(uid),
-        Command::Search { query, limit } => cmd_search(query, limit),
+        Command::Search {
+            query,
+            limit,
+            scope,
+        } => cmd_search(query, limit, scope),
        Command::Rename { path, new_name } => cmd_rename(path, new_name),
        Command::Move { path, new_parent } => cmd_move(path, new_parent),
        Command::Rm { path } => cmd_rm(path),
@@ -691,6 +813,7 @@ fn main() -> Result<()> {
        Command::Refresh { target, full } => cmd_refresh(target, full),
        Command::Devices { action } => cmd_devices(action),
        Command::Sync { action } => cmd_sync(action),
+        Command::Conflicts { action } => cmd_conflicts(action),
        Command::Share {
            path,
            emails,
@@ -798,6 +921,10 @@ fn cmd_sync(action: SyncCmd) -> Result<()> {
                            Some(pending) => format!("{} → {pending}", f.mode),
                            None => f.mode.clone(),
                        };
+                        let mode = match f.paused {
+                            true => format!("{mode}, paused"),
+                            false => mode,
+                        };
                        println!(
                            "[{}]  {}  ({mode}, {}, synced: {sync})",
                            f.id, f.local_path, f.state
@@ -834,10 +961,114 @@ fn cmd_sync(action: SyncCmd) -> Result<()> {
            })?)?
        }
        SyncCmd::Now { id } => ok_or_bail(control_request(CtlRequest::SyncNow { id })?)?,
+        SyncCmd::Pause {
+            folder: Some(id), ..
+        } => ok_or_bail(control_request(CtlRequest::SetSyncFolderPaused {
+            id,
+            paused: true,
+        })?)?,
+        SyncCmd::Resume { folder: Some(id) } => {
+            ok_or_bail(control_request(CtlRequest::SetSyncFolderPaused {
+                id,
+                paused: false,
+            })?)?
+        }
+        SyncCmd::Pause {
+            duration,
+            folder: None,
+        } => {
+            let until = duration.map(|secs| unix_now().saturating_add(secs as i64));
+            ok_or_bail(control_request(CtlRequest::SetSyncPaused {
+                paused: true,
+                until,
+            })?)?
+        }
+        SyncCmd::Queue => return cmd_sync_queue(),
+        SyncCmd::Limit { up, down } => return cmd_sync_limit(up, down),
+        SyncCmd::Retry { id } => ok_or_bail(control_request(CtlRequest::RetryPendingOp { id })?)?,
+        SyncCmd::Resume { folder: None } => {
+            ok_or_bail(control_request(CtlRequest::SetSyncPaused {
+                paused: false,
+                until: None,
+            })?)?
+        }
        SyncCmd::Mode { id, mode } => {
            ok_or_bail(control_request(CtlRequest::SetSyncFolderMode { id, mode })?)?
        }
-        SyncCmd::Restore { yes } => return cmd_sync_restore(yes),
+        SyncCmd::Restore { yes, device } => return cmd_sync_restore(yes, device),
+    }
+    Ok(())
+}
+
+/// `pdfs conflicts`: list conflict copies, or resolve one.
+fn cmd_conflicts(action: Option<ConflictCmd>) -> Result<()> {
+    if let Some(ConflictCmd::Resolve { path, keep, name }) = action {
+        let keep = match keep.as_str() {
+            "original" => ConflictKeep::Original,
+            "copy" => ConflictKeep::Copy,
+            _ => ConflictKeep::Both {
+                name: name.unwrap_or_default(),
+            },
+        };
+        let path = path_arg(&path)?;
+        return ok_or_bail(control_request(CtlRequest::ResolveConflict { path, keep })?);
+    }
+    let response = control_request(CtlRequest::ListConflicts)?;
+    if emit_json(&response)? {
+        return Ok(());
+    }
+    match response {
+        CtlResponse::Conflicts { items } if items.is_empty() => println!("No conflicts."),
+        CtlResponse::Conflicts { items } => {
+            for c in items {
+                println!("{}", c.path);
+                let verdict = match (c.original_exists, c.identical) {
+                    (false, _) => "original is gone".to_string(),
+                    (true, true) => format!("identical to {}", c.original_path),
+                    (true, false) => format!(
+                        "differs from {} ({} vs {})",
+                        c.original_path,
+                        human_bytes(c.size),
+                        human_bytes(c.original_size.unwrap_or_default()),
+                    ),
+                };
+                println!("      {verdict}");
+            }
+        }
+        CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
+        other => bail!("unexpected response: {other:?}"),
+    }
+    Ok(())
+}
+
+/// `pdfs sync queue`: what has not reached Proton Drive yet, and why.
+fn cmd_sync_queue() -> Result<()> {
+    let response = control_request(CtlRequest::ListPendingOps)?;
+    if emit_json(&response)? {
+        return Ok(());
+    }
+    match response {
+        CtlResponse::PendingOps { items } if items.is_empty() => {
+            println!("Nothing queued: everything is on Proton Drive.");
+        }
+        CtlResponse::PendingOps { items } => {
+            let now = unix_now();
+            for op in items {
+                let state = match (op.parked, op.next_attempt_at) {
+                    (true, _) => "waiting for its final name".to_string(),
+                    (false, Some(at)) if at > now => {
+                        format!("next try in {}", human_age((at - now) as u64))
+                    }
+                    (false, _) => "due now".to_string(),
+                };
+                println!("[{}]  {}  {}  ({state})", op.id, op.kind, op.path);
+                if let Some(error) = &op.last_error {
+                    println!("      failed {} time(s): {error}", op.attempts);
+                }
+            }
+        }
+        CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
+        other => bail!("unexpected response: {other:?}"),
    }
    Ok(())
 }
@@ -848,8 +1079,13 @@ fn cmd_sync(action: SyncCmd) -> Result<()> {
 /// The daemon only ever *proposes* local paths — a path recorded by another
 /// machine may name a home directory that does not exist here — so the default
 /// flow is propose-and-confirm. `--yes` accepts the proposals for scripting.
-fn cmd_sync_restore(yes: bool) -> Result<()> {
-    let response = control_request(CtlRequest::ListRestorableFolders)?;
+fn cmd_sync_restore(yes: bool, device: Option<String>) -> Result<()> {
+    let response = control_request(match &device {
+        Some(device) => CtlRequest::ListDeviceRestorableFolders {
+            device: device.clone(),
+        },
+        None => CtlRequest::ListRestorableFolders,
+    })?;
    if emit_json(&response)? {
        return Ok(());
    }
@@ -899,8 +1135,12 @@ fn cmd_sync_restore(yes: bool) -> Result<()> {
        println!("Nothing selected.");
        return Ok(());
    }
-    ok_or_bail(control_request(CtlRequest::RestoreSyncFolders {
-        items: chosen,
+    ok_or_bail(control_request(match device {
+        Some(device) => CtlRequest::RestoreDeviceFolders {
+            device,
+            items: chosen,
+        },
+        None => CtlRequest::RestoreSyncFolders { items: chosen },
    })?)
 }

@@ -1038,12 +1278,17 @@ fn cmd_share_role(path: PathBuf, id: String, kind: ShareKindArg, role: String) -
    })?)
 }

-fn cmd_unshare(path: PathBuf, id: String, kind: ShareKindArg) -> Result<()> {
-    ok_or_bail(control_request(CtlRequest::RemoveShareEntry {
-        path: path_arg(&path)?,
-        id,
-        kind: kind.to_kind(),
-    })?)
+fn cmd_unshare(path: PathBuf, id: Option<String>, kind: Option<ShareKindArg>) -> Result<()> {
+    let path = path_arg(&path)?;
+    let request = match (id, kind) {
+        (Some(id), Some(kind)) => CtlRequest::RemoveShareEntry {
+            path,
+            id,
+            kind: kind.to_kind(),
+        },
+        _ => CtlRequest::StopSharing { path },
+    };
+    ok_or_bail(control_request(request)?)
 }

 fn cmd_public_link(action: PublicLinkCmd) -> Result<()> {
@@ -1472,9 +1717,15 @@ fn cmd_status() -> Result<()> {
            failing_error,
            staged_bytes,
            staged_oldest_secs,
+            paused,
+            paused_until,
            ..
        }) => {
-            let state = if online { "" } else { ", offline" };
+            let state = match (online, paused) {
+                (_, true) => ", sync paused",
+                (false, false) => ", offline",
+                (true, false) => "",
+            };
            let queued = match pending_summary(pending_uploads, pending_changes) {
                Some(s) => format!(", {s}"),
                None => String::new(),
@@ -1490,6 +1741,10 @@ fn cmd_status() -> Result<()> {
                    human_age(staged_oldest_secs),
                );
            }
+            if let Some(until) = paused_until {
+                let left = until.saturating_sub(unix_now()).max(0) as u64;
+                println!("Paused     sync resumes in {}", human_age(left.max(1)));
+            }
            if parked_uploads > 0 {
                println!("Parked     {parked_uploads} upload(s) waiting for a final filename");
            }
@@ -1682,6 +1937,8 @@ fn mount_once(mountpoint: Option<PathBuf>) -> Result<pdfs_fuse::MountOutcome> {
        pdfs_fuse::MountOptions {
            username,
            sweep_mode: config.resolved_conflict_sweep(),
+            upload_limit: config.upload_limit.unwrap_or(0),
+            download_limit: config.download_limit.unwrap_or(0),
        },
    );

@@ -1817,6 +2074,7 @@ fn cmd_photos(limit: usize, offset: usize, favorites: bool) -> Result<()> {
        kind: None,
        range: None,
        favorites,
+        not_in_album: false,
    })? {
        CtlResponse::Photos {
            available: false, ..
@@ -1886,6 +2144,42 @@ fn cmd_albums() -> Result<()> {
    Ok(())
 }

+fn cmd_new_album(name: String) -> Result<()> {
+    match control_request(CtlRequest::CreateAlbum { name })? {
+        CtlResponse::AlbumCreated { uid } => println!("{uid}"),
+        CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
+        other => bail!("unexpected response: {other:?}"),
+    }
+    Ok(())
+}
+
+/// Send an album add or remove and report it per photo; any failed photo
+/// fails the command.
+fn cmd_album_change(request: CtlRequest, verb: &str) -> Result<()> {
+    match control_request(request)? {
+        CtlResponse::AlbumChanged { changed, failed } => {
+            println!("{} {verb}", photo_count(changed.len()));
+            for failure in &failed {
+                eprintln!("{}: {}", failure.uid, failure.message);
+            }
+            if !failed.is_empty() {
+                bail!("{} failed", photo_count(failed.len()));
+            }
+        }
+        CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
+        other => bail!("unexpected response: {other:?}"),
+    }
+    Ok(())
+}
+
+fn photo_count(n: usize) -> String {
+    if n == 1 {
+        "1 photo".to_string()
+    } else {
+        format!("{n} photos")
+    }
+}
+
 fn cmd_import_google_photos(archives: Vec<PathBuf>, dry_run: bool, wait: bool) -> Result<()> {
    // The daemon opens the archives itself off the shared filesystem, so it gets
    // absolute paths — the same arrangement `pdfs upload` uses.
@@ -2112,8 +2406,13 @@ fn cmd_open_photo(uid: String) -> Result<()> {
    Ok(())
 }

-fn cmd_search(query: String, limit: usize) -> Result<()> {
-    match control_request(CtlRequest::Search { query, limit })? {
+fn cmd_search(query: String, limit: usize, scope: Option<PathBuf>) -> Result<()> {
+    let scope = scope.map(|p| path_arg(&p)).transpose()?;
+    match control_request(CtlRequest::Search {
+        query,
+        limit,
+        scope,
+    })? {
        CtlResponse::SearchResults { hits } if hits.is_empty() => println!("(no matches)"),
        CtlResponse::SearchResults { hits } => {
            for h in hits {
@@ -2384,6 +2683,72 @@ fn path_arg(path: &Path) -> Result<String> {

 /// Format an age in seconds for a report line, coarsely — the point of the
 /// number is whether it is minutes or weeks.
+/// Parse a `sync pause --for` duration: a whole number followed by `m`, `h` or
+/// `d`. Returns seconds.
+fn parse_pause_duration(text: &str) -> Result<u64, String> {
+    let text = text.trim();
+    let split = text.char_indices().last().map_or(0, |(at, _)| at);
+    let (number, unit) = text.split_at(split);
+    let per_unit: u64 = match unit {
+        "m" => 60,
+        "h" => 3600,
+        "d" => 86_400,
+        _ => return Err("use a number followed by m, h or d, e.g. 30m".to_string()),
+    };
+    match number.parse::<u64>() {
+        Ok(n) if n > 0 => Ok(n.saturating_mul(per_unit)),
+        _ => Err("use a positive whole number, e.g. 30m".to_string()),
+    }
+}
+
+/// Read a bytes-per-second rate: a whole number with an optional `K`, `M` or
+/// `G` suffix in the same binary units `human_bytes` prints.
+fn parse_rate(text: &str) -> Result<u64, String> {
+    let text = text.trim();
+    let (number, scale) = match text.char_indices().last() {
+        Some((at, 'K' | 'k')) => (&text[..at], 1024),
+        Some((at, 'M' | 'm')) => (&text[..at], 1_048_576),
+        Some((at, 'G' | 'g')) => (&text[..at], 1_073_741_824),
+        _ => (text, 1),
+    };
+    number
+        .parse::<u64>()
+        .map(|n| n.saturating_mul(scale))
+        .map_err(|_| "use a whole number with an optional K, M or G, e.g. 2M".to_string())
+}
+
+fn human_rate(rate: u64) -> String {
+    if rate == 0 {
+        "unlimited".to_string()
+    } else {
+        format!("{}/s", human_bytes(rate))
+    }
+}
+
+/// `pdfs sync limit`: set the bandwidth caps, keeping whichever one is not
+/// given, or print both when neither is.
+fn cmd_sync_limit(up: Option<u64>, down: Option<u64>) -> Result<()> {
+    let config = AppDirs::new()?.load_config();
+    let upload = up.or(config.upload_limit).unwrap_or(0);
+    let download = down.or(config.download_limit).unwrap_or(0);
+    if up.is_none() && down.is_none() {
+        println!("Upload     {}", human_rate(upload));
+        println!("Download   {}", human_rate(download));
+        return Ok(());
+    }
+    ok_or_bail(control_request(CtlRequest::SetBandwidthLimits {
+        upload,
+        download,
+    })?)
+}
+
+fn unix_now() -> i64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_secs() as i64)
+        .unwrap_or(0)
+}
+
 fn human_age(secs: u64) -> String {
    const UNITS: [(&str, u64); 4] = [("d", 86_400), ("h", 3_600), ("m", 60), ("s", 1)];
    for (unit, scale) in UNITS {
@@ -2847,6 +3212,40 @@ fn control_request(req: CtlRequest) -> Result<CtlResponse> {
        .with_context(|| format!("talk to mount daemon at {}", socket.display()))
 }

+#[cfg(test)]
+mod pause_tests {
+    use super::*;
+
+    #[test]
+    fn pause_durations_read_minutes_hours_and_days() {
+        assert_eq!(parse_pause_duration("30m"), Ok(1800));
+        assert_eq!(parse_pause_duration("1h"), Ok(3600));
+        assert_eq!(parse_pause_duration("2d"), Ok(172_800));
+    }
+
+    #[test]
+    fn pause_durations_reject_what_they_cannot_read() {
+        assert!(parse_pause_duration("").is_err());
+        assert!(parse_pause_duration("0h").is_err());
+        assert!(parse_pause_duration("1w").is_err());
+        assert!(parse_pause_duration("h").is_err());
+        assert!(parse_pause_duration("-1h").is_err());
+        assert!(parse_pause_duration("1ä").is_err());
+    }
+
+    #[test]
+    fn rates_read_plain_bytes_and_binary_suffixes() {
+        assert_eq!(parse_rate("0"), Ok(0));
+        assert_eq!(parse_rate("1500"), Ok(1500));
+        assert_eq!(parse_rate("500K"), Ok(512_000));
+        assert_eq!(parse_rate("2m"), Ok(2_097_152));
+        assert!(parse_rate("").is_err());
+        assert!(parse_rate("M").is_err());
+        assert!(parse_rate("1.5M").is_err());
+        assert!(parse_rate("2MB").is_err());
+    }
+}
+
 #[cfg(test)]
 mod diagnose_tests {
    use super::*;
@@ -2977,3 +3376,36 @@ mod login_wait_tests {
        assert!(shared_by_line(&entry).unwrap().contains("WARNING"));
    }
 }
+
+#[cfg(test)]
+mod unshare_tests {
+    use super::*;
+    use clap::Parser;
+
+    #[test]
+    fn unshare_with_only_a_path_stops_sharing() {
+        let cli = Cli::try_parse_from(["pdfs", "unshare", "docs/report.pdf"]).unwrap();
+        assert!(matches!(
+            cli.command,
+            Command::Unshare {
+                id: None,
+                kind: None,
+                ..
+            }
+        ));
+    }
+
+    #[test]
+    fn unshare_with_an_id_needs_its_kind() {
+        assert!(Cli::try_parse_from(["pdfs", "unshare", "docs", "abc"]).is_err());
+        let cli = Cli::try_parse_from(["pdfs", "unshare", "docs", "abc", "member"]).unwrap();
+        assert!(matches!(
+            cli.command,
+            Command::Unshare {
+                id: Some(_),
+                kind: Some(_),
+                ..
+            }
+        ));
+    }
+}
@@ -0,0 +1,250 @@
+AD	Andorra
+AE	United Arab Emirates
+AF	Afghanistan
+AG	Antigua and Barbuda
+AI	Anguilla
+AL	Albania
+AM	Armenia
+AO	Angola
+AQ	Antarctica
+AR	Argentina
+AS	American Samoa
+AT	Austria
+AU	Australia
+AW	Aruba
+AX	Åland Islands
+AZ	Azerbaijan
+BA	Bosnia and Herzegovina
+BB	Barbados
+BD	Bangladesh
+BE	Belgium
+BF	Burkina Faso
+BG	Bulgaria
+BH	Bahrain
+BI	Burundi
+BJ	Benin
+BL	Saint Barthélemy
+BM	Bermuda
+BN	Brunei Darussalam
+BO	Bolivia, Plurinational State of
+BQ	Bonaire, Sint Eustatius and Saba
+BR	Brazil
+BS	Bahamas
+BT	Bhutan
+BV	Bouvet Island
+BW	Botswana
+BY	Belarus
+BZ	Belize
+CA	Canada
+CC	Cocos (Keeling) Islands
+CD	Congo, The Democratic Republic of the
+CF	Central African Republic
+CG	Congo
+CH	Switzerland
+CI	Côte d'Ivoire
+CK	Cook Islands
+CL	Chile
+CM	Cameroon
+CN	China
+CO	Colombia
+CR	Costa Rica
+CU	Cuba
+CV	Cabo Verde
+CW	Curaçao
+CX	Christmas Island
+CY	Cyprus
+CZ	Czechia
+DE	Germany
+DJ	Djibouti
+DK	Denmark
+DM	Dominica
+DO	Dominican Republic
+DZ	Algeria
+EC	Ecuador
+EE	Estonia
+EG	Egypt
+EH	Western Sahara
+ER	Eritrea
+ES	Spain
+ET	Ethiopia
+FI	Finland
+FJ	Fiji
+FK	Falkland Islands (Malvinas)
+FM	Micronesia, Federated States of
+FO	Faroe Islands
+FR	France
+GA	Gabon
+GB	United Kingdom
+GD	Grenada
+GE	Georgia
+GF	French Guiana
+GG	Guernsey
+GH	Ghana
+GI	Gibraltar
+GL	Greenland
+GM	Gambia
+GN	Guinea
+GP	Guadeloupe
+GQ	Equatorial Guinea
+GR	Greece
+GS	South Georgia and the South Sandwich Islands
+GT	Guatemala
+GU	Guam
+GW	Guinea-Bissau
+GY	Guyana
+HK	Hong Kong
+HM	Heard Island and McDonald Islands
+HN	Honduras
+HR	Croatia
+HT	Haiti
+HU	Hungary
+ID	Indonesia
+IE	Ireland
+IL	Israel
+IM	Isle of Man
+IN	India
+IO	British Indian Ocean Territory
+IQ	Iraq
+IR	Iran, Islamic Republic of
+IS	Iceland
+IT	Italy
+JE	Jersey
+JM	Jamaica
+JO	Jordan
+JP	Japan
+KE	Kenya
+KG	Kyrgyzstan
+KH	Cambodia
+KI	Kiribati
+KM	Comoros
+KN	Saint Kitts and Nevis
+KP	Korea, Democratic People's Republic of
+KR	Korea, Republic of
+KW	Kuwait
+KY	Cayman Islands
+KZ	Kazakhstan
+LA	Lao People's Democratic Republic
+LB	Lebanon
+LC	Saint Lucia
+LI	Liechtenstein
+LK	Sri Lanka
+LR	Liberia
+LS	Lesotho
+LT	Lithuania
+LU	Luxembourg
+LV	Latvia
+LY	Libya
+MA	Morocco
+MC	Monaco
+MD	Moldova, Republic of
+ME	Montenegro
+MF	Saint Martin (French part)
+MG	Madagascar
+MH	Marshall Islands
+MK	North Macedonia
+ML	Mali
+MM	Myanmar
+MN	Mongolia
+MO	Macao
+MP	Northern Mariana Islands
+MQ	Martinique
+MR	Mauritania
+MS	Montserrat
+MT	Malta
+MU	Mauritius
+MV	Maldives
+MW	Malawi
+MX	Mexico
+MY	Malaysia
+MZ	Mozambique
+NA	Namibia
+NC	New Caledonia
+NE	Niger
+NF	Norfolk Island
+NG	Nigeria
+NI	Nicaragua
+NL	Netherlands
+NO	Norway
+NP	Nepal
+NR	Nauru
+NU	Niue
+NZ	New Zealand
+OM	Oman
+PA	Panama
+PE	Peru
+PF	French Polynesia
+PG	Papua New Guinea
+PH	Philippines
+PK	Pakistan
+PL	Poland
+PM	Saint Pierre and Miquelon
+PN	Pitcairn
+PR	Puerto Rico
+PS	Palestine, State of
+PT	Portugal
+PW	Palau
+PY	Paraguay
+QA	Qatar
+RE	Réunion
+RO	Romania
+RS	Serbia
+RU	Russian Federation
+RW	Rwanda
+SA	Saudi Arabia
+SB	Solomon Islands
+SC	Seychelles
+SD	Sudan
+SE	Sweden
+SG	Singapore
+SH	Saint Helena, Ascension and Tristan da Cunha
+SI	Slovenia
+SJ	Svalbard and Jan Mayen
+SK	Slovakia
+SL	Sierra Leone
+SM	San Marino
+SN	Senegal
+SO	Somalia
+SR	Suriname
+SS	South Sudan
+ST	Sao Tome and Principe
+SV	El Salvador
+SX	Sint Maarten (Dutch part)
+SY	Syrian Arab Republic
+SZ	Eswatini
+TC	Turks and Caicos Islands
+TD	Chad
+TF	French Southern Territories
+TG	Togo
+TH	Thailand
+TJ	Tajikistan
+TK	Tokelau
+TL	Timor-Leste
+TM	Turkmenistan
+TN	Tunisia
+TO	Tonga
+TR	Türkiye
+TT	Trinidad and Tobago
+TV	Tuvalu
+TW	Taiwan, Province of China
+TZ	Tanzania, United Republic of
+UA	Ukraine
+UG	Uganda
+UM	United States Minor Outlying Islands
+US	United States
+UY	Uruguay
+UZ	Uzbekistan
+VA	Holy See (Vatican City State)
+VC	Saint Vincent and the Grenadines
+VE	Venezuela, Bolivarian Republic of
+VG	Virgin Islands, British
+VI	Virgin Islands, U.S.
+VN	Viet Nam
+VU	Vanuatu
+WF	Wallis and Futuna
+WS	Samoa
+XK	Kosovo
+YE	Yemen
+YT	Mayotte
+ZA	South Africa
+ZM	Zambia
+ZW	Zimbabwe
@@ -298,6 +298,10 @@ pub struct Pin {
    /// which is why it is defaulted.
    #[serde(default)]
    pub is_dir: Option<bool>,
+    /// A pinned file whose content is on disk right now. The daemon fills it
+    /// in when it answers `ListPins`; folders and older daemons say `false`.
+    #[serde(default)]
+    pub cached: bool,
 }

 /// The legacy JSON pin registry, kept only to import a pre-P5 `pins.json` into
@@ -1854,6 +1858,7 @@ impl ContentCache {
                path: row.path,
                recursive: row.recursive,
                is_dir: row.is_dir,
+                cached: false,
            })
            .collect()
    }
@@ -85,6 +85,15 @@ pub struct AppConfig {
    /// writes an explicit value here. Defaulted for configs predating the field.
    #[serde(default)]
    pub cache_budget: Option<u64>,
+    /// Upload cap in bytes per second shared by every upload. `None` or `0`
+    /// means no cap. Defaulted for configs predating the field.
+    #[serde(default)]
+    pub upload_limit: Option<u64>,
+    /// Download cap in bytes per second shared by every download, FUSE reads
+    /// included. `None` or `0` means no cap. Defaulted for configs predating
+    /// the field.
+    #[serde(default)]
+    pub download_limit: Option<u64>,
    /// Mountpoint the daemon mounts at. `None` means
    /// [`AppDirs::default_mountpoint`]; the Settings page writes an explicit
    /// path here. Defaulted for configs predating the field.
@@ -119,6 +128,85 @@ pub struct AppConfig {
    /// field.
    #[serde(default)]
    pub prompt: Option<PromptConfig>,
+    /// Paint the desktop app in Proton's colours instead of the system theme
+    /// and accent colour. `None` means "follow the system". Defaulted for
+    /// configs predating the field; also read from `proton_accent`, its name
+    /// while it only changed the accent.
+    #[serde(default, alias = "proton_accent")]
+    pub proton_theme: Option<bool>,
+    /// How the desktop app's My Files page lays out and orders a folder.
+    /// Defaulted for configs predating the field.
+    #[serde(default)]
+    pub files_view: FilesView,
+    /// The user hid the tray icon from its own menu. The tray exits at start
+    /// while this is set, and the app does not spawn it; Preferences turns it
+    /// back on. Defaulted for configs predating the field.
+    #[serde(default)]
+    pub tray_hidden: bool,
+    /// Language for the desktop app, tray and search prompt, as a gettext code
+    /// such as `de` or `pt_BR`. `None` means "follow the system locale".
+    /// Defaulted for configs predating the field.
+    #[serde(default)]
+    pub language: Option<String>,
+    /// Draw the Places map from OpenFreeMap's street map instead of the
+    /// built-in outline. Off by default: the tiles come from a third party,
+    /// which then learns which parts of the world are looked at. Defaulted for
+    /// configs predating the field.
+    #[serde(default)]
+    pub online_map: bool,
+}
+
+/// The My Files page's view choices, remembered between runs.
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[serde(default)]
+pub struct FilesView {
+    /// Columns instead of the icon grid.
+    pub list: bool,
+    pub sort: FileSort,
+    pub descending: bool,
+    /// Folders ahead of files, whatever the sort.
+    pub folders_first: bool,
+}
+
+impl Default for FilesView {
+    fn default() -> Self {
+        Self {
+            list: false,
+            sort: FileSort::Name,
+            descending: false,
+            folders_first: true,
+        }
+    }
+}
+
+/// The key a My Files listing is ordered by.
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum FileSort {
+    #[default]
+    Name,
+    Size,
+    Modified,
+}
+
+impl FileSort {
+    /// The name used in the desktop app's actions and the config file.
+    pub fn as_str(self) -> &'static str {
+        match self {
+            FileSort::Name => "name",
+            FileSort::Size => "size",
+            FileSort::Modified => "modified",
+        }
+    }
+
+    pub fn parse(value: &str) -> Option<Self> {
+        match value {
+            "name" => Some(FileSort::Name),
+            "size" => Some(FileSort::Size),
+            "modified" => Some(FileSort::Modified),
+            _ => None,
+        }
+    }
 }

 impl Default for AppConfig {
@@ -127,12 +215,19 @@ impl Default for AppConfig {
            app_version: APP_VERSION.to_string(),
            user_agent: USER_AGENT.to_string(),
            cache_budget: None,
+            upload_limit: None,
+            download_limit: None,
            mountpoint: None,
            ignore_patterns: None,
            device_uid: None,
            conflict_sweep: None,
            open_with: None,
            prompt: None,
+            proton_theme: None,
+            files_view: FilesView::default(),
+            tray_hidden: false,
+            language: None,
+            online_map: false,
        }
    }
 }
@@ -471,17 +566,54 @@ mod tests {
            app_version: "external-drive-test-client@1.0.0".to_string(),
            user_agent: "test-agent/1.0".to_string(),
            cache_budget: Some(1234),
+            upload_limit: Some(500_000),
+            download_limit: None,
            mountpoint: Some("/tmp/x".to_string()),
            ignore_patterns: Some(vec!["build/".to_string()]),
            device_uid: Some("dev-uid".to_string()),
            conflict_sweep: Some(SweepMode::Enforce),
            open_with: None,
            prompt: None,
+            proton_theme: Some(true),
+            files_view: FilesView {
+                list: true,
+                sort: FileSort::Modified,
+                descending: true,
+                folders_first: false,
+            },
+            tray_hidden: true,
+            language: Some("de".to_string()),
+            online_map: true,
        };
        let json = serde_json::to_string(&config).unwrap();
        let decoded: AppConfig = serde_json::from_str(&json).unwrap();
        assert_eq!(decoded.app_version, "external-drive-test-client@1.0.0");
        assert_eq!(decoded.user_agent, "test-agent/1.0");
+        assert_eq!(decoded.proton_theme, Some(true));
+        assert!(decoded.tray_hidden);
+        assert!(decoded.online_map);
+        assert_eq!(decoded.language.as_deref(), Some("de"));
+        assert_eq!(decoded.upload_limit, Some(500_000));
+        assert_eq!(decoded.download_limit, None);
+        assert_eq!(decoded.files_view, config.files_view);
+    }
+
+    #[test]
+    fn a_config_without_a_files_view_gets_the_default() {
+        let decoded: AppConfig =
+            serde_json::from_str(r#"{"app_version":"a","user_agent":"b"}"#).unwrap();
+        assert_eq!(decoded.files_view, FilesView::default());
+        let partial: FilesView = serde_json::from_str(r#"{"sort":"size"}"#).unwrap();
+        assert_eq!(partial.sort, FileSort::Size);
+        assert!(partial.folders_first);
+    }
+
+    #[test]
+    fn the_old_proton_accent_setting_turns_on_the_proton_theme() {
+        let decoded: AppConfig =
+            serde_json::from_str(r#"{"app_version":"a","user_agent":"b","proton_accent":true}"#)
+                .unwrap();
+        assert_eq!(decoded.proton_theme, Some(true));
    }

    #[test]
@@ -554,6 +686,11 @@ mod tests {
        let json = r#"{"app_version":"v","user_agent":"u"}"#;
        let decoded: AppConfig = serde_json::from_str(json).unwrap();
        assert!(decoded.ignore_patterns.is_none());
+        assert!(!decoded.tray_hidden, "an old config keeps the tray icon");
+        assert!(
+            decoded.language.is_none(),
+            "an old config follows the system"
+        );
        assert_eq!(
            decoded.resolved_ignore_patterns().len(),
            DEFAULT_IGNORE_PATTERNS.len(),
@@ -63,10 +63,14 @@ pub enum Request {
        /// timeline. Like `kind`, the offset is relative to the filtered set.
        #[serde(default)]
        range: Option<(i64, i64)>,
-        /// Restrict the page to favourited photos. Older front-ends omit it and
+        /// Restrict the page to favorited photos. Older front-ends omit it and
        /// get the whole timeline, as before.
        #[serde(default)]
        favorites: bool,
+        /// Restrict the page to photos no album of ours holds — what is left to
+        /// file. Older front-ends omit it and get the whole timeline, as before.
+        #[serde(default)]
+        not_in_album: bool,
    },
    /// Every photo of one photo's group — the JPEG and the RAW of one shot, a
    /// live photo and its clip. Replies with [`Response::Photos`], holding one
@@ -80,6 +84,34 @@ pub enum Request {
        #[serde(default)]
        kind: Option<PhotoKind>,
    },
+    /// Photos taken on today's date in earlier years, newest first, at most
+    /// `limit` of them — the "On this day" strip above the timeline. Replies
+    /// with [`Response::Photos`]; a front-end groups them by year itself.
+    PhotosOnThisDay { limit: usize },
+    /// Sets of photos that are byte-identical copies of each other, going by
+    /// the server's content hash. Replies with [`Response::PhotoDuplicates`].
+    PhotoDuplicates,
+    /// Sets of shots that look alike going by their thumbnails: resized or
+    /// re-encoded copies, and bursts of one moment. Starts hashing the
+    /// thumbnails not hashed yet in the background and replies at once with
+    /// the sets found so far; a front-end asks again until the reply's
+    /// `hashing` is `None`. Replies with [`Response::PhotoSimilar`].
+    PhotoSimilar,
+    /// The towns the photos were taken in, the one with the most photos first.
+    /// Only photos whose uploader recorded a location count. Replies with
+    /// [`Response::Places`].
+    PhotoPlaces,
+    /// Fetch a page of the photos taken in one town, newest first. `id` is the
+    /// town's id from [`Request::PhotoPlaces`]. Replies with
+    /// [`Response::Photos`], like an album page.
+    PlacePhotos {
+        id: u32,
+        offset: usize,
+        limit: usize,
+    },
+    /// Every photo taken in one town with where exactly it was taken, for the
+    /// map's close-up. Replies with [`Response::PhotoLocations`].
+    PlaceLocations { id: u32 },
    /// List the account's photo albums, newest activity first, including the
    /// albums other people share with us. Metadata only — an album's cover
    /// thumbnail is fetched with [`Request::PhotoThumbs`] like any other photo.
@@ -94,6 +126,25 @@ pub enum Request {
        offset: usize,
        limit: usize,
    },
+    /// Create an album named `name`. Replies with [`Response::AlbumCreated`].
+    CreateAlbum { name: String },
+    /// Rename the album `uid`. Replies with [`Response::Ok`].
+    RenameAlbum { uid: String, name: String },
+    /// Delete the album `uid`. Its photos stay in the timeline; with
+    /// `delete_photos` set, photos that exist only in the album (saved from a
+    /// shared album) are deleted with it, which the server otherwise refuses.
+    /// Replies with [`Response::Ok`].
+    DeleteAlbum {
+        uid: String,
+        #[serde(default)]
+        delete_photos: bool,
+    },
+    /// Add timeline photos to the album `uid`. Replies with
+    /// [`Response::AlbumChanged`].
+    AddToAlbum { uid: String, photos: Vec<String> },
+    /// Take photos out of the album `uid`. They stay in the timeline: this is
+    /// not a trash. Replies with [`Response::AlbumChanged`].
+    RemoveFromAlbum { uid: String, photos: Vec<String> },
    /// Fetch thumbnails for the given photo uids, downloading the ones not
    /// already cached (one batched round-trip) and replying with their on-disk
    /// paths. Keep the batch small — it is served on demand, as tiles scroll in.
@@ -107,8 +158,14 @@ pub enum Request {
    ///
    /// A photo that belongs to a group takes the whole group with it: trashing
    /// the JPEG of a shot and leaving its RAW behind is not what anyone means by
-    /// deleting that photo.
-    TrashNodes { uids: Vec<String> },
+    /// deleting that photo. With `files_only` set, exactly the listed files
+    /// go and their groups stay: the duplicate finder removes one copy of a
+    /// shot, not the shot. Older front-ends omit it and trash whole groups.
+    TrashNodes {
+        uids: Vec<String>,
+        #[serde(default)]
+        files_only: bool,
+    },
    /// Fetch thumbnails for ordinary Drive image files shown outside the Photos
    /// timeline. The modification time is the cache validity tag, so replacing
    /// an image can never reuse its previous revision's thumbnail.
@@ -181,7 +238,7 @@ pub enum Request {
    /// time by more than a day: `IMG-20230219-WA0001.jpg` filed under 2026 is
    /// the signature of an import whose metadata sidecars did not match.
    ///
-    /// Favourites and album memberships are carried across; the original is
+    /// Favorites and album memberships are carried across; the original is
    /// **trashed**, not deleted, so a bad run is recoverable from Proton's
    /// trash. With `dry_run` nothing is uploaded or trashed and the report says
    /// what would have been done.
@@ -245,8 +302,15 @@ pub enum Request {
        uid: Option<String>,
    },
    /// Full-text search node names against the daemon's local metadata index.
-    /// `limit` caps the number of hits returned. Replies with [`Response::SearchResults`].
-    Search { query: String, limit: usize },
+    /// `limit` caps the number of hits returned. `scope`, a mountpoint-relative
+    /// folder, restricts hits to that subtree; older front-ends omit it and
+    /// search everything. Replies with [`Response::SearchResults`].
+    Search {
+        query: String,
+        limit: usize,
+        #[serde(default)]
+        scope: Option<String>,
+    },
    /// Search the daemon's index of *local* (non-Drive) files on this machine.
    /// Independent of [`Request::Search`] so a front-end can fire both at once and
    /// render whichever lands first. Replies with [`Response::LocalResults`].
@@ -299,6 +363,10 @@ pub enum Request {
    /// persist it to config so the next mount keeps it. Replies with
    /// [`Response::Ok`].
    SetCacheBudget { bytes: u64 },
+    /// Cap uploads and downloads at these bytes per second (`0` = no cap),
+    /// live for running transfers, and persist both to config so the next
+    /// mount keeps them. Replies with [`Response::Ok`].
+    SetBandwidthLimits { upload: u64, download: u64 },
    /// Report on the health of the metadata database and content cache: sizes,
    /// row counts, and — when `deep` — SQLite's own integrity check. Replies
    /// with [`Response::CacheReport`].
@@ -381,9 +449,33 @@ pub enum Request {
    /// Switch a synced folder between `mirror` and `ondemand` (Phase 3). Replies
    /// with [`Response::Ok`].
    SetSyncFolderMode { id: i64, mode: String },
+    /// Pause or resume one mirror folder's reconcile, independent of the
+    /// global pause. Persisted until resumed. Replies with [`Response::Ok`].
+    SetSyncFolderPaused { id: i64, paused: bool },
    /// Force a reconcile pass: one folder by id, or all when `id` is `None`.
    /// Replies with [`Response::Ok`].
    SyncNow { id: Option<i64> },
+    /// Pause or resume syncing: queued uploads and changes stop draining and
+    /// mirror folders stop reconciling, while reads through the mount keep
+    /// working. `until` is the Unix second a pause ends by itself; `None`
+    /// pauses until resumed. Ignored when resuming. Replies with
+    /// [`Response::Ok`].
+    SetSyncPaused { paused: bool, until: Option<i64> },
+    /// List the queue of uploads and changes not yet on the remote. Replies
+    /// with [`Response::PendingOps`].
+    ListPendingOps,
+    /// Retry a backed-off queued op now instead of waiting out its backoff;
+    /// every failed op when `id` is `None`. Replies with [`Response::Ok`].
+    RetryPendingOp { id: Option<i64> },
+    /// List the `(sync-conflict …)` copies under My Files and in synced
+    /// folders. Replies with
+    /// [`Response::Conflicts`].
+    ListConflicts,
+    /// Resolve one conflict copy (`path` mountpoint-relative, or absolute for a
+    /// copy in a synced folder).
+    /// Everything removed goes to the Proton trash. Replies with
+    /// [`Response::Ok`].
+    ResolveConflict { path: String, keep: ConflictKeep },
    /// List the folders under this machine's device that can be synced here,
    /// each with a proposed local path (features.md 5.2). Replies with
    /// [`Response::RestorableFolders`].
@@ -391,6 +483,18 @@ pub enum Request {
    /// Attach the given remote device folders to local paths and sync them down.
    /// Replies with [`Response::Ok`].
    RestoreSyncFolders { items: Vec<RestoreItem> },
+    /// [`Request::ListRestorableFolders`] for another registered device, by
+    /// uid, so its folders can be synced down to this machine. Replies with
+    /// [`Response::RestorableFolders`].
+    ListDeviceRestorableFolders { device: String },
+    /// [`Request::RestoreSyncFolders`] for folders under another device. A
+    /// separate variant rather than an optional field: an older daemon that
+    /// ignored the field would attach the folders under this machine's device
+    /// share instead. Replies with [`Response::Ok`].
+    RestoreDeviceFolders {
+        device: String,
+        items: Vec<RestoreItem>,
+    },

    // ---- sharing a node ---------------------------------------------------
    /// Invite `emails` (Proton and/or external addresses, auto-detected) to the
@@ -466,6 +570,13 @@ pub enum Request {
    RemovePublicLink { path: String, id: String },
    /// The by-uid twin of [`Request::RemovePublicLink`].
    RemovePublicLinkByUid { uid: String, id: String },
+    /// Stop sharing the node at `path`: remove its public link, every pending
+    /// invitation and every member. Each removal is attempted even if an
+    /// earlier one fails. Replies with [`Response::Ok`], or an error naming
+    /// what is still shared.
+    StopSharing { path: String },
+    /// The by-uid twin of [`Request::StopSharing`].
+    StopSharingByUid { uid: String },

    // ---- revisions --------------------------------------------------------
    /// List the version history of the file at mountpoint-relative `path`,
@@ -626,6 +737,61 @@ pub struct DeviceInfo {
    pub adopted: bool,
 }

+/// One `(sync-conflict …)` copy and the file it is a copy of (in
+/// [`Response::Conflicts`]).
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ConflictInfo {
+    /// Mountpoint-relative path of the copy, or its absolute local path when it
+    /// sits in a synced folder.
+    pub path: String,
+    /// Path of the file it is a copy of, in the same form as `path`.
+    pub original_path: String,
+    /// False when the original is gone and only the copy is left.
+    pub original_exists: bool,
+    pub size: u64,
+    /// Unix seconds.
+    pub modified: i64,
+    pub original_size: Option<u64>,
+    pub original_modified: Option<i64>,
+    /// Same size and content hash as the original: keeping either loses nothing.
+    pub identical: bool,
+}
+
+/// Which side of a conflict to keep (in [`Request::ResolveConflict`]).
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+pub enum ConflictKeep {
+    /// Keep the original; the copy goes to Trash.
+    Original,
+    /// Keep the copy under the original's name; the original goes to Trash.
+    Copy,
+    /// Keep both; the copy is renamed to `name`.
+    Both { name: String },
+}
+
+/// One queued upload or change (in [`Response::PendingOps`]).
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct PendingOpInfo {
+    /// Queue row id, for [`Request::RetryPendingOp`].
+    pub id: i64,
+    /// `revision`, `create`, `mkdir`, `rename` or `trash`.
+    pub kind: String,
+    /// Mountpoint-relative path of the file or folder, or its name when the
+    /// path is no longer known.
+    pub path: String,
+    /// Failed attempts so far.
+    pub attempts: i64,
+    /// The latest failure, when there has been one.
+    pub last_error: Option<String>,
+    /// Unix second the op was queued.
+    pub queued_at: i64,
+    /// Unix second of the next attempt; `None` while parked.
+    pub next_attempt_at: Option<i64>,
+    /// Held back until a transient file gets its final name.
+    pub parked: bool,
+    /// Failed often enough to count as stuck.
+    pub failing: bool,
+}
+
 /// One synced local folder on this machine's device (in [`Response::SyncFolders`]).
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct SyncFolderInfo {
@@ -651,6 +817,9 @@ pub struct SyncFolderInfo {
    /// running. Live daemon state, not a stored column.
    #[serde(default)]
    pub progress: Option<SyncProgress>,
+    /// The folder is paused on its own (see [`Request::SetSyncFolderPaused`]).
+    #[serde(default)]
+    pub paused: bool,
 }

 /// A folder under this machine's device offered for restore (in
@@ -976,6 +1145,10 @@ pub struct SearchHit {
    pub size: u64,
    pub modified: i64,
    pub pinned: bool,
+    /// Whether a valid copy of the content is in the local cache. Legacy
+    /// daemons omit it; clients then treat the file as online-only.
+    #[serde(default)]
+    pub cached: bool,
    /// Node uid in `volume~link` form.
    pub uid: String,
    /// Absolute path through the most specific active on-demand mount, when the
@@ -1283,6 +1456,45 @@ pub struct AlbumInfo {
    pub shared: bool,
 }

+/// One town in a [`Response::Places`] listing.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct PlaceInfo {
+    /// The town's GeoNames id — what [`Request::PlacePhotos`] takes.
+    pub id: u32,
+    /// The town's name, as the town itself spells it.
+    pub name: String,
+    /// ISO 3166-1 alpha-2 code of the town's country.
+    pub country: String,
+    /// Where the town is, in decimal degrees, for the map. Zero from a daemon
+    /// older than the map.
+    #[serde(default)]
+    pub latitude: f64,
+    #[serde(default)]
+    pub longitude: f64,
+    /// How many photos were taken there, counting a RAW+JPEG shot once.
+    pub photo_count: usize,
+    /// The newest photo taken there, shown as the place's cover.
+    pub cover: PhotoItem,
+}
+
+/// One photo and where it was taken, in decimal degrees. Part of
+/// [`Response::PhotoLocations`].
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct PhotoLocation {
+    pub photo: PhotoItem,
+    pub latitude: f64,
+    pub longitude: f64,
+}
+
+/// How many of the timeline's photos a running refresh has read the metadata
+/// (and so the location) of, out of how many. Part of [`Response::Places`],
+/// and of [`Response::PhotoSimilar`] for how many shots have been hashed.
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+pub struct MappingProgress {
+    pub done: usize,
+    pub total: usize,
+}
+
 /// One photo in a [`Request::PhotosTimeline`] page.
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct PhotoItem {
@@ -1308,8 +1520,8 @@ pub struct PhotoItem {
    /// the split omit it; a front-end then treats everything as a still photo.
    #[serde(default = "default_photo_kind")]
    pub kind: PhotoKind,
-    /// Whether the photo is favourited. Older daemons omit it, which a front-end
-    /// reads as "not favourited" — the same thing it would show for a photo whose
+    /// Whether the photo is favorited. Older daemons omit it, which a front-end
+    /// reads as "not favorited" — the same thing it would show for a photo whose
    /// tags it has not learned yet.
    #[serde(default)]
    pub favorite: bool,
@@ -1558,6 +1770,13 @@ pub enum Response {
        /// Age of the oldest staged write, in seconds.
        #[serde(default)]
        staged_oldest_secs: u64,
+        /// True while the user has sync paused (see [`Request::SetSyncPaused`]).
+        #[serde(default)]
+        paused: bool,
+        /// The Unix second a timed pause ends; `None` when paused until
+        /// resumed, or not paused.
+        #[serde(default)]
+        paused_until: Option<i64>,
    },
    /// A human-readable success message.
    Ok { message: String },
@@ -1634,6 +1853,31 @@ pub enum Response {
    /// The months the timeline spans (reply to [`Request::PhotoMonths`]),
    /// newest first.
    PhotoMonths { months: Vec<PhotoMonth> },
+    /// The duplicate sets (reply to [`Request::PhotoDuplicates`]), newest
+    /// first. Each set lists the copy worth keeping first.
+    PhotoDuplicates { sets: Vec<Vec<PhotoItem>> },
+    /// The sets of alike shots (reply to [`Request::PhotoSimilar`]), newest
+    /// first, each in capture order; and how far hashing has got, `None`
+    /// once no pass is running. `uncompared` counts the shots left out
+    /// because no thumbnail could be read for them.
+    PhotoSimilar {
+        sets: Vec<Vec<PhotoItem>>,
+        #[serde(default)]
+        hashing: Option<MappingProgress>,
+        #[serde(default)]
+        uncompared: usize,
+    },
+    /// The towns the photos were taken in (reply to [`Request::PhotoPlaces`]),
+    /// and how far a running timeline refresh has got reading photo locations
+    /// — `None` when none is reading any.
+    Places {
+        items: Vec<PlaceInfo>,
+        #[serde(default)]
+        mapping: Option<MappingProgress>,
+    },
+    /// The photos of one town, each with its location (reply to
+    /// [`Request::PlaceLocations`]).
+    PhotoLocations { items: Vec<PhotoLocation> },
    /// Thumbnails for a [`Request::PhotoThumbs`] batch.
    Thumbs { items: Vec<PhotoThumb> },
    /// Per-node outcome of a [`Request::TrashNodes`] batch. Reported per uid
@@ -1644,6 +1888,15 @@ pub enum Response {
        trashed: Vec<String>,
        failed: Vec<TrashFailure>,
    },
+    /// The album a [`Request::CreateAlbum`] made.
+    AlbumCreated { uid: String },
+    /// Outcome of a [`Request::AddToAlbum`] or [`Request::RemoveFromAlbum`],
+    /// per photo like [`Response::Trashed`]: `changed` photos were added or
+    /// removed, `failed` ones were not.
+    AlbumChanged {
+        changed: Vec<String>,
+        failed: Vec<TrashFailure>,
+    },
    /// A [`Request::FileThumbs`] generation is no longer current. This is
    /// retryable after reserving a fresh generation and must never be interpreted
    /// as a permanent "no thumbnail" verdict.
@@ -1687,6 +1940,10 @@ pub enum Response {
    Locations { items: Vec<MountSpec> },
    /// This device's synced folders (reply to [`Request::ListSyncFolders`]).
    SyncFolders { items: Vec<SyncFolderInfo> },
+    /// The upload/change queue (reply to [`Request::ListPendingOps`]).
+    PendingOps { items: Vec<PendingOpInfo> },
+    /// Conflict copies (reply to [`Request::ListConflicts`]).
+    Conflicts { items: Vec<ConflictInfo> },
    /// Folders offered for restore (reply to [`Request::ListRestorableFolders`]).
    RestorableFolders { items: Vec<RestorableFolder> },
    /// A node's share: members + pending invitations, and its public link if any
@@ -2017,7 +2274,17 @@ mod tests {
    fn trash_requests_and_outcomes_roundtrip() {
        let request = Request::TrashNodes {
            uids: vec!["volume~first".into(), "volume~second".into()],
+            files_only: false,
        };
+        // An older front-end's request trashes whole groups.
+        let old: Request = serde_json::from_str(r#"{"TrashNodes":{"uids":["v~a"]}}"#).unwrap();
+        assert!(matches!(
+            old,
+            Request::TrashNodes {
+                files_only: false,
+                ..
+            }
+        ));
        let line = serde_json::to_string(&request).unwrap();
        assert!(!line.contains('\n'), "wire form must be a single line");
        let decoded: Request = serde_json::from_str(&line).unwrap();
@@ -2133,6 +2400,7 @@ mod tests {
                size: 12,
                modified: 123,
                pinned: true,
+                cached: false,
                uid: "vol~link".into(),
                mounted_path: Some("/home/me/Videos/report.pdf".into()),
                score: 985,
@@ -2243,7 +2511,7 @@ mod tests {
            serde_json::from_str(r#"{"Search":{"query":"old","limit":20}}"#).unwrap();
        assert!(matches!(
            drive,
-            Request::Search { query, limit } if query == "old" && limit == 20
+            Request::Search { query, limit, scope: None } if query == "old" && limit == 20
        ));

        let local: Request =
@@ -2254,6 +2522,15 @@ mod tests {
        ));
    }

+    #[test]
+    fn delete_album_keeps_photos_unless_asked() {
+        let request: Request = serde_json::from_str(r#"{"DeleteAlbum":{"uid":"v~a"}}"#).unwrap();
+        assert!(matches!(
+            request,
+            Request::DeleteAlbum { uid, delete_photos: false } if uid == "v~a"
+        ));
+    }
+
    /// The trash requests carry uids rather than paths; they must survive the same
    /// line-delimited round-trip, since a mangled uid would restore or destroy the
    /// wrong node.
@@ -2294,6 +2571,55 @@ mod tests {
        }
    }

+    /// A place listing and a place page cross the wire intact: a mangled id
+    /// would open the wrong town.
+    #[test]
+    fn places_requests_and_reply_roundtrip() {
+        for req in [
+            Request::PhotoPlaces,
+            Request::PlacePhotos {
+                id: 2950159,
+                offset: 60,
+                limit: 30,
+            },
+            Request::PlaceLocations { id: 2950159 },
+        ] {
+            let line = serde_json::to_string(&req).unwrap();
+            let back: Request = serde_json::from_str(&line).unwrap();
+            assert_eq!(line, serde_json::to_string(&back).unwrap());
+        }
+
+        let line = r#"{"Places":{"items":[{"id":2950159,"name":"Berlin","country":"DE","photo_count":2,
+            "cover":{"uid":"vol~b2","capture_time":1700000000,"thumb_path":null,"name":"b2.jpg","ratio":null,"no_thumb":false}}]}}"#;
+        let Response::Places { items, mapping } = serde_json::from_str(line).unwrap() else {
+            panic!("not a place listing");
+        };
+        assert_eq!(items.len(), 1);
+        assert_eq!((items[0].id, items[0].country.as_str()), (2950159, "DE"));
+        assert_eq!(items[0].cover.uid, "vol~b2");
+        // A daemon from before the progress field still parses: no mapping.
+        assert_eq!(mapping, None);
+
+        let reply = Response::Places {
+            items: Vec::new(),
+            mapping: Some(MappingProgress {
+                done: 120,
+                total: 480,
+            }),
+        };
+        let line = serde_json::to_string(&reply).unwrap();
+        let Response::Places { mapping, .. } = serde_json::from_str(&line).unwrap() else {
+            panic!("not a place listing");
+        };
+        assert_eq!(
+            mapping,
+            Some(MappingProgress {
+                done: 120,
+                total: 480
+            })
+        );
+    }
+
    /// The sharing and devices requests must survive the same line-delimited JSON
    /// round-trip: a mangled id or role would touch the wrong share or member.
    #[test]
@@ -2320,6 +2646,14 @@ mod tests {
                id: 3,
                mode: "ondemand".into(),
            },
+            Request::SetSyncFolderPaused {
+                id: 3,
+                paused: true,
+            },
+            Request::SetBandwidthLimits {
+                upload: 1_000_000,
+                download: 0,
+            },
            Request::SyncNow { id: Some(3) },
            Request::AdoptDevice {
                uid: Some("dev-1".into()),
@@ -2333,6 +2667,17 @@ mod tests {
                    mode: "mirror".into(),
                }],
            },
+            Request::ListDeviceRestorableFolders {
+                device: "dev-2".into(),
+            },
+            Request::RestoreDeviceFolders {
+                device: "dev-2".into(),
+                items: vec![RestoreItem {
+                    remote_uid: "vol~link".into(),
+                    local_path: "/home/me/Work".into(),
+                    mode: "ondemand".into(),
+                }],
+            },
            Request::ShareNode {
                path: "a/b".into(),
                emails: vec!["x@proton.me".into(), "y@example.com".into()],
@@ -2441,6 +2786,7 @@ mod tests {
                    pending_mode: None,
                    mounted: true,
                    progress: None,
+                    paused: false,
                },
                MountSpec {
                    id: 2,
@@ -2455,6 +2801,7 @@ mod tests {
                    pending_mode: Some(MountMode::OnDemand),
                    mounted: false,
                    progress: None,
+                    paused: false,
                },
                MountSpec {
                    id: 3,
@@ -2476,6 +2823,7 @@ mod tests {
                        total: 5,
                        current: "report.pdf".into(),
                    }),
+                    paused: true,
                },
            ],
        };
@@ -2593,7 +2941,7 @@ mod tests {
        }
    }

-    /// A front-end that predates the favourites filter sends no `favorites`
+    /// A front-end that predates the favorites filter sends no `favorites`
    /// field, and must keep getting the whole timeline rather than an empty page.
    #[test]
    fn timeline_requests_without_the_favorites_filter_still_decode() {
@@ -2603,6 +2951,7 @@ mod tests {
            decoded,
            Request::PhotosTimeline {
                favorites: false,
+                not_in_album: false,
                kind: None,
                range: None,
                ..
@@ -2731,6 +3080,12 @@ mod tests {
                },
                "RemovePublicLinkByUid",
            ),
+            (
+                Request::StopSharingByUid {
+                    uid: "vol~link".into(),
+                },
+                "StopSharingByUid",
+            ),
        ];

        for (request, variant) in cases {
@@ -2749,7 +3104,8 @@ mod tests {
                | Request::UpdateShareRoleByUid { uid, .. }
                | Request::RemoveShareEntryByUid { uid, .. }
                | Request::CreatePublicLinkByUid { uid, .. }
-                | Request::RemovePublicLinkByUid { uid, .. } => uid,
+                | Request::RemovePublicLinkByUid { uid, .. }
+                | Request::StopSharingByUid { uid } => uid,
                other => panic!("decoded into the wrong dispatch variant: {other:?}"),
            };
            assert_eq!(decoded_uid, "vol~link");
@@ -29,6 +29,17 @@ impl Db {
        Ok(())
    }

+    /// Whether the kept log already holds an entry of `kind` for `target`. Lets
+    /// the daemon report something once across restarts rather than once per
+    /// run, without keeping a second table in step with the log.
+    pub fn activity_has(&self, kind: ActivityKind, target: &str) -> Result<bool> {
+        let kind = serde_json::to_string(&kind)?;
+        let conn = self.read();
+        let mut stmt =
+            conn.prepare("SELECT 1 FROM activity WHERE kind = ?1 AND target = ?2 LIMIT 1")?;
+        Ok(stmt.exists(params![kind, target])?)
+    }
+
    /// The most recent activity, newest first, capped at `limit` entries. Rows
    /// whose stored `kind` no longer parses (written by an older build) are
    /// skipped rather than failing the whole read.
@@ -178,7 +178,7 @@ impl Db {
                    ratio: r.get(3)?,
                    thumb_state: r.get(4)?,
                    kind: crate::control::PhotoKind::from_i64(r.get(5)?),
-                    // Album rows have no favourite state of their own: an album
+                    // Album rows have no favorite state of their own: an album
                    // photo on someone else's volume is not in our timeline, and
                    // favouriting one is not supported yet anyway.
                    favorite: false,
@@ -239,7 +239,7 @@ impl Db {
                    ratio: r.get(3)?,
                    thumb_state: r.get(4)?,
                    kind: crate::control::PhotoKind::from_i64(r.get(5)?),
-                    // Album rows have no favourite state of their own: an album
+                    // Album rows have no favorite state of their own: an album
                    // photo on someone else's volume is not in our timeline, and
                    // favouriting one is not supported yet anyway.
                    favorite: false,
@@ -9,7 +9,7 @@ use super::Db;
 use crate::Result;

 /// Current schema version. Bump on every forward migration added below.
-pub(super) const SCHEMA_VERSION: i64 = 31;
+pub(super) const SCHEMA_VERSION: i64 = 34;

 impl Db {
    pub(super) fn migrate(&self) -> Result<()> {
@@ -270,6 +270,52 @@ impl Db {
                tx.execute_batch(MIGRATION_V31)?;
            }
        }
+        if current < 32 {
+            // Data only, so safe to repeat; each table is guarded for a very
+            // old fixture that never had it.
+            for table in ["photos", "album_photos"] {
+                let has_table: bool = tx.query_row(
+                    "SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = ?1",
+                    [table],
+                    |row| row.get::<_, i64>(0),
+                )? > 0;
+                if has_table {
+                    tx.execute(&MIGRATION_V32.replace("{table}", table), [])?;
+                }
+            }
+        }
+        if current < 33 {
+            // Same guards as V26-V31.
+            let has_column: bool = tx.query_row(
+                "SELECT COUNT(*) FROM pragma_table_info('photos') WHERE name = 'place_id'",
+                [],
+                |row| row.get::<_, i64>(0),
+            )? > 0;
+            let has_photos: bool = tx.query_row(
+                "SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = 'photos'",
+                [],
+                |row| row.get::<_, i64>(0),
+            )? > 0;
+            if has_photos && !has_column {
+                tx.execute_batch(MIGRATION_V33)?;
+            }
+        }
+        if current < 34 {
+            // Same guards as V26-V33.
+            let has_column: bool = tx.query_row(
+                "SELECT COUNT(*) FROM pragma_table_info('photos') WHERE name = 'similar_hash'",
+                [],
+                |row| row.get::<_, i64>(0),
+            )? > 0;
+            let has_photos: bool = tx.query_row(
+                "SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = 'photos'",
+                [],
+                |row| row.get::<_, i64>(0),
+            )? > 0;
+            if has_photos && !has_column {
+                tx.execute_batch(MIGRATION_V34)?;
+            }
+        }
        tx.execute(
            "INSERT INTO sync_state (key, value) VALUES ('schema_version', ?1)
             ON CONFLICT(key) DO UPDATE SET value = excluded.value",
@@ -684,7 +730,7 @@ CREATE INDEX idx_album_photos_seq ON album_photos(album_uid, seq);
 CREATE INDEX idx_album_photos_uid ON album_photos(uid);
 ";

-/// V20: whether a photo is a favourite.
+/// V20: whether a photo is a favorite.
 ///
 /// A column rather than a tag table: `Favorite` is the only Proton photo tag a
 /// user sets by hand (the rest — Video, Screenshot, Selfie, Raw… — are the
@@ -938,7 +984,7 @@ CREATE INDEX IF NOT EXISTS idx_photos_group ON photos(group_key);
 /// Schema v31: which photos a refresh still has to read from the server.
 ///
 /// A refresh used to resolve every photo's node to learn its name, media type,
-/// favourite tag, content hash and photo relation — minutes of round-trips for a
+/// favorite tag, content hash and photo relation — minutes of round-trips for a
 /// library of any size, repeated every time the timeline went stale. `resolved_at`
 /// records that the work was already done, so a refresh only reads the photos it
 /// has never read and the ones a remote event marked stale (`resolved_at = NULL`).
@@ -952,3 +998,38 @@ ALTER TABLE photos ADD COLUMN resolved_at INTEGER;
 CREATE INDEX IF NOT EXISTS idx_photos_unresolved ON photos(resolved_at);
 UPDATE photos SET resolved_at = strftime('%s','now') WHERE name IS NOT NULL;
 ";
+
+/// V32: give videos written off as un-thumbnailable another chance.
+///
+/// Before local video thumbnails, the fallback fed a video's bytes to the image
+/// decoder, which could only fail, and that failure was recorded as the
+/// permanent "no thumbnail" verdict. Run once per table in `{table}`.
+const MIGRATION_V32: &str = "UPDATE {table} SET thumb_state = 0 WHERE kind = 1 AND thumb_state = 2";
+
+/// Schema v33: where each photo was taken.
+///
+/// `latitude` and `longitude` come from the location other clients write into
+/// a photo's extended attributes; `place_id` is the GeoNames id of the nearest
+/// town (see `crate::places`), so the Places view is a plain `GROUP BY`.
+///
+/// Every photo is marked unresolved, so the next refresh reads the location of
+/// the whole library once. That is the backfill: the metadata is on the node
+/// the refresh reads anyway, and nothing has to be downloaded.
+const MIGRATION_V33: &str = "
+ALTER TABLE photos ADD COLUMN latitude REAL;
+ALTER TABLE photos ADD COLUMN longitude REAL;
+ALTER TABLE photos ADD COLUMN place_id INTEGER;
+CREATE INDEX IF NOT EXISTS idx_photos_place ON photos(place_id);
+UPDATE photos SET resolved_at = NULL;
+";
+
+/// Schema v34: what each photo looks like, for finding similar ones.
+///
+/// `similar_hash` is a 64-bit difference hash of the photo's thumbnail (see
+/// `crate::similar`): resized and re-encoded copies of one picture land a few
+/// bits apart, where the server's `content_hash` only matches byte-identical
+/// files. `NULL` until the daemon has hashed the thumbnail, which it does as
+/// thumbnails arrive and when the similar-photo finder asks for the rest.
+const MIGRATION_V34: &str = "
+ALTER TABLE photos ADD COLUMN similar_hash INTEGER;
+";
@@ -56,10 +56,10 @@ pub use local::LocalFileHit;
 pub use maintenance::{DbStats, VacuumOutcome};
 pub use nodes::{PublishedSharedRoot, SearchHit, StoredNode};
 pub use ops::{
-    AttachedBlob, LOCAL_VOLUME, OP_CREATE, OP_MKDIR, OP_RENAME, OP_REVISION, OP_TRASH, PARK_UNTIL,
-    PendingCounts, PendingOp, RenameMeta, op_supersedes,
+    AttachedBlob, FAILING_ATTEMPTS, LOCAL_VOLUME, OP_CREATE, OP_MKDIR, OP_RENAME, OP_REVISION,
+    OP_TRASH, PARK_EXPIRY_MS, PARK_UNTIL, PendingCounts, PendingOp, RenameMeta, op_supersedes,
 };
-pub use photos::{StoredPhoto, THUMB_HAVE, THUMB_NONE, THUMB_UNKNOWN, TimelineRow};
+pub use photos::{StoredPhoto, StoredPlace, THUMB_HAVE, THUMB_NONE, THUMB_UNKNOWN, TimelineRow};
 pub use pins::PinRow;
 pub use sync::{StoredSyncEntry, StoredSyncFolder};
 pub use trash::StoredTrash;
@@ -171,6 +171,7 @@ impl Db {
                pending_mode: pending_mode.as_deref().map(MountMode::from),
                mounted: false,
                progress: None,
+                paused: false,
            });
        }
        Ok(mounts)
@@ -355,6 +355,22 @@ impl Db {
    /// than [`TRIGRAM_MIN`] fall back to a `LIKE` scan since trigram indexes
    /// nothing below 3 chars.
    pub fn search(&self, query: &str, limit: usize) -> Result<Vec<SearchHit>> {
+        self.search_in(query, limit, None)
+    }
+
+    /// [`search`](Self::search) restricted to the subtree under the
+    /// mountpoint-relative folder `scope`. `None` or an empty scope searches
+    /// everything.
+    pub fn search_in(
+        &self,
+        query: &str,
+        limit: usize,
+        scope: Option<&str>,
+    ) -> Result<Vec<SearchHit>> {
+        let scope = scope.map(|s| s.trim_matches('/')).filter(|s| !s.is_empty());
+        // Rows whose path is not persisted yet pass the SQL filter and are
+        // checked once their path is walked below.
+        let scope_pat = scope.map(|s| format!("{}/%", like_escape(s)));
        let query = query.trim();
        if query.is_empty() {
            return Ok(Vec::new());
@@ -365,9 +381,10 @@ impl Db {
            let mut stmt = conn.prepare(
                "SELECT node_json, uid, path FROM nodes
                 WHERE name LIKE ?1 ESCAPE '\\' AND trashed = 0 AND node_json IS NOT NULL
+                   AND (?3 IS NULL OR path IS NULL OR path LIKE ?3 ESCAPE '\\')
                 ORDER BY name LIMIT ?2",
            )?;
-            collect_hits(stmt.query_map(params![pat, limit as i64], hit_row)?)?
+            collect_hits(stmt.query_map(params![pat, limit as i64, scope_pat], hit_row)?)?
        } else {
            // Escape double quotes and quote each term, then combine with AND so
            // all terms must match but can appear in any order or position.
@@ -380,9 +397,10 @@ impl Db {
                "SELECT n.node_json, n.uid, n.path
                 FROM nodes_fts f JOIN nodes n ON n.rowid = f.rowid
                 WHERE f.name MATCH ?1 AND n.trashed = 0 AND n.node_json IS NOT NULL
+                   AND (?3 IS NULL OR n.path IS NULL OR n.path LIKE ?3 ESCAPE '\\')
                 ORDER BY f.rank LIMIT ?2",
            )?;
-            collect_hits(stmt.query_map(params![phrase, limit as i64], hit_row)?)?
+            collect_hits(stmt.query_map(params![phrase, limit as i64, scope_pat], hit_row)?)?
        };

        let mut hits = Vec::with_capacity(rows.len());
@@ -392,6 +410,13 @@ impl Db {
                Some(path) => path,
                None => walk_path_of(&conn, &uid)?,
            };
+            if let Some(scope) = scope
+                && !path
+                    .strip_prefix(scope)
+                    .is_some_and(|rest| rest.starts_with('/'))
+            {
+                continue;
+            }
            hits.push(SearchHit { node, path });
        }
        Ok(hits)
@@ -84,6 +84,25 @@ pub const LOCAL_VOLUME: &str = "local";
 /// stall+resume, fork a `(sync-conflict)` copy (docs/BUGS.md B70).
 pub const PARK_UNTIL: i64 = 8_000_000_000_000;

+/// How long a create may stay parked before the park is treated as permanent
+/// and the bytes are let through anyway (ms).
+///
+/// The park has exactly one exit: a rename from the transient name to the
+/// finished one. Every writer that reaches that rename does so in seconds — an
+/// atomic-write scratch file immediately, a download when it completes. A park
+/// still standing an hour later belongs to a writer that will never perform
+/// that rename: an editor that deletes its swap file instead, a download the
+/// user abandoned, or a file that simply *is* named `report.tmp` and is never
+/// going to be called anything else.
+///
+/// Before this existed such a row sat at [`PARK_UNTIL`] for the life of the
+/// database, holding the only copy of the file's bytes in `staging/` and
+/// counting against the queue while promising progress that could not come. The
+/// sweep un-parks it instead of dropping it: bytes the user can see in the mount
+/// are bytes the user expects on Drive, and invariant 1 of the drain (a staged
+/// blob is dropped only once its op has landed) admits no other answer.
+pub const PARK_EXPIRY_MS: i64 = 60 * 60 * 1000;
+
 /// A mutation that has been accepted locally but not yet performed against the
 /// API — the durable half of the write-back queue (offline.md Phase 3).
 ///
@@ -661,6 +680,40 @@ impl Db {
        Ok(rows)
    }

+    /// Every parked create/mkdir, oldest first, for the park sweep.
+    ///
+    /// Parked rows are invisible to [`next_due_op`](Self::next_due_op) by
+    /// construction, so nothing else in the drain ever looks at them. This is
+    /// the one query that does.
+    pub fn parked_create_ops(&self) -> Result<Vec<PendingOp>> {
+        let conn = self.read();
+        let mut stmt = conn.prepare(
+            "SELECT id, kind, uid, parent_uid, name, blob_path, meta_json, created_at,
+                    attempts, last_error, next_attempt_at
+             FROM pending_op
+             WHERE next_attempt_at >= ?1 AND kind IN (?2, ?3)
+             ORDER BY created_at",
+        )?;
+        let rows = stmt
+            .query_map(params![PARK_UNTIL, OP_CREATE, OP_MKDIR], |r| {
+                Ok(PendingOp {
+                    id: r.get(0)?,
+                    kind: r.get(1)?,
+                    uid: r.get(2)?,
+                    parent_uid: r.get(3)?,
+                    name: r.get(4)?,
+                    blob_path: r.get(5)?,
+                    meta_json: r.get(6)?,
+                    created_at: r.get(7)?,
+                    attempts: r.get(8)?,
+                    last_error: r.get(9)?,
+                    next_attempt_at: r.get(10)?,
+                })
+            })?
+            .collect::<std::result::Result<Vec<_>, _>>()?;
+        Ok(rows)
+    }
+
    /// How many queued ops there are of each kind, for `Response::Status`.
    ///
    /// Split because "3 uploads queued" has to mean three files whose bytes are
@@ -719,6 +772,31 @@ impl Db {
        Ok(())
    }

+    /// Make one backed-off op due now, for the user's "Retry now". Parked ops are
+    /// left alone: they wait for a rename, not for time, and un-parking one would
+    /// upload a file its writer has not finished. Returns whether a row changed.
+    pub fn retry_op_now(&self, id: i64, now: i64) -> Result<bool> {
+        let conn = self.conn.lock();
+        let changed = conn.execute(
+            "UPDATE pending_op SET next_attempt_at = ?2
+             WHERE id = ?1 AND next_attempt_at > ?2 AND next_attempt_at < ?3",
+            params![id, now, PARK_UNTIL],
+        )?;
+        Ok(changed > 0)
+    }
+
+    /// [`retry_op_now`](Self::retry_op_now) for every op that has failed at
+    /// least once. Returns how many rows changed.
+    pub fn retry_failed_ops_now(&self, now: i64) -> Result<usize> {
+        let conn = self.conn.lock();
+        let changed = conn.execute(
+            "UPDATE pending_op SET next_attempt_at = ?1
+             WHERE attempts > 0 AND next_attempt_at > ?1 AND next_attempt_at < ?2",
+            params![now, PARK_UNTIL],
+        )?;
+        Ok(changed)
+    }
+
    /// Record a failed attempt and when to next try. Leaves the row in place —
    /// the staged bytes are still the only copy of the user's write.
    ///
@@ -3,7 +3,7 @@

 use rusqlite::params;

-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};

 use super::Db;
 use crate::Result;
@@ -42,6 +42,15 @@ pub struct StoredPhoto {
    pub has_raw: bool,
 }

+/// A town photos were taken in: its GeoNames id (see [`crate::places`]), how
+/// many photos it holds, and the newest of them.
+#[derive(Clone, Debug, PartialEq)]
+pub struct StoredPlace {
+    pub id: u32,
+    pub count: usize,
+    pub cover: StoredPhoto,
+}
+
 /// One row of a timeline replacement. Everything but the uid and the capture
 /// time is "what this refresh learned": a `None` keeps whatever is already
 /// stored rather than clearing it, because the timeline DTO carries only the uid
@@ -58,6 +67,8 @@ pub struct TimelineRow {
    /// The main photo this one is *related* to (a live-photo video, a burst
    /// sibling), when the server says it belongs to one.
    pub main_uid: Option<String>,
+    /// Where the photo was taken, as `(latitude, longitude)` in decimal degrees.
+    pub location: Option<(f64, f64)>,
    /// When this refresh resolved the photo's node, if it did at all. `Some`
    /// makes every other field authoritative — including a `None` that means
    /// "the server no longer reports one" — while `None` means the refresh
@@ -86,6 +97,9 @@ struct Learned {
    favorite: bool,
    content_hash: Option<String>,
    main_uid: Option<String>,
+    location: Option<(f64, f64)>,
+    /// What its thumbnail looks like (see [`crate::similar`]).
+    similar_hash: Option<i64>,
    /// When this photo's node was last resolved, kept so a refresh that skips it
    /// does not make it look unresolved again.
    resolved_at: Option<i64>,
@@ -281,7 +295,7 @@ impl Db {
        let learned: HashMap<String, Learned> = {
            let mut stmt = tx.prepare(
                "SELECT uid, name, ratio, thumb_state, media_type, favorite, content_hash, \
-                 main_uid, resolved_at FROM photos",
+                 main_uid, resolved_at, latitude, longitude, similar_hash FROM photos",
            )?;
            let rows = stmt.query_map([], |r| {
                Ok((
@@ -295,6 +309,10 @@ impl Db {
                        content_hash: r.get(6)?,
                        main_uid: r.get(7)?,
                        resolved_at: r.get(8)?,
+                        location: r
+                            .get::<_, Option<f64>>(9)?
+                            .zip(r.get::<_, Option<f64>>(10)?),
+                        similar_hash: r.get(11)?,
                    },
                ))
            })?;
@@ -317,14 +335,20 @@ impl Db {
                    carried.name = row.name.clone();
                    carried.media_type = row.media_type.clone();
                    carried.favorite = row.favorite.unwrap_or(false);
+                    // New bytes may show another picture: hash it again.
+                    if row.content_hash != carried.content_hash {
+                        carried.similar_hash = None;
+                    }
                    carried.content_hash = row.content_hash.clone();
                    carried.main_uid = row.main_uid.clone();
+                    carried.location = row.location;
                } else {
                    carried.name = row.name.clone().or(carried.name);
                    carried.media_type = row.media_type.clone().or(carried.media_type);
                    carried.favorite = row.favorite.unwrap_or(carried.favorite);
                    carried.content_hash = row.content_hash.clone().or(carried.content_hash);
                    carried.main_uid = row.main_uid.clone().or(carried.main_uid);
+                    carried.location = row.location.or(carried.location);
                }
                carried.resolved_at = row.resolved_at.or(carried.resolved_at);
                // The tab this photo lands in is derived here, once, so a page or
@@ -355,8 +379,10 @@ impl Db {
            let mut stmt = tx.prepare(
                "INSERT INTO photos
                   (uid, capture_time, name, ratio, thumb_state, seq, media_type, kind, favorite,
-                    content_hash, main_uid, group_key, resolved_at)
-                 VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13)",
+                    content_hash, main_uid, group_key, resolved_at, latitude, longitude,
+                    place_id, similar_hash)
+                 VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15,
+                         ?16, ?17)",
            )?;
            for (seq, ((row, carried, kind), group_key)) in
                resolved.iter().zip(group_keys.iter()).enumerate()
@@ -375,6 +401,13 @@ impl Db {
                    carried.main_uid,
                    group_key,
                    carried.resolved_at,
+                    carried.location.map(|(lat, _)| lat),
+                    carried.location.map(|(_, lon)| lon),
+                    carried
+                        .location
+                        .and_then(|(lat, lon)| crate::places::nearest(lat, lon))
+                        .map(|city| city.id),
+                    carried.similar_hash,
                ])?;
            }
        }
@@ -447,6 +480,14 @@ impl Db {
                albums.execute([uid])?;
            }
        }
+        // A group whose representative went is left pointing at nothing, which
+        // drops its other files off every page. Make them stand alone until the
+        // next refresh groups them again.
+        tx.execute(
+            "UPDATE photos SET group_key = NULL WHERE group_key IS NOT NULL \
+             AND group_key NOT IN (SELECT uid FROM photos)",
+            [],
+        )?;
        tx.commit()?;
        Ok(removed)
    }
@@ -455,7 +496,8 @@ impl Db {
    /// restricts the page to one tab (Photos / Videos / Raw); `range`, when set,
    /// restricts it to a `[from, to)` capture-time window (epoch seconds) — the
    /// date scrubber's jump. `offset` is relative to whatever the filters leave.
-    /// `favorites` restricts the page to favourited photos.
+    /// `favorites` restricts the page to favorited photos, and `not_in_album`
+    /// to the shots no album holds any file of.
    ///
    /// The page holds one row per *group*: the RAW and the JPEG of one shot are
    /// one tile. The Raw tab is the exception and lists every raw file, because
@@ -467,6 +509,7 @@ impl Db {
        kind: Option<crate::control::PhotoKind>,
        range: Option<(i64, i64)>,
        favorites: bool,
+        not_in_album: bool,
    ) -> Result<Vec<StoredPhoto>> {
        let conn = self.read();
        // Built up so any combination of the optional filters is one indexed
@@ -490,6 +533,15 @@ impl Db {
        if favorites {
            conds.push("p.favorite = 1".to_string());
        }
+        // By group, not by file: a shot filed as its JPEG is filed, even though
+        // its RAW was never added anywhere.
+        if not_in_album {
+            conds.push(
+                "NOT EXISTS (SELECT 1 FROM album_photos a JOIN photos m ON m.uid = a.uid \
+                 WHERE COALESCE(m.group_key, m.uid) = COALESCE(p.group_key, p.uid))"
+                    .to_string(),
+            );
+        }
        if !conds.is_empty() {
            sql.push_str(" WHERE ");
            sql.push_str(&conds.join(" AND "));
@@ -577,6 +629,256 @@ impl Db {
        Ok(rows)
    }

+    /// Photos taken on `today`'s calendar day in earlier years, newest first —
+    /// the "On this day" strip. `today` is epoch seconds: its local month and day
+    /// pick the date, and its own year is left out, because today's photos are
+    /// what the timeline already opens on. One row per group, like the timeline.
+    pub fn photos_on_this_day(&self, today: i64, limit: usize) -> Result<Vec<StoredPhoto>> {
+        let conn = self.read();
+        let sql = format!(
+            "{PHOTO_SELECT} WHERE p.uid = COALESCE(p.group_key, p.uid) \
+             AND strftime('%m-%d', p.capture_time, 'unixepoch', 'localtime') \
+                 = strftime('%m-%d', ?1, 'unixepoch', 'localtime') \
+             AND strftime('%Y', p.capture_time, 'unixepoch', 'localtime') \
+                 < strftime('%Y', ?1, 'unixepoch', 'localtime') \
+             ORDER BY p.seq LIMIT ?2"
+        );
+        let mut stmt = conn.prepare(&sql)?;
+        let rows = stmt
+            .query_map(params![today, limit as i64], stored_photo)?
+            .collect::<rusqlite::Result<_>>()?;
+        Ok(rows)
+    }
+
+    /// Every town photos were taken in, with how many and the newest one as its
+    /// cover, most photographed first. Counted per group, like the timeline;
+    /// photos without a location, or taken far from any town, are in none.
+    pub fn photo_places(&self) -> Result<Vec<StoredPlace>> {
+        let rows: Vec<(u32, usize, String)> = {
+            let conn = self.read();
+            // SQLite fills the bare `uid` from the row `MIN(seq)` picked, which
+            // is the newest photo of the place.
+            let mut stmt = conn.prepare(
+                "SELECT place_id, COUNT(*), uid, MIN(seq) FROM photos \
+                 WHERE uid = COALESCE(group_key, uid) AND place_id IS NOT NULL \
+                 GROUP BY place_id ORDER BY COUNT(*) DESC, MIN(seq)",
+            )?;
+            stmt.query_map([], |r| {
+                Ok((r.get(0)?, r.get::<_, i64>(1)? as usize, r.get(2)?))
+            })?
+            .collect::<rusqlite::Result<_>>()?
+        };
+        let uids: Vec<String> = rows.iter().map(|(_, _, uid)| uid.clone()).collect();
+        let mut covers: HashMap<String, StoredPhoto> = self
+            .photos_by_uid(&uids)?
+            .into_iter()
+            .map(|photo| (photo.uid.clone(), photo))
+            .collect();
+        Ok(rows
+            .into_iter()
+            .filter_map(|(id, count, uid)| {
+                Some(StoredPlace {
+                    id,
+                    count,
+                    cover: covers.remove(&uid)?,
+                })
+            })
+            .collect())
+    }
+
+    /// One page of the photos taken in a town, newest first, one per group.
+    pub fn photos_at_place(
+        &self,
+        id: u32,
+        offset: usize,
+        limit: usize,
+    ) -> Result<Vec<StoredPhoto>> {
+        let conn = self.read();
+        let sql = format!(
+            "{PHOTO_SELECT} WHERE p.uid = COALESCE(p.group_key, p.uid) AND p.place_id = ?1 \
+             ORDER BY p.seq LIMIT ?2 OFFSET ?3"
+        );
+        let mut stmt = conn.prepare(&sql)?;
+        let rows = stmt
+            .query_map(params![id, limit as i64, offset as i64], stored_photo)?
+            .collect::<rusqlite::Result<_>>()?;
+        Ok(rows)
+    }
+
+    /// Every photo taken in a town, one per group as in [`Self::photos_at_place`],
+    /// with where exactly it was taken. A group's own location is that of the
+    /// photo standing for it.
+    pub fn photo_locations_at_place(&self, id: u32) -> Result<Vec<(StoredPhoto, (f64, f64))>> {
+        let photos = self.photos_at_place(id, 0, usize::MAX >> 1)?;
+        let located: HashMap<String, (f64, f64)> = {
+            let conn = self.read();
+            let mut stmt = conn.prepare(
+                "SELECT uid, latitude, longitude FROM photos \
+                 WHERE place_id = ?1 AND latitude IS NOT NULL AND longitude IS NOT NULL",
+            )?;
+            stmt.query_map(params![id], |r| Ok((r.get(0)?, (r.get(1)?, r.get(2)?))))?
+                .collect::<rusqlite::Result<_>>()?
+        };
+        Ok(photos
+            .into_iter()
+            .filter_map(|photo| {
+                let at = *located.get(&photo.uid)?;
+                Some((photo, at))
+            })
+            .collect())
+    }
+
+    /// Sets of photos with the same content hash, each set ordered with the
+    /// copy worth keeping first, and the sets newest first.
+    ///
+    /// The copy to keep is the one in the most albums, then the one that is part
+    /// of a larger group (the JPEG's RAW is filed with it, a stray re-upload is
+    /// not), then the earliest in server order. At most one file per group is
+    /// listed: the files of one RAW+JPEG shot are not copies of each other, and a
+    /// set left with one member is no set.
+    pub fn photo_duplicates(&self) -> Result<Vec<Vec<StoredPhoto>>> {
+        let rows: Vec<(String, String, String)> = {
+            let conn = self.read();
+            let mut stmt = conn.prepare(
+                "SELECT p.uid, p.content_hash, COALESCE(p.group_key, p.uid) AS k FROM photos p \
+                 WHERE p.content_hash IN (SELECT content_hash FROM photos \
+                     WHERE content_hash IS NOT NULL GROUP BY content_hash HAVING COUNT(*) > 1) \
+                 ORDER BY p.content_hash, \
+                     (SELECT COUNT(*) FROM album_photos a WHERE a.uid = p.uid) DESC, \
+                     (SELECT COUNT(*) FROM photos m WHERE COALESCE(m.group_key, m.uid) = COALESCE(p.group_key, p.uid)) DESC, \
+                     p.seq",
+            )?;
+            stmt.query_map([], |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)))?
+                .collect::<rusqlite::Result<_>>()?
+        };
+        let uids: Vec<String> = rows.iter().map(|(uid, _, _)| uid.clone()).collect();
+        let mut stored: HashMap<String, StoredPhoto> = self
+            .photos_by_uid(&uids)?
+            .into_iter()
+            .map(|photo| (photo.uid.clone(), photo))
+            .collect();
+
+        let mut sets: Vec<Vec<StoredPhoto>> = Vec::new();
+        let mut hash_of_set: Option<&str> = None;
+        let mut groups_in_set: HashSet<&str> = HashSet::new();
+        for (uid, hash, group) in &rows {
+            if hash_of_set != Some(hash.as_str()) {
+                hash_of_set = Some(hash);
+                groups_in_set.clear();
+                sets.push(Vec::new());
+            }
+            if !groups_in_set.insert(group) {
+                continue;
+            }
+            if let (Some(set), Some(photo)) = (sets.last_mut(), stored.remove(uid)) {
+                set.push(photo);
+            }
+        }
+        sets.retain(|set| set.len() > 1);
+        sets.sort_by_key(|set| std::cmp::Reverse(set.iter().map(|p| p.capture_time).max()));
+        Ok(sets)
+    }
+
+    /// Shots whose look hasn't been hashed yet, by the uid of the photo the
+    /// grid shows for each, newest first, at most `limit`. Videos, and photos
+    /// with no thumbnail to hash, are left out. A shot counts as hashed once
+    /// any of its files is, since they all show one picture.
+    pub fn photos_unhashed(&self, limit: usize) -> Result<Vec<StoredPhoto>> {
+        let uids: Vec<String> = {
+            let conn = self.read();
+            let mut stmt = conn.prepare(
+                "SELECT COALESCE(group_key, uid) AS k FROM photos \
+                 GROUP BY k \
+                 HAVING MAX(similar_hash) IS NULL \
+                    AND MAX(kind != ?1 AND thumb_state != ?2) \
+                 ORDER BY MAX(capture_time) DESC LIMIT ?3",
+            )?;
+            stmt.query_map(
+                params![
+                    crate::control::PhotoKind::Video.as_i64(),
+                    THUMB_NONE,
+                    limit as i64
+                ],
+                |r| r.get(0),
+            )?
+            .collect::<rusqlite::Result<_>>()?
+        };
+        self.photos_by_uid(&uids)
+    }
+
+    /// Record the look of photo `uid`: its difference hash, or
+    /// [`crate::similar::NO_HASH`] when its thumbnail gave none.
+    pub fn photo_set_similar_hash(&self, uid: &str, hash: u64) -> Result<()> {
+        let conn = self.conn.lock();
+        conn.execute(
+            "UPDATE photos SET similar_hash = ?2 WHERE uid = ?1",
+            params![uid, hash as i64],
+        )?;
+        Ok(())
+    }
+
+    /// How many shots have been hashed, out of how many could be.
+    pub fn similar_progress(&self) -> Result<(usize, usize)> {
+        let conn = self.read();
+        let (hashed, total): (i64, i64) = conn.query_row(
+            "SELECT COUNT(*) FILTER (WHERE hashed), COUNT(*) FROM \
+               (SELECT MAX(similar_hash) IS NOT NULL AS hashed FROM photos \
+                GROUP BY COALESCE(group_key, uid) \
+                HAVING MAX(similar_hash) IS NOT NULL \
+                    OR MAX(kind != ?1 AND thumb_state != ?2))",
+            params![crate::control::PhotoKind::Video.as_i64(), THUMB_NONE],
+            |r| Ok((r.get(0)?, r.get(1)?)),
+        )?;
+        Ok((hashed.max(0) as usize, total.max(0) as usize))
+    }
+
+    /// Sets of shots that look alike (see [`crate::similar`]), one photo per
+    /// shot in capture order, and the sets newest first. A set whose photos
+    /// are all byte-identical copies is left to [`Self::photo_duplicates`].
+    pub fn photo_similar(&self) -> Result<Vec<Vec<StoredPhoto>>> {
+        let rows: Vec<(String, u64, Option<String>)> = {
+            let conn = self.read();
+            let mut stmt = conn.prepare(
+                "SELECT COALESCE(group_key, uid) AS k, MAX(similar_hash), \
+                        MAX(content_hash) FILTER (WHERE uid = COALESCE(group_key, uid)) \
+                 FROM photos GROUP BY k \
+                 HAVING MAX(similar_hash) IS NOT NULL AND MAX(similar_hash) != ?1",
+            )?;
+            stmt.query_map(params![crate::similar::NO_HASH as i64], |r| {
+                Ok((r.get(0)?, r.get::<_, i64>(1)? as u64, r.get(2)?))
+            })?
+            .collect::<rusqlite::Result<_>>()?
+        };
+        let hashes: Vec<u64> = rows.iter().map(|(_, hash, _)| *hash).collect();
+        let found: Vec<Vec<usize>> = crate::similar::sets(&hashes)
+            .into_iter()
+            .filter(|set| {
+                let first = &rows[set[0]].2;
+                first.is_none() || set.iter().any(|&i| rows[i].2 != *first)
+            })
+            .collect();
+        let uids: Vec<String> = found.iter().flatten().map(|&i| rows[i].0.clone()).collect();
+        let mut stored: HashMap<String, StoredPhoto> = self
+            .photos_by_uid(&uids)?
+            .into_iter()
+            .map(|photo| (photo.uid.clone(), photo))
+            .collect();
+        let mut sets: Vec<Vec<StoredPhoto>> = found
+            .iter()
+            .map(|set| {
+                let mut photos: Vec<StoredPhoto> = set
+                    .iter()
+                    .filter_map(|&i| stored.remove(&rows[i].0))
+                    .collect();
+                photos.sort_by_key(|p| p.capture_time);
+                photos
+            })
+            .filter(|set| set.len() > 1)
+            .collect();
+        sets.sort_by_key(|set| std::cmp::Reverse(set.iter().map(|p| p.capture_time).max()));
+        Ok(sets)
+    }
+
    /// Per-tab counts for the Photos page subtitle: `(photos, videos, raw)`.
    pub fn photos_counts(&self) -> Result<(usize, usize, usize)> {
        use crate::control::PhotoKind;
@@ -620,7 +922,7 @@ impl Db {
        Ok(photos)
    }

-    /// Record a photo's favourite flag locally, after the server accepted the
+    /// Record a photo's favorite flag locally, after the server accepted the
    /// change. A uid the timeline does not hold is a no-op — an album photo on
    /// someone else's volume is never in our own `photos` table.
    pub fn photos_set_favorite(&self, uid: &str, favorite: bool) -> Result<()> {
@@ -140,7 +140,7 @@ fn photos_replace_keeps_what_was_learned_and_drops_what_left() {
    ])
    .unwrap();

-    let page = db.photos_page(0, 10, None, None, false).unwrap();
+    let page = db.photos_page(0, 10, None, None, false, false).unwrap();
    assert_eq!(
        page.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
        ["p0", "p1", "p2"],
@@ -163,7 +163,14 @@ fn photos_replace_keeps_what_was_learned_and_drops_what_left() {
    // The counts break down by tab, and a filtered page returns only its tab.
    assert_eq!(db.photos_counts().unwrap(), (2, 1, 0));
    let videos = db
-        .photos_page(0, 10, Some(crate::control::PhotoKind::Video), None, false)
+        .photos_page(
+            0,
+            10,
+            Some(crate::control::PhotoKind::Video),
+            None,
+            false,
+            false,
+        )
        .unwrap();
    assert_eq!(
        videos.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
@@ -176,7 +183,7 @@ fn photos_replace_keeps_what_was_learned_and_drops_what_left() {
    // A date-range page keeps only the window's photos: [150, 350) is p1+p2,
    // not p0 at 400. Combined with a kind filter both conditions apply.
    let ranged = db
-        .photos_page(0, 10, None, Some((150, 350)), false)
+        .photos_page(0, 10, None, Some((150, 350)), false, false)
        .unwrap();
    assert_eq!(
        ranged.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
@@ -189,6 +196,7 @@ fn photos_replace_keeps_what_was_learned_and_drops_what_left() {
            Some(crate::control::PhotoKind::Video),
            Some((150, 350)),
            false,
+            false,
        )
        .unwrap();
    assert_eq!(
@@ -218,11 +226,11 @@ fn favorites_are_remembered_across_refreshes_and_filter_a_page() {
        },
    ])
    .unwrap();
-    let favorites = db.photos_page(0, 10, None, None, true).unwrap();
+    let favorites = db.photos_page(0, 10, None, None, true, false).unwrap();
    assert_eq!(
        favorites.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
        ["p1"],
-        "only the favourited photo is in a favourites page"
+        "only the favorited photo is in a favorites page"
    );

    // A local toggle survives a refresh that could not resolve the photo's node
@@ -236,7 +244,7 @@ fn favorites_are_remembered_across_refreshes_and_filter_a_page() {
        TimelineRow::new("p2", 200),
    ])
    .unwrap();
-    let favorites = db.photos_page(0, 10, None, None, true).unwrap();
+    let favorites = db.photos_page(0, 10, None, None, true, false).unwrap();
    assert_eq!(
        favorites.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
        ["p2"],
@@ -245,6 +253,305 @@ fn favorites_are_remembered_across_refreshes_and_filter_a_page() {
    assert!(db.photos_by_uid(&["p2".into()]).unwrap()[0].favorite);
 }

+/// The strip shows the same calendar day in earlier years only: not today's
+/// own photos, not the day before, and one tile per RAW+JPEG shot.
+#[test]
+fn on_this_day_finds_the_same_date_in_earlier_years() {
+    const DAY: i64 = 86_400;
+    // Noon UTC, so the local date is the same in every common time zone.
+    let today = 1_781_524_800; // 2026-06-15 12:00 UTC
+    let year_ago = today - 365 * DAY; // 2025-06-15
+    let three_years_ago = today - (365 * 3 + 1) * DAY; // 2023-06-15, past a 29 February
+    let db = Db::open_in_memory().unwrap();
+    db.photos_replace(&[
+        TimelineRow::new("today", today),
+        TimelineRow {
+            name: Some("IMG_1.JPG".into()),
+            ..TimelineRow::new("jpeg", year_ago)
+        },
+        TimelineRow {
+            name: Some("IMG_1.CR2".into()),
+            ..TimelineRow::new("raw", year_ago)
+        },
+        TimelineRow::new("day-before", year_ago - DAY),
+        TimelineRow::new("older", three_years_ago),
+    ])
+    .unwrap();
+
+    let found = db.photos_on_this_day(today, 10).unwrap();
+    assert_eq!(
+        found.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
+        ["jpeg", "older"]
+    );
+}
+
+fn hashed(uid: &str, capture_time: i64, name: &str, hash: &str) -> TimelineRow {
+    TimelineRow {
+        name: Some(name.into()),
+        content_hash: Some(hash.into()),
+        ..TimelineRow::new(uid, capture_time)
+    }
+}
+
+fn located(uid: &str, capture_time: i64, name: &str, at: (f64, f64)) -> TimelineRow {
+    TimelineRow {
+        name: Some(name.into()),
+        location: Some(at),
+        resolved_at: Some(1),
+        ..TimelineRow::new(uid, capture_time)
+    }
+}
+
+const BERLIN: (f64, f64) = (52.52, 13.405);
+const PARIS: (f64, f64) = (48.857, 2.352);
+
+/// Places count shots, not files, lead with the most photographed town, and
+/// leave out photos with no location or taken far from any town.
+#[test]
+fn places_group_photos_by_the_nearest_town() {
+    let db = Db::open_in_memory().unwrap();
+    db.photos_replace(&[
+        located("b2", 500, "IMG_5.JPG", BERLIN),
+        located("p1", 400, "IMG_4.JPG", PARIS),
+        located("b1-jpeg", 300, "IMG_3.JPG", BERLIN),
+        located("b1-raw", 300, "IMG_3.CR2", BERLIN),
+        located("sea", 200, "IMG_2.JPG", (0.0, -30.0)),
+        TimelineRow::new("nowhere", 100),
+    ])
+    .unwrap();
+
+    let places = db.photo_places().unwrap();
+    let summary: Vec<(&str, usize, &str)> = places
+        .iter()
+        .map(|place| {
+            let city = crate::places::city(place.id).expect("a known town");
+            (city.name, place.count, place.cover.uid.as_str())
+        })
+        .collect();
+    assert_eq!(summary, [("Berlin", 2, "b2"), ("Paris", 1, "p1")]);
+
+    let berlin: Vec<String> = db
+        .photos_at_place(places[0].id, 0, 10)
+        .unwrap()
+        .into_iter()
+        .map(|p| p.uid)
+        .collect();
+    assert_eq!(berlin, ["b2", "b1-jpeg"]);
+}
+
+/// A town's photos come with where each was taken, one per RAW+JPEG shot.
+#[test]
+fn place_photos_carry_their_own_location() {
+    let db = Db::open_in_memory().unwrap();
+    let kreuzberg = (52.497, 13.411);
+    db.photos_replace(&[
+        located("b2", 500, "IMG_5.JPG", BERLIN),
+        located("b1-jpeg", 300, "IMG_3.JPG", kreuzberg),
+        located("b1-raw", 300, "IMG_3.CR2", kreuzberg),
+    ])
+    .unwrap();
+    let id = db.photo_places().unwrap()[0].id;
+    let located: Vec<(String, (f64, f64))> = db
+        .photo_locations_at_place(id)
+        .unwrap()
+        .into_iter()
+        .map(|(photo, at)| (photo.uid, at))
+        .collect();
+    assert_eq!(
+        located,
+        [("b2".to_owned(), BERLIN), ("b1-jpeg".to_owned(), kreuzberg)]
+    );
+}
+
+/// A refresh that skips an already-resolved photo keeps where it was taken; one
+/// that reads the node again takes what the node now says.
+#[test]
+fn a_skipped_refresh_keeps_a_photos_location() {
+    let db = Db::open_in_memory().unwrap();
+    db.photos_replace(&[located("a", 100, "IMG_1.JPG", BERLIN)])
+        .unwrap();
+    db.photos_replace(&[TimelineRow::new("a", 100)]).unwrap();
+    assert_eq!(db.photo_places().unwrap().len(), 1);
+
+    db.photos_replace(&[TimelineRow {
+        resolved_at: Some(2),
+        ..TimelineRow::new("a", 100)
+    }])
+    .unwrap();
+    assert!(db.photo_places().unwrap().is_empty());
+}
+
+/// A copy an album holds is the one kept; the files of one RAW+JPEG shot are
+/// never copies of each other; a hash only one file carries is no set.
+#[test]
+fn duplicates_list_the_copy_to_keep_first() {
+    let db = Db::open_in_memory().unwrap();
+    db.photos_replace(&[
+        hashed("copy", 500, "IMG_2.JPG", "h2"),
+        hashed("filed", 400, "IMG_2(1).JPG", "h2"),
+        hashed("jpeg", 300, "IMG_1.JPG", "h1"),
+        hashed("raw", 300, "IMG_1.CR2", "h1"),
+        hashed("stray", 200, "IMG_1(1).CR2", "h1"),
+        hashed("alone", 100, "IMG_3.JPG", "h3"),
+    ])
+    .unwrap();
+    db.album_photos_replace("a1", &[("filed".into(), 400, None, None)])
+        .unwrap();
+
+    let sets = db.photo_duplicates().unwrap();
+    let uids: Vec<Vec<&str>> = sets
+        .iter()
+        .map(|set| set.iter().map(|p| p.uid.as_str()).collect())
+        .collect();
+    assert_eq!(uids, [vec!["filed", "copy"], vec!["jpeg", "stray"]]);
+}
+
+/// Shots that look alike form a set, one photo per shot, while a set of
+/// byte-identical copies is left to the duplicate finder.
+#[test]
+fn similar_photos_group_by_look_and_skip_exact_copies() {
+    let db = Db::open_in_memory().unwrap();
+    db.photos_replace(&[
+        hashed("big", 500, "IMG_1.JPG", "h1"),
+        hashed("small", 400, "IMG_1-small.JPG", "h2"),
+        hashed("copy", 300, "IMG_2.JPG", "h3"),
+        hashed("copy2", 200, "IMG_2(1).JPG", "h3"),
+        hashed("other", 100, "IMG_3.JPG", "h4"),
+        hashed("flat", 50, "IMG_4.JPG", "h5"),
+    ])
+    .unwrap();
+    let look = 0x0f0f_3c3c_5a5a_9696_u64;
+    db.photo_set_similar_hash("big", look).unwrap();
+    db.photo_set_similar_hash("small", look ^ 0b101).unwrap();
+    db.photo_set_similar_hash("copy", !look).unwrap();
+    db.photo_set_similar_hash("copy2", !look).unwrap();
+    db.photo_set_similar_hash("other", look ^ 0xffff_ffff)
+        .unwrap();
+    db.photo_set_similar_hash("flat", crate::similar::NO_HASH)
+        .unwrap();
+
+    let sets = db.photo_similar().unwrap();
+    let uids: Vec<Vec<&str>> = sets
+        .iter()
+        .map(|set| set.iter().map(|p| p.uid.as_str()).collect())
+        .collect();
+    assert_eq!(uids, [vec!["small", "big"]]);
+    assert_eq!(db.similar_progress().unwrap(), (6, 6));
+}
+
+/// What is left to hash skips videos and hashed shots, and a hash survives a
+/// refresh unless the photo's bytes changed.
+#[test]
+fn similar_hashes_are_kept_until_the_photo_changes() {
+    let db = Db::open_in_memory().unwrap();
+    let resolved = |uid: &str, hash: &str| TimelineRow {
+        resolved_at: Some(1),
+        ..hashed(uid, 100, &format!("{uid}.JPG"), hash)
+    };
+    db.photos_replace(&[
+        resolved("a", "h1"),
+        resolved("b", "h2"),
+        hashed("clip", 50, "clip.mp4", "h3"),
+    ])
+    .unwrap();
+    db.photo_set_similar_hash("a", 7).unwrap();
+    db.photo_set_similar_hash("b", 9).unwrap();
+    let left = |db: &Db| -> Vec<String> {
+        db.photos_unhashed(10)
+            .unwrap()
+            .into_iter()
+            .map(|p| p.uid)
+            .collect()
+    };
+    assert!(left(&db).is_empty());
+    assert_eq!(db.similar_progress().unwrap(), (2, 2));
+
+    db.photos_replace(&[
+        resolved("a", "h1"),
+        resolved("b", "h2-edited"),
+        hashed("clip", 50, "clip.mp4", "h3"),
+    ])
+    .unwrap();
+    assert_eq!(left(&db), ["b"]);
+    assert_eq!(db.similar_progress().unwrap(), (1, 2));
+}
+
+/// Trashing the file a group is shown as leaves the rest of the group on the
+/// timeline instead of pointing at a photo that is gone.
+#[test]
+fn deleting_a_group_representative_keeps_its_other_files() {
+    let db = Db::open_in_memory().unwrap();
+    db.photos_replace(&[
+        hashed("jpeg", 300, "IMG_1.JPG", "h1"),
+        hashed("raw", 300, "IMG_1.CR2", "h2"),
+    ])
+    .unwrap();
+    assert_eq!(
+        db.photos_page(0, 10, None, None, false, false)
+            .unwrap()
+            .len(),
+        1
+    );
+
+    db.photos_delete(&["jpeg".into()]).unwrap();
+    let page = db.photos_page(0, 10, None, None, false, false).unwrap();
+    assert_eq!(
+        page.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
+        ["raw"]
+    );
+}
+
+#[test]
+fn not_in_album_hides_photos_any_album_holds() {
+    let db = Db::open_in_memory().unwrap();
+    db.photos_replace(&[
+        TimelineRow::new("p1", 300),
+        TimelineRow::new("p2", 200),
+        TimelineRow::new("p3", 100),
+    ])
+    .unwrap();
+    db.album_photos_replace("a1", &[("p1".into(), 300, None, None)])
+        .unwrap();
+    db.album_photos_replace("a2", &[("p3".into(), 100, None, None)])
+        .unwrap();
+
+    let page = db.photos_page(0, 10, None, None, false, true).unwrap();
+    assert_eq!(
+        page.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
+        ["p2"]
+    );
+}
+
+/// Filing the JPEG of a RAW+JPEG shot files the shot: the grid shows it as
+/// one tile, and that tile is in an album.
+#[test]
+fn not_in_album_counts_a_raw_pair_as_filed() {
+    let db = Db::open_in_memory().unwrap();
+    db.photos_replace(&[
+        TimelineRow {
+            name: Some("IMG_1234.JPG".into()),
+            ..TimelineRow::new("jpeg", 300)
+        },
+        TimelineRow {
+            name: Some("img_1234.cr2".into()),
+            ..TimelineRow::new("raw", 300)
+        },
+        TimelineRow {
+            name: Some("IMG_9999.JPG".into()),
+            ..TimelineRow::new("alone", 200)
+        },
+    ])
+    .unwrap();
+    db.album_photos_replace("a1", &[("raw".into(), 300, None, None)])
+        .unwrap();
+
+    let page = db.photos_page(0, 10, None, None, false, true).unwrap();
+    assert_eq!(
+        page.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
+        ["alone"]
+    );
+}
+
 #[test]
 fn photos_page_slices_the_timeline_in_order() {
    let db = Db::open_in_memory().unwrap();
@@ -253,12 +560,16 @@ fn photos_page_slices_the_timeline_in_order() {
        .collect();
    db.photos_replace(&items).unwrap();

-    let page = db.photos_page(2, 2, None, None, false).unwrap();
+    let page = db.photos_page(2, 2, None, None, false, false).unwrap();
    assert_eq!(
        page.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
        ["p2", "p3"]
    );
-    assert!(db.photos_page(9, 2, None, None, false).unwrap().is_empty());
+    assert!(
+        db.photos_page(9, 2, None, None, false, false)
+            .unwrap()
+            .is_empty()
+    );
 }

 #[test]
@@ -1083,6 +1394,40 @@ fn search_trigram_substring_and_path() {
    );
 }

+#[test]
+fn search_in_scope_only_returns_hits_below_the_folder() {
+    let db = Db::open_in_memory().unwrap();
+    db.upsert_node(&folder("root", None, "My Files")).unwrap();
+    db.upsert_node(&folder("work", Some("root"), "Work"))
+        .unwrap();
+    db.upsert_node(&folder("sub", Some("work"), "Old")).unwrap();
+    db.upsert_node(&folder("work2", Some("root"), "Work 2"))
+        .unwrap();
+    db.upsert_node(&file("f1", "work", "report.pdf", 1))
+        .unwrap();
+    db.upsert_node(&file("f2", "sub", "report-2019.pdf", 1))
+        .unwrap();
+    db.upsert_node(&file("f3", "work2", "report-copy.pdf", 1))
+        .unwrap();
+    db.upsert_node(&file("f4", "root", "report-top.pdf", 1))
+        .unwrap();
+
+    let mut paths: Vec<String> = db
+        .search_in("report", 10, Some("Work"))
+        .unwrap()
+        .into_iter()
+        .map(|h| h.path)
+        .collect();
+    paths.sort();
+    // A sibling whose name starts with the scope is not inside it.
+    assert_eq!(paths, vec!["Work/Old/report-2019.pdf", "Work/report.pdf"]);
+    // Short queries take the LIKE path and scope the same way.
+    assert_eq!(db.search_in("re", 10, Some("Work/Old")).unwrap().len(), 1);
+    // No scope, or the root, is everywhere.
+    assert_eq!(db.search_in("report", 10, None).unwrap().len(), 4);
+    assert_eq!(db.search_in("report", 10, Some("")).unwrap().len(), 4);
+}
+
 #[test]
 fn search_excludes_trashed_and_respects_limit() {
    let db = Db::open_in_memory().unwrap();
@@ -1380,6 +1725,29 @@ fn activity_reads_back_newest_first() {
    assert_eq!(db.activity_list(1).unwrap().len(), 1);
 }

+#[test]
+fn activity_has_finds_only_matching_kind_and_target() {
+    let db = Db::open_in_memory().unwrap();
+    db.activity_add(&activity(
+        "a (sync-conflict 1).txt",
+        ActivityKind::Conflict,
+        false,
+    ))
+    .unwrap();
+    db.activity_add(&activity("b.txt", ActivityKind::Upload, true))
+        .unwrap();
+
+    assert!(
+        db.activity_has(ActivityKind::Conflict, "a (sync-conflict 1).txt")
+            .unwrap()
+    );
+    assert!(
+        !db.activity_has(ActivityKind::Upload, "a (sync-conflict 1).txt")
+            .unwrap()
+    );
+    assert!(!db.activity_has(ActivityKind::Conflict, "b.txt").unwrap());
+}
+
 #[test]
 fn activity_prunes_to_the_keep_limit() {
    let db = Db::open_in_memory().unwrap();
@@ -3049,6 +3417,57 @@ fn a_parked_transient_create_stays_off_the_drain_until_finalized() {
    assert_eq!(due.blob_path.as_deref(), Some("/staging/blob1"));
 }

+/// The park sweep's query: parked creates are the rows nothing else in the drain
+/// can see, so it has to find them by the sentinel and report how long each has
+/// been parked. Ordinary queued work is not its business.
+#[test]
+fn parked_creates_are_listed_with_the_age_the_sweep_judges_them_by() {
+    let db = Db::open_in_memory().unwrap();
+    let parent = uid("root").to_string();
+    let parked = uid("swap").to_string();
+    let due = uid("ordinary").to_string();
+    for (node, name, next_attempt_at, created_at) in [
+        (&parked, ".notes.txt.swp", PARK_UNTIL, 1_000),
+        (&due, "notes.txt", 0, 2_000),
+    ] {
+        db.enqueue_op(&PendingOp {
+            id: 0,
+            kind: OP_CREATE.to_string(),
+            uid: node.clone(),
+            parent_uid: Some(parent.clone()),
+            name: Some(name.to_string()),
+            blob_path: Some(format!("/staging/{name}")),
+            meta_json: None,
+            created_at,
+            attempts: 0,
+            last_error: None,
+            next_attempt_at,
+        })
+        .unwrap();
+    }
+
+    let rows = db.parked_create_ops().unwrap();
+    assert_eq!(rows.len(), 1, "only the parked create is swept");
+    assert_eq!(rows[0].uid, parked);
+    assert_eq!(rows[0].created_at, 1_000, "the park's age is readable");
+    assert_eq!(
+        rows[0].blob_path.as_deref(),
+        Some("/staging/.notes.txt.swp")
+    );
+
+    // What the sweep does with an expired park: un-park it, and it drains like
+    // any other create rather than waiting for a rename that is not coming.
+    assert!(db.set_create_hold(&parked, false).unwrap());
+    assert!(
+        db.parked_create_ops().unwrap().is_empty(),
+        "an un-parked create is no longer the sweep's business"
+    );
+    assert_eq!(
+        db.next_due_op(1_000 + PARK_EXPIRY_MS).unwrap().unwrap().uid,
+        parked
+    );
+}
+
 /// Backoff still gates: nothing is returned before an op is due.
 #[test]
 fn next_due_op_respects_backoff() {
@@ -3969,7 +4388,7 @@ fn photos_delete_removes_the_photo_and_its_album_membership() {

    assert_eq!(db.photos_delete(&["p2".into()]).unwrap(), 1);

-    let page = db.photos_page(0, 10, None, None, false).unwrap();
+    let page = db.photos_page(0, 10, None, None, false, false).unwrap();
    assert_eq!(
        page.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
        ["p1", "p3"],
@@ -4009,7 +4428,7 @@ fn a_raw_and_its_jpeg_are_one_entry_in_the_grid() {
    ])
    .unwrap();

-    let page = db.photos_page(0, 10, None, None, false).unwrap();
+    let page = db.photos_page(0, 10, None, None, false, false).unwrap();
    assert_eq!(
        page.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
        ["jpeg", "alone"],
@@ -4022,7 +4441,14 @@ fn a_raw_and_its_jpeg_are_one_entry_in_the_grid() {

    // The Raw tab answers "which raws do I have", so it lists files.
    let raws = db
-        .photos_page(0, 10, Some(crate::control::PhotoKind::Raw), None, false)
+        .photos_page(
+            0,
+            10,
+            Some(crate::control::PhotoKind::Raw),
+            None,
+            false,
+            false,
+        )
        .unwrap();
    assert_eq!(
        raws.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
@@ -4067,7 +4493,7 @@ fn a_pixel_raw_capture_groups_with_its_cover_jpeg() {
    ])
    .unwrap();

-    let page = db.photos_page(0, 10, None, None, false).unwrap();
+    let page = db.photos_page(0, 10, None, None, false, false).unwrap();
    assert_eq!(
        page.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
        ["cover", "notes", "other"],
@@ -4106,7 +4532,7 @@ fn a_shared_name_alone_does_not_group_photos() {
    ])
    .unwrap();

-    let page = db.photos_page(0, 10, None, None, false).unwrap();
+    let page = db.photos_page(0, 10, None, None, false, false).unwrap();
    assert_eq!(page.len(), 3, "three shots, three tiles");
    assert!(page.iter().all(|p| p.group_size == 1));
 }
@@ -4129,7 +4555,7 @@ fn the_servers_photo_relation_groups_a_live_photo() {
    ])
    .unwrap();

-    let page = db.photos_page(0, 10, None, None, false).unwrap();
+    let page = db.photos_page(0, 10, None, None, false, false).unwrap();
    assert_eq!(
        page.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
        ["main"]
@@ -4150,6 +4576,48 @@ fn the_servers_photo_relation_groups_a_live_photo() {
 /// A database written before grouping existed opens, keeps its timeline, and
 /// shows every photo — a row with no `group_key` is its own group, which is how
 /// the gallery behaved before the column.
+#[test]
+fn migration_v32_retries_videos_written_off_as_unthumbnailable() {
+    let path = std::env::temp_dir().join(format!(
+        "pdfs-db-v31-fixture-{}-{}.db",
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
+    ));
+    {
+        let db = Db::open(&path).unwrap();
+        db.photos_replace(&[
+            TimelineRow {
+                name: Some("VID-20260804-WA0023.mp4".into()),
+                ..TimelineRow::new("video", 300)
+            },
+            TimelineRow {
+                name: Some("broken.jpg".into()),
+                ..TimelineRow::new("photo", 200)
+            },
+        ])
+        .unwrap();
+        db.photo_set_thumb("video", THUMB_NONE, None).unwrap();
+        db.photo_set_thumb("photo", THUMB_NONE, None).unwrap();
+        let conn = rusqlite::Connection::open(&path).unwrap();
+        conn.execute_batch("UPDATE sync_state SET value = '31' WHERE key = 'schema_version';")
+            .unwrap();
+    }
+
+    let db = Db::open(&path).unwrap();
+    let state = |uid: &str| db.photos_by_uid(&[uid.into()]).unwrap()[0].thumb_state;
+    assert_eq!(state("video"), THUMB_UNKNOWN, "the video is tried again");
+    assert_eq!(
+        state("photo"),
+        THUMB_NONE,
+        "an undecodable photo stays written off"
+    );
+    drop(db);
+    let _ = std::fs::remove_file(&path);
+}
+
 #[test]
 fn migration_v30_leaves_a_v29_timeline_intact() {
    let path = std::env::temp_dir().join(format!(
@@ -4189,7 +4657,7 @@ fn migration_v30_leaves_a_v29_timeline_intact() {
    }

    let db = Db::open(&path).unwrap();
-    let page = db.photos_page(0, 10, None, None, false).unwrap();
+    let page = db.photos_page(0, 10, None, None, false, false).unwrap();
    assert_eq!(
        page.iter().map(|p| p.uid.as_str()).collect::<Vec<_>>(),
        ["jpeg", "raw"],
@@ -4210,7 +4678,7 @@ fn migration_v30_leaves_a_v29_timeline_intact() {
        },
    ])
    .unwrap();
-    let page = db.photos_page(0, 10, None, None, false).unwrap();
+    let page = db.photos_page(0, 10, None, None, false, false).unwrap();
    assert_eq!(page.len(), 1);
    assert_eq!(page[0].uid, "jpeg");

@@ -4239,14 +4707,14 @@ fn photos_replace_keeps_a_skipped_photos_name() {
        },
    ])
    .unwrap();
-    let page = db.photos_page(0, 10, None, None, false).unwrap();
+    let page = db.photos_page(0, 10, None, None, false, false).unwrap();
    assert_eq!(page.len(), 1, "one shot, two files");
    assert!(page[0].has_raw);

    // The next refresh resolves neither, because both are already resolved.
    db.photos_replace(&[TimelineRow::new("jpeg", 300), TimelineRow::new("raw", 300)])
        .unwrap();
-    let page = db.photos_page(0, 10, None, None, false).unwrap();
+    let page = db.photos_page(0, 10, None, None, false, false).unwrap();
    assert_eq!(page.len(), 1, "the group survives a skipped refresh");
    assert_eq!(page[0].name.as_deref(), Some("IMG_1234.JPG"));
    assert!(page[0].has_raw, "the raw file is still a raw file");
@@ -4429,3 +4897,58 @@ fn migration_v31_treats_an_existing_timeline_as_resolved() {
    let _ = std::fs::remove_file(&path);
    let _ = std::fs::remove_file(format!("{}.lock", path.display()));
 }
+
+fn queued_op(db: &Db, uid: &str, failures: i64, next_attempt_at: i64) -> i64 {
+    let (id, _) = db
+        .enqueue_op(&ops::PendingOp {
+            id: 0,
+            kind: ops::OP_REVISION.to_string(),
+            uid: uid.to_string(),
+            parent_uid: None,
+            name: None,
+            blob_path: None,
+            meta_json: None,
+            created_at: 1000,
+            attempts: 0,
+            last_error: None,
+            next_attempt_at,
+        })
+        .unwrap();
+    for _ in 0..failures {
+        db.record_op_failure(id, "boom", next_attempt_at).unwrap();
+    }
+    id
+}
+
+/// "Retry now" must make a backed-off op due, but never un-park a transient
+/// file's op: that one waits for its finishing rename, not for time.
+#[test]
+fn retry_now_makes_a_backed_off_op_due_but_leaves_parked_ops_parked() {
+    let db = Db::open_in_memory().unwrap();
+    let backed_off = queued_op(&db, "vol~a", 3, 90_000);
+    let parked = queued_op(&db, "vol~b", 0, ops::PARK_UNTIL);
+
+    assert!(db.retry_op_now(backed_off, 5_000).unwrap());
+    assert!(!db.retry_op_now(parked, 5_000).unwrap());
+
+    let ops = db.pending_ops().unwrap();
+    let due = |id: i64| ops.iter().find(|op| op.id == id).unwrap().next_attempt_at;
+    assert_eq!(due(backed_off), 5_000);
+    assert_eq!(due(parked), ops::PARK_UNTIL);
+}
+
+#[test]
+fn retry_all_touches_only_ops_that_have_failed() {
+    let db = Db::open_in_memory().unwrap();
+    let failed = queued_op(&db, "vol~a", 2, 90_000);
+    let debounced = queued_op(&db, "vol~b", 0, 7_000);
+    let parked = queued_op(&db, "vol~c", 4, ops::PARK_UNTIL);
+
+    assert_eq!(db.retry_failed_ops_now(5_000).unwrap(), 1);
+
+    let ops = db.pending_ops().unwrap();
+    let due = |id: i64| ops.iter().find(|op| op.id == id).unwrap().next_attempt_at;
+    assert_eq!(due(failed), 5_000);
+    assert_eq!(due(debounced), 7_000);
+    assert_eq!(due(parked), ops::PARK_UNTIL);
+}
@@ -14,13 +14,16 @@ pub mod localindex;
 pub mod menu;
 pub mod mounts;
 pub mod opener;
+pub mod places;
 pub mod profile;
 pub mod sdkcache;
 pub mod search;
 pub mod service;
 pub mod shell;
+pub mod similar;
 pub mod syncignore;
 pub mod takeout;
+pub mod tray;

 pub use access::{Access, access_for, perm_bits};
 pub use error::{CoreError, CoreResult, Error, Result};
@@ -110,6 +110,9 @@ pub struct MountSpec {
    /// Live device sync progress, absent when no pass is running.
    #[serde(default)]
    pub progress: Option<SyncProgress>,
+    /// A synced folder paused on its own. Live daemon state, not a stored column.
+    #[serde(default)]
+    pub paused: bool,
 }

 #[cfg(test)]
@@ -0,0 +1,185 @@
+//! Offline reverse geocoding: the town a photo was taken in, from its GPS
+//! position, without asking any service.
+//!
+//! The towns are GeoNames' `cities15000` dump (every place with more than
+//! 15,000 people), trimmed to id, name, position and country in
+//! `data/cities15000.tsv` by `scripts/geonames-cities.py`. The script drops the
+//! parts of a city, such as Kreuzberg or "Paris 15 Vaugirard", so that a photo
+//! lands in the town people would name. GeoNames publishes the dump under
+//! CC BY 4.0, which is why the About dialog credits it.
+//!
+//! `data/countries.tsv` maps each country code to its ISO 3166-1 English name,
+//! as the `iso-codes` project spells it, so a front end can translate it
+//! through that project's `iso_3166-1` gettext domain.
+
+use std::collections::HashMap;
+use std::sync::OnceLock;
+
+/// How far from the nearest town a photo may be and still count as taken
+/// there, in km. Farther out (at sea, in the wilderness) it has no place.
+pub const MAX_DISTANCE_KM: f64 = 50.0;
+
+/// Mean Earth radius in km, for the haversine distance.
+const EARTH_RADIUS_KM: f64 = 6371.0;
+
+const CITIES: &str = include_str!("../data/cities15000.tsv");
+const COUNTRIES: &str = include_str!("../data/countries.tsv");
+
+/// One town of the table.
+#[derive(Debug, Clone, PartialEq)]
+pub struct City {
+    /// The GeoNames id, stable across dumps.
+    pub id: u32,
+    pub name: &'static str,
+    pub latitude: f64,
+    pub longitude: f64,
+    /// ISO 3166-1 alpha-2 country code.
+    pub country: &'static str,
+}
+
+/// The towns, and an index of them by whole-degree cell.
+struct Table {
+    cities: Vec<City>,
+    cells: HashMap<(i32, i32), Vec<usize>>,
+}
+
+fn table() -> &'static Table {
+    static TABLE: OnceLock<Table> = OnceLock::new();
+    TABLE.get_or_init(|| {
+        let cities: Vec<City> = CITIES.lines().filter_map(parse_city).collect();
+        let mut cells: HashMap<(i32, i32), Vec<usize>> = HashMap::new();
+        for (index, city) in cities.iter().enumerate() {
+            cells
+                .entry(cell(city.latitude, city.longitude))
+                .or_default()
+                .push(index);
+        }
+        Table { cities, cells }
+    })
+}
+
+fn parse_city(line: &'static str) -> Option<City> {
+    let mut fields = line.split('\t');
+    Some(City {
+        id: fields.next()?.parse().ok()?,
+        name: fields.next()?,
+        latitude: fields.next()?.parse().ok()?,
+        longitude: fields.next()?.parse().ok()?,
+        country: fields.next()?,
+    })
+}
+
+fn cell(latitude: f64, longitude: f64) -> (i32, i32) {
+    (latitude.floor() as i32, longitude.floor() as i32)
+}
+
+/// Great-circle distance between two positions, in km.
+pub fn distance_km(a: (f64, f64), b: (f64, f64)) -> f64 {
+    let (lat1, lat2) = (a.0.to_radians(), b.0.to_radians());
+    let dlat = lat2 - lat1;
+    let dlon = (b.1 - a.1).to_radians();
+    let h = (dlat / 2.0).sin().powi(2) + lat1.cos() * lat2.cos() * (dlon / 2.0).sin().powi(2);
+    2.0 * EARTH_RADIUS_KM * h.sqrt().min(1.0).asin()
+}
+
+/// The town nearest to a position, if one lies within [`MAX_DISTANCE_KM`].
+pub fn nearest(latitude: f64, longitude: f64) -> Option<&'static City> {
+    if !latitude.is_finite() || !longitude.is_finite() {
+        return None;
+    }
+    let table = table();
+    // A degree of latitude is about 111 km everywhere; a degree of longitude
+    // shrinks towards the poles, so more cells are needed to cover the radius.
+    let lat_span = (MAX_DISTANCE_KM / 111.0).ceil() as i32;
+    let lon_span = {
+        let scale = latitude.to_radians().cos().abs().max(0.01);
+        ((MAX_DISTANCE_KM / (111.0 * scale)).ceil() as i32).min(180)
+    };
+    let (row, column) = cell(latitude, longitude);
+    let mut best: Option<(f64, &City)> = None;
+    for dlat in -lat_span..=lat_span {
+        for dlon in -lon_span..=lon_span {
+            // Longitude wraps at the antimeridian: -181 is 179.
+            let lon_cell = (column + dlon + 180).rem_euclid(360) - 180;
+            let Some(indices) = table.cells.get(&(row + dlat, lon_cell)) else {
+                continue;
+            };
+            for &index in indices {
+                let city = &table.cities[index];
+                let d = distance_km((latitude, longitude), (city.latitude, city.longitude));
+                if d <= MAX_DISTANCE_KM && best.is_none_or(|(bd, _)| d < bd) {
+                    best = Some((d, city));
+                }
+            }
+        }
+    }
+    best.map(|(_, city)| city)
+}
+
+/// The town with this GeoNames id.
+pub fn city(id: u32) -> Option<&'static City> {
+    let cities = &table().cities;
+    // The table is sorted by id.
+    cities
+        .binary_search_by_key(&id, |city| city.id)
+        .ok()
+        .map(|index| &cities[index])
+}
+
+/// The English ISO 3166-1 name of a country code, such as "Germany" for "DE".
+pub fn country_name(code: &str) -> Option<&'static str> {
+    COUNTRIES.lines().find_map(|line| {
+        let (c, name) = line.split_once('\t')?;
+        (c == code).then_some(name)
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_position_in_a_town_resolves_to_that_town() {
+        let berlin = nearest(52.52, 13.405).expect("Berlin is a town");
+        assert_eq!(berlin.name, "Berlin");
+        assert_eq!(berlin.country, "DE");
+        assert_eq!(city(berlin.id), Some(berlin));
+    }
+
+    #[test]
+    fn the_open_sea_has_no_town() {
+        assert_eq!(nearest(0.0, -30.0), None);
+        assert_eq!(nearest(f64::NAN, 0.0), None);
+    }
+
+    #[test]
+    fn a_town_across_the_antimeridian_is_still_found() {
+        // Just east of 180°, the nearest towns in Fiji are west of it.
+        let town = nearest(-16.8, 179.99);
+        assert!(town.is_none_or(|t| t.country == "FJ"));
+        let suva = nearest(-18.14, 178.44).expect("Suva is a town");
+        assert_eq!(suva.country, "FJ");
+    }
+
+    #[test]
+    fn every_town_has_a_named_country() {
+        for city in &table().cities {
+            assert!(
+                country_name(city.country).is_some(),
+                "{} has no country name for {}",
+                city.name,
+                city.country
+            );
+        }
+        assert_eq!(country_name("DE"), Some("Germany"));
+    }
+
+    #[test]
+    fn distances_are_great_circle_km() {
+        let d = distance_km((52.52, 13.405), (48.137, 11.575));
+        assert!(
+            (d - 504.0).abs() < 5.0,
+            "Berlin to Munich is about 504 km, got {d}"
+        );
+    }
+}
@@ -0,0 +1,193 @@
+//! Telling photos apart by what they show rather than by their bytes.
+//!
+//! The server's content hash only matches byte-identical files. A photo that
+//! was resized, re-encoded or sent through a messenger is another file, so the
+//! similar-photo finder hashes each thumbnail instead: a 64-bit difference
+//! hash ("dHash"), which compares neighbouring brightness in a 9×8 grid. Two
+//! copies of one picture land a few bits apart, and different pictures about
+//! half of the bits apart.
+
+/// Hashes this many bits apart or fewer show the same picture.
+pub const SIMILAR_BITS: u32 = 6;
+
+/// Stored for a photo whose thumbnail was looked at and gave no usable hash
+/// (it couldn't be decoded, or is one flat colour), so it isn't looked at
+/// again. A real hash is never 0: a picture that would hash to 0 has no
+/// brightness changes, which [`difference_hash`] turns down as flat.
+pub const NO_HASH: u64 = 0;
+
+/// Samples of the grid that differ by less than this in brightness, all of
+/// them, make a flat picture — a black frame, a blank page — whose hash is
+/// noise and would match every other flat picture.
+const FLAT: u8 = 8;
+
+/// The difference hash of an 8-bit greyscale image `width` px wide, rows
+/// stored one after another in `luma`. `None` for an empty or flat image.
+pub fn difference_hash(width: usize, height: usize, luma: &[u8]) -> Option<u64> {
+    if width == 0 || height == 0 || luma.len() < width * height {
+        return None;
+    }
+    // Box-average down to 9×8, so every source pixel counts once and the hash
+    // doesn't depend on which pixels a nearest-neighbour pick happens to hit.
+    let mut grid = [[0u8; 9]; 8];
+    for (gy, row) in grid.iter_mut().enumerate() {
+        let (y0, y1) = span(gy, 8, height);
+        for (gx, cell) in row.iter_mut().enumerate() {
+            let (x0, x1) = span(gx, 9, width);
+            let mut sum = 0u64;
+            for y in y0..y1 {
+                sum += luma[y * width + x0..y * width + x1]
+                    .iter()
+                    .map(|&v| u64::from(v))
+                    .sum::<u64>();
+            }
+            *cell = (sum / ((y1 - y0) * (x1 - x0)) as u64) as u8;
+        }
+    }
+    let (min, max) = grid
+        .iter()
+        .flatten()
+        .fold((u8::MAX, 0), |(min, max), &v| (min.min(v), max.max(v)));
+    if max - min < FLAT {
+        return None;
+    }
+    let mut hash = 0u64;
+    for row in &grid {
+        for pair in row.windows(2) {
+            hash = hash << 1 | u64::from(pair[0] < pair[1]);
+        }
+    }
+    (hash != NO_HASH).then_some(hash)
+}
+
+/// The source pixels `from..to` that cell `i` of `cells` covers along an edge
+/// of `len` px; never empty, even for an edge shorter than the grid.
+fn span(i: usize, cells: usize, len: usize) -> (usize, usize) {
+    let from = (i * len / cells).min(len - 1);
+    let to = ((i + 1) * len / cells).max(from + 1);
+    (from, to)
+}
+
+/// Whether two hashes show the same picture.
+pub fn alike(a: u64, b: u64) -> bool {
+    (a ^ b).count_ones() <= SIMILAR_BITS
+}
+
+/// Group `hashes` into sets of alike ones, by index, each set in index order
+/// and the sets by their first index. A hash alike to none other is in no
+/// set. Alike is taken as catching: a burst of shots each a little different
+/// from the last is one set.
+pub fn sets(hashes: &[u64]) -> Vec<Vec<usize>> {
+    // Two hashes at most SIMILAR_BITS apart agree on at least one of their
+    // eight bytes, as long as SIMILAR_BITS < 8. So only hashes sharing some
+    // byte are compared, not every pair of the library.
+    const _: () = assert!(SIMILAR_BITS < 8);
+    let mut parent: Vec<usize> = (0..hashes.len()).collect();
+    fn root(parent: &mut [usize], mut i: usize) -> usize {
+        while parent[i] != i {
+            parent[i] = parent[parent[i]];
+            i = parent[i];
+        }
+        i
+    }
+    for byte in 0..8 {
+        let mut buckets: Vec<Vec<usize>> = vec![Vec::new(); 256];
+        for (i, &hash) in hashes.iter().enumerate() {
+            buckets[(hash >> (byte * 8)) as u8 as usize].push(i);
+        }
+        for bucket in &buckets {
+            for (n, &a) in bucket.iter().enumerate() {
+                for &b in &bucket[n + 1..] {
+                    if alike(hashes[a], hashes[b]) {
+                        let (ra, rb) = (root(&mut parent, a), root(&mut parent, b));
+                        if ra != rb {
+                            parent[ra.max(rb)] = ra.min(rb);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    let mut by_root: std::collections::BTreeMap<usize, Vec<usize>> = Default::default();
+    for i in 0..hashes.len() {
+        let r = root(&mut parent, i);
+        by_root.entry(r).or_default().push(i);
+    }
+    by_root.into_values().filter(|set| set.len() > 1).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A 90×80 picture: a bright disc on a gradient.
+    fn picture(width: usize, height: usize) -> Vec<u8> {
+        let mut luma = Vec::with_capacity(width * height);
+        for y in 0..height {
+            for x in 0..width {
+                let (fx, fy) = (x as f64 / width as f64, y as f64 / height as f64);
+                let disc = ((fx - 0.3).powi(2) + (fy - 0.6).powi(2)).sqrt() < 0.2;
+                let v = if disc { 240.0 } else { 40.0 + 120.0 * fx * fy };
+                luma.push(v as u8);
+            }
+        }
+        luma
+    }
+
+    #[test]
+    fn a_resized_copy_hashes_alike() {
+        let big = difference_hash(900, 800, &picture(900, 800)).unwrap();
+        let small = difference_hash(91, 79, &picture(91, 79)).unwrap();
+        assert!(
+            alike(big, small),
+            "{} bits apart",
+            (big ^ small).count_ones()
+        );
+    }
+
+    #[test]
+    fn a_different_picture_hashes_apart() {
+        let one = difference_hash(90, 80, &picture(90, 80)).unwrap();
+        let mirrored: Vec<u8> = picture(90, 80)
+            .chunks(90)
+            .flat_map(|row| row.iter().rev().copied().collect::<Vec<_>>())
+            .collect();
+        let other = difference_hash(90, 80, &mirrored).unwrap();
+        assert!(!alike(one, other));
+    }
+
+    #[test]
+    fn a_flat_picture_has_no_hash() {
+        assert_eq!(difference_hash(64, 64, &[17; 64 * 64]), None);
+        assert_eq!(difference_hash(0, 0, &[]), None);
+        assert_eq!(difference_hash(4, 4, &[0; 3]), None);
+    }
+
+    #[test]
+    fn a_picture_smaller_than_the_grid_still_hashes() {
+        let luma: Vec<u8> = (0..4 * 3).map(|i| (i * 20) as u8).collect();
+        assert!(difference_hash(4, 3, &luma).is_some());
+    }
+
+    #[test]
+    fn alike_hashes_form_sets_and_catch_on() {
+        let a = 0x0123_4567_89ab_cdef_u64;
+        let hashes = [
+            a,
+            !a,
+            a ^ 0b111,
+            a ^ 0b111 ^ (0b1111 << 40),
+            0x5555_0000_ffff_aaaa,
+        ];
+        assert_eq!(sets(&hashes), vec![vec![0, 2, 3]]);
+    }
+
+    #[test]
+    fn hashes_apart_in_most_bytes_are_still_found() {
+        // One bit apart in each of six bytes: six bits in all, and only the
+        // top two bytes agree.
+        let a = 1u64 << 63;
+        let b = (0..6).fold(a, |h, byte| h | 1 << (byte * 8));
+        assert_eq!(sets(&[a, b]), vec![vec![0, 1]]);
+    }
+}
@@ -45,18 +45,30 @@ pub const DEFAULT_IGNORE_PATTERNS: &[&str] = &[
    "Thumbs.db",
 ];

-/// Suffixes of files that are, by convention, incomplete or throwaway while they
-/// wear the name: a download in flight, an editor's swap or backup, an atomic
-/// write's scratch copy. On an on-demand mount these should never seal a remote
-/// revision — the app renames the finished file to its real name, and only that
-/// belongs on Drive. See [`is_transient_name`] and docs/BUGS.md B70.
+/// Suffixes that mean a file is incomplete *by construction*: only the program
+/// writing it gives it this name, only while the write is in flight, and the
+/// finished article always arrives under a different one. On an on-demand mount
+/// these should never seal a remote revision — the app renames the finished file
+/// to its real name, and only that belongs on Drive. See [`is_transient_name`]
+/// and docs/BUGS.md B70.
+///
+/// `.tmp`/`.temp` are deliberately **not** here, though they are in
+/// [`DEFAULT_IGNORE_PATTERNS`]. The two lists answer different questions. Skipping
+/// a `report.tmp` during a mirror reconcile costs nothing — the file stays on
+/// disk, and a later pass picks it up if the rules change. Parking one on the
+/// on-demand mount is irreversible in practice: the only exit is a rename to a
+/// finished name, and a file that is simply *called* `index.tmp` — a static-site
+/// template, a tool's output — never gets one. It then never reaches Drive at
+/// all, silently, while its bytes pin `staging/`. That is what a real Takeout
+/// tree of `index.tmp`/`preview.tmp` gallery templates did: 43 creates parked
+/// forever. The generic-scratch case they were added for renames within
+/// milliseconds, so it never needed the park; the download suffixes below, which
+/// stay in flight for minutes, are what B70 was actually about.
 const TRANSIENT_SUFFIXES: &[&str] = &[
    ".crdownload", // Chromium/Brave/Edge
    ".part",       // Firefox, wget, aria2c
    ".partial",    // some downloaders / older IE
    ".download",   // Safari / macOS
-    ".tmp",        // generic scratch
-    ".temp",       // generic scratch
    ".swp",        // vim swap
    ".swx",        // vim swap (secondary)
 ];
@@ -319,8 +331,6 @@ mod tests {
            "movie.mkv.part",
            "big.iso.partial",
            "photo.jpg.download",
-            "export.xml.tmp",
-            "notes.TEMP",
            ".notes.txt.swp",
            "doc.txt~",
            ".~lock.report.odt#",
@@ -340,6 +350,10 @@ mod tests {
            "archive.partly.zip", // ".partly" is not ".part"
            "template.dotx",
            "readme",
+            // A file that is *named* `.tmp` and never renamed: parking it would
+            // keep it off Drive for good.
+            "index.tmp",
+            "notes.TEMP",
        ] {
            assert!(!is_transient_name(name), "{name} should not be transient");
        }
@@ -812,7 +812,7 @@ mod tests {
    }

    #[test]
-    fn sidecar_supplies_capture_time_and_favourite() {
+    fn sidecar_supplies_capture_time_and_favorite() {
        let mut sidecars = HashMap::new();
        sidecar(
            &mut sidecars,
@@ -0,0 +1,20 @@
+//! Talking to a running `pdfs-tray`.
+//!
+//! The tray binds [`AppDirs::tray_socket`] to keep a single instance. The same
+//! socket takes one command, [`QUIT`], so the desktop app can take the icon
+//! away when the user hides it or stops Proton Drive.
+
+use std::io::Write;
+use std::os::unix::net::UnixStream;
+
+use crate::config::AppDirs;
+
+/// The line that asks the tray to exit.
+pub const QUIT: &str = "quit";
+
+/// Ask a running tray to exit. False when no tray answers.
+pub fn quit(dirs: &AppDirs) -> bool {
+    UnixStream::connect(dirs.tray_socket())
+        .and_then(|mut stream| stream.write_all(format!("{QUIT}\n").as_bytes()))
+        .is_ok()
+}
@@ -175,6 +175,40 @@ impl Core {
        Ok(page.into_iter().map(|p| self.photo_item(p)).collect())
    }

+    /// Make sure every album of ours has its contents on disk, for a filter
+    /// that asks which photos no album holds. Contents are otherwise fetched
+    /// the first time an album is opened, so an album never opened would read
+    /// as empty and its photos as unfiled.
+    ///
+    /// Shared-with-me albums are skipped: their photos live on the sharer's
+    /// volume and are never in our timeline. The freshness stamps are no guide
+    /// here — any album change clears all of them — so only an album whose
+    /// server count disagrees with an empty local copy is waited for.
+    pub(crate) fn ensure_album_contents(&self) -> CoreResult<()> {
+        if self.db.albums_count().map_err(CoreError::from)? == 0
+            && !self.rt.block_on(self.refresh_albums())?
+        {
+            return Ok(());
+        }
+        let albums = self.db.albums_list().map_err(CoreError::from)?;
+        for album in albums.iter().filter(|a| !a.shared && a.photo_count > 0) {
+            let stored = self
+                .db
+                .album_photos_count(&album.uid)
+                .map_err(CoreError::from)?;
+            if stored > 0 {
+                continue;
+            }
+            let Some(uid) = parse_uid(&album.uid) else {
+                continue;
+            };
+            if let Err(error) = self.rt.block_on(self.refresh_album(&uid)) {
+                warn!(album = %album.uid, %error, "fetching an album's contents failed");
+            }
+        }
+        Ok(())
+    }
+
    /// Re-enumerate one album's photos and replace its persisted contents.
    pub(crate) async fn refresh_album(&self, album: &NodeUid) -> CoreResult<()> {
        let photos = self.photos();
@@ -221,6 +255,84 @@ impl Core {
        Ok(())
    }

+    /// Create an album and return its uid. The listing is refreshed before
+    /// answering, so the next [`Core::albums`] already shows it.
+    pub(crate) fn create_album(&self, name: &str) -> CoreResult<String> {
+        let uid = self
+            .rt
+            .block_on(self.photos().create_album(name))
+            .map_err(|e| CoreError::from_api(&e, "create album"))?;
+        self.after_album_change(None);
+        Ok(uid.to_string())
+    }
+
+    pub(crate) fn rename_album(&self, album: &NodeUid, name: &str) -> CoreResult<()> {
+        self.rt
+            .block_on(self.photos().rename_album(album, name))
+            .map_err(|e| CoreError::from_api(&e, "rename album"))?;
+        self.after_album_change(None);
+        Ok(())
+    }
+
+    /// Delete an album. Its photos stay in the timeline unless `delete_photos`,
+    /// which only matters for photos that exist in the album alone.
+    pub(crate) fn delete_album(&self, album: &NodeUid, delete_photos: bool) -> CoreResult<()> {
+        self.rt
+            .block_on(self.photos().delete_album(album, delete_photos))
+            .map_err(|e| CoreError::from_api(&e, "delete album"))?;
+        let key = album.to_string();
+        if let Err(error) = self.db.album_photos_replace(&key, &[]) {
+            warn!(%album, %error, "a deleted album's photos could not be dropped");
+        }
+        self.after_album_change(None);
+        Ok(())
+    }
+
+    /// Add photos to an album, per photo: `(added, failed)`.
+    pub(crate) fn add_to_album(
+        &self,
+        album: &NodeUid,
+        photos: &[NodeUid],
+    ) -> CoreResult<AlbumOutcome> {
+        let outcomes = self
+            .rt
+            .block_on(self.photos().add_photos_to_album(album, photos))
+            .map_err(|e| CoreError::from_api(&e, "add to album"))?;
+        self.after_album_change(Some(album));
+        Ok(album_outcome(outcomes))
+    }
+
+    /// Take photos out of an album, per photo: `(removed, failed)`. The photos
+    /// stay in the timeline.
+    pub(crate) fn remove_from_album(
+        &self,
+        album: &NodeUid,
+        photos: &[NodeUid],
+    ) -> CoreResult<AlbumOutcome> {
+        let outcomes = self
+            .rt
+            .block_on(self.photos().remove_photos_from_album(album, photos))
+            .map_err(|e| CoreError::from_api(&e, "remove from album"))?;
+        self.after_album_change(Some(album));
+        Ok(album_outcome(outcomes))
+    }
+
+    /// Bring the persisted listing, and `album`'s contents when given, up to
+    /// date after a change made here, so the reply is followed by a listing
+    /// that shows it. A failed refresh only leaves them stale: the change
+    /// itself went through.
+    fn after_album_change(&self, album: Option<&NodeUid>) {
+        self.invalidate_albums();
+        if let Err(error) = self.rt.block_on(self.refresh_albums()) {
+            warn!(%error, "album listing refresh after a change failed");
+        }
+        if let Some(album) = album
+            && let Err(error) = self.rt.block_on(self.refresh_album(album))
+        {
+            warn!(%album, %error, "album refresh after a change failed");
+        }
+    }
+
    /// Drop the album listing's and every album's freshness stamp, so the next
    /// request re-enumerates. Paired with [`Core::invalidate_photos`] — a change
    /// to the timeline can just as easily be a change to an album.
@@ -230,6 +342,20 @@ impl Core {
    }
 }

+/// Photos an album change applied to, and the ones it failed for with why.
+pub(crate) type AlbumOutcome = (Vec<String>, Vec<(String, String)>);
+
+fn album_outcome(outcomes: Vec<pdfs_core::batch::Outcome>) -> AlbumOutcome {
+    let (done, failed) = pdfs_core::batch::split(outcomes);
+    (
+        done.iter().map(|uid| uid.to_string()).collect(),
+        failed
+            .into_iter()
+            .map(|(uid, error)| (uid.to_string(), error.to_string()))
+            .collect(),
+    )
+}
+
 /// Project a persisted album into the wire item a front-end paints.
 fn album_info(album: StoredAlbum) -> AlbumInfo {
    AlbumInfo {
@@ -511,7 +511,7 @@ impl PhotoEventPlan {
 ///
 /// `is_echo` claims an event as this daemon's own write. The feed replays our
 /// writes back at us and a `NodeUpdated` carries no revision id, so without this
-/// every favourite the user toggles here would mark its own photo stale and buy
+/// every favorite the user toggles here would mark its own photo stale and buy
 /// a resolve of a node we just wrote.
 fn classify_photo_events(
    events: &[DriveEvent],
@@ -529,7 +529,7 @@ fn classify_photo_events(
                if *is_trashed {
                    plan.gone.push(node_uid.to_string());
                } else if !is_echo(node_uid) {
-                    // An untrash, a rename, a favourite toggled on the phone: the
+                    // An untrash, a rename, a favorite toggled on the phone: the
                    // event says which node changed but never what about it, so
                    // the uid is marked stale and the next refresh reads it.
                    plan.touched.push(node_uid.to_string());
@@ -974,7 +974,7 @@ mod tests {
                },
                DriveEvent::NodeUpdated {
                    id: DriveEventId::from("e3"),
-                    node_uid: uid("favourited"),
+                    node_uid: uid("favorited"),
                    parent_node_uid: None,
                    is_trashed: false,
                    is_shared: false,
@@ -986,7 +986,7 @@ mod tests {
            plan,
            PhotoEventPlan {
                gone: vec![uid("deleted").to_string(), uid("trashed").to_string()],
-                touched: vec![uid("favourited").to_string()],
+                touched: vec![uid("favorited").to_string()],
                full: false,
            }
        );
@@ -0,0 +1,179 @@
+//! Listing and resolving `(sync-conflict …)` copies for the user.
+//!
+//! The sweep ([`crate::sweep`]) removes copies it can prove identical and flags
+//! the rest once in the activity feed. That leaves divergent copies sitting in
+//! folders with nothing but a name to find them by. This module lists them with
+//! the file they are a copy of, and resolves one the way the user chooses:
+//!
+//! - **Keep the original**: trash the copy.
+//! - **Keep the copy**: trash the original, then give the copy its name.
+//! - **Keep both**: rename the copy to a name of the user's choosing.
+//!
+//! Every resolution goes through the Proton trash, never a delete, so a wrong
+//! choice is undone by restoring from Trash. Resolution refuses to touch a file
+//! that is open, being written, or still owed an upload, for the same reason the
+//! sweep does: the node is about to change under the decision.
+//!
+//! Copies under My Files are named by their mountpoint-relative path. Copies
+//! inside a synced folder are named by their absolute local path, so a resolve
+//! request routes to the on-demand mount that serves them. A copy inside a
+//! mirror folder is listed too, but it is a local file first: the sync engine
+//! owns it, so it is resolved by editing the folder, not through here.
+
+use super::*;
+use pdfs_core::control::{ConflictInfo, ConflictKeep};
+use sweep::conflict_base_name;
+
+impl Core {
+    /// Where the user finds a conflict copy: its mountpoint-relative path under
+    /// My Files, or its absolute local path inside a synced folder. `None` for a
+    /// node no location of this machine shows, such as one in another
+    /// computer's device tree.
+    ///
+    /// The sweep only flags what this can name, and the listing uses it too. A
+    /// flagged copy the listing cannot see reads as resolved in the activity
+    /// feed while it still sits in the folder (`docs/BUGS.md` B99).
+    pub(crate) fn conflict_path(&self, roots: &SearchRoots, uid: &NodeUid) -> Option<String> {
+        let uid = uid.to_string();
+        if let Ok(Some(path)) = self
+            .db
+            .path_relative_to(&self.primary_root_uid.to_string(), &uid)
+        {
+            return Some(path);
+        }
+        let drive_path = self.db.node_path(&uid).ok().flatten()?;
+        roots.resolve(&drive_path)
+    }
+
+    /// Every conflict copy this machine shows, with the file it is a copy of.
+    pub(crate) fn list_conflicts(&self) -> CoreResult<Vec<ConflictInfo>> {
+        let stored = self
+            .db
+            .load_all()
+            .map_err(|e| CoreError::internal(format!("listing conflicts: {e:?}")))?;
+        let nodes: Vec<Node> = stored
+            .into_iter()
+            .map(|stored| stored.node)
+            .filter(|node| !node.trashed && !node.is_folder() && self.is_own_or_virtual(&node.uid))
+            .collect();
+        let mut by_parent_name: HashMap<(Option<&NodeUid>, &str), &Node> = HashMap::new();
+        for node in &nodes {
+            by_parent_name.insert((node.parent_uid.as_ref(), node.name.as_str()), node);
+        }
+        let roots = self.search_roots();
+        let mut items = Vec::new();
+        for node in &nodes {
+            let Some(base) = conflict_base_name(&node.name) else {
+                continue;
+            };
+            let Some(path) = self.conflict_path(&roots, &node.uid) else {
+                continue;
+            };
+            let original = by_parent_name
+                .get(&(node.parent_uid.as_ref(), base.as_str()))
+                .copied();
+            items.push(ConflictInfo {
+                original_path: sibling_path(&path, &base),
+                original_exists: original.is_some(),
+                size: node_size(node),
+                modified: node.modification_time,
+                original_size: original.map(node_size),
+                original_modified: original.map(|o| o.modification_time),
+                identical: original.is_some_and(|o| {
+                    node_size(o) == node_size(node)
+                        && node_content_sha1(node)
+                            .is_some_and(|sha| node_content_sha1(o).as_deref() == Some(&sha))
+                }),
+                path,
+            });
+        }
+        items.sort_by(|a, b| a.path.cmp(&b.path));
+        Ok(items)
+    }
+
+    /// Resolve the conflict copy at mountpoint-relative `copy`. Returns a line
+    /// for the user saying what happened.
+    pub(crate) fn resolve_conflict(&self, copy: &Path, keep: &ConflictKeep) -> CoreResult<String> {
+        let copy_name = copy
+            .file_name()
+            .and_then(|n| n.to_str())
+            .ok_or_else(|| CoreError::invalid("the conflict copy has no file name"))?;
+        let base = conflict_base_name(copy_name)
+            .ok_or_else(|| CoreError::invalid(format!("{copy_name} is not a conflict copy")))?;
+        let original = copy.with_file_name(&base);
+        self.require_settled(copy)?;
+        let message = match keep {
+            ConflictKeep::Original => {
+                self.delete(copy)?;
+                self.log_activity(ActivityKind::Trash, copy_name, format!("kept {base}"), true);
+                format!("kept {base}; the copy is in Trash")
+            }
+            ConflictKeep::Copy => {
+                self.require_settled(&original)?;
+                self.delete(&original)?;
+                // The original is already in Trash. A failed rename leaves the
+                // copy under its conflict name, which loses nothing — say so
+                // rather than leave the user guessing where their file went.
+                self.rename(copy, &base).map_err(|e| {
+                    e.context(&format!(
+                        "{base} was moved to Trash, but the copy kept its conflict name"
+                    ))
+                })?;
+                self.log_activity(
+                    ActivityKind::Rename,
+                    &base,
+                    format!("kept the conflict copy {copy_name}"),
+                    true,
+                );
+                format!("kept the copy as {base}; the previous version is in Trash")
+            }
+            ConflictKeep::Both { name } => {
+                let name = name.trim();
+                if name == base || name == copy_name {
+                    return Err(CoreError::invalid("choose a name that no other file has"));
+                }
+                self.rename(copy, name)?;
+                self.log_activity(ActivityKind::Rename, name, format!("was {copy_name}"), true);
+                format!("kept both; the copy is now {name}")
+            }
+        };
+        Ok(message)
+    }
+
+    /// Refuse to resolve around a file that is open, being written, or still
+    /// owed an upload: the decision would be about content that is changing.
+    fn require_settled(&self, rel: &Path) -> CoreResult<()> {
+        let (_, uid) = self.resolve(rel)?;
+        let queued = self.db.has_any_op(&uid.to_string()).unwrap_or(true);
+        if queued || self.is_busy(&uid) {
+            return Err(CoreError::conflict(format!(
+                "{} is still being written or uploaded; try again once it has synced",
+                rel.display()
+            )));
+        }
+        self.conflict_notified.lock().remove(&uid);
+        Ok(())
+    }
+}
+
+/// The path of `name` next to the file at `path`.
+fn sibling_path(path: &str, name: &str) -> String {
+    match path.rsplit_once('/') {
+        Some((dir, _)) => format!("{dir}/{name}"),
+        None => name.to_string(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn the_original_sits_next_to_its_copy() {
+        assert_eq!(
+            sibling_path("a/b/f (sync-conflict 1).txt", "f.txt"),
+            "a/b/f.txt"
+        );
+        assert_eq!(sibling_path("f (sync-conflict 1).txt", "f.txt"), "f.txt");
+    }
+}
@@ -22,13 +22,33 @@ use pdfs_core::control::{
 };
 use pdfs_core::{CoreError, CoreResult};
 use proton_drive_rs::proton_sdk::ids::NodeUid;
-use tracing::{info, warn};
+use tracing::{debug, info, warn};

 use super::transfers::CountingReader;
 use super::{Core, count_noun, human_bytes, human_duration, parse_uid};

 const MAX_CONTROL_REQUEST_BYTES: u64 = 1024 * 1024;
 const CONTROL_READ_TIMEOUT: Duration = Duration::from_secs(10);
+/// Answer a [`CtlRequest::StopSharing`]: log it, and turn a partial removal
+/// into an error that names what is still shared.
+fn stop_sharing_reply(
+    core: &Core,
+    target: &str,
+    result: CoreResult<super::sharing::StopSharingOutcome>,
+) -> CtlResponse {
+    match result.map(|outcome| outcome.into_result()) {
+        Ok(Ok(message)) => {
+            core.log_activity(ActivityKind::Unshare, target, "stopped sharing", true);
+            CtlResponse::Ok { message }
+        }
+        Ok(Err(left)) => {
+            core.log_activity(ActivityKind::Unshare, target, &left, false);
+            CtlResponse::error(CoreError::remote(left))
+        }
+        Err(e) => CtlResponse::error(e),
+    }
+}
+
 /// A client that connects, sends a request and then never reads its reply used
 /// to park a handler thread forever in `write_all`; 64 of those exhaust
 /// [`MAX_CONTROL_HANDLERS`] permanently. Generous enough for the largest
@@ -46,6 +66,32 @@ const MAX_ROW_LIMIT: usize = 1000;
 fn clamp_limit(limit: usize) -> usize {
    limit.min(MAX_ROW_LIMIT)
 }
+/// Answer an album add or remove: parse the uids, run `change`, and report
+/// per photo.
+fn album_change(
+    uid: &str,
+    photos: &[String],
+    change: impl FnOnce(&NodeUid, &[NodeUid]) -> CoreResult<super::albums::AlbumOutcome>,
+) -> CtlResponse {
+    let Some(album) = parse_uid(uid) else {
+        return CtlResponse::error(CoreError::invalid(format!("bad album uid: {uid}")));
+    };
+    let photos = match Core::parse_uids(photos) {
+        Ok(photos) => photos,
+        Err(e) => return CtlResponse::error(e),
+    };
+    match change(&album, &photos) {
+        Ok((changed, failed)) => CtlResponse::AlbumChanged {
+            changed,
+            failed: failed
+                .into_iter()
+                .map(|(uid, message)| TrashFailure { uid, message })
+                .collect(),
+        },
+        Err(e) => CtlResponse::error(e),
+    }
+}
+
 static ACTIVE_CONTROL_HANDLERS: AtomicUsize = AtomicUsize::new(0);

 struct ControlHandlerPermit;
@@ -139,6 +185,38 @@ fn route_to_mount(core: &Core, mountpoint: &Path, path: &str) -> CoreResult<(Cor
    rel_to_mount(mountpoint, path).map(|rel| (core.clone(), rel))
 }

+/// [`route_to_mount`] for a conflict copy. The listing names a copy inside a
+/// synced folder by its absolute local path (`docs/BUGS.md` B99), so the
+/// resolve has to run against the on-demand mount serving it. A mirror folder
+/// has no mount to run against: its copy is an ordinary local file.
+fn route_conflict(core: &Core, mountpoint: &Path, path: &str) -> CoreResult<(Core, PathBuf)> {
+    let routed = route_to_mount(core, mountpoint, path).map_err(|e| {
+        let p = Path::new(path);
+        let mirrored = core
+            .db
+            .sync_folder_list()
+            .unwrap_or_default()
+            .iter()
+            .any(|folder| folder.mode == "mirror" && p.starts_with(&folder.local_path));
+        if mirrored {
+            CoreError::invalid(format!(
+                "{path} is in a mirrored folder; rename or delete the local file there"
+            ))
+        } else {
+            e
+        }
+    })?;
+    if routed
+        .1
+        .components()
+        .all(|component| matches!(component, Component::Normal(_) | Component::CurDir))
+    {
+        Ok(routed)
+    } else {
+        Err(CoreError::invalid(format!("{path} escapes the mountpoint")))
+    }
+}
+
 /// Turn a CLI-supplied path into a mountpoint-relative path. An absolute path
 /// must live under `mountpoint`; a relative path is taken as already relative to
 /// the mount root.
@@ -164,6 +242,50 @@ fn rel_to_mount(mountpoint: &Path, path: &str) -> CoreResult<PathBuf> {

 /// Handle one control-socket connection: read a single JSON request line,
 /// dispatch it against `core`, and write back a JSON response line.
+/// Refresh scopes being served right now, one entry per running refresh.
+///
+/// A `Vec` because there are three scopes and at most `MAX_CONTROL_HANDLERS`
+/// handlers, so a set would buy nothing.
+static REFRESHING: std::sync::Mutex<Vec<String>> = std::sync::Mutex::new(Vec::new());
+
+/// What makes two refreshes the same work: the scope, and for a directory the
+/// folder, since refreshing one folder says nothing about another. A full
+/// photos refresh is not the same work as an ordinary one — it forgets what the
+/// daemon knows first — so it keys apart.
+fn scope_key(scope: &RefreshScope) -> String {
+    match scope {
+        RefreshScope::Dir { path } => format!("dir:{path}"),
+        RefreshScope::Trash => "trash".to_string(),
+        RefreshScope::Photos { full: true } => "photos:full".to_string(),
+        RefreshScope::Photos { full: false } => "photos".to_string(),
+    }
+}
+
+/// Holds one refresh scope for as long as it is being served. `acquire`
+/// returns `None` when that scope is already in flight.
+struct RefreshGuard(String);
+
+impl RefreshGuard {
+    fn acquire(scope: &RefreshScope) -> Option<Self> {
+        let key = scope_key(scope);
+        let mut running = REFRESHING.lock().unwrap_or_else(|e| e.into_inner());
+        if running.contains(&key) {
+            return None;
+        }
+        running.push(key.clone());
+        Some(Self(key))
+    }
+}
+
+impl Drop for RefreshGuard {
+    fn drop(&mut self) {
+        let mut running = REFRESHING.lock().unwrap_or_else(|e| e.into_inner());
+        if let Some(at) = running.iter().position(|key| *key == self.0) {
+            running.swap_remove(at);
+        }
+    }
+}
+
 fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: UnixStream) {
    if let Err(e) = stream.set_read_timeout(Some(CONTROL_READ_TIMEOUT)) {
        warn!(error = %e, "control: could not set request timeout");
@@ -202,6 +324,8 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
                failing_error: queued.last_error.clone(),
                staged_bytes: staging.bytes,
                staged_oldest_secs: staging.oldest_secs,
+                paused: core.sync_pause().is_some(),
+                paused_until: core.sync_pause().flatten(),
                username: username.to_string(),
                mountpoint: mountpoint.display().to_string(),
                pinned: pins.len(),
@@ -238,7 +362,7 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
            Err(e) => CtlResponse::error(e),
        },
        Ok(CtlRequest::ListPins) => CtlResponse::Pins {
-            pins: core.cache.list_pins(),
+            pins: core.list_pins(),
        },
        Ok(CtlRequest::ListDir { path }) => match route_to_mount(core, mountpoint, &path) {
            Ok((core, rel)) => match core.list_dir(&rel) {
@@ -247,52 +371,84 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
            },
            Err(e) => CtlResponse::error(e),
        },
-        Ok(CtlRequest::Refresh { scope }) => {
-            let result = match &scope {
-                RefreshScope::Dir { path } => route_to_mount(core, mountpoint, path)
-                    .and_then(|(core, rel)| core.refresh_dir(&rel)),
-                RefreshScope::Trash => {
-                    core.invalidate_trash();
-                    Ok(())
+        Ok(CtlRequest::Refresh { scope }) => match RefreshGuard::acquire(&scope) {
+            // The same scope is already being refreshed by another handler.
+            // Running it again cannot make the answer newer, and the duplicate
+            // would spend its whole run contending for the state and database
+            // locks the first one holds — which is how five stacked photo
+            // refreshes sat in flight for twenty-three minutes at mount time.
+            None => {
+                debug!(scope = %scope_key(&scope), "a refresh of this scope is already running");
+                CtlResponse::Ok {
+                    message: "refreshing".to_string(),
                }
-                RefreshScope::Photos { full } => {
-                    core.invalidate_photos();
-                    // A full refresh is "forget what you know", not a second code
-                    // path: the ordinary refresh then finds every photo stale.
-                    if let Some(Err(e)) = full.then(|| core.db.photos_mark_all_unresolved()) {
-                        warn!(error = %e, "marking the whole timeline unresolved failed");
-                    }
-                    // Whatever changed the timeline can just as easily have
-                    // changed an album; one scope covers the whole photos view.
-                    core.invalidate_albums();
-                    // The refresh is started here, not awaited. A library of
-                    // twelve thousand photos is re-read in chunks of
-                    // `TIMELINE_ENRICH_CHUNK` nodes, which takes minutes —
-                    // longer than the client's read bound, so awaiting it
-                    // returned `Resource temporarily unavailable` to a caller
-                    // whose refresh was in fact running fine (B92). The front
-                    // end follows it with `PhotosRefreshStatus`.
-                    core.spawn_timeline_refresh();
-                    Ok(())
-                }
-            };
-            match result {
-                Ok(()) => CtlResponse::Ok {
-                    message: match scope {
-                        RefreshScope::Photos { .. } => "refreshing".to_string(),
-                        _ => "refreshed".to_string(),
-                    },
-                },
-                Err(e) => CtlResponse::error(e),
            }
-        }
+            Some(_refreshing) => {
+                let result = match &scope {
+                    RefreshScope::Dir { path } => route_to_mount(core, mountpoint, path)
+                        .and_then(|(core, rel)| core.refresh_dir(&rel)),
+                    RefreshScope::Trash => {
+                        core.invalidate_trash();
+                        Ok(())
+                    }
+                    RefreshScope::Photos { full } if !full && core.timeline_refreshing() => {
+                        // A refresh is already running and will publish exactly the
+                        // timeline this request asks for. Doing the work again
+                        // cannot make it newer, and the invalidation plus the
+                        // album read contend with the running refresh for the
+                        // database lock — which is how a handful of stacked photo
+                        // refreshes at mount time left five control requests
+                        // in flight for twenty-three minutes.
+                        debug!("a photos refresh is already running; joining it");
+                        Ok(())
+                    }
+                    RefreshScope::Photos { full } => {
+                        core.invalidate_photos();
+                        // A full refresh is "forget what you know", not a second code
+                        // path: the ordinary refresh then finds every photo stale.
+                        if let Some(Err(e)) = full.then(|| core.db.photos_mark_all_unresolved()) {
+                            warn!(error = %e, "marking the whole timeline unresolved failed");
+                        }
+                        // Whatever changed the timeline can just as easily have
+                        // changed an album; one scope covers the whole photos view.
+                        core.invalidate_albums();
+                        // The refresh is started here, not awaited. A library of
+                        // twelve thousand photos is re-read in chunks of
+                        // `TIMELINE_ENRICH_CHUNK` nodes, which takes minutes —
+                        // longer than the client's read bound, so awaiting it
+                        // returned `Resource temporarily unavailable` to a caller
+                        // whose refresh was in fact running fine (B92). The front
+                        // end follows it with `PhotosRefreshStatus`.
+                        core.spawn_timeline_refresh();
+                        Ok(())
+                    }
+                };
+                match result {
+                    Ok(()) => CtlResponse::Ok {
+                        message: match scope {
+                            RefreshScope::Photos { .. } => "refreshing".to_string(),
+                            _ => "refreshed".to_string(),
+                        },
+                    },
+                    Err(e) => CtlResponse::error(e),
+                }
+            }
+        },
        Ok(CtlRequest::PhotosTimeline {
            offset,
            limit,
            kind,
            range,
            favorites,
-        }) => match core.photos_timeline(offset, clamp_limit(limit), kind, range, favorites) {
+            not_in_album,
+        }) => match core.photos_timeline(
+            offset,
+            clamp_limit(limit),
+            kind,
+            range,
+            favorites,
+            not_in_album,
+        ) {
            Ok(Some(items)) => CtlResponse::Photos {
                available: true,
                items,
@@ -305,6 +461,49 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
            },
            Err(e) => CtlResponse::error(e),
        },
+        Ok(CtlRequest::PhotoDuplicates) => match core.photo_duplicates() {
+            Ok(sets) => CtlResponse::PhotoDuplicates { sets },
+            Err(e) => CtlResponse::error(e),
+        },
+        Ok(CtlRequest::PhotoSimilar) => match core.photo_similar() {
+            Ok((sets, hashing, uncompared)) => CtlResponse::PhotoSimilar {
+                sets,
+                hashing,
+                uncompared,
+            },
+            Err(e) => CtlResponse::error(e),
+        },
+        Ok(CtlRequest::PhotoPlaces) => match core.photo_places() {
+            Ok(items) => CtlResponse::Places {
+                items,
+                mapping: core.timeline_progress(),
+            },
+            Err(e) => CtlResponse::error(e),
+        },
+        Ok(CtlRequest::PlacePhotos { id, offset, limit }) => {
+            match core.place_photos(id, offset, clamp_limit(limit)) {
+                Ok(items) => CtlResponse::Photos {
+                    available: true,
+                    items,
+                    counts: None,
+                },
+                Err(e) => CtlResponse::error(e),
+            }
+        }
+        Ok(CtlRequest::PlaceLocations { id }) => match core.place_locations(id) {
+            Ok(items) => CtlResponse::PhotoLocations { items },
+            Err(e) => CtlResponse::error(e),
+        },
+        Ok(CtlRequest::PhotosOnThisDay { limit }) => {
+            match core.photos_on_this_day(clamp_limit(limit)) {
+                Ok(items) => CtlResponse::Photos {
+                    available: true,
+                    items,
+                    counts: None,
+                },
+                Err(e) => CtlResponse::error(e),
+            }
+        }
        Ok(CtlRequest::PhotoGroup { uid }) => match core.photo_group(&uid) {
            Ok(items) => CtlResponse::Photos {
                available: true,
@@ -317,9 +516,9 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
            Some(node_uid) => match core.set_photo_favorite(&node_uid, favorite) {
                Ok(()) => CtlResponse::Ok {
                    message: if favorite {
-                        "added to favourites".to_string()
+                        "added to favorites".to_string()
                    } else {
-                        "removed from favourites".to_string()
+                        "removed from favorites".to_string()
                    },
                },
                Err(e) => CtlResponse::error(e),
@@ -351,6 +550,38 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
            },
            None => CtlResponse::error(CoreError::invalid(format!("bad album uid: {uid}"))),
        },
+        Ok(CtlRequest::CreateAlbum { name }) => match core.create_album(&name) {
+            Ok(uid) => CtlResponse::AlbumCreated { uid },
+            Err(e) => CtlResponse::error(e),
+        },
+        Ok(CtlRequest::RenameAlbum { uid, name }) => match parse_uid(&uid) {
+            Some(album) => match core.rename_album(&album, &name) {
+                Ok(()) => CtlResponse::Ok {
+                    message: format!("renamed album to {name}"),
+                },
+                Err(e) => CtlResponse::error(e),
+            },
+            None => CtlResponse::error(CoreError::invalid(format!("bad album uid: {uid}"))),
+        },
+        Ok(CtlRequest::DeleteAlbum { uid, delete_photos }) => match parse_uid(&uid) {
+            Some(album) => match core.delete_album(&album, delete_photos) {
+                Ok(()) => CtlResponse::Ok {
+                    message: "album deleted".to_string(),
+                },
+                Err(e) => CtlResponse::error(e),
+            },
+            None => CtlResponse::error(CoreError::invalid(format!("bad album uid: {uid}"))),
+        },
+        Ok(CtlRequest::AddToAlbum { uid, photos }) => {
+            album_change(&uid, &photos, |album, photos| {
+                core.add_to_album(album, photos)
+            })
+        }
+        Ok(CtlRequest::RemoveFromAlbum { uid, photos }) => {
+            album_change(&uid, &photos, |album, photos| {
+                core.remove_from_album(album, photos)
+            })
+        }
        Ok(CtlRequest::PhotoMonths { kind }) => match core.db.photos_months(kind) {
            Ok(months) => CtlResponse::PhotoMonths {
                months: months
@@ -366,8 +597,8 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
                items: core.photo_thumbs(&parsed),
            }
        }
-        Ok(CtlRequest::TrashNodes { uids }) => match Core::parse_uids(&uids) {
-            Ok(parsed) => match core.trash_photos(&parsed) {
+        Ok(CtlRequest::TrashNodes { uids, files_only }) => match Core::parse_uids(&uids) {
+            Ok(parsed) => match core.trash_photos(&parsed, files_only) {
                Ok((trashed, failed)) => CtlResponse::Trashed {
                    trashed,
                    failed: failed
@@ -561,7 +792,11 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
                Err(e) => CtlResponse::error(e),
            }
        }
-        Ok(CtlRequest::Search { query, limit }) => match core.search(&query, clamp_limit(limit)) {
+        Ok(CtlRequest::Search {
+            query,
+            limit,
+            scope,
+        }) => match core.search(&query, clamp_limit(limit), scope.as_deref()) {
            Ok(hits) => CtlResponse::SearchResults { hits },
            Err(e) => CtlResponse::error(e),
        },
@@ -742,9 +977,14 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
        },
        Ok(CtlRequest::EmptyTrash) => match core.empty_trash() {
            Ok(n) => {
-                core.log_activity(ActivityKind::EmptyTrash, format!("{n} item(s)"), "", true);
+                let items = if n == 1 {
+                    "1 item".to_string()
+                } else {
+                    format!("{n} items")
+                };
+                core.log_activity(ActivityKind::EmptyTrash, items.clone(), "", true);
                CtlResponse::Ok {
-                    message: format!("emptied trash ({n} item(s))"),
+                    message: format!("emptied trash ({items})"),
                }
            }
            Err(e) => CtlResponse::error(e),
@@ -824,6 +1064,29 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
                ))),
            }
        }
+        Ok(CtlRequest::SetBandwidthLimits { upload, download }) => {
+            core.transfers.set_limits(upload, download);
+            // Persisted like the cache budget: best-effort, the live caps are
+            // already applied.
+            match AppDirs::new().map(|dirs| {
+                let mut cfg = dirs.load_config();
+                cfg.upload_limit = Some(upload);
+                cfg.download_limit = Some(download);
+                dirs.save_config(&cfg)
+            }) {
+                Ok(Ok(())) => CtlResponse::Ok {
+                    message: format!(
+                        "bandwidth limits set to {upload} B/s up, {download} B/s down"
+                    ),
+                },
+                Ok(Err(e)) => CtlResponse::error(CoreError::internal(format!(
+                    "limits applied but config write failed: {e}"
+                ))),
+                Err(e) => CtlResponse::error(CoreError::internal(format!(
+                    "limits applied but config unavailable: {e}"
+                ))),
+            }
+        }
        Ok(CtlRequest::ListDevices) => match core.list_devices() {
            Ok(items) => CtlResponse::Devices { items },
            Err(e) => CtlResponse::error(e),
@@ -907,6 +1170,17 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
                Err(e) => CtlResponse::error(e),
            }
        }
+        Ok(CtlRequest::SetSyncFolderPaused { id, paused }) => {
+            match core.set_sync_folder_paused(id, paused) {
+                Ok(()) => CtlResponse::Ok {
+                    message: match paused {
+                        true => format!("folder {id} paused"),
+                        false => format!("folder {id} resumed"),
+                    },
+                },
+                Err(e) => CtlResponse::error(e),
+            }
+        }
        Ok(CtlRequest::SyncNow { id }) => {
            core.sync_now(id);
            CtlResponse::Ok {
@@ -916,22 +1190,77 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
                },
            }
        }
-        Ok(CtlRequest::ListRestorableFolders) => match core.list_restorable_folders() {
+        Ok(CtlRequest::SetSyncPaused { paused, until }) => {
+            match core.set_sync_paused(paused, until) {
+                Ok(()) => CtlResponse::Ok {
+                    message: match (paused, until) {
+                        (false, _) => "sync resumed".to_string(),
+                        (true, None) => "sync paused until resumed".to_string(),
+                        (true, Some(_)) => "sync paused".to_string(),
+                    },
+                },
+                Err(e) => CtlResponse::error(e),
+            }
+        }
+        Ok(CtlRequest::ListConflicts) => match core.list_conflicts() {
+            Ok(items) => CtlResponse::Conflicts { items },
+            Err(e) => CtlResponse::error(e),
+        },
+        Ok(CtlRequest::ResolveConflict { path, keep }) => {
+            match route_conflict(core, mountpoint, &path) {
+                Ok((core, rel)) => match core.resolve_conflict(&rel, &keep) {
+                    Ok(message) => CtlResponse::Ok { message },
+                    Err(e) => CtlResponse::error(e),
+                },
+                Err(e) => CtlResponse::error(e),
+            }
+        }
+        Ok(CtlRequest::ListPendingOps) => match core.pending_op_infos() {
+            Ok(items) => CtlResponse::PendingOps { items },
+            Err(e) => CtlResponse::error(e),
+        },
+        Ok(CtlRequest::RetryPendingOp { id }) => match core.retry_pending_ops(id) {
+            Ok(0) if id.is_some() => CtlResponse::Ok {
+                message: "nothing to retry: the operation is already due or waiting for a rename"
+                    .to_string(),
+            },
+            Ok(moved) => CtlResponse::Ok {
+                message: format!("retrying {moved} queued operation(s) now"),
+            },
+            Err(e) => CtlResponse::error(e),
+        },
+        Ok(CtlRequest::ListRestorableFolders) => match core.list_restorable_folders(None) {
            Ok(items) => CtlResponse::RestorableFolders { items },
            Err(e) => CtlResponse::error(e),
        },
-        Ok(CtlRequest::RestoreSyncFolders { items }) => {
+        Ok(CtlRequest::ListDeviceRestorableFolders { device }) => {
+            match core.list_restorable_folders(Some(&device)) {
+                Ok(items) => CtlResponse::RestorableFolders { items },
+                Err(e) => CtlResponse::error(e),
+            }
+        }
+        Ok(
+            request @ (CtlRequest::RestoreSyncFolders { .. }
+            | CtlRequest::RestoreDeviceFolders { .. }),
+        ) => {
+            let (device, items) = match request {
+                CtlRequest::RestoreDeviceFolders { device, items } => (Some(device), items),
+                CtlRequest::RestoreSyncFolders { items } => (None, items),
+                _ => unreachable!("matched above"),
+            };
            // Like AddSyncFolder: each restored folder downloads a whole tree,
            // which outlasts the socket timeout. Ack, then work.
            let core = core.clone();
-            std::thread::spawn(move || match core.restore_sync_folders(&items) {
-                Ok(message) => {
-                    core.touch_profile();
-                    core.log_activity(ActivityKind::Download, &message, "", true);
-                }
-                Err(e) => {
-                    warn!(error = %e, "restore failed");
-                    core.log_activity(ActivityKind::Download, "restore folders", &e, false);
+            std::thread::spawn(move || {
+                match core.restore_sync_folders(&items, device.as_deref()) {
+                    Ok(message) => {
+                        core.touch_profile();
+                        core.log_activity(ActivityKind::Download, &message, "", true);
+                    }
+                    Err(e) => {
+                        warn!(error = %e, "restore failed");
+                        core.log_activity(ActivityKind::Download, "restore folders", &e, false);
+                    }
                }
            });
            CtlResponse::Ok {
@@ -1102,6 +1431,13 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
                Err(e) => CtlResponse::error(e),
            }
        }
+        Ok(CtlRequest::StopSharing { path }) => match rel_to_mount(mountpoint, &path) {
+            Ok(rel) => stop_sharing_reply(core, &path, core.stop_sharing(&rel)),
+            Err(e) => CtlResponse::error(e),
+        },
+        Ok(CtlRequest::StopSharingByUid { uid }) => {
+            stop_sharing_reply(core, &uid, core.stop_sharing_by_uid(&uid))
+        }
        Ok(CtlRequest::ListRevisions { path }) => match rel_to_mount(mountpoint, &path) {
            Ok(rel) => match core.list_revisions(&rel) {
                Ok(items) => CtlResponse::Revisions { items },
@@ -1370,3 +1706,28 @@ mod request_limit_tests {
        assert!(rel_to_mount(mountpoint, "/mnt/elsewhere").is_err());
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Two refreshes of the same scope are one piece of work; two refreshes of
+    /// different scopes are not.
+    #[test]
+    fn a_scope_refreshes_once_at_a_time() {
+        let photos = RefreshScope::Photos { full: false };
+        let held = RefreshGuard::acquire(&photos).expect("first refresh runs");
+        assert!(RefreshGuard::acquire(&photos).is_none());
+        // A full refresh forgets what the daemon knows, so it is other work.
+        assert!(RefreshGuard::acquire(&RefreshScope::Photos { full: true }).is_some());
+        assert!(
+            RefreshGuard::acquire(&RefreshScope::Dir {
+                path: "a".to_string()
+            })
+            .is_some()
+        );
+
+        drop(held);
+        assert!(RefreshGuard::acquire(&photos).is_some());
+    }
+}
@@ -128,6 +128,7 @@ impl Core {
            location.mounted = self.states.is_mounted_at(Path::new(&location.local_path));
            if let MountKind::Device { sync_folder_id } = &location.kind {
                location.progress = progress.get(sync_folder_id).cloned();
+                location.paused = self.sync_folder_paused(*sync_folder_id);
            }
        }
        Ok(locations)
@@ -226,6 +227,39 @@ impl Core {
        Ok(format!("adopted device {name}"))
    }

+    /// The device a restore reads from: this machine's own for `None`, else
+    /// the registered device with that uid.
+    ///
+    /// Another device is looked up without touching the cached device row —
+    /// restoring its folders here must not make this machine back up as it.
+    /// Its folders are then attached with that device's share id, so they sync
+    /// against the other computer's tree.
+    pub(crate) fn restore_source(&self, device: Option<&str>) -> CoreResult<StoredDevice> {
+        let Some(uid) = device else {
+            return self.ensure_device();
+        };
+        let remote = self
+            .rt
+            .block_on(self.client.enumerate_devices())
+            .map_err(|e| CoreError::from_api(&e, "enumerate devices"))?;
+        let d = remote
+            .into_iter()
+            .find(|d| d.uid.to_string() == uid)
+            .ok_or_else(|| CoreError::not_found(format!("no device {uid} in this account")))?;
+        Ok(StoredDevice {
+            uid: d.uid.to_string(),
+            share_id: d.share_id.to_string(),
+            root_uid: d.root_folder_uid.to_string(),
+            name: d
+                .name
+                .as_deref()
+                .ok()
+                .unwrap_or("(unnamed device)")
+                .to_string(),
+            created: d.creation_time,
+        })
+    }
+
    // ---- device folder sync (devices.md, Phase 1) -------------------------

    /// Auto-register (or recover) this machine as a Proton Drive Device, caching
@@ -448,7 +482,8 @@ impl Core {
            .into_iter()
            .map(|f| {
                let live = progress.get(&f.id).cloned();
-                sync_folder_info(f, live)
+                let paused = self.sync_folder_paused(f.id);
+                sync_folder_info(f, live, paused)
            })
            .collect())
    }
@@ -561,6 +596,7 @@ impl Core {
            return Err(CoreError::invalid(format!("no synced folder with id {id}")));
        }
        drop(_guard);
+        self.clear_sync_folder_paused(id);
        // Stop watching the folder we just dropped.
        let _ = self.sync_tx.send(sync::SyncMsg::Rewatch);
        if delete_remote
@@ -625,6 +661,13 @@ impl Core {
            .ok_or_else(|| CoreError::not_found(format!("no synced folder with id {id}")))?;
        let current_mode = ApplicableMountMode::parse(&folder.mode)
            .map_err(|error| CoreError::invalid(format!("unsupported current mode: {error}")))?;
+        // A switch waits on the folder's reconcile, which a pause skips; refuse
+        // it up front rather than queue it indefinitely.
+        if current_mode != target_mode && self.sync_folder_paused(id) {
+            return Err(CoreError::invalid(
+                "this folder is paused; resume it before changing its mode",
+            ));
+        }
        if current_mode == target_mode {
            let mode_str = target_mode.as_str();
            let lock = self.sync_lock(id);
@@ -73,7 +73,29 @@ pub(crate) fn request_kind(line: &str) -> String {
        line.strip_prefix('"')
            .and_then(|rest| rest.split('"').next())
    };
-    name.unwrap_or("unknown").to_string()
+    let name = name.unwrap_or("unknown");
+    // A bare `Refresh` says nothing about which view wedged, and the three
+    // scopes cost wildly different amounts of work: a directory refresh is two
+    // cheap calls, a photos refresh can pull a whole library. The scope is one
+    // more peek into the same line.
+    if name == "Refresh"
+        && let Some(scope) = tagged_name_after(line, "\"scope\"")
+    {
+        return format!("Refresh({scope})");
+    }
+    name.to_string()
+}
+
+/// The variant name serde wrote for the value of `key`, whether that value is a
+/// bare string (a unit variant) or an object whose single key is the name.
+fn tagged_name_after(line: &str, key: &str) -> Option<String> {
+    let rest = line.split_once(key)?.1.trim_start();
+    let rest = rest.strip_prefix(':')?.trim_start();
+    let rest = rest.strip_prefix('{').map_or(rest, str::trim_start);
+    rest.strip_prefix('"')?
+        .split('"')
+        .next()
+        .map(str::to_string)
 }

 /// Resident set size in bytes, or `0` when `/proc` did not answer.
@@ -181,6 +203,26 @@ mod tests {
        assert_eq!(request_kind("garbage"), "unknown");
    }

+    /// A stuck `Refresh` is only actionable if the report says which view it
+    /// was refreshing, so the scope rides along with the name.
+    #[test]
+    fn a_refresh_reports_its_scope() {
+        assert_eq!(
+            request_kind("{\"Refresh\":{\"scope\":{\"Photos\":{\"full\":true}}}}"),
+            "Refresh(Photos)"
+        );
+        assert_eq!(
+            request_kind("{\"Refresh\":{\"scope\":{\"Dir\":{\"path\":\"a\"}}}}"),
+            "Refresh(Dir)"
+        );
+        assert_eq!(
+            request_kind("{\"Refresh\":{\"scope\":\"Trash\"}}"),
+            "Refresh(Trash)"
+        );
+        // A shape this does not recognise still names the request.
+        assert_eq!(request_kind("{\"Refresh\":{}}"), "Refresh");
+    }
+
    /// A guard registers for its lifetime and nothing longer: a handler that
    /// returns must not leave a permanent "in flight" entry behind.
    #[test]
@@ -33,7 +33,9 @@ use futures::StreamExt;
 use pdfs_core::batch;
 use pdfs_core::cache::{Baseline, StagedWrite};
 use pdfs_core::control::{ActivityKind, TransferDirection};
-use pdfs_core::db::{OP_CREATE, OP_MKDIR, OP_RENAME, OP_REVISION, OP_TRASH, PendingOp, RenameMeta};
+use pdfs_core::db::{
+    OP_CREATE, OP_MKDIR, OP_RENAME, OP_REVISION, OP_TRASH, PARK_EXPIRY_MS, PendingOp, RenameMeta,
+};
 use proton_drive_rs::proton_sdk::error::ProtonError;
 use proton_drive_rs::proton_sdk::ids::NodeUid;
 use proton_drive_rs::{Node, NodeMoveItem};
@@ -283,8 +285,9 @@ impl Core {
                }
            };
            let online = self.online.load(Ordering::Relaxed);
+            let paused = self.sync_paused();
            let op = match due {
-                Some(op) if online => op,
+                Some(op) if online && !paused => op,
                idle => {
                    // Claimed but offline: hand it straight back, or it stays
                    // invisible to every worker until this one happens to be
@@ -299,6 +302,18 @@ impl Core {
                        // Cheap and a no-op when empty.
                        self.cache.flush_touches();
                        self.recover_fsynced_writes();
+                        // Parked rows are invisible to `claim_next_due_op`, so
+                        // an idle queue is exactly when a park that has outlived
+                        // its writer has to be noticed.
+                        self.sweep_parked_creates();
+                    }
+                    // Paused, nothing due changes that: sleep until a resume
+                    // wakes the worker (or the idle poll notices a timed pause
+                    // ran out), not until the next op falls due — that is
+                    // "now" for everything already queued.
+                    if paused {
+                        self.wait_for_drain_work();
+                        continue;
                    }
                    // A debounced or backed-off op may be waiting: sleep only
                    // until it becomes due rather than the full idle-poll.
@@ -930,6 +945,7 @@ impl Core {
        if !meta.complete {
            return Err("queued create holds an incomplete blob".into());
        }
+        let thumbnails = self.upload_thumbnails(Path::new(blob), name);
        let guard = self
            .transfers
            .begin(name, op.uid.clone(), TransferDirection::Upload, meta.len);
@@ -940,7 +956,7 @@ impl Core {
            media_type_for(name),
            reader,
            meta.len as i64,
-            Vec::new(),
+            thumbnails,
            None,
            false,
        ))?;
@@ -1130,6 +1146,7 @@ impl Core {
        }

        let alt = conflict_name(&name, now_secs());
+        let thumbnails = self.upload_thumbnails(blob, &alt);
        let guard =
            self.transfers
                .begin(&alt, meta.uid.clone(), TransferDirection::Upload, meta.len);
@@ -1140,7 +1157,7 @@ impl Core {
            media_type_for(&alt),
            reader,
            meta.len as i64,
-            Vec::new(),
+            thumbnails,
            None,
            false,
        ))?;
@@ -1201,6 +1218,101 @@ impl Core {
        Ok(())
    }

+    /// Whether any mount still holds an open handle on `uid`.
+    ///
+    /// A transient file that is still open is still being written, however long
+    /// it has been parked, and the rename that finishes it has not happened yet.
+    fn uid_is_open(&self, uid: &NodeUid) -> bool {
+        let mut open = false;
+        self.for_each_state(|st| {
+            if open {
+                return;
+            }
+            open = st
+                .by_uid
+                .get(uid)
+                .and_then(|ino| st.entries.get(ino))
+                .is_some_and(|entry| entry.open_count > 0);
+        });
+        open
+    }
+
+    /// Retire parks that are never going to end (docs/BUGS.md B70).
+    ///
+    /// A parked create waits for one event: the rename from the transient name
+    /// to the finished one. Nothing else ever un-parks it, and plenty of writers
+    /// never perform it — an editor unlinks its swap file, a download is
+    /// abandoned, or the file was always going to be called `index.tmp`. Such a
+    /// row stayed at [`PARK_UNTIL`] for the life of the database, pinning the
+    /// only copy of its bytes in `staging/` and counting against the queue.
+    ///
+    /// Two outcomes, and neither deletes bytes a user can still see:
+    ///
+    /// * The node is gone from the tree — the file was deleted while its create
+    ///   was parked, so the create is no longer wanted. The op and its blob go,
+    ///   which is what [`Core::discard_queued_ops`] would have done had the
+    ///   delete path reached it.
+    /// * The node is still there and has been parked past
+    ///   [`PARK_EXPIRY_MS`] with nothing holding it open — the park has outlived
+    ///   the writer it was protecting. Un-park it, and the ordinary drain
+    ///   uploads it like any other create.
+    ///
+    /// An open node is left alone whatever its age: it is still being written.
+    fn sweep_parked_creates(&self) {
+        let parked = match self.db.parked_create_ops() {
+            Ok(parked) if !parked.is_empty() => parked,
+            Ok(_) => return,
+            Err(error) => {
+                warn!(%error, "reading parked creates failed; skipping the park sweep");
+                return;
+            }
+        };
+        let now = now_millis();
+        let (mut released, mut dropped) = (0usize, 0usize);
+        for op in &parked {
+            let Some(uid) = parse_node_uid(&op.uid) else {
+                continue;
+            };
+            let name = op.name.as_deref().unwrap_or("?");
+            let known = match self.db.node_by_uid(&op.uid) {
+                Ok(known) => known.is_some(),
+                // Never infer "deleted" from a failed read: that would discard
+                // the bytes over a transient database error.
+                Err(error) => {
+                    debug!(%uid, %error, "cannot tell whether a parked node still exists");
+                    continue;
+                }
+            };
+            if !known {
+                if let Err(error) = self.discard_queued_ops(&uid) {
+                    warn!(%uid, name, ?error, "dropping a deleted transient's parked create failed");
+                    continue;
+                }
+                dropped += 1;
+                debug!(%uid, name, "dropped a parked create whose file was deleted");
+                continue;
+            }
+            if park_verdict(op.created_at, now, self.uid_is_open(&uid)) != ParkVerdict::Release {
+                continue;
+            }
+            match self.db.set_create_hold(&op.uid, false) {
+                Ok(true) => {
+                    released += 1;
+                    info!(%uid, name, parked_ms = now - op.created_at,
+                          "un-parked a transient create that was never renamed; uploading it");
+                }
+                Ok(false) => {}
+                Err(error) => warn!(%uid, name, %error, "un-parking an expired park failed"),
+            }
+        }
+        if released > 0 || dropped > 0 {
+            info!(released, dropped, "swept parked creates");
+        }
+        if released > 0 {
+            self.wake_drain();
+        }
+    }
+
    /// Drop `uid`'s pending entry, but only while it still names `blob`.
    ///
    /// A supersede can replace the entry while the op that owned it is in
@@ -1328,6 +1440,7 @@ impl Core {
        }

        let name = self.node_name(&uid);
+        let thumbnails = self.upload_thumbnails(&blob, &name);
        let guard =
            self.transfers
                .begin(&name, meta.uid.clone(), TransferDirection::Upload, meta.len);
@@ -1341,7 +1454,7 @@ impl Core {
            &uid,
            reader,
            meta.len as i64,
-            Vec::new(),
+            thumbnails,
            None,
        ));
        let took = started.elapsed();
@@ -1573,6 +1686,24 @@ fn is_own_self_supersede(complete: bool, remote_rev: Option<&str>, own_rev: Opti
    complete && remote_rev.is_some() && remote_rev == own_rev
 }

+/// What the park sweep does with one parked create whose node still exists.
+#[derive(Debug, PartialEq, Eq)]
+enum ParkVerdict {
+    /// Leave it parked: the rename it waits for can still come.
+    Keep,
+    /// Un-park it: nothing will rename it now, so the bytes go up as they are.
+    Release,
+}
+
+/// Judge one parked create by age alone. An open node is kept whatever its age
+/// — it is still being written, and the rename is the writer's last step.
+fn park_verdict(created_at: i64, now: i64, open: bool) -> ParkVerdict {
+    if open || now - created_at < PARK_EXPIRY_MS {
+        return ParkVerdict::Keep;
+    }
+    ParkVerdict::Release
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -1598,6 +1729,28 @@ mod tests {
        }
    }

+    /// The park's only ordinary exit is the transient-to-final rename. The
+    /// sweep is what happens when that rename never comes.
+    #[test]
+    fn a_park_expires_only_once_it_is_old_and_nobody_holds_the_file() {
+        let now = PARK_EXPIRY_MS * 10;
+        // Fresh: the writer may still rename it.
+        assert_eq!(
+            park_verdict(now - PARK_EXPIRY_MS + 1, now, false),
+            ParkVerdict::Keep
+        );
+        // Old, but still open: a slow write is not an abandoned one.
+        assert_eq!(
+            park_verdict(now - PARK_EXPIRY_MS, now, true),
+            ParkVerdict::Keep
+        );
+        // Old and closed: no rename is coming.
+        assert_eq!(
+            park_verdict(now - PARK_EXPIRY_MS, now, false),
+            ParkVerdict::Release
+        );
+    }
+
    #[test]
    fn drain_authorities_match_each_operation_kind() {
        for kind in [OP_REVISION, OP_TRASH] {
@@ -42,7 +42,7 @@ use std::os::unix::net::UnixListener;
 use std::path::{Component, Path, PathBuf};
 use std::sync::Arc;
 use std::sync::OnceLock;
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64, Ordering};
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};

 use fuser::ReplyXattr;
@@ -80,6 +80,7 @@ use proton_drive_rs::{

 mod albums;
 mod background;
+mod conflicts;
 mod control;
 use control::run_control_socket;
 mod devices;
@@ -88,8 +89,10 @@ mod drain;
 mod filesystem;
 pub use filesystem::ProtonFs;
 mod mount;
+mod pause;
 mod photos;
 mod profile;
+mod queue;
 mod reads;
 mod redate;
 mod revisions;
@@ -197,6 +200,22 @@ const UPLOAD_TIME_MEMORY: usize = 512;
 /// for the SDK's own per-request concurrency.
 const DRAIN_WORKERS: usize = 3;

+/// How long a staged blob that names no node is kept before it is retired.
+///
+/// Staging is exempt from the cache budget because it holds the only copy of
+/// writes that have not been uploaded, so nothing there is ever evicted to
+/// reclaim space. That is right for a blob that still describes something. It is
+/// wrong for one whose sidecar is missing or names a `local~` placeholder whose
+/// create is gone: no future run can address it, no UI accounts for it, and it
+/// occupies disk for the life of the machine. Real instance: 95 such blobs,
+/// ~445 MiB, the oldest two months old, re-announced on every mount.
+///
+/// A month is far longer than any transfer or any plausible "I will look at that
+/// later", and the retirement is announced per blob with its size, so the one
+/// case that matters — bytes a human still wants — has a month of warnings and a
+/// path to go and fetch them from.
+const STAGING_ORPHAN_RETAIN: Duration = Duration::from_secs(30 * 24 * 60 * 60);
+
 const ONLINE_PROBE_MIN: Duration = Duration::from_secs(5);
 const ONLINE_PROBE_MAX: Duration = Duration::from_secs(300);
 /// How long the persisted photos timeline stays good before a page request
@@ -492,6 +511,10 @@ struct Core {
    /// `Response::Status` so the UI can say so rather than leaving the user to
    /// infer it from a wall of EIO.
    online: Arc<AtomicBool>,
+    /// When the user paused syncing, the Unix second it resumes by itself;
+    /// [`pause::PAUSED_INDEFINITELY`] for "until resumed", `0` when not paused.
+    /// Persisted, so a pause survives a restart (see [`Core::sync_paused`]).
+    sync_paused_until: Arc<AtomicI64>,
    /// Writes accepted from the kernel but not yet uploaded, keyed by node
    /// (offline.md Phase 3). The in-memory face of the `pending_op` table, from
    /// which it is rebuilt on mount.
@@ -527,17 +550,25 @@ struct Core {
    /// already running, so a burst of page requests against a stale listing kicks
    /// off one refresh rather than one per request.
    timeline_refreshing: Arc<AtomicBool>,
+    /// How far the running timeline refresh has got resolving photo metadata,
+    /// as `(done, total)` photos; `None` when no refresh is resolving any. The
+    /// Places view shows it while a library's locations are first read.
+    timeline_progress: Arc<Mutex<Option<(usize, usize)>>>,
    /// The same, for the album listing.
    albums_refreshing: Arc<AtomicBool>,
    trash_refreshing: Arc<AtomicBool>,
+    /// True while the similar-photo pass hashes thumbnails (see
+    /// [`Core::photo_similar`]), so asking again doesn't start a second one.
+    similar_hashing: Arc<AtomicBool>,
    /// Fires whenever a trash refresh persists a batch or finishes, so a
    /// `ListTrash` request waiting on a first-ever refresh wakes on progress
    /// instead of polling or blocking for the whole run. See
    /// [`Core::await_trash_refresh`].
    trash_progress: Arc<tokio::sync::Notify>,
-    /// Conflict copies the sweep has already flagged as needing attention this
-    /// run, so a divergent `(sync-conflict …)` file is logged once rather than
-    /// on every sweep pass. See [`Core::run_conflict_sweep_loop`].
+    /// Conflict copies the sweep has already checked against the activity log
+    /// this run, so each pass does not ask the database again. The log itself
+    /// is what keeps a copy from being flagged again after a restart. See
+    /// [`Core::run_conflict_sweep_loop`] and `docs/BUGS.md` B99.
    conflict_notified: Arc<Mutex<HashSet<NodeUid>>>,
    /// Whether the conflict sweep may actually trash the duplicates it finds, or
    /// only report them. Resolved once at mount from config + environment
@@ -1394,6 +1425,15 @@ fn release_must_retain_queued_trash(db: &Db, uid: &NodeUid) -> pdfs_core::Result
    db.has_pending_op(&uid.to_string(), OP_TRASH)
 }

+/// The size of a staged blob that has outlived [`STAGING_ORPHAN_RETAIN`], or
+/// `None` while it is younger than that — or while its age cannot be read at
+/// all, which is never grounds for deleting bytes.
+fn orphan_past_retention(blob: &Path) -> Option<u64> {
+    let meta = std::fs::metadata(blob).ok()?;
+    let age = meta.modified().ok()?.elapsed().ok()?;
+    (age >= STAGING_ORPHAN_RETAIN).then_some(meta.len())
+}
+
 fn release_can_discard_unlinked(db: &Db, uid: &NodeUid) -> bool {
    match release_must_retain_queued_trash(db, uid) {
        Ok(retain) => !retain,
@@ -1718,6 +1758,9 @@ impl Core {
        };
        let mut queued = 0usize;
        let mut stranded = 0usize;
+        let mut retired = 0usize;
+        let mut retired_bytes = 0u64;
+        let mut example: Option<PathBuf> = None;
        for (blob, meta) in staged {
            if claimed.contains(&blob.to_string_lossy().into_owned()) {
                continue;
@@ -1725,9 +1768,17 @@ impl Core {
            let addressable = meta.as_ref().and_then(|m| parse_node_uid(&m.uid));
            let Some((meta, uid)) = meta.zip(addressable).filter(|(_, uid)| !is_local_uid(uid))
            else {
+                if let Some(bytes) = orphan_past_retention(&blob) {
+                    retired += 1;
+                    retired_bytes += bytes;
+                    warn!(blob = %blob.display(), bytes,
+                          age_days = STAGING_ORPHAN_RETAIN.as_secs() / 86_400,
+                          "retiring staged bytes that name no node and have outlived retention");
+                    self.cache.discard_staged(&blob);
+                    continue;
+                }
                stranded += 1;
-                warn!(blob = %blob.display(),
-                      "staged bytes belong to no queued upload and name no node; kept for recovery");
+                example.get_or_insert_with(|| blob.clone());
                continue;
            };
            if self.pending.lock().contains_key(&uid) {
@@ -1773,8 +1824,21 @@ impl Core {
                }
            }
        }
-        if queued > 0 || stranded > 0 {
-            info!(queued, stranded, "reconciled orphaned staged writes");
+        if stranded > 0 {
+            // One line, not one per blob. A tree of them says exactly as much as
+            // a single count and an example does, and said it on every mount:
+            // 86 identical warnings for the same 86 files, boot after boot.
+            warn!(
+                count = stranded,
+                example = %example.map(|b| b.display().to_string()).unwrap_or_default(),
+                "staged bytes belong to no queued upload and name no node; kept for recovery"
+            );
+        }
+        if queued > 0 || stranded > 0 || retired > 0 {
+            info!(
+                queued,
+                stranded, retired, retired_bytes, "reconciled orphaned staged writes"
+            );
        }
    }

@@ -3801,10 +3865,25 @@ impl Core {
    /// Full-text search node names against the local SQLite index, mapping each
    /// DB hit to the wire [`SearchHit`] (resolving live pin state from the cache,
    /// which the DB doesn't track). Pure local lookup — never hits the network.
-    fn search(&self, query: &str, limit: usize) -> CoreResult<Vec<SearchHit>> {
+    /// Every pin, with `cached` saying whether a pinned file's content is on
+    /// disk, so a front-end listing pins can badge them without a round-trip
+    /// per file.
+    fn list_pins(&self) -> Vec<pdfs_core::cache::Pin> {
+        let mut pins = self.cache.list_pins();
+        for pin in pins.iter_mut().filter(|pin| pin.is_dir == Some(false)) {
+            if let Ok(Some(node)) = self.db.node_by_uid(&pin.uid) {
+                pin.cached =
+                    self.cache
+                        .is_cached(&node.uid, node.modification_time, node_size(&node));
+            }
+        }
+        pins
+    }
+
+    fn search(&self, query: &str, limit: usize, scope: Option<&str>) -> CoreResult<Vec<SearchHit>> {
        let hits = self
            .db
-            .search(query, limit)
+            .search_in(query, limit, scope)
            .map_err(|e| CoreError::from_api(&e, "search"))?;
        let roots = self.search_roots();
        let pinned = self.pinned_set();
@@ -3816,6 +3895,12 @@ impl Core {
                size: node_size(&h.node),
                modified: h.node.modification_time,
                pinned: pinned.contains(&h.node.uid.to_string()),
+                cached: !h.node.is_folder()
+                    && self.cache.is_cached(
+                        &h.node.uid,
+                        h.node.modification_time,
+                        node_size(&h.node),
+                    ),
                uid: h.node.uid.to_string(),
                mounted_path: roots.resolve(&h.path),
                path: h.path,
@@ -3883,6 +3968,12 @@ impl Core {
                        size: node_size(&hit.node),
                        modified: hit.node.modification_time,
                        pinned: is_pinned,
+                        cached: !hit.node.is_folder()
+                            && self.cache.is_cached(
+                                &hit.node.uid,
+                                hit.node.modification_time,
+                                node_size(&hit.node),
+                            ),
                        uid,
                        mounted_path: roots.resolve(&hit.path),
                        path: hit.path,
@@ -5085,7 +5176,11 @@ fn evict_dir_contents(dir: &Path) -> std::io::Result<()> {

 /// Convert a stored synced folder into its wire form for the front-ends, with
 /// the live progress of its pass when one is running.
-fn sync_folder_info(f: StoredSyncFolder, progress: Option<SyncProgress>) -> SyncFolderInfo {
+fn sync_folder_info(
+    f: StoredSyncFolder,
+    progress: Option<SyncProgress>,
+    paused: bool,
+) -> SyncFolderInfo {
    SyncFolderInfo {
        id: f.id,
        local_path: f.local_path,
@@ -5095,6 +5190,7 @@ fn sync_folder_info(f: StoredSyncFolder, progress: Option<SyncProgress>) -> Sync
        state: f.state,
        last_sync: f.last_sync,
        progress,
+        paused,
    }
 }

@@ -6124,14 +6220,64 @@ mod tests {
        Access, AccessFlags, Errno, HashMap, Intervals, PendingRevision, RootListingSnapshot,
        SELF_CHANGE_TTL_MS, ShareId, SharedWithMeItem, StateRegistry, VirtualRootPlan,
        accepted_share_provenance, conflict_name, copy_pending_for_truncate, expand_restore,
-        fuse_name, is_stale_mount, node_visible, note_self_change, parse_node_uid,
-        prepare_shared_roots, preserve_on_access_denied, publish_virtual_root_in_listing,
-        reconcile_virtual_root_in_listing, release_can_discard_unlinked,
-        release_must_retain_queued_trash, release_unlinked_entry, rename_needs_queue,
-        require_node_parent_access, require_rename_access, resolve_anywhere_with,
-        shared_with_me_uid, take_self_change, uid_write_authority, virtual_node,
+        fuse_name, is_stale_mount, node_visible, note_self_change, orphan_past_retention,
+        parse_node_uid, prepare_shared_roots, preserve_on_access_denied,
+        publish_virtual_root_in_listing, reconcile_virtual_root_in_listing,
+        release_can_discard_unlinked, release_must_retain_queued_trash, release_unlinked_entry,
+        rename_needs_queue, require_node_parent_access, require_rename_access,
+        resolve_anywhere_with, shared_with_me_uid, take_self_change, uid_write_authority,
+        virtual_node,
    };
    use super::{Db, WriteAuthority};
+    use std::time::Duration;
+
+    /// Staged bytes that name no node are kept for a month, because the only
+    /// copy of a write must outlive the bug that stranded it. Past that, one
+    /// boot retires them instead of re-announcing them every boot forever.
+    #[test]
+    fn a_stranded_blob_is_retired_only_once_it_outlives_retention() {
+        let dir = std::env::temp_dir().join(format!("pdfs-orphan-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let blob = dir.join("blob");
+        std::fs::write(&blob, b"twelve bytes").unwrap();
+
+        // Written just now: still recoverable, still kept.
+        assert_eq!(orphan_past_retention(&blob), None);
+
+        set_mtime_ago(
+            &blob,
+            super::STAGING_ORPHAN_RETAIN + Duration::from_secs(60),
+        );
+        assert_eq!(orphan_past_retention(&blob), Some(12));
+
+        // A blob that is not there is not a blob to retire.
+        std::fs::remove_file(&blob).unwrap();
+        assert_eq!(orphan_past_retention(&blob), None);
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    /// Backdate a file's mtime, which is what the retention check reads.
+    fn set_mtime_ago(path: &std::path::Path, ago: Duration) {
+        let when = std::time::SystemTime::now() - ago;
+        let secs = when
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs() as libc::time_t;
+        let times = [
+            libc::timeval {
+                tv_sec: secs,
+                tv_usec: 0,
+            },
+            libc::timeval {
+                tv_sec: secs,
+                tv_usec: 0,
+            },
+        ];
+        let c_path = std::ffi::CString::new(path.as_os_str().as_encoded_bytes()).unwrap();
+        // SAFETY: both pointers are valid for the call and nothing keeps them.
+        let rc = unsafe { libc::utimes(c_path.as_ptr(), times.as_ptr()) };
+        assert_eq!(rc, 0, "utimes: {}", std::io::Error::last_os_error());
+    }

    /// `(uid, parent)` pairs in the shape [`Db::trash_parents`] returns.
    fn relations(pairs: &[(&str, Option<&str>)]) -> Vec<(String, Option<String>)> {
@@ -241,6 +241,9 @@ pub struct MountOptions {
    pub username: String,
    /// What the background conflict sweep may do. See `docs/BUGS.md` B71.
    pub sweep_mode: SweepMode,
+    /// Upload and download caps in bytes per second (`0` = no cap).
+    pub upload_limit: u64,
+    pub download_limit: u64,
 }

 /// Spawn one FUSE session rooted at an arbitrary remote node.
@@ -340,6 +343,8 @@ pub fn mount(
    let MountOptions {
        username,
        sweep_mode,
+        upload_limit,
+        download_limit,
    } = options;
    // Start the uptime clock here rather than at the first `pdfs diagnostics`,
    // so the age it reports is the daemon's own.
@@ -357,6 +362,7 @@ pub fn mount(
    // handlers can trigger reconciles.
    let (sync_tx, sync_rx) = std::sync::mpsc::channel::<sync::SyncMsg>();

+    let paused_until = pause::load_paused_until(&db);
    let core = Core {
        client: client.clone(),
        rt: rt.clone(),
@@ -377,6 +383,7 @@ pub fn mount(
        shared_generation: Arc::new(AtomicU64::new(0)),
        shared_refresh_deadlines: Arc::new(Mutex::new(SharedRefreshDeadlines::default())),
        online: Arc::new(AtomicBool::new(online)),
+        sync_paused_until: Arc::new(AtomicI64::new(paused_until)),
        pending: Arc::new(Mutex::new(HashMap::new())),
        hidden: Arc::new(Mutex::new(HashSet::new())),
        drain_wake: Arc::new((Mutex::new(false), Condvar::new())),
@@ -384,6 +391,8 @@ pub fn mount(
        upload_times: Arc::new(Mutex::new(HashMap::new())),
        upload_cancel: Arc::new(Mutex::new(HashMap::new())),
        timeline_refreshing: Arc::new(AtomicBool::new(false)),
+        timeline_progress: Arc::new(Mutex::new(None)),
+        similar_hashing: Arc::new(AtomicBool::new(false)),
        albums_refreshing: Arc::new(AtomicBool::new(false)),
        trash_refreshing: Arc::new(AtomicBool::new(false)),
        trash_progress: Arc::new(tokio::sync::Notify::new()),
@@ -417,6 +426,7 @@ pub fn mount(
    // Before anything can queue work against it: the drain thread below reaches
    // every mount's inode space through this registry, not through `core.state`.
    core.register_state(mountpoint);
+    core.transfers.set_limits(upload_limit, download_limit);

    // Writes queued by a previous run (or left behind by a crash) are still owed
    // an upload, and reads must be served from their staged blobs until they land.
@@ -451,6 +461,10 @@ pub fn mount(
    // Start the folder-sync engine. It watches every mirror folder, polls the
    // remotes, and reconciles on its own thread — never in front of a FUSE call.
    workers.extend(sync::spawn(core.clone(), sync_rx));
+    // A timed pause persisted by an earlier run still has to end on time.
+    if pause::paused_at(paused_until, now_secs()) && paused_until != pause::PAUSED_INDEFINITELY {
+        core.arm_pause_timer(paused_until);
+    }

    // Reconcile leftover `(sync-conflict …)` copies: drop the ones that turned
    // out identical to the live file, surface the ones that genuinely diverge.
@@ -0,0 +1,235 @@
+//! Pausing sync: the user's "stop uploading for a while".
+//!
+//! A pause holds back the two things that push local state to the remote — the
+//! drain worker's queued uploads and changes, and the mirror-folder reconcile.
+//! Nothing else stops: reads through the mount keep hydrating on demand (a read
+//! is not a sync), writes keep being accepted and staged, and the watcher and
+//! poll keep noticing changes. Resuming lets all of it catch up at once.
+//!
+//! The pause is persisted in the database, so a restart does not quietly undo
+//! it. A timed pause ends by itself; [`Core::set_sync_paused`] arms a timer for
+//! that, and [`Core::sync_paused`] compares against the clock anyway, so a
+//! deadline that passed while the daemon was down is already over on mount.
+//!
+//! A single mirror folder can be paused on its own as well: its reconcile is
+//! skipped, and with it any mode switch queued behind that reconcile, until the
+//! folder is resumed. On-demand folders cannot be paused alone — their writes
+//! go through the shared queue, which only the global pause holds back.
+
+use super::*;
+
+/// The `state` key holding the resume time, in Unix seconds.
+const PAUSED_UNTIL_KEY: &str = "sync_paused_until";
+
+/// The `state` key prefix marking one synced folder paused; its id follows.
+const FOLDER_PAUSED_PREFIX: &str = "sync_folder_paused:";
+
+fn folder_paused_key(id: i64) -> String {
+    format!("{FOLDER_PAUSED_PREFIX}{id}")
+}
+
+/// Whether synced folder `id` is paused on its own. A row that cannot be read
+/// counts as running, like the global pause.
+fn load_folder_paused(db: &Db, id: i64) -> bool {
+    match db.state_i64(&folder_paused_key(id)) {
+        Ok(value) => value.is_some_and(|v| v != 0),
+        Err(error) => {
+            warn!(id, %error, "reading a folder pause failed; treating it as running");
+            false
+        }
+    }
+}
+
+/// Persist synced folder `id`'s own pause, or clear it.
+fn store_folder_paused(db: &Db, id: i64, paused: bool) -> pdfs_core::Result<()> {
+    match paused {
+        true => db.set_state_i64(&folder_paused_key(id), 1),
+        false => db.clear_state(&folder_paused_key(id)),
+    }
+}
+
+/// A pause with no end time: it lasts until the user resumes.
+pub(crate) const PAUSED_INDEFINITELY: i64 = i64::MAX;
+
+/// The persisted pause, or `0` when there is none (or it cannot be read — a
+/// broken state row must not keep sync paused forever).
+pub(crate) fn load_paused_until(db: &Db) -> i64 {
+    match db.state_i64(PAUSED_UNTIL_KEY) {
+        Ok(Some(until)) => until,
+        Ok(None) => 0,
+        Err(error) => {
+            warn!(%error, "reading the sync pause failed; treating sync as running");
+            0
+        }
+    }
+}
+
+/// Whether a pause lasting until `until` is still in force at `now` (both Unix
+/// seconds). `0` is "not paused".
+pub(crate) fn paused_at(until: i64, now: i64) -> bool {
+    until != 0 && now < until
+}
+
+impl Core {
+    /// True while the user has sync paused.
+    pub(crate) fn sync_paused(&self) -> bool {
+        paused_at(self.sync_paused_until.load(Ordering::Relaxed), now_secs())
+    }
+
+    /// The pause's end, for status reporting: `None` when not paused,
+    /// `Some(None)` when paused until resumed, `Some(Some(t))` when it ends at
+    /// Unix second `t`.
+    pub(crate) fn sync_pause(&self) -> Option<Option<i64>> {
+        let until = self.sync_paused_until.load(Ordering::Relaxed);
+        match paused_at(until, now_secs()) {
+            false => None,
+            true if until == PAUSED_INDEFINITELY => Some(None),
+            true => Some(Some(until)),
+        }
+    }
+
+    /// Pause sync until Unix second `until` (`None`: until resumed), or resume
+    /// it when `paused` is false.
+    pub(crate) fn set_sync_paused(
+        &self,
+        paused: bool,
+        until: Option<i64>,
+    ) -> Result<(), CoreError> {
+        let value = match (paused, until) {
+            (false, _) => 0,
+            (true, None) => PAUSED_INDEFINITELY,
+            (true, Some(until)) if until <= now_secs() => {
+                return Err(CoreError::invalid("the pause would already be over"));
+            }
+            (true, Some(until)) => until,
+        };
+        let persisted = match value {
+            0 => self.db.clear_state(PAUSED_UNTIL_KEY),
+            value => self.db.set_state_i64(PAUSED_UNTIL_KEY, value),
+        };
+        if let Err(error) = persisted {
+            return Err(CoreError::internal(format!(
+                "saving the sync pause: {error}"
+            )));
+        }
+        self.sync_paused_until.store(value, Ordering::Relaxed);
+        match value {
+            0 => {
+                info!("sync resumed");
+                self.resume_sync_work();
+            }
+            PAUSED_INDEFINITELY => info!("sync paused until resumed"),
+            until => {
+                info!(until, "sync paused");
+                self.arm_pause_timer(until);
+            }
+        }
+        Ok(())
+    }
+
+    /// True while the user has this one synced folder paused. A row that cannot
+    /// be read counts as running, like the global pause.
+    pub(crate) fn sync_folder_paused(&self, id: i64) -> bool {
+        load_folder_paused(&self.db, id)
+    }
+
+    /// Pause or resume one mirror folder's reconcile. Resuming reconciles it
+    /// straight away to catch up on what the watcher saw meanwhile.
+    pub(crate) fn set_sync_folder_paused(&self, id: i64, paused: bool) -> Result<(), CoreError> {
+        let folder = self
+            .db
+            .sync_folder_get(id)
+            .map_err(|e| CoreError::internal(format!("db: {e:?}")))?
+            .ok_or_else(|| CoreError::not_found(format!("no synced folder with id {id}")))?;
+        if paused && folder.mode != "mirror" {
+            return Err(CoreError::invalid(
+                "only a mirrored folder can be paused on its own; an on-demand folder uploads \
+                 through the shared queue, so pause all sync instead",
+            ));
+        }
+        if let Err(error) = store_folder_paused(&self.db, id, paused) {
+            return Err(CoreError::internal(format!(
+                "saving the folder pause: {error}"
+            )));
+        }
+        if paused {
+            info!(id, path = %folder.local_path, "folder sync paused");
+        } else {
+            info!(id, path = %folder.local_path, "folder sync resumed");
+            self.sync_now(Some(id));
+        }
+        Ok(())
+    }
+
+    /// Forget a removed folder's pause, so a later folder reusing its id does
+    /// not start out paused.
+    pub(crate) fn clear_sync_folder_paused(&self, id: i64) {
+        if let Err(error) = store_folder_paused(&self.db, id, false) {
+            warn!(id, %error, "clearing a removed folder's pause failed");
+        }
+    }
+
+    /// Wake everything a pause held back: the drain worker, and a full
+    /// reconcile to pick up whatever the watcher saw meanwhile.
+    fn resume_sync_work(&self) {
+        self.wake_drain();
+        self.sync_now(None);
+    }
+
+    /// End a timed pause when its time comes. A later pause or resume replaces
+    /// the stored deadline, which the timer checks before acting, so a stale
+    /// timer does nothing.
+    pub(crate) fn arm_pause_timer(&self, until: i64) {
+        let core = self.clone();
+        let wait = Duration::from_secs(until.saturating_sub(now_secs()).max(0) as u64);
+        let spawned = std::thread::Builder::new()
+            .name("pdfs-pause".into())
+            .spawn(move || {
+                if !core.shutdown.sleep(wait) {
+                    return;
+                }
+                if core
+                    .sync_paused_until
+                    .compare_exchange(until, 0, Ordering::Relaxed, Ordering::Relaxed)
+                    .is_ok()
+                {
+                    if let Err(error) = core.db.clear_state(PAUSED_UNTIL_KEY) {
+                        warn!(%error, "clearing an expired sync pause failed");
+                    }
+                    info!("sync pause ended");
+                    core.resume_sync_work();
+                }
+            });
+        if let Err(error) = spawned {
+            // The drain and the reconcile still read the clock, so the pause
+            // still ends — just at the next idle poll instead of on time.
+            warn!(%error, "starting the sync pause timer failed");
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_pause_is_in_force_until_its_deadline() {
+        assert!(!paused_at(0, 100));
+        assert!(paused_at(200, 100));
+        assert!(!paused_at(200, 200));
+        assert!(!paused_at(200, 300));
+        assert!(paused_at(PAUSED_INDEFINITELY, i64::MAX - 1));
+    }
+
+    #[test]
+    fn a_folder_pause_is_kept_per_folder_until_cleared() {
+        let db = Db::open(std::path::Path::new(":memory:")).unwrap();
+        assert!(!load_folder_paused(&db, 3));
+        store_folder_paused(&db, 3, true).unwrap();
+        assert!(load_folder_paused(&db, 3));
+        assert!(!load_folder_paused(&db, 4));
+        assert!(!load_folder_paused(&db, 33));
+        store_folder_paused(&db, 3, false).unwrap();
+        assert!(!load_folder_paused(&db, 3));
+    }
+}
@@ -248,15 +248,19 @@ impl Core {

    // ---- restore (features.md 5.2) ----------------------------------------

-    /// The folders under this machine's device that could be synced here, each
-    /// carrying a proposed local path.
+    /// The folders under a device that could be synced here, each carrying a
+    /// proposed local path. `device` names another registered device by uid;
+    /// `None` is this machine's own.
    ///
    /// The proposal comes from the profile when one exists and its path is
    /// usable on this machine, and from `~/<name>` otherwise — a restored
    /// `/home/other-user/Documents` would be wrong on a machine where that user
    /// does not exist, and silently creating it would be worse.
-    pub(crate) fn list_restorable_folders(&self) -> CoreResult<Vec<RestorableFolder>> {
-        let device = self.ensure_device()?;
+    pub(crate) fn list_restorable_folders(
+        &self,
+        device: Option<&str>,
+    ) -> CoreResult<Vec<RestorableFolder>> {
+        let device = self.restore_source(device)?;
        let root_uid = parse_uid(&device.root_uid).ok_or_else(|| {
            CoreError::internal(format!("bad device root uid: {}", device.root_uid))
        })?;
@@ -334,11 +338,12 @@ impl Core {
    pub(crate) fn restore_sync_folders(
        &self,
        items: &[pdfs_core::control::RestoreItem],
+        device: Option<&str>,
    ) -> CoreResult<String> {
        if items.is_empty() {
            return Err(CoreError::invalid("nothing to restore"));
        }
-        let device = self.ensure_device()?;
+        let device = self.restore_source(device)?;
        let existing = self
            .db
            .sync_folder_list()
@@ -499,6 +504,19 @@ mod tests {
        assert_before(add, "PROFILE_DIR_NAME", "ensure_device()");
    }

+    /// Restoring another computer's folders reads that device, but must not
+    /// rewrite the cached device row: this machine would then back up as the
+    /// other computer.
+    #[test]
+    fn restoring_from_another_device_keeps_this_machines_identity() {
+        let source = function_source(include_str!("devices.rs"), "fn restore_source(");
+        assert!(source.contains("ensure_device()"), "None is this machine");
+        assert!(
+            !source.contains("device_set"),
+            "the cached row is untouched"
+        );
+    }
+
    fn function_source<'a>(source: &'a str, signature: &str) -> &'a str {
        let start = source.find(signature).expect("function signature exists");
        let body = &source[start..];
@@ -0,0 +1,60 @@
+//! The user's view of the pending-op queue: what has not reached the remote
+//! yet, why, and a way to stop waiting out a backoff.
+//!
+//! Read-only apart from "retry now", which only moves a row's next-attempt time.
+//! Nothing here drops a queued op: its staged blob is the only copy of the
+//! user's write (see `docs/RECOVERY.md`).
+
+use super::*;
+use pdfs_core::control::PendingOpInfo;
+use pdfs_core::db::{FAILING_ATTEMPTS, PARK_UNTIL};
+
+impl Core {
+    /// Every queued op, oldest first, with a path a person can read.
+    pub(crate) fn pending_op_infos(&self) -> CoreResult<Vec<PendingOpInfo>> {
+        let ops = self
+            .db
+            .pending_ops()
+            .map_err(|e| CoreError::internal(format!("listing the queue: {e}")))?;
+        Ok(ops
+            .into_iter()
+            .map(|op| {
+                let parked = op.next_attempt_at >= PARK_UNTIL;
+                let path = self
+                    .db
+                    .node_path(&op.uid)
+                    .ok()
+                    .flatten()
+                    .filter(|path| !path.is_empty())
+                    .or_else(|| op.name.clone())
+                    .unwrap_or_else(|| op.uid.clone());
+                PendingOpInfo {
+                    id: op.id,
+                    kind: op.kind,
+                    path,
+                    attempts: op.attempts,
+                    last_error: op.last_error,
+                    queued_at: op.created_at / 1000,
+                    next_attempt_at: (!parked).then_some(op.next_attempt_at / 1000),
+                    parked,
+                    failing: op.attempts >= FAILING_ATTEMPTS,
+                }
+            })
+            .collect())
+    }
+
+    /// Retry one backed-off op now, or every failed one when `id` is `None`.
+    /// Returns how many ops were moved up.
+    pub(crate) fn retry_pending_ops(&self, id: Option<i64>) -> CoreResult<usize> {
+        let now = now_millis();
+        let moved = match id {
+            Some(id) => self.db.retry_op_now(id, now).map(usize::from),
+            None => self.db.retry_failed_ops_now(now),
+        }
+        .map_err(|e| CoreError::internal(format!("retrying the queue: {e}")))?;
+        if moved > 0 {
+            self.wake_drain();
+        }
+        Ok(moved)
+    }
+}
@@ -8,7 +8,7 @@
 //!
 //! Proton has no API for editing a sealed capture time, so the repair is a
 //! rewrite: download the photo, upload it again with the capture time its file
-//! name implies, put the new copy back into the albums and favourites the old
+//! name implies, put the new copy back into the albums and favorites the old
 //! one was in, then **trash** (not delete) the original. Trash rather than
 //! delete so a bad run is recoverable from Proton's own trash for 30 days.
 //!
@@ -213,7 +213,7 @@ impl Core {
        drop(guard);
        let new_uid = uploaded.map_err(|e| CoreError::from_api(&e, "re-upload photo"))?;

-        // Favourite and albums before the trash: a failure here leaves both
+        // Favorite and albums before the trash: a failure here leaves both
        // copies on the account, which is recoverable by hand. Losing the
        // original first would not be.
        if candidate.favorite {
@@ -227,7 +227,7 @@ impl Core {
                // just set does not come back as a remote change.
                Ok(_) => self.note_self_change(&new_uid),
                Err(e) => {
-                    warn!(name = candidate.name, error = %e, "cannot re-favourite re-dated photo")
+                    warn!(name = candidate.name, error = %e, "cannot re-favorite re-dated photo")
                }
            }
        }
@@ -388,6 +388,66 @@ impl Core {
            .map_err(|e| CoreError::from_api(&e, "remove public link"))
    }

+    /// Stop sharing the node at `rel`: remove its public link, then every
+    /// external invitation, Proton invitation and member. The SDK has no call
+    /// that deletes a share outright, so this composes the per-entry ones.
+    pub(crate) fn stop_sharing(&self, rel: &Path) -> CoreResult<StopSharingOutcome> {
+        let (_ino, uid) = self.resolve(rel)?;
+        self.stop_sharing_for_uid(&uid)
+    }
+
+    /// [`Core::stop_sharing`] for a node addressed through any daemon location.
+    pub(crate) fn stop_sharing_by_uid(&self, uid: &str) -> CoreResult<StopSharingOutcome> {
+        let uid = self.resolve_anywhere(uid)?;
+        self.stop_sharing_for_uid(&uid)
+    }
+
+    /// Each step runs even when an earlier one failed, so a single stuck
+    /// member does not leave the public link up. The link goes first: it is the
+    /// widest exposure. Only a failure to list what is there fails the whole
+    /// request; a failed removal is counted in the outcome.
+    fn stop_sharing_for_uid(&self, uid: &NodeUid) -> CoreResult<StopSharingOutcome> {
+        let mut outcome = StopSharingOutcome::default();
+        let link = self
+            .rt
+            .block_on(self.client.get_public_link(uid))
+            .map_err(|e| CoreError::from_api(&e, "get public link"))?;
+        if let Some(link) = link {
+            let result = self.rt.block_on(self.client.remove_public_link(&link));
+            outcome.record("the public link", result);
+        }
+        let external = self
+            .rt
+            .block_on(self.client.list_external_invitations(uid))
+            .map_err(|e| CoreError::from_api(&e, "list external invitations"))?;
+        for ext in external {
+            let result = self
+                .rt
+                .block_on(self.client.delete_external_invitation(&ext));
+            outcome.record(&ext.invitee_email, result);
+        }
+        let invitations = self
+            .rt
+            .block_on(self.client.list_share_invitations(uid))
+            .map_err(|e| CoreError::from_api(&e, "list invitations"))?;
+        for inv in invitations {
+            let result = self.rt.block_on(self.client.delete_invitation(&inv));
+            outcome.record(&inv.invitee_email, result);
+        }
+        let members = self
+            .rt
+            .block_on(self.client.list_share_members(uid))
+            .map_err(|e| CoreError::from_api(&e, "list members"))?;
+        for member in members {
+            let result = self.rt.block_on(self.client.remove_member(&member));
+            outcome.record(&member.email, result);
+        }
+        if !outcome.failed.is_empty() {
+            debug!(%uid, failed = ?outcome.failed, "stop sharing: some entries remain");
+        }
+        Ok(outcome)
+    }
+
    // ---- shared with me ---------------------------------------------------

    /// List nodes shared with me that I have accepted.
@@ -657,6 +717,47 @@ impl Core {
    }
 }

+/// What [`Core::stop_sharing`] managed to remove.
+#[derive(Debug, Default, PartialEq, Eq)]
+pub(crate) struct StopSharingOutcome {
+    /// Entries removed (the link, invitations and members alike).
+    pub(crate) removed: usize,
+    /// What could not be removed, by email (or "the public link"), with why.
+    pub(crate) failed: Vec<(String, String)>,
+}
+
+impl StopSharingOutcome {
+    fn record<E: std::fmt::Display>(&mut self, what: &str, result: Result<(), E>) {
+        match result {
+            Ok(()) => self.removed += 1,
+            Err(e) => self.failed.push((what.to_string(), e.to_string())),
+        }
+    }
+
+    /// The reply for the control socket: a sentence for a full success, an
+    /// error naming what is left otherwise.
+    pub(crate) fn into_result(self) -> Result<String, String> {
+        if self.failed.is_empty() {
+            return Ok(match self.removed {
+                0 => "it was not shared".to_string(),
+                1 => "stopped sharing: removed 1 entry".to_string(),
+                n => format!("stopped sharing: removed {n} entries"),
+            });
+        }
+        let left = self
+            .failed
+            .iter()
+            .map(|(what, why)| format!("{what} ({why})"))
+            .collect::<Vec<_>>()
+            .join(", ");
+        Err(format!(
+            "removed {} of {}; still shared: {left}",
+            self.removed,
+            self.removed + self.failed.len()
+        ))
+    }
+}
+
 /// Walk one inode space from `uid` up to its root, building the path. `None` if
 /// that mount has never interned the node, or if the chain breaks partway —
 /// a broken chain is a missing path, never a partial one.
@@ -671,3 +772,37 @@ fn walk_to_root(st: &super::State, uid: &NodeUid) -> Option<String> {
    parts.reverse();
    Some(parts.join("/"))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn stopping_a_share_that_is_gone_says_so() {
+        let outcome = StopSharingOutcome::default();
+        assert_eq!(outcome.into_result().unwrap(), "it was not shared");
+    }
+
+    #[test]
+    fn a_failed_removal_names_what_is_still_shared() {
+        let mut outcome = StopSharingOutcome::default();
+        outcome.record::<String>("the public link", Ok(()));
+        outcome.record("bob@example.com", Err("forbidden"));
+        outcome.record::<String>("carol@example.com", Ok(()));
+        assert_eq!(
+            outcome.into_result().unwrap_err(),
+            "removed 2 of 3; still shared: bob@example.com (forbidden)"
+        );
+    }
+
+    #[test]
+    fn a_full_removal_counts_the_entries() {
+        let mut outcome = StopSharingOutcome::default();
+        outcome.record::<String>("the public link", Ok(()));
+        outcome.record::<String>("bob@example.com", Ok(()));
+        assert_eq!(
+            outcome.into_result().unwrap(),
+            "stopped sharing: removed 2 entries"
+        );
+    }
+}
@@ -109,6 +109,7 @@ impl Core {
            by_parent_name.insert((parent, node.name.as_str()), node);
        }

+        let roots = self.search_roots();
        let online = self.online.load(std::sync::atomic::Ordering::Relaxed);
        for node in &nodes {
            if node.trashed || node.is_folder() {
@@ -132,7 +133,16 @@ impl Core {
                        self.remove_conflict_copy(node, &base);
                    }
                }
-                SweepAction::Flag(detail) => self.flag_conflict(&node.uid, &node.name, detail),
+                // Only flag what the conflict listing can show. Anything else
+                // would sit in the feed as "resolved" with no way to act on
+                // it (`docs/BUGS.md` B99).
+                SweepAction::Flag(detail) => {
+                    if self.conflict_path(&roots, &node.uid).is_some() {
+                        self.flag_conflict(&node.uid, &node.name, detail);
+                    } else {
+                        debug!(uid = %node.uid, name = %node.name, "conflict sweep: copy is outside every location; not flagged");
+                    }
+                }
            }
        }
    }
@@ -261,7 +271,7 @@ impl Core {
    /// is tracked in that fork's `State` — so consulting `self.state` alone
    /// answered "idle" for every such file and let the sweep delete one with a
    /// writer attached (`docs/BUGS.md` B74). Busy anywhere means busy.
-    fn is_busy(&self, uid: &NodeUid) -> bool {
+    pub(crate) fn is_busy(&self, uid: &NodeUid) -> bool {
        let mut busy = false;
        self.for_each_state(|st| {
            let Some(&ino) = st.by_uid.get(uid) else {
@@ -273,12 +283,21 @@ impl Core {
        busy
    }

-    /// Surface a conflict copy that needs the user's attention, at most once per
-    /// daemon run so the activity feed is not spammed each pass.
+    /// Surface a conflict copy that needs the user's attention, once. The
+    /// in-memory set spares the database each pass; the activity log itself is
+    /// what keeps a restart from logging the same copy again (`docs/BUGS.md`
+    /// B99). A copy's name carries its own timestamp, so the name identifies it.
    fn flag_conflict(&self, uid: &NodeUid, name: &str, detail: String) {
        if !self.conflict_notified.lock().insert(uid.clone()) {
            return;
        }
+        match self.db.activity_has(ActivityKind::Conflict, name) {
+            Ok(false) => {}
+            Ok(true) => return,
+            // Cannot tell: a repeat entry is harmless, a missing one hides a
+            // conflict.
+            Err(e) => warn!(%uid, name, error = ?e, "conflict sweep: activity check failed"),
+        }
        debug!(%uid, name, detail, "conflict sweep: flagged divergent conflict copy");
        self.log_activity(ActivityKind::Conflict, name, detail, false);
    }
@@ -82,6 +82,12 @@ impl Core {
    /// is guaranteed — a switch requested over the control socket cannot wait for a
    /// pass that may run for minutes.
    pub(crate) fn reconcile_folder(&self, folder: &StoredSyncFolder) {
+        // A paused folder skips the settle too: a queued switch to on-demand
+        // evicts the local tree, which is only safe after a pass uploaded it.
+        if self.sync_folder_paused(folder.id) {
+            debug!(id = folder.id, "sync: folder paused, skipping reconcile");
+            return;
+        }
        // `ondemand` folders are live FUSE mounts, not mirrored, so there is nothing
        // to reconcile — but one may still carry a queued switch back to `mirror`,
        // so the settle below is not skipped with it.
@@ -1220,6 +1226,9 @@ impl Core {
        // Taken from the descriptor being streamed, so it names the content that
        // actually goes up rather than whatever is at the path when we finish.
        let streamed = LocalSig::from(&meta);
+        let thumbnails = self
+            .upload_thumbnails_async(path.clone(), name.to_string())
+            .await;
        // Count the bytes as they are read, so this upload shows up in
        // `GetQueueStatus` next to a manual one. The uid isn't known until the
        // draft is sealed, so the transfer registers without one.
@@ -1240,7 +1249,7 @@ impl Core {
                crate::media_type_for(name),
                reader,
                meta.len() as i64,
-                Vec::new(),
+                thumbnails,
                Some(mtime),
                false,
            )
@@ -1268,6 +1277,9 @@ impl Core {
        let meta = file.metadata().map_err(|e| format!("stat {rel}: {e}"))?;
        let mtime = system_mtime(&meta);
        let streamed = LocalSig::from(&meta);
+        let thumbnails = self
+            .upload_thumbnails_async(path.clone(), base_name(rel).to_string())
+            .await;
        let reader = OwnedCountingReader::new(
            file,
            self.transfers.begin(
@@ -1278,7 +1290,7 @@ impl Core {
            ),
        );
        self.client
-            .upload_new_revision_from(uid, reader, meta.len() as i64, Vec::new(), Some(mtime))
+            .upload_new_revision_from(uid, reader, meta.len() as i64, thumbnails, Some(mtime))
            .await
            .map_err(|e| format!("upload revision {rel}: {e}"))?;
        warn_if_torn(rel, &path, streamed);
@@ -115,6 +115,9 @@ fn engine_loop(core: Core, rx: Receiver<SyncMsg>) {
            reconcile_all(&core);
        } else {
            for id in ids {
+                if core.sync_paused() {
+                    break;
+                }
                if let Ok(Some(folder)) = core.db.sync_folder_get(id) {
                    core.reconcile_folder(&folder);
                }
@@ -151,6 +154,9 @@ fn poll_only_loop(core: &Core, rx: Receiver<SyncMsg>) {
            reconcile_all(core);
        } else {
            for id in ids {
+                if core.sync_paused() {
+                    break;
+                }
                if let Ok(Some(folder)) = core.db.sync_folder_get(id) {
                    core.reconcile_folder(&folder);
                }
@@ -230,8 +236,14 @@ pub(super) fn classify(
    true
 }

-/// Reconcile every mirror folder in turn.
+/// Reconcile every mirror folder in turn. Skipped while sync is paused: the
+/// resume sends a fresh [`SyncMsg::ReconcileAll`], which walks everything the
+/// watcher reported meanwhile.
 fn reconcile_all(core: &Core) {
+    if core.sync_paused() {
+        debug!("sync: paused, skipping reconcile");
+        return;
+    }
    let folders = match core.db.sync_folder_list() {
        Ok(f) => f,
        Err(e) => {
@@ -357,9 +357,9 @@ impl Core {
            }
        }

-        // Favourites are a separate call: the upload seal takes classification
+        // Favorites are a separate call: the upload seal takes classification
        // tags, but `Favorite` is not one of them — it goes through the photos
-        // volume's dedicated favourite endpoint.
+        // volume's dedicated favorite endpoint.
        if !favorites.is_empty() {
            let updates: Vec<PhotoTagsUpdate> = favorites
                .into_iter()
@@ -370,7 +370,7 @@ impl Core {
                })
                .collect();
            if let Err(e) = self.rt.block_on(photos.update_photos(&updates)) {
-                warn!(error = %e, "marking imported favourites failed");
+                warn!(error = %e, "marking imported favorites failed");
            }
        }
        Ok(())
@@ -13,6 +13,10 @@
 //! always reflects exactly what is in flight — even if the work fails partway
 //! and unwinds.
 //!
+//! The same per-block tick enforces the user's bandwidth limits: every byte a
+//! transfer moves is charged to its direction's [`RateLimit`], and the thread
+//! moving it sleeps off whatever the charge puts it over the cap.
+//!
 //! [`Request::GetQueueStatus`]: pdfs_core::control::Request::GetQueueStatus

 use parking_lot::Mutex;
@@ -20,7 +24,7 @@ use std::collections::HashMap;
 use std::io::{Read, Write};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
-use std::time::Instant;
+use std::time::{Duration, Instant};

 use pdfs_core::control::{JobItem, TransferDirection, TransferItem};

@@ -52,6 +56,59 @@ pub struct TransferRegistry {
    inner: Mutex<HashMap<u64, Arc<Entry>>>,
    jobs: Mutex<HashMap<u64, Arc<JobEntry>>>,
    next: AtomicU64,
+    upload_limit: RateLimit,
+    download_limit: RateLimit,
+}
+
+/// How far ahead of its cap a direction may run before it is made to wait, so a
+/// small file still goes out at full speed.
+const RATE_BURST: Duration = Duration::from_secs(1);
+
+/// A bytes-per-second cap shared by every transfer in one direction; `0` is no
+/// cap.
+///
+/// A virtual clock rather than a refilled bucket: each charge pushes
+/// `next_free` forward by the time its bytes take at the cap, so concurrent
+/// transfers split the cap between them instead of each getting all of it.
+#[derive(Default)]
+struct RateLimit {
+    rate: AtomicU64,
+    next_free: Mutex<Option<Instant>>,
+}
+
+impl RateLimit {
+    fn set(&self, rate: u64) {
+        self.rate.store(rate, Ordering::Relaxed);
+        // A new cap starts from now, not from the debt the old one ran up.
+        *self.next_free.lock() = None;
+    }
+
+    /// Charge `n` bytes moved at `now`, returning how long the mover must wait
+    /// to stay under the cap.
+    fn charge(&self, n: u64, now: Instant) -> Duration {
+        let rate = self.rate.load(Ordering::Relaxed);
+        if rate == 0 || n == 0 {
+            return Duration::ZERO;
+        }
+        let mut next_free = self.next_free.lock();
+        let start = next_free.filter(|t| *t > now).unwrap_or(now);
+        let done = start + Duration::from_secs_f64(n as f64 / rate as f64);
+        *next_free = Some(done);
+        done.saturating_duration_since(now + RATE_BURST)
+    }
+}
+
+/// Sleep off a rate-limit wait. The bulk uploader reads on tokio workers, so
+/// the sleep is announced to the runtime there rather than silently holding a
+/// worker other tasks — FUSE reads among them — may need.
+fn throttle(wait: Duration) {
+    use tokio::runtime::{Handle, RuntimeFlavor};
+    match Handle::try_current() {
+        Ok(handle) if handle.runtime_flavor() == RuntimeFlavor::MultiThread => {
+            tokio::task::block_in_place(|| std::thread::sleep(wait))
+        }
+        _ => std::thread::sleep(wait),
+    }
 }

 impl TransferRegistry {
@@ -59,6 +116,20 @@ impl TransferRegistry {
        Arc::new(Self::default())
    }

+    /// Cap uploads and downloads at these bytes per second; `0` lifts a cap.
+    /// Applies to transfers already running from their next block.
+    pub fn set_limits(&self, upload: u64, download: u64) {
+        self.upload_limit.set(upload);
+        self.download_limit.set(download);
+    }
+
+    fn limit(&self, direction: TransferDirection) -> &RateLimit {
+        match direction {
+            TransferDirection::Upload => &self.upload_limit,
+            TransferDirection::Download => &self.download_limit,
+        }
+    }
+
    /// Register a new transfer of `total` bytes (`0` = unknown), returning a
    /// guard that tracks progress and deregisters the transfer when dropped.
    pub fn begin(
@@ -169,9 +240,17 @@ pub struct TransferGuard {
 }

 impl TransferGuard {
-    /// Record `n` more bytes moved.
+    /// Record `n` more bytes moved, then wait if they put the direction over
+    /// its cap.
    pub fn add(&self, n: u64) {
        self.entry.done.fetch_add(n, Ordering::Relaxed);
+        let wait = self
+            .reg
+            .limit(self.entry.direction)
+            .charge(n, Instant::now());
+        if !wait.is_zero() {
+            throttle(wait);
+        }
    }
 }

@@ -310,14 +389,61 @@ impl<R: Read> Read for CountingReader<'_, R> {
            && cancel.load(Ordering::Relaxed)
        {
            // Not `Ok(0)`: a short read is how this reader says "end of file",
-            // and the SDK would seal a truncated revision from it.
-            return Err(std::io::Error::new(
-                std::io::ErrorKind::Interrupted,
-                "upload superseded by a newer write",
-            ));
+            // and the SDK would seal a truncated revision from it. Not
+            // `Interrupted` either: every reader loop, the SDK's included,
+            // retries that kind, and this flag never clears, so the drain
+            // thread spun forever with the transfer stuck at 0 bytes (B98).
+            return Err(std::io::Error::other("upload superseded by a newer write"));
        }
        let n = self.inner.read(buf)?;
        self.guard.add(n as u64);
        Ok(n)
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn an_uncapped_direction_never_waits() {
+        let limit = RateLimit::default();
+        assert_eq!(limit.charge(u64::MAX / 2, Instant::now()), Duration::ZERO);
+    }
+
+    #[test]
+    fn a_capped_direction_waits_once_past_its_burst() {
+        let limit = RateLimit::default();
+        limit.set(1000);
+        let now = Instant::now();
+        // One second of bytes is the burst: no wait yet.
+        assert_eq!(limit.charge(1000, now), Duration::ZERO);
+        // Two more seconds' worth at the same instant: wait out all but the burst.
+        assert_eq!(limit.charge(2000, now), Duration::from_secs(2));
+        // Lifting the cap drops the debt with it.
+        limit.set(0);
+        assert_eq!(limit.charge(5000, now), Duration::ZERO);
+    }
+
+    #[test]
+    fn concurrent_transfers_share_one_cap() {
+        let limit = RateLimit::default();
+        limit.set(1000);
+        let now = Instant::now();
+        assert_eq!(limit.charge(1500, now), Duration::from_millis(500));
+        assert_eq!(limit.charge(1500, now), Duration::from_secs(2));
+    }
+
+    #[test]
+    fn a_cancelled_upload_fails_its_read_instead_of_asking_for_a_retry() {
+        let reg = TransferRegistry::new();
+        let guard = reg.begin("f", "", TransferDirection::Upload, 4);
+        let cancel = Arc::new(AtomicBool::new(true));
+        let mut reader = CountingReader::new(&b"data"[..], &guard).with_cancel(cancel);
+        // `read_exact` retries `Interrupted` the way the SDK's block loop does,
+        // so this hangs rather than fails if the cancel asks for a retry.
+        let err = reader.read_exact(&mut [0; 4]).unwrap_err();
+        assert_ne!(err.kind(), std::io::ErrorKind::Interrupted);
+        assert_eq!(guard.entry.done.load(Ordering::Relaxed), 0);
+    }
+}
@@ -69,6 +69,9 @@ async fn run_uploads(
                    format!("destination access denied: errno {}", error.code()),
                ));
            }
+            let thumbnails = core
+                .upload_thumbnails_async(t.path.clone(), t.name.clone())
+                .await;
            match core
                .client
                .upload_file_from(
@@ -77,7 +80,7 @@ async fn run_uploads(
                    media_type_for(&t.name),
                    reader,
                    t.size as i64,
-                    Vec::new(),
+                    thumbnails,
                    mtime,
                    false,
                )
@@ -35,3 +35,9 @@ adw = { package = "libadwaita", version = "0.9", features = ["v1_5"] }
 async-channel = "2"
 exif = { version = "0.6", package = "kamadak-exif" }
 webkit6 = "0.6"
+# Town and street names on the Places map, with font fallback for every script.
+pangocairo = "0.22"
+# Map tiles for the opt-in online map. The same build proton-sdk already pulls in.
+reqwest = { version = "0.13", default-features = false, features = ["rustls", "webpki-roots"] }
+# The system libintl (glibc) rather than a bundled gettext build.
+gettext-rs = { version = "0.7", features = ["gettext-system"] }
@@ -9,6 +9,8 @@ fn main() {
            &format!("{}/pdfs.gresource", out_dir),
            "--sourcedir",
            "resources/icons",
+            "--sourcedir",
+            "resources",
            "resources/pdfs.gresource.xml",
        ])
        .status()
@@ -22,10 +24,8 @@ fn main() {
    }

    println!("cargo:rerun-if-changed=resources/pdfs.gresource.xml");
-    println!(
-        "cargo:rerun-if-changed=resources/icons/scalable/actions/pdfs-build-thumbnails-symbolic.svg"
-    );
-    println!(
-        "cargo:rerun-if-changed=resources/icons/scalable/actions/pdfs-folder-upload-symbolic.svg"
-    );
+    println!("cargo:rerun-if-changed=resources/icons");
+    println!("cargo:rerun-if-changed=resources/style.css");
+    println!("cargo:rerun-if-changed=resources/proton-theme.css");
+    println!("cargo:rerun-if-changed=../../packaging/io.narl.proton-drive-linux.svg");
 }
@@ -0,0 +1,393 @@
+47.98,8.00 48.94,9.45 48.94,11.26
+47.98,8.00 46.42,6.50 44.94,4.91 43.99,4.95 43.58,4.85 43.13,4.64 42.86,4.32 42.02,4.14 41.88,3.98
+34.25,31.21 34.53,31.53 34.48,31.58
+35.55,32.40 35.19,32.53 35.07,32.46 34.96,32.16 34.95,31.84 35.20,31.75 34.95,31.60 34.87,31.40 34.91,31.35 35.10,31.37 35.45,31.48
+35.11,33.08 35.41,33.08 35.49,33.12 35.53,33.25 35.60,33.24
+35.79,32.73 35.89,32.94 35.79,33.29 35.84,33.42
+34.00,35.07 33.87,35.09 33.48,35.00 33.38,35.16 33.19,35.17 32.92,35.09 32.71,35.17
+77.80,35.50 77.89,35.45 78.04,35.48 78.01,35.25 78.33,34.61 78.67,34.52 78.97,34.30 78.97,34.23 78.73,34.01 78.80,33.50 78.92,33.39
+77.05,35.11 77.00,34.99 76.59,34.74 76.04,34.67 75.71,34.50 75.32,34.58
+91.63,27.76 91.98,27.73 92.10,27.81 92.55,27.88 92.69,27.99 92.64,28.06 92.70,28.15 93.17,28.36 93.36,28.65 93.90,28.74 93.97,28.86 94.27,28.97 94.29,29.14 94.62,29.31 94.77,29.18 95.39,29.04 95.52,29.21 95.71,29.24 95.77,29.34 96.13,29.38 96.23,29.25 96.36,29.25 96.18,29.12 96.20,28.96 96.44,29.05 96.58,28.76 96.28,28.41 96.39,28.37 96.60,28.46 96.78,28.37 97.08,28.37 97.32,28.22
+128.37,38.62 128.17,38.36 128.04,38.31 127.09,38.28 126.67,37.92 126.63,37.78
+-8.68,27.66 -8.82,27.66 -8.75,27.19 -8.79,27.12 -9.41,27.09 -9.82,26.85 -10.03,26.91 -10.25,26.86 -10.76,27.02 -11.39,26.88 -11.32,26.74 -11.34,26.63 -11.51,26.47 -11.72,26.10 -12.06,25.99 -12.43,24.83 -12.99,24.47 -13.31,23.98 -13.89,23.69 -14.10,23.10 -14.22,22.31 -14.63,21.86 -14.61,21.75 -14.75,21.50 -14.97,21.44 -16.04,21.50 -17.00,21.42
+35.92,4.62 35.76,4.81 35.80,5.16 35.75,5.34 35.47,5.42 35.33,5.36 35.27,5.49
+-124.76,48.49 -123.86,48.26 -123.39,48.25 -123.14,48.40 -123.24,48.64 -123.01,48.79 -123.31,48.99
+91.63,27.76 91.64,27.92 91.27,28.08 91.02,27.97 90.33,28.12
+23.61,51.52 23.61,51.61 23.71,51.64 23.98,51.59 24.36,51.87 25.79,51.92 27.14,51.75 27.30,51.60 27.69,51.57 27.70,51.48 27.86,51.59 28.18,51.61 28.60,51.54 28.73,51.43 29.10,51.63 29.35,51.38 30.16,51.48 30.33,51.33 30.54,51.27 30.63,51.36 30.53,51.60 30.76,51.90 31.08,52.08 31.76,52.10
+35.84,33.42 35.60,33.24
+35.84,33.42 36.03,33.59 35.94,33.67 35.99,33.75 36.09,33.83 36.37,33.84 36.28,33.93 36.58,34.22 36.50,34.43 36.33,34.50 36.43,34.61 36.38,34.66 35.98,34.63
+34.68,-12.01 34.76,-12.03 34.68,-12.12 34.68,-12.01
+80.21,42.19 80.26,42.24 80.16,42.63 80.20,42.73 80.54,42.87 80.38,42.97 80.39,43.04 80.62,43.13 80.75,43.10 80.79,43.16 80.67,43.31 80.70,43.43 80.65,43.56 80.36,44.10 80.36,44.55 80.38,44.66 80.48,44.71 80.26,44.81 80.00,44.80 79.87,44.88 80.06,45.01 80.85,45.13 81.69,45.35 81.79,45.23 81.94,45.16 82.27,45.22 82.52,45.13 82.62,45.29 82.61,45.42 82.33,45.52 82.32,45.59 82.97,46.97 83.03,47.19 84.02,46.97 84.67,46.97 84.79,46.83 85.23,47.04 85.48,47.06 85.66,47.25 85.53,47.92 85.75,48.39 86.55,48.53 86.72,48.70 86.73,48.94 86.81,49.05 87.05,49.11 87.32,49.09
+23.48,53.94 24.19,53.95 24.32,53.89 24.77,53.97 24.87,54.15 25.05,54.13 25.46,54.29 25.51,54.16 25.75,54.16 25.75,54.26 25.55,54.33 25.72,54.56 25.72,54.72 25.86,54.92 26.18,55.00 26.29,55.14 26.60,55.13 26.78,55.27 26.46,55.34 26.59,55.67
+-53.37,-33.74 -53.53,-33.66 -53.53,-33.17 -53.13,-32.74 -53.16,-32.68 -53.60,-32.40 -53.76,-32.06 -54.22,-31.86 -54.59,-31.49 -54.90,-31.39 -55.04,-31.28 -55.17,-31.28 -55.56,-30.88 -55.63,-30.86 -55.81,-31.03
+116.68,49.82 116.03,48.78 115.82,48.58 115.79,48.25 115.53,48.13 115.62,47.87 115.90,47.69 116.23,47.86 116.76,47.87 117.07,47.81 117.35,47.65 117.77,47.99 118.15,48.03 118.50,47.98 118.76,47.76 119.08,47.65 119.16,47.53 119.71,47.15 119.90,46.86 119.87,46.67 119.71,46.61 119.33,46.61 118.84,46.76 118.72,46.69 118.31,46.72 118.07,46.67 117.74,46.52 117.44,46.59 117.33,46.36 116.86,46.39 116.56,46.29 116.21,45.89 116.20,45.74 115.68,45.46 114.56,45.39 114.42,45.20 114.08,44.97 113.59,44.75 112.71,44.88 112.41,45.06 111.90,45.06 111.62,44.83 111.40,44.37 111.60,44.11 111.84,43.93 111.93,43.71 111.55,43.50 111.01,43.34 110.40,42.77 109.34,42.44 108.17,42.45 106.77,42.29 105.20,41.74 104.98,41.60 104.50,41.66 104.50,41.88 103.71,41.75 103.07,42.01 102.16,42.16 101.97,42.22 101.66,42.50 101.50,42.54 99.98,42.68 99.47,42.57 97.21,42.79 96.39,42.72 96.30,42.93 95.86,43.28 95.53,43.95 95.33,44.04 95.35,44.28 95.05,44.26 94.71,44.35 94.20,44.65 93.96,44.67 93.52,44.94 92.79,45.04 91.58,45.08 91.05,45.22 90.88,45.20 90.66,45.53 90.71,45.73 91.00,46.04 90.91,46.27 91.03,46.57 90.87,46.95 90.72,47.00 90.50,47.29 90.33,47.66 90.10,47.75 90.03,47.88 89.78,47.83 89.48,48.03 89.05,48.00 88.58,48.22 88.52,48.38 87.98,48.56 88.06,48.71 87.74,48.88 87.87,49.00 87.81,49.16
+13.81,48.77 13.55,48.96 13.40,48.98 12.92,49.33 12.68,49.41 12.39,49.74 12.51,49.90 12.21,50.10 12.09,50.30 12.28,50.18 12.55,50.39 12.94,50.41 13.02,50.49 13.44,50.60 13.56,50.70 14.37,50.90 14.26,51.00 14.32,51.04 14.55,50.99 14.66,50.83 14.81,50.86
+27.35,57.53 26.97,57.61 26.46,57.54 25.99,57.84 25.28,58.05 25.26,58.00 25.11,58.06 24.32,57.87
+27.35,57.53 27.51,57.51 27.54,57.43 27.83,57.29 27.64,56.85 27.85,56.85 28.10,56.55 28.20,56.26 28.15,56.14
+21.05,56.07 21.65,56.31 22.08,56.41 22.88,56.40 23.04,56.32 23.20,56.37 24.12,56.26 24.47,56.28 24.84,56.41 25.07,56.20 25.66,56.10 26.28,55.75 26.59,55.67
+20.62,69.04 20.12,69.02 20.35,68.85 20.24,68.67 19.97,68.54 20.24,68.48 19.97,68.36 18.30,68.56 18.16,68.53 18.18,68.20 17.92,67.96 17.32,68.10 16.78,67.90 16.57,67.62 16.19,67.51 16.13,67.43 16.43,67.16 16.40,67.05 15.42,66.49 15.48,66.31 15.04,66.17 14.54,66.13 14.63,65.79 14.48,65.30 13.65,64.58 14.08,64.46 14.14,64.17 13.96,64.01 13.20,64.08 12.79,64.00 12.18,63.60 12.21,63.49 12.00,63.29 12.22,63.00 12.11,62.92 12.11,62.59 12.30,62.29 12.16,61.72 12.88,61.35 12.71,61.06 12.29,61.00 12.59,60.45 12.49,60.11 12.17,59.91 11.93,59.86 11.83,59.70 11.68,59.59 11.80,59.29 11.64,58.93 11.47,58.91 11.34,59.09 11.24,59.10 11.14,59.09 11.06,58.96 10.91,58.95
+20.62,69.04 21.07,69.04 21.13,69.08 21.07,69.21 21.59,69.27 22.30,68.86 22.41,68.72 23.32,68.65 23.71,68.71 23.85,68.81 24.94,68.59 25.09,68.64 25.25,68.82 25.58,68.89 25.75,68.99 25.77,69.28 26.07,69.69 26.53,69.92 27.13,69.91 27.75,70.06 27.89,70.06 28.41,69.82 29.14,69.67 29.33,69.47 28.85,69.18 28.83,69.12 28.97,69.02
+104.43,10.41 104.56,10.52 104.85,10.53 105.05,10.70 105.05,10.91 105.31,10.85 105.41,10.95 105.76,10.99 105.85,10.86 106.16,10.79 106.16,11.04 105.86,11.29 105.85,11.64 106.01,11.76 106.40,11.69 106.41,11.95 106.70,11.98 106.76,12.05 106.93,12.08 107.21,12.30 107.33,12.32 107.39,12.26 107.51,12.36 107.56,12.54 107.48,13.03 107.61,13.44 107.33,14.13 107.36,14.37 107.49,14.55 107.52,14.71
+-69.51,-17.50 -69.31,-17.94 -69.09,-18.05 -69.15,-18.14 -68.97,-18.97 -68.46,-19.43 -68.70,-19.72 -68.56,-19.97 -68.60,-20.04 -68.76,-20.09 -68.69,-20.31 -68.76,-20.42 -68.48,-20.63 -68.56,-20.72 -68.56,-20.90 -68.44,-20.95 -68.20,-21.30 -68.19,-21.62 -68.08,-21.98 -67.99,-22.06 -67.88,-22.49 -67.88,-22.82 -67.58,-22.89 -67.19,-22.82
+-69.51,-17.51 -69.85,-17.70 -69.80,-17.99 -69.93,-18.21 -70.18,-18.33 -70.42,-18.35
+6.34,49.45 6.49,49.80 6.20,49.92 6.11,50.03 6.12,50.12
+2.52,51.10 2.60,50.88 2.76,50.75 2.84,50.71 3.11,50.78 3.23,50.66 3.27,50.53 3.60,50.48 3.69,50.31 3.95,50.34 4.17,50.25 4.15,49.97 4.55,49.96 4.82,50.15 4.86,50.14 4.79,49.96 4.87,49.79 5.28,49.68 5.51,49.51 5.79,49.54
+6.12,50.12 5.98,50.17 5.74,49.92 5.72,49.81 5.88,49.64 5.79,49.54
+46.43,41.89 45.95,42.04 45.64,42.21 45.71,42.50 45.34,42.53 45.16,42.68 44.87,42.76 44.77,42.62 44.64,42.73 44.51,42.75 43.83,42.57 43.74,42.62 43.78,42.75 43.09,42.99 42.99,43.09 42.76,43.17 42.57,43.16 42.42,43.22 41.58,43.22 40.65,43.53 40.15,43.57 39.98,43.42
+20.96,40.85 20.93,40.90 20.71,40.93 20.49,41.27 20.45,41.52 20.52,41.57 20.57,41.87
+20.57,41.87 20.58,42.01 20.49,42.22 20.24,42.34 20.06,42.55
+41.51,41.52 41.82,41.43 41.93,41.50 42.47,41.44 42.61,41.58 42.75,41.58 43.15,41.31 43.21,41.20 43.40,41.18 43.44,41.11
+101.14,21.57 101.20,21.52 101.25,21.20 101.54,21.23 101.70,21.15 101.80,21.21 101.72,21.31 101.74,21.83 101.60,21.99 101.52,22.25 101.74,22.50 101.84,22.39 102.02,22.44 102.13,22.38
+73.63,39.45 73.82,39.49 73.91,39.58 73.84,39.80 73.99,40.04 74.41,40.14 74.68,40.31 74.83,40.33 74.84,40.48 75.11,40.45 75.56,40.63 75.68,40.31 75.87,40.30 76.26,40.43 76.32,40.35 76.48,40.45 76.66,40.78 76.91,41.02 77.58,40.99 78.12,41.08 78.44,41.42 79.29,41.78 79.77,41.90 79.84,42.00 80.22,42.03 80.21,42.19
+43.44,41.11 44.23,41.21 44.84,41.21 44.81,41.26 45.00,41.29
+80.21,42.19 79.92,42.41 79.43,42.48 79.13,42.78 76.99,42.97 75.84,42.94 75.64,42.81 75.37,42.84 74.82,42.98 74.21,43.24 73.95,43.20 73.56,43.00 73.42,42.59 73.49,42.41 72.28,42.76 71.76,42.82 71.26,42.73 70.89,42.34 70.95,42.25
+-56.48,1.94 -56.84,1.88 -57.12,2.01 -57.32,1.96 -57.55,1.73 -57.98,1.65 -58.03,1.52 -58.34,1.59 -58.40,1.48 -58.51,1.44 -58.51,1.28 -58.68,1.28 -58.82,1.20 -59.23,1.38 -59.54,1.70 -59.67,1.75 -59.67,1.84 -59.76,1.90 -59.76,2.27 -59.89,2.36 -59.99,2.69 -59.97,2.99 -59.83,3.35 -59.85,3.59 -59.68,3.70 -59.55,3.93 -59.74,4.23 -59.70,4.38 -59.83,4.48 -60.15,4.53 -60.03,4.74 -59.99,5.08 -60.14,5.24 -60.74,5.20
+8.39,55.10 8.59,54.92 9.25,54.81 9.74,54.83
+9.52,30.23 9.90,30.39 10.22,30.78 10.26,30.94 10.11,31.46 10.27,31.68 10.48,31.74 10.61,31.93 10.83,32.08 11.51,32.41 11.53,32.52 11.45,32.64 11.50,33.18
+45.00,41.29 45.19,41.15 45.07,41.08 45.42,40.99 45.59,40.85 45.38,40.67 45.45,40.53 45.57,40.42 45.96,40.23 45.89,40.02 45.58,39.98 46.20,39.59 46.48,39.56 46.48,39.48 46.37,39.40 46.58,39.22 46.40,39.19 46.49,39.07 46.49,38.91
+44.77,39.70 45.03,39.77 45.17,39.57 45.25,39.60 45.46,39.49 45.78,39.55 45.77,39.38 45.98,39.24 45.95,39.18 46.11,38.88
+20.24,46.11 20.51,46.17 20.61,46.13 20.76,46.25 21.12,46.28 21.26,46.41 21.32,46.61 21.50,46.70 21.66,47.04 22.00,47.40 22.00,47.51 22.29,47.73 22.61,47.77 22.88,47.95
+70.96,40.24 71.30,40.29 71.63,40.22 71.69,40.15 71.96,40.26 72.13,40.44 72.36,40.40 72.40,40.58 72.60,40.53 73.14,40.81 72.66,40.87 72.36,41.04 72.19,41.03 72.16,41.17 71.88,41.20 71.86,41.31 71.66,41.54 71.60,41.50 71.59,41.33 71.42,41.34 71.39,41.12 70.86,41.22 70.69,41.45 70.47,41.41 70.20,41.51 70.18,41.57 70.63,41.88 70.80,41.92 70.86,42.03 71.23,42.16 71.04,42.28 70.95,42.25
+18.83,49.51 18.94,49.50 18.97,49.40 19.15,49.40 19.44,49.60 19.63,49.41 19.77,49.37 19.76,49.20 20.06,49.18 20.16,49.32 20.36,49.39 20.62,49.39 20.87,49.31 21.08,49.42 21.64,49.41 21.89,49.34 22.02,49.21 22.54,49.07
+-7.22,55.09 -7.38,55.03 -7.55,54.77 -7.91,54.70 -7.75,54.59 -8.12,54.48 -8.12,54.41 -7.85,54.22 -7.61,54.14 -7.32,54.13 -7.16,54.24 -7.20,54.30 -7.01,54.41 -6.80,54.21 -6.65,54.16 -6.65,54.06 -6.22,54.09
+18.83,49.51 18.81,49.61 18.59,49.76 18.56,49.88 18.03,50.04 17.87,49.97 17.63,50.12 17.59,50.16 17.74,50.23 17.70,50.31 17.42,50.25 16.88,50.43 16.99,50.24 16.64,50.10 16.21,50.42 16.42,50.57 16.28,50.66 16.01,50.61 15.73,50.74 15.35,50.81 15.26,50.96 14.99,51.01 14.98,50.89 14.81,50.86
+70.96,40.24 70.95,40.19 70.64,40.08 70.62,40.00 70.52,39.95 70.45,40.05 69.97,40.20 69.53,40.10 69.48,39.92 69.31,39.97 69.28,39.92 69.23,39.76 69.30,39.52 70.50,39.59 70.80,39.39 71.00,39.41 71.07,39.49 71.47,39.60 71.50,39.48 71.73,39.42 71.73,39.31 71.78,39.28 72.04,39.35 72.23,39.21 72.36,39.34 72.56,39.38 73.11,39.36 73.63,39.45
+20.00,39.71 20.25,39.68 20.31,39.80 20.38,39.80 20.31,39.98 20.66,40.12 20.81,40.45 20.95,40.49 21.03,40.62 20.96,40.85
+33.20,-14.01 33.15,-13.94 32.99,-14.02 32.87,-13.82 32.77,-13.76 32.80,-13.69 32.67,-13.59 32.85,-13.46 32.97,-13.22 33.00,-12.90 32.95,-12.80 33.02,-12.63 33.40,-12.49 33.51,-12.35 33.34,-12.31 33.25,-12.11 33.30,-11.69 33.23,-11.42 33.38,-11.16 33.26,-10.89 33.46,-10.78 33.66,-10.55 33.53,-10.23 33.31,-10.04 33.35,-9.86 33.20,-9.63 33.00,-9.62 32.92,-9.41
+22.13,48.41 22.14,48.57 22.30,48.69 22.54,49.07
+-11.51,6.91 -11.27,7.23 -10.65,7.76 -10.57,8.07 -10.36,8.19 -10.28,8.49
+24.15,8.67 24.22,8.61 24.21,8.37 24.29,8.29 24.85,8.14 25.20,7.81 25.25,7.72 25.18,7.56 25.28,7.43 25.89,7.06 26.36,6.64 26.31,6.46 26.51,6.07 27.14,5.72 27.33,5.19
+42.92,11.00 43.25,11.50
+42.92,11.00 42.56,11.08 41.96,10.94 41.80,10.98 41.79,11.69 42.38,12.47
+29.40,-4.45 29.32,-4.90 29.61,-5.72 29.48,-6.03 29.54,-6.31 29.71,-6.62 30.21,-7.04 30.75,-8.19
+42.38,12.47 42.48,12.51 42.70,12.38 42.87,12.62 43.12,12.71
+13.81,48.77 14.05,48.60 14.69,48.60 14.79,48.75 14.92,48.77 14.97,48.98 15.07,49.00 15.83,48.86 16.06,48.75 16.37,48.74 16.54,48.80 16.88,48.70 16.95,48.60
+42.36,37.11 42.77,37.37 42.94,37.32 43.09,37.37 43.68,37.23 44.11,37.30 44.19,37.25 44.20,37.05 44.28,36.98 44.61,37.18 44.77,37.14
+16.09,46.86 16.25,46.97 16.45,47.01 16.49,47.12 16.42,47.22 16.44,47.40 16.62,47.45 16.68,47.54 16.64,47.61 16.42,47.67 16.59,47.75 16.79,47.68 17.07,47.71 17.03,47.84 17.15,48.01
+7.02,45.93 7.13,45.88 7.54,45.98 7.79,45.92 7.99,46.02 8.13,46.16 8.10,46.27 8.42,46.45 8.46,46.25 8.64,46.11 8.82,46.08 8.78,46.00 8.95,45.83 9.02,45.85 9.00,46.01 9.25,46.29 9.26,46.48 9.43,46.48 9.53,46.31 9.94,46.36 10.04,46.24 10.13,46.24 10.04,46.48 10.09,46.60 10.43,46.55 10.40,46.67 10.45,46.86
+10.45,46.86 10.35,46.98 10.13,46.85 9.88,46.94 9.85,47.01 9.58,47.06
+44.77,37.14 44.79,37.29 44.57,37.44 44.55,37.66 44.59,37.71 44.21,37.91 44.45,38.33 44.30,38.39 44.27,38.84 44.17,38.93 44.18,39.14 44.08,39.22 44.02,39.38 44.39,39.42 44.46,39.67 44.59,39.77 44.82,39.65
+23.48,53.94 23.45,54.14 23.37,54.20 22.89,54.39 22.77,54.36
+30.75,-8.19 30.89,-8.47 31.03,-8.60 31.35,-8.61 31.53,-8.71 31.67,-8.91 31.92,-8.94 31.94,-9.05 32.43,-9.16 32.92,-9.41
+7.20,53.28 7.19,53.00 7.03,52.65 6.71,52.62 6.75,52.46 6.97,52.44 7.04,52.38 6.98,52.21 6.72,52.08 6.80,51.97 6.52,51.85 6.36,51.82 6.17,51.88 5.95,51.80 6.20,51.45 6.08,51.22 6.13,51.15 5.86,51.03 6.05,50.90 5.99,50.75
+9.58,47.06 9.61,47.11 9.53,47.27
+-8.49,7.56 -8.43,7.60 -8.23,7.56 -8.01,8.08 -8.05,8.17 -8.26,8.25 -8.24,8.46 -8.05,8.50 -7.82,8.47 -7.74,8.38 -7.68,8.41 -7.72,8.64 -7.95,8.79 -7.94,8.98 -7.78,9.08 -7.92,9.19 -7.90,9.42 -8.03,9.40 -8.14,9.50 -8.16,9.97 -7.99,10.16
+7.49,43.77 7.48,43.86 7.68,44.08 7.64,44.16 7.32,44.14 6.90,44.34 6.84,44.51 7.03,44.72 6.99,44.83 6.74,44.92 6.63,45.07 6.69,45.14 6.84,45.14 7.08,45.24 7.15,45.38 6.79,45.74 6.80,45.81 7.02,45.93
+28.97,69.02 28.41,68.90 28.77,68.84 28.48,68.54 28.56,68.35 28.69,68.19 29.34,68.06 29.99,67.67 29.94,67.55 29.24,67.10 29.07,66.89 29.90,66.09 30.09,65.79 30.10,65.68 29.72,65.62 29.82,65.57 29.73,65.47 29.71,65.34 29.61,65.25 29.81,65.20 29.83,65.15 29.62,65.04 29.60,64.97 29.78,64.80 30.11,64.73 30.12,64.64 29.99,64.52 30.11,64.37 30.49,64.24 30.53,64.08 30.21,63.80 29.99,63.74 31.18,63.21 31.53,62.89 31.19,62.48 29.25,61.29 28.41,60.90 27.73,60.46
+30.87,69.78 30.92,69.61 30.86,69.54 30.62,69.53 30.18,69.64 30.19,69.54 30.09,69.43 29.39,69.30 29.21,69.10 28.97,69.02
+55.19,22.70 55.20,23.03 55.53,23.82 55.47,23.94 55.99,24.06 55.93,24.22 55.76,24.24 55.80,24.87 55.92,24.97 56.00,24.95 55.97,24.86 56.06,24.74 56.39,24.98
+48.57,41.84 48.39,41.60 48.06,41.46 47.79,41.20 47.32,41.28 47.14,41.52 46.75,41.81 46.57,41.80 46.54,41.87 46.43,41.89
+-54.62,2.33 -54.72,2.44 -54.88,2.45 -54.98,2.60 -55.39,2.44 -55.73,2.41 -55.96,2.52 -56.14,2.26 -55.92,2.04 -55.93,1.89 -56.02,1.84 -56.48,1.94
+46.43,41.89 46.20,41.74 46.18,41.66 46.31,41.51 46.67,41.29 46.53,41.09 46.43,41.08 46.17,41.20 45.92,41.19 45.73,41.26 45.72,41.34 45.28,41.45 45.00,41.29
+-11.39,12.40 -11.45,12.56 -11.39,12.94 -11.63,13.37 -11.76,13.39 -11.83,13.32 -12.05,13.63 -11.96,13.88 -12.02,13.97 -12.02,14.21 -12.23,14.46 -12.19,14.65 -12.28,14.81
+-54.62,2.33 -54.13,2.12 -53.77,2.35 -53.51,2.25 -53.33,2.34 -53.23,2.20 -52.90,2.21 -52.58,2.53 -52.33,3.18 -51.99,3.70 -51.65,4.06
+2.71,6.37 2.77,6.71 2.72,6.98 2.79,7.48 2.69,7.87 2.77,9.05 3.04,9.08 3.15,9.32 3.14,9.45 3.33,9.67 3.35,9.81 3.56,9.91 3.65,10.16 3.58,10.29 3.65,10.41 3.77,10.42 3.83,10.61 3.72,11.08 3.49,11.40 3.60,11.70
+13.07,-4.63 12.80,-4.43 12.38,-4.62 12.31,-4.77 12.20,-4.78 12.02,-5.00
+16.52,46.50 16.32,46.53 16.24,46.48 16.23,46.37 16.07,46.37 15.64,46.20 15.59,46.14 15.67,46.05 15.65,45.86 15.28,45.73 15.35,45.66 15.28,45.58 15.34,45.47 14.79,45.48 14.57,45.66 14.37,45.48 13.99,45.51 13.88,45.43 13.58,45.52
+18.91,45.93 18.67,45.91 18.53,45.80 18.36,45.75 17.81,45.79 17.31,46.00 16.87,46.34 16.52,46.50
+20.24,46.11 19.61,46.17 19.28,46.00 19.09,46.02 18.91,45.93
+16.52,46.50 16.28,46.86 16.09,46.86
+51.27,24.61 50.97,24.57 50.80,24.79
+25.26,-17.79 25.24,-17.97 25.94,-18.94 25.95,-19.08 26.17,-19.54 26.68,-19.89 27.18,-20.10 27.26,-20.23 27.28,-20.48 27.68,-20.50 27.67,-21.06 28.01,-21.55 29.03,-21.80 29.04,-22.02 29.36,-22.19
+77.80,35.50 77.45,35.48 76.77,35.66
+28.01,41.97 27.53,41.92 27.24,42.09 27.01,42.06 26.58,41.95 26.51,41.83 26.36,41.80 26.32,41.72
+102.93,11.71 102.74,12.09 102.76,12.43 102.50,12.67 102.46,13.02 102.33,13.29 102.34,13.56 102.55,13.59 102.54,13.66 102.91,14.14 103.20,14.33 103.60,14.42 103.98,14.36 104.78,14.43 104.97,14.37 105.00,14.25 105.07,14.23 105.18,14.35
+88.89,27.32 88.74,27.18 88.86,26.96 89.15,26.82 89.33,26.85 89.55,26.80 89.61,26.72 90.12,26.75 90.35,26.89 90.74,26.77 91.29,26.79 91.43,26.87 91.67,26.80 92.05,26.87 92.07,26.98 91.99,27.10 92.08,27.29 91.99,27.45 91.74,27.44 91.59,27.56 91.63,27.76
+104.07,1.28 104.06,1.40 103.82,1.46 103.70,1.44 103.60,1.21
+100.12,6.44 100.18,6.67 100.26,6.68 100.35,6.55 100.75,6.46 100.87,6.25 101.05,6.24 101.08,5.96 100.98,5.77 101.11,5.64 101.26,5.79 101.56,5.91 101.68,5.78 101.87,5.83 102.10,6.24
+5.99,50.75 6.24,50.60 6.17,50.55 6.20,50.50 6.34,50.45 6.36,50.32 6.18,50.23 6.12,50.12
+-71.78,19.72 -71.71,19.49 -71.75,19.29 -71.65,19.16 -71.81,18.99 -71.74,18.73 -71.87,18.61 -72.00,18.60 -71.76,18.34 -71.77,18.04
+14.06,13.08 13.61,13.70
+46.53,29.10 46.91,29.54 47.15,30.00 47.33,30.08 47.64,30.10 47.98,29.98
+88.11,27.87 88.14,27.95 88.58,28.09 88.80,28.01 88.85,27.87 88.75,27.52 88.89,27.32
+-90.10,13.74 -90.05,13.90 -89.55,14.24 -89.57,14.39 -89.36,14.42
+124.04,-9.34 124.09,-9.42 124.28,-9.43 124.41,-9.31 124.44,-9.19
+124.92,-8.94 124.94,-9.05 125.10,-9.00 125.15,-9.04 125.10,-9.19 124.96,-9.21 125.07,-9.51
+115.14,4.90 115.27,4.63 115.29,4.35 115.11,4.39 115.03,4.90
+109.63,2.03 109.54,1.90 109.64,1.78 109.65,1.61 110.51,0.86 111.10,1.05 111.81,1.01 111.92,1.11 112.08,1.14 112.19,1.44 112.48,1.56 112.94,1.57 113.01,1.43 113.62,1.24 113.90,1.43 114.39,1.50 114.51,1.45 114.70,1.85 114.83,1.98 114.76,2.16 114.79,2.25 115.18,2.52 115.08,2.63 115.12,2.89 115.25,3.03 115.45,3.03 115.57,3.45 115.57,3.94 115.68,4.19 115.84,4.33 116.02,4.29 116.24,4.36 116.41,4.31 116.51,4.37 117.10,4.34 117.54,4.17 117.88,4.19
+10.45,46.86 10.99,46.78 11.24,46.98 11.78,46.99 12.17,47.08 12.15,46.94 12.39,46.70 13.70,46.52
+13.70,46.52 13.38,46.26 13.63,46.18 13.48,46.01 13.61,45.96 13.58,45.81 13.87,45.61 13.72,45.59
+29.01,-2.72 29.10,-2.60 29.30,-2.67 29.39,-2.81 29.70,-2.79 29.87,-2.72 29.93,-2.34 30.12,-2.42 30.41,-2.31 30.55,-2.40
+92.57,21.98 92.63,21.31 92.57,21.26 92.33,21.44 92.18,21.29 92.32,20.79
+1.43,42.60 1.29,42.71 0.70,42.85 0.63,42.69 -0.04,42.69 -0.30,42.83 -0.59,42.80 -0.76,42.94 -1.18,43.02 -1.30,43.10 -1.46,43.05 -1.41,43.24 -1.71,43.31 -1.79,43.41
+1.43,42.60 1.50,42.64 1.71,42.60 1.71,42.50
+1.71,42.50 2.03,42.35 2.20,42.42 2.65,42.34 2.89,42.46 3.21,42.43
+1.43,42.60 1.45,42.44 1.71,42.50
+74.89,37.23 75.12,37.39 74.89,37.60 74.94,37.77 74.78,38.19 74.81,38.46 74.28,38.66 74.13,38.66 74.03,38.54 73.80,38.61 73.70,38.85 73.81,38.97 73.61,39.23 73.63,39.45
+74.89,37.23 74.73,37.29 74.37,37.16 74.54,37.02
+20.96,40.85 21.40,40.91 21.58,40.87 21.99,41.13 22.60,41.14 22.72,41.18 22.78,41.33 22.92,41.34
+21.56,42.25 21.39,42.22 21.29,42.10 21.06,42.17 20.78,42.07 20.72,41.87 20.57,41.87
+22.34,42.31 22.24,42.36 21.56,42.25
+22.34,42.31 22.52,42.44 22.44,42.63 22.47,42.84 22.71,42.88 22.98,43.19 22.55,43.45 22.37,43.78 22.42,44.01 22.60,44.08 22.63,44.19 22.71,44.24
+22.92,41.34 23.00,41.74 22.84,41.99 22.58,42.10 22.34,42.31
+18.44,42.56 18.52,42.43
+18.44,42.56 17.80,42.90 17.67,42.90
+78.92,33.39 79.12,33.23
+20.34,42.83 20.47,42.86 20.48,42.95 20.62,43.03 20.62,43.20 20.80,43.26 20.84,43.17 21.06,43.09 21.40,42.83 21.39,42.75 21.75,42.67 21.61,42.39 21.52,42.33 21.56,42.25
+20.34,42.83 20.05,42.76 20.06,42.55
+19.19,43.53 19.22,43.45 19.61,43.17 20.27,42.94 20.34,42.83
+-89.36,14.42 -89.12,14.37 -88.71,14.03 -88.51,13.98 -88.48,13.85 -88.15,13.99 -87.99,13.88 -87.80,13.89 -87.72,13.81 -87.78,13.52 -87.74,13.45 -87.81,13.40
+-87.34,12.98 -87.01,13.01 -86.92,13.22 -86.73,13.28 -86.76,13.75 -86.33,13.77 -86.04,14.05 -85.98,13.97 -85.73,13.86 -85.68,13.98 -85.18,14.34 -85.16,14.53 -85.04,14.61 -84.99,14.75 -84.86,14.81 -84.65,14.66 -84.45,14.64 -84.24,14.75 -84.15,14.72 -83.64,14.88 -83.54,14.98 -83.16,14.99
+-75.28,-0.11 -75.78,0.09 -76.07,0.35 -76.27,0.44 -76.39,0.40 -76.43,0.26 -76.49,0.24 -76.83,0.25 -77.40,0.39 -77.47,0.64 -77.65,0.72 -77.70,0.84 -77.83,0.83 -78.18,0.97 -78.86,1.46
+-57.60,3.37 -57.65,3.52 -57.83,3.68 -58.03,4.00 -58.05,4.17 -57.85,4.67 -57.92,4.82 -57.88,4.88 -57.71,4.99 -57.33,5.02 -57.21,5.20 -57.32,5.34 -57.19,5.55
+-54.08,3.33 -53.99,3.59 -54.35,4.05 -54.48,4.84 -54.45,5.01 -54.16,5.36
+-58.41,-33.94 -58.48,-33.65 -58.38,-33.14 -58.24,-33.11 -58.13,-32.98 -58.20,-32.47
+-57.61,-30.19 -57.87,-30.59 -57.81,-30.86 -57.90,-30.98 -57.89,-31.20 -58.05,-31.49 -57.99,-31.58 -58.01,-31.68 -58.19,-31.92 -58.12,-32.25 -58.20,-32.47
+-54.62,-25.58 -54.44,-25.62 -54.15,-25.52 -53.89,-25.67 -53.67,-26.29 -53.75,-26.75 -53.72,-26.88 -53.84,-27.12 -54.16,-27.25 -54.33,-27.42 -54.83,-27.55 -54.91,-27.71 -55.10,-27.87 -55.73,-28.20 -55.69,-28.38 -55.89,-28.37 -56.94,-29.59 -57.22,-29.78 -57.41,-30.03 -57.61,-30.19
+20.62,69.04 20.90,68.98 20.92,68.91 22.00,68.52 22.85,68.37 23.10,68.26 23.18,68.14 23.32,68.13 23.64,67.95 23.50,67.88 23.54,67.61 23.45,67.46 23.73,67.42 23.77,67.33 23.63,67.23 23.64,67.13 23.99,66.81 23.67,66.38 23.72,66.22 23.91,66.15 24.16,65.81 24.19,65.61 24.12,65.51
+4.23,51.39 4.17,51.31 3.90,51.21 3.58,51.29 3.43,51.25 3.35,51.38
+5.99,50.75 5.75,50.76 5.64,50.84 5.75,50.95 5.80,51.15 5.48,51.29 5.21,51.28 5.03,51.47 4.85,51.40 4.76,51.49 4.63,51.42 4.50,51.47 4.38,51.43 4.37,51.36 4.23,51.39
+6.34,49.45 6.53,49.39 6.74,49.16 6.89,49.21 7.04,49.11 7.45,49.15 7.61,49.06 8.13,48.97 8.14,48.89 7.84,48.64 7.62,48.16 7.53,47.67 7.62,47.59
+9.52,47.52 9.18,47.67 8.88,47.66 8.57,47.78 8.40,47.69 8.57,47.65 8.45,47.60 7.62,47.59
+9.53,47.27 9.63,47.47 9.52,47.52
+9.58,47.06 9.49,47.06 9.53,47.27
+7.02,45.93 6.77,46.17 6.82,46.28 6.76,46.42 6.43,46.43 6.23,46.33 6.27,46.25 6.20,46.19 6.01,46.14 5.97,46.21 6.10,46.28 6.12,46.38 6.07,46.46 6.16,46.61 6.41,46.76 6.46,46.95 6.67,47.03 7.00,47.32 6.90,47.39 6.97,47.45 7.14,47.49 7.34,47.43 7.62,47.59
+-7.41,37.18 -7.50,37.59 -7.44,37.73 -7.19,38.01 -7.02,38.04 -6.96,38.19 -7.11,38.18 -7.34,38.46 -7.28,38.71 -7.05,38.91 -7.00,39.06 -7.17,39.14 -7.34,39.47 -7.54,39.66 -7.12,39.68 -6.98,39.80 -6.90,40.02 -7.03,40.17 -6.81,40.34 -6.84,40.78 -6.93,41.01 -6.21,41.53 -6.31,41.64 -6.54,41.67 -6.62,41.94 -7.15,41.98 -7.21,41.90 -7.40,41.83 -7.92,41.88 -8.15,41.81 -8.22,41.90 -8.13,42.02 -8.27,42.14 -8.78,41.94
+13.81,48.77 13.79,48.59 13.72,48.54 13.49,48.58 13.37,48.36 12.76,48.11 12.95,47.89 12.90,47.72 13.05,47.66 13.01,47.48 12.81,47.54 12.77,47.64 12.69,47.67 12.48,47.64 12.21,47.72 12.19,47.62 11.72,47.58 11.04,47.39 10.87,47.52 10.44,47.55 10.37,47.37 10.18,47.28 10.20,47.36 10.07,47.39 9.97,47.51 9.75,47.58 9.52,47.52
+16.09,46.86 15.98,46.80 15.96,46.68 15.77,46.71 15.44,46.63 14.89,46.61 14.55,46.40 13.70,46.52
+18.44,42.56 18.55,42.64 18.47,42.78 18.46,43.00 18.62,43.03 18.67,43.23 18.85,43.35 19.03,43.29 18.95,43.53 19.19,43.53
+19.19,43.53 19.30,43.59 19.45,43.56 19.50,43.64 19.25,43.97 19.58,44.01 19.12,44.36 19.35,44.88 18.84,44.88 18.66,45.08 18.00,45.14 17.81,45.08 17.65,45.16 17.50,45.12 17.13,45.17 16.92,45.28 16.79,45.20 16.53,45.22 16.29,45.01 16.03,45.19 15.79,45.18 15.74,44.77 16.10,44.52 16.30,44.12 17.08,43.52 17.27,43.45 17.29,43.31 17.65,43.01 17.59,42.94
+19.01,44.87 19.10,44.97 19.06,45.14 19.14,45.20 19.40,45.21 19.00,45.40 19.06,45.52 18.92,45.60 18.95,45.66 18.84,45.84 18.91,45.93
+16.95,48.60 17.14,48.84 17.76,48.89 18.09,49.07 18.16,49.26 18.60,49.49 18.83,49.51
+17.15,48.01 16.87,48.39 16.95,48.60
+17.15,48.01 17.32,47.99 17.76,47.77 18.72,47.79 18.79,48.00 19.47,48.11 19.63,48.22 19.95,48.15 20.33,48.30 20.49,48.53 21.45,48.55 21.72,48.35 22.13,48.41
+14.81,50.86 15.02,51.25 14.91,51.46 14.72,51.52 14.74,51.63 14.60,51.83 14.75,52.08 14.55,52.36 14.62,52.53 14.13,52.88 14.41,53.22 14.21,53.95
+22.88,47.95 22.77,48.11 22.58,48.13 22.35,48.26 22.25,48.41 22.13,48.41
+28.59,43.74 28.22,43.77 28.05,43.82 27.88,43.99 27.74,43.96 27.43,44.02 27.09,44.17 26.22,44.01 25.82,43.77 25.50,43.67 23.22,43.87 22.92,43.83 22.87,43.95 23.03,44.08 22.71,44.24
+20.24,46.11 20.71,45.74 20.77,45.75 20.79,45.47 21.49,45.15 21.35,45.01 21.53,44.90 21.36,44.83
+22.92,41.34 23.64,41.39 24.01,41.46 24.06,41.53 24.49,41.56 24.77,41.36 24.99,41.36 25.25,41.24 25.92,41.31 26.14,41.39 26.07,41.67 26.11,41.73 26.41,41.70 26.58,41.60 26.62,41.40 26.33,41.24 26.33,40.95 26.04,40.73
+20.06,42.55 19.79,42.48 19.73,42.63 19.65,42.63 19.28,42.17 19.36,42.07 19.34,41.87
+26.62,48.26 26.79,48.26 26.98,48.16 27.61,47.34 28.07,46.98 28.24,46.64 28.24,46.45 28.10,45.97 28.16,45.65 28.07,45.60 28.21,45.45
+22.88,47.95 23.20,48.08 23.41,47.99 24.18,47.91 24.58,47.93 24.89,47.72 24.98,47.72 25.46,47.91 26.16,47.99 26.31,48.20 26.62,48.26
+22.54,49.07 22.81,49.02 22.85,49.06 22.71,49.17 22.73,49.30 22.65,49.54 22.71,49.61 23.71,50.38 23.97,50.41 24.09,50.53 23.98,50.79 24.10,50.87 23.66,51.31 23.61,51.52
+20.90,55.29 21.39,55.28 22.07,55.06 22.57,55.06 22.82,54.87 22.68,54.56 22.77,54.36
+31.76,52.10 31.58,52.31 31.62,52.55 31.52,52.70 31.56,52.76 31.26,53.02 31.42,53.20 31.67,53.20 31.85,53.11 32.14,53.09 32.70,53.34 32.71,53.42 32.47,53.55 32.45,53.69 32.20,53.78 31.75,53.81 31.83,54.03 31.40,54.20 31.18,54.45 31.07,54.49 31.15,54.63 30.80,54.78 30.83,54.91 30.98,55.05 30.81,55.31 30.90,55.40 30.91,55.57 30.23,55.85 29.94,55.85 29.48,55.68 29.35,55.78 29.38,55.94 29.03,56.02 28.79,55.94 28.56,56.09 28.28,56.06 28.15,56.14
+31.76,52.10 32.12,52.05 32.28,52.11 32.44,52.31 32.81,52.25 33.15,52.34 33.74,52.34 33.92,52.25 34.11,51.98 34.40,51.78 34.38,51.72 34.12,51.68 34.27,51.34 34.21,51.26 34.71,51.17 35.06,51.20 35.16,51.06 35.31,51.04 35.44,50.73 35.41,50.54 35.59,50.37 35.67,50.35 35.89,50.44 36.12,50.41 36.31,50.28 36.50,50.28 36.62,50.21 36.76,50.29 37.42,50.41 37.70,50.11 38.05,49.92 38.26,50.05 38.92,49.82 39.17,49.86 39.30,49.74 39.46,49.73 39.78,49.57 40.08,49.58 40.11,49.25 39.89,49.06 39.69,49.01 39.75,48.91 40.00,48.82 39.79,48.81 39.64,48.59 39.84,48.54 39.89,48.36 39.85,48.30 39.96,48.27 39.78,47.89 39.66,47.84 38.90,47.86 38.64,47.67 38.37,47.61 38.29,47.56 38.20,47.32 38.28,47.28 38.20,47.18 38.21,47.09
+43.44,41.11 43.63,40.93 43.72,40.72 43.57,40.48 43.71,40.17 43.67,40.13 44.01,40.01 44.29,40.04 44.78,39.68
+87.82,49.16 88.12,49.26 88.19,49.45 88.83,49.45 88.90,49.54 89.01,49.47 89.11,49.50 89.24,49.63 89.40,49.61 89.65,49.72 89.64,49.90 89.98,49.98 90.05,50.09 90.66,50.22 91.02,50.42 91.42,50.47 91.80,50.69 92.19,50.70 92.35,50.86 92.63,50.69 92.78,50.78 92.94,50.78 93.10,50.60 94.25,50.56 94.35,50.22 94.61,50.02 94.93,50.04 95.11,49.94 95.52,49.91 95.79,50.01 95.94,49.96 96.07,50.00 96.32,49.90 96.99,49.88 97.21,49.73 97.36,49.74 97.59,49.91 98.00,50.01 98.25,50.30 98.28,50.53 98.03,50.64 97.84,51.05 98.04,51.45 98.22,51.51 98.35,51.72 98.64,51.80 98.89,52.12 99.72,51.87 99.92,51.76 100.47,51.73 101.38,51.45 102.11,51.35 102.22,50.83 102.32,50.72 102.29,50.59 102.68,50.39 103.16,50.29 103.30,50.20 103.63,50.14 104.08,50.15 104.47,50.31 105.38,50.47 106.22,50.30 106.71,50.31 107.23,49.99 107.92,49.95 107.97,49.65 108.61,49.32 109.24,49.33 110.71,49.14 111.34,49.36 112.08,49.42 112.49,49.53 112.81,49.52 113.06,49.62 113.16,49.80 113.57,50.01 114.30,50.27 114.74,50.23 115.43,49.90 115.72,49.88 116.22,50.01 116.55,49.92 116.68,49.82
+116.68,49.82 117.25,49.62 117.87,49.51 118.45,49.84 119.26,50.07 119.35,50.28 119.16,50.41 119.45,50.70 120.07,51.60 120.51,51.85 120.75,52.10 120.67,52.30 120.70,52.49 120.66,52.57 120.17,52.60 120.07,52.63 120.04,52.72 120.70,53.17 120.99,53.28 122.34,53.49 123.61,53.55 124.81,53.13 125.08,53.20 125.65,53.04 125.73,52.89 125.87,52.87 126.05,52.74 126.02,52.61 126.34,52.36 126.51,51.93 126.70,51.70 126.71,51.57 126.81,51.51 126.92,51.10 127.31,50.71 127.34,50.35 127.59,50.21 127.49,49.98 127.55,49.80 127.71,49.67 128.00,49.57 128.70,49.60 128.82,49.46 129.07,49.37 129.50,49.39 130.20,48.89 130.55,48.86 130.62,48.77 130.55,48.60 130.80,48.34 130.71,48.13 130.73,48.02 130.92,47.84 130.96,47.71 132.48,47.71 132.71,47.95 133.14,48.11 133.47,48.10 133.84,48.27 134.29,48.37 134.67,48.25 134.67,48.15 134.57,48.02 134.75,47.72 134.54,47.49 134.29,47.41 134.17,47.30 134.20,47.13 133.87,46.50 133.86,46.25 133.70,46.14 133.65,45.96 133.51,45.88 133.44,45.60 133.19,45.49 133.11,45.13 132.94,45.03 131.98,45.24 131.85,45.33 131.45,44.98 130.98,44.84 131.26,44.07 131.17,43.70 131.18,43.51 131.26,43.38 131.07,42.90 130.58,42.81 130.42,42.73 130.58,42.62 130.53,42.54
+130.53,42.54 130.25,42.74 130.24,42.89 129.90,43.00 129.70,42.45 129.52,42.38 129.31,42.41 129.20,42.22 128.92,42.04 128.05,41.99 128.03,41.90 128.29,41.61 128.15,41.39 128.01,41.45 127.69,41.44 127.18,41.53 126.95,41.77 126.72,41.72 126.60,41.64 126.49,41.36 125.99,40.90 125.73,40.87 125.42,40.66 124.89,40.46 124.39,40.10 124.36,40.00
+130.53,42.54 130.69,42.30
+70.96,40.24 70.65,40.20 70.37,40.38 70.38,40.45 70.75,40.72 70.40,41.04 70.29,40.89 69.71,40.66 69.41,40.80 69.36,40.77 69.31,40.63 69.21,40.57 69.30,40.33 69.22,40.29 69.27,40.20 68.95,40.22 68.63,40.17 68.97,40.09 68.80,40.05 68.87,39.91 68.64,39.84 68.59,39.63 68.46,39.54 67.72,39.62 67.43,39.47 67.36,39.22 67.65,39.13 67.69,38.99 68.04,38.98 68.13,38.93 68.05,38.67 68.09,38.47 68.35,38.21 68.29,38.03 67.81,37.49 67.76,37.17
+35.89,35.92 36.15,35.83 36.20,35.94 36.35,36.00 36.38,36.17 36.64,36.23 36.54,36.46 36.66,36.80 36.94,36.76 37.07,36.65 37.44,36.64 38.19,36.90 38.44,36.86 38.77,36.69 39.36,36.68 40.02,36.83 40.71,37.10 41.52,37.09 42.06,37.21 42.20,37.30 42.31,37.23 42.36,37.11
+35.45,31.48 35.40,31.23 35.44,31.13 35.14,30.42 35.14,30.14 34.97,29.56
+35.55,32.40 35.56,31.77 35.45,31.48
+35.61,32.68 35.55,32.40
+88.11,27.87 87.14,27.84 86.61,28.10 86.52,27.96 86.41,27.93 86.14,28.11 86.08,28.08 86.06,27.93 85.99,27.91 85.68,28.28 85.12,28.32 85.09,28.37 85.16,28.59 84.80,28.56 84.23,28.91 84.10,29.22 83.94,29.28 83.58,29.18 83.16,29.61 82.85,29.68 82.22,30.06 82.04,30.33 81.64,30.39 81.42,30.34 81.18,30.04 81.11,30.04 81.01,30.16
+97.32,28.22 97.34,27.94 96.88,27.59 96.90,27.44 97.10,27.12 96.95,27.13 96.73,27.33 96.19,27.26 95.46,26.76 95.13,26.60 95.05,26.35 95.13,26.04 95.02,25.91 94.95,25.70 94.58,25.32 94.55,25.22 94.71,25.05 94.29,24.32 94.13,23.88 93.68,24.01 93.49,23.97 93.33,24.06 93.41,23.68 93.39,23.34 93.35,23.08 93.31,23.03 93.16,23.03 93.08,22.72 93.15,22.23 93.04,22.18 92.96,22.00 92.85,22.01 92.69,22.13 92.57,21.98
+100.12,20.32 99.89,20.42 99.72,20.33 99.46,20.36 99.49,20.15 99.34,20.08 99.07,20.10 98.92,19.77 98.37,19.69 98.02,19.75 97.82,19.46 97.80,19.13 97.71,18.93 97.75,18.59 97.52,18.50 97.37,18.52 97.45,18.36 97.63,18.29 97.74,17.94 97.71,17.80 98.44,16.98 98.48,16.73 98.66,16.33 98.84,16.42 98.89,16.35 98.82,16.18 98.59,16.05 98.56,15.37 98.19,15.20 98.20,14.98 98.25,14.81 98.57,14.36 98.93,14.05 99.14,13.72 99.18,13.23 99.12,13.03 99.22,12.74 99.41,12.55 99.61,11.78 99.19,11.11 98.76,10.66 98.70,10.19
+103.09,18.14 103.09,18.14
+103.09,18.14 103.26,18.28 103.29,18.41 103.95,18.32 104.43,17.70 104.74,17.46 104.82,17.30 104.74,16.88 104.82,16.47 105.05,16.16 105.41,15.99 105.40,15.83 105.64,15.66 105.49,15.26 105.55,14.93 105.50,14.59 105.42,14.47 105.18,14.35
+100.12,20.32 100.14,20.25 100.32,20.39 100.52,20.18 100.54,20.09 100.40,19.76 100.51,19.55 100.74,19.51 100.97,19.61 101.21,19.55 101.20,19.33 101.29,18.98 101.05,18.44 101.14,18.14 100.91,17.58 100.96,17.54 101.17,17.50 101.69,17.89 101.77,18.03 101.95,18.08 102.10,18.21 102.55,17.97 102.66,17.82 102.81,17.95 103.05,18.03 103.09,18.14
+101.14,21.57 101.08,21.47 100.70,21.25 100.54,20.99 100.52,20.92 100.62,20.86 100.25,20.73 100.12,20.32
+97.32,28.22 97.54,28.51 97.60,28.52 98.06,28.19 98.30,27.55 98.45,27.66 98.65,27.57 98.74,26.79 98.69,26.19 98.56,26.07 98.66,25.86 98.47,25.79 98.33,25.59 98.14,25.57 98.01,25.29 97.82,25.25 97.71,25.03 97.74,24.87 97.58,24.77 97.53,24.49 97.67,24.38 97.71,24.23 97.56,23.91 97.69,23.90 98.21,24.11 98.58,24.07 98.84,24.12 98.68,23.91 98.83,23.62 98.80,23.52 98.88,23.38 98.86,23.19 99.42,23.07 99.51,22.96 99.39,22.83 99.34,22.50 99.21,22.28 99.19,22.13 99.92,22.03 99.94,21.76 100.10,21.66 100.15,21.48 100.60,21.47 101.08,21.76 101.13,21.74 101.14,21.57
+102.13,22.38 102.58,21.90 102.66,21.68 102.74,21.68 102.82,21.81 102.95,21.68 102.85,21.27 103.10,20.89 103.64,20.70 104.10,20.95 104.58,20.65 104.37,20.44 104.62,20.37 104.70,20.21 104.85,20.20 104.93,20.02 104.59,19.62 104.03,19.68 104.06,19.48 103.89,19.30 104.72,18.80 105.15,18.65 105.11,18.41 105.33,18.19 105.46,18.15 105.69,17.74 106.50,16.95 106.55,16.65 106.66,16.49 106.74,16.45 106.85,16.52 106.93,16.35 107.40,16.04 107.39,15.95 107.17,15.80 107.65,15.26 107.48,14.98 107.52,14.71
+27.40,5.11 27.07,5.20 26.82,5.06 25.53,5.31 25.40,5.26 25.25,5.02 25.07,4.97 24.77,4.93 24.32,4.99 23.42,4.66 23.12,4.74 22.86,4.72 22.71,4.59 22.42,4.13 21.69,4.28 21.54,4.24 20.56,4.46 20.23,4.83 19.81,5.09 19.50,5.13 19.07,4.89 18.83,4.52 18.59,4.35 18.61,3.48
+30.55,-2.40 30.42,-2.64 30.47,-2.69 30.43,-2.87 30.78,-2.98 30.79,-3.27 30.63,-3.35 30.63,-3.42 30.43,-3.59 30.15,-4.09 29.95,-4.31 29.72,-4.46 29.40,-4.45
+29.01,-2.72 29.02,-2.80 29.22,-3.05 29.21,-3.83 29.40,-4.45
+29.58,-1.39 29.35,-1.52 29.20,-1.72 29.13,-1.86 29.13,-2.20 28.88,-2.40 28.89,-2.64 29.01,-2.72
+35.27,5.49 34.98,5.86 34.71,6.66 34.06,7.23 33.90,7.51 33.67,7.67 33.23,7.76 33.00,7.90 33.28,8.44 33.95,8.44 34.07,8.55 34.08,9.46
+22.86,10.92 22.49,11.00 22.04,10.82 21.77,10.64 21.71,10.57 21.68,10.29 21.53,10.21 21.40,10.00 21.26,9.97 20.77,9.41 20.34,9.13 20.07,9.13 19.67,9.02 19.15,9.02 18.96,8.94 18.89,8.84 19.11,8.66 18.56,8.05 17.65,7.98 16.78,7.55 16.55,7.87 16.40,7.77 16.38,7.68 15.96,7.51 15.48,7.52
+13.29,2.16 13.22,2.26 11.56,2.30 11.35,2.30 11.33,2.17
+11.13,-3.92 11.23,-3.69 11.50,-3.52 11.69,-3.68 11.88,-3.67 11.83,-3.53 11.93,-3.32 11.72,-3.18 11.76,-2.98 11.64,-2.86 11.54,-2.84 11.61,-2.34 11.73,-2.39 11.95,-2.34 12.06,-2.41 12.45,-2.33 12.43,-1.93 12.59,-1.83 12.79,-1.93 12.99,-2.31 13.46,-2.40 13.73,-2.14 13.88,-2.33 13.89,-2.47 13.99,-2.49 14.20,-2.35 14.16,-2.22 14.25,-2.00 14.38,-1.89 14.47,-0.57 14.21,-0.43 14.07,-0.27 13.86,-0.20 13.95,0.35 14.09,0.54 14.32,0.62 14.43,0.90 14.18,1.37 13.85,1.42 13.22,1.25 13.25,1.37 13.17,1.79 13.29,2.16
+15.48,7.52 15.55,7.79 15.44,7.85 15.12,8.56 14.33,9.20 13.98,9.69 14.24,9.98 14.84,9.94 15.65,10.01 15.28,10.36 15.13,10.65 15.03,11.11 15.12,11.54 15.08,11.85 14.88,12.27 14.85,12.50 14.76,12.66 14.54,12.82 14.46,13.02 14.06,13.08
+14.06,13.08 14.20,12.38 14.52,12.30 14.62,12.15 14.58,11.53 14.20,11.27 13.98,11.21 13.70,10.87 13.54,10.61 13.41,10.17 13.27,10.04 13.20,9.56 12.93,9.43 12.78,8.82 12.58,8.62 12.40,8.60 12.23,8.28 12.02,7.59 11.77,7.27 11.86,7.12 11.58,6.89 11.48,6.60 11.24,6.45 11.11,6.46 11.01,6.74 10.61,7.06 10.48,6.89 10.21,6.89 10.14,7.00 9.78,6.76 9.66,6.53 9.00,5.92 8.80,5.20 8.56,4.76
+3.60,11.70 3.66,11.76 3.61,11.89 3.65,12.53 3.95,12.78 4.04,12.93 4.15,13.46 4.66,13.73 5.24,13.76 5.49,13.87 6.30,13.66 6.59,13.41 6.87,13.04 7.01,13.00 7.83,13.34 8.10,13.29 8.75,12.91 9.62,12.81 10.05,13.21 10.48,13.33 11.41,13.35 11.99,13.19 12.12,13.09 12.46,13.09 12.65,13.33 12.87,13.45 13.32,13.67 13.61,13.70
+1.19,6.09 0.98,6.32 0.74,6.45 0.53,6.85 0.63,7.35 0.51,7.44 0.50,7.55 0.61,7.73 0.58,8.15 0.69,8.35 0.37,8.76 0.49,8.85 0.47,9.12 0.53,9.40 0.41,9.49 0.26,9.43 0.23,9.46 0.34,9.60 0.26,9.64 0.32,9.69 0.38,10.29 -0.09,10.67 0.01,11.02 -0.07,11.12
+-2.70,9.48 -2.67,9.28 -2.75,9.05 -2.60,8.80 -2.51,8.21 -2.61,8.15 -2.61,8.05 -2.79,7.93 -2.99,7.20 -3.24,6.81 -3.24,6.65 -3.00,5.71 -2.96,5.64 -2.79,5.60 -2.76,5.36 -2.82,5.15 -3.11,5.09
+-5.52,10.43 -5.46,10.77 -5.49,11.04 -5.35,11.13 -5.25,11.38 -5.29,11.83 -5.11,11.97 -4.70,12.08 -4.43,12.34 -4.42,12.58 -4.48,12.67 -4.23,12.79 -4.33,13.12 -4.15,13.31 -3.95,13.40 -3.53,13.18 -3.30,13.28 -3.25,13.66 -2.95,13.65 -2.87,13.95 -2.59,14.23 -2.46,14.27 -2.11,14.17 -1.97,14.46 -1.70,14.51 -1.05,14.82 -0.76,15.05 -0.54,15.08 -0.41,15.01 -0.24,15.06 0.22,14.91
+-2.70,9.48 -2.82,9.43 -2.99,9.69 -3.22,9.90 -3.79,9.92 -4.27,9.74 -4.33,9.65 -4.63,9.71 -4.97,9.93 -5.10,10.24 -5.38,10.31 -5.52,10.43
+-8.49,7.56 -8.30,6.98 -8.33,6.80 -8.60,6.51 -8.29,6.32 -7.89,6.23 -7.80,5.98 -7.45,5.84 -7.40,5.55 -7.43,5.32 -7.57,5.08 -7.59,4.82 -7.54,4.35
+-8.49,7.56 -8.66,7.69 -8.89,7.26 -9.12,7.22 -9.26,7.38 -9.46,7.42 -9.37,7.70 -9.52,8.35 -9.68,8.48 -9.74,8.45 -9.78,8.54 -10.06,8.43 -10.15,8.52 -10.28,8.49
+-5.52,10.43 -5.84,10.39 -6.03,10.19 -6.20,10.23 -6.26,10.72 -6.43,10.67 -6.42,10.56 -6.65,10.66 -6.69,10.35 -6.95,10.34 -7.02,10.14 -7.36,10.26 -7.50,10.44 -7.66,10.43 -7.81,10.24 -7.99,10.16
+-15.04,10.94 -14.68,11.51 -14.27,11.66 -13.73,11.74 -13.74,12.01 -13.95,12.18 -13.71,12.31 -13.67,12.48 -13.73,12.67
+-11.39,12.40 -11.50,12.20 -11.31,12.02 -10.93,12.21 -10.71,11.90 -10.47,12.14 -10.27,12.21 -9.75,12.03 -9.66,12.14 -9.36,12.26 -9.40,12.46 -9.22,12.48 -9.04,12.40 -8.82,11.92 -8.82,11.67 -8.40,11.37 -8.67,11.01 -8.47,11.05 -8.34,10.99 -8.27,10.49 -8.01,10.32 -7.99,10.16
+107.52,14.71 107.41,14.56 107.29,14.59 106.94,14.33 106.78,14.34 106.50,14.58 106.35,14.45 106.23,14.48 106.17,14.37 105.98,14.34 106.12,14.05 106.07,13.92 105.90,13.92 105.74,14.08 105.53,14.16 105.35,14.11 105.18,14.35
+114.06,4.60 114.22,4.48 114.32,4.26 114.42,4.26 114.57,4.05 114.65,4.04 114.78,4.17 114.84,4.39 114.75,4.72 115.03,4.90
+-88.23,15.73 -88.96,15.15 -89.14,15.07 -89.22,14.87 -89.17,14.61 -89.36,14.42
+-77.37,8.66 -77.48,8.50 -77.20,7.97 -77.35,7.84 -77.35,7.71 -77.54,7.57 -77.59,7.54 -77.76,7.70 -77.74,7.54 -77.90,7.23
+-60.74,5.20 -61.39,5.94 -61.13,6.21 -61.20,6.59 -61.15,6.69 -60.87,6.79 -60.72,6.77 -60.35,7.00 -60.35,7.15 -60.58,7.16 -60.63,7.21 -60.61,7.32 -60.72,7.54 -60.51,7.81 -60.38,7.83 -60.03,8.05 -59.96,8.19 -59.85,8.25 -59.83,8.31 -60.02,8.55
+-60.74,5.20 -60.67,5.16 -60.60,4.95 -61.00,4.54 -61.28,4.52 -61.55,4.29 -61.82,4.20 -62.15,4.10 -62.41,4.16 -62.71,4.02 -62.76,3.67 -62.86,3.59 -62.97,3.59 -63.34,3.94 -63.53,3.89 -64.02,3.93 -64.19,4.13 -64.58,4.14 -64.79,4.28 -64.82,4.23 -64.67,4.01 -64.22,3.59 -64.22,3.20 -64.01,2.67 -64.05,2.50 -63.39,2.41 -63.43,2.16 -64.01,1.93 -64.11,1.62 -64.21,1.53 -64.30,1.46 -64.49,1.45 -64.73,1.25 -65.10,1.11 -65.47,0.69 -65.56,0.69 -65.52,0.84 -65.68,0.98 -66.06,0.79 -66.35,0.77 -66.88,1.22
+52.49,41.78 53.06,42.15 54.12,42.34 54.85,41.97 55.43,41.30 55.98,41.32
+55.98,41.32 57.02,41.26 57.12,41.35 57.02,41.45 56.96,41.86 57.29,42.12 57.81,42.19 58.03,42.49 58.28,42.43 58.40,42.29 58.47,42.30 58.15,42.63 58.26,42.69 58.48,42.66 58.59,42.78 58.88,42.56 59.16,42.51 59.35,42.32 59.86,42.30 59.99,42.21 59.94,41.97 60.20,41.80 60.08,41.76 60.14,41.59 60.09,41.40 60.45,41.22 60.87,41.25 61.24,41.19 61.50,41.28 61.90,41.09 62.10,40.68 62.38,40.33 62.48,39.98 63.51,39.38 63.76,39.16 64.16,38.95 64.31,38.98 65.61,38.24 65.97,38.24 66.57,38.01 66.63,37.93 66.53,37.79 66.52,37.35
+49.23,46.34 48.54,46.61 48.50,46.70 48.56,46.76 48.88,46.71 48.96,46.77 48.55,47.32 48.17,47.71 47.48,47.80 47.29,47.74 47.09,47.95 47.12,48.13 47.06,48.23 46.66,48.41 46.61,48.57 46.70,48.81 47.03,49.15 46.80,49.37 46.89,49.70 46.99,49.85 47.25,50.00 47.33,50.27 47.50,50.40 47.71,50.38 48.33,49.86 48.43,49.83 48.76,49.93 48.84,50.01 48.63,50.61 48.81,50.60 49.32,50.85 49.50,51.08 49.82,51.13 50.31,51.32 50.79,51.73 51.16,51.65 51.34,51.48 51.61,51.48 52.22,51.71 52.57,51.48 53.34,51.48 54.14,51.04 54.42,50.78 54.47,50.58 54.56,50.54 54.65,50.66 54.55,50.95 54.64,51.01 55.36,50.67 55.69,50.58 56.05,50.71 56.14,50.84 56.49,51.02 56.62,50.98 57.01,51.07 57.44,50.89 57.65,50.93 57.84,51.09 58.36,51.06 58.88,50.69 59.45,50.62 59.52,50.58 59.52,50.49 59.81,50.58 59.96,50.80 60.06,50.85 60.42,50.68 60.94,50.70 61.39,50.86 61.59,51.23 61.55,51.32 61.36,51.44 60.46,51.65 60.39,51.77 60.03,51.93 60.43,52.13 60.67,52.15 60.99,52.34 60.77,52.68 61.05,52.97 61.97,52.94 62.08,53.01 62.01,53.11 61.66,53.23 61.20,53.29 61.16,53.34 61.23,53.45 61.53,53.52 61.47,53.58 61.25,53.55 60.98,53.62 61.11,53.75 61.14,53.96 61.23,54.02 61.33,54.05 61.93,53.95 63.85,54.24 64.46,54.38 64.93,54.40 65.09,54.34 65.24,54.52 65.48,54.62 65.71,54.62 65.91,54.69 66.22,54.67 68.16,54.98 68.24,55.05 68.21,55.16 68.52,55.20 68.98,55.39 69.49,55.36 70.18,55.16 70.49,55.28 70.74,55.31 70.91,55.13 71.19,54.60 71.15,54.36 71.05,54.26 71.09,54.21 71.34,54.16 72.00,54.21 72.19,54.33 72.39,54.12 72.45,53.94 72.59,54.00 72.56,54.09 72.62,54.13 72.91,54.11 73.23,53.96 73.62,54.07 73.71,54.04 73.68,53.93 73.40,53.81 73.31,53.71 73.29,53.60 73.41,53.45 73.86,53.62 74.21,53.58 74.35,53.49 74.45,53.65 74.83,53.83 75.22,53.89 75.38,53.97 75.44,54.09 76.84,54.44 76.65,54.15 76.42,54.15 76.48,54.02 77.86,53.27 79.47,51.49 79.99,50.77 80.07,50.76 80.09,50.84 80.22,50.91 80.42,50.95 80.45,51.18 80.74,51.29 80.88,51.28 80.97,51.19 81.13,51.19 81.07,50.97 81.39,50.96 81.47,50.74 82.49,50.73 82.76,50.89 83.36,50.99 83.95,50.77 84.18,50.52 84.32,50.24 84.99,50.06 85.00,49.89 85.23,49.62 86.18,49.50 86.68,49.78 86.73,49.70 86.63,49.56 86.81,49.49 87.00,49.29 87.23,49.22 87.32,49.09
+34.20,31.32 34.90,29.48
+33.98,4.22 34.38,4.62
+41.88,3.98 41.14,3.96 40.77,4.27 39.84,3.85 39.54,3.47 39.23,3.48 38.09,3.65 36.91,4.41 36.08,4.45 35.92,4.62
+23.38,-17.64 21.42,-18.00 21.11,-17.96 20.75,-18.02 20.39,-17.89 18.96,-17.80 18.72,-17.70 18.40,-17.40 14.02,-17.41 13.48,-17.04 13.10,-16.97 12.55,-17.21 12.01,-17.17 11.74,-17.25
+25.26,-17.79 25.64,-17.82 26.00,-17.97 26.14,-17.91 26.33,-17.93 26.78,-18.04 27.02,-17.96 27.93,-16.90 28.76,-16.53 28.83,-16.42 28.91,-15.99 29.49,-15.70 30.40,-15.64
+23.38,-17.64 24.27,-17.48 24.73,-17.52 25.00,-17.57 25.26,-17.79
+31.29,-22.40 32.43,-21.30 32.35,-21.14 32.48,-20.95 32.49,-20.66 32.67,-20.52 32.99,-19.98 33.01,-19.87 32.78,-19.39 32.85,-19.10 32.70,-18.94 32.72,-18.83 32.88,-18.73 32.99,-18.36 32.97,-17.25 32.88,-16.88 32.95,-16.71 32.24,-16.45 31.94,-16.43 31.69,-16.21 31.49,-16.18 31.24,-16.02 30.44,-16.00 30.40,-15.64
+12.28,-6.00 12.42,-6.05 13.18,-5.86 16.43,-5.90 16.70,-6.16 16.74,-6.62 16.92,-6.93 16.98,-7.26 17.58,-8.10 18.01,-8.11 18.56,-7.94 18.94,-8.00 19.34,-7.97 19.53,-7.14 19.66,-7.04 19.88,-6.99 20.59,-6.92 20.54,-7.18 20.61,-7.28 21.78,-7.31 21.84,-7.42 21.80,-8.11 21.90,-8.34 21.91,-8.69 21.81,-9.47 22.20,-10.04 22.27,-10.26 22.31,-10.69 22.18,-10.89 22.23,-11.12 22.31,-11.20 22.56,-11.06 23.08,-11.09 23.46,-10.97 23.83,-11.01 23.97,-10.87
+-16.56,13.59 -15.51,13.59 -15.43,13.73 -15.11,13.81 -14.94,13.79 -14.41,13.50 -13.98,13.54 -13.83,13.41 -13.85,13.34 -14.25,13.24 -15.15,13.56 -15.29,13.40 -15.81,13.33 -15.83,13.16 -16.65,13.15 -16.76,13.06
+0.22,14.91 0.16,14.50 0.38,14.25 0.35,14.14 0.43,13.97 0.62,13.70 0.90,13.61 1.20,13.36 0.99,13.36 0.99,13.04 1.56,12.64 1.79,12.61 1.96,12.71 2.10,12.70 2.23,12.47 2.07,12.38 2.07,12.31 2.39,11.90
+18.61,3.48 18.47,3.62 18.16,3.50 17.49,3.69 16.61,3.51 16.48,3.17 16.47,2.83 16.18,2.27
+16.18,2.26 16.08,2.11 16.14,1.72 16.06,1.68 15.74,1.92 15.34,1.94 15.16,2.04 14.90,2.01 14.88,2.08 14.76,2.08 14.58,2.20 14.48,2.15 13.29,2.16
+15.48,7.52 15.21,7.21 14.74,6.28 14.51,6.16 14.43,6.04 14.62,5.87 14.56,5.28 14.64,5.18 14.73,4.60 15.06,4.28 15.14,4.04 15.03,4.02 15.13,3.83 15.77,3.13 15.90,3.10 16.06,2.91 16.18,2.26
+33.98,4.22 33.49,3.76 33.15,3.77 33.00,3.88 32.34,3.71 32.14,3.52 31.94,3.61 31.80,3.80 31.55,3.68 31.15,3.79 30.93,3.63 30.84,3.49
+13.07,-4.63 12.83,-4.74 12.45,-5.07 12.52,-5.15 12.50,-5.70 12.21,-5.76
+31.95,-25.96 31.99,-24.46 31.80,-23.89 31.55,-23.48 31.29,-22.40
+33.20,-14.01 30.23,-14.99 30.40,-15.64
+34.96,-11.58 34.62,-11.62 34.36,-12.16 34.56,-13.36 34.66,-13.49 34.91,-13.55 35.25,-13.90 35.85,-14.67 35.89,-14.89 35.81,-15.27 35.82,-15.68 35.76,-16.06 35.36,-16.16 35.17,-16.56 35.28,-16.81 35.27,-17.12 35.06,-17.08 35.08,-16.83 34.93,-16.76 34.42,-16.25 34.40,-16.08 34.25,-15.89 34.54,-15.30 34.51,-14.60 34.33,-14.41 33.64,-14.57 33.20,-14.01
+29.58,-1.39 29.56,-0.98 29.72,0.10 29.93,0.50 29.94,0.82 30.18,0.97 30.32,1.19 30.48,1.24 31.25,2.04 31.27,2.15 31.18,2.27 30.96,2.40 30.73,2.46 30.85,2.89 30.75,3.04 30.91,3.41 30.84,3.49
+36.52,14.26 36.43,15.13 36.52,15.25 36.91,16.30 36.89,16.62 36.98,16.80 37.01,17.06 37.41,17.06 37.55,17.32 37.78,17.46 38.25,17.58 38.61,18.01
+42.38,12.47 42.13,12.77 41.95,12.88 41.77,13.18 41.36,13.50 40.82,14.11 40.14,14.46 39.90,14.44 39.53,14.54 39.20,14.48 39.02,14.63 38.81,14.48 38.43,14.43 38.22,14.65 37.88,14.85 37.57,14.15 37.26,14.45 37.02,14.27 36.81,14.32 36.52,14.26
+27.35,57.53 27.40,57.67 27.54,57.80 27.78,57.87 27.67,57.93 27.50,58.22 27.53,58.44 27.43,58.79 27.76,59.05 27.90,59.28 28.15,59.37 28.01,59.48
+74.31,32.81 74.66,32.76 74.69,32.49 74.99,32.46 75.30,32.32
+-84.35,10.98 -84.70,11.05 -84.91,10.95 -85.58,11.19 -85.74,11.06
+-82.88,8.07 -83.03,8.34 -82.86,8.45 -82.86,8.64 -82.92,8.74 -82.73,8.92 -82.94,9.06 -82.94,9.45 -82.80,9.59 -82.64,9.51 -82.56,9.58
+-66.88,1.22 -67.21,2.39 -67.62,2.79 -67.86,2.79 -67.83,2.89 -67.31,3.42 -67.66,3.86 -67.86,4.51 -67.82,5.27 -67.64,5.56 -67.58,5.83 -67.47,5.93 -67.48,6.18 -67.86,6.29 -68.47,6.16 -68.94,6.20 -69.27,6.10 -69.43,6.12 -70.13,6.95 -70.74,7.09 -71.13,6.99 -72.01,7.03 -72.21,7.37 -72.39,7.42 -72.47,7.52 -72.45,7.97 -72.36,8.09 -72.39,8.29 -72.67,8.63 -72.80,9.11 -72.96,9.14 -73.06,9.26 -73.37,9.19 -73.01,9.79 -72.87,10.49 -72.69,10.84 -72.45,11.11 -72.25,11.20 -71.96,11.67 -71.32,11.86
+-68.44,-52.36 -68.46,-52.29 -69.96,-52.01 -71.97,-51.96 -71.95,-51.88 -72.41,-51.54 -72.30,-51.30 -72.38,-51.10 -72.28,-50.91 -72.34,-50.68 -72.51,-50.61 -73.15,-50.74 -73.31,-50.36 -73.50,-50.13 -73.48,-49.77
+-68.63,-52.65 -68.65,-54.92 -68.06,-54.88 -67.35,-54.93 -66.48,-55.11
+22.77,54.36 19.60,54.46
+48.44,28.54 47.67,28.53 47.43,28.99 46.53,29.10
+44.77,37.14 44.88,36.80 45.02,36.70 45.05,36.47 45.24,36.36 45.36,36.02 45.56,35.98 45.78,35.82 46.27,35.77 46.00,35.61 45.98,35.48 46.11,35.32 46.13,35.13 45.92,35.03 45.68,34.80 45.64,34.57 45.50,34.58 45.44,34.42 45.54,34.22 45.40,33.97 45.74,33.60 45.88,33.61 45.87,33.49 46.02,33.42 46.15,33.23 46.08,33.09 46.11,32.96 46.38,32.93 47.12,32.47 47.37,32.42 47.51,32.15 47.83,31.79 47.68,31.40 47.68,31.00 48.01,30.99 48.01,30.47 48.33,30.29 48.43,30.04 48.55,29.96
+61.26,35.62 61.25,35.87 61.15,35.98 61.21,36.19 61.12,36.64 60.34,36.64 60.06,36.96 59.45,37.25 59.30,37.51 58.82,37.68 58.26,37.67 57.98,37.83 57.35,37.97 57.31,38.13 57.19,38.22 56.44,38.25 56.32,38.19 56.27,38.08 55.58,38.10 55.38,38.05 54.90,37.78 54.70,37.47 54.19,37.33 53.91,37.34
+140.97,-2.60 140.97,-6.35 140.86,-6.74 140.98,-6.91 140.98,-9.12
+9.52,30.23 9.31,30.12 9.64,29.64 9.81,29.18 9.92,27.79 9.75,27.33 9.89,26.85 9.88,26.63 9.86,26.55 9.49,26.33 9.45,26.07 10.00,25.33 10.03,25.05 10.26,24.59 10.40,24.49 10.69,24.55 11.51,24.31 11.97,23.52
+-13.73,12.67 -15.20,12.68 -15.57,12.49 -16.71,12.35
+-11.39,12.40 -12.40,12.34 -12.93,12.53 -13.06,12.49 -13.08,12.63 -13.73,12.67
+0.90,10.99 0.49,10.95 -0.07,11.12
+-139.06,60.00 -139.19,60.08 -139.08,60.34 -139.68,60.33 -139.97,60.18 -140.45,60.30 -140.53,60.22 -141.00,60.30 -141.00,69.65
+-130.62,54.71 -130.21,55.03 -130.02,55.28 -130.12,55.69 -130.03,55.89 -130.06,56.07 -130.41,56.12 -130.48,56.23 -130.74,56.34 -131.58,56.60 -131.82,56.59 -131.87,56.79 -132.10,56.86 -132.03,57.03 -132.34,57.08 -132.23,57.20 -133.42,58.34 -133.40,58.41 -133.82,58.71 -134.30,58.90 -134.44,59.09 -134.94,59.29 -135.07,59.44 -135.05,59.58 -135.48,59.79 -136.32,59.60 -136.25,59.53 -136.35,59.46 -136.47,59.46 -136.47,59.28 -136.58,59.15 -136.81,59.15 -137.44,58.90 -137.52,58.92 -137.48,58.99 -137.59,59.23 -138.63,59.78 -138.71,59.90 -139.06,60.00
+-123.31,48.99 -122.69,48.99
+-88.89,15.89 -89.24,15.89 -89.16,17.81
+-75.28,-0.11 -75.48,-0.16 -75.63,-0.12 -75.26,-0.59 -75.25,-0.95 -75.41,-0.92 -75.57,-1.53 -76.09,-2.13 -76.68,-2.56 -77.86,-2.98 -78.18,-3.35 -78.16,-3.47 -78.23,-3.49 -78.35,-3.40 -78.42,-3.78 -78.68,-4.33 -78.69,-4.56 -78.91,-4.71 -78.92,-4.86 -79.03,-4.97 -79.33,-4.93 -79.50,-4.67 -79.52,-4.54 -79.64,-4.45 -79.80,-4.48 -80.14,-4.30 -80.38,-4.46 -80.48,-4.43 -80.35,-4.21 -80.49,-4.17 -80.49,-4.01 -80.30,-4.01 -80.18,-3.88 -80.32,-3.39
+-69.97,-4.24 -70.34,-3.81 -70.53,-3.87 -70.74,-3.78 -70.07,-2.75 -70.10,-2.66 -70.97,-2.21 -71.40,-2.33 -71.75,-2.15 -71.98,-2.33 -72.22,-2.40 -72.40,-2.43 -72.63,-2.35 -72.94,-2.39 -73.15,-2.28 -73.13,-2.08 -73.20,-1.83 -73.50,-1.69 -73.52,-1.45 -73.66,-1.25 -74.25,-0.97 -74.42,-0.58 -74.80,-0.20 -74.95,-0.19 -75.14,-0.05 -75.28,-0.11
+-66.88,1.22 -67.08,1.19 -67.12,1.70 -67.40,2.12 -67.56,2.07 -67.82,1.79 -67.94,1.75 -68.19,1.99 -68.26,1.85 -68.18,1.72 -69.32,1.72 -69.54,1.77 -69.85,1.71 -69.85,1.06 -69.31,1.05 -69.16,0.86 -69.15,0.66 -69.28,0.63 -69.47,0.73 -70.05,0.58 -70.07,-0.14 -69.92,-0.32 -69.63,-0.51 -69.61,-0.76 -69.45,-1.00 -69.40,-1.19 -69.97,-4.24
+-69.58,-10.95 -68.69,-12.50 -68.76,-12.69 -68.98,-12.88 -68.98,-13.50 -69.07,-13.68 -68.87,-14.17 -69.00,-14.27 -69.01,-14.38 -69.36,-14.80 -69.37,-14.96 -69.17,-15.24 -69.42,-15.64 -69.22,-16.15 -68.84,-16.34 -69.03,-16.48 -69.02,-16.64 -69.20,-16.77 -69.44,-17.09 -69.62,-17.20 -69.51,-17.50
+-69.58,-10.95 -68.85,-11.01 -68.73,-11.12 -68.62,-11.11 -68.31,-10.98 -68.07,-10.70 -67.72,-10.68 -67.42,-10.39 -67.11,-10.27 -66.58,-9.90 -65.92,-9.79 -65.56,-9.80 -65.40,-9.71 -65.31,-9.87 -65.30,-10.15 -65.45,-10.51 -65.32,-11.02 -65.39,-11.25 -65.18,-11.65 -65.19,-11.75 -65.09,-11.74 -64.99,-11.98 -64.51,-12.25 -64.42,-12.44 -63.94,-12.53 -63.69,-12.48 -63.35,-12.68 -63.07,-12.67 -63.02,-12.81 -62.77,-13.00 -62.12,-13.16 -61.79,-13.53 -61.08,-13.49 -60.51,-13.79 -60.40,-14.02 -60.47,-14.18 -60.30,-14.62 -60.27,-15.09 -60.58,-15.10 -60.24,-15.48 -60.18,-16.27 -58.54,-16.33 -58.35,-16.28 -58.35,-16.49 -58.48,-16.70 -58.40,-17.23 -57.99,-17.51 -57.83,-17.51 -57.59,-18.12 -57.50,-18.21 -57.57,-18.28 -57.78,-18.91 -57.73,-18.92 -57.72,-19.04 -57.80,-19.08 -58.13,-19.74 -57.86,-19.98 -58.16,-20.16
+-69.97,-4.24 -70.05,-4.33 -70.24,-4.30 -70.40,-4.15 -70.80,-4.17 -70.97,-4.35 -71.84,-4.50 -72.35,-4.79 -72.70,-5.07 -72.89,-5.12 -72.98,-5.63 -73.24,-6.10 -73.14,-6.47 -73.76,-6.91 -73.80,-7.08 -73.72,-7.31 -73.96,-7.38 -74.00,-7.56 -73.72,-7.78 -73.78,-7.94 -73.64,-8.07 -73.55,-8.35 -73.36,-8.48 -73.30,-8.65 -72.97,-8.99 -72.97,-9.12 -73.21,-9.41 -72.81,-9.41 -72.38,-9.51 -72.17,-9.84 -72.14,-10.01 -71.24,-9.97 -70.54,-9.44 -70.64,-9.82 -70.64,-11.01 -70.53,-10.95 -70.29,-11.06 -69.96,-10.93 -69.58,-10.95
+-62.65,-22.23 -62.28,-21.07 -62.28,-20.56 -61.92,-20.06 -61.76,-19.65 -60.01,-19.30 -59.09,-19.29 -58.18,-19.82 -58.16,-20.16
+-17.05,20.81 -16.96,21.33 -13.02,21.33 -13.15,22.82 -13.03,23.00 -12.62,23.27 -12.02,23.47 -12.02,26.00 -8.68,26.00 -8.68,27.29
+-8.68,27.29 -4.82,25.00
+-8.68,27.66 -8.66,28.72 -7.69,29.35 -7.49,29.39 -7.16,29.61 -6.64,29.57 -6.52,29.66 -6.48,29.82 -6.00,29.83 -5.45,29.96 -5.18,30.17 -4.97,30.47 -4.32,30.70 -3.99,30.91 -3.67,30.96 -3.62,31.07 -3.83,31.20 -3.79,31.36 -3.83,31.66 -3.02,31.83 -2.86,32.07 -2.45,32.13 -1.28,32.09
+-8.68,27.29 -8.68,27.66
+-12.28,14.81 -12.86,15.24 -12.93,15.45 -13.21,15.62 -13.41,16.06 -13.51,16.14 -13.87,16.15 -14.09,16.42 -14.30,16.58 -14.53,16.66 -14.99,16.68 -15.77,16.49 -16.24,16.53 -16.44,16.20 -16.54,15.84
+-4.82,25.00 -6.59,24.99 -5.63,16.57 -5.36,16.28 -5.51,15.50 -9.18,15.50 -9.34,15.53 -9.35,15.68 -9.43,15.62 -9.45,15.46 -9.94,15.37 -10.70,15.42 -10.95,15.15 -11.50,15.64 -11.76,15.43 -11.94,14.89 -12.10,14.75 -12.28,14.81
+4.23,19.14 3.40,18.99 3.26,19.01 3.11,19.15 3.26,19.41 3.20,19.79 3.13,19.85 2.41,20.06 2.22,20.25 1.75,20.33 1.61,20.56 1.17,20.82 1.15,21.10 -4.82,25.00
+4.23,19.14 5.84,19.48 7.48,20.87 11.97,23.52
+9.52,30.23 9.04,32.07 8.33,32.54 8.11,33.06 7.73,33.27 7.50,33.83 7.51,34.08 7.75,34.25 7.84,34.41 8.12,34.56 8.25,34.73 8.28,34.98 8.39,35.20 8.25,35.80 8.35,36.37 8.21,36.52 8.44,36.76 8.60,36.83 8.58,36.94
+23.98,19.50 15.98,23.45 14.98,23.00
+24.98,22.00 24.98,20.00 23.98,20.00 23.98,19.50
+25.15,31.65 24.85,31.33 24.96,30.68 24.70,30.20 24.98,29.18 24.98,22.00
+22.86,10.92 22.92,11.34 22.59,11.58 22.58,11.99 22.47,12.07 22.35,12.66 22.23,12.71 21.93,12.68 21.83,12.79 21.99,13.11 22.23,13.33 22.11,13.80 22.17,13.91 22.54,14.16 22.38,14.55 22.67,14.72 22.76,15.00 22.93,15.16 22.93,15.53 23.11,15.70 23.97,15.72 23.98,19.50
+24.98,22.00 31.21,21.99 31.40,22.20 31.49,22.15 31.43,22.00 36.87,22.00
+41.88,3.98 41.34,3.20 40.96,2.81 40.98,-0.87 41.52,-1.57 41.53,-1.70
+42.92,11.00 42.66,10.60 42.84,10.20 43.07,9.93 43.18,9.88 43.48,9.38 43.62,9.34 43.98,9.01 46.98,8.00 47.98,8.00
+30.75,-8.19 28.90,-8.49 28.93,-8.59 28.87,-8.79 28.40,-9.22 28.60,-9.68 28.65,-10.55 28.36,-11.48 28.38,-11.57 28.48,-11.81 29.06,-12.35 29.49,-12.42 29.51,-12.23 29.80,-12.16 29.78,-13.44 29.65,-13.41 29.63,-13.30 29.55,-13.25 29.20,-13.40 29.01,-13.37 28.73,-12.93 28.55,-12.84 28.41,-12.52 27.57,-12.23 27.42,-11.94 27.24,-11.78 27.16,-11.58 27.05,-11.62 26.95,-11.90 26.82,-11.97 26.03,-11.89 25.51,-11.75 25.35,-11.62 25.29,-11.21 24.52,-11.44 24.38,-11.42 24.34,-11.37 24.40,-11.26 24.37,-11.13 24.14,-11.03 24.08,-10.89 23.97,-10.87
+23.38,-17.64 22.15,-16.60 22.04,-16.26 21.98,-15.96 21.98,-13.00 23.96,-12.99 23.88,-12.80 23.99,-12.42 23.97,-11.64 24.05,-11.41 23.97,-10.87
+33.90,-1.00 33.94,0.17 34.16,0.61 34.41,0.87 34.48,1.04 34.80,1.24 34.78,1.38 34.97,1.64 34.98,1.77 34.91,2.48 34.74,2.82 34.59,2.92 34.52,3.12 34.45,3.16 34.40,3.41 34.44,3.65 34.17,3.81 34.19,3.87 33.98,4.22
+33.90,-1.00 37.64,-3.05 37.69,-3.25 37.62,-3.51 39.22,-4.69
+11.33,2.17 9.98,2.17 9.80,2.30
+11.33,2.17 11.34,1.00 10.03,1.00 9.91,0.96 9.76,1.07 9.59,1.03
+25.26,-17.79 24.91,-17.82 24.53,-18.05 24.36,-17.98 24.24,-18.02 23.60,-18.46 23.30,-18.03 23.22,-18.00 20.97,-18.32 20.98,-21.96 19.98,-22.00 19.98,-24.75
+19.98,-24.78 19.98,-28.45 19.54,-28.57 19.31,-28.73 19.25,-28.90 19.16,-28.94 18.84,-28.87 18.10,-28.87 17.45,-28.70 17.35,-28.50 17.36,-28.27 17.06,-28.03 16.88,-28.13 16.76,-28.45 16.45,-28.62
+19.98,-24.75 19.98,-24.78
+0.90,10.99 0.79,10.71 0.76,10.39 1.33,10.00 1.39,9.36 1.60,9.05 1.62,7.00 1.53,6.99 1.60,6.61 1.78,6.29 1.62,6.22
+42.80,16.37 43.17,16.69 43.18,16.81 43.12,16.94 43.16,17.21 43.24,17.27 43.19,17.36 43.42,17.52 43.92,17.32 44.16,17.40 45.15,17.43 45.54,17.30 46.31,17.23 46.73,17.27 46.98,16.95 47.14,16.95 47.44,17.11 47.58,17.45 48.17,18.16 49.04,18.58 51.98,19.00
+51.98,19.00 52.73,17.30 52.80,17.27 53.09,16.65
+55.19,22.70 55.64,22.00 54.98,20.00 51.98,19.00
+55.19,22.70 55.10,22.62 52.56,22.93 51.59,24.08 51.57,24.29
+42.36,37.11 41.79,36.60 41.42,36.51 41.30,36.38 41.25,36.07 41.35,35.64 41.22,35.29 41.19,34.77 40.99,34.43 40.69,34.33 38.77,33.37
+35.79,32.73 36.37,32.39 36.82,32.32 38.77,33.37
+35.61,32.68 35.79,32.73
+39.15,32.12 39.29,32.24 39.25,32.35 39.04,32.31 38.98,32.47 39.06,32.49 38.77,33.37
+34.95,29.35 36.07,29.20 36.48,29.50 36.76,29.87 37.47,30.00 37.65,30.33 37.98,30.50 36.96,31.49 38.96,31.99 39.15,32.12
+46.53,29.10 46.36,29.06 44.69,29.20 42.07,31.08 40.37,31.94 39.15,32.12
+61.59,25.20 61.66,25.75 61.75,25.84 61.84,26.23 62.13,26.37 62.24,26.36 62.31,26.49 62.44,26.56 63.16,26.65 63.30,27.15 63.17,27.25 62.76,27.25 62.81,27.50 62.76,28.24 62.56,28.24 62.35,28.41 61.89,28.55 61.62,28.79 61.32,29.37 60.84,29.86
+60.84,29.86 61.81,30.91 61.76,31.29 61.66,31.38 60.82,31.50 60.83,32.25 60.56,33.06 60.56,33.14 60.92,33.51 60.51,33.64 60.49,34.09 60.64,34.31 60.89,34.32 60.73,34.52 60.95,34.65 61.08,34.86 61.15,35.09 61.10,35.27 61.19,35.31 61.28,35.51 61.26,35.62
+73.73,36.89 74.04,36.83 74.54,37.02
+60.84,29.86 62.48,29.41 63.57,29.50 64.10,29.39 64.39,29.54 65.10,29.56 66.18,29.84 66.31,29.97 66.24,30.11 66.35,30.80 66.40,30.91 66.60,31.02 66.83,31.26 66.92,31.31 67.45,31.23 67.74,31.34 67.58,31.51 68.02,31.68 68.16,31.80 68.44,31.75 68.60,31.80 68.87,31.63 69.08,31.74 69.28,31.94 69.24,32.43 69.41,32.68 69.50,33.02 69.92,33.11 70.26,33.29 70.28,33.37 70.13,33.62 69.87,33.90 69.89,34.01 69.99,34.05 70.33,33.96 70.65,33.95 71.05,34.05 71.10,34.37 70.97,34.53 71.62,35.18 71.55,35.29 71.60,35.41 71.57,35.55 71.40,35.88 71.19,36.04 71.23,36.12 71.62,36.44 71.77,36.43 72.25,36.73 72.62,36.83 73.73,36.89
+70.95,42.25 70.72,42.17 70.58,42.04 70.42,42.08 70.10,41.82 69.15,41.43 68.99,41.21 68.58,40.88 68.57,40.62 68.42,40.62 68.05,40.81 68.11,41.03 67.94,41.20 66.71,41.18 66.50,41.99 66.01,42.00 66.10,42.99 65.80,42.88 65.50,43.31 64.91,43.71 64.44,43.55 63.21,43.63 61.99,43.49 61.16,44.17 61.01,44.39 58.56,45.56 55.98,44.99 55.98,41.32
+13.61,13.70 13.45,14.38 14.37,15.75 15.47,16.91 15.74,19.90 15.96,20.35 15.59,20.73 15.54,20.87 15.61,20.95 15.18,21.52 15.17,21.92 14.98,23.00
+11.97,23.52 13.48,23.18 14.22,22.62 14.98,23.00
+0.22,14.91 0.29,14.98 0.95,14.98 1.30,15.27 3.00,15.34 3.06,15.43 3.50,15.36 3.52,15.48 3.84,15.70 4.12,16.36 4.23,17.00 4.23,19.14
+-0.07,11.12 -0.30,11.17 -0.63,10.93 -0.70,10.99 -1.04,11.01 -2.83,11.00 -2.91,10.59 -2.79,10.43 -2.78,9.75 -2.70,9.48
+-13.29,9.05 -13.03,9.10 -12.96,9.26 -12.76,9.37 -12.50,9.86 -12.43,9.90 -12.28,9.93 -12.14,9.88 -11.92,9.92 -11.91,9.99 -11.27,10.00 -10.69,9.31 -10.75,9.10 -10.62,9.06 -10.61,8.87 -10.50,8.69 -10.71,8.34 -10.56,8.32 -10.39,8.48 -10.28,8.49
+5.79,49.54 6.01,49.45 6.18,49.50 6.34,49.45
+56.08,26.06 56.17,26.05 56.14,25.69 56.30,25.65
+30.51,-1.07 30.36,-1.07 30.10,-1.37 29.93,-1.47 29.83,-1.34 29.58,-1.39
+30.51,-1.07 30.51,-1.21 30.81,-1.56 30.88,-2.14 30.83,-2.34 30.55,-2.40
+33.90,-1.00 30.81,-0.99 30.51,-1.07
+34.59,-11.97 34.54,-12.02 34.62,-12.07 34.59,-11.97
+87.32,49.09 87.82,49.16
+45.50,40.66 45.48,40.61 45.55,40.62 45.50,40.66
+44.99,41.09 45.00,41.02 44.99,41.09
+12.44,43.98 12.40,43.93 12.49,43.90 12.50,43.99 12.44,43.98
+70.57,41.02 70.65,40.94 70.57,41.02
+-117.13,32.53 -114.72,32.72 -114.84,32.51 -111.04,31.32 -108.21,31.33 -108.21,31.78 -106.45,31.77 -106.15,31.45 -104.92,30.58 -104.68,30.13 -104.62,29.85 -104.40,29.57 -103.26,29.00 -103.09,29.04 -102.89,29.22 -102.73,29.64 -102.34,29.86 -101.99,29.80 -101.55,29.81 -101.38,29.74 -100.75,29.18 -100.33,28.50 -100.30,28.33 -99.75,27.73 -99.51,27.55 -99.46,27.06 -99.23,26.76 -99.11,26.45 -98.28,26.11 -97.80,26.04 -97.38,25.87 -97.15,25.96
+-92.24,14.55 -92.16,14.69 -92.16,14.96 -92.07,15.07 -92.20,15.28 -91.74,16.07 -90.45,16.07 -90.42,16.39 -90.63,16.51 -90.71,16.71 -91.41,17.26 -90.99,17.25 -90.99,17.82 -89.16,17.81 -89.13,17.97 -89.05,18.00 -88.90,17.91 -88.81,17.97 -88.46,18.48 -88.04,18.42 -88.04,18.20 -87.83,18.18
+-54.62,-25.58 -54.61,-25.43 -54.44,-25.12 -54.28,-24.31 -54.32,-24.13 -54.24,-24.05 -54.63,-23.81 -55.19,-24.02 -55.42,-23.95 -55.65,-22.89 -55.62,-22.67 -55.85,-22.31 -56.25,-22.26 -56.45,-22.08 -56.63,-22.23 -56.94,-22.27 -57.57,-22.18 -57.72,-22.10 -57.96,-22.11 -57.95,-21.49 -57.83,-21.00 -58.16,-20.16
+-62.65,-22.23 -62.21,-22.61 -61.80,-23.18 -61.21,-23.56 -61.03,-23.76 -60.51,-23.96 -59.89,-24.09 -59.19,-24.56 -58.37,-24.96 -57.96,-25.05 -57.64,-25.33 -57.57,-25.53 -57.75,-25.70 -57.89,-26.01 -58.11,-26.18 -58.20,-26.38 -58.19,-26.63 -58.32,-26.86 -58.62,-27.13 -58.60,-27.31 -58.17,-27.27 -57.11,-27.47 -56.60,-27.47 -56.44,-27.55 -56.16,-27.32 -55.71,-27.41 -55.43,-27.01 -55.14,-26.93 -54.83,-26.65 -54.68,-26.31 -54.62,-25.58
+-62.65,-22.23 -62.84,-22.00 -63.92,-22.03 -64.27,-22.60 -64.33,-22.83 -64.61,-22.23 -64.99,-22.11 -65.77,-22.10 -66.22,-21.80 -66.37,-22.11 -66.71,-22.22 -66.80,-22.41 -67.03,-22.55 -67.19,-22.82
+26.62,48.26 26.85,48.39 27.23,48.37 27.55,48.48 27.82,48.42 28.09,48.26 28.29,48.24 28.46,48.09 28.53,48.15 28.77,48.12 28.92,47.95 29.13,47.96 29.21,47.78 29.13,47.49 29.54,47.27 29.51,47.13 29.57,46.96 29.88,46.83 29.94,46.72 29.92,46.54 30.13,46.42 29.84,46.35 29.71,46.45 29.61,46.40 29.30,46.47 29.20,46.38 29.19,46.52 28.96,46.46 28.93,46.36 29.01,46.18 28.95,46.05 28.74,45.94 28.73,45.85 28.49,45.67 28.50,45.52 28.21,45.45
+67.76,37.17 67.96,36.97 68.07,36.95 68.91,37.33 69.30,37.12 69.41,37.21 69.40,37.40 69.49,37.55 69.82,37.61 70.04,37.55 70.19,37.58 70.25,37.66 70.21,37.92 70.62,38.33 70.88,38.46 71.26,38.31 71.33,38.17 71.28,37.92 71.58,37.91 71.43,37.13 71.53,36.85 71.67,36.70 71.80,36.69 72.36,36.98 72.66,37.03 72.90,37.27 73.38,37.46 73.72,37.42 73.65,37.24 74.17,37.33 74.35,37.42 74.66,37.39 74.89,37.23
+66.52,37.35 66.83,37.37 67.07,37.33 67.20,37.24 67.52,37.27 67.76,37.17
+61.26,35.62 61.34,35.63 61.62,35.43 61.98,35.44 62.31,35.17 62.46,35.25 62.69,35.26 63.06,35.45 63.17,35.68 63.13,35.85 64.01,36.01 64.51,36.34 64.82,37.13 65.09,37.24 65.55,37.25 65.64,37.47 65.77,37.57 66.11,37.41 66.52,37.35
+92.57,21.98 92.49,22.69 92.36,22.93 92.25,23.68 91.93,23.69 91.94,23.50 91.75,23.29 91.75,23.05 91.62,22.98 91.51,23.03 91.44,23.20 91.37,23.20 91.37,23.07 91.32,23.10 91.16,23.66 91.23,23.92 91.37,24.09 91.88,24.20 91.95,24.36 92.10,24.41 92.23,24.88 92.44,24.85 92.47,24.94 92.05,25.17 90.44,25.16 89.83,25.29 89.82,25.94 89.67,26.21 89.59,26.19 89.55,26.01 89.37,26.01 89.19,26.11 89.02,26.41 88.92,26.38 88.97,26.25 88.83,26.25 88.68,26.29 88.62,26.43 88.42,26.57 88.35,26.50 88.44,26.37 88.15,26.09 88.08,25.89 88.50,25.54 88.77,25.49 88.95,25.26 88.82,25.18 88.46,25.19 88.31,24.88 88.15,24.91 88.02,24.63 88.15,24.49 88.29,24.48 88.72,24.27 88.70,24.00 88.57,23.67 88.74,23.44 88.72,23.25 88.93,23.19 88.85,23.04 89.05,22.09
+2.39,11.90 2.37,12.22 2.81,12.38 3.60,11.70
+18.61,3.48 18.62,3.30 18.49,2.92 18.21,2.41 18.07,2.01 18.06,1.53 17.90,1.12 17.89,0.23 17.72,-0.28 17.75,-0.55 17.28,-1.00 16.88,-1.23 16.54,-1.84 16.22,-2.18 16.22,-3.03 16.15,-3.46 15.99,-3.77 15.87,-3.93 15.60,-4.03 15.27,-4.31 14.71,-4.88 14.41,-4.83 14.37,-4.59 14.45,-4.45 14.36,-4.30 13.94,-4.48 13.72,-4.45 13.66,-4.72 13.41,-4.84 13.14,-4.60 13.07,-4.63
+28.98,-30.00 29.10,-29.92 29.14,-29.70 29.29,-29.57 29.39,-29.27 29.30,-29.09 28.95,-28.88 28.63,-28.58 27.74,-28.94 27.29,-29.52 27.06,-29.63 27.39,-30.32 27.75,-30.60 28.06,-30.63 28.39,-30.15 28.65,-30.13 28.98,-30.00
+29.36,-22.19 29.66,-22.15 30.19,-22.29 30.92,-22.29 31.29,-22.40
+19.98,-24.78 20.43,-25.15 20.79,-25.92 20.82,-26.16 20.63,-26.44 20.69,-26.82 21.69,-26.84 21.79,-26.71 22.09,-26.58 22.22,-26.39 22.60,-26.13 22.88,-25.46 23.06,-25.31 23.39,-25.29 23.89,-25.60 24.19,-25.63 24.33,-25.74 24.75,-25.82 25.44,-25.71 25.58,-25.61 25.91,-24.75 26.40,-24.61 26.84,-24.24 26.99,-23.70 27.09,-23.58 27.76,-23.20 28.21,-22.69 28.38,-22.59 28.84,-22.48 29.13,-22.21 29.36,-22.19
+34.96,-11.58 35.56,-11.60 35.79,-11.45 35.91,-11.45 36.31,-11.71 36.67,-11.68 36.98,-11.57 37.37,-11.71 37.72,-11.58 37.92,-11.29 38.18,-11.28 38.49,-11.41 38.79,-11.23 39.32,-11.12 39.99,-10.82 40.46,-10.46
+-84.35,10.98 -84.17,10.78 -83.92,10.74 -83.71,10.79 -83.64,10.92
+28.15,56.14 27.90,56.08 27.64,55.91 27.58,55.80 27.05,55.83 26.59,55.67
+28.21,45.45 28.45,45.29 28.76,45.23 28.78,45.31 29.40,45.42 29.71,45.26
+21.36,44.83 21.91,44.67 22.09,44.54 22.50,44.71 22.64,44.65 22.73,44.57 22.55,44.54 22.49,44.44 22.71,44.24
+56.23,25.30 56.24,25.21 56.29,25.28 56.23,25.30
+32.11,-26.84 32.89,-26.85
+71.74,39.98 71.67,39.95 71.75,39.91 71.79,40.00 71.74,39.98
+-122.69,48.99 -95.16,48.99 -95.16,49.37 -94.85,49.30 -94.80,49.00 -94.62,48.74 -94.06,48.66 -93.71,48.53 -93.38,48.62 -93.00,48.61 -92.50,48.44 -92.41,48.28 -92.17,48.34 -92.01,48.30 -91.52,48.06 -90.92,48.21 -90.74,48.10 -90.09,48.12 -89.90,48.00 -89.46,48.00 -88.38,48.30 -84.88,46.90 -84.78,46.64 -84.56,46.46 -84.15,46.54 -84.09,46.23 -83.98,46.08 -83.62,46.12 -83.47,45.99 -83.59,45.82 -82.55,45.35 -82.14,43.57 -82.41,43.07 -82.55,42.62 -83.07,42.30 -83.15,42.14 -83.14,41.98 -83.03,41.83 -82.69,41.68 -82.44,41.67 -81.28,42.21 -80.25,42.37 -79.04,42.80 -78.92,42.91 -79.03,43.02 -79.06,43.28 -79.17,43.47 -78.85,43.58 -76.82,43.63 -76.46,44.06 -76.15,44.30 -75.00,44.97 -71.52,45.01 -71.33,45.29 -71.13,45.26 -71.00,45.34 -70.87,45.27 -70.80,45.40 -70.69,45.43 -70.70,45.55 -70.42,45.74 -70.30,45.91 -70.25,46.25 -70.07,46.44 -70.01,46.71 -69.24,47.46 -69.05,47.43 -69.05,47.27 -68.94,47.21 -68.24,47.35 -67.81,47.08 -67.80,45.73 -67.43,45.60 -67.49,45.47 -67.43,45.38 -67.47,45.28 -67.37,45.17 -67.12,45.17
+34.96,-11.58 34.89,-11.39 34.77,-11.34 34.61,-11.08 34.66,-10.71 34.58,-10.53 34.52,-10.03 34.32,-9.73 34.09,-9.54 34.00,-9.50 33.95,-9.66 33.89,-9.67
+107.97,21.51 107.76,21.66 107.35,21.61 107.27,21.71 107.06,21.79 106.97,21.92 106.66,21.98 106.65,22.24 106.55,22.34 106.55,22.50 106.78,22.78 106.54,22.91 106.28,22.86 106.15,22.97 105.84,22.92 105.55,23.07 105.28,23.35 104.86,23.14 104.80,22.91 104.69,22.82 104.37,22.70 104.14,22.80 104.05,22.75 103.94,22.54 103.62,22.78 103.49,22.59 103.33,22.77 102.98,22.45 102.83,22.59 102.47,22.75 102.13,22.38
+7.44,43.75 7.38,43.73
+12.43,41.91 12.43,41.91
+113.55,22.22 113.48,22.20
+114.02,22.51 114.12,22.57 114.27,22.54
+70.61,39.79 70.48,39.88 70.70,39.85 70.61,39.79
+71.22,39.91 71.01,39.90 71.04,39.99 70.97,40.04 70.98,40.13 71.23,40.05 71.18,39.98 71.22,39.91
+145.94,43.10 145.78,43.48 145.69,43.55 145.54,43.51 145.24,43.78 145.27,43.91 145.62,44.29 145.66,44.45 145.58,44.79
+-1.28,32.09 -1.23,32.11 -1.24,32.34 -1.07,32.47 -1.45,32.78 -1.68,33.32 -1.63,33.57 -1.71,33.78 -1.71,34.18 -1.79,34.37 -1.73,34.47 -1.85,34.61 -1.80,34.75 -2.13,34.97 -2.22,35.10
+29.00,9.61 29.47,9.77 29.60,9.92 29.61,10.07 30.00,10.28 30.76,9.73 31.22,9.80 31.79,10.38 31.93,10.66 32.42,11.09 32.34,11.31 32.34,11.72 32.07,12.01 32.74,12.01 32.72,12.22 33.20,12.22 33.07,11.59 33.17,10.85 33.13,10.76 33.38,10.65 33.91,10.18 33.96,9.86 33.87,9.51 34.08,9.46
+24.15,8.67 24.21,8.77 24.53,8.89 24.67,9.39 24.78,9.53 24.79,9.81 24.96,9.99 25.02,10.24 25.10,10.31 25.86,10.41 25.92,10.17 26.55,9.53 26.66,9.48 27.07,9.61 27.88,9.60
+27.88,9.60 28.05,9.33 28.84,9.33 28.84,9.46 29.00,9.61
+-56.48,1.94 -56.70,2.04 -57.20,2.85 -57.30,3.38 -57.60,3.37
+-54.62,2.33 -54.40,2.46 -54.20,2.82 -54.20,3.14 -54.08,3.33
+33.89,-9.67 33.70,-9.60 33.42,-9.61 33.33,-9.52 32.92,-9.41
+33.59,46.10 33.66,46.22 34.22,46.10 34.45,45.97 34.69,45.98 34.79,45.89 34.80,45.79 35.00,45.73
+77.05,35.11 76.77,35.66
+77.05,35.11 77.80,35.50
+79.12,33.23 79.38,33.15 79.33,32.98 79.50,32.73 79.38,32.57 79.22,32.50
+79.22,32.50 78.92,32.36 78.70,32.60 78.41,32.56 78.49,32.23
+78.49,32.23 78.73,31.98 78.72,31.88
+78.72,31.88 78.69,31.74 78.80,31.62 78.73,31.47 78.74,31.32 78.84,31.30
+78.84,31.30 78.97,31.33 79.01,31.41 79.11,31.40 79.37,31.08
+79.37,31.08 79.57,30.95 79.79,30.97 79.91,30.90
+79.91,30.90 80.19,30.76 80.19,30.57
+80.19,30.57 80.68,30.41 80.99,30.24 81.01,30.16
+90.33,28.12 90.35,28.24 90.22,28.28 89.98,28.31 89.80,28.24
+89.80,28.24 89.48,28.06 89.12,27.62
+89.12,27.62 89.02,27.51
+89.02,27.51 88.89,27.32
+75.30,32.32 75.32,32.22 75.25,32.14 74.74,31.95 74.56,31.82 74.51,31.71 74.59,31.47 74.52,31.19 74.63,31.03 74.34,30.89 73.90,30.44 73.93,30.22 73.81,30.09 73.38,29.93 73.23,29.55 72.90,29.03 72.34,28.75 72.13,28.35 71.95,28.18 71.87,27.96 70.80,27.71 70.69,27.77 70.63,27.94 70.40,28.03 70.14,27.85 69.90,27.47 69.54,27.12 69.47,26.80 69.51,26.74 70.15,26.51 70.10,25.91 70.26,25.71 70.65,25.67 70.65,25.42 71.05,24.69 70.97,24.57 71.04,24.40 70.72,24.24 70.58,24.28 70.55,24.42 70.49,24.41 70.10,24.29 70.02,24.19 69.81,24.17 69.56,24.27 68.83,24.26 68.78,24.31 68.73,24.27 68.72,23.96 68.38,23.95 68.17,23.86
+36.69,45.62 36.69,45.43 36.59,45.30 36.64,45.26 36.51,45.20 36.61,44.95
+-55.81,-31.03 -56.00,-31.08 -56.00,-30.85
+-56.00,-30.85 -56.18,-30.63 -56.83,-30.11 -57.12,-30.14 -57.21,-30.28 -57.55,-30.26 -57.61,-30.19
+-73.48,-49.77 -73.58,-49.58 -73.46,-49.31 -73.14,-49.30
+-73.14,-49.30 -73.15,-49.19 -73.03,-49.01 -72.65,-48.84 -72.58,-48.48 -72.35,-48.37 -72.29,-48.23 -72.33,-48.11 -72.51,-47.97 -72.52,-47.88 -72.35,-47.49 -72.04,-47.24 -71.90,-47.20 -71.96,-47.02 -71.94,-46.83 -71.70,-46.65 -71.76,-46.32 -71.88,-46.16 -71.63,-45.95 -71.75,-45.84 -71.75,-45.58 -71.51,-45.51 -71.35,-45.33 -71.35,-45.23 -71.60,-44.98 -72.04,-44.90 -72.06,-44.77 -71.26,-44.76 -71.16,-44.56 -71.21,-44.44 -71.82,-44.38 -71.81,-44.11 -71.68,-43.93 -71.79,-43.75 -71.74,-43.70 -71.75,-43.59 -71.90,-43.44 -71.90,-43.35 -71.75,-43.24 -71.78,-43.17 -72.10,-43.07 -72.14,-42.58 -72.05,-42.47 -72.11,-42.25 -72.03,-42.15 -71.86,-42.15 -71.75,-42.05 -71.91,-41.65 -71.87,-40.89 -71.94,-40.79 -71.80,-40.44 -71.70,-40.34 -71.82,-40.18 -71.66,-40.02 -71.64,-39.89 -71.72,-39.64 -71.54,-39.60 -71.42,-39.29 -71.40,-38.94 -70.95,-38.74 -70.85,-38.54 -70.97,-38.45 -71.03,-38.04 -71.17,-37.76 -71.13,-37.45 -71.20,-37.30 -71.12,-37.11 -71.19,-36.84 -71.06,-36.52 -70.75,-36.39 -70.72,-36.28 -70.40,-36.06 -70.42,-35.52 -70.56,-35.25 -70.39,-35.15 -70.29,-34.73 -70.05,-34.30 -69.85,-34.22 -69.89,-33.73 -69.80,-33.40 -69.82,-33.28 -70.02,-33.27 -70.08,-33.20 -70.09,-33.03 -70.02,-32.88 -70.12,-32.81 -70.17,-32.47 -70.32,-32.27 -70.36,-32.08 -70.25,-31.96 -70.45,-31.84 -70.59,-31.57 -70.52,-31.15 -70.39,-31.12 -70.31,-31.02 -70.35,-30.90 -70.15,-30.36 -69.96,-30.36 -69.84,-30.18 -69.96,-30.08 -69.93,-29.77 -70.03,-29.32 -69.83,-29.10 -69.66,-28.41 -69.17,-27.92 -68.85,-27.15 -68.71,-27.10 -68.59,-27.14 -68.32,-26.97 -68.32,-26.88 -68.59,-26.47 -68.58,-26.35 -68.41,-26.15 -68.59,-25.42 -68.50,-25.16 -68.38,-25.09 -68.56,-24.84 -68.56,-24.75 -68.25,-24.39 -67.36,-24.03 -67.01,-23.00 -67.19,-22.82
+75.32,34.58 74.30,34.77 73.96,34.65 73.81,34.42 73.81,34.33 73.97,34.24 73.92,34.04 74.25,33.99 74.22,33.89 74.00,33.79 73.98,33.72 74.15,33.51 73.99,33.22 74.30,32.99 74.31,32.81
+23.61,51.52 23.54,51.71 23.63,51.81 23.65,52.04 23.18,52.29 23.41,52.52 23.84,52.66 23.92,52.77 23.86,53.11 23.48,53.94
+34.08,9.46 34.16,9.85 34.31,10.19 34.28,10.53 34.34,10.66 34.57,10.88 34.77,10.75 34.93,10.86 34.96,11.28 35.11,11.82 35.67,12.62 36.13,12.76 36.16,13.09 36.39,13.63 36.52,14.26
+2.39,11.90 2.29,11.69 1.98,11.42 1.43,11.45 1.32,11.30 1.15,11.25 1.08,11.08 0.99,11.08 0.90,10.99
+31.95,-25.96 31.87,-25.98 31.42,-25.75 31.21,-25.84 30.80,-26.41 30.79,-26.76 30.88,-26.79 31.06,-27.11 31.47,-27.30 31.96,-27.31 31.99,-26.82 32.11,-26.84
+32.11,-26.84 32.06,-26.02 31.95,-25.96
+76.77,35.66 76.56,35.77 76.55,35.89 76.15,35.83 76.07,35.98 75.91,36.05 75.97,36.38
+27.33,5.19 27.79,4.64 28.19,4.35 28.43,4.32 28.73,4.50 29.22,4.39 29.47,4.61 29.68,4.59 30.19,3.98 30.51,3.84 30.59,3.62 30.76,3.62 30.84,3.49
+22.86,10.92 23.31,10.39 23.65,9.82 23.62,9.34 23.47,9.11 23.55,8.94 23.54,8.82 23.68,8.73 24.15,8.67
+46.11,38.88 46.49,38.91
+44.78,39.68 45.14,39.25 45.48,39.01 46.11,38.88
+46.49,38.91 47.48,39.50 47.77,39.65 48.00,39.68 48.32,39.40 48.10,39.24 48.29,39.02 48.05,38.93 48.00,38.85 48.59,38.41 48.87,38.44
+81.01,30.16 80.85,30.14 80.40,29.73 80.25,29.42 80.23,29.19 80.08,28.99 80.07,28.83 80.42,28.61 80.59,28.65 81.85,27.87 81.99,27.91 82.45,27.67 82.68,27.67 82.73,27.52 83.29,27.37 83.45,27.47 83.83,27.38 84.09,27.49 84.61,27.30 84.69,27.04 85.13,26.86 85.24,26.75 85.57,26.84 85.70,26.78 85.79,26.60 86.01,26.65 86.70,26.44 87.02,26.56 87.09,26.43 87.29,26.36 87.41,26.42 87.85,26.44 88.00,26.38 88.16,26.72 87.98,27.13 88.15,27.75 88.11,27.87
+75.97,36.38 75.84,36.65 75.67,36.74 75.42,36.74 75.35,36.91 74.54,37.02
@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+  <!-- "Filters": a funnel, wide at the top and narrowing to a short spout.
+       No stock icon theme ships one under a standard name. -->
+  <path fill="#222222" d="M 1.5,2 H 14.5 L 9.5,8.5 V 13.5 L 6.5,15 V 8.5 Z"/>
+</svg>
@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+  <!-- "Available offline": a filled disc with a down arrow knocked out of it
+       (one path, fill-rule evenodd, so symbolic recolouring keeps working).
+       Replaces the star, which every desktop uses for "favourite". -->
+  <path fill="#222222" fill-rule="evenodd" d="M 8,1 A 7,7 0 1 0 8,15 A 7,7 0 1 0 8,1 Z M 7,4 H 9 V 8.6 L 10.8,6.8 L 12.2,8.2 L 8,12.4 L 3.8,8.2 L 5.2,6.8 L 7,8.6 Z"/>
+</svg>
@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+  <!-- "Online only": a cloud outline. Lighter than the stock weather icon, so a
+       folder full of cloud-only files does not shout. -->
+  <path fill="#222222" fill-rule="evenodd" d="M 8.5,3 C 6.6,3 5,4.3 4.6,6.1 C 2.6,6.3 1,8 1,10 C 1,12.2 2.8,14 5,14 H 12 C 13.7,14 15,12.7 15,11 C 15,9.5 13.9,8.2 12.4,8 C 12.1,5.2 10.5,3 8.5,3 Z M 8.5,4.5 C 9.9,4.5 11,5.9 11,8 V 9.4 H 12 C 12.8,9.4 13.5,10.1 13.5,11 C 13.5,11.8 12.8,12.5 12,12.5 H 5 C 3.6,12.5 2.5,11.4 2.5,10 C 2.5,8.6 3.6,7.5 5,7.5 H 5.9 L 6,6.7 C 6.2,5.4 7.2,4.5 8.5,4.5 Z"/>
+</svg>
@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+  <!-- Upload-files action: an up arrow over a tray, the pair to
+       pdfs-folder-upload-symbolic. Stock themes only offer `document-send`,
+       which reads as "send by mail". -->
+  <path fill="#222222" d="M 8,1 L 3.5,5.5 L 4.9,6.9 L 7,4.8 V 11 H 9 V 4.8 L 11.1,6.9 L 12.5,5.5 Z"/>
+  <path fill="#222222" d="M 1,10 V 14 C 1,14.6 1.4,15 2,15 H 14 C 14.6,15 15,14.6 15,14 V 10 H 13 V 13 H 3 V 10 Z"/>
+</svg>
@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 48 48">
+  <path fill="#6d4aff" d="M4 12a4 4 0 0 1 4-4h11.2a4 4 0 0 1 2.9 1.2L25 12h15a4 4 0 0 1 4 4v22a4 4 0 0 1-4 4H8a4 4 0 0 1-4-4z"/>
+  <path fill="#8a6eff" d="M4 19a3 3 0 0 1 3-3h34a3 3 0 0 1 3 3v19a4 4 0 0 1-4 4H8a4 4 0 0 1-4-4z"/>
+  <path fill="#ffffff" fill-opacity="0.18" d="M7 16h34a3 3 0 0 1 3 3v1a3 3 0 0 0-3-3H7a3 3 0 0 0-3 3v-1a3 3 0 0 1 3-3z"/>
+</svg>
@@ -6,5 +6,22 @@
  <gresource prefix="/de/nils/protondrivelinux/icons">
    <file preprocess="xml-stripblanks">scalable/actions/pdfs-build-thumbnails-symbolic.svg</file>
    <file preprocess="xml-stripblanks">scalable/actions/pdfs-folder-upload-symbolic.svg</file>
+    <file preprocess="xml-stripblanks">scalable/actions/pdfs-upload-symbolic.svg</file>
+    <file preprocess="xml-stripblanks">scalable/actions/pdfs-filter-symbolic.svg</file>
+    <file preprocess="xml-stripblanks">scalable/actions/pdfs-offline-symbolic.svg</file>
+    <file preprocess="xml-stripblanks">scalable/actions/pdfs-online-only-symbolic.svg</file>
+    <!-- The Proton theme's folder: a full-colour icon from the icon theme
+         can't be recoloured by CSS. -->
+    <file preprocess="xml-stripblanks">scalable/places/pdfs-proton-folder.svg</file>
+    <!-- The app icon, from the one file packaging installs, so the in-app brand
+         matches the launcher and resolves even when nothing is installed. -->
+    <file alias="scalable/apps/io.narl.proton-drive-linux.svg" preprocess="xml-stripblanks">../../../packaging/io.narl.proton-drive-linux.svg</file>
+  </gresource>
+  <!-- The app stylesheet, loaded once at startup. Colours come from the
+       libadwaita palette so the app follows the system accent, light/dark and
+       high contrast. The Proton theme is a separate, opt-in provider. -->
+  <gresource prefix="/de/nils/protondrivelinux">
+    <file>style.css</file>
+    <file>proton-theme.css</file>
  </gresource>
 </gresources>
@@ -0,0 +1,72 @@
+/* Proton theme — the Proton web apps' Snow (light) and Carbon (dark) palettes.
+ *
+ * Loaded by main.rs after libadwaita's own stylesheet, which it re-applies on
+ * top of the user's GTK theme so that theme's hard-coded colours can't show
+ * through. Only libadwaita's colour variables are set here; every widget
+ * derives its look from them. Values from ProtonMail/WebClients,
+ * packages/colors/themes/src/{snow,carbon}/standard-base.css.
+ */
+
+:root {
+    --accent-bg-color: #6d4aff;
+    --accent-fg-color: #ffffff;
+    --destructive-bg-color: #dc3251;
+    --destructive-fg-color: #ffffff;
+    --error-bg-color: #dc3251;
+    --error-fg-color: #ffffff;
+    --success-bg-color: #1ea885;
+    --success-fg-color: #ffffff;
+    --warning-bg-color: #ff9900;
+    --warning-fg-color: rgb(0 0 0 / 80%);
+
+    --window-bg-color: #ffffff;
+    --window-fg-color: #0c0c14;
+    --view-bg-color: #ffffff;
+    --view-fg-color: #0c0c14;
+    --headerbar-bg-color: #ffffff;
+    --headerbar-fg-color: #0c0c14;
+    --headerbar-backdrop-color: #ffffff;
+    --sidebar-bg-color: #f5f4f2;
+    --sidebar-fg-color: #0c0c14;
+    --sidebar-backdrop-color: #f8f8f6;
+    --secondary-sidebar-bg-color: #f8f8f6;
+    --secondary-sidebar-fg-color: #0c0c14;
+    --secondary-sidebar-backdrop-color: #f8f8f6;
+    --card-bg-color: #f5f4f2;
+    --card-fg-color: #0c0c14;
+    --dialog-bg-color: #ffffff;
+    --dialog-fg-color: #0c0c14;
+    --popover-bg-color: #ffffff;
+    --popover-fg-color: #0c0c14;
+    --thumbnail-bg-color: #f5f4f2;
+    --thumbnail-fg-color: #0c0c14;
+}
+
+@media (prefers-color-scheme: dark) {
+    :root {
+        --destructive-bg-color: #f5385a;
+        --error-bg-color: #f5385a;
+
+        --window-bg-color: #1e1c26;
+        --window-fg-color: #ffffff;
+        --view-bg-color: #1e1c26;
+        --view-fg-color: #ffffff;
+        --headerbar-bg-color: #1e1c26;
+        --headerbar-fg-color: #ffffff;
+        --headerbar-backdrop-color: #1e1c26;
+        --sidebar-bg-color: #16141c;
+        --sidebar-fg-color: #ffffff;
+        --sidebar-backdrop-color: #16141c;
+        --secondary-sidebar-bg-color: #1a1821;
+        --secondary-sidebar-fg-color: #ffffff;
+        --secondary-sidebar-backdrop-color: #1a1821;
+        --card-bg-color: #292733;
+        --card-fg-color: #ffffff;
+        --dialog-bg-color: #292733;
+        --dialog-fg-color: #ffffff;
+        --popover-bg-color: #292733;
+        --popover-fg-color: #ffffff;
+        --thumbnail-bg-color: #292733;
+        --thumbnail-fg-color: #ffffff;
+    }
+}
@@ -0,0 +1,100 @@
+/* Proton Drive for Linux — app stylesheet.
+ *
+ * Colours come from the libadwaita palette (var(--accent-bg-color),
+ * var(--success-color), ...) so the app follows the system accent, light/dark
+ * and high contrast. The one exception is the photo viewer, which always sits
+ * on a near-black backdrop and so uses fixed light-on-dark colours. The Proton
+ * theme is opt-in and lives in its own provider (see main.rs and
+ * proton-theme.css).
+ */
+
+/* Brand */
+.brand-title { font-size: 1.6rem; font-weight: 800; }
+
+/* Sidebar footer */
+.sidebar-footer { padding: 6px 12px 12px 12px; }
+.sidebar-status { padding: 6px 8px; border-radius: 8px; }
+.sidebar-status image.success { color: var(--success-color); }
+.sidebar-status image.warning { color: var(--warning-color); }
+.sidebar-status image.error { color: var(--error-color); }
+.sidebar-quota progressbar trough, .sidebar-quota progressbar progress { min-height: 4px; }
+.sidebar-account { padding: 4px 4px 4px 8px; }
+
+/* File browser */
+.file-grid { padding: 6px; }
+.file-tile { padding: 8px; border-radius: 10px; }
+.file-tile:hover { background: color-mix(in srgb, var(--accent-bg-color) 10%, transparent); }
+.file-tile:selected, .file-tile:hover:selected { background: color-mix(in srgb, var(--accent-bg-color) 20%, transparent); }
+.file-thumbnail { border-radius: 7px; }
+.file-badge { -gtk-icon-shadow: 0 1px 2px rgba(0, 0, 0, 0.5); }
+.badge-pinned { color: var(--yellow-3); }
+.badge-cached { color: var(--success-color); }
+.badge-cloud { color: color-mix(in srgb, currentColor 55%, transparent); }
+.browser-statusbar { background-color: alpha(currentColor, 0.025); }
+scale.browser-status-meter trough, progressbar.browser-status-meter trough { min-width: 104px; }
+scale.browser-status-meter trough { min-height: 6px; }
+progressbar.browser-status-meter trough, progressbar.browser-status-meter progress { min-height: 6px; }
+.bulk-bar { padding: 6px 8px; border-radius: 12px; background: color-mix(in srgb, var(--accent-bg-color) 12%, transparent); }
+.dropzone { border: 2px dashed alpha(currentColor, 0.25); border-radius: 16px; padding: 28px 18px; transition: background 160ms ease, border-color 160ms ease; }
+.dropzone-active { border-color: var(--accent-bg-color); background: color-mix(in srgb, var(--accent-bg-color) 10%, transparent); }
+.files-drop-active { outline: 2px dashed var(--accent-bg-color); outline-offset: -4px; border-radius: 12px; background: color-mix(in srgb, var(--accent-bg-color) 6%, transparent); }
+
+/* Photo viewer: always light-on-dark, whatever the system style */
+.photo-viewer-window { background-color: #111014; }
+.viewer-top-bar { background: linear-gradient(to bottom, rgba(0, 0, 0, 0.75), rgba(0, 0, 0, 0)); padding: 10px 16px 28px 20px; color: white; }
+.viewer-title { font-weight: 700; font-size: 1.05rem; text-shadow: 0 1px 3px rgba(0, 0, 0, 0.9); color: white; }
+.viewer-counter { font-size: 0.8rem; color: rgba(255, 255, 255, 0.72); text-shadow: 0 1px 3px rgba(0, 0, 0, 0.9); }
+.viewer-action-btn { color: white; background-color: rgba(255, 255, 255, 0.12); border-radius: 50%; min-width: 34px; min-height: 34px; margin-left: 4px; }
+.viewer-action-btn:hover { background-color: rgba(255, 255, 255, 0.28); color: white; }
+.viewer-action-btn:checked { background-color: var(--accent-bg-color); color: var(--accent-fg-color); }
+.viewer-close-btn { background-color: rgba(255, 255, 255, 0.2); margin-left: 10px; }
+.viewer-close-btn:hover { background-color: var(--destructive-bg-color); color: var(--destructive-fg-color); }
+.viewer-nav-btn { background-color: rgba(0, 0, 0, 0.45); color: white; margin: 20px; min-width: 44px; min-height: 44px; border-radius: 50%; opacity: 0.7; transition: opacity 150ms ease, background-color 150ms ease; }
+.viewer-nav-btn:hover { background-color: rgba(0, 0, 0, 0.85); color: white; opacity: 1; }
+.viewer-nav-btn:disabled { opacity: 0; }
+.photo-scrubber { min-width: 20px; padding: 0 2px; }
+.photo-scrubber value { font-weight: 600; background-color: var(--popover-bg-color); border-radius: 6px; padding: 2px 8px; }
+.viewer-spinner { color: white; }
+.viewer-status { color: white; font-size: 1rem; background-color: rgba(0, 0, 0, 0.75); padding: 12px 24px; border-radius: 12px; }
+.viewer-info-panel { background-color: var(--window-bg-color); border-left: 1px solid alpha(currentColor, 0.12); }
+
+/* Photos grid */
+.gallery-day { font-size: 0.82rem; font-weight: 700; letter-spacing: 0.04em; text-transform: uppercase; color: alpha(currentColor, 0.65); padding: 2px 2px 6px 2px; }
+.photo-tile { padding: 0; margin: 0; min-height: 0; min-width: 0; border: none; border-radius: 4px; background: none; box-shadow: none; transition: box-shadow 180ms ease; }
+.photo-tile:hover { box-shadow: 0 8px 22px rgba(0, 0, 0, 0.45); }
+.photo-tile:focus { outline: 2px solid var(--accent-color); outline-offset: -2px; }
+.photo-thumb { transition: transform 220ms ease; }
+.photo-tile:hover .photo-thumb { transform: scale(1.06); }
+.photo-check { color: white; background: rgba(0, 0, 0, 0.5); border-radius: 999px; padding: 3px; }
+.photo-check-on { background: var(--accent-bg-color); color: var(--accent-fg-color); }
+.photo-tile-selected { outline: 3px solid var(--accent-bg-color); outline-offset: -3px; }
+.photo-placeholder { color: alpha(currentColor, 0.35); background: alpha(currentColor, 0.07); }
+.photo-caption { font-size: 0.78rem; color: white; text-shadow: 0 1px 3px rgba(0, 0, 0, 0.9); padding: 22px 10px 6px 10px; opacity: 0; transition: opacity 180ms ease; }
+.photo-tile:hover .photo-caption { opacity: 1; background: linear-gradient(to top, rgba(0, 0, 0, 0.55), rgba(0, 0, 0, 0)); }
+.photo-video-badge { color: white; background: rgba(0, 0, 0, 0.45); border-radius: 999px; padding: 8px; min-width: 20px; min-height: 20px; box-shadow: 0 2px 8px rgba(0, 0, 0, 0.5); transition: background 160ms ease; }
+.photo-video-badge-small { padding: 3px; min-width: 0; min-height: 0; }
+.photo-tile:hover .photo-video-badge { background: color-mix(in srgb, var(--accent-bg-color) 85%, transparent); }
+.photo-group-badge { font-size: 0.68rem; font-weight: 700; letter-spacing: 0.04em; color: white; background: rgba(0, 0, 0, 0.55); border-radius: 6px; padding: 1px 5px; margin: 6px; text-shadow: 0 1px 2px rgba(0, 0, 0, 0.9); }
+.memory-card { padding: 0; border-radius: 12px; }
+.memory-cover { border-radius: 12px; background: alpha(currentColor, 0.06); }
+.memory-label { font-weight: 700; color: white; text-shadow: 0 1px 3px rgba(0, 0, 0, 0.9); padding: 22px 10px 6px 10px; background: linear-gradient(to top, rgba(0, 0, 0, 0.6), rgba(0, 0, 0, 0)); }
+.album-card { padding: 0; border-radius: 16px; transition: background 180ms ease; }
+.album-card:hover { background: alpha(currentColor, 0.07); }
+.album-cover { border-radius: 16px; background: alpha(currentColor, 0.06); box-shadow: 0 4px 16px rgba(0, 0, 0, 0.32); transition: box-shadow 180ms ease; }
+.album-card:hover .album-cover { box-shadow: 0 10px 26px rgba(0, 0, 0, 0.5); }
+.album-card:hover .photo-thumb { transform: scale(1.05); }
+.view-switch button { padding-left: 18px; padding-right: 18px; }
+
+/* Shared with Me: what a share lets me do, as a tinted pill beside the name. */
+.role-pill { padding: 2px 10px; border-radius: 999px; font-weight: 600; color: var(--accent-color); background-color: color-mix(in srgb, var(--accent-bg-color) 16%, transparent); }
+
+/* Photos: how many timeline filters are on, as a small badge on the Filters button. */
+.filter-count { min-width: 18px; padding: 0 5px; border-radius: 999px; font-size: 0.8em; font-weight: 700; color: var(--accent-fg-color); background-color: var(--accent-bg-color); }
+/* The Places map: sea and land come in the map's own colours; markers (drawn
+ * in the area's own colour) in the accent. */
+.places-map-frame { border-radius: 12px; }
+.places-map { color: var(--accent-bg-color); }
+/* Credit on the Places street map, in the corner as on every web map. */
+.places-spot-photo { padding: 0; }
+.places-spot-photo picture { border-radius: 6px; overflow: hidden; }
+.places-map-credit { padding: 2px 8px; border-top-left-radius: 8px; color: var(--window-fg-color); background: color-mix(in srgb, var(--window-bg-color) 80%, transparent); }
@@ -1,53 +1,137 @@
 use crate::*;

 pub(crate) struct ActivityState {
-    // Activity page: one section, newest-first, rebuilt wholesale on each load.
+    // Activity page: a "Needs attention" section for live conflicts, then the
+    // feed grouped by day, rebuilt wholesale on each change.
    pub(crate) content: gtk4::Stack,
    pub(crate) status: adw::StatusPage,
    pub(crate) retry: gtk4::Button,
-    pub(crate) group: adw::PreferencesGroup,
-    pub(crate) rows: RefCell<Vec<gtk4::Widget>>,
+    pub(crate) attention: adw::PreferencesGroup,
+    pub(crate) attention_rows: RefCell<Vec<adw::ActionRow>>,
+    pub(crate) days: gtk4::Box,
    pub(crate) inflight: Cell<bool>,
-    /// Fingerprint of the feed currently on screen (see [`activity_key`]). The
-    /// page polls every couple of seconds and usually gets back exactly what it
-    /// is already showing; rebuilding all 200 rows for that would throw away the
-    /// user's scroll position several times a minute.
+    /// Fingerprint of what is on screen (see [`activity_key`]). The page polls
+    /// every couple of seconds and usually gets back exactly what it is already
+    /// showing; rebuilding every row for that would throw away the user's
+    /// scroll position several times a minute.
    pub(crate) key: RefCell<Option<String>>,
+    /// The last feed the daemon sent, so a filter change repaints without a
+    /// round-trip.
+    pub(crate) items: RefCell<Vec<ActivityEntry>>,
+    pub(crate) filter: Cell<ActivityFilter>,
+    /// Conflict copies still waiting for a decision, or `None` before the first
+    /// listing. Lets a logged conflict read as resolved once it is gone.
+    pub(crate) conflicts: RefCell<Option<Vec<ConflictInfo>>>,
+    pub(crate) conflicts_inflight: Cell<bool>,
+    pub(crate) conflicts_at: Cell<Option<Instant>>,
 }

 /// Widgets the Activity page's load/repaint touch.
 pub(crate) struct ActivityWidgets {
    pub(crate) content: gtk4::Stack,
    pub(crate) status: adw::StatusPage,
-    pub(crate) group: adw::PreferencesGroup,
+    pub(crate) attention: adw::PreferencesGroup,
+    pub(crate) days: gtk4::Box,
+    pub(crate) filters: Vec<(ActivityFilter, gtk4::ToggleButton)>,
    pub(crate) retry: gtk4::Button,
    pub(crate) refresh: gtk4::Button,
 }

-/// The Activity page: a newest-first feed of the mutations and transfers the
-/// daemon performed this session (uploads, deletes, shares, …).
-pub(crate) fn build_activity_page() -> (gtk4::Widget, ActivityWidgets) {
-    let title = gtk4::Label::builder()
-        .label("Activity")
-        .halign(gtk4::Align::Start)
-        .hexpand(true)
-        .build();
-    title.add_css_class("title-2");
-    let refresh = refresh_button();
-    let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
-    header.set_hexpand(true);
-    header.append(&title);
-    header.append(&refresh);
+/// Which slice of the feed the filter bar shows.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum ActivityFilter {
+    All,
+    Transfers,
+    Changes,
+    Sharing,
+    Problems,
+}

-    let group = adw::PreferencesGroup::new();
-    let clamp = adw::Clamp::builder().child(&group).build();
+impl ActivityFilter {
+    const ALL: [ActivityFilter; 5] = [
+        ActivityFilter::All,
+        ActivityFilter::Transfers,
+        ActivityFilter::Changes,
+        ActivityFilter::Sharing,
+        ActivityFilter::Problems,
+    ];
+
+    fn label(self) -> String {
+        match self {
+            ActivityFilter::All => pgettext("activity filter", "All"),
+            ActivityFilter::Transfers => pgettext("activity filter", "Transfers"),
+            ActivityFilter::Changes => pgettext("activity filter", "Changes"),
+            ActivityFilter::Sharing => pgettext("activity filter", "Sharing"),
+            ActivityFilter::Problems => pgettext("activity filter", "Problems"),
+        }
+    }
+
+    /// Whether an entry belongs in this slice. A failed action is a problem
+    /// whatever it was, and also stays under its own kind.
+    pub(crate) fn matches(self, entry: &ActivityEntry) -> bool {
+        use ActivityKind::*;
+        match self {
+            ActivityFilter::All => true,
+            ActivityFilter::Transfers => matches!(entry.kind, Upload | Download | Sync),
+            ActivityFilter::Changes => matches!(
+                entry.kind,
+                Rename | Move | CreateFolder | Trash | Restore | DeleteForever | EmptyTrash
+            ),
+            ActivityFilter::Sharing => matches!(entry.kind, Share | PublicLink | Unshare),
+            ActivityFilter::Problems => !entry.ok || entry.kind == Conflict,
+        }
+    }
+}
+
+/// The Activity page: a newest-first feed of the mutations and transfers the
+/// daemon performed (uploads, deletes, shares, …), grouped by day, with the
+/// conflicts that still need a decision on top.
+pub(crate) fn build_activity_page() -> (gtk4::Widget, ActivityWidgets) {
+    let refresh = refresh_button();
+
+    // Filter chips: a linked row of radio toggles.
+    let bar = gtk4::Box::new(gtk4::Orientation::Horizontal, 0);
+    bar.add_css_class("linked");
+    bar.set_halign(gtk4::Align::Start);
+    let mut filters: Vec<(ActivityFilter, gtk4::ToggleButton)> = Vec::new();
+    for filter in ActivityFilter::ALL {
+        let button = gtk4::ToggleButton::with_label(&filter.label());
+        if let Some((_, first)) = filters.first() {
+            button.set_group(Some(first));
+        } else {
+            button.set_active(true);
+        }
+        bar.append(&button);
+        filters.push((filter, button));
+    }
+
+    let attention = adw::PreferencesGroup::builder()
+        .title(gettext("Needs attention"))
+        .visible(false)
+        .build();
+    let days = gtk4::Box::new(gtk4::Orientation::Vertical, 24);
+
+    let column = gtk4::Box::new(gtk4::Orientation::Vertical, 24);
+    column.set_margin_top(18);
+    column.set_margin_bottom(18);
+    column.set_margin_start(18);
+    column.set_margin_end(18);
+    column.append(&bar);
+    column.append(&attention);
+    column.append(&days);
+    let clamp = adw::Clamp::builder()
+        .maximum_size(900)
+        .tightening_threshold(600)
+        .child(&column)
+        .build();
    let scroll = gtk4::ScrolledWindow::builder()
        .vexpand(true)
+        .hscrollbar_policy(gtk4::PolicyType::Never)
        .child(&clamp)
        .build();

    let retry = gtk4::Button::builder()
-        .label("Retry")
+        .label(gettext("Retry"))
        .halign(gtk4::Align::Center)
        .build();
    retry.add_css_class("pill");
@@ -66,20 +150,17 @@ pub(crate) fn build_activity_page() -> (gtk4::Widget, ActivityWidgets) {
    content.add_named(&scroll, Some("list"));
    content.add_named(&status, Some("status"));

-    let inner = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
-    inner.set_margin_top(12);
-    inner.set_margin_bottom(12);
-    inner.set_margin_start(12);
-    inner.set_margin_end(12);
-    inner.append(&header);
-    inner.append(&content);
+    let (frame, header, _) = page_frame(&gettext("Activity"), &content);
+    header.pack_end(&refresh);

    (
-        inner.upcast(),
+        frame.upcast(),
        ActivityWidgets {
            content,
            status,
-            group,
+            attention,
+            days,
+            filters,
            retry,
            refresh,
        },
@@ -87,12 +168,26 @@ pub(crate) fn build_activity_page() -> (gtk4::Widget, ActivityWidgets) {
 }

 /// Install the Activity page's retry button.
-pub(crate) fn wire_activity(ui: &Rc<Ui>, retry: &gtk4::Button) {
+pub(crate) fn wire_activity(
+    ui: &Rc<Ui>,
+    retry: &gtk4::Button,
+    filters: &[(ActivityFilter, gtk4::ToggleButton)],
+) {
    let ui_retry = ui.clone();
    retry.connect_clicked(move |_| {
        service::restart();
        load_activity(&ui_retry);
    });
+    for (filter, button) in filters {
+        let ui = ui.clone();
+        let filter = *filter;
+        button.connect_toggled(move |button| {
+            if button.is_active() {
+                ui.activity.filter.set(filter);
+                paint_activity(&ui);
+            }
+        });
+    }
 }

 /// Show a status page in place of the Activity list.
@@ -118,6 +213,7 @@ pub(crate) fn activity_status(
 /// pass fills the feed as it works rather than only once it is done. Anything
 /// other than a good answer leaves the rows alone until the next tick.
 pub(crate) fn refresh_activity(ui: &Rc<Ui>) {
+    refresh_activity_conflicts(ui, false);
    if ui.activity.inflight.get() {
        return;
    }
@@ -141,6 +237,7 @@ pub(crate) fn refresh_activity(ui: &Rc<Ui>) {
 }

 pub(crate) fn load_activity(ui: &Rc<Ui>) {
+    refresh_activity_conflicts(ui, true);
    if ui.activity.inflight.get() {
        return;
    }
@@ -148,8 +245,8 @@ pub(crate) fn load_activity(ui: &Rc<Ui>) {
    activity_status(
        ui,
        "document-open-recent-symbolic",
-        "Loading…",
-        "Reading recent activity.",
+        &gettext("Loading…"),
+        &gettext("Reading recent activity."),
        false,
    );
    ui.busy_begin();
@@ -167,15 +264,15 @@ pub(crate) fn load_activity(ui: &Rc<Ui>) {
            Ok(Ok(Response::Error { message, .. })) => activity_status(
                &ui,
                "dialog-warning-symbolic",
-                "Couldn't read activity",
+                &gettext("Couldn't read activity"),
                &message,
                false,
            ),
            Ok(Ok(_)) => activity_status(
                &ui,
                "dialog-warning-symbolic",
-                "Couldn't read activity",
-                "Unexpected reply from the mount service.",
+                &gettext("Couldn't read activity"),
+                &gettext("Unexpected reply from the mount service."),
                false,
            ),
            Ok(Err(_)) | Err(_) => activity_unreachable(&ui),
@@ -189,8 +286,8 @@ pub(crate) fn activity_unreachable(ui: &Rc<Ui>) {
        activity_status(
            ui,
            "network-offline-symbolic",
-            "Not connected",
-            "The Proton Drive mount service isn't running.",
+            &gettext("Not connected"),
+            &gettext("The Proton Drive mount service isn't running."),
            true,
        );
        return;
@@ -198,8 +295,8 @@ pub(crate) fn activity_unreachable(ui: &Rc<Ui>) {
    activity_status(
        ui,
        "folder-remote-symbolic",
-        "Connecting…",
-        "Waiting for the Proton Drive mount service to come up.",
+        &gettext("Connecting…"),
+        &gettext("Waiting for the Proton Drive mount service to come up."),
        false,
    );
    let ui = ui.clone();
@@ -210,93 +307,350 @@ pub(crate) fn activity_unreachable(ui: &Rc<Ui>) {
    });
 }

-/// A cheap fingerprint of a feed: how many entries, and what the newest one is.
-/// The log is append-only and newest-first, so a feed with the same length and
-/// the same newest entry is the same feed.
-pub(crate) fn activity_key(items: &[ActivityEntry]) -> String {
-    match items.first() {
-        Some(a) => format!("{}:{}:{}:{}", items.len(), a.time, a.target, a.detail),
-        None => String::new(),
-    }
-}
-
-/// Rebuild the Activity section from a fresh log, unless it is already showing
-/// exactly this feed.
-pub(crate) fn repaint_activity(ui: &Rc<Ui>, items: &[ActivityEntry]) {
-    let key = activity_key(items);
-    if ui.activity.key.borrow().as_deref() == Some(key.as_str()) {
+/// Poll the conflicts still waiting for a decision while the Activity page is
+/// on screen. `force` skips the TTL, for navigation and right after a
+/// resolution. Listing walks every node the daemon knows, so the tick asks far
+/// less often than it does for the feed.
+pub(crate) fn refresh_activity_conflicts(ui: &Rc<Ui>, force: bool) {
+    let state = &ui.activity;
+    if state.conflicts_inflight.get()
+        || (!force
+            && state
+                .conflicts_at
+                .get()
+                .is_some_and(|at| at.elapsed() < CONFLICTS_TTL))
+    {
        return;
    }
-    *ui.activity.key.borrow_mut() = Some(key);
-    for row in ui.activity.rows.borrow_mut().drain(..) {
-        ui.activity.group.remove(&row);
+    state.conflicts_inflight.set(true);
+    let rx = spawn_request(ui.dirs.control_socket(), Request::ListConflicts);
+    let ui = ui.clone();
+    glib::spawn_future_local(async move {
+        let result = rx.recv().await;
+        let state = &ui.activity;
+        state.conflicts_inflight.set(false);
+        state.conflicts_at.set(Some(Instant::now()));
+        // An older daemon, or none, has no list: leave the logged conflicts as
+        // they are rather than calling them resolved.
+        let items = match result {
+            Ok(Ok(Response::Conflicts { items })) => Some(items),
+            _ => None,
+        };
+        *state.conflicts.borrow_mut() = items;
+        if ui.stack.visible_child_name().as_deref() == Some("activity") {
+            paint_activity(&ui);
+        }
+    });
+}
+
+/// A cheap fingerprint of what the page shows: the feed's length and newest
+/// entry (the log is append-only and newest-first, so that pins the feed), the
+/// filter, and which conflicts are still open.
+pub(crate) fn activity_key(
+    items: &[ActivityEntry],
+    filter: ActivityFilter,
+    conflicts: Option<&[ConflictInfo]>,
+) -> String {
+    let newest = match items.first() {
+        Some(a) => format!("{}:{}:{}:{}", items.len(), a.time, a.target, a.detail),
+        None => String::new(),
+    };
+    let open = conflicts.map(|c| {
+        c.iter()
+            .map(|c| c.path.as_str())
+            .collect::<Vec<_>>()
+            .join("\n")
+    });
+    format!("{newest}|{filter:?}|{open:?}")
+}
+
+/// Keep a fresh log from the daemon and repaint with it.
+pub(crate) fn repaint_activity(ui: &Rc<Ui>, items: &[ActivityEntry]) {
+    *ui.activity.items.borrow_mut() = items.to_vec();
+    paint_activity(ui);
+}
+
+/// One feed row: an entry and how many times it was logged in a row (or, for
+/// a conflict, at all).
+#[derive(Debug)]
+pub(crate) struct FeedRow<'a> {
+    pub(crate) entry: &'a ActivityEntry,
+    pub(crate) count: usize,
+    /// When the oldest collapsed repeat happened.
+    pub(crate) first: i64,
+}
+
+/// Collapse repeats so the feed reads as news. The daemon flags a divergent
+/// conflict once per run, so the same copy comes back every day it stays
+/// unresolved: every conflict entry folds into its newest mention. Any other
+/// entry folds only into an identical one right before it (a retry loop
+/// failing the same way).
+pub(crate) fn collapse_feed(items: &[ActivityEntry]) -> Vec<FeedRow<'_>> {
+    let same = |a: &ActivityEntry, b: &ActivityEntry| {
+        a.kind == b.kind && a.ok == b.ok && a.target == b.target && a.detail == b.detail
+    };
+    let mut rows: Vec<FeedRow> = Vec::new();
+    for entry in items {
+        let prior = if entry.kind == ActivityKind::Conflict {
+            rows.iter_mut().find(|row| same(row.entry, entry))
+        } else {
+            rows.last_mut().filter(|row| same(row.entry, entry))
+        };
+        match prior {
+            Some(row) => {
+                row.count += 1;
+                row.first = row.first.min(entry.time);
+            }
+            None => rows.push(FeedRow {
+                entry,
+                count: 1,
+                first: entry.time,
+            }),
+        }
    }
-    if items.is_empty() {
+    rows
+}
+
+/// A section title for the day `at` falls on, seen from `now`: "Today",
+/// "Yesterday", a weekday within the week, then a date.
+pub(crate) fn day_label(at: &glib::DateTime, now: &glib::DateTime) -> String {
+    let today = now.ymd();
+    if at.ymd() == today {
+        return gettext("Today");
+    }
+    if now.add_days(-1).is_ok_and(|y| y.ymd() == at.ymd()) {
+        return gettext("Yesterday");
+    }
+    let format = if now.difference(at).as_seconds() < 6 * 86_400 {
+        "%A".to_string()
+    } else if at.year() == now.year() {
+        // Translators: strftime format for a day heading in this year, such as "Wednesday, September 23".
+        gettext("%A, %B %-d")
+    } else {
+        // Translators: strftime format for a day heading in an earlier year, such as "December 31, 2025".
+        gettext("%B %-d, %Y")
+    };
+    at.format(&format)
+        .map(|s| s.to_string())
+        .unwrap_or_default()
+}
+
+/// Rebuild the page from the kept feed and conflict list, unless it already
+/// shows exactly this.
+pub(crate) fn paint_activity(ui: &Rc<Ui>) {
+    let state = &ui.activity;
+    let items = state.items.borrow();
+    let conflicts = state.conflicts.borrow();
+    let filter = state.filter.get();
+    let key = activity_key(&items, filter, conflicts.as_deref());
+    if state.key.borrow().as_deref() == Some(key.as_str()) {
+        return;
+    }
+    let open: &[ConflictInfo] = conflicts.as_deref().unwrap_or_default();
+    if items.is_empty() && open.is_empty() {
        activity_status(
            ui,
            "document-open-recent-symbolic",
-            "Nothing yet",
-            "Uploads, moves, shares and other changes appear here as they happen.",
+            &gettext("Nothing yet"),
+            &gettext("Uploads, moves, shares and other changes appear here as they happen."),
            false,
        );
        return;
    }
-    ui.activity.content.set_visible_child_name("list");
-    let mut rows: Vec<gtk4::Widget> = Vec::new();
-    for a in items {
-        let mut subtitle = activity_time(a.time);
-        if !a.detail.is_empty() {
-            subtitle = format!("{subtitle} · {}", a.detail);
-        }
-        let row = adw::ActionRow::builder()
-            .title(format!("{} {}", activity_verb(a.kind), a.target))
-            .subtitle(subtitle)
+    *state.key.borrow_mut() = Some(key);
+    state.content.set_visible_child_name("list");
+
+    // Needs attention: the live conflicts, each opening the resolve dialog.
+    for row in state.attention_rows.borrow_mut().drain(..) {
+        state.attention.remove(&row);
+    }
+    state.attention.set_visible(!open.is_empty());
+    state.attention.set_description(Some(&ngettext_f(
+        "A file was changed in two places at once. Choose which version to keep.",
+        "{n} files were changed in two places at once. Choose which versions to keep.",
+        open.len() as u64,
+        &[],
+    )));
+    let mut attention_rows = state.attention_rows.borrow_mut();
+    for conflict in open {
+        let row = conflict_row(ui, conflict);
+        state.attention.add(&row);
+        attention_rows.push(row);
+    }
+    drop(attention_rows);
+
+    while let Some(child) = state.days.first_child() {
+        state.days.remove(&child);
+    }
+    let rows: Vec<FeedRow> = collapse_feed(&items)
+        .into_iter()
+        .filter(|row| filter.matches(row.entry))
+        .collect();
+    if rows.is_empty() {
+        let empty = adw::StatusPage::builder()
+            .icon_name("edit-find-symbolic")
+            .title(gettext("No matching activity"))
+            .description(gettext("Nothing in the recent log fits this filter."))
            .build();
-        let icon = if a.ok {
-            activity_icon(a.kind)
-        } else {
-            "dialog-warning-symbolic"
+        empty.add_css_class("compact");
+        state.days.append(&empty);
+        return;
+    }
+    let now = glib::DateTime::now_local().ok();
+    let mut group: Option<(String, adw::PreferencesGroup)> = None;
+    for row in rows {
+        let at = glib::DateTime::from_unix_local(row.entry.time).ok();
+        let label = match (&at, &now) {
+            (Some(at), Some(now)) => day_label(at, now),
+            _ => String::new(),
        };
-        row.add_prefix(&gtk4::Image::from_icon_name(icon));
-        row.set_activatable(false);
-        ui.activity.group.add(&row);
-        rows.push(row.upcast());
+        if group.as_ref().is_none_or(|(day, _)| *day != label) {
+            let section = adw::PreferencesGroup::builder().title(&label).build();
+            state.days.append(&section);
+            group = Some((label, section));
+        }
+        if let Some((_, section)) = &group {
+            section.add(&feed_row(ui, &row, at.as_ref(), open));
+        }
    }
-    *ui.activity.rows.borrow_mut() = rows;
 }

-/// A human verb for an activity kind, used as the row title's lead word.
-pub(crate) fn activity_verb(kind: ActivityKind) -> &'static str {
+/// One row of the feed.
+fn feed_row(
+    ui: &Rc<Ui>,
+    row: &FeedRow,
+    at: Option<&glib::DateTime>,
+    open: &[ConflictInfo],
+) -> adw::ActionRow {
+    let a = row.entry;
+    let title = activity_title(a.kind, &a.target);
+    // A logged conflict names the copy; it is still open while the daemon
+    // still lists a copy by that name.
+    let pending = (a.kind == ActivityKind::Conflict)
+        .then(|| open.iter().find(|c| file_name(&c.path) == a.target))
+        .flatten();
+    let resolved = a.kind == ActivityKind::Conflict
+        && pending.is_none()
+        && ui.activity.conflicts.borrow().is_some();
+
+    let mut subtitle: Vec<String> = Vec::new();
+    if !a.detail.is_empty() {
+        subtitle.push(capitalize(&a.detail));
+    }
+    if row.count > 1 {
+        let since = activity_time(row.first);
+        // Translators: {time} is a date and time such as "Sep 21, 14:05".
+        subtitle.push(ngettext_f(
+            "{n} time since {time}",
+            "{n} times since {time}",
+            row.count as u64,
+            &[("time", &since)],
+        ));
+    }
+    if resolved {
+        subtitle.push(pgettext("state", "Resolved"));
+    }
+    let widget = adw::ActionRow::builder()
+        .title(title)
+        .subtitle(subtitle.join(" · "))
+        .use_markup(false)
+        .title_lines(1)
+        .subtitle_lines(2)
+        .build();
+
+    // A failure and a conflict are different news: a conflict kept both
+    // copies, a failure lost the action. Each gets its own icon and colour.
+    let icon = gtk4::Image::from_icon_name(if resolved {
+        "object-select-symbolic"
+    } else if a.ok || a.kind == ActivityKind::Conflict {
+        activity_icon(a.kind)
+    } else {
+        "dialog-error-symbolic"
+    });
+    if resolved {
+        icon.add_css_class("success");
+    } else if a.kind == ActivityKind::Conflict {
+        icon.add_css_class("warning");
+    } else if !a.ok {
+        icon.add_css_class("error");
+    }
+    widget.add_prefix(&icon);
+
+    // Translators: strftime format for the time of day in the activity feed, such as "14:05".
+    let time_format = gettext("%H:%M");
+    let time = gtk4::Label::new(Some(
+        &at.and_then(|at| at.format(&time_format).ok())
+            .map(|s| s.to_string())
+            .unwrap_or_default(),
+    ));
+    time.add_css_class("dim-label");
+    time.add_css_class("numeric");
+    if let Some(at) = at.and_then(|at| at.format("%c").ok()) {
+        time.set_tooltip_text(Some(&at));
+    }
+    widget.add_suffix(&time);
+
+    if let Some(conflict) = pending {
+        let resolve = gtk4::Button::builder()
+            .label(gettext("Resolve…"))
+            .valign(gtk4::Align::Center)
+            .build();
+        let ui = ui.clone();
+        let conflict = conflict.clone();
+        resolve.connect_clicked(move |_| prompt_resolve_conflict(&ui, &conflict));
+        widget.add_suffix(&resolve);
+    }
+    widget
+}
+
+/// The row title for an activity: what happened to `target`, as one sentence
+/// per kind so translators can place the name where their language needs it.
+pub(crate) fn activity_title(kind: ActivityKind, target: &str) -> String {
+    let args = [("name", target)];
    match kind {
-        ActivityKind::Upload => "Uploaded",
-        ActivityKind::Download => "Downloaded",
-        ActivityKind::Sync => "Synced",
-        ActivityKind::Rename => "Renamed",
-        ActivityKind::Move => "Moved",
-        ActivityKind::CreateFolder => "Created folder",
-        ActivityKind::Trash => "Trashed",
-        ActivityKind::Restore => "Restored",
-        ActivityKind::DeleteForever => "Deleted",
-        ActivityKind::EmptyTrash => "Emptied trash —",
-        ActivityKind::Share => "Shared",
-        ActivityKind::PublicLink => "Linked",
-        ActivityKind::Unshare => "Unshared",
-        ActivityKind::Conflict => "Conflict",
+        // Translators: {name} is a file or folder name.
+        ActivityKind::Upload => gettext_f("Uploaded {name}", &args),
+        // Translators: {name} is a file or folder name.
+        ActivityKind::Download => gettext_f("Downloaded {name}", &args),
+        // Translators: {name} is a file or folder name.
+        ActivityKind::Sync => gettext_f("Synced {name}", &args),
+        // Translators: {name} is a file or folder name.
+        ActivityKind::Rename => gettext_f("Renamed {name}", &args),
+        // Translators: {name} is a file or folder name.
+        ActivityKind::Move => gettext_f("Moved {name}", &args),
+        // Translators: {name} is a folder name.
+        ActivityKind::CreateFolder => gettext_f("Created folder {name}", &args),
+        // Translators: {name} is a file or folder name.
+        ActivityKind::Trash => gettext_f("Trashed {name}", &args),
+        // Translators: {name} is a file or folder name.
+        ActivityKind::Restore => gettext_f("Restored {name}", &args),
+        // Translators: {name} is a file or folder name.
+        ActivityKind::DeleteForever => gettext_f("Deleted {name}", &args),
+        // The target of an empty is a count, not a name to lead with a verb.
+        // Translators: {count} is the number of items removed from the Trash.
+        ActivityKind::EmptyTrash => gettext_f("Emptied Trash ({count})", &[("count", target)]),
+        // Translators: {name} is a file or folder name.
+        ActivityKind::Share => gettext_f("Shared {name}", &args),
+        // Translators: {name} is a file or folder name.
+        ActivityKind::PublicLink => gettext_f("Created a link to {name}", &args),
+        // Translators: {name} is a file or folder name.
+        ActivityKind::Unshare => gettext_f("Unshared {name}", &args),
+        // Translators: {name} is the name of the conflict copy.
+        ActivityKind::Conflict => gettext_f("Conflict {name}", &args),
    }
 }

 /// A themed icon for an activity kind.
 pub(crate) fn activity_icon(kind: ActivityKind) -> &'static str {
    match kind {
-        ActivityKind::Upload => "document-send-symbolic",
+        ActivityKind::Upload => "pdfs-upload-symbolic",
        ActivityKind::Download => "document-save-symbolic",
        ActivityKind::Sync => "emblem-synchronizing-symbolic",
        ActivityKind::Rename => "document-edit-symbolic",
        ActivityKind::Move => "go-jump-symbolic",
        ActivityKind::CreateFolder => "folder-new-symbolic",
-        ActivityKind::Trash | ActivityKind::DeleteForever | ActivityKind::EmptyTrash => {
-            "user-trash-symbolic"
-        }
+        ActivityKind::Trash => "user-trash-symbolic",
+        ActivityKind::DeleteForever | ActivityKind::EmptyTrash => "edit-delete-symbolic",
        ActivityKind::Restore => "edit-undo-symbolic",
        ActivityKind::Share | ActivityKind::PublicLink => "emblem-shared-symbolic",
        ActivityKind::Unshare => "action-unavailable-symbolic",
@@ -307,7 +661,104 @@ pub(crate) fn activity_icon(kind: ActivityKind) -> &'static str {
 /// Format an epoch-seconds timestamp for the Activity feed, in local time.
 pub(crate) fn activity_time(secs: i64) -> String {
    glib::DateTime::from_unix_local(secs)
-        .and_then(|dt| dt.format("%b %-d, %H:%M"))
+        // Translators: strftime format for a date and time in the activity feed, such as "Sep 23, 14:05".
+        .and_then(|dt| dt.format(&gettext("%b %-d, %H:%M")))
        .map(|s| s.to_string())
        .unwrap_or_default()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn entry(time: i64, kind: ActivityKind, target: &str, detail: &str, ok: bool) -> ActivityEntry {
+        ActivityEntry {
+            time,
+            kind,
+            target: target.into(),
+            detail: detail.into(),
+            ok,
+        }
+    }
+
+    #[test]
+    fn a_conflict_logged_every_day_shows_once_with_a_count() {
+        let items = vec![
+            entry(
+                300,
+                ActivityKind::Conflict,
+                "a (sync-conflict).txt",
+                "differs",
+                false,
+            ),
+            entry(250, ActivityKind::Upload, "b.txt", "", true),
+            entry(
+                200,
+                ActivityKind::Conflict,
+                "a (sync-conflict).txt",
+                "differs",
+                false,
+            ),
+            entry(
+                100,
+                ActivityKind::Conflict,
+                "a (sync-conflict).txt",
+                "differs",
+                false,
+            ),
+        ];
+        let rows = collapse_feed(&items);
+        assert_eq!(rows.len(), 2);
+        assert_eq!(rows[0].entry.time, 300);
+        assert_eq!(rows[0].count, 3);
+        assert_eq!(rows[0].first, 100);
+        assert_eq!(rows[1].count, 1);
+    }
+
+    #[test]
+    fn other_entries_collapse_only_when_back_to_back() {
+        let items = vec![
+            entry(300, ActivityKind::Upload, "b.txt", "timeout", false),
+            entry(200, ActivityKind::Upload, "b.txt", "timeout", false),
+            entry(150, ActivityKind::Trash, "c.txt", "", true),
+            entry(100, ActivityKind::Upload, "b.txt", "timeout", false),
+        ];
+        let counts: Vec<usize> = collapse_feed(&items).iter().map(|r| r.count).collect();
+        assert_eq!(counts, vec![2, 1, 1]);
+    }
+
+    #[test]
+    fn the_problems_filter_holds_failures_and_conflicts() {
+        let failed = entry(1, ActivityKind::Upload, "a", "", false);
+        let conflict = entry(1, ActivityKind::Conflict, "a", "", false);
+        let fine = entry(1, ActivityKind::Upload, "a", "", true);
+        assert!(ActivityFilter::Problems.matches(&failed));
+        assert!(ActivityFilter::Problems.matches(&conflict));
+        assert!(!ActivityFilter::Problems.matches(&fine));
+        assert!(ActivityFilter::Transfers.matches(&failed));
+        assert!(!ActivityFilter::Sharing.matches(&fine));
+    }
+
+    #[test]
+    fn days_read_today_yesterday_weekday_then_date() {
+        let tz = glib::TimeZone::utc();
+        let at = |y, m, d, h| glib::DateTime::new(&tz, y, m, d, h, 0, 0.0).unwrap();
+        let now = at(2026, 9, 23, 12);
+        assert_eq!(day_label(&at(2026, 9, 23, 1), &now), "Today");
+        assert_eq!(day_label(&at(2026, 9, 22, 23), &now), "Yesterday");
+        // Weekday and month names follow the locale, so compare against it.
+        let named = |dt: glib::DateTime, format: &str| dt.format(format).unwrap().to_string();
+        assert_eq!(
+            day_label(&at(2026, 9, 20, 10), &now),
+            named(at(2026, 9, 20, 10), "%A")
+        );
+        assert_eq!(
+            day_label(&at(2026, 9, 1, 10), &now),
+            named(at(2026, 9, 1, 10), "%A, %B %-d")
+        );
+        assert_eq!(
+            day_label(&at(2025, 12, 31, 10), &now),
+            named(at(2025, 12, 31, 10), "%B %-d, %Y")
+        );
+    }
+}
@@ -16,23 +16,35 @@ const COVER_EDGE: i32 = 200;

 /// Show the Albums grid and (re)load it. Called when the Albums toggle goes on.
 pub(crate) fn show_albums(ui: &Rc<Ui>) {
-    close_album(ui);
-    ui.gallery.content.set_visible_child_name("albums");
+    show_album_grid(ui);
    load_albums(ui);
 }

+/// Switch to the album grid as it was last filled, keeping its scroll
+/// position. The timeline's filters do not apply to albums, so they go.
+fn show_album_grid(ui: &Rc<Ui>) {
+    close_album(ui);
+    close_place(ui);
+    ui.gallery.filters.set_visible(false);
+    ui.gallery.content.set_visible_child_name("albums");
+}
+
 /// Ask the daemon for the album listing and rebuild the grid.
 pub(crate) fn load_albums(ui: &Rc<Ui>) {
    if ui.gallery.albums_loading.get() {
        return;
    }
    ui.gallery.albums_loading.set(true);
-    albums_status(
-        ui,
-        "view-grid-symbolic",
-        "Loading albums…",
-        "Reading your Proton Drive albums.",
-    );
+    // A grid already on screen stays there while it refreshes, rather than
+    // blinking to a loading page and losing its scroll position.
+    if ui.gallery.albums_stack.visible_child_name().as_deref() != Some("grid") {
+        albums_status(
+            ui,
+            "view-grid-symbolic",
+            &gettext("Loading albums…"),
+            &gettext("Reading your Proton Drive albums."),
+        );
+    }

    let rx = spawn_request(ui.dirs.control_socket(), Request::PhotoAlbums);
    let ui = ui.clone();
@@ -45,33 +57,33 @@ pub(crate) fn load_albums(ui: &Rc<Ui>) {
            })) => albums_status(
                &ui,
                "image-missing-symbolic",
-                "No photo library",
-                "This Proton account doesn't have Photos enabled.",
+                &gettext("No photo library"),
+                &gettext("This Proton account doesn't have Photos enabled."),
            ),
            Ok(Ok(Response::Albums { items, .. })) if items.is_empty() => albums_status(
                &ui,
                "view-grid-symbolic",
-                "No albums",
-                "Albums you create in Proton Photos appear here.",
+                &gettext("No albums"),
+                &gettext("Create one with New Album, or in Proton Photos."),
            ),
            Ok(Ok(Response::Albums { items, .. })) => {
                fill_albums(&ui, &items);
                ui.gallery.albums_stack.set_visible_child_name("grid");
            }
            Ok(Ok(Response::Error { message, kind })) => {
-                toast_failure(&ui, "Couldn't load albums", &message, kind);
+                toast_failure(&ui, &gettext("Couldn't load albums"), &message, kind);
                albums_status(
                    &ui,
                    "dialog-warning-symbolic",
-                    "Couldn't load albums",
+                    &gettext("Couldn't load albums"),
                    &message,
                );
            }
            Ok(Ok(_)) | Ok(Err(_)) | Err(_) => albums_status(
                &ui,
                "network-offline-symbolic",
-                "Not connected",
-                "The Proton Drive mount service didn't respond.",
+                &gettext("Not connected"),
+                &gettext("The Proton Drive mount service didn't respond."),
            ),
        }
    });
@@ -80,15 +92,34 @@ pub(crate) fn load_albums(ui: &Rc<Ui>) {
 /// Replace the grid's cards with `albums`, in the order the daemon gave them
 /// (newest activity first).
 fn fill_albums(ui: &Rc<Ui>, albums: &[AlbumInfo]) {
+    let scroll = ui
+        .gallery
+        .albums
+        .ancestor(gtk4::ScrolledWindow::static_type())
+        .and_downcast::<gtk4::ScrolledWindow>();
+    let position = scroll.as_ref().map(|s| s.vadjustment().value());
    while let Some(child) = ui.gallery.albums.first_child() {
        ui.gallery.albums.remove(&child);
    }
+    *ui.gallery.album_list.borrow_mut() = albums.to_vec();
+    if ui.gallery.album.borrow().is_none() {
+        ui.gallery.title.set_subtitle(&ngettext_f(
+            "{n} album",
+            "{n} albums",
+            albums.len() as u64,
+            &[],
+        ));
+    }
    for album in albums {
        ui.gallery.albums.append(&album_card(ui, album));
    }
    // The covers are ordinary photos as far as the daemon is concerned, so the
    // batch that fills them is the gallery's own.
    schedule_thumbs(ui);
+    // A refresh rebuilds the cards; put the view back where the user was.
+    if let (Some(scroll), Some(position)) = (scroll, position) {
+        glib::idle_add_local_once(move || scroll.vadjustment().set_value(position));
+    }
 }

 /// One album as a clickable card: its cover, its name, and how many photos it
@@ -150,28 +181,409 @@ fn album_card(ui: &Rc<Ui>, album: &AlbumInfo) -> gtk4::Button {
        want_cover(ui, uid, &picture);
    }

+    let context = gtk4::GestureClick::builder().button(3).build();
+    let ui_context = ui.clone();
+    let menu_album = album.clone();
+    context.connect_pressed(move |gesture, _, x, y| {
+        gesture.set_state(gtk4::EventSequenceState::Claimed);
+        if let Some(anchor) = gesture.widget() {
+            show_album_menu(&ui_context, &menu_album, &anchor, x, y);
+        }
+    });
+    button.add_controller(context);
+
    let ui_open = ui.clone();
    let album = album.clone();
    button.connect_clicked(move |_| open_album(&ui_open, album.clone()));
    button
 }

+/// The album card's menu. Albums shared with us belong to someone else, so
+/// they only open.
+fn show_album_menu(ui: &Rc<Ui>, album: &AlbumInfo, anchor: &gtk4::Widget, x: f64, y: f64) {
+    let mut menu = ActionMenu::new();
+    let (ui_c, album_c) = (ui.clone(), album.clone());
+    menu.item(&pgettext("verb", "Open"), move || {
+        open_album(&ui_c, album_c.clone())
+    });
+    if !album.shared {
+        menu.section();
+        let (ui_c, album_c) = (ui.clone(), album.clone());
+        menu.item(&gettext("Rename…"), move || {
+            prompt_rename_album(&ui_c, &album_c)
+        });
+        menu.section();
+        let (ui_c, album_c) = (ui.clone(), album.clone());
+        menu.item(&gettext("Delete Album…"), move || {
+            confirm_delete_album(&ui_c, &album_c)
+        });
+    }
+    menu.popup_at(anchor, x, y);
+}
+
+/// Ask for an album name. `on_name` gets the trimmed name; Create stays off
+/// while the entry is blank.
+fn prompt_album_name(
+    ui: &Rc<Ui>,
+    heading: &str,
+    action: &str,
+    current: &str,
+    on_name: impl Fn(String) + 'static,
+) {
+    let win = ui_window(ui);
+    let dialog = adw::AlertDialog::builder().heading(heading).build();
+    let group = adw::PreferencesGroup::new();
+    let row = adw::EntryRow::builder()
+        .title(gettext("Album name"))
+        .activates_default(true)
+        .build();
+    row.set_text(current);
+    group.add(&row);
+    dialog.set_extra_child(Some(&group));
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("ok", action);
+    dialog.set_response_appearance("ok", adw::ResponseAppearance::Suggested);
+    dialog.set_response_enabled("ok", !current.trim().is_empty());
+    dialog.set_default_response(Some("ok"));
+    dialog.set_close_response("cancel");
+    let dialog_typed = dialog.clone();
+    row.connect_changed(move |row| {
+        dialog_typed.set_response_enabled("ok", !row.text().trim().is_empty());
+    });
+    dialog.connect_response(None, move |_, resp| {
+        let name = row.text().trim().to_string();
+        if resp == "ok" && !name.is_empty() {
+            on_name(name);
+        }
+    });
+    dialog.present(win.as_ref());
+}
+
+/// Ask for a name and create an album, then add `photos` to it, if any.
+pub(crate) fn prompt_new_album(ui: &Rc<Ui>, photos: Vec<String>) {
+    let ui_c = ui.clone();
+    let (heading, action) = (gettext("New Album"), gettext("Create"));
+    prompt_album_name(ui, &heading, &action, "", move |name| {
+        let rx = spawn_request(ui_c.dirs.control_socket(), Request::CreateAlbum { name });
+        let ui = ui_c.clone();
+        let photos = photos.clone();
+        ui.busy_begin();
+        glib::spawn_future_local(async move {
+            let reply = rx.recv().await;
+            ui.busy_end();
+            match reply {
+                Ok(Ok(Response::AlbumCreated { uid })) => {
+                    if photos.is_empty() {
+                        toast(&ui, &gettext("Album created"));
+                        reload_album_grid(&ui);
+                    } else {
+                        add_to_album(&ui, uid, photos);
+                    }
+                }
+                Ok(Ok(Response::Error { message, kind })) => {
+                    toast_failure(&ui, &gettext("Couldn't create the album"), &message, kind)
+                }
+                _ => toast_error(
+                    &ui,
+                    &gettext("Couldn't create the album"),
+                    &gettext("The mount service didn't respond."),
+                ),
+            }
+        });
+    });
+}
+
+fn prompt_rename_album(ui: &Rc<Ui>, album: &AlbumInfo) {
+    let (ui_c, uid) = (ui.clone(), album.uid.clone());
+    let (heading, action) = (gettext("Rename Album"), gettext("Rename"));
+    prompt_album_name(ui, &heading, &action, &album.name, move |name| {
+        run_album_request(
+            &ui_c,
+            Request::RenameAlbum {
+                uid: uid.clone(),
+                name,
+            },
+            gettext("Album renamed"),
+            gettext("Couldn't rename the album"),
+        );
+    });
+}
+
+fn confirm_delete_album(ui: &Rc<Ui>, album: &AlbumInfo) {
+    let Some(win) = ui_window(ui) else { return };
+    let (ui_c, uid) = (ui.clone(), album.uid.clone());
+    confirm_destructive(
+        &win,
+        &gettext("Delete Album?"),
+        // Translators: {name} is the album's name.
+        &gettext_f(
+            "“{name}” is deleted. Its photos stay in your timeline.",
+            &[("name", &album.name)],
+        ),
+        &gettext("Delete"),
+        move || {
+            run_album_request(
+                &ui_c,
+                Request::DeleteAlbum {
+                    uid: uid.clone(),
+                    delete_photos: false,
+                },
+                gettext("Album deleted"),
+                gettext("Couldn't delete the album"),
+            )
+        },
+    );
+}
+
+/// Send an album rename or delete and refresh the grid once it lands.
+fn run_album_request(ui: &Rc<Ui>, request: Request, done: String, failed: String) {
+    let rx = spawn_request(ui.dirs.control_socket(), request);
+    let ui = ui.clone();
+    ui.busy_begin();
+    glib::spawn_future_local(async move {
+        let reply = rx.recv().await;
+        ui.busy_end();
+        match reply {
+            Ok(Ok(Response::Ok { .. })) => {
+                toast(&ui, &done);
+                reload_album_grid(&ui);
+            }
+            Ok(Ok(Response::Error { message, kind })) => {
+                toast_failure(&ui, &failed, &message, kind)
+            }
+            _ => toast_error(&ui, &failed, &gettext("The mount service didn't respond.")),
+        }
+    });
+}
+
+/// Refill the album grid if it is on screen; otherwise it reloads when shown.
+fn reload_album_grid(ui: &Rc<Ui>) {
+    if ui.gallery.content.visible_child_name().as_deref() == Some("albums") {
+        load_albums(ui);
+    }
+}
+
+/// Offer our own albums to add `photos` to, plus a new one.
+pub(crate) fn prompt_add_to_album(ui: &Rc<Ui>, photos: Vec<String>) {
+    let rx = spawn_request(ui.dirs.control_socket(), Request::PhotoAlbums);
+    let ui = ui.clone();
+    glib::spawn_future_local(async move {
+        let albums: Vec<AlbumInfo> = match rx.recv().await {
+            Ok(Ok(Response::Albums { items, .. })) => {
+                items.into_iter().filter(|album| !album.shared).collect()
+            }
+            Ok(Ok(Response::Error { message, kind })) => {
+                toast_failure(&ui, &gettext("Couldn't load albums"), &message, kind);
+                return;
+            }
+            _ => {
+                toast_error(
+                    &ui,
+                    &gettext("Couldn't load albums"),
+                    &gettext("The mount service didn't respond."),
+                );
+                return;
+            }
+        };
+        if albums.is_empty() {
+            prompt_new_album(&ui, photos);
+            return;
+        }
+
+        let list = gtk4::ListBox::builder()
+            .selection_mode(gtk4::SelectionMode::None)
+            .build();
+        list.add_css_class("boxed-list");
+        for album in &albums {
+            let row = adw::ActionRow::builder()
+                .title(glib::markup_escape_text(&album.name))
+                .subtitle(album_subtitle(album))
+                .activatable(true)
+                .build();
+            list.append(&row);
+        }
+        let scroll = gtk4::ScrolledWindow::builder()
+            .hscrollbar_policy(gtk4::PolicyType::Never)
+            .propagate_natural_height(true)
+            .max_content_height(360)
+            .child(&list)
+            .build();
+        let dialog = adw::AlertDialog::builder()
+            .heading(gettext("Add to Album"))
+            .body(match photos.len() {
+                1 => gettext("Choose an album for this photo."),
+                n => ngettext_f(
+                    "Choose an album for {n} photo.",
+                    "Choose an album for {n} photos.",
+                    n as u64,
+                    &[],
+                ),
+            })
+            .extra_child(&scroll)
+            .build();
+        dialog.add_response("cancel", &gettext("Cancel"));
+        dialog.add_response("new", &gettext("New Album…"));
+        dialog.set_close_response("cancel");
+
+        let (ui_c, dialog_c, photos_c) = (ui.clone(), dialog.clone(), photos.clone());
+        list.connect_row_activated(move |_, row| {
+            if let Some(album) = albums.get(row.index().max(0) as usize) {
+                dialog_c.close();
+                add_to_album(&ui_c, album.uid.clone(), photos_c.clone());
+            }
+        });
+        let ui_c = ui.clone();
+        dialog.connect_response(Some("new"), move |_, _| {
+            prompt_new_album(&ui_c, photos.clone())
+        });
+        dialog.present(ui_window(&ui).as_ref());
+    });
+}
+
+fn add_to_album(ui: &Rc<Ui>, album: String, photos: Vec<String>) {
+    let rx = spawn_request(
+        ui.dirs.control_socket(),
+        Request::AddToAlbum { uid: album, photos },
+    );
+    let ui = ui.clone();
+    ui.busy_begin();
+    glib::spawn_future_local(async move {
+        let reply = rx.recv().await;
+        ui.busy_end();
+        match reply {
+            Ok(Ok(Response::AlbumChanged { changed, failed })) => {
+                if let Some(failure) = failed.first() {
+                    toast_error(
+                        &ui,
+                        &gettext("Some photos couldn't be added"),
+                        &failure.message,
+                    );
+                } else {
+                    toast(
+                        &ui,
+                        &ngettext_f(
+                            "Added {n} photo to the album",
+                            "Added {n} photos to the album",
+                            changed.len() as u64,
+                            &[],
+                        ),
+                    );
+                }
+                // Filed photos no longer belong in a timeline of unfiled ones.
+                // The daemon's filter drops them too, so the paging offset stays
+                // in step with what is left.
+                if ui.gallery.not_in_album.get() && ui.gallery.album.borrow().is_none() {
+                    ui.gallery
+                        .selected
+                        .borrow_mut()
+                        .retain(|uid| !changed.contains(uid));
+                    remove_photos(&ui, &changed);
+                }
+                reload_album_grid(&ui);
+            }
+            Ok(Ok(Response::Error { message, kind })) => {
+                toast_failure(&ui, &gettext("Couldn't add to the album"), &message, kind)
+            }
+            _ => toast_error(
+                &ui,
+                &gettext("Couldn't add to the album"),
+                &gettext("The mount service didn't respond."),
+            ),
+        }
+    });
+}
+
+/// Take photos out of the open album. They leave the view at once and come
+/// back if the server refuses; the timeline keeps them either way.
+pub(crate) fn remove_from_album(ui: &Rc<Ui>, album: &AlbumInfo, photos: Vec<String>) {
+    let removed = remove_photos(ui, &photos);
+    set_selection_mode(ui, false);
+    let rx = spawn_request(
+        ui.dirs.control_socket(),
+        Request::RemoveFromAlbum {
+            uid: album.uid.clone(),
+            photos,
+        },
+    );
+    let ui = ui.clone();
+    ui.busy_begin();
+    glib::spawn_future_local(async move {
+        let reply = rx.recv().await;
+        ui.busy_end();
+        match reply {
+            Ok(Ok(Response::AlbumChanged { changed, failed })) => {
+                if !failed.is_empty() {
+                    let kept: Vec<PhotoItem> = removed
+                        .iter()
+                        .filter(|photo| failed.iter().any(|f| f.uid == photo.uid))
+                        .cloned()
+                        .collect();
+                    restore_photos(&ui, kept);
+                    toast_error(
+                        &ui,
+                        &gettext("Some photos couldn't be removed from the album"),
+                        &failed[0].message,
+                    );
+                }
+                if changed.is_empty() {
+                    return;
+                }
+                // The open album's count, as the header shows it.
+                let mut open = ui.gallery.album.borrow_mut();
+                if let Some(album) = open.as_mut() {
+                    album.photo_count = album.photo_count.saturating_sub(changed.len());
+                    ui.gallery.title.set_subtitle(&album_subtitle(album));
+                }
+                drop(open);
+                toast(
+                    &ui,
+                    &ngettext_f(
+                        "Removed {n} photo from the album",
+                        "Removed {n} photos from the album",
+                        changed.len() as u64,
+                        &[],
+                    ),
+                );
+            }
+            Ok(Ok(Response::Error { message, kind })) => {
+                restore_photos(&ui, removed);
+                toast_failure(
+                    &ui,
+                    &gettext("Couldn't remove from the album"),
+                    &message,
+                    kind,
+                )
+            }
+            _ => {
+                restore_photos(&ui, removed);
+                toast_error(
+                    &ui,
+                    &gettext("Couldn't remove from the album"),
+                    &gettext("The mount service didn't respond."),
+                )
+            }
+        }
+    });
+}
+
 /// "12 photos", plus where the album came from when it isn't ours.
 fn album_subtitle(album: &AlbumInfo) -> String {
-    let photos = match album.photo_count {
-        1 => "1 photo".to_string(),
-        n => format!("{n} photos"),
-    };
+    let count = album.photo_count as u64;
    if album.shared {
-        format!("{photos} · shared with me")
+        ngettext_f(
+            "{n} photo · shared with me",
+            "{n} photos · shared with me",
+            count,
+            &[],
+        )
    } else {
-        photos
+        ngettext_f("{n} photo", "{n} photos", count, &[])
    }
 }

 /// Queue an album cover for the gallery's own thumbnail machinery: same batching,
 /// same texture cache, same decode pacing as a timeline tile.
-fn want_cover(ui: &Rc<Ui>, uid: String, picture: &gtk4::Picture) {
+pub(crate) fn want_cover(ui: &Rc<Ui>, uid: String, picture: &gtk4::Picture) {
    if let Some(texture) = ui.gallery.photo_tex.borrow().get(&uid) {
        picture.set_paintable(Some(texture));
        return;
@@ -192,10 +604,10 @@ fn want_cover(ui: &Rc<Ui>, uid: String, picture: &gtk4::Picture) {
 /// Open one album in the gallery: the timeline view, paged from the album
 /// instead, with the filters that don't apply to it out of the way.
 pub(crate) fn open_album(ui: &Rc<Ui>, album: AlbumInfo) {
-    ui.gallery.title.set_label(&album.name);
-    ui.gallery.subtitle.set_label(&album_subtitle(&album));
-    ui.gallery.subtitle.set_visible(true);
+    ui.gallery.title.set_title(&album.name);
+    ui.gallery.title.set_subtitle(&album_subtitle(&album));
    *ui.gallery.album.borrow_mut() = Some(album);
+    ui.gallery.timeline_stale.set(true);

    // An album page carries no kind or date filter, and Upload targets the
    // timeline rather than an album — hide those rather than offer controls that
@@ -219,8 +631,7 @@ pub(crate) fn close_album(ui: &Rc<Ui>) {
    if ui.gallery.album.borrow_mut().take().is_none() {
        return;
    }
-    ui.gallery.title.set_label("Gallery");
-    ui.gallery.filters.set_visible(true);
+    ui.gallery.title.set_title(&gettext("Photos"));
    ui.gallery.view_switch.set_visible(true);
    ui.gallery.upload.set_visible(true);
    ui.gallery.back.set_visible(false);
@@ -251,15 +662,35 @@ pub(crate) fn wire_albums(ui: &Rc<Ui>) {
        if !btn.is_active() {
            return;
        }
-        // The timeline is reloaded rather than restored, because an open album
-        // left the model holding its own photos.
        close_album(&ui_photos);
+        close_place(&ui_photos);
+        ui_photos.gallery.filters.set_visible(true);
        ui_photos.gallery.content.set_visible_child_name("timeline");
-        load_gallery(&ui_photos, false);
+        // The timeline comes back as it was left unless an album took over the
+        // model since; then it has to be reloaded.
+        if ui_photos.gallery.timeline_stale.replace(false) || ui_photos.gallery.model.n_items() == 0
+        {
+            load_gallery(&ui_photos, false);
+        } else {
+            update_gallery_subtitle(&ui_photos);
+        }
    });

+    // Back returns to the grid the album or place was opened from, scrolled
+    // where it was, instead of reloading it.
    let ui_back = ui.clone();
    ui.gallery.back.clone().connect_clicked(move |_| {
-        show_albums(&ui_back);
+        if ui_back.gallery.place.borrow().is_some() {
+            show_place_grid(&ui_back);
+            return;
+        }
+        show_album_grid(&ui_back);
+        let count = ui_back.gallery.album_list.borrow().len();
+        ui_back.gallery.title.set_subtitle(&ngettext_f(
+            "{n} album",
+            "{n} albums",
+            count as u64,
+            &[],
+        ));
    });
 }
@@ -36,61 +36,39 @@ pub(crate) struct DevicesWidgets {
    /// machine's own device is deliberately not among them; see
    /// [`repaint_devices`].
    pub(crate) group: adw::PreferencesGroup,
-    /// "Restore Folders" — re-attach this device's remote folders to local
-    /// directories after adopting it on a new machine.
-    pub(crate) restore: gtk4::Button,
    pub(crate) retry: gtk4::Button,
    pub(crate) refresh: gtk4::Button,
 }

-/// The Computers page: a "This computer" section listing the local folders synced
-/// to this machine's device (each row offering a mode toggle and Remove), plus an
-/// "Other devices" section listing the account's other registered devices.
+/// The Computers page: a "This computer" section naming the device this machine
+/// backs up to (renamable from its header), plus an "Other computers" section
+/// listing the account's other registered devices. The synced folders
+/// themselves live on the Sync page.
 pub(crate) fn build_devices_page() -> (gtk4::Widget, DevicesWidgets) {
-    let title = gtk4::Label::builder()
-        .label("Computers")
-        .halign(gtk4::Align::Start)
-        .build();
-    title.add_css_class("title-2");
-    let titles = gtk4::Box::new(gtk4::Orientation::Vertical, 2);
-    titles.set_hexpand(true);
-    titles.append(&title);
-
-    let restore = gtk4::Button::builder()
-        .label("Restore Folders")
-        .tooltip_text("Sync this computer's Drive folders back to local directories")
-        .valign(gtk4::Align::Center)
-        .build();
-    restore.add_css_class("flat");
    let refresh = refresh_button();

-    let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
-    header.append(&titles);
-    header.append(&refresh);
-    header.append(&restore);
-
    // This page is about device *identity* — which computer this is, which other
    // computers back up to the account, and how to adopt one. The folders
-    // themselves are local paths, so they live on the Locations page; keeping a
+    // themselves are local paths, so they live on the Sync page; keeping a
    // second copy of that list here would be two places to change the same mode.
    let sync_group = adw::PreferencesGroup::builder()
-        .title("This computer")
-        .description("The device this machine backs up to.")
+        .title(gettext("This computer"))
+        .description(gettext("The computer this machine backs up as."))
        .build();
    // Rename control for *this* machine's device, in the section header. The
    // current device is filtered out of "Other computers", so this is the only
    // place it can be renamed; insensitive until the device list identifies it.
    let rename_this = gtk4::Button::builder()
        .icon_name("document-edit-symbolic")
-        .tooltip_text("Rename this computer")
+        .tooltip_text(gettext("Rename this computer"))
        .valign(gtk4::Align::Center)
        .sensitive(false)
        .build();
    rename_this.add_css_class("flat");
    sync_group.set_header_suffix(Some(&rename_this));
    let group = adw::PreferencesGroup::builder()
-        .title("Other computers")
-        .description("Other devices backing up to this account.")
+        .title(gettext("Other computers"))
+        .description(gettext("Other computers backing up to this account."))
        .build();

    let groups = gtk4::Box::new(gtk4::Orientation::Vertical, 18);
@@ -103,7 +81,7 @@ pub(crate) fn build_devices_page() -> (gtk4::Widget, DevicesWidgets) {
        .build();

    let retry = gtk4::Button::builder()
-        .label("Retry")
+        .label(gettext("Retry"))
        .halign(gtk4::Align::Center)
        .build();
    retry.add_css_class("pill");
@@ -123,37 +101,35 @@ pub(crate) fn build_devices_page() -> (gtk4::Widget, DevicesWidgets) {
    content.add_named(&status, Some("status"));

    let inner = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
-    inner.set_margin_top(12);
-    inner.set_margin_bottom(12);
-    inner.set_margin_start(12);
-    inner.set_margin_end(12);
-    inner.append(&header);
+    inner.set_margin_top(18);
+    inner.set_margin_bottom(18);
+    inner.set_margin_start(18);
+    inner.set_margin_end(18);
    inner.append(&content);
+    let (frame, header, _) = page_frame(&gettext("Computers"), &inner);
+    header.pack_end(&refresh);

    (
-        inner.upcast(),
+        frame.upcast(),
        DevicesWidgets {
            content,
            status,
            sync_group,
            rename_this,
            group,
-            restore,
            retry,
            refresh,
        },
    )
 }

-/// Install the Devices page's retry button and the "Restore Folders" action.
-pub(crate) fn wire_devices(ui: &Rc<Ui>, retry: &gtk4::Button, restore: &gtk4::Button) {
+/// Install the Devices page's retry button and the Rename action.
+pub(crate) fn wire_devices(ui: &Rc<Ui>, retry: &gtk4::Button) {
    let ui_retry = ui.clone();
    retry.connect_clicked(move |_| {
        service::restart();
        load_devices(&ui_retry);
    });
-    let ui_restore = ui.clone();
-    restore.connect_clicked(move |_| prompt_restore_folders(&ui_restore));
    let ui_ren = ui.clone();
    ui.devices.rename_this.connect_clicked(move |_| {
        if let Some((uid, name)) = ui_ren.devices.this_device.borrow().clone() {
@@ -182,8 +158,8 @@ pub(crate) fn load_devices(ui: &Rc<Ui>) {
    devices_status(
        ui,
        "computer-symbolic",
-        "Loading…",
-        "Reading your devices.",
+        &gettext("Loading…"),
+        &gettext("Reading your computers."),
        false,
    );
    ui.busy_begin();
@@ -230,8 +206,8 @@ pub(crate) fn devices_unreachable(ui: &Rc<Ui>) {
        devices_status(
            ui,
            "network-offline-symbolic",
-            "Not connected",
-            "The Proton Drive mount service isn't running.",
+            &gettext("Not connected"),
+            &gettext("The Proton Drive mount service isn't running."),
            true,
        );
        return;
@@ -239,8 +215,8 @@ pub(crate) fn devices_unreachable(ui: &Rc<Ui>) {
    devices_status(
        ui,
        "folder-remote-symbolic",
-        "Connecting…",
-        "Waiting for the Proton Drive mount service to come up.",
+        &gettext("Connecting…"),
+        &gettext("Waiting for the Proton Drive mount service to come up."),
        false,
    );
    let ui = ui.clone();
@@ -271,10 +247,21 @@ pub(crate) fn repaint_devices(ui: &Rc<Ui>, devices: &[DeviceInfo]) {
    match devices.iter().find(|d| d.this_device) {
        Some(me) => {
            *ui.devices.this_device.borrow_mut() = Some((me.uid.clone(), me.name.clone()));
+            ui.devices
+                .sync_group
+                // Translators: {name} is the name of this computer's device.
+                .set_description(Some(&gettext_f(
+                    "Backing up as “{name}”.",
+                    &[("name", &me.name)],
+                )));
            ui.devices.rename_this.set_sensitive(true);
            ui.devices
                .rename_this
-                .set_tooltip_text(Some(&format!("Rename this computer ({})", me.name)));
+                // Translators: {name} is the name of this computer's device.
+                .set_tooltip_text(Some(&gettext_f(
+                    "Rename this computer ({name})",
+                    &[("name", &me.name)],
+                )));
        }
        None => {
            *ui.devices.this_device.borrow_mut() = None;
@@ -284,8 +271,8 @@ pub(crate) fn repaint_devices(ui: &Rc<Ui>, devices: &[DeviceInfo]) {
    let others: Vec<&DeviceInfo> = devices.iter().filter(|d| !d.this_device).collect();
    if others.is_empty() {
        let row = adw::ActionRow::builder()
-            .title("No other computers")
-            .subtitle("Desktop apps syncing to this account appear here.")
+            .title(gettext("No other computers"))
+            .subtitle(gettext("Desktop apps syncing to this account appear here."))
            .build();
        row.add_prefix(&gtk4::Image::from_icon_name("computer-symbolic"));
        ui.devices.group.add(&row);
@@ -299,43 +286,34 @@ pub(crate) fn repaint_devices(ui: &Rc<Ui>, devices: &[DeviceInfo]) {
            .subtitle(device_subtitle(dev))
            .build();
        row.add_prefix(&gtk4::Image::from_icon_name("computer-symbolic"));
-        let remove = gtk4::Button::builder()
-            .icon_name("user-trash-symbolic")
-            .tooltip_text("Remove this computer and everything it backed up")
-            .valign(gtk4::Align::Center)
-            .build();
-        remove.add_css_class("flat");
-        let rename = gtk4::Button::builder()
-            .icon_name("document-edit-symbolic")
-            .tooltip_text("Rename computer")
-            .valign(gtk4::Align::Center)
-            .build();
-        rename.add_css_class("flat");
        // Adoption is how a reinstalled or renamed machine re-attaches to the
        // device it used to be, instead of registering a duplicate. It only
-        // makes sense on *another* device's row, which is the only place this
+        // makes sense on *another* computer's row, which is the only place this
        // loop paints.
-        let adopt = gtk4::Button::builder()
-            .icon_name("insert-object-symbolic")
-            .tooltip_text("Use this computer's identity for this machine")
-            .valign(gtk4::Align::Center)
-            .build();
-        adopt.add_css_class("flat");
-        let ui_ad = ui.clone();
-        let uid_ad = dev.uid.clone();
-        let name_ad = dev.name.clone();
-        adopt.connect_clicked(move |_| prompt_adopt_device(&ui_ad, &uid_ad, &name_ad));
-        row.add_suffix(&adopt);
-        let ui_ren = ui.clone();
-        let uid_ren = dev.uid.clone();
-        let name_ren = dev.name.clone();
-        rename.connect_clicked(move |_| prompt_rename_device(&ui_ren, &uid_ren, &name_ren));
-        let ui_rm = ui.clone();
-        let uid_rm = dev.uid.clone();
-        let name_rm = dev.name.clone();
-        remove.connect_clicked(move |_| prompt_remove_device(&ui_rm, &uid_rm, &name_rm));
-        row.add_suffix(&rename);
-        row.add_suffix(&remove);
+        let (ui_ren, uid_ren, name_ren) = (ui.clone(), dev.uid.clone(), dev.name.clone());
+        let (ui_ad, uid_ad, name_ad) = (ui.clone(), dev.uid.clone(), dev.name.clone());
+        let (ui_rm, uid_rm, name_rm) = (ui.clone(), dev.uid.clone(), dev.name.clone());
+        let (ui_rs, uid_rs, name_rs) = (ui.clone(), dev.uid.clone(), dev.name.clone());
+        row.add_suffix(&more_menu_button(vec![
+            (
+                &gettext("Restore to This Computer…"),
+                Box::new(move || {
+                    prompt_restore_folders(&ui_rs, Some((uid_rs.clone(), name_rs.clone())))
+                }),
+            ),
+            (
+                &gettext("Rename…"),
+                Box::new(move || prompt_rename_device(&ui_ren, &uid_ren, &name_ren)),
+            ),
+            (
+                &gettext("Use This Computer's Identity…"),
+                Box::new(move || prompt_adopt_device(&ui_ad, &uid_ad, &name_ad)),
+            ),
+            (
+                &gettext("Remove Computer…"),
+                Box::new(move || prompt_remove_device(&ui_rm, &uid_rm, &name_rm)),
+            ),
+        ]));
        ui.devices.group.add(&row);
        rows.push(row.upcast());
    }
@@ -347,10 +325,19 @@ pub(crate) fn repaint_devices(ui: &Rc<Ui>, devices: &[DeviceInfo]) {
 /// "never" is the fact that tells the user this computer isn't backing anything up.
 pub(crate) fn device_subtitle(dev: &DeviceInfo) -> String {
    match dev.last_sync {
-        Some(secs) if secs > 0 => {
-            format!("{} · last synced {}", dev.device_type, activity_time(secs))
-        }
-        _ => format!("{} · never synced", dev.device_type),
+        // Translators: {platform} is the device's platform (such as "Linux"), {time} a date and time.
+        Some(secs) if secs > 0 => gettext_f(
+            "{platform} · last synced {time}",
+            &[
+                ("platform", &dev.device_type),
+                ("time", &activity_time(secs)),
+            ],
+        ),
+        // Translators: {platform} is the device's platform, such as "Linux".
+        _ => gettext_f(
+            "{platform} · never synced",
+            &[("platform", &dev.device_type)],
+        ),
    }
 }

@@ -365,19 +352,24 @@ pub(crate) fn repaint_this_computer(ui: &Rc<Ui>, folders: &[SyncFolderInfo]) {
        ui.devices.sync_group.remove(&row);
    }
    let row = adw::ActionRow::builder()
-        .title("This computer")
+        .title(gettext("This computer"))
        .subtitle(this_computer_subtitle(folders))
        .build();
    row.add_prefix(&gtk4::Image::from_icon_name("computer-symbolic"));
    let manage = gtk4::Button::builder()
-        .label("Locations")
-        .tooltip_text("Manage this computer's folders and mountpoint")
+        .label(gettext("Open Sync"))
+        .tooltip_text(gettext("Manage this computer's folders and mountpoint"))
        .valign(gtk4::Align::Center)
        .build();
    manage.add_css_class("flat");
    let ui_go = ui.clone();
    manage.connect_clicked(move |_| ui_go.stack.set_visible_child_name("locations"));
    row.add_suffix(&manage);
+    let ui_rs = ui.clone();
+    row.add_suffix(&more_menu_button(vec![(
+        &gettext("Restore Folders…"),
+        Box::new(move || prompt_restore_folders(&ui_rs, None)),
+    )]));
    ui.devices.sync_group.add(&row);
    *ui.devices.sync_rows.borrow_mut() = vec![row.upcast()];
 }
@@ -386,30 +378,41 @@ pub(crate) fn repaint_this_computer(ui: &Rc<Ui>, folders: &[SyncFolderInfo]) {
 /// attention — the one fact worth surfacing away from the folder list itself.
 pub(crate) fn this_computer_subtitle(folders: &[SyncFolderInfo]) -> String {
    if folders.is_empty() {
-        return "No folders backed up yet — add one under Locations.".to_string();
+        return gettext("No folders backed up yet — add one on the Sync page.");
    }
-    let count = match folders.len() {
-        1 => "1 folder backed up".to_string(),
-        n => format!("{n} folders backed up"),
-    };
+    let count = ngettext_f(
+        "{n} folder backed up",
+        "{n} folders backed up",
+        folders.len() as u64,
+        &[],
+    );
    let attention = folders
        .iter()
        .filter(|f| f.state == "error" || f.state == "conflict")
        .count();
    match attention {
-        0 => format!("{count} · manage them under Locations"),
-        1 => format!("{count} · 1 needs attention"),
-        n => format!("{count} · {n} need attention"),
+        // Translators: {folders} is "N folders backed up".
+        0 => gettext_f(
+            "{folders} · manage them on the Sync page",
+            &[("folders", &count)],
+        ),
+        // Translators: {folders} is "N folders backed up"; {n} counts the folders with a problem.
+        n => ngettext_f(
+            "{folders} · {n} needs attention",
+            "{folders} · {n} need attention",
+            n as u64,
+            &[("folders", &count)],
+        ),
    }
 }

 /// Human label for a synced folder's `state` column.
-pub(crate) fn sync_state_label(state: &str) -> &str {
+pub(crate) fn sync_state_label(state: &str) -> String {
    match state {
-        "syncing" => "syncing…",
-        "error" => "sync error",
-        "conflict" => "needs attention",
-        _ => "up to date",
+        "syncing" => gettext("syncing…"),
+        "error" => gettext("sync error"),
+        "conflict" => gettext("needs attention"),
+        _ => gettext("up to date"),
    }
 }

@@ -421,18 +424,30 @@ pub(crate) fn sync_progress_label(p: &SyncProgress) -> String {
    match p.phase {
        // Before the first pass finishes there is no estimate, so the count would
        // be "checked 12 of 12" — worse than saying nothing.
-        SyncPhase::Scanning if p.total == 0 => "checking for changes…".to_string(),
-        SyncPhase::Scanning => format!(
-            "checking for changes — {} of {}",
-            p.done,
-            p.total.max(p.done)
+        SyncPhase::Scanning if p.total == 0 => gettext("checking for changes…"),
+        // Translators: {done} and {total} count folders and files checked so far.
+        SyncPhase::Scanning => gettext_f(
+            "checking for changes — {done} of {total}",
+            &[
+                ("done", &p.done.to_string()),
+                ("total", &p.total.max(p.done).to_string()),
+            ],
        ),
        SyncPhase::Applying => {
-            let count = format!("{} of {}", p.done + 1, p.total.max(p.done + 1));
+            let done = (p.done + 1).to_string();
+            let total = p.total.max(p.done + 1).to_string();
            if p.current.is_empty() {
-                format!("syncing {count}")
+                // Translators: {done} and {total} count the changes applied so far.
+                gettext_f(
+                    "syncing {done} of {total}",
+                    &[("done", &done), ("total", &total)],
+                )
            } else {
-                format!("syncing {} — {count}", p.current)
+                // Translators: {file} is the path being synced; {done} and {total} count the changes applied so far.
+                gettext_f(
+                    "syncing {file} — {done} of {total}",
+                    &[("file", &p.current), ("done", &done), ("total", &total)],
+                )
            }
        }
    }
@@ -442,7 +457,7 @@ pub(crate) fn sync_progress_label(p: &SyncProgress) -> String {
 pub(crate) fn prompt_add_sync_folder(ui: &Rc<Ui>) {
    let win = ui_window(ui);
    let dialog = gtk4::FileDialog::builder()
-        .title("Add Folder to Sync")
+        .title(gettext("Add Folder to Sync"))
        .build();
    let ui = ui.clone();
    dialog.select_folder(win.as_ref(), gio::Cancellable::NONE, move |res| {
@@ -466,65 +481,81 @@ pub(crate) fn prompt_add_sync_folder(ui: &Rc<Ui>) {
                    // or too late (row flashes in). Instead let the periodic
                    // `refresh_locations` tick pick the row up whenever it
                    // actually lands, which is what keeps a running pass live too.
-                    toast(&ui, "Syncing folder…");
+                    toast(&ui, &gettext("Syncing folder…"));
                }
                Ok(Ok(Response::Error { message, kind })) => {
-                    toast_failure(&ui, "Couldn't add folder", &message, kind)
+                    toast_failure(&ui, &gettext("Couldn't add folder"), &message, kind)
                }
                _ => toast_error(
                    &ui,
-                    "Couldn't add folder",
-                    "The mount service didn't respond.",
+                    &gettext("Couldn't add folder"),
+                    &gettext("The mount service didn't respond."),
                ),
            }
        });
    });
 }

-/// Ask the daemon what this machine's device holds, then show a picker mapping
-/// each remote folder onto a local directory.
+/// Ask the daemon what a device holds, then show a picker mapping each remote
+/// folder onto a local directory. `device` is another computer as `(uid, name)`;
+/// `None` is this machine's own device.
 ///
 /// The daemon's paths are proposals — from the device's `profile.json` when it
 /// makes sense here, else `~/<name>` — so every one of them is editable and
 /// nothing is restored without being ticked.
-pub(crate) fn prompt_restore_folders(ui: &Rc<Ui>) {
+pub(crate) fn prompt_restore_folders(ui: &Rc<Ui>, device: Option<(String, String)>) {
    ui.busy_begin();
-    let rx = spawn_request(ui.dirs.control_socket(), Request::ListRestorableFolders);
+    let request = match &device {
+        Some((uid, _)) => Request::ListDeviceRestorableFolders {
+            device: uid.clone(),
+        },
+        None => Request::ListRestorableFolders,
+    };
+    let rx = spawn_request(ui.dirs.control_socket(), request);
    let ui = ui.clone();
    glib::spawn_future_local(async move {
        let result = rx.recv().await;
        ui.busy_end();
        match result {
-            Ok(Ok(Response::RestorableFolders { items })) => show_restore_picker(&ui, items),
-            Ok(Ok(Response::Error { message, kind })) => {
-                toast_failure(&ui, "Couldn't list folders to restore", &message, kind)
+            Ok(Ok(Response::RestorableFolders { items })) => {
+                show_restore_picker(&ui, items, device)
            }
+            Ok(Ok(Response::Error { message, kind })) => toast_failure(
+                &ui,
+                &gettext("Couldn't list folders to restore"),
+                &message,
+                kind,
+            ),
            _ => toast_error(
                &ui,
-                "Couldn't list folders to restore",
-                "The mount service didn't respond.",
+                &gettext("Couldn't list folders to restore"),
+                &gettext("The mount service didn't respond."),
            ),
        }
    });
 }

 /// The restore picker itself: one editable row per restorable folder.
-fn show_restore_picker(ui: &Rc<Ui>, items: Vec<RestorableFolder>) {
+fn show_restore_picker(
+    ui: &Rc<Ui>,
+    items: Vec<RestorableFolder>,
+    device: Option<(String, String)>,
+) {
    let win = ui_window(ui);
    let candidates: Vec<RestorableFolder> =
        items.into_iter().filter(|f| !f.already_synced).collect();
    if candidates.is_empty() {
        toast(
            ui,
-            "Nothing to restore — this computer's folders are all synced here.",
+            &nothing_to_restore(device.as_ref().map(|(_, n)| n.as_str())),
        );
        return;
    }

    let group = adw::PreferencesGroup::builder()
-        .description(
+        .description(gettext(
            "Tick the folders to sync to this machine, and adjust where each one should live.",
-        )
+        ))
        .build();
    // Held so the response handler can read back what the user ticked and typed.
    let mut controls: Vec<(String, String, gtk4::CheckButton, adw::EntryRow)> = Vec::new();
@@ -546,12 +577,14 @@ fn show_restore_picker(ui: &Rc<Ui>, items: Vec<RestorableFolder>) {
        .child(&group)
        .build();
    let dialog = adw::AlertDialog::builder()
-        .heading("Restore folders")
-        .body("These folders are backed up under this computer in Proton Drive.")
+        .heading(gettext("Restore folders"))
+        .body(restore_picker_body(
+            device.as_ref().map(|(_, n)| n.as_str()),
+        ))
        .extra_child(&scroll)
        .build();
-    dialog.add_response("cancel", "Cancel");
-    dialog.add_response("restore", "Restore");
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("restore", &gettext("Restore"));
    dialog.set_response_appearance("restore", adw::ResponseAppearance::Suggested);
    dialog.set_default_response(Some("restore"));
    dialog.set_close_response("cancel");
@@ -577,18 +610,48 @@ fn show_restore_picker(ui: &Rc<Ui>, items: Vec<RestorableFolder>) {
        // rows appear as the periodic refresh picks them up.
        run_devices_mutation(
            &ui,
-            Request::RestoreSyncFolders { items },
-            "Restoring folders…",
-            "Couldn't restore folders",
+            match &device {
+                Some((uid, _)) => Request::RestoreDeviceFolders {
+                    device: uid.clone(),
+                    items,
+                },
+                None => Request::RestoreSyncFolders { items },
+            },
+            &gettext("Restoring folders…"),
+            &gettext("Couldn't restore folders"),
        );
    });
    dialog.present(win.as_ref());
 }

+/// The restore picker's body: whose backup the folders come from.
+pub(crate) fn restore_picker_body(device: Option<&str>) -> String {
+    match device {
+        // Translators: {name} is the name of another computer.
+        Some(name) => gettext_f(
+            "These folders are backed up from “{name}”. Restored folders keep syncing with that computer's copy.",
+            &[("name", name)],
+        ),
+        None => gettext("These folders are backed up under this computer in Proton Drive."),
+    }
+}
+
+/// The toast when every folder of a device is already synced here.
+pub(crate) fn nothing_to_restore(device: Option<&str>) -> String {
+    match device {
+        // Translators: {name} is the name of another computer.
+        Some(name) => gettext_f(
+            "Nothing to restore — “{name}”'s folders are all synced here.",
+            &[("name", name)],
+        ),
+        None => gettext("Nothing to restore — this computer's folders are all synced here."),
+    }
+}
+
 /// Flip a synced folder between `mirror` and `ondemand`. Reloads after so the
 /// row's subtitle and switch reflect the daemon's real state (the request may be
 /// rejected, e.g. switching to on-demand while a folder is mid-sync).
-pub(crate) fn set_sync_folder_mode(ui: &Rc<Ui>, id: i64, mode: &str) {
+pub(crate) fn set_sync_folder_mode(ui: &Rc<Ui>, id: i64, mode: &'static str) {
    let rx = spawn_request(
        ui.dirs.control_socket(),
        Request::SetSyncFolderMode {
@@ -599,22 +662,42 @@ pub(crate) fn set_sync_folder_mode(ui: &Rc<Ui>, id: i64, mode: &str) {
    let ui = ui.clone();
    glib::spawn_future_local(async move {
        match rx.recv().await {
-            Ok(Ok(Response::Ok { message })) => toast(&ui, &message),
+            // The daemon's own text is written for the log; the toast says what
+            // the person will see happen. A switch may be queued behind a running
+            // pass, hence "will".
+            Ok(Ok(Response::Ok { .. })) => toast(
+                &ui,
+                &if mode == "ondemand" {
+                    gettext("Folder will switch to on-demand")
+                } else {
+                    gettext("Folder will download and stay synced")
+                },
+            ),
            Ok(Ok(Response::Error { message, kind })) => {
-                toast_failure(&ui, "Couldn't change mode", &message, kind)
+                toast_failure(&ui, &gettext("Couldn't change mode"), &message, kind)
            }
            _ => toast_error(
                &ui,
-                "Couldn't change mode",
-                "The mount service didn't respond.",
+                &gettext("Couldn't change mode"),
+                &gettext("The mount service didn't respond."),
            ),
        }
-        if ui.stack.visible_child_name().as_deref() == Some("devices") {
-            load_devices(&ui);
-        }
+        reload_sync_pages(&ui);
    });
 }

+/// Repaint whichever of the two pages that show sync folders is on screen. Sync
+/// folder changes are raised from Locations as well as Computers, and both must
+/// show the daemon's answer at once rather than on the next tick — a rejected
+/// mode switch would otherwise stay visibly flipped.
+pub(crate) fn reload_sync_pages(ui: &Rc<Ui>) {
+    match ui.stack.visible_child_name().as_deref() {
+        Some("devices") => load_devices(ui),
+        Some("locations") => refresh_locations(ui),
+        _ => {}
+    }
+}
+
 /// Confirm, then stop syncing a folder. Offers to also delete the cloud copy.
 pub(crate) fn prompt_remove_sync_folder(ui: &Rc<Ui>, id: i64, path: &str, ondemand: bool) {
    let win = ui_window(ui);
@@ -625,36 +708,36 @@ pub(crate) fn prompt_remove_sync_folder(ui: &Rc<Ui>, id: i64, path: &str, ondema
    // nasty surprise if the dialog claimed the local files were safe, and is
    // recoverable only by turning On-demand off *first* and letting it download.
    let body = if ondemand {
-        format!(
-            "Stop syncing “{path}”?\n\nThis folder is on-demand: its files live in Proton \
-             Drive, not on this disk, so the folder will be empty once it is unmounted. To \
-             keep a local copy, cancel, turn off On-demand, and wait for the download to \
-             finish before removing it."
+        // Translators: {path} is a local folder path.
+        gettext_f(
+            "Stop syncing “{path}”?\n\nThis folder is on-demand: its files live in Proton Drive, not on this disk, so the folder will be empty once it is unmounted. To keep a local copy, cancel, turn off On-demand, and wait for the download to finish before removing it.",
+            &[("path", path)],
        )
    } else {
-        format!(
-            "Stop syncing “{path}”?\n\nThe local files stay on this disk and simply stop \
-             being synced. Choose whether to also delete the copy in Proton Drive."
+        // Translators: {path} is a local folder path.
+        gettext_f(
+            "Stop syncing “{path}”?\n\nThe local files stay on this disk and simply stop being synced. Choose whether to also delete the copy in Proton Drive.",
+            &[("path", path)],
        )
    };
    let dialog = adw::AlertDialog::builder()
-        .heading("Stop syncing folder")
+        .heading(gettext("Stop syncing folder"))
        .body(body)
        .build();
    let group = adw::PreferencesGroup::new();
    let delete_remote = adw::SwitchRow::builder()
-        .title("Also delete from Proton Drive")
+        .title(gettext("Also delete from Proton Drive"))
        .subtitle(if ondemand {
-            "Deletes the only copy of these files."
+            gettext("Deletes the only copy of these files.")
        } else {
-            "The local copy is unaffected."
+            gettext("The local copy is unaffected.")
        })
        .active(false)
        .build();
    group.add(&delete_remote);
    dialog.set_extra_child(Some(&group));
-    dialog.add_response("cancel", "Cancel");
-    dialog.add_response("remove", "Stop Syncing");
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("remove", &gettext("Stop Syncing"));
    dialog.set_response_appearance("remove", adw::ResponseAppearance::Destructive);
    dialog.set_default_response(Some("cancel"));
    dialog.set_close_response("cancel");
@@ -667,8 +750,8 @@ pub(crate) fn prompt_remove_sync_folder(ui: &Rc<Ui>, id: i64, path: &str, ondema
                    id,
                    delete_remote: delete_remote.is_active(),
                },
-                "Stopped syncing folder",
-                "Couldn't stop syncing the folder",
+                &gettext("Stopped syncing folder"),
+                &gettext("Couldn't stop syncing the folder"),
            );
        }
    });
@@ -679,19 +762,20 @@ pub(crate) fn prompt_remove_sync_folder(ui: &Rc<Ui>, id: i64, path: &str, ondema
 pub(crate) fn prompt_rename_device(ui: &Rc<Ui>, uid: &str, current: &str) {
    let win = ui_window(ui);
    let dialog = adw::AlertDialog::builder()
-        .heading("Rename device")
-        .body(format!("Rename “{current}”."))
+        .heading(gettext("Rename Computer"))
+        // Translators: {name} is the computer's current name.
+        .body(gettext_f("Rename “{name}”.", &[("name", current)]))
        .build();
    let group = adw::PreferencesGroup::new();
    let row = adw::EntryRow::builder()
-        .title("New name")
+        .title(gettext("New name"))
        .activates_default(true)
        .build();
    row.set_text(current);
    group.add(&row);
    dialog.set_extra_child(Some(&group));
-    dialog.add_response("cancel", "Cancel");
-    dialog.add_response("rename", "Rename");
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("rename", &gettext("Rename"));
    dialog.set_response_appearance("rename", adw::ResponseAppearance::Suggested);
    dialog.set_default_response(Some("rename"));
    dialog.set_close_response("cancel");
@@ -703,7 +787,11 @@ pub(crate) fn prompt_rename_device(ui: &Rc<Ui>, uid: &str, current: &str) {
        }
        let name = row.text().trim().to_string();
        if name.is_empty() {
-            toast_error(&ui, "Couldn't rename device", "A name is required.");
+            toast_error(
+                &ui,
+                &gettext("Couldn't rename the computer"),
+                &gettext("A name is required."),
+            );
            return;
        }
        run_devices_mutation(
@@ -712,29 +800,43 @@ pub(crate) fn prompt_rename_device(ui: &Rc<Ui>, uid: &str, current: &str) {
                uid: uid.clone(),
                name,
            },
-            "Device renamed",
-            "Couldn't rename the device",
+            &gettext("Computer renamed"),
+            &gettext("Couldn't rename the computer"),
        );
    });
    dialog.present(win.as_ref());
 }

-/// Confirm, then remove (deregister) a device.
+/// Confirm, then remove (deregister) a computer. Removing deletes everything the
+/// computer backed up, so the confirm button stays off until the name is typed.
 pub(crate) fn prompt_remove_device(ui: &Rc<Ui>, uid: &str, name: &str) {
    let win = ui_window(ui);
-    let dialog = adw::AlertDialog::builder()
-        .heading("Remove computer")
-        .body(format!(
-            "Remove “{name}” from this account?\n\nEverything it backed up to Proton Drive is \
-             deleted along with it. The files on that computer itself are not touched — but \
-             this cannot be undone from here."
-        ))
+    let confirm = adw::EntryRow::builder()
+        // Translators: {name} is the computer's name, which the user must type.
+        .title(gettext_f("Type “{name}” to confirm", &[("name", name)]))
        .build();
-    dialog.add_response("cancel", "Cancel");
-    dialog.add_response("remove", "Remove");
+    let group = adw::PreferencesGroup::new();
+    group.add(&confirm);
+    let dialog = adw::AlertDialog::builder()
+        .heading(gettext("Remove Computer"))
+        // Translators: {name} is the name of the computer being removed.
+        .body(gettext_f(
+            "Remove “{name}” from this account?\n\nEverything it backed up to Proton Drive is deleted along with it. The files on that computer itself are not touched — but this cannot be undone from here.",
+            &[("name", name)],
+        ))
+        .extra_child(&group)
+        .build();
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("remove", &gettext("Remove"));
    dialog.set_response_appearance("remove", adw::ResponseAppearance::Destructive);
+    dialog.set_response_enabled("remove", false);
    dialog.set_default_response(Some("cancel"));
    dialog.set_close_response("cancel");
+    let dialog_typed = dialog.clone();
+    let expected = name.to_string();
+    confirm.connect_changed(move |row| {
+        dialog_typed.set_response_enabled("remove", row.text().trim() == expected);
+    });
    let ui = ui.clone();
    let uid = uid.to_string();
    dialog.connect_response(None, move |_, resp| {
@@ -742,8 +844,8 @@ pub(crate) fn prompt_remove_device(ui: &Rc<Ui>, uid: &str, name: &str) {
            run_devices_mutation(
                &ui,
                Request::DeleteDevice { uid: uid.clone() },
-                "Device removed",
-                "Couldn't remove the device",
+                &gettext("Computer removed"),
+                &gettext("Couldn't remove the computer"),
            );
        }
    });
@@ -760,16 +862,15 @@ pub(crate) fn prompt_remove_device(ui: &Rc<Ui>, uid: &str, name: &str) {
 pub(crate) fn prompt_adopt_device(ui: &Rc<Ui>, uid: &str, name: &str) {
    let win = ui_window(ui);
    let dialog = adw::AlertDialog::builder()
-        .heading("Use this computer's identity")
-        .body(format!(
-            "Treat this machine as “{name}”?\n\nNew synced folders are created under that \
-             computer in Proton Drive, and this machine keeps that identity even if its hostname \
-             changes. Folders already synced here are not moved.\n\nUse “Restore folders” \
-             afterwards to bring back what “{name}” was syncing."
+        .heading(gettext("Use this computer's identity"))
+        // Translators: {name} is the name of the other computer whose identity is adopted.
+        .body(gettext_f(
+            "Treat this machine as “{name}”?\n\nNew synced folders are created under that computer in Proton Drive, and this machine keeps that identity even if its hostname changes. Folders already synced here are not moved.\n\nUse “Restore folders” afterwards to bring back what “{name}” was syncing.",
+            &[("name", name)],
        ))
        .build();
-    dialog.add_response("cancel", "Cancel");
-    dialog.add_response("adopt", "Use identity");
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("adopt", &gettext("Use identity"));
    dialog.set_response_appearance("adopt", adw::ResponseAppearance::Suggested);
    dialog.set_default_response(Some("cancel"));
    dialog.set_close_response("cancel");
@@ -782,35 +883,33 @@ pub(crate) fn prompt_adopt_device(ui: &Rc<Ui>, uid: &str, name: &str) {
                Request::AdoptDevice {
                    uid: Some(uid.clone()),
                },
-                "Identity adopted",
-                "Couldn't adopt that computer",
+                &gettext("Identity adopted"),
+                &gettext("Couldn't adopt that computer"),
            );
        }
    });
    dialog.present(win.as_ref());
 }

-/// Run a mutation raised from the Devices page and reload the page on success.
-pub(crate) fn run_devices_mutation(
-    ui: &Rc<Ui>,
-    req: Request,
-    done: &'static str,
-    failed: &'static str,
-) {
+/// Run a mutation raised from Computers or Locations and reload the page on success.
+pub(crate) fn run_devices_mutation(ui: &Rc<Ui>, req: Request, done: &str, failed: &str) {
    ui.busy_begin();
    let rx = spawn_request(ui.dirs.control_socket(), req);
    let ui = ui.clone();
    let done = done.to_string();
+    let failed = failed.to_string();
    glib::spawn_future_local(async move {
        let result = rx.recv().await;
        ui.busy_end();
        match result {
            Ok(Ok(Response::Ok { .. })) => {
-                load_devices(&ui);
+                reload_sync_pages(&ui);
                toast(&ui, &done);
            }
-            Ok(Ok(Response::Error { message, kind })) => toast_failure(&ui, failed, &message, kind),
-            _ => toast_error(&ui, failed, "The mount service didn't respond."),
+            Ok(Ok(Response::Error { message, kind })) => {
+                toast_failure(&ui, &failed, &message, kind)
+            }
+            _ => toast_error(&ui, &failed, &gettext("The mount service didn't respond.")),
        }
    });
 }
@@ -829,6 +928,7 @@ mod tests {
            last_sync: 0,
            pending_mode: None,
            progress: None,
+            paused: false,
        }
    }

@@ -836,7 +936,7 @@ mod tests {
    fn a_machine_with_no_folders_is_told_where_to_add_one() {
        assert_eq!(
            this_computer_subtitle(&[]),
-            "No folders backed up yet — add one under Locations."
+            "No folders backed up yet — add one on the Sync page."
        );
    }

@@ -846,7 +946,7 @@ mod tests {
        // the Computers page can surface that something is wrong.
        assert_eq!(
            this_computer_subtitle(&[folder("idle"), folder("idle")]),
-            "2 folders backed up · manage them under Locations"
+            "2 folders backed up · manage them on the Sync page"
        );
        assert_eq!(
            this_computer_subtitle(&[folder("idle"), folder("error")]),
@@ -857,4 +957,11 @@ mod tests {
            "2 folders backed up · 2 need attention"
        );
    }
+
+    #[test]
+    fn the_restore_picker_names_the_computer_it_restores_from() {
+        assert!(restore_picker_body(Some("laptop")).contains("“laptop”"));
+        assert!(restore_picker_body(None).contains("this computer"));
+        assert!(nothing_to_restore(Some("laptop")).contains("“laptop”"));
+    }
 }
@@ -0,0 +1,476 @@
+use crate::*;
+
+/// Side of a copy's thumbnail in the duplicates dialog, in px.
+const COPY_SIZE: i32 = 150;
+
+/// Each set's copies with their Keep toggles.
+type SetToggles = Vec<Vec<(PhotoItem, gtk4::ToggleButton)>>;
+
+/// How often the dialog asks again while the daemon hashes thumbnails.
+const HASHING_POLL: std::time::Duration = std::time::Duration::from_secs(1);
+
+/// What the finder looks for.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Finder {
+    /// Byte-identical copies, going by the server's content hash.
+    Exact,
+    /// Shots that look alike, going by their thumbnails.
+    Similar,
+}
+
+/// The dialog's parts that a search fills in.
+struct FinderView {
+    ui: Rc<Ui>,
+    status: adw::StatusPage,
+    progress: gtk4::ProgressBar,
+    note: gtk4::Label,
+    stack: gtk4::Stack,
+    trash: gtk4::Button,
+    toolbar: adw::ToolbarView,
+    /// Bumped by every new search and when the dialog closes, so a reply or a
+    /// poll for an older one is dropped.
+    generation: Cell<u32>,
+    /// The Trash button's handler for the review on show.
+    clicked: RefCell<Option<glib::SignalHandlerId>>,
+}
+
+/// Open the duplicate finder: every set of photos stored more than once, side
+/// by side, with the copy worth keeping ticked. The copies left unticked go to
+/// Trash — one file each, never the rest of their shot. The Similar switch
+/// looks for shots that look alike instead.
+pub(crate) fn show_duplicates(ui: &Rc<Ui>) {
+    let progress = gtk4::ProgressBar::builder()
+        .show_text(true)
+        .width_request(280)
+        .halign(gtk4::Align::Center)
+        .visible(false)
+        .build();
+    let note = gtk4::Label::builder()
+        .wrap(true)
+        .justify(gtk4::Justification::Center)
+        .visible(false)
+        .build();
+    note.add_css_class("dim-label");
+    let status_extra = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
+    status_extra.append(&progress);
+    status_extra.append(&note);
+    let status = adw::StatusPage::builder()
+        .icon_name("edit-copy-symbolic")
+        .vexpand(true)
+        .child(&status_extra)
+        .build();
+    status.add_css_class("compact");
+
+    let stack = gtk4::Stack::new();
+    stack.add_named(&status, Some("status"));
+
+    let trash = gtk4::Button::builder()
+        .halign(gtk4::Align::End)
+        .sensitive(false)
+        .build();
+    trash.add_css_class("destructive-action");
+    trash.add_css_class("pill");
+    let bottom = gtk4::Box::new(gtk4::Orientation::Horizontal, 0);
+    bottom.add_css_class("toolbar");
+    bottom.set_halign(gtk4::Align::End);
+    bottom.append(&trash);
+
+    let exact = gtk4::ToggleButton::builder()
+        .label(pgettext("duplicates", "Exact"))
+        .tooltip_text(gettext("Photos stored more than once"))
+        .active(true)
+        .build();
+    let similar = gtk4::ToggleButton::builder()
+        .label(pgettext("duplicates", "Similar"))
+        .tooltip_text(gettext("Photos that look alike"))
+        .group(&exact)
+        .build();
+    let switch = gtk4::Box::new(gtk4::Orientation::Horizontal, 0);
+    switch.add_css_class("linked");
+    switch.append(&exact);
+    switch.append(&similar);
+    let header = adw::HeaderBar::new();
+    header.set_title_widget(Some(&switch));
+
+    let toolbar = adw::ToolbarView::new();
+    toolbar.add_top_bar(&header);
+    toolbar.set_content(Some(&stack));
+    toolbar.add_bottom_bar(&bottom);
+    toolbar.set_reveal_bottom_bars(false);
+
+    let dialog = adw::Dialog::builder()
+        .title(gettext("Duplicates"))
+        .content_width(760)
+        .content_height(640)
+        .child(&toolbar)
+        .build();
+    dialog.present(ui_window(ui).as_ref());
+
+    let view = Rc::new(FinderView {
+        ui: ui.clone(),
+        status,
+        progress,
+        note,
+        stack,
+        trash,
+        toolbar,
+        generation: Cell::new(0),
+        clicked: RefCell::new(None),
+    });
+    let view_closed = view.clone();
+    dialog.connect_closed(move |_| {
+        view_closed
+            .generation
+            .set(view_closed.generation.get().wrapping_add(1));
+    });
+    let view_switch = view.clone();
+    similar.connect_toggled(move |similar| {
+        let finder = if similar.is_active() {
+            Finder::Similar
+        } else {
+            Finder::Exact
+        };
+        search(&view_switch, finder);
+    });
+    search(&view, Finder::Exact);
+}
+
+/// Drop what the dialog shows and look again, for `finder`.
+fn search(view: &Rc<FinderView>, finder: Finder) {
+    let generation = view.generation.get().wrapping_add(1);
+    view.generation.set(generation);
+    if let Some(review) = view.stack.child_by_name("review") {
+        view.stack.remove(&review);
+    }
+    if let Some(handler) = view.clicked.take() {
+        view.trash.disconnect(handler);
+    }
+    view.toolbar.set_reveal_bottom_bars(false);
+    view.status.set_icon_name(Some("edit-copy-symbolic"));
+    view.status.set_title(&match finder {
+        Finder::Exact => gettext("Looking for duplicates…"),
+        Finder::Similar => gettext("Looking for similar photos…"),
+    });
+    view.status.set_description(None);
+    view.progress.set_visible(false);
+    view.note.set_visible(false);
+    view.stack.set_visible_child_name("status");
+    ask(view, finder, generation);
+}
+
+/// Ask the daemon for `finder`'s sets and show them, or, while it is still
+/// hashing thumbnails, how far it has got — and ask again in a moment.
+fn ask(view: &Rc<FinderView>, finder: Finder, generation: u32) {
+    let request = match finder {
+        Finder::Exact => Request::PhotoDuplicates,
+        Finder::Similar => Request::PhotoSimilar,
+    };
+    let rx = spawn_request(view.ui.dirs.control_socket(), request);
+    let view = view.clone();
+    glib::spawn_future_local(async move {
+        let reply = rx.recv().await;
+        if view.generation.get() != generation {
+            return;
+        }
+        let failed = match finder {
+            Finder::Exact => gettext("Couldn't look for duplicates"),
+            Finder::Similar => gettext("Couldn't look for similar photos"),
+        };
+        let (sets, uncompared) = match reply {
+            Ok(Ok(Response::PhotoDuplicates { sets })) => (sets, 0),
+            Ok(Ok(Response::PhotoSimilar {
+                hashing: Some(MappingProgress { done, total }),
+                ..
+            })) => {
+                view.status.set_title(&gettext("Comparing photos…"));
+                view.status.set_description(Some(&gettext(
+                    "Photos are compared by their thumbnails. The first time takes a while.",
+                )));
+                view.progress.set_fraction(if total == 0 {
+                    0.0
+                } else {
+                    done as f64 / total as f64
+                });
+                view.progress.set_text(Some(&gettext_f(
+                    // Translators: {done} and {total} are numbers of photos.
+                    "{done} of {total}",
+                    &[("done", &thousands(done)), ("total", &thousands(total))],
+                )));
+                view.progress.set_visible(true);
+                glib::timeout_add_local_once(HASHING_POLL, move || {
+                    if view.generation.get() == generation {
+                        ask(&view, finder, generation);
+                    }
+                });
+                return;
+            }
+            Ok(Ok(Response::PhotoSimilar {
+                sets,
+                hashing: None,
+                uncompared,
+            })) => (sets, uncompared),
+            Ok(Ok(Response::Error { message, .. })) => {
+                view.status.set_icon_name(Some("dialog-warning-symbolic"));
+                view.status.set_title(&failed);
+                view.status.set_description(Some(&message));
+                view.progress.set_visible(false);
+                return;
+            }
+            _ => {
+                view.status.set_icon_name(Some("dialog-warning-symbolic"));
+                view.status.set_title(&failed);
+                view.status
+                    .set_description(Some(&gettext("The mount service didn't respond.")));
+                view.progress.set_visible(false);
+                return;
+            }
+        };
+        view.progress.set_visible(false);
+        if sets.is_empty() {
+            view.status.set_icon_name(Some("emblem-ok-symbolic"));
+            match finder {
+                Finder::Exact => {
+                    view.status.set_title(&gettext("No duplicates"));
+                    view.status.set_description(Some(&gettext(
+                        "Every photo in your library is stored once.",
+                    )));
+                }
+                Finder::Similar => {
+                    view.status.set_title(&gettext("No similar photos"));
+                    view.status.set_description(Some(&gettext(
+                        "No two photos in your library look alike.",
+                    )));
+                }
+            }
+            if uncompared > 0 {
+                view.note.set_label(&uncompared_note(uncompared));
+                view.note.set_visible(true);
+            }
+            return;
+        }
+        let (review, handler) = duplicate_review(&view.ui, sets, &view.trash, finder, uncompared);
+        view.clicked.replace(Some(handler));
+        view.stack.add_named(&review, Some("review"));
+        view.stack.set_visible_child_name("review");
+        view.toolbar.set_reveal_bottom_bars(true);
+        schedule_thumbs(&view.ui);
+    });
+}
+
+/// Says how many photos the similar finder left out for want of a thumbnail.
+fn uncompared_note(n: usize) -> String {
+    ngettext_f(
+        "{n} photo couldn't be compared because it has no thumbnail yet.",
+        "{n} photos couldn't be compared because they have no thumbnail yet.",
+        n as u64,
+        &[],
+    )
+}
+
+/// The review list: one section per set, each photo a thumbnail with a Keep
+/// toggle. Wires `trash` to move every photo not kept to Trash, and returns
+/// that handler so a new search can take it off again.
+///
+/// Exact copies start with only the first of each set kept. Similar photos
+/// all start kept: photos that look alike can still be different shots.
+fn duplicate_review(
+    ui: &Rc<Ui>,
+    sets: Vec<Vec<PhotoItem>>,
+    trash: &gtk4::Button,
+    finder: Finder,
+    uncompared: usize,
+) -> (gtk4::Widget, glib::SignalHandlerId) {
+    let intro = gtk4::Label::builder()
+        .label(match finder {
+            Finder::Exact => gettext(
+                "These photos are stored more than once. The copies you don't keep move to Trash, where you can restore them.",
+            ),
+            Finder::Similar => gettext(
+                "These photos look alike. They can be copies of one photo or different shots of one moment, so all of them are kept until you untick them. The photos you don't keep move to Trash, where you can restore them.",
+            ),
+        })
+        .wrap(true)
+        .xalign(0.0)
+        .build();
+    intro.add_css_class("dim-label");
+
+    let content = gtk4::Box::new(gtk4::Orientation::Vertical, 18);
+    content.set_margin_top(12);
+    content.set_margin_bottom(12);
+    content.set_margin_start(18);
+    content.set_margin_end(18);
+    content.append(&intro);
+    if uncompared > 0 {
+        let note = gtk4::Label::builder()
+            .label(uncompared_note(uncompared))
+            .wrap(true)
+            .xalign(0.0)
+            .build();
+        note.add_css_class("dim-label");
+        content.append(&note);
+    }
+
+    // Every copy's toggle, by set, so the button can count what goes.
+    let toggles: Rc<RefCell<SetToggles>> = Rc::new(RefCell::new(Vec::new()));
+    for set in sets {
+        let Some(first) = set.first() else {
+            continue;
+        };
+        let date = section_heading(first.capture_time, Grouping::Day);
+        let title = match finder {
+            // Translators: heading of one set in the duplicates dialog; {date} is the day the photo was taken.
+            Finder::Exact => ngettext_f(
+                "{date}, {n} copy",
+                "{date}, {n} copies",
+                set.len() as u64,
+                &[("date", &date)],
+            ),
+            // Translators: heading of one set of photos that look alike; {date} is the day the first was taken.
+            Finder::Similar => ngettext_f(
+                "{date}, {n} photo",
+                "{date}, {n} photos",
+                set.len() as u64,
+                &[("date", &date)],
+            ),
+        };
+        let heading = gtk4::Label::builder().label(title).xalign(0.0).build();
+        heading.add_css_class("heading");
+        let row = gtk4::Box::new(gtk4::Orientation::Horizontal, 12);
+        let mut set_toggles = Vec::new();
+        for (index, photo) in set.into_iter().enumerate() {
+            let (card, keep) = copy_card(ui, &photo, index == 0 || finder == Finder::Similar);
+            row.append(&card);
+            set_toggles.push((photo, keep));
+        }
+        let row_scroll = gtk4::ScrolledWindow::builder()
+            .vscrollbar_policy(gtk4::PolicyType::Never)
+            .propagate_natural_height(true)
+            .child(&row)
+            .build();
+        let section = gtk4::Box::new(gtk4::Orientation::Vertical, 6);
+        section.append(&heading);
+        section.append(&row_scroll);
+        content.append(&section);
+        toggles.borrow_mut().push(set_toggles);
+    }
+
+    let sync = {
+        let toggles = toggles.clone();
+        let trash = trash.clone();
+        move || {
+            let n = doomed(&toggles.borrow()).len();
+            trash.set_label(&match finder {
+                Finder::Exact => ngettext_f(
+                    "Move {n} copy to Trash",
+                    "Move {n} copies to Trash",
+                    n as u64,
+                    &[],
+                ),
+                Finder::Similar => ngettext_f(
+                    "Move {n} photo to Trash",
+                    "Move {n} photos to Trash",
+                    n as u64,
+                    &[],
+                ),
+            });
+            trash.set_sensitive(n > 0);
+        }
+    };
+    sync();
+    for set in toggles.borrow().iter() {
+        for (_, keep) in set {
+            let toggles = toggles.clone();
+            let sync = sync.clone();
+            keep.connect_toggled(move |keep| {
+                // A set always keeps a copy: unticking the last one would trash
+                // the photo itself, which is not what removing duplicates means.
+                if !keep.is_active()
+                    && toggles.borrow().iter().any(|set| {
+                        set.iter().any(|(_, t)| t == keep)
+                            && set.iter().all(|(_, t)| !t.is_active())
+                    })
+                {
+                    keep.set_active(true);
+                    return;
+                }
+                sync();
+            });
+        }
+    }
+
+    let ui_trash = ui.clone();
+    let handler = trash.connect_clicked(move |button| {
+        let uids = doomed(&toggles.borrow());
+        if uids.is_empty() {
+            return;
+        }
+        // An exact copy is one file of its shot; a similar photo stands for
+        // its whole shot, raw and all.
+        trash_photos(&ui_trash, uids, finder == Finder::Exact);
+        if let Some(dialog) = button
+            .ancestor(adw::Dialog::static_type())
+            .and_downcast::<adw::Dialog>()
+        {
+            dialog.close();
+        }
+    });
+
+    let scroll = gtk4::ScrolledWindow::builder()
+        .hscrollbar_policy(gtk4::PolicyType::Never)
+        .vexpand(true)
+        .child(&content)
+        .build();
+    (scroll.upcast(), handler)
+}
+
+/// The uids of every copy not kept.
+fn doomed(toggles: &SetToggles) -> Vec<String> {
+    toggles
+        .iter()
+        .flatten()
+        .filter(|(_, keep)| !keep.is_active())
+        .map(|(photo, _)| photo.uid.clone())
+        .collect()
+}
+
+/// One copy: its thumbnail, its file name, and whether to keep it.
+fn copy_card(ui: &Rc<Ui>, photo: &PhotoItem, keep: bool) -> (gtk4::Box, gtk4::ToggleButton) {
+    let picture = gtk4::Picture::builder()
+        .content_fit(gtk4::ContentFit::Cover)
+        .can_shrink(true)
+        .build();
+    let placeholder = gtk4::Image::builder()
+        .icon_name("image-x-generic-symbolic")
+        .pixel_size(24)
+        .build();
+    placeholder.add_css_class("photo-placeholder");
+    let overlay = gtk4::Overlay::new();
+    overlay.set_size_request(COPY_SIZE, COPY_SIZE);
+    overlay.set_child(Some(&placeholder));
+    overlay.add_overlay(&picture);
+    overlay.set_overflow(gtk4::Overflow::Hidden);
+    overlay.add_css_class("memory-cover");
+    want_thumb(ui, photo, &picture);
+
+    let name = photo.name.clone().unwrap_or_default();
+    let label = gtk4::Label::builder()
+        .label(&name)
+        .tooltip_text(&name)
+        .ellipsize(gtk4::pango::EllipsizeMode::Middle)
+        .max_width_chars(18)
+        .build();
+    label.add_css_class("caption");
+
+    let toggle = gtk4::ToggleButton::builder()
+        .label(gettext("Keep"))
+        .active(keep)
+        .build();
+    toggle.add_css_class("pill");
+
+    let card = gtk4::Box::new(gtk4::Orientation::Vertical, 6);
+    card.set_size_request(COPY_SIZE, -1);
+    card.append(&overlay);
+    card.append(&label);
+    card.append(&toggle);
+    (card, toggle)
+}
@@ -6,34 +6,40 @@ pub(crate) struct LoginState {
    pub(crate) email: adw::EntryRow,
    pub(crate) password: adw::PasswordEntryRow,
    pub(crate) login_button: gtk4::Button,
+    /// Spins inside the Sign in button while a sign-in is running.
+    pub(crate) login_spinner: gtk4::Spinner,
    pub(crate) login_status: gtk4::Label,
 }

-/// The login page: an email row, password row, a primary "Sign in" button and a
-/// status label, centred in a clamp. The 2FA code is prompted lazily in a
-/// dialog (see [`prompt_2fa`]) only when the account actually requires it.
-#[allow(clippy::type_complexity)]
-pub(crate) fn build_login_page() -> (
-    gtk4::Widget,
-    (
-        adw::EntryRow,
-        adw::PasswordEntryRow,
-        gtk4::Button,
-        gtk4::Label,
-    ),
-) {
+/// Where the login page's account links go.
+const SIGNUP_URL: &str = "https://account.proton.me/drive/signup";
+const RESET_PASSWORD_URL: &str = "https://account.proton.me/reset-password";
+
+/// The login page: an email row, password row, a primary "Sign in" button, a
+/// status label and links to create an account or reset the password, centred
+/// in a clamp. The 2FA code is prompted lazily in a dialog (see [`prompt_2fa`])
+/// only when the account actually requires it.
+pub(crate) fn build_login_page() -> (gtk4::Widget, LoginState) {
    let group = adw::PreferencesGroup::builder()
-        .title("Sign in to Proton")
-        .description("Use your Proton account to connect Drive.")
+        .title(gettext("Sign in to Proton"))
+        .description(gettext("Use your Proton account to connect Drive."))
        .build();

-    let email = adw::EntryRow::builder().title("Email or username").build();
-    let password = adw::PasswordEntryRow::builder().title("Password").build();
+    let email = adw::EntryRow::builder()
+        .title(gettext("Email or username"))
+        .build();
+    let password = adw::PasswordEntryRow::builder()
+        .title(gettext("Password"))
+        .build();
    group.add(&email);
    group.add(&password);

+    let login_spinner = gtk4::Spinner::builder().visible(false).build();
+    let button_content = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
+    button_content.append(&login_spinner);
+    button_content.append(&gtk4::Label::new(Some(&gettext("Sign in"))));
    let login_button = gtk4::Button::builder()
-        .label("Sign in")
+        .child(&button_content)
        .halign(gtk4::Align::Center)
        .build();
    login_button.add_css_class("suggested-action");
@@ -46,9 +52,8 @@ pub(crate) fn build_login_page() -> (
    login_status.add_css_class("dim-label");

    let header = gtk4::Box::new(gtk4::Orientation::Vertical, 4);
-    let logo = gtk4::Image::from_icon_name("folder-remote-symbolic");
-    logo.set_pixel_size(64);
-    logo.add_css_class("brand-icon");
+    let logo = gtk4::Image::from_icon_name(APP_ID);
+    logo.set_pixel_size(96);
    let title = gtk4::Label::new(Some("Proton Drive"));
    title.add_css_class("brand-title");
    header.append(&logo);
@@ -64,6 +69,17 @@ pub(crate) fn build_login_page() -> (
    inner.append(&group);
    inner.append(&login_button);
    inner.append(&login_status);
+    let links = gtk4::Box::new(gtk4::Orientation::Horizontal, 0);
+    links.set_halign(gtk4::Align::Center);
+    links.append(&gtk4::LinkButton::with_label(
+        SIGNUP_URL,
+        &gettext("Create account"),
+    ));
+    links.append(&gtk4::LinkButton::with_label(
+        RESET_PASSWORD_URL,
+        &gettext("Forgot password?"),
+    ));
+    inner.append(&links);

    let clamp = adw::Clamp::builder()
        .maximum_size(420)
@@ -73,7 +89,13 @@ pub(crate) fn build_login_page() -> (

    (
        scroll.upcast(),
-        (email, password, login_button, login_status),
+        LoginState {
+            email,
+            password,
+            login_button,
+            login_spinner,
+            login_status,
+        },
    )
 }

@@ -99,12 +121,12 @@ pub(crate) fn wire_login(ui: &Rc<Ui>) {
        if username.is_empty() || password.is_empty() {
            ui.login
                .login_status
-                .set_text("Enter your email and password.");
+                .set_text(&gettext("Enter your email and password."));
            return;
        }

-        ui.login.login_button.set_sensitive(false);
-        ui.login.login_status.set_text("Signing in…");
+        set_signing_in(&ui, true);
+        ui.login.login_status.set_text(&gettext("Signing in…"));
        let (rx, totp_req_rx, hv_req_rx) = spawn_login(username, password);

        // Surface the 2FA dialog only if the SDK actually asks for a code (i.e.
@@ -129,7 +151,7 @@ pub(crate) fn wire_login(ui: &Rc<Ui>) {
                ui_hv
                    .login
                    .login_status
-                    .set_text("Complete the verification to continue…");
+                    .set_text(&gettext("Complete the verification to continue…"));
                prompt_human_verification(&ui_hv, &url, token_tx);
            }
        });
@@ -139,8 +161,8 @@ pub(crate) fn wire_login(ui: &Rc<Ui>) {
            let result = rx
                .recv()
                .await
-                .unwrap_or_else(|_| Err("login cancelled".into()));
-            ui.login.login_button.set_sensitive(true);
+                .unwrap_or_else(|_| Err(gettext("login cancelled")));
+            set_signing_in(&ui, false);
            match result {
                Ok(()) => {
                    ui.login.login_status.set_text("");
@@ -151,15 +173,53 @@ pub(crate) fn wire_login(ui: &Rc<Ui>) {
                    service::enable_start();
                    refresh(&ui);
                }
-                Err(e) => ui
-                    .login
-                    .login_status
-                    .set_text(&format!("Sign-in failed: {e}")),
+                Err(e) => ui.login.login_status.set_text(&e),
            }
        });
    });
 }

+/// Lock the form and spin the button while a sign-in runs.
+fn set_signing_in(ui: &Rc<Ui>, running: bool) {
+    ui.login.login_button.set_sensitive(!running);
+    ui.login.email.set_sensitive(!running);
+    ui.login.password.set_sensitive(!running);
+    ui.login.login_spinner.set_visible(running);
+    ui.login.login_spinner.set_spinning(running);
+}
+
+/// What to tell the person when sign-in fails. Proton's own API messages are
+/// written for people ("Incorrect login credentials…"), so they pass through;
+/// everything else is mapped from its kind rather than shown as a debug string.
+pub(crate) fn login_error_message(error: &pdfs_core::Error) -> String {
+    use pdfs_core::proton_sdk::ProtonError;
+    match error {
+        pdfs_core::Error::Proton(ProtonError::Api(api)) if api.http_status == 429 => {
+            gettext("Too many sign-in attempts. Wait a few minutes and try again.")
+        }
+        pdfs_core::Error::Proton(ProtonError::Api(api)) if !api.message.is_empty() => {
+            api.message.clone()
+        }
+        pdfs_core::Error::Proton(ProtonError::Transport(_)) => {
+            gettext("Couldn't reach Proton. Check your internet connection and try again.")
+        }
+        pdfs_core::Error::Keyring(_) => gettext(
+            "Signed in, but the session couldn't be saved to the system keyring. Make sure a keyring (GNOME Keyring or KWallet) is running and unlocked.",
+        ),
+        pdfs_core::Error::Other(message) if message.contains("two-factor") => {
+            gettext("Sign-in cancelled: no two-factor code was entered.")
+        }
+        pdfs_core::Error::Other(message) if message.contains("verification") => gettext(
+            "Sign-in cancelled: the verification wasn't completed. Sign in again to get a new one.",
+        ),
+        other => {
+            let error = other.to_string();
+            // Translators: {error} is an error message, usually in English.
+            gettext_f("Sign-in failed: {error}", &[("error", &error)])
+        }
+    }
+}
+
 /// Run the async SRP + optional 2FA login on a dedicated current-thread Tokio
 /// runtime. Returns two channels: the first yields the final login result once;
 /// the second fires *only if* the account needs a 2FA code, carrying a
@@ -223,7 +283,7 @@ pub(crate) fn spawn_login(
                },
            )
            .await
-            .map_err(|e| e.to_string())
+            .map_err(|e| login_error_message(&e))
        });
        let _ = tx.send_blocking(result);
    });
@@ -235,20 +295,22 @@ pub(crate) fn spawn_login(
 /// the worker reads as a cancelled login.
 pub(crate) fn prompt_2fa(ui: &Rc<Ui>, code_tx: std::sync::mpsc::Sender<String>) {
    let dialog = adw::AlertDialog::builder()
-        .heading("Two-factor authentication")
-        .body("Enter the code from your authenticator app.")
+        .heading(gettext("Two-factor authentication"))
+        .body(gettext(
+            "Enter the code from your authenticator app, or one of your recovery codes.",
+        ))
        .build();

    let group = adw::PreferencesGroup::new();
    let entry = adw::EntryRow::builder()
-        .title("Authentication code")
+        .title(gettext("Authentication code"))
        .activates_default(true)
        .build();
    group.add(&entry);
    dialog.set_extra_child(Some(&group));

-    dialog.add_response("cancel", "Cancel");
-    dialog.add_response("confirm", "Confirm");
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("confirm", &gettext("Confirm"));
    dialog.set_response_appearance("confirm", adw::ResponseAppearance::Suggested);
    dialog.set_default_response(Some("confirm"));
    dialog.set_close_response("cancel");
@@ -268,17 +330,45 @@ pub(crate) fn prompt_2fa(ui: &Rc<Ui>, code_tx: std::sync::mpsc::Sender<String>)
    dialog.present(parent.as_ref());
 }

-/// Connect the sign-out button: disable+stop the mount service (so the daemon
-/// isn't left running without credentials), forget the stored session, and drop
-/// back to the login page.
-pub(crate) fn wire_logout(ui: &Rc<Ui>, button: &gtk4::Button) {
+/// Sign out, after a confirmation: disable+stop the mount service (so the
+/// daemon isn't left running without credentials), forget the stored session,
+/// and drop back to the login page.
+pub(crate) fn sign_out(ui: &Rc<Ui>) {
+    let Some(window) = ui_window(ui) else { return };
    let ui = ui.clone();
-    button.connect_clicked(move |_| {
-        service::disable_stop();
-        if let Err(e) = auth::logout() {
-            tracing::error!("logout failed: {e}");
-        }
-        *ui.session.borrow_mut() = None;
-        refresh(&ui);
-    });
+    confirm_destructive(
+        &window,
+        &gettext("Sign Out?"),
+        &gettext(
+            "Proton Drive will disconnect and stop syncing until you sign in again. Files already on this computer stay where they are.",
+        ),
+        &gettext("Sign Out"),
+        move || {
+            service::disable_stop();
+            if let Err(e) = auth::logout() {
+                tracing::error!("logout failed: {e}");
+            }
+            *ui.session.borrow_mut() = None;
+            refresh(&ui);
+        },
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::login_error_message;
+
+    #[test]
+    fn a_cancelled_prompt_says_which_step_was_skipped() {
+        let totp = pdfs_core::Error::Other("two-factor entry cancelled".into());
+        assert!(login_error_message(&totp).contains("two-factor code"));
+        let hv = pdfs_core::Error::Other("verification cancelled".into());
+        assert!(login_error_message(&hv).contains("verification wasn't completed"));
+    }
+
+    #[test]
+    fn an_unmapped_error_keeps_its_text() {
+        let error = pdfs_core::Error::Other("something odd".into());
+        assert_eq!(login_error_message(&error), "Sign-in failed: something odd");
+    }
 }
@@ -0,0 +1,877 @@
+//! The online street map under the Places map: vector tiles from OpenFreeMap,
+//! fetched and drawn on a worker thread, and handed to the map as finished
+//! images.
+//!
+//! It is off unless turned on in Preferences, since every tile fetched tells
+//! OpenFreeMap which part of the world is being looked at. OpenFreeMap needs
+//! no account or key, and its tiles are OpenStreetMap data in the
+//! OpenMapTiles schema; both have to be credited wherever the map shows.
+//!
+//! Tiles are kept on disk under the cache directory, per build of the tile
+//! set. A build never changes, so a cached tile is good until OpenFreeMap
+//! publishes the next one, and then the old build's directory goes. Town and
+//! country names are not baked into the images: they come back as [`Label`]s
+//! for the map to set on top, where it can keep them upright, sharp and apart
+//! from each other.
+
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use gtk4::cairo;
+
+use super::mvt::{self, Kind, Layer};
+
+/// Where OpenFreeMap describes its current tile set.
+const TILEJSON_URL: &str = "https://tiles.openfreemap.org/planet";
+
+/// The deepest zoom OpenFreeMap has tiles for. Closer in, a tile is drawn
+/// from part of its ancestor at this zoom.
+pub(crate) const DATA_MAX_ZOOM: u8 = 14;
+
+/// A tile's edge in logical px at the zoom it was made for.
+pub(crate) const TILE_EDGE: f64 = 256.0;
+
+/// How many tiles are fetched at once.
+const PARALLEL_FETCHES: usize = 6;
+
+/// How long one fetch may take.
+const FETCH_TIMEOUT: Duration = Duration::from_secs(20);
+
+/// Past this size the tile cache is emptied rather than left to grow.
+const DISK_BUDGET: u64 = 256 * 1024 * 1024;
+
+/// One tile of the Web Mercator grid: at zoom `z` the world is `2^z` tiles
+/// wide and tall, counted from the north-west.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub(crate) struct TileKey {
+    pub(crate) z: u8,
+    pub(crate) x: u32,
+    pub(crate) y: u32,
+}
+
+impl TileKey {
+    pub(crate) fn parent(self) -> Option<Self> {
+        (self.z > 0).then(|| Self {
+            z: self.z - 1,
+            x: self.x / 2,
+            y: self.y / 2,
+        })
+    }
+
+    /// The tile whose data this one is drawn from.
+    fn data(self) -> Self {
+        let mut key = self;
+        while key.z > DATA_MAX_ZOOM {
+            key = key.parent().unwrap_or(key);
+        }
+        key
+    }
+}
+
+/// The colours of the map, for a light or a dark window.
+pub(crate) struct Palette {
+    pub(crate) land: u32,
+    pub(crate) water: u32,
+    wood: u32,
+    grass: u32,
+    ice: u32,
+    sand: u32,
+    residential: u32,
+    industrial: u32,
+    building: u32,
+    motorway: u32,
+    primary: u32,
+    road: u32,
+    casing: u32,
+    rail: u32,
+    path: u32,
+    pub(crate) border: u32,
+    state_border: u32,
+    pub(crate) coast: u32,
+    pub(crate) text: u32,
+    pub(crate) halo: u32,
+    pub(crate) water_text: u32,
+}
+
+pub(crate) const LIGHT: Palette = Palette {
+    land: 0xf4f2ee,
+    water: 0xb3cde3,
+    wood: 0xd3e5c5,
+    grass: 0xdcebcf,
+    ice: 0xf2f6f9,
+    sand: 0xefe7d2,
+    residential: 0xebe7e2,
+    industrial: 0xebe4e8,
+    building: 0xdcd5ce,
+    motorway: 0xf2c98f,
+    primary: 0xfbe4ad,
+    road: 0xffffff,
+    casing: 0xd2cbc1,
+    rail: 0xb5afa8,
+    path: 0xbfae9c,
+    border: 0x9d94b5,
+    state_border: 0xc2bbd2,
+    coast: 0x9fbbd4,
+    text: 0x34313d,
+    halo: 0xffffff,
+    water_text: 0x4f7398,
+};
+
+pub(crate) const DARK: Palette = Palette {
+    land: 0x24222d,
+    water: 0x141c2b,
+    wood: 0x212c26,
+    grass: 0x232d27,
+    ice: 0x2c313a,
+    sand: 0x2d2b27,
+    residential: 0x292733,
+    industrial: 0x2b2833,
+    building: 0x322f3c,
+    motorway: 0x7a6647,
+    primary: 0x625a4b,
+    road: 0x46434f,
+    casing: 0x1a1822,
+    rail: 0x4e4a5a,
+    path: 0x3f3b49,
+    border: 0x857ca0,
+    state_border: 0x5c556f,
+    coast: 0x2c3b52,
+    text: 0xe7e4ef,
+    halo: 0x16141c,
+    water_text: 0x86a6cb,
+};
+
+pub(crate) fn palette(dark: bool) -> &'static Palette {
+    if dark { &DARK } else { &LIGHT }
+}
+
+pub(crate) fn set_rgb(cr: &cairo::Context, color: u32, alpha: f64) {
+    cr.set_source_rgba(
+        f64::from((color >> 16) & 0xff) / 255.0,
+        f64::from((color >> 8) & 0xff) / 255.0,
+        f64::from(color & 0xff) / 255.0,
+        alpha,
+    );
+}
+
+/// What kind of place a name stands for, which sets how it is written and
+/// which names win when they would overlap.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub(crate) enum LabelClass {
+    Country,
+    State,
+    City,
+    Town,
+    Village,
+    Suburb,
+    Hamlet,
+    Water,
+}
+
+impl LabelClass {
+    fn from_place(class: &str) -> Option<Self> {
+        Some(match class {
+            "country" => Self::Country,
+            "state" | "province" => Self::State,
+            "city" => Self::City,
+            "town" => Self::Town,
+            "village" => Self::Village,
+            "suburb" | "quarter" => Self::Suburb,
+            "hamlet" | "neighbourhood" | "isolated_dwelling" => Self::Hamlet,
+            _ => return None,
+        })
+    }
+
+    /// The zoom from which such names are shown at all.
+    pub(crate) fn min_zoom(self) -> u8 {
+        match self {
+            Self::Country | Self::Water | Self::City => 0,
+            Self::State => 4,
+            Self::Town => 8,
+            Self::Village => 11,
+            Self::Suburb => 12,
+            Self::Hamlet => 14,
+        }
+    }
+
+    /// The zoom past which such names are left out again: a country's name
+    /// is no help once its towns are.
+    pub(crate) fn max_zoom(self) -> u8 {
+        match self {
+            Self::Country => 7,
+            Self::State => 9,
+            _ => u8::MAX,
+        }
+    }
+}
+
+/// A name to set on the map, at its place in world space (0..1 both ways).
+#[derive(Clone, Debug)]
+pub(crate) struct Label {
+    pub(crate) x: f64,
+    pub(crate) y: f64,
+    pub(crate) text: String,
+    pub(crate) class: LabelClass,
+    /// Lower is more important, within a class.
+    pub(crate) rank: f64,
+}
+
+/// A finished tile: premultiplied ARGB pixels, as cairo keeps them.
+pub(crate) struct Raster {
+    pub(crate) key: TileKey,
+    pub(crate) dark: bool,
+    pub(crate) edge: i32,
+    pub(crate) pixels: Vec<u8>,
+    pub(crate) labels: Vec<Label>,
+}
+
+impl Raster {
+    pub(crate) fn surface(self) -> Option<cairo::ImageSurface> {
+        let stride = self.edge * 4;
+        cairo::ImageSurface::create_for_data(
+            self.pixels,
+            cairo::Format::ARgb32,
+            self.edge,
+            self.edge,
+            stride,
+        )
+        .ok()
+    }
+}
+
+pub(crate) enum Done {
+    Tile(Raster),
+    /// Nothing came: no network, or no such tile. The outline shows there.
+    Failed(TileKey),
+    /// The tile went off screen before its turn.
+    Dropped(TileKey),
+}
+
+struct Job {
+    key: TileKey,
+    dark: bool,
+}
+
+/// The worker thread making tiles. Dropping it stops the thread once the
+/// fetches under way are done.
+pub(crate) struct Tiles {
+    jobs: async_channel::Sender<Job>,
+    wanted: Arc<Mutex<HashSet<TileKey>>>,
+    /// Device pixels per logical px the tiles are made at.
+    pub(crate) scale: i32,
+}
+
+impl Tiles {
+    /// Start the worker, caching under `cache_dir`, drawing names in
+    /// `language` where the map has them. Finished tiles arrive on the
+    /// returned channel.
+    pub(crate) fn start(
+        cache_dir: PathBuf,
+        language: String,
+        scale: i32,
+    ) -> (Self, async_channel::Receiver<Done>) {
+        let (jobs, job_rx) = async_channel::unbounded();
+        let (done_tx, done_rx) = async_channel::unbounded();
+        let wanted = Arc::new(Mutex::new(HashSet::new()));
+        let worker = Worker {
+            dir: cache_dir,
+            language,
+            scale,
+            wanted: wanted.clone(),
+            done: done_tx,
+        };
+        let spawned = std::thread::Builder::new()
+            .name("map-tiles".into())
+            .spawn(move || worker.run(job_rx));
+        if let Err(e) = spawned {
+            tracing::warn!("map tiles: cannot start the worker: {e}");
+        }
+        (
+            Self {
+                jobs,
+                wanted,
+                scale,
+            },
+            done_rx,
+        )
+    }
+
+    pub(crate) fn request(&self, key: TileKey, dark: bool) {
+        let _ = self.jobs.try_send(Job { key, dark });
+    }
+
+    /// The tiles on screen now. A queued tile that isn't is skipped.
+    pub(crate) fn set_wanted(&self, keys: HashSet<TileKey>) {
+        if let Ok(mut wanted) = self.wanted.lock() {
+            *wanted = keys;
+        }
+    }
+}
+
+struct Worker {
+    dir: PathBuf,
+    language: String,
+    scale: i32,
+    wanted: Arc<Mutex<HashSet<TileKey>>>,
+    done: async_channel::Sender<Done>,
+}
+
+impl Worker {
+    fn run(self, jobs: async_channel::Receiver<Job>) {
+        let runtime = match tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+        {
+            Ok(runtime) => runtime,
+            Err(e) => {
+                tracing::warn!("map tiles: no runtime: {e}");
+                return;
+            }
+        };
+        let client = match reqwest::Client::builder()
+            .user_agent(concat!(
+                "proton-drive-linux/",
+                env!("CARGO_PKG_VERSION"),
+                " (",
+                env!("CARGO_PKG_REPOSITORY"),
+                ")"
+            ))
+            .timeout(FETCH_TIMEOUT)
+            .build()
+        {
+            Ok(client) => client,
+            Err(e) => {
+                tracing::warn!("map tiles: no HTTP client: {e}");
+                return;
+            }
+        };
+        let worker = Arc::new(self);
+        runtime.block_on(async move {
+            let source = Arc::new(tokio::sync::Mutex::new(None::<String>));
+            let slots = Arc::new(tokio::sync::Semaphore::new(PARALLEL_FETCHES));
+            while let Ok(job) = jobs.recv().await {
+                let Ok(permit) = slots.clone().acquire_owned().await else {
+                    break;
+                };
+                let (worker, client, source) = (worker.clone(), client.clone(), source.clone());
+                tokio::spawn(async move {
+                    let done = worker.make(&client, &source, job).await;
+                    let _ = worker.done.send(done).await;
+                    drop(permit);
+                });
+            }
+            // Let the tiles under way finish before the runtime goes.
+            let _ = slots.acquire_many(PARALLEL_FETCHES as u32).await;
+        });
+    }
+
+    async fn make(
+        self: &Arc<Self>,
+        client: &reqwest::Client,
+        source: &tokio::sync::Mutex<Option<String>>,
+        job: Job,
+    ) -> Done {
+        let key = job.key;
+        let still_wanted = self.wanted.lock().map(|w| w.contains(&key)).unwrap_or(true);
+        if !still_wanted {
+            return Done::Dropped(key);
+        }
+        let Some(data) = self.load(client, source, key.data()).await else {
+            return Done::Failed(key);
+        };
+        let worker = self.clone();
+        let made = tokio::task::spawn_blocking(move || {
+            let layers = mvt::decode(&data)?;
+            render(&layers, key, job.dark, worker.scale, &worker.language)
+        })
+        .await;
+        match made {
+            Ok(Some(raster)) => Done::Tile(raster),
+            _ => Done::Failed(key),
+        }
+    }
+
+    /// The tile's data, from the disk cache or else from OpenFreeMap.
+    async fn load(
+        &self,
+        client: &reqwest::Client,
+        source: &tokio::sync::Mutex<Option<String>>,
+        key: TileKey,
+    ) -> Option<Vec<u8>> {
+        let template = {
+            let mut source = source.lock().await;
+            if source.is_none() {
+                *source = self.tile_source(client).await;
+            }
+            source.clone()?
+        };
+        let path = self
+            .build_dir(&template)?
+            .join(key.z.to_string())
+            .join(key.x.to_string())
+            .join(format!("{}.pbf", key.y));
+        if let Ok(data) = tokio::fs::read(&path).await {
+            return Some(data);
+        }
+        let url = template
+            .replace("{z}", &key.z.to_string())
+            .replace("{x}", &key.x.to_string())
+            .replace("{y}", &key.y.to_string());
+        let reply = client.get(&url).send().await.ok()?;
+        if !reply.status().is_success() {
+            tracing::debug!("map tile {url}: {}", reply.status());
+            return None;
+        }
+        let data = reply.bytes().await.ok()?.to_vec();
+        if let Some(parent) = path.parent() {
+            let _ = tokio::fs::create_dir_all(parent).await;
+        }
+        let _ = tokio::fs::write(&path, &data).await;
+        Some(data)
+    }
+
+    /// The URL template of OpenFreeMap's current build, remembered on disk so
+    /// the cached tiles still show without a network.
+    async fn tile_source(&self, client: &reqwest::Client) -> Option<String> {
+        let saved = self.dir.join("tiles.json");
+        let fetched = async {
+            let reply = client.get(TILEJSON_URL).send().await.ok()?;
+            if !reply.status().is_success() {
+                return None;
+            }
+            reply.bytes().await.ok()
+        }
+        .await;
+        let (json, fresh) = match fetched {
+            Some(json) => (json.to_vec(), true),
+            None => (tokio::fs::read(&saved).await.ok()?, false),
+        };
+        let template = tile_template(&json)?;
+        if fresh {
+            let _ = tokio::fs::create_dir_all(&self.dir).await;
+            let _ = tokio::fs::write(&saved, &json).await;
+            let (dir, build) = (self.dir.clone(), build_name(&template)?);
+            let _ = tokio::task::spawn_blocking(move || prune(&dir, &build)).await;
+        }
+        Some(template)
+    }
+
+    fn build_dir(&self, template: &str) -> Option<PathBuf> {
+        Some(self.dir.join(build_name(template)?))
+    }
+}
+
+/// The first tile URL template in a TileJSON document.
+fn tile_template(json: &[u8]) -> Option<String> {
+    let doc: serde_json::Value = serde_json::from_slice(json).ok()?;
+    let template = doc.get("tiles")?.get(0)?.as_str()?;
+    template
+        .starts_with("https://")
+        .then(|| template.to_owned())
+}
+
+/// The tile set's build, the path segment before `/{z}`: a safe directory
+/// name, or `None`.
+fn build_name(template: &str) -> Option<String> {
+    let head = template.split("/{z}").next()?;
+    let name = head.rsplit('/').next()?;
+    let safe = !name.is_empty()
+        && name
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-' || c == '.')
+        && name != "."
+        && name != "..";
+    safe.then(|| name.to_owned())
+}
+
+/// Remove the cached builds other than `keep`, and `keep` itself once it
+/// holds more than [`DISK_BUDGET`].
+fn prune(dir: &Path, keep: &str) {
+    let Ok(entries) = std::fs::read_dir(dir) else {
+        return;
+    };
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if !path.is_dir() {
+            continue;
+        }
+        let stale = entry.file_name() != keep || dir_size(&path) > DISK_BUDGET;
+        if stale && let Err(e) = std::fs::remove_dir_all(&path) {
+            tracing::debug!("map tiles: cannot remove {}: {e}", path.display());
+        }
+    }
+}
+
+fn dir_size(dir: &Path) -> u64 {
+    let Ok(entries) = std::fs::read_dir(dir) else {
+        return 0;
+    };
+    entries
+        .flatten()
+        .map(|entry| match entry.metadata() {
+            Ok(meta) if meta.is_dir() => dir_size(&entry.path()),
+            Ok(meta) => meta.len(),
+            Err(_) => 0,
+        })
+        .sum()
+}
+
+/// Draw tile `key` from the layers of its data tile, at `scale` device px
+/// per logical px, and gather the names on it.
+fn render(
+    layers: &[Layer],
+    key: TileKey,
+    dark: bool,
+    scale: i32,
+    language: &str,
+) -> Option<Raster> {
+    let edge = (TILE_EDGE as i32) * scale.max(1);
+    let surface = cairo::ImageSurface::create(cairo::Format::ARgb32, edge, edge).ok()?;
+    let labels = {
+        let cr = cairo::Context::new(&surface).ok()?;
+        cr.scale(f64::from(scale), f64::from(scale));
+        let painter = Painter {
+            cr: &cr,
+            key,
+            data: key.data(),
+            colors: palette(dark),
+        };
+        painter.paint(layers);
+        gather_labels(layers, key.data(), language)
+    };
+    surface.flush();
+    let pixels = surface.take_data().ok()?.to_vec();
+    Some(Raster {
+        key,
+        dark,
+        edge,
+        pixels,
+        labels,
+    })
+}
+
+struct Painter<'a> {
+    cr: &'a cairo::Context,
+    key: TileKey,
+    data: TileKey,
+    colors: &'static Palette,
+}
+
+impl Painter<'_> {
+    fn paint(&self, layers: &[Layer]) {
+        let c = self.colors;
+        let z = self.key.z;
+        set_rgb(self.cr, c.land, 1.0);
+        let _ = self.cr.paint();
+
+        let layer = |name: &str| layers.iter().find(|l| l.name == name);
+        if let Some(layer) = layer("landcover") {
+            self.fill(layer, |class| match class {
+                "wood" | "forest" => Some(c.wood),
+                "grass" | "wetland" => Some(c.grass),
+                "ice" | "glacier" => Some(c.ice),
+                "sand" | "beach" => Some(c.sand),
+                _ => None,
+            });
+        }
+        if let Some(layer) = layer("landuse") {
+            self.fill(layer, |class| match class {
+                "residential" | "suburb" | "neighbourhood" => Some(c.residential),
+                "industrial" | "commercial" | "retail" | "railway" => Some(c.industrial),
+                "stadium" | "pitch" | "playground" | "cemetery" => Some(c.grass),
+                _ => None,
+            });
+        }
+        if let Some(layer) = layer("park") {
+            self.fill(layer, |_| Some(c.grass));
+        }
+        if let Some(layer) = layer("water") {
+            self.fill(layer, |_| Some(c.water));
+        }
+        if let Some(layer) = layer("waterway") {
+            self.stroke(layer, |class| {
+                let (base, from) = match class {
+                    "river" => (1.2, 8),
+                    "canal" => (1.0, 12),
+                    "stream" => (0.6, 13),
+                    _ => return None,
+                };
+                (z >= from).then(|| (c.water, grow(base, z), false))
+            });
+        }
+        if z >= 13
+            && let Some(layer) = layer("building")
+        {
+            self.fill(layer, |_| Some(c.building));
+        }
+        if let Some(layer) = layer("transportation") {
+            self.roads(layer);
+        }
+        if let Some(layer) = layer("boundary") {
+            self.borders(layer);
+        }
+    }
+
+    /// Map tile units of the data tile onto this tile's logical px.
+    fn to_px(&self, layer: &Layer, (u, v): (f64, f64)) -> (f64, f64) {
+        let k = f64::from(1u32 << (self.key.z - self.data.z));
+        let ox = f64::from(self.key.x) - f64::from(self.data.x) * k;
+        let oy = f64::from(self.key.y) - f64::from(self.data.y) * k;
+        (
+            (u / layer.extent * k - ox) * TILE_EDGE,
+            (v / layer.extent * k - oy) * TILE_EDGE,
+        )
+    }
+
+    fn trace(&self, layer: &Layer, part: &[(f64, f64)], close: bool) {
+        for (i, &point) in part.iter().enumerate() {
+            let (x, y) = self.to_px(layer, point);
+            if i == 0 {
+                self.cr.move_to(x, y);
+            } else {
+                self.cr.line_to(x, y);
+            }
+        }
+        if close {
+            self.cr.close_path();
+        }
+    }
+
+    /// Fill the layer's polygons in the colour `color` picks by class.
+    fn fill(&self, layer: &Layer, color: impl Fn(&str) -> Option<u32>) {
+        self.cr.set_fill_rule(cairo::FillRule::EvenOdd);
+        for feature in &layer.features {
+            if feature.kind != Kind::Polygon {
+                continue;
+            }
+            let class = layer.text(feature, "class").unwrap_or("");
+            let Some(rgb) = color(class) else {
+                continue;
+            };
+            self.cr.new_path();
+            for part in &feature.parts {
+                self.trace(layer, part, true);
+            }
+            set_rgb(self.cr, rgb, 1.0);
+            let _ = self.cr.fill();
+        }
+    }
+
+    /// Stroke the layer's lines as `style` says by class: colour, width in
+    /// px, and whether dashed.
+    fn stroke(&self, layer: &Layer, style: impl Fn(&str) -> Option<(u32, f64, bool)>) {
+        self.cr.set_line_cap(cairo::LineCap::Round);
+        self.cr.set_line_join(cairo::LineJoin::Round);
+        for feature in &layer.features {
+            if feature.kind != Kind::Line {
+                continue;
+            }
+            let class = layer.text(feature, "class").unwrap_or("");
+            let Some((rgb, width, dashed)) = style(class) else {
+                continue;
+            };
+            self.cr.new_path();
+            for part in &feature.parts {
+                self.trace(layer, part, false);
+            }
+            set_rgb(self.cr, rgb, 1.0);
+            self.cr.set_line_width(width);
+            let dash = [width * 2.0, width * 2.0];
+            self.cr.set_dash(if dashed { &dash } else { &[] }, 0.0);
+            let _ = self.cr.stroke();
+        }
+        self.cr.set_dash(&[], 0.0);
+    }
+
+    /// Roads, minor first so the major ones cross over them, each on a
+    /// darker casing once they are wide enough for one.
+    fn roads(&self, layer: &Layer) {
+        let c = self.colors;
+        let z = self.key.z;
+        let road = |class: &str| -> Option<(u32, f64, u8)> {
+            let (color, width, rank) = match class {
+                "motorway" if z >= 6 => (c.motorway, grow(2.2, z), 4),
+                "trunk" if z >= 7 => (c.motorway, grow(2.2, z), 4),
+                "primary" if z >= 8 => (c.primary, grow(1.8, z), 3),
+                "secondary" if z >= 10 => (c.road, grow(1.4, z), 2),
+                "tertiary" if z >= 11 => (c.road, grow(1.4, z), 2),
+                "minor" | "busway" if z >= 12 => (c.road, grow(1.0, z), 1),
+                "service" if z >= 14 => (c.road, grow(0.6, z), 0),
+                _ => return None,
+            };
+            Some((color, width, rank))
+        };
+        for rank in 0..=4u8 {
+            let pick = |class: &str| road(class).filter(|r| r.2 == rank);
+            if z >= 12 {
+                self.stroke(layer, |class| {
+                    pick(class).map(|(_, width, _)| (c.casing, width + 1.5, false))
+                });
+            }
+            self.stroke(layer, |class| {
+                pick(class).map(|(color, width, _)| (color, width, false))
+            });
+        }
+        self.stroke(layer, |class| match class {
+            "rail" | "transit" if z >= 10 => Some((c.rail, grow(0.7, z).min(2.5), false)),
+            "path" | "track" if z >= 14 => Some((c.path, 0.8, true)),
+            _ => None,
+        });
+    }
+
+    fn borders(&self, layer: &Layer) {
+        let c = self.colors;
+        let z = self.key.z;
+        self.cr.set_line_cap(cairo::LineCap::Round);
+        for feature in &layer.features {
+            if feature.kind != Kind::Line || layer.number(feature, "maritime") == Some(1.0) {
+                continue;
+            }
+            let (color, width, dashed) = match layer.number(feature, "admin_level") {
+                Some(level) if level <= 2.0 => {
+                    (c.border, (0.9 * 1.12f64.powi(i32::from(z))).min(2.5), false)
+                }
+                Some(level) if level <= 4.0 && z >= 5 => (c.state_border, 0.8, true),
+                _ => continue,
+            };
+            let dashed = dashed || layer.number(feature, "disputed") == Some(1.0);
+            self.cr.new_path();
+            for part in &feature.parts {
+                self.trace(layer, part, false);
+            }
+            set_rgb(self.cr, color, 1.0);
+            self.cr.set_line_width(width);
+            self.cr
+                .set_dash(if dashed { &[3.0, 2.5] } else { &[] }, 0.0);
+            let _ = self.cr.stroke();
+        }
+        self.cr.set_dash(&[], 0.0);
+    }
+}
+
+/// A line width that grows with the zoom, as the things it stands for get
+/// bigger on screen.
+fn grow(base: f64, z: u8) -> f64 {
+    (base * 1.4f64.powi(i32::from(z) - 10)).clamp(0.5, 24.0)
+}
+
+/// The names of towns, countries and seas on data tile `data`, in world
+/// space. Names in the tile's buffer beyond its edge are left to the
+/// neighbour they belong to.
+fn gather_labels(layers: &[Layer], data: TileKey, language: &str) -> Vec<Label> {
+    let n = f64::from(1u32 << data.z);
+    let mut labels = Vec::new();
+    for layer in layers {
+        let water = match layer.name.as_str() {
+            "place" => false,
+            "water_name" => true,
+            _ => continue,
+        };
+        for feature in &layer.features {
+            if feature.kind != Kind::Point {
+                continue;
+            }
+            let class = if water {
+                LabelClass::Water
+            } else {
+                let Some(class) = layer
+                    .text(feature, "class")
+                    .and_then(LabelClass::from_place)
+                else {
+                    continue;
+                };
+                class
+            };
+            let Some(text) = label_name(layer, feature, language) else {
+                continue;
+            };
+            let rank = layer.number(feature, "rank").unwrap_or(99.0);
+            for &(u, v) in feature.parts.iter().flatten() {
+                if !(0.0..layer.extent).contains(&u) || !(0.0..layer.extent).contains(&v) {
+                    continue;
+                }
+                labels.push(Label {
+                    x: (f64::from(data.x) + u / layer.extent) / n,
+                    y: (f64::from(data.y) + v / layer.extent) / n,
+                    text: text.clone(),
+                    class,
+                    rank,
+                });
+            }
+        }
+    }
+    labels
+}
+
+/// A feature's name in `language` where the map has it, else in Latin
+/// letters, else as written locally.
+fn label_name(layer: &Layer, feature: &mvt::Feature, language: &str) -> Option<String> {
+    [
+        format!("name:{language}"),
+        format!("name_{language}"),
+        "name:latin".to_owned(),
+        "name".to_owned(),
+    ]
+    .iter()
+    .find_map(|key| layer.text(feature, key).filter(|name| !name.is_empty()))
+    .map(|name| name.replace('\n', " "))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deep_tiles_draw_from_their_ancestor_at_the_data_zoom() {
+        let key = TileKey {
+            z: 16,
+            x: 34_336,
+            y: 22_437,
+        };
+        assert_eq!(
+            key.data(),
+            TileKey {
+                z: 14,
+                x: 8_584,
+                y: 5_609
+            }
+        );
+        let shallow = TileKey { z: 3, x: 4, y: 2 };
+        assert_eq!(shallow.data(), shallow);
+    }
+
+    #[test]
+    fn the_build_comes_from_the_tile_template() {
+        let json = br#"{"tiles":["https://tiles.openfreemap.org/planet/20260913_164504_pt/{z}/{x}/{y}.pbf"]}"#;
+        let template = tile_template(json).unwrap();
+        assert_eq!(build_name(&template).as_deref(), Some("20260913_164504_pt"));
+        assert_eq!(build_name("https://example.org/../{z}/{x}/{y}.pbf"), None);
+        assert_eq!(
+            tile_template(br#"{"tiles":["http://plain.example/{z}"]}"#),
+            None
+        );
+    }
+
+    #[test]
+    fn an_old_build_is_pruned_and_the_current_one_kept() {
+        let dir = std::env::temp_dir().join(format!("pdfs-map-prune-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(dir.join("old/1/0")).unwrap();
+        std::fs::create_dir_all(dir.join("new/1/0")).unwrap();
+        std::fs::write(dir.join("new/1/0/0.pbf"), b"tile").unwrap();
+        std::fs::write(dir.join("tiles.json"), b"{}").unwrap();
+        prune(&dir, "new");
+        assert!(!dir.join("old").exists());
+        assert!(dir.join("new/1/0/0.pbf").exists());
+        assert!(dir.join("tiles.json").exists());
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
+
+    #[test]
+    fn roads_widen_as_the_map_zooms_in() {
+        assert!(grow(1.4, 14) > grow(1.4, 10));
+        assert_eq!(grow(2.2, 30), 24.0);
+    }
+}
@@ -2,10 +2,15 @@ pub(crate) mod activity;
 pub(crate) mod albums;
 pub(crate) mod browser;
 pub(crate) mod devices;
+pub(crate) mod duplicates;
 pub(crate) mod locations;
 pub(crate) mod login;
+pub(crate) mod map_tiles;
+pub(crate) mod mvt;
 pub(crate) mod photo_viewer;
 pub(crate) mod photos;
+pub(crate) mod places;
+pub(crate) mod places_map;
 pub(crate) mod shared;
 pub(crate) mod shared_by_me;
 pub(crate) mod status;
@@ -0,0 +1,386 @@
+//! A reader for Mapbox Vector Tiles, the format the online Places map's tiles
+//! come in: protobuf, one message per tile, holding named layers of point,
+//! line and polygon features with key/value tags.
+//!
+//! Only what drawing needs is read — layer names, tags and geometry — and a
+//! tile that doesn't parse is `None` rather than an error: the map then shows
+//! the outline underneath it. The format is at
+//! <https://github.com/mapbox/vector-tile-spec>.
+
+/// One layer of a tile, such as `water` or `transportation`.
+pub(crate) struct Layer {
+    pub(crate) name: String,
+    /// The tile's width in geometry units; 4096 almost everywhere.
+    pub(crate) extent: f64,
+    keys: Vec<String>,
+    values: Vec<Value>,
+    pub(crate) features: Vec<Feature>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) enum Value {
+    Text(String),
+    Number(f64),
+    Bool(bool),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Kind {
+    Point,
+    Line,
+    Polygon,
+}
+
+pub(crate) struct Feature {
+    pub(crate) kind: Kind,
+    /// Pairs of indices into the layer's keys and values.
+    tags: Vec<(u32, u32)>,
+    /// Points, lines or polygon rings, in tile units. A point feature holds
+    /// one part with all its points.
+    pub(crate) parts: Vec<Vec<(f64, f64)>>,
+}
+
+impl Layer {
+    /// The value `feature` carries for `key`.
+    pub(crate) fn tag(&self, feature: &Feature, key: &str) -> Option<&Value> {
+        feature.tags.iter().find_map(|&(k, v)| {
+            (self.keys.get(k as usize)? == key).then(|| self.values.get(v as usize))?
+        })
+    }
+
+    pub(crate) fn text(&self, feature: &Feature, key: &str) -> Option<&str> {
+        match self.tag(feature, key)? {
+            Value::Text(text) => Some(text),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn number(&self, feature: &Feature, key: &str) -> Option<f64> {
+        match self.tag(feature, key)? {
+            Value::Number(n) => Some(*n),
+            _ => None,
+        }
+    }
+}
+
+/// Every layer of the tile in `data`.
+pub(crate) fn decode(data: &[u8]) -> Option<Vec<Layer>> {
+    let mut tile = Reader::new(data);
+    let mut layers = Vec::new();
+    while let Some((field, wire)) = tile.field()? {
+        match field {
+            3 => layers.push(decode_layer(tile.bytes()?)?),
+            _ => tile.skip(wire)?,
+        }
+    }
+    Some(layers)
+}
+
+fn decode_layer(data: &[u8]) -> Option<Layer> {
+    let mut layer = Layer {
+        name: String::new(),
+        extent: 4096.0,
+        keys: Vec::new(),
+        values: Vec::new(),
+        features: Vec::new(),
+    };
+    let mut reader = Reader::new(data);
+    while let Some((field, wire)) = reader.field()? {
+        match field {
+            1 => layer.name = reader.text()?,
+            2 => {
+                if let Some(feature) = decode_feature(reader.bytes()?) {
+                    layer.features.push(feature);
+                }
+            }
+            3 => layer.keys.push(reader.text()?),
+            4 => layer.values.push(decode_value(reader.bytes()?)?),
+            5 => layer.extent = reader.varint()? as f64,
+            _ => reader.skip(wire)?,
+        }
+    }
+    Some(layer)
+}
+
+fn decode_value(data: &[u8]) -> Option<Value> {
+    let mut reader = Reader::new(data);
+    let mut value = Value::Bool(false);
+    while let Some((field, wire)) = reader.field()? {
+        value = match field {
+            1 => Value::Text(reader.text()?),
+            2 => Value::Number(f64::from(f32::from_bits(reader.fixed32()?))),
+            3 => Value::Number(f64::from_bits(reader.fixed64()?)),
+            4 | 5 => Value::Number(reader.varint()? as i64 as f64),
+            6 => Value::Number(zigzag(reader.varint()?) as f64),
+            7 => Value::Bool(reader.varint()? != 0),
+            _ => {
+                reader.skip(wire)?;
+                continue;
+            }
+        };
+    }
+    Some(value)
+}
+
+/// A feature, or `None` for one this map can't draw (unknown geometry type,
+/// or broken).
+fn decode_feature(data: &[u8]) -> Option<Feature> {
+    let mut reader = Reader::new(data);
+    let mut kind = None;
+    let mut tags = Vec::new();
+    let mut geometry = Vec::new();
+    while let Some((field, wire)) = reader.field()? {
+        match field {
+            2 => {
+                let packed = reader.packed()?;
+                tags = packed
+                    .as_chunks::<2>()
+                    .0
+                    .iter()
+                    .map(|&[k, v]| (k as u32, v as u32))
+                    .collect();
+            }
+            3 => {
+                kind = match reader.varint()? {
+                    1 => Some(Kind::Point),
+                    2 => Some(Kind::Line),
+                    3 => Some(Kind::Polygon),
+                    _ => None,
+                }
+            }
+            4 => geometry = reader.packed()?,
+            _ => reader.skip(wire)?,
+        }
+    }
+    let kind = kind?;
+    Some(Feature {
+        kind,
+        tags,
+        parts: decode_geometry(kind, &geometry)?,
+    })
+}
+
+/// Turn the command stream of a feature's geometry into its parts. Positions
+/// are deltas from the previous one, carried across parts.
+fn decode_geometry(kind: Kind, commands: &[u64]) -> Option<Vec<Vec<(f64, f64)>>> {
+    let mut parts: Vec<Vec<(f64, f64)>> = Vec::new();
+    let (mut x, mut y) = (0i64, 0i64);
+    let mut i = 0;
+    while i < commands.len() {
+        let command = commands[i] & 7;
+        let count = (commands[i] >> 3) as usize;
+        i += 1;
+        match command {
+            // MoveTo starts a part — except for points, which all share one.
+            1 | 2 => {
+                if i + 2 * count > commands.len() {
+                    return None;
+                }
+                for n in 0..count {
+                    x += zigzag(commands[i + 2 * n]);
+                    y += zigzag(commands[i + 2 * n + 1]);
+                    let starts = command == 1 && (kind != Kind::Point || parts.is_empty());
+                    if starts {
+                        parts.push(Vec::new());
+                    }
+                    parts.last_mut()?.push((x as f64, y as f64));
+                }
+                i += 2 * count;
+            }
+            // ClosePath: the ring's end joins its start, which drawing does.
+            7 => {}
+            _ => return None,
+        }
+    }
+    Some(parts)
+}
+
+fn zigzag(n: u64) -> i64 {
+    ((n >> 1) as i64) ^ -((n & 1) as i64)
+}
+
+/// The protobuf wire format, as far as vector tiles use it.
+struct Reader<'a> {
+    data: &'a [u8],
+    at: usize,
+}
+
+impl<'a> Reader<'a> {
+    fn new(data: &'a [u8]) -> Self {
+        Self { data, at: 0 }
+    }
+
+    /// The next field's number and wire type; `Some(None)` at the end, `None`
+    /// on a broken message.
+    fn field(&mut self) -> Option<Option<(u64, u8)>> {
+        if self.at >= self.data.len() {
+            return Some(None);
+        }
+        let key = self.varint()?;
+        Some(Some((key >> 3, (key & 7) as u8)))
+    }
+
+    fn varint(&mut self) -> Option<u64> {
+        let mut value = 0u64;
+        for shift in (0..64).step_by(7) {
+            let byte = *self.data.get(self.at)?;
+            self.at += 1;
+            value |= u64::from(byte & 0x7f) << shift;
+            if byte & 0x80 == 0 {
+                return Some(value);
+            }
+        }
+        None
+    }
+
+    fn take(&mut self, n: usize) -> Option<&'a [u8]> {
+        let end = self.at.checked_add(n)?;
+        let bytes = self.data.get(self.at..end)?;
+        self.at = end;
+        Some(bytes)
+    }
+
+    fn bytes(&mut self) -> Option<&'a [u8]> {
+        let len = usize::try_from(self.varint()?).ok()?;
+        self.take(len)
+    }
+
+    fn text(&mut self) -> Option<String> {
+        Some(String::from_utf8_lossy(self.bytes()?).into_owned())
+    }
+
+    fn fixed32(&mut self) -> Option<u32> {
+        Some(u32::from_le_bytes(self.take(4)?.try_into().ok()?))
+    }
+
+    fn fixed64(&mut self) -> Option<u64> {
+        Some(u64::from_le_bytes(self.take(8)?.try_into().ok()?))
+    }
+
+    fn packed(&mut self) -> Option<Vec<u64>> {
+        let mut inner = Reader::new(self.bytes()?);
+        let mut values = Vec::new();
+        while inner.at < inner.data.len() {
+            values.push(inner.varint()?);
+        }
+        Some(values)
+    }
+
+    fn skip(&mut self, wire: u8) -> Option<()> {
+        match wire {
+            0 => {
+                self.varint()?;
+            }
+            1 => {
+                self.take(8)?;
+            }
+            2 => {
+                self.bytes()?;
+            }
+            5 => {
+                self.take(4)?;
+            }
+            _ => return None,
+        }
+        Some(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn varint(mut n: u64, out: &mut Vec<u8>) {
+        while n >= 0x80 {
+            out.push((n as u8) | 0x80);
+            n >>= 7;
+        }
+        out.push(n as u8);
+    }
+
+    fn field(number: u64, bytes: &[u8], out: &mut Vec<u8>) {
+        varint(number << 3 | 2, out);
+        varint(bytes.len() as u64, out);
+        out.extend_from_slice(bytes);
+    }
+
+    fn packed(values: &[u64]) -> Vec<u8> {
+        let mut out = Vec::new();
+        for &v in values {
+            varint(v, &mut out);
+        }
+        out
+    }
+
+    fn zz(n: i64) -> u64 {
+        ((n << 1) ^ (n >> 63)) as u64
+    }
+
+    /// A tile with one `water` layer holding one square tagged class=lake.
+    fn lake_tile() -> Vec<u8> {
+        let mut feature = Vec::new();
+        field(2, &packed(&[0, 0]), &mut feature);
+        varint(3 << 3, &mut feature);
+        varint(3, &mut feature);
+        let square = [
+            1 | 1 << 3,
+            zz(10),
+            zz(10),
+            2 | 3 << 3,
+            zz(20),
+            zz(0),
+            zz(0),
+            zz(20),
+            zz(-20),
+            zz(0),
+            7 | 1 << 3,
+        ];
+        field(4, &packed(&square), &mut feature);
+
+        let mut value = Vec::new();
+        field(1, b"lake", &mut value);
+
+        let mut layer = Vec::new();
+        field(1, b"water", &mut layer);
+        field(2, &feature, &mut layer);
+        field(3, b"class", &mut layer);
+        field(4, &value, &mut layer);
+        varint(5 << 3, &mut layer);
+        varint(4096, &mut layer);
+
+        let mut tile = Vec::new();
+        field(3, &layer, &mut tile);
+        tile
+    }
+
+    #[test]
+    fn a_polygon_decodes_with_its_tags() {
+        let layers = decode(&lake_tile()).unwrap();
+        let [water] = &layers[..] else {
+            panic!("one layer expected");
+        };
+        assert_eq!(water.name, "water");
+        assert_eq!(water.extent, 4096.0);
+        let feature = &water.features[0];
+        assert_eq!(feature.kind, Kind::Polygon);
+        assert_eq!(water.text(feature, "class"), Some("lake"));
+        assert_eq!(water.text(feature, "name"), None);
+        assert_eq!(
+            feature.parts,
+            vec![vec![(10.0, 10.0), (30.0, 10.0), (30.0, 30.0), (10.0, 30.0)]]
+        );
+    }
+
+    #[test]
+    fn a_cut_off_tile_is_rejected() {
+        let tile = lake_tile();
+        assert!(decode(&tile[..tile.len() - 3]).is_none());
+    }
+
+    #[test]
+    fn points_of_one_feature_share_a_part() {
+        let commands = [1 | 2 << 3, zz(5), zz(5), zz(1), zz(-1)];
+        let parts = decode_geometry(Kind::Point, &commands).unwrap();
+        assert_eq!(parts, vec![vec![(5.0, 5.0), (6.0, 4.0)]]);
+    }
+}
@@ -0,0 +1,514 @@
+//! The Places view of the Photos page: a grid of the towns the photos were
+//! taken in, and the place that opens when one is clicked.
+//!
+//! An open place works like an open album: it is parked in
+//! [`GalleryState::place`], and [`load_gallery`] pages
+//! [`Request::PlacePhotos`] instead of the timeline.
+
+use crate::*;
+
+/// Edge length in px of a place's cover, the same as an album's.
+const COVER_EDGE: i32 = 200;
+
+/// Edge length in px of a photo in the list of photos taken on one spot.
+const SPOT_EDGE: i32 = 96;
+
+/// How often the listing is asked for again while photo locations are read.
+const MAPPING_POLL: std::time::Duration = std::time::Duration::from_secs(2);
+
+/// Show the Places grid and (re)load it. Called when the Places toggle goes on.
+pub(crate) fn show_places(ui: &Rc<Ui>) {
+    show_place_grid(ui);
+    load_places(ui);
+}
+
+/// Switch to the place grid as it was last filled, keeping its scroll
+/// position. The timeline's filters do not apply to places, so they go.
+pub(crate) fn show_place_grid(ui: &Rc<Ui>) {
+    close_place(ui);
+    close_album(ui);
+    ui.gallery.filters.set_visible(false);
+    ui.gallery.content.set_visible_child_name("places");
+    ui.gallery
+        .title
+        .set_subtitle(&places_subtitle(ui.gallery.place_count.get()));
+}
+
+/// Ask the daemon for the place listing and rebuild the grid.
+pub(crate) fn load_places(ui: &Rc<Ui>) {
+    if ui.gallery.places_loading.get() {
+        return;
+    }
+    ui.gallery.places_loading.set(true);
+    // A grid already on screen stays there while it refreshes.
+    if ui.gallery.places_stack.visible_child_name().as_deref() != Some("grid") {
+        places_status(
+            ui,
+            "mark-location-symbolic",
+            &gettext("Loading places…"),
+            &gettext("Finding where your photos were taken."),
+        );
+    }
+
+    let rx = spawn_request(ui.dirs.control_socket(), Request::PhotoPlaces);
+    let ui = ui.clone();
+    glib::spawn_future_local(async move {
+        let result = rx.recv().await;
+        ui.gallery.places_loading.set(false);
+        let mapping = match &result {
+            Ok(Ok(Response::Places { mapping, .. })) => *mapping,
+            _ => None,
+        };
+        sync_mapping(&ui, mapping);
+        match result {
+            Ok(Ok(Response::Places { items, .. })) if items.is_empty() && mapping.is_some() => {
+                ui.gallery.place_count.set(0);
+                places_status(
+                    &ui,
+                    "mark-location-symbolic",
+                    &gettext("Mapping your photos…"),
+                    &gettext("Places show up here once the locations of your photos are read."),
+                )
+            }
+            Ok(Ok(Response::Places { items, .. })) if items.is_empty() => {
+                ui.gallery.place_count.set(0);
+                if ui.gallery.place.borrow().is_none() {
+                    ui.gallery.title.set_subtitle("");
+                }
+                places_status(
+                    &ui,
+                    "mark-location-symbolic",
+                    &gettext("No places"),
+                    &gettext(
+                        "Photos that carry the location they were taken at show up here, grouped by town.",
+                    ),
+                )
+            }
+            Ok(Ok(Response::Places { items, .. })) => {
+                fill_places(&ui, &items);
+                ui.gallery.places_map.set_places(&items);
+                show_places_layout(&ui);
+            }
+            Ok(Ok(Response::Error { message, kind })) => {
+                toast_failure(&ui, &gettext("Couldn't load places"), &message, kind);
+                places_status(
+                    &ui,
+                    "dialog-warning-symbolic",
+                    &gettext("Couldn't load places"),
+                    &message,
+                );
+            }
+            Ok(Ok(_)) | Ok(Err(_)) | Err(_) => places_status(
+                &ui,
+                "network-offline-symbolic",
+                &gettext("Not connected"),
+                &gettext("The Proton Drive mount service didn't respond."),
+            ),
+        }
+    });
+}
+
+/// Show how far the daemon has got reading photo locations, and ask again in a
+/// moment while it is still reading — the new places land once it is done.
+fn sync_mapping(ui: &Rc<Ui>, mapping: Option<MappingProgress>) {
+    if let Some(source) = ui.gallery.places_poll.take() {
+        source.remove();
+    }
+    ui.gallery.places_mapping.set_visible(mapping.is_some());
+    let Some(MappingProgress { done, total }) = mapping else {
+        return;
+    };
+    ui.gallery.places_mapping_label.set_label(&gettext_f(
+        // Translators: {done} and {total} are numbers of photos.
+        "Mapping photos: {done} of {total}",
+        &[("done", &thousands(done)), ("total", &thousands(total))],
+    ));
+    ui.gallery.places_mapping_bar.set_fraction(if total == 0 {
+        0.0
+    } else {
+        done as f64 / total as f64
+    });
+    let ui_poll = ui.clone();
+    let source = glib::timeout_add_local_once(MAPPING_POLL, move || {
+        ui_poll.gallery.places_poll.take();
+        let on_places = ui_poll.gallery.content.visible_child_name().as_deref() == Some("places");
+        if on_places && ui_poll.gallery.place.borrow().is_none() {
+            load_places(&ui_poll);
+        }
+    });
+    ui.gallery.places_poll.replace(Some(source));
+}
+
+/// Replace the grid's cards with `places`, the one with the most photos first.
+fn fill_places(ui: &Rc<Ui>, places: &[PlaceInfo]) {
+    let scroll = ui
+        .gallery
+        .places
+        .ancestor(gtk4::ScrolledWindow::static_type())
+        .and_downcast::<gtk4::ScrolledWindow>();
+    let position = scroll.as_ref().map(|s| s.vadjustment().value());
+    while let Some(child) = ui.gallery.places.first_child() {
+        ui.gallery.places.remove(&child);
+    }
+    ui.gallery.place_count.set(places.len());
+    if ui.gallery.place.borrow().is_none() {
+        ui.gallery
+            .title
+            .set_subtitle(&places_subtitle(places.len()));
+    }
+    for place in places {
+        ui.gallery.places.append(&place_card(ui, place));
+    }
+    schedule_thumbs(ui);
+    if let (Some(scroll), Some(position)) = (scroll, position) {
+        glib::idle_add_local_once(move || scroll.vadjustment().set_value(position));
+    }
+}
+
+pub(crate) fn places_subtitle(count: usize) -> String {
+    ngettext_f("{n} place", "{n} places", count as u64, &[])
+}
+
+/// "Germany · 12 photos": where the town is, and how much was taken there.
+pub(crate) fn place_subtitle(place: &PlaceInfo) -> String {
+    ngettext_f(
+        // Translators: {country} is a country name, {n} a number of photos.
+        "{country} · {n} photo",
+        "{country} · {n} photos",
+        place.photo_count as u64,
+        &[("country", &country_name(&place.country))],
+    )
+}
+
+/// One place as a clickable card: its newest photo, the town, and the country
+/// with the number of photos taken there.
+fn place_card(ui: &Rc<Ui>, place: &PlaceInfo) -> gtk4::Button {
+    let picture = gtk4::Picture::builder()
+        .content_fit(gtk4::ContentFit::Cover)
+        .can_shrink(true)
+        .hexpand(true)
+        .vexpand(true)
+        .build();
+    picture.add_css_class("photo-thumb");
+
+    let placeholder = gtk4::Image::builder()
+        .icon_name("mark-location-symbolic")
+        .pixel_size(32)
+        .halign(gtk4::Align::Center)
+        .valign(gtk4::Align::Center)
+        .build();
+    placeholder.add_css_class("photo-placeholder");
+
+    let cover = gtk4::Overlay::new();
+    cover.set_child(Some(&placeholder));
+    cover.add_overlay(&picture);
+    cover.set_size_request(COVER_EDGE, COVER_EDGE);
+    cover.set_overflow(gtk4::Overflow::Hidden);
+    cover.add_css_class("album-cover");
+
+    let name = gtk4::Label::builder()
+        .label(&place.name)
+        .halign(gtk4::Align::Start)
+        .xalign(0.0)
+        .ellipsize(gtk4::pango::EllipsizeMode::End)
+        .build();
+    name.add_css_class("heading");
+
+    let subtitle = place_subtitle(place);
+    let count = gtk4::Label::builder()
+        .label(&subtitle)
+        .halign(gtk4::Align::Start)
+        .xalign(0.0)
+        .ellipsize(gtk4::pango::EllipsizeMode::End)
+        .build();
+    count.add_css_class("dim-label");
+    count.add_css_class("caption");
+
+    let card = gtk4::Box::new(gtk4::Orientation::Vertical, 4);
+    card.append(&cover);
+    card.append(&name);
+    card.append(&count);
+
+    let button = gtk4::Button::builder().child(&card).build();
+    button.add_css_class("flat");
+    button.add_css_class("album-card");
+    button.set_tooltip_text(Some(&format!("{}\n{subtitle}", place.name)));
+
+    want_cover(ui, place.cover.uid.clone(), &picture);
+    // The map marks the town with the same photo.
+    cover_map_marker(ui, &place.cover.uid, &picture);
+
+    let ui_open = ui.clone();
+    let place = place.clone();
+    button.connect_clicked(move |_| open_place(&ui_open, place.clone()));
+    button
+}
+
+/// Hand the map the photo `picture` shows once it is there.
+fn cover_map_marker(ui: &Rc<Ui>, uid: &str, picture: &gtk4::Picture) {
+    let map = Rc::downgrade(&ui.gallery.places_map);
+    let set = move |picture: &gtk4::Picture, uid: &str| {
+        let texture = picture.paintable().and_downcast::<gtk4::gdk::Texture>();
+        if let (Some(map), Some(texture)) = (map.upgrade(), texture) {
+            map.set_cover(uid, &texture);
+        }
+    };
+    set(picture, uid);
+    let uid = uid.to_owned();
+    picture.connect_paintable_notify(move |picture| set(picture, &uid));
+}
+
+/// Get the map the thumbnail of a photo it marks on its own, through the
+/// gallery's thumbnail pipeline.
+fn want_map_thumb(ui: &Rc<Ui>, photo: &PhotoItem) {
+    if let Some(texture) = ui.gallery.photo_tex.borrow().get(&photo.uid) {
+        ui.gallery.places_map.set_cover(&photo.uid, texture);
+        return;
+    }
+    // A town's card may be waiting for the same photo: share its picture
+    // rather than take its place in the queue.
+    let waiting = ui.gallery.thumb_wanted.borrow().get(&photo.uid).cloned();
+    let picture = waiting.unwrap_or_else(|| {
+        let picture = gtk4::Picture::new();
+        want_thumb(ui, photo, &picture);
+        picture
+    });
+    cover_map_marker(ui, &photo.uid, &picture);
+    schedule_thumbs(ui);
+}
+
+/// List the photos taken on one spot of the map in a popover at `(x, y)`;
+/// clicking one opens it in its town.
+fn show_spot_photos(ui: &Rc<Ui>, photos: Vec<(PlaceInfo, PhotoItem)>, (x, y): (f64, f64)) {
+    let Some((place, _)) = photos.first() else {
+        return;
+    };
+    let popover = gtk4::Popover::new();
+    popover.set_parent(ui.gallery.places_map.widget());
+    popover.set_pointing_to(Some(&gtk4::gdk::Rectangle::new(x as i32, y as i32, 1, 1)));
+
+    let content = gtk4::Box::new(gtk4::Orientation::Vertical, 6);
+    content.set_margin_top(6);
+    content.set_margin_bottom(6);
+    content.set_margin_start(6);
+    content.set_margin_end(6);
+    let title = gtk4::Label::builder()
+        .label(&place.name)
+        .halign(gtk4::Align::Start)
+        .build();
+    title.add_css_class("heading");
+    let count = gtk4::Label::builder()
+        .label(ngettext_f(
+            "{n} photo",
+            "{n} photos",
+            photos.len() as u64,
+            &[],
+        ))
+        .halign(gtk4::Align::Start)
+        .build();
+    count.add_css_class("dim-label");
+    count.add_css_class("caption");
+    content.append(&title);
+    content.append(&count);
+
+    let grid = gtk4::FlowBox::builder()
+        .selection_mode(gtk4::SelectionMode::None)
+        .homogeneous(true)
+        .min_children_per_line(1)
+        .max_children_per_line(4)
+        .row_spacing(4)
+        .column_spacing(4)
+        .build();
+    for (place, photo) in photos {
+        let picture = gtk4::Picture::builder()
+            .content_fit(gtk4::ContentFit::Cover)
+            .can_shrink(true)
+            .width_request(SPOT_EDGE)
+            .height_request(SPOT_EDGE)
+            .build();
+        spot_thumb(ui, &photo, &picture);
+        let button = gtk4::Button::builder()
+            .child(&picture)
+            .tooltip_text(format_capture_time(photo.capture_time))
+            .build();
+        button.add_css_class("flat");
+        button.add_css_class("places-spot-photo");
+        let ui_open = ui.clone();
+        let popover_open = popover.clone();
+        button.connect_clicked(move |_| {
+            popover_open.popdown();
+            open_place_photo(&ui_open, place.clone(), photo.uid.clone());
+        });
+        grid.append(&button);
+    }
+    schedule_thumbs(ui);
+    let scroller = gtk4::ScrolledWindow::builder()
+        .hscrollbar_policy(gtk4::PolicyType::Never)
+        .propagate_natural_width(true)
+        .propagate_natural_height(true)
+        .max_content_height(360)
+        .child(&grid)
+        .build();
+    content.append(&scroller);
+    popover.set_child(Some(&content));
+    // Gone with its last use; its parent is the map, which stays.
+    popover.connect_closed(|popover| {
+        let popover = popover.clone();
+        glib::idle_add_local_once(move || popover.unparent());
+    });
+    popover.popup();
+}
+
+/// Show photo's thumbnail in `picture`, sharing one another widget is
+/// already waiting for.
+fn spot_thumb(ui: &Rc<Ui>, photo: &PhotoItem, picture: &gtk4::Picture) {
+    let waiting = ui.gallery.thumb_wanted.borrow().get(&photo.uid).cloned();
+    match waiting {
+        Some(waiting) => {
+            waiting
+                .bind_property("paintable", picture, "paintable")
+                .sync_create()
+                .build();
+        }
+        None => want_thumb(ui, photo, picture),
+    }
+}
+
+/// Get the map the photos of town `id` with where each was taken.
+fn load_place_locations(ui: &Rc<Ui>, id: u32) {
+    let rx = spawn_request(ui.dirs.control_socket(), Request::PlaceLocations { id });
+    let ui = ui.clone();
+    glib::spawn_future_local(async move {
+        match rx.recv().await {
+            Ok(Ok(Response::PhotoLocations { items })) => {
+                ui.gallery.places_map.set_locations(id, items)
+            }
+            // The map keeps showing the town as one marker.
+            Ok(Ok(Response::Error { message, .. })) => {
+                tracing::debug!("place locations failed: {message}")
+            }
+            Ok(Ok(_)) | Ok(Err(_)) | Err(_) => tracing::debug!("place locations: no reply"),
+        }
+    });
+}
+
+/// Open `place` and then photo `uid` in it, paging through the town until
+/// the photo has loaded.
+fn open_place_photo(ui: &Rc<Ui>, place: PlaceInfo, uid: String) {
+    open_place(ui, place);
+    view_when_loaded(ui, uid);
+}
+
+fn view_when_loaded(ui: &Rc<Ui>, uid: String) {
+    let ui_page = ui.clone();
+    ui.gallery.page_waiters.borrow_mut().push(Box::new(move || {
+        let ui = ui_page;
+        if find_photo_index(&ui.gallery.model, &uid).is_some() {
+            open_photo_viewer(&ui, uid);
+        } else if ui.gallery.has_more.get() && ui.gallery.place.borrow().is_some() {
+            view_when_loaded(&ui, uid);
+            ui.gallery.burst.set(true);
+            load_gallery(&ui, true);
+        }
+    }));
+}
+
+/// Open one place in the gallery: the timeline view, paged from that town.
+fn open_place(ui: &Rc<Ui>, place: PlaceInfo) {
+    ui.gallery.title.set_title(&place.name);
+    ui.gallery.title.set_subtitle(&place_subtitle(&place));
+    *ui.gallery.place.borrow_mut() = Some(place);
+    ui.gallery.timeline_stale.set(true);
+
+    // As in an album: no filters, no Upload, no view switch — back leads out.
+    ui.gallery.filters.set_visible(false);
+    ui.gallery.view_switch.set_visible(false);
+    ui.gallery.upload.set_visible(false);
+    ui.gallery.back.set_visible(true);
+    ui.gallery.kind.set(None);
+    ui.gallery.range.set(None);
+
+    ui.gallery.content.set_visible_child_name("timeline");
+    load_gallery(ui, false);
+}
+
+/// Leave an open place, restoring the timeline's header. A no-op when no place
+/// is open.
+pub(crate) fn close_place(ui: &Rc<Ui>) {
+    if ui.gallery.place.borrow_mut().take().is_none() {
+        return;
+    }
+    ui.gallery.title.set_title(&gettext("Photos"));
+    ui.gallery.view_switch.set_visible(true);
+    ui.gallery.upload.set_visible(true);
+    ui.gallery.back.set_visible(false);
+}
+
+/// Show the place grid's own status page (loading, empty, or an error).
+fn places_status(ui: &Rc<Ui>, icon: &str, title: &str, description: &str) {
+    ui.gallery.places_status.set_icon_name(Some(icon));
+    ui.gallery.places_status.set_title(title);
+    ui.gallery.places_status.set_description(Some(description));
+    ui.gallery.places_stack.set_visible_child_name("status");
+}
+
+/// Wire the Places toggle of the view switcher.
+pub(crate) fn wire_places(ui: &Rc<Ui>) {
+    let ui_places = ui.clone();
+    ui.gallery.places_btn.clone().connect_toggled(move |btn| {
+        if btn.is_active() {
+            show_places(&ui_places);
+        }
+    });
+
+    let ui_layout = ui.clone();
+    ui.gallery.places_map_btn.connect_toggled(move |_| {
+        // A status page (loading, empty, an error) stays until a listing
+        // replaces it; only the grid and the map swap.
+        if ui_layout
+            .gallery
+            .places_stack
+            .visible_child_name()
+            .as_deref()
+            != Some("status")
+        {
+            show_places_layout(&ui_layout);
+        }
+    });
+
+    let map = &ui.gallery.places_map;
+    let ui_open = ui.clone();
+    map.connect_open(move |place| open_place(&ui_open, place));
+    let ui_photo = ui.clone();
+    map.connect_open_photo(move |place, uid| open_place_photo(&ui_photo, place, uid));
+    let ui_locations = ui.clone();
+    map.connect_want_locations(move |id| load_place_locations(&ui_locations, id));
+    let ui_thumb = ui.clone();
+    map.connect_want_thumb(move |photo| want_map_thumb(&ui_thumb, &photo));
+    let ui_spot = ui.clone();
+    map.connect_open_spot(move |photos, at| show_spot_photos(&ui_spot, photos, at));
+    map.set_online(ui.dirs.load_config().online_map, ui.dirs.cache_dir());
+}
+
+/// Switch to the Places map and zoom in on `(latitude, longitude)`, where a
+/// photo in the viewer was taken.
+pub(crate) fn show_on_map(ui: &Rc<Ui>, latitude: f64, longitude: f64) {
+    ui.gallery.places_map_btn.set_active(true);
+    if ui.gallery.places_btn.is_active() {
+        // Already in Places, perhaps inside a town: back out to the listing.
+        show_places(ui);
+    } else {
+        ui.gallery.places_btn.set_active(true);
+    }
+    ui.gallery.places_map.show_spot(latitude, longitude);
+}
+
+/// Show the places as cards or on the map, as the Grid/Map toggle says.
+fn show_places_layout(ui: &Rc<Ui>) {
+    let layout = if ui.gallery.places_map_btn.is_active() {
+        "map"
+    } else {
+        "grid"
+    };
+    ui.gallery.places_stack.set_visible_child_name(layout);
+}
@@ -10,6 +10,11 @@ pub(crate) struct SharedState {
    pub(crate) with_me_group: adw::PreferencesGroup,
    pub(crate) invitations_group: adw::PreferencesGroup,
    pub(crate) bookmarks_group: adw::PreferencesGroup,
+    /// The header title; its subtitle carries the path inside a shared folder.
+    pub(crate) title: adw::WindowTitle,
+    /// Header button that leaves the current shared folder.
+    pub(crate) back: gtk4::Button,
+    pub(crate) add_bookmark: gtk4::Button,
    /// Where in a shared folder the page currently is, as `(uid, name)` from the
    /// top level down. Empty = the top level. Shared subtrees have no path in the
    /// mount, so descending is uid-addressed and the stack *is* the breadcrumb.
@@ -32,6 +37,8 @@ pub(crate) struct SharedWidgets {
    pub(crate) retry: gtk4::Button,
    pub(crate) add_bookmark: gtk4::Button,
    pub(crate) refresh: gtk4::Button,
+    pub(crate) title: adw::WindowTitle,
+    pub(crate) back: gtk4::Button,
 }

 /// The Shared page: three stacked sections — items shared *with* me (each with a
@@ -39,38 +46,32 @@ pub(crate) struct SharedWidgets {
 /// links I've bookmarked (open / remove). All three live outside the mount tree,
 /// so the page addresses them by uid/id/token and always re-lists from the daemon.
 pub(crate) fn build_shared_page() -> (gtk4::Widget, SharedWidgets) {
-    let title = gtk4::Label::builder()
-        .label("Shared with me")
-        .halign(gtk4::Align::Start)
-        .build();
-    title.add_css_class("title-2");
-    let titles = gtk4::Box::new(gtk4::Orientation::Vertical, 2);
-    titles.set_hexpand(true);
-    titles.append(&title);
-
    let add_bookmark = gtk4::Button::builder()
-        .label("Add Bookmark")
-        .valign(gtk4::Align::Center)
+        .icon_name("bookmark-new-symbolic")
+        .tooltip_text(gettext(
+            "Add Bookmark — save a public link to open it from here",
+        ))
        .build();
-    add_bookmark.add_css_class("flat");
    let refresh = refresh_button();

-    let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
-    header.append(&titles);
-    header.append(&refresh);
-    header.append(&add_bookmark);
-
-    let shared_with_me = adw::PreferencesGroup::builder()
-        .title("Shared with me")
-        .build();
+    // Only sections with something in them are shown, so an account with one
+    // share reads as one list rather than three boxes, two of them saying
+    // "nothing here". Invitations come first: they are the one thing on the
+    // page waiting for a decision.
    let invitations = adw::PreferencesGroup::builder()
-        .title("Invitations")
+        .title(gettext("Invitations"))
+        .description(gettext("Accept to add the item to your shared files."))
+        .visible(false)
+        .build();
+    let shared_with_me = adw::PreferencesGroup::new();
+    let bookmarks = adw::PreferencesGroup::builder()
+        .title(gettext("Bookmarks"))
+        .visible(false)
        .build();
-    let bookmarks = adw::PreferencesGroup::builder().title("Bookmarks").build();

-    let groups = gtk4::Box::new(gtk4::Orientation::Vertical, 18);
-    groups.append(&shared_with_me);
+    let groups = gtk4::Box::new(gtk4::Orientation::Vertical, 24);
    groups.append(&invitations);
+    groups.append(&shared_with_me);
    groups.append(&bookmarks);
    let clamp = adw::Clamp::builder().child(&groups).build();
    let scroll = gtk4::ScrolledWindow::builder()
@@ -79,7 +80,7 @@ pub(crate) fn build_shared_page() -> (gtk4::Widget, SharedWidgets) {
        .build();

    let retry = gtk4::Button::builder()
-        .label("Retry")
+        .label(gettext("Retry"))
        .halign(gtk4::Align::Center)
        .build();
    retry.add_css_class("pill");
@@ -99,15 +100,24 @@ pub(crate) fn build_shared_page() -> (gtk4::Widget, SharedWidgets) {
    content.add_named(&status, Some("status"));

    let inner = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
-    inner.set_margin_top(12);
-    inner.set_margin_bottom(12);
-    inner.set_margin_start(12);
-    inner.set_margin_end(12);
-    inner.append(&header);
+    inner.set_margin_top(18);
+    inner.set_margin_bottom(18);
+    inner.set_margin_start(18);
+    inner.set_margin_end(18);
    inner.append(&content);

+    let back = gtk4::Button::builder()
+        .icon_name("go-previous-symbolic")
+        .tooltip_text(gettext("Back"))
+        .visible(false)
+        .build();
+    let (frame, header, title) = page_frame(&gettext("Shared with Me"), &inner);
+    header.pack_start(&back);
+    header.pack_end(&refresh);
+    header.pack_end(&add_bookmark);
+
    (
-        inner.upcast(),
+        frame.upcast(),
        SharedWidgets {
            content,
            status,
@@ -117,12 +127,19 @@ pub(crate) fn build_shared_page() -> (gtk4::Widget, SharedWidgets) {
            retry,
            add_bookmark,
            refresh,
+            title,
+            back,
        },
    )
 }

-/// Install the Shared page's retry and Add-Bookmark buttons.
+/// Install the Shared page's retry, back and Add-Bookmark buttons.
 pub(crate) fn wire_shared(ui: &Rc<Ui>, retry: &gtk4::Button, add_bookmark: &gtk4::Button) {
+    let ui_back = ui.clone();
+    ui.shared.back.connect_clicked(move |_| {
+        ui_back.shared.nav.borrow_mut().pop();
+        load_shared(&ui_back);
+    });
    let ui_retry = ui.clone();
    retry.connect_clicked(move |_| {
        service::restart();
@@ -161,8 +178,8 @@ pub(crate) fn load_shared(ui: &Rc<Ui>) {
    shared_status(
        ui,
        "emblem-shared-symbolic",
-        "Loading…",
-        "Reading your shared items.",
+        &gettext("Loading…"),
+        &gettext("Reading your shared items."),
        false,
    );

@@ -214,8 +231,8 @@ fn load_shared_folder(ui: &Rc<Ui>, uid: String) {
    shared_status(
        ui,
        "folder-symbolic",
-        "Loading…",
-        "Reading this shared folder.",
+        &gettext("Loading…"),
+        &gettext("Reading this shared folder."),
        false,
    );
    ui.busy_begin();
@@ -234,7 +251,7 @@ fn load_shared_folder(ui: &Rc<Ui>, uid: String) {
                // The folder is gone or access was revoked: fall back to the top
                // level rather than stranding the page on a dead uid.
                ui.shared.nav.borrow_mut().pop();
-                toast_failure(&ui, "Couldn't open shared folder", &message, kind);
+                toast_failure(&ui, &gettext("Couldn't open shared folder"), &message, kind);
                load_shared(&ui);
            }
            _ => {
@@ -245,8 +262,27 @@ fn load_shared_folder(ui: &Rc<Ui>, uid: String) {
    });
 }

-/// Paint the contents of the shared folder at the top of the nav stack: a row to
-/// go back up, then the children. Invitations and bookmarks are hidden here —
+/// The header subtitle inside a shared folder: the folders from the share root
+/// down, the way a breadcrumb reads.
+pub(crate) fn shared_path(nav: &[(String, String)]) -> String {
+    nav.iter()
+        .map(|(_, name)| name.as_str())
+        .collect::<Vec<_>>()
+        .join(" / ")
+}
+
+/// The Invitations heading, with the count once there is more than one.
+pub(crate) fn invitations_title(count: usize) -> String {
+    if count > 1 {
+        // Translators: the Invitations heading; {count} is the number of pending invitations (2 or more).
+        gettext_f("Invitations ({count})", &[("count", &count.to_string())])
+    } else {
+        gettext("Invitations")
+    }
+}
+
+/// Paint the contents of the shared folder at the top of the nav stack; the
+/// header's back button leads up again. Invitations and bookmarks are hidden here —
 /// they are top-level things, not contents of this folder.
 fn repaint_shared_folder(ui: &Rc<Ui>, entries: &[DirEntry]) {
    for (group, row) in ui.shared.rows.borrow_mut().drain(..) {
@@ -255,36 +291,23 @@ fn repaint_shared_folder(ui: &Rc<Ui>, entries: &[DirEntry]) {
    ui.shared.content.set_visible_child_name("list");
    ui.shared.invitations_group.set_visible(false);
    ui.shared.bookmarks_group.set_visible(false);
+    ui.shared.back.set_visible(true);
+    ui.shared.with_me_group.set_visible(true);
+    ui.shared.add_bookmark.set_visible(false);

    let nav = ui.shared.nav.borrow().clone();
-    let title = nav
-        .iter()
-        .map(|(_, name)| name.as_str())
-        .collect::<Vec<_>>()
-        .join(" / ");
-    ui.shared.with_me_group.set_title(&title);
+    ui.shared.title.set_subtitle(&shared_path(&nav));
+    ui.shared.with_me_group.set_title("");

    let mut rows: Vec<(adw::PreferencesGroup, gtk4::Widget)> = Vec::new();
-    let up = adw::ActionRow::builder()
-        .title("Back")
-        .activatable(true)
-        .build();
-    up.add_prefix(&gtk4::Image::from_icon_name("go-up-symbolic"));
-    let ui_up = ui.clone();
-    up.connect_activated(move |_| {
-        ui_up.shared.nav.borrow_mut().pop();
-        load_shared(&ui_up);
-    });
-    ui.shared.with_me_group.add(&up);
-    rows.push((ui.shared.with_me_group.clone(), up.upcast()));

    if entries.is_empty() {
-        let row = dim_row("This folder is empty.");
+        let row = dim_row(&gettext("This folder is empty."));
        ui.shared.with_me_group.add(&row);
        rows.push((ui.shared.with_me_group.clone(), row.upcast()));
    } else {
        for entry in entries {
-            let row = shared_entry_row(ui, entry);
+            let row = shared_entry_row(ui, entry, false);
            ui.shared.with_me_group.add(&row);
            rows.push((ui.shared.with_me_group.clone(), row.upcast()));
        }
@@ -294,7 +317,10 @@ fn repaint_shared_folder(ui: &Rc<Ui>, entries: &[DirEntry]) {

 /// A row for one node shared with me: folders descend into, files download and
 /// open with the user's default application.
-fn shared_entry_row(ui: &Rc<Ui>, entry: &DirEntry) -> adw::ActionRow {
+///
+/// `leavable` rows are share roots: only those carry a Leave action, since
+/// leaving a folder's child on its own is not a thing the API offers.
+fn shared_entry_row(ui: &Rc<Ui>, entry: &DirEntry, leavable: bool) -> adw::ActionRow {
    let row = adw::ActionRow::builder()
        .title(&entry.name)
        .activatable(true)
@@ -306,8 +332,8 @@ fn shared_entry_row(ui: &Rc<Ui>, entry: &DirEntry) -> adw::ActionRow {
    // What I am allowed to do with someone else's file is the thing this page
    // cannot leave implicit: a viewer share is browsable and unwritable, and
    // that is only visible if it is said.
-    if let Some(badge) = role_badge(&entry.role) {
-        row.add_suffix(&badge);
+    if let Some(pill) = role_pill(&entry.role) {
+        row.add_suffix(&pill);
    }
    // The "shared by" in the subtitle is what the invitation claims. When its
    // signature does not check out against that person's keys, the claim must
@@ -317,10 +343,14 @@ fn shared_entry_row(ui: &Rc<Ui>, entry: &DirEntry) -> adw::ActionRow {
        let warning = gtk4::Image::from_icon_name("dialog-warning-symbolic");
        warning.add_css_class("warning");
        warning.set_valign(gtk4::Align::Center);
-        warning.set_tooltip_text(Some(UNVERIFIED_INVITER_TOOLTIP));
+        warning.set_tooltip_text(Some(&gettext(UNVERIFIED_INVITER_TOOLTIP)));
        row.add_suffix(&warning);
    }
    row.add_prefix(&file_thumbnail(ui, entry, 40, 24, true));
+    row.add_suffix(&shared_entry_menu(ui, entry, leavable));
+    if entry.is_dir {
+        row.add_suffix(&gtk4::Image::from_icon_name("go-next-symbolic"));
+    }
    let ui_act = ui.clone();
    let uid = entry.uid.clone();
    let name = entry.name.clone();
@@ -340,35 +370,71 @@ fn shared_entry_row(ui: &Rc<Ui>, entry: &DirEntry) -> adw::ActionRow {
    row
 }

+/// A shared row's ⋮ menu: open it, find it in My Files when the mount has
+/// interned it, and leave it (share roots only).
+fn shared_entry_menu(ui: &Rc<Ui>, entry: &DirEntry, leavable: bool) -> gtk4::MenuButton {
+    let mut items: Vec<(String, MenuAction)> = Vec::new();
+    let (ui_open, uid, name, is_dir) = (
+        ui.clone(),
+        entry.uid.clone(),
+        entry.name.clone(),
+        entry.is_dir,
+    );
+    items.push((
+        pgettext("verb", "Open"),
+        Box::new(move || {
+            if is_dir {
+                ui_open
+                    .shared
+                    .nav
+                    .borrow_mut()
+                    .push((uid.clone(), name.clone()));
+                load_shared(&ui_open);
+            } else {
+                open_shared_file(&ui_open, &uid, &name);
+            }
+        }),
+    ));
+    if !entry.path.is_empty() {
+        let (ui_show, entry_show) = (ui.clone(), entry.clone());
+        items.push((
+            gettext("Show in My Files"),
+            Box::new(move || show_in_my_files(&ui_show, &entry_show)),
+        ));
+    }
+    if leavable {
+        let (ui_leave, uid, name) = (ui.clone(), entry.uid.clone(), entry.name.clone());
+        items.push((
+            gettext("Leave…"),
+            Box::new(move || prompt_leave_shared(&ui_leave, &uid, &name)),
+        ));
+    }
+    let (labels, actions): (Vec<String>, Vec<MenuAction>) = items.into_iter().unzip();
+    let button = more_menu_button(labels.iter().map(String::as_str).zip(actions).collect());
+    button.set_valign(gtk4::Align::Center);
+    button
+}
+
 /// Tooltip on the warning shown next to a share whose invitation did not verify.
-const UNVERIFIED_INVITER_TOOLTIP: &str = "The invitation's signature doesn't match the sender's keys. \
-     It may not really be from them.";
+const UNVERIFIED_INVITER_TOOLTIP: &str = gettext_noop(
+    "The invitation's signature doesn't match the sender's keys. It may not really be from them.",
+);

 /// A shared row's subtitle: who shared it and when (share roots only — that is
-/// where the invitation lives), its size (files only), and where it can be
-/// reached in the local mount once the synthetic `Shared with me/` directory has
-/// interned it. An unlisted share has no local path yet, and says nothing rather
-/// than pointing at a directory that is not there.
+/// where the invitation lives) and its size (files only). Where the share sits
+/// in the mount is one menu item away ("Show in My Files"), not spelled out on
+/// every row, where the long path wrapped the subtitle onto a second line.
 pub(crate) fn shared_row_subtitle(entry: &DirEntry) -> String {
    let mut parts: Vec<String> = Vec::new();
    if !entry.shared_by.is_empty() {
-        let date = if entry.shared_at > 0 {
-            format_modified(entry.shared_at)
-        } else {
-            String::new()
-        };
-        parts.push(if date.is_empty() {
-            format!("Shared by {}", entry.shared_by)
-        } else {
-            format!("Shared by {} on {date}", entry.shared_by)
-        });
+        parts.push(entry.shared_by.clone());
+        if entry.shared_at > 0 {
+            parts.push(format_modified(entry.shared_at));
+        }
    }
    if !entry.is_dir {
        parts.push(human_bytes(entry.size));
    }
-    if !entry.path.is_empty() {
-        parts.push(format!("in {}", entry.path));
-    }
    parts.join(" · ")
 }

@@ -376,22 +442,34 @@ pub(crate) fn shared_row_subtitle(entry: &DirEntry) -> String {
 /// owned content carries no role, and a role the API did not report is not
 /// guessed at (the SDK's `from_permissions_exact` returns `None` for an
 /// unrecognised mask rather than degrading it to viewer).
-pub(crate) fn role_label(role: &str) -> Option<&'static str> {
+pub(crate) fn role_label(role: &str) -> Option<String> {
    match role {
-        "viewer" => Some("Viewer"),
-        "editor" => Some("Editor"),
-        "admin" => Some("Admin"),
+        "viewer" => Some(pgettext("role", "Viewer")),
+        "editor" => Some(pgettext("role", "Editor")),
+        "admin" => Some(pgettext("role", "Admin")),
        _ => None,
    }
 }

-/// A dim role pill for a share I did not create.
-pub(crate) fn role_badge(role: &str) -> Option<gtk4::Label> {
-    let badge = gtk4::Label::new(Some(role_label(role)?));
-    badge.add_css_class("dim-label");
-    badge.add_css_class("caption");
-    badge.set_valign(gtk4::Align::Center);
-    Some(badge)
+/// What a role lets me do, as a short phrase for the row's pill. A bare
+/// "Editor" beside a Leave button read like one more button.
+pub(crate) fn role_access(role: &str) -> Option<String> {
+    match role {
+        "viewer" => Some(gettext("Can view")),
+        "editor" => Some(gettext("Can edit")),
+        "admin" => Some(gettext("Can manage")),
+        _ => None,
+    }
+}
+
+/// A tinted, rounded pill saying what I may do with a share I did not create.
+pub(crate) fn role_pill(role: &str) -> Option<gtk4::Label> {
+    let pill = gtk4::Label::new(Some(&role_access(role)?));
+    pill.add_css_class("role-pill");
+    pill.add_css_class("caption");
+    pill.set_valign(gtk4::Align::Center);
+    pill.set_tooltip_text(role_label(role).as_deref());
+    Some(pill)
 }

 /// Download a file shared with me into the daemon's cache and hand it to the
@@ -404,7 +482,8 @@ fn open_shared_file(ui: &Rc<Ui>, uid: &str, name: &str) {
        return;
    }
    ui.busy_begin();
-    toast(ui, &format!("Downloading “{name}”…"));
+    // Translators: {name} is a file name.
+    toast(ui, &gettext_f("Downloading “{name}”…", &[("name", name)]));
    let rx = spawn_request(
        ui.dirs.control_socket(),
        Request::OpenSharedFile {
@@ -423,12 +502,12 @@ fn open_shared_file(ui: &Rc<Ui>, uid: &str, name: &str) {
            // the shared node's name instead.
            Ok(Ok(Response::FilePath { path })) => open_named_path(&path, &name),
            Ok(Ok(Response::Error { message, kind })) => {
-                toast_failure(&ui, "Couldn't open file", &message, kind)
+                toast_failure(&ui, &gettext("Couldn't open file"), &message, kind)
            }
            _ => toast_error(
                &ui,
-                "Couldn't open file",
-                "The mount service didn't respond.",
+                &gettext("Couldn't open file"),
+                &gettext("The mount service didn't respond."),
            ),
        }
    });
@@ -441,8 +520,8 @@ pub(crate) fn shared_unreachable(ui: &Rc<Ui>) {
        shared_status(
            ui,
            "network-offline-symbolic",
-            "Not connected",
-            "The Proton Drive mount service isn't running.",
+            &gettext("Not connected"),
+            &gettext("The Proton Drive mount service isn't running."),
            true,
        );
        return;
@@ -450,8 +529,8 @@ pub(crate) fn shared_unreachable(ui: &Rc<Ui>) {
    shared_status(
        ui,
        "folder-remote-symbolic",
-        "Connecting…",
-        "Waiting for the Proton Drive mount service to come up.",
+        &gettext("Connecting…"),
+        &gettext("Waiting for the Proton Drive mount service to come up."),
        false,
    );
    let ui = ui.clone();
@@ -474,119 +553,130 @@ pub(crate) fn repaint_shared(
    for (group, row) in ui.shared.rows.borrow_mut().drain(..) {
        group.remove(&row);
    }
+    ui.shared.title.set_subtitle("");
+    ui.shared.back.set_visible(false);
+    ui.shared.add_bookmark.set_visible(true);
+    if shared.is_empty() && invitations.is_empty() && bookmarks.is_empty() {
+        shared_status(
+            ui,
+            "emblem-shared-symbolic",
+            &gettext("Nothing Shared with You"),
+            &gettext(
+                "Files and folders other people share with you appear here. Public links you bookmark are kept here too.",
+            ),
+            false,
+        );
+        return;
+    }
    ui.shared.content.set_visible_child_name("list");
-    ui.shared.invitations_group.set_visible(true);
-    ui.shared.bookmarks_group.set_visible(true);
-    ui.shared.with_me_group.set_title("Shared with me");
+    ui.shared
+        .invitations_group
+        .set_visible(!invitations.is_empty());
+    ui.shared.bookmarks_group.set_visible(!bookmarks.is_empty());
+    ui.shared.with_me_group.set_visible(!shared.is_empty());
+    // The list only needs a heading when another section sits beside it.
+    ui.shared
+        .with_me_group
+        .set_title(&if invitations.is_empty() && bookmarks.is_empty() {
+            String::new()
+        } else {
+            gettext("Shared with you")
+        });
+    ui.shared
+        .invitations_group
+        .set_title(&invitations_title(invitations.len()));
    let mut rows: Vec<(adw::PreferencesGroup, gtk4::Widget)> = Vec::new();

-    // Shared with me: name + Leave.
-    if shared.is_empty() {
-        let row = dim_row("Nothing is shared with you.");
+    for entry in shared {
+        let row = shared_entry_row(ui, entry, true);
        ui.shared.with_me_group.add(&row);
        rows.push((ui.shared.with_me_group.clone(), row.upcast()));
-    } else {
-        for entry in shared {
-            let row = shared_entry_row(ui, entry);
-            let leave = gtk4::Button::builder()
-                .label("Leave")
-                .valign(gtk4::Align::Center)
-                .build();
-            leave.add_css_class("flat");
-            let ui_leave = ui.clone();
-            let uid = entry.uid.clone();
-            let name = entry.name.clone();
-            leave.connect_clicked(move |_| prompt_leave_shared(&ui_leave, &uid, &name));
-            row.add_suffix(&leave);
-            ui.shared.with_me_group.add(&row);
-            rows.push((ui.shared.with_me_group.clone(), row.upcast()));
-        }
    }

    // Invitations: inviter + item, Accept / Reject.
-    if invitations.is_empty() {
-        let row = dim_row("No pending invitations.");
+    for inv in invitations {
+        let item = inv.name.clone().unwrap_or_else(|| gettext("a shared item"));
+        let row = adw::ActionRow::builder()
+            .title(&item)
+            // Translators: {email} is the address of the person who sent the invitation.
+            .subtitle(gettext_f("From {email}", &[("email", &inv.inviter_email)]))
+            .build();
+        row.add_prefix(&gtk4::Image::from_icon_name(if inv.is_dir {
+            "folder-symbolic"
+        } else {
+            "text-x-generic-symbolic"
+        }));
+        let reject = gtk4::Button::builder()
+            .icon_name("window-close-symbolic")
+            .tooltip_text(gettext("Reject"))
+            .valign(gtk4::Align::Center)
+            .build();
+        reject.add_css_class("flat");
+        let accept = gtk4::Button::builder()
+            .label(gettext("Accept"))
+            .valign(gtk4::Align::Center)
+            .build();
+        accept.add_css_class("suggested-action");
+        accept.add_css_class("pill");
+        let ui_acc = ui.clone();
+        let id_acc = inv.id.clone();
+        accept.connect_clicked(move |_| {
+            respond_invitation(&ui_acc, &id_acc, true);
+        });
+        let ui_rej = ui.clone();
+        let id_rej = inv.id.clone();
+        let name_rej = inv.name.clone().unwrap_or_else(|| gettext("this item"));
+        reject.connect_clicked(move |btn| {
+            let ui = ui_rej.clone();
+            let id = id_rej.clone();
+            confirm_destructive(
+                btn,
+                &gettext("Reject Invitation?"),
+                // Translators: {name} is the shared item's name, or "this item".
+                &gettext_f(
+                    "You won't have access to {name} unless it is shared again.",
+                    &[("name", &name_rej)],
+                ),
+                &gettext("Reject"),
+                move || respond_invitation(&ui, &id, false),
+            );
+        });
+        row.add_suffix(&accept);
+        row.add_suffix(&reject);
        ui.shared.invitations_group.add(&row);
        rows.push((ui.shared.invitations_group.clone(), row.upcast()));
-    } else {
-        for inv in invitations {
-            let item = inv
-                .name
-                .clone()
-                .unwrap_or_else(|| "a shared item".to_string());
-            let row = adw::ActionRow::builder()
-                .title(&item)
-                .subtitle(format!("from {}", inv.inviter_email))
-                .build();
-            row.add_prefix(&gtk4::Image::from_icon_name(if inv.is_dir {
-                "folder-symbolic"
-            } else {
-                "text-x-generic-symbolic"
-            }));
-            let reject = gtk4::Button::builder()
-                .icon_name("window-close-symbolic")
-                .tooltip_text("Reject")
-                .valign(gtk4::Align::Center)
-                .build();
-            reject.add_css_class("flat");
-            let accept = gtk4::Button::builder()
-                .label("Accept")
-                .valign(gtk4::Align::Center)
-                .build();
-            accept.add_css_class("suggested-action");
-            let ui_acc = ui.clone();
-            let id_acc = inv.id.clone();
-            accept.connect_clicked(move |_| {
-                respond_invitation(&ui_acc, &id_acc, true);
-            });
-            let ui_rej = ui.clone();
-            let id_rej = inv.id.clone();
-            reject.connect_clicked(move |_| {
-                respond_invitation(&ui_rej, &id_rej, false);
-            });
-            row.add_suffix(&accept);
-            row.add_suffix(&reject);
-            ui.shared.invitations_group.add(&row);
-            rows.push((ui.shared.invitations_group.clone(), row.upcast()));
-        }
    }

    // Bookmarks: name/URL, Open / Remove.
-    if bookmarks.is_empty() {
-        let row = dim_row("No saved bookmarks.");
+    for bm in bookmarks {
+        let title = bm.name.clone().unwrap_or_else(|| gettext("Shared link"));
+        let row = adw::ActionRow::builder()
+            .title(&title)
+            .subtitle(&bm.url)
+            .build();
+        row.add_prefix(&gtk4::Image::from_icon_name("emblem-symbolic-link"));
+        let remove = gtk4::Button::builder()
+            .icon_name("user-trash-symbolic")
+            .tooltip_text(gettext("Remove bookmark"))
+            .valign(gtk4::Align::Center)
+            .build();
+        remove.add_css_class("flat");
+        let open = gtk4::Button::builder()
+            .icon_name("external-link-symbolic")
+            .tooltip_text(gettext("Open in browser"))
+            .valign(gtk4::Align::Center)
+            .build();
+        open.add_css_class("flat");
+        let url_open = bm.url.clone();
+        open.connect_clicked(move |_| open_uri(&url_open));
+        let ui_rm = ui.clone();
+        let token = bm.token.clone();
+        let name_rm = title.clone();
+        remove.connect_clicked(move |_| prompt_remove_bookmark(&ui_rm, &token, &name_rm));
+        row.add_suffix(&open);
+        row.add_suffix(&remove);
        ui.shared.bookmarks_group.add(&row);
        rows.push((ui.shared.bookmarks_group.clone(), row.upcast()));
-    } else {
-        for bm in bookmarks {
-            let title = bm.name.clone().unwrap_or_else(|| "Shared link".to_string());
-            let row = adw::ActionRow::builder()
-                .title(&title)
-                .subtitle(&bm.url)
-                .build();
-            row.add_prefix(&gtk4::Image::from_icon_name("emblem-symbolic-link"));
-            let remove = gtk4::Button::builder()
-                .icon_name("user-trash-symbolic")
-                .tooltip_text("Remove bookmark")
-                .valign(gtk4::Align::Center)
-                .build();
-            remove.add_css_class("flat");
-            let open = gtk4::Button::builder()
-                .icon_name("external-link-symbolic")
-                .tooltip_text("Open in browser")
-                .valign(gtk4::Align::Center)
-                .build();
-            open.add_css_class("flat");
-            let url_open = bm.url.clone();
-            open.connect_clicked(move |_| open_uri(&url_open));
-            let ui_rm = ui.clone();
-            let token = bm.token.clone();
-            let name_rm = title.clone();
-            remove.connect_clicked(move |_| prompt_remove_bookmark(&ui_rm, &token, &name_rm));
-            row.add_suffix(&open);
-            row.add_suffix(&remove);
-            ui.shared.bookmarks_group.add(&row);
-            rows.push((ui.shared.bookmarks_group.clone(), row.upcast()));
-        }
    }

    *ui.shared.rows.borrow_mut() = rows;
@@ -600,24 +690,32 @@ pub(crate) fn respond_invitation(ui: &Rc<Ui>, id: &str, accept: bool) {
        Request::RejectInvitation { id: id.to_string() }
    };
    let (done, failed) = if accept {
-        ("Invitation accepted", "Couldn't accept the invitation")
+        (
+            gettext("Invitation accepted"),
+            gettext("Couldn't accept the invitation"),
+        )
    } else {
-        ("Invitation rejected", "Couldn't reject the invitation")
+        (
+            gettext("Invitation rejected"),
+            gettext("Couldn't reject the invitation"),
+        )
    };
-    run_shared_mutation(ui, req, done, failed);
+    run_shared_mutation(ui, req, &done, &failed);
 }

 /// Confirm, then leave a node shared with me.
 pub(crate) fn prompt_leave_shared(ui: &Rc<Ui>, uid: &str, name: &str) {
    let win = ui_window(ui);
    let dialog = adw::AlertDialog::builder()
-        .heading("Leave shared item")
-        .body(format!(
-            "Leave “{name}”? You'll lose access until you're invited again."
+        .heading(gettext("Leave shared item"))
+        // Translators: {name} is the shared item's name.
+        .body(gettext_f(
+            "Leave “{name}”? You'll lose access until you're invited again.",
+            &[("name", name)],
        ))
        .build();
-    dialog.add_response("cancel", "Cancel");
-    dialog.add_response("leave", "Leave");
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("leave", &pgettext("verb", "Leave"));
    dialog.set_response_appearance("leave", adw::ResponseAppearance::Destructive);
    dialog.set_default_response(Some("cancel"));
    dialog.set_close_response("cancel");
@@ -628,8 +726,8 @@ pub(crate) fn prompt_leave_shared(ui: &Rc<Ui>, uid: &str, name: &str) {
            run_shared_mutation(
                &ui,
                Request::LeaveShared { uid: uid.clone() },
-                "Left shared item",
-                "Couldn't leave the shared item",
+                &gettext("Left shared item"),
+                &gettext("Couldn't leave the shared item"),
            );
        }
    });
@@ -640,11 +738,15 @@ pub(crate) fn prompt_leave_shared(ui: &Rc<Ui>, uid: &str, name: &str) {
 pub(crate) fn prompt_remove_bookmark(ui: &Rc<Ui>, token: &str, name: &str) {
    let win = ui_window(ui);
    let dialog = adw::AlertDialog::builder()
-        .heading("Remove bookmark")
-        .body(format!("Remove the bookmark for “{name}”?"))
+        .heading(gettext("Remove bookmark"))
+        // Translators: {name} is the bookmark's name.
+        .body(gettext_f(
+            "Remove the bookmark for “{name}”?",
+            &[("name", name)],
+        ))
        .build();
-    dialog.add_response("cancel", "Cancel");
-    dialog.add_response("remove", "Remove");
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("remove", &gettext("Remove"));
    dialog.set_response_appearance("remove", adw::ResponseAppearance::Destructive);
    dialog.set_default_response(Some("cancel"));
    dialog.set_close_response("cancel");
@@ -657,8 +759,8 @@ pub(crate) fn prompt_remove_bookmark(ui: &Rc<Ui>, token: &str, name: &str) {
                Request::DeleteBookmark {
                    token: token.clone(),
                },
-                "Bookmark removed",
-                "Couldn't remove the bookmark",
+                &gettext("Bookmark removed"),
+                &gettext("Couldn't remove the bookmark"),
            );
        }
    });
@@ -669,23 +771,23 @@ pub(crate) fn prompt_remove_bookmark(ui: &Rc<Ui>, token: &str, name: &str) {
 pub(crate) fn prompt_add_bookmark(ui: &Rc<Ui>) {
    let win = ui_window(ui);
    let dialog = adw::AlertDialog::builder()
-        .heading("Add bookmark")
-        .body("Paste a Proton Drive public link to save it here.")
+        .heading(gettext("Add bookmark"))
+        .body(gettext("Paste a Proton Drive public link to save it here."))
        .build();
    let group = adw::PreferencesGroup::new();
    let url_row = adw::EntryRow::builder()
-        .title("Public link URL")
+        .title(gettext("Public link URL"))
        .activates_default(true)
        .build();
    let pw_row = adw::PasswordEntryRow::builder()
-        .title("Password (if the link has one)")
+        .title(gettext("Password (if the link has one)"))
        .activates_default(true)
        .build();
    group.add(&url_row);
    group.add(&pw_row);
    dialog.set_extra_child(Some(&group));
-    dialog.add_response("cancel", "Cancel");
-    dialog.add_response("add", "Add");
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("add", &gettext("Add"));
    dialog.set_response_appearance("add", adw::ResponseAppearance::Suggested);
    dialog.set_default_response(Some("add"));
    dialog.set_close_response("cancel");
@@ -696,7 +798,11 @@ pub(crate) fn prompt_add_bookmark(ui: &Rc<Ui>) {
        }
        let url = url_row.text().trim().to_string();
        if url.is_empty() {
-            toast_error(&ui, "Couldn't add bookmark", "A URL is required.");
+            toast_error(
+                &ui,
+                &gettext("Couldn't add bookmark"),
+                &gettext("A URL is required."),
+            );
            return;
        }
        let pw = pw_row.text().to_string();
@@ -704,24 +810,20 @@ pub(crate) fn prompt_add_bookmark(ui: &Rc<Ui>) {
        run_shared_mutation(
            &ui,
            Request::CreateBookmark { url, password },
-            "Bookmark saved",
-            "Couldn't add the bookmark",
+            &gettext("Bookmark saved"),
+            &gettext("Couldn't add the bookmark"),
        );
    });
    dialog.present(win.as_ref());
 }

 /// Run a mutation raised from the Shared page and reload the page on success.
-pub(crate) fn run_shared_mutation(
-    ui: &Rc<Ui>,
-    req: Request,
-    done: &'static str,
-    failed: &'static str,
-) {
+pub(crate) fn run_shared_mutation(ui: &Rc<Ui>, req: Request, done: &str, failed: &str) {
    ui.busy_begin();
    let rx = spawn_request(ui.dirs.control_socket(), req);
    let ui = ui.clone();
    let done = done.to_string();
+    let failed = failed.to_string();
    glib::spawn_future_local(async move {
        let result = rx.recv().await;
        ui.busy_end();
@@ -730,8 +832,10 @@ pub(crate) fn run_shared_mutation(
                load_shared(&ui);
                toast(&ui, &done);
            }
-            Ok(Ok(Response::Error { message, kind })) => toast_failure(&ui, failed, &message, kind),
-            _ => toast_error(&ui, failed, "The mount service didn't respond."),
+            Ok(Ok(Response::Error { message, kind })) => {
+                toast_failure(&ui, &failed, &message, kind)
+            }
+            _ => toast_error(&ui, &failed, &gettext("The mount service didn't respond.")),
        }
    });
 }
@@ -761,13 +865,10 @@ mod tests {
    fn a_share_root_says_who_shared_it() {
        let mut root = entry(true, "", "viewer");
        root.shared_by = "alice@proton.me".into();
-        assert_eq!(shared_row_subtitle(&root), "Shared by alice@proton.me");
+        assert_eq!(shared_row_subtitle(&root), "alice@proton.me");
        root.shared_at = 1_700_000_000;
        let subtitle = shared_row_subtitle(&root);
-        assert!(
-            subtitle.starts_with("Shared by alice@proton.me on "),
-            "{subtitle}"
-        );
+        assert!(subtitle.starts_with("alice@proton.me · "), "{subtitle}");
    }

    #[test]
@@ -783,9 +884,23 @@ mod tests {
    }

    #[test]
-    fn a_resident_share_reports_where_it_can_be_reached() {
+    fn a_resident_share_keeps_its_path_out_of_the_subtitle() {
        let subtitle = shared_row_subtitle(&entry(true, "Shared with me/Team Budget", "editor"));
-        assert_eq!(subtitle, "in Shared with me/Team Budget");
+        assert_eq!(subtitle, "");
+    }
+
+    #[test]
+    fn a_role_pill_says_what_it_allows() {
+        assert_eq!(role_access("viewer").as_deref(), Some("Can view"));
+        assert_eq!(role_access("editor").as_deref(), Some("Can edit"));
+        assert_eq!(role_access("admin").as_deref(), Some("Can manage"));
+        assert_eq!(role_access(""), None);
+    }
+
+    #[test]
+    fn the_invitations_heading_counts_only_several() {
+        assert_eq!(invitations_title(1), "Invitations");
+        assert_eq!(invitations_title(4), "Invitations (4)");
    }

    #[test]
@@ -799,4 +914,14 @@ mod tests {
        assert!(role_label("").is_none());
        assert!(role_label("inherited").is_none());
    }
+
+    #[test]
+    fn the_header_path_reads_from_the_share_root_down() {
+        assert_eq!(shared_path(&[]), "");
+        let nav = vec![
+            ("u1".to_string(), "Team".to_string()),
+            ("u2".to_string(), "Reports".to_string()),
+        ];
+        assert_eq!(shared_path(&nav), "Team / Reports");
+    }
 }
@@ -22,20 +22,10 @@ pub(crate) struct SharedByMeWidgets {
 }

 /// The Shared page: one section listing the items I have shared with others —
-/// each row summarizing who has access and carrying its public link (copy/open)
-/// and a Manage shortcut into the per-node Share dialog.
+/// each row summarizing who has access, opening the item when activated, with
+/// Copy link and a menu for the link and the per-node Share dialog.
 pub(crate) fn build_shared_by_me_page() -> (gtk4::Widget, SharedByMeWidgets) {
-    let title = gtk4::Label::builder()
-        .label("Shared")
-        .halign(gtk4::Align::Start)
-        .hexpand(true)
-        .build();
-    title.add_css_class("title-2");
    let refresh = refresh_button();
-    let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
-    header.set_hexpand(true);
-    header.append(&title);
-    header.append(&refresh);

    let group = adw::PreferencesGroup::new();
    let clamp = adw::Clamp::builder().child(&group).build();
@@ -45,7 +35,7 @@ pub(crate) fn build_shared_by_me_page() -> (gtk4::Widget, SharedByMeWidgets) {
        .build();

    let retry = gtk4::Button::builder()
-        .label("Retry")
+        .label(gettext("Retry"))
        .halign(gtk4::Align::Center)
        .build();
    retry.add_css_class("pill");
@@ -65,15 +55,16 @@ pub(crate) fn build_shared_by_me_page() -> (gtk4::Widget, SharedByMeWidgets) {
    content.add_named(&status, Some("status"));

    let inner = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
-    inner.set_margin_top(12);
-    inner.set_margin_bottom(12);
-    inner.set_margin_start(12);
-    inner.set_margin_end(12);
-    inner.append(&header);
+    inner.set_margin_top(18);
+    inner.set_margin_bottom(18);
+    inner.set_margin_start(18);
+    inner.set_margin_end(18);
    inner.append(&content);
+    let (frame, header, _) = page_frame(&gettext("Shared by Me"), &inner);
+    header.pack_end(&refresh);

    (
-        inner.upcast(),
+        frame.upcast(),
        SharedByMeWidgets {
            content,
            status,
@@ -118,8 +109,8 @@ pub(crate) fn load_shared_by_me(ui: &Rc<Ui>) {
    shared_by_me_status(
        ui,
        "emblem-shared-symbolic",
-        "Loading…",
-        "Reading what you've shared.",
+        &gettext("Loading…"),
+        &gettext("Reading what you've shared."),
        false,
    );
    ui.busy_begin();
@@ -137,15 +128,15 @@ pub(crate) fn load_shared_by_me(ui: &Rc<Ui>) {
            Ok(Ok(Response::Error { message, .. })) => shared_by_me_status(
                &ui,
                "dialog-warning-symbolic",
-                "Couldn't read your shares",
+                &gettext("Couldn't read your shares"),
                &message,
                false,
            ),
            Ok(Ok(_)) => shared_by_me_status(
                &ui,
                "dialog-warning-symbolic",
-                "Couldn't read your shares",
-                "Unexpected reply from the mount service.",
+                &gettext("Couldn't read your shares"),
+                &gettext("Unexpected reply from the mount service."),
                false,
            ),
            Ok(Err(_)) | Err(_) => {
@@ -162,8 +153,8 @@ pub(crate) fn shared_by_me_unreachable(ui: &Rc<Ui>) {
        shared_by_me_status(
            ui,
            "network-offline-symbolic",
-            "Not connected",
-            "The Proton Drive mount service isn't running.",
+            &gettext("Not connected"),
+            &gettext("The Proton Drive mount service isn't running."),
            true,
        );
        return;
@@ -171,8 +162,8 @@ pub(crate) fn shared_by_me_unreachable(ui: &Rc<Ui>) {
    shared_by_me_status(
        ui,
        "folder-remote-symbolic",
-        "Connecting…",
-        "Waiting for the Proton Drive mount service to come up.",
+        &gettext("Connecting…"),
+        &gettext("Waiting for the Proton Drive mount service to come up."),
        false,
    );
    let ui = ui.clone();
@@ -192,8 +183,8 @@ pub(crate) fn repaint_shared_by_me(ui: &Rc<Ui>, items: &[SharedItem]) {
        shared_by_me_status(
            ui,
            "emblem-shared-symbolic",
-            "Nothing shared yet",
-            "Items you share with people or by link show up here.",
+            &gettext("Nothing shared yet"),
+            &gettext("Items you share with people or by link show up here."),
            false,
        );
        return;
@@ -208,43 +199,31 @@ pub(crate) fn repaint_shared_by_me(ui: &Rc<Ui>, items: &[SharedItem]) {
            .build();
        row.add_prefix(&file_thumbnail(ui, &entry, 40, 24, true));

-        // Copy / open the public link, when there is one with a recovered URL.
-        if let Some(url) = item.link.as_ref().and_then(|l| l.url.clone()) {
+        // A node the daemon can place in my tree opens like it would in My Files.
+        if !item.path.is_empty() {
+            row.set_activatable(true);
+            let ui_open = ui.clone();
+            let entry_open = entry.clone();
+            row.connect_activated(move |_| open_shared_by_me(&ui_open, &entry_open));
+        }
+
+        let url = item.link.as_ref().and_then(|l| l.url.clone());
+        // The one action people come here for most gets its own button.
+        if let Some(url) = url.clone() {
            let copy = gtk4::Button::builder()
                .icon_name("edit-copy-symbolic")
-                .tooltip_text("Copy link")
+                .tooltip_text(gettext("Copy link"))
                .valign(gtk4::Align::Center)
                .build();
            copy.add_css_class("flat");
            let ui_copy = ui.clone();
-            let url_copy = url.clone();
            copy.connect_clicked(move |btn| {
-                btn.clipboard().set_text(&url_copy);
-                toast(&ui_copy, "Link copied");
+                btn.clipboard().set_text(&url);
+                toast(&ui_copy, &gettext("Link copied"));
            });
-            let open = gtk4::Button::builder()
-                .icon_name("external-link-symbolic")
-                .tooltip_text("Open link")
-                .valign(gtk4::Align::Center)
-                .build();
-            open.add_css_class("flat");
-            let url_open = url.clone();
-            open.connect_clicked(move |_| open_uri(&url_open));
            row.add_suffix(&copy);
-            row.add_suffix(&open);
        }
-
-        // Manage opens the per-node Share dialog. It used to be offered only for
-        // an item whose path the daemon could resolve; the dialog now addresses a
-        // pathless node by uid, so every shared item can be managed from here.
-        let manage = gtk4::Button::builder()
-            .label("Manage")
-            .valign(gtk4::Align::Center)
-            .build();
-        manage.add_css_class("flat");
-        let ui_manage = ui.clone();
-        manage.connect_clicked(move |_| open_share_dialog(&ui_manage, &entry));
-        row.add_suffix(&manage);
+        row.add_suffix(&shared_by_me_menu(ui, &entry, url));

        ui.shared_by_me.group.add(&row);
        rows.push(row.upcast());
@@ -252,28 +231,122 @@ pub(crate) fn repaint_shared_by_me(ui: &Rc<Ui>, items: &[SharedItem]) {
    *ui.shared_by_me.rows.borrow_mut() = rows;
 }

+/// The ⋮ menu on a shared item: open it, the link, the Share dialog, and
+/// Stop Sharing.
+///
+/// Manage access opens the per-node Share dialog, which addresses a pathless
+/// node by uid, so every shared item can be managed from here.
+fn shared_by_me_menu(ui: &Rc<Ui>, entry: &DirEntry, url: Option<String>) -> gtk4::MenuButton {
+    let mut items: Vec<(String, MenuAction)> = Vec::new();
+    if !entry.path.is_empty() {
+        let (ui_c, entry_c) = (ui.clone(), entry.clone());
+        items.push((
+            pgettext("verb", "Open"),
+            Box::new(move || open_shared_by_me(&ui_c, &entry_c)),
+        ));
+        let (ui_c, entry_c) = (ui.clone(), entry.clone());
+        items.push((
+            gettext("Show in My Files"),
+            Box::new(move || show_in_my_files(&ui_c, &entry_c)),
+        ));
+    }
+    if let Some(url) = url {
+        items.push((gettext("Open Link"), Box::new(move || open_uri(&url))));
+    }
+    let (ui_c, entry_c) = (ui.clone(), entry.clone());
+    items.push((
+        gettext("Manage Access…"),
+        Box::new(move || open_share_dialog(&ui_c, &entry_c)),
+    ));
+    let (ui_c, entry_c) = (ui.clone(), entry.clone());
+    items.push((
+        gettext("Stop Sharing…"),
+        Box::new(move || prompt_stop_sharing(&ui_c, &entry_c)),
+    ));
+    let (labels, actions): (Vec<String>, Vec<MenuAction>) = items.into_iter().unzip();
+    more_menu_button(labels.iter().map(String::as_str).zip(actions).collect())
+}
+
+/// Confirm, then remove every member, invitation and the public link.
+pub(crate) fn prompt_stop_sharing(ui: &Rc<Ui>, entry: &DirEntry) {
+    let dialog = adw::AlertDialog::builder()
+        .heading(gettext("Stop sharing?"))
+        // Translators: {name} is the shared item's name.
+        .body(gettext_f(
+            "Everyone you invited loses access to “{name}”, pending invitations are withdrawn and its public link stops working.",
+            &[("name", &entry.name)],
+        ))
+        .build();
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("stop", &gettext("Stop Sharing"));
+    dialog.set_response_appearance("stop", adw::ResponseAppearance::Destructive);
+    dialog.set_default_response(Some("cancel"));
+    dialog.set_close_response("cancel");
+    let ui_c = ui.clone();
+    let uid = entry.uid.clone();
+    let name = entry.name.clone();
+    dialog.connect_response(Some("stop"), move |_, _| {
+        run_mutation(
+            &ui_c,
+            Request::StopSharingByUid { uid: uid.clone() },
+            // Translators: {name} is the item's name.
+            gettext_f("Stopped sharing {name}", &[("name", &name)]),
+            gettext_noop("Couldn't stop sharing"),
+        );
+    });
+    dialog.present(ui_window(ui).as_ref());
+}
+
+/// Open a shared item: a folder in My Files, a file the way My Files would.
+fn open_shared_by_me(ui: &Rc<Ui>, entry: &DirEntry) {
+    if entry.is_dir {
+        ui.stack.set_visible_child_name("browser");
+        ui.browser.search.set_text("");
+        browse_to(ui, entry.path.clone());
+    } else {
+        activate_entry(ui, entry);
+    }
+}
+
+/// Go to the folder holding a shared item in My Files.
+pub(crate) fn show_in_my_files(ui: &Rc<Ui>, entry: &DirEntry) {
+    let parent = entry
+        .path
+        .rsplit_once('/')
+        .map(|(parent, _)| parent.to_string())
+        .unwrap_or_default();
+    ui.stack.set_visible_child_name("browser");
+    ui.browser.search.set_text("");
+    browse_to(ui, parent);
+}
+
 /// A one-line summary of who can reach a shared item, for its row subtitle.
 pub(crate) fn shared_item_summary(item: &SharedItem) -> String {
    let mut parts = Vec::new();
    if item.member_count > 0 {
-        parts.push(format!(
-            "{} {}",
-            item.member_count,
-            if item.member_count == 1 {
-                "person"
-            } else {
-                "people"
-            }
+        // Translators: how many people have access to a shared item.
+        parts.push(ngettext_f(
+            "{n} person",
+            "{n} people",
+            item.member_count as u64,
+            &[],
        ));
    }
    if item.invite_count > 0 {
-        parts.push(format!("{} pending", item.invite_count));
+        // Translators: how many invitations to a shared item are not accepted yet.
+        parts.push(ngettext_f(
+            "{n} pending",
+            "{n} pending",
+            item.invite_count as u64,
+            &[],
+        ));
    }
    if item.link.is_some() {
-        parts.push("Public link".to_string());
+        parts.push(gettext("Public link"));
    }
    if parts.is_empty() {
-        "Shared".to_string()
+        // Translators: a shared item's summary when no people or link can be counted.
+        pgettext("state", "Shared")
    } else {
        parts.join(" · ")
    }
@@ -1,8 +1,8 @@
 //! The Import page: bringing a Google Photos **Takeout** export into Proton
 //! Photos.
 //!
-//! Reached from Settings → *Import from Google Photos* (and from the Gallery's
-//! import button), because it is a one-off migration rather than something the
+//! Reached from the Photos page's import button (and its empty timeline),
+//! because it is a one-off migration rather than something the
 //! photo timeline does every day. It gets a page of its own instead of a dialog
 //! for two reasons: an export is a *set* of archives that has to be staged and
 //! checked before anything is sent, and the import that follows runs for hours,
@@ -17,12 +17,12 @@
 //! The daemon owns the run itself ([`Request::ImportTakeout`]): this page only
 //! stages paths, launches, polls [`Request::ImportStatus`] for the final report,
 //! and reads live progress off the import's job in the transfer snapshot the
-//! Settings tick already fetches (see [`takeout_progress`]).
+//! status tick already fetches (see [`takeout_progress`]).

 use crate::*;

 /// The title the daemon gives the import's job in [`Request::GetQueueStatus`].
-/// Matching on it is how this page borrows the progress the Settings tick is
+/// Matching on it is how this page borrows the progress the status tick is
 /// already polling instead of adding a second poll of its own.
 const IMPORT_JOB: &str = "Importing Google Photos";

@@ -70,8 +70,11 @@ fn save_staged(ui: &Rc<Ui>) {
    }
 }

-const EMPTY_LIST_DESCRIPTION: &str = "Photos already in Proton Photos are matched by name and content and skipped, so \
-     re-running an interrupted import is safe.";
+fn empty_list_description() -> String {
+    gettext(
+        "Photos already in Proton Photos are matched by name and content and skipped, so re-running an interrupted import is safe.",
+    )
+}

 pub(crate) struct TakeoutState {
    /// Archives staged for this import, in the order they were added. Sent as
@@ -126,37 +129,26 @@ pub(crate) struct TakeoutWidgets {
 }

 pub(crate) fn build_takeout_page() -> (gtk4::Widget, TakeoutWidgets) {
-    // Header: a back button out to Settings, since this page is reached from
+    // Header: a back button out to Photos, since this page is reached from
    // there and has no sidebar row of its own to navigate back with.
    let back_button = gtk4::Button::builder()
        .icon_name("go-previous-symbolic")
-        .tooltip_text("Back to Settings")
+        .tooltip_text(gettext("Back to Photos"))
        .valign(gtk4::Align::Center)
        .build();
    back_button.add_css_class("flat");

-    let title = gtk4::Label::builder()
-        .label("Import from Google Photos")
-        .halign(gtk4::Align::Start)
-        .build();
-    title.add_css_class("title-2");
    let subtitle = gtk4::Label::builder()
-        .label("Add a Google Takeout export to your Proton Photos timeline.")
+        .label(gettext(
+            "Add a Google Takeout export to your Proton Photos timeline.",
+        ))
        .halign(gtk4::Align::Start)
        .wrap(true)
        .xalign(0.0)
        .build();
    subtitle.add_css_class("dim-label");

-    let titles = gtk4::Box::new(gtk4::Orientation::Vertical, 2);
-    titles.set_hexpand(true);
-    titles.append(&title);
-    titles.append(&subtitle);
-
-    let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
-    header.append(&back_button);
-    header.append(&titles);
-    let header_clamp = adw::Clamp::builder().child(&header).build();
+    let subtitle_clamp = adw::Clamp::builder().child(&subtitle).build();

    // Drop zone. It is a hint, not the only way in — the button under it does
    // the same thing for anyone not dragging, and the drop target covers the
@@ -165,18 +157,18 @@ pub(crate) fn build_takeout_page() -> (gtk4::Widget, TakeoutWidgets) {
    drop_icon.set_pixel_size(48);
    drop_icon.add_css_class("dim-label");
    let drop_title = gtk4::Label::builder()
-        .label("Drop your Takeout .zip files here")
+        .label(gettext("Drop your Takeout .zip files here"))
        .build();
    drop_title.add_css_class("title-4");
    let drop_hint = gtk4::Label::builder()
-        .label("Add every part of the export at once — a photo and its metadata often sit in different parts.")
+        .label(gettext("Add every part of the export at once — a photo and its metadata often sit in different parts."))
        .wrap(true)
        .justify(gtk4::Justification::Center)
        .max_width_chars(48)
        .build();
    drop_hint.add_css_class("dim-label");
    let choose_button = gtk4::Button::builder()
-        .label("Choose files…")
+        .label(gettext("Choose files…"))
        .halign(gtk4::Align::Center)
        .build();
    choose_button.add_css_class("pill");
@@ -194,13 +186,13 @@ pub(crate) fn build_takeout_page() -> (gtk4::Widget, TakeoutWidgets) {
    // group carries a placeholder row while empty so it never renders as a bare
    // title.
    let list_group = adw::PreferencesGroup::builder()
-        .title("Archives to import")
-        .description(EMPTY_LIST_DESCRIPTION)
+        .title(gettext("Archives to import"))
+        .description(empty_list_description())
        .build();

    let clear_button = gtk4::Button::builder()
-        .label("Clear")
-        .tooltip_text("Remove every staged archive")
+        .label(gettext("Clear"))
+        .tooltip_text(gettext("Remove every staged archive"))
        .build();
    clear_button.add_css_class("flat");

@@ -208,16 +200,22 @@ pub(crate) fn build_takeout_page() -> (gtk4::Widget, TakeoutWidgets) {
    // what an import *would* do, without uploading a byte. It is offered first
    // because the import behind it is hours long and hard to take back.
    let scan_button = gtk4::Button::builder()
-        .label("Scan")
-        .tooltip_text("Check the archives and report what would be imported, without uploading")
+        .label(pgettext("verb", "Scan"))
+        .tooltip_text(gettext(
+            "Check the archives and report what would be imported, without uploading",
+        ))
        .build();
    scan_button.add_css_class("pill");
-    let import_button = gtk4::Button::builder().label("Import").build();
+    let import_button = gtk4::Button::builder()
+        .label(pgettext("verb", "Import"))
+        .build();
    import_button.add_css_class("pill");
    import_button.add_css_class("suggested-action");
    let cancel_button = gtk4::Button::builder()
-        .label("Stop import")
-        .tooltip_text("Finish the photo on the wire, file what was uploaded, then stop")
+        .label(gettext("Stop import"))
+        .tooltip_text(gettext(
+            "Finish the photo on the wire, file what was uploaded, then stop",
+        ))
        .build();
    cancel_button.add_css_class("pill");
    cancel_button.add_css_class("destructive-action");
@@ -235,9 +233,9 @@ pub(crate) fn build_takeout_page() -> (gtk4::Widget, TakeoutWidgets) {
    actions.append(&import_button);

    // Progress: the import's job from the transfer snapshot, so this page shows
-    // the same numbers the Settings Activity list does.
+    // the same numbers the Sync page's Transfers list does.
    let progress_group = adw::PreferencesGroup::builder()
-        .title("Import in progress")
+        .title(gettext("Import in progress"))
        .visible(false)
        .build();
    let progress_box = gtk4::Box::new(gtk4::Orientation::Vertical, 6);
@@ -259,7 +257,7 @@ pub(crate) fn build_takeout_page() -> (gtk4::Widget, TakeoutWidgets) {
    // outlives the window being on this page, and "what happened" is the whole
    // reason to come back to it.
    let summary_group = adw::PreferencesGroup::builder()
-        .title("Last import")
+        .title(gettext("Last import"))
        .visible(false)
        .build();

@@ -284,8 +282,10 @@ pub(crate) fn build_takeout_page() -> (gtk4::Widget, TakeoutWidgets) {
    page.set_margin_bottom(18);
    page.set_margin_start(18);
    page.set_margin_end(18);
-    page.append(&header_clamp);
+    page.append(&subtitle_clamp);
    page.append(&scroll);
+    let (frame, header, _) = page_frame(&gettext("Import from Google Photos"), &page);
+    header.pack_start(&back_button);

    let widgets = TakeoutWidgets {
        list_group: list_group.clone(),
@@ -302,7 +302,7 @@ pub(crate) fn build_takeout_page() -> (gtk4::Widget, TakeoutWidgets) {
        progress_bar: progress_bar.clone(),
        summary_group: summary_group.clone(),
    };
-    (page.upcast(), widgets)
+    (frame.upcast(), widgets)
 }

 pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
@@ -341,10 +341,10 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
    widgets.choose_button.connect_clicked(move |_| {
        // Multi-select on purpose: the whole export goes in one request.
        let dialog = gtk4::FileDialog::builder()
-            .title("Select your Google Takeout archives")
+            .title(gettext("Select your Google Takeout archives"))
            .build();
        let filter = gtk4::FileFilter::new();
-        filter.set_name(Some("Takeout archives"));
+        filter.set_name(Some(&gettext("Takeout archives")));
        filter.add_pattern("*.zip");
        let filters = gio::ListStore::new::<gtk4::FileFilter>();
        filters.append(&filter);
@@ -384,15 +384,16 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
        let count = ui_import.takeout.archives.borrow().len();
        let ui = ui_import.clone();
        let dialog = adw::AlertDialog::builder()
-            .heading("Import this export?")
-            .body(format!(
-                "{count} archive(s) will be uploaded to Proton Photos, creating albums as they \
-                 appear in the export. This can take hours; you can stop it at any point and \
-                 what has been uploaded stays. Photos you already have are skipped.",
+            .heading(gettext("Import this export?"))
+            .body(ngettext_f(
+                "{n} archive will be uploaded to Proton Photos, creating albums as they appear in the export. This can take hours; you can stop it at any point and what has been uploaded stays. Photos you already have are skipped.",
+                "{n} archives will be uploaded to Proton Photos, creating albums as they appear in the export. This can take hours; you can stop it at any point and what has been uploaded stays. Photos you already have are skipped.",
+                count as u64,
+                &[],
            ))
            .build();
-        dialog.add_response("cancel", "Cancel");
-        dialog.add_response("import", "Import");
+        dialog.add_response("cancel", &gettext("Cancel"));
+        dialog.add_response("import", &pgettext("verb", "Import"));
        dialog.set_response_appearance("import", adw::ResponseAppearance::Suggested);
        dialog.set_default_response(Some("cancel"));
        dialog.set_close_response("cancel");
@@ -413,14 +414,14 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
            let result = rx.recv().await;
            ui.busy_end();
            match result {
-                Ok(Ok(Response::Ok { .. })) => toast(&ui, "Stopping the import…"),
+                Ok(Ok(Response::Ok { .. })) => toast(&ui, &gettext("Stopping the import…")),
                Ok(Ok(Response::Error { message, kind })) => {
-                    toast_failure(&ui, "Couldn't stop the import", &message, kind);
+                    toast_failure(&ui, &gettext("Couldn't stop the import"), &message, kind);
                }
                _ => toast_error(
                    &ui,
-                    "Couldn't stop the import",
-                    "The mount service didn't respond.",
+                    &gettext("Couldn't stop the import"),
+                    &gettext("The mount service didn't respond."),
                ),
            }
        });
@@ -429,7 +430,7 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
    let ui_back = ui.clone();
    widgets
        .back_button
-        .connect_clicked(move |_| ui_back.stack.set_visible_child_name("main"));
+        .connect_clicked(move |_| ui_back.stack.set_visible_child_name("gallery"));

    // Restore whatever was staged when the window last closed, before the first
    // paint, so the page comes up as the user left it.
@@ -470,10 +471,15 @@ pub(crate) fn add_archives(ui: &Rc<Ui>, paths: Vec<PathBuf>) {
    if rejected > 0 {
        toast(
            ui,
-            "Only Takeout .zip files can be imported — extracted folders aren't supported.",
+            &gettext(
+                "Only Takeout .zip files can be imported — extracted folders aren't supported.",
+            ),
        );
    } else if added > 0 {
-        toast(ui, &format!("Added {added} archive(s)"));
+        toast(
+            ui,
+            &ngettext_f("Added {n} archive", "Added {n} archives", added as u64, &[]),
+        );
    }
 }

@@ -488,8 +494,8 @@ pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
    if staged.is_empty() {
        ui.takeout
            .list_group
-            .set_description(Some(EMPTY_LIST_DESCRIPTION));
-        let row = dim_row("No archives added yet.");
+            .set_description(Some(&empty_list_description()));
+        let row = dim_row(&gettext("No archives added yet."));
        ui.takeout.list_group.add(&row);
        rows.push(row.upcast());
    } else {
@@ -507,7 +513,7 @@ pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
                .build();
            let remove = gtk4::Button::builder()
                .icon_name("edit-delete-symbolic")
-                .tooltip_text("Remove from this import")
+                .tooltip_text(gettext("Remove from this import"))
                .valign(gtk4::Align::Center)
                .build();
            remove.add_css_class("flat");
@@ -525,10 +531,14 @@ pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
            ui.takeout.list_group.add(&row);
            rows.push(row.upcast());
        }
-        ui.takeout.list_group.set_description(Some(&format!(
-            "{} archive(s), {} in total. {EMPTY_LIST_DESCRIPTION}",
-            staged.len(),
-            human_bytes(total)
+        let size = human_bytes(total);
+        let note = empty_list_description();
+        // Translators: {size} is a file size such as "4.2 MB"; {note} is the sentence about skipped duplicates.
+        ui.takeout.list_group.set_description(Some(&ngettext_f(
+            "{n} archive, {size} in total. {note}",
+            "{n} archives, {size} in total. {note}",
+            staged.len() as u64,
+            &[("size", &size), ("note", &note)],
        )));
    }
    *ui.takeout.rows.borrow_mut() = rows;
@@ -582,28 +592,28 @@ fn start_import(ui: &Rc<Ui>, dry_run: bool) {
                ui.takeout.summary_group.set_visible(false);
                ui.takeout.progress_group.set_visible(true);
                ui.takeout.progress_bar.set_fraction(0.0);
-                ui.takeout.progress_label.set_text(if dry_run {
-                    "Reading archives…"
+                ui.takeout.progress_label.set_text(&if dry_run {
+                    gettext("Reading archives…")
                } else {
-                    "Starting import…"
+                    gettext("Starting import…")
                });
                sync_takeout_actions(&ui);
                toast(
                    &ui,
-                    if dry_run {
-                        "Scanning the export…"
+                    &if dry_run {
+                        gettext("Scanning the export…")
                    } else {
-                        "Import started — you can leave this page, it keeps running."
+                        gettext("Import started — you can leave this page, it keeps running.")
                    },
                );
            }
            Ok(Ok(Response::Error { message, kind })) => {
-                toast_failure(&ui, "Couldn't start the import", &message, kind);
+                toast_failure(&ui, &gettext("Couldn't start the import"), &message, kind);
            }
            _ => toast_error(
                &ui,
-                "Couldn't start the import",
-                "The mount service didn't respond.",
+                &gettext("Couldn't start the import"),
+                &gettext("The mount service didn't respond."),
            ),
        }
    });
@@ -636,23 +646,35 @@ pub(crate) fn refresh_takeout(ui: &Rc<Ui>) {
            if was_running {
                let dry = ui.takeout.dry_run.get();
                let headline = if dry {
-                    "Scan finished"
+                    gettext("Scan finished")
                } else {
-                    "Import finished"
+                    gettext("Import finished")
                };
-                toast(&ui, headline);
+                toast(&ui, &headline);
                if !dry {
                    let body = match &summary {
-                        Some(s) if s.failed > 0 => {
-                            format!("{} photos added, {} failed.", s.uploaded, s.failed)
-                        }
-                        Some(s) if s.cancelled => {
-                            format!("Stopped after {} photos.", s.uploaded)
-                        }
-                        Some(s) => format!("{} photos added to Proton Photos.", s.uploaded),
-                        None => "The Google Photos import has finished.".to_string(),
+                        // Translators: {n} is the number of photos uploaded, {failed} the number that failed.
+                        Some(s) if s.failed > 0 => ngettext_f(
+                            "{n} photo added, {failed} failed.",
+                            "{n} photos added, {failed} failed.",
+                            s.uploaded as u64,
+                            &[("failed", &s.failed.to_string())],
+                        ),
+                        Some(s) if s.cancelled => ngettext_f(
+                            "Stopped after {n} photo.",
+                            "Stopped after {n} photos.",
+                            s.uploaded as u64,
+                            &[],
+                        ),
+                        Some(s) => ngettext_f(
+                            "{n} photo added to Proton Photos.",
+                            "{n} photos added to Proton Photos.",
+                            s.uploaded as u64,
+                            &[],
+                        ),
+                        None => gettext("The Google Photos import has finished."),
                    };
-                    notify("takeout-import", headline, &body);
+                    notify("takeout-import", &headline, &body);
                }
            }
        }
@@ -672,69 +694,72 @@ fn repaint_summary(ui: &Rc<Ui>, summary: &ImportSummary) {
        ui.takeout.summary_group.remove(&row);
    }
    let dry = ui.takeout.dry_run.get();
-    ui.takeout
-        .summary_group
-        .set_title(if dry { "Scan result" } else { "Last import" });
-    ui.takeout.summary_group.set_description(Some(if dry {
-        "Nothing was uploaded — this is what an import would do."
-    } else if summary.cancelled {
-        "Stopped early. Everything uploaded so far is in your timeline; run it again to \
-         continue where it left off."
+    ui.takeout.summary_group.set_title(&if dry {
+        gettext("Scan result")
    } else {
-        "Finished."
+        gettext("Last import")
+    });
+    ui.takeout.summary_group.set_description(Some(&if dry {
+        gettext("Nothing was uploaded — this is what an import would do.")
+    } else if summary.cancelled {
+        gettext("Stopped early. Everything uploaded so far is in your timeline; run it again to continue where it left off.")
+    } else {
+        gettext("Finished.")
    }));

    // Only lines that carry information: a run with no failures should not have
    // to show a "0 failed" row for the user to read past.
    let mut lines: Vec<(String, String)> = vec![
-        ("Photos in the export".into(), summary.found.to_string()),
+        (gettext("Photos in the export"), summary.found.to_string()),
        (
-            if dry { "Would upload" } else { "Uploaded" }.into(),
+            if dry {
+                gettext("Would upload")
+            } else {
+                gettext("Uploaded")
+            },
            summary.uploaded.to_string(),
        ),
    ];
    if summary.duplicates > 0 {
        lines.push((
-            "Already in Proton Photos".into(),
+            gettext("Already in Proton Photos"),
            summary.duplicates.to_string(),
        ));
    }
    if summary.albums_created > 0 {
        lines.push((
            if dry {
-                "Albums to create"
+                gettext("Albums to create")
            } else {
-                "Albums created"
-            }
-            .into(),
+                gettext("Albums created")
+            },
            summary.albums_created.to_string(),
        ));
    }
    if summary.album_links > 0 {
        lines.push((
-            "Photos filed into albums".into(),
+            gettext("Photos filed into albums"),
            summary.album_links.to_string(),
        ));
    }
    if summary.skipped_trashed > 0 {
        lines.push((
-            "Skipped (in Google's trash)".into(),
+            gettext("Skipped (in Google's trash)"),
            summary.skipped_trashed.to_string(),
        ));
    }
    if summary.bytes > 0 {
        lines.push((
            if dry {
-                "Data to upload"
+                gettext("Data to upload")
            } else {
-                "Data uploaded"
-            }
-            .into(),
+                gettext("Data uploaded")
+            },
            human_bytes(summary.bytes),
        ));
    }
    if summary.failed > 0 {
-        lines.push(("Failed".into(), summary.failed.to_string()));
+        lines.push((pgettext("state", "Failed"), summary.failed.to_string()));
    }

    let mut rows = Vec::new();
@@ -751,7 +776,7 @@ fn repaint_summary(ui: &Rc<Ui>, summary: &ImportSummary) {
    ui.takeout.summary_group.set_visible(true);
 }

-/// Paint the import's progress from the transfer snapshot the Settings tick
+/// Paint the import's progress from the transfer snapshot the status tick
 /// already fetched, so this page costs no extra poll. A job with no known total
 /// pulses instead of showing a fraction, the same as the Activity list.
 pub(crate) fn takeout_progress(ui: &Rc<Ui>, jobs: &[JobItem]) {
@@ -763,17 +788,22 @@ pub(crate) fn takeout_progress(ui: &Rc<Ui>, jobs: &[JobItem]) {
        ui.takeout
            .progress_bar
            .set_fraction((job.done as f64 / job.total as f64).min(1.0));
-        ui.takeout
-            .progress_label
-            .set_text(&format!("{} of {} — {}", job.done, job.total, job.detail));
+        let done = job.done.to_string();
+        let total = job.total.to_string();
+        // Translators: progress such as "120 of 4000 — IMG_0001.jpg"; {detail} is what is being worked on.
+        let text = gettext_f(
+            "{done} of {total} — {detail}",
+            &[("done", &done), ("total", &total), ("detail", &job.detail)],
+        );
+        ui.takeout.progress_label.set_text(&text);
    } else {
        ui.takeout.progress_bar.pulse();
        ui.takeout
            .progress_label
-            .set_text(if job.detail.is_empty() {
-                "Working…"
+            .set_text(&if job.detail.is_empty() {
+                gettext("Working…")
            } else {
-                &job.detail
+                job.detail.clone()
            });
    }
 }
@@ -10,7 +10,11 @@ pub(crate) struct TrashState {
    /// Empties the trash; insensitive while it is empty (or unread).
    pub(crate) empty: gtk4::Button,
    /// "12 items" under the page title.
-    pub(crate) subtitle: gtk4::Label,
+    pub(crate) subtitle: adw::WindowTitle,
+    pub(crate) selection: gtk4::MultiSelection,
+    /// The bottom bar acting on the selection; revealed while anything is selected.
+    pub(crate) selection_bar: gtk4::Revealer,
+    pub(crate) selection_label: gtk4::Label,
 }

 /// The widgets of the Trash page that a load repaints.
@@ -22,11 +26,18 @@ pub(crate) struct TrashWidgets {
    pub(crate) retry: gtk4::Button,
    pub(crate) empty: gtk4::Button,
    pub(crate) refresh: gtk4::Button,
-    pub(crate) subtitle: gtk4::Label,
+    pub(crate) subtitle: adw::WindowTitle,
+    pub(crate) selection: gtk4::MultiSelection,
+    pub(crate) selection_bar: gtk4::Revealer,
+    pub(crate) selection_label: gtk4::Label,
+    pub(crate) restore_selected: gtk4::Button,
+    pub(crate) delete_selected: gtk4::Button,
 }

 /// The Trash page: a flat list of everything Drive is holding in the trash, each
-/// row offering Restore and Delete Forever, with Empty Trash in the header.
+/// row offering Restore and Delete Forever, with Empty Trash in the header. A
+/// selection (click, Shift/Ctrl+click, Ctrl+A) gets the same two actions in a
+/// bottom bar.
 ///
 /// A trashed node has no path inside the mount — the daemon forgets it when it is
 /// trashed — so unlike the Files page this one addresses entries by uid and always
@@ -35,33 +46,15 @@ pub(crate) struct TrashWidgets {
 pub(crate) fn build_trash_page() -> (gtk4::Widget, TrashWidgets) {
    let model = gio::ListStore::new::<BoxedAnyObject>();

-    let title = gtk4::Label::builder()
-        .label("Trash")
-        .halign(gtk4::Align::Start)
-        .build();
-    title.add_css_class("title-2");
-    let subtitle = gtk4::Label::builder().halign(gtk4::Align::Start).build();
-    subtitle.add_css_class("dim-label");
-    let titles = gtk4::Box::new(gtk4::Orientation::Vertical, 2);
-    titles.set_hexpand(true);
-    titles.append(&title);
-    titles.append(&subtitle);
-
    let empty = gtk4::Button::builder()
-        .label("Empty Trash")
-        .valign(gtk4::Align::Center)
+        .label(gettext("Empty Trash…"))
+        .tooltip_text(gettext("Permanently delete everything in the Trash"))
        .sensitive(false)
        .build();
-    empty.add_css_class("destructive-action");
    let refresh = refresh_button();

-    let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
-    header.append(&titles);
-    header.append(&refresh);
-    header.append(&empty);
-
    let retry = gtk4::Button::builder()
-        .label("Retry")
+        .label(gettext("Retry"))
        .halign(gtk4::Align::Center)
        .build();
    retry.add_css_class("pill");
@@ -74,11 +67,10 @@ pub(crate) fn build_trash_page() -> (gtk4::Widget, TrashWidgets) {
        .build();
    status.add_css_class("compact");

-    // No selection model: every action lives on the row it acts on, so a
-    // mis-aimed Delete Forever isn't one click away from a stale selection.
-    let list = gtk4::ListView::builder()
-        .model(&gtk4::NoSelection::new(Some(model.clone())))
-        .build();
+    // Bulk Delete Forever always confirms with the count, so a stale selection
+    // can't delete anything silently.
+    let selection = gtk4::MultiSelection::new(Some(model.clone()));
+    let list = gtk4::ListView::builder().model(&selection).build();
    let scroll = gtk4::ScrolledWindow::builder()
        .vexpand(true)
        .child(&list)
@@ -91,15 +83,32 @@ pub(crate) fn build_trash_page() -> (gtk4::Widget, TrashWidgets) {
    content.add_named(&status, Some("status"));

    let inner = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
-    inner.set_margin_top(12);
-    inner.set_margin_bottom(12);
-    inner.set_margin_start(12);
-    inner.set_margin_end(12);
-    inner.append(&header);
+    inner.set_margin_top(18);
+    inner.set_margin_bottom(18);
+    inner.set_margin_start(18);
+    inner.set_margin_end(18);
    inner.append(&content);

+    let selection_label = gtk4::Label::new(None);
+    let restore_selected = gtk4::Button::with_label(&pgettext("verb", "Restore"));
+    let delete_selected = gtk4::Button::with_label(&gettext("Delete Permanently…"));
+    delete_selected.add_css_class("destructive-action");
+    let bar = gtk4::ActionBar::new();
+    bar.set_center_widget(Some(&selection_label));
+    bar.pack_start(&restore_selected);
+    bar.pack_end(&delete_selected);
+    let selection_bar = gtk4::Revealer::builder()
+        .transition_type(gtk4::RevealerTransitionType::SlideUp)
+        .child(&bar)
+        .build();
+    inner.append(&selection_bar);
+
+    let (frame, header, subtitle) = page_frame(&gettext("Trash"), &inner);
+    header.pack_start(&empty);
+    header.pack_end(&refresh);
+
    (
-        inner.upcast(),
+        frame.upcast(),
        TrashWidgets {
            model,
            list,
@@ -109,6 +118,11 @@ pub(crate) fn build_trash_page() -> (gtk4::Widget, TrashWidgets) {
            empty,
            refresh,
            subtitle,
+            selection,
+            selection_bar,
+            selection_label,
+            restore_selected,
+            delete_selected,
        },
    )
 }
@@ -116,7 +130,9 @@ pub(crate) fn build_trash_page() -> (gtk4::Widget, TrashWidgets) {
 /// Install the row factory and the Empty Trash button. The row's two buttons read
 /// the entry off the [`gtk4::ListItem`] they were clicked on rather than a
 /// captured copy, so a recycled row always acts on the item it currently shows.
-pub(crate) fn wire_trash(ui: &Rc<Ui>, list: &gtk4::ListView, empty: &gtk4::Button) {
+pub(crate) fn wire_trash(ui: &Rc<Ui>, widgets: &TrashWidgets) {
+    let list = &widgets.list;
+    let empty = &widgets.empty;
    let factory = gtk4::SignalListItemFactory::new();
    let ui_setup = ui.clone();
    factory.connect_setup(move |_, item| {
@@ -138,13 +154,13 @@ pub(crate) fn wire_trash(ui: &Rc<Ui>, list: &gtk4::ListView, empty: &gtk4::Butto

        let restore = gtk4::Button::builder()
            .icon_name("edit-undo-symbolic")
-            .tooltip_text("Restore to its original folder")
+            .tooltip_text(gettext("Restore to its original folder"))
            .valign(gtk4::Align::Center)
            .build();
        restore.add_css_class("flat");
        let purge = gtk4::Button::builder()
            .icon_name("edit-delete-symbolic")
-            .tooltip_text("Delete permanently")
+            .tooltip_text(gettext("Delete permanently"))
            .valign(gtk4::Align::Center)
            .build();
        purge.add_css_class("flat");
@@ -160,7 +176,7 @@ pub(crate) fn wire_trash(ui: &Rc<Ui>, list: &gtk4::ListView, empty: &gtk4::Butto
        let item_purge = item.clone();
        purge.connect_clicked(move |_| {
            if let Some(entry) = bound_entry(&item_purge) {
-                prompt_delete_forever(&ui_purge, &entry);
+                prompt_delete_forever(&ui_purge, std::slice::from_ref(&entry));
            }
        });

@@ -195,11 +211,17 @@ pub(crate) fn wire_trash(ui: &Rc<Ui>, list: &gtk4::ListView, empty: &gtk4::Butto
            }
            if let Some(meta) = text.last_child().and_downcast::<gtk4::Label>() {
                let kind = if entry.is_dir {
-                    "Folder".to_string()
+                    gettext("Folder")
                } else {
                    human_bytes(entry.size)
                };
-                meta.set_label(&format!("{kind} · {}", format_modified(entry.modified)));
+                let modified = format_modified(entry.modified);
+                // Translators: {kind} is "Folder" or a file size; {modified} is a date.
+                let text = gettext_f(
+                    "{kind} · {modified}",
+                    &[("kind", &kind), ("modified", &modified)],
+                );
+                meta.set_label(&text);
            }
        }
    });
@@ -207,6 +229,49 @@ pub(crate) fn wire_trash(ui: &Rc<Ui>, list: &gtk4::ListView, empty: &gtk4::Butto

    let ui_empty = ui.clone();
    empty.connect_clicked(move |_| prompt_empty_trash(&ui_empty));
+
+    let ui_sel = ui.clone();
+    widgets
+        .selection
+        .connect_selection_changed(move |_, _, _| sync_trash_selection(&ui_sel));
+    let ui_restore = ui.clone();
+    widgets.restore_selected.connect_clicked(move |_| {
+        let entries = selected_trash(&ui_restore);
+        if !entries.is_empty() {
+            restore_entries(&ui_restore, &entries);
+        }
+    });
+    let ui_delete = ui.clone();
+    widgets.delete_selected.connect_clicked(move |_| {
+        let entries = selected_trash(&ui_delete);
+        if !entries.is_empty() {
+            prompt_delete_forever(&ui_delete, &entries);
+        }
+    });
+}
+
+/// The trashed entries currently selected, in list order.
+fn selected_trash(ui: &Rc<Ui>) -> Vec<DirEntry> {
+    let selected = ui.trash.selection.selection();
+    (0..selected.size())
+        .filter_map(|i| ui.trash.model.item(selected.nth(i as u32)))
+        .filter_map(|obj| obj.downcast::<BoxedAnyObject>().ok())
+        .map(|obj| obj.borrow::<DirEntry>().clone())
+        .collect()
+}
+
+/// Reveal the selection bar while anything is selected and count what is.
+fn sync_trash_selection(ui: &Rc<Ui>) {
+    let count = ui.trash.selection.selection().size() as usize;
+    ui.trash.selection_bar.set_reveal_child(count > 0);
+    if count > 0 {
+        ui.trash.selection_label.set_label(&ngettext_f(
+            "{n} item selected",
+            "{n} items selected",
+            count as u64,
+            &[],
+        ));
+    }
 }

 /// The [`DirEntry`] a list item is currently bound to, or `None` for an unbound
@@ -224,11 +289,12 @@ pub(crate) fn load_trash(ui: &Rc<Ui>) {
    // that may already be gone.
    ui.trash.model.remove_all();
    ui.trash.empty.set_sensitive(false);
+    sync_trash_selection(ui);
    trash_status(
        ui,
        "user-trash-symbolic",
-        "Loading…",
-        "Reading the trash.",
+        &gettext("Loading…"),
+        &gettext("Reading the trash."),
        false,
    );

@@ -243,15 +309,15 @@ pub(crate) fn load_trash(ui: &Rc<Ui>) {
            Ok(Ok(Response::Error { message, .. })) => trash_status(
                &ui,
                "dialog-warning-symbolic",
-                "Couldn't read the trash",
+                &gettext("Couldn't read the trash"),
                &message,
                false,
            ),
            Ok(Ok(_)) => trash_status(
                &ui,
                "dialog-warning-symbolic",
-                "Couldn't read the trash",
-                "Unexpected reply from the mount service.",
+                &gettext("Couldn't read the trash"),
+                &gettext("Unexpected reply from the mount service."),
                false,
            ),
            Ok(Err(_)) | Err(_) => trash_unreachable(&ui),
@@ -266,8 +332,8 @@ pub(crate) fn trash_unreachable(ui: &Rc<Ui>) {
        trash_status(
            ui,
            "network-offline-symbolic",
-            "Not connected",
-            "The Proton Drive mount service isn't running.",
+            &gettext("Not connected"),
+            &gettext("The Proton Drive mount service isn't running."),
            true,
        );
        return;
@@ -275,8 +341,8 @@ pub(crate) fn trash_unreachable(ui: &Rc<Ui>) {
    trash_status(
        ui,
        "folder-remote-symbolic",
-        "Connecting…",
-        "Waiting for the Proton Drive mount service to come up.",
+        &gettext("Connecting…"),
+        &gettext("Waiting for the Proton Drive mount service to come up."),
        false,
    );
    let ui = ui.clone();
@@ -294,29 +360,32 @@ pub(crate) fn trash_status(ui: &Rc<Ui>, icon: &str, title: &str, description: &s
    ui.trash.status.set_description(Some(description));
    ui.trash.retry.set_visible(retry);
    ui.trash.content.set_visible_child_name("status");
-    ui.trash.subtitle.set_label("");
+    ui.trash.subtitle.set_subtitle("");
 }

 /// Repopulate the trash list, most recently modified first — the order in which a
 /// user looks for what they just deleted.
 pub(crate) fn repaint_trash(ui: &Rc<Ui>, entries: &[DirEntry]) {
    ui.trash.model.remove_all();
+    sync_trash_selection(ui);
    ui.trash.empty.set_sensitive(!entries.is_empty());
    if entries.is_empty() {
        trash_status(
            ui,
            "user-trash-symbolic",
-            "Trash is empty",
-            "Items you delete from Proton Drive show up here.",
+            &gettext("Trash is empty"),
+            &gettext("Items you delete from Proton Drive show up here."),
            false,
        );
        return;
    }
    ui.trash.content.set_visible_child_name("list");
-    ui.trash.subtitle.set_label(&match entries.len() {
-        1 => "1 item".to_string(),
-        n => format!("{n} items"),
-    });
+    ui.trash.subtitle.set_subtitle(&ngettext_f(
+        "{n} item",
+        "{n} items",
+        entries.len() as u64,
+        &[],
+    ));

    let mut sorted = entries.to_vec();
    sorted.sort_by_key(|e| std::cmp::Reverse(e.modified));
@@ -327,30 +396,66 @@ pub(crate) fn repaint_trash(ui: &Rc<Ui>, entries: &[DirEntry]) {

 /// Restore one trashed entry to the folder it was trashed from.
 pub(crate) fn restore_entry(ui: &Rc<Ui>, entry: &DirEntry) {
-    let name = entry.name.clone();
+    restore_entries(ui, std::slice::from_ref(entry));
+}
+
+/// Restore trashed entries to the folders they were trashed from.
+pub(crate) fn restore_entries(ui: &Rc<Ui>, entries: &[DirEntry]) {
    run_mutation(
        ui,
        Request::Restore {
-            uids: vec![entry.uid.clone()],
+            uids: entries.iter().map(|e| e.uid.clone()).collect(),
        },
-        format!("Restored “{name}”"),
-        "Couldn't restore",
+        match entries {
+            // Translators: {name} is a file or folder name.
+            [one] => gettext_f("Restored “{name}”", &[("name", &one.name)]),
+            _ => ngettext_f(
+                "Restored {n} item",
+                "Restored {n} items",
+                entries.len() as u64,
+                &[],
+            ),
+        },
+        gettext_noop("Couldn't restore"),
    );
 }

-/// Confirm, then permanently delete one trashed entry. Irreversible, so it asks.
-pub(crate) fn prompt_delete_forever(ui: &Rc<Ui>, entry: &DirEntry) {
+/// Confirm, then permanently delete trashed entries. Irreversible, so it asks.
+pub(crate) fn prompt_delete_forever(ui: &Rc<Ui>, entries: &[DirEntry]) {
    let win = ui_window(ui);
-    let uid = entry.uid.clone();
-    let name = entry.name.clone();
+    let uids: Vec<String> = entries.iter().map(|e| e.uid.clone()).collect();
+    let count = entries.len() as u64;
+    let (body, done) = match entries {
+        [one] => {
+            let args = [("name", one.name.as_str())];
+            (
+                // Translators: {name} is a file or folder name.
+                gettext_f("Permanently delete “{name}”? This cannot be undone.", &args),
+                // Translators: {name} is a file or folder name.
+                gettext_f("Deleted “{name}” permanently", &args),
+            )
+        }
+        _ => (
+            ngettext_f(
+                "Permanently delete {n} item? This cannot be undone.",
+                "Permanently delete {n} items? This cannot be undone.",
+                count,
+                &[],
+            ),
+            ngettext_f(
+                "Deleted {n} item permanently",
+                "Deleted {n} items permanently",
+                count,
+                &[],
+            ),
+        ),
+    };
    let dialog = adw::AlertDialog::builder()
-        .heading("Delete permanently")
-        .body(format!(
-            "Permanently delete “{name}”? This cannot be undone."
-        ))
+        .heading(gettext("Delete Permanently"))
+        .body(body)
        .build();
-    dialog.add_response("cancel", "Cancel");
-    dialog.add_response("delete", "Delete Permanently");
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("delete", &gettext("Delete Permanently"));
    dialog.set_response_appearance("delete", adw::ResponseAppearance::Destructive);
    dialog.set_default_response(Some("cancel"));
    dialog.set_close_response("cancel");
@@ -360,11 +465,9 @@ pub(crate) fn prompt_delete_forever(ui: &Rc<Ui>, entry: &DirEntry) {
        if resp == "delete" {
            run_mutation(
                &ui,
-                Request::DeleteForever {
-                    uids: vec![uid.clone()],
-                },
-                format!("Deleted “{name}” permanently"),
-                "Couldn't delete",
+                Request::DeleteForever { uids: uids.clone() },
+                done.clone(),
+                gettext_noop("Couldn't delete"),
            );
        }
    });
@@ -376,13 +479,16 @@ pub(crate) fn prompt_empty_trash(ui: &Rc<Ui>) {
    let win = ui_window(ui);
    let count = ui.trash.model.n_items();
    let dialog = adw::AlertDialog::builder()
-        .heading("Empty Trash")
-        .body(format!(
-            "Permanently delete all {count} item(s) in the trash? This cannot be undone."
+        .heading(gettext("Empty Trash"))
+        .body(ngettext_f(
+            "Permanently delete all {n} item in the trash? This cannot be undone.",
+            "Permanently delete all {n} items in the trash? This cannot be undone.",
+            count as u64,
+            &[],
        ))
        .build();
-    dialog.add_response("cancel", "Cancel");
-    dialog.add_response("empty", "Empty Trash");
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("empty", &gettext("Empty Trash"));
    dialog.set_response_appearance("empty", adw::ResponseAppearance::Destructive);
    dialog.set_default_response(Some("cancel"));
    dialog.set_close_response("cancel");
@@ -393,8 +499,8 @@ pub(crate) fn prompt_empty_trash(ui: &Rc<Ui>) {
            run_mutation(
                &ui,
                Request::EmptyTrash,
-                "Trash emptied".to_string(),
-                "Couldn't empty the trash",
+                gettext("Trash emptied"),
+                gettext_noop("Couldn't empty the trash"),
            );
        }
    });
@@ -54,7 +54,7 @@ pub(crate) fn prompt_human_verification(
        .build();

    let dialog = adw::Dialog::builder()
-        .title("Verification")
+        .title(gettext("Verification"))
        .content_width(420)
        .content_height(560)
        .build();
@@ -9,10 +9,9 @@ pub(crate) struct DetailsState {
    /// Set while the details pane is being populated, so setting the offline
    /// switch programmatically doesn't fire a pin/unpin round-trip.
    pub(crate) details_suppress: Cell<bool>,
-    /// The grid's and list's selection models. Both wrap the one browser model, so
-    /// a selection in either drives the details pane.
-    pub(crate) grid_selection: gtk4::MultiSelection,
-    pub(crate) list_selection: gtk4::MultiSelection,
+    /// The one selection model behind both the grid and the list, so switching
+    /// views keeps what is selected; it drives the details pane.
+    pub(crate) selection: gtk4::MultiSelection,
 }

 /// The widgets in the browser's details pane that a selection repaints.
@@ -26,20 +25,37 @@ pub(crate) struct DetailsWidgets {
    pub(crate) pin_row: adw::SwitchRow,
    pub(crate) open_button: gtk4::Button,
    pub(crate) rename_button: gtk4::Button,
+    /// Who has access and whether there is a public link; filled on selection.
+    pub(crate) sharing_row: adw::ActionRow,
+    pub(crate) share_button: gtk4::Button,
+    pub(crate) copy_link_button: gtk4::Button,
    /// Files only — folders have no revision history.
+    pub(crate) versions_group: adw::PreferencesGroup,
+    pub(crate) versions_row: adw::ActionRow,
    pub(crate) versions_button: gtk4::Button,
    pub(crate) trash_button: gtk4::Button,
    pub(crate) close_button: gtk4::Button,
+    /// The header toggle that asks for the pane. Selecting an entry only
+    /// fills the pane; it is shown while this is on, so a click never moves
+    /// the files under the pointer halfway through a double-click.
+    pub(crate) toggle: gtk4::ToggleButton,
+    /// "details" while an entry is shown, "empty" with nothing selected.
+    pub(crate) pages: gtk4::Stack,
 }

 /// The details pane shown beside the file views: a big type icon over the entry's
-/// name, its properties, an offline (pin) toggle and the primary actions. Built
-/// empty; [`repaint_details`] fills it from the selected [`DirEntry`] and
-/// [`wire_details`] connects the buttons.
+/// name, then Info, Offline, Sharing and Versions sections and the primary
+/// actions. Built empty; [`show_details`] fills it from the selected
+/// [`DirEntry`] and [`wire_details`] connects the buttons.
 pub(crate) fn build_details_pane() -> (gtk4::Widget, DetailsWidgets) {
+    let toggle = gtk4::ToggleButton::builder()
+        .icon_name("sidebar-show-right-symbolic")
+        .tooltip_text(gettext("Details (Alt+Enter)"))
+        .build();
+
    let close_button = gtk4::Button::builder()
        .icon_name("window-close-symbolic")
-        .tooltip_text("Close details")
+        .tooltip_text(gettext("Close details"))
        .halign(gtk4::Align::End)
        .build();
    close_button.add_css_class("flat");
@@ -65,19 +81,21 @@ pub(crate) fn build_details_pane() -> (gtk4::Widget, DetailsWidgets) {
    head.append(&name);
    head.append(&kind);

-    let props = adw::PreferencesGroup::new();
+    let props = adw::PreferencesGroup::builder()
+        .title(gettext("Info"))
+        .build();
    let size_row = adw::ActionRow::builder()
-        .title("Size")
+        .title(pgettext("column", "Size"))
        .subtitle("—")
        .build();
    size_row.add_css_class("property");
    let modified_row = adw::ActionRow::builder()
-        .title("Modified")
+        .title(pgettext("column", "Modified"))
        .subtitle("—")
        .build();
    modified_row.add_css_class("property");
    let path_row = adw::ActionRow::builder()
-        .title("Location")
+        .title(gettext("Location"))
        .subtitle("—")
        .subtitle_lines(3)
        .build();
@@ -86,21 +104,63 @@ pub(crate) fn build_details_pane() -> (gtk4::Widget, DetailsWidgets) {
    props.add(&modified_row);
    props.add(&path_row);

-    let offline = adw::PreferencesGroup::new();
+    let offline = adw::PreferencesGroup::builder()
+        .title(pgettext("state", "Offline"))
+        .build();
    let pin_row = adw::SwitchRow::builder()
-        .title("Available offline")
-        .subtitle("Keep a local copy on this device.")
+        .title(gettext("Available offline"))
+        .subtitle(gettext(
+            "Keep a copy on this computer, even without a connection.",
+        ))
        .build();
    offline.add(&pin_row);

-    let open_button = gtk4::Button::builder().label("Open").build();
+    let sharing = adw::PreferencesGroup::builder()
+        .title(gettext("Sharing"))
+        .build();
+    let sharing_row = adw::ActionRow::builder()
+        .title(gettext("Access"))
+        .subtitle("—")
+        .build();
+    sharing_row.add_css_class("property");
+    sharing.add(&sharing_row);
+    let share_button = gtk4::Button::builder().label(gettext("Share…")).build();
+    let copy_link_button = gtk4::Button::builder().label(gettext("Copy Link")).build();
+    let share_actions = gtk4::Box::builder()
+        .orientation(gtk4::Orientation::Horizontal)
+        .spacing(6)
+        .homogeneous(true)
+        .margin_top(6)
+        .build();
+    share_actions.append(&share_button);
+    share_actions.append(&copy_link_button);
+    sharing.add(&share_actions);
+
+    let versions_group = adw::PreferencesGroup::builder()
+        .title(gettext("Versions"))
+        .build();
+    let versions_row = adw::ActionRow::builder()
+        .title(gettext("History"))
+        .subtitle("—")
+        .build();
+    versions_row.add_css_class("property");
+    versions_group.add(&versions_row);
+    let versions_button = gtk4::Button::builder()
+        .label(gettext("Versions…"))
+        .margin_top(6)
+        .build();
+    versions_group.add(&versions_button);
+
+    let open_button = gtk4::Button::builder()
+        .label(pgettext("verb", "Open"))
+        .build();
    open_button.add_css_class("suggested-action");
    open_button.add_css_class("pill");
-    let rename_button = gtk4::Button::builder().label("Rename").build();
+    let rename_button = gtk4::Button::builder().label(gettext("Rename")).build();
    rename_button.add_css_class("pill");
-    let versions_button = gtk4::Button::builder().label("Versions").build();
-    versions_button.add_css_class("pill");
-    let trash_button = gtk4::Button::builder().label("Move to Trash").build();
+    let trash_button = gtk4::Button::builder()
+        .label(gettext("Move to Trash"))
+        .build();
    trash_button.add_css_class("destructive-action");
    trash_button.add_css_class("pill");

@@ -108,7 +168,6 @@ pub(crate) fn build_details_pane() -> (gtk4::Widget, DetailsWidgets) {
    actions.set_margin_top(6);
    actions.append(&open_button);
    actions.append(&rename_button);
-    actions.append(&versions_button);
    actions.append(&trash_button);

    let inner = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
@@ -120,14 +179,45 @@ pub(crate) fn build_details_pane() -> (gtk4::Widget, DetailsWidgets) {
    inner.append(&head);
    inner.append(&props);
    inner.append(&offline);
+    inner.append(&sharing);
+    inner.append(&versions_group);
    inner.append(&actions);

    let scroll = gtk4::ScrolledWindow::builder()
        .hscrollbar_policy(gtk4::PolicyType::Never)
        .child(&inner)
        .build();
+    // With the pane open and nothing selected (a fresh folder, a cleared
+    // selection) it says so rather than closing: opening and closing it by
+    // itself would move the files under the pointer.
+    let empty_close = gtk4::Button::builder()
+        .icon_name("window-close-symbolic")
+        .tooltip_text(gettext("Close details"))
+        .halign(gtk4::Align::End)
+        .margin_top(12)
+        .margin_end(12)
+        .build();
+    empty_close.add_css_class("flat");
+    empty_close.add_css_class("circular");
+    let toggle_off = toggle.clone();
+    empty_close.connect_clicked(move |_| toggle_off.set_active(false));
+    let empty_status = adw::StatusPage::builder()
+        .icon_name("sidebar-show-right-symbolic")
+        .title(gettext("No item selected"))
+        .description(gettext("Select a file or folder to see its details."))
+        .vexpand(true)
+        .build();
+    empty_status.add_css_class("compact");
+    let empty = gtk4::Box::new(gtk4::Orientation::Vertical, 0);
+    empty.append(&empty_close);
+    empty.append(&empty_status);
+
+    let pages = gtk4::Stack::new();
+    pages.add_named(&scroll, Some("details"));
+    pages.add_named(&empty, Some("empty"));
+    pages.set_visible_child_name("empty");
    let pane = adw::ToolbarView::new();
-    pane.set_content(Some(&scroll));
+    pane.set_content(Some(&pages));
    pane.add_css_class("background");

    (
@@ -140,11 +230,18 @@ pub(crate) fn build_details_pane() -> (gtk4::Widget, DetailsWidgets) {
            modified_row,
            path_row,
            pin_row,
+            sharing_row,
+            share_button,
+            copy_link_button,
+            versions_group,
+            versions_row,
            open_button,
            rename_button,
            versions_button,
            trash_button,
            close_button,
+            toggle,
+            pages,
        },
    )
 }
@@ -152,29 +249,40 @@ pub(crate) fn build_details_pane() -> (gtk4::Widget, DetailsWidgets) {
 /// Connect the details pane: mirror the grid's and list's selection into it, and
 /// wire its buttons back onto the entry it's showing.
 pub(crate) fn wire_details(ui: &Rc<Ui>) {
-    // Both views share one model but have their own selection, so watch both.
-    for selection in [
-        ui.details.grid_selection.clone(),
-        ui.details.list_selection.clone(),
-    ] {
+    {
        let ui_sel = ui.clone();
-        selection.connect_selection_changed(move |_, _, _| {
-            // The details pane describes *one* entry. A batch is the bulk bar's
-            // business, so the pane steps aside rather than picking a member of
-            // the selection to speak for the rest.
-            let entries = selected_entries(&ui_sel);
-            match entries.as_slice() {
-                [entry] => show_details(&ui_sel, entry),
-                _ => hide_details(&ui_sel),
-            }
-            sync_bulk_bar(&ui_sel);
-        });
+        ui.details
+            .selection
+            .connect_selection_changed(move |_, _, _| {
+                // The details pane describes *one* entry. A batch is the bulk bar's
+                // business, so the pane steps aside rather than picking a member of
+                // the selection to speak for the rest.
+                let entries = selected_entries(&ui_sel);
+                match entries.as_slice() {
+                    [entry] => show_details(&ui_sel, entry),
+                    _ => clear_details(&ui_sel),
+                }
+                sync_bulk_bar(&ui_sel);
+            });
    }

    let ui_close = ui.clone();
    ui.details.details.close_button.connect_clicked(move |_| {
-        clear_selection(&ui_close);
-        hide_details(&ui_close);
+        ui_close.details.details.toggle.set_active(false);
+    });
+
+    let ui_toggle = ui.clone();
+    ui.details.details.toggle.connect_toggled(move |toggle| {
+        ui_toggle.browser.split.set_show_sidebar(toggle.is_active());
+    });
+    // On a narrow window the pane overlays the files, and a click outside it
+    // closes it; the toggle follows so the next click on it opens it again.
+    let ui_split = ui.clone();
+    ui.browser.split.connect_show_sidebar_notify(move |split| {
+        let toggle = &ui_split.details.details.toggle;
+        if toggle.is_active() != split.shows_sidebar() {
+            toggle.set_active(split.shows_sidebar());
+        }
    });

    let ui_open = ui.clone();
@@ -204,11 +312,28 @@ pub(crate) fn wire_details(ui: &Rc<Ui>) {
                open_versions_dialog(&ui_versions, &entry);
            }
        });
+    let ui_share = ui.clone();
+    ui.details.details.share_button.connect_clicked(move |_| {
+        let entry = ui_share.details.details_entry.borrow().clone();
+        if let Some(entry) = entry {
+            open_share_dialog(&ui_share, &entry);
+        }
+    });
+    let ui_link = ui.clone();
+    ui.details
+        .details
+        .copy_link_button
+        .connect_clicked(move |_| {
+            let entry = ui_link.details.details_entry.borrow().clone();
+            if let Some(entry) = entry {
+                copy_entry_link(&ui_link, &entry);
+            }
+        });
    let ui_trash = ui.clone();
    ui.details.details.trash_button.connect_clicked(move |_| {
        let entry = ui_trash.details.details_entry.borrow().clone();
        if let Some(entry) = entry {
-            prompt_delete(&ui_trash, &entry);
+            trash_entry(&ui_trash, &entry);
        }
    });
    let ui_pin = ui.clone();
@@ -230,14 +355,17 @@ pub(crate) fn wire_details(ui: &Rc<Ui>) {
        });
 }

-/// Reveal the details pane and paint it from `entry`.
+/// Paint the details pane from `entry`. It shows while the header toggle is on.
 pub(crate) fn show_details(ui: &Rc<Ui>, entry: &DirEntry) {
    ui.details.details_suppress.set(true);
    let d = &ui.details.details;
-    d.icon.set_icon_name(Some(icon_base_for(entry)));
+    d.icon.set_icon_name(Some(icon_for(entry)));
    d.name.set_label(&entry.name);
-    d.kind
-        .set_label(if entry.is_dir { "Folder" } else { "File" });
+    d.kind.set_label(&if entry.is_dir {
+        gettext("Folder")
+    } else {
+        gettext("File")
+    });
    d.size_row.set_subtitle(&if entry.is_dir {
        "—".to_string()
    } else {
@@ -251,39 +379,149 @@ pub(crate) fn show_details(ui: &Rc<Ui>, entry: &DirEntry) {
        Some(i) => &rel[..i],
        None => "",
    };
-    d.path_row.set_subtitle(if parent.is_empty() {
-        "Proton Drive"
+    d.path_row.set_subtitle(&if parent.is_empty() {
+        gettext("Proton Drive")
    } else {
-        parent
+        parent.to_string()
    });
+    // Pinning is per file: the context menu and the selection bar offer it for
+    // files only, so the pane must not offer it for folders either.
    d.pin_row.set_active(entry.pinned);
+    d.pin_row.set_visible(!entry.is_dir);
    d.pin_row.set_sensitive(*ui.mounted.borrow());
-    d.open_button
-        .set_label(if entry.is_dir { "Open folder" } else { "Open" });
+    d.open_button.set_label(&if entry.is_dir {
+        gettext("Open folder")
+    } else {
+        pgettext("verb", "Open")
+    });
    // Only files have revisions, and only a connected daemon can fetch them.
-    d.versions_button.set_visible(!entry.is_dir);
-    d.versions_button.set_sensitive(*ui.mounted.borrow());
+    let mounted = *ui.mounted.borrow();
+    d.versions_group.set_visible(!entry.is_dir);
+    d.versions_button.set_sensitive(mounted);
+    d.share_button.set_sensitive(mounted);
+    d.copy_link_button.set_sensitive(mounted);
+    d.sharing_row.set_subtitle("—");
+    d.versions_row.set_subtitle("—");
    ui.details.details_suppress.set(false);

    *ui.details.details_entry.borrow_mut() = Some(entry.clone());
-    // Reveal the pane on idle, not inline. This runs from `selection_changed`,
-    // which fires on the *first* press of a double-click; mutating the widget
-    // tree here cancels GtkGridView's multi-press tracking, so the second press
-    // restarts the count and `activate` never fires — the folder needs two
-    // double-clicks. Deferring lets the click gesture finish first. Guard on the
-    // entry still being present so a navigation that clears it wins the race.
-    let ui = ui.clone();
-    glib::idle_add_local_once(move || {
-        if ui.details.details_entry.borrow().is_some() {
-            ui.browser.split.set_show_sidebar(true);
+    if mounted {
+        load_details_extras(ui, entry);
+    }
+    // Only the content changes. Whether the pane shows is the toggle's call:
+    // this runs from `selection_changed`, on the *first* press of a
+    // double-click, and sliding the pane in there would move the files so the
+    // second press lands elsewhere and the folder never opens.
+    d.pages.set_visible_child_name("details");
+}
+
+/// Fill the Sharing and Versions rows, which need the network. The answers
+/// land only if the pane still shows the same entry.
+fn load_details_extras(ui: &Rc<Ui>, entry: &DirEntry) {
+    let by_uid = entry.path.is_empty() && !entry.uid.is_empty();
+    let rel = entry_rel(ui, entry);
+    let share_req = if by_uid {
+        Request::ListShareByUid {
+            uid: entry.uid.clone(),
+        }
+    } else {
+        Request::ListShare { path: rel.clone() }
+    };
+    let rx = spawn_request(ui.dirs.control_socket(), share_req);
+    let (ui_c, uid) = (ui.clone(), entry.uid.clone());
+    glib::spawn_future_local(async move {
+        let text = match rx.recv().await {
+            Ok(Ok(Response::Share { entries, link })) => {
+                sharing_summary(entries.len(), link.is_some())
+            }
+            _ => gettext("Couldn't load sharing"),
+        };
+        if details_showing(&ui_c, &uid) {
+            ui_c.details.details.sharing_row.set_subtitle(&text);
+        }
+    });
+
+    if entry.is_dir {
+        return;
+    }
+    let req = if by_uid {
+        Request::ListRevisionsByUid {
+            uid: entry.uid.clone(),
+        }
+    } else {
+        Request::ListRevisions { path: rel }
+    };
+    let rx = spawn_request(ui.dirs.control_socket(), req);
+    let (ui_c, uid) = (ui.clone(), entry.uid.clone());
+    glib::spawn_future_local(async move {
+        let text = match rx.recv().await {
+            Ok(Ok(Response::Revisions { items })) => versions_summary(&items),
+            _ => gettext("Couldn't load versions"),
+        };
+        if details_showing(&ui_c, &uid) {
+            ui_c.details.details.versions_row.set_subtitle(&text);
        }
    });
 }

-/// Hide the details pane and forget the entry it was showing, so a stale entry
-/// can't be acted on after the listing moves on.
-pub(crate) fn hide_details(ui: &Rc<Ui>) {
-    ui.browser.split.set_show_sidebar(false);
+fn details_showing(ui: &Rc<Ui>, uid: &str) -> bool {
+    ui.details
+        .details_entry
+        .borrow()
+        .as_ref()
+        .is_some_and(|e| e.uid == uid)
+}
+
+/// "Only you", "3 people", "Public link" or both.
+pub(crate) fn sharing_summary(people: usize, link: bool) -> String {
+    let n = people as u64;
+    match (people, link) {
+        (0, false) => gettext("Only you"),
+        (0, true) => gettext("Anyone with the link"),
+        (_, false) => ngettext_f("Shared with {n} person", "Shared with {n} people", n, &[]),
+        (_, true) => ngettext_f(
+            "Shared with {n} person · Public link",
+            "Shared with {n} people · Public link",
+            n,
+            &[],
+        ),
+    }
+}
+
+/// "3 versions · latest 2 Sep 2026".
+pub(crate) fn versions_summary(items: &[RevisionInfo]) -> String {
+    let latest = items.iter().map(|r| r.created).max();
+    match (items.len(), latest) {
+        (0, _) | (_, None) => gettext("No earlier versions"),
+        // Translators: {date} is the date of the only version.
+        (1, Some(t)) => gettext_f("1 version · {date}", &[("date", &format_modified(t))]),
+        // Translators: {date} is the date of the newest version.
+        (n, Some(t)) => ngettext_f(
+            "{n} version · latest {date}",
+            "{n} versions · latest {date}",
+            n as u64,
+            &[("date", &format_modified(t))],
+        ),
+    }
+}
+
+/// Show the pane for `entry`, turning the header toggle on.
+pub(crate) fn open_details(ui: &Rc<Ui>, entry: &DirEntry) {
+    ui.details.details.toggle.set_active(true);
+    show_details(ui, entry);
+}
+
+/// Alt+Enter: show or hide the pane for the selected entry.
+pub(crate) fn toggle_details(ui: &Rc<Ui>) {
+    let toggle = &ui.details.details.toggle;
+    toggle.set_active(!toggle.is_active());
+}
+
+/// Forget the entry the pane was showing, so a stale entry can't be acted on
+/// after the listing moves on. An open pane stays open and says nothing is
+/// selected.
+pub(crate) fn clear_details(ui: &Rc<Ui>) {
+    ui.details.details.pages.set_visible_child_name("empty");
    *ui.details.details_entry.borrow_mut() = None;
 }

@@ -293,3 +531,35 @@ pub(crate) fn hide_details(ui: &Rc<Ui>) {
 pub(crate) fn selected_entry(ui: &Rc<Ui>) -> Option<DirEntry> {
    ui.details.details_entry.borrow().clone()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sharing_summary_names_people_and_link() {
+        assert_eq!(sharing_summary(0, false), "Only you");
+        assert_eq!(sharing_summary(0, true), "Anyone with the link");
+        assert_eq!(sharing_summary(1, false), "Shared with 1 person");
+        assert_eq!(
+            sharing_summary(3, true),
+            "Shared with 3 people · Public link"
+        );
+    }
+
+    #[test]
+    fn versions_summary_counts_revisions() {
+        let rev = |created| RevisionInfo {
+            id: String::new(),
+            is_active: false,
+            created,
+            size_on_storage: 0,
+            claimed_size: None,
+            claimed_modified: None,
+            signed_by: None,
+            has_thumbnails: false,
+        };
+        assert_eq!(versions_summary(&[]), "No earlier versions");
+        assert!(versions_summary(&[rev(10), rev(20)]).starts_with("2 versions · latest "));
+    }
+}
@@ -0,0 +1,159 @@
+use crate::*;
+
+/// An action run by an [`ActionMenu`] item.
+pub(crate) type MenuAction = Box<dyn Fn()>;
+
+/// A `gio::Menu` whose items run closures, for menus whose contents depend on
+/// what they were opened for (a row, a selection, a photo). Each item gets its
+/// own action in a private `menu` group, installed on whatever hosts the
+/// popover, so the result is a real [`gtk4::PopoverMenu`]: arrow keys, Enter,
+/// Escape and mnemonics work, and it reads as a menu to assistive technology.
+pub(crate) struct ActionMenu {
+    menu: gio::Menu,
+    section: gio::Menu,
+    group: gio::SimpleActionGroup,
+    count: usize,
+}
+
+impl ActionMenu {
+    pub(crate) fn new() -> Self {
+        Self {
+            menu: gio::Menu::new(),
+            section: gio::Menu::new(),
+            group: gio::SimpleActionGroup::new(),
+            count: 0,
+        }
+    }
+
+    fn next_action(&mut self) -> String {
+        self.count += 1;
+        format!("a{}", self.count)
+    }
+
+    /// A plain item.
+    pub(crate) fn item(&mut self, label: &str, run: impl Fn() + 'static) -> &mut Self {
+        let name = self.next_action();
+        let action = gio::SimpleAction::new(&name, None);
+        action.connect_activate(move |_, _| run());
+        self.group.add_action(&action);
+        self.section
+            .append(Some(label), Some(&format!("menu.{name}")));
+        self
+    }
+
+    /// A check item showing `active`; `run` gets the state the user asked for.
+    pub(crate) fn toggle(
+        &mut self,
+        label: &str,
+        active: bool,
+        run: impl Fn(bool) + 'static,
+    ) -> &mut Self {
+        let name = self.next_action();
+        let action = gio::SimpleAction::new_stateful(&name, None, &active.to_variant());
+        action.connect_activate(move |action, _| {
+            let next = !action
+                .state()
+                .and_then(|s| s.get::<bool>())
+                .unwrap_or(false);
+            action.set_state(&next.to_variant());
+            run(next);
+        });
+        self.group.add_action(&action);
+        self.section
+            .append(Some(label), Some(&format!("menu.{name}")));
+        self
+    }
+
+    /// Close the current section; the next item starts a new one below a
+    /// separator. An empty section is skipped, so callers can end a group of
+    /// conditional items unconditionally.
+    pub(crate) fn section(&mut self) -> &mut Self {
+        self.flush(None);
+        self
+    }
+
+    /// Close the current section under a heading.
+    pub(crate) fn labelled_section(&mut self, heading: &str) -> &mut Self {
+        self.flush(Some(heading));
+        self
+    }
+
+    fn flush(&mut self, heading: Option<&str>) {
+        if self.section.n_items() > 0 {
+            self.menu.append_section(heading, &self.section);
+            self.section = gio::Menu::new();
+        }
+    }
+
+    fn finish(mut self) -> (gio::Menu, gio::SimpleActionGroup) {
+        self.flush(None);
+        (self.menu, self.group)
+    }
+
+    /// Pop the menu up over `anchor` at `(x, y)` in its coordinates. The
+    /// popover removes itself once dismissed; it waits for an idle turn, so the
+    /// item that closed it still finds its action.
+    pub(crate) fn popup_at(self, anchor: &impl IsA<gtk4::Widget>, x: f64, y: f64) {
+        let (menu, group) = self.finish();
+        let anchor = anchor.as_ref();
+        let host = popover_host(anchor);
+        let (x, y) = anchor
+            .compute_point(&host, &gtk4::graphene::Point::new(x as f32, y as f32))
+            .map(|p| (p.x() as f64, p.y() as f64))
+            .unwrap_or((x, y));
+        let popover = gtk4::PopoverMenu::from_model(Some(&menu));
+        popover.set_has_arrow(false);
+        popover.set_position(gtk4::PositionType::Bottom);
+        popover.set_halign(gtk4::Align::Start);
+        popover.set_pointing_to(Some(&gtk4::gdk::Rectangle::new(x as i32, y as i32, 1, 1)));
+        popover.insert_action_group("menu", Some(&group));
+        popover.set_parent(&host);
+        popover.connect_closed(|p| {
+            let p = p.clone();
+            glib::idle_add_local_once(move || p.unparent());
+        });
+        popover.popup();
+    }
+
+    /// A flat ⋮ button that opens this menu.
+    pub(crate) fn button(self) -> gtk4::MenuButton {
+        let (menu, group) = self.finish();
+        let button = gtk4::MenuButton::builder()
+            .icon_name("view-more-symbolic")
+            // Translators: tooltip of a button that opens a menu of further actions.
+            .tooltip_text(gettext("More"))
+            .valign(gtk4::Align::Center)
+            .menu_model(&menu)
+            .build();
+        button.insert_action_group("menu", Some(&group));
+        button.add_css_class("flat");
+        button
+    }
+}
+
+/// Where a menu opened over `anchor` should live in the widget tree: the
+/// outermost grid or list view around it, or `anchor` itself. CSS descendant
+/// selectors reach through a popover to its parent, and themes style the
+/// insides of list items (`gridview > child box { margin: 12px }` in
+/// Catppuccin); a menu parented to a tile picks those rules up and puts a wide
+/// margin around every section. Under the view itself it is no item's child.
+fn popover_host(anchor: &gtk4::Widget) -> gtk4::Widget {
+    let mut host = anchor.clone();
+    let mut widget = anchor.parent();
+    while let Some(w) = widget {
+        widget = w.parent();
+        if w.is::<gtk4::GridView>() || w.is::<gtk4::ListView>() || w.is::<gtk4::ColumnView>() {
+            host = w;
+        }
+    }
+    host
+}
+
+/// A flat ⋮ button whose menu lists `items` as (label, action).
+pub(crate) fn more_menu_button(items: Vec<(&str, MenuAction)>) -> gtk4::MenuButton {
+    let mut menu = ActionMenu::new();
+    for (label, run) in items {
+        menu.item(label, run);
+    }
+    menu.button()
+}
@@ -1,4 +1,5 @@
 pub(crate) mod details;
+pub(crate) mod menu;
 pub(crate) mod share_dialog;
 pub(crate) mod thumbnails;
 pub(crate) mod versions_dialog;
@@ -1,7 +1,19 @@
 use crate::*;

-/// The roles offered in the Share dialog's dropdowns, in index order.
-pub(crate) const SHARE_ROLES: [&str; 3] = ["Viewer", "Editor", "Admin"];
+/// The role labels offered in the Share dialog's dropdowns, in index order.
+pub(crate) fn share_roles() -> [String; 3] {
+    [
+        pgettext("role", "Viewer"),
+        pgettext("role", "Editor"),
+        pgettext("role", "Admin"),
+    ]
+}
+
+/// A dropdown model from translated labels.
+fn string_list(labels: &[String]) -> gtk4::StringList {
+    let labels: Vec<&str> = labels.iter().map(String::as_str).collect();
+    gtk4::StringList::new(&labels)
+}

 /// Map a role dropdown index to the wire role string.
 pub(crate) fn role_index_to_wire(idx: u32) -> &'static str {
@@ -21,6 +33,100 @@ pub(crate) fn role_wire_to_index(role: &str) -> u32 {
    }
 }

+/// The expiry choices offered when creating a public link, in dropdown order,
+/// with their lifetime in days (`None` never expires).
+pub(crate) const LINK_EXPIRY: [(&str, Option<i64>); 4] = [
+    // Translators: a public link that never expires.
+    (gettext_noop("Never"), None),
+    (gettext_noop("1 day"), Some(1)),
+    (gettext_noop("7 days"), Some(7)),
+    (gettext_noop("30 days"), Some(30)),
+];
+
+/// The Unix expiry for a [`LINK_EXPIRY`] choice, counted from `now`.
+pub(crate) fn link_expiry_at(idx: u32, now: i64) -> Option<i64> {
+    LINK_EXPIRY
+        .get(idx as usize)
+        .and_then(|(_, days)| *days)
+        .map(|days| now + days * 86_400)
+}
+
+/// A loose shape check for an email address: one `@` with something before
+/// it and a dotted domain after it. The server does the real validation; this
+/// only catches typos before the Invite button is pressed.
+pub(crate) fn looks_like_email(s: &str) -> bool {
+    let Some((local, domain)) = s.split_once('@') else {
+        return false;
+    };
+    !local.is_empty()
+        && !domain.contains('@')
+        && !s.chars().any(char::is_whitespace)
+        && domain
+            .split_once('.')
+            .is_some_and(|(host, rest)| !host.is_empty() && !rest.is_empty())
+        && !domain.ends_with('.')
+}
+
+/// Split the invite field into addresses. Returns `Err` with the first entry
+/// that doesn't look like an email, and `Ok` with an empty list when the field
+/// is blank.
+pub(crate) fn parse_emails(raw: &str) -> Result<Vec<String>, String> {
+    raw.split([',', ' ', ';'])
+        .map(str::trim)
+        .filter(|s| !s.is_empty())
+        .map(|s| {
+            if looks_like_email(s) {
+                Ok(s.to_string())
+            } else {
+                Err(s.to_string())
+            }
+        })
+        .collect()
+}
+
+/// A button showing a spinner while its request runs. It goes insensitive
+/// on [`Busy::start`] and gets its label or icon back when dropped, so moving
+/// the guard into the request's future ends the busy state on every path.
+pub(crate) struct Busy {
+    button: gtk4::Button,
+    label: Option<glib::GString>,
+    icon: Option<glib::GString>,
+}
+
+impl Busy {
+    pub(crate) fn start(button: &gtk4::Button) -> Self {
+        let label = button.label();
+        let icon = button.icon_name();
+        let spinner = gtk4::Spinner::builder().spinning(true).build();
+        match &label {
+            Some(text) => {
+                let content = gtk4::Box::new(gtk4::Orientation::Horizontal, 6);
+                content.append(&spinner);
+                content.append(&gtk4::Label::new(Some(text)));
+                button.set_child(Some(&content));
+            }
+            None => button.set_child(Some(&spinner)),
+        }
+        button.set_sensitive(false);
+        Self {
+            button: button.clone(),
+            label,
+            icon,
+        }
+    }
+}
+
+impl Drop for Busy {
+    fn drop(&mut self) {
+        if let Some(label) = &self.label {
+            self.button.set_label(label);
+        } else if let Some(icon) = &self.icon {
+            self.button.set_icon_name(icon);
+        }
+        self.button.set_sensitive(true);
+    }
+}
+
 /// How an open Share dialog addresses its node.
 ///
 /// A node the browser is showing has a mountpoint-relative path. A node reached
@@ -94,19 +200,19 @@ impl ShareTarget {
        }
    }

-    fn create_link(&self, role: String, password: Option<String>) -> Request {
+    fn create_link(&self, role: String, password: Option<String>, expires: Option<i64>) -> Request {
        match self {
            ShareTarget::Path(path) => Request::CreatePublicLink {
                path: path.clone(),
                role,
                password,
-                expires: None,
+                expires,
            },
            ShareTarget::Uid(uid) => Request::CreatePublicLinkByUid {
                uid: uid.clone(),
                role,
                password,
-                expires: None,
+                expires,
            },
        }
    }
@@ -142,7 +248,11 @@ pub(crate) struct ShareDialog {
 /// access and their roles, and create/copy/remove a public link.
 pub(crate) fn open_share_dialog(ui: &Rc<Ui>, entry: &DirEntry) {
    if !*ui.mounted.borrow() {
-        toast_error(ui, "Can't share", "Proton Drive isn't connected.");
+        toast_error(
+            ui,
+            &gettext("Can't share"),
+            &gettext("Proton Drive isn't connected."),
+        );
        return;
    }
    // A node with no path is not a bug here: Shared and Shared-with-me list
@@ -155,30 +265,40 @@ pub(crate) fn open_share_dialog(ui: &Rc<Ui>, entry: &DirEntry) {

    let toolbar = adw::ToolbarView::new();
    let header = adw::HeaderBar::new();
-    header.set_title_widget(Some(&adw::WindowTitle::new("Share", &entry.name)));
+    header.set_title_widget(Some(&adw::WindowTitle::new(
+        &pgettext("verb", "Share"),
+        &entry.name,
+    )));
    toolbar.add_top_bar(&header);

    // Invite section: emails + role + optional message.
    let invite_group = adw::PreferencesGroup::builder()
-        .title("Invite people")
-        .description("Proton and non-Proton email addresses, separated by spaces or commas.")
+        .title(gettext("Invite people"))
+        .description(gettext(
+            "Proton and non-Proton email addresses, separated by spaces or commas.",
+        ))
        .build();
-    let email_row = adw::EntryRow::builder().title("Email addresses").build();
-    let role_model = gtk4::StringList::new(&SHARE_ROLES);
+    let email_row = adw::EntryRow::builder()
+        .title(gettext("Email addresses"))
+        .build();
+    let role_model = string_list(&share_roles());
    let role_drop = gtk4::DropDown::builder()
        .model(&role_model)
        .selected(0)
        .valign(gtk4::Align::Center)
        .build();
-    let role_wrap = adw::ActionRow::builder().title("Role").build();
+    let role_wrap = adw::ActionRow::builder().title(gettext("Role")).build();
    role_wrap.add_suffix(&role_drop);
-    let message_row = adw::EntryRow::builder().title("Message (optional)").build();
+    let message_row = adw::EntryRow::builder()
+        .title(gettext("Message (optional)"))
+        .build();
    let invite_btn = gtk4::Button::builder()
-        .label("Send Invitations")
+        .label(gettext("Send Invitations"))
        .halign(gtk4::Align::End)
        .margin_top(6)
        .build();
    invite_btn.add_css_class("suggested-action");
+    invite_btn.set_sensitive(false);
    let invite_wrap = adw::PreferencesRow::builder()
        .activatable(false)
        .child(&invite_btn)
@@ -189,10 +309,10 @@ pub(crate) fn open_share_dialog(ui: &Rc<Ui>, entry: &DirEntry) {
    invite_group.add(&invite_wrap);

    let people = adw::PreferencesGroup::builder()
-        .title("People with access")
+        .title(gettext("People with access"))
        .build();
    let link_group = adw::PreferencesGroup::builder()
-        .title("Public link")
+        .title(gettext("Public link"))
        .build();

    let content = gtk4::Box::new(gtk4::Orientation::Vertical, 18);
@@ -212,7 +332,7 @@ pub(crate) fn open_share_dialog(ui: &Rc<Ui>, entry: &DirEntry) {
    toolbar.set_content(Some(&scroll));

    let dialog = adw::Dialog::builder()
-        .title("Share")
+        .title(pgettext("verb", "Share"))
        .content_width(480)
        .content_height(560)
        .child(&toolbar)
@@ -227,6 +347,29 @@ pub(crate) fn open_share_dialog(ui: &Rc<Ui>, entry: &DirEntry) {
        link_rows: RefCell::new(Vec::new()),
    });

+    // Check the addresses as they are typed: a malformed one marks the row as
+    // an error and keeps the Invite button off, so a typo never reaches the
+    // server as a failed invitation.
+    let btn = invite_btn.clone();
+    email_row.connect_changed(move |row| {
+        let parsed = parse_emails(&row.text());
+        match &parsed {
+            Err(bad) => {
+                row.add_css_class("error");
+                // Translators: {text} is what the user typed in place of an email address.
+                row.set_tooltip_text(Some(&gettext_f(
+                    "“{text}” isn't an email address",
+                    &[("text", bad)],
+                )));
+            }
+            Ok(_) => {
+                row.remove_css_class("error");
+                row.set_tooltip_text(None);
+            }
+        }
+        btn.set_sensitive(parsed.is_ok_and(|emails| !emails.is_empty()));
+    });
+
    // Enter in either free-text field sends the invitations, no mouse needed.
    let btn = invite_btn.clone();
    email_row.connect_entry_activated(move |_| btn.emit_clicked());
@@ -235,16 +378,15 @@ pub(crate) fn open_share_dialog(ui: &Rc<Ui>, entry: &DirEntry) {

    // Invite button.
    let state_inv = state.clone();
-    invite_btn.connect_clicked(move |_| {
-        let raw = email_row.text();
-        let emails: Vec<String> = raw
-            .split([',', ' ', ';'])
-            .map(str::trim)
-            .filter(|s| !s.is_empty())
-            .map(str::to_string)
-            .collect();
+    invite_btn.connect_clicked(move |btn| {
+        // Enter in a field reaches here even while the button is off.
+        if !btn.is_sensitive() {
+            return;
+        }
+        let Ok(emails) = parse_emails(&email_row.text()) else {
+            return;
+        };
        if emails.is_empty() {
-            toast_error(&state_inv.ui, "Couldn't share", "Enter at least one email.");
            return;
        }
        let role = role_index_to_wire(role_drop.selected()).to_string();
@@ -255,8 +397,9 @@ pub(crate) fn open_share_dialog(ui: &Rc<Ui>, entry: &DirEntry) {
        share_dialog_op(
            &state_inv,
            state_inv.target.invite(emails, role, message),
-            "Invitations sent",
-            "Couldn't send invitations",
+            &gettext("Invitations sent"),
+            &gettext("Couldn't send invitations"),
+            Some(Busy::start(btn)),
            Some(Box::new(move || {
                email_clear.set_text("");
                msg_clear.set_text("");
@@ -279,12 +422,12 @@ pub(crate) fn share_dialog_reload(state: &Rc<ShareDialog>) {
                repaint_share_link(&state, link.as_ref());
            }
            Ok(Ok(Response::Error { message, .. })) => {
-                toast_error(&state.ui, "Couldn't load sharing", &message)
+                toast_error(&state.ui, &gettext("Couldn't load sharing"), &message)
            }
            _ => toast_error(
                &state.ui,
-                "Couldn't load sharing",
-                "The mount service didn't respond.",
+                &gettext("Couldn't load sharing"),
+                &gettext("The mount service didn't respond."),
            ),
        }
    });
@@ -297,7 +440,7 @@ pub(crate) fn repaint_share_people(state: &Rc<ShareDialog>, entries: &[ShareEntr
    }
    let mut rows: Vec<gtk4::Widget> = Vec::new();
    if entries.is_empty() {
-        let row = dim_row("No one else has access yet.");
+        let row = dim_row(&gettext("No one else has access yet."));
        state.people.add(&row);
        rows.push(row.upcast());
        *state.people_rows.borrow_mut() = rows;
@@ -305,9 +448,9 @@ pub(crate) fn repaint_share_people(state: &Rc<ShareDialog>, entries: &[ShareEntr
    }
    for entry in entries {
        let subtitle = match entry.kind {
-            ShareEntryKind::Member => "Member".to_string(),
-            ShareEntryKind::ProtonInvite => "Invited (pending)".to_string(),
-            ShareEntryKind::ExternalInvite => "Invited (external, pending)".to_string(),
+            ShareEntryKind::Member => gettext("Member"),
+            ShareEntryKind::ProtonInvite => gettext("Invited (pending)"),
+            ShareEntryKind::ExternalInvite => gettext("Invited (external, pending)"),
        };
        let row = adw::ActionRow::builder()
            .title(&entry.email)
@@ -320,7 +463,7 @@ pub(crate) fn repaint_share_people(state: &Rc<ShareDialog>, entries: &[ShareEntr
            entry.kind,
            ShareEntryKind::Member | ShareEntryKind::ProtonInvite
        ) {
-            let model = gtk4::StringList::new(&SHARE_ROLES);
+            let model = string_list(&share_roles());
            let drop = gtk4::DropDown::builder()
                .model(&model)
                .selected(role_wire_to_index(&entry.role))
@@ -337,15 +480,16 @@ pub(crate) fn repaint_share_people(state: &Rc<ShareDialog>, entries: &[ShareEntr
                        kind,
                        role_index_to_wire(d.selected()).to_string(),
                    ),
-                    "Role updated",
-                    "Couldn't update the role",
+                    &gettext("Role updated"),
+                    &gettext("Couldn't update the role"),
+                    None,
                    None,
                );
            });
            row.add_suffix(&drop);
        } else {
            let label = gtk4::Label::builder()
-                .label(capitalize(&entry.role))
+                .label(role_label(&entry.role).unwrap_or_else(|| capitalize(&entry.role)))
                .valign(gtk4::Align::Center)
                .build();
            label.add_css_class("dim-label");
@@ -354,20 +498,37 @@ pub(crate) fn repaint_share_people(state: &Rc<ShareDialog>, entries: &[ShareEntr

        let remove = gtk4::Button::builder()
            .icon_name("user-trash-symbolic")
-            .tooltip_text("Remove access")
+            .tooltip_text(gettext("Remove access"))
            .valign(gtk4::Align::Center)
            .build();
        remove.add_css_class("flat");
        let state_rm = state.clone();
        let id = entry.id.clone();
        let kind = entry.kind;
-        remove.connect_clicked(move |_| {
-            share_dialog_op(
-                &state_rm,
-                state_rm.target.remove_entry(id.clone(), kind),
-                "Access removed",
-                "Couldn't remove access",
-                None,
+        let who = entry.email.clone();
+        remove.connect_clicked(move |btn| {
+            let state = state_rm.clone();
+            let id = id.clone();
+            let button = btn.clone();
+            confirm_destructive(
+                btn,
+                &gettext("Remove Access?"),
+                // Translators: {email} is the address of the person losing access.
+                &gettext_f(
+                    "{email} will no longer be able to open this item.",
+                    &[("email", &who)],
+                ),
+                &gettext("Remove"),
+                move || {
+                    share_dialog_op(
+                        &state,
+                        state.target.remove_entry(id.clone(), kind),
+                        &gettext("Access removed"),
+                        &gettext("Couldn't remove access"),
+                        Some(Busy::start(&button)),
+                        None,
+                    );
+                },
            );
        });
        row.add_suffix(&remove);
@@ -389,13 +550,23 @@ pub(crate) fn repaint_share_link(state: &Rc<ShareDialog>, link: Option<&PublicLi
    match link {
        Some(link) => {
            let url = link.url.clone().unwrap_or_default();
-            let subtitle = if link.has_password {
-                format!("Anyone with the link ({}) · password-protected", link.role)
-            } else {
-                format!("Anyone with the link ({})", link.role)
-            };
+            let role = role_label(&link.role).unwrap_or_else(|| capitalize(&link.role));
+            // Translators: {role} is the link's role, such as "Viewer".
+            let mut subtitle = gettext_f("Anyone with the link ({role})", &[("role", &role)]);
+            if link.has_password {
+                subtitle.push_str(" · ");
+                subtitle.push_str(&gettext("password-protected"));
+            }
+            if let Some(expires) = link.expires {
+                subtitle.push_str(" · ");
+                subtitle.push_str(&link_expiry_label(expires, glib::real_time() / 1_000_000));
+            }
            let row = adw::ActionRow::builder()
-                .title(if url.is_empty() { "Public link" } else { &url })
+                .title(if url.is_empty() {
+                    gettext("Public link")
+                } else {
+                    url.clone()
+                })
                .subtitle(&subtitle)
                .build();
            row.add_css_class("property");
@@ -403,7 +574,7 @@ pub(crate) fn repaint_share_link(state: &Rc<ShareDialog>, link: Option<&PublicLi
            if !url.is_empty() {
                let copy = gtk4::Button::builder()
                    .icon_name("edit-copy-symbolic")
-                    .tooltip_text("Copy link")
+                    .tooltip_text(gettext("Copy link"))
                    .valign(gtk4::Align::Center)
                    .build();
                copy.add_css_class("flat");
@@ -411,26 +582,38 @@ pub(crate) fn repaint_share_link(state: &Rc<ShareDialog>, link: Option<&PublicLi
                let url_copy = url.clone();
                copy.connect_clicked(move |btn| {
                    btn.clipboard().set_text(&url_copy);
-                    toast(&state_copy.ui, "Link copied");
+                    toast(&state_copy.ui, &gettext("Link copied"));
                });
                row.add_suffix(&copy);
            }

            let remove = gtk4::Button::builder()
                .icon_name("user-trash-symbolic")
-                .tooltip_text("Remove link")
+                .tooltip_text(gettext("Remove link"))
                .valign(gtk4::Align::Center)
                .build();
            remove.add_css_class("flat");
            let state_rm = state.clone();
            let id = link.id.clone();
-            remove.connect_clicked(move |_| {
-                share_dialog_op(
-                    &state_rm,
-                    state_rm.target.remove_link(id.clone()),
-                    "Public link removed",
-                    "Couldn't remove the link",
-                    None,
+            remove.connect_clicked(move |btn| {
+                let state = state_rm.clone();
+                let id = id.clone();
+                let button = btn.clone();
+                confirm_destructive(
+                    btn,
+                    &gettext("Remove Public Link?"),
+                    &gettext("The link stops working for everyone who has it. A new link will have a different address."),
+                    &gettext("Remove Link"),
+                    move || {
+                        share_dialog_op(
+                            &state,
+                            state.target.remove_link(id.clone()),
+                            &gettext("Public link removed"),
+                            &gettext("Couldn't remove the link"),
+                            Some(Busy::start(&button)),
+                            None,
+                        );
+                    },
                );
            });
            row.add_suffix(&remove);
@@ -439,19 +622,30 @@ pub(crate) fn repaint_share_link(state: &Rc<ShareDialog>, link: Option<&PublicLi
            rows.push(row.upcast());
        }
        None => {
-            let role_model = gtk4::StringList::new(&["Viewer", "Editor"]);
+            let role_model = string_list(&[pgettext("role", "Viewer"), pgettext("role", "Editor")]);
            let role_drop = gtk4::DropDown::builder()
                .model(&role_model)
                .selected(0)
                .valign(gtk4::Align::Center)
                .build();
-            let role_row = adw::ActionRow::builder().title("Link role").build();
+            let role_row = adw::ActionRow::builder()
+                .title(gettext("Link role"))
+                .build();
            role_row.add_suffix(&role_drop);
            let pw_row = adw::PasswordEntryRow::builder()
-                .title("Password (optional)")
+                .title(gettext("Password (optional)"))
                .build();
+            let expiry_names: Vec<String> =
+                LINK_EXPIRY.iter().map(|(name, _)| gettext(name)).collect();
+            let expiry_drop = gtk4::DropDown::builder()
+                .model(&string_list(&expiry_names))
+                .selected(0)
+                .valign(gtk4::Align::Center)
+                .build();
+            let expiry_row = adw::ActionRow::builder().title(gettext("Expires")).build();
+            expiry_row.add_suffix(&expiry_drop);
            let create = gtk4::Button::builder()
-                .label("Create Public Link")
+                .label(gettext("Create Public Link"))
                .halign(gtk4::Align::End)
                .margin_top(6)
                .build();
@@ -467,7 +661,10 @@ pub(crate) fn repaint_share_link(state: &Rc<ShareDialog>, link: Option<&PublicLi

            let state_c = state.clone();
            let pw_for = pw_row.clone();
-            create.connect_clicked(move |_| {
+            create.connect_clicked(move |btn| {
+                if !btn.is_sensitive() {
+                    return;
+                }
                let role = if role_drop.selected() == 1 {
                    "editor"
                } else {
@@ -476,14 +673,17 @@ pub(crate) fn repaint_share_link(state: &Rc<ShareDialog>, link: Option<&PublicLi
                .to_string();
                let pw = pw_for.text().to_string();
                let password = if pw.is_empty() { None } else { Some(pw) };
-                share_dialog_create_link(&state_c, role, password);
+                let expires = link_expiry_at(expiry_drop.selected(), glib::real_time() / 1_000_000);
+                share_dialog_create_link(&state_c, role, password, expires, Busy::start(btn));
            });

            state.link_group.add(&role_row);
            state.link_group.add(&pw_row);
+            state.link_group.add(&expiry_row);
            state.link_group.add(&create_wrap);
            rows.push(role_row.upcast());
            rows.push(pw_row.upcast());
+            rows.push(expiry_row.upcast());
            rows.push(create_wrap.upcast());
        }
    }
@@ -496,57 +696,132 @@ pub(crate) fn share_dialog_create_link(
    state: &Rc<ShareDialog>,
    role: String,
    password: Option<String>,
+    expires: Option<i64>,
+    busy: Busy,
 ) {
    let rx = spawn_request(
        state.ui.dirs.control_socket(),
-        state.target.create_link(role, password),
+        state.target.create_link(role, password, expires),
    );
    let state = state.clone();
    glib::spawn_future_local(async move {
-        match rx.recv().await {
+        let reply = rx.recv().await;
+        drop(busy);
+        match reply {
            Ok(Ok(Response::PublicLink { .. })) => {
-                toast(&state.ui, "Public link created");
+                toast(&state.ui, &gettext("Public link created"));
                share_dialog_reload(&state);
            }
            Ok(Ok(Response::Error { message, .. })) => {
-                toast_error(&state.ui, "Couldn't create the link", &message)
+                toast_error(&state.ui, &gettext("Couldn't create the link"), &message)
            }
            _ => toast_error(
                &state.ui,
-                "Couldn't create the link",
-                "The mount service didn't respond.",
+                &gettext("Couldn't create the link"),
+                &gettext("The mount service didn't respond."),
            ),
        }
    });
 }

 /// Run a Share-dialog mutation, then reload the dialog on success. `on_success`
-/// runs an extra UI tweak (e.g. clearing the invite fields) before the reload.
+/// runs an extra UI tweak (e.g. clearing the invite fields) before the reload;
+/// `busy` keeps the button that started it spinning until the reply arrives.
 pub(crate) fn share_dialog_op(
    state: &Rc<ShareDialog>,
    req: Request,
-    done: &'static str,
-    failed: &'static str,
+    done: &str,
+    failed: &str,
+    busy: Option<Busy>,
    on_success: Option<Box<dyn Fn()>>,
 ) {
    let rx = spawn_request(state.ui.dirs.control_socket(), req);
    let state = state.clone();
+    let (done, failed) = (done.to_string(), failed.to_string());
    glib::spawn_future_local(async move {
-        match rx.recv().await {
+        let reply = rx.recv().await;
+        drop(busy);
+        match reply {
            Ok(Ok(Response::Ok { .. })) => {
                if let Some(cb) = on_success {
                    cb();
                }
-                toast(&state.ui, done);
+                toast(&state.ui, &done);
                share_dialog_reload(&state);
            }
-            Ok(Ok(Response::Error { message, .. })) => toast_error(&state.ui, failed, &message),
+            Ok(Ok(Response::Error { message, .. })) => toast_error(&state.ui, &failed, &message),
            _ => {
                // A role dropdown that failed is now out of sync with the server;
                // reload to snap it back.
-                toast_error(&state.ui, failed, "The mount service didn't respond.");
+                toast_error(
+                    &state.ui,
+                    &failed,
+                    &gettext("The mount service didn't respond."),
+                );
                share_dialog_reload(&state);
            }
        }
    });
 }
+
+/// How an existing link's expiry reads in its subtitle: the date it stops
+/// working, or that it already has.
+pub(crate) fn link_expiry_label(expires: i64, now: i64) -> String {
+    if expires <= now {
+        // Translators: a public link past its expiry date.
+        return gettext("expired");
+    }
+    // Translators: strftime format for a link's expiry date; "%x" is the locale's date, such as "09/23/26".
+    let format = gettext("%x");
+    let date = glib::DateTime::from_unix_local(expires)
+        .ok()
+        .and_then(|at| at.format(&format).ok())
+        .map(|s| s.to_string())
+        .unwrap_or_default();
+    // Translators: {date} is the date a public link stops working.
+    gettext_f("expires {date}", &[("date", &date)])
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn email_check_accepts_plain_addresses() {
+        assert!(looks_like_email("a@b.co"));
+        assert!(looks_like_email("first.last+tag@mail.example.org"));
+    }
+
+    #[test]
+    fn email_check_rejects_typos() {
+        for bad in [
+            "a", "a@", "@b.co", "a@b", "a@b.", "a@.co", "a@@b.co", "a@b@c.co",
+        ] {
+            assert!(!looks_like_email(bad), "{bad}");
+        }
+    }
+
+    #[test]
+    fn parse_emails_splits_and_reports_first_bad_entry() {
+        assert_eq!(
+            parse_emails("a@b.co, c@d.org;e@f.net"),
+            Ok(vec!["a@b.co".into(), "c@d.org".into(), "e@f.net".into()])
+        );
+        assert_eq!(parse_emails("  ,  "), Ok(vec![]));
+        assert_eq!(parse_emails("a@b.co oops"), Err("oops".into()));
+    }
+
+    #[test]
+    fn link_expiry_counts_days_from_now() {
+        assert_eq!(link_expiry_at(0, 1_000), None);
+        assert_eq!(link_expiry_at(1, 1_000), Some(1_000 + 86_400));
+        assert_eq!(link_expiry_at(3, 0), Some(30 * 86_400));
+        assert_eq!(link_expiry_at(99, 0), None);
+    }
+
+    #[test]
+    fn past_expiry_reads_expired() {
+        assert_eq!(link_expiry_label(10, 20), "expired");
+        assert!(link_expiry_label(2_000_000_000, 0).starts_with("expires "));
+    }
+}
@@ -173,7 +173,7 @@ pub(crate) fn bind_file_thumbnail(
    let fallback_name = if symbolic_fallback {
        format!("{}-symbolic", icon_base_for(entry))
    } else {
-        icon_base_for(entry).to_string()
+        icon_for(entry).to_string()
    };
    fallback.set_icon_name(Some(&fallback_name));
    fallback.set_visible(true);
@@ -85,11 +85,19 @@ pub(crate) struct VersionsDialog {
 /// Open the Versions dialog for a file.
 pub(crate) fn open_versions_dialog(ui: &Rc<Ui>, entry: &DirEntry) {
    if !*ui.mounted.borrow() {
-        toast_error(ui, "Can't load versions", "Proton Drive isn't connected.");
+        toast_error(
+            ui,
+            &gettext("Can't load versions"),
+            &gettext("Proton Drive isn't connected."),
+        );
        return;
    }
    if entry.is_dir {
-        toast_error(ui, "No versions", "Folders don't have versions.");
+        toast_error(
+            ui,
+            &gettext("No versions"),
+            &gettext("Folders don't have versions."),
+        );
        return;
    }
    let target = if entry.path.is_empty() {
@@ -100,12 +108,17 @@ pub(crate) fn open_versions_dialog(ui: &Rc<Ui>, entry: &DirEntry) {

    let toolbar = adw::ToolbarView::new();
    let header = adw::HeaderBar::new();
-    header.set_title_widget(Some(&adw::WindowTitle::new("Versions", &entry.name)));
+    header.set_title_widget(Some(&adw::WindowTitle::new(
+        &gettext("Versions"),
+        &entry.name,
+    )));
    toolbar.add_top_bar(&header);

    let group = adw::PreferencesGroup::builder()
-        .title("Version history")
-        .description("Proton Drive keeps earlier versions of a file until you delete them.")
+        .title(gettext("Version history"))
+        .description(gettext(
+            "Proton Drive keeps earlier versions of a file until you delete them.",
+        ))
        .build();

    let content = gtk4::Box::new(gtk4::Orientation::Vertical, 18);
@@ -123,7 +136,7 @@ pub(crate) fn open_versions_dialog(ui: &Rc<Ui>, entry: &DirEntry) {
    toolbar.set_content(Some(&scroll));

    let dialog = adw::Dialog::builder()
-        .title("Versions")
+        .title(gettext("Versions"))
        .content_width(520)
        .content_height(520)
        .child(&toolbar)
@@ -149,12 +162,12 @@ pub(crate) fn versions_dialog_reload(state: &Rc<VersionsDialog>) {
        match rx.recv().await {
            Ok(Ok(Response::Revisions { items })) => repaint_versions(&state, &items),
            Ok(Ok(Response::Error { message, .. })) => {
-                toast_error(&state.ui, "Couldn't load versions", &message)
+                toast_error(&state.ui, &gettext("Couldn't load versions"), &message)
            }
            _ => toast_error(
                &state.ui,
-                "Couldn't load versions",
-                "The mount service didn't respond.",
+                &gettext("Couldn't load versions"),
+                &gettext("The mount service didn't respond."),
            ),
        }
    });
@@ -167,7 +180,7 @@ fn repaint_versions(state: &Rc<VersionsDialog>, items: &[RevisionInfo]) {
    }
    let mut rows: Vec<gtk4::Widget> = Vec::new();
    if items.is_empty() {
-        let row = dim_row("No earlier versions.");
+        let row = dim_row(&gettext("No earlier versions."));
        state.group.add(&row);
        rows.push(row.upcast());
        *state.rows.borrow_mut() = rows;
@@ -182,16 +195,27 @@ fn repaint_versions(state: &Rc<VersionsDialog>, items: &[RevisionInfo]) {
            .filter(|size| *size >= 0)
            .unwrap_or(item.size_on_storage)
            .max(0) as u64;
-        let mut subtitle = format!("{} · {}", activity_time(item.created), human_bytes(size));
+        // A revision id means nothing to a person; name earlier versions by
+        // when they were saved instead.
+        let (title, mut subtitle) = if item.is_active {
+            (
+                gettext("Current version"),
+                // Translators: {time} is when the version was saved, {size} its file size.
+                gettext_f(
+                    "{time} · {size}",
+                    &[
+                        ("time", &activity_time(item.created)),
+                        ("size", &human_bytes(size)),
+                    ],
+                ),
+            )
+        } else {
+            (activity_time(item.created), human_bytes(size))
+        };
        if let Some(email) = &item.signed_by {
            subtitle.push_str(" · ");
            subtitle.push_str(email);
        }
-        let title = if item.is_active {
-            "Current version".to_string()
-        } else {
-            format!("Version {}", item.id)
-        };
        let row = adw::ActionRow::builder()
            .title(title)
            .subtitle(subtitle)
@@ -199,7 +223,7 @@ fn repaint_versions(state: &Rc<VersionsDialog>, items: &[RevisionInfo]) {

        let save = gtk4::Button::builder()
            .icon_name("document-save-symbolic")
-            .tooltip_text("Save a copy…")
+            .tooltip_text(gettext("Save a copy…"))
            .valign(gtk4::Align::Center)
            .build();
        save.add_css_class("flat");
@@ -211,7 +235,7 @@ fn repaint_versions(state: &Rc<VersionsDialog>, items: &[RevisionInfo]) {
        if !item.is_active {
            let restore = gtk4::Button::builder()
                .icon_name("edit-undo-symbolic")
-                .tooltip_text("Restore this version")
+                .tooltip_text(gettext("Restore this version"))
                .valign(gtk4::Align::Center)
                .build();
            restore.add_css_class("flat");
@@ -222,7 +246,7 @@ fn repaint_versions(state: &Rc<VersionsDialog>, items: &[RevisionInfo]) {

            let delete = gtk4::Button::builder()
                .icon_name("user-trash-symbolic")
-                .tooltip_text("Delete this version permanently")
+                .tooltip_text(gettext("Delete this version permanently"))
                .valign(gtk4::Align::Center)
                .build();
            delete.add_css_class("flat");
@@ -242,14 +266,15 @@ fn repaint_versions(state: &Rc<VersionsDialog>, items: &[RevisionInfo]) {
 /// every device on the account, not only this one.
 fn prompt_restore_version(state: &Rc<VersionsDialog>, revision_id: &str) {
    let dialog = adw::AlertDialog::builder()
-        .heading("Restore version")
-        .body(format!(
-            "Make this version the current content of “{}”? The version it replaces stays in the history.",
-            state.name
+        .heading(gettext("Restore version"))
+        // Translators: {name} is a file name.
+        .body(gettext_f(
+            "Make this version the current content of “{name}”? The version it replaces stays in the history.",
+            &[("name", &state.name)],
        ))
        .build();
-    dialog.add_response("cancel", "Cancel");
-    dialog.add_response("restore", "Restore");
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("restore", &pgettext("verb", "Restore"));
    dialog.set_response_appearance("restore", adw::ResponseAppearance::Suggested);
    dialog.set_default_response(Some("cancel"));
    dialog.set_close_response("cancel");
@@ -266,8 +291,8 @@ fn prompt_restore_version(state: &Rc<VersionsDialog>, revision_id: &str) {
            state.target.restore(revision_id.clone()),
            // The server applies the swap in the background, so the wording
            // promises the request, not the result.
-            "Restoring that version",
-            "Couldn't restore that version",
+            &gettext("Restoring that version"),
+            &gettext("Couldn't restore that version"),
        );
    });
    dialog.present(window.as_ref());
@@ -276,11 +301,13 @@ fn prompt_restore_version(state: &Rc<VersionsDialog>, revision_id: &str) {
 /// Confirm, then permanently delete one revision.
 fn prompt_delete_version(state: &Rc<VersionsDialog>, revision_id: &str) {
    let dialog = adw::AlertDialog::builder()
-        .heading("Delete version")
-        .body("Delete this version permanently? Its content can't be recovered.")
+        .heading(gettext("Delete version"))
+        .body(gettext(
+            "Delete this version permanently? Its content can't be recovered.",
+        ))
        .build();
-    dialog.add_response("cancel", "Cancel");
-    dialog.add_response("delete", "Delete");
+    dialog.add_response("cancel", &gettext("Cancel"));
+    dialog.add_response("delete", &pgettext("verb", "Delete"));
    dialog.set_response_appearance("delete", adw::ResponseAppearance::Destructive);
    dialog.set_default_response(Some("cancel"));
    dialog.set_close_response("cancel");
@@ -295,8 +322,8 @@ fn prompt_delete_version(state: &Rc<VersionsDialog>, revision_id: &str) {
        versions_dialog_op(
            &state,
            state.target.delete(revision_id.clone()),
-            "Version deleted",
-            "Couldn't delete that version",
+            &gettext("Version deleted"),
+            &gettext("Couldn't delete that version"),
        );
    });
    dialog.present(window.as_ref());
@@ -310,7 +337,7 @@ fn prompt_delete_version(state: &Rc<VersionsDialog>, revision_id: &str) {
 fn prompt_save_version(state: &Rc<VersionsDialog>, revision_id: &str) {
    let window = ui_window(&state.ui);
    let dialog = gtk4::FileDialog::builder()
-        .title("Save version")
+        .title(gettext("Save version"))
        .initial_name(&state.name)
        .build();
    let state = state.clone();
@@ -320,16 +347,16 @@ fn prompt_save_version(state: &Rc<VersionsDialog>, revision_id: &str) {
        let Some(dest) = file.path().and_then(|p| p.to_str().map(str::to_string)) else {
            toast_error(
                &state.ui,
-                "Couldn't save that version",
-                "That location isn't a local file.",
+                &gettext("Couldn't save that version"),
+                &gettext("That location isn't a local file."),
            );
            return;
        };
        versions_dialog_op(
            &state,
            state.target.save_as(revision_id.clone(), dest),
-            "Version saved",
-            "Couldn't save that version",
+            &gettext("Version saved"),
+            &gettext("Couldn't save that version"),
        );
    });
 }
@@ -347,7 +374,11 @@ fn versions_dialog_op(state: &Rc<VersionsDialog>, request: Request, done: &str,
                versions_dialog_reload(&state);
            }
            Ok(Ok(Response::Error { message, .. })) => toast_error(&state.ui, &failed, &message),
-            _ => toast_error(&state.ui, &failed, "The mount service didn't respond."),
+            _ => toast_error(
+                &state.ui,
+                &failed,
+                &gettext("The mount service didn't respond."),
+            ),
        }
    });
 }
@@ -16,8 +16,8 @@ use pdfs_core::config::AppDirs;
 use pdfs_core::menu::{self, MenuChoice, MenuItem, PromptConfig};
 use pdfs_core::opener::OpenWith;

-use crate::Hit;
 use crate::query;
+use crate::{Hit, gettext, gettext_f};

 /// Guard against a launcher that keeps handing back text we cannot satisfy —
 /// without it a scripted (non-interactive) menu could spin forever.
@@ -90,8 +90,10 @@ pub(crate) fn run(options: Options) -> Result<(), String> {
 /// shows which round you are in.
 fn title(query: Option<&str>) -> String {
    match query {
-        Some(text) => format!("Drive: {text} › "),
-        None => "Search Drive › ".to_string(),
+        // Translators: the launcher prompt while refining a search; {query} is the text searched for. Keep the trailing space.
+        Some(text) => gettext_f("Drive: {query} › ", &[("query", text)]),
+        // Translators: the launcher prompt; keep the trailing space, the input follows it directly.
+        None => gettext("Search Drive › "),
    }
 }

@@ -107,8 +109,10 @@ fn title(query: Option<&str>) -> String {
 /// wording is parenthesised and avoids words that read like a filename query.
 fn placeholder(query: Option<&str>) -> String {
    match query {
-        Some(text) => format!("(no matches for “{text}”)"),
-        None => "(no pinned files — type to search)".to_string(),
+        // Translators: the only row of an empty launcher list; {query} is the text searched for. Keep the parentheses.
+        Some(text) => gettext_f("(no matches for “{query}”)", &[("query", text)]),
+        // Translators: the only row of an empty launcher list. Keep the parentheses, and avoid words that look like a file name.
+        None => gettext("(no pinned files — type to search)"),
    }
 }

@@ -142,6 +146,7 @@ mod tests {
            size: 0,
            modified: 0,
            pinned: false,
+            cached: false,
            uid: "uid".into(),
            mounted_path: None,
            score: 0,
@@ -32,13 +32,14 @@ use pdfs_core::menu::{self, PromptConfig};
 use pdfs_core::opener::OpenWith;

 use crate::query;
-use crate::{Hit, SEARCH_DEBOUNCE};
+use crate::{Hit, SEARCH_DEBOUNCE, gettext, gettext_noop};

 /// Separates the visible half of a feed line from its payload.
 const FIELD: char = '\t';

 /// What the launcher prompt reads, matching the dmenu front end's wording.
-const PROMPT: &str = "Search Drive › ";
+// Translators: the launcher prompt; keep the trailing space, the input follows it directly.
+const PROMPT: &str = gettext_noop("Search Drive › ");

 pub(crate) struct Options {
    /// Search for this immediately instead of opening on the pinned files.
@@ -166,7 +167,8 @@ fn interactive(query: Option<String>) -> Result<(), String> {
 /// empty list with no explanation, so a failure becomes a visible row instead.
 pub(crate) fn feed(query: Option<&str>) {
    let Ok(dirs) = AppDirs::new() else {
-        println!("(cannot resolve app dirs)");
+        // Translators: shown as a row in the search list. Keep the parentheses.
+        println!("{}", gettext("(cannot resolve app dirs)"));
        return;
    };
    let limit = dirs.load_config().resolved_prompt().resolved_menu_limit();
@@ -219,7 +221,7 @@ fn fzf_argv(exe: &std::path::Path, query: Option<&str>) -> Vec<String> {
    .iter()
    .map(|arg| (*arg).to_string())
    .collect();
-    argv.push(format!("--prompt={PROMPT}"));
+    argv.push(format!("--prompt={}", gettext(PROMPT)));
    // `reload:` rather than `reload(…)`: the unparenthesised form runs to the
    // end of the argument, so an install path containing a bracket cannot
    // truncate the command fzf parses out of it.
@@ -268,6 +270,7 @@ mod tests {
            size: 7,
            modified: 9,
            pinned: false,
+            cached: false,
            uid: "uid~1".into(),
            mounted_path: None,
            score: 42,
@@ -0,0 +1,379 @@
+//! Translation layer shared by `pdfs-app`, `pdfs-tray` and `pdfs-prompt`.
+//!
+//! Strings go through GNU gettext in the `pdfs` text domain. [`init`] runs first
+//! in every binary: it applies the language picked in Preferences (if any) on
+//! top of the system locale, then binds the domain to the installed catalogs.
+//!
+//! Messages with values use named placeholders (`{name}`) filled in by
+//! [`gettext_f`] and [`ngettext_f`], so translators can reorder them. `po/`
+//! holds the template and the catalogs; see `docs/TRANSLATING.md`.
+
+// Each binary includes this module and uses a different part of it.
+#![allow(dead_code)]
+
+use gettextrs::LocaleCategory;
+use pdfs_core::config::AppDirs;
+
+/// The gettext text domain, matching `po/pdfs.pot` and the installed `.mo` name.
+pub(crate) const DOMAIN: &str = "pdfs";
+
+/// Overrides the catalog directory at run time, for running from a source tree
+/// (`PDFS_LOCALEDIR=target/locale`).
+const LOCALEDIR_ENV: &str = "PDFS_LOCALEDIR";
+
+/// Where packages install the catalogs unless the build sets `PDFS_LOCALEDIR`.
+const DEFAULT_LOCALEDIR: &str = "/usr/share/locale";
+
+/// Languages the app ships a catalog for, as (gettext code, native name). The
+/// Preferences picker lists them after "System Default". US English is the
+/// source language and needs no catalog. Names stay untranslated so a user can
+/// always find their own language.
+pub(crate) const LANGUAGES: &[(&str, &str)] = &[
+    ("de", "Deutsch"),
+    ("en_GB", "English (UK)"),
+    ("en_US", "English (US)"),
+    ("es", "Español"),
+    ("fr", "Français"),
+    ("it", "Italiano"),
+    ("nl", "Nederlands"),
+    ("pl", "Polski"),
+    ("pt_BR", "Português (Brasil)"),
+];
+
+/// Set up the locale and the text domain. Call first thing in `main`, before
+/// any thread starts: an explicit language is applied through the process
+/// environment, so that GTK's own strings follow it too.
+pub(crate) fn init() {
+    let language = AppDirs::new()
+        .ok()
+        .and_then(|dirs| dirs.load_config().language)
+        .filter(|code| LANGUAGES.iter().any(|(known, _)| known == code));
+    gettextrs::setlocale(LocaleCategory::LcAll, "");
+    if let Some(code) = language {
+        apply_language(&code);
+    }
+    let dir = std::env::var(LOCALEDIR_ENV)
+        .ok()
+        .filter(|dir| !dir.is_empty())
+        .unwrap_or_else(|| {
+            option_env!("PDFS_LOCALEDIR")
+                .unwrap_or(DEFAULT_LOCALEDIR)
+                .to_string()
+        });
+    if let Err(e) = gettextrs::bindtextdomain(DOMAIN, dir) {
+        tracing::warn!("bindtextdomain failed: {e}");
+    }
+    let _ = gettextrs::bind_textdomain_codeset(DOMAIN, "UTF-8");
+    // Country names come translated from the iso-codes catalogs, which live in
+    // the system's own locale directory.
+    let _ = gettextrs::bind_textdomain_codeset(ISO_3166_DOMAIN, "UTF-8");
+    if let Err(e) = gettextrs::textdomain(DOMAIN) {
+        tracing::warn!("textdomain failed: {e}");
+    }
+}
+
+/// The iso-codes text domain that translates ISO 3166-1 country names.
+const ISO_3166_DOMAIN: &str = "iso_3166-1";
+
+/// The name of the country with ISO 3166-1 code `code`, in the user's language.
+/// The English names are the iso-codes project's own, so that project's
+/// catalogs translate them; Kosovo has no ISO code of its own and is
+/// translated here. An unknown code is shown as it is.
+pub(crate) fn country_name(code: &str) -> String {
+    if code == "XK" {
+        return gettext("Kosovo");
+    }
+    match pdfs_core::places::country_name(code) {
+        Some(name) => gettextrs::dgettext(ISO_3166_DOMAIN, name),
+        None => code.to_string(),
+    }
+}
+
+/// Make `code` the message language. gettext reads `LANGUAGE` first, but
+/// ignores it while the message locale is "C" or "C.UTF-8", so a system without
+/// a configured locale also gets its message locale moved to a real one. Both
+/// go into the environment, because GTK calls `setlocale` again during its own
+/// start.
+fn apply_language(code: &str) {
+    // SAFETY: `init` runs at the top of `main`, before any other thread exists.
+    unsafe { std::env::set_var("LANGUAGE", code) };
+    let current = gettextrs::setlocale(LocaleCategory::LcMessages, "")
+        .map(|name| String::from_utf8_lossy(&name).into_owned())
+        .unwrap_or_default();
+    if !is_c_locale(&current) {
+        return;
+    }
+    for candidate in message_locales(code) {
+        if gettextrs::setlocale(LocaleCategory::LcMessages, candidate.as_str()).is_some() {
+            // SAFETY: as above, still single-threaded.
+            unsafe { std::env::set_var("LC_MESSAGES", &candidate) };
+            return;
+        }
+    }
+}
+
+fn is_c_locale(name: &str) -> bool {
+    let base = name.split('.').next().unwrap_or(name);
+    matches!(base, "" | "C" | "POSIX")
+}
+
+/// Locales to try, in order, as the message locale for `code`: the language's
+/// own locale, then US English, which any locale-enabled system has and which
+/// is enough for gettext to honour `LANGUAGE`.
+fn message_locales(code: &str) -> Vec<String> {
+    let full = if code.contains('_') {
+        code.to_string()
+    } else {
+        format!("{code}_{}", code.to_uppercase())
+    };
+    let mut locales = vec![format!("{full}.UTF-8")];
+    if full != "en_US" {
+        locales.push("en_US.UTF-8".to_string());
+    }
+    locales
+}
+
+/// Mark `msgid` for extraction without translating it yet, for tables of
+/// labels built at compile time. Pass the value through [`gettext`] where it is
+/// shown.
+pub(crate) const fn gettext_noop(msgid: &'static str) -> &'static str {
+    msgid
+}
+
+/// Translate `msgid`.
+pub(crate) fn gettext(msgid: &str) -> String {
+    gettextrs::gettext(msgid)
+}
+
+/// Translate `msgid` in context `context`, for short strings whose meaning
+/// depends on where they appear ("Open" the verb against "Open" the state).
+pub(crate) fn pgettext(context: &str, msgid: &str) -> String {
+    gettextrs::pgettext(context, msgid)
+}
+
+/// Translate the singular or plural form for `n`.
+pub(crate) fn ngettext(singular: &str, plural: &str, n: u64) -> String {
+    gettextrs::ngettext(singular, plural, plural_count(n))
+}
+
+/// Translate `msgid`, then fill its `{name}` placeholders from `args`.
+pub(crate) fn gettext_f(msgid: &str, args: &[(&str, &str)]) -> String {
+    fill(&gettext(msgid), args)
+}
+
+/// Translate the form for `n`, then fill `{n}` with the count and the other
+/// placeholders from `args`.
+pub(crate) fn ngettext_f(singular: &str, plural: &str, n: u64, args: &[(&str, &str)]) -> String {
+    let count = n.to_string();
+    let filled = fill(&ngettext(singular, plural, n), args);
+    fill(&filled, &[("n", &count)])
+}
+
+/// The translated form of [`pdfs_core::control::pending_summary`]: what is
+/// still waiting to go up, or `None` when nothing is.
+pub(crate) fn pending_summary(uploads: u64, changes: u64) -> Option<String> {
+    match (uploads, changes) {
+        (0, 0) => None,
+        (uploads, 0) => Some(ngettext_f(
+            "{n} upload queued",
+            "{n} uploads queued",
+            uploads,
+            &[],
+        )),
+        (0, changes) => Some(ngettext_f(
+            "{n} change queued",
+            "{n} changes queued",
+            changes,
+            &[],
+        )),
+        (uploads, changes) => {
+            let uploads = ngettext_f("{n} upload", "{n} uploads", uploads, &[]);
+            let changes = ngettext_f("{n} change", "{n} changes", changes, &[]);
+            // Translators: {uploads} is "3 uploads", {changes} is "2 changes".
+            Some(gettext_f(
+                "{uploads}, {changes} queued",
+                &[("uploads", &uploads), ("changes", &changes)],
+            ))
+        }
+    }
+}
+
+/// gettext takes the count as `u32`. Counts past that pick the same form as
+/// the largest one, which is the plural in every shipped language.
+fn plural_count(n: u64) -> u32 {
+    u32::try_from(n).unwrap_or(u32::MAX)
+}
+
+/// Replace each `{key}` in `template` with its value. Unknown placeholders are
+/// left as they are, so a translation mistake shows up rather than vanishing.
+fn fill(template: &str, args: &[(&str, &str)]) -> String {
+    let mut out = template.to_string();
+    for (key, value) in args {
+        out = out.replace(&format!("{{{key}}}"), value);
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn fill_replaces_named_placeholders_in_any_order() {
+        assert_eq!(
+            fill("{b} before {a}", &[("a", "x"), ("b", "y")]),
+            "y before x"
+        );
+    }
+
+    #[test]
+    fn fill_keeps_unknown_placeholders() {
+        assert_eq!(fill("{missing} {a}", &[("a", "1")]), "{missing} 1");
+    }
+
+    #[test]
+    fn ngettext_f_fills_the_count() {
+        assert_eq!(ngettext_f("{n} file", "{n} files", 1, &[]), "1 file");
+        assert_eq!(
+            ngettext_f(
+                "{n} file in {dir}",
+                "{n} files in {dir}",
+                3,
+                &[("dir", "A")]
+            ),
+            "3 files in A"
+        );
+    }
+
+    #[test]
+    fn pending_summary_matches_the_core_wording() {
+        for (uploads, changes) in [(0, 0), (1, 0), (3, 0), (0, 1), (2, 4)] {
+            assert_eq!(
+                pending_summary(uploads, changes),
+                pdfs_core::control::pending_summary(uploads, changes)
+            );
+        }
+    }
+
+    #[test]
+    fn plural_count_saturates() {
+        assert_eq!(plural_count(7), 7);
+        assert_eq!(plural_count(u64::MAX), u32::MAX);
+    }
+
+    #[test]
+    fn language_codes_are_unique_and_sorted() {
+        let codes: Vec<&str> = LANGUAGES.iter().map(|(code, _)| *code).collect();
+        let mut sorted = codes.clone();
+        sorted.sort_unstable();
+        sorted.dedup();
+        assert_eq!(codes, sorted);
+    }
+
+    fn repo_file(path: &str) -> std::path::PathBuf {
+        std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../..")
+            .join(path)
+    }
+
+    fn linguas() -> Vec<String> {
+        std::fs::read_to_string(repo_file("po/LINGUAS"))
+            .unwrap()
+            .lines()
+            .map(str::trim)
+            .filter(|line| !line.is_empty() && !line.starts_with('#'))
+            .map(str::to_string)
+            .collect()
+    }
+
+    #[test]
+    fn every_offered_language_has_a_catalog() {
+        let linguas = linguas();
+        for (code, _) in LANGUAGES {
+            // US English is the source language.
+            if *code != "en_US" {
+                assert!(
+                    linguas.iter().any(|lang| lang == code),
+                    "{code} is not in po/LINGUAS"
+                );
+            }
+        }
+        for lang in &linguas {
+            assert!(
+                repo_file(&format!("po/{lang}.po")).exists(),
+                "po/{lang}.po is missing"
+            );
+        }
+    }
+
+    #[test]
+    fn potfiles_lists_every_source_that_translates() {
+        let listed = std::fs::read_to_string(repo_file("po/POTFILES.in")).unwrap();
+        let listed: Vec<&str> = listed.lines().map(str::trim).collect();
+        let src = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
+        let mut stack = vec![src];
+        while let Some(dir) = stack.pop() {
+            for entry in std::fs::read_dir(dir).unwrap() {
+                let path = entry.unwrap().path();
+                if path.is_dir() {
+                    stack.push(path);
+                    continue;
+                }
+                if path.extension().is_none_or(|ext| ext != "rs") {
+                    continue;
+                }
+                let text = std::fs::read_to_string(&path).unwrap();
+                if !text.contains("gettext") {
+                    continue;
+                }
+                let relative = path.strip_prefix(env!("CARGO_MANIFEST_DIR")).unwrap();
+                let name = format!("crates/pdfs-gui/{}", relative.display());
+                assert!(
+                    listed.contains(&name.as_str()),
+                    "{name} is not in po/POTFILES.in"
+                );
+            }
+        }
+    }
+
+    /// `msgfmt --check` rejects a translation whose `{placeholders}` differ from
+    /// the English, besides syntax errors. Skipped where gettext is not installed.
+    #[test]
+    fn catalogs_compile_with_matching_placeholders() {
+        let msgfmt = std::process::Command::new("msgfmt")
+            .arg("--version")
+            .output();
+        if msgfmt.is_err() {
+            eprintln!("msgfmt not installed; skipping the catalog check");
+            return;
+        }
+        for lang in linguas() {
+            let output = std::process::Command::new("msgfmt")
+                .args(["--check", "--output-file=/dev/null"])
+                .arg(repo_file(&format!("po/{lang}.po")))
+                .output()
+                .unwrap();
+            assert!(
+                output.status.success(),
+                "po/{lang}.po: {}",
+                String::from_utf8_lossy(&output.stderr)
+            );
+        }
+    }
+
+    #[test]
+    fn c_locales_are_detected() {
+        assert!(is_c_locale("C"));
+        assert!(is_c_locale("POSIX"));
+        assert!(is_c_locale("C.UTF-8"));
+        assert!(is_c_locale("C.utf8"));
+        assert!(!is_c_locale("de_DE.UTF-8"));
+    }
+
+    #[test]
+    fn message_locales_start_with_the_language_region() {
+        assert_eq!(message_locales("de"), ["de_DE.UTF-8", "en_US.UTF-8"]);
+        assert_eq!(message_locales("pt_BR"), ["pt_BR.UTF-8", "en_US.UTF-8"]);
+        assert_eq!(message_locales("en_US"), ["en_US.UTF-8"]);
+    }
+}
@@ -1,14 +1,16 @@
 //! `pdfs-tray` — system-tray front-end for the Proton Drive Linux client.
 //!
-//! Slice 1 of the GUI phase: a StatusNotifierItem (SNI) tray icon with a menu
-//! showing login/mount status and offering mount, unmount, open-folder and quit.
-//! It talks to the running mount daemon over the same control socket the CLI
-//! uses, so the tray is a thin presentation layer over [`pdfs_core::control`].
+//! A StatusNotifierItem (SNI) tray icon whose icon and tooltip say what the
+//! drive is doing (synced, syncing, paused, offline, needs attention), with a
+//! menu to open the app or the folder, pause sync, connect, hide the icon and
+//! stop Proton Drive. It talks to the running mount daemon over the same
+//! control socket the CLI uses, so the tray is a thin presentation layer over
+//! [`pdfs_core::control`]. Anything that needs a dialog opens `pdfs-app`.
 //!
 //! GTK4 has no tray widget (GNOME dropped the systray), so the tray itself is an
-//! SNI item via the `ksni` crate; the GTK4/libadwaita settings window arrives in
-//! a later slice.
+//! SNI item via the `ksni` crate.

+use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::time::Duration;
@@ -16,22 +18,57 @@ use std::time::Duration;
 use anyhow::{Context, Result};
 use ksni::blocking::TrayMethods;
 use ksni::menu::StandardItem;
-use ksni::{MenuItem, Tray};
+use ksni::{MenuItem, Status, ToolTip, Tray};
 use pdfs_core::auth;
 use pdfs_core::config::AppDirs;
-use pdfs_core::control::{
-    JobItem, Request, Response, TransferDirection, TransferItem, pending_summary, send,
-};
+use pdfs_core::control::{JobItem, Request, Response, TransferDirection, TransferItem, send};
 use pdfs_core::service;

+mod i18n;
+use i18n::{gettext, gettext_f, ngettext_f};
+
 /// How often the tray re-polls the daemon to refresh its menu.
 const POLL_INTERVAL: Duration = Duration::from_secs(3);

+/// The one word the icon says about the drive, derived from each poll.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Phase {
+    /// Mounted, online, nothing queued.
+    Synced,
+    /// Mounted with changes queued or bytes moving.
+    Syncing,
+    Paused,
+    /// Mounted but the API is unreachable: cached files only.
+    Offline,
+    /// Changes keep failing; the user has to look.
+    Attention,
+    /// Signed in, but no mount daemon is running.
+    Disconnected,
+    SignedOut,
+}
+
+impl Phase {
+    /// A stock symbolic icon for the phase. Stock names follow the panel's
+    /// theme and colour, and need nothing installed beside the binary.
+    fn icon(self) -> &'static str {
+        match self {
+            Phase::Synced => "folder-remote-symbolic",
+            Phase::Syncing => "emblem-synchronizing-symbolic",
+            Phase::Paused => "media-playback-pause-symbolic",
+            Phase::Offline => "network-offline-symbolic",
+            Phase::Attention => "dialog-warning-symbolic",
+            Phase::Disconnected | Phase::SignedOut => "network-offline-symbolic",
+        }
+    }
+}
+
 /// Snapshot of what the tray knows about the daemon, recomputed each poll.
 #[derive(Clone)]
 struct DriveState {
-    /// Human-readable first menu line ("Mounted at …", "Not running", …).
+    /// Human-readable first menu line ("Mounted at …", "Not running", …), also
+    /// the tooltip.
    line: String,
+    phase: Phase,
    /// Whether a mount daemon is currently serving the control socket.
    mounted: bool,
    /// Mountpoint to act on (from the daemon when mounted, else the default).
@@ -39,6 +76,10 @@ struct DriveState {
    /// One-line sync summary of in-flight transfers, empty when idle. Shown as a
    /// disabled menu line under the status line.
    sync: String,
+    /// Whether the user has sync paused; decides Pause vs Resume.
+    paused: bool,
+    /// Queued changes that keep failing, for the "N issues" item.
+    failing: u64,
 }

 /// Summarise a work snapshot into one menu line, or empty when idle. A single
@@ -49,7 +90,14 @@ struct DriveState {
 fn sync_line(items: &[TransferItem], jobs: &[JobItem]) -> String {
    match items {
        [] => match jobs.first() {
-            Some(j) if j.total > 0 => format!("{} ({} of {})", j.title, j.done, j.total),
+            Some(j) if j.total > 0 => {
+                let (done, total) = (j.done.to_string(), j.total.to_string());
+                // Translators: {title} names a running job such as a scan; {done} and {total} are counts.
+                gettext_f(
+                    "{title} ({done} of {total})",
+                    &[("title", &j.title), ("done", &done), ("total", &total)],
+                )
+            }
            Some(j) => format!("{}…", j.title),
            None => String::new(),
        },
@@ -72,8 +120,10 @@ fn sync_line(items: &[TransferItem], jobs: &[JobItem]) -> String {
                .count();
            let up = items.len() - down;
            match (down, up) {
-                (d, 0) => format!("↓ {d} downloading"),
-                (0, u) => format!("↑ {u} uploading"),
+                // Translators: {n} files are downloading; keep the arrow.
+                (d, 0) => ngettext_f("↓ {n} downloading", "↓ {n} downloading", d as u64, &[]),
+                // Translators: {n} files are uploading; keep the arrow.
+                (0, u) => ngettext_f("↑ {n} uploading", "↑ {n} uploading", u as u64, &[]),
                (d, u) => format!("↓ {d} · ↑ {u}"),
            }
        }
@@ -82,6 +132,7 @@ fn sync_line(items: &[TransferItem], jobs: &[JobItem]) -> String {

 struct DriveTray {
    state: DriveState,
+    socket: PathBuf,
 }

 /// Ask the daemon for its status, falling back to the stored session so the
@@ -94,64 +145,157 @@ fn poll_state(socket: &Path, default_mountpoint: &Path) -> DriveState {
            online,
            pending_uploads,
            pending_changes,
+            failing_ops,
+            paused,
            ..
-        }) => DriveState {
-            line: match (online, pending_summary(pending_uploads, pending_changes)) {
-                (true, None) => format!("Mounted at {mountpoint} ({pinned} pinned)"),
-                (true, Some(q)) => format!("Syncing — {q} ({pinned} pinned)"),
-                (false, None) => format!("Offline — cached files only ({pinned} pinned)"),
-                (false, Some(q)) => format!("Offline — {q}"),
-            },
-            mounted: true,
-            mountpoint: PathBuf::from(mountpoint),
+        }) => {
            // Same daemon is up, so a cheap follow-up poll gives the sync line.
-            sync: match send(socket, &Request::GetQueueStatus) {
+            let sync = match send(socket, &Request::GetQueueStatus) {
                Ok(Response::Transfers { items, jobs }) => sync_line(&items, &jobs),
                _ => String::new(),
-            },
-        },
+            };
+            let queued = i18n::pending_summary(pending_uploads, pending_changes);
+            let phase = phase_of(
+                paused,
+                failing_ops,
+                online,
+                queued.is_some() || !sync.is_empty(),
+            );
+            DriveState {
+                line: match (online, queued) {
+                    _ if paused => gettext("Sync paused"),
+                    _ if failing_ops > 0 => ngettext_f(
+                        "{n} change needs attention",
+                        "{n} changes need attention",
+                        failing_ops,
+                        &[],
+                    ),
+                    // Translators: {mountpoint} is a folder path; {n} is the number of pinned items.
+                    (true, None) => ngettext_f(
+                        "Mounted at {mountpoint} ({n} pinned)",
+                        "Mounted at {mountpoint} ({n} pinned)",
+                        pinned as u64,
+                        &[("mountpoint", &mountpoint)],
+                    ),
+                    // Translators: {queued} is a queue summary such as "3 uploads queued"; {n} is the number of pinned items.
+                    (true, Some(q)) => ngettext_f(
+                        "Syncing — {queued} ({n} pinned)",
+                        "Syncing — {queued} ({n} pinned)",
+                        pinned as u64,
+                        &[("queued", &q)],
+                    ),
+                    // Translators: {n} is the number of pinned items.
+                    (false, None) => ngettext_f(
+                        "Offline — cached files only ({n} pinned)",
+                        "Offline — cached files only ({n} pinned)",
+                        pinned as u64,
+                        &[],
+                    ),
+                    // Translators: {queued} is a queue summary such as "3 uploads queued".
+                    (false, Some(q)) => gettext_f("Offline — {queued}", &[("queued", &q)]),
+                },
+                phase,
+                mounted: true,
+                paused,
+                mountpoint: PathBuf::from(mountpoint),
+                sync,
+                failing: failing_ops,
+            }
+        }
        // Socket answered but with something unexpected — treat as up but odd.
        Ok(_) => DriveState {
-            line: "Mount: unexpected daemon response".into(),
+            line: gettext("Mount: unexpected daemon response"),
+            phase: Phase::Attention,
            mounted: true,
            mountpoint: default_mountpoint.to_path_buf(),
            sync: String::new(),
+            paused: false,
+            failing: 0,
        },
        // No daemon: describe login state instead so the menu is still useful.
        Err(_) => {
-            let line = match auth::load() {
-                Ok(s) => format!("Logged in as {} — not mounted", s.username),
-                Err(pdfs_core::Error::NotLoggedIn) => "Not logged in".into(),
-                Err(e) => format!("Error: {e}"),
+            let (line, phase) = match auth::load() {
+                Ok(s) => (
+                    // Translators: {username} is the Proton account name.
+                    gettext_f(
+                        "Logged in as {username} — not mounted",
+                        &[("username", &s.username)],
+                    ),
+                    Phase::Disconnected,
+                ),
+                Err(pdfs_core::Error::NotLoggedIn) => (gettext("Not signed in"), Phase::SignedOut),
+                Err(e) => (
+                    // Translators: {error} is an error message, in English.
+                    gettext_f("Error: {error}", &[("error", &e.to_string())]),
+                    Phase::Attention,
+                ),
            };
            DriveState {
                line,
+                phase,
                mounted: false,
                mountpoint: default_mountpoint.to_path_buf(),
                sync: String::new(),
+                paused: false,
+                failing: 0,
            }
        }
    }
 }

+/// The phase a running mount is in. A pause is the user's own doing and says
+/// so first; failures outrank everything else the daemon reports.
+fn phase_of(paused: bool, failing: u64, online: bool, busy: bool) -> Phase {
+    if paused {
+        Phase::Paused
+    } else if failing > 0 {
+        Phase::Attention
+    } else if !online {
+        Phase::Offline
+    } else if busy {
+        Phase::Syncing
+    } else {
+        Phase::Synced
+    }
+}
+
+/// "3 issues — View": the menu item that opens the Sync page's queue.
+fn issues_label(failing: u64) -> String {
+    // Translators: a menu item that opens the list of failing changes.
+    ngettext_f("{n} issue — View", "{n} issues — View", failing, &[])
+}
+
 fn open_folder(mountpoint: &Path) {
    pdfs_core::opener::open_default(mountpoint, true);
 }

-/// Launch (or, since it's `SingleMainWindow`, raise) the settings/management
-/// window. The app binary lives next to the tray binary; fall back to the bare
+/// Launch (or, since it's `SingleMainWindow`, raise) the desktop app with
+/// `args`. The app binary lives next to the tray binary; fall back to the bare
 /// name so a PATH install still works.
-fn open_manager() {
+fn open_manager(args: &[&str]) {
    let exe = std::env::current_exe()
        .ok()
        .and_then(|p| p.parent().map(|d| d.join("pdfs-app")))
        .filter(|p| p.exists())
        .unwrap_or_else(|| PathBuf::from("pdfs-app"));
-    if let Err(e) = Command::new(&exe).spawn() {
+    if let Err(e) = Command::new(&exe).args(args).spawn() {
        tracing::error!("failed to launch {}: {e}", exe.display());
    }
 }

+/// Remember that the user hid the icon, so the next login's autostart and the
+/// app both leave it away, then exit.
+fn hide_tray() {
+    if let Ok(dirs) = AppDirs::new() {
+        let mut config = dirs.load_config();
+        config.tray_hidden = true;
+        if let Err(e) = dirs.save_config(&config) {
+            tracing::warn!("hide tray icon: {e}");
+        }
+    }
+    std::process::exit(0);
+}
+
 impl Tray for DriveTray {
    fn id(&self) -> String {
        "io.narl.proton-drive-linux".into()
@@ -162,91 +306,125 @@ impl Tray for DriveTray {
    }

    fn icon_name(&self) -> String {
-        "folder-remote".into()
+        self.state.phase.icon().into()
+    }
+
+    fn status(&self) -> Status {
+        match self.state.phase {
+            Phase::Attention => Status::NeedsAttention,
+            _ => Status::Active,
+        }
+    }
+
+    fn tool_tip(&self) -> ToolTip {
+        let mut description = self.state.line.clone();
+        if !self.state.sync.is_empty() {
+            description = format!("{description}\n{}", self.state.sync);
+        }
+        ToolTip {
+            title: "Proton Drive".into(),
+            description,
+            ..Default::default()
+        }
+    }
+
+    /// A left click opens the app, as it does for most tray icons.
+    fn activate(&mut self, _x: i32, _y: i32) {
+        open_manager(&[]);
    }

    fn menu(&self) -> Vec<MenuItem<Self>> {
        // Value captured into the action closure (which only gets `&mut Self`).
        let open_mp = self.state.mountpoint.clone();
-
-        let mut items: Vec<MenuItem<Self>> = vec![
+        let label = |text: &str| -> MenuItem<Self> {
            StandardItem {
-                label: self.state.line.clone(),
+                label: text.to_string(),
                enabled: false,
                ..Default::default()
            }
-            .into(),
-        ];
-
-        // Live sync status, shown only while something is transferring.
-        if !self.state.sync.is_empty() {
-            items.push(
-                StandardItem {
-                    label: self.state.sync.clone(),
-                    enabled: false,
-                    ..Default::default()
-                }
-                .into(),
-            );
-        }
-
-        items.extend([
-            MenuItem::Separator,
+            .into()
+        };
+        let item = |text: &str, run: fn(&mut Self)| -> MenuItem<Self> {
            StandardItem {
-                label: "Open Manager".into(),
-                activate: Box::new(|_: &mut Self| open_manager()),
+                label: text.to_string(),
+                activate: Box::new(run),
                ..Default::default()
            }
-            .into(),
-        ]);
+            .into()
+        };
+
+        let mut items: Vec<MenuItem<Self>> = vec![label(&self.state.line)];
+        // Live sync status, shown only while something is transferring.
+        if !self.state.sync.is_empty() {
+            items.push(label(&self.state.sync));
+        }
+        if self.state.failing > 0 {
+            items.push(item(&issues_label(self.state.failing), |_| {
+                open_manager(&["--page", "locations"])
+            }));
+        }
+        items.push(MenuItem::Separator);
+
+        match self.state.phase {
+            // Nothing to mount without a session; the app's sign-in page is the
+            // way in.
+            Phase::SignedOut => items.push(item(&gettext("Sign In…"), |_| open_manager(&[]))),
+            _ => items.push(item(&gettext("Open Proton Drive"), |_| open_manager(&[]))),
+        }

        if self.state.mounted {
            items.push(
                StandardItem {
-                    label: "Open folder".into(),
+                    label: gettext("Open Folder"),
                    activate: Box::new(move |_: &mut Self| open_folder(&open_mp)),
                    ..Default::default()
                }
                .into(),
            );
-            // Stop the systemd service (clean SIGTERM → lazy unmount). The next
-            // login or reboot brings it back; this is a deliberate disconnect.
+            // Pause holds uploads back but leaves the mount readable, so it
+            // sits apart from Stop, which takes the whole mount away.
+            let paused = self.state.paused;
            items.push(
                StandardItem {
-                    label: "Disconnect".into(),
+                    label: if paused {
+                        gettext("Resume Sync")
+                    } else {
+                        gettext("Pause Sync")
+                    },
                    activate: Box::new(move |this: &mut Self| {
-                        service::stop();
-                        this.state.mounted = false;
-                        this.state.line = "Disconnecting…".into();
+                        let request = Request::SetSyncPaused {
+                            paused: !paused,
+                            until: None,
+                        };
+                        match send(&this.socket, &request) {
+                            Ok(Response::Ok { .. }) => this.state.paused = !paused,
+                            Ok(other) => tracing::warn!("pause sync: {other:?}"),
+                            Err(e) => tracing::warn!("pause sync: {e}"),
+                        }
                    }),
                    ..Default::default()
                }
                .into(),
            );
-        } else {
+        } else if self.state.phase == Phase::Disconnected {
            // Enable+start the service so it mounts now and on future logins.
-            items.push(
-                StandardItem {
-                    label: "Connect".into(),
-                    activate: Box::new(|this: &mut Self| {
-                        service::enable_start();
-                        this.state.line = "Connecting…".into();
-                    }),
-                    ..Default::default()
-                }
-                .into(),
-            );
+            items.push(item(&gettext("Connect"), |this| {
+                service::enable_start();
+                this.state.line = gettext("Connecting…");
+            }));
        }

        items.push(MenuItem::Separator);
-        items.push(
-            StandardItem {
-                label: "Quit".into(),
-                activate: Box::new(|_: &mut Self| std::process::exit(0)),
-                ..Default::default()
-            }
-            .into(),
-        );
+        items.push(item(&gettext("Hide Tray Icon"), |_| hide_tray()));
+        if self.state.mounted {
+            // Stopping unmounts the drive, so the app asks first; the tray has no
+            // GTK of its own to ask with.
+            items.push(item(&gettext("Stop Proton Drive…"), |_| {
+                open_manager(&["--confirm-stop"])
+            }));
+        } else {
+            items.push(item(&gettext("Quit"), |_| std::process::exit(0)));
+        }
        items
    }
 }
@@ -257,8 +435,15 @@ fn main() -> Result<()> {
            tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| "info".into()),
        )
        .init();
+    i18n::init();

    let dirs = AppDirs::new().context("resolve app dirs")?;
+    // Hidden from its own menu: the session's autostart still runs the tray, and
+    // this is where that choice is kept.
+    if dirs.load_config().tray_hidden {
+        tracing::info!("tray icon is hidden in the config; exiting.");
+        return Ok(());
+    }

    // Ensure only one instance of the tray runs.
    let tray_sock = dirs.tray_socket();
@@ -267,7 +452,7 @@ fn main() -> Result<()> {
        return Ok(());
    }
    let _ = std::fs::remove_file(&tray_sock);
-    let _lock_socket = std::os::unix::net::UnixListener::bind(&tray_sock)
+    let lock_socket = std::os::unix::net::UnixListener::bind(&tray_sock)
        .context("failed to bind tray single-instance socket")?;
    // Owner-only like the control socket (B6). This one only guards single
    // instancing, so a failure is logged rather than fatal — but there is no
@@ -276,11 +461,25 @@ fn main() -> Result<()> {
        tracing::warn!(error = %e, "could not restrict tray socket permissions");
    }

+    // The app asks the tray to leave through its socket, when the user hides
+    // the icon from Preferences or stops Proton Drive.
+    std::thread::spawn(move || {
+        for stream in lock_socket.incoming().flatten() {
+            let mut line = String::new();
+            if BufReader::new(stream).read_line(&mut line).is_ok()
+                && line.trim() == pdfs_core::tray::QUIT
+            {
+                std::process::exit(0);
+            }
+        }
+    });
+
    let socket = dirs.control_socket();
    let default_mountpoint = dirs.default_mountpoint();

    let tray = DriveTray {
        state: poll_state(&socket, &default_mountpoint),
+        socket: socket.clone(),
    };

    // The tray autostarts with the session and can beat the desktop's SNI
@@ -299,3 +498,23 @@ fn main() -> Result<()> {
        handle.update(move |t: &mut DriveTray| t.state = st);
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_pause_outranks_failures_and_failures_outrank_the_rest() {
+        assert_eq!(phase_of(true, 3, false, true), Phase::Paused);
+        assert_eq!(phase_of(false, 3, false, true), Phase::Attention);
+        assert_eq!(phase_of(false, 0, false, true), Phase::Offline);
+        assert_eq!(phase_of(false, 0, true, true), Phase::Syncing);
+        assert_eq!(phase_of(false, 0, true, false), Phase::Synced);
+    }
+
+    #[test]
+    fn the_issues_item_counts_in_the_singular_and_plural() {
+        assert_eq!(issues_label(1), "1 issue — View");
+        assert_eq!(issues_label(4), "4 issues — View");
+    }
+}
@@ -23,6 +23,8 @@ use pdfs_core::menu::PromptMode;
 use pdfs_core::opener::{self, OpenWith};

 mod activation;
+mod i18n;
+use i18n::{gettext, gettext_f, gettext_noop, ngettext_f, pgettext};
 mod dmenu;
 mod fzf;
 mod query;
@@ -51,11 +53,13 @@ enum Filter {

 /// The chip row, in Tab-cycle order.
 const FILTERS: [(Filter, &str); 5] = [
-    (Filter::All, "All"),
-    (Filter::Folders, "Folders"),
-    (Filter::Documents, "Documents"),
-    (Filter::Images, "Images"),
-    (Filter::Media, "Media"),
+    // Translators: a filter chip that shows every kind of result.
+    (Filter::All, gettext_noop("All")),
+    (Filter::Folders, gettext_noop("Folders")),
+    (Filter::Documents, gettext_noop("Documents")),
+    (Filter::Images, gettext_noop("Images")),
+    // Translators: a filter chip for audio and video files.
+    (Filter::Media, gettext_noop("Media")),
 ];

 impl Filter {
@@ -162,9 +166,13 @@ impl Hit {
                None => {
                    let parent = parent_of(&h.path);
                    if parent.is_empty() {
-                        "My files".to_string()
+                        gettext("My files")
                    } else {
-                        format!("My files / {}", parent.replace('/', " / "))
+                        // Translators: {path} is a folder path inside the user's Drive, such as "Work / Taxes".
+                        gettext_f(
+                            "My files / {path}",
+                            &[("path", &parent.replace('/', " / "))],
+                        )
                    }
                }
            },
@@ -425,6 +433,7 @@ fn main() -> glib::ExitCode {
            tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| "info".into()),
        )
        .init();
+    i18n::init();

    let raw: Vec<String> = std::env::args().skip(1).collect();
    if raw.iter().any(|arg| arg == "-h" || arg == "--help") {
@@ -506,7 +515,7 @@ fn build_window(app: &adw::Application) -> Option<Rc<Ui>> {

    let window = adw::ApplicationWindow::builder()
        .application(app)
-        .title("Search Proton Drive")
+        .title(gettext("Search Proton Drive"))
        .default_width(720)
        .default_height(540)
        .resizable(false)
@@ -527,7 +536,7 @@ fn build_window(app: &adw::Application) -> Option<Rc<Ui>> {
    search_bar.append(&search_icon);

    let entry = gtk4::Entry::builder()
-        .placeholder_text("Search in Drive and on this computer")
+        .placeholder_text(gettext("Search in Drive and on this computer"))
        .hexpand(true)
        .build();
    entry.add_css_class("search-entry");
@@ -537,7 +546,8 @@ fn build_window(app: &adw::Application) -> Option<Rc<Ui>> {
    spinner.set_visible(false);
    search_bar.append(&spinner);

-    let esc = gtk4::Label::new(Some("Esc"));
+    // Translators: the Escape key, shown as a hint that it closes the window.
+    let esc = gtk4::Label::new(Some(&gettext("Esc")));
    esc.add_css_class("key-hint");
    search_bar.append(&esc);
    card.append(&search_bar);
@@ -551,9 +561,9 @@ fn build_window(app: &adw::Application) -> Option<Rc<Ui>> {
    let results = gtk4::Box::new(gtk4::Orientation::Vertical, 0);
    results.add_css_class("results");

-    let search_section = Section::new("Best matches", "system-search-symbolic");
+    let search_section = Section::new(&gettext("Best matches"), "system-search-symbolic");
    let drive_section = Section::new("Proton Drive", "folder-remote-symbolic");
-    let local_section = Section::new("This computer", "drive-harddisk-symbolic");
+    let local_section = Section::new(&gettext("This computer"), "drive-harddisk-symbolic");
    search_section.attach(&results);
    drive_section.attach(&results);
    local_section.attach(&results);
@@ -567,7 +577,7 @@ fn build_window(app: &adw::Application) -> Option<Rc<Ui>> {

    let placeholder = adw::StatusPage::builder()
        .icon_name("system-search-symbolic")
-        .title("No results")
+        .title(gettext("No results"))
        .build();
    placeholder.add_css_class("compact");

@@ -575,12 +585,12 @@ fn build_window(app: &adw::Application) -> Option<Rc<Ui>> {
    // is still usable for nothing else, so it owns the whole view.
    let offline = adw::StatusPage::builder()
        .icon_name("network-offline-symbolic")
-        .title("Proton Drive is not running")
-        .description("Start the mount daemon to search your Drive.")
+        .title(gettext("Proton Drive is not running"))
+        .description(gettext("Start the mount daemon to search your Drive."))
        .build();
    offline.add_css_class("compact");
    let retry = gtk4::Button::builder()
-        .label("Retry")
+        .label(gettext("Retry"))
        .halign(gtk4::Align::Center)
        .build();
    retry.add_css_class("pill");
@@ -601,14 +611,15 @@ fn build_window(app: &adw::Application) -> Option<Rc<Ui>> {
    let footer = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
    footer.add_css_class("footer");
    let hint = gtk4::Label::builder()
-        .label("Connecting…")
+        .label(gettext("Connecting…"))
        .xalign(0.0)
        .hexpand(true)
        .ellipsize(gtk4::pango::EllipsizeMode::End)
        .build();
    hint.add_css_class("footer-text");
    footer.append(&hint);
-    let keys = gtk4::Label::new(Some("↑↓ navigate · ↵ open · Tab filter"));
+    // Translators: keyboard hints in the footer; keep the arrow and Enter symbols.
+    let keys = gtk4::Label::new(Some(&gettext("↑↓ navigate · ↵ open · Tab filter")));
    keys.add_css_class("footer-text");
    footer.append(&keys);
    card.append(&footer);
@@ -646,7 +657,7 @@ fn build_window(app: &adw::Application) -> Option<Rc<Ui>> {

    for (filter, label) in FILTERS {
        let chip = gtk4::ToggleButton::builder()
-            .label(label)
+            .label(gettext(label))
            .active(filter == Filter::All)
            .build();
        chip.add_css_class("chip");
@@ -852,7 +863,7 @@ impl Ui {
    /// Ask the daemon for status and, if it answers, load the suggested (pinned)
    /// files. Runs off-thread: a dead daemon must not freeze the first frame.
    fn connect(self: &Rc<Self>) {
-        self.hint.set_label("Connecting…");
+        self.hint.set_label(&gettext("Connecting…"));
        let rx = spawn_request(self.socket.clone(), Request::Status);
        let ui = self.clone();
        glib::spawn_future_local(async move {
@@ -865,7 +876,7 @@ impl Ui {
                }
                _ => {
                    ui.entry.set_sensitive(false);
-                    ui.hint.set_label("Daemon offline");
+                    ui.hint.set_label(&gettext("Daemon offline"));
                    ui.stack.set_visible_child_name("offline");
                }
            }
@@ -879,7 +890,7 @@ impl Ui {
        self.spinner.stop();
        self.spinner.set_visible(false);
        self.entry.set_sensitive(false);
-        self.hint.set_label("Daemon offline");
+        self.hint.set_label(&gettext("Daemon offline"));
        self.stack.set_visible_child_name("offline");
    }

@@ -908,6 +919,7 @@ impl Ui {
                        size: 0,
                        modified: 0,
                        pinned: true,
+                        cached: pin.cached,
                        uid: pin.uid,
                        mounted_path: None,
                        score: 0,
@@ -1071,7 +1083,8 @@ impl Ui {
        visible.extend(local);
        if searching {
            rank_hits(&mut visible);
-            self.search_section.set_rows(&visible, Some("Best matches"));
+            self.search_section
+                .set_rows(&visible, Some(&gettext("Best matches")));
            self.drive_section.set_rows(&[], None);
            self.local_section.set_rows(&[], None);
        } else {
@@ -1080,8 +1093,10 @@ impl Ui {
                .iter()
                .take_while(|hit| matches!(hit, Hit::Drive(_)))
                .count();
-            self.drive_section
-                .set_rows(&visible[..drive_count], Some("Pinned in Proton Drive"));
+            self.drive_section.set_rows(
+                &visible[..drive_count],
+                Some(&gettext("Pinned in Proton Drive")),
+            );
            self.local_section.set_rows(&visible[drive_count..], None);
        }

@@ -1092,18 +1107,20 @@ impl Ui {
        *self.rendered_query.borrow_mut() = query;

        if total == 0 {
-            self.placeholder.set_title(if searching {
-                "No results"
+            self.placeholder.set_title(&if searching {
+                gettext("No results")
            } else {
-                "Search your Drive"
+                gettext("Search your Drive")
            });
            self.placeholder
-                .set_description(Some(match (searching, self.indexing.get()) {
-                    (true, true) => {
-                        "Still indexing this computer — local results will fill in shortly."
-                    }
-                    (true, false) => "Try a different search, or another filter.",
-                    _ => "Start typing to search Proton Drive and the files on this computer.",
+                .set_description(Some(&match (searching, self.indexing.get()) {
+                    (true, true) => gettext(
+                        "Still indexing this computer — local results will fill in shortly.",
+                    ),
+                    (true, false) => gettext("Try a different search, or another filter."),
+                    _ => gettext(
+                        "Start typing to search Proton Drive and the files on this computer.",
+                    ),
                }));
            self.stack.set_visible_child_name("empty");
            self.cursor.set(None);
@@ -1128,18 +1145,23 @@ impl Ui {
    fn status_text(&self, total: usize, searching: bool) -> String {
        if !searching {
            return match total {
-                0 => "No pinned files".to_string(),
-                1 => "1 pinned file".to_string(),
-                n => format!("{n} pinned files"),
+                0 => gettext("No pinned files"),
+                n => ngettext_f("{n} pinned file", "{n} pinned files", n as u64, &[]),
            };
        }
-        let drive = self.drive_count();
-        let local = total - drive;
-        let mut text = format!("{drive} in Drive · {local} on this computer");
+        let drive = self.drive_count().to_string();
+        let local = (total - self.drive_count()).to_string();
+        let args = [("drive", drive.as_str()), ("local", local.as_str())];
        if self.indexing.get() {
-            text.push_str(" · indexing…");
+            // Translators: result counts in the footer while this computer is still being indexed; {drive} and {local} are numbers.
+            gettext_f(
+                "{drive} in Drive · {local} on this computer · indexing…",
+                &args,
+            )
+        } else {
+            // Translators: result counts in the footer; {drive} and {local} are numbers.
+            gettext_f("{drive} in Drive · {local} on this computer", &args)
        }
-        text
    }

    /// Move the cursor by `delta` rows, wrapping at both ends.
@@ -1271,7 +1293,9 @@ impl Ui {
                self.opening.set(true);
                self.spinner.set_visible(true);
                self.spinner.start();
-                self.hint.set_label(&format!("Opening {}…", drive.name));
+                // Translators: {name} is a file name.
+                let opening = gettext_f("Opening {name}…", &[("name", &drive.name)]);
+                self.hint.set_label(&opening);

                let rx = spawn_request(
                    self.socket.clone(),
@@ -1292,9 +1316,13 @@ impl Ui {
                            ui.dismiss();
                        }
                        Ok(Ok(Response::Error { message, .. })) => {
-                            ui.hint.set_label(&format!("Could not open: {message}"));
+                            // Translators: {message} is an error from the daemon, in English.
+                            ui.hint.set_label(&gettext_f(
+                                "Could not open: {message}",
+                                &[("message", &message)],
+                            ));
                        }
-                        _ => ui.hint.set_label("Could not reach the daemon"),
+                        _ => ui.hint.set_label(&gettext("Could not reach the daemon")),
                    }
                });
            }
@@ -1402,8 +1430,10 @@ fn home_relative(parent: &str) -> String {
            .ok()
            .map(|rel| rel.display().to_string())
    }) {
-        Some(rel) if rel.is_empty() => "Home".to_string(),
-        Some(rel) => format!("Home / {}", rel.replace('/', " / ")),
+        // Translators: the user's home folder, as the location of a result.
+        Some(rel) if rel.is_empty() => gettext("Home"),
+        // Translators: {path} is a folder path inside the home folder, folder names separated by " / ".
+        Some(rel) => gettext_f("Home / {path}", &[("path", &rel.replace('/', " / "))]),
        None => parent.to_string(),
    }
 }
@@ -1417,16 +1447,21 @@ fn parent_of(path: &str) -> String {

 fn format_size(bytes: u64) -> String {
    const UNITS: [(u64, &str); 3] = [
-        (1024 * 1024 * 1024, "GB"),
-        (1024 * 1024, "MB"),
-        (1024, "KB"),
+        // Translators: a file size in gigabytes; {size} is a number such as "4.2".
+        (1024 * 1024 * 1024, gettext_noop("{size} GB")),
+        // Translators: a file size in megabytes; {size} is a number such as "4.2".
+        (1024 * 1024, gettext_noop("{size} MB")),
+        // Translators: a file size in kilobytes; {size} is a number such as "4.2".
+        (1024, gettext_noop("{size} KB")),
    ];
    for (scale, unit) in UNITS {
        if bytes >= scale {
-            return format!("{:.1} {unit}", bytes as f64 / scale as f64);
+            let size = format!("{:.1}", bytes as f64 / scale as f64);
+            return gettext_f(unit, &[("size", &size)]);
        }
    }
-    format!("{bytes} B")
+    // Translators: a file size in bytes; {size} is a whole number.
+    gettext_f("{size} B", &[("size", &bytes.to_string())])
 }

 /// Coarse relative age, in the granularity a launcher row has room for.
@@ -1436,12 +1471,18 @@ fn format_age(epoch_secs: i64) -> String {
        .map_or(0, |d| d.as_secs() as i64);
    let diff = now - epoch_secs;
    match diff {
-        d if d < 60 => "now".to_string(),
-        d if d < 3600 => format!("{}m", d / 60),
-        d if d < 86_400 => format!("{}h", d / 3600),
-        d if d < 2_592_000 => format!("{}d", d / 86_400),
-        d if d < 31_536_000 => format!("{}mo", d / 2_592_000),
-        d => format!("{}y", d / 31_536_000),
+        // Translators: the age of a file modified under a minute ago.
+        d if d < 60 => pgettext("age", "now"),
+        // Translators: a compact file age; {count} is a number of minutes.
+        d if d < 3600 => gettext_f("{count}m", &[("count", &(d / 60).to_string())]),
+        // Translators: a compact file age; {count} is a number of hours.
+        d if d < 86_400 => gettext_f("{count}h", &[("count", &(d / 3600).to_string())]),
+        // Translators: a compact file age; {count} is a number of days.
+        d if d < 2_592_000 => gettext_f("{count}d", &[("count", &(d / 86_400).to_string())]),
+        // Translators: a compact file age; {count} is a number of months.
+        d if d < 31_536_000 => gettext_f("{count}mo", &[("count", &(d / 2_592_000).to_string())]),
+        // Translators: a compact file age; {count} is a number of years.
+        d => gettext_f("{count}y", &[("count", &(d / 31_536_000).to_string())]),
    }
 }

@@ -1613,6 +1654,7 @@ mod tests {
                size: 1,
                modified: 1,
                pinned: false,
+                cached: false,
                uid: "v~a".into(),
                mounted_path: None,
                score: 100,
@@ -17,7 +17,7 @@ use pdfs_core::control::{
 use pdfs_core::opener::{self, OpenWith};

 use crate::activation::{DriveActivation, drive_activation, mounted_or_relative, mounted_target};
-use crate::{Hit, file_name, is_document, is_image, is_media, rank_hits};
+use crate::{Hit, file_name, gettext_f, is_document, is_image, is_media, rank_hits};

 /// Where the mount lives, for turning a Drive path into something an
 /// application can open. Falls back to the configured default so a momentarily
@@ -45,6 +45,7 @@ pub(crate) fn pins(socket: &Path) -> Result<Vec<Hit>, String> {
                size: 0,
                modified: 0,
                pinned: true,
+                cached: pin.cached,
                uid: pin.uid,
                mounted_path: None,
                score: 0,
@@ -163,7 +164,13 @@ pub(crate) fn open(
 /// One control-socket round-trip, with the daemon-is-down case phrased for a
 /// terminal rather than a status page.
 pub(crate) fn request(socket: &Path, request: Request) -> Result<Response, String> {
-    send(socket, &request).map_err(|e| format!("cannot reach the Proton Drive daemon: {e}"))
+    send(socket, &request).map_err(|e| {
+        // Translators: shown as a row in the search list; {error} is a system error, in English.
+        gettext_f(
+            "cannot reach the Proton Drive daemon: {error}",
+            &[("error", &e.to_string())],
+        )
+    })
 }

 #[cfg(test)]
@@ -178,6 +185,7 @@ mod tests {
            size: 0,
            modified: 0,
            pinned: false,
+            cached: false,
            uid: "uid".into(),
            mounted_path: None,
            score: 0,
@@ -12,6 +12,176 @@ Conventions:

 ---

+## B99 — Conflict copies in synced folders are logged again on every start and shown as "Resolved"
+
+**Status:** Fixed (unverified). No daemon carrying the change has been restarted against the
+affected copies yet.
+**Found:** 2026-09-27. The Activity page listed the same six conflict copies every day, e.g.
+`Conflict [EMBER] Oshi no Ko S2 - 12 (sync-conflict 1786815864).mkv` with `Differs from … · 24 times
+since Sep 20, 13:13 · Resolved`. `find` showed all six copies still on disk, in `~/Videos` and
+`~/Documents`. Both are on-demand sync folders. `pdfs conflicts` answered `No conflicts.`. The
+journal showed the daemon mounting at 17:29:33, and the entries were stamped 17:30. That is the
+sweep's 30-second warmup.
+
+**Where:** `crates/pdfs-fuse/src/sweep.rs` (`flag_conflict`, `sweep_conflicts_once`),
+`crates/pdfs-fuse/src/conflicts.rs` (`list_conflicts`), `crates/pdfs-fuse/src/control.rs`
+(`ResolveConflict`).
+
+**Cause.** There were two faults.
+
+- The sweep kept its "already flagged" set only in memory. Every daemon start forgot it, so the
+  first pass logged every open conflict again.
+- The sweep flags copies anywhere in the account's own tree. `list_conflicts` only reported copies
+  below My Files, and resolving only accepted paths under the primary mount. A copy in a synced
+  folder was logged but never listed, so the GUI read it as resolved. It also could not be
+  resolved from the GUI or the CLI.
+
+**Fix.** `Core::conflict_path` names a copy by its mountpoint-relative path under My Files, or
+by its absolute local path inside a synced folder. It reuses the roots that search already
+resolves hits through. The listing uses it, and the sweep flags only copies it can name. So the
+feed never holds a conflict the listing cannot answer for. `ResolveConflict` routes an absolute
+path to the on-demand mount that serves it. For a copy in a mirror folder, it says to edit the
+local file instead. Before logging, `flag_conflict` checks the activity log
+(`Db::activity_has`), so a restart does not log the same copy again. The copy's name carries its
+own timestamp, so the name identifies the copy. No schema change.
+Regression test: `activity_has_finds_only_matching_kind_and_target`.
+
+---
+
+## B98 — A superseded upload spins its drain thread forever and shows as "Uploading" at 0 bytes
+
+**Status:** Fixed (unverified) — the daemon carrying the change has not been driven against a
+superseded upload yet.
+**Found:** 2026-09-23. The Sync page showed `Unconfirmed 654050.crdownload — 0 bytes of 23.8 MiB`
+for hours after Brave had finished and renamed the download. `pdfs transfers` listed the same
+entry, `pdfs diagnostics` showed every worker idle, and `/proc/<pid>/task` showed `pdfs-drain-1`
+in state `R` at 100% CPU, holding a deleted staging blob open.
+
+**Where:** `crates/pdfs-fuse/src/transfers.rs` (`CountingReader::read`).
+
+**Cause.** A write that lands while a revision is on the wire cancels that upload through the
+flag `CountingReader` checks before every read. The reader reported the cancel as
+`ErrorKind::Interrupted`. Every read loop treats that kind as "try again", including the SDK's
+`read_full_block`, and the flag never clears, so the loop never ended. The `TransferGuard` was
+never dropped, so the transfer stayed in the registry, and the drain thread was lost until the
+daemon restarted. A browser download is the natural trigger: the `.crdownload` file keeps growing,
+so each new write supersedes the upload of the previous one.
+
+**Fix.** The cancel is reported as `ErrorKind::Other`, which the SDK turns into an error.
+`drain_revision` already recognises a cancelled upload and returns without counting a failure.
+Regression test: `a_cancelled_upload_fails_its_read_instead_of_asking_for_a_retry`.
+
+---
+
+## B97 — Photo refreshes stack up on the control socket, and shutdown turns the resolve pass into a burst of "undecryptable photo" warnings
+
+**Status:** Fixed (unverified) — the daemon carrying the change has not been driven against a real
+library yet.
+**Found:** 2026-09-19, while reading the journal for issues that were still open. `pdfs diagnostics`
+had reported a `Refresh` running for 23 minutes with `in_flight` at 5, and every mount that ended
+in a `systemctl --user restart` was followed by ~95 `skipping undecryptable photo` warnings.
+
+**Where:** `crates/pdfs-fuse/src/control.rs` (`Refresh` handler), `crates/pdfs-fuse/src/photos.rs`
+(`refresh_timeline`), `crates/pdfs-fuse/src/diagnostics.rs` (`request_kind`).
+
+**Cause.** Two unrelated faults with one symptom each.
+
+The stall: every `Refresh` arm is individually cheap — a directory refresh resolves and
+invalidates one listing, a photos refresh clears one state key and spawns the real work — but
+nothing stopped several of them running at once. A front end that asks again while the first
+refresh is still going gets a second handler that does the whole thing again: `invalidate_photos`,
+optionally `photos_mark_all_unresolved` over the entire timeline, `invalidate_albums`. Each of
+those takes the database lock the already-running refresh holds for minutes at a time, so the
+duplicates queue behind it, hold a control handler slot, and appear as a wedged `Refresh`. The
+report could not even say which view was wedged: `request_kind` reads only serde's external tag,
+so all three scopes logged as a bare `Refresh`.
+
+The warning burst: `refresh_timeline` resolves photo metadata in chunks and keeps going through
+teardown. The runtime is cancelled under it, every decrypt task in flight fails with "task was
+cancelled", and the SDK logs one `skipping undecryptable photo` per node. Nothing was corrupt —
+the library was fine on the next mount, because `photos_replace` preserves prior metadata and
+leaves `resolved_at` null so the next refresh re-reads exactly those photos.
+
+**What changed.** A refresh scope is now single-flight: `RefreshGuard` holds the scope key
+(`dir:<path>`, `trash`, `photos`, `photos:full`) for as long as one is being served, and a second
+request for that same key is answered `refreshing` immediately instead of repeating the work. A
+non-full photos refresh is additionally skipped while `timeline_refreshing()` is true, since that
+work outlives the request that started it. `request_kind` now names the scope, so the diagnostics
+report says `Refresh(Photos)` rather than `Refresh`. And the resolve loop stops asking for chunks
+once `Shutdown::is_stopping()`, logging `stopped` and the resolved-versus-wanted counts on the way
+out.
+
+---
+
+## B96 — Staged bytes that name no node are never retired, and are re-announced on every boot
+
+**Status:** Fixed (unverified).
+**Found:** 2026-09-19, in the journal: the same "staged bytes belong to no queued upload" warning
+appeared once per blob per mount, forever. The staging directory held 138 blobs / 575 MiB, of
+which 95 (~445 MiB) referenced no node at all; the oldest were two months old.
+
+**Where:** `crates/pdfs-fuse/src/lib.rs` (`reconcile_staging`).
+
+**Cause.** Startup reconciliation is deliberately conservative: staged bytes are the only copy of
+an un-uploaded write, so a blob it cannot match to a queued op is kept rather than deleted. But
+"kept" had no end. A blob whose node is gone from the database can never be matched by any future
+boot, so the warning was both permanent and per-blob, and the bytes accumulated with no ceiling.
+
+**What changed.** A blob that names no node and whose mtime is older than `STAGING_ORPHAN_RETAIN`
+(30 days) is retired, with its size logged. A month is long enough that a write stranded by a bug
+can still be recovered by hand. Younger orphans are still kept, but they are now counted and
+reported as one aggregated warning with one example path, not one line each.
+
+---
+
+## B95 — A real `index.tmp` is treated as a browser tempfile and parked forever
+
+**Status:** Fixed (unverified).
+**Found:** 2026-09-19, while working out why 43 uploads were parked. Most of them were
+`index.tmp` and `preview.tmp` files from a Google Photos Takeout import — ordinary files whose
+final name simply ends in `.tmp`.
+
+**Where:** `crates/pdfs-core/src/syncignore.rs` (`TRANSIENT_SUFFIXES`).
+
+**Cause.** One suffix list served two mechanisms with very different consequences. On a mirror
+mount, calling a name transient means "do not reconcile it yet", which is reversible and costs
+nothing if wrong. On an on-demand mount it means "park the create until the writer renames it"
+(B70) — and a file whose real, final name ends in `.tmp` is never renamed, so the park stands
+forever and the bytes never go up.
+
+**What changed.** `.tmp` and `.temp` are out of `TRANSIENT_SUFFIXES`. The remaining suffixes
+(`.crdownload`, `.part`, `.partial`, `.download`, `.swp`, `.swx`) belong to writers that always
+rename. A `.tmp` write from a program that does rename is still handled — by the rename itself,
+which supersedes the create.
+
+---
+
+## B94 — A parked create has no exit but the rename, so an abandoned one is stuck forever
+
+**Status:** Fixed (unverified).
+**Found:** 2026-09-19, while reading the journal: 43 rows in `pending_op` carried the
+`PARK_UNTIL` sentinel, some for weeks. `pdfs status` reported them as parked uploads that never
+moved.
+
+**Where:** `crates/pdfs-core/src/db/ops.rs` (`parked_create_ops`, `PARK_EXPIRY_MS`),
+`crates/pdfs-fuse/src/drain.rs` (`sweep_parked_creates`).
+
+**Cause.** B70 parks a transient create by writing `PARK_UNTIL` into `next_attempt_at`, and the
+only thing that clears it is the transient-to-final rename (`Db::set_create_hold`). If the rename
+never happens — the writer crashed, the user deleted the temp file, or the name was never
+transient in the first place (B95) — the row is invisible to `claim_next_due_op` and stays in the
+queue permanently, holding its staged blob.
+
+**What changed.** The primary drain worker sweeps parked creates when the queue is idle, which is
+exactly when a park that has outlived its writer matters. A parked create whose node is gone from
+the database has its queued ops discarded. One whose node still exists, that is older than
+`PARK_EXPIRY_MS` (1 hour) and that nobody has open, is un-parked rather than dropped — drain
+invariant 1 says staged bytes are only dropped once their op has landed, so the sweep lets the
+bytes through under the transient name instead of destroying them. An open node is left parked
+whatever its age: it is still being written.
+
+---
+
 ## B93 — A photo whose node would not resolve lost its name, and with it its tab and its group

 **Status:** Fixed (unverified) — found and fixed while making the timeline refresh incremental
@@ -9,9 +9,322 @@ release ships. Migrations are forward-only — a database written by a newer cli
 refuse-to-open, not a downgrade, so rolling back a release means restoring the cache from
 scratch (user data in `staging/` and `recovery/` is never touched by this).

+## [Unreleased]
+
+## [2.4.0] — 2026-09-28
+
+Schema: **34**. Photos gain a `similar_hash` column for the similar-photo finder. It stays
+empty until the finder is first opened, so updating reads and downloads nothing.
+
+### Added
+- **Similar photos.** The duplicate finder gains a Similar switch that also finds resized or
+  re-encoded copies and shots of one moment, by comparing the thumbnails. The first search
+  hashes every thumbnail the server has, with a progress bar; photos without one are not
+  downloaded and are counted as not compared. Every photo in a set starts ticked Keep, since
+  photos that look alike can be different shots, and a photo not kept goes to Trash with the
+  rest of its shot.
+- **Photos on the map.** Every town is marked with one of its photos and a count, and nearby
+  towns merge into one marker until you zoom in. Zoomed in on a town, each photo gets its own
+  marker where it was taken; clicking one opens it in the viewer, and clicking photos taken
+  on one spot lists them all. "Show on map" in the photo viewer now goes to that spot on the
+  Places map instead of a web browser.
+- **Street map for Places.** An opt-in setting under Appearance draws the map from
+  [OpenFreeMap](https://openfreemap.org/) (OpenStreetMap data), with streets, water, parks and
+  town names in your language. It is off by default because the tile server learns which parts
+  of the world you look at. Tiles are cached under the cache directory (at most 256 MB), and
+  the built-in outline shows wherever they haven't loaded.
+- **Proton theme.** The "Proton purple accent" preference is now a whole Proton theme: the
+  Proton web apps' light and dark colours, not just the accent. It also holds when `gtk.css`
+  imports another GTK theme (Catppuccin, Fluent, ...), whose own colours used to show through
+  almost everywhere. Folders get Proton's purple folder icon rather than the icon theme's.
+  Anyone who had the accent turned on gets the theme.
+- **Country borders on the Places map.** The offline map draws country borders, with sea and
+  land in their own colours.
+
+## [2.3.0] — 2026-09-28
+
+Schema: **33**. Photos gain their location; the first timeline refresh after updating reads
+the metadata of the whole library once (nothing is downloaded), and the Places view shows how
+far it has got.
+
+### Added
+- **Places.** A third Photos view groups photos by the town they were taken in, as cards or on a
+  world map. Towns are looked up offline in bundled GeoNames data (CC BY 4.0), and the map is
+  drawn offline from Natural Earth land outlines (public domain), so no map tiles are fetched.
+  Install `iso-codes`, a new optional dependency, for country names in your language.
+- **On this day.** A strip at the top of the timeline shows a card for every earlier year with
+  photos taken on today's date.
+- **Find duplicates.** Photos can list every set of byte-identical copies and move the copies
+  you don't keep to Trash. The copy in the most albums is kept by default.
+- **Photos in no album.** A filter narrows the timeline to photos no album holds yet.
+- **One Filters popover.** Favorites, "in no album" and the month jump now share a Filters
+  button, which shows how many filters are on and can clear them all at once.
+- **Zoom-level grouping and range select.** Zooming out groups the timeline by month, then by
+  year. Shift+click selects a range, and dragging across the timeline selects what it sweeps.
+- **Slideshow.** The photo viewer plays the loaded photos full screen, with F5 or a top-bar
+  button.
+- **App icon in the app.** The sidebar header and the login page show the app's own icon.
+
+### Fixed
+- **Photos grid.** The timeline is laid out as square tiles that fill the window's width
+  exactly, and a theme's own `gtk.css` can no longer pad the tiles. It stays at its top, and at
+  the photo you were looking at, when the window is resized or zoomed.
+- **Timeline shaking near the top.** Scrolling up to the "On this day" strip no longer makes the
+  whole page jump between two heights.
+- **Filters while loading.** Changing a filter while a page was still loading could leave the
+  timeline showing the old filter.
+
+## [2.2.2] — 2026-09-27
+
+Schema: **32** (unchanged).
+
+### Fixed
+- **Conflicts in synced folders.** A conflict copy inside a synced folder is now listed under
+  Needs attention and can be resolved there or with `pdfs conflicts`. It used to be logged again
+  after every restart and marked "Resolved" while it was still on disk (B99).
+
+## [2.2.1] — 2026-09-24
+
+Schema: **32** (unchanged).
+
+### Added
+- **Legal information in About.** The About dialog now links to the source code and to Proton's
+  terms of service and privacy policy, and its Legal page carries the full disclaimer: this client
+  is unofficial, not affiliated with or endorsed by Proton AG, and comes without warranty.
+
+## [2.2.0] — 2026-09-23
+
+Schema: **32**. Videos that earlier got no thumbnail are tried again.
+
+### Added
+- **Video thumbnails.** Videos without a thumbnail from Drive now show a frame from the clip in
+  Photos. This needs `ffmpeg`, a new optional dependency.
+- **Uploads carry a thumbnail.** Photos and videos uploaded from this client now include one, so
+  they show a preview in Proton's own apps as well, without downloading the whole file.
+
+### Fixed
+- **The Photos gallery no longer jumps** while thumbnails load, when zooming, or when switching
+  tabs and back.
+- **The month scrubber no longer collides with the scrollbar.**
+- **The photo details panel is no longer empty.**
+- **Photo details read like a camera's:** "Google Pixel 6" instead of quoted EXIF values, shutter
+  speeds such as 1/19 s, and a labelled ISO.
+
+## [2.1.1] — 2026-09-23
+
+Schema: **31** (unchanged).
+
+### Fixed
+- **Uploads no longer get stuck at 0 bytes.** When a file changed again while its previous
+  version was uploading, such as a browser download that is still growing, the old upload could
+  hang forever. It kept one background thread busy at full CPU and showed as "Uploading" in the
+  Transfers list until the daemon restarted.
+
+## [2.1.0] — 2026-09-23
+
+The desktop app, the tray and the search prompt speak German, British English, Spanish, French,
+Italian, Dutch, Polish and Brazilian Portuguese, picked from the system language or chosen in
+Preferences.
+
+Schema: **31** (unchanged).
+
+### Added
+- **Translations.** The desktop app, the tray and the search prompt are translated into German,
+  British English, Spanish, French, Italian, Dutch, Polish and Brazilian Portuguese, and follow the
+  system language. Counts use each language's plural rules, and dates use its own formats. The
+  desktop files carry translated descriptions and search keywords. The `pdfs` CLI and messages
+  from the daemon stay in English. [docs/TRANSLATING.md](TRANSLATING.md) describes how to improve a
+  translation or add a language. A few labels on the Photos page (the filter tabs, the gallery
+  subtitle and the heading shown when a filtered timeline is empty) are still in English.
+- **Language preference.** Preferences → General → Appearance → Language overrides the system
+  language for the app, the tray and the prompt, from their next start.
+
+### Changed
+- **Packages install translations.** The Arch, AUR, Debian and Fedora packages install the compiled
+  catalogs under `/usr/share/locale`, and the release tarball carries them in `locale/`. Building
+  the source packages now needs `gettext`.
+
+## [2.0.0] — 2026-09-23
+
+A redesign of the desktop app: a new shell with a Preferences dialog, keyboard-driven context
+menus, a docked details pane, a rewritten photo viewer with infinite scroll, album management,
+stop sharing and link expiry, a redesigned Shared with Me page, per-device restore, a tray that
+shows the sync state, and a new app icon.
+
+Schema: **31** (unchanged).
+
+### Added
+- **Pause and resume sync.** The Sync page, the tray and `pdfs sync pause [--for 1h]` /
+  `pdfs sync resume` hold back queued uploads and mirror-folder reconciles. Reads through the mount
+  keep working, writes keep being accepted and staged, and a timed pause ends by itself. The pause
+  survives a restart.
+- **See what is waiting to upload.** The Sync page lists the queue with each item's last error and
+  next retry, with Retry now per item and Retry All; `pdfs sync queue` and `pdfs sync retry [id]`
+  do the same from the CLI. Nothing in the queue is ever dropped from here.
+- **Resolve sync conflicts.** `(sync-conflict …)` copies under My Files are listed on the Sync page
+  next to the file they conflict with, with sizes, times and whether the content differs. Keep the
+  original, keep the copy or keep both under a new name; whatever is not kept goes to Trash.
+  `pdfs conflicts` and `pdfs conflicts resolve <path> --keep original|copy|both` do the same from
+  the CLI. Files that are open or still uploading are refused until they settle.
+- **Pause one folder.** A mirrored folder on the Sync page has its own pause button; while paused
+  it is not reconciled in either direction and its mode cannot be switched, and resuming syncs it
+  straight away. `pdfs sync pause --folder <id>` / `pdfs sync resume --folder <id>` do the same, and
+  `pdfs sync list` marks paused folders. The pause is kept across restarts. On-demand folders
+  upload through the shared queue, so only the global pause holds them back.
+- **Bandwidth limits.** Preferences → General → Network caps upload and download speed in MiB/s,
+  shared by every transfer and applied to running ones from their next block; downloads include
+  reads through the mount. `pdfs sync limit --up 2M --down 0` does the same, and `pdfs sync limit`
+  on its own prints the current caps. The caps are kept in `config.json` across restarts.
+- **Tray states and menu.** The tray icon shows whether the drive is synced, syncing, paused,
+  offline or needs attention. It asks the panel for attention while changes keep failing, and
+  its tooltip gives the same line as the menu. A left click opens the app. The menu gains
+  "N issues — View", which opens the Sync page, and "Sign In…" when signed out. "Hide Tray Icon"
+  is remembered across logins (`tray_hidden` in `config.json`), and Preferences → Appearance
+  → Show tray icon brings the icon back. "Stop Proton Drive…" asks for confirmation in the app,
+  then stops the service and the tray. `pdfs-app` accepts `--page <name>` and `--confirm-stop`.
+  A second launch raises the running window instead of opening another one.
+- **Stop sharing.** Shared by Me → item menu → "Stop Sharing…" and `pdfs unshare <path>` (with no
+  id) remove the public link, every invitation and every member in one go. Each step is tried even
+  if an earlier one fails, and a partial result names what is still shared.
+- **Restore another computer's folders.** Every computer's menu on the Computers page has
+  "Restore to This Computer…", which syncs that computer's backed-up folders down to paths you
+  pick; they keep syncing with that computer's copy, and this machine keeps its own identity.
+  This computer's own restore moved from the header into its row's menu. `pdfs sync restore
+  --device <uid>` does the same from the CLI.
+- **Public link expiry.** The Share dialog's create-link form has an "Expires" choice (Never,
+  1 day, 7 days, 30 days), and an existing link shows when it expires or that it has expired.
+
+### Changed
+- **New app shell.** Every page has its own header bar; the sidebar ends in a footer with sync
+  state, storage and the account; the Settings page became a Preferences dialog (Ctrl+,), with
+  transfers on the Sync page and developer details in About. The app follows the system accent
+  colour; the Proton purple accent is a preference.
+- **My Files header.** New folder and both uploads sit in one **New** menu; the view button switches
+  grid and list, and its menu sorts by name, size or date, reversed or not, folders first or not.
+  The choice is remembered. Build Thumbnails and Open in File Manager moved to the folder menu.
+- **Browsing history.** Back and forward buttons (Alt+Left/Right, mouse back/forward) replace the
+  single Up button; Alt+Up goes to the parent folder. Back leaves a search first.
+- **Move to…** picks the destination from a folder browser instead of a typed path, and works on a
+  whole selection. Rename selects the name without its extension.
+- **Drop to upload.** Files and folders dropped on My Files upload into the folder on screen. The
+  upload toast links to the Sync page.
+- **Photos.** The main view is called Timeline. Right-clicking a photo opens a menu to open it,
+  favourite it, select it or move it to Trash; Ctrl+A selects every loaded photo. An empty filter
+  says what it filtered ("No videos in June 2024") instead of the first-run hint. A banner shows
+  while a Takeout import runs and links to it. Pages load 200 photos at a time and keep loading
+  until the window is full.
+- **Trash.** Select several items (click, Shift/Ctrl+click, Ctrl+A) to restore or permanently
+  delete them together; the permanent delete still asks first, with the count.
+- **Shared by Me.** A row opens the item. Copy link stays one click away; Open, Show in My Files,
+  Open Link and Manage Access… are in the row's menu.
+- **Computers.** Rename, Use This Computer's Identity and Remove are in one menu per computer.
+  Removing a computer deletes its backups, so the dialog now asks for its name to be typed. The
+  page says which computer this machine backs up as, and says "computer" throughout.
+- **Sign in.** Failures read as sentences — wrong password, too many attempts, no connection, no
+  keyring, a skipped two-factor or verification step — instead of the raw error. The button spins
+  while signing in, and the page links to account creation and password reset. The two-factor
+  dialog mentions recovery codes.
+- **Real menus.** Right-click menus in My Files, Photos, Shared by Me and Computers are GTK menus:
+  arrow keys, Enter and Escape work, and the Menu key or Shift+F10 opens the one for the selection
+  in My Files. Items follow one order — Open, Open With…, Play · Available offline · Share…,
+  Copy Link · Rename…, Move To…, Versions… · Move to Trash. Right-clicking empty space offers New
+  Folder, the uploads, Select All, Refresh and Open in File Manager. Open With… asks which
+  application to use.
+- **One selection in My Files.** The grid and the list share their selection, so switching views
+  keeps what is selected, and dragging across empty space draws a selection box in both.
+- **Details pane.** On a window at least 1000 px wide the details pane docks beside the files
+  instead of covering them. It has Info, Offline, Sharing and Versions sections: who has access or
+  whether there is a public link, how many versions there are, and Share…, Copy Link and
+  Versions… buttons.
+- **Search in this folder.** Inside a folder, a folder button beside the search box limits the search
+  to that folder and everything below it. `pdfs search --in <folder>` does the same from the CLI.
+  In the list view a Location column shows which folder each hit is in. Pinned files listed by the
+  search prompt and `pdfs-query` show whether they are on disk, instead of always showing them as
+  not downloaded.
+- **Album management.** The Albums view has a New Album button, and an album's right-click menu
+  offers Rename… and Delete Album…. Deleting an album keeps its photos in the timeline. A photo's
+  menu and the selection bar offer Add to Album…, and inside an album, Remove from Album takes a
+  photo out without trashing it. Albums shared with you only open. The CLI gains `pdfs new-album`,
+  `rename-album`, `delete-album`, `add-to-album` and `remove-from-album`. This needs
+  proton-drive-rs 0.6.6.
+- **Albums view fixes.** The timeline's filter row no longer shows over the album grid. The header
+  counts albums. Back from an album returns to the grid where you left it instead of reloading it,
+  and going from Albums back to Timeline keeps the timeline's scroll position unless an album was
+  opened in between.
+- **Photo viewer rewrite.** The lightbox's controls fade out after two seconds without pointer
+  movement. Photos zoom with Ctrl+scroll, a pinch, `+`/`-`, `1` for 100 % and double-click, and
+  pan by dragging; `0` fits them again. The details panel docks beside the photo instead of
+  covering it. Stepping past the last loaded photo loads the next page, and the counter shows the
+  library's total rather than the loaded count. A video plays inline. Save a Copy uses the photo's
+  real name and reports failures, and Open With… offers the app chooser.
+- **Photos scroll without a Load More button.** The timeline loads the next page while you are
+  still a screen and a half from the end, with a spinner under it while a page is on its way. A
+  month scrubber on the right edge of the whole timeline, marked by year, jumps to the month you
+  drag it to and follows the scroll otherwise.
+- **Activity log redesign.** The feed is grouped by day (Today, Yesterday, weekday, date), with
+  a time column and filter chips for All, Transfers, Changes, Sharing and Problems. A conflict the
+  daemon logs again on every run now shows once, with a count. A "Needs attention" section on top
+  lists the conflicts still waiting for a decision. Each logged conflict has a Resolve… button that
+  opens the same dialog as the Sync page, and reads as resolved once the copy is gone.
+- **Share dialog.** The Invite button stays off until every address looks like an email; a
+  malformed one marks the field red and names the entry in a tooltip. Buttons show a spinner
+  while their request runs, so a slow invite or link removal can't be sent twice.
+- **New app icon.** A white cloud with the download arrow cut out of it, on a rounded Proton
+  purple tile with a darker lower edge, drawn to the GNOME app-icon grid. It stays legible down to
+  16 px on light and dark panels.
+- **Shared with Me redesign.** Only sections with something in them are shown, and a page
+  with nothing shared says so in one place. Pending invitations sit at the top, with an Accept
+  button beside each. A row reads as the name over who shared it, when, and its size; what the
+  share allows is a tinted pill ("Can view", "Can edit", "Can manage") rather than a bare
+  role word that looked like a button. Open, Show in My Files and Leave… are in the row's ⋮
+  menu, and folders show a chevron. Inside a shared folder the header shows the path from the
+  share down, with a back button. Add Bookmark is an icon in the header.
+- **US spelling throughout.** The app, the CLI and the docs say "Favorite" and "color", matching the
+  `pdfs favorite` command.
+
+## [1.11.1] — 2026-09-19
+
+Schema: **31** (unchanged).
+
+### Fixed
+- **Double-click opens folders reliably.** Selecting a file no longer slides the details pane in
+  by itself: the pane moved the files under the pointer between the two clicks of a double-click,
+  so the folder did not open. The pane now shows on request, from the header's Details toggle,
+  Alt+Enter or the item menu's Details, and then follows the selection. Closing it keeps the
+  selection.
+- **The details pane opens only when asked.** On a wide window it used to show at start, empty,
+  and close again whenever you entered a folder. It now follows the header toggle alone. With
+  nothing selected it says so instead of closing, so opening a folder no longer moves the files.
+- **Context menus no longer have wide margins under some themes.** A menu opened on a file tile
+  was placed inside the tile, so a theme's rules for tile contents (Catppuccin's
+  `gridview > child box { margin: 12px }`) spaced out every section.
+- **My Files behaves more like a file manager.** A click on empty space between the files clears
+  the selection; Ctrl or Shift held keeps it. Backspace goes back while the focus is on the files.
+- **An upload parked behind a temp-file rename no longer stays parked forever.** A create for a
+  name that looks like a writer's temporary file waits for the rename to the final name. If that
+  rename never came — the writer crashed, the file was deleted, or the name was never temporary —
+  the upload sat in the queue permanently, holding its staged bytes. The queue now sweeps parked
+  creates while it is idle: one whose file is gone is dropped, and one that has been parked for
+  over an hour with nobody holding it open is uploaded under the name it has. An open file is
+  left alone however old it is (B94).
+- **A file whose real name ends in `.tmp` uploads normally.** `.tmp` and `.temp` were treated as
+  writer temp-file suffixes, so ordinary files — a Google Photos Takeout `index.tmp`, for
+  instance — were parked waiting for a rename that was never going to happen (B95).
+- **Staged bytes that belong to nothing are cleaned up.** A staged blob that matches no queued
+  upload and names no node used to be kept forever and warned about once per blob on every mount.
+  Blobs older than 30 days are now retired with their size logged; younger ones are kept, but
+  reported as a single line instead of one per blob (B96).
+- **Refreshing the gallery repeatedly no longer wedges the control socket.** Each refresh scope
+  now runs one at a time; asking again while one is running is answered immediately rather than
+  repeating work that contends with it for the database. `pdfs diagnostics` also names the scope
+  of a running refresh (B97).
+- **Shutting down during a photo refresh no longer logs a wall of "undecryptable photo"
+  warnings.** The metadata pass stops when teardown begins instead of running into the cancelled
+  runtime. Nothing was wrong with those photos; the next refresh reads them again (B97).
+
 ## [1.11.0] — 2026-09-19

-Schema: **30** (`photos.content_hash` / `main_uid` / `group_key`); SDK bumped to `proton-sdk` /
+Schema: **31** (V30 `photos.content_hash` / `main_uid` / `group_key`, V31 `photos.resolved_at`); SDK bumped to `proton-sdk` /
 `proton-drive-rs` **0.6.5**.

 ### Changed
@@ -797,6 +1110,18 @@ First stable release: FUSE files-on-demand mount, sync daemon under `proton-driv
 - The outstanding FUSE defects tracked in `docs/BUGS.md`, plus a truncate defect, validated
  by a new POSIX compliance suite for the filesystem.

+[2.4.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v2.4.0
+
+[2.3.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v2.3.0
+[2.2.2]: https://github.com/narrrl/proton-drive-linux/releases/tag/v2.2.2
+[2.2.1]: https://github.com/narrrl/proton-drive-linux/releases/tag/v2.2.1
+[2.1.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v2.1.0
+[2.0.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v2.0.0
+[1.11.1]: https://github.com/narrrl/proton-drive-linux/releases/tag/v1.11.1
+[1.11.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v1.11.0
+[1.10.2]: https://github.com/narrrl/proton-drive-linux/releases/tag/v1.10.2
+[1.10.1]: https://github.com/narrrl/proton-drive-linux/releases/tag/v1.10.1
+[1.10.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v1.10.0
 [1.9.3]: https://github.com/narrrl/proton-drive-linux/releases/tag/v1.9.3
 [1.9.2]: https://github.com/narrrl/proton-drive-linux/releases/tag/v1.9.2
 [1.9.1]: https://github.com/narrrl/proton-drive-linux/releases/tag/v1.9.1
@@ -14,7 +14,7 @@ Consolidated from the historical feature roadmap; current bug status lives in [`
 * **Custom FUSE Mount Options (Horizon 1)**: Expose custom mounting parameters in configuration (e.g. `ro` for read-only, `direct_io` to bypass kernel caching, `allow_other`). Auto-generate systemd user mount units upon sync folder configuration.
 * **Symbolic Link & Hard Link Virtualization (Horizon 2)**: Add symbolic link virtualization inside the metadata store (`NodeType::Symlink`) by intercepting `readlink(2)` and `symlink(2)`. Targets should sync remotely as small encrypted metadata placeholder files on Drive (`proton-vfs-symlink: <target>`).
 * **Desktop File Manager Integration (Horizon 2)**: Develop shell extension plugins for popular Linux file managers (Nautilus Python plugin, Dolphin Service Menus, Thunar custom actions) to offer context-menu shortcuts ("Pin", "Unpin", "Copy Share Link", "View Version History") and file overlay sync badges.
-* **Integrated Photo Gallery Enhancements (Horizon 2)**: Album *editing* — rename, cover photo, delete, and removing photos from an album — is still unported in the SDK (TS `updateAlbum` / `deleteAlbum` / `removePhotos`), as is adding a photo that lives on someone else's volume (TS `copyPhoto`). Album **creation** and adding own-volume photos landed with the Google Photos import. Still open: an auto-upload Pictures folder pipeline, and a GUI for creating albums by hand. Exif display, the date-based timeline scrubber and favourites are implemented.
+* **Integrated Photo Gallery Enhancements (Horizon 2)**: Album *editing* — rename, cover photo, delete, and removing photos from an album — is still unported in the SDK (TS `updateAlbum` / `deleteAlbum` / `removePhotos`), as is adding a photo that lives on someone else's volume (TS `copyPhoto`). Album **creation** and adding own-volume photos landed with the Google Photos import. Still open: an auto-upload Pictures folder pipeline, and a GUI for creating albums by hand. Exif display, the date-based timeline scrubber and favorites are implemented.
 * **Google Photos import follow-ups**: the importer uploads photos one at a time — a large export would finish sooner with a bounded concurrent upload pool. Trash folders are recognized by a hardcoded list of localized names ([`takeout.rs`](../crates/pdfs-core/src/takeout.rs) `TRASH_FOLDERS`); a locale not on it imports its trash as ordinary photos. Motion-photo `.MP`/`.MV` sidecar videos are ignored rather than uploaded as related photos. Live validation against a real export is pending.
 * **Random-Access Media Streaming seek support (Horizon 2)**: Intercept out-of-order sparse reads (player seeks) in `pdfs-fuse` and prioritize downloading blocks around the seek offset, aborting/postponing sequential pre-fetches.
 * **Dynamic Sync Dashboard & Queue Visualization (Horizon 2)**: GUI real-time transfer list (progress bars, speed, ETA), sync history feed, storage usage breakdown, and global pause/resume sync controls.
@@ -135,10 +135,10 @@ Three properties that shape the code:
 - **The active revision cannot be deleted.** `Core::delete_revision_for_uid` checks that locally so the user gets a sentence rather than an API code, and the dialog gives the current row no delete button.
 - **Saving a version never overwrites.** `SaveRevisionAs` refuses an existing destination and removes a partial file if the download fails — a half-written export looks identical to a good one to every tool that opens it afterwards.

-### Photo Favourites (Implemented)
+### Photo Favorites (Implemented)
 **Files**: [`photos.rs`](../crates/pdfs-fuse/src/photos.rs), [`photo_viewer.rs`](../crates/pdfs-gui/src/app/pages/photo_viewer.rs)

-The gallery can mark and filter favourites, through the SDK's photo-tag API (`update_photos`). Schema **v20** adds `photos.favorite`; the flag is learned in the timeline enrichment pass that already resolves each photo's name and media type, and is kept across a refresh that could not resolve a photo — the same learned-and-kept rule as `media_type`. The lightbox carries a star toggle, the Photos header a favourites filter, and the CLI has `pdfs favorite <uid> [--remove]` plus `pdfs photos --favorites`.
+The gallery can mark and filter favorites, through the SDK's photo-tag API (`update_photos`). Schema **v20** adds `photos.favorite`; the flag is learned in the timeline enrichment pass that already resolves each photo's name and media type, and is kept across a refresh that could not resolve a photo — the same learned-and-kept rule as `media_type`. The lightbox carries a star toggle, the Photos header a favorites filter, and the CLI has `pdfs favorite <uid> [--remove]` plus `pdfs photos --favorites`.

 Favouriting a photo that is not on this account's own photos volume (shared with us, or album-only) needs it re-encrypted for our timeline root, which the SDK does not implement; the daemon surfaces that as an error rather than silently doing nothing.

@@ -155,7 +155,7 @@ The gallery lays each day out in justified rows (`justify_rows` / `plan_rows` /
 ### RAW + JPEG Grouping (Implemented)
 **Files**: [`photos.rs`](../crates/pdfs-core/src/db/photos.rs), [`migrations.rs`](../crates/pdfs-core/src/db/migrations.rs), [`photos.rs`](../crates/pdfs-fuse/src/photos.rs), [`photo_viewer.rs`](../crates/pdfs-gui/src/app/pages/photo_viewer.rs)

-Schema **v30** adds `content_hash`, `main_uid` and an indexed `group_key` to `photos`. The first two come from the server's `PhotoProperties` and are filled by the enrichment pass in `refresh_timeline` that already resolves each photo's name, media type and favourite tag; `group_key` is computed in `photos_replace`, where the whole timeline is in hand.
+Schema **v30** adds `content_hash`, `main_uid` and an indexed `group_key` to `photos`. The first two come from the server's `PhotoProperties` and are filled by the enrichment pass in `refresh_timeline` that already resolves each photo's name, media type and favorite tag; `group_key` is computed in `photos_replace`, where the whole timeline is in hand.

 - **Precedence.** The server relation first (`main_photo_uid` and `related_photo_uids`, read from whichever end resolves — the two can land in different enrichment chunks); then same capture day, same case-insensitive name stem, and one member raw while the other is not; otherwise the photo is its own group. The union-find pass is over the timeline in memory, so it costs one pass per refresh rather than a query per photo.
 - **Representative.** The non-raw member when there is one — a JPEG decodes in milliseconds and is what the person expects to see. `group_key` holds that member's uid, so "is this the tile" is `uid = group_key`, an index scan.
@@ -0,0 +1,78 @@
+# Translating Proton Drive for Linux
+
+The desktop app (`pdfs-app`), the tray (`pdfs-tray`) and the search prompt (`pdfs-prompt`) are
+translated with GNU gettext in the `pdfs` text domain. The `pdfs` command-line tool and the daemon's
+own messages stay in English, because scripts parse their output.
+
+US English is the source language. The shipped catalogs are listed in [`po/LINGUAS`](../po/LINGUAS):
+German, British English, Spanish, French, Italian, Dutch, Polish and Brazilian Portuguese.
+
+## Picking a language
+
+The apps follow the system locale (`LANGUAGE`, `LC_ALL`, `LC_MESSAGES`, `LANG`). Preferences →
+General → Appearance → **Language** overrides that for the app, the tray and the prompt. The choice is
+stored as `language` in `config.json` and takes effect the next time they start.
+
+## Layout
+
+| Path | Purpose |
+| --- | --- |
+| `crates/pdfs-gui/src/i18n.rs` | Locale setup and the `gettext`, `gettext_f`, `ngettext_f`, `pgettext` and `gettext_noop` helpers |
+| `po/POTFILES.in` | Sources that `xgettext` scans |
+| `po/pdfs.pot` | The template, generated from the sources |
+| `po/<lang>.po` | One catalog per language |
+| `po/update.sh` | Regenerates the template and merges it into every catalog |
+| `po/build.sh <localedir>` | Compiles the catalogs to `<localedir>/<lang>/LC_MESSAGES/pdfs.mo` |
+
+## Updating an existing translation
+
+1. Run `po/update.sh`. It regenerates `po/pdfs.pot` and merges new and changed strings into each
+   catalog, marking changed ones `fuzzy`.
+2. Edit `po/<lang>.po` with a PO editor (Poedit, Lokalize, GNOME Translation Editor) or a text
+   editor. Translate the empty entries and review every `fuzzy` one, then remove its `fuzzy` flag.
+3. Check the catalog with `msgfmt --check --statistics -o /dev/null po/<lang>.po`.
+4. Try it from the source tree:
+
+   ```bash
+   po/build.sh target/locale
+   PDFS_LOCALEDIR=target/locale LANGUAGE=<lang> cargo run -p pdfs-gui --bin pdfs-app
+   ```
+
+## Adding a language
+
+1. Add the code (for example `sv` or `pt_PT`) to `po/LINGUAS`, keeping the list sorted.
+2. Run `po/update.sh`. It creates `po/<lang>.po` from the template with `msginit`.
+3. Fill in the `Plural-Forms` header if `msginit` did not, and translate the catalog.
+4. Add the code and the language's own name to `LANGUAGES` in `crates/pdfs-gui/src/i18n.rs`, so the
+   Preferences picker offers it.
+5. Add `GenericName[<lang>]`, `Comment[<lang>]` and `Keywords[<lang>]` lines to the two desktop files
+   in `packaging/`.
+
+`cargo test -p pdfs-gui` checks that every language in the picker has a catalog, that
+`po/POTFILES.in` lists every source file that calls gettext, and that every catalog passes
+`msgfmt --check`.
+
+## Rules for translators
+
+- Keep every `{placeholder}` from the English text. You may move it, but not rename or drop it.
+  `msgfmt --check` rejects a catalog where they differ. Plural forms keep `{n}` in every form.
+- Read the `#.` translator comments above an entry. They explain placeholders and date formats.
+- Date entries such as `%b %e` are `strftime` formats for GLib's `DateTime::format`. Translate them
+  into the order and separators your language uses, not into literal dates.
+- A `msgctxt` such as `verb` or `column` tells you which meaning of a short word is meant.
+- Keep product names as they are: Proton Drive, Proton, Google Takeout.
+- Use the same term for the same thing across the catalog, and follow the terminology of your
+  desktop (GNOME or KDE) for common actions such as Trash, Preferences and Cancel.
+
+## Rules for developers
+
+- Wrap every user-visible GUI string: `gettext("Move to Trash")`.
+- Never build a sentence from translated pieces or with `format!`. Use named placeholders:
+  `gettext_f("Moved {name} to Trash", &[("name", &name)])`.
+- Counts use `ngettext_f("{n} item", "{n} items", count, &[])`; `{n}` is filled in for you.
+- Give short, ambiguous words a context: `pgettext("verb", "Open")`.
+- Mark labels in `const` tables with `gettext_noop` and translate them where they are shown.
+- The message id must be a single string literal on one line, since `xgettext` reads literals only.
+- Add a `// Translators:` comment on the line above a call whose meaning is not obvious.
+- Do not translate log messages, CLI output, action or icon names, or values the daemon sends back.
+- Run `po/update.sh` after changing strings and commit the updated template and catalogs.
@@ -0,0 +1,353 @@
+# UI/UX audit and improvement plan
+
+Audit date: 2026-09-23. Scope: `pdfs-gui` (all pages, dialogs, photo viewer), `pdfs-tray`, and the
+backend capabilities the UI would need. File references are to `crates/pdfs-gui/src/app/` unless
+stated otherwise.
+
+## 1. Summary
+
+The client is functionally rich but the UI is built page by page, and it shows:
+
+- **No sync control surface.** There is no way to pause or resume sync, no list of what is stuck or
+  failing, and no conflict overview. The backend has no pause at all, no per-op listing, and no
+  per-file conflict record (conflicts exist only as `(sync-conflict <ts>)` files plus activity rows).
+  The GUI reads `online`, `pending_uploads` and `pending_changes` from `Status` and ignores
+  `failing_ops`, `failing_error`, `parked_uploads` and `staged_*`.
+- **Information architecture is scattered.** Live transfers are a group on *Settings* while the
+  *Activity* page is history only. *Locations* and *Computers* point at each other. Import lives under
+  Settings but is launched from Gallery and returns to Settings. Sign-out, quota, mount status,
+  pinned files, import and developer info all share the Settings page.
+- **Chrome is non-standard.** Every page draws its own title and toolbar row under an almost empty
+  `AdwHeaderBar` whose title is always "Proton Drive". Two stacked bars, wasted height, no current
+  folder in the title.
+- **Icons and wording drift.** Upload uses `document-send-symbolic` (reads as "send"), offline uses
+  stars (reads as "favorite"), trash icons mean "stop syncing", "remove device" and "remove
+  bookmark". "Keep offline" / "Unpin" / "Remove offline copy" / "Available offline" are one concept.
+  "Computers" vs "device", "Gallery" vs "Photos", "mount service" vs "daemon" vs "Connect".
+- **Theming is hardcoded.** `PROTON_PURPLE` overrides the system accent; badge, viewer and tile
+  colours are hex/rgba literals and ignore light, dark and high-contrast modes.
+- **Several visible bugs** (section 9).
+
+## 2. Design principles
+
+1. **Follow GNOME HIG and current libadwaita.** The system has libadwaita 1.9; the crate is pinned to
+   feature `v1_5`. Raise it to at least `v1_7` to get `adw::Spinner`, `ToggleGroup`,
+   `InlineViewSwitcher`, `ButtonRow`, `WrapBox`, `BottomSheet`, and (1.8) `ShortcutsDialog`.
+2. **Sync state is first class.** The user must always see: up to date / syncing / paused / offline /
+   needs attention, and be one click from pausing or from the list of problems.
+3. **One term, one icon, one place** per concept (glossary in section 8).
+4. **Secondary and destructive actions go into menus.** Rows get at most one visible suffix action
+   plus a `view-more-symbolic` menu. Destructive actions are red inside the menu and in the confirm
+   dialog, not as filled buttons in headers.
+5. **Never block on the network visibly.** Keep old content on screen while reloading, show a header
+   spinner, never flash the whole page to a "Loading…" status page.
+6. **Respect the system.** Use the system accent by default (brand purple stays on login, app icon
+   and an opt-in toggle). Use named colours (`@success_color`, `@warning_color`, `@error_color`).
+
+## 3. New information architecture
+
+### Sidebar
+
+```
+Proton Drive                     (header: app name)
+  My files
+  Photos
+  Shared with me        (badge: pending invitations)
+  Shared by me
+  Computers
+  Trash
+─────────────
+  Sync                  (badge: issue count, icon reflects state)
+─────────────  footer
+  [●] Up to date · Pause          ← sync status strip, click opens Sync
+  ▓▓▓░░░ 269 GiB of 1.6 TiB       ← quota
+  (avatar) user@proton.me   ⋮     ← account menu: Preferences, Sign out…
+```
+
+- **Remove** sidebar rows: *Locations* (merged into Sync), *Activity* (becomes the Sync "History"
+  view), *Settings* (becomes an `AdwPreferencesDialog`, `Ctrl+,`).
+- **Rename** *Gallery* to *Photos* and *Shared* to *Shared by me*.
+- Primary menu: Preferences, Keyboard Shortcuts, About. The About dialog's `debug_info` gets app
+  version, user agent, daemon status and config path (replacing the "Developer" group).
+
+### Sync page (new, replaces Locations + Activity + Settings→Activity)
+
+Top: an `AdwBanner`-style status card with state icon, one-line summary ("Syncing 12 files · 3.4
+MB/s", "Paused until you resume", "2 files need attention") and one primary button: **Pause** /
+**Resume** (split button with "Pause for 1 hour / until tomorrow / until resumed").
+
+Below, an `InlineViewSwitcher` with four views:
+
+1. **Issues** (default when non-empty): conflicts, failing uploads (`last_error`, attempts, next
+   retry), folders in `error`/`conflict` state, parked uploads older than N minutes. Each row has a
+   primary fix action (Resolve…, Retry now) and a menu (Show in folder, Discard change…).
+2. **Transfers**: in-flight uploads and downloads with progress, speed, cancel; background jobs
+   (thumbnail build, Takeout import, re-date) with their own cancel.
+3. **Folders**: the old Locations list. Row: path, mode as a dropdown suffix (Synced / On-demand, with
+   confirm when going on-demand deletes local copies), state subtitle, `Sync now` and a menu (Open,
+   Change location…, Pause this folder, Stop syncing…). "Add folder…" as a `ButtonRow` at the end.
+   The primary mount appears first and is not removable.
+4. **History**: the old Activity feed, with a kind filter, failures in `@error_color`, rows
+   activatable (open or reveal the target), and "Clear history".
+
+### Preferences dialog (slimmed Settings)
+
+| Page | Contents |
+|---|---|
+| General | Start on login; Mount location (path + Change…); Notifications (on sync issues, on import done) |
+| Storage | Cache usage bar; Cache budget (spin row, in GB, "Unlimited" switch instead of magic 0); Clear cache…; Offline files (count + "Manage" → Sync › Folders filter or a sub-page) |
+| Sync | Ignore patterns (editable list); Conflict clean-up: Off / Report / Remove identical copies (`conflict_sweep`); later: bandwidth limits |
+| Advanced | Open-with rules, search prompt config (only if kept in GUI) |
+
+Moved out: account row and Sign out (sidebar account menu, with confirm), quota (sidebar footer),
+mount status (sidebar status strip), live transfers (Sync), Google Photos import (Photos page menu),
+version/user agent (About → Debug info).
+
+## 4. Backend work required
+
+Everything below is new; nothing like it exists today.
+
+### B-1 Pause and resume (global, then per folder)
+
+- `Request::SetSyncPaused { paused: bool, until: Option<i64> }`, persisted (config key
+  `sync_paused_until` or a DB setting) so a pause survives restarts; `Response::Status` gains
+  `paused` and `paused_until`.
+- Drain: `run_pending_drain` (`pdfs-fuse/src/drain.rs:265`) already releases claimed ops while
+  offline; gate on `paused` at the same point and reuse the wake path.
+- Sync engine: add `SyncMsg::Pause/Resume` or gate `reconcile_all` / `reconcile_folder`; the 120 s
+  poll and watcher keep recording, they just do not apply.
+- FUSE reads must keep working while paused (on-demand hydration is a read, not a sync); document that
+  pause means "no uploads, no mirror reconcile".
+- Per folder later: `sync_folder.paused` column, skipped in `reconcile_all`.
+- Bandwidth limits later: token bucket in `CountingReader` / `CountingWriter`
+  (`pdfs-fuse/src/transfers.rs`).
+
+### B-2 Pending ops and transfers
+
+- `Request::ListPendingOps` → id, kind, path/name, attempts, `last_error` (classified as
+  `ErrorKind`), `next_attempt_at`, parked flag, staged bytes.
+- `Request::RetryOp { id }` (set `next_attempt_at = now`, wake drain) and `RetryAllFailing`.
+- `Request::DiscardOp { id }` for a create/revision whose bytes should be dropped. Must save the
+  staged blob to a local recovery folder first; never silent data loss (see `docs/RECOVERY.md`).
+- `TransferItem` gains a stable id and `Request::CancelTransfer { id }`.
+- Per-folder last error message on `SyncFolderInfo` (today the text only exists in the activity feed).
+
+### B-3 Conflicts
+
+- `Request::ListConflicts`: walk nodes whose name parses with `sweep.rs` `conflict_base_name`, for
+  the mount and every mirror folder. Return copy path, original path (if it exists), both sizes and
+  mtimes, whether content is identical (size + `content_sha1`, as the sweep already proves), and
+  which side is local vs remote when known.
+- Optionally a `conflict` table written by `keep_as_conflict_copy` / `preserve_conflict_copy` so the
+  origin (drain vs mirror, device) is recorded instead of inferred from names.
+- `Request::ResolveConflict { copy, keep: Original | Copy | Both }`:
+  - Original: trash the copy (re-verify like the enforcing sweep does).
+  - Copy: upload the copy's content as a new revision of the original, then trash the copy (the old
+    content stays in version history, so this is reversible).
+  - Both: rename the copy to a user-chosen name, drop the `(sync-conflict …)` stamp.
+- Activity rows for each resolution.
+
+## 5. Shell and visual polish (all pages)
+
+- **Per-page header bars.** Give each stack page its own `adw::ToolbarView` + `adw::HeaderBar` (or
+  inject page widgets into the shared bar on page switch). Title = page name, or the current folder
+  in My files. Page actions move into the header; the extra toolbar row disappears.
+- **One page skeleton.** Same margins everywhere (today 12 vs 18), same `Clamp` rule (lists that are
+  settings-like clamp at 720, file/photo grids are full width), same status pages (`compact`,
+  `vexpand`, crossfade), same Retry semantics (Retry reloads; "Start Proton Drive" is a separate,
+  explicitly labelled button when the service is down).
+- **Loading.** `adw::Spinner` in the header; keep the old model until the new one lands; status page
+  only on first load.
+- **Theme.** Drop the global `accent_*` override; offer "Use Proton purple accent" in Preferences.
+  Replace hex colours with named colours; test light, dark and high contrast.
+- **Move the 70-line CSS string** in `main.rs:232` to `resources/style.css` in the gresource
+  (`style-dark.css` if needed), so it can be edited and linted.
+- **Shortcuts.** Replace the hand-rolled cheatsheet with `adw::ShortcutsDialog` (or
+  `GtkShortcutsWindow` before 1.8) listing all bindings, including F5/Ctrl+R and the viewer keys.
+- **Toasts vs dialogs.** Dialogs report their own errors inline (versions, share, add bookmark); a
+  toast behind a modal is invisible. Pluralise properly (`ngettext`-ready helpers, no "item(s)").
+- **i18n groundwork.** Wrap user strings in a `gettext!`-style macro now, even without translations,
+  so later localisation is mechanical.
+
+## 6. Page-by-page plan
+
+### My files
+
+Header: `[‹ ›]  Path bar (breadcrumbs, scroll to end, Ctrl+L to edit)  … [search] [view ▾] [+ New ▾]`
+
+- **New ▾** (`list-add-symbolic`, suggested): New folder (Ctrl+Shift+N), Upload files (Ctrl+U),
+  Upload folder. Replaces three separate icons, fixes the "send" icon.
+- **View ▾** split button: Grid/List (Ctrl+1/2), Sort by Name/Size/Modified, ascending/descending,
+  Folders first, zoom slider. Persist choice (config or GSettings).
+- **Folder ⋮ menu** (in header or background context menu): Refresh, Build thumbnails, Make folder
+  available offline, Open in file manager, Share folder…. Build thumbnails leaves the main toolbar.
+- **Navigation.** Back/forward history (Alt+←/→), Up (Alt+↑); searching then pressing Back clears
+  the search consistently.
+- **Context menus** as `gtk::PopoverMenu` from `gio::Menu` + actions: keyboard navigable, Menu /
+  Shift+F10, same action set as details pane. Add a background menu. Order: Open, Open with…, Play
+  (media) · Available offline (check item) · Share…, Copy link · Rename…, Move to…, Versions… ·
+  Move to Trash (destructive).
+- **Offline state.** One concept "Available offline", toggle semantics. Badges: cloud-only = no
+  badge or subtle `cloud-outline`; downloaded = check; available offline = pin/`folder-download`
+  style filled icon. Use named colours. Folders can be made available offline too, or the toggle is
+  hidden for them (fix `details.rs:259`).
+- **List view.** Sortable, resizable columns: Name, Status, Size, Modified (date + time), and
+  Location for search results. Rubberband selection. One selection model shared between views.
+- **Details pane.** On wide windows a real side pane (breakpoint, not overlay); header bar with
+  close; real thumbnail; sections: Info, Offline, Sharing (people count, link), Versions (latest 3 +
+  "All versions…"). Same actions as the context menu.
+- **Selection bar** (≥1 selected, not ≥2): count + size, Available offline, Move to…, Share (single),
+  Move to Trash; Select all (Ctrl+A). Drop the confirm dialog for trash since Undo exists (trash is
+  reversible), or keep confirm and drop Undo — not both.
+- **Drag and drop.** Drop external files/folders to upload (reuse Takeout's `FileList` target), drag
+  the whole selection, highlight drop targets, breadcrumbs accept drops, Undo toast on move.
+- **Move to…** a folder-picker dialog (tree/list of Drive folders) instead of a free-text path.
+- **Rename** pre-selects the stem, not the extension; drop the redundant "Rename “x”." body.
+- **Search.** Scope toggle (This folder / Everywhere), "Showing first 200 results" note, Location
+  column, correct cached badges (search hits hardcode `cached: false`).
+- **Upload feedback.** Toast "Uploading 3 items" with "View" → Sync › Transfers.
+
+### Photos (was Gallery)
+
+- Header: title "Photos", `InlineViewSwitcher` Timeline | Albums in the header, Select toggle,
+  `+ Upload` (fix: use `adw::ButtonContent`, today `.icon_name()` overwrites `.label()` at
+  `photos.rs:426-432`), ⋮ menu: Import from Google Photos…, Refresh, Rebuild library.
+- Filters: a single filter dropdown/`ToggleGroup` (All, Photos, Videos, RAW, Favorites) instead of
+  two segmented rows where "Photos" appears twice. Counts follow the active filter.
+- **Month scrubber** on the right edge that *jumps* (not filters); the month dropdown becomes a real
+  "Filter by date" if kept.
+- Infinite scroll with prefetch (no "Load more" pill; page size ≥ 200; also trigger when the first
+  page does not fill the viewport).
+- Tiles: `ContentFit::Cover` (crop) in justified rows, known aspect ratio from metadata to prevent
+  reflow, placeholder as a tinted card of the final size, subtle hover (no 1.06 scale with heavy
+  shadow on a 2 px gap grid), last row justified up to a max stretch.
+- Context menu on tiles: Open, Favorite, Add to album, Download/Save copy, Show in My files, Move to
+  Trash. Selection: Shift range, Ctrl+A, bulk Favorite, Add to album, Download.
+- Empty states per filter ("No favorites yet", "No videos in June 2024") instead of the global
+  "No photos yet" with upload buttons.
+- Import: runs show a banner on Photos ("Importing from Google Photos — 1,204 of 5,000 · View") and
+  Back returns to where the user came from.
+- **Albums:** Create, rename, delete, remove from album (not trash). Fix state bugs: filter row
+  hidden on the album grid, subtitle count, scroll position kept when switching back.
+- **Viewer:** `adw::Window` (or full-window overlay), controls auto-hide after 2 s idle, zoom/pan
+  (pinch, Ctrl+scroll, double-click), info panel beside the image instead of over the top bar,
+  pages beyond the loaded 60, counter against the real total, videos play inline with
+  `gtk::Video`, trash with the same confirm/undo rule as the grid, real filename in "Save a copy",
+  success toast, "Open with…" app chooser, favorite tooltip reflects state, readable dates.
+
+### Shared with me / Shared by me
+
+- Shared with me: header title shows the drill-down path, with back; invitations as a banner at
+  the top ("2 invitations · Review") opening a list, Reject confirmed; bookmarks become a separate
+  view or section via a switcher. Rows: Open, Save to My files, Available offline where supported.
+- Shared by me: rows activatable (open), suffix "Manage" becomes a menu with Copy link, Manage
+  access…, Stop sharing….
+- Share dialog: inline validation, loading spinner, confirm "Remove access" and "Delete link",
+  human role names, link expiry.
+
+### Computers
+
+- Show the real device name for "This computer" with rename inline.
+- Other computers: one suffix menu (Rename, Use this identity…, Remove…). Remove uses a destructive
+  confirm that requires typing the device name since it deletes backups.
+- "Restore folders" becomes a per-device action ("Restore to this computer…") with an inline-empty
+  state when nothing is restorable, and moves the "Add folder" responsibility fully to Sync.
+- Terminology: "computer" everywhere in UI copy.
+
+### Trash
+
+- Same skeleton as other list pages (clamped `boxed-list`), sort by deleted date, multi-select with
+  Restore / Delete permanently, "Empty Trash…" moved into a header ⋮ menu or kept as a flat button
+  with a destructive confirm, proper plurals, Retry on error.
+
+### Login
+
+- Human error messages mapped from error kinds, spinner in the button, "Create account" and "Forgot
+  password" links, recovery-code hint in 2FA, cancelling CAPTCHA returns to the form with a message.
+
+## 7. Tray
+
+- Symbolic icon variants: `pdfs-synced`, `pdfs-syncing`, `pdfs-paused`, `pdfs-offline`,
+  `pdfs-attention`; tooltip with the one-line state; `NeedsAttention` status for issues.
+- Menu: status line · "N issues — View" (opens Sync › Issues) · Pause sync ▸ (1 h, until tomorrow,
+  until resumed) / Resume · Open Proton Drive · Open folder · "Sign in…" when logged out (no
+  "Connect") · Stop Proton Drive (confirm) · "Hide tray icon" instead of "Quit" (daemon keeps
+  running and the label must not suggest otherwise).
+
+## 8. Glossary (one term, one icon)
+
+| Concept | UI term | Icon |
+|---|---|---|
+| Root of Drive | My files | `folder-symbolic` |
+| Background service | Proton Drive (running / stopped) — never "daemon" or "mount service" in UI | — |
+| Cloud-only file | Online only | none / `cloud-outline` |
+| Pinned file | Available offline | pin/download-filled custom icon, not stars |
+| Upload | Upload files / Upload folder | `document-upload`-style arrow up, custom pair |
+| Folder sync mode | Synced / On-demand | — |
+| Stop syncing a folder | Stop syncing… | `media-playback-stop-symbolic` in a menu, not trash |
+| Remove a computer | Remove computer… | destructive, in menu |
+| Conflict copy | Conflict | `dialog-warning-symbolic` + warning colour |
+| Failure | Failed / Needs attention | `dialog-error-symbolic` + error colour |
+| Pause | Pause sync / Resume sync | `media-playback-pause-symbolic` / `-start-` |
+| Photos section | Photos | `image-x-generic-symbolic` |
+| Sharing | Shared by me / Shared with me | distinct icons (`emblem-shared` / `folder-publicshare`) |
+
+Spelling: US English throughout ("Favorite", "color"), matching the `pdfs favorite` command and
+Proton's own apps. Title Case for
+dialog headings and buttons in dialogs, Sentence case for menu items and rows (HIG).
+
+## 9. Bugs found during the audit (quick wins)
+
+1. Photos Upload pill loses its label (`photos.rs:426-432`); same for viewer "Show on map"
+   (`photo_viewer.rs:594-598`).
+2. Takeout Back always goes to Settings, sidebar highlights Settings when opened from Photos
+   (`main.rs:779`, `takeout.rs:131-136`).
+3. Thumbnail-build completion message computed then hidden (`browser.rs:1632-1667`).
+4. Search results show cached files as cloud-only (`browser.rs:2344`).
+5. Details "Available offline" switch shown for folders (`details.rs:259`).
+6. Grid and list keep separate selections; details pane can describe a hidden-view item.
+7. F2 silently does nothing with multiple items selected.
+8. Filter changes on the Albums grid swap to the timeline while the Albums toggle stays active
+   (`photos.rs:958-997`).
+9. Subtitle "60 photos" next to "All 1,416" (loaded count vs total, `photos.rs:2007-2015`); viewer
+   counter "12 of 60".
+10. Viewer info panel covers Close/Trash/Save (`photo_viewer.rs:588` vs `648`).
+11. Locations mode switch and removal reload Computers, not Locations; a rejected mode switch stays
+    flipped until the next tick (`devices.rs:612`, `devices.rs:809`, `locations.rs:374`).
+12. Going on-demand deletes local copies without confirmation.
+13. Retry on Not-connected silently restarts the systemd unit; Locations' Retry does not.
+14. Toasts from Versions/Share dialogs land behind the modal.
+15. "Emptied trash —" dangling dash, "item(s)", "archive(s)", raw revision id as version title,
+    raw lowercase link role.
+16. Bulk context menu shows a separator directly under the header when a folder is selected.
+17. Sign out, Reject invitation, Remove access, Delete link, tray Disconnect: no confirmation.
+18. Stale doc comments (`devices.rs:46-48`, `locations.rs:329-331`, `albums.rs:4`,
+    `browser.rs:1155`).
+
+## 10. Phased roadmap
+
+Each phase is shippable on its own. Estimates are rough, for one developer.
+
+| Phase | Content | Crates | Size |
+|---|---|---|---|
+| 0 Quick wins | Section 9 bugs, glossary wording, icon swaps (upload, offline, stop syncing), confirmations, plurals | gui, tray | S (2–3 days) |
+| 1 Shell | libadwaita feature bump, per-page header bars, sidebar restructure + footer (status, quota, account), Preferences dialog, About debug info, theme/colour cleanup, CSS to gresource, shortcuts dialog | gui | M (1 week) |
+| 2 Sync hub + pause | B-1 global pause, B-2 list/retry pending ops, Sync page (status card, Issues, Transfers, Folders, History), tray states and pause menu, GUI uses `failing_*` / `parked_*` | core, fuse, gui, tray, cli | L (1.5–2 weeks) |
+| 3 Conflicts | B-3 list + resolve, Issues rows with a compare/resolve dialog (both versions side by side: size, date, device, preview for images/text), CLI `pdfs conflicts` | core, fuse, gui, cli | M–L |
+| 4 File browser | Header layout, New menu, sort/persisted view, PopoverMenu context menus, details side pane, DnD upload, folder picker for Move, search scope | gui | L |
+| 5 Photos | Rename, header switcher, filters, infinite scroll + scrubber, tile layout, context menu, album management, viewer rewrite (auto-hide, zoom, inline video) | gui (+ core for album mutations) | L |
+| 6 Rest | Shared pages, Computers, Trash, Login, per-folder pause, bandwidth limits, i18n wrapping | all | M |
+
+Phase 2 is where the user-reported gaps (pause, resume, stuck items) get closed; phase 3 closes the
+conflict overview. Phases 0–1 fix most of the "unpolished" impression cheaply and should come first
+because later phases build on the new header/page skeleton.
+
+### Verification per phase
+
+- `cargo fmt --all -- --check`, `cargo clippy --workspace --all-targets -- -D warnings`,
+  `cargo test --workspace`.
+- Backend phases: DB migration tests in `crates/pdfs-core/src/db/tests.rs` (paused state, conflict
+  table if added), drain tests proving no op is claimed while paused, resolve-conflict tests proving
+  the losing side stays recoverable (trash or version history).
+- GUI phases: before/after screenshots in `images/` (light and dark), keyboard-only walkthrough of
+  each page, narrow-window check (sidebar collapse breakpoint).