chore(release): 2.8.0

chore(fuse): log how long each queued upload takes
"pending upload landed" now carries upload_ms, the time on the wire, and total_ms, the whole op including the conflict check and gap-fill. A slow drain then shows where its time goes without a profiler.
2026-11-04 16:56:59 +01:00 · 2026-09-30 03:56:47 +02:00 · 2026-09-30 03:55:48 +02:00 · 2026-09-30 03:25:00 +02:00 · 2026-09-30 03:25:00 +02:00 · 2026-09-29 21:22:54 +02:00
89 changed files with 14858 additions and 6037 deletions
@@ -32,8 +32,14 @@ jobs:
        with:
          toolchain: '1.96'
          components: rustfmt, clippy
          cache: false
      # Tags can only restore caches saved on main, so only main saves one. The
      # release workflow restores this key for its quality gates.
      - uses: swatinem/rust-cache@v2
        with:
          shared-key: debug
          save-if: ${{ github.ref == 'refs/heads/main' }}
      - name: Formatting
        run: cargo fmt --all -- --check
@@ -57,3 +63,37 @@ jobs:
  # Real Proton credentials and /dev/fuse deliberately do not run on pull
  # requests. Follow docs/TESTING.md on a dedicated test-account runner.
  # Keeps the release-profile dependencies cached on main, where the release
  # workflow can restore them; a tag cannot reuse the caches of earlier tags.
  release-cache:
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    runs-on: ubuntu-24.04
    steps:
      - uses: actions/checkout@v7
      - name: Install native dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y \
            pkg-config \
            libfuse3-dev \
            libgtk-4-dev \
            libadwaita-1-dev \
            libwebkitgtk-6.0-dev \
            libsecret-1-dev \
            libdbus-1-dev
      - name: Install minimum supported Rust
        uses: actions-rust-lang/setup-rust-toolchain@v1
        with:
          toolchain: '1.96'
          cache: false
      - uses: swatinem/rust-cache@v2
        with:
          shared-key: release
      - name: Release build
        run: cargo build --release --locked
@@ -10,8 +10,60 @@ permissions:
  contents: write
 jobs:
  checks:
    name: Release quality gates
    runs-on: ubuntu-24.04
    steps:
      - name: Checkout repository
        uses: actions/checkout@v7
      - name: Install system dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y \
            pkg-config \
            libfuse3-dev \
            libgtk-4-dev \
            libadwaita-1-dev \
            libwebkitgtk-6.0-dev \
            libsecret-1-dev \
            libdbus-1-dev
      - name: Set up Rust
        uses: actions-rust-lang/setup-rust-toolchain@v1
        with:
          toolchain: '1.96'
          components: rustfmt, clippy
          cache: false
      # A tag can read the caches of main but its own caches are useless to the next
      # tag, so this only restores what CI saved on main.
      - name: Cache Cargo target
        uses: swatinem/rust-cache@v2
        with:
          shared-key: debug
          save-if: false
      - name: Verify tag and manifest versions
        if: startsWith(github.ref, 'refs/tags/')
        shell: bash
        run: |
          tag_version="${GITHUB_REF_NAME#v}"
          manifest_version="$(sed -n 's/^version = "\([^"]*\)"/\1/p' Cargo.toml | head -n1)"
          pkgbuild_version="$(sed -n 's/^pkgver=//p' packaging/PKGBUILD | head -n1)"
          test "$tag_version" = "$manifest_version"
          test "$tag_version" = "$pkgbuild_version"
      - name: Release quality gates
        run: |
          cargo fmt --all -- --check
          cargo clippy --workspace --all-targets -- -D warnings
          cargo test --workspace --locked
          scripts/fuse-acceptance.sh --offline-only
  build-release:
-    name: Build and Release
+    name: Build packages
    runs-on: ubuntu-24.04
    environment: 'rpm signing'
@@ -38,27 +90,14 @@ jobs:
        uses: actions-rust-lang/setup-rust-toolchain@v1
        with:
          toolchain: '1.96'
-          components: rustfmt, clippy
+          cache: false
      # Restores the release-profile dependencies that CI builds on main.
      - name: Cache Cargo target
        uses: swatinem/rust-cache@v2
-
+        with:
-      - name: Verify tag and manifest versions
+          shared-key: release
-        if: startsWith(github.ref, 'refs/tags/')
+          save-if: false
        shell: bash
        run: |
          tag_version="${GITHUB_REF_NAME#v}"
          manifest_version="$(sed -n 's/^version = "\([^"]*\)"/\1/p' Cargo.toml | head -n1)"
          pkgbuild_version="$(sed -n 's/^pkgver=//p' packaging/PKGBUILD | head -n1)"
          test "$tag_version" = "$manifest_version"
          test "$tag_version" = "$pkgbuild_version"
      - name: Release quality gates
        run: |
          cargo fmt --all -- --check
          cargo clippy --workspace --all-targets -- -D warnings
          cargo test --workspace --locked
          scripts/fuse-acceptance.sh --offline-only
      - name: Build release binaries
        run: |
@@ -127,7 +166,7 @@ jobs:
          Maintainer: Nils Pukropp <contact@narl.io>
          Depends: fuse3, libgtk-4-1 (>= 4.12.0), libadwaita-1-0 (>= 1.5.0), libsecret-1-0, libwebkitgtk-6.0-4, libimage-exiftool-perl
          Installed-Size: ${INSTALLED_SIZE}
-          Homepage: https://github.com/narrrl/proton-drive-linux
+          Homepage: https://proton-drive.narl.io
          Description: Unofficial Proton Drive client for Linux
           Files-on-demand Proton Drive for the Linux desktop, unaffiliated with Proton AG:
           - FUSE virtual mount with block-level caching
@@ -152,6 +191,7 @@ jobs:
            --define "_topdir $PWD/rpmbuild" \
            --define "_sourcedir $PWD" \
            --define "git_dir $PWD" \
            --define "prebuilt 1" \
            --define "version ${RPM_VERSION}" \
            --define "_dbpath $PWD/rpmbuild/db" \
            packaging/proton-drive-linux.spec
@@ -190,8 +230,19 @@ jobs:
            *.rpm
          if-no-files-found: error
-      - name: Create GitHub Release
+  publish:
    name: Create GitHub Release
    needs: [checks, build-release]
    if: startsWith(github.ref, 'refs/tags/')
    runs-on: ubuntu-24.04
    steps:
      - name: Download packages
        uses: actions/download-artifact@v8
        with:
          name: proton-drive-linux-builds
      - name: Create GitHub Release
        uses: softprops/action-gh-release@v3
        with:
          files: |
@@ -205,7 +256,7 @@ jobs:
  aur:
    name: Publish AUR packages
-    needs: build-release
+    needs: publish
    if: startsWith(github.ref, 'refs/tags/')
    uses: ./.github/workflows/aur.yml
    with:
@@ -6,9 +6,10 @@ deliberately high — everything else is ordinary Rust review.
 ## Before you start
- Read [`AGENTS.md`](AGENTS.md) for repository conventions and
+- Read [`AGENTS.md`](AGENTS.md) for repository conventions,
-  [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) for how the daemon, front ends, and SDK fit
+  [`docs/DEVELOPMENT.md`](docs/DEVELOPMENT.md) for building, running and debugging from source,
-  together.
+  and [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) for how the daemon, front ends, and SDK fit
  together. [`docs/README.md`](docs/README.md) indexes the rest.
 - Check [`docs/BUGS.md`](docs/BUGS.md) — it is the authoritative issue ledger, and your problem may
  already be tracked there with context.
 - For anything larger than a fix, open an issue first so the design can be discussed before you
@@ -23,8 +24,9 @@ cargo build --workspace
 ```
 GUI and FUSE targets need the GTK4, libadwaita, WebKitGTK 6, libsecret, D-Bus, and FUSE3
-development packages listed in the [README](README.md#prerequisites). Minimum supported Rust
+development packages listed in [`docs/INSTALL.md`](docs/INSTALL.md#build-dependencies). Minimum
-version is 1.96.
+supported Rust version is 1.96. [`docs/DEVELOPMENT.md`](docs/DEVELOPMENT.md#running-from-source)
 explains how to run your build next to, or instead of, the installed service.
 ## Quality gates
@@ -51,6 +53,13 @@ use a dedicated test account, never one holding data you cannot lose.
  control-socket work stays off GTK's main thread.
 - **`staging/` and `recovery/` may hold the only copy of user data.** Nothing may clear or purge
  them opportunistically.
 - **The GUI is fully translated.** Wrap every user-visible string in the helpers from
  `crates/pdfs-gui/src/i18n.rs`, run `po/update.sh`, and translate the new entries in every
  catalog in `po/LINGUAS` in the same change. See [`docs/TRANSLATING.md`](docs/TRANSLATING.md).
  The CLI and daemon messages stay in English.
 - **Document what users see.** A new command, setting or behaviour belongs in the matching page
  under `docs/` (user guide, CLI reference or configuration) and in the `[Unreleased]` section of
  [`docs/CHANGELOG.md`](docs/CHANGELOG.md).
 ## Commits and pull requests
@@ -3474,7 +3474,7 @@ checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"
 [[package]]
 name = "pdfs-cli"
-version = "2.5.0"
+version = "2.8.0"
 dependencies = [
 "anyhow",
 "clap",
@@ -3489,7 +3489,7 @@ dependencies = [
 [[package]]
 name = "pdfs-core"
-version = "2.5.0"
+version = "2.8.0"
 dependencies = [
 "async-trait",
 "dbus-secret-service-keyring-store",
@@ -3513,7 +3513,7 @@ dependencies = [
 [[package]]
 name = "pdfs-fuse"
-version = "2.5.0"
+version = "2.8.0"
 dependencies = [
 "base64 0.23.1",
 "fuser",
@@ -3533,7 +3533,7 @@ dependencies = [
 [[package]]
 name = "pdfs-gui"
-version = "2.5.0"
+version = "2.8.0"
 dependencies = [
 "anyhow",
 "async-channel",
@@ -3773,9 +3773,9 @@ dependencies = [
 [[package]]
 name = "proton-drive-rs"
-version = "0.7.0"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0f6996724e51e99f03d2843828de9477afc39baa764403cb69490cabc1c4d93"
+checksum = "8807e007328fd08cad9fe93c84dd7cdb38dc97469250edf3d6b58c6df0ac0d4f"
 dependencies = [
 "async-trait",
 "base64 0.23.1",
@@ -3800,9 +3800,9 @@ dependencies = [
 [[package]]
 name = "proton-sdk"
-version = "0.7.0"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91cc25654133bd5714407a1df0996eaf214a6e8e0bb95d8139bc42e7cee31c34"
+checksum = "085cd6506a49d8892a2b7ed6b5db3909750d9844610178f55979ed330d9fe715"
 dependencies = [
 "aes-gcm 0.11.1",
 "async-trait",
@@ -3,20 +3,20 @@ resolver = "2"
 members = ["crates/pdfs-core", "crates/pdfs-fuse", "crates/pdfs-cli", "crates/pdfs-gui"]
 [workspace.package]
-version = "2.5.0"
+version = "2.8.0"
 edition = "2024"
 license = "MIT"
 authors = ["Nils Pukropp <contact@narl.io>"]
 rust-version = "1.96"
 repository = "https://github.com/narrrl/proton-drive-linux"
-homepage = "https://github.com/narrrl/proton-drive-linux"
+homepage = "https://proton-drive.narl.io"
 readme = "README.md"
 keywords = ["proton", "drive", "fuse", "sync", "linux"]
 categories = ["filesystem", "command-line-utilities"]
 [workspace.dependencies]
-proton-sdk = { version = "0.7.0" }
+proton-sdk = { version = "0.7.1" }
-proton-drive-rs = { version = "0.7.0" }
+proton-drive-rs = { version = "0.7.1" }
 # Internal crates.
 pdfs-core = { path = "crates/pdfs-core" }
@@ -4,513 +4,164 @@
 # Proton Drive for Linux
-**Files-on-demand Proton Drive for the Linux desktop** — a FUSE virtual mount with block-level
+**Proton Drive on the Linux desktop.** Your files as a folder that downloads on demand, synced
-caching, a scriptable CLI, and a native GTK4 app with tray and search launcher.
+local folders, Photos, sharing, and a native GTK4 app with tray and search launcher, plus a
 scriptable CLI.
 **[proton-drive.narl.io](https://proton-drive.narl.io)**
 [![CI](https://github.com/narrrl/proton-drive-linux/actions/workflows/ci.yml/badge.svg)](https://github.com/narrrl/proton-drive-linux/actions/workflows/ci.yml)
 [![Release](https://img.shields.io/github/v/release/narrrl/proton-drive-linux?sort=semver)](https://github.com/narrrl/proton-drive-linux/releases/latest)
 [![AUR](https://img.shields.io/aur/version/proton-drive-for-linux)](https://aur.archlinux.org/packages/proton-drive-for-linux)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Rust 1.96+](https://img.shields.io/badge/rust-1.96%2B-orange.svg)](https://www.rust-lang.org)
 [![Platform: Linux](https://img.shields.io/badge/platform-linux-lightgrey.svg)](#prerequisites)
-<img src="images/files.png" alt="The GTK4 file browser" width="820">
+<img src="images/files.png" alt="My files in the Proton Drive app" width="820">
 </div>
 > [!IMPORTANT]
 > This is an **unofficial**, community-built client. It is not affiliated with, endorsed by, or
 > supported by Proton AG. "Proton" and "Proton Drive" are trademarks of Proton AG, used here only
-> to describe what the software talks to. Use a test account first, and read
+> to describe what the software talks to. Try it with data you have another copy of first, and
-> [`docs/RECOVERY.md`](docs/RECOVERY.md) before trusting it with data you cannot lose.
+> read [what survives a lost machine](docs/RECOVERY.md) before you rely on it.
 ## Install
 ```bash
 # Debian / Ubuntu
 sudo apt install ./proton-drive-linux_*.deb
 # Fedora
 sudo dnf install ./proton-drive-linux-*.rpm
 # Arch Linux (AUR)
 paru -S proton-drive-for-linux        # or -git / -bin
 ```
 Packages for each release are attached to the [latest
 release](https://github.com/narrrl/proton-drive-linux/releases/latest); see
 [Installation & Packages](#installation--packages) for details and
 [Building from Source](#building-from-source) to compile it yourself.
 ```bash
 pdfs login          # sign in (SRP + 2FA, credentials go to the system keyring)
 pdfs status         # mount state, queued writes, cache usage
 pdfs-app            # the desktop app
 ```
 ## Contents
 - [Features](#features) · [Quick search](#quick-search-and-media-opening) · [Opening files](#choosing-how-files-open)
 - [Selective sync](#selective-sync-pdfsignore) · [Diagnostics](#diagnostics--maintenance) · [Scripting](#scripting---json)
 - [Performance](#performance--caching) · [Filesystem safety](#filesystem-safety) · [Screenshots](#screenshots)
 - [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) · [Translating](docs/TRANSLATING.md) ·
 [Known issues](docs/BUGS.md) · [Changelog](docs/CHANGELOG.md) ·
 [Contributing](CONTRIBUTING.md) · [Security policy](SECURITY.md)
 ## Features
- **Files-on-Demand (FUSE)**: Mount your Proton Drive as a virtual filesystem where files are downloaded only when opened, utilizing smart block-level caching and disk-backed writes.
+**Files**
 - **Command-Line Interface (CLI)**: Manage your drive, authenticate, and monitor sync status directly from the terminal.
 - **Non-Blocking GTK4 Desktop App**: Browse files, manage pins, configure options, and monitor active transfers through a modern, native GUI with a fully non-blocking asynchronous main loop.
 - **File Thumbnails**: Browse locally cached image previews in Files, Shared, and Trash, including embedded previews from camera RAW files. Build a whole folder tree from the Files toolbar and resize the grid from the status bar.
 - **Shared Links & Invites**: Browse files shared with you by other users, and view/manage your own public shared links directly in the GUI.
 - **Local Backup (Computers)**: Sync and back up local directories (like Downloads, Documents, Pictures, etc.) directly to your Proton Drive account.
 - **Locations**: One page (and `pdfs locations`) listing every place Proton Drive occupies on this machine — the main mount plus each backed-up folder — with its mode, sync state, and whether it is read-only. Switching a folder between a full local copy and on-demand happens here.
 - **System Tray Integration**: Background indicator for status monitoring, quick actions, and fast sync controls.
 - **Unified Search Launcher (HUD)**: A resident Google Drive-style launcher (`pdfs-prompt`) that searches Proton Drive and local files together, ranks the best matches, tolerates abbreviations and typos, and is ideal for a system-wide hotkey. It can also present the same search in your own launcher (`--dmenu`) or, searching live as you type, in `fzf` (`--fzf`).
 - **Secure Credential Storage**: Integrates with the system Secret Service (GNOME Keyring, KWallet, etc.) with smart in-memory credential caching to avoid UI thread blockages.
 - **Proton Photos Support**: Access your Proton Photos timeline, view thumbnails, and download backed-up media natively (available in the GUI as a navigation tab and via the CLI).
 - **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.
-## Quick Search and Media Opening
+- **Your Drive as a folder.** `~/ProtonDrive` works with every program. Files download when they
  are opened, a block at a time, so a video starts playing and a large archive can be read
  without fetching all of it.
 - **Available offline.** Keep chosen files and folders fully downloaded; everything else is
  cached within a size limit you set.
 - **Synced folders.** Back up folders such as `~/Documents` under your computer in Proton Drive,
  as a full two-way copy or online only. Gitignore-style `.pdfsignore` rules, conflict copies
  instead of overwrites, pause and bandwidth limits.
 - **Safe writes.** Changes are staged on disk and queued before they are acknowledged, so they
  survive a lost connection, a crash or a reboot and upload when they can.
-`pdfs-prompt` searches Drive metadata and the local home-directory index in one request. Results are ranked together rather than split by source. Matching is case-insensitive and supports exact names, prefixes, parent paths, multiple terms, punctuation-separated words, ordered abbreviations, common typos, and adjacent transpositions.
+**Desktop app**
-The prompt stays resident after its first launch, so invoking the shortcut again reuses and resets the existing window. Drive folders open from the mount. Audio and video results also open through FUSE, allowing media players to seek and request ranges without downloading the entire file first; ordinary Drive files are materialized into the local cache before opening.
+- **Browse** My files, Shared with me, Shared by me, Computers and Trash, with thumbnails
  (including camera RAW), drag and drop, details and **version history**.
 - **Photos.** Timeline with favorites, albums, and Places on a map; RAW+JPEG pairs shown as one
  photo; duplicate finder; slideshow; **import from Google Photos** (Takeout).
 - **Sharing.** Invite people as viewer, editor or admin, create public links with password and
  expiry, accept invitations.
 - **Sync overview.** What is uploading, what is waiting, what failed and why, and a history of
  what happened.
 - **Tray icon** with status, pause and quick actions, and a **search launcher** (`pdfs-prompt`)
  that searches Proton Drive and your home folder together, as its own window, through fuzzel,
  rofi or wofi, or live in `fzf`.
 - **Restore a computer.** Continue a backup on a new machine and bring its folders back in one
  step.
 - **Sign-in** with two-factor authentication and CAPTCHA; the session is kept in the system
  keyring.
 - Available in English, German, Spanish, French, Italian, Dutch, Polish and Brazilian
  Portuguese.
-### Using your own launcher (fuzzel, rofi, wofi, …)
+**Command line**
-`pdfs-prompt --dmenu` runs the same search through an external dmenu-style
+- About 55 `pdfs` commands cover files, sync, sharing, Photos, Trash, versions and diagnostics.
-launcher instead of the built-in window, so the HUD matches the rest of a
+  Query commands print JSON with `--json`.
 tiling-WM desktop:
-```bash
+## Install
 pdfs-prompt --dmenu                                   # fuzzel/rofi/wofi/tofi/bemenu/dmenu, whichever is installed
 pdfs-prompt --dmenu --menu 'fuzzel --dmenu --width 60'
 pdfs-prompt --dmenu --query invoice                   # skip straight to a search
 ```
-A launcher filters a fixed list — it cannot ask for a new one per keystroke — so
+| Distribution | Package |
 searching takes two steps, and the prompt says which step you are on:
 - `Search Drive ›` lists your pinned files. Type anything that isn't one of them
  and press Enter to search for it.
 - `Drive: invoice ›` lists the results. Enter opens one; typing something else
  and pressing Enter searches again. Escape closes.
 `--query` skips the first step. fuzzel and rofi also get file-type icons.
 To make an existing keybinding use it without re-binding, and to pin the
 launcher command, set them in `config.json`:
 ```json
 {
  "prompt": {
    "mode": "dmenu",
    "menu": ["fuzzel", "--dmenu", "--width", "60"],
    "menu_limit": 50
  }
 }
 ```
 `--gtk` overrides `"mode": "dmenu"` for one invocation. A `{prompt}` token
 anywhere in `menu` is replaced by the prompt text; without one, the launcher's
 own prompt flag is appended.
 ### Live launcher search (fzf)
 The two-step above exists because no dmenu-style launcher can call back for new
 results per keystroke. `fzf` can, so `pdfs-prompt --fzf` searches as you type,
 exactly like the built-in window:
 ```bash
 pdfs-prompt --fzf                    # pinned files, then live results as you type
 pdfs-prompt --fzf --query invoice    # start on a search
 ```
 Every keystroke re-queries the daemon (debounced, like the GTK prompt) and fzf's
 own matcher is switched off, so the ordering you see is the daemon's ranking —
 abbreviations and typos included, which a launcher filtering a fixed list cannot
 do. Enter opens; Escape closes.
 fzf is a terminal program, so when it is started without one — from a WM
 keybinding — it spawns a terminal for itself: foot, ghostty, kitty, alacritty,
 wezterm or xterm, whichever is installed. Each is launched with the app-id/class
 `pdfs-prompt`, so one window rule floats it whichever terminal you have. In
 Hyprland:
 ```
 windowrulev2 = float, class:^(pdfs-prompt)$
 windowrulev2 = size 900 500, class:^(pdfs-prompt)$
 windowrulev2 = center, class:^(pdfs-prompt)$
 bind = SUPER, space, exec, pdfs-prompt --fzf
 ```
 Set it as the default front end, and pick the terminal explicitly, in
 `config.json`:
 ```json
 {
  "prompt": {
    "mode": "fzf",
    "terminal": ["foot", "--app-id=pdfs-prompt", "--"],
    "menu_limit": 50
  }
 }
 ```
 A `{cmd}` token anywhere in `terminal` is replaced by the command to run;
 without one it is appended, which is what every detected terminal expects.
 ## Choosing How Files Open
 By default every result is handed to `xdg-open`. An `open_with` block in
 `config.json` overrides that per file type — for instance opening text in
 Neovim inside Alacritty, while everything else still goes to the desktop:
 ```json
 {
  "open_with": {
    "terminal": ["alacritty", "-e"],
    "rules": [
      { "match": ["@text"], "command": ["nvim"], "terminal": true },
      { "match": ["*.png", "*.jpg"], "command": ["imv"] }
    ]
  }
 }
 ```
 - `match` takes file-name globs (`*.md`, `notes-*.txt`) or the classes `@dir`,
  `@text`, `@document`, `@image`, `@media`, `@any`. First matching rule wins.
 - `command` is argv, not a shell line. A `{}` token is replaced by the path;
  without one the path is appended. `$VAR` tokens expand from the environment,
  so `["$EDITOR"]` follows your editor.
 - `"terminal": true` wraps the command in `terminal`. When that is unset, the
  terminal comes from `$PDFS_TERMINAL`, then `$TERMINAL`, then the first known
  emulator on `PATH`; a bare name like `TERMINAL=alacritty` gains the right
  "run this" flag automatically.
 - `"default": [...]` replaces `xdg-open` for everything unmatched.
 The rules apply to the prompt (both front ends) and to the GTK browser, so a
 file opens the same way wherever it was picked. Patterns are matched against the
 Drive name — a downloaded file is stored in the cache under its content hash,
 which says nothing about its type, so matching that would send everything to
 `xdg-open`.
 ## Selective Sync (`.pdfsignore`)
 Two-way synced folders skip paths matched by ignore rules, so syncing a project
 directory does not upload `node_modules/`, `target/`, or `.git/`.
 Rules come from two places, and both apply:
 1. **Per folder** — a `.pdfsignore` file at the root of the synced folder
   (`.protonignore` also works). Gitignore syntax, including negation:
   ```gitignore
   # everything build-related
   build/
   *.log
   # ...except this one
   !important.log
   ```
 2. **Globally** — an `ignore_patterns` list in `config.json`, applied to every
   synced folder. When unset, sensible defaults apply: `.git/`, `.hg/`, `.svn/`,
   `node_modules/`, `target/`, `.venv/`, `__pycache__/`, `*~`, `*.swp`, `*.tmp`,
   `.DS_Store`, and `Thumbs.db`.
   ```json
   {
     "ignore_patterns": ["node_modules/", "target/", "*.iso"]
   }
   ```
   Set it to `[]` to opt out of the defaults entirely.
 Rules are re-read at the start of every sync pass, so edits take effect on the
 next pass without restarting the daemon.
 **Ignoring is never destructive.** If a rule starts matching a file that was
 already synced, its copy on Drive is left untouched — the file simply stops
 being tracked. Removing the rule later picks the existing remote file back up
 rather than re-uploading it.
 ## Diagnostics & Maintenance
 When something looks wrong, `pdfs diagnose` checks the installation and prints a
 report. It runs without a daemon on purpose — the state worth diagnosing is
 usually the state where the daemon will not start:
 ```console
 $ pdfs diagnose
 Paths
 [ok  ]   state dir: /home/you/.local/state/proton-drive-linux
 [ok  ]   database: /home/you/.local/state/proton-drive-linux/cache.db (170.3 MiB)
 Account
 [ok  ]   keyring session: you@proton.me
 Daemon
 [ok  ]   daemon responding
 [ok  ]   mounted at: /home/you/ProtonDrive
 [ok  ]   queued writes: none
 No problems found.
 ```
 It exits non-zero if any check fails, so it works in a health-check script.
 For the local metadata database and content cache:
 | Command | What it does |
 |---|---|
-| `pdfs cache inspect` | Database size, reclaimable space, per-table row counts, cache usage against budget |
+| Debian, Ubuntu 24.04 or newer | `.deb` from the [latest release](https://github.com/narrrl/proton-drive-linux/releases/latest) |
-| `pdfs cache inspect --deep` | Also runs SQLite's integrity check — reads every page, so it is slow on a large database |
+| Fedora 44 or newer | `.rpm` from the [latest release](https://github.com/narrrl/proton-drive-linux/releases/latest) |
-| `pdfs cache vacuum` | Checkpoints the write-ahead log and compacts the database |
+| Arch Linux | [`proton-drive-for-linux`](https://aur.archlinux.org/packages/proton-drive-for-linux) (also `-bin` and `-git`) in the AUR |
-| `pdfs cache clear` | Deletes cached file content, keeping pinned files |
+| Anything else | [Build from source](docs/INSTALL.md#build-from-source) |
-`vacuum` takes a write lock for its duration and needs room for a second copy of
+```bash
-the database while it runs, so it is a deliberate operation rather than
+sudo apt install ./proton-drive-linux_*.deb        # Debian, Ubuntu
-something the daemon does on a timer.
+sudo dnf install ./proton-drive-linux-*.rpm        # Fedora
-
+paru -S proton-drive-for-linux                     # Arch
 Before a release, run the real-kernel acceptance suite against a dedicated test
 account and mount. See [`docs/TESTING.md`](docs/TESTING.md); it includes optional
 two-mount convergence checks and confines destructive operations to a fresh
 test directory.
 ## Scripting (`--json`)
 Query commands accept a global `--json` flag and emit machine-readable output:
 ```console
 $ pdfs --json sync list | jq '.items[] | select(.state != "idle") | .local_path'
 $ pdfs --json cache inspect | jq '.db_reclaimable_bytes'
 $ pdfs --json status | jq -r '.mount.mountpoint'
 ```
-Supported on `status`, `ls`, `pins`, `sync list`, `devices list`, `transfers`,
+Then open **Proton Drive** from your applications menu and sign in. The app starts the background
-`activity`, and `cache inspect`. Commands that perform an action keep their
+service, and your files appear in `~/ProtonDrive`.
 human output — a script that needs to know whether one worked has the exit code.
-Two things worth relying on:
+Signing in from a terminal instead? `pdfs login` stores the session but does not start the
 service. Enable it once:
- **The payload is unwrapped.** Output is `{"items": […]}`, not the daemon's
+```bash
-  internal `{"SyncFolders": {"items": […]}}`, so scripts never name an internal
+pdfs login
-  variant.
+systemctl --user enable --now proton-drive.service
- **Errors still fail.** A daemon-side error prints its JSON body (with a
+pdfs status
-  machine-readable `kind`) on stdout *and* exits non-zero, so `set -e` and
+```
  `if pdfs …` behave as expected rather than treating a failed lookup as
  success.
-## Performance & Caching
+[docs/INSTALL.md](docs/INSTALL.md) has the requirements, optional extras (tray on GNOME, RAW and
 video thumbnails), headless use and uninstalling.
-The client includes several optimizations designed for high efficiency, a low memory footprint, and a responsive user experience:
+## Documentation
- **On-Demand Block Cache**: Files are read in fixed 4 MiB blocks. For unpinned files, the client fetches and caches only the blocks containing the requested byte ranges. This enables fast sequential and sparse reads (e.g. media streaming or metadata scanning) without downloading entire files.
+| | |
- **Disk-Backed Writes**: Large file writes are staged on disk in temporary scratch files (rather than fully buffered in RAM) and track modified byte intervals. Only the unedited remote segments are fetched at commit time, keeping memory usage minimal.
+|---|---|
- **Non-Blocking GTK4 Loop**: To prevent UI freezes, all synchronous D-Bus credential checks, control socket requests, and cache usage calculations are offloaded to background worker threads or fetched asynchronously.
+| [User guide](docs/USER_GUIDE.md) | Everything the app, tray and launcher do |
- **Flicker-Free UI Rendering**: The GTK4 application performs differential rendering of the pins list, only modifying list rows when the list content changes, preserving the user's scroll position and widget focus.
+| [Command-line reference](docs/CLI.md) | Every `pdfs` command and scripting with `--json` |
- **Durable Staging**: Scratch metadata and staged writes are synced and atomically published before an upload is acknowledged locally. Rapid revisions supersede pending work transactionally.
+| [Configuration](docs/CONFIGURATION.md) | `config.json`, file locations, environment variables, the service |
-
+| [Troubleshooting](docs/TROUBLESHOOTING.md) | Diagnosing problems and fixing common ones |
-## Filesystem Safety
+| [Recovering on a new computer](docs/RECOVERY.md) | Getting your synced folders back after a reinstall or a lost machine |
-
+| [Changelog](docs/CHANGELOG.md) | What changed in each release |
 Version 1.0 strengthens the boundaries around local-only data and destructive reconciliation:
 - Truncate composes with queued revisions, preserving the authoritative prefix and correct zero-filled growth.
 - Combined move-and-rename operations are queued durably and tolerate partially completed remote state.
 - Session tombstones prevent successfully unlinked entries from reappearing through eventually consistent listings.
 - Names are valid UTF-8 and no longer than Linux's 255-byte component limit.
 - Incomplete mirror scans are non-destructive, and total-wipe protection covers every non-empty baseline.
 - Failed conflict preservation, local deletion, or staging publication does not settle a new baseline or discard the only local copy.
 - State, cache, and config directories must be real, current-user-owned `0700` directories; control sockets are `0600`.
 For contributors: [development guide](docs/DEVELOPMENT.md), [architecture](docs/ARCHITECTURE.md),
 [testing](docs/TESTING.md), [translating](docs/TRANSLATING.md), [roadmap](docs/ROADMAP.md) and the
 [bug ledger](docs/BUGS.md). The [documentation index](docs/README.md) lists everything.
 ## Screenshots
 ### GUI Application & Launcher
 <table>
  <tr>
-    <td align="center" width="50%"><img src="images/login.png" alt="Login Screen" width="100%"><br><sub><b>Login Screen</b></sub></td>
+    <td align="center" width="50%"><img src="images/files.png" alt="My files" width="100%"><br><sub><b>My files</b></sub></td>
-    <td align="center" width="50%"><img src="images/files.png" alt="Files Browser" width="100%"><br><sub><b>Files Browser</b></sub></td>
+    <td align="center" width="50%"><img src="images/photos.png" alt="Photos timeline" width="100%"><br><sub><b>Photos</b></sub></td>
  </tr>
  <tr>
-    <td align="center" width="50%"><img src="images/shared.png" alt="Shared Links" width="100%"><br><sub><b>Shared Links</b></sub></td>
+    <td align="center" width="50%"><img src="images/photos_map.png" alt="Photos places map" width="100%"><br><sub><b>Places</b></sub></td>
-    <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>
+    <td align="center" width="50%"><img src="images/computers.png" alt="Computers" width="100%"><br><sub><b>Computers</b></sub></td>
  </tr>
  <tr>
-    <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/sync.png" alt="Sync folders" width="100%"><br><sub><b>Sync</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>
+    <td align="center" width="50%"><img src="images/conflicts.png" alt="Sync history showing resolved conflicts" width="100%"><br><sub><b>Sync history</b></sub></td>
  </tr>
  <tr>
-    <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_gtk.png" alt="Search launcher" width="100%"><br><sub><b>Search launcher</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>
+    <td align="center" width="50%"><img src="images/prompt_fzf.png" alt="Search launcher in fzf" width="100%"><br><sub><b>Search launcher in 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/login.png" alt="Sign in" width="100%"><br><sub><b>Sign in</b></sub></td>
-    <td align="center" width="50%"><img src="images/settings.png" alt="Settings" width="100%"><br><sub><b>Settings</b></sub></td>
+    <td></td>
  </tr>
 </table>
---
+## How it works
-## Prerequisites
+A background service (`proton-drive.service`, the `pdfs daemon` command) holds your session,
 mounts `~/ProtonDrive` through FUSE, runs the upload queue and the sync engine, and follows
 Proton's event stream for changes made elsewhere. The app, the tray, the launcher and the CLI are
 clients of that service over a local socket. Everything is end-to-end encrypted with your Proton
 keys before it leaves the machine, through a Rust implementation of Proton's Drive SDK.
-To compile the application from source or run the built binaries, ensure you have the following system libraries installed on your distribution:
+Files you open are decrypted into a local cache so programs can read them. What that means for
-
+the security of the machine is spelled out in the
-### Ubuntu / Debian (24.04+)
+[threat model](docs/ARCHITECTURE.md#8-threat-model-what-this-client-writes-to-disk-in-plaintext).
 ```bash
 sudo apt-get update
 sudo apt-get install -y \
  pkg-config \
  libfuse3-dev \
  libgtk-4-dev \
  libadwaita-1-dev \
  libwebkitgtk-6.0-dev \
  libsecret-1-dev \
  libdbus-1-dev \
  libimage-exiftool-perl
 ```
 ### Arch Linux
 ```bash
 sudo pacman -S --needed pkgconf fuse3 gtk4 libadwaita libsecret dbus webkitgtk-6.0 perl-image-exiftool
 ```
 ### Fedora (44+)
 ```bash
 sudo dnf install -y \
  pkgconf-pkg-config fuse3-devel gtk4-devel libadwaita-devel \
  webkitgtk6.0-devel libsecret-devel dbus-devel glib2-devel \
  perl-Image-ExifTool cargo rust
 ```
 Runtime extras (pick your desktop):
 ```bash
 # GNOME — keyring + tray (AppIndicator)
 sudo dnf install -y gnome-keyring gnome-shell-extension-appindicator xdg-utils
 # KDE Plasma — KWallet (Secret Service); tray works via built-in SNI
 sudo dnf install -y kwallet xdg-utils
 ```
 ---
 ## Building from Source
 Ensure you have Rust and Cargo installed (minimum supported Rust version is 1.96).
 1. Clone the repository and navigate into the project directory:
   ```bash
   git clone https://github.com/narrrl/proton-drive-linux.git
   cd proton-drive-linux
   ```
 2. Build the workspace in release mode:
   ```bash
   cargo build --release --locked
   ```
 The compiled binaries will be available under `target/release/`:
 - `pdfs`: The CLI utility.
 - `pdfs-app`: The GTK4 application.
 - `pdfs-tray`: The tray status notifier.
 - `pdfs-prompt`: The launcher prompt for quick HUD search.
 ---
 ## Installation & Packages
 ### 1. Debian / Ubuntu (.deb)
 Install the debian package via `dpkg` or `apt`:
 ```bash
 sudo apt install ./proton-drive-linux_*.deb
 ```
 ### 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
 ```
 ### 3. Fedora (local RPM)
 A local `.spec` is available under `packaging/`. From the repository root:
 ```bash
 sudo dnf install -y rpm-build
 rpmbuild -bb packaging/proton-drive-linux.spec \
  --define "git_dir $PWD" \
  --define "_rpmdir $PWD/packaging/out" \
  --define "_builddir $PWD/packaging/build" \
  --define "_sourcedir $PWD" \
  --define "_specdir $PWD/packaging" \
  --define "_srcrpmdir $PWD/packaging/out"
 sudo dnf install packaging/out/x86_64/proton-drive-linux-*.rpm
 ```
 ---
 ## Automated Releases (CI/CD)
 This project has a GitHub Actions CI workflow configured under `.github/workflows/release.yml`.
 ### How it works:
 1. **Triggers**: 
   - Pushing a git tag matching `v*` (e.g. `git tag v0.1.0 && git push origin v0.1.0`).
   - Manual runs via the **Actions** tab in GitHub (**workflow_dispatch**).
 2. **Quality Gates and Build Process**:
   - For tagged builds, verifies that the tag, workspace version, and `packaging/PKGBUILD` version agree.
   - Runs `cargo fmt`, Clippy with warnings denied, the locked workspace test suite, and the account-free FUSE acceptance contract.
   - Spawns an Ubuntu runner and installs GTK4, Libadwaita, FUSE3, and Secret Service packages.
   - Sets up the Rust compiler and caches build targets to speed up runs.
   - Compiles the workspace members in release mode.
 3. **Artifact Packaging**:
   - Generates a `.tar.gz` containing the raw binaries (`pdfs`, `pdfs-app`, `pdfs-tray`, `pdfs-prompt`).
   - Packs them into Debian (`.deb`) and Fedora (`.rpm`) packages.
   - Includes the systemd user service and tray autostart entry in the Debian package.
 4. **Publishing**:
   - Creates a GitHub Release matching the pushed tag and uploads the `.deb`, `.rpm`, and `.tar.gz` packages as release assets.
   - For manual runs, compiles and exposes the packages as workflow run artifacts for testing.
 ---
 ## Contributing
-Bug reports, packaging fixes, and patches are welcome — see [CONTRIBUTING.md](CONTRIBUTING.md) for
+Bug reports, translations and patches are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for the
-the workflow and the quality gates CI enforces, and [SECURITY.md](SECURITY.md) for reporting a
+workflow and the checks CI runs, and [SECURITY.md](SECURITY.md) to report a vulnerability
-vulnerability privately.
+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).
 The Places map uses [GeoNames](https://www.geonames.org/) data (CC BY 4.0) and
 [Natural Earth](https://www.naturalearthdata.com/) outlines (public domain). The optional street
 map comes from [OpenFreeMap](https://openfreemap.org/), © [OpenStreetMap](https://www.openstreetmap.org/copyright)
 contributors.
 Proton Drive is a service of Proton AG. This project is an independent client and carries no
 affiliation with or endorsement from Proton AG.
@@ -30,5 +30,10 @@ the interesting boundaries are:
 - **Cryptography.** Key derivation, signature handling, and anything that could publish plaintext
  or the wrong key material to Proton.
 What the client deliberately keeps in plaintext on disk, and why, is documented in the
 [threat model](docs/ARCHITECTURE.md#8-threat-model-what-this-client-writes-to-disk-in-plaintext).
 Behaviour described there is known and not a vulnerability by itself; a way to make it worse
 than described is.
 Out of scope: vulnerabilities in Proton's own service (report those to Proton AG), and issues that
 require an attacker who already has your user account on the machine.
@@ -30,7 +30,7 @@ struct Cli {
    /// Emit machine-readable JSON instead of formatted text.
    ///
    /// Applies to the query commands (`status`, `ls`, `pins`, `sync list`,
-    /// `devices list`, `locations`, `transfers`, `activity`, `cache inspect`). Commands that
+    /// `devices list`, `locations`, `transfers`, `activity`, `trash`, `cache inspect`). Commands that
    /// perform an action keep their human output — a script that needs to know
    /// whether one succeeded has the exit code.
    #[arg(long, global = true)]
@@ -290,12 +290,17 @@ enum Command {
        /// New name (a single path component).
        new_name: String,
    },
-    /// Move a file or folder into another folder via the running daemon.
+    /// Move files or folders into another folder via the running daemon.
    ///
    /// The paths may be in different locations: My files and any synced
    /// folder, on-demand or mirrored. The move happens on Proton Drive, so
    /// nothing is downloaded or uploaded again, unlike `mv` between two
    /// locations. The last path is the destination folder.
    Move {
-        /// File/folder path, inside the mountpoint or relative to it.
+        /// Files/folders to move, then the destination folder: each inside a
-        path: PathBuf,
+        /// location, or relative to the mountpoint.
-        /// Destination folder path, inside the mountpoint or relative to it.
+        #[arg(required = true, num_args = 2.., value_name = "PATH")]
-        new_parent: PathBuf,
+        paths: Vec<PathBuf>,
    },
    /// Trash a file or folder via the running daemon.
    Rm {
@@ -800,7 +805,10 @@ fn main() -> Result<()> {
            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::Move { mut paths } => {
            let new_parent = paths.pop().expect("clap requires at least two paths");
            cmd_move(paths, new_parent)
        }
        Command::Rm { path } => cmd_rm(path),
        Command::Mkdir { parent, name } => cmd_mkdir(parent, name),
        Command::Upload { sources, parent } => cmd_upload(sources, parent),
@@ -2439,15 +2447,34 @@ fn cmd_rename(path: PathBuf, new_name: String) -> Result<()> {
    Ok(())
 }
-fn cmd_move(path: PathBuf, new_parent: PathBuf) -> Result<()> {
+/// Move each of `sources` into `new_parent`, one request each. A refusal names
 /// its source and the rest still move; the command fails if any did not.
 fn cmd_move(sources: Vec<PathBuf>, new_parent: PathBuf) -> Result<()> {
    let new_parent = path_arg(&new_parent)?;
    let mut failed = 0;
    for source in &sources {
        let outcome = path_arg(source).and_then(|path| {
            match control_request(CtlRequest::Move {
-        path: path_arg(&path)?,
+                path,
-        new_parent: path_arg(&new_parent)?,
+                new_parent: new_parent.clone(),
            })? {
-        CtlResponse::Ok { message } => println!("{message}"),
+                CtlResponse::Ok { message } => Ok(message),
                CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
                other => bail!("unexpected response: {other:?}"),
            }
        });
        match outcome {
            Ok(message) => println!("{message}"),
            Err(e) if sources.len() == 1 => return Err(e),
            Err(e) => {
                eprintln!("{}: {e:#}", source.display());
                failed += 1;
            }
        }
    }
    if failed > 0 {
        bail!("{failed} of {} could not be moved", sources.len());
    }
    Ok(())
 }
@@ -2524,7 +2551,11 @@ fn cmd_diagnostics() -> Result<()> {
 }
 fn cmd_trash() -> Result<()> {
-    match control_request(CtlRequest::ListTrash)? {
+    let response = control_request(CtlRequest::ListTrash)?;
    if emit_json(&response)? {
        return Ok(());
    }
    match response {
        CtlResponse::Entries { entries } if entries.is_empty() => println!("(trash is empty)"),
        CtlResponse::Entries { entries } => {
            for e in entries {
@@ -730,6 +730,60 @@ impl ContentCache {
        Some(buf)
    }
    /// Write the whole content of `uid` at `(mtime, size)` to `dst` from the
    /// cache alone, and report whether that worked.
    ///
    /// A whole-file blob is cloned. Otherwise every block of the revision has to
    /// be cached, under its recorded geometry or, failing that, the uniform one
    /// the read path would use. Anything short of the full content leaves
    /// nothing at `dst`, so a caller falls back to a download with a clean slate.
    ///
    /// This is what lets a mirror folder take a file an on-demand mount has
    /// already read, after a move between them, without fetching it again. The
    /// trust is the read path's: the same `(mtime, size)` key, and blocks that
    /// were validated when they were fetched.
    pub fn copy_cached_to(&self, uid: &NodeUid, mtime: i64, size: u64, dst: &Path) -> bool {
        if size == 0 {
            return false;
        }
        if let Some(blob) = self.valid_blob(uid, mtime, size) {
            if Self::clone_or_copy(&blob, dst).is_ok_and(|len| len == size) {
                self.touch(Self::key(uid));
                return true;
            }
            let _ = std::fs::remove_file(dst);
            return false;
        }
        let geometry = self
            .block_geometry(uid, mtime, size)
            .unwrap_or_else(|| BlockGeometry::uniform(size));
        if geometry.size() != size {
            return false;
        }
        let spans = geometry.spans(0, size);
        // Checked up front so a file with one block missing costs stats, not a
        // copy of every block before it.
        if !spans
            .iter()
            .all(|&span| self.has_block(uid, mtime, size, span))
        {
            return false;
        }
        let written = (|| -> Option<()> {
            use std::io::Write;
            let mut out = std::fs::File::create(dst).ok()?;
            for span in spans {
                out.write_all(&self.cached_block(uid, mtime, size, span)?)
                    .ok()?;
            }
            (out.metadata().ok()?.len() == size).then_some(())
        })();
        if written.is_none() {
            let _ = std::fs::remove_file(dst);
        }
        written.is_some()
    }
    /// Store `bytes` as the cached content for `uid`, tagged with `(mtime,
    /// size)`. The blob is written to a temp file then renamed so a concurrent
    /// reader never sees a partial blob; the meta tag is written last so a
@@ -2561,6 +2615,46 @@ mod tests {
        assert!(c.cached_block(&u, 100, 5000, blk(5000, 0)).is_none());
    }
    #[test]
    fn a_cached_blob_is_copied_out_whole() {
        let (c, d) = cache();
        let u = uid("blob");
        c.store(&u, 7, 5, b"hello").unwrap();
        let dst = d.path().join("out");
        assert!(c.copy_cached_to(&u, 7, 5, &dst));
        assert_eq!(std::fs::read(&dst).unwrap(), b"hello");
        // Another revision is not this one.
        assert!(!c.copy_cached_to(&u, 8, 5, &d.path().join("stale")));
        assert!(!d.path().join("stale").exists());
    }
    #[test]
    fn cached_blocks_are_copied_out_in_order() {
        let (c, d) = cache();
        let u = uid("blocks");
        let size = BLOCK_SIZE + 3;
        let first = vec![1_u8; BLOCK_SIZE as usize];
        c.store_block(&u, 7, size, blk(size, 0), &first).unwrap();
        c.store_block(&u, 7, size, blk(size, 1), b"end").unwrap();
        let dst = d.path().join("out");
        assert!(c.copy_cached_to(&u, 7, size, &dst));
        let bytes = std::fs::read(&dst).unwrap();
        assert_eq!(bytes.len() as u64, size);
        assert_eq!(&bytes[..BLOCK_SIZE as usize], first.as_slice());
        assert_eq!(&bytes[BLOCK_SIZE as usize..], b"end");
    }
    #[test]
    fn a_file_with_a_block_missing_is_not_copied_out() {
        let (c, d) = cache();
        let u = uid("partial");
        let size = BLOCK_SIZE + 3;
        c.store_block(&u, 7, size, blk(size, 1), b"end").unwrap();
        let dst = d.path().join("out");
        assert!(!c.copy_cached_to(&u, 7, size, &dst));
        assert!(!dst.exists(), "a partial copy must not be left behind");
    }
    /// The [`BlockSpan`] the uniform geometry gives block `idx` of a file of
    /// `size` bytes — the shape these tests were written against, and the one
    /// this client's own uploads still have.
@@ -339,7 +339,10 @@ pub enum Request {
    /// single path component (no separators). Replies with [`Response::Ok`].
    Rename { path: String, new_name: String },
    /// Move a file or folder into a new parent folder. Both `path` and
-    /// `new_parent` are mountpoint-relative. Replies with [`Response::Ok`].
+    /// `new_parent` are mountpoint-relative, or both absolute local paths; two
    /// absolute paths may lie in different locations (My files, an on-demand
    /// or a mirror synced folder), and the move is still made on Proton Drive
    /// without transferring content. Replies with [`Response::Ok`].
    Move { path: String, new_parent: String },
    /// Trash a file or folder. `path` is mountpoint-relative. Replies with
    /// [`Response::Ok`].
@@ -559,6 +559,15 @@ impl Db {
        if listed != Some(1) {
            return Ok(None);
        }
        drop(conn);
        self.known_children(parent).map(Some)
    }
    /// The children the DB knows under `parent`, whether or not the folder's
    /// listing is still marked complete. Only for when nothing better can be
    /// had: a listing dropped as stale may miss or keep a child.
    pub fn known_children(&self, parent: &NodeUid) -> Result<Vec<Node>> {
        let conn = self.read();
        let mut stmt = conn.prepare(
            "SELECT node_json FROM nodes
             WHERE parent_uid = ?1 AND node_json IS NOT NULL AND trashed = 0",
@@ -568,7 +577,7 @@ impl Db {
        for json in rows {
            out.push(serde_json::from_str(&json?)?);
        }
-        Ok(Some(out))
+        Ok(out)
    }
    // --- Content-cache LRU index (P4) -------------------------------------
@@ -66,6 +66,52 @@ pub fn op_supersedes(kind: &str) -> bool {
    matches!(kind, OP_REVISION | OP_RENAME | OP_TRASH)
 }
 /// Delete the ops that removing `uid` takes with it, returning the staged blobs
 /// they held.
 ///
 /// That is every op for `uid` or for anything queued beneath it, plus the
 /// revisions of files the node tree places beneath it. A revision op carries
 /// no `parent_uid`, so the queue alone cannot tell that its file sits inside
 /// a removed folder: the upload outlived the folder, failed forever against a
 /// trashed node, and kept its blob on disk (`docs/BUGS.md` B102).
 ///
 /// Only revisions are taken from the node tree. A queued rename that moved a
 /// node *into* the folder has to land, or the node would stay where it was
 /// on the server instead of going to the trash with the folder.
 fn drop_doomed_ops(tx: &rusqlite::Transaction<'_>, uid: &str) -> Result<Vec<String>> {
    const DOOMED: &str = "
        WITH RECURSIVE
          queued(uid) AS (
            SELECT ?1
            UNION
            SELECT p.uid FROM pending_op p JOIN queued q ON p.parent_uid = q.uid
          ),
          below(uid) AS (
            SELECT ?1
            UNION
            SELECT n.uid FROM nodes n JOIN below b ON n.parent_uid = b.uid
          ),
          doomed(id) AS (
            SELECT id FROM pending_op
            WHERE uid IN (SELECT uid FROM queued)
               OR (kind = 'revision' AND uid IN (SELECT uid FROM below))
          )";
    let blobs: Vec<String> = {
        let mut stmt = tx.prepare(&format!(
            "{DOOMED}
             SELECT blob_path FROM pending_op
             WHERE id IN (SELECT id FROM doomed) AND blob_path IS NOT NULL"
        ))?;
        let rows = stmt.query_map(params![uid], |r| r.get::<_, String>(0))?;
        rows.collect::<std::result::Result<Vec<_>, _>>()?
    };
    tx.execute(
        &format!("{DOOMED} DELETE FROM pending_op WHERE id IN (SELECT id FROM doomed)"),
        params![uid],
    )?;
    Ok(blobs)
 }
 /// The volume id given to a node that exists only on this machine, so far. A
 /// real [`NodeUid`] is `{volume}~{link}`, so a placeholder is `local~<uuid>` and
 /// round-trips through the same `Display`/parse path as any other uid.
@@ -174,6 +220,24 @@ pub struct AttachedBlob {
 }
 impl Db {
    /// Whether a queued trash still holds `name` somewhere.
    ///
    /// A replacing rename or a delete-then-recreate queues the trash of the old
    /// node ahead of the op that wants its name. With several drain workers the
    /// later op can run first and find the name still taken; this tells it to
    /// wait for the trash rather than land under a conflict name.
    pub fn has_pending_trash_named(&self, name: &str) -> Result<bool> {
        let conn = self.read();
        conn.query_row(
            "SELECT EXISTS(
                SELECT 1 FROM pending_op WHERE kind = ?1 AND name = ?2
             )",
            params![OP_TRASH, name],
            |row| row.get(0),
        )
        .map_err(Into::into)
    }
    /// Whether a specific desired-state operation is still queued for a node.
    pub fn has_pending_op(&self, uid: &str, kind: &str) -> Result<bool> {
        let conn = self.read();
@@ -252,27 +316,9 @@ impl Db {
        name: &str,
        created_at: i64,
    ) -> Result<(i64, Vec<String>)> {
        const SUBTREE: &str = "
            WITH RECURSIVE doomed(uid) AS (
              SELECT ?1
              UNION
              SELECT p.uid FROM pending_op p JOIN doomed d ON p.parent_uid = d.uid
            )";
        let mut conn = self.conn.lock();
        let tx = conn.transaction()?;
-        let blobs: Vec<String> = {
+        let blobs = drop_doomed_ops(&tx, uid)?;
            let mut stmt = tx.prepare(&format!(
                "{SUBTREE}
                 SELECT blob_path FROM pending_op
                 WHERE uid IN (SELECT uid FROM doomed) AND blob_path IS NOT NULL"
            ))?;
            let rows = stmt.query_map(params![uid], |row| row.get::<_, String>(0))?;
            rows.collect::<std::result::Result<Vec<_>, _>>()?
        };
        tx.execute(
            &format!("{SUBTREE} DELETE FROM pending_op WHERE uid IN (SELECT uid FROM doomed)"),
            params![uid],
        )?;
        tx.execute(
            "INSERT INTO pending_op
               (kind, uid, parent_uid, name, blob_path, meta_json, created_at, next_attempt_at)
@@ -326,6 +372,67 @@ impl Db {
        Ok(Some(AttachedBlob { id, superseded }))
    }
    /// Retire a queued create that has just landed as `real`, and repoint
    /// everything that named its placeholder, in one transaction.
    ///
    /// The drain uploads the blob the create held when it was picked up. A
    /// write that closes while that upload is on the wire attaches a newer blob
    /// to the *same row* (`attach_blob_to_create`), so deleting the row by id
    /// threw that write away: the server kept the older bytes and nothing was
    /// left queued to replace them. When the row no longer holds `uploaded`, it
    /// becomes a revision of `real` instead, with its sidecar passed through
    /// `rewrite` so it names the real node. Returns that blob and sidecar, or
    /// `None` when the create is simply done.
    pub fn finish_create(
        &self,
        id: i64,
        uploaded: Option<&str>,
        local: &str,
        real: &str,
        rewrite: impl FnOnce(&str) -> Option<String>,
    ) -> Result<Option<(String, String)>> {
        let mut conn = self.conn.lock();
        let tx = conn.transaction()?;
        let row: Option<(Option<String>, Option<String>)> = tx
            .query_row(
                "SELECT blob_path, meta_json FROM pending_op WHERE id = ?1",
                params![id],
                |r| Ok((r.get(0)?, r.get(1)?)),
            )
            .optional()?;
        let newer = match row {
            Some((Some(blob), Some(meta))) if uploaded != Some(blob.as_str()) => {
                rewrite(&meta).map(|meta| (blob, meta))
            }
            _ => None,
        };
        match &newer {
            Some((_, meta)) => {
                tx.execute(
                    "UPDATE pending_op
                     SET kind = ?2, uid = ?3, parent_uid = NULL, name = NULL, meta_json = ?4,
                         attempts = 0, last_error = NULL, next_attempt_at = 0
                     WHERE id = ?1",
                    params![id, OP_REVISION, real, meta],
                )?;
            }
            None => {
                tx.execute("DELETE FROM pending_op WHERE id = ?1", params![id])?;
            }
        }
        tx.execute(
            "UPDATE pending_op SET parent_uid = ?2 WHERE parent_uid = ?1",
            params![local, real],
        )?;
        tx.execute(
            "UPDATE nodes SET parent_uid = ?2 WHERE parent_uid = ?1",
            params![local, real],
        )?;
        tx.execute("DELETE FROM nodes WHERE uid = ?1", params![local])?;
        tx.commit()?;
        Ok(newer)
    }
    /// Replace the sidecar of a queued op, for a baseline that has moved under
    /// it.
    ///
@@ -428,29 +535,12 @@ impl Db {
    /// and in the user's pending count, for the life of the database.
    ///
    /// Only `create`/`mkdir` ops carry a `parent_uid`, so for a file this
-    /// recursion finds nothing and costs one query.
+    /// recursion finds nothing and costs one query. Revisions of files the
    /// node tree places beneath `uid` go too; see [`drop_doomed_ops`].
    pub fn delete_ops_for_uid(&self, uid: &str) -> Result<Vec<String>> {
        const SUBTREE: &str = "
            WITH RECURSIVE doomed(uid) AS (
              SELECT ?1
              UNION
              SELECT p.uid FROM pending_op p JOIN doomed d ON p.parent_uid = d.uid
            )";
        let mut conn = self.conn.lock();
        let tx = conn.transaction()?;
-        let blobs: Vec<String> = {
+        let blobs = drop_doomed_ops(&tx, uid)?;
            let mut stmt = tx.prepare(&format!(
                "{SUBTREE}
                 SELECT blob_path FROM pending_op
                 WHERE uid IN (SELECT uid FROM doomed) AND blob_path IS NOT NULL"
            ))?;
            let rows = stmt.query_map(params![uid], |r| r.get::<_, String>(0))?;
            rows.collect::<std::result::Result<Vec<_>, _>>()?
        };
        tx.execute(
            &format!("{SUBTREE} DELETE FROM pending_op WHERE uid IN (SELECT uid FROM doomed)"),
            params![uid],
        )?;
        tx.commit()?;
        Ok(blobs)
    }
@@ -765,6 +855,19 @@ impl Db {
    /// drain replaces it with the uid the server assigns.
    pub const LOCAL_VOLUME: &str = "local";
    /// Whether op `id` is still queued. A drain worker that claimed it can find
    /// it gone: the node was deleted, or a newer write superseded it, while the
    /// worker was talking to the server.
    pub fn op_exists(&self, id: i64) -> Result<bool> {
        let conn = self.read();
        let count: i64 = conn.query_row(
            "SELECT COUNT(*) FROM pending_op WHERE id = ?1",
            params![id],
            |row| row.get(0),
        )?;
        Ok(count > 0)
    }
    /// Drop a queued op, once its upload has actually landed.
    pub fn delete_op(&self, id: i64) -> Result<()> {
        let conn = self.conn.lock();
@@ -260,6 +260,88 @@ impl Db {
        Ok(())
    }
    /// Drop the baseline rows of `rel_path` and everything under it.
    ///
    /// Used when a subtree leaves a mirror folder through a move on Drive: its
    /// local copy is about to be removed, and rows left behind would read as
    /// "deleted locally" and trash the moved nodes at their new place.
    pub fn sync_entries_remove_subtree(&self, folder_id: i64, rel_path: &str) -> Result<()> {
        let conn = self.conn.lock();
        conn.execute(
            "DELETE FROM sync_entry
              WHERE folder_id = ?1
                AND (rel_path = ?2 OR substr(rel_path, 1, length(?2) + 1) = ?2 || '/')",
            params![folder_id, rel_path],
        )?;
        Ok(())
    }
    /// Move the baseline rows of `from_rel` and everything under it to `to_rel`
    /// in folder `to_folder`, in one transaction.
    ///
    /// Used when a move on Drive took a mirror subtree along with its local
    /// copy: the rows still describe both sides correctly, only under a new
    /// path, so the next pass on either folder has nothing to do. The two
    /// folders may be the same one.
    pub fn sync_entries_move(
        &self,
        from_folder: i64,
        from_rel: &str,
        to_folder: i64,
        to_rel: &str,
    ) -> Result<()> {
        let mut conn = self.conn.lock();
        let tx = conn.transaction()?;
        {
            let mut select = tx.prepare(
                "SELECT rel_path, remote_uid, local_mtime, local_size, remote_rev, remote_hash,
                        local_mtime_ns
                   FROM sync_entry
                  WHERE folder_id = ?1
                    AND (rel_path = ?2 OR substr(rel_path, 1, length(?2) + 1) = ?2 || '/')",
            )?;
            let rows = select
                .query_map(params![from_folder, from_rel], |r| {
                    Ok(StoredSyncEntry {
                        rel_path: r.get(0)?,
                        remote_uid: r.get(1)?,
                        local_mtime: r.get(2)?,
                        local_size: r.get(3)?,
                        remote_rev: r.get(4)?,
                        remote_hash: r.get(5)?,
                        local_mtime_ns: r.get(6)?,
                    })
                })?
                .collect::<rusqlite::Result<Vec<_>>>()?;
            let mut delete =
                tx.prepare("DELETE FROM sync_entry WHERE folder_id = ?1 AND rel_path = ?2")?;
            for row in &rows {
                delete.execute(params![from_folder, row.rel_path])?;
            }
            let mut insert = tx.prepare(
                "INSERT OR REPLACE INTO sync_entry
                   (folder_id, rel_path, remote_uid, local_mtime, local_size, remote_rev,
                    remote_hash, local_mtime_ns)
                 VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)",
            )?;
            for row in rows {
                let rel = format!("{to_rel}{}", &row.rel_path[from_rel.len()..]);
                insert.execute(params![
                    to_folder,
                    rel,
                    row.remote_uid,
                    row.local_mtime,
                    row.local_size,
                    row.remote_rev,
                    row.remote_hash,
                    row.local_mtime_ns,
                ])?;
            }
        }
        tx.commit()?;
        Ok(())
    }
    /// Drop the entire baseline for a folder. Used when flipping ondemand→mirror:
    /// the local tree was evicted, so the old baseline is stale and would make the
    /// next reconcile mistake "locally deleted" for "must re-download". Clearing it
@@ -788,6 +788,8 @@ fn children_if_listed_gated_on_flag() {
    // Not listed yet → unknown, force a re-fetch.
    assert!(db.children_if_listed(&uid("root")).unwrap().is_none());
    // Still known, for a caller that has nothing better while offline.
    assert_eq!(db.known_children(&uid("root")).unwrap().len(), 2);
    db.set_listed(&uid("root"), true).unwrap();
    let kids = db.children_if_listed(&uid("root")).unwrap().unwrap();
@@ -2458,6 +2460,20 @@ fn atomic_trash_replacement_returns_owned_blobs_after_commit() {
    assert!(ops[0].blob_path.is_none());
 }
 #[test]
 fn a_queued_trash_holds_its_name_until_it_lands() {
    let db = Db::open_in_memory().unwrap();
    let node = uid("held-name").to_string();
    assert!(!db.has_pending_trash_named("report.txt").unwrap());
    let (trash_id, _) = db.replace_ops_with_trash(&node, "report.txt", 1).unwrap();
    assert!(db.has_pending_trash_named("report.txt").unwrap());
    assert!(!db.has_pending_trash_named("other.txt").unwrap());
    db.delete_op(trash_id).unwrap();
    assert!(!db.has_pending_trash_named("report.txt").unwrap());
 }
 #[test]
 fn failed_atomic_trash_insert_keeps_prior_revision_and_blob_ownership() {
    let db = Db::open_in_memory().unwrap();
@@ -2498,6 +2514,71 @@ fn failed_atomic_trash_insert_keeps_prior_revision_and_blob_ownership() {
    );
 }
 /// A revision op names no parent, so the queue alone cannot see that its file
 /// sits inside a folder being removed. The node tree can: trashing the folder
 /// has to take the uploads of the files below it along, or they fail forever
 /// against a trashed node and keep their bytes on disk (B102). A rename that
 /// moved a node into the folder still has to land.
 #[test]
 fn trashing_a_folder_drops_the_queued_revisions_of_files_below_it() {
    let db = Db::open_in_memory().unwrap();
    db.upsert_nodes(&[
        folder("root", None, "My Files"),
        folder("doomed", Some("root"), "doomed"),
        folder("sub", Some("doomed"), "sub"),
        file("deep", "sub", "deep.bin", 1),
        file("moved", "doomed", "moved.txt", 1),
        file("kept", "root", "kept.bin", 1),
    ])
    .unwrap();
    let op = |kind: &str, link: &str, blob: Option<&str>| PendingOp {
        id: 0,
        kind: kind.to_string(),
        uid: uid(link).to_string(),
        parent_uid: None,
        name: None,
        blob_path: blob.map(str::to_string),
        meta_json: Some("{}".to_string()),
        created_at: 1,
        attempts: 0,
        last_error: None,
        next_attempt_at: 0,
    };
    db.enqueue_op(&op(OP_REVISION, "deep", Some("/staging/deep")))
        .unwrap();
    db.enqueue_op(&op(OP_RENAME, "moved", None)).unwrap();
    db.enqueue_op(&op(OP_REVISION, "kept", Some("/staging/kept")))
        .unwrap();
    let doomed = uid("doomed").to_string();
    let (_, blobs) = db.replace_ops_with_trash(&doomed, "doomed", 2).unwrap();
    assert_eq!(blobs, vec!["/staging/deep"]);
    let mut left: Vec<(String, String)> = db
        .pending_ops()
        .unwrap()
        .into_iter()
        .map(|op| (op.kind, op.uid))
        .collect();
    left.sort();
    assert_eq!(
        left,
        vec![
            (OP_RENAME.to_string(), uid("moved").to_string()),
            (OP_REVISION.to_string(), uid("kept").to_string()),
            (OP_TRASH.to_string(), doomed.clone()),
        ]
    );
    // Deleting outright follows the same tree.
    db.enqueue_op(&op(OP_REVISION, "deep", Some("/staging/deep2")))
        .unwrap();
    assert_eq!(
        db.delete_ops_for_uid(&uid("sub").to_string()).unwrap(),
        vec!["/staging/deep2"]
    );
 }
 /// Deleting a folder that was created offline must take the ops queued
 /// underneath it with it: they name a placeholder parent that will now never
 /// become real, so nothing could ever drain them and nothing is left to
@@ -2699,6 +2780,99 @@ fn attaching_to_an_already_drained_create_reports_it_is_gone() {
    assert!(out.is_none());
 }
 #[test]
 fn a_write_attached_while_its_create_uploads_becomes_a_revision() {
    let db = Db::open_in_memory().unwrap();
    let local = "local~abc";
    let real = uid("real").to_string();
    let create = |blob: Option<&str>| PendingOp {
        id: 0,
        kind: OP_CREATE.to_string(),
        uid: local.to_string(),
        parent_uid: Some(uid("parent").to_string()),
        name: Some("new.txt".to_string()),
        blob_path: blob.map(str::to_string),
        meta_json: blob.map(|_| "{\"uid\":\"local~abc\"}".to_string()),
        created_at: 1,
        attempts: 0,
        last_error: None,
        next_attempt_at: 0,
    };
    let (id, _) = db.enqueue_op(&create(None)).unwrap();
    // The drain picked the create up with no blob; the file's first write
    // closes while the empty upload is on the wire.
    db.attach_blob_to_create(local, "/staging/written", "{\"uid\":\"local~abc\"}")
        .unwrap()
        .expect("create is still queued");
    let newer = db
        .finish_create(id, None, local, &real, |json| {
            Some(json.replace("local~abc", "vol~real"))
        })
        .unwrap();
    assert_eq!(
        newer,
        Some((
            "/staging/written".to_string(),
            "{\"uid\":\"vol~real\"}".to_string()
        ))
    );
    let ops = db.pending_ops().unwrap();
    assert_eq!(ops.len(), 1, "the write is still queued");
    assert_eq!(ops[0].kind, OP_REVISION);
    assert_eq!(ops[0].uid, real);
    assert_eq!(ops[0].blob_path.as_deref(), Some("/staging/written"));
    assert_eq!(ops[0].parent_uid, None);
 }
 #[test]
 fn a_create_whose_blob_landed_is_retired() {
    let db = Db::open_in_memory().unwrap();
    let local = "local~abc";
    let real = uid("real").to_string();
    let (id, _) = db
        .enqueue_op(&PendingOp {
            id: 0,
            kind: OP_CREATE.to_string(),
            uid: local.to_string(),
            parent_uid: Some(uid("parent").to_string()),
            name: Some("new.txt".to_string()),
            blob_path: Some("/staging/sent".to_string()),
            meta_json: Some("{}".to_string()),
            created_at: 1,
            attempts: 0,
            last_error: None,
            next_attempt_at: 0,
        })
        .unwrap();
    db.enqueue_op(&PendingOp {
        id: 0,
        kind: OP_CREATE.to_string(),
        uid: "local~child".to_string(),
        parent_uid: Some(local.to_string()),
        name: Some("inside.txt".to_string()),
        blob_path: None,
        meta_json: None,
        created_at: 2,
        attempts: 0,
        last_error: None,
        next_attempt_at: 0,
    })
    .unwrap();
    let newer = db
        .finish_create(id, Some("/staging/sent"), local, &real, |_| {
            panic!("an unchanged create has no sidecar to rewrite")
        })
        .unwrap();
    assert_eq!(newer, None);
    let ops = db.pending_ops().unwrap();
    assert_eq!(ops.len(), 1, "only the child is left");
    assert_eq!(ops[0].parent_uid.as_deref(), Some(real.as_str()));
 }
 #[test]
 fn draining_a_folder_repoints_its_queued_children() {
    let db = Db::open_in_memory().unwrap();
@@ -2920,6 +3094,94 @@ fn clearing_a_stale_pending_mode_preserves_the_newer_intent() {
    assert_eq!(db.sync_folder_get(id).unwrap().unwrap().pending_mode, None);
 }
 fn baseline_row(rel: &str) -> StoredSyncEntry {
    StoredSyncEntry {
        rel_path: rel.into(),
        remote_uid: Some(format!("vol~{rel}")),
        local_mtime: 1_700_000_000,
        local_mtime_ns: Some(1_700_000_000_000_000_001),
        local_size: 7,
        remote_rev: Some("1700000000".into()),
        remote_hash: Some("7".into()),
    }
 }
 #[test]
 fn moving_a_baseline_subtree_takes_its_rows_and_leaves_name_prefixed_siblings() {
    let db = Db::open_in_memory().unwrap();
    let from = db.sync_folder_add("/home/me/A", "vol~a", "share").unwrap();
    let to = db.sync_folder_add("/home/me/B", "vol~b", "share").unwrap();
    for rel in [
        "docs",
        "docs/x.txt",
        "docs/sub/y.txt",
        "docsextra.txt",
        "other",
    ] {
        db.sync_entry_upsert(from, &baseline_row(rel)).unwrap();
    }
    db.sync_entry_upsert(to, &baseline_row("inbox")).unwrap();
    db.sync_entries_move(from, "docs", to, "inbox/docs")
        .unwrap();
    let left = db.sync_entries(from).unwrap();
    let mut left: Vec<_> = left.keys().cloned().collect();
    left.sort();
    assert_eq!(left, ["docsextra.txt", "other"]);
    let moved = db.sync_entries(to).unwrap();
    let mut keys: Vec<_> = moved.keys().cloned().collect();
    keys.sort();
    assert_eq!(
        keys,
        [
            "inbox",
            "inbox/docs",
            "inbox/docs/sub/y.txt",
            "inbox/docs/x.txt"
        ]
    );
    // Only the path changes: the row still describes the same node on both sides.
    assert_eq!(
        moved["inbox/docs/x.txt"],
        StoredSyncEntry {
            rel_path: "inbox/docs/x.txt".into(),
            ..baseline_row("docs/x.txt")
        }
    );
 }
 #[test]
 fn moving_a_baseline_subtree_within_one_folder_renames_it() {
    let db = Db::open_in_memory().unwrap();
    let folder = db.sync_folder_add("/home/me/A", "vol~a", "share").unwrap();
    for rel in ["old", "old/f.txt", "new"] {
        db.sync_entry_upsert(folder, &baseline_row(rel)).unwrap();
    }
    db.sync_entries_move(folder, "old", folder, "new/old")
        .unwrap();
    let mut keys: Vec<_> = db.sync_entries(folder).unwrap().into_keys().collect();
    keys.sort();
    assert_eq!(keys, ["new", "new/old", "new/old/f.txt"]);
 }
 #[test]
 fn removing_a_baseline_subtree_keeps_name_prefixed_siblings() {
    let db = Db::open_in_memory().unwrap();
    let folder = db.sync_folder_add("/home/me/A", "vol~a", "share").unwrap();
    for rel in ["docs", "docs/x.txt", "docsextra.txt"] {
        db.sync_entry_upsert(folder, &baseline_row(rel)).unwrap();
    }
    db.sync_entries_remove_subtree(folder, "docs").unwrap();
    let keys: Vec<_> = db.sync_entries(folder).unwrap().into_keys().collect();
    assert_eq!(keys, ["docsextra.txt"]);
 }
 #[test]
 fn mirror_uid_lookup_covers_the_root_and_synced_descendants_only() {
    let db = Db::open_in_memory().unwrap();
@@ -4963,3 +5225,28 @@ fn retry_all_touches_only_ops_that_have_failed() {
    assert_eq!(due(debounced), 7_000);
    assert_eq!(due(parked), ops::PARK_UNTIL);
 }
 #[test]
 fn a_queued_op_stops_existing_once_the_node_is_deleted() {
    let db = Db::open_in_memory().unwrap();
    let (id, _) = db
        .enqueue_op(&PendingOp {
            id: 0,
            kind: OP_REVISION.to_string(),
            uid: uid("journal").to_string(),
            parent_uid: None,
            name: None,
            blob_path: Some("/staging/journal".to_string()),
            meta_json: Some("{}".to_string()),
            created_at: 1,
            attempts: 0,
            last_error: None,
            next_attempt_at: 0,
        })
        .unwrap();
    assert!(db.op_exists(id).unwrap());
    let blobs = db.delete_ops_for_uid(&uid("journal").to_string()).unwrap();
    assert_eq!(blobs, vec!["/staging/journal"]);
    assert!(!db.op_exists(id).unwrap());
 }
@@ -9,7 +9,7 @@ use crate::shutdown::Shutdown;
 ///
 /// Returns whether this mount actually held the node, so the caller can evict
 /// its content blob once if *any* mount did.
-fn forget_and_notify(st: &mut State, notify: &mut NotifyBatch, uid: &NodeUid) -> bool {
+pub(crate) fn forget_and_notify(st: &mut State, notify: &mut NotifyBatch, uid: &NodeUid) -> bool {
    // Capture the inode before `forget` clears the uid mapping.
    let child = st.by_uid.get(uid).copied();
    let Some((parent, name)) = st.forget(uid) else {
@@ -378,9 +378,10 @@ pub(super) async fn run_event_sync(
    info!(?cursor, "event sync started");
    loop {
-        tokio::time::sleep(POLL_INTERVAL).await;
+        core.next_poll(POLL_INTERVAL).await;
-        let events = match client.enumerate_events(&scope, cursor.as_ref()).await {
+        let events = match link::bounded(client.enumerate_events(&scope, cursor.as_ref())).await {
            Ok(events) => events,
            Err(e) if core.lost_link(&e, "poll events") => continue,
            Err(e) => {
                warn!(error = %e, "event poll failed; retrying after interval");
                continue;
@@ -471,9 +472,10 @@ pub(super) async fn run_photos_event_sync(core: Core) {
    info!(?cursor, "photo event sync started");
    loop {
-        tokio::time::sleep(POLL_INTERVAL).await;
+        core.next_poll(POLL_INTERVAL).await;
-        let events = match photos.enumerate_events(&scope, cursor.as_ref()).await {
+        let events = match link::bounded(photos.enumerate_events(&scope, cursor.as_ref())).await {
            Ok(events) => events,
            Err(error) if core.lost_link(&error, "poll photo events") => continue,
            Err(error) => {
                warn!(%error, "photo event poll failed; retrying after interval");
                continue;
@@ -974,6 +974,24 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
            },
            Err(e) => CtlResponse::error(e),
        },
        // Two absolute paths may name two different locations, which only
        // `move_between` can resolve; a relative pair keeps the old meaning.
        Ok(CtlRequest::Move { path, new_parent })
            if Path::new(&path).is_absolute() && Path::new(&new_parent).is_absolute() =>
        {
            match core.move_between(Path::new(&path), Path::new(&new_parent)) {
                Ok(name) => {
                    core.log_activity(ActivityKind::Move, &name, format!("to {new_parent}"), true);
                    CtlResponse::Ok {
                        message: format!("moved {name}"),
                    }
                }
                Err(e) => {
                    core.log_activity(ActivityKind::Move, &path, &e, false);
                    CtlResponse::error(e)
                }
            }
        }
        Ok(CtlRequest::Move { path, new_parent }) => {
            match (
                rel_to_mount(mountpoint, &path),
@@ -38,10 +38,10 @@ use pdfs_core::db::{
 };
 use proton_drive_rs::proton_sdk::error::ProtonError;
 use proton_drive_rs::proton_sdk::ids::NodeUid;
-use proton_drive_rs::{Node, NodeMoveItem};
+use proton_drive_rs::{Node, NodeKind, NodeMoveItem};
 use tracing::{debug, error, info, warn};
-use super::state::Intervals;
+use super::state::{Intervals, PendingRevision};
 use super::transfers::CountingReader;
 use super::{
    Core, DRAIN_BACKOFF_MAX, DRAIN_BACKOFF_MIN, DRAIN_IDLE_POLL, DRAIN_REVISION_DEBOUNCE,
@@ -673,6 +673,9 @@ impl Core {
                // *different* name is the non-destructive resolution: it neither
                // clobbers their file nor drops ours, and it is visible.
                Err(e) if is_already_exists(&e) => {
                    if self.db.has_pending_trash_named(&name)? {
                        return Err(held_by_queued_trash(&name));
                    }
                    let alt = conflict_name(&name, now_secs());
                    warn!(%uid, name, alt, "destination already holds that name; using a conflict name");
                    self.move_renaming(&uid, &parent, Some(&alt))?;
@@ -696,8 +699,8 @@ impl Core {
                    let landed = match self.drain_rename_in_place(&uid, &node.name, &name) {
                        Ok(landed) => landed,
                        // The node went with it; nothing is left to rename.
-                        Err(e) if is_gone(&e) => node.name.clone(),
+                        Err(e) if is_gone(e.as_ref()) => node.name.clone(),
-                        Err(e) => return Err(e.into()),
+                        Err(e) => return Err(e),
                    };
                    self.log_activity(
                        ActivityKind::Rename,
@@ -725,16 +728,19 @@ impl Core {
        uid: &NodeUid,
        current: &str,
        name: &str,
-    ) -> Result<String, ProtonError> {
+    ) -> Result<String, Box<dyn std::error::Error>> {
        if current == name {
            return Ok(current.to_string());
        }
-        match self.rt.block_on(self.client.rename_node(uid, name, None)) {
+        match self.rename_remote(uid, name) {
            Ok(()) => Ok(name.to_string()),
            Err(e) if is_already_exists(&e) => {
                if self.db.has_pending_trash_named(name)? {
                    return Err(held_by_queued_trash(name));
                }
                let alt = conflict_name(name, now_secs());
                warn!(%uid, name, alt, "rename target name is taken; using a conflict name");
-                self.rt.block_on(self.client.rename_node(uid, &alt, None))?;
+                self.rename_remote(uid, &alt)?;
                self.adopt_drained_name(uid, &alt);
                self.log_activity(
                    ActivityKind::Rename,
@@ -744,7 +750,7 @@ impl Core {
                );
                Ok(alt)
            }
-            Err(e) => Err(e),
+            Err(e) => Err(e.into()),
        }
    }
@@ -842,8 +848,26 @@ impl Core {
        // reachable only because the op waited, which is the whole point of the
        // queue. Never overwrite theirs and never drop ours: land under a
        // conflict name, exactly as the sync engine does.
        //
        // Two things can hold the name that are not someone else's file. The
        // node a create made before the network dropped its answer is ours: the
        // create was queued because nobody heard back, so adopt it. And a node
        // whose trash is still queued is about to let go of it.
        let mut name = wanted.clone();
        let mut adopted = false;
        let mut real = self.create_drained_node(op, &parent, &name);
        if real.as_ref().is_err_and(|e| is_already_exists(e.as_ref()))
            && let Some(twin) = self.adoptable_twin(op, &parent, &wanted)?
        {
            info!(%local, %twin, wanted, "the name is held by our own unanswered create; adopting it");
            real = Ok(twin);
            adopted = true;
        }
        if real.as_ref().is_err_and(|e| is_already_exists(e.as_ref()))
            && self.db.has_pending_trash_named(&wanted)?
        {
            return Err(held_by_queued_trash(&wanted));
        }
        if real.as_ref().is_err_and(|e| is_already_exists(e.as_ref())) {
            name = conflict_name(&wanted, now_secs());
            warn!(%local, wanted, name, "name is taken remotely; creating under a conflict name");
@@ -886,20 +910,62 @@ impl Core {
        // Retire the op before touching anything else: if we crash here the node
        // exists remotely and the local placeholder is reconciled by the event
        // sync, whereas a surviving op would create the file a second time.
-        self.db.delete_op(op.id)?;
+        // An adopted node was made empty, so a blob this op carries has not been
        // uploaded: it goes on as a revision of the node instead.
        let uploaded = (!adopted).then_some(op.blob_path.as_deref()).flatten();
        let newer = self.retire_create(op, uploaded, &local, &real)?;
        self.adopt_real_uid(&local, &real)?;
        // The feed will report this create back to us; the tree already has it
        // under its real uid, so that event is ours to ignore (`Core::self_changes`).
        self.note_self_change(&real);
-        if let Some(blob) = op.blob_path.as_deref() {
+        // The uploaded blob is done with either way: a write that replaced it
        // while it was on the wire already discarded it when it attached.
        if let Some(blob) = uploaded {
            self.cache.discard_staged(Path::new(blob));
        }
-        self.pending.lock().remove(&local);
+        if newer {
            info!(%local, %real, name, "a write landed during the create; queued it as a revision");
            self.wake_drain();
        }
        self.log_activity(ActivityKind::Upload, &name, "created", true);
        info!(%local, %real, name, kind = %op.kind, "pending create landed");
        Ok(())
    }
    /// The node already holding `name` under `parent`, if it is the one an
    /// earlier attempt at this op made before its answer was lost.
    ///
    /// A create that timed out may still have landed; the op was queued because
    /// the caller never heard back. Without this, its replay forked a
    /// `(sync-conflict)` copy of a file nobody else had touched.
    fn adoptable_twin(
        &self,
        op: &PendingOp,
        parent: &NodeUid,
        name: &str,
    ) -> Result<Option<NodeUid>, Box<dyn std::error::Error>> {
        let uids = self
            .rt
            .block_on(self.client.enumerate_folder_children_node_uids(parent))?;
        let children = self.rt.block_on(self.client.enumerate_nodes_light(&uids))?;
        let Some(twin) = children
            .into_iter()
            .find(|node| node.name == name && !node.trashed)
        else {
            return Ok(None);
        };
        // The light listing carries no file size, and an adoptable file is
        // exactly an empty one.
        let twin = match twin.kind {
            NodeKind::Folder => twin,
            NodeKind::File { .. } => match self.fetch_node_remote(&twin.uid)? {
                Some(node) => node,
                None => return Ok(None),
            },
        };
        Ok(adoptable(op.kind == OP_MKDIR, &twin, op.created_at).then_some(twin.uid))
    }
    /// Make one queued `create`/`mkdir` real under a given name, and hand back
    /// the API's own error so the caller can tell a name clash from a failure.
    ///
@@ -963,6 +1029,62 @@ impl Core {
        Ok(uid)
    }
    /// Retire a landed create's op and move its queued state to the real uid.
    /// True when a newer write attached to the create while it was uploading,
    /// which is now queued as a revision of `real`.
    ///
    /// Runs under the `pending` lock, which `Core::enqueue_staged_write` also
    /// holds from attaching a blob to a create until it records the pending
    /// entry. So a write either attached before this ran and is carried over,
    /// or finds the create gone and queues against the real uid itself. The
    /// open write handles are repointed right after, for the same reason:
    /// a handle released later must not queue against the placeholder.
    fn retire_create(
        &self,
        op: &PendingOp,
        uploaded: Option<&str>,
        local: &NodeUid,
        real: &NodeUid,
    ) -> Result<bool, Box<dyn std::error::Error>> {
        let real_str = real.to_string();
        let newer = {
            let mut pending = self.pending.lock();
            let newer =
                self.db
                    .finish_create(op.id, uploaded, &local.to_string(), &real_str, |json| {
                        let mut meta: StagedWrite = serde_json::from_str(json).ok()?;
                        meta.uid = real_str.clone();
                        serde_json::to_string(&meta).ok()
                    })?;
            pending.remove(local);
            if let Some((blob, json)) = &newer {
                let meta: StagedWrite = serde_json::from_str(json)?;
                pending.insert(
                    real.clone(),
                    PendingRevision {
                        path: PathBuf::from(blob),
                        meta,
                    },
                );
            }
            newer.is_some()
        };
        self.for_each_state(|st| {
            if let Some(ino) = st.by_uid.remove(local) {
                st.by_uid.insert(real.clone(), ino);
                if let Some(e) = st.entries.get_mut(&ino) {
                    e.uid = real.clone();
                }
            }
            for aw in st.active_writes.values_mut() {
                if aw.uid == *local {
                    aw.uid = real.clone();
                }
            }
        });
        Ok(newer)
    }
    /// Swap a placeholder uid for the real one across everything that keyed off
    /// it: queued children, the DB, the in-memory tree, and the caches.
    ///
@@ -985,17 +1107,22 @@ impl Core {
            .fetch_node(real)
            .map_err(|e| self.errno_error(e, "fetch node"))?;
        // Repoints queued children and node rows, and drops the placeholder row.
        // A no-op after `retire_create`, which has already done both.
        self.db
            .remap_local_uid(&local.to_string(), &real.to_string())?;
        self.for_each_state(|st| {
-            let Some(ino) = st.by_uid.remove(local) else {
+            if let Some(ino) = st.by_uid.remove(local) {
                st.by_uid.insert(real.clone(), ino);
            }
            let Some(&ino) = st.by_uid.get(real) else {
                return;
            };
-            st.by_uid.insert(real.clone(), ino);
+            let mut landed = node.clone();
            st.keep_open_write_size(ino, &mut landed);
            if let Some(e) = st.entries.get_mut(&ino) {
                e.uid = real.clone();
-                e.node = node.clone();
+                e.node = landed;
            }
            // Where the op said the node goes and where it actually landed can
            // differ — a conflict re-homes it — so the tree follows the parent
@@ -1024,6 +1151,9 @@ impl Core {
        if let Err(e) = self.db.upsert_node(&node) {
            warn!(%real, error = %e, "db upsert_node failed after remap");
        }
        // A write carried over from the create was made against no revision at
        // all; the one just created is what it now replaces.
        self.rebaseline_pending(real, &node);
        if node.is_folder() {
            // It was recorded as listed while local (it was empty and had nothing
            // to enumerate). That still holds: its queued children re-intern under
@@ -1407,6 +1537,7 @@ impl Core {
    /// Upload a staged revision of a file the server already knows about.
    pub(crate) fn drain_revision(&self, op: &PendingOp) -> Result<(), Box<dyn std::error::Error>> {
        let op_started = Instant::now();
        let blob = op
            .blob_path
            .clone()
@@ -1416,6 +1547,16 @@ impl Core {
        let uid = parse_node_uid(&meta.uid).ok_or("staged write has an unparseable uid")?;
        if let Some(reason) = self.revision_conflict(&uid, &meta)? {
            // Trashing the file from the mount drops its queued write, but not
            // from under a worker already holding it. That worker then finds the
            // node trashed — by us — and would upload the withdrawn bytes as a
            // conflict copy (a `recovered-…` file in the root when the tree has
            // already forgotten the node). A write nobody queues any more is
            // not a conflict.
            if !self.db.op_exists(op.id)? {
                debug!(%uid, reason, "queued write withdrawn while it drained; dropping it");
                return Ok(());
            }
            return self.keep_as_conflict_copy(op, &blob, &meta, &uid, &reason);
        }
@@ -1452,6 +1593,12 @@ impl Core {
        // this is on the wire can stop it rather than paying for a revision the
        // op it queued will immediately replace.
        let cancel = self.begin_cancellable_upload(&uid);
        // An unlink that withdrew this op before the flag above existed had no
        // upload to cancel; the row is the record that it happened.
        if !self.db.op_exists(op.id)? {
            debug!(%uid, "queued write withdrawn before it went out; dropping it");
            return Ok(());
        }
        let reader = CountingReader::new(File::open(&blob)?, &guard).with_cancel(cancel.flag());
        let started = Instant::now();
        let sent = self.rt.block_on(self.client.upload_new_revision_from(
@@ -1498,7 +1645,15 @@ impl Core {
        self.evict_reader(&uid);
        self.refresh_after_upload(&uid);
        self.log_activity(ActivityKind::Upload, &name, "uploaded", true);
-        info!(%uid, len = meta.len, "pending upload landed");
+        // Both times, so a slow drain shows whether the upload itself or the
        // checks and gap-fill around it are where the time goes.
        info!(
            %uid,
            len = meta.len,
            upload_ms = took.as_millis() as u64,
            total_ms = op_started.elapsed().as_millis() as u64,
            "pending upload landed"
        );
        Ok(())
    }
@@ -1708,6 +1863,31 @@ fn park_verdict(created_at: i64, now: i64, open: bool) -> ParkVerdict {
    ParkVerdict::Release
 }
 /// The retryable error for an op whose name a queued trash has yet to free.
 fn held_by_queued_trash(name: &str) -> Box<dyn std::error::Error> {
    format!("{name} is still held by a node whose trash is queued").into()
 }
 /// How much older than its op a remote node may be and still be the one an
 /// unanswered call made. The op is queued the moment the call gives up, so the
 /// node is at most one call's deadline older; the rest is clock skew between
 /// this machine and Proton.
 const ADOPT_WINDOW_MS: i64 = 2 * 60 * 1000;
 /// Whether `twin`, found holding the name a queued create wants, is the node an
 /// earlier, unanswered attempt at that create made: the same kind, created
 /// around when the op was queued, and for a file still empty, as the mount's
 /// create leaves it.
 fn adoptable(is_dir: bool, twin: &Node, op_created_ms: i64) -> bool {
    if twin.creation_time.saturating_mul(1000) < op_created_ms - ADOPT_WINDOW_MS {
        return false;
    }
    match &twin.kind {
        NodeKind::Folder => is_dir,
        NodeKind::File { claimed_size, .. } => !is_dir && *claimed_size == Some(0),
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -2087,6 +2267,29 @@ mod tests {
        }
    }
    #[test]
    fn only_a_fresh_empty_twin_of_the_same_kind_is_adopted() {
        // The op was queued at t=1000 s, after a create that got no answer.
        let queued = 1_000_000;
        let made = |mut node: Node, secs: i64| {
            node.creation_time = secs;
            node
        };
        assert!(adoptable(false, &made(file_node(0, 0, None), 990), queued));
        assert!(adoptable(true, &made(folder_node("d", None), 990), queued));
        // Made long before the op: someone else's file, not our lost create.
        assert!(!adoptable(false, &made(file_node(0, 0, None), 800), queued));
        // Our create leaves a file empty; one with content is someone else's.
        assert!(!adoptable(false, &made(file_node(0, 5, None), 990), queued));
        // The kind has to match what the op makes.
        assert!(!adoptable(true, &made(file_node(0, 0, None), 990), queued));
        assert!(!adoptable(
            false,
            &made(folder_node("d", None), 990),
            queued
        ));
    }
    fn baseline(mtime: i64, size: u64, rev: Option<&str>) -> Baseline {
        Baseline {
            mtime,
@@ -290,7 +290,7 @@ impl Filesystem for ProtonFs {
            }
            return;
        }
-        let (uid, mtime, fsize, is_video) = {
+        let (uid, mtime, fsize, provisional, is_video) = {
            let st = self.core.state();
            match st.entries.get(&ino.0) {
                Some(e) if e.node.is_file() => {
@@ -300,14 +300,24 @@ impl Filesystem for ProtonFs {
                    };
                    let is_video =
                        PhotoKind::classify(Some(&e.node.name), media_type) == PhotoKind::Video;
-                    let fsize = self
+                    let queued = self.core.pending.lock().get(&e.uid).map(|p| p.meta.len);
-                        .core
+                    // Still the cheap enumeration's ciphertext size (B12).
-                        .pending
+                    let provisional = queued.is_none()
-                        .lock()
+                        && matches!(
-                        .get(&e.uid)
+                            &e.node.kind,
-                        .map(|p| p.meta.len)
+                            NodeKind::File {
-                        .unwrap_or_else(|| node_size(&e.node));
+                                claimed_size: None,
-                    (e.uid.clone(), e.node.modification_time, fsize, is_video)
+                                ..
                            }
                        );
                    let fsize = queued.unwrap_or_else(|| node_size(&e.node));
                    (
                        e.uid.clone(),
                        e.node.modification_time,
                        fsize,
                        provisional,
                        is_video,
                    )
                }
                Some(_) => {
                    reply.error(Errno::EISDIR);
@@ -330,6 +340,13 @@ impl Filesystem for ProtonFs {
        // races with nothing. FUSE does not require replies in request order.
        let core = self.core.clone();
        self.core.workers.run(Lane::Transfer, "read", move || {
            // The revision disagrees with a provisional size, and B84 fails
            // such a read outright, so settle the size first. On the network,
            // hence here and not above (bugs.md B100).
            let fsize = match provisional {
                true => core.resolve_provisional_size(ino.0, &uid).unwrap_or(fsize),
                false => fsize,
            };
            match core.read_range(&uid, mtime, fsize, offset, size as u64, cache_blocks) {
                Ok(bytes) => reply.data(&bytes),
                Err(e) => reply.error(e),
@@ -425,10 +442,7 @@ impl Filesystem for ProtonFs {
                reply.error(Errno::EBADF);
                return;
            };
-            let end = offset + data.len() as u64;
+            aw.record_write(offset, offset + data.len() as u64);
            aw.written.add(offset, end);
            aw.len = aw.len.max(end);
            aw.dirty = true;
            let len = aw.len;
            st.set_size(ino.0, len);
            len
@@ -1193,7 +1207,7 @@ impl ProtonFs {
    /// open.
    fn serve_open(&self, ino: INodeNo, flags: OpenFlags, reply: ReplyOpen) {
        let write_requested = flags.acc_mode() != OpenAccMode::O_RDONLY;
-        let (uid, base_mtime, base_size, base_revision_id) = {
+        let (uid, base_mtime, base_size, provisional, base_revision_id) = {
            let mut st = self.core.state();
            match st.entries.get_mut(&ino.0) {
                Some(e) if e.node.is_file() => {
@@ -1206,6 +1220,14 @@ impl ProtonFs {
                        e.uid.clone(),
                        e.node.modification_time,
                        node_size(&e.node),
                        // Still the cheap enumeration's ciphertext size (B12).
                        matches!(
                            &e.node.kind,
                            NodeKind::File {
                                claimed_size: None,
                                ..
                            }
                        ),
                        node_revision_id(&e.node),
                    )
                }
@@ -1251,6 +1273,21 @@ impl ProtonFs {
        // `reply` is consumed by whichever arm answers, so the loop yields an
        // outcome and the answer is sent once, after it.
        let outcome = 'install: {
            // The handle starts at the base's size. A provisional one is the
            // ciphertext size, so the file would grow by the encryption overhead
            // and reading the base would fail (bugs.md B100). A queued revision
            // stamps a real size, so this only goes to the network for a file
            // the listing has not sized yet.
            let base_size = match provisional && self.core.pending_blob(&uid).is_none() {
                false => base_size,
                true => match self.core.resolve_provisional_size(ino.0, &uid) {
                    Some(size) => size,
                    None => {
                        error!(%uid, "could not settle the size of the base for a write open");
                        break 'install Err(Errno::EIO);
                    }
                },
            };
            for attempt in 0..OPEN_BASE_ATTEMPTS {
                let pending_base = self.core.pending.lock().get(&uid).cloned();
                if pending_base.as_ref().is_some_and(|p| !p.meta.complete) {
@@ -1427,6 +1464,12 @@ impl ProtonFs {
            return;
        }
        if let Err(e) = self.core.ensure_children(parent) {
            // The parent was looked up a moment ago, so ENOENT here means it
            // left the tree in between. Log it: the caller only sees "no such
            // file" on a create.
            if e == Errno::ENOENT {
                warn!(parent, name, "create: the parent folder is no longer known");
            }
            reply.error(e);
            return;
        }
@@ -1435,6 +1478,10 @@ impl ProtonFs {
            match st.entries.get(&parent) {
                Some(e) => e.uid.clone(),
                None => {
                    warn!(
                        parent,
                        name, "create: the parent folder left the tree during its listing"
                    );
                    reply.error(Errno::ENOENT);
                    return;
                }
@@ -1454,37 +1501,45 @@ impl ProtonFs {
        //
        // A parent that is itself still queued forces the same path even when we
        // are online: the API has no folder to put this in yet.
-        let node =
+        //
-            if !transient && self.core.online.load(Ordering::Relaxed) && !is_local_uid(&parent_uid)
+        // A create that set out online and lost the network on the way lands in
-            {
+        // the queue too, so a Wi-Fi drop costs the caller a wait, never an EIO.
        let minted = if !transient && self.core.is_online() && !is_local_uid(&parent_uid) {
            if let Err(error) = self.core.require_uid_writable(&parent_uid) {
                reply.error(error);
                return;
            }
            // Create an empty file on the remote so it has a real uid immediately;
            // written bytes are buffered and sealed as a new revision on close.
-                let new_uid = match self.core.rt.block_on(self.core.client.upload_file(
+            match self.core.block_on_bounded(self.core.client.upload_file(
                &parent_uid,
                name,
                media_type_for(name),
                b"",
            )) {
-                    Ok(u) => u,
+                Ok(new_uid) => match self.core.fetch_node(&new_uid) {
                    Ok(n) => Some(n),
                    // The file exists remotely but we could not read it back.
                    // The queued create finds it by name and adopts it.
                    Err(e) if e == Errno::EIO && !self.core.is_online() => None,
                    Err(e) => {
                        reply.error(e);
                        return;
                    }
                },
                Err(e) if self.core.lost_link(&e, "create") => None,
                Err(e) => {
                    error!(%parent_uid, name, error = %e, "create file failed");
                    reply.error(Errno::EIO);
                    return;
                }
                };
                match self.core.fetch_node(&new_uid) {
                    Ok(n) => n,
                    Err(e) => {
                        reply.error(e);
                        return;
                    }
            }
        } else {
-                match self
+            None
        };
        let node = match minted {
            Some(node) => node,
            None => match self
                .core
                .queue_local_node(&parent_uid, name, false, transient)
            {
@@ -1493,7 +1548,7 @@ impl ProtonFs {
                    reply.error(e);
                    return;
                }
-                }
+            },
        };
        let new_uid = node.uid.clone();
        // The base this handle writes over is the node as it actually exists —
@@ -1584,39 +1639,43 @@ impl ProtonFs {
        // As in `create`: offline — or under a parent that is itself still
        // queued — the folder becomes a placeholder that the drain turns into a
        // real one (offline.md Phase 3b).
-        let node = if self.core.online.load(Ordering::Relaxed) && !is_local_uid(&parent_uid) {
+        // Losing the network on the way queues it the same way.
        let minted = if self.core.is_online() && !is_local_uid(&parent_uid) {
            if let Err(error) = self.core.require_uid_writable(&parent_uid) {
                reply.error(error);
                return;
            }
            let new_uid =
            match self
                .core
-                    .rt
+                .block_on_bounded(self.core.client.create_folder(&parent_uid, name, now))
                    .block_on(self.core.client.create_folder(&parent_uid, name, now))
            {
-                    Ok(u) => u,
+                Ok(new_uid) => match self.core.fetch_node(&new_uid) {
                    Ok(n) => Some(n),
                    Err(e) if e == Errno::EIO && !self.core.is_online() => None,
                    Err(e) => {
                        reply.error(e);
                        return;
                    }
                },
                Err(e) if self.core.lost_link(&e, "mkdir") => None,
                Err(e) => {
                    error!(%parent_uid, name, error = %e, "create folder failed");
                    reply.error(Errno::EIO);
                    return;
                }
                };
            match self.core.fetch_node(&new_uid) {
                Ok(n) => n,
                Err(e) => {
                    reply.error(e);
                    return;
                }
            }
        } else {
-            match self.core.queue_local_node(&parent_uid, name, true, false) {
+            None
        };
        let node = match minted {
            Some(node) => node,
            None => match self.core.queue_local_node(&parent_uid, name, true, false) {
                Ok(n) => n,
                Err(e) => {
                    reply.error(e);
                    return;
                }
-            }
+            },
        };
        let mut st = self.core.state();
        let local = is_local_uid(&node.uid);
@@ -1706,12 +1765,18 @@ impl ProtonFs {
        if let Some(uid) = unlinked_uid
            && release_can_discard_unlinked(&self.core.db, &uid)
        {
            // Ops withdrawn at unlink left the bytes this handle read behind,
            // owned by no op any more; they go with the last handle.
            let withdrawn = self.core.pending_blob(&uid);
            if let Err(error) = self.core.discard_queued_ops(&uid) {
                warn!(%uid, ?error, "queued-op cleanup failed; retaining unlinked state");
            } else {
                if let Err(error) = self.core.db.delete_node(&uid) {
                    warn!(%uid, %error, "deleting released unlinked node state failed");
                }
                if let Some(blob) = withdrawn {
                    self.core.cache.discard_staged(&blob);
                }
                self.core.cache.evict(&uid);
                self.core.evict_reader(&uid);
            }
@@ -1932,12 +1997,11 @@ impl ProtonFs {
        // take the synchronous path, so a genuine API refusal (permissions, a
        // name clash) surfaces to the caller instead of becoming a queued op
        // that can only ever conflict.
-        if rename_needs_queue(
+        // The queued rename, as a closure: the network going away under the
-            self.core.online.load(Ordering::Relaxed),
+        // synchronous path below lands here too, with whatever half already
-            is_local_uid(&new_parent_uid),
+        // reached Drive. The op records the end state, so the drain finishes
-            newparent != parent,
+        // the rest.
-            newname != name,
+        let queue_it = |reply: ReplyEmpty| {
        ) {
            let queued = if replacement_authorized {
                self.core.queue_rename_authorized(
                    ino,
@@ -1978,6 +2042,14 @@ impl ProtonFs {
                    reply.error(e);
                }
            }
        };
        if rename_needs_queue(
            self.core.is_online(),
            is_local_uid(&new_parent_uid),
            newparent != parent,
            newname != name,
        ) {
            queue_it(reply);
            return;
        }
        // Rename first if both halves change. Moving first makes the encrypted
@@ -1996,11 +2068,12 @@ impl ProtonFs {
            return;
        }
        if newname != name
-            && let Err(e) = self
+            && let Err(e) = self.core.rename_remote(&uid, newname)
                .core
                .rt
                .block_on(self.core.client.rename_node(&uid, newname, None))
        {
            if self.core.lost_link(&e, "rename") {
                queue_it(reply);
                return;
            }
            error!(%uid, error = %e, "rename failed");
            self.core.restore_replaced(victim.as_ref(), newname);
            reply.error(Errno::EIO);
@@ -2011,8 +2084,7 @@ impl ProtonFs {
            let moved = loop {
                match self
                    .core
-                    .rt
+                    .block_on_bounded(self.core.client.move_node(&uid, &new_parent_uid))
                    .block_on(self.core.client.move_node(&uid, &new_parent_uid))
                {
                    Ok(()) => break Ok(()),
                    Err(e)
@@ -2031,6 +2103,10 @@ impl ProtonFs {
                }
            };
            if let Err(e) = moved {
                if self.core.lost_link(&e, "move") {
                    queue_it(reply);
                    return;
                }
                error!(%uid, attempts, error = %e, "move after rename failed");
                // The rename half landed in the source directory.
                let mut state = self.core.state();
@@ -2092,7 +2168,12 @@ impl ProtonFs {
        // it just means its queued creation is no longer wanted. This works
        // offline, which the remote path below cannot (offline.md Phase 3b).
        if is_local_uid(&uid) {
-            if !open_now && let Err(error) = self.core.discard_queued_ops(&uid) {
+            let dropped = if open_now {
                self.core.withdraw_queued_ops(&uid)
            } else {
                self.core.discard_queued_ops(&uid)
            };
            if let Err(error) = dropped {
                reply.error(error);
                return;
            }
@@ -2103,12 +2184,14 @@ impl ProtonFs {
        }
        // Offline: queue it. Trashing is the one mutation a user expects to work
        // regardless — the file is gone from their point of view the moment the
-        // command returns (offline.md Phase 3b).
+        // command returns (offline.md Phase 3b). The same when the network goes
-        if !self.core.online.load(Ordering::Relaxed) {
+        // away under the remote call below.
-            match self.core.queue_trash(&uid, name) {
+        let queue_it = |reply: ReplyEmpty| match self.core.queue_trash(&uid, name) {
            Ok(()) => reply.ok(),
            Err(e) => reply.error(e),
-            }
+        };
        if !self.core.is_online() {
            queue_it(reply);
            return;
        }
        if let Err(e) = self.core.require_uid_writable(&uid) {
@@ -2117,10 +2200,13 @@ impl ProtonFs {
        }
        if let Err(e) = self
            .core
-            .rt
+            .block_on_bounded(self.core.client.trash_nodes(std::slice::from_ref(&uid)))
            .block_on(self.core.client.trash_nodes(std::slice::from_ref(&uid)))
            .and_then(batch::into_unit)
        {
            if self.core.lost_link(&e, "trash") {
                queue_it(reply);
                return;
            }
            error!(%uid, error = %e, "trash failed");
            self.core
                .log_activity(ActivityKind::Trash, name, e.to_string(), false);
@@ -2131,7 +2217,13 @@ impl ProtonFs {
        // Otherwise an EIO response still made the path disappear locally.
        self.core.hidden.lock().insert(uid.clone());
        self.core.state().forget_or_unlink(&uid);
-        if !open_now {
+        if open_now {
            // The open handle keeps the staged bytes; the drain must not send
            // them to a node that is already in the trash (docs/BUGS.md B106).
            if let Err(error) = self.core.withdraw_queued_ops(&uid) {
                warn!(%uid, ?error, "remote trash landed but queued-op cleanup failed");
            }
        } else {
            if let Err(error) = self.core.discard_queued_ops(&uid) {
                warn!(%uid, ?error, "remote trash landed but queued-op cleanup failed");
            }
@@ -0,0 +1,315 @@
 //! Noticing that the network went away mid-session, and that it came back.
 //!
 //! The mount used to learn it was offline only at startup: a daemon that had
 //! connected once kept `online` true for the rest of its life, so a Wi-Fi drop
 //! turned every create, mkdir, delete and rename into a two-minute wait for an
 //! `EIO`, while the queue that exists for exactly this sat unused. Now any
 //! remote call a handler waits on reports a failure to reach Proton through
 //! [`Core::lost_link`], which flips the mount offline; the handler then takes its
 //! queued path, and the probe thread here flips it back when Proton answers.
 use std::future::Future;
 use std::sync::atomic::Ordering;
 use std::time::{Duration, Instant};
 use parking_lot::{Condvar, Mutex};
 use proton_drive_rs::proton_sdk::api::ResponseCode;
 use proton_drive_rs::proton_sdk::error::{ProtonApiError, ProtonError};
 use tracing::{debug, info, warn};
 use crate::{Core, ONLINE_PROBE_MAX, ONLINE_PROBE_MIN, ROOT_INO};
 /// How long a remote call a FUSE handler is waiting on may take before the link
 /// is treated as down.
 ///
 /// The SDK's own budget for one request is four attempts of up to 30 seconds
 /// each, so a dead link held the caller for about two minutes. A metadata call
 /// that has had no answer in 20 seconds is not going to be one the user wants to
 /// keep waiting for; queueing the change is the better answer.
 pub(crate) const INTERACTIVE_CALL_TIMEOUT: Duration = Duration::from_secs(20);
 /// How long one probe may wait for an answer. A probe is a single small request,
 /// and a probe stuck in the SDK's retry budget would delay noticing the link is
 /// back by as long as it waits.
 const PROBE_TIMEOUT: Duration = Duration::from_secs(10);
 /// First delay between probes after a drop seen mid-session, and the ceiling it
 /// doubles to while the outage is young. A blip should end in seconds, not in
 /// the minutes [`ONLINE_PROBE_MAX`] allows.
 const PROBE_AFTER_DROP: Duration = Duration::from_secs(2);
 const PROBE_YOUNG_MAX: Duration = Duration::from_secs(30);
 /// How long an outage counts as young. Past it the probe backs off to
 /// [`ONLINE_PROBE_MAX`], because a laptop can sit offline for days and each
 /// probe is a real API round trip.
 const YOUNG_OUTAGE: Duration = Duration::from_secs(10 * 60);
 /// How often the idle probe thread checks for teardown while the link is up.
 const IDLE_CHECK: Duration = Duration::from_secs(1);
 /// The shared half of the online flag: when the link went down, and a condvar
 /// that fires on every change so waiters need not poll.
 #[derive(Default)]
 pub(crate) struct Link {
    lost_at: Mutex<Option<Instant>>,
    changed: Condvar,
    /// Folders listed from the DB alone while offline, to relist once back.
    pub(crate) stale_listings: Mutex<std::collections::HashSet<u64>>,
 }
 /// Whether a failed call failed because Proton could not be reached, rather
 /// than because it answered and refused.
 ///
 /// A transport error is the network. So is a request timeout: the SDK reports
 /// Proton's own "try again" codes that way, and [`no_answer`] reports our
 /// deadline that way. Anything else Proton actually said, and says again on a
 /// retry, so it must reach the caller rather than be queued.
 pub(crate) fn is_network_error(e: &ProtonError) -> bool {
    match e {
        ProtonError::Transport(_) => true,
        ProtonError::Api(api) => {
            matches!(
                api.code,
                ResponseCode::RequestTimeout | ResponseCode::Timeout
            )
        }
        _ => false,
    }
 }
 /// The error a call reports when it runs past `after` without an answer.
 pub(crate) fn no_answer(after: Duration) -> ProtonError {
    ProtonError::Api(ProtonApiError {
        code: ResponseCode::RequestTimeout,
        http_status: 408,
        message: format!("no answer within {}s", after.as_secs()),
        details: None,
    })
 }
 /// Run a remote call, giving up after [`INTERACTIVE_CALL_TIMEOUT`].
 pub(crate) async fn bounded<T>(
    call: impl Future<Output = Result<T, ProtonError>>,
 ) -> Result<T, ProtonError> {
    match tokio::time::timeout(INTERACTIVE_CALL_TIMEOUT, call).await {
        Ok(result) => result,
        Err(_) => Err(no_answer(INTERACTIVE_CALL_TIMEOUT)),
    }
 }
 /// The next delay between probes, given the current one and how long the
 /// outage has lasted.
 fn next_probe_delay(delay: Duration, outage: Duration) -> Duration {
    let cap = if outage < YOUNG_OUTAGE {
        PROBE_YOUNG_MAX
    } else {
        ONLINE_PROBE_MAX
    };
    (delay * 2).min(cap)
 }
 impl Core {
    /// Whether the mount currently believes Proton is reachable.
    pub(crate) fn is_online(&self) -> bool {
        self.online.load(Ordering::Relaxed)
    }
    /// Run a remote call a caller is waiting on, giving up after
    /// [`INTERACTIVE_CALL_TIMEOUT`]. The timer is built inside the runtime: a
    /// FUSE worker has no reactor of its own.
    pub(crate) fn block_on_bounded<T>(
        &self,
        call: impl Future<Output = Result<T, ProtonError>>,
    ) -> Result<T, ProtonError> {
        self.rt.block_on(bounded(call))
    }
    /// Report a failed remote call. Returns whether it failed for want of a
    /// network, in which case the mount is now offline and the caller should
    /// take its queued path instead of failing.
    pub(crate) fn lost_link(&self, e: &ProtonError, what: &str) -> bool {
        if !is_network_error(e) {
            return false;
        }
        self.mark_offline(what, e);
        true
    }
    /// Flip the mount offline and wake the probe. Only the first caller of an
    /// outage logs it; the rest are the same outage.
    pub(crate) fn mark_offline(&self, what: &str, error: &dyn std::fmt::Display) {
        let mut lost_at = self.link.lost_at.lock();
        if self.online.swap(false, Ordering::Relaxed) {
            *lost_at = Some(Instant::now());
            warn!(during = what, %error,
                  "lost the connection to Proton; queueing changes until it returns");
            self.link.changed.notify_all();
        }
    }
    /// Flip the mount back online, wake everything waiting for it, and let the
    /// queue drain.
    fn mark_online(&self) {
        {
            let mut lost_at = self.link.lost_at.lock();
            self.online.store(true, Ordering::Relaxed);
            match lost_at.take() {
                Some(since) => {
                    info!(
                        offline_secs = since.elapsed().as_secs(),
                        "connection to Proton is back"
                    )
                }
                None => info!("back online"),
            }
            self.link.changed.notify_all();
        }
        self.relist_offline_listings();
        // Anything written while offline is queued and waiting on exactly this,
        // including ops that failed on the way down and are sitting out a
        // backoff sized for a server that keeps refusing.
        if let Err(e) = self.db.retry_failed_ops_now(crate::now_millis()) {
            warn!(error = %e, "moving backed-off ops up after a reconnect failed");
        }
        self.wake_drain();
    }
    /// Wait up to `budget` for the link to come back. Returns whether it is up.
    pub(crate) fn wait_online(&self, budget: Duration) -> bool {
        let deadline = Instant::now() + budget;
        let mut lost_at = self.link.lost_at.lock();
        while !self.is_online() {
            if self.shutdown.is_stopping()
                || self
                    .link
                    .changed
                    .wait_until(&mut lost_at, deadline)
                    .timed_out()
            {
                return self.is_online();
            }
        }
        true
    }
    /// Wait out `interval` before a background poll of Proton, and while the
    /// link is down, until it is back. Returns as soon as it comes back, so the
    /// poll catches up on what changed during the outage at once instead of
    /// one interval later. A poll into a dead link would only wait out the
    /// SDK's retries and fail.
    pub(crate) async fn next_poll(&self, interval: Duration) {
        let due = Instant::now() + interval;
        let mut was_offline = false;
        loop {
            if !self.is_online() {
                was_offline = true;
            } else if was_offline || Instant::now() >= due {
                return;
            }
            tokio::time::sleep(IDLE_CHECK).await;
        }
    }
    /// Watch the link for the life of the mount: sleep while it is up, and
    /// probe it back while it is down (offline.md Phase 1).
    ///
    /// A mount that started from the cache is down from the first moment; one
    /// that started online goes down when [`Core::mark_offline`] says so.
    pub(crate) fn run_online_probe(&self) {
        // Only an offline start never had a chance to repair its share id.
        let mut repair_share_id = !self.is_online();
        loop {
            {
                let mut lost_at = self.link.lost_at.lock();
                while self.is_online() {
                    if self.shutdown.is_stopping() {
                        return;
                    }
                    self.link.changed.wait_for(&mut lost_at, IDLE_CHECK);
                }
            }
            if !self.probe_until_online() {
                return;
            }
            if std::mem::take(&mut repair_share_id) {
                self.repair_primary_share_id(&self.primary_root_uid);
            }
        }
    }
    /// Probe until Proton answers, then flip the mount online. Returns `false`
    /// if the daemon is stopping.
    fn probe_until_online(&self) -> bool {
        let started = self.link.lost_at.lock().unwrap_or_else(Instant::now);
        let mut delay = if started.elapsed() < YOUNG_OUTAGE {
            PROBE_AFTER_DROP
        } else {
            ONLINE_PROBE_MIN
        };
        loop {
            if !self.shutdown.sleep(delay) {
                return false;
            }
            let probe = self.rt.block_on(async {
                match tokio::time::timeout(PROBE_TIMEOUT, self.client.get_my_files_folder()).await {
                    Ok(result) => result,
                    Err(_) => Err(no_answer(PROBE_TIMEOUT)),
                }
            });
            match probe {
                Ok(root) => {
                    {
                        let mut st = self.state();
                        if let Some(e) = st.entries.get_mut(&ROOT_INO) {
                            e.node = root.clone();
                        }
                    }
                    if let Err(e) = self.db.upsert_node(&root) {
                        warn!(error = %e, "refresh root after reconnect failed");
                    }
                    self.mark_online();
                    return true;
                }
                Err(e) => {
                    debug!(error = %e, ?delay, "online probe failed; still offline");
                    delay = next_probe_delay(delay, started.elapsed());
                }
            }
        }
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    fn api(code: ResponseCode) -> ProtonError {
        ProtonError::Api(ProtonApiError {
            code,
            http_status: 422,
            message: String::new(),
            details: None,
        })
    }
    #[test]
    fn only_an_unanswered_call_counts_as_a_lost_link() {
        assert!(is_network_error(&no_answer(INTERACTIVE_CALL_TIMEOUT)));
        assert!(is_network_error(&api(ResponseCode::Timeout)));
        assert!(!is_network_error(&api(ResponseCode::AlreadyExists)));
        assert!(!is_network_error(&api(ResponseCode::InvalidRequirements)));
        assert!(!is_network_error(&ProtonError::invalid_operation("bug")));
    }
    #[test]
    fn a_young_outage_is_probed_often_and_an_old_one_rarely() {
        let young = Duration::from_secs(60);
        let old = YOUNG_OUTAGE + Duration::from_secs(1);
        assert_eq!(
            next_probe_delay(PROBE_AFTER_DROP, young),
            2 * PROBE_AFTER_DROP
        );
        assert_eq!(next_probe_delay(PROBE_YOUNG_MAX, young), PROBE_YOUNG_MAX);
        assert_eq!(next_probe_delay(PROBE_YOUNG_MAX, old), 2 * PROBE_YOUNG_MAX);
        assert_eq!(next_probe_delay(ONLINE_PROBE_MAX, old), ONLINE_PROBE_MAX);
    }
 }
@@ -383,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)),
        link: Arc::new(Default::default()),
        sync_paused_until: Arc::new(AtomicI64::new(paused_until)),
        pending: Arc::new(Mutex::new(HashMap::new())),
        hidden: Arc::new(Mutex::new(HashSet::new())),
@@ -411,6 +412,7 @@ pub fn mount(
        thumbnail_build_cancel: Arc::new(tokio::sync::Notify::new()),
        thumbnail_misses: Arc::new(Mutex::new(Default::default())),
        quota: Arc::new(Mutex::new(None)),
        quota_refreshing: Arc::new(AtomicBool::new(false)),
        size_upgrades: Arc::new(Mutex::new(HashMap::new())),
        size_waiters: Arc::new(Default::default()),
        notifier: Arc::new(OnceLock::new()),
@@ -484,9 +486,10 @@ pub fn mount(
        );
    }
-    // Mounted from the cache: watch for the network coming back so the mount can
+    // Watch the link for the life of the mount: a mount from the cache waits for
-    // stop being read-only-ish without the user restarting the daemon.
+    // the network to come back, and an online one can lose it at any moment and
-    if !online {
+    // must notice it coming back just the same.
    {
        let core = core.clone();
        workers.push(
            std::thread::Builder::new()
@@ -36,6 +36,21 @@ pub(super) const REPAIR_MAX: u64 = 512 * 1024 * 1024;
 /// demand read in the SDK's flat block semaphore.
 pub(super) const PREFETCH_BUDGET: usize = 8;
 /// How long one read may wait on the network before it fails with `EIO`.
 ///
 /// The SDK bounds each request, not a read: a block that times out is retried,
 /// and a read can need several blocks, a block table and a repair. On a link
 /// that stalled without dropping, one `read` held a FUSE worker for 34 minutes
 /// and the application behind it with it (`docs/BUGS.md` B107). An error the
 /// caller can retry beats a process stuck in `D` state.
 pub(super) const READ_FETCH_TIMEOUT: Duration = Duration::from_secs(120);
 /// How long a read of blocks nothing has cached waits for a lost link to come
 /// back before failing. Long enough to ride out a Wi-Fi blip, short enough
 /// that a program reading while the laptop is really offline gets its `EIO`
 /// before the user gives up on it.
 const READ_OFFLINE_WAIT: Duration = Duration::from_secs(30);
 /// Cap on tracked sequential streams. Only reads in progress matter, so the map
 /// is cleared wholesale rather than aged — losing the ramp costs one read.
 const MAX_PREFETCH_STREAMS: usize = 256;
@@ -364,6 +379,7 @@ impl Core {
                    let result = match self.client.open_revision(uid).await {
                        Ok(reader) => Ok(Arc::new(reader)),
                        Err(e) => {
                            self.lost_link(&e, "open a revision");
                            warn!(%uid, error = %e, "open_revision failed");
                            Err(Errno::EIO)
                        }
@@ -649,6 +665,7 @@ impl Core {
                    .store_block_geometry(uid, mtime, fsize, reader.block_sizes());
            }
            let bytes = reader.read_at(span.start, span.len).await.map_err(|e| {
                self.lost_link(&e, "read a block");
                warn!(%uid, start = span.start, len = span.len, error = %e, "block read failed");
                Errno::EIO
            })?;
@@ -939,7 +956,21 @@ impl Core {
        }
        if !misses.is_empty() {
-            let fetched = self.rt.block_on(async {
+            // One deadline for the whole read, including any wait for a lost
            // link. A fetch that failed because the link went down is tried
            // once more when it is back, so a blip is a slow read, not an `EIO`.
            let deadline = Instant::now() + READ_FETCH_TIMEOUT;
            let mut retried = false;
            let fetched = loop {
                if !self.is_online() {
                    let wait =
                        READ_OFFLINE_WAIT.min(deadline.saturating_duration_since(Instant::now()));
                    if !self.wait_online(wait) {
                        debug!(%uid, offset, len, "read of uncached blocks while offline; failing it");
                        return Err(Errno::EIO);
                    }
                }
                let fetch = async {
                    // Resolve the file's keys and block table once, then read every
                    // missing block through the shared reader. Previously each block
                    // called `download_range`, which redid that resolution per block.
@@ -960,7 +991,32 @@ impl Core {
                        out.push(joined.map_err(|_| Errno::EIO)??);
                    }
                    Ok::<_, Errno>(out)
-            })?;
+                };
                // Dropping the fetch on the deadline aborts the block tasks with
                // it; blocks that already landed stay cached for the retry. The
                // timer is built inside the runtime: a FUSE worker has no reactor
                // of its own, and building it out here panicked every remote read.
                let budget = deadline.saturating_duration_since(Instant::now());
                match self
                    .rt
                    .block_on(async { tokio::time::timeout(budget, fetch).await })
                {
                    Ok(Ok(fetched)) => break fetched,
                    // The fetch saw the link go down; the top of the loop waits
                    // for it within what is left of the deadline.
                    Ok(Err(_)) if !retried && !self.is_online() => retried = true,
                    Ok(Err(e)) => return Err(e),
                    Err(_) => {
                        warn!(
                            %uid, offset, len, secs = READ_FETCH_TIMEOUT.as_secs(),
                            "read got no answer from the network in time; failing it"
                        );
                        self.evict_reader(uid);
                        self.mark_offline("read", &crate::link::no_answer(READ_FETCH_TIMEOUT));
                        return Err(Errno::EIO);
                    }
                }
            };
            for (bidx, bytes) in fetched {
                blocks[(bidx - first) as usize] = Some(bytes);
            }
@@ -0,0 +1,603 @@
 //! Moving a file or folder between two locations without moving its content.
 //!
 //! `~/ProtonDrive` and every on-demand synced folder are separate FUSE
 //! sessions, and a mirror folder is a plain local directory. The kernel refuses
 //! `rename(2)` between two mounts with `EXDEV` before the daemon hears of it, so
 //! `mv` falls back to copy and delete: every file is downloaded, uploaded again,
 //! and the original is trashed.
 //!
 //! On Proton Drive the same move is one metadata change, because My files and
 //! this computer's device folders all live on the main volume. So a move
 //! request that names two absolute paths is resolved here, against every
 //! location this daemon knows, and done as a server-side move. The local side
 //! is then brought level: a mount forgets the node and re-lists, and a mirror
 //! folder either renames its copy along or drops it once Drive has it.
 use std::collections::HashMap;
 use std::path::{Component, Path, PathBuf};
 use std::sync::Arc;
 use std::time::Duration;
 use parking_lot::Mutex;
 use pdfs_core::db::{StoredSyncEntry, StoredSyncFolder};
 use pdfs_core::{CoreError, CoreResult};
 use proton_drive_rs::NodeKind;
 use proton_drive_rs::proton_sdk::ids::NodeUid;
 use tracing::{info, warn};
 use super::background::forget_and_notify;
 use super::sync::mirror_subtree_unsynced;
 use super::{Core, is_local_uid, parse_uid};
 /// How long a move waits for a mirror folder's sync pass to finish before it
 /// reports the folder busy. A pass can run for hours on a first sync, so the
 /// move does not wait it out.
 const MIRROR_LOCK_WAIT: Duration = Duration::from_secs(5);
 /// Where one side of a move lives.
 enum Place {
    /// My files or an on-demand folder: a live inode space. `core` is rooted at
    /// that mount and `rel` is relative to its mountpoint.
    Mounted { core: Box<Core>, rel: PathBuf },
    /// A mirror folder: a local directory kept in step by the sync engine.
    /// `rel` is `/`-separated, relative to the folder, as the baseline keys it.
    Mirror {
        folder: StoredSyncFolder,
        rel: String,
    },
 }
 impl Place {
    fn mirror_id(&self) -> Option<i64> {
        match self {
            Place::Mirror { folder, .. } => Some(folder.id),
            Place::Mounted { .. } => None,
        }
    }
    fn is_root(&self) -> bool {
        match self {
            Place::Mounted { rel, .. } => rel.as_os_str().is_empty(),
            Place::Mirror { rel, .. } => rel.is_empty(),
        }
    }
 }
 /// The mirror folder that holds `abs`, and `abs` relative to it. The deepest
 /// folder wins, although folders are not expected to nest.
 fn mirror_covering(
    folders: Vec<StoredSyncFolder>,
    abs: &Path,
 ) -> Option<(StoredSyncFolder, String)> {
    let folder = folders
        .into_iter()
        .filter(|f| f.mode == "mirror" && abs.starts_with(&f.local_path))
        .max_by_key(|f| Path::new(&f.local_path).components().count())?;
    let rel = abs.strip_prefix(&folder.local_path).ok()?;
    let parts = rel
        .components()
        .map(|c| match c {
            Component::Normal(part) => part.to_str(),
            _ => None,
        })
        .collect::<Option<Vec<_>>>()?;
    Some((folder, parts.join("/")))
 }
 /// `name` inside the folder at `parent`, in baseline form.
 fn join_rel(parent: &str, name: &str) -> String {
    if parent.is_empty() {
        name.to_string()
    } else {
        format!("{parent}/{name}")
    }
 }
 /// Rename `from` to `to`, failing with `EEXIST` rather than replacing
 /// whatever appeared at `to` since it was checked. A filesystem that cannot
 /// promise that gets a plain rename after one more look.
 fn rename_noreplace(from: &Path, to: &Path) -> std::io::Result<()> {
    use std::ffi::CString;
    use std::os::unix::ffi::OsStrExt;
    let cstr = |p: &Path| {
        CString::new(p.as_os_str().as_bytes())
            .map_err(|_| std::io::Error::from_raw_os_error(libc::EINVAL))
    };
    let (c_from, c_to) = (cstr(from)?, cstr(to)?);
    // SAFETY: both are valid NUL-terminated paths that outlive the call.
    let rc = unsafe {
        libc::syscall(
            libc::SYS_renameat2,
            libc::AT_FDCWD,
            c_from.as_ptr(),
            libc::AT_FDCWD,
            c_to.as_ptr(),
            libc::RENAME_NOREPLACE,
        )
    };
    if rc == 0 {
        return Ok(());
    }
    let err = std::io::Error::last_os_error();
    match err.raw_os_error() {
        Some(libc::EINVAL | libc::ENOSYS) => {
            if std::fs::symlink_metadata(to).is_ok() {
                return Err(std::io::Error::from_raw_os_error(libc::EEXIST));
            }
            std::fs::rename(from, to)
        }
        _ => Err(err),
    }
 }
 /// Whether `uid` is `root` or lies under it, as far as the nodes table knows.
 fn under(core: &Core, root: &NodeUid, uid: &str) -> bool {
    let root = root.to_string();
    uid == root || matches!(core.db.path_relative_to(&root, uid), Ok(Some(_)))
 }
 impl Core {
    /// Move the file or folder at `src` into the folder at `dest_parent`. Both
    /// are absolute local paths and may be in different locations: My files,
    /// an on-demand folder, or a mirror folder. Returns the moved name.
    ///
    /// Within one inode space this is [`Core::move_to`]. Across locations it
    /// is a server-side move followed by local bookkeeping; see the module
    /// documentation. Anything the move could lose is refused up front.
    pub(crate) fn move_between(&self, src: &Path, dest_parent: &Path) -> CoreResult<String> {
        let source = self.locate(src)?;
        let dest = self.locate(dest_parent)?;
        if let (
            Place::Mounted { core, rel },
            Place::Mounted {
                core: dest_core,
                rel: dest_rel,
            },
        ) = (&source, &dest)
            && Arc::ptr_eq(&core.state, &dest_core.state)
        {
            return core.move_to(rel, dest_rel);
        }
        if source.is_root() {
            return Err(CoreError::invalid(format!(
                "{} is the root of a synced location and cannot be moved",
                src.display()
            )));
        }
        if dest_parent.starts_with(src) {
            return Err(CoreError::invalid("cannot move a folder into itself"));
        }
        let name = src
            .file_name()
            .and_then(|n| n.to_str())
            .ok_or_else(|| CoreError::invalid(format!("{} has no usable name", src.display())))?
            .to_string();
        // Hold every mirror folder involved, lowest id first, so no sync pass
        // sees the move half done and two moves cannot deadlock.
        let mut ids: Vec<i64> = [source.mirror_id(), dest.mirror_id()]
            .into_iter()
            .flatten()
            .collect();
        ids.sort_unstable();
        ids.dedup();
        let locks: Vec<Arc<Mutex<()>>> = ids.iter().map(|&id| self.sync_lock(id)).collect();
        let mut guards = Vec::with_capacity(locks.len());
        for lock in &locks {
            guards.push(lock.try_lock_for(MIRROR_LOCK_WAIT).ok_or_else(|| {
                CoreError::conflict("a synced folder is busy syncing; try again when it is done")
            })?);
        }
        let mut baselines: HashMap<i64, HashMap<String, StoredSyncEntry>> = HashMap::new();
        for &id in &ids {
            let baseline = self
                .db
                .sync_entries(id)
                .map_err(|e| CoreError::internal(format!("db: {e}")))?;
            baselines.insert(id, baseline);
        }
        let src_uid = self.source_uid(&source, &baselines)?;
        let dest_uid = self.dest_uid(&dest, &baselines, &name)?;
        if src_uid.volume_id != dest_uid.volume_id {
            return Err(CoreError::invalid(
                "the two locations are on different Proton Drive volumes; copy it instead",
            ));
        }
        if under(self, &src_uid, &dest_uid.to_string()) {
            return Err(CoreError::invalid("cannot move a folder into itself"));
        }
        // Mirror to mirror renames the local copy along, so it needs nothing
        // proven about it. Another filesystem makes that impossible, and the
        // pair then drops the source copy like any other move out of a mirror.
        let mut renamed = None;
        if let (
            Place::Mirror { folder, rel },
            Place::Mirror {
                folder: dest_folder,
                rel: dest_rel,
            },
        ) = (&source, &dest)
        {
            let from = src.to_path_buf();
            let to = dest_parent.join(&name);
            match rename_noreplace(&from, &to) {
                Ok(()) => renamed = Some((from, to)),
                Err(e) if e.raw_os_error() == Some(libc::EXDEV) => {
                    info!(from = %folder.local_path, to = %dest_folder.local_path,
                        "move: mirror folders are on different filesystems");
                }
                Err(e) if e.raw_os_error() == Some(libc::EEXIST) => {
                    return Err(CoreError::conflict(format!(
                        "{name} already exists in {}",
                        dest_parent.display()
                    )));
                }
                Err(e) => {
                    return Err(CoreError::internal(format!(
                        "could not move {} to {}: {e}",
                        rel,
                        join_rel(dest_rel, &name)
                    )));
                }
            }
        }
        if renamed.is_none()
            && let Place::Mirror { folder, rel } = &source
            && let Some(reason) =
                mirror_subtree_unsynced(Path::new(&folder.local_path), rel, &baselines[&folder.id])
        {
            return Err(CoreError::conflict(format!(
                "{name} is not fully synced yet ({reason}); wait for the sync to finish"
            )));
        }
        if let Err(e) = self.rt.block_on(self.client.move_node(&src_uid, &dest_uid)) {
            if let Some((from, to)) = &renamed
                && let Err(back) = std::fs::rename(to, from)
            {
                warn!(from = %to.display(), to = %from.display(), error = %back,
                    "move: could not put the local copy back after the move failed");
            }
            return Err(CoreError::from_api(&e, "move"));
        }
        self.settle_source(&source, &src_uid, renamed.is_some(), &dest, &name, src);
        self.settle_dest(&dest, &dest_uid, &name);
        drop(guards);
        if renamed.is_none()
            && let Place::Mirror { folder, .. } = &dest
        {
            // Nothing local exists yet; the folder's next pass downloads it.
            self.sync_now(Some(folder.id));
        }
        Ok(name)
    }
    /// Which location `abs` is in. A mount is looked for first: a mirror folder
    /// cannot live inside a FUSE mount, and a mount is what the kernel sees.
    fn locate(&self, abs: &Path) -> CoreResult<Place> {
        if let Some((core, rel)) = self.rooted_at(abs) {
            if !rel
                .components()
                .all(|c| matches!(c, Component::Normal(_) | Component::CurDir))
            {
                return Err(CoreError::invalid(format!(
                    "{} escapes its location",
                    abs.display()
                )));
            }
            return Ok(Place::Mounted {
                core: Box::new(core),
                rel,
            });
        }
        let folders = self
            .db
            .sync_folder_list()
            .map_err(|e| CoreError::internal(format!("db: {e}")))?;
        mirror_covering(folders, abs)
            .map(|(folder, rel)| Place::Mirror { folder, rel })
            .ok_or_else(|| {
                CoreError::invalid(format!(
                    "{} is not in a Proton Drive location",
                    abs.display()
                ))
            })
    }
    /// The node being moved, once everything that must hold before it leaves
    /// its location has been checked.
    fn source_uid(
        &self,
        source: &Place,
        baselines: &HashMap<i64, HashMap<String, StoredSyncEntry>>,
    ) -> CoreResult<NodeUid> {
        match source {
            Place::Mounted { core, rel } => {
                let (ino, uid) = core.resolve(rel)?;
                if is_local_uid(&uid) {
                    return Err(CoreError::conflict(
                        "it is not uploaded yet; wait for the upload to finish",
                    ));
                }
                let old_parent = core.source_parent_uid(ino, rel)?;
                for authority in [&uid, &old_parent] {
                    core.require_uid_writable(authority)
                        .map_err(|e| core.errno_error(e, "move access"))?;
                }
                if self.has_pending_work_under(&uid)? {
                    return Err(CoreError::conflict(
                        "it has changes that are not uploaded yet; wait for the upload to finish",
                    ));
                }
                Ok(uid)
            }
            Place::Mirror { folder, rel } => baselines[&folder.id]
                .get(rel)
                .and_then(|entry| entry.remote_uid.as_deref())
                .and_then(parse_uid)
                .ok_or_else(|| {
                    CoreError::conflict(
                        "it is not on Proton Drive yet; wait for the sync to finish",
                    )
                }),
        }
    }
    /// The folder the node moves into. Refuses one that already holds `name`
    /// on this disk; Drive refuses a clash on its side by itself.
    fn dest_uid(
        &self,
        dest: &Place,
        baselines: &HashMap<i64, HashMap<String, StoredSyncEntry>>,
        name: &str,
    ) -> CoreResult<NodeUid> {
        let uid = match dest {
            Place::Mounted { core, rel } => {
                let (ino, uid) = core.resolve(rel)?;
                let is_folder = core
                    .state()
                    .entries
                    .get(&ino)
                    .is_some_and(|entry| matches!(entry.node.kind, NodeKind::Folder));
                if !is_folder {
                    return Err(CoreError::invalid("the destination is not a folder"));
                }
                core.require_uid_writable(&uid)
                    .map_err(|e| core.errno_error(e, "move access"))?;
                uid
            }
            Place::Mirror { folder, rel } => {
                let local = Path::new(&folder.local_path).join(rel);
                if !local.is_dir() {
                    return Err(CoreError::invalid("the destination is not a folder"));
                }
                if std::fs::symlink_metadata(local.join(name)).is_ok() {
                    return Err(CoreError::conflict(format!(
                        "{name} already exists in the destination"
                    )));
                }
                let uid = if rel.is_empty() {
                    Some(folder.remote_uid.as_str())
                } else {
                    baselines[&folder.id]
                        .get(rel)
                        .and_then(|entry| entry.remote_uid.as_deref())
                };
                uid.and_then(parse_uid).ok_or_else(|| {
                    CoreError::conflict(
                        "the destination is not on Proton Drive yet; wait for the sync to finish",
                    )
                })?
            }
        };
        if is_local_uid(&uid) {
            return Err(CoreError::conflict(
                "the destination is not uploaded yet; wait for the upload to finish",
            ));
        }
        Ok(uid)
    }
    /// Whether the queue owes Drive anything for `uid` or a node under it, or a
    /// file under it is open for writing. Moving such a node away would strand
    /// the pending change against a path that no longer leads to it.
    fn has_pending_work_under(&self, uid: &NodeUid) -> CoreResult<bool> {
        let ops = self
            .db
            .pending_ops()
            .map_err(|e| CoreError::internal(format!("db: {e}")))?;
        if ops.iter().any(|op| {
            under(self, uid, &op.uid)
                || op
                    .parent_uid
                    .as_deref()
                    .is_some_and(|p| under(self, uid, p))
        }) {
            return Ok(true);
        }
        // Collected first so no State lock is held across the nodes-table reads.
        let mut writing = Vec::new();
        self.for_each_state(|st| {
            writing.extend(st.active_writes.values().map(|w| w.uid.to_string()));
        });
        Ok(writing.iter().any(|w| under(self, uid, w)))
    }
    /// Bring the source location level with a move Drive has made.
    fn settle_source(
        &self,
        source: &Place,
        uid: &NodeUid,
        renamed: bool,
        dest: &Place,
        name: &str,
        src: &Path,
    ) {
        match source {
            Place::Mounted { core, rel } => {
                // Forget it everywhere, so no mount keeps serving it under the
                // old path. The content cache is keyed by uid and stays valid.
                self.for_each_mount(|st, notify| {
                    forget_and_notify(st, notify, uid);
                });
                core.invalidate_parent_listing(rel);
            }
            Place::Mirror { folder, rel } if renamed => {
                let Place::Mirror {
                    folder: dest_folder,
                    rel: dest_rel,
                } = dest
                else {
                    unreachable!("a local rename needs a mirror destination");
                };
                if let Err(e) = self.db.sync_entries_move(
                    folder.id,
                    rel,
                    dest_folder.id,
                    &join_rel(dest_rel, name),
                ) {
                    // The next passes see a copy with no baseline on one side
                    // and a baseline with no copy on the other. That uploads
                    // the files again and trashes the moved node, but loses
                    // nothing.
                    warn!(error = ?e, "move: could not carry the sync baseline along");
                }
            }
            Place::Mirror { folder, rel } => {
                // Drive had all of it when the move was checked, so the local
                // copy is only a stale duplicate now. Something written into it
                // since would go with it, so look again first; if anything is
                // new, the copy stays and the next pass uploads it as new.
                let changed = match self.db.sync_entries(folder.id) {
                    Ok(baseline) => {
                        mirror_subtree_unsynced(Path::new(&folder.local_path), rel, &baseline)
                    }
                    Err(e) => Some(format!("db: {e}")),
                };
                if let Err(e) = self.db.sync_entries_remove_subtree(folder.id, rel) {
                    warn!(error = ?e, "move: could not drop the sync baseline");
                }
                if let Some(reason) = changed {
                    warn!(path = %src.display(), reason,
                        "move: the local copy changed during the move; keeping it");
                    return;
                }
                let removed = if src.is_dir() {
                    std::fs::remove_dir_all(src)
                } else {
                    std::fs::remove_file(src)
                };
                if let Err(e) = removed {
                    warn!(path = %src.display(), error = %e,
                        "move: could not remove the local copy after the move");
                }
            }
        }
    }
    /// Bring the destination location level with a move Drive has made.
    fn settle_dest(&self, dest: &Place, uid: &NodeUid, name: &str) {
        if let Place::Mounted { .. } = dest {
            self.invalidate_children_of(uid);
            // A lookup that missed before the move may be cached as absent.
            self.for_each_mount(|st, notify| {
                if let Some(&ino) = st.by_uid.get(uid) {
                    notify.inval_entry(ino, name.to_string());
                }
            });
        }
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    fn folder(id: i64, local_path: &str, mode: &str) -> StoredSyncFolder {
        StoredSyncFolder {
            id,
            local_path: local_path.to_string(),
            remote_uid: format!("vol~root{id}"),
            remote_share_id: String::new(),
            mode: mode.to_string(),
            pending_mode: None,
            state: "idle".to_string(),
            last_sync: 0,
        }
    }
    #[test]
    fn mirror_covering_finds_the_mirror_folder_and_the_path_inside_it() {
        let folders = vec![folder(1, "/home/u/Docs", "mirror")];
        let (found, rel) = mirror_covering(folders, Path::new("/home/u/Docs/a/b.txt")).unwrap();
        assert_eq!(found.id, 1);
        assert_eq!(rel, "a/b.txt");
    }
    #[test]
    fn mirror_covering_gives_an_empty_path_for_the_folder_itself() {
        let folders = vec![folder(1, "/home/u/Docs", "mirror")];
        let (_, rel) = mirror_covering(folders, Path::new("/home/u/Docs")).unwrap();
        assert_eq!(rel, "");
    }
    #[test]
    fn mirror_covering_prefers_the_deepest_folder() {
        let folders = vec![
            folder(1, "/home/u/Docs", "mirror"),
            folder(2, "/home/u/Docs/Work", "mirror"),
        ];
        let (found, rel) = mirror_covering(folders, Path::new("/home/u/Docs/Work/x")).unwrap();
        assert_eq!(found.id, 2);
        assert_eq!(rel, "x");
    }
    #[test]
    fn mirror_covering_skips_on_demand_folders_and_name_prefixed_siblings() {
        let folders = || {
            vec![
                folder(1, "/home/u/Docs", "mirror"),
                folder(2, "/home/u/Media", "ondemand"),
            ]
        };
        assert!(mirror_covering(folders(), Path::new("/home/u/Media/x")).is_none());
        assert!(mirror_covering(folders(), Path::new("/home/u/Docs2/x")).is_none());
    }
    #[test]
    fn mirror_covering_refuses_a_path_that_climbs_out() {
        let folders = vec![folder(1, "/home/u/Docs", "mirror")];
        assert!(mirror_covering(folders, Path::new("/home/u/Docs/../etc")).is_none());
    }
    #[test]
    fn join_rel_names_a_child_of_the_folder_root_without_a_slash() {
        assert_eq!(join_rel("", "a"), "a");
        assert_eq!(join_rel("x/y", "a"), "x/y/a");
    }
    #[test]
    fn a_local_rename_never_replaces_what_is_already_there() {
        let dir = std::env::temp_dir().join(format!("pdfs-relocate-{}", std::process::id()));
        let _ = std::fs::remove_dir_all(&dir);
        std::fs::create_dir_all(&dir).unwrap();
        let (a, b, c) = (dir.join("a"), dir.join("b"), dir.join("c"));
        std::fs::write(&a, b"moved").unwrap();
        std::fs::write(&b, b"kept").unwrap();
        let err = rename_noreplace(&a, &b).unwrap_err();
        assert_eq!(err.raw_os_error(), Some(libc::EEXIST));
        assert_eq!(std::fs::read(&b).unwrap(), b"kept");
        assert!(a.exists());
        rename_noreplace(&a, &c).unwrap();
        assert!(!a.exists());
        assert_eq!(std::fs::read(&c).unwrap(), b"moved");
        std::fs::remove_dir_all(&dir).unwrap();
    }
 }
@@ -610,10 +610,10 @@ impl Core {
    /// Proton products (not Drive-only). A remote round-trip; nothing here is
    /// cached.
    pub(crate) fn account_quota(&self) -> CoreResult<(i64, i64)> {
-        let q = self
+        let q = self.block_on_bounded(self.client.quota()).map_err(|e| {
-            .rt
+            self.lost_link(&e, "account quota");
-            .block_on(self.client.quota())
+            CoreError::from_api(&e, "account quota")
-            .map_err(|e| CoreError::from_api(&e, "account quota"))?;
+        })?;
        *self.quota.lock() = Some((std::time::Instant::now(), q.max_space, q.used_space));
        Ok((q.max_space, q.used_space))
    }
@@ -632,11 +632,22 @@ impl Core {
        {
            return Some((max_space, used_space));
        }
-        match self.account_quota() {
+        let last = || self.quota.lock().map(|(_, max, used)| (max, used));
        if !self.is_online()
            || self
                .quota_refreshing
                .swap(true, std::sync::atomic::Ordering::AcqRel)
        {
            return last();
        }
        let refreshed = self.account_quota();
        self.quota_refreshing
            .store(false, std::sync::atomic::Ordering::Release);
        match refreshed {
            Ok(q) => Some(q),
            Err(error) => {
                debug!(%error, "account quota refresh failed; serving the last known figures");
-                self.quota.lock().map(|(_, max, used)| (max, used))
+                last()
            }
        }
    }
@@ -128,6 +128,23 @@ pub(crate) struct WriteHandle {
    pub(crate) open_count: usize,
 }
 impl WriteHandle {
    /// Account for `[offset, end)` having been written through this handle.
    ///
    /// A write past the end leaves a hole that reads as zeros, exactly like a
    /// grow through `setattr`, so the hole is authored too. Left unauthored, a
    /// hole below the base size was refilled from the base at commit: a file
    /// shrunk and then written past its new end got its old bytes back.
    pub(crate) fn record_write(&mut self, offset: u64, end: u64) {
        if offset > self.len {
            self.written.add(self.len, offset);
        }
        self.written.add(offset, end);
        self.len = self.len.max(end);
        self.dirty = true;
    }
 }
 /// A released write whose upload has not happened yet (offline.md Phase 3).
 ///
 /// The bytes live in the content cache's staging dir and the intent lives in the
@@ -783,12 +800,13 @@ impl State {
        self.intern_mem_with_access(parent, node, access)
    }
-    fn intern_mem_with_access(&mut self, parent: u64, node: Node, access: Access) -> u64 {
+    fn intern_mem_with_access(&mut self, parent: u64, mut node: Node, access: Access) -> u64 {
        if let Some(&ino) = self.by_uid.get(&node.uid) {
            let changed = self
                .entries
                .get(&ino)
                .is_some_and(|entry| entry.access != access);
            self.keep_open_write_size(ino, &mut node);
            if let Some(e) = self.entries.get_mut(&ino) {
                e.node = node;
                e.parent = parent;
@@ -833,6 +851,23 @@ impl State {
    /// Allocate (or reuse) a stable inode for a node that came *from* the
    /// database, which is why nothing is written back.
    /// Carry the size and mtime of a file open for writing over onto `node`,
    /// which is about to replace its entry.
    ///
    /// The open handle is ahead of anything Drive can report until release
    /// queues it. Taking the remote's size shrank a SQLite database to its empty
    /// create while SQLite held it open, and the kernel then capped every read
    /// at that size (docs/BUGS.md B109).
    pub(crate) fn keep_open_write_size(&self, ino: u64, node: &mut Node) {
        let (Some(aw), Some(entry)) = (self.active_writes.get(&ino), self.entries.get(&ino)) else {
            return;
        };
        if let NodeKind::File { claimed_size, .. } = &mut node.kind {
            *claimed_size = Some(aw.len as i64);
            node.modification_time = entry.node.modification_time;
        }
    }
    pub(crate) fn intern_from_db(&mut self, parent: u64, node: Node) -> u64 {
        self.intern_mem(parent, node)
    }
@@ -1863,4 +1898,71 @@ mod tests {
        let shared = st.intern(owned_root, shared);
        assert_eq!(st.entries[&shared].access, Access::Viewer);
    }
    fn handle(len: u64, base_size: u64) -> WriteHandle {
        let path = std::env::temp_dir().join(format!("pdfs-handle-test-{}", std::process::id()));
        let file = File::create(&path).unwrap();
        let _ = std::fs::remove_file(&path);
        WriteHandle {
            ino: 2,
            uid: uid("file"),
            file: Arc::new(file),
            path,
            written: Intervals::default(),
            len,
            base_size,
            base_mtime: 0,
            base_revision_id: None,
            dirty: false,
            open_count: 1,
        }
    }
    #[test]
    fn a_listing_does_not_shrink_a_file_open_for_writing() {
        let (mut st, _dir) = state();
        let ino = st.intern(0, node("file", "root", "workload.db", false));
        let mut h = handle(16384, 0);
        h.ino = ino;
        st.active_writes.insert(ino, h);
        st.set_size(ino, 16384);
        st.touch_mtime(ino, 500);
        // The remote still holds the empty file the create sealed.
        st.intern(0, node("file", "root", "workload.db", false));
        assert_eq!(crate::node_size(&st.entries[&ino].node), 16384);
        assert_eq!(st.entries[&ino].node.modification_time, 500);
        // Once the handle is gone the remote is authoritative again.
        st.active_writes.remove(&ino);
        st.intern(0, node("file", "root", "workload.db", false));
        assert_eq!(crate::node_size(&st.entries[&ino].node), 0);
    }
    #[test]
    fn a_write_past_the_end_authors_the_hole_it_leaves() {
        // Opened over a 100-byte base, shrunk to 10, then written at 50: bytes
        // 10..50 are zeros now, not the base's bytes 10..50.
        let mut h = handle(100, 100);
        h.written.clip(10);
        h.len = 10;
        h.record_write(50, 60);
        assert_eq!(h.len, 60);
        assert_eq!(
            h.written.segments(0, 60),
            vec![(0, 10, false), (10, 60, true)],
            "only the head still comes from the base"
        );
    }
    #[test]
    fn a_write_inside_the_file_leaves_the_rest_to_the_base() {
        let mut h = handle(100, 100);
        h.record_write(40, 50);
        assert_eq!(h.len, 100);
        assert_eq!(
            h.written.segments(0, 100),
            vec![(0, 40, false), (40, 50, true), (50, 100, false)]
        );
    }
 }
@@ -73,6 +73,9 @@ enum Applied {
    Downloaded,
    /// A conflict copy was kept.
    Conflict,
    /// The local file to upload was deleted after the scan planned it. There is
    /// nothing left to send, and the next pass sees the deletion (B108).
    Vanished,
 }
 impl Core {
@@ -1147,13 +1150,10 @@ impl Core {
                Ok(Applied::Dir(rel.clone(), uid))
            }
            Pending::UploadNew { rel, parent } => {
-                self.upload_new(folder_id, local_root, rel, parent).await?;
+                self.upload_new(folder_id, local_root, rel, parent).await
                Ok(Applied::Uploaded)
            }
            Pending::UploadRevision { rel, uid } => {
-                self.upload_revision(folder_id, local_root, rel, uid)
+                self.upload_revision(folder_id, local_root, rel, uid).await
                    .await?;
                Ok(Applied::Uploaded)
            }
            Pending::Download {
                rel,
@@ -1217,10 +1217,12 @@ impl Core {
        local_root: &Path,
        rel: &str,
        parent: &NodeUid,
-    ) -> Result<(), String> {
+    ) -> Result<Applied, String> {
        let path = local_root.join(rel_to_path(rel));
        let name = base_name(rel);
-        let file = std::fs::File::open(&path).map_err(|e| format!("open {rel}: {e}"))?;
+        let Some(file) = open_to_upload(&path, rel)? else {
            return Ok(Applied::Vanished);
        };
        let meta = file.metadata().map_err(|e| format!("stat {rel}: {e}"))?;
        let mtime = system_mtime(&meta);
        // Taken from the descriptor being streamed, so it names the content that
@@ -1261,7 +1263,8 @@ impl Core {
        self.invalidate_children_of(parent);
        warn_if_torn(rel, &path, streamed);
        self.record_file_baseline(folder_id, rel, Some(streamed), &uid)
-            .await
+            .await?;
        Ok(Applied::Uploaded)
    }
    /// Upload a changed local file as a new revision of an existing remote node.
@@ -1271,9 +1274,11 @@ impl Core {
        local_root: &Path,
        rel: &str,
        uid: &NodeUid,
-    ) -> Result<(), String> {
+    ) -> Result<Applied, String> {
        let path = local_root.join(rel_to_path(rel));
-        let file = std::fs::File::open(&path).map_err(|e| format!("open {rel}: {e}"))?;
+        let Some(file) = open_to_upload(&path, rel)? else {
            return Ok(Applied::Vanished);
        };
        let meta = file.metadata().map_err(|e| format!("stat {rel}: {e}"))?;
        let mtime = system_mtime(&meta);
        let streamed = LocalSig::from(&meta);
@@ -1295,7 +1300,8 @@ impl Core {
            .map_err(|e| format!("upload revision {rel}: {e}"))?;
        warn_if_torn(rel, &path, streamed);
        self.record_file_baseline(folder_id, rel, Some(streamed), uid)
-            .await
+            .await?;
        Ok(Applied::Uploaded)
    }
    /// Download a remote file to its local path (atomically via a temp file),
@@ -1328,7 +1334,21 @@ impl Core {
                .map(|d| d.as_nanos())
                .unwrap_or(0)
        ));
-        {
+        // A file an on-demand mount already read, say one just moved here from
        // it, is in the content cache under the same revision key.
        let seeded = size > 0 && self.cache.copy_cached_to(uid, mtime, size as u64, &tmp);
        if seeded {
            std::fs::File::open(&tmp)
                .and_then(|f| f.sync_all())
                .map_err(|e| {
                    let _ = std::fs::remove_file(&tmp);
                    format!("sync tmp {rel}: {e}")
                })?;
            debug!(
                rel,
                "sync: placed from the content cache instead of downloading"
            );
        } else {
            let out = std::fs::File::create(&tmp).map_err(|e| format!("create tmp {rel}: {e}"))?;
            // Count the bytes as they land, so the download reports progress like
            // an on-demand hydration does.
@@ -1431,6 +1451,23 @@ impl Core {
    }
 }
 /// Open a local file for upload, or `None` when it is gone.
 ///
 /// A scan plans uploads from a listing, and the file can be deleted before its
 /// upload starts — a build or a test tree cleaned up mid-pass. That is not a
 /// failure: the next pass sees the deletion. Counting it as one put the folder
 /// in `error` for a file nobody wanted any more (B108).
 fn open_to_upload(path: &Path, rel: &str) -> Result<Option<std::fs::File>, String> {
    match std::fs::File::open(path) {
        Ok(file) => Ok(Some(file)),
        Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
            debug!(rel, "sync: file deleted before its upload; skipping");
            Ok(None)
        }
        Err(e) => Err(format!("open {rel}: {e}")),
    }
 }
 /// Say so when a file changed under an upload that was streaming it.
 ///
 /// Purely diagnostic — the correction is already in place, because the baseline
@@ -1602,6 +1639,76 @@ fn walk_local_tree(
    Ok(())
 }
 /// Why the mirror copy at `rel` holds something Proton Drive does not, or
 /// `None` when everything under it is on Drive exactly as it is on disk.
 ///
 /// A move out of a mirror folder removes the local copy once Drive has moved
 /// the node, so anything only this disk has would be lost with it: a file not
 /// uploaded yet, one edited since, a deletion not carried up yet, or anything
 /// the engine never uploads. That is why ignored names count here, and why the
 /// walk is its own rather than [`walk_local_tree`], which skips symlinks.
 pub(crate) fn mirror_subtree_unsynced(
    root: &Path,
    rel: &str,
    baseline: &HashMap<String, StoredSyncEntry>,
 ) -> Option<String> {
    let mut seen = HashSet::new();
    if let Some(reason) = unsynced_local(root, rel, baseline, &mut seen) {
        return Some(reason);
    }
    let prefix = format!("{rel}/");
    baseline
        .keys()
        .filter(|r| *r == rel || r.starts_with(&prefix))
        .find(|r| !seen.contains(r.as_str()))
        .map(|r| format!("{r} was deleted here but not on Proton Drive yet"))
 }
 fn unsynced_local(
    root: &Path,
    rel: &str,
    baseline: &HashMap<String, StoredSyncEntry>,
    seen: &mut HashSet<String>,
 ) -> Option<String> {
    let path = root.join(rel_to_path(rel));
    let meta = match std::fs::symlink_metadata(&path) {
        Ok(meta) => meta,
        Err(e) => return Some(format!("cannot read {rel}: {e}")),
    };
    let Some(base) = baseline.get(rel) else {
        return Some(format!("{rel} is not on Proton Drive yet"));
    };
    seen.insert(rel.to_string());
    if meta.is_file() {
        return (!LocalSig::from(&meta).same_content(&LocalSig::from(base)))
            .then(|| format!("{rel} has changes that are not on Proton Drive yet"));
    }
    if !meta.is_dir() {
        return Some(format!("{rel} is not a regular file or folder"));
    }
    let entries = match std::fs::read_dir(&path) {
        Ok(entries) => entries,
        Err(e) => return Some(format!("cannot read {rel}: {e}")),
    };
    for entry in entries {
        let name = match entry {
            Ok(entry) => entry.file_name(),
            Err(e) => return Some(format!("cannot read {rel}: {e}")),
        };
        let Some(name) = name.to_str() else {
            return Some(format!("{rel} holds a name that is not valid UTF-8"));
        };
        // A download the engine left half done; it is the engine's to clean up.
        if name.contains(".pdfs-tmp-") {
            continue;
        }
        if let Some(reason) = unsynced_local(root, &format!("{rel}/{name}"), baseline, seen) {
            return Some(reason);
        }
    }
    None
 }
 /// Publish a conflict copy without overwriting an earlier conflict bearing the
 /// same timestamp. The original is removed only after the new copy is durable.
 fn preserve_conflict_copy(path: &Path, stamp: i64) -> std::io::Result<PathBuf> {
@@ -2155,6 +2262,27 @@ mod tests {
        assert_eq!(remote_sig(&e), None);
    }
    #[test]
    fn a_file_deleted_before_its_upload_is_skipped_not_failed() {
        let root = std::env::temp_dir().join(format!("pdfs-b108-{}", std::process::id()));
        std::fs::create_dir_all(&root).unwrap();
        let gone = root.join("gone.txt");
        assert!(open_to_upload(&gone, "gone.txt").unwrap().is_none());
        std::fs::write(&gone, b"x").unwrap();
        assert!(open_to_upload(&gone, "gone.txt").unwrap().is_some());
        // Other open failures still count as errors.
        let err = open_to_upload(&gone.join("child"), "gone.txt/child");
        assert!(err.unwrap_err().starts_with("open gone.txt/child:"));
        let _ = std::fs::remove_dir_all(&root);
        let mut o = Outcome::default();
        o.record(&Applied::Vanished);
        assert!(o.is_empty());
        assert_eq!(o.errors, 0);
    }
    #[test]
    fn outcome_summarises_only_what_it_moved() {
        let mut o = Outcome::default();
@@ -2346,6 +2474,94 @@ mod tests {
        );
    }
    /// A baseline row recording `path` as it is on disk right now.
    fn synced_row(root: &Path, rel: &str) -> (String, StoredSyncEntry) {
        let meta = std::fs::symlink_metadata(root.join(rel_to_path(rel))).unwrap();
        let sig = LocalSig::from(&meta);
        let entry = StoredSyncEntry {
            rel_path: rel.to_string(),
            remote_uid: Some(format!("vol~{rel}")),
            local_mtime: sig.mtime,
            local_mtime_ns: sig.mtime_ns,
            local_size: sig.size,
            remote_rev: None,
            remote_hash: None,
        };
        (rel.to_string(), entry)
    }
    fn synced_subtree(name: &str) -> (PathBuf, HashMap<String, StoredSyncEntry>) {
        let root = sync_test_dir(name);
        std::fs::create_dir_all(root.join("dir/sub")).unwrap();
        std::fs::write(root.join("dir/a.txt"), b"a").unwrap();
        std::fs::write(root.join("dir/sub/b.txt"), b"b").unwrap();
        let baseline = ["dir", "dir/sub", "dir/a.txt", "dir/sub/b.txt"]
            .into_iter()
            .map(|rel| synced_row(&root, rel))
            .collect();
        (root, baseline)
    }
    #[test]
    fn a_fully_synced_mirror_subtree_may_leave() {
        let (root, baseline) = synced_subtree("move-synced");
        let reason = mirror_subtree_unsynced(&root, "dir", &baseline);
        std::fs::remove_dir_all(&root).unwrap();
        assert_eq!(reason, None);
    }
    #[test]
    fn a_mirror_subtree_with_a_file_not_uploaded_may_not_leave() {
        let (root, baseline) = synced_subtree("move-new-file");
        std::fs::write(root.join("dir/sub/new.txt"), b"n").unwrap();
        let reason = mirror_subtree_unsynced(&root, "dir", &baseline);
        std::fs::remove_dir_all(&root).unwrap();
        assert!(reason.unwrap().contains("dir/sub/new.txt"));
    }
    #[test]
    fn a_mirror_subtree_with_an_edit_not_uploaded_may_not_leave() {
        let (root, baseline) = synced_subtree("move-edit");
        std::fs::write(root.join("dir/a.txt"), b"longer now").unwrap();
        let reason = mirror_subtree_unsynced(&root, "dir", &baseline);
        std::fs::remove_dir_all(&root).unwrap();
        assert!(reason.unwrap().contains("dir/a.txt"));
    }
    #[test]
    fn a_mirror_subtree_with_a_deletion_not_carried_up_may_not_leave() {
        let (root, baseline) = synced_subtree("move-deleted");
        std::fs::remove_file(root.join("dir/sub/b.txt")).unwrap();
        let reason = mirror_subtree_unsynced(&root, "dir", &baseline);
        std::fs::remove_dir_all(&root).unwrap();
        assert!(reason.unwrap().contains("dir/sub/b.txt"));
    }
    #[test]
    fn a_mirror_subtree_holding_a_symlink_may_not_leave() {
        let (root, baseline) = synced_subtree("move-symlink");
        std::os::unix::fs::symlink("a.txt", root.join("dir/link")).unwrap();
        let reason = mirror_subtree_unsynced(&root, "dir", &baseline);
        std::fs::remove_dir_all(&root).unwrap();
        assert!(reason.unwrap().contains("dir/link"));
    }
    #[test]
    fn a_name_prefixed_sibling_does_not_hold_a_mirror_subtree_back() {
        let (root, mut baseline) = synced_subtree("move-sibling");
        // Deleted here but not on Drive, yet outside the subtree being moved.
        baseline.insert(
            "dirt".to_string(),
            StoredSyncEntry {
                rel_path: "dirt".to_string(),
                ..baseline["dir/a.txt"].clone()
            },
        );
        let reason = mirror_subtree_unsynced(&root, "dir", &baseline);
        std::fs::remove_dir_all(&root).unwrap();
        assert_eq!(reason, None);
    }
    /// The same rule one level up: if the sync root itself cannot be read, the
    /// pass sees nothing, and "nothing" must never mean "delete everything".
    #[test]
@@ -108,6 +108,7 @@ impl Outcome {
            Applied::Uploaded => self.uploaded += 1,
            Applied::Downloaded => self.downloaded += 1,
            Applied::Conflict => self.conflicts += 1,
            Applied::Vanished => {}
        }
    }
@@ -27,5 +27,6 @@ fn main() {
    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=resources/prompt.css");
    println!("cargo:rerun-if-changed=../../packaging/io.narl.proton-drive-linux.svg");
 }
@@ -33,5 +33,7 @@
  <gresource prefix="/de/nils/protondrivelinux">
    <file>style.css</file>
    <file>proton-theme.css</file>
    <!-- The search launcher's own sheet, over the same palette. -->
    <file>prompt.css</file>
  </gresource>
 </gresources>
@@ -0,0 +1,224 @@
 /* The search launcher (pdfs-prompt). Colours come from the libadwaita
   palette, so the launcher follows the system accent, light/dark and high
   contrast like the app; the opt-in Proton theme recolours both alike. */
 window.launcher-window {
  background: transparent;
 }
 .launcher-card {
  background-color: var(--view-bg-color);
  color: var(--view-fg-color);
  border: 1px solid var(--border-color);
  border-radius: 14px;
  box-shadow: 0 16px 48px rgb(0 0 0 / 35%);
 }
 .search-bar {
  padding: 14px 18px;
  border-bottom: 1px solid var(--border-color);
 }
 .search-icon {
  -gtk-icon-size: 20px;
  color: color-mix(in srgb, currentColor 55%, transparent);
 }
 .search-entry {
  background: none;
  border: none;
  box-shadow: none;
  outline: none;
  padding: 2px 0;
  font-size: 1.15rem;
 }
 .key-hint {
  padding: 2px 8px;
  border-radius: 6px;
  background-color: color-mix(in srgb, currentColor 8%, transparent);
  font-size: 0.75rem;
  opacity: 0.55;
 }
 .chip-row {
  padding: 10px 14px;
  border-bottom: 1px solid var(--border-color);
 }
 .chip {
  padding: 4px 14px;
  min-height: 0;
  border-radius: 999px;
  background: none;
  border: 1px solid var(--border-color);
  box-shadow: none;
  font-size: 0.86rem;
  font-weight: 500;
 }
 .chip:hover {
  background-color: color-mix(in srgb, currentColor 6%, transparent);
 }
 .chip:checked {
  background-color: var(--accent-bg-color);
  color: var(--accent-fg-color);
  border-color: var(--accent-bg-color);
 }
 /* --- results ------------------------------------------------------------ */
 .results {
  padding: 2px 8px 10px 8px;
 }
 .section-header {
  padding: 12px 10px 6px 10px;
 }
 .section-title {
  font-size: 0.78rem;
  font-weight: 700;
  letter-spacing: 0.06em;
  text-transform: uppercase;
  opacity: 0.55;
 }
 .section-icon {
  -gtk-icon-size: 14px;
  opacity: 0.55;
 }
 .result-list {
  background: none;
 }
 .result-row {
  padding: 6px 10px;
  border-radius: 10px;
 }
 .result-row:hover {
  background-color: color-mix(in srgb, currentColor 5%, transparent);
 }
 /* A soft tint rather than a solid accent bar: the text keeps its colour, so
   the highlighted match stays readable on the selected row. */
 .result-row:selected,
 .result-row:selected:hover {
  background-color: color-mix(in srgb, var(--accent-bg-color) 18%, transparent);
  color: inherit;
 }
 .result-name {
  font-weight: 500;
 }
 .result-location,
 .result-meta {
  font-size: 0.8rem;
  opacity: 0.55;
 }
 .result-row:selected .result-location,
 .result-row:selected .result-meta {
  opacity: 0.7;
 }
 .thumb {
  border-radius: 6px;
 }
 .result-badge,
 .preview-badge {
  -gtk-icon-size: 14px;
 }
 .badge-pinned {
  color: var(--success-color);
 }
 .badge-cached {
  color: var(--accent-color);
 }
 .badge-cloud,
 .badge-local {
  opacity: 0.55;
 }
 /* --- preview ------------------------------------------------------------ */
 .preview {
  padding: 16px;
  background-color: color-mix(in srgb, currentColor 3%, transparent);
 }
 .preview-thumb {
  margin-bottom: 12px;
 }
 .preview-thumb .thumb {
  border-radius: 10px;
 }
 .preview-name {
  font-weight: 700;
  font-size: 1.05rem;
 }
 .preview-kind {
  font-size: 0.85rem;
  opacity: 0.6;
  margin-bottom: 12px;
 }
 .preview-key {
  font-size: 0.8rem;
  opacity: 0.55;
 }
 .preview-value {
  font-size: 0.85rem;
 }
 .preview-actions {
  margin-top: 12px;
 }
 .preview-action {
  padding: 6px 8px;
  border-radius: 8px;
 }
 .preview-shortcut {
  font-size: 0.75rem;
  opacity: 0.6;
 }
 .preview-feedback {
  margin-top: 6px;
  font-size: 0.8rem;
  color: var(--accent-color);
 }
 .preview-empty {
  opacity: 0.2;
 }
 /* --- footer ------------------------------------------------------------- */
 .footer {
  padding: 8px 16px;
  border-top: 1px solid var(--border-color);
 }
 .footer-text {
  font-size: 0.78rem;
  opacity: 0.5;
 }
 statuspage.compact > scrolledwindow > viewport > box {
  margin: 24px 12px;
 }
@@ -8,6 +8,8 @@ pub(crate) mod events;
 pub(crate) mod i18n;
 pub(crate) mod pages;
 pub(crate) mod reload;
 #[path = "../theme.rs"]
 pub(crate) mod theme;
 pub(crate) mod widgets;
 use compat::*;
@@ -30,6 +32,7 @@ use pages::takeout::*;
 use pages::trash::*;
 use pages::verify::*;
 use reload::{LoadTicket, Loader, replace_items};
 use theme::{load_resources, proton_theme_active, set_proton_theme};
 use widgets::compat::*;
 use widgets::details::*;
 use widgets::file_list::*;
@@ -210,7 +213,7 @@ fn main() -> glib::ExitCode {
        .flags(gio::ApplicationFlags::HANDLES_COMMAND_LINE)
        .build();
    app.connect_startup(|_| {
-        load_proton_theme();
+        load_resources("/de/nils/protondrivelinux/style.css");
        if let Ok(dirs) = AppDirs::new() {
            set_proton_theme(dirs.load_config().proton_theme.unwrap_or(false));
        }
@@ -287,157 +290,6 @@ pub(crate) fn spawn_tray() {
    }
 }
 /// Register the bundled GResources (custom icons, the stylesheet) and load the
 /// app stylesheet. The Proton theme is a separate provider, applied by
 /// [`set_proton_theme`] from the saved preference.
 fn load_proton_theme() {
    let bytes = include_bytes!(concat!(env!("OUT_DIR"), "/pdfs.gresource"));
    let resource_data = glib::Bytes::from_static(bytes);
    if let Ok(resource) = gio::Resource::from_data(&resource_data) {
        gio::resources_register(&resource);
    } else {
        tracing::error!("failed to load gresource bundle");
    }
    let Some(display) = gtk4::gdk::Display::default() else {
        return;
    };
    let provider = gtk4::CssProvider::new();
    provider.load_from_resource("/de/nils/protondrivelinux/style.css");
    // Above the user's own gtk.css, which often imports a whole theme: its
    // `button { padding: 6px 10px; min-width: 16px }` would otherwise pad every
    // photo tile and push the grid past the window. Every rule in the sheet is
    // scoped to the app's own classes, so nothing else the user styled changes.
    // One above the Proton theme too, so the app's rules refine it.
    gtk4::style_context_add_provider_for_display(
        &display,
        &provider,
        gtk4::STYLE_PROVIDER_PRIORITY_USER + 2,
    );
    gtk4::IconTheme::for_display(&display).add_resource_path("/de/nils/protondrivelinux/icons");
 }
 thread_local! {
    /// The Proton theme provider while it is installed. Kept so turning the
    /// preference off can remove exactly what turning it on added.
    static PROTON_THEME: RefCell<Option<gtk4::CssProvider>> = const { RefCell::new(None) };
 }
 /// Whether the Proton theme is on.
 fn proton_theme_active() -> bool {
    PROTON_THEME.with(|slot| slot.borrow().is_some())
 }
 /// libadwaita's own stylesheet, bundled in the library.
 const ADWAITA_STYLESHEET: &str = "/org/gnome/Adwaita/styles/gtk.css";
 /// The Proton palette laid over it, from our own bundle.
 const PROTON_PALETTE: &str = "/de/nils/protondrivelinux/proton-theme.css";
 /// Make the theme provider's `@media (prefers-color-scheme)` and
 /// `(prefers-contrast)` rules match what libadwaita shows, now and whenever it
 /// changes. A provider evaluates those itself, and a new one assumes light.
 ///
 /// The properties are set by name because they only exist since GTK 4.20, and
 /// the app still runs on older GTK, whose libadwaita has no such rules anyway.
 fn follow_style_manager(provider: &gtk4::CssProvider) {
    fn set_enum(provider: &gtk4::CssProvider, property: &str, nick: &str) {
        let Some(pspec) = provider.find_property(property) else {
            return;
        };
        if let Some(value) = glib::EnumClass::with_type(pspec.value_type())
            .and_then(|class| class.to_value_by_nick(nick))
        {
            provider.set_property_from_value(property, &value);
        }
    }
    fn apply(provider: &gtk4::CssProvider, manager: &adw::StyleManager) {
        let scheme = if manager.is_dark() { "dark" } else { "light" };
        set_enum(provider, "prefers-color-scheme", scheme);
        let contrast = if manager.is_high_contrast() {
            "more"
        } else {
            "no-preference"
        };
        set_enum(provider, "prefers-contrast", contrast);
    }
    let manager = adw::StyleManager::default();
    apply(provider, &manager);
    // Weak, so a provider the preference removed isn't kept alive; its
    // handlers then do nothing.
    let weak = provider.downgrade();
    let weak_dark = weak.clone();
    manager.connect_dark_notify(move |manager| {
        if let Some(provider) = weak_dark.upgrade() {
            apply(&provider, manager);
        }
    });
    manager.connect_high_contrast_notify(move |manager| {
        if let Some(provider) = weak.upgrade() {
            apply(&provider, manager);
        }
    });
 }
 /// Paint the app in the Proton web apps' colours (`on`) or follow the system
 /// theme and accent colour.
 ///
 /// Setting libadwaita's colour variables alone isn't enough: a GTK theme the
 /// user's `gtk.css` imports (Catppuccin, Fluent, ...) sits above the app and
 /// hard-codes its own accent into hundreds of rules. So the theme provider,
 /// one above the user's CSS, first resets every property, then re-applies
 /// libadwaita's whole stylesheet and finally the Proton palette, which leaves
 /// nothing of the user's theme inside the app.
 fn set_proton_theme(on: bool) {
    let Some(display) = gtk4::gdk::Display::default() else {
        return;
    };
    PROTON_THEME.with(|slot| {
        let mut slot = slot.borrow_mut();
        match (on, slot.as_ref()) {
            (true, None) => {
                let stylesheet = |path| {
                    gio::resources_lookup_data(path, gio::ResourceLookupFlags::NONE)
                        .map(|bytes| String::from_utf8_lossy(&bytes).into_owned())
                };
                let palette = stylesheet(PROTON_PALETTE).unwrap_or_default();
                let css = match stylesheet(ADWAITA_STYLESHEET) {
                    // Its images are named relative to the sheet, which a
                    // string loaded here doesn't have.
                    Ok(adwaita) => format!(
                        "* {{ all: unset; }}\n{}\n{palette}",
                        adwaita.replace(
                            "url(\"assets/",
                            "url(\"resource:///org/gnome/Adwaita/styles/assets/"
                        )
                    ),
                    // Still recolours everything that follows libadwaita's
                    // variables; only a custom theme's own rules show through.
                    Err(e) => {
                        tracing::warn!("libadwaita stylesheet not found, only recolouring: {e}");
                        palette
                    }
                };
                let provider = gtk4::CssProvider::new();
                follow_style_manager(&provider);
                provider.load_from_string(&css);
                gtk4::style_context_add_provider_for_display(
                    &display,
                    &provider,
                    gtk4::STYLE_PROVIDER_PRIORITY_USER + 1,
                );
                *slot = Some(provider);
            }
            (false, Some(provider)) => {
                gtk4::style_context_remove_provider_for_display(&display, provider);
                *slot = None;
            }
            _ => {}
        }
    });
 }
 /// Build the application window, wire the two pages, kick off the refresh loop,
 /// and present it.
 fn build_window(app: &adw::Application) {
@@ -816,6 +668,15 @@ fn build_window(app: &adw::Application) {
        sync_sidebar(&ui_nav);
        match st.visible_child_name().as_deref() {
            Some("browser") => load_browser(&ui_nav),
            // The Albums and Places listings are re-read in place. Loading the
            // timeline instead would swap it in under the Albums or Places toggle.
            Some("gallery") if !ui_nav.gallery.in_collection() => {
                match ui_nav.gallery.view_switch.active() {
                    VIEW_ALBUMS => load_albums(&ui_nav),
                    VIEW_PLACES => load_places(&ui_nav),
                    _ => load_gallery(&ui_nav, false),
                }
            }
            Some("gallery") => load_gallery(&ui_nav, false),
            // Every visit reads the page again. The rows already on screen stay
            // up while it does, so arriving costs no "Loading…" flash.
@@ -1347,7 +1208,7 @@ fn install_window_actions(ui: &Rc<Ui>, window: &adw::ApplicationWindow) {
            .application_icon("io.narl.proton-drive-linux")
            .version(pdfs_core::config::APP_VERSION)
            .developer_name("Nils Pukropp")
-            .website("https://github.com/narrrl/proton-drive-linux")
+            .website("https://proton-drive.narl.io")
            .issue_url("https://github.com/narrrl/proton-drive-linux/issues")
            .copyright("© 2026 Nils Pukropp (contact@narl.io)")
            .license_type(gtk4::License::MitX11)
@@ -1920,6 +1920,10 @@ pub(crate) fn prompt_rename(ui: &Rc<Ui>, entry: &DirEntry) {
 /// Pick a destination folder by browsing Drive's folders, and move `entries`
 /// there through the daemon.
 ///
 /// Besides My files the picker offers every synced folder. A move into one is
 /// still made on Proton Drive, so nothing is downloaded or uploaded again; it
 /// is sent with absolute paths, which is how the daemon tells locations apart.
 pub(crate) fn prompt_move(ui: &Rc<Ui>, entries: Vec<DirEntry>) {
    if entries.is_empty() {
        return;
@@ -1967,6 +1971,7 @@ pub(crate) fn prompt_move(ui: &Rc<Ui>, entries: Vec<DirEntry>) {
    dialog.set_default_response(Some("move"));
    dialog.set_close_response("cancel");
    let mountpoint = ui.dirs.resolved_mountpoint(&ui.dirs.load_config());
    let picker = Rc::new(MovePicker {
        ui: ui.clone(),
        dialog: dialog.clone(),
@@ -1974,28 +1979,93 @@ pub(crate) fn prompt_move(ui: &Rc<Ui>, entries: Vec<DirEntry>) {
        list,
        up: up.clone(),
        sources: sources.clone(),
-        folder: RefCell::new(String::new()),
+        folder: RefCell::new(MoveTarget::Locations),
        generation: Cell::new(0),
    });
    let picker_up = picker.clone();
    up.connect_clicked(move |_| {
-        let folder = picker_up.folder.borrow().clone();
+        let parent = picker_up.folder.borrow().parent();
-        let parent = folder.rfind('/').map(|i| &folder[..i]).unwrap_or_default();
+        picker_up.open(parent);
        picker_up.open(parent.to_string());
    });
    // Start where the browser is: moving is most often one level up or down.
-    picker.open(ui.browser.path.borrow().clone());
+    picker.open(MoveTarget::Drive(ui.browser.path.borrow().clone()));
    let ui = ui.clone();
    let picker_done = picker.clone();
    dialog.connect_response(None, move |_, resp| {
-        if resp == "move" {
+        if resp != "move" {
-            run_bulk_move(&ui, sources.clone(), picker_done.folder.borrow().clone());
+            return;
        }
        match picker_done.folder.borrow().clone() {
            MoveTarget::Locations => {}
            MoveTarget::Drive(folder) => run_bulk_move(&ui, sources.clone(), folder),
            MoveTarget::Synced { path, .. } => {
                let absolute = sources
                    .iter()
                    .map(|rel| mountpoint.join(rel).to_string_lossy().into_owned())
                    .collect();
                run_bulk_move(&ui, absolute, path);
            }
        }
    });
    dialog.present(ui_window(&picker.ui).as_ref());
 }
 /// Where the Move dialog is looking, and the destination if the user confirms.
 #[derive(Clone, Debug, PartialEq)]
 pub(crate) enum MoveTarget {
    /// The list of places to move to: My files and each synced folder.
    Locations,
    /// A folder in My files, mountpoint-relative; empty for My files itself.
    Drive(String),
    /// A folder inside a synced folder, as an absolute local path. `root` is
    /// the synced folder. A mirror folder is a plain directory, read from disk.
    Synced {
        root: String,
        path: String,
        mirror: bool,
    },
 }
 impl MoveTarget {
    /// One level up. The top of a location leads back to the list of them.
    pub(crate) fn parent(&self) -> MoveTarget {
        match self {
            MoveTarget::Locations => MoveTarget::Locations,
            MoveTarget::Drive(folder) if folder.is_empty() => MoveTarget::Locations,
            MoveTarget::Drive(folder) => MoveTarget::Drive(
                folder
                    .rfind('/')
                    .map(|i| folder[..i].to_string())
                    .unwrap_or_default(),
            ),
            MoveTarget::Synced { root, path, .. } if path == root => MoveTarget::Locations,
            MoveTarget::Synced { root, path, mirror } => MoveTarget::Synced {
                root: root.clone(),
                path: Path::new(path)
                    .parent()
                    .map(|p| p.to_string_lossy().into_owned())
                    .unwrap_or_else(|| root.clone()),
                mirror: *mirror,
            },
        }
    }
    /// `name` inside this folder, in the same form.
    fn child(&self, name: &str) -> MoveTarget {
        match self {
            MoveTarget::Locations => MoveTarget::Locations,
            MoveTarget::Drive(folder) if folder.is_empty() => MoveTarget::Drive(name.to_string()),
            MoveTarget::Drive(folder) => MoveTarget::Drive(format!("{folder}/{name}")),
            MoveTarget::Synced { root, path, mirror } => MoveTarget::Synced {
                root: root.clone(),
                path: Path::new(path).join(name).to_string_lossy().into_owned(),
                mirror: *mirror,
            },
        }
    }
 }
 /// The Move dialog's folder browser.
 struct MovePicker {
    ui: Rc<Ui>,
@@ -2006,71 +2076,81 @@ struct MovePicker {
    /// What is being moved, mountpoint-relative.
    sources: Vec<String>,
    /// The folder on show, and the destination if the user confirms now.
-    folder: RefCell<String>,
+    folder: RefCell<MoveTarget>,
    /// Drops a listing that arrives after the user went elsewhere.
    generation: Cell<u64>,
 }
 impl MovePicker {
-    fn open(self: &Rc<Self>, folder: String) {
+    fn open(self: &Rc<Self>, folder: MoveTarget) {
        let generation = self.generation.get().wrapping_add(1);
        self.generation.set(generation);
-        self.location.set_label(if folder.is_empty() {
+        let (label, tooltip) = match &folder {
-            "Proton Drive"
+            MoveTarget::Locations => (gettext("Locations"), String::new()),
-        } else {
+            MoveTarget::Drive(rel) if rel.is_empty() => (gettext("My files"), String::new()),
-            &folder
+            MoveTarget::Drive(rel) => (rel.clone(), rel.clone()),
-        });
+            MoveTarget::Synced { path, .. } => (path.clone(), path.clone()),
-        self.location.set_tooltip_text(Some(&folder));
+        };
-        self.up.set_sensitive(!folder.is_empty());
+        self.location.set_label(&label);
-        self.dialog
+        self.location.set_tooltip_text(Some(&tooltip));
-            .set_response_enabled("move", move_target_allowed(&self.sources, &folder));
+        self.up
            .set_sensitive(!matches!(folder, MoveTarget::Locations));
        let allowed = match &folder {
            MoveTarget::Locations => false,
            MoveTarget::Drive(rel) => move_target_allowed(&self.sources, rel),
            // What is moved is in My files, so it cannot be in a synced folder.
            MoveTarget::Synced { .. } => true,
        };
        self.dialog.set_response_enabled("move", allowed);
        *self.folder.borrow_mut() = folder.clone();
        while let Some(row) = self.list.first_child() {
            self.list.remove(&row);
        }
        self.list.append(&picker_note(&gettext("Loading…")));
-        let rx = spawn_request(
+
            self.ui.dirs.control_socket(),
            Request::ListDir {
                path: folder.clone(),
            },
        );
        let picker = self.clone();
        glib::spawn_future_local(async move {
-            let result = rx.recv().await;
+            let listed = match &folder {
                MoveTarget::Locations => picker.locations().await,
                MoveTarget::Drive(rel) => picker.drive_folders(&folder, rel.clone()).await,
                MoveTarget::Synced {
                    path, mirror: true, ..
                } => local_folders(&folder, path.clone()).await,
                MoveTarget::Synced { path, .. } => {
                    picker.drive_folders(&folder, path.clone()).await
                }
            };
            if picker.generation.get() != generation {
                return;
            }
            while let Some(row) = picker.list.first_child() {
                picker.list.remove(&row);
            }
-            let Ok(Ok(Response::Entries { entries })) = result else {
+            let Some(rows) = listed else {
                picker
                    .list
                    .append(&picker_note(&gettext("Couldn't read this folder.")));
                return;
            };
            let mut folders: Vec<DirEntry> = entries.into_iter().filter(|e| e.is_dir).collect();
            folders.sort_by_key(|e| e.name.to_lowercase());
            let mut shown = 0;
-            for entry in folders {
+            for (title, subtitle, target) in rows {
                let path = if folder.is_empty() {
                    entry.name.clone()
                } else {
                    format!("{folder}/{}", entry.name)
                };
                // A folder cannot go inside itself, so do not offer to open it.
-                if picker.sources.contains(&path) {
+                if let MoveTarget::Drive(path) = &target
                    && picker.sources.contains(path)
                {
                    continue;
                }
                let row = adw::ActionRow::builder()
-                    .title(glib::markup_escape_text(&entry.name).as_str())
+                    .title(glib::markup_escape_text(&title).as_str())
                    .activatable(true)
                    .build();
                if let Some(subtitle) = subtitle {
                    row.set_subtitle(glib::markup_escape_text(&subtitle).as_str());
                }
                row.add_prefix(&gtk4::Image::from_icon_name("folder-symbolic"));
                row.add_suffix(&gtk4::Image::from_icon_name("go-next-symbolic"));
                let open = picker.clone();
-                row.connect_activated(move |_| open.open(path.clone()));
+                row.connect_activated(move |_| open.open(target.clone()));
                picker.list.append(&row);
                shown += 1;
            }
@@ -2081,6 +2161,92 @@ impl MovePicker {
            }
        });
    }
    /// My files and every synced folder, as rows of the top level.
    async fn locations(&self) -> Option<Vec<PickerRow>> {
        let mut rows = vec![(gettext("My files"), None, MoveTarget::Drive(String::new()))];
        let rx = spawn_request(self.ui.dirs.control_socket(), Request::ListSyncFolders);
        let Ok(Ok(Response::SyncFolders { mut items })) = rx.recv().await else {
            // My files alone is still somewhere to move to.
            return Some(rows);
        };
        items.sort_by_key(|f| f.local_path.to_lowercase());
        for folder in items {
            let name = Path::new(&folder.local_path)
                .file_name()
                .map(|n| n.to_string_lossy().into_owned())
                .unwrap_or_else(|| folder.local_path.clone());
            rows.push((
                name,
                Some(folder.local_path.clone()),
                MoveTarget::Synced {
                    root: folder.local_path.clone(),
                    path: folder.local_path,
                    mirror: folder.mode == "mirror",
                },
            ));
        }
        Some(rows)
    }
    /// The folders in a mounted folder: `folder` is mountpoint-relative for My
    /// files and absolute for an on-demand synced folder.
    async fn drive_folders(&self, here: &MoveTarget, folder: String) -> Option<Vec<PickerRow>> {
        let rx = spawn_request(
            self.ui.dirs.control_socket(),
            Request::ListDir {
                path: folder.clone(),
            },
        );
        let Ok(Ok(Response::Entries { entries })) = rx.recv().await else {
            return None;
        };
        let mut names: Vec<String> = entries
            .into_iter()
            .filter(|e| e.is_dir)
            .map(|e| e.name)
            .collect();
        names.sort_by_key(|name| name.to_lowercase());
        Some(
            names
                .into_iter()
                .map(|name| {
                    let target = here.child(&name);
                    (name, None, target)
                })
                .collect(),
        )
    }
 }
 /// One row of the picker: its title, an optional subtitle, and where it leads.
 type PickerRow = (String, Option<String>, MoveTarget);
 /// The folders in a mirror folder's directory `path`, read from disk off the
 /// main thread. A mirror folder has no mount for `ListDir` to read.
 async fn local_folders(here: &MoveTarget, path: String) -> Option<Vec<PickerRow>> {
    let names = gio::spawn_blocking(move || {
        let mut names: Vec<String> = std::fs::read_dir(&path)
            .ok()?
            .flatten()
            .filter(|e| e.file_type().is_ok_and(|t| t.is_dir()))
            .filter_map(|e| e.file_name().into_string().ok())
            .filter(|name| !name.contains(".pdfs-tmp-"))
            .collect();
        names.sort_by_key(|name| name.to_lowercase());
        Some(names)
    })
    .await
    .ok()??;
    Some(
        names
            .into_iter()
            .map(|name| {
                let target = here.child(&name);
                (name, None, target)
            })
            .collect(),
    )
 }
 fn picker_note(text: &str) -> gtk4::ListBoxRow {
@@ -2786,8 +2952,8 @@ fn listing_summary(files: usize, folders: usize, file_bytes: u64) -> String {
 #[cfg(test)]
 mod tests {
    use super::{
-        hit_location, listing_summary, move_target_allowed, show_thumbnail_build_progress,
+        MoveTarget, hit_location, listing_summary, move_target_allowed,
-        sort_entries,
+        show_thumbnail_build_progress, sort_entries,
    };
    use pdfs_core::config::{FileSort, FilesView};
    use pdfs_core::control::{DirEntry, ThumbnailBuildStatus};
@@ -2880,4 +3046,43 @@ mod tests {
        status.running = false;
        assert!(!show_thumbnail_build_progress(&status));
    }
    #[test]
    fn move_picker_climbs_from_a_location_top_to_the_list_of_locations() {
        assert_eq!(
            MoveTarget::Drive(String::new()).parent(),
            MoveTarget::Locations
        );
        let root = MoveTarget::Synced {
            root: "/home/u/Docs".into(),
            path: "/home/u/Docs".into(),
            mirror: true,
        };
        assert_eq!(root.parent(), MoveTarget::Locations);
    }
    #[test]
    fn move_picker_climbs_one_folder_at_a_time_inside_a_location() {
        assert_eq!(
            MoveTarget::Drive("a/b".into()).parent(),
            MoveTarget::Drive("a".into())
        );
        assert_eq!(
            MoveTarget::Drive("a".into()).parent(),
            MoveTarget::Drive(String::new())
        );
        let inner = MoveTarget::Synced {
            root: "/home/u/Docs".into(),
            path: "/home/u/Docs/x/y".into(),
            mirror: false,
        };
        assert_eq!(
            inner.parent(),
            MoveTarget::Synced {
                root: "/home/u/Docs".into(),
                path: "/home/u/Docs/x".into(),
                mirror: false,
            }
        );
    }
 }
@@ -262,20 +262,22 @@ pub(crate) fn build_locations_page(history: &gtk4::Widget) -> (gtk4::Widget, Loc
    (frame.upcast(), widgets)
 }
-/// `child` in a clamp that scrolls vertically only, with page margins.
+/// `child` across the page's full width, scrolling vertically only, with page
 /// margins.
 fn scrolled_column(child: &impl IsA<gtk4::Widget>) -> gtk4::ScrolledWindow {
-    let clamp = adw::Clamp::builder().child(child).build();
+    let column = gtk4::Box::new(gtk4::Orientation::Vertical, 0);
-    clamp.set_margin_top(18);
+    column.append(child);
-    clamp.set_margin_bottom(18);
+    column.set_margin_top(18);
-    clamp.set_margin_start(18);
+    column.set_margin_bottom(18);
-    clamp.set_margin_end(18);
+    column.set_margin_start(18);
    column.set_margin_end(18);
    // Never scroll sideways: a location's subtitle holds a full path, and letting
    // the row grow to fit one pushes the controls at its end off screen.
    // Constrained, the path ellipsizes and the controls stay reachable.
    gtk4::ScrolledWindow::builder()
        .vexpand(true)
        .hscrollbar_policy(gtk4::PolicyType::Never)
-        .child(&clamp)
+        .child(&column)
        .build()
 }
@@ -1069,7 +1069,11 @@ pub(crate) fn repaint_transfers(ui: &Rc<Ui>, items: &[TransferItem], jobs: &[Job
            let row_box = gtk4::Box::new(gtk4::Orientation::Vertical, 4);
            row_box.set_margin_top(8);
            row_box.set_margin_bottom(8);
-            let label = gtk4::Label::builder().halign(gtk4::Align::Start).build();
+            // Ellipsized so a long file name cannot widen the page.
            let label = gtk4::Label::builder()
                .halign(gtk4::Align::Start)
                .ellipsize(gtk4::pango::EllipsizeMode::Middle)
                .build();
            label.add_css_class("dim-label");
            let bar = gtk4::ProgressBar::new();
            row_box.append(&label);
@@ -0,0 +1,143 @@
 //! Match highlighting: which characters of a result name the query matched,
 //! as Pango markup with those characters in bold.
 //!
 //! Each query term is looked for as a substring of the name first, and as a
 //! subsequence ("rpt" in "report") when that fails, which is roughly how the
 //! daemon's ranking treats a term too. Case is folded one character at a
 //! time, so every range stays on a character boundary of the original name,
 //! whatever the script.
 use gtk4::glib;
 /// One character of a name: its byte range and its case-folded form.
 struct Folded {
    start: usize,
    end: usize,
    folded: String,
 }
 fn fold(text: &str) -> Vec<Folded> {
    text.char_indices()
        .map(|(start, c)| Folded {
            start,
            end: start + c.len_utf8(),
            folded: c.to_lowercase().collect(),
        })
        .collect()
 }
 /// The byte ranges of `name` that `query` matched, sorted and merged.
 pub(crate) fn ranges(name: &str, query: &str) -> Vec<(usize, usize)> {
    let chars = fold(name);
    let mut found: Vec<(usize, usize)> = Vec::new();
    for term in query.split_whitespace() {
        let term: Vec<String> = fold(term).into_iter().map(|c| c.folded).collect();
        if let Some(at) = substring(&chars, &term) {
            found.push((chars[at].start, chars[at + term.len() - 1].end));
        } else if let Some(hits) = subsequence(&chars, &term) {
            found.extend(hits.into_iter().map(|at| (chars[at].start, chars[at].end)));
        }
    }
    found.sort_unstable();
    let mut merged: Vec<(usize, usize)> = Vec::with_capacity(found.len());
    for (start, end) in found {
        match merged.last_mut() {
            Some(last) if start <= last.1 => last.1 = last.1.max(end),
            _ => merged.push((start, end)),
        }
    }
    merged
 }
 /// Where `term` first occurs in `chars`, as a character index.
 fn substring(chars: &[Folded], term: &[String]) -> Option<usize> {
    if term.is_empty() || term.len() > chars.len() {
        return None;
    }
    (0..=chars.len() - term.len()).find(|&at| {
        chars[at..at + term.len()]
            .iter()
            .zip(term)
            .all(|(c, t)| c.folded == *t)
    })
 }
 /// The character indices of the leftmost match of `term` as a subsequence,
 /// or `None` when not every character of it can be found in order.
 fn subsequence(chars: &[Folded], term: &[String]) -> Option<Vec<usize>> {
    if term.is_empty() {
        return None;
    }
    let mut hits = Vec::with_capacity(term.len());
    let mut next = 0;
    for wanted in term {
        let at = (next..chars.len()).find(|&i| chars[i].folded == *wanted)?;
        hits.push(at);
        next = at + 1;
    }
    Some(hits)
 }
 /// `name` as Pango markup, escaped, with the matched characters in bold.
 pub(crate) fn markup(name: &str, query: &str) -> String {
    let mut out = String::with_capacity(name.len() + 16);
    let mut done = 0;
    for (start, end) in ranges(name, query) {
        out.push_str(&glib::markup_escape_text(&name[done..start]));
        out.push_str("<b>");
        out.push_str(&glib::markup_escape_text(&name[start..end]));
        out.push_str("</b>");
        done = end;
    }
    out.push_str(&glib::markup_escape_text(&name[done..]));
    out
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn a_substring_match_is_one_range_in_any_case() {
        assert_eq!(ranges("Tax Report.pdf", "REP"), vec![(4, 7)]);
    }
    #[test]
    fn a_term_that_is_no_substring_falls_back_to_a_subsequence() {
        // r, p and t of "report", not the "rt" pair at the end of a substring.
        assert_eq!(ranges("report.txt", "rpt"), vec![(0, 1), (2, 3), (5, 6)]);
    }
    #[test]
    fn a_term_with_no_match_highlights_nothing() {
        assert!(ranges("report.txt", "xyz").is_empty());
        assert!(ranges("report.txt", "").is_empty());
    }
    #[test]
    fn several_terms_merge_into_sorted_ranges() {
        assert_eq!(
            ranges("tax return 2024", "2024 tax ret"),
            vec![(0, 3), (4, 7), (11, 15)]
        );
        assert_eq!(ranges("abc", "ab bc"), vec![(0, 3)]);
    }
    #[test]
    fn non_ascii_names_keep_ranges_on_character_boundaries() {
        assert_eq!(ranges("Über Größe.odt", "über"), vec![(0, 5)]);
        assert_eq!(ranges("Über Größe.odt", "GRÖ"), vec![(6, 10)]);
        assert_eq!(markup("Über Größe.odt", "größe"), "Über <b>Größe</b>.odt");
        assert_eq!(
            markup("日本語のメモ.txt", "メモ"),
            "日本語の<b>メモ</b>.txt"
        );
    }
    #[test]
    fn markup_escapes_the_name_inside_and_outside_matches() {
        assert_eq!(markup("a<b>&c", "b"), "a&lt;<b>b</b>&gt;&amp;c");
        assert_eq!(markup("R&D.pdf", "r&d"), "<b>R&amp;D</b>.pdf");
        assert_eq!(markup("<none>", "zzz"), "&lt;none&gt;");
    }
 }
@@ -0,0 +1,363 @@
 //! Recent files and frecency.
 //!
 //! The launcher remembers what it opened in `prompt-history.json` under the
 //! state directory. With an empty query those files come first, and while
 //! searching a file opened often and lately gets a bonus on top of its match
 //! score (see [`frecency_bonus`]).
 //!
 //! One writer thread owns the file: it loads it, applies every recorded visit
 //! in order and writes the result back atomically. A visit recorded before the
 //! first load finished simply waits in the channel, so it is merged into the
 //! loaded list rather than overwriting it. The main thread only ever sees
 //! snapshots.
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use gtk4::glib;
 use crate::Hit;
 /// How many files the history keeps. More than the launcher ever shows, so
 /// frecency still knows a file that dropped off the recent list.
 const MAX_VISITS: usize = 50;
 /// The frecency bonus of one visit made just now.
 const VISIT_BONUS: f64 = 1500.0;
 /// The bonus halves every this many days without a visit.
 const HALF_LIFE_DAYS: f64 = 14.0;
 /// The largest frecency bonus. A name match is worth up to 20000 points, so
 /// history breaks ties between similar matches but cannot beat a much better
 /// one.
 const MAX_BONUS: f64 = 6000.0;
 #[derive(Clone, serde::Serialize, serde::Deserialize)]
 pub(crate) struct Visit {
    pub(crate) hit: Hit,
    /// When the file was last opened, in epoch seconds.
    pub(crate) last: i64,
    pub(crate) count: u32,
 }
 /// The history bonus for a file opened `count` times, the last time
 /// `age_secs` ago.
 pub(crate) fn frecency_bonus(count: u32, age_secs: i64) -> i64 {
    let age_days = age_secs.max(0) as f64 / 86_400.0;
    let bonus = f64::from(count) * VISIT_BONUS * 0.5f64.powf(age_days / HALF_LIFE_DAYS);
    bonus.min(MAX_BONUS) as i64
 }
 /// Count one more visit of `hit` at `now`, newest first, and keep at most
 /// [`MAX_VISITS`]. The stored hit is replaced, so its size, date and sync
 /// state are the ones from the latest search.
 fn record(visits: &mut Vec<Visit>, hit: Hit, now: i64) {
    let key = hit.key();
    let count = match visits.iter().position(|visit| visit.hit.key() == key) {
        Some(at) => visits.remove(at).count.saturating_add(1),
        None => 1,
    };
    visits.insert(
        0,
        Visit {
            hit,
            last: now,
            count,
        },
    );
    visits.truncate(MAX_VISITS);
 }
 /// Drop local files that no longer exist. Drive files stay: checking them
 /// would touch the mount, and a stale one only costs a row.
 fn prune(visits: &mut Vec<Visit>) -> bool {
    let before = visits.len();
    visits.retain(|visit| match &visit.hit {
        Hit::Local(hit) => Path::new(&hit.path).symlink_metadata().is_ok(),
        Hit::Drive(_) => true,
    });
    visits.len() != before
 }
 fn load(path: &Path) -> Vec<Visit> {
    match std::fs::read(path) {
        Ok(bytes) => serde_json::from_slice(&bytes).unwrap_or_else(|e| {
            tracing::warn!("ignoring unreadable {}: {e}", path.display());
            Vec::new()
        }),
        Err(_) => Vec::new(),
    }
 }
 /// Write the history through a temporary file and a rename, so a crash
 /// mid-write leaves the old file rather than half a new one.
 fn save(path: &Path, visits: &[Visit]) -> std::io::Result<()> {
    let json = serde_json::to_vec(visits).map_err(std::io::Error::other)?;
    if let Some(dir) = path.parent() {
        std::fs::create_dir_all(dir)?;
    }
    let tmp = path.with_extension("json.tmp");
    let mut file = std::fs::File::create(&tmp)?;
    file.write_all(&json)?;
    file.sync_all()?;
    std::fs::rename(&tmp, path)
 }
 enum Command {
    Record(Hit, i64),
    Prune,
 }
 /// The writer thread's loop: load, then apply commands until the launcher
 /// exits. `publish` receives the list after the load and after every change.
 fn serve(path: &Path, commands: &async_channel::Receiver<Command>, publish: impl Fn(Vec<Visit>)) {
    let mut visits = load(path);
    let pruned = prune(&mut visits);
    publish(visits.clone());
    if pruned && let Err(e) = save(path, &visits) {
        tracing::warn!("cannot write {}: {e}", path.display());
    }
    while let Ok(command) = commands.recv_blocking() {
        let changed = match command {
            Command::Record(hit, now) => {
                record(&mut visits, hit, now);
                true
            }
            Command::Prune => prune(&mut visits),
        };
        if changed {
            if let Err(e) = save(path, &visits) {
                tracing::warn!("cannot write {}: {e}", path.display());
            }
            publish(visits.clone());
        }
    }
 }
 /// The main thread's view of the history.
 pub(crate) struct History {
    visits: Rc<RefCell<Vec<Visit>>>,
    commands: async_channel::Sender<Command>,
 }
 impl History {
    /// Start the writer thread. `changed` runs on the main thread whenever a
    /// new snapshot arrives.
    pub(crate) fn start(path: PathBuf, changed: impl Fn() + 'static) -> Self {
        let (commands, inbox) = async_channel::unbounded();
        let (snapshots, updates) = async_channel::unbounded::<Vec<Visit>>();
        let spawned = std::thread::Builder::new()
            .name("prompt-history".into())
            .spawn(move || {
                serve(&path, &inbox, |visits| {
                    let _ = snapshots.send_blocking(visits);
                })
            });
        if let Err(e) = spawned {
            tracing::warn!("cannot start the history writer: {e}");
        }
        let visits = Rc::new(RefCell::new(Vec::new()));
        let shared = visits.clone();
        glib::spawn_future_local(async move {
            while let Ok(snapshot) = updates.recv().await {
                *shared.borrow_mut() = snapshot;
                changed();
            }
        });
        Self { visits, commands }
    }
    /// Remember that `hit` was opened just now.
    pub(crate) fn record(&self, hit: Hit) {
        let _ = self.commands.try_send(Command::Record(hit, now()));
    }
    /// Forget local files that were deleted since they were opened.
    pub(crate) fn prune(&self) {
        let _ = self.commands.try_send(Command::Prune);
    }
    /// The most recently opened files, newest first.
    pub(crate) fn recent(&self, limit: usize) -> Vec<Hit> {
        self.visits
            .borrow()
            .iter()
            .take(limit)
            .map(|visit| visit.hit.clone())
            .collect()
    }
    /// The frecency bonus of every remembered file, by [`Hit::key`].
    pub(crate) fn bonuses(&self) -> HashMap<(bool, String), i64> {
        let now = now();
        self.visits
            .borrow()
            .iter()
            .map(|visit| {
                (
                    visit.hit.key(),
                    frecency_bonus(visit.count, now - visit.last),
                )
            })
            .collect()
    }
 }
 fn now() -> i64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map_or(0, |d| d.as_secs() as i64)
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use pdfs_core::control::{LocalHit, SearchHit};
    const DAY: i64 = 86_400;
    fn drive(name: &str) -> Hit {
        Hit::Drive(SearchHit {
            name: name.into(),
            path: format!("Docs/{name}"),
            is_dir: false,
            size: 1,
            modified: 1,
            pinned: false,
            cached: false,
            uid: format!("v~{name}"),
            mounted_path: None,
            score: 0,
        })
    }
    fn scratch_dir(test: &str) -> PathBuf {
        let dir = std::env::temp_dir().join(format!(
            "pdfs-prompt-history-{test}-{}-{}",
            std::process::id(),
            now()
        ));
        std::fs::create_dir_all(&dir).unwrap();
        dir
    }
    #[test]
    fn the_bonus_halves_every_two_weeks() {
        assert_eq!(frecency_bonus(1, 0), 1500);
        assert_eq!(frecency_bonus(1, 14 * DAY), 750);
        assert_eq!(frecency_bonus(1, 28 * DAY), 375);
        assert_eq!(frecency_bonus(2, 14 * DAY), 1500);
        // A clock that went backwards counts as "just now", not as a boost.
        assert_eq!(frecency_bonus(1, -DAY), 1500);
    }
    #[test]
    fn the_bonus_is_capped() {
        assert_eq!(frecency_bonus(4, 0), 6000);
        assert_eq!(frecency_bonus(1000, 0), 6000);
        assert!(frecency_bonus(1000, 365 * DAY) < 6000);
    }
    #[test]
    fn a_repeat_visit_moves_the_file_to_the_top_and_counts_it() {
        let mut visits = Vec::new();
        record(&mut visits, drive("a.pdf"), 10);
        record(&mut visits, drive("b.pdf"), 20);
        record(&mut visits, drive("a.pdf"), 30);
        assert_eq!(visits.len(), 2);
        assert_eq!(visits[0].hit.name(), "a.pdf");
        assert_eq!((visits[0].count, visits[0].last), (2, 30));
        assert_eq!(visits[1].count, 1);
    }
    #[test]
    fn the_history_keeps_the_newest_fifty_files() {
        let mut visits = Vec::new();
        for n in 0..60 {
            record(&mut visits, drive(&format!("{n}.pdf")), n);
        }
        assert_eq!(visits.len(), MAX_VISITS);
        assert_eq!(visits[0].hit.name(), "59.pdf");
        assert_eq!(visits[MAX_VISITS - 1].hit.name(), "10.pdf");
    }
    #[test]
    fn the_history_file_round_trips() {
        let dir = scratch_dir("round-trip");
        let path = dir.join("prompt-history.json");
        let mut visits = Vec::new();
        record(&mut visits, drive("a.pdf"), 10);
        record(&mut visits, drive("a.pdf"), 20);
        save(&path, &visits).unwrap();
        let loaded = load(&path);
        assert_eq!(loaded.len(), 1);
        assert_eq!(loaded[0].hit.key(), drive("a.pdf").key());
        assert_eq!((loaded[0].count, loaded[0].last), (2, 20));
        assert!(!path.with_extension("json.tmp").exists());
        std::fs::remove_dir_all(dir).unwrap();
    }
    #[test]
    fn visits_recorded_before_the_load_are_merged_into_it() {
        let dir = scratch_dir("merge");
        let path = dir.join("prompt-history.json");
        let mut stored = Vec::new();
        record(&mut stored, drive("old.pdf"), 10);
        record(&mut stored, drive("old.pdf"), 20);
        save(&path, &stored).unwrap();
        // Both visits are queued before the writer has read the file.
        let (commands, inbox) = async_channel::unbounded();
        commands
            .send_blocking(Command::Record(drive("old.pdf"), 30))
            .unwrap();
        commands
            .send_blocking(Command::Record(drive("new.pdf"), 40))
            .unwrap();
        drop(commands);
        let published = RefCell::new(Vec::new());
        serve(&path, &inbox, |visits| published.borrow_mut().push(visits));
        let last = published.borrow().last().cloned().unwrap();
        assert_eq!(last.len(), 2);
        assert_eq!(last[0].hit.name(), "new.pdf");
        assert_eq!((last[1].hit.name(), last[1].count), ("old.pdf", 3));
        let on_disk = load(&path);
        assert_eq!(on_disk.len(), 2);
        assert_eq!(on_disk[1].count, 3);
        std::fs::remove_dir_all(dir).unwrap();
    }
    #[test]
    fn pruning_drops_deleted_local_files_only() {
        let dir = scratch_dir("prune");
        let kept = dir.join("kept.txt");
        std::fs::write(&kept, "x").unwrap();
        let local = |path: &Path| {
            Hit::Local(LocalHit {
                name: path.file_name().unwrap().to_string_lossy().into_owned(),
                path: path.display().to_string(),
                is_dir: false,
                size: 1,
                modified: 1,
                score: 0,
            })
        };
        let mut visits = Vec::new();
        record(&mut visits, local(&kept), 1);
        record(&mut visits, local(&dir.join("gone.txt")), 2);
        record(&mut visits, drive("remote.pdf"), 3);
        assert!(prune(&mut visits));
        let names: Vec<&str> = visits.iter().map(|visit| visit.hit.name()).collect();
        assert_eq!(names, ["remote.pdf", "kept.txt"]);
        std::fs::remove_dir_all(dir).unwrap();
    }
 }
@@ -0,0 +1,323 @@
 //! The preview pane beside the results: a thumbnail of the selected hit, what
 //! it is, where it is and whether it is on this computer, and the actions for
 //! it with their shortcuts.
 use std::cell::RefCell;
 use std::path::Path;
 use std::rc::Rc;
 use std::time::Duration;
 use adw::prelude::*;
 use gtk4::{gio, glib};
 use super::row::{fill_slot, thumb_slot};
 use super::thumbs::Thumbs;
 use crate::{Hit, dates, gettext, human_bytes, pgettext};
 /// Width of the pane.
 pub(crate) const PREVIEW_WIDTH: i32 = 300;
 /// The thumbnail area, inside the pane's padding.
 const THUMB_WIDTH: i32 = 268;
 const THUMB_HEIGHT: i32 = 180;
 /// How long "Path copied" stays up.
 const COPIED_FEEDBACK: Duration = Duration::from_millis(1500);
 /// One label/value line of the details grid.
 struct Detail {
    title: gtk4::Label,
    value: gtk4::Label,
 }
 impl Detail {
    fn new(grid: &gtk4::Grid, row: i32, title: &str) -> Self {
        let title = gtk4::Label::builder()
            .label(title)
            .xalign(0.0)
            .valign(gtk4::Align::Start)
            .build();
        title.add_css_class("preview-key");
        // A wrapping label asks for its whole text on one line as its natural
        // width, which would widen the pane and squeeze the results. Capping it
        // keeps the pane at its fixed width; long values wrap, then ellipsize.
        let value = gtk4::Label::builder()
            .xalign(0.0)
            .hexpand(true)
            .wrap(true)
            .wrap_mode(gtk4::pango::WrapMode::WordChar)
            .max_width_chars(1)
            .lines(3)
            .ellipsize(gtk4::pango::EllipsizeMode::Middle)
            .build();
        value.add_css_class("preview-value");
        grid.attach(&title, 0, row, 1, 1);
        grid.attach(&value, 1, row, 1, 1);
        Self { title, value }
    }
    /// Show `value`, or hide the line when there is nothing to say.
    fn set(&self, value: Option<&str>) {
        self.title.set_visible(value.is_some());
        self.value.set_visible(value.is_some());
        self.value.set_label(value.unwrap_or_default());
    }
 }
 pub(crate) struct Preview {
    pub(crate) root: gtk4::Box,
    stack: gtk4::Stack,
    slot: gtk4::Overlay,
    name: gtk4::Label,
    kind: gtk4::Label,
    size: Detail,
    modified: Detail,
    location: Detail,
    availability: Detail,
    availability_icon: gtk4::Image,
    pub(crate) open: gtk4::Button,
    open_label: gtk4::Label,
    pub(crate) reveal: gtk4::Button,
    pub(crate) copy: gtk4::Button,
    copied: gtk4::Revealer,
    copied_timer: Rc<RefCell<Option<glib::SourceId>>>,
 }
 /// A flat action button: the label, and its shortcut at the far end.
 fn action(icon: &str, label: &str, accelerator: &str) -> (gtk4::Button, gtk4::Label) {
    let content = gtk4::Box::new(gtk4::Orientation::Horizontal, 10);
    content.append(&gtk4::Image::from_icon_name(icon));
    let text = gtk4::Label::builder()
        .label(label)
        .xalign(0.0)
        .hexpand(true)
        .max_width_chars(1)
        .ellipsize(gtk4::pango::EllipsizeMode::End)
        .build();
    content.append(&text);
    let shortcut = gtk4::ShortcutLabel::new(accelerator);
    shortcut.add_css_class("preview-shortcut");
    content.append(&shortcut);
    let button = gtk4::Button::builder()
        .child(&content)
        .focus_on_click(false)
        .focusable(false)
        .build();
    button.add_css_class("flat");
    button.add_css_class("preview-action");
    (button, text)
 }
 impl Preview {
    pub(crate) fn new() -> Self {
        let details = gtk4::Box::new(gtk4::Orientation::Vertical, 0);
        let slot = thumb_slot(THUMB_WIDTH, THUMB_HEIGHT, 96, gtk4::ContentFit::Contain);
        slot.add_css_class("preview-thumb");
        details.append(&slot);
        let name = gtk4::Label::builder()
            .xalign(0.0)
            .wrap(true)
            .wrap_mode(gtk4::pango::WrapMode::WordChar)
            .max_width_chars(1)
            .lines(3)
            .ellipsize(gtk4::pango::EllipsizeMode::End)
            .build();
        name.add_css_class("preview-name");
        details.append(&name);
        let kind = gtk4::Label::builder()
            .xalign(0.0)
            .max_width_chars(1)
            .ellipsize(gtk4::pango::EllipsizeMode::End)
            .build();
        kind.add_css_class("preview-kind");
        details.append(&kind);
        let grid = gtk4::Grid::builder()
            .row_spacing(6)
            .column_spacing(12)
            .build();
        grid.add_css_class("preview-details");
        let size = Detail::new(&grid, 0, &pgettext("column", "Size"));
        let modified = Detail::new(&grid, 1, &pgettext("column", "Modified"));
        let location = Detail::new(&grid, 2, &gettext("Location"));
        // Translators: a heading in the launcher's preview pane, followed by
        // "Available offline", "Downloaded", "Online only" or "On this computer".
        let availability = Detail::new(&grid, 3, &gettext("Availability"));
        // The availability value is an icon and a text.
        let availability_icon = gtk4::Image::new();
        availability_icon.add_css_class("preview-badge");
        grid.remove(&availability.value);
        let availability_box = gtk4::Box::new(gtk4::Orientation::Horizontal, 6);
        availability_box.append(&availability_icon);
        availability_box.append(&availability.value);
        grid.attach(&availability_box, 1, 3, 1, 1);
        details.append(&grid);
        let spacer = gtk4::Box::builder().vexpand(true).build();
        details.append(&spacer);
        let actions = gtk4::Box::new(gtk4::Orientation::Vertical, 2);
        actions.add_css_class("preview-actions");
        let (open, open_label) = action("document-open-symbolic", "", "Return");
        let (reveal, _) = action(
            "folder-open-symbolic",
            &gettext("Show in Folder"),
            "<Control>Return",
        );
        let (copy, _) = action("edit-copy-symbolic", &gettext("Copy Path"), "<Control>c");
        actions.append(&open);
        actions.append(&reveal);
        actions.append(&copy);
        details.append(&actions);
        let copied_label = gtk4::Label::new(Some(&gettext("Path copied")));
        copied_label.add_css_class("preview-feedback");
        let copied = gtk4::Revealer::builder()
            .transition_type(gtk4::RevealerTransitionType::Crossfade)
            .child(&copied_label)
            .build();
        details.append(&copied);
        let empty = gtk4::Image::from_icon_name("system-search-symbolic");
        empty.set_pixel_size(64);
        empty.add_css_class("preview-empty");
        let stack = gtk4::Stack::builder()
            .transition_type(gtk4::StackTransitionType::Crossfade)
            .transition_duration(100)
            .vexpand(true)
            .build();
        stack.add_named(&empty, Some("empty"));
        stack.add_named(&details, Some("details"));
        let root = gtk4::Box::builder()
            .orientation(gtk4::Orientation::Vertical)
            .width_request(PREVIEW_WIDTH)
            .hexpand(false)
            .build();
        root.add_css_class("preview");
        root.append(&stack);
        Self {
            root,
            stack,
            slot,
            name,
            kind,
            size,
            modified,
            location,
            availability,
            availability_icon,
            open,
            open_label,
            reveal,
            copy,
            copied,
            copied_timer: Rc::new(RefCell::new(None)),
        }
    }
    /// Show `hit`, or the empty pane when nothing is selected.
    pub(crate) fn show(&self, hit: Option<&Hit>, thumbs: &Rc<Thumbs>, mountpoint: &Path) {
        let Some(hit) = hit else {
            self.stack.set_visible_child_name("empty");
            return;
        };
        self.stack.set_visible_child_name("details");
        fill_slot(&self.slot, hit, thumbs, mountpoint);
        self.name.set_label(hit.name());
        self.name.set_tooltip_text(Some(hit.name()));
        let content_type = if hit.is_dir() {
            glib::GString::from("inode/directory")
        } else {
            gio::functions::content_type_guess(Some(hit.name()), None).0
        };
        self.kind
            .set_label(&gio::functions::content_type_get_description(&content_type));
        let size = (!hit.is_dir() && hit.size() > 0).then(|| human_bytes(hit.size()));
        self.size.set(size.as_deref());
        let modified = (hit.modified() > 0).then(|| dates::relative(hit.modified()));
        self.modified.set(modified.as_deref());
        self.modified.value.set_tooltip_text(
            (hit.modified() > 0)
                .then(|| dates::full(hit.modified()))
                .as_deref(),
        );
        let location = hit.location();
        self.location.set(Some(&location));
        self.location.value.set_tooltip_text(Some(&location));
        match availability(hit) {
            Some((icon, class, text)) => {
                self.availability.set(Some(&text));
                self.availability_icon.set_icon_name(Some(icon));
                for other in ["badge-pinned", "badge-cached", "badge-cloud", "badge-local"] {
                    self.availability_icon.remove_css_class(other);
                }
                self.availability_icon.add_css_class(class);
                self.availability_icon.set_visible(true);
            }
            None => {
                self.availability.set(None);
                self.availability_icon.set_visible(false);
            }
        }
        self.open_label.set_label(&if hit.is_dir() {
            gettext("Open folder")
        } else {
            pgettext("verb", "Open")
        });
    }
    /// Say "Path copied" for a moment.
    pub(crate) fn flash_copied(&self) {
        self.copied.set_reveal_child(true);
        if let Some(source) = self.copied_timer.borrow_mut().take() {
            source.remove();
        }
        let copied = self.copied.clone();
        let slot = self.copied_timer.clone();
        let timer = glib::timeout_add_local_once(COPIED_FEEDBACK, move || {
            slot.borrow_mut().take();
            copied.set_reveal_child(false);
        });
        *self.copied_timer.borrow_mut() = Some(timer);
    }
 }
 /// Where the hit's content is: its icon, its style class and its wording.
 fn availability(hit: &Hit) -> Option<(&'static str, &'static str, String)> {
    match hit {
        Hit::Local(_) => Some((
            "drive-harddisk-symbolic",
            "badge-local",
            gettext("On this computer"),
        )),
        Hit::Drive(drive) if drive.pinned => Some((
            "pdfs-offline-symbolic",
            "badge-pinned",
            gettext("Available offline"),
        )),
        // A folder is never downloaded as a whole; only pinning says anything.
        Hit::Drive(drive) if drive.is_dir => None,
        Hit::Drive(drive) if drive.cached => Some((
            "pdfs-cached-symbolic",
            "badge-cached",
            pgettext("file state", "Downloaded"),
        )),
        Hit::Drive(_) => Some((
            "pdfs-online-only-symbolic",
            "badge-cloud",
            pgettext("file state", "Online only"),
        )),
    }
 }
@@ -0,0 +1,187 @@
 //! Result rows: a thumbnail or icon, the name with its matched characters in
 //! bold, the location, and on the right the sync state, size and age.
 use std::cell::Cell;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use adw::prelude::*;
 use gtk4::{gdk, gio};
 use super::highlight;
 use super::thumbs::Thumbs;
 use crate::theme::proton_theme_active;
 use crate::{Hit, format_age, human_bytes};
 /// Edge of a row's thumbnail.
 const ROW_THUMB: i32 = 40;
 /// A thumbnail surface: an icon, with a picture laid over it that shows once
 /// the thumbnail has loaded. [`Thumbs`] paints the picture.
 pub(crate) fn thumb_slot(
    width: i32,
    height: i32,
    icon_size: i32,
    fit: gtk4::ContentFit,
 ) -> gtk4::Overlay {
    let fallback = gtk4::Image::builder().pixel_size(icon_size).build();
    let picture = gtk4::Picture::builder()
        .width_request(width)
        .height_request(height)
        .content_fit(fit)
        .can_shrink(true)
        .visible(false)
        .build();
    picture.set_overflow(gtk4::Overflow::Hidden);
    picture.add_css_class("thumb");
    let overlay = gtk4::Overlay::new();
    overlay.set_size_request(width, height);
    overlay.set_halign(gtk4::Align::Center);
    overlay.set_valign(gtk4::Align::Center);
    overlay.set_child(Some(&fallback));
    overlay.add_overlay(&picture);
    overlay
 }
 /// Show `hit` in a slot from [`thumb_slot`]: its icon at once, and its
 /// thumbnail when there is one.
 pub(crate) fn fill_slot(slot: &gtk4::Overlay, hit: &Hit, thumbs: &Rc<Thumbs>, mountpoint: &Path) {
    let Some(fallback) = slot.child().and_downcast::<gtk4::Image>() else {
        return;
    };
    let Some(picture) = fallback.next_sibling().and_downcast::<gtk4::Picture>() else {
        return;
    };
    fallback.set_from_gicon(&icon_for(hit.name(), hit.is_dir()));
    fallback.set_visible(true);
    picture.set_visible(false);
    picture.set_paintable(gdk::Paintable::NONE);
    thumbs.want(hit, mountpoint, &picture);
 }
 /// The desktop's own full-colour icon for a file name, so results look like
 /// the user's file manager. Folders are Proton's purple ones while the Proton
 /// theme is on, as in the app's browser.
 pub(crate) fn icon_for(name: &str, is_dir: bool) -> gio::Icon {
    if is_dir {
        let folder = if proton_theme_active() {
            "pdfs-proton-folder"
        } else {
            "folder"
        };
        return gio::ThemedIcon::new(folder).upcast();
    }
    let (content_type, _uncertain) = gio::functions::content_type_guess(Some(name), None);
    gio::functions::content_type_get_icon(&content_type)
 }
 /// The sync badge of a Drive file, as in the app's browser: pinned, cached,
 /// or online only. Folders and local files have none.
 pub(crate) fn badge_for(hit: &Hit) -> Option<(&'static str, &'static str)> {
    let Hit::Drive(drive) = hit else {
        return None;
    };
    if drive.is_dir {
        return None;
    }
    Some(if drive.pinned {
        ("pdfs-offline-symbolic", "badge-pinned")
    } else if drive.cached {
        ("pdfs-cached-symbolic", "badge-cached")
    } else {
        ("pdfs-online-only-symbolic", "badge-cloud")
    })
 }
 pub(crate) fn build_row(
    hit: &Hit,
    query: &str,
    thumbs: &Rc<Thumbs>,
    mountpoint: &Path,
 ) -> gtk4::ListBoxRow {
    let row = gtk4::ListBoxRow::new();
    row.add_css_class("result-row");
    // Focus stays in the search entry; the list only shows the cursor.
    row.set_focusable(false);
    let content = gtk4::Box::new(gtk4::Orientation::Horizontal, 12);
    let slot = thumb_slot(ROW_THUMB, ROW_THUMB, 32, gtk4::ContentFit::Cover);
    fill_slot(&slot, hit, thumbs, mountpoint);
    content.append(&slot);
    let text = gtk4::Box::new(gtk4::Orientation::Vertical, 1);
    text.set_hexpand(true);
    text.set_valign(gtk4::Align::Center);
    let name = gtk4::Label::builder()
        .label(highlight::markup(hit.name(), query))
        .use_markup(true)
        .xalign(0.0)
        .ellipsize(gtk4::pango::EllipsizeMode::Middle)
        .build();
    name.add_css_class("result-name");
    text.append(&name);
    let location = gtk4::Label::builder()
        .label(hit.location())
        .xalign(0.0)
        .ellipsize(gtk4::pango::EllipsizeMode::Start)
        .build();
    location.add_css_class("result-location");
    text.append(&location);
    content.append(&text);
    let meta = gtk4::Box::new(gtk4::Orientation::Horizontal, 10);
    meta.set_valign(gtk4::Align::Center);
    if let Some((icon, class)) = badge_for(hit) {
        let badge = gtk4::Image::from_icon_name(icon);
        badge.add_css_class("result-badge");
        badge.add_css_class(class);
        meta.append(&badge);
    }
    if !hit.is_dir() && hit.size() > 0 {
        let size = gtk4::Label::new(Some(&human_bytes(hit.size())));
        size.add_css_class("result-meta");
        meta.append(&size);
    }
    if hit.modified() > 0 {
        let modified = gtk4::Label::new(Some(&format_age(hit.modified())));
        modified.add_css_class("result-meta");
        meta.append(&modified);
    }
    content.append(&meta);
    row.set_child(Some(&content));
    row
 }
 /// Let a row be dragged into a file manager or an application as a file.
 /// `dropped` runs once a drop was accepted; a cancelled drag changes nothing.
 pub(crate) fn attach_drag(row: &gtk4::ListBoxRow, path: PathBuf, dropped: impl Fn() + 'static) {
    let source = gtk4::DragSource::new();
    source.set_actions(gdk::DragAction::COPY);
    let files = gdk::FileList::from_array(&[gio::File::for_path(&path)]);
    source.set_content(Some(&gdk::ContentProvider::for_value(&files.to_value())));
    let cancelled = Rc::new(Cell::new(false));
    let begin = cancelled.clone();
    source.connect_drag_begin(move |source, _| {
        begin.set(false);
        if let Some(widget) = source.widget() {
            source.set_icon(Some(&gtk4::WidgetPaintable::new(Some(&widget))), 0, 0);
        }
    });
    let cancel = cancelled.clone();
    source.connect_drag_cancel(move |_, _, _| {
        cancel.set(true);
        false
    });
    source.connect_drag_end(move |_, _, _| {
        if !cancelled.get() {
            dropped();
        }
    });
    row.add_controller(source);
 }
@@ -0,0 +1,697 @@
 //! Thumbnails for the launcher's rows and preview pane.
 //!
 //! The main thread keeps a small LRU of textures, the keys known to have no
 //! thumbnail, and the pictures waiting for one (as weak references, so a row
 //! that was rebuilt or dropped keeps nothing alive). Everything that touches
 //! a file runs on two worker threads, which try in order:
 //!
 //! 1. the freedesktop thumbnail cache, valid only when its `Thumb::MTime`
 //!    matches the file's;
 //! 2. for local images, decoding the file itself, and writing the result back
 //!    to that cache for the next time and for every other application;
 //! 3. for Drive images, the daemon's `FileThumbs`, batched after a short quiet
 //!    period.
 //!
 //! Workers hand back `gdk::Texture`s, never a `Pixbuf`, which may not cross
 //! threads. Each job carries the render epoch it was queued in, and workers
 //! skip jobs a newer query has made pointless.
 use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::io::Write;
 use std::os::unix::fs::{DirBuilderExt, OpenOptionsExt};
 use std::path::{Path, PathBuf};
 use std::rc::{Rc, Weak};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{Duration, UNIX_EPOCH};
 use gtk4::gdk_pixbuf::Pixbuf;
 use gtk4::prelude::*;
 use gtk4::{gdk, glib};
 use pdfs_core::control::{FileThumbRequest, Request, Response, is_thumbnail_image_name};
 use crate::{Hit, spawn_request};
 /// Decoded textures kept in memory. A launcher shows a few dozen rows, so
 /// this covers several searches back.
 const TEXTURE_CACHE_MAX: usize = 128;
 const MISSING_MAX: usize = 1024;
 const WORKERS: usize = 2;
 /// Edge of the thumbnails this loader decodes and writes: the freedesktop
 /// "large" size.
 const THUMB_SIZE: i32 = 256;
 /// Local images above this size are not decoded here; a thumbnail is not
 /// worth reading that much.
 const MAX_SOURCE_BYTES: u64 = 64 * 1024 * 1024;
 /// Quiet period before Drive misses go to the daemon as one batch, so typing
 /// a word asks once for the final result set.
 const DAEMON_DEBOUNCE: Duration = Duration::from_millis(150);
 const DAEMON_RETRY: Duration = Duration::from_secs(1);
 const DAEMON_BATCH: usize = 32;
 /// Where a job finds its image.
 enum Source {
    /// A file on this machine.
    Local(PathBuf),
    /// A Drive file: the thumbnail cache is keyed by its mounted path, and
    /// the daemon is asked on a miss.
    Drive {
        mounted: PathBuf,
        request: FileThumbRequest,
    },
    /// A thumbnail the daemon made, in its own cache.
    Daemon(PathBuf),
 }
 struct Job {
    epoch: u64,
    key: String,
    source: Source,
 }
 enum Outcome {
    Texture(gdk::Texture),
    Missing,
    /// Not in the thumbnail cache; the daemon has to make it.
    Daemon(FileThumbRequest),
    /// Queued for an older render; handed back in case it is wanted again.
    Skipped(Source),
 }
 struct Done {
    key: String,
    outcome: Outcome,
 }
 pub(crate) struct Thumbs {
    socket: PathBuf,
    epoch: Arc<AtomicU64>,
    jobs: async_channel::Sender<Job>,
    textures: RefCell<HashMap<String, gdk::Texture>>,
    /// Least recently used first.
    order: RefCell<VecDeque<String>>,
    missing: RefCell<HashSet<String>>,
    missing_order: RefCell<VecDeque<String>>,
    waiters: RefCell<HashMap<String, Vec<glib::WeakRef<gtk4::Picture>>>>,
    /// Keys with a worker job or a daemon request outstanding.
    working: RefCell<HashSet<String>>,
    /// Drive misses waiting for the next batch, by key.
    queued: RefCell<HashMap<String, FileThumbRequest>>,
    /// Drive items the daemon is working on under `generation`, by key.
    sent: RefCell<HashMap<String, FileThumbRequest>>,
    generation: Cell<u64>,
    reserving: Cell<bool>,
    inflight: Cell<bool>,
    flush: RefCell<Option<glib::SourceId>>,
 }
 impl Thumbs {
    pub(crate) fn new(socket: PathBuf) -> Rc<Self> {
        let epoch = Arc::new(AtomicU64::new(0));
        let (jobs, inbox) = async_channel::unbounded::<Job>();
        let (done, results) = async_channel::unbounded::<Done>();
        for n in 0..WORKERS {
            let inbox = inbox.clone();
            let done = done.clone();
            let epoch = epoch.clone();
            let spawned = std::thread::Builder::new()
                .name(format!("prompt-thumbs-{n}"))
                .spawn(move || work(n, &inbox, &done, &epoch));
            if let Err(e) = spawned {
                tracing::warn!("cannot start a thumbnail worker: {e}");
            }
        }
        let thumbs = Rc::new(Self {
            socket,
            epoch,
            jobs,
            textures: RefCell::new(HashMap::new()),
            order: RefCell::new(VecDeque::new()),
            missing: RefCell::new(HashSet::new()),
            missing_order: RefCell::new(VecDeque::new()),
            waiters: RefCell::new(HashMap::new()),
            working: RefCell::new(HashSet::new()),
            queued: RefCell::new(HashMap::new()),
            sent: RefCell::new(HashMap::new()),
            generation: Cell::new(0),
            reserving: Cell::new(false),
            inflight: Cell::new(false),
            flush: RefCell::new(None),
        });
        let weak = Rc::downgrade(&thumbs);
        glib::spawn_future_local(async move {
            while let Ok(done) = results.recv().await {
                let Some(thumbs) = weak.upgrade() else {
                    break;
                };
                thumbs.finish(done);
            }
        });
        thumbs
    }
    /// Paint `hit`'s thumbnail into `picture` now if it is known, or as soon
    /// as it is. Folders and non-images keep the slot's icon.
    pub(crate) fn want(self: &Rc<Self>, hit: &Hit, mountpoint: &Path, picture: &gtk4::Picture) {
        let key = hit.thumb_key();
        // The widget name binds the picture to one key: a late reply for
        // another hit must not paint into it.
        picture.set_widget_name(&key);
        if hit.is_dir() || !is_thumbnail_image_name(hit.name()) {
            return;
        }
        if matches!(hit, Hit::Drive(drive) if drive.uid.is_empty()) {
            return;
        }
        let cached = self.textures.borrow().get(&key).cloned();
        if let Some(texture) = cached {
            self.touch(&key);
            paint(picture, &key, &texture);
            return;
        }
        if self.missing.borrow().contains(&key) {
            return;
        }
        self.waiters
            .borrow_mut()
            .entry(key.clone())
            .or_default()
            .push(picture.downgrade());
        if !self.working.borrow_mut().insert(key.clone()) {
            return;
        }
        let source = match hit {
            Hit::Local(local) => Source::Local(PathBuf::from(&local.path)),
            Hit::Drive(drive) => Source::Drive {
                mounted: hit.fs_path(mountpoint),
                request: FileThumbRequest {
                    uid: drive.uid.clone(),
                    modified: drive.modified,
                    name: drive.name.clone(),
                },
            },
        };
        self.dispatch(key, source);
    }
    /// The rows are about to be rebuilt: forget their pictures, and let the
    /// workers skip what was queued for them.
    pub(crate) fn begin_render(&self) {
        self.epoch.fetch_add(1, Ordering::SeqCst);
        self.waiters.borrow_mut().clear();
    }
    /// The rows are rebuilt and have asked for their thumbnails. Drive work
    /// for hits that are gone is dropped, and cancelled at the daemon when it
    /// had already been sent.
    pub(crate) fn end_render(self: &Rc<Self>) {
        let wanted: HashSet<String> = self.waiters.borrow().keys().cloned().collect();
        let mut dropped = Vec::new();
        self.queued.borrow_mut().retain(|key, _| {
            let keep = wanted.contains(key);
            if !keep {
                dropped.push(key.clone());
            }
            keep
        });
        let stale = self.sent.borrow().keys().any(|key| !wanted.contains(key));
        if stale {
            self.cancel_daemon();
            // Still-wanted items go back into the next batch, under a fresh
            // generation.
            let sent: Vec<(String, FileThumbRequest)> = self.sent.borrow_mut().drain().collect();
            for (key, request) in sent {
                if wanted.contains(&key) {
                    self.queued.borrow_mut().insert(key, request);
                } else {
                    dropped.push(key);
                }
            }
            self.schedule(DAEMON_DEBOUNCE);
        }
        let mut working = self.working.borrow_mut();
        for key in dropped {
            working.remove(&key);
        }
    }
    /// The launcher was dismissed: stop everything.
    pub(crate) fn cancel_all(&self) {
        self.epoch.fetch_add(1, Ordering::SeqCst);
        self.waiters.borrow_mut().clear();
        self.working.borrow_mut().clear();
        self.queued.borrow_mut().clear();
        self.sent.borrow_mut().clear();
        if let Some(source) = self.flush.borrow_mut().take() {
            source.remove();
        }
        self.cancel_daemon();
    }
    fn dispatch(&self, key: String, source: Source) {
        let job = Job {
            epoch: self.epoch.load(Ordering::SeqCst),
            key: key.clone(),
            source,
        };
        if self.jobs.try_send(job).is_err() {
            self.working.borrow_mut().remove(&key);
        }
    }
    fn wanted(&self, key: &str) -> bool {
        self.waiters.borrow().contains_key(key)
    }
    fn finish(self: &Rc<Self>, done: Done) {
        let Done { key, outcome } = done;
        match outcome {
            Outcome::Texture(texture) => {
                self.working.borrow_mut().remove(&key);
                self.store_texture(&key, texture.clone());
                let waiters = self.waiters.borrow_mut().remove(&key);
                for picture in waiters.into_iter().flatten() {
                    if let Some(picture) = picture.upgrade() {
                        paint(&picture, &key, &texture);
                    }
                }
            }
            Outcome::Missing => {
                self.working.borrow_mut().remove(&key);
                self.store_missing(key.clone());
                self.waiters.borrow_mut().remove(&key);
            }
            Outcome::Daemon(request) => {
                if self.wanted(&key) {
                    self.queued.borrow_mut().insert(key, request);
                    self.schedule(DAEMON_DEBOUNCE);
                } else {
                    self.working.borrow_mut().remove(&key);
                }
            }
            Outcome::Skipped(source) => {
                // A newer render may want the same image again.
                if self.wanted(&key) {
                    self.dispatch(key, source);
                } else {
                    self.working.borrow_mut().remove(&key);
                }
            }
        }
    }
    fn touch(&self, key: &str) {
        let mut order = self.order.borrow_mut();
        if let Some(at) = order.iter().position(|held| held == key) {
            order.remove(at);
            order.push_back(key.to_string());
        }
    }
    fn store_texture(&self, key: &str, texture: gdk::Texture) {
        let mut textures = self.textures.borrow_mut();
        if textures.insert(key.to_string(), texture).is_none() {
            self.order.borrow_mut().push_back(key.to_string());
        } else {
            drop(textures);
            self.touch(key);
            return;
        }
        let mut order = self.order.borrow_mut();
        while order.len() > TEXTURE_CACHE_MAX {
            if let Some(old) = order.pop_front() {
                textures.remove(&old);
            }
        }
    }
    fn store_missing(&self, key: String) {
        let mut missing = self.missing.borrow_mut();
        let mut order = self.missing_order.borrow_mut();
        if missing.insert(key.clone()) {
            order.push_back(key);
        }
        while order.len() > MISSING_MAX {
            if let Some(old) = order.pop_front() {
                missing.remove(&old);
            }
        }
    }
    /// Stop the daemon's work for this launcher. The generation is shared
    /// with the app, so this is only sent when something was asked for.
    fn cancel_daemon(&self) {
        let generation = self.generation.replace(0);
        if generation != 0 {
            // The reply is not needed; `spawn_request` owns the round-trip.
            drop(spawn_request(
                self.socket.clone(),
                Request::CancelFileThumbs {
                    generation: generation.saturating_add(1),
                },
            ));
        }
    }
    fn schedule(self: &Rc<Self>, delay: Duration) {
        if let Some(source) = self.flush.borrow_mut().take() {
            source.remove();
        }
        let weak = Rc::downgrade(self);
        let source = glib::timeout_add_local_once(delay, move || {
            if let Some(thumbs) = weak.upgrade() {
                thumbs.flush.borrow_mut().take();
                thumbs.send_batch();
            }
        });
        *self.flush.borrow_mut() = Some(source);
    }
    fn send_batch(self: &Rc<Self>) {
        if self.inflight.get() || self.queued.borrow().is_empty() {
            return;
        }
        if self.generation.get() == 0 {
            self.reserve();
            return;
        }
        let batch: Vec<(String, FileThumbRequest)> = {
            let mut queued = self.queued.borrow_mut();
            let keys: Vec<String> = queued.keys().take(DAEMON_BATCH).cloned().collect();
            keys.into_iter()
                .filter_map(|key| queued.remove_entry(&key))
                .collect()
        };
        self.sent.borrow_mut().extend(batch.iter().cloned());
        let generation = self.generation.get();
        self.inflight.set(true);
        let rx = spawn_request(
            self.socket.clone(),
            Request::FileThumbs {
                items: batch.iter().map(|(_, request)| request.clone()).collect(),
                generation,
            },
        );
        let weak = Rc::downgrade(self);
        glib::spawn_future_local(async move {
            let reply = rx.recv().await;
            let Some(thumbs) = weak.upgrade() else {
                return;
            };
            thumbs.inflight.set(false);
            thumbs.receive(generation, batch, reply);
            if !thumbs.queued.borrow().is_empty() {
                thumbs.schedule(Duration::ZERO);
            }
        });
    }
    fn receive(
        self: &Rc<Self>,
        generation: u64,
        batch: Vec<(String, FileThumbRequest)>,
        reply: Result<Result<Response, String>, async_channel::RecvError>,
    ) {
        // Cancelled while in flight: `end_render` or `cancel_all` already
        // re-queued what is still wanted. A finished thumbnail is still worth
        // painting.
        let current = generation == self.generation.get();
        match reply {
            Ok(Ok(Response::Thumbs { items })) => {
                let mut by_uid: HashMap<String, (String, FileThumbRequest)> = batch
                    .into_iter()
                    .map(|(key, request)| (request.uid.clone(), (key, request)))
                    .collect();
                let mut again = Vec::new();
                for item in items {
                    let Some((key, request)) = by_uid.remove(&item.uid) else {
                        continue;
                    };
                    if let Some(path) = item.path {
                        if current {
                            self.sent.borrow_mut().remove(&key);
                        }
                        if self.wanted(&key) {
                            self.working.borrow_mut().insert(key.clone());
                            self.dispatch(key, Source::Daemon(PathBuf::from(path)));
                        } else {
                            self.working.borrow_mut().remove(&key);
                        }
                    } else if !current {
                        continue;
                    } else if item.pending {
                        again.push((key, request));
                    } else {
                        self.sent.borrow_mut().remove(&key);
                        self.working.borrow_mut().remove(&key);
                        self.store_missing(key.clone());
                        self.waiters.borrow_mut().remove(&key);
                    }
                }
                if current {
                    again.extend(by_uid.into_values());
                    self.retry(again);
                }
            }
            Ok(Ok(Response::FileThumbsStale)) if current => {
                self.generation.set(0);
                self.retry(batch);
            }
            Ok(Ok(Response::Error { message, .. })) if current => {
                tracing::debug!("launcher thumbnails failed: {message}");
                self.retry(batch);
            }
            _ if current => self.retry(batch),
            _ => {}
        }
    }
    /// Ask again for items the daemon is still making, after a pause.
    fn retry(self: &Rc<Self>, items: Vec<(String, FileThumbRequest)>) {
        if items.is_empty() {
            return;
        }
        let weak = Rc::downgrade(self);
        glib::timeout_add_local_once(DAEMON_RETRY, move || {
            let Some(thumbs) = weak.upgrade() else {
                return;
            };
            for (key, request) in items {
                // Gone from `sent` means cancelled or already answered.
                if thumbs.sent.borrow_mut().remove(&key).is_some() && thumbs.wanted(&key) {
                    thumbs.queued.borrow_mut().insert(key, request);
                } else {
                    thumbs.working.borrow_mut().remove(&key);
                }
            }
            thumbs.send_batch();
        });
    }
    fn reserve(self: &Rc<Self>) {
        if self.reserving.replace(true) {
            return;
        }
        let rx = spawn_request(self.socket.clone(), Request::ReserveFileThumbGeneration);
        let weak: Weak<Self> = Rc::downgrade(self);
        glib::spawn_future_local(async move {
            let reply = rx.recv().await;
            let Some(thumbs) = weak.upgrade() else {
                return;
            };
            thumbs.reserving.set(false);
            match reply {
                Ok(Ok(Response::FileThumbGeneration { generation })) if generation != 0 => {
                    thumbs.generation.set(generation);
                    thumbs.send_batch();
                }
                _ => thumbs.schedule(DAEMON_RETRY),
            }
        });
    }
 }
 /// Show `texture` in `picture` if the picture still belongs to `key`, and hide
 /// the icon underneath it.
 fn paint(picture: &gtk4::Picture, key: &str, texture: &gdk::Texture) {
    if picture.widget_name() != key {
        return;
    }
    picture.set_paintable(Some(texture));
    picture.set_visible(true);
    if let Some(overlay) = picture.parent().and_downcast::<gtk4::Overlay>()
        && let Some(fallback) = overlay.child()
    {
        fallback.set_visible(false);
    }
 }
 fn work(
    index: usize,
    inbox: &async_channel::Receiver<Job>,
    done: &async_channel::Sender<Done>,
    epoch: &AtomicU64,
 ) {
    while let Ok(job) = inbox.recv_blocking() {
        // A daemon thumbnail is already made; decoding it is cheap and the
        // texture is cached for the next render.
        let stale =
            !matches!(job.source, Source::Daemon(_)) && job.epoch < epoch.load(Ordering::SeqCst);
        let outcome = if stale {
            Outcome::Skipped(job.source)
        } else {
            load(index, job.source)
        };
        if done
            .send_blocking(Done {
                key: job.key,
                outcome,
            })
            .is_err()
        {
            break;
        }
    }
 }
 fn load(worker: usize, source: Source) -> Outcome {
    match source {
        Source::Local(path) => {
            let Ok(meta) = std::fs::metadata(&path) else {
                return Outcome::Missing;
            };
            let mtime = meta
                .modified()
                .ok()
                .and_then(|at| at.duration_since(UNIX_EPOCH).ok())
                .map_or(0, |at| at.as_secs() as i64);
            if let Some(pixbuf) = cached(&path, mtime) {
                return texture(&pixbuf);
            }
            if meta.len() > MAX_SOURCE_BYTES {
                return Outcome::Missing;
            }
            let Some((pixbuf, scaled)) = decode(&path) else {
                return Outcome::Missing;
            };
            // An image that already fits is its own thumbnail.
            if scaled && let Err(e) = write_cached(worker, &path, mtime, &pixbuf) {
                tracing::debug!("cannot cache a thumbnail of {}: {e}", path.display());
            }
            texture(&pixbuf)
        }
        Source::Drive { mounted, request } => match cached(&mounted, request.modified) {
            Some(pixbuf) => texture(&pixbuf),
            None => Outcome::Daemon(request),
        },
        Source::Daemon(path) => match gdk::Texture::from_filename(&path) {
            Ok(texture) => Outcome::Texture(texture),
            Err(e) => {
                tracing::debug!("cannot decode {}: {e}", path.display());
                Outcome::Missing
            }
        },
    }
 }
 /// `$XDG_CACHE_HOME/thumbnails`.
 fn thumbnail_root() -> PathBuf {
    glib::user_cache_dir().join("thumbnails")
 }
 /// The URI and its MD5, which name a file's entry in the thumbnail cache.
 fn cache_name(path: &Path) -> Option<(String, String)> {
    let uri = glib::filename_to_uri(path, None).ok()?.to_string();
    let md5 = glib::compute_checksum_for_data(glib::ChecksumType::Md5, uri.as_bytes())?.to_string();
    Some((uri, md5))
 }
 /// A thumbnail from the shared cache, if one was made for this version of
 /// the file.
 fn cached(path: &Path, mtime: i64) -> Option<Pixbuf> {
    let (_, md5) = cache_name(path)?;
    let root = thumbnail_root();
    ["large", "x-large", "normal"].iter().find_map(|size| {
        let pixbuf = Pixbuf::from_file(root.join(size).join(format!("{md5}.png"))).ok()?;
        let stamp = pixbuf.option("tEXt::Thumb::MTime")?;
        (stamp.parse::<i64>().ok()? == mtime).then_some(pixbuf)
    })
 }
 /// Decode a local image at most [`THUMB_SIZE`] on its longer edge, upright.
 /// The bool says whether it had to be scaled down.
 fn decode(path: &Path) -> Option<(Pixbuf, bool)> {
    let (_, width, height) = Pixbuf::file_info(path)?;
    let scaled = width > THUMB_SIZE || height > THUMB_SIZE;
    let pixbuf = if scaled {
        Pixbuf::from_file_at_scale(path, THUMB_SIZE, THUMB_SIZE, true)
    } else {
        Pixbuf::from_file(path)
    }
    .ok()?;
    let pixbuf = pixbuf.apply_embedded_orientation().unwrap_or(pixbuf);
    Some((pixbuf, scaled))
 }
 /// Store a thumbnail as the freedesktop spec asks: in `large/`, with
 /// `Thumb::URI` and `Thumb::MTime`, readable only by the user, and written
 /// through a temporary file so another reader never sees half of it.
 fn write_cached(worker: usize, path: &Path, mtime: i64, pixbuf: &Pixbuf) -> std::io::Result<()> {
    let (uri, md5) = cache_name(path).ok_or_else(|| std::io::Error::other("no file URI"))?;
    let dir = thumbnail_root().join("large");
    std::fs::DirBuilder::new()
        .recursive(true)
        .mode(0o700)
        .create(&dir)?;
    let mtime = mtime.to_string();
    let png = pixbuf
        .save_to_bufferv(
            "png",
            &[
                ("tEXt::Thumb::URI", uri.as_str()),
                ("tEXt::Thumb::MTime", mtime.as_str()),
            ],
        )
        .map_err(std::io::Error::other)?;
    let tmp = dir.join(format!(
        "{md5}.png.pdfs-{}-{worker}.tmp",
        std::process::id()
    ));
    let written = std::fs::OpenOptions::new()
        .write(true)
        .create(true)
        .truncate(true)
        .mode(0o600)
        .open(&tmp)
        .and_then(|mut file| file.write_all(&png))
        .and_then(|()| std::fs::rename(&tmp, dir.join(format!("{md5}.png"))));
    if written.is_err() {
        let _ = std::fs::remove_file(&tmp);
    }
    written
 }
 /// A `Pixbuf` may not leave its thread; its pixels, as a memory texture, can.
 fn texture(pixbuf: &Pixbuf) -> Outcome {
    let format = if pixbuf.has_alpha() {
        gdk::MemoryFormat::R8g8b8a8
    } else {
        gdk::MemoryFormat::R8g8b8
    };
    let texture = gdk::MemoryTexture::new(
        pixbuf.width(),
        pixbuf.height(),
        format,
        &pixbuf.read_pixel_bytes(),
        pixbuf.rowstride() as usize,
    );
    Outcome::Texture(texture.upcast())
 }
@@ -0,0 +1,158 @@
 //! The bundled resources and the optional Proton theme, shared by `pdfs-app`
 //! and `pdfs-prompt` so both paint the same way from the same preference.
 use std::cell::RefCell;
 use adw::prelude::*;
 use gtk4::{gio, glib};
 /// Register the bundled GResources (custom icons, the stylesheets) and load
 /// `stylesheet`, the front end's own sheet. The Proton theme is a separate
 /// provider, applied by [`set_proton_theme`] from the saved preference.
 pub(crate) fn load_resources(stylesheet: &str) {
    let bytes = include_bytes!(concat!(env!("OUT_DIR"), "/pdfs.gresource"));
    let resource_data = glib::Bytes::from_static(bytes);
    if let Ok(resource) = gio::Resource::from_data(&resource_data) {
        gio::resources_register(&resource);
    } else {
        tracing::error!("failed to load gresource bundle");
    }
    let Some(display) = gtk4::gdk::Display::default() else {
        return;
    };
    let provider = gtk4::CssProvider::new();
    provider.load_from_resource(stylesheet);
    // Above the user's own gtk.css, which often imports a whole theme: its
    // `button { padding: 6px 10px; min-width: 16px }` would otherwise pad every
    // photo tile and push the grid past the window. Every rule in the sheet is
    // scoped to the app's own classes, so nothing else the user styled changes.
    // One above the Proton theme too, so the app's rules refine it.
    gtk4::style_context_add_provider_for_display(
        &display,
        &provider,
        gtk4::STYLE_PROVIDER_PRIORITY_USER + 2,
    );
    gtk4::IconTheme::for_display(&display).add_resource_path("/de/nils/protondrivelinux/icons");
 }
 thread_local! {
    /// The Proton theme provider while it is installed. Kept so turning the
    /// preference off can remove exactly what turning it on added.
    static PROTON_THEME: RefCell<Option<gtk4::CssProvider>> = const { RefCell::new(None) };
 }
 /// Whether the Proton theme is on.
 pub(crate) fn proton_theme_active() -> bool {
    PROTON_THEME.with(|slot| slot.borrow().is_some())
 }
 /// libadwaita's own stylesheet, bundled in the library.
 const ADWAITA_STYLESHEET: &str = "/org/gnome/Adwaita/styles/gtk.css";
 /// The Proton palette laid over it, from our own bundle.
 const PROTON_PALETTE: &str = "/de/nils/protondrivelinux/proton-theme.css";
 /// Make the theme provider's `@media (prefers-color-scheme)` and
 /// `(prefers-contrast)` rules match what libadwaita shows, now and whenever it
 /// changes. A provider evaluates those itself, and a new one assumes light.
 ///
 /// The properties are set by name because they only exist since GTK 4.20, and
 /// the app still runs on older GTK, whose libadwaita has no such rules anyway.
 fn follow_style_manager(provider: &gtk4::CssProvider) {
    fn set_enum(provider: &gtk4::CssProvider, property: &str, nick: &str) {
        let Some(pspec) = provider.find_property(property) else {
            return;
        };
        if let Some(value) = glib::EnumClass::with_type(pspec.value_type())
            .and_then(|class| class.to_value_by_nick(nick))
        {
            provider.set_property_from_value(property, &value);
        }
    }
    fn apply(provider: &gtk4::CssProvider, manager: &adw::StyleManager) {
        let scheme = if manager.is_dark() { "dark" } else { "light" };
        set_enum(provider, "prefers-color-scheme", scheme);
        let contrast = if manager.is_high_contrast() {
            "more"
        } else {
            "no-preference"
        };
        set_enum(provider, "prefers-contrast", contrast);
    }
    let manager = adw::StyleManager::default();
    apply(provider, &manager);
    // Weak, so a provider the preference removed isn't kept alive; its
    // handlers then do nothing.
    let weak = provider.downgrade();
    let weak_dark = weak.clone();
    manager.connect_dark_notify(move |manager| {
        if let Some(provider) = weak_dark.upgrade() {
            apply(&provider, manager);
        }
    });
    manager.connect_high_contrast_notify(move |manager| {
        if let Some(provider) = weak.upgrade() {
            apply(&provider, manager);
        }
    });
 }
 /// Paint the window in the Proton web apps' colours (`on`) or follow the
 /// system theme and accent colour.
 ///
 /// Setting libadwaita's colour variables alone isn't enough: a GTK theme the
 /// user's `gtk.css` imports (Catppuccin, Fluent, ...) sits above the app and
 /// hard-codes its own accent into hundreds of rules. So the theme provider,
 /// one above the user's CSS, first resets every property, then re-applies
 /// libadwaita's whole stylesheet and finally the Proton palette, which leaves
 /// nothing of the user's theme inside the app.
 pub(crate) fn set_proton_theme(on: bool) {
    let Some(display) = gtk4::gdk::Display::default() else {
        return;
    };
    PROTON_THEME.with(|slot| {
        let mut slot = slot.borrow_mut();
        match (on, slot.as_ref()) {
            (true, None) => {
                let stylesheet = |path| {
                    gio::resources_lookup_data(path, gio::ResourceLookupFlags::NONE)
                        .map(|bytes| String::from_utf8_lossy(&bytes).into_owned())
                };
                let palette = stylesheet(PROTON_PALETTE).unwrap_or_default();
                let css = match stylesheet(ADWAITA_STYLESHEET) {
                    // Its images are named relative to the sheet, which a
                    // string loaded here doesn't have.
                    Ok(adwaita) => format!(
                        "* {{ all: unset; }}\n{}\n{palette}",
                        adwaita.replace(
                            "url(\"assets/",
                            "url(\"resource:///org/gnome/Adwaita/styles/assets/"
                        )
                    ),
                    // Still recolours everything that follows libadwaita's
                    // variables; only a custom theme's own rules show through.
                    Err(e) => {
                        tracing::warn!("libadwaita stylesheet not found, only recolouring: {e}");
                        palette
                    }
                };
                let provider = gtk4::CssProvider::new();
                follow_style_manager(&provider);
                provider.load_from_string(&css);
                gtk4::style_context_add_provider_for_display(
                    &display,
                    &provider,
                    gtk4::STYLE_PROVIDER_PRIORITY_USER + 1,
                );
                *slot = Some(provider);
            }
            (false, Some(provider)) => {
                gtk4::style_context_remove_provider_for_display(&display, provider);
                *slot = None;
            }
            _ => {}
        }
    });
 }
@@ -1,6 +1,13 @@
-# Proton Drive Linux Client: Architecture Specification
+# Architecture
-This document provides a deep, comprehensive architectural description of the Proton Drive Linux Client (`pdfs`). It specifies the design patterns, data flows, thread models, and subsystem dependencies that govern the virtual filesystem (FUSE), database persistence, cache management, and two-way sync engine.
+This document describes how the Proton Drive Linux client (`pdfs`) is built: the crates, the
 filesystem and its caches, the write queue, the sync engine, the control protocol, the thread
 layout, what the client writes to disk in plaintext, and the CAPTCHA flow. It is written for
 contributors and for anyone auditing the client. User-facing documentation starts at
 [docs/README.md](README.md).
 Numbers quoted here (thread counts, timeouts, limits) are the constants in the source at the time
 of writing; the source is authoritative when they disagree.
 ---
@@ -35,6 +42,11 @@ graph TD
 | [`pdfs-cli`](../crates/pdfs-cli) | Command Line Interface | Command routing, daemon launcher, IPC client wrapper. | Stateless; communicates with daemon over IPC control socket. |
 | [`pdfs-gui`](../crates/pdfs-gui) | Graphical Interface | GTK pages, tray, and the resident quick-search prompt. | Keeps UI state only; all durable state and Drive access remain behind the IPC socket. |
 The workspace ships four binaries: `pdfs` (the CLI, and the daemon as `pdfs daemon`) from
 `pdfs-cli`, and `pdfs-app`, `pdfs-tray` and `pdfs-prompt` from `pdfs-gui`. The daemon runs as the
 systemd user unit `proton-drive.service`. Only the daemon holds the database, the caches and the
 API client; every other binary is a client of its control socket.
 ---
 ## 2. In-Memory VFS State & File Operations
@@ -105,11 +117,29 @@ A mirror folder is a plain local directory with no FUSE session, so a row can le
 ## 3. Read Path & Block Caching Pipeline
-Read requests are parallelized and served in blocks of size `BLOCK_SIZE` (4 MiB).
+Reads are served from the revision's content blocks. `Core::read_range` looks in three places
 before the network:
-* **Unpinned files (Streaming):** Avoids writing full files to disk to preserve storage. Instead, blocks are kept in a fixed-size `stream_ring` (in-memory ring cache) and evicted immediately.
+1. **Whole-file blob.** A file kept available offline is downloaded completely into
-* **Pinned files (Persistent):** Block downloads are saved directly to `ContentCache` on disk.
+   `ContentCache` and read from there.
-* **Read-Ahead:** The reader thread spawns asynchronous tasks to pre-fetch upcoming blocks.
+2. **Stream ring.** For every other file, a bounded in-memory ring (`RING_BYTES`, 128 MiB) of
   recently decrypted blocks is checked first, because the kernel reads in pieces far smaller
   than a block.
 3. **Block cache.** Blocks are then looked up on disk, under `content/blocks/`. They count
   against `cache_budget` and are evicted least-recently-used.
 On a miss, only the blocks that overlap the request are fetched, through a `RevisionReader` kept
 open per revision (`MAX_OPEN_READERS = 64`, validated by `(mtime, size)`).
 * **Block geometry.** Block boundaries come from the revision itself. The first read of a file
  assumes uniform `BLOCK_SIZE` (4 MiB) blocks; once a reader is open, the real block sizes are
  recorded (`store_block_geometry`) and later reads plan on them. Proton does not guarantee
  4 MiB blocks, and assuming it served wrong bytes (`docs/BUGS.md` B85).
 * **Read-ahead.** A read that proves sequential prefetches a window of 2 to 8 blocks
  (`PREFETCH_MIN`, `PREFETCH_MAX`). Prefetch takes a permit from a global budget of 8 and gives up
  instead of queueing, so it never delays a demand read.
 * **Large videos.** An unpinned video of 256 MiB or more (`STREAM_BYPASS_MIN`) streams without
  persisting its blocks, so watching a film does not evict the rest of the cache.
 ```mermaid
 sequenceDiagram
@@ -121,21 +151,25 @@ sequenceDiagram
    participant API as Proton API Client
    Kernel->>FUSE: read(ino, fh, offset, size)
-    FUSE->>FUSE: calculate block indices [first_block..last_block]
+    alt Whole-file blob cached (available offline)
-    loop For each block index
+        FUSE->>Cache: read blob range
-        alt Block in disk Cache (Pinned/Cache hit)
+        Cache-->>FUSE: bytes
-            FUSE->>Cache: read_block(block_idx)
+    else
-            Cache-->>FUSE: block bytes
+        FUSE->>FUSE: block_geometry() spans overlapping [offset, offset+size)
-        else Block in stream ring cache
+        loop For each span
-            FUSE->>Ring: get(block_idx)
+            alt Span in stream ring
                FUSE->>Ring: get(span)
                Ring-->>FUSE: block bytes
-        else Block Cache Miss
+            else Span in block cache
-            FUSE->>API: download_range(offset, len)
+                FUSE->>Cache: read_block(span)
                Cache-->>FUSE: block bytes
            else Miss
                FUSE->>API: RevisionReader.read_at(span)
                API-->>FUSE: decrypted block bytes
-            alt caching_enabled
+                opt Not a large unpinned video
-                FUSE->>Cache: store_block(block_idx)
+                    FUSE->>Cache: store_block(span)
-            else streaming_only
+                end
-                FUSE->>Ring: insert(block_idx)
+                FUSE->>Ring: insert(span)
            end
        end
    end
@@ -220,6 +254,35 @@ graph TD
 5. **Depth-Ascending Batching:** Folders are processed first to ensure hierarchies exist before files are placed. Work is executed concurrently up to a set limit.
 6. **Safety Gate and Settle:** Destructive plans are rejected when the scan is incomplete. Total-wipe protection applies to every non-empty baseline, including a single-entry folder. On success, baseline entries are upserted, timestamps updated, and any pending mode switches (e.g. going on-demand) are evaluated. Failed local deletion or conflict preservation retains the previous baseline and prevents remote content from overwriting the local source.
 ### Conflict Copies
 A conflict keeps both versions. The local file is renamed to
 `{stem} (sync-conflict {unix_secs}).{ext}` (with `-1`, `-2`, … appended to the timestamp when the
 name is taken) and the remote version is downloaded under the original name. The conflict sweep
 (§7) later trashes copies proven byte-identical to their sibling when `conflict_sweep` is
 `enforce`.
 ### Devices and the Machine Profile
 Synced folders live under a *device*: a per-computer root in Proton Drive. `Core::ensure_device`
 decides which device this machine is: the adopted `device_uid` from `config.json` when set,
 otherwise a Linux device whose name equals the hostname, otherwise a newly registered one. An
 adopted UID that no longer exists is reported, never silently replaced.
 Because the local database does not survive a lost machine, the daemon backs up the machine's
 arrangement to `<device root>/.proton-drive-linux/profile.json` (`pdfs_core::profile`): each synced
 folder's remote UID, local path and mode, the pins, and the ignore patterns. It goes up the normal
 upload path and so is end-to-end encrypted like any other file. Mutating requests call
 `Core::touch_profile`, which coalesces a burst of changes into one upload. `PROFILE_VERSION`
 guards the format: a reader refuses a profile from a newer version instead of applying part of it.
 Restore (`ListRestorableFolders`, `RestoreSyncFolders`, and the `Device` variants for another
 computer) lists the device root's folders, proposes a local path from the profile when its parent
 exists on this machine and `~/<name>` otherwise, and on confirmation adds a `sync_folder` row per
 folder bound to the remote UID. The download is an ordinary reconcile against an empty baseline;
 on-demand mode is applied through the normal mode-switch request. The user guide is
 [RECOVERY.md](RECOVERY.md).
 ---
 ## 6. IPC Socket Protocol
@@ -232,7 +295,31 @@ The CLI and GUI front-ends do not access database files or make network calls di
 * **Control Protocol:**
  * Client sends a single JSON line (`Request`).
  * Daemon parses, handles the request, and replies with a single JSON line (`Response`).
-  * Timeout durations are separated: **2 seconds** for writes (avoids hangs on defunct sockets) and **120 seconds** for reads (accommodates heavy transfers).
+  * Timeout durations are separated: **2 seconds** for writes (avoids hangs on defunct sockets) and **120 seconds** for reads (accommodates heavy transfers). Status polls use a 5-second read timeout, which is what the app reports as "Not responding".
 * **Errors:** A failed request replies with `Response::Error { message, kind }`. The `kind` is machine-readable, and `pdfs --json` passes it through.
 * **Compatibility:** After an upgrade, the old daemon keeps running until the service restarts, so front ends must cope with a daemon that does not know a newer request. It answers such a request with an error instead of dropping the connection. New fields are added with `#[serde(default)]`, and new variants get a separate request rather than an optional field an old daemon would ignore.
 ### Push Events
 Since 2.5.0 the front ends do not poll. The app and the tray each send `Request::Subscribe` once
 and keep the connection open; the daemon then streams one `Event` per line:
 | Event | Sent when | Payload |
 |---|---|---|
 | `Status` | On subscribe, and whenever any status field changes | A full `Response::Status` |
 | `Transfers` | On subscribe, and whenever the transfer snapshot changes | Transfers and background jobs |
 | `Changed { topics }` | Something a page shows changed | `Topic`s to re-read: `files`, `photos`, `trash`, `shares`, `devices`, `locations`, `queue`, `conflicts`, `activity` |
 | `Heartbeat` | Every 10 seconds of silence | — |
 Code that changes state publishes its topics to the `EventHub` (`crates/pdfs-fuse/src/events.rs`);
 the control handler maps each mutating request to the topics it touches. Changes within 150 ms
 of each other are coalesced into one event. A new subscription is told every topic changed, so it
 catches up on anything it missed. At most 8 subscriptions are served at once.
 On the client side, `pdfs_core::control::follow` reconnects across daemon restarts with backoff
 and treats 25 seconds without a line as a stuck daemon. A daemon older than 2.5.0 answers
 `Subscribe` with an error; `follow` then falls back to polling status and transfers, so the front
 end sees the same events, only later.
 ### Unified Search
@@ -246,12 +333,18 @@ The prompt is a single-instance GTK application. It retains and hides its window
 The background daemon relies on the following thread topology:
-1. **Main Thread / Dispatch Loop:** Blocks on `fuser::Session` loop. Reads kernel FUSE events and hands off network-bound VFS work to the FUSE workers pool.
+1. **Main Thread / Dispatch Loop:** Blocks on `fuser::Session` loop. Reads kernel FUSE events and hands off network-bound VFS work to the FUSE workers pool. Each on-demand synced folder is a further FUSE session with its own dispatch loop and its own inode space (`State`).
 2. **FUSE Workers Pool (11 threads, two lanes):** Bounded thread pool handling network operations. Split into 3 threads reserved for metadata (`lookup`, `readdir`) and 8 general threads that serve transfers (block reads) and fall back to metadata when no transfer is waiting. Reserved threads never accept a transfer — that is what keeps a directory listing from queuing behind saturated downloads (audit A6).
-3. **IPC listener Thread:** Listens on the Unix socket and admits at most 64 concurrent, timeout-bound handlers for front-end status/configuration requests.
+3. **Control Threads (`pdfs-control`):** Listen on the Unix socket and admit at most 64 concurrent, timeout-bound handlers. Long-lived subscriptions hold one handler each, up to 8 (see §6).
-4. **Sync Engine Loop Thread:** Serializes sync runs. Wakes on debounced local inotify filesystem changes, remote polling intervals, or manual user requests.
+4. **Sync Engine Threads (`pdfs-sync`, `pdfs-sync-poll`):** Serialize sync passes. Wake on debounced inotify changes, the periodic poll, remote events, or a user request.
-5. **Drain Queue Worker Thread:** Processes staged writes (`PendingOp`) sequentially, uploading revisions and retrying with exponential backoff on failures.
+5. **Drain Workers (`pdfs-drain-0` … `pdfs-drain-2`):** `DRAIN_WORKERS = 3` threads share the queue of staged writes and changes (`PendingOp`), with per-node ordering (§4), and retry failures with exponential backoff. Worker 0 also runs the queue's idle chores.
 6. **Conflict Sweep Thread (`pdfs-conflict-sweep`, optional):** Reconciles leftover `(sync-conflict …)` copies — 30 s warmup, then one pass every 5 minutes. A copy proven identical to its live sibling (equal size **and** equal `content_sha1`) is redundant; anything it cannot prove identical is surfaced to the activity feed and left alone. Governed by `AppConfig.conflict_sweep` / `PDFS_CONFLICT_SWEEP` (`SweepMode`): **report-only by default**, `off` skips the thread entirely, and only `enforce` lets it trash. Because it deletes, the enforcing path re-verifies revision id, size, digest, name, parent, queued ops and open handles immediately before acting rather than trusting its own pass-start snapshot. See `docs/BUGS.md` B69 and B71.
 7. **Remote Event Tasks (Tokio):** `run_event_sync` follows Proton's event stream for the Drive volume and applies each change to every mounted inode space, invalidating kernel entries as it goes. The cursor is persisted after every batch, so changes made while the daemon was stopped are applied on the next start. `run_photos_event_sync` follows the photos volume separately; it only drops gallery rows or the timeline's freshness stamp, since photos are not part of the mount.
 8. **Event Sampler (`pdfs-events`):** Publishes status, transfer and sync-progress changes to subscribed front-ends (§6).
 9. **Supervisor (`pdfs-supervisor`):** Logs workers that hold one job for minutes, a queue that stops draining and control requests that never return; samples memory; and pings the systemd watchdog only after a real round trip over the control socket, so a hung daemon is restarted (`WatchdogSec=120`). `pdfs diagnostics` reports the same data on demand.
 10. **Smaller helpers:** `pdfs-online-probe` (connectivity), `pdfs-localindex` (home-directory index for the search prompt), `pdfs-pause` (ends a timed pause), `pdfs-conflict-sweep`, and `pdfs-similar` (duplicate-photo detection, on request).
 Every long-lived loop waits on one shared `Shutdown` signal instead of sleeping, so an in-process remount joins the old generation of threads instead of leaking it (`docs/BUGS.md` B44).
 ---
@@ -377,3 +470,113 @@ sequenceDiagram
   This ensures compatibility with all versions of Proton's client verification scripts.
 3. **SRP Handshake Reset:** Because a gated login burns the SRP handshake on the API side, the client cannot simply resume the previous request. Instead, `auth::login_interactive` restarts the SRP process from scratch with the verification credentials attached, keeping the complex handshake details isolated from the front-end.
 4. **CLI Fallback:** Since the CLI has no native web browser engine, hitting the CAPTCHA gate fails immediately with a user-friendly message directing the user to sign in once via the GUI (`pdfs-app`) to persist the authenticated session keys to the system keyring.
 ---
 ## 10. Feature Design Notes
 Notes on individual features whose code is shaped by a constraint that is not obvious from the
 code alone.
 ### File Version History
 **Files**: [`revisions.rs`](../crates/pdfs-fuse/src/revisions.rs), [`control.rs`](../crates/pdfs-core/src/control.rs), [`versions_dialog.rs`](../crates/pdfs-gui/src/app/widgets/versions_dialog.rs)
 Proton Drive keeps every revision a client committed; the daemon only ever addressed the active one, so a file overwritten by a sync pass could be recovered only from whatever the local `recovery/` directory happened to hold.
 The control protocol gained `ListRevisions` / `RestoreRevision` / `DeleteRevision` / `SaveRevisionAs` (each with a `…ByUid` twin for nodes the primary mount cannot name), the CLI gained `pdfs versions list|restore|save|rm`, and the browser's details pane gained a **Versions** button opening a per-file dialog.
 Three properties that shape the code:
 - **A restore is server-side and asynchronous.** No content crosses the wire and nothing enters the drain queue; the server answers 202 and swaps the active revision in the background, so the daemon evicts the file's cached blocks and open readers rather than describing the new state, and the UI wording promises the request, not the result.
 - **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 Favorites
 **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 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.
 ### Justified Gallery, Gallery Delete
 **Files**: [`photos.rs`](../crates/pdfs-gui/src/app/pages/photos.rs), [`photo_viewer.rs`](../crates/pdfs-gui/src/app/pages/photo_viewer.rs), [`photos.rs`](../crates/pdfs-fuse/src/photos.rs), [`background.rs`](../crates/pdfs-fuse/src/background.rs)
 The gallery lays each day out in justified rows (`justify_rows` / `plan_rows` / `fit_row`): photos are taken in capture order until their summed aspect ratio no longer fits the target row height, and the row is then scaled so it ends exactly on the content width. A tile is therefore its own photo's shape, and `ContentFit::Contain` has nothing left to crop. The last row of a day is left at the target height rather than stretched, because a day holding two photos is a short day, not a layout fault.
 - **Ratios that are not known yet.** `PhotoItem::ratio` is persisted, but a photo that has never been decoded has none. Those are laid out square and remembered in `assumed_ratios`; when a decode proves the real shape the day re-flows on the existing debounce timer, so a screenful of decodes costs one re-flow rather than one per photo. Ratios are clamped to 0.4–3.0 so a single panorama cannot decide what a row looks like.
 - **Thumbnails survive recycling.** A reply for a tile that has already been re-bound still lands in the texture cache, which is an LRU of 1500 textures keyed by uid, and the rows just outside the realised range are prefetched in the scroll direction.
 - **Delete is uid-addressed.** The photos volume is not in the FUSE mount, so the path-based `Request::Delete` cannot reach it. `Request::TrashNodes { uids }` trashes through the SDK and answers `Response::Trashed { trashed, failed }`; the daemon then drops those rows with `Db::photos_delete` (album membership included) so the gallery does not wait for a timeline refresh. The GUI removes the tiles optimistically with an Undo toast and puts back anything the server refused.
 - **Remote deletions arrive on their own.** The Drive volume and the photos volume have separate event streams, so `run_photos_event_sync` polls the photos volume with its own cursor (`photos_event_cursor` in the state table). Trash and delete events remove rows; anything else only invalidates freshness, because there is no inode space to converge on this volume. Together with a 60 s `TIMELINE_TTL` and a `RefreshScope::Photos` that now awaits the refresh, a photo deleted on a phone leaves the grid in about ten seconds.
 ### RAW + JPEG Grouping
 **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 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.
 - **What is grouped and what is not.** `photos_page`, `photos_months` and `photos_counts` count groups, except on the Raw tab, which lists files. Album pages are never grouped: an album is a list someone made. The relation is learned-and-kept like `media_type`, so a refresh that could not resolve a node does not break a group up.
 - **Deleting.** `Core::trash_photos` expands each uid to its group before trashing, because the grid shows the shot as one tile — leaving the RAW behind would put the photo back on the Raw tab and nowhere else. The GUI's confirmation names the file count.
 - **The other files.** `Request::PhotoGroup { uid }` answers with the group's members as ordinary `PhotoItem`s, which is what the lightbox's switch steps through.
 ### Persistent SDK Entity Cache
 **Files**: [`sdkcache.rs`](../crates/pdfs-core/src/sdkcache.rs), [`auth.rs`](../crates/pdfs-core/src/auth.rs), [`background.rs`](../crates/pdfs-fuse/src/background.rs)
 The SDK's Drive entity cache (decrypted node metadata: name, size, parent, signing share) defaulted to memory, so every daemon restart re-fetched and re-decrypted the tree the previous run had already walked. It is now backed by SQLite.
 - **Its own file** (`sdk_cache.db` in the state directory), not `cache.db`: the daemon's `Db` is one `Mutex<Connection>` shared by every FUSE thread and the control socket, and this traffic is frequent, small and entirely reconstructible. A separate file also means no schema migration — the store can be deleted at any time.
 - **Encrypted at rest** by wrapping it in the SDK's `EncryptedCacheRepository`, keyed by the mailbox password. A password change reads as a cold cache (the SDK treats an undecryptable entry as a miss and clears the store), not as an error.
 - **Staleness** is closed by the event loop, which already replays from a persisted cursor and calls `invalidate_caches_for_event` for every event — including those raised while the daemon was down. The one case with no trail is a *seeded* cursor (first-ever mount, or a lost cursor), where the seed path now clears the store instead of trusting it. `auth::logout` removes the file.
 Needed a small additive SDK change (`ProtonDriveClient::with_entity_repository`, 0.5.1): `with_entity_cache` is a constructor and so could not be combined with `with_key_salts`, which the daemon requires.
 ### Per-node Batch Outcomes
 **File**: [`batch.rs`](../crates/pdfs-core/src/batch.rs)
 SDK 0.5.0 made `trash_nodes` / `restore_nodes` / `delete_nodes` report one outcome per node instead of failing the whole call (mirroring upstream's streamed `NodeActionResult`). `pdfs_core::batch::into_unit` collapses the single-node calls back to a `Result`; `batch::split` handles a collected batch.
 A restore is expanded before it is sent (`expand_restore`, `pdfs-fuse/src/lib.rs`): the persisted trash listing carries each row's `parent_uid` (schema 29), so a restore takes the connected piece of the trashed tree — every trashed descendant of what was asked for, and every trashed ancestor above it — and sends it shallowest wave first, because the server cannot put a node back under a parent that is still trashed. A uid the listing does not know about (it is materialised in chunks, and can be stale) is restored on its own rather than dropped.
 The trash view's restore and permanent-delete use the SDK's **streaming** variants (`restore_nodes_streaming` / `delete_nodes_streaming`) and apply local state per node as each batch lands rather than after the last one. For a permanent delete — which is irreversible — that means a daemon interrupted mid-batch has forgotten exactly the nodes the server destroyed, no more and no fewer. Both report per-node failures and count only what actually succeeded; only a batch where nothing succeeded is an error.
 ### Moves Between Locations
 **Files**: [`relocate.rs`](../crates/pdfs-fuse/src/relocate.rs), [`control.rs`](../crates/pdfs-fuse/src/control.rs), [`browser.rs`](../crates/pdfs-gui/src/app/pages/browser.rs)
 The primary mount and every on-demand folder are separate FUSE sessions, and a mirror folder has no session at all. The kernel answers `rename(2)` between two mounts with `EXDEV` before the daemon hears of it, so `mv` copies and deletes. On Proton Drive the same move is one `move_node`, because My files and this device's folders are on the main volume.
 `Request::Move` with two absolute paths is therefore resolved by `Core::move_between` against every location: a live mount through `rooted_at`, otherwise the mirror folder with the longest `local_path` prefix, whose uids come from the `sync_entry` baseline. Two paths in one inode space still go to `move_to`. Relative paths keep their old meaning.
 - **Nothing that exists only on this disk may be lost.** A mounted source is refused while it or anything under it has a queued op or a file open for writing. A mirror source is refused unless every file under it matches its baseline and every baseline row still has its file (`mirror_subtree_unsynced`); ignored names and symlinks count as unsynced, because the local copy is removed after the move.
 - **Mirror to mirror renames along.** The local copy is renamed first, with `RENAME_NOREPLACE` so nothing that appeared at the destination meanwhile is overwritten, and its baseline rows are moved with `sync_entries_move`, so neither folder's next pass has anything to do. If `move_node` fails, the rename is undone. `EXDEV` between two filesystems falls back to the check above, then drops the source copy.
 - **A dropped mirror copy is checked twice.** The check runs again just before the source copy is deleted. A file written into it during the move keeps the whole copy; its baseline is gone, so the next pass uploads it as new.
 - **Sync passes are held off.** Every mirror folder involved is locked through `sync_lock`, by ascending id, with a five-second bound. A folder that is still busy is reported rather than waited on.
 - **The local side is levelled afterwards.** A mounted source forgets the node in every inode space and notifies the kernel. A mounted destination has its listing cleared. A mirror destination that received nothing locally gets a reconcile, which downloads the node. That download first asks `ContentCache::copy_cached_to` for the file: a whole cached blob, or every block of it, is copied into place instead of fetched, so a move out of an on-demand folder costs no traffic for what was already opened there.
 ### Open-for-Write Deferral for Mirror Sync
 **File**: [`sync.rs`](../crates/pdfs-fuse/src/sync.rs)
 The mirror folder sync engine now defers uploading any file that is currently held open for writing by another process, matching the guarantee the FUSE mount path already provides (where uploads are deferred until `close(fd)`).
 **Problem**: Previously, the mirror sync path relied solely on a 2-second trailing-edge debounce (with a 30-second ceiling) to avoid uploading files mid-write. This was insufficient for slow continuous writers (e.g., database dumps, large exports, or editors that keep files open for extended periods), which could have their incomplete state uploaded as a real revision.
 **Solution**: Before each reconcile pass, the sync engine scans `/proc/*/fd` once to build a set of canonical paths within the sync root that any process holds open for writing (`O_WRONLY` or `O_RDWR`). Files in this set are:
 - **Kept in the local walk** — so they are not misclassified as deletions
 - **Treated as unchanged** — so no upload is queued for them
 - **Counted as `deferred`** — so the activity summary reports them (e.g., "3 uploaded, 1 deferred (open for write)")
 - **Picked up on the next pass** — after the writer has closed the file
 **How it works**:
 1. `open_for_write_set(root)` reads `/proc/*/fd` → `readlink` for each fd → prefix-checks against the sync root → reads `/proc/<pid>/fdinfo/<n>` to check the `flags:` line's low two bits (O_ACCMODE)
 2. `walk_local` sets `LocalItem.open_for_write = true` for matching files
 3. Both `do_reconcile` and `push_pass` skip upload classification for flagged files
 4. `Outcome.deferred` tracks the count for the activity summary
 **Performance**: The `/proc` scan completes in low single-digit milliseconds on a typical desktop. Only fds whose `readlink` target falls under the sync root incur the `fdinfo` read.
 **Tests added**: 8 unit tests covering `is_write_mode` parsing of various fdinfo flag combinations, and `Outcome` summary formatting with deferred counts.
 | Sync Path | Open-for-write protection | Mechanism |
 |---|---|---|
 | FUSE mount | Yes | Upload deferred until `close(fd)` |
 | Mirror folders | Yes | `/proc/*/fd` scan per reconcile pass |
@@ -12,6 +12,334 @@ Conventions:
 ---
 ## B111 — Renaming a file back right after renaming it fails with EIO
 **Status:** Fixed (unverified).
 **Found:** 2026-09-29, by the acceptance case "unusual but legal names", on My files and on the
 on-demand folder. The case renames each file to `renamed-N` and back at once. One rename back per
 run failed with `EIO`, and the journal showed `rename failed ... proton api error
 InvalidRequirements (http 422): This file or folder was out of date, rename failed.`
 **Where:** every remote rename: `serve_rename` in `crates/pdfs-fuse/src/filesystem.rs`,
 `drain_rename_in_place` in `crates/pdfs-fuse/src/drain.rs`, and the control `rename` in
 `crates/pdfs-fuse/src/lib.rs`.
 **Cause.** The SDK's `rename_node` reads the node's details from the server and sends its current
 name hash as `OriginalHash`. Right after a rename of the same node, that read can still return the
 old hash. Drive then refuses the request as out of date. The daemon reported this at once as
 `EIO`, although the same request succeeds a moment later.
 **Fix.** All remote renames go through `Core::rename_remote`. It retries a rename that fails with
 `InvalidRequirements` up to 20 times, half a second apart, the same window the move after a
 rename already uses. Any other error still returns at once.
 ## B110 — A read that settles a provisional size deadlocks on its own page lock
 **Status:** Fixed (unverified).
 **Found:** 2026-09-29, by the acceptance case "application workloads", which timed out on My
 files and on the on-demand folder on a fast network. The journal showed `a fuse worker has held
 the same job for a long time worker=pdfs-fuse-8 job=read` growing past 700 s with no network
 error. `/proc/<pid>/task/*/wchan` put that worker, and one more, in `__folio_lock`, while the
 daemon had no file on any mount open.
 **Where:** `crates/pdfs-fuse/src/lib.rs` (`Core::apply_size_upgrade`).
 **Cause.** B100 made `read` settle a provisional size before it fetches, through
 `resolve_provisional_size` and `apply_size_upgrade`. That function tells the kernel about the new
 size with `inval_inode(ino, 0, 0)`, which also drops the file's page cache. The kernel holds the
 page lock of the read being served until the daemon replies. The invalidation waits for the same
 lock, on the thread that has to send the reply, so neither ever finishes. The process that
 issued the read hangs, and so does anything else that touches those pages.
 **Fix.** The size upgrade invalidates attributes only (`offset -1`). A size upgrade does not
 change content, so the page cache has nothing stale to drop. A daemon already stuck this way
 needs a restart.
 ## B109 — A re-listing shrinks a file that is open for writing, and SQLite reads it as malformed
 **Status:** Fixed (unverified).
 **Found:** 2026-09-29, by the acceptance case "application workloads" on My files. It failed
 several runs in a row with `database disk image is malformed` at the `SELECT COUNT(*)` right
 after a 500-row insert, and the daemon logged nothing. A diagnosis added to the case showed
 `workload.db` at 0 bytes while SQLite still held it open with 16 KiB written.
 **Where:** `crates/pdfs-fuse/src/state.rs` (`State::keep_open_write_size`, called from
 `intern_mem_with_access`), the local-uid remap in `crates/pdfs-fuse/src/drain.rs`, and the size
 upgrade in `crates/pdfs-fuse/src/lib.rs`.
 **Cause.** An online create seals an empty file on Drive. Until the last close, the written
 bytes live only in the open handle, and the entry's size is the handle's. Any re-listing of the
 parent re-interned the node from Drive, which replaced that size with 0. Such re-listings come
 from event echoes and sibling creates, and SQLite's journal is one. The kernel then got size 0
 from `getattr` and ended SQLite's reads at EOF without asking the daemon, so the database read
 back as empty pages. Queued writes were already protected (B11); open handles were not.
 **Fix.** A node that has an open write handle keeps the handle's size and its local mtime when
 a listing, a size upgrade or a create landing replaces its entry. After the last close, the
 queued write takes over as before.
 ## B108 — A file deleted during a mirror pass puts the sync folder in `error`
 **Status:** Fixed (unverified).
 **Found:** 2026-09-29, by the account run of `scripts/fuse-acceptance.sh --quick`. It stopped with
 `sync folder … entered error` before the managed-move phase. At the same time the journal
 showed `sync: step failed; continuing error=open …/workloads/tree.tar: No such file or directory`
 for eleven files. The contract suite had removed its `workloads` tree while the mirror pass
 was still uploading it.
 **Where:** `crates/pdfs-fuse/src/sync.rs` (`upload_new`, `upload_revision`, `open_to_upload`).
 **Cause.** A pass plans its uploads from a scan and runs them later. When a planned file was
 deleted in between, opening it failed with `NotFound`. That counted as a failed step, so the pass
 ended in `error` and logged "item(s) failed; will retry" for files nobody wanted any more.
 **Fix.** An upload whose local file is gone when it starts is skipped (`Applied::Vanished`) and
 does not count as an error. The next pass sees the deletion and handles it like any other.
 Other open failures are still errors.
 ## B107 — One read on a stalled connection hangs the reading program for half an hour
 **Status:** Fixed (unverified).
 **Found:** 2026-09-29, by the acceptance case "application workloads" on My files, which hit its
 180 s timeout. The journal showed `a fuse worker has held the same job for a long time
 worker=pdfs-fuse-10 job=read` from `age_secs=124` up to `age_secs=2059`. Event polls in the
 same window failed with `HTTP transport error` after 91-103 s.
 **Where:** `crates/pdfs-fuse/src/reads.rs` (`Core::read_range_remote`, `READ_FETCH_TIMEOUT`).
 **Cause.** The SDK bounds each request (30 s for the API, 300 s for a storage block) and retries
 failed ones, but nothing bounds a whole read. A read can need a block table, several blocks and a
 repair, each with its own retries. On a connection that stalled without dropping, one `read`
 held its FUSE worker for about 34 minutes, and the program that issued it could not be
 interrupted for that time.
 **Fix.** The network part of a read now has a 120 s deadline. When it passes, the read fails
 with `EIO`, the file's revision reader is dropped so the next read starts fresh, and blocks that
 already arrived stay cached for the retry. A single read is at most a few 4 MiB blocks, so this
 only fails a read on a link slower than about 70 KB/s. A block repair that has to download a
 large file whole can also hit the deadline on a slow link; pinning the file avoids that.
 The first version of this fix built the timer on the FUSE worker thread, outside the runtime.
 Every read that went to the network panicked with `there is no reactor running`, and the kernel
 got `EIO`. The next account run failed 11 cases on My files this way. The timer is now built
 inside `block_on`, and a unit test runs that pattern from a thread without a runtime.
 ---
 ## B106 — Saving over a file that was just read fails with "already exists"
 **Status:** Fixed (unverified).
 **Found:** 2026-09-29, by the acceptance case "application workloads" on an on-demand folder,
 after installing the B104 fix: `OSError: [Errno 5]` from `os.replace` in the editor-save loop,
 at the third save. The journal had `rename failed … AlreadyExists (http 422): A file or folder
 with name already exists` from `rename_node`.
 **Where:** `crates/pdfs-fuse/src/lib.rs` (`Core::remove_replaced`,
 `Core::withdraw_queued_ops`), `crates/pdfs-fuse/src/filesystem.rs` (`trash_child`,
 `finish_release`), `crates/pdfs-fuse/src/drain.rs` (`Core::drain_revision`).
 **Cause.** A regression from B104. The save loop writes a temporary file, renames it over the
 document, and reads the document back. `close()` returns before the daemon sees the release, so
 at the next save the replaced file still counts as open. B104 then left its queued upload in
 the queue until the final close, and the drain could send it after the file had been trashed.
 The next rename onto the name was refused. `unlink` of an open file had kept its queued upload
 the same way.
 **Fix.** A file trashed or replaced while open now loses its queued ops at once, and an upload
 already under way is cancelled. Only the staged bytes stay, because the open handle reads them,
 and they are deleted at the final close. A drain worker that claimed the op before it was
 withdrawn checks that the op still exists before it sends any bytes.
 ---
 ## B105 — A file deleted while its upload is in flight comes back as a conflict copy
 **Status:** Fixed (unverified).
 **Found:** 2026-09-29, in the daemon journal of an acceptance run on the account. During the
 SQLite workload two `queued write conflicts; keeping a conflict copy` warnings named files called
 `recovered-XrPUSW5W` and `recovered-JbZM_pWK`, with the reason `the file was trashed remotely`.
 Each was followed by `pending upload failed; will retry` and `No such file or directory`.
 **Where:** `crates/pdfs-fuse/src/drain.rs` (`Core::drain_revision`),
 `crates/pdfs-core/src/db/ops.rs` (`Db::op_exists`).
 **Cause.** SQLite writes, syncs and deletes its journal file within milliseconds. The sync
 queues an upload of the journal. The delete trashes the node and drops that queued upload, but a
 drain worker that already holds the op carries on. It then asks the server about the node,
 finds it trashed, and treats the trash as another device's change: it tries to upload the bytes
 as a conflict copy. The tree has already forgotten the node, so the copy is named `recovered-…`
 and placed in the Drive root. Here the blob was already gone and the attempt failed, but with
 the blob still on disk the copy would land.
 **Fix.** Before keeping a conflict copy, the drain checks that its op is still queued. When the
 op is gone, the write was withdrawn by the delete, or superseded, while the worker held it, and
 it is dropped.
 ---
 ## B104 — Reading a file that was replaced by a rename fails with `EIO`
 **Status:** Fixed (unverified).
 **Found:** 2026-09-29, by the acceptance case "rename patterns" on My files and on an on-demand
 folder: `OSError: [Errno 5] Input/output error` at
 `os.pread(reader, 64, 0)` after `os.replace(replacement, target)` with `reader` open on `target`.
 The mirror folder, a local disk, passed.
 **Where:** `crates/pdfs-fuse/src/lib.rs` (`Core::remove_replaced`).
 **Cause.** A rename over an existing file first trashes that file, because Drive has no atomic
 replace. That step forgot the replaced inode outright and evicted its cache and reader, even
 when a handle was still open on it. The next read through that handle found no inode and
 failed. `rename(2)`, like `unlink(2)`, keeps a replaced file readable through the handles
 already open on it. The unlink path (`trash_child`) already did this, but the rename path
 did not.
 **Fix.** `remove_replaced` now handles an open victim as `unlink` does. It keeps the inode as
 an unlinked entry, and leaves its cache and reader to the final close. That applies both to a
 node the server knows and to one whose create is still queued. Its queued ops at first also
 waited for the final close; B106 moved them back to the trash.
 ---
 ## B103 — One stuck trash refresh freezes the trash listing until the daemon restarts
 **Status:** Fixed (unverified). The hang itself has not been reproduced on purpose.
 **Found:** 2026-09-29, while timing the acceptance suite's wide-directory case. Its cleanup trashed
 the test folder, then waited for it to show up in the trash so it could delete it permanently. It
 never did. From 06:55 UTC on, every trash listing logged `trash refresh still running; answering
 with what has materialized` and returned the same 362 entries. No `trash refresh: enumerated` line
 followed, so the first server call of the refresh never returned.
 **Where:** `crates/pdfs-fuse/src/lib.rs` (`Core::refresh_trash`, `within_trash_call`).
 **Cause.** Trash refreshes are single-flight: a request joins the refresh already running instead
 of starting another. The refresh awaited its server calls with no deadline, so one call that
 never returned kept the flag set forever. Every later request joined it, waited out its 20 s
 budget, and answered with the stale listing.
 **Fix.** Each server call of a refresh (`enumerate_trash_node_uids`, and each `enumerate_nodes`
 chunk) fails after `TRASH_CALL_TIMEOUT` (120 s). The refresh then ends with an error, clears the
 flag, and the next request starts a fresh one.
 ---
 ## B102 — Removing a folder leaves the queued uploads of the files inside it
 **Status:** Fixed (unverified). No daemon carrying the change has run the acceptance suite yet.
 **Found:** 2026-09-29, after the account run that found B101. Its cleanup removed both test roots
 and reported "nothing left behind", but `pdfs sync queue` still listed two `revision` ops for
 `pdfs-acceptance-…/boundaries/reshaped`, each holding about 8 MiB of staged bytes. They retried
 against the trash forever ("the share has not been writable for 300s").
 **Where:** `crates/pdfs-core/src/db/ops.rs` (`drop_doomed_ops`, used by
 `Db::replace_ops_with_trash` and `Db::delete_ops_for_uid`), `crates/pdfs-fuse/src/lib.rs`
 (`Core::delete`, `Core::release_dropped_ops`).
 **Cause.** Two gaps.
 - **The queue could not see which files a folder holds.** Removing a node dropped the ops for it
  and for anything *queued* beneath it, found through `pending_op.parent_uid`. Only `create` and
  `mkdir` ops carry a parent, so a `revision` of a file that already existed remotely was never
  found, however deep in the removed folder it sat.
 - **`pdfs rm` dropped nothing at all.** The control socket's delete trashed the node remotely but
  left every op queued for it, unlike an unlink through the mount.
 **Fix.** Removal also follows the node tree (`nodes.parent_uid`) and drops the `revision` ops of
 every file below the node, with their blobs, pending entries and in-flight uploads. Queued renames
 below it are kept: one that moved a node into the folder still has to land for the node to go to
 the trash with it. `pdfs rm` now drops the queued ops once the remote trash succeeds. The
 acceptance janitor lists the daemon queue after cleanup and reports any op still naming one of its
 roots as a leftover.
 Regression test: `trashing_a_folder_drops_the_queued_revisions_of_files_below_it`.
 ---
 ## B101 — A shrunk file written past its end gets old bytes back, or fails with `EIO`; a write during a create's upload is lost
 **Status:** Fixed (unverified). No daemon carrying the change has run the acceptance suite yet.
 **Found:** 2026-09-29, by the new acceptance case "block boundaries and overwrites that change
 the block count". It failed with `Input/output error` in My files and in an on-demand folder, every
 time. The journal had `the revision's block table disagrees with the node size ... fsize=8388611
 reader_size=0`, then `pending upload failed; will retry ... gap-fill from base failed: Errno(5)`
 on every retry.
 **Where:** `crates/pdfs-fuse/src/state.rs` (`WriteHandle::record_write`),
 `crates/pdfs-fuse/src/drain.rs` (`Core::drain_local_node`, `Core::retire_create`),
 `crates/pdfs-fuse/src/lib.rs` (`Core::enqueue_staged_write`),
 `crates/pdfs-core/src/db/ops.rs` (`Db::finish_create`).
 **Cause.** Two defects.
 - **The hole of a write past the end was not authored.** A write handle tracks which ranges it
  wrote; everything else below the base size is filled from the base when it is committed. A
  grow through `setattr` marks its new tail as written, but a `pwrite` past the end did not mark
  the hole it leaves. After `ftruncate(fd, 4 MiB)` and `pwrite(fd, data, 4 MiB + 10)`, bytes
  4 MiB to 4 MiB + 10 were refilled from the old base instead of reading as zeros. That silently
  restored truncated bytes. When the base was itself a queued revision the remote did not have
  yet, the fill read a revision of the wrong size, and B84's check failed it: `EIO` on read, and
  a drain that retried forever.
 - **A write that closed while its file's create uploaded was lost.** The create of a new file
  drains on its own, often while the file is still open. A write that closes meanwhile attaches
  its blob to the create's queue row. When the create landed, the drain deleted that row by id,
  so the server kept the older bytes (often an empty file) and nothing was queued to replace
  them. A handle still open after the create landed carried the placeholder uid, found no create
  to attach to, and failed its `close` with `EIO`.
 **Fix.** A write past the end authors the hole (`WriteHandle::record_write`).
 `Db::finish_create` retires a landed create in one transaction: if the row now holds a newer blob
 than the one uploaded, it becomes a revision of the real uid instead of being deleted. The drain
 does this under the `pending` lock, which `enqueue_staged_write` holds from attaching a blob until
 it records the pending entry, and then repoints open write handles to the real uid. A write that
 still finds the create gone waits for its inode's real uid (`Core::landed_uid`) and queues a
 revision against it.
 Regression tests: `a_write_past_the_end_authors_the_hole_it_leaves`,
 `a_write_attached_while_its_create_uploads_becomes_a_revision`,
 `a_create_whose_blob_landed_is_retired`, and the live acceptance cases "block boundaries and
 overwrites that change the block count" (now also read back after the queue drains) and
 `regression B101`.
 ---
 ## B100 — A freshly copied file reads as `EIO` or 53 bytes too big
 **Status:** Fixed (unverified). No daemon carrying the change has read a file with a provisional
 size yet.
 **Found:** 2026-09-29, checking a 222-file copy into `Documents/pi-backup` on 2.7.0. `find -printf
 %s` showed 10 small files 52 to 59 bytes bigger than their originals. `cat` of one of them failed
 with `Input/output error`, and the journal had `the revision's block table disagrees with the
 node size ... fsize=221 reader_size=169` followed by `repair download did not match the node
 size`. The node's DB row and `claimed_size` were correct (169). A few minutes later the same files
 reported the right size and matched the originals byte for byte.
 **Where:** `crates/pdfs-fuse/src/filesystem.rs` (`read`, `serve_open`),
 `crates/pdfs-fuse/src/lib.rs` (`Core::upgrade_sizes`, `Core::run_size_upgrade`).
 **Cause.** Three things together.
 - A listing built from the cheap enumeration (B12) has no `claimed_size`, so a file reports its
  ciphertext size until the size upgrade lands. The upgrade's own documentation said reads were
  unaffected because the revision reader carries its own size.
 - B84 made that untrue. `read_block` now treats a revision that disagrees with the size it was
  given as damage: it repairs from the whole-file download, and when that does not match either,
  it fails the read. With a provisional size the two never match, so every read failed.
 - `getattr` normally settles the size before answering (B14), which kept this rare. But only
  `MAX_SIZE_UPGRADES` (8) folders may upgrade at once, and past that cap `upgrade_sizes` returned
  nothing. The `stat` was answered with the ciphertext size at once, and nothing retried the
  folder until the next `stat`. A recursive walk over many fresh folders goes past the cap.
 A write open had the same fault: its handle started at the provisional size, so the file would
 gain the encryption overhead and reading the base would fail.
 **Fix.** `read` and a write `open` settle a provisional size before using it
 (`Core::resolve_provisional_size`, one node fetch, on the worker that already goes to the
 network). A folder past the cap is now queued instead of dropped. When a running upgrade ends,
 its thread takes over the oldest queued folder, so at most 8 threads still run.
 Regression tests: `a_folder_past_the_cap_is_queued_not_dropped`,
 `a_finished_batch_hands_its_thread_the_oldest_queued_one`. The read and open paths need a live
 mount and have no unit test; the acceptance case `regression B100` covers them on a real mount.
 ---
 ## 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
@@ -11,6 +11,170 @@ scratch (user data in `staging/` and `recovery/` is never touched by this).
 ## [Unreleased]
 ## [2.8.0] — 2026-09-30
 Schema: **35** (unchanged). Requires `proton-drive-rs` **0.7.1**.
 ### Added
 - **`pdfs trash --json`** prints the trash listing as JSON.
 - **The FUSE acceptance suite tests the signed-in account by default.**
  `scripts/fuse-acceptance.sh` with no arguments creates test folders in My files and new
  on-demand and mirror sync folders, runs every case in each, and removes all of it afterwards,
  also on a failure or interrupt. A run that dies is cleaned up by the next one. New cases cover
  block boundaries, unusual names, a deep tree, a wide directory, rename patterns, handle coherency,
  throughput and B100. `--offline-only` runs the account-free suite as before.
 ### Changed
 - **The mount keeps working through a network drop.** When Drive stops answering, the daemon
  now marks itself offline within about 20 seconds instead of failing every call for up to two
  minutes. While offline, creating, renaming and deleting files and folders is queued instead of
  failing with `Input/output error`, folders list from the local cache, and a read that needs
  data from Drive waits up to 30 seconds for the connection. The daemon checks every few seconds
  for the connection to return, then uploads the queued changes. A file whose creation timed
  out but reached Drive anyway is taken over rather than uploaded again as a conflict copy.
 - **A dead connection is noticed sooner.** `proton-drive-rs` 0.7.1 sends TCP keepalives, so a
  connection that died silently fails instead of waiting for its request timeout.
 ### Fixed
 - **Truncating and then writing past the end no longer brings old bytes back.** The gap
  between the new end and the write now reads as zeros, as it should, instead of the file's
  earlier content. When that earlier content had not been uploaded yet, the file failed with
  `Input/output error` and its upload retried forever (B101).
 - **A write made while a new file is first uploading is no longer lost.** Drive could keep an
  empty or older copy of a file written right after it was created, and closing a file held open
  across its first upload could fail (B101).
 - **Removing a folder also cancels the pending uploads of the files inside it.** Before, an
  edit that had not reached Drive yet kept retrying against the trash forever and kept its
  staged copy on disk. `pdfs rm` now also drops what was queued for what it removes (B102).
 - **A program reading a file keeps its data when another program replaces the file.** Saving
  over a file by renaming a new copy onto it (what most editors and `os.replace` do) made
  reads through handles already open on the old file fail with `Input/output error` (B104).
 - **Short-lived files no longer come back as conflict copies.** A file deleted right after it
  was written, such as a SQLite journal, could be uploaded as a `recovered-…` conflict copy in
  the Drive root (B105).
 - **Editors can save over a file several times in a row.** The fix for B104 could leave the
  upload of a replaced file queued, and the next save onto the same name failed with
  `Input/output error` (B106).
 - **Renaming a file back right after renaming it no longer fails.** Drive can briefly call the
  second rename out of date, and the daemon now waits it out instead of returning an I/O error
  (B111).
 - **Reading a freshly listed file no longer hangs.** When a read had to fetch the file's real
  size first, the daemon could wait on the read it was serving, and the program froze until
  the daemon restarted (B110).
 - **Databases and other files kept open while written no longer read back empty.** When the
  folder was listed again while a file was still open, its size dropped to what Drive held,
  often 0 bytes, and SQLite reported `database disk image is malformed` (B109).
 - **Deleting files during a mirror pass no longer marks the folder as failed.** A file removed
  after the pass planned its upload was counted as an error, so the folder showed `error` until
  a later pass (B108).
 - **A read no longer hangs when the connection stalls.** A read that gets no answer from Drive
  within two minutes now fails with `Input/output error` instead of blocking the program for
  as long as half an hour (B107).
 - **The trash no longer freezes after a server call hangs.** Until the daemon restarted, the
  trash kept showing the same entries, and a folder just deleted could not be found there to
  delete permanently (B103).
 - **Freshly listed files read correctly.** A file whose real size had not been fetched yet
  reported its encrypted size, about 53 bytes too big, and reading it failed with
  `Input/output error`. This happened most often right after copying a large folder. Reads and
  write opens now fetch the real size first, and a big folder walk no longer skips size lookups
  (B100).
 ## [2.7.0] — 2026-09-29
 Schema: **35** (unchanged).
 ### Added
 - **Moves between locations without transferring content.** `pdfs move` and the app's
  **Move to…** now take a file or folder from My files into a synced folder, or between two
  synced folders, on-demand or mirrored. The move happens on Proton Drive, so nothing is
  downloaded or uploaded again. `mv` between two locations still copies, because the kernel
  refuses a rename between two mounts. The app's Move dialog lists every location at its top
  level. A move is refused, with the reason, when the source still has changes that are not on
  Proton Drive, when the two locations are on different volumes, or when a synced folder stays
  busy with a sync pass.
 - **`pdfs move` takes several sources.** `pdfs move a b c DEST` moves all three and
  reports each one that could not move.
 - **Moving into a mirrored folder reuses cached content.** A file already cached by
  an online-only folder is copied into place instead of downloaded again.
 ### Changed
 - **New project homepage: [proton-drive.narl.io](https://proton-drive.narl.io).** The About
  dialog's website link, the README, and the package metadata (Cargo, PKGBUILDs, `.deb`,
  `.rpm`) point there. The source code link stays on GitHub.
 ## [2.6.2] — 2026-09-28
 Schema: **35** (unchanged).
 ### Fixed
 - **Photos remembers the Albums and Places views.** Leaving Photos from Albums or Places and
  coming back showed the timeline while the Albums or Places toggle stayed selected. The page
  now reopens on the selected view, and Places keeps its Grid or Map layout.
 - **The Sync page keeps a steady width.** A long file name in Transfers no longer widens the
  page. Overview and Folders now fill the width next to the sidebar.
 ## [2.6.1] — 2026-09-28
 Schema: **35** (unchanged).
 ### Added
 - **`pdfs-prompt --preload`.** Starts the launcher hidden, for session autostart such as
  Hyprland's `exec-once`, so the first shortcut opens it as fast as later ones. It does nothing
  when the launcher is already running.
 ### Fixed
 - **Launcher invocations no longer pile up.** Each shortcut press after the first used to leave
  a `pdfs-prompt` process behind after handing the request to the running launcher. It now exits.
 ## [2.6.0] — 2026-09-28
 The search launcher (`pdfs-prompt`) is rebuilt around a preview pane, and it now looks like the
 app it belongs to.
 Schema: **35** (unchanged).
 ### Added
 - **Launcher preview pane.** The selected result shows a large thumbnail, its type, size,
  modified date, location and whether it is on this computer, with Open (Enter), Show in Folder
  (Ctrl+Enter) and Copy Path (Ctrl+C, or Ctrl+Shift+C while text is selected in the search box).
  Show in Folder selects the file in the file manager through `org.freedesktop.FileManager1`
  and falls back to opening the folder.
 - **Recent files.** With an empty search box, the launcher lists the last files opened from it
  above the pinned ones. Files opened often and lately also rank higher in search results. The
  history lives in `prompt-history.json` in the state directory and forgets local files that
  no longer exist.
 - **Thumbnails in the launcher.** Images show a thumbnail in the result list and the preview,
  from the desktop's thumbnail cache, decoded locally (and written back to that cache), or
  fetched by the daemon for Drive files.
 - **Drag and drop from the launcher.** A result can be dragged into a file manager or another
  application as a file.
 ### Changed
 - **The launcher follows the app's theme.** It uses the system accent colour, light and dark
  style, and the opt-in Proton theme, instead of always pinning Proton purple. Changes to the
  theme or to `open_with` apply the next time the launcher opens.
 - **Launcher layout.** Results are grouped into Recent, Pinned in Proton Drive and Best matches;
  matched characters are bold, and each row shows its sync state, size and age. A click selects
  a row and a double-click opens it; the search box keeps the keyboard focus throughout.
 - **Faster search as you type.** The launcher searches 80 ms after the last keystroke instead
  of 120 ms.
 ### Fixed
 - **The launcher no longer freezes on a stuck mount.** Checking whether a Drive file is in the
  mount runs off the main thread and gives up after 2 seconds, falling back to the daemon.
  Escape cancels a Drive file that is still opening.
 ### Documentation
 - **Rewritten user documentation.** New pages for installation, the user guide, the command-line
  reference, configuration and troubleshooting, and a documentation index in `docs/README.md`.
  The README is shorter and points to them.
 - **Recovery** describes the current restore flow (adopting a computer, `pdfs sync restore`, the
  machine profile) instead of the old manual runbook.
 - **Architecture** covers push events, remote event streams, the revision block geometry, the
  thread layout of 2.5.0 and the machine profile. The development page is now a developer guide,
  and open work moved to `docs/ROADMAP.md`.
 - `scripts/publish-wiki.sh` publishes the user pages to the GitHub wiki.
 ## [2.5.0] — 2026-09-28
 A polish pass over the desktop app: the daemon pushes changes instead of being polled, pages
@@ -320,7 +484,7 @@ Schema: **31** (unchanged).
  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
+  pan by dragging; `0` fits them again. The details panel docks beside the photo instead of 120 ms
  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.
@@ -658,7 +822,7 @@ thumbnail.
  slider for the icon grid, and account storage usage. Zoom resizes the realised grid cells rather
  than rebuilding the model, so dragging the slider does not tear down the selection; the default
  size reproduces the previous fixed 72 px tiles. Capacity stays out of the bar until a real
-  reading lands, and the quota fetch (60 s TTL) now also runs while Files is on screen instead of
+  reading lands, and the quota fetch (60 s TTL) now also runs while Files is on screen instead of 120 ms
  only in Settings.
 - Repository housekeeping: `CONTRIBUTING.md`, `CODE_OF_CONDUCT.md`, `SECURITY.md`, issue and pull
  request templates, a project logo, and workspace crate metadata (`repository`, `homepage`,
@@ -1177,8 +1341,14 @@ 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.8.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v2.8.0
 [2.7.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v2.7.0
 [2.6.2]: https://github.com/narrrl/proton-drive-linux/releases/tag/v2.6.2
 [2.6.1]: https://github.com/narrrl/proton-drive-linux/releases/tag/v2.6.1
 [2.6.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v2.6.0
 [2.5.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v2.5.0
 [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
@@ -0,0 +1,192 @@
 # Command-line reference
 `pdfs` controls the Proton Drive service from a terminal and from scripts. Almost every command
 talks to the running service (`proton-drive.service`); `login`, `logout`, `mount`, `daemon` and
 `diagnose` work without it.
 `pdfs <command> --help` prints the full help of any command. This page groups them by task.
 - [Conventions](#conventions)
 - [Account and service](#account-and-service)
 - [Files](#files)
 - [Available offline](#available-offline)
 - [Synced folders](#synced-folders)
 - [Conflicts](#conflicts)
 - [Computers](#computers)
 - [Trash](#trash)
 - [Versions](#versions)
 - [Sharing](#sharing)
 - [Photos](#photos)
 - [Activity and transfers](#activity-and-transfers)
 - [Maintenance and diagnostics](#maintenance-and-diagnostics)
 - [Scripting with `--json`](#scripting-with---json)
 ## Conventions
 - **Paths** name items in My files. They may be absolute paths inside the Proton Drive folder
  (`~/ProtonDrive/Documents/a.pdf`) or relative to it (`Documents/a.pdf`).
 - **UIDs** identify items that have no path in the mount: photos, trashed items, shared items and
  computers. The listing commands print them.
 - **Exit codes**: `0` on success, non-zero on any failure, including an error reported by the
  service.
 - **Output** is English and stable enough for `grep`; use `--json` where it is available.
 ## Account and service
 | Command | Description |
 |---|---|
 | `pdfs login [-u EMAIL]` | Sign in (password, then a 2FA code if the account has one) and store the session in the system keyring. Restarts the service if it is running. |
 | `pdfs logout` | Remove the stored session. |
 | `pdfs status` | Account, mount, queue and cache state. |
 | `pdfs quota` | Storage used across all Proton products. |
 | `pdfs locations` | Every local place the service occupies: the Proton Drive folder and each synced folder, with mode and state. |
 | `pdfs daemon [MOUNTPOINT]` | Run the service in the foreground: wait for a session, mount, stay mounted. `proton-drive.service` runs this. |
 | `pdfs mount [MOUNTPOINT]` | Mount once and block until unmounted. Defaults to `~/ProtonDrive`. |
 `pdfs login` cannot show a CAPTCHA. If Proton asks for one, sign in with `pdfs-app` instead.
 ## Files
 | Command | Description |
 |---|---|
 | `pdfs ls [PATH]` | List a folder. |
 | `pdfs search QUERY [--in FOLDER] [--limit N]` | Search names in the local index. |
 | `pdfs mkdir PARENT NAME` | Create a folder. |
 | `pdfs rename PATH NEW_NAME` | Rename a file or folder. |
 | `pdfs move PATH... NEW_PARENT` | Move one or more files or folders into another folder. The two may be in different locations (My files, an on-demand or a mirrored synced folder); the move happens on Proton Drive, without downloading or uploading anything. |
 | `pdfs rm PATH` | Move to the Trash. |
 | `pdfs upload SOURCES... [-t FOLDER]` | Upload local files and folders (recursively) in the background. Follow with `pdfs transfers`. |
 | `pdfs refresh [TARGET] [--full]` | Forget a cached listing so the next read fetches it again. `TARGET` is a folder, `trash` or `photos`; `--full` with `photos` re-reads every photo's metadata. |
 Ordinary file tools (`cp`, `mv`, `rsync`, editors) work on the Proton Drive folder directly. These
 commands are for scripts and for cases where the mount is not available.
 ## Available offline
 | Command | Description |
 |---|---|
 | `pdfs pin PATH` | Download a file completely and keep it on this computer. |
 | `pdfs unpin PATH` | Release it back to online only. |
 | `pdfs pins` | List files kept available offline. |
 ## Synced folders
 | Command | Description |
 |---|---|
 | `pdfs sync add PATH` | Back up a local folder under this computer and keep it in sync. |
 | `pdfs sync list` | List synced folders with their IDs and state. |
 | `pdfs sync rm ID [--delete-remote]` | Stop syncing. Local files stay; `--delete-remote` also removes the copy on Proton Drive. |
 | `pdfs sync mode ID mirror\|ondemand` | Switch between a full local copy (`mirror`) and online only (`ondemand`). |
 | `pdfs sync now [ID]` | Start a sync pass now, for all folders or one. |
 | `pdfs sync pause [--for 1h] [--folder ID]` | Pause uploads and synced folders. Reading files keeps working. `--for` ends the pause by itself (`30m`, `1h`, `2d`). |
 | `pdfs sync resume [--folder ID]` | Resume after a pause. |
 | `pdfs sync limit [--up RATE] [--down RATE]` | Cap bandwidth, for example `500K` or `2M` per second. `0` removes a cap. Without options, prints the current caps. |
 | `pdfs sync queue` | List changes that have not reached Proton Drive yet. |
 | `pdfs sync retry [ID]` | Retry one queued operation, or every failed one. |
 | `pdfs sync restore [--device UID] [--yes]` | Re-attach this computer's backed-up folders to local folders and download them. `--device` restores another computer's folders. See [RECOVERY.md](RECOVERY.md). |
 ## Conflicts
 | Command | Description |
 |---|---|
 | `pdfs conflicts` | List `(sync-conflict …)` copies. |
 | `pdfs conflicts resolve PATH --keep original\|copy\|both [--name NAME]` | `original` trashes the copy; `copy` trashes the original and gives the copy its name; `both` renames the copy to `--name`. |
 ## Computers
 | Command | Description |
 |---|---|
 | `pdfs devices list` | List computers registered to the account. |
 | `pdfs devices rename UID NAME` | Rename a computer. |
 | `pdfs devices rm UID` | Remove a computer and its backup from the account. |
 | `pdfs devices adopt UID` | Make this machine continue another computer's backup, for example after a reinstall. `--clear` returns to matching by hostname. |
 ## Trash
 | Command | Description |
 |---|---|
 | `pdfs trash` | List the Trash with the UIDs the next commands take. |
 | `pdfs restore UIDS...` | Put items back where they were. |
 | `pdfs delete-forever UIDS...` | Delete items permanently. |
 | `pdfs empty-trash` | Delete everything in the Trash permanently. |
 ## Versions
 | Command | Description |
 |---|---|
 | `pdfs versions list PATH` | List a file's versions, newest first. |
 | `pdfs versions restore PATH ID` | Make an earlier version current. Runs on the server; nothing is re-uploaded. |
 | `pdfs versions save PATH ID DEST` | Write an earlier version to a local file. Refuses to overwrite `DEST`. |
 | `pdfs versions rm PATH ID` | Delete an earlier version permanently. The current version cannot be deleted. |
 ## Sharing
 | Command | Description |
 |---|---|
 | `pdfs share PATH EMAILS... [--role viewer\|editor\|admin] [--message TEXT]` | Invite people to a file or folder. |
 | `pdfs members PATH` | List members, pending invitations and the public link. |
 | `pdfs share-role PATH ID KIND ROLE` | Change a member's or invitation's role. |
 | `pdfs unshare PATH [ID KIND]` | Stop sharing, or remove one member or invitation. |
 | `pdfs public-link create PATH [--role] [--password] [--expires EPOCH]` | Create a public link. `--expires` takes Unix seconds. |
 | `pdfs public-link remove PATH ID` | Remove a public link. |
 | `pdfs shared` | List what you share. |
 | `pdfs shared-with-me [UID]` | List what others share with you, or the contents of one shared folder. |
 | `pdfs shared-get UID [DEST]` | Download a file shared with you. |
 | `pdfs leave UID` | Leave a share. |
 | `pdfs invitations list\|accept ID\|reject ID` | Manage invitations addressed to you. |
 | `pdfs bookmarks list\|add URL [--password]\|rm TOKEN` | Manage saved public links. |
 ## Photos
 | Command | Description |
 |---|---|
 | `pdfs photos [--limit N] [--offset N] [--favorites]` | List the timeline, newest first. |
 | `pdfs open-photo UID` | Download a photo and print its cached path. |
 | `pdfs favorite UID [--remove]` | Mark or unmark a favorite. |
 | `pdfs albums` | List albums, including those shared with you. |
 | `pdfs album UID` | List an album's photos. |
 | `pdfs new-album NAME` | Create an album and print its UID. |
 | `pdfs rename-album UID NAME` | Rename an album. |
 | `pdfs delete-album UID` | Delete an album. Its photos stay in the timeline. |
 | `pdfs add-to-album UID PHOTOS...` | Add photos to an album. |
 | `pdfs remove-from-album UID PHOTOS...` | Take photos out of an album. |
 | `pdfs import-google-photos ARCHIVES... [--dry-run] [--wait]` | Import a Google Takeout export. Pass every `.zip` of the export. |
 | `pdfs import-status` / `pdfs cancel-import` | Follow or stop a running import. |
 | `pdfs redate-photos [--dry-run] [--from DATE] [--to DATE] [--limit N] [--wait]` | Fix photos filed under their upload day when the file name carries the real date. |
 | `pdfs redate-status` / `pdfs cancel-redate` | Follow or stop a running re-date. |
 ## Activity and transfers
 | Command | Description |
 |---|---|
 | `pdfs activity [-l N]` | Recent activity, newest first. |
 | `pdfs transfers` | Uploads and downloads in progress. |
 ## Maintenance and diagnostics
 | Command | Description |
 |---|---|
 | `pdfs diagnose` | Check the installation and print a report. Works without the service. Exits non-zero if a check fails. |
 | `pdfs diagnostics` | What a running service is doing now: worker threads, queues, requests in flight, memory. For a service that has stopped answering. |
 | `pdfs cache inspect [--deep]` | Database size, reclaimable space, row counts, cache use against the limit. `--deep` also runs SQLite's integrity check (slow). |
 | `pdfs cache vacuum` | Compact the database. Needs free space for a second copy of it while it runs. |
 | `pdfs cache clear` | Delete cached file content. Files kept available offline stay. |
 [TROUBLESHOOTING.md](TROUBLESHOOTING.md) explains when to use each of these.
 ## Scripting with `--json`
 The global `--json` flag makes query commands print JSON: `status`, `ls`, `pins`, `sync list`,
 `devices list`, `locations`, `transfers`, `activity`, `trash` and `cache inspect`. Commands that change
 something keep their human-readable output; check their exit code.
 ```bash
 pdfs --json status | jq -r '.mount.mountpoint'
 pdfs --json sync list | jq -r '.items[] | select(.state != "idle") | .local_path'
 pdfs --json cache inspect | jq '.db_reclaimable_bytes'
 ```
 - The payload is unwrapped: a list is `{"items": [...]}`, never the service's internal message
  name.
 - An error from the service is printed as JSON with a machine-readable `kind` and still exits
  non-zero, so `set -e` and `if pdfs …` behave as expected.
@@ -0,0 +1,201 @@
 # Configuration
 Most settings are in the app under **Preferences**. This page documents the configuration file
 behind them, the settings that exist only there, the environment variables the programs read,
 and where the client keeps its data.
 - [Files and directories](#files-and-directories)
 - [`config.json`](#configjson)
 - [Environment variables](#environment-variables)
 - [The systemd service](#the-systemd-service)
 ## Files and directories
 | Path | Contents |
 |---|---|
 | `~/.config/proton-drive-linux/config.json` | Settings (this page) |
 | `~/.local/state/proton-drive-linux/cache.db` | Metadata database: names, folder tree, sync state, upload queue, photo index |
 | `~/.local/state/proton-drive-linux/sdk_cache.db` | Encrypted cache of Proton Drive metadata. Safe to delete while the service is stopped |
 | `~/.local/state/proton-drive-linux/control.sock` | Socket the app, tray, prompt and CLI use to reach the service |
 | `~/.cache/proton-drive-linux/content/` | File content cache, see below |
 | `~/ProtonDrive` | The Proton Drive folder (default mountpoint) |
 | System keyring | The session. Never written to disk by the client |
 The directories honour `XDG_CONFIG_HOME`, `XDG_STATE_HOME` and `XDG_CACHE_HOME`. They must be real
 directories owned by you with mode `0700`; the service refuses to start otherwise.
 Inside `content/`:
 | Directory | Contents | Safe to delete? |
 |---|---|---|
 | top level, `blocks/`, `thumbs/` | Cached file content and thumbnails | Yes — use `pdfs cache clear` |
 | `scratch/` | Files open for writing right now | **No** |
 | `staging/` | Closed files waiting to upload | **No** — may be the only copy |
 | `recovery/` | Writes rescued after a crash, waiting to be queued | **No** — may be the only copy |
 > [!CAUTION]
 > Never delete `staging/` or `recovery/` by hand. Check `pdfs sync queue` first. Content there has
 > not reached Proton Drive and exists nowhere else.
 Everything in these directories except the keyring is **decrypted**. See
 [ARCHITECTURE.md §8](ARCHITECTURE.md#8-threat-model-what-this-client-writes-to-disk-in-plaintext).
 ## `config.json`
 The file is created with defaults on first start. Every key is optional; a missing key takes its
 default. Edit it while the app is closed, then restart the service
 (`systemctl --user restart proton-drive.service`) for service settings to apply.
 An unreadable file is never overwritten: the programs log an error and run with defaults until you
 fix it.
 ```json
 {
  "mountpoint": "/home/you/ProtonDrive",
  "cache_budget": 10737418240,
  "upload_limit": null,
  "download_limit": 5242880,
  "ignore_patterns": ["node_modules/", "target/", "*.iso"],
  "language": "de",
  "proton_theme": true,
  "online_map": false,
  "tray_hidden": false,
  "files_view": { "list": true, "sort": "modified", "descending": true, "folders_first": true },
  "open_with": {
    "terminal": ["alacritty", "-e"],
    "rules": [{ "match": ["@text"], "command": ["nvim"], "terminal": true }]
  },
  "prompt": { "mode": "fzf", "menu_limit": 50 }
 }
 ```
 ### Reference
 | Key | Type | Default | In the app | Meaning |
 |---|---|---|---|---|
 | `mountpoint` | path | `~/ProtonDrive` | General → Location | Where My files is mounted |
 | `cache_budget` | bytes | 5 GiB | Storage → Cache | Soft limit for cached content. `0` means unlimited. Available-offline files do not count against it |
 | `upload_limit` | bytes/s | none | General → Network | Shared cap for all uploads. `0` or `null` means none |
 | `download_limit` | bytes/s | none | General → Network | Shared cap for all downloads, reads from the mount included |
 | `ignore_patterns` | list | see below | — | Global ignore rules for synced folders |
 | `device_uid` | string | none | Computers → Continue This Backup Here… | The computer this machine continues. Unset means "match by hostname" |
 | `conflict_sweep` | `off` / `report` / `enforce` | `report` | — | See [`conflict_sweep`](#conflict_sweep) |
 | `language` | gettext code | system | General → Appearance | Language of the app, tray and prompt, such as `de` or `pt_BR` |
 | `proton_theme` | bool | follow system | General → Appearance | Proton's colours instead of the system theme |
 | `online_map` | bool | `false` | General → Appearance | Street map for Places from OpenFreeMap |
 | `tray_hidden` | bool | `false` | General → Appearance | Hide the tray icon |
 | `files_view` | object | grid, by name | My files view menu | `list`, `sort` (`name`, `size`, `modified`), `descending`, `folders_first` |
 | `open_with` | object | `xdg-open` | — | See [`open_with`](#open_with) |
 | `prompt` | object | built-in window | — | See [`prompt`](#prompt) |
 `app_version` and `user_agent` identify the client to Proton. Leave them alone.
 ### `ignore_patterns`
 Gitignore-style rules applied to every synced folder, in addition to each folder's own
 `.pdfsignore`. When the key is absent, these defaults apply:
 ```json
 [".git/", ".hg/", ".svn/", "node_modules/", "target/", ".venv/", "__pycache__/",
 "*~", "*.swp", "*.tmp", ".DS_Store", "Thumbs.db"]
 ```
 Set it to `[]` to turn the defaults off. See
 [USER_GUIDE.md](USER_GUIDE.md#excluding-files-with-pdfsignore) for how ignoring behaves.
 ### `conflict_sweep`
 A background task looks for `(sync-conflict …)` copies that are byte-identical to the file they
 were copied from.
 | Value | Behaviour |
 |---|---|
 | `off` | Do not run. |
 | `report` | Log and show what would be removed; remove nothing. **Default.** |
 | `enforce` | Move copies proven identical (same size and SHA-1) to the Trash. |
 `PDFS_CONFLICT_SWEEP` overrides the setting for one run of the service.
 ### `open_with`
 Decides how files picked in the search launcher or the app are opened. Rules are tried in order;
 the first match wins.
 ```json
 {
  "open_with": {
    "terminal": ["alacritty", "-e"],
    "default": ["xdg-open"],
    "rules": [
      { "match": ["@text", "*.rs", "*.toml"], "command": ["nvim"], "terminal": true },
      { "match": ["*.png", "*.jpg"], "command": ["imv"] },
      { "match": ["@document"], "command": ["$EDITOR", "{}"], "terminal": true }
    ]
  }
 }
 ```
 - `match` takes file-name globs (`*.md`, `notes-*.txt`) or the classes `@dir`, `@text`,
  `@document`, `@image`, `@media` and `@any`. Patterns are matched against the name in Drive, not
  against the cached file, which is stored under a content hash.
 - `command` is an argument list, not a shell line. `{}` is replaced by the path; without it the
  path is appended. `$VAR` expands from the environment.
 - `"terminal": true` runs the command inside `terminal`. When `terminal` is unset, the client uses
  `$PDFS_TERMINAL`, then `$TERMINAL`, then the first known terminal on `PATH`, and adds that
  terminal's "run this command" flag for you.
 - `default` replaces `xdg-open` for files no rule matches.
 ### `prompt`
 Settings for `pdfs-prompt`.
 | Key | Default | Meaning |
 |---|---|---|
 | `mode` | `gtk` | Front end used without a flag: `gtk`, `dmenu` or `fzf` |
 | `menu` | first installed of fuzzel, rofi, wofi, tofi, bemenu, dmenu | Launcher for `dmenu` mode, as an argument list. `{prompt}` is replaced by the prompt text; without it, the launcher's own prompt flag is added |
 | `terminal` | first installed of foot, ghostty, kitty, alacritty, wezterm, xterm | Terminal for `fzf` mode. `{cmd}` is replaced by the command; without it, the command is appended |
 | `menu_limit` | `50` | Results shown in `dmenu` and `fzf` mode |
 | `menu_icons` | `true` | File-type icons in launchers that support them |
 ```json
 {
  "prompt": {
    "mode": "dmenu",
    "menu": ["fuzzel", "--dmenu", "--width", "60"],
    "terminal": ["foot", "--app-id=pdfs-prompt", "--"]
  }
 }
 ```
 Command-line flags win over the file: `--gtk`, `--dmenu`, `--fzf` and `--menu`.
 ## Environment variables
 | Variable | Read by | Effect |
 |---|---|---|
 | `RUST_LOG` | all | Log filter, for example `RUST_LOG=debug` or `RUST_LOG=pdfs_fuse=debug,info`. Default `info` |
 | `PDFS_CONFLICT_SWEEP` | service | Overrides `conflict_sweep` (`off`, `report`, `enforce`) |
 | `PDFS_TERMINAL`, `TERMINAL` | app, prompt | Terminal for `open_with` rules with `"terminal": true` |
 | `LANGUAGE`, `LC_ALL`, `LC_MESSAGES`, `LANG` | app, tray, prompt | Interface language when `language` is unset |
 | `PDFS_LOCALEDIR` | app, tray, prompt | Load translations from another directory (development) |
 | `PDFS_STAND_IN_WIDGETS` | app | `1` uses the libadwaita 1.5 fallback widgets on newer systems (development) |
 The acceptance suite has its own `PDFS_ACCEPTANCE_*` variables, listed in [TESTING.md](TESTING.md).
 ## The systemd service
 `proton-drive.service` is a user unit. It restarts the service whenever it exits, restarts it when
 it stops answering for two minutes (`WatchdogSec=120`), and caps its memory at 6 GiB. To change
 the unit without editing the packaged file, use a drop-in:
 ```bash
 systemctl --user edit proton-drive.service
 ```
 ```ini
 [Service]
 Environment=RUST_LOG=pdfs_fuse=debug,info
 Environment=PDFS_CONFLICT_SWEEP=off
 ```
 Logs go to the journal: `journalctl --user -u proton-drive.service -f`.
@@ -1,214 +1,164 @@
-# Development and Verification Status for 1.0
+# Development guide
-This document summarizes the work still pending after the 1.0.0 release branch and records the most important recently completed changes. [`BUGS.md`](BUGS.md) is the authoritative issue ledger; [`TESTING.md`](TESTING.md) defines the acceptance commands.
+How to build, run, debug and release the client from source. Read
 [CONTRIBUTING.md](../CONTRIBUTING.md) for the review rules and [ARCHITECTURE.md](ARCHITECTURE.md)
 for how the pieces fit together.
---
+- [Setup](#setup)
 - [Repository layout](#repository-layout)
 - [Running from source](#running-from-source)
 - [Quality gates](#quality-gates)
 - [Debugging](#debugging)
 - [Common changes](#common-changes)
 - [Releasing](#releasing)
-## 1. Core Feature Roadmap (Horizon Tasks)
+## Setup
 Consolidated from the historical feature roadmap; current bug status lives in [`BUGS.md`](BUGS.md).
-* **Local Cache & Metadata Encryption at Rest (Priority 5 / Horizon 1)**: Encrypt the SQLite database `cache.db` on disk using SQLCipher (`rusqlite` feature `bundled-sqlcipher`), and encrypt raw content cache blocks (`content/blocks/` and `content/scratch/`) using a fast symmetric scheme like AES-GCM or ChaCha20-Poly1305. The encryption key should be derived from the OS Keyring. (The SDK entity cache in `sdk_cache.db` is already encrypted at rest — see *Persistent SDK Entity Cache* below — but `cache.db` and the content cache are not.)
+You need Rust 1.96 or newer and the native development packages listed under
-* **Active Bandwidth Throttling & Traffic Shaping (Horizon 1)**: Add speed governors for daemon uploads and downloads. Support configuration variables `max_upload_rate_kbps` and `max_download_rate_kbps` in `config.json` that can be dynamically adjusted over the Unix control socket.
+[Build dependencies](INSTALL.md#build-dependencies) for your distribution. Then:
 * **Interactive & Policy-Based Conflict Resolution (Horizon 1)**: Implement configurable conflict resolution policies (`rename-local`, `rename-remote`, `prefer-local`, `prefer-remote`, `interactive`). Add a "Conflicts" tab to the GUI to notify the user, block sync, and launch external visual diff tools (like Meld or KDiff3).
 * **Multi-Account / Multi-Profile Support (Horizon 3)**: Enable running multiple profiles concurrently. Support separate configuration namespaces (e.g. `profiles/<profile_name>/`), independent SQLite databases, distinct mount paths (e.g. `~/ProtonDrive/Personal` and `~/ProtonDrive/Work`), and multiple daemon processes.
 * **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 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.
 * **Interactive Terminal UI (TUI) Mode (Horizon 3)**: Implement `pdfs tui` using the `ratatui` crate to show transfer speed, sync status, active transfer queue with progress bars, and scrolling daemon logs.
 * **Shutdown Safety & Write Queue Visibility (Horizon 1 / P4)**: Register systemd inhibitor locks in `pdfs-fuse` when there are outstanding staging writes to prevent shutdown or sleep, pop up warnings when exiting the GUI, and build a blocking `pdfs sync flush` command.
 * **Block-Level Deduplication (Horizon 3)**: Transition to a Content-Addressable block cache where cached blocks are stored on disk by their SHA-256 hash. Map logical ranges in the database: `(node_uid, block_idx) -> block_hash` to avoid storing or downloading identical blocks.
 * **Pre-emptive Sync Debouncing & File System Events (Horizon 3)**: Group filesystem write events on paths and delay sync queue insertion until a quiet period has elapsed (e.g. 5 seconds of inactivity) to prevent thrashing the Proton API.
---
+```bash
 git clone https://github.com/narrrl/proton-drive-linux.git
 cd proton-drive-linux
 cargo build --workspace
 ```
-## 2. Performance, Correctness & Robustness Items
+The GUI builds against libadwaita 1.5, the version in Ubuntu 24.04, and uses newer widgets at run
-Consolidated from the performance and media-streaming audit notes.
+time when the installed library has them (`crates/pdfs-gui/src/compat.rs`).
-* **B6. Debounce the LRU access touch**: Keep last-touch times in memory and flush them in batches (debounce window of 30-60 seconds) to avoid performing a SQLite `UPDATE` to the `cache_entries` table on every cache hit.
+## Repository layout
 * **E12. Client in-flight cap shape**: Address the lock discrepancy between `MAX_CONCURRENT_BLOCK_DOWNLOADS = 10` (per-file) and `DEFAULT_MAX_INFLIGHT_BLOCKS = 12` (global client-wide). Either raise the global cap, lower the per-file window, or dynamically calculate the window to prevent single files from starving concurrent transfers.
 * **Pipeline `enumerate_nodes_detail` (P2.8 / 8)**: Introduce pipelined node enumeration to speed up directory listings.
 * **Local ancestor-chain walk (P3.4 / 4)**: Optimize recursive path lookups where full batching is impossible.
 * **Name Search for Photos/Videos**: Add search by photo/video name (deferred from Phase 3 gallery implementation).
 * **Sequential-Read Prefetch for Media Streaming**: Implement sequential read prefetch for media files to avoid stalls when buffering.
 * **Minor sweep items (Phase F)**:
  * **F1. `StreamRing.tags` Leak**: Clean up tag entries in `StreamRing.tags` when blocks are evicted. Currently, it only shrinks on `drop_node` (revision mismatch), leading to tag accumulation.
  * **F2. Non-saturating bytes subtraction**: Use `saturating_sub` in `lib.rs:382` (`self.bytes -= dropped.len()`) to prevent release mode panics/wrapping if accounting drifts.
  * **F3. Short block yields a short read / EOF**: Address the kernel EOF interpretation on short block reads. Either pad the block or fail loudly rather than silently serving short data.
  * **F4. `stream_readahead` check-then-spawn race**: Prevent duplicate concurrent readahead tasks for the same block. Check-then-spawn is currently racey.
  * **F5. `refresh_blocks` permit lock (SDK)**: Ensure URL refreshing (`refresh_blocks`) does not hold an in-flight block permit, preventing expired URLs from pinning client permits.
  * **F7. Document temporary cache file safety**: Add explanatory comment to `cache.rs:362` explaining why `with_extension("tmp")` is safe there but not in `store_thumbnail`.
---
+| Path | Contents |
 |---|---|
 | `crates/pdfs-core` | Shared library: authentication and keyring (`auth`), configuration (`config`), SQLite schema and queries (`db/`), content cache (`cache`), control protocol (`control`), search scoring, sync ignore rules, Google Takeout parsing, machine profile |
 | `crates/pdfs-fuse` | The daemon: FUSE filesystem, read path (`reads`), write queue (`queue`, `drain`, `upload`), sync engine (`sync/`), remote events (`background`), push events for front ends (`events`), control handlers (`control`), photos, devices, supervisor |
 | `crates/pdfs-cli` | The `pdfs` binary |
 | `crates/pdfs-gui` | `pdfs-app`, `pdfs-tray` and `pdfs-prompt`. Pages in `src/app/pages/`, shared widgets in `src/app/widgets/`, CSS and icons in `resources/` |
 | `po/` | Translation template, catalogs and the scripts that maintain them |
 | `packaging/` | systemd unit, desktop files, icon, PKGBUILD, RPM spec, AUR recipes |
 | `scripts/` | FUSE acceptance suite, map-data generators |
 | `docs/` | This documentation |
-## 3. Open & Unverified Bugs
+The GUI talks to the daemon only through the control socket. Anything a front end needs that the
-Derived from: [`BUGS.md`](BUGS.md)
+daemon does not offer yet is a new request in `pdfs_core::control`, not a database read.
-* **B2. Unattributed Trash Origin**: Investigate why deleted/moved files are occasionally sent to trash instead of vanishing on older rename operations.
+## Running from source
 * **B10. GLib Critical Warning on HUD Close**: Assertion failure `g_list_store_remove: assertion '!g_sequence_iter_is_end (it)' failed` when prompt window closes during active launch (`xdg-open`). Needs investigation under `G_DEBUG=fatal-criticals`.
 * **B15. Empty-but-listed folders and duplicate UIDs**: Investigate folder-identity issues (e.g. duplicate remote folders like `Music` with different UIDs) and how folders obtain `listed = 1` in the database without matching child rows.
 * **B8 (CAPTCHA sign-in bridge)**: Verify a real gated sign-in using Webkit CAPTCHA completion.
 * **Draft Revision Upload loop**: Verify SDK-side deletion and retry logic when a conflicting draft revision exists under the same client UID.
 * **Optimistic Size Loss on Restart**: Verify that pending uploads retain their optimistic sizes across a daemon restart.
 * **B48 — stale listing after unlink**: Session tombstones and authoritative empty listings are implemented; run focused live verification against eventually consistent remote enumeration.
 * **B49–B55 — data-safety fixes**: Conflict preservation, orphan/staging durability, transactional supersession, one-entry wipe protection, and incomplete-scan handling have regression coverage but still require the fault, power-loss, and live mode-matrix cases recorded in `BUGS.md`.
 * **B56–B60 — fail-closed state and IPC fixes**: Future schemas, event cursor advancement, socket limits, private-directory validation, and atomic config saves are implemented. Malformed-schema, database-full, connection-flood, wrong-owner, and concurrent/faulted-save verification remains.
 * **B61 — credential rotation persistence**: Surface and retry keyring persistence failures so a rotated single-use refresh token cannot be lost on restart.
 * **B62–B65 — release assurance**: Clean-install package verification, complete version/protocol identity, recovery sign-off, advisory/license policy, SBOM, provenance, checksums, and signatures remain.
 * **B66–B67 — lifecycle and recovery**: Add queue flush/shutdown protection and explicit device adoption during fresh-state restore.
 * **B68/B78 — profile backup**: the destination is fixed and verified live — `profile.json` now lives in `.proton-drive-linux/` under the device root, since the API refuses file creation at the root itself. What remains from B68 is making backup *health* visible (today a failure is a `WARN` in the log and nothing in the UI) and re-running the replacement-machine restore end to end.
 * **B79 — cross-mount permission classification**: fixed and verified live; the standing guard is the `regression B79` acceptance case. The second-account cases it neighbours (`regression B34`) still cannot run — see below.
---
+The packaged service and a daemon run from source cannot share the same state directory. Stop the
 service before you run your own build:
-## 4. Testing, Verification & Disaster Recovery Drills
+```bash
-Derived from: [`TESTING.md`](TESTING.md) and [`RECOVERY.md`](RECOVERY.md)
+systemctl --user stop proton-drive.service
 RUST_LOG=pdfs_fuse=debug,info cargo run -p pdfs-cli -- daemon
 ```
-* **IPC Memory and Performance Stress Tests (Phase 3)**: Verify memory allocations do not balloon when sending large `UploadPhoto` JSON payloads. Test control socket timeout behaviors under long-running block operations.
+In another terminal:
 * **Fault Injection and Resiliency Tests (Phase 4)**:
  * **Network degradation**: Verify that interrupted uploads leave readable staging buffers and result in clean backoff retries.
  * **Disk full (ENOSPC)**: Verify that write staging and gap-filling report correct errors to FUSE and preserve staged work.
  * **Concurrent reader starvation**: Test that parallel sequential reads do not freeze directory lookups or metadata handlers.
 * **Disaster Recovery Drill (P5 / Phase 5)**: Execute a complete manual disaster recovery test:
  1. Register a device.
  2. Sync a folder and upload data.
  3. Wipe the local state directory and SQLite cache.
  4. Restart the daemon.
  5. Run `pdfs sync restore` and assert the recovered filesystem matches the source byte-for-byte.
 * **Second-account sharing run (mount-architecture.md P7)**: The only outstanding verification for the mount/sharing work. One account covers `context_share_id`, the shared-with-me listing, sharing from device folders and the Locations page — all confirmed. A **second account** is required for the shared-tree rendering under a foreign volume, `accept_invitation`, `update_member_role`, the `regression B34` viewer cases (which skip cleanly today), and above all an **editor-role write into a foreign share**, the only thing that validates `membership_address_for`.
 * **Managed live mode matrix**: Before release, run `scripts/fuse-acceptance.sh --managed-live <empty-a> <empty-b>` with `PDFS_ACCEPTANCE_ONLY` unset. It validates on-demand/on-demand, on-demand/mirror, mirror/on-demand, and mirror/mirror transitions.
 * **Crash-consistency matrix**: Inject failure after scratch/sidecar sync, each staging rename, directory sync, pending-op insert/commit, and source deletion; prove that a complete discoverable copy and either the old or new queue record always survives.
---
+```bash
 cargo run -p pdfs-cli -- status
 po/build.sh target/locale                               # compile translations once
 PDFS_LOCALEDIR=target/locale cargo run -p pdfs-gui --bin pdfs-app
 cargo run -p pdfs-gui --bin pdfs-tray
 cargo run -p pdfs-gui --bin pdfs-prompt -- --fzf
 ```
-## 5. Fixed & Resolved Bugs
+To keep the systemd unit but point it at your build, see
-Derived from: [`BUGS.md`](BUGS.md)
+[INSTALL.md](INSTALL.md#using-a-binary-outside-usrbin).
-### Completely Fixed & Verified
+> [!CAUTION]
-* **B1 — FUSE rename loses the file (data loss)**: In `rename`, the node's database row was deleted while only updating the in-memory state, causing the file to vanish on next listing sync. Fixed by correctly calling `st.invalidate_listing(newparent)` to refresh SQLite cache states.
+> Develop against a test account. The acceptance suite and a buggy daemon can delete or rewrite
-* **B4 — `invalidate_listing` silently skipped non-resident folders**: Folders not loaded in memory were being skipped during listing invalidation, leaving stale cache flags in the DB. Fixed by removing the residency check guard.
+> files in Proton Drive.
 * **B5 — `ls -l` costs a network round trip per file (thumbnail xattr probes)**: File listings triggered blocking network checks for thumbnails on unsupported files. Fixed by caching negative thumbnail results and restricting xattr advertisement to supported image/media files.
 * **B6 — Daemon sets no file modes: `control.sock` is an unguarded authority**: The Unix control socket was created without restricting file permissions, exposing daemon controls to other local users. Fixed by applying proper creation permission masks.
 * **B7 — renamed directory reads as missing until the entry TTL expires**: Kernel cache maps remained stale after a FUSE directory re-anchor. Fixed by proactively sending entry invalidation notifications to the kernel.
 * **B9 — Enter did not open the selected result in the launcher**: Hooked up keyboard execution (Enter key) in `pdfs-prompt` search HUD to launch the selected item using `xdg-open`.
 * **B11 — a file moved while its create is still queued reads as empty**: Reconciling a local rename on a file that had not finished uploading yet uploaded empty blocks. Fixed by carrying over and staging the correct logical file size.
 * **B12 — cold enumeration is slow per entry, and goes superlinear past ~500**: S2K decryption and thumbnail resolution loops were serial. Fixed by parallelizing key derivations and caching metadata.
 * **B13 — `rename` over an existing destination fails instead of replacing it**: Fixed POSIX rename target overwrite behavior to replace existing destinations.
 * **B14 — provisional (ciphertext) sizes make rsync read short and abort the file**: Adjusted size reporting to align logical and ciphertext sizing, preventing premature EOF.
 * **B45 — truncate over a queued rewrite**: Path-based and handle-based truncate now compose over the complete pending blob; shrink, growth, and sparse I/O are live-verified.
 * **B46 — combined cross-directory move and rename**: The desired end state is durably queued and reconciles partially completed remote operations; replacement and combined cases are live-verified.
 * **B47 — overlong/invalid names**: All name-taking callbacks share a validator for `NAME_MAX`, reserved components, and UTF-8; managed-live verification passed.
-### Implemented in 1.0 (Further Fault Verification Pending)
+> [!TIP]
 > A daemon stopped in a debugger or deadlocked freezes every process that touches the mount,
 > including your shell if its prompt reads the current directory. Keep your shell outside
 > `~/ProtonDrive`, prefix commands that touch it with `timeout`, and unmount a dead mount with
 > `fusermount3 -uz ~/ProtonDrive`.
-* **Unified search and resident prompt**: `SearchV2` combines Drive and local lookup with shared relevance scoring and content/source filters. The prompt reuses its window and opens streamable media through FUSE.
+## Quality gates
 * **Durable write publication**: Scratch sidecars and staged blobs use synced temporary files, atomic renames, and directory synchronization; orphan rescue retains its source on failure.
 * **Transactional pending operations**: Superseding a queued operation cannot delete the old durable record unless the replacement commits.
 * **Safer mirror reconciliation**: Conflict-copy failure aborts publication, incomplete scans are non-destructive, and total-wipe protection includes one-entry baselines.
 * **Bounded IPC**: Control requests are limited to 1 MiB and 10 seconds, with at most 64 active handlers.
 * **Private local state**: Sensitive directories require correct ownership, real-directory identity, and `0700`; sockets use `0600`; config saves are atomic and malformed input is preserved.
 * **Release gates**: Tag/workspace/package versions are checked and formatting, lint, tests, and offline FUSE acceptance run before packaging.
-### Code Fixed / Implemented (Pending Verification)
+CI (`.github/workflows/ci.yml`) runs these on every push to `main` and every pull request. Run them before you
-* **B8 — no way to complete a CAPTCHA, so a gated sign-in is unrecoverable**: Implemented a Webkit-based bridge to prompt the user to resolve interactive CAPTCHAs during gated logins. (Needs verification on a real gate request).
+push:
-### Closed / Not a Bug
+```bash
-* **B3 — Activity log timestamps written in seconds, read as milliseconds**: Closed as investigator error (timestamps are consistent).
+cargo fmt --all -- --check
 cargo clippy --workspace --all-targets -- -D warnings
 cargo test --workspace --locked
 scripts/fuse-acceptance.sh --offline-only
 ```
---
+For changes to the FUSE layer, the write queue or the sync engine, also run the live acceptance
 cases described in [TESTING.md](TESTING.md).
-## 6. Recently Implemented Features
+For changes to GUI strings, check that every catalog is complete:
-### File Version History (Implemented)
+```bash
-**Files**: [`revisions.rs`](../crates/pdfs-fuse/src/revisions.rs), [`control.rs`](../crates/pdfs-core/src/control.rs), [`versions_dialog.rs`](../crates/pdfs-gui/src/app/widgets/versions_dialog.rs)
+for l in $(cat po/LINGUAS); do msgfmt --check --statistics -o /dev/null po/$l.po; done
 ```
-Proton Drive keeps every revision a client committed; the daemon only ever addressed the active one, so a file overwritten by a sync pass could be recovered only from whatever the local `recovery/` directory happened to hold.
+## Debugging
-The control protocol gained `ListRevisions` / `RestoreRevision` / `DeleteRevision` / `SaveRevisionAs` (each with a `…ByUid` twin for nodes the primary mount cannot name), the CLI gained `pdfs versions list|restore|save|rm`, and the browser's details pane gained a **Versions** button opening a per-file dialog.
+| Tool | Use |
 |---|---|
 | `RUST_LOG` | Log filter for every binary, for example `RUST_LOG=pdfs_fuse::sync=trace,info` |
 | `pdfs diagnose` | Static checks: directories, FUSE, keyring, socket, database integrity. Works without the daemon |
 | `pdfs diagnostics` | Live state of a running daemon: each worker's current job and its age, queue depth, control requests in flight, memory |
 | `pdfs cache inspect --deep` | Database size, row counts and SQLite `integrity_check` |
 | `pdfs --json …` | Raw protocol payloads for query commands |
 | `GTK_DEBUG=interactive` | The GTK inspector for `pdfs-app` |
 | `PDFS_STAND_IN_WIDGETS=1` | Force the libadwaita 1.5 fallback widgets on a newer system |
 | `G_DEBUG=fatal-criticals` | Turn GLib criticals into crashes to get a backtrace |
-Three properties that shape the code:
+The databases are ordinary SQLite files. Open a copy, not the live file:
- **A restore is server-side and asynchronous.** No content crosses the wire and nothing enters the drain queue; the server answers 202 and swaps the active revision in the background, so the daemon evicts the file's cached blocks and open readers rather than describing the new state, and the UI wording promises the request, not the result.
+```bash
- **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.
+cp ~/.local/state/proton-drive-linux/cache.db /tmp/cache.db
- **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.
+sqlite3 /tmp/cache.db '.tables'
 ```
-### Photo Favorites (Implemented)
+## Common changes
 **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 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`.
+**A new control request.** Add the variant to `Request` (and a `Response` if it returns data) in
 `crates/pdfs-core/src/control.rs`, handle it in `crates/pdfs-fuse/src/control.rs`, and list the
 `Topic`s it changes in the same file so subscribed front ends refresh. A daemon from the previous
 release may still be running when a new front end starts, so treat an error reply to a new
 request as "not supported".
-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.
+**A schema change.** Migrations are forward-only. Add a new step to
 `crates/pdfs-core/src/db/migrations.rs` and bump `SCHEMA_VERSION`; never edit a shipped step. Add
 a test in `crates/pdfs-core/src/db/tests.rs` that migrates from the previous version.
-### Justified Gallery, Gallery Delete (Implemented)
+**A GUI string.** Wrap it in the helpers from `crates/pdfs-gui/src/i18n.rs`, add any new source
-**Files**: [`photos.rs`](../crates/pdfs-gui/src/app/pages/photos.rs), [`photo_viewer.rs`](../crates/pdfs-gui/src/app/pages/photo_viewer.rs), [`photos.rs`](../crates/pdfs-fuse/src/photos.rs), [`background.rs`](../crates/pdfs-fuse/src/background.rs)
+file to `po/POTFILES.in`, run `po/update.sh`, and translate the new entries in every catalog. See
 [TRANSLATING.md](TRANSLATING.md). The CLI and daemon messages stay in English.
-The gallery lays each day out in justified rows (`justify_rows` / `plan_rows` / `fit_row`): photos are taken in capture order until their summed aspect ratio no longer fits the target row height, and the row is then scaled so it ends exactly on the content width. A tile is therefore its own photo's shape, and `ContentFit::Contain` has nothing left to crop. The last row of a day is left at the target height rather than stretched, because a day holding two photos is a short day, not a layout fault.
+**A setting.** Add the field to `AppConfig` in `crates/pdfs-core/src/config.rs` with
 `#[serde(default)]`, so older files still load, and document it in
 [CONFIGURATION.md](CONFIGURATION.md).
- **Ratios that are not known yet.** `PhotoItem::ratio` is persisted, but a photo that has never been decoded has none. Those are laid out square and remembered in `assumed_ratios`; when a decode proves the real shape the day re-flows on the existing debounce timer, so a screenful of decodes costs one re-flow rather than one per photo. Ratios are clamped to 0.4–3.0 so a single panorama cannot decide what a row looks like.
+## Releasing
 - **Thumbnails survive recycling.** A reply for a tile that has already been re-bound still lands in the texture cache, which is an LRU of 1500 textures keyed by uid, and the rows just outside the realised range are prefetched in the scroll direction.
 - **Delete is uid-addressed.** The photos volume is not in the FUSE mount, so the path-based `Request::Delete` cannot reach it. `Request::TrashNodes { uids }` trashes through the SDK and answers `Response::Trashed { trashed, failed }`; the daemon then drops those rows with `Db::photos_delete` (album membership included) so the gallery does not wait for a timeline refresh. The GUI removes the tiles optimistically with an Undo toast and puts back anything the server refused.
 - **Remote deletions arrive on their own.** The Drive volume and the photos volume have separate event streams, so `run_photos_event_sync` polls the photos volume with its own cursor (`photos_event_cursor` in the state table). Trash and delete events remove rows; anything else only invalidates freshness, because there is no inode space to converge on this volume. Together with a 60 s `TIMELINE_TTL` and a `RefreshScope::Photos` that now awaits the refresh, a photo deleted on a phone leaves the grid in about ten seconds.
-### RAW + JPEG Grouping (Implemented)
+Releases are cut from `main` by pushing a `v*` tag. `.github/workflows/release.yml` then:
 **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 favorite tag; `group_key` is computed in `photos_replace`, where the whole timeline is in hand.
+1. checks that the tag, the workspace version in `Cargo.toml` and `pkgver` in
   `packaging/PKGBUILD` agree;
 2. runs the quality gates;
 3. builds the release binaries and packages a `.tar.gz`, a `.deb` and a GPG-signed `.rpm`;
 4. publishes them as a GitHub release;
 5. calls `.github/workflows/aur.yml`, which updates and pushes the AUR recipes and commits them
   back to `main`.
- **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.
+To prepare a release:
 - **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.
 - **What is grouped and what is not.** `photos_page`, `photos_months` and `photos_counts` count groups, except on the Raw tab, which lists files. Album pages are never grouped: an album is a list someone made. The relation is learned-and-kept like `media_type`, so a refresh that could not resolve a node does not break a group up.
 - **Deleting.** `Core::trash_photos` expands each uid to its group before trashing, because the grid shows the shot as one tile — leaving the RAW behind would put the photo back on the Raw tab and nowhere else. The GUI's confirmation names the file count.
 - **The other files.** `Request::PhotoGroup { uid }` answers with the group's members as ordinary `PhotoItem`s, which is what the lightbox's switch steps through.
-### Persistent SDK Entity Cache (Implemented)
+```bash
-**Files**: [`sdkcache.rs`](../crates/pdfs-core/src/sdkcache.rs), [`auth.rs`](../crates/pdfs-core/src/auth.rs), [`background.rs`](../crates/pdfs-fuse/src/background.rs)
+# 1. Bump the version in Cargo.toml and packaging/PKGBUILD, then refresh the lock file.
 cargo update --workspace
 # 2. Move the [Unreleased] notes in docs/CHANGELOG.md under the new version.
 # 3. Commit, tag and push.
 git commit -am "chore(release): X.Y.Z"
 git tag vX.Y.Z
 git push origin main vX.Y.Z
 ```
-The SDK's Drive entity cache (decrypted node metadata: name, size, parent, signing share) defaulted to memory, so every daemon restart re-fetched and re-decrypted the tree the previous run had already walked. It is now backed by SQLite.
+Before a release that touches the filesystem or sync, run the managed live mode matrix from
-
+[TESTING.md](TESTING.md). Open release-assurance items are listed in [ROADMAP.md](ROADMAP.md).
 - **Its own file** (`sdk_cache.db` in the state directory), not `cache.db`: the daemon's `Db` is one `Mutex<Connection>` shared by every FUSE thread and the control socket, and this traffic is frequent, small and entirely reconstructible. A separate file also means no schema migration — the store can be deleted at any time.
 - **Encrypted at rest** by wrapping it in the SDK's `EncryptedCacheRepository`, keyed by the mailbox password. A password change reads as a cold cache (the SDK treats an undecryptable entry as a miss and clears the store), not as an error.
 - **Staleness** is closed by the event loop, which already replays from a persisted cursor and calls `invalidate_caches_for_event` for every event — including those raised while the daemon was down. The one case with no trail is a *seeded* cursor (first-ever mount, or a lost cursor), where the seed path now clears the store instead of trusting it. `auth::logout` removes the file.
 Needed a small additive SDK change (`ProtonDriveClient::with_entity_repository`, 0.5.1): `with_entity_cache` is a constructor and so could not be combined with `with_key_salts`, which the daemon requires.
 ### Per-node Batch Outcomes (Implemented)
 **File**: [`batch.rs`](../crates/pdfs-core/src/batch.rs)
 SDK 0.5.0 made `trash_nodes` / `restore_nodes` / `delete_nodes` report one outcome per node instead of failing the whole call (mirroring upstream's streamed `NodeActionResult`). `pdfs_core::batch::into_unit` collapses the single-node calls back to a `Result`; `batch::split` handles a collected batch.
 A restore is expanded before it is sent (`expand_restore`, `pdfs-fuse/src/lib.rs`): the persisted trash listing carries each row's `parent_uid` (schema 29), so a restore takes the connected piece of the trashed tree — every trashed descendant of what was asked for, and every trashed ancestor above it — and sends it shallowest wave first, because the server cannot put a node back under a parent that is still trashed. A uid the listing does not know about (it is materialised in chunks, and can be stale) is restored on its own rather than dropped.
 The trash view's restore and permanent-delete use the SDK's **streaming** variants (`restore_nodes_streaming` / `delete_nodes_streaming`) and apply local state per node as each batch lands rather than after the last one. For a permanent delete — which is irreversible — that means a daemon interrupted mid-batch has forgotten exactly the nodes the server destroyed, no more and no fewer. Both report per-node failures and count only what actually succeeded; only a batch where nothing succeeded is an error.
 ### Open-for-Write Deferral for Mirror Sync (Implemented)
 **File**: [`sync.rs`](../crates/pdfs-fuse/src/sync.rs)
 The mirror folder sync engine now defers uploading any file that is currently held open for writing by another process, matching the guarantee the FUSE mount path already provides (where uploads are deferred until `close(fd)`).
 **Problem**: Previously, the mirror sync path relied solely on a 2-second trailing-edge debounce (with a 30-second ceiling) to avoid uploading files mid-write. This was insufficient for slow continuous writers (e.g., database dumps, large exports, or editors that keep files open for extended periods), which could have their incomplete state uploaded as a real revision.
 **Solution**: Before each reconcile pass, the sync engine scans `/proc/*/fd` once to build a set of canonical paths within the sync root that any process holds open for writing (`O_WRONLY` or `O_RDWR`). Files in this set are:
 - **Kept in the local walk** — so they are not misclassified as deletions
 - **Treated as unchanged** — so no upload is queued for them
 - **Counted as `deferred`** — so the activity summary reports them (e.g., "3 uploaded, 1 deferred (open for write)")
 - **Picked up on the next pass** — after the writer has closed the file
 **How it works**:
 1. `open_for_write_set(root)` reads `/proc/*/fd` → `readlink` for each fd → prefix-checks against the sync root → reads `/proc/<pid>/fdinfo/<n>` to check the `flags:` line's low two bits (O_ACCMODE)
 2. `walk_local` sets `LocalItem.open_for_write = true` for matching files
 3. Both `do_reconcile` and `push_pass` skip upload classification for flagged files
 4. `Outcome.deferred` tracks the count for the activity summary
 **Performance**: The `/proc` scan completes in low single-digit milliseconds on a typical desktop. Only fds whose `readlink` target falls under the sync root incur the `fdinfo` read.
 **Tests added**: 8 unit tests covering `is_write_mode` parsing of various fdinfo flag combinations, and `Outcome` summary formatting with deferred counts.
 | Sync Path | Open-for-write protection | Mechanism |
 |---|---|---|
 | FUSE mount | ✅ Perfect | Upload deferred until `close(fd)` |
 | Mirror folders | ✅ Perfect | `/proc/*/fd` scan per reconcile pass |
@@ -0,0 +1,243 @@
 # Installation
 This page covers installing Proton Drive for Linux from a package or from source, the first
 sign-in, running without a desktop, and removing the client again.
 - [Requirements](#requirements)
 - [Install a package](#install-a-package)
 - [Build from source](#build-from-source)
 - [First run](#first-run)
 - [Headless and server use](#headless-and-server-use)
 - [Updating](#updating)
 - [Uninstalling](#uninstalling)
 ## Requirements
 | | Minimum |
 |---|---|
 | Architecture | x86_64 (release packages); other architectures build from source |
 | Kernel | FUSE 3 (`fuse3` package, `/dev/fuse` available to your user) |
 | GTK / libadwaita | GTK 4.12, libadwaita 1.5 (1.8 or newer gets the newest widgets) |
 | WebKitGTK | 6.0 — used only for the CAPTCHA page during sign-in |
 | Secret Service | GNOME Keyring, KWallet, KeePassXC, or another provider of `org.freedesktop.secrets` |
 | Rust (source builds) | 1.96 |
 The session is stored only in the Secret Service. Without a running provider, sign-in succeeds but
 cannot be saved, and the service cannot start unattended.
 Optional runtime extras:
 | Package | Adds |
 |---|---|
 | `exiftool` (`perl-image-exiftool`, `libimage-exiftool-perl`) | Thumbnails for camera RAW files |
 | `ffmpeg` | Video thumbnails |
 | `iso-codes` | Country names in your language on the Places map |
 | `xdg-utils` | "Open Folder" in the tray, and the default file opener |
 | `fzf` plus a terminal (foot, kitty, alacritty, …) | `pdfs-prompt --fzf`, the search-as-you-type launcher |
 | AppIndicator extension (GNOME only) | The tray icon. KDE Plasma and most other desktops show it natively |
 ## Install a package
 Every [release](https://github.com/narrrl/proton-drive-linux/releases/latest) ships a `.deb`, a
 signed `.rpm` and a `.tar.gz` of the raw binaries. All packages install the same files:
 | Path | Purpose |
 |---|---|
 | `/usr/bin/pdfs` | Command-line client and background service |
 | `/usr/bin/pdfs-app` | Desktop app |
 | `/usr/bin/pdfs-tray` | Tray icon |
 | `/usr/bin/pdfs-prompt` | Search launcher |
 | `/usr/lib/systemd/user/proton-drive.service` | User service that keeps the drive mounted |
 | `/etc/xdg/autostart/io.narl.proton-drive-linux-tray.desktop` | Starts the tray at login |
 | `/usr/share/locale/*/LC_MESSAGES/pdfs.mo` | Translations |
 ### Debian and Ubuntu (24.04 or newer)
 ```bash
 sudo apt install ./proton-drive-linux_*_amd64.deb
 ```
 ### Fedora (44 or newer)
 ```bash
 sudo dnf install ./proton-drive-linux-*.x86_64.rpm
 ```
 For a Fedora package built from your own checkout, see
 [Build an RPM locally](#build-an-rpm-locally).
 ### Arch Linux (AUR)
 Three 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) | Latest tagged release, built from source |
 | [`proton-drive-for-linux-bin`](https://aur.archlinux.org/packages/proton-drive-for-linux-bin) | Latest tagged release, prebuilt binaries |
 | [`proton-drive-for-linux-git`](https://aur.archlinux.org/packages/proton-drive-for-linux-git) | `main`, built from git |
 ```bash
 paru -S proton-drive-for-linux     # or yay, or any other AUR helper
 ```
 The recipes live in [`packaging/aur/`](../packaging/aur/README.md).
 ### Other distributions
 Unpack the `.tar.gz` into a directory on your `PATH`, then install the service unit as shown in
 [Using a binary outside `/usr/bin`](#using-a-binary-outside-usrbin).
 ## Build from source
 ### Build dependencies
 **Debian / Ubuntu 24.04+**
 ```bash
 sudo apt-get install -y pkg-config gettext libfuse3-dev libgtk-4-dev libadwaita-1-dev \
  libwebkitgtk-6.0-dev libsecret-1-dev libdbus-1-dev
 ```
 **Fedora 44+**
 ```bash
 sudo dnf install -y cargo rust gettext pkgconf-pkg-config fuse3-devel gtk4-devel \
  libadwaita-devel webkitgtk6.0-devel libsecret-devel dbus-devel glib2-devel
 ```
 **Arch Linux**
 ```bash
 sudo pacman -S --needed rust gettext pkgconf fuse3 gtk4 libadwaita webkitgtk-6.0 libsecret dbus
 ```
 Install Rust 1.96 or newer with [rustup](https://rustup.rs) if your distribution ships an older
 toolchain.
 ### Compile
 ```bash
 git clone https://github.com/narrrl/proton-drive-linux.git
 cd proton-drive-linux
 cargo build --release --locked
 po/build.sh target/locale        # optional: compile the translations
 ```
 The four binaries are in `target/release/`: `pdfs`, `pdfs-app`, `pdfs-tray` and `pdfs-prompt`.
 ### Build a package from the working tree
 **Arch Linux:**
 ```bash
 cd packaging && makepkg -fi
 ```
 <a id="build-an-rpm-locally"></a>**Fedora:**
 ```bash
 sudo dnf install -y rpm-build
 rpmbuild -bb packaging/proton-drive-linux.spec \
  --define "git_dir $PWD" \
  --define "_rpmdir $PWD/packaging/out" \
  --define "_builddir $PWD/packaging/build" \
  --define "_sourcedir $PWD" \
  --define "_specdir $PWD/packaging" \
  --define "_srcrpmdir $PWD/packaging/out"
 sudo dnf install packaging/out/x86_64/proton-drive-linux-*.rpm
 ```
 ### Using a binary outside `/usr/bin`
 The service unit starts `/usr/bin/pdfs daemon`. If you installed the binaries somewhere else, for
 example `~/.local/bin`, install the unit for your user and point it at your binary:
 ```bash
 mkdir -p ~/.config/systemd/user
 cp packaging/proton-drive.service ~/.config/systemd/user/
 sed -i "s|^ExecStart=.*|ExecStart=$HOME/.local/bin/pdfs daemon|" \
  ~/.config/systemd/user/proton-drive.service
 systemctl --user daemon-reload
 ```
 To start the tray at login, copy `packaging/io.narl.proton-drive-linux-tray.desktop` to
 `~/.config/autostart/`. For the app launcher entry, copy `packaging/io.narl.proton-drive-linux.desktop`
 to `~/.local/share/applications/` and the icon `packaging/io.narl.proton-drive-linux.svg` to
 `~/.local/share/icons/hicolor/scalable/apps/`.
 ## First run
 ### With the desktop app
 1. Open **Proton Drive** from your application menu, or run `pdfs-app`.
 2. Sign in with your Proton email and password, and your two-factor code if the account has one.
   If Proton asks for a CAPTCHA (common on a VPN or a new network), the app shows the challenge in
   a window and continues after you solve it.
 3. The app enables and starts `proton-drive.service`. Your Drive appears at `~/ProtonDrive`.
 The service is tied to your graphical session. It starts after you log in and stops when you log
 out. Change the folder location under **Preferences → General → Location**.
 ### With the command line
 `pdfs login` stores the session but does not enable the service, so a setup that runs the daemon
 another way stays untouched. Enable the service yourself:
 ```bash
 pdfs login                                        # email, password, 2FA code
 systemctl --user enable --now proton-drive.service
 pdfs status                                       # account, mount and queue state
 ```
 The CLI cannot show a CAPTCHA. If sign-in reports one, sign in once with `pdfs-app` instead; the
 session it stores is used by the CLI and the service as well.
 ## Headless and server use
 The service unit is bound to `graphical-session.target`. On a machine without a desktop session,
 run the daemon directly or from your own unit:
 ```bash
 pdfs daemon                      # waits for a stored session, mounts, stays mounted
 pdfs mount /srv/proton           # mounts once at a given path, blocks until unmounted
 ```
 Both still need a Secret Service provider. On a server, run
 `gnome-keyring-daemon --unlock` or KeePassXC's Secret Service integration inside the user's D-Bus
 session.
 ## Updating
 Install the new package over the old one. The service picks up the new binary the next time it
 starts; to switch at once:
 ```bash
 systemctl --user restart proton-drive.service
 ```
 Database migrations run automatically and only move forward. A database written by a newer
 release refuses to open in an older one, so downgrading means clearing the local database (see
 [Troubleshooting](TROUBLESHOOTING.md#start-over-with-a-clean-local-state)).
 ## Uninstalling
 > [!WARNING]
 > Check that nothing is waiting to upload before you remove local state. `pdfs sync queue` must be
 > empty. Queued writes exist only on this computer until they reach Proton Drive.
 ```bash
 pdfs sync queue                                   # must list nothing
 systemctl --user disable --now proton-drive.service
 pdfs logout                                       # removes the session from the keyring
 ```
 Then remove the package (`sudo apt remove proton-drive-linux`, `sudo dnf remove
 proton-drive-linux`, or `sudo pacman -R proton-drive-for-linux`), and, if you want no trace left,
 the local data:
 ```bash
 rm -rf ~/.config/proton-drive-linux ~/.local/state/proton-drive-linux ~/.cache/proton-drive-linux
 ```
 Sign out of the device in your Proton account settings as well, and remove the computer from
 **Computers** in the Proton Drive web app if you no longer want its backups.
@@ -0,0 +1,28 @@
 # Documentation
 ## For users
 | Page | What it covers |
 |---|---|
 | [Installation](INSTALL.md) | Packages, building from source, first sign-in, updating and uninstalling |
 | [User guide](USER_GUIDE.md) | My files, available offline, synced folders, conflicts, Photos, sharing, Trash and versions, Computers, the search launcher, the tray |
 | [Command-line reference](CLI.md) | Every `pdfs` command, grouped by task, and scripting with `--json` |
 | [Configuration](CONFIGURATION.md) | `config.json`, environment variables, file locations, the systemd service |
 | [Troubleshooting](TROUBLESHOOTING.md) | Diagnosing problems, common symptoms, starting over, reporting a bug |
 | [Recovering on a new computer](RECOVERY.md) | What survives a lost machine and how to restore your synced folders |
 | [Changelog](CHANGELOG.md) | What changed in each release |
 ## For contributors
 | Page | What it covers |
 |---|---|
 | [Development guide](DEVELOPMENT.md) | Building, running and debugging from source; releasing |
 | [Architecture](ARCHITECTURE.md) | Crates, read and write paths, sync engine, control protocol, threads, threat model |
 | [Testing](TESTING.md) | Unit tests and the FUSE acceptance suite |
 | [Translating](TRANSLATING.md) | Adding and updating translations |
 | [Roadmap](ROADMAP.md) | Planned work and verification still owed |
 | [Bug ledger](BUGS.md) | Every tracked defect with its analysis and status |
 | [UI/UX plan](UI_UX_PLAN.md) | Design audit and notes behind the 2.x desktop app |
 Also see [CONTRIBUTING.md](../CONTRIBUTING.md) and [SECURITY.md](../SECURITY.md) in the repository
 root.
@@ -1,262 +1,168 @@
-# Recovery: Getting a Replacement Machine Back onto Your Device
+# Recovering on a new computer
-You lose the laptop. You install `pdfs` on a new one. What does it take to get the
+Your laptop is lost, stolen or reinstalled. This page explains what survives, and how to get
-synced folders back?
+your synced folders back on the replacement machine.
-This document is two things: **§2 is the runbook that works with the client as it
+- [1. What survives](#1-what-survives)
-stands today**, gotchas included, and **§3 is the plan to reduce that runbook to
+- [2. Restore your synced folders](#2-restore-your-synced-folders)
-one command.** §1 is the part neither can fix — what actually died with the
+- [3. How the restore works](#3-how-the-restore-works)
-machine.
+- [4. Known gaps](#4-known-gaps)
---
+## 1. What survives
-## 1. What survives, and what does not
+### On Proton Drive
-### Survives (it is on Drive, or derivable)
+| What | Where |
 | Thing | Where it lives |
 |---|---|
 | Every file that finished uploading | Proton Drive |
-| The Device registration itself | Proton Drive (`enumerate_devices`) |
+| The computer's registration and its backup | **Computers** in the app and the web |
-| The device's folder tree — one folder per synced folder | Proton Drive, under the device root |
+| One folder per synced folder, under that computer | Proton Drive |
-| Your account, keys, sharing | Proton |
+| The machine profile: which folders were synced, to which local path, in which mode; pins; ignore patterns | `.proton-drive-linux/profile.json` under the computer's backup, end-to-end encrypted like any other file |
 | Your account, keys and shares | Proton |
-### Does not survive
+The service rewrites the profile a short while after you add, remove or switch a synced folder,
 or change a pin.
-| Thing | Why | Recoverable? |
+### Lost with the machine
 | What | Why | Recoverable? |
 |---|---|---|
-| Undrained `staging/` + `recovery/` blobs | Writes the kernel accepted but that never reached Drive. They existed only on that disk. | **No.** |
+| Changes still in `staging/` or `recovery/` | Writes that were accepted locally but never reached Proton Drive | **No** |
-| Local-only files in a mirror folder that had not uploaded yet | Same. | **No.** |
+| New files in a synced folder that had not uploaded yet | Same | **No** |
-| `sync_folder` rows — which local path maps to which remote folder, and in which mode | Local SQLite (`cache.db`) | Rebuildable by hand (§2), not automatically (§3) |
+| `config.json`: mountpoint, cache limit, bandwidth limits, appearance | Local config directory | Set again in **Preferences** |
-| `sync_entry` baseline | Local SQLite | Not needed. An empty baseline reconciles correctly — see §2.4. |
+| The local database and content cache | Local disk | Not needed; rebuilt from Proton Drive |
 | Pins | Local SQLite | Rebuildable by hand |
 | `config.json` — mountpoint, cache budget | Local config dir | Rebuildable by hand |
 | `cache.db` node/FTS/photo caches | Local SQLite | Pure cache; rebuilds itself |
-The first two rows are the only genuinely unrecoverable ones, and today nothing
+Only the first two rows are real losses. Before you retire a working machine, check that
-warns you they are non-empty before you walk away from a machine. That is tracked
+`pdfs sync queue` prints "Nothing queued" (or that **Sync → Overview** shows nothing waiting).
 separately from this document as a pending-writes visibility gap.
-### Before anything else: revoke
+### Before anything else: revoke the old session
-The lost machine holds a decrypted content cache, a plaintext index of every node
+The lost machine holds a decrypted content cache, a plain-text index of your file names and a
-name in your Drive (`cache.db`), and a live session in its keyring. Whether that
+live session in its keyring. Whether its disk was encrypted decides how much of that is exposed,
-matters depends on whether its disk was encrypted — but the session does not.
+but the session is valid either way.
-**Revoke the session from your Proton account settings before restoring.** Nothing
+**Sign the lost machine out from your Proton account's security settings before you restore.**
-in this client can do that for you; the daemon on the lost machine holds
+The client cannot do that for you.
 credentials it will happily keep refreshing.
-If you have also lost your password, Proton's recovery phrase is what determines
+If you have also lost your password, account recovery is Proton's matter, not this client's.
-whether the data is reachable at all. That is upstream of this client entirely: if
+Proton Drive is end-to-end encrypted: without the password or a recovery method, the data cannot
-zero-knowledge encryption worked as advertised, nobody at Proton can help.
+be decrypted.
---
+## 2. Restore your synced folders
-## 2. The runbook that works today
+### Step 1: Install and sign in
-### 2.1 Install, log in
+Install the client as described in [INSTALL.md](INSTALL.md) and sign in with `pdfs-app`. Signing
 in from the app also starts the service.
-```bash
+### Step 2: Continue the old computer's backup
 pdfs login          # stores the session in the keyring
 systemctl --user start proton-drive     # or let autostart do it
 ```
-### 2.2 Re-adopt the device — check this before anything else
+Tell this machine which computer it replaces, so new changes go into the existing backup instead
 of a second, empty one.
-`Core::ensure_device` recovers an existing device by **matching a Linux device
+- **In the app:** open **Computers**, open the menu of the old computer and choose
-whose name equals this machine's hostname**, read from
+  **Continue This Backup Here…**.
-`/proc/sys/kernel/hostname`. So:
+- **From a terminal:**
-```bash
+  ```bash
-hostnamectl hostname            # what this machine will register as
+  pdfs devices list                 # find the old computer's UID
-pdfs devices list               # what the account already has
+  pdfs devices adopt UID
-```
+  ```
- **Hostnames match** → the new machine silently re-adopts the old device and its
+Adoption takes effect at once and is stored in `config.json` as `device_uid`. It survives a
-  root folder. This is the happy path, and it is why the rest of the runbook works.
+change of hostname. `pdfs devices adopt --clear` returns to the default, which is to match a
- **Hostnames differ** → `pdfs` registers a **second device**. Nothing errors.
+computer whose name equals this machine's hostname.
  Your old device and all its folders are still there, but this machine is not
  attached to them, and every step below will quietly create empty folders under
  the new device instead.
-> **The single most important step in this document:** if the hostnames differ,
+> [!NOTE]
-> set the new machine's hostname to match the old device's name *before* adding
+> Without adoption, the client only finds the old computer if this machine has the same
-> any sync folders.
+> hostname. Otherwise it registers a new computer, and nothing points at the old backup.
 > ```bash
 > sudo hostnamectl set-hostname OLD-DEVICE-NAME
 > ```
 > There is no supported way to adopt a device by uid yet — see §3.1.
-### 2.3 Find out which folders the device had
+### Step 3: Restore the folders
-```bash
+- **In the app:** open **Computers**, open the menu of **This computer** and choose
-pdfs devices list       # confirm the device and note its name
+  **Restore Folders…**. Confirm or change the local path of each folder.
-```
+- **From a terminal:**
-The device's synced folders are the folders directly under its root in Drive.
+  ```console
-Browse them in the GUI's Computers page, or in the Proton Drive web app under
+  $ pdfs sync restore
-that device. **Write down their exact names** — you need them in the next step.
+  Documents [mirror] -> /home/you/Documents (Enter to accept, 'n' to skip, or a path)
  Projects [ondemand] -> /home/you/Projects (Enter to accept, 'n' to skip, or a path)
  ```
-### 2.4 Re-attach each folder
+  Press Enter to accept a path, type `n` to skip the folder, or type another path. `--yes`
  accepts every proposal without asking.
-For each folder name you noted, create the local directory and add it:
+For each folder you accept, the service creates the local directory, attaches it to the folder in
 the backup, restores its mode (**Mirror** or **Online only**) and downloads it. Follow the
 progress on **Sync → Overview** or with `pdfs sync list`.
-```bash
+> [!TIP]
-mkdir -p ~/Documents
+> Restore into empty or missing directories. If a directory already holds files, for example
-pdfs sync add ~/Documents
+> from another backup, the client cannot tell which side is newer. It keeps both: your local file
-```
+> is renamed to a `(sync-conflict …)` copy and the version from Proton Drive is downloaded. See
 > [Conflicts](USER_GUIDE.md#conflicts).
-`add_sync_folder` looks for a folder under the device root named after the local
+### Step 4: Restore the rest by hand
 directory's **basename**, and reuses it if found rather than creating a second
 one. So `~/Documents` re-attaches to the existing `Documents`. With an empty
 baseline and an empty local directory, the first reconcile classifies every remote
 path as `(None, Some(remote))` with no baseline → **download**, and the folder
 refills from Drive.
-Three things to be careful about:
+- **Available offline files.** The profile records them, but the restore does not apply them yet.
  Mark them again in the app, or with `pdfs pin PATH`.
 - **Preferences.** Set the cache limit, bandwidth limits, mountpoint and appearance again.
- **The basename must match exactly.** Restoring to `~/docs` when the device
+### Step 5: Clean up
  folder is `Documents` does not re-attach — it creates a *new*, empty `docs`
  folder in Drive and syncs nothing. The failure is silent; you just see an empty
  directory. Check with `pdfs sync list` and the Computers page.
 - **Add the folder empty, or accept conflict copies.** If the local directory
  already has files (restored from a backup, say), there is no baseline to say
  which side is newer, so both sides read as changed and the reconcile takes the
  conflict arm: your local file is renamed to a `(sync-conflict <ts>)` copy and
  the remote version is downloaded. Nothing is lost, but it is noisy. Restoring
  into an empty directory avoids it.
 - **A wholly empty local tree is now safe.** Before the audit fixes, adding a
  folder whose local side was empty against a populated remote could, on a later
  pass, be read as "the user deleted everything" and trash the lot. `sync.rs`'s
  `guard_local_wipe` now refuses any pass where every baseline path has vanished
  locally, which is exactly the restore shape.
-### 2.5 Restore modes, pins, and settings by hand
+If this machine registered a second computer before you adopted the old one, remove it:
 ```bash
 pdfs sync list                       # note the ids
 pdfs sync mode <id> ondemand         # for folders that were on-demand
 ```
 Nothing records which folders were `ondemand` before, so this is from memory. Pins
 and the cache budget/mountpoint likewise: set them again from the Settings page.
 ### 2.6 Clean up
 If a duplicate device got created before you noticed the hostname mismatch:
 ```bash
 pdfs devices list
-pdfs devices rm <uid-of-the-stray-device>
+pdfs devices rm UID
 ```
-Check what is under it in the web app first. Deleting a device you actually
+> [!WARNING]
-attached folders to will take its folders with it.
+> Removing a computer deletes its backup from Proton Drive. Check what is under it in
 > **Computers → Browse Files** first.
---
+### Restoring another computer's folders
-## 3. The plan: make this one command
+To bring folders from a computer that still exists, for example a desktop whose documents you want
 on a laptop, use **Restore to This Computer…** on that computer's row, or:
-The pieces all exist — device enumeration, folder-name reuse, an empty-baseline
+```bash
-reconcile that downloads correctly. What is missing is that the restore is
+pdfs sync restore --device UID
-**implicit, name-based, and undiscoverable**. Each phase below removes one of
+```
 those properties. They are independent and land in this order by value.
-### P1 — Adopt a device explicitly, by uid
+The folders stay part of the other computer's backup and sync in both directions. This machine
 does not take over that computer's backup.
-**Problem:** device identity is inferred from the hostname. A new laptop with a
+## 3. How the restore works
 new name silently forks a second device, and the failure looks like "my files
 didn't come back" rather than an error.
- Add `Request::AdoptDevice { uid }`: validate the uid against
+This section is for the curious and for anyone debugging a restore.
  `enumerate_devices`, write the `StoredDevice` row, and refuse if any
  `sync_folder` rows already reference a different device.
 - `pdfs devices adopt <uid>`, and an "Adopt this device" action on rows in the
  GUI's Computers page that are not the current machine.
 - Make the fork *visible* rather than silent: when `ensure_device` is about to
  create a device and the account already has other Linux devices, log a warning
  naming them, and surface it in `pdfs status`.
-Keep hostname matching as the default. It is right for the common case; it just
+- **Which computer the machine is.** At start, the service uses `device_uid` from `config.json`
-must not be the *only* way.
+  when it is set. When it is not, it looks for a Linux computer in the account whose name equals
  the hostname, and registers a new one when there is none. An adopted UID that no longer exists
  in the account is reported in the log instead of being replaced silently.
 - **What can be restored.** `pdfs sync restore` lists the folders directly under the computer's
  backup, except `.proton-drive-linux`. Folders already synced on this machine are skipped.
 - **Proposed paths.** When the profile names a local path whose parent directory exists on this
  machine, that path is proposed. Otherwise the proposal is `~/<folder name>`. The service never
  writes to a path you have not confirmed.
 - **Attaching by UID.** The restore binds each local path to the remote folder's UID, not to its
  name. Restoring `Documents` into `~/docs` works.
 - **Downloading.** A restored folder starts with an empty sync baseline. Against an empty local
  directory, every remote file counts as new and is downloaded. Files present on both sides with
  no baseline become conflict copies, as described above.
 - **The wipe guard.** A sync pass in which every previously synced file has vanished locally is
  refused instead of being mirrored to Proton Drive as a mass deletion. A folder that was emptied
  by accident therefore does not empty the backup.
 - **The profile format.** `profile.json` carries a `version` field. A client refuses a profile
  written by a newer, incompatible client instead of applying part of it.
-### P2 — Discover and re-attach the device's folders
+## 4. Known gaps
-**Problem:** §2.3 and §2.4 are "remember what you had, then retype it exactly."
+| Gap | Effect |
 - Add `Request::ListDeviceFolders { device_uid }` — enumerate the device root's
  child folders and report name, node uid, child count, and total size. This is
  the "what did this machine sync?" answer that today requires the web app.
 - Add `Request::AttachSyncFolder { remote_uid, local_path, mode }` — the
  re-attach counterpart to `AddSyncFolder`. It binds a local path to a **specific
  remote uid** rather than resolving by basename, which removes the silent
  `~/docs` vs `Documents` failure entirely.
 - CLI: `pdfs sync restore [--device <uid>] [--into <dir>]` — list the device's
  folders, propose `<dir>/<name>` for each (default `$HOME`), and attach the ones
  the user confirms.
 - GUI: a "Restore folders from this device" flow on the Computers page, with a
  per-folder local-path picker defaulting to `~/<name>`.
 Refuse to attach into a non-empty directory without an explicit
 `--allow-nonempty`, so the conflict-copy noise of §2.4 is opt-in rather than a
 surprise.
 ### P3 — Back the profile up to Drive
 **Problem:** modes, pins, mountpoint, and cache budget exist only on the dead
 machine, so even a perfect P2 restores folders in the wrong mode with no pins.
 Write a small JSON document into a hidden folder in the user's own Drive — say
 `.proton-drive-linux/profile.json` — containing, per device:
 - sync folders: remote uid, the local path last used, and mode
 - pinned node uids
 - mountpoint and cache budget
 It rides on Drive's own encryption, so this introduces no new crypto and no new
 place for plaintext to sit. Rewrite it whenever any of those change, debounced.
 On a fresh install, after login: *"Found settings from `<device>`, last updated
 `<date>`. Restore?"* Node uids are stable across machines, so pins restore
 exactly. Local paths need remapping when the username or home differs — show the
 old path, default the new one to `$HOME/<basename>`.
 Store the last-used local path only as a *hint*. Restoring a profile must never
 write to a path the user has not confirmed in this session.
 ### P4 — Make the unrecoverable visible
 Nothing above helps with §1's undrained writes, because by then it is too late.
 The mitigation is to make the pending queue impossible to miss *before* the
 machine is lost:
 - pending count and bytes in `pdfs status`, using the existing `pending` map and
  `TransferRegistry`
 - a tray icon state and a GUI banner while the queue is non-empty
 - a warning on logout or shutdown while it is non-empty
 ### P5 — Verification
 None of the above is trustworthy without exercising the actual shape of the
 disaster. The end-to-end test is: register a device, sync a folder, upload
 content, **delete the local state directory and cache entirely** (simulating the
 lost machine), restart, restore, and assert the tree comes back byte-identical.
 That is a two-account or at least two-state-dir integration test against a live
 account, not a unit test. Until the mock-backend problem described in
 `audit-plan.md` is solved, it stays manual — but it should be run, and its result
 recorded here, before P1–P3 are called done.
 ---
 ## 4. Current status
 | Phase | State |
 |---|---|
-| Manual runbook (§2) | Works, with the hostname and basename caveats |
+| Pins are backed up but not restored | Mark files available offline again by hand |
-| P1 explicit adoption | Not started |
+| No warning at shutdown or sign-out while changes are queued | Check `pdfs sync queue` before you retire a machine |
-| P2 discover + attach | Not started |
+| The full disaster drill (delete all local state, restore, compare byte for byte) has not been run against a live account | The individual steps are tested; the whole sequence is not |
-| P3 profile on Drive | Not started |
+
-| P4 pending visibility | Not started |
+Planned work is tracked in [ROADMAP.md](ROADMAP.md).
 | P5 restore drill | Never run |
@@ -0,0 +1,72 @@
 # Roadmap
 Planned work and open verification, as of 2.5.0. Individual defects and their status live in
 [BUGS.md](BUGS.md), which is the authoritative ledger; this page groups what is left by theme.
 Nothing here is a promise of a date.
 - [Data safety and recovery](#data-safety-and-recovery)
 - [Features](#features)
 - [Performance and correctness](#performance-and-correctness)
 - [Verification still owed](#verification-still-owed)
 - [Release assurance](#release-assurance)
 ## Data safety and recovery
 | Item | State | Notes |
 |---|---|---|
 | Protect queued changes at shutdown | Not started | A systemd inhibitor lock while `staging/` holds unsent data, a warning when signing out, and a blocking `pdfs sync flush`. Today the queue is visible through `pdfs sync queue`, the tray and **Sync → Overview**, but nothing stops a shutdown (B66) |
 | Restore pins from the machine profile | Not started | `profile.json` records pins; `sync restore` does not apply them yet |
 | Profile backup health | Not started | A failed profile upload is a `WARN` in the log and nothing in the UI (B68) |
 | Rotated credentials survive a keyring failure | Open | Surface and retry keyring write failures so a rotated single-use refresh token is not lost (B61) |
 | Encrypt local state at rest | Not started | SQLCipher for `cache.db` and an AEAD for the content cache, keyed from the keyring. `sdk_cache.db` is already encrypted. See [ARCHITECTURE.md §8](ARCHITECTURE.md#8-threat-model-what-this-client-writes-to-disk-in-plaintext) |
 ## Features
 | Item | State | Notes |
 |---|---|---|
 | File-manager integration | Not started | Context-menu actions (available offline, share link, versions) and sync badges for Nautilus, Dolphin and Thunar |
 | Terminal UI | Not started | `pdfs tui` with transfers, sync state and logs |
 | Multiple accounts | Not started | Separate config, state and mountpoint per profile, one daemon each |
 | Mount options | Not started | Read-only mount, `allow_other` |
 | Symbolic links | Not started | Proton Drive has no link type; links would need a placeholder format. Until then, creating one fails with `EOPNOTSUPP` |
 | Add someone else's photo to your album | Blocked | Needs `copyPhoto` in the SDK |
 | Photo name search | Not started | Photos search by date and filters only |
 | Automatic photo upload from a folder | Not started | |
 | Faster Google Photos import | Not started | Uploads run one at a time. Trash folders of locales missing from `TRASH_FOLDERS` import as photos; motion-photo `.MP` parts are skipped |
 | Content-addressed block cache | Idea | Store blocks by hash to deduplicate identical content |
 ## Performance and correctness
 | Item | Notes |
 |---|---|
 | Saturating stream-ring accounting | `self.bytes -= …` in `crates/pdfs-fuse/src/reads.rs` should saturate so an accounting drift cannot wrap in release builds |
 | Block geometry learned one read late | The first read of a file plans on 4 MiB blocks; accepted as a bounded cost (B87) |
 | Path-based commands under secondary mounts | `pin`, `rename`, `move`, `rm` and sharing cannot name a path inside an on-demand synced folder yet (B88) |
 | Unicode normalization | NFC and NFD names are distinct, deliberately (B36) |
 | Pipelined node enumeration | Faster cold listings of large folders |
 ## Verification still owed
 Fixes marked *unverified* in [BUGS.md](BUGS.md) have unit or offline coverage but have not been
 driven against a live account. The larger outstanding runs:
 - **Disaster-recovery drill.** Register a device, sync a folder, delete all local state, restore
  with `pdfs sync restore` and compare the tree byte for byte. See [RECOVERY.md](RECOVERY.md).
 - **Second-account sharing.** Shared trees on a foreign volume, accepting invitations, changing
  roles, the viewer cases of `regression B34`, and an editor writing into someone else's share.
 - **Fault injection.** Network loss mid-upload, a full disk during staging, and crash points
  across the write publication path (after each fsync, rename and queue commit).
 - **CAPTCHA sign-in** against a real verification request (B8).
 - **Managed live mode matrix** before each release:
  `scripts/fuse-acceptance.sh --managed-live <empty-a> <empty-b>`. See [TESTING.md](TESTING.md).
 - **The overnight hang** (B91) is not diagnosed yet. The supervisor and `pdfs diagnostics` exist to
  catch the next occurrence.
 ## Release assurance
 | Item | State |
 |---|---|
 | Tag, workspace and PKGBUILD version agreement | Enforced by the release workflow |
 | Clean-install test of the `.deb` and `.rpm` in a VM | Pending (B62) |
 | Protocol version identity between front ends and daemon | Open (B63) |
 | SBOM, provenance and checksums for release artifacts | Open (B65). The RPM is GPG-signed |
@@ -25,18 +25,81 @@ Proton:
 scripts/fuse-acceptance.sh --offline-only
 ```
-Kernel/FUSE behavior and remote convergence need a real mount. Live testing is
+Kernel/FUSE behavior and remote convergence need a real mount. With no
-explicitly opt-in and always runs the account-free contract first. It runs
+arguments, the script tests the account the running service is logged in to:
 destructive POSIX operations only below a fresh `pdfs-acceptance-*` directory.
 It refuses paths that are not FUSE mounts and removes its directory on success,
 failure, or interruption.
-Use a dedicated test account without irreplaceable data:
+```console
 scripts/fuse-acceptance.sh           # every case, every mount kind
 scripts/fuse-acceptance.sh --quick   # one on-demand/mirror pair instead of four
 ```
 An account run does this, in order:
 1. Runs the account-free contract as the reference.
 2. Runs the contract in a fresh `pdfs-acceptance-<id>` folder in My files and
   diffs it against the reference.
 3. Registers two new sync folders under `~/.cache/pdfs-acceptance/run-<id>/`
   and runs the contract and the move cases in every on-demand/mirror pairing.
 4. Removes everything it created, locally and remotely, and reports a
   `cleanup` result. The run fails if anything is left behind.
 Cleanup identifies remote folders by uid, never by name alone, so nothing of
 yours is touched. It removes each sync folder with `sync rm --delete-remote`,
 trashes the My files folder, and then deletes both permanently from the trash.
 It only counts a folder as gone once a fresh trash listing no longer shows it.
 It then reads `pdfs sync queue` and counts any queued op that still names one
 of its folders as left behind too, since such an op keeps its staged bytes and
 retries forever (B102).
 Cleanup also runs on a failure, Ctrl-C, `SIGTERM` or `SIGHUP`. While it runs,
 two more interrupts are ignored; a third abandons it.
 Each run records what it is about to create in
 `~/.cache/pdfs-acceptance/run-<id>/manifest.json` before it creates it, and
 holds a lock on that directory. If a run dies without cleaning up (`kill -9`, a
 hard timeout, a power cut), the next run finds the unlocked manifest and
 finishes that cleanup first. It then removes stray `pdfs-acceptance-<32 hex>`
 folders that no live run claims: in My files (older than
 `PDFS_ACCEPTANCE_REAP_AGE`, default one hour), under the acceptance home, and
 in the trash. A run does not start while that reap leaves anything behind.
 The run creates and destroys real remote folders, so a dedicated test account
 without irreplaceable data is still the safest target.
 `--live PATH...` tests mounts you set up yourself and leaves the sync folder
 configuration alone. It runs destructive POSIX operations only below a fresh
 `pdfs-acceptance-*` directory, refuses paths that are not FUSE mounts, and
 removes its directory on success, failure, or interruption:
 ```console
 scripts/fuse-acceptance.sh --live /mnt/on-demand-testmount
 ```
 ### Edge cases and performance
 Besides the syscall contract, the suite covers:
 - **Block boundaries.** Files of 0 bytes up to two 4 MiB blocks plus 3 bytes,
  including every size next to a boundary, then overwrites that grow, shrink
  and reshape them.
 - **Unusual names.** A 255-byte name, NFC and NFD forms of the same text,
  newline, tab, emoji, characters Windows forbids, leading and trailing
  spaces, and a case-only rename.
 - **A deep tree and a wide directory.** 24 levels of nesting renamed at the
  top; 128 entries created concurrently, concurrent unlinks, then `rm -rf`.
  Online, each create is a round trip to the server, and the kernel runs
  creates in one directory one at a time. So the wide case gets twice the
  per-case timeout and notes the time per create as `wide.create_ms`.
 - **Rename patterns.** Swaps, chains, log rotation, replacing a file under an
  open reader, the `EISDIR`/`ENOTDIR`/`ENOENT` refusals, and a folder moved out
  and back.
 - **Handle coherency.** Unsynced writes seen by a second handle, two `O_APPEND`
  writers, 30 rewrite generations, and a truncate under a reader.
 - **Throughput.** 64 MiB written and read sequentially, 1 MiB in 4 KiB writes,
  and metadata operations on 100 files. The rates are printed. The case fails
  below `PDFS_ACCEPTANCE_MIN_MIBPS` (default 10) or `PDFS_ACCEPTANCE_MIN_OPS`
  (default 20 operations per second, or 3 on a FUSE mount, where each create
  and unlink waits for Drive before it returns).
 ### The mount is diffed against an ordinary filesystem
 The local reference run is not only a self-test of the runner. Every case
@@ -78,10 +141,19 @@ in-flight `.crdownload` must not be sealed as a revision) and B74 (a file
 renamed after close must keep its content) need a real mount and a reachable
 daemon; they are skipped, not failed, without one.
-B74 is currently **failing** — it is a live data-loss defect, not a regression
+**B100** (a copied tree reads back at its exact sizes) copies 48 files of
-guard, and it was found by exactly this mechanism: the B70 case failed, and
+assorted sizes into the mount at once, as `cp -r` does. On a live mount it
-narrowing it produced a smaller reproduction that has its own case now. Expect a
+waits for the queue, checks every size and byte, runs `pdfs refresh` on each
-red run against a real mount until it is fixed.
+folder to drop the cached listing, and checks again. The refresh is what
 brought back the provisional sizes the bug reported.
 **B101** (a write during its create's upload reaches Drive) holds new files open for
 different times before writing, so their empty creates land before, during and after the
 bytes arrive, then checks every file after the queue drains.
 B74 was found by exactly this mechanism: the B70 case failed, and narrowing it
 produced a smaller reproduction that got its own case. The defect is fixed and
 live-validated (2026-07-26); the case now guards against its return.
 **B79** (an on-demand device folder accepts writes) discovers its target from
 `pdfs locations --json` and skips when this machine has no mounted on-demand
@@ -137,13 +209,17 @@ stops at the first failure.
 it ran. A suite can pass every assertion while the daemon logs failures behind
 it; that has happened, and it was caught only by reading the journal by hand.
-Abandoned `pdfs-acceptance-*` roots from a crashed run are removed at startup,
+With `--live`, abandoned `pdfs-acceptance-*` roots from a crashed run are
-but only if they match the exact generated name and are over an hour old
+removed at startup, but only if they match the exact generated name and are
-(`PDFS_ACCEPTANCE_REAP_AGE`), so a concurrent run is never disturbed.
+over an hour old (`PDFS_ACCEPTANCE_REAP_AGE`), so a concurrent run is never
 disturbed. An account run instead uses the manifest and reaper described
 above.
 ### Automated mode matrix
-The managed live runner accepts two existing, empty, unmounted directories. It
+An account run drives this matrix itself, in folders it creates. To use
 directories of your choice instead, the managed live runner accepts two
 existing, empty, unmounted directories. It
 registers both as new sync folders, waits for initial synchronization, then
 tests all four pairs in order: on-demand/on-demand, on-demand/mirror,
 mirror/on-demand, and mirror/mirror. Every transition must become idle, and an
@@ -160,6 +236,23 @@ in `pdfs sync list`. Use `PDFS_ACCEPTANCE_SYNC_TIMEOUT` to extend transition
 timeouts and `PDFS_ACCEPTANCE_PDFS` to select a non-installed CLI binary, for
 example `target/debug/pdfs`.
 After the contract, each mode pair also runs the move cases (`--list` shows
 them as `managed`). They move trees between the two folders in both
 directions, move several sources in one `pdfs move`, and pass a tree through
 My files and out again. Every case waits for Drive before and after the move.
 It then checks that the tree is only at the destination, that every byte
 arrived, and that neither side made conflict copies. The refusal cases prove
 that nothing moves and nothing is lost when:
 - the destination already has the name;
 - a folder would move into itself;
 - a mirror source holds something Drive lacks (a symlink);
 - a file in an on-demand source is still open for writing.
 The My files case writes a test folder into your real My files and removes it
 afterwards. It skips when the daemon reports no My files mount, or when the
 locations are on different volumes.
 ### Durability drill
 `--durability` restarts `proton-drive.service` in the middle of the suite and
@@ -0,0 +1,204 @@
 # Troubleshooting
 Start with `pdfs diagnose`, then find your symptom below. If nothing here helps,
 [open an issue](https://github.com/narrrl/proton-drive-linux/issues/new/choose) with the
 information listed under [Reporting a problem](#reporting-a-problem).
 - [First checks](#first-checks)
 - [Signing in](#signing-in)
 - [The Proton Drive folder](#the-proton-drive-folder)
 - [Uploads and sync](#uploads-and-sync)
 - [Disk space](#disk-space)
 - [Desktop integration](#desktop-integration)
 - [Start over with a clean local state](#start-over-with-a-clean-local-state)
 - [Reporting a problem](#reporting-a-problem)
 ## First checks
 ### `pdfs diagnose`
 Checks the installation and prints a report. It does not need the service, because the state
 worth diagnosing is often the one where the service will not start.
 ```console
 $ pdfs diagnose
 Paths
 [ok  ]   state dir: /home/you/.local/state/proton-drive-linux
 [ok  ]   cache dir: /home/you/.cache/proton-drive-linux
 [ok  ]   state dir writable: write and fsync succeeded
 [ok  ]   database: /home/you/.local/state/proton-drive-linux/cache.db (473.1 MiB)
 FUSE
 [ok  ]   /dev/fuse: /dev/fuse
 [ok  ]   unmount helper: fusermount3 or fusermount on PATH
 Account
 [ok  ]   keyring session: you@proton.me
 Daemon
 [ok  ]   control socket: /home/you/.local/state/proton-drive-linux/control.sock
 [ok  ]   daemon responding
 [ok  ]   active mount: /home/you/ProtonDrive (fuse.protondrive)
 [ok  ]   network: online
 [ok  ]   queued writes: none
 [ok  ]   database integrity: SQLite integrity_check passed
 [ok  ]   configured mountpoint: /home/you/ProtonDrive
 No problems found.
 ```
 It exits non-zero when a check fails, so it also works in a health-check script.
 ### Logs
 ```bash
 journalctl --user -u proton-drive.service -f           # follow the service
 journalctl --user -u proton-drive.service -b -p warning  # warnings since boot
 ```
 For more detail, raise the log level with a drop-in (see
 [CONFIGURATION.md](CONFIGURATION.md#the-systemd-service)) and restart the service.
 ### Service state
 ```bash
 systemctl --user status proton-drive.service
 pdfs status
 ```
 ## Signing in
 **"Proton is asking for a CAPTCHA"** — Proton wants human verification, usually on a VPN or an
 unfamiliar network. The CLI cannot show it. Sign in with `pdfs-app`, which displays the challenge;
 the stored session then works for the CLI too.
 **Sign-in works but is forgotten after a restart** — no Secret Service provider is running, or its
 keyring is locked. Install and unlock GNOME Keyring, KWallet or KeePassXC (with Secret Service
 enabled). `pdfs diagnose` shows `keyring session` as failing in that case.
 ## The Proton Drive folder
 > [!TIP]
 > When the service hangs, any program that touches the Proton Drive folder can hang with it,
 > including `ls` and your shell's prompt. Prefix exploratory commands with `timeout 5`.
 **`Transport endpoint is not connected`** — the service stopped without unmounting. Unmount and
 restart:
 ```bash
 fusermount3 -uz ~/ProtonDrive
 systemctl --user restart proton-drive.service
 ```
 **The folder is empty or missing** — check that the service runs and is signed in
 (`pdfs status`). The service waits for a stored session before it mounts.
 **Everything in the folder hangs** — find out what the service is doing, then restart it:
 ```bash
 timeout 10 pdfs diagnostics
 systemctl --user restart proton-drive.service
 ```
 The service watchdog restarts a service that stops answering for two minutes by itself. Attach the
 `pdfs diagnostics` output to a bug report; it shows which worker is stuck.
 **A change made on another device does not show up** — changes arrive through Proton's event
 stream, normally within seconds. To fetch a folder again at once:
 ```bash
 pdfs refresh Documents
 ```
 **"Permission denied" when writing** — the item is in a share where you are a viewer, or under
 `Shared with me/`, which is read-only as a folder. Check your role with `pdfs shared-with-me`.
 **A program says "Operation not supported"** — Proton Drive cannot store symbolic links, hard
 links, device files or FIFOs. The error is intentional. Use a synced folder for
 projects that need them, or exclude those paths.
 ## Uploads and sync
 **Something is stuck uploading** — list the queue and retry:
 ```bash
 pdfs sync queue
 pdfs sync retry           # every failed operation
 pdfs sync retry 42        # one operation
 ```
 The app shows the same list on **Sync → Overview**. An operation that keeps failing shows its
 error there.
 **A file in a synced folder does not upload** — check that:
 - it is not matched by `.pdfsignore` or `ignore_patterns`;
 - no program still holds it open for writing (such files wait until closed);
 - sync is not paused (`pdfs status`, tray);
 - the folder has no error on **Sync → Folders**.
 `pdfs sync now` starts a pass immediately.
 **Files named `(sync-conflict …)` appeared** — the file changed in two places at once. Nothing was
 lost; see [Conflicts](USER_GUIDE.md#conflicts) to pick a version.
 **Photos show the wrong date after a Google Takeout import** — run
 `pdfs redate-photos --dry-run`, see [USER_GUIDE.md](USER_GUIDE.md#importing-from-google-photos).
 ## Disk space
 | What | Check | Reduce |
 |---|---|---|
 | Content cache | `pdfs cache inspect` | Lower **Preferences → Storage → Cache size limit**, or `pdfs cache clear` |
 | Available-offline files | `pdfs pins` | `pdfs unpin PATH` |
 | Metadata database | `pdfs cache inspect` (reclaimable) | `pdfs cache vacuum` |
 | Synced folders | `pdfs sync list` | Switch large folders to online only: `pdfs sync mode ID ondemand` |
 `pdfs cache vacuum` locks the database while it runs and needs free space for a second copy of it.
 ## Desktop integration
 **No tray icon on GNOME** — install and enable the AppIndicator and KStatusNotifierItem Support
 extension. Other desktops show the icon natively. If you hid it from its own menu, turn it back on
 under **Preferences → General → Appearance**.
 **The search launcher does nothing** — `pdfs-prompt` needs the service. Run it from a terminal to
 see its error. For `--fzf`, install `fzf` and a supported terminal.
 **The app shows "Not responding"** — the service runs but does not answer within five seconds.
 See [Everything in the folder hangs](#the-proton-drive-folder).
 ## Start over with a clean local state
 This removes the local database and cache so they are rebuilt from Proton Drive. It is the fix for
 a damaged database and the only way to downgrade to an older release.
 > [!WARNING]
 > Content in `staging/` and `recovery/` has not reached Proton Drive yet. Deleting it loses those
 > changes permanently. Wait until `pdfs sync queue` is empty.
 ```bash
 pdfs sync queue                                   # must list nothing
 systemctl --user stop proton-drive.service
 mv ~/.local/state/proton-drive-linux ~/.local/state/proton-drive-linux.bak
 mv ~/.cache/proton-drive-linux ~/.cache/proton-drive-linux.bak
 systemctl --user start proton-drive.service
 ```
 Your session is in the keyring and your settings in `~/.config`, so you stay signed in. Synced
 folders are not re-attached automatically; restore them with `pdfs sync restore` as described in
 [RECOVERY.md](RECOVERY.md#2-restore-your-synced-folders). Delete the `.bak` directories once
 everything is back.
 ## Reporting a problem
 Include:
 - `pdfs --version`, your distribution and desktop;
 - the output of `pdfs diagnose`;
 - relevant log lines from `journalctl --user -u proton-drive.service`;
 - for a hang, the output of `timeout 10 pdfs diagnostics`;
 - the steps that reproduce it.
 Logs contain file names. Remove anything private before posting. Report security problems
 privately as described in [SECURITY.md](../SECURITY.md).
@@ -0,0 +1,325 @@
 # User guide
 How Proton Drive for Linux works and how to use it day to day. For installation see
 [INSTALL.md](INSTALL.md); every command mentioned here is described in [CLI.md](CLI.md).
 - [How it works](#how-it-works)
 - [My files](#my-files)
 - [Keeping files on this computer](#keeping-files-on-this-computer)
 - [Syncing local folders](#syncing-local-folders)
 - [Conflicts](#conflicts)
 - [Pausing and limiting sync](#pausing-and-limiting-sync)
 - [Photos](#photos)
 - [Sharing](#sharing)
 - [Trash and version history](#trash-and-version-history)
 - [Computers](#computers)
 - [Search launcher](#search-launcher)
 - [Choosing how files open](#choosing-how-files-open)
 - [Tray](#tray)
 - [Preferences](#preferences)
 ## How it works
 A background service, `proton-drive.service`, runs `pdfs daemon`. It holds your session, talks to
 Proton Drive, and keeps your Drive mounted as a folder. Everything else is a front end that asks
 the service to do things over a local socket:
 | Program | What it is |
 |---|---|
 | `pdfs-app` | The desktop app: files, photos, sharing, sync, preferences |
 | `pdfs-tray` | Tray icon with status, pause and quick actions |
 | `pdfs-prompt` | A search launcher for a keyboard shortcut |
 | `pdfs` | The command-line client, for everything above and for scripts |
 Your Drive, your file names and your photos are end-to-end encrypted by Proton. On this computer,
 the service must decrypt what it shows you, and it keeps a decrypted cache and index on disk. Use
 full-disk or home-directory encryption. [ARCHITECTURE.md §8](ARCHITECTURE.md#8-threat-model-what-this-client-writes-to-disk-in-plaintext)
 lists exactly what is stored.
 The app uses these words consistently, and so does this guide:
 | Term | Meaning |
 |---|---|
 | **My files** | The root of your Drive |
 | **Proton Drive folder** | Where My files appears on disk, `~/ProtonDrive` by default |
 | **Online only** | A file or folder whose content downloads when opened |
 | **Available offline** | A single file kept on this computer |
 | **Synced folder** | A local folder with a full copy on this computer, backed up to Proton Drive |
 | **Proton Drive service** | The background service (`proton-drive.service`) |
 ## My files
 My files is mounted at `~/ProtonDrive`. Every file and folder appears immediately, but content
 downloads only when a program reads it:
 - **Reads fetch only what is needed.** A video player that seeks, or a tool that reads a file
  header, downloads only those parts. Media streams while it plays.
 - **Writes are safe offline.** When a program closes a file it wrote, the service stores the new
  content on disk and queues the upload. The queue survives network loss, restarts and crashes.
  `pdfs sync queue` lists what has not reached Proton Drive yet.
 - **Recently read content is cached** on disk up to the cache size limit (5 GiB by default) and
  evicted oldest first.
 - **Items shared with you** appear under `Shared with me/` inside the Proton Drive folder. Shares
  where you are a viewer are read-only.
 The **My files** page of the app browses the same tree without going through the mount. It has a
 grid and a list view, sorting, thumbnails (including camera RAW previews), multi-select and drag
 and drop upload. **Details** (Alt+Enter) shows size, dates, sharing and version history for the
 selected item.
 Symbolic links, hard links, device files and FIFOs cannot be stored on Proton Drive. Programs that
 try to create them get a clean error, not a hang or `EIO`.
 ## Keeping files on this computer
 Turn on **Make available offline** for a file in My files, or run `pdfs pin <path>`. The file is
 downloaded completely and never evicted from the cache. `pdfs pins` lists these files, and
 **Preferences → Storage → Available offline** shows them in the app.
 Turning it off (`pdfs unpin <path>`) frees the space. The file stays on Proton Drive.
 ## Syncing local folders
 A synced folder is an ordinary folder on this computer, for example `~/Documents`, that is
 backed up to Proton Drive under this computer's name. It appears on the **Computers** page of the
 app and in the web app.
 - Add one with **Add Folder to Sync** on the **Computers** page, or `pdfs sync add ~/Documents`.
 - Changes flow both ways. Local edits upload a few seconds after the file is closed; remote edits
  download on the next pass.
 - A file that another program still holds open for writing is not uploaded until it is closed.
 - **Sync → Folders** in the app, and `pdfs sync list`, show every folder and its state.
 Each synced folder can also be switched to **Online only**. The local copy is replaced by a mount
 of the folder, so the files stay visible but take no disk space until opened. Switch with the
 **Synced / Online only** switch on the folder's card, or `pdfs sync mode <id> ondemand` and back
 with `pdfs sync mode <id> mirror`. `pdfs locations` lists every local place the service occupies.
 ### Moving between synced folders and My files
 `~/ProtonDrive` and each online-only folder are separate mounts, and a mirrored folder is a plain
 folder on disk. `mv`, and dragging in a file manager, cannot rename across them, so they copy
 and then delete: every file is downloaded, uploaded again, and the original goes to the Trash.
 Use `pdfs move <path> <folder>` or **Move to…** in the app instead. The move happens on Proton
 Drive, so it takes seconds whatever the size. For example:
 ```sh
 pdfs move ~/Documents/Scans ~/ProtonDrive/Archive
 pdfs move ~/Documents/a.pdf ~/Documents/b.pdf ~/ProtonDrive/Archive
 ```
 The last path is the destination folder; everything before it moves there.
 Files already opened in an online-only folder are not downloaded again when
 they move into a mirrored one.
 A move out of a synced folder waits until its files are on Proton Drive. A file that is still
 uploading, has changes that are not uploaded, or is excluded by `.pdfsignore` stops the move,
 and the message names it.
 Removing a synced folder (**Stop Syncing** or `pdfs sync rm <id>`) keeps the local files and the
 copy on Proton Drive. Add `--delete-remote` (or tick **Also delete from Proton Drive**) to delete
 the copy on Proton Drive as well.
 ### Excluding files with `.pdfsignore`
 Synced folders skip build output, dependency folders and editor leftovers. Rules come from two
 places, and both apply:
 1. A `.pdfsignore` file at the root of the synced folder (`.protonignore` also works), using
   gitignore syntax, including `!` to re-include:
   ```gitignore
   build/
   *.log
   !important.log
   ```
 2. The global `ignore_patterns` list in `config.json` (see
   [CONFIGURATION.md](CONFIGURATION.md#ignore_patterns)). When unset, it defaults to `.git/`,
   `.hg/`, `.svn/`, `node_modules/`, `target/`, `.venv/`, `__pycache__/`, `*~`, `*.swp`, `*.tmp`,
   `.DS_Store` and `Thumbs.db`.
 Rules are re-read on every pass. Ignoring never deletes anything: a file that becomes ignored is
 simply no longer tracked, and its copy on Proton Drive stays.
 ## Conflicts
 When the same file changed on this computer and somewhere else since the last sync, neither side
 is thrown away. The local version is kept as a copy named like
 `report (sync-conflict 1759068180).odt`, where the number is the time of the conflict in seconds
 since 1970, and the remote version takes the original name.
 Conflicts appear under **Sync → Overview → Needs attention** and in `pdfs conflicts`. For each
 one, keep the original, keep the copy, or keep both under a new name:
 ```bash
 pdfs conflicts
 pdfs conflicts resolve "Documents/report (sync-conflict 1759068180).odt" --keep copy
 ```
 The version you do not keep goes to the Trash, so a wrong choice can be undone.
 ## Pausing and limiting sync
 - **Pause** from the tray, the Sync page, or `pdfs sync pause`. Uploads and synced folders wait;
  reading files keeps working. `pdfs sync resume` continues.
 - **Limit bandwidth** under **Preferences → General → Network**, or with
  `pdfs sync limit --up 2M --down 10M`. `0` removes a limit.
 - **Retry** a failed upload from **Sync → Overview**, or with `pdfs sync retry`.
 ## Photos
 The **Photos** page shows your Proton Photos library. Photos are stored separately from My files
 and do not appear in the Proton Drive folder.
 - **Timeline** groups photos by day, month or year as you zoom. Drag the scrubber on the right edge
  to jump through the years. **On this day** shows photos from the same date in earlier years.
 - **Filters** narrow the timeline to images, videos or RAW files, to favorites, or to photos that
  are in no album.
 - **RAW + JPEG pairs** of the same shot show as one tile. The viewer switches between them, and
  moving the tile to the Trash removes both.
 - **Albums** lists your albums and albums shared with you. Create, rename and delete albums, and
  add or remove photos.
 - **Places** groups photos by the town they were taken in, as cards or on a map. Towns come from
  bundled [GeoNames](https://www.geonames.org/) data (CC BY 4.0) and the map from
  [Natural Earth](https://www.naturalearthdata.com/) (public domain), so nothing is fetched online.
  An optional street map from [OpenFreeMap](https://openfreemap.org/) (© OpenStreetMap
  contributors) can be enabled under **Preferences → General → Appearance**. It is off by default
  because the tile server learns which areas you look at.
 - **Viewer**: favorites, EXIF details, show on map, slideshow (F5).
 - **Find Duplicates…** in the page menu lists byte-identical copies. The **Similar** switch also
  finds resized or re-encoded copies and burst shots by comparing thumbnails.
 - **Upload** adds photos. Its menu holds **Import from Google Photos…**.
 ### Importing from Google Photos
 Request a Google Takeout export of Google Photos, then pass every `.zip` of it at once. A photo's
 metadata often sits in a different part of the export than the photo itself.
 ```bash
 pdfs import-google-photos --dry-run ~/Downloads/takeout-*.zip   # see what would happen
 pdfs import-google-photos --wait ~/Downloads/takeout-*.zip
 ```
 Albums are recreated, capture dates and locations are taken from the metadata, and photos already
 on the account are skipped, so an interrupted import can be run again. `pdfs import-status` and
 `pdfs cancel-import` follow or stop an import that runs in the background.
 If photos from an earlier import are filed under the day they were uploaded,
 `pdfs redate-photos --dry-run` finds those whose file name carries a different date, and
 `pdfs redate-photos` fixes them. Proton cannot change a capture date in place, so each fix
 re-uploads the photo and moves the original to the Trash, keeping favorites and albums.
 ## Sharing
 - **Share…** on a file or folder invites people by email as viewer or editor, or creates a public
  link with an optional password and expiry. `pdfs share`, `pdfs members`, `pdfs share-role`,
  `pdfs unshare` and `pdfs public-link` do the same from a terminal.
 - **Shared by me** lists everything you share, filtered by links, people or expired links. Copy a
  live link or stop several shares at once.
 - **Shared with me** lists what others share with you, with who shared it and your access.
  Pending invitations wait in a banner; `pdfs invitations` accepts or rejects them. Saved public
  links (`pdfs bookmarks`) have their own view.
 ## Trash and version history
 The **Trash** page lists trashed items with the date they were deleted. Restore puts an item back
 where it was, together with trashed folders above it. **Delete Forever** and **Empty Trash** are
 permanent. The CLI equivalents are `pdfs trash`, `pdfs restore`, `pdfs delete-forever` and
 `pdfs empty-trash`.
 Proton Drive keeps earlier versions of every file. **Details → Versions…** in the app, or
 `pdfs versions list <path>`, shows them. You can:
 - **Restore** a version. This happens on the server; nothing is re-uploaded.
 - **Save** a version to a separate local file without touching the current one.
 - **Delete** an old version permanently. The current version cannot be deleted.
 ## Computers
 **Computers** lists this computer and every other computer that backs up to your account.
 - **This computer** shows its synced folders with their state, and **Restore Folders…** brings
  back folders that are backed up under it but not synced here yet.
 - **Another computer** can be browsed read-only in the same list or grid as My files, and
  **Restore to This Computer…** downloads its folders here.
 - **Continue This Backup Here…** makes this computer take over another computer's backup, for
  example after reinstalling or replacing a machine. See [RECOVERY.md](RECOVERY.md).
 ## Search launcher
 `pdfs-prompt` searches Proton Drive and your home folder together, in one ranked list. It
 tolerates prefixes, abbreviations, typos and swapped letters, and matches on parent folder names
 as well. Bind it to a keyboard shortcut in your desktop settings.
 The window stays loaded after the first use, so later shortcuts open it instantly. Folders, audio
 and video open straight from the Proton Drive folder, so players can start before the whole file
 downloads. Other Drive files download first, then open.
 To make the first shortcut instant as well, start the launcher hidden with your session.
 `pdfs-prompt --preload` loads the window without showing it and does nothing if the launcher is
 already running. For Hyprland:
 ```ini
 exec-once = pdfs-prompt --preload
 bind = SUPER, space, exec, pdfs-prompt
 ```
 ### Using your own launcher
 `pdfs-prompt --dmenu` shows the results in fuzzel, rofi, wofi, tofi, bemenu or dmenu, whichever is
 installed:
 ```bash
 pdfs-prompt --dmenu
 pdfs-prompt --dmenu --menu 'fuzzel --dmenu --width 60'
 pdfs-prompt --dmenu --query invoice
 ```
 A dmenu-style launcher filters a fixed list and cannot ask for new results per keystroke, so the
 search takes two steps. The first list, `Search Drive ›`, shows your available-offline files; type
 a query and press Enter to search. The second, `Drive: invoice ›`, shows the results; Enter opens
 one, and typing something else searches again.
 ### Search as you type with fzf
 `pdfs-prompt --fzf` re-queries the service on every keystroke, like the built-in window. When
 started from a keybinding without a terminal, it opens one itself (foot, ghostty, kitty,
 alacritty, wezterm or xterm) with the app ID `pdfs-prompt`, so one window rule covers all of them.
 For Hyprland:
 ```ini
 windowrulev2 = float, class:^(pdfs-prompt)$
 windowrulev2 = size 900 500, class:^(pdfs-prompt)$
 windowrulev2 = center, class:^(pdfs-prompt)$
 bind = SUPER, space, exec, pdfs-prompt --fzf
 ```
 To make `--dmenu` or `--fzf` the default without changing your keybinding, set `prompt.mode` in
 `config.json` ([CONFIGURATION.md](CONFIGURATION.md#prompt)). `--gtk` forces the built-in window.
 ## Choosing how files open
 Files open with `xdg-open` by default. The `open_with` section of `config.json` overrides that per
 file type, for example text in Neovim inside a terminal. The rules apply to the search launcher
 and to the app. See [CONFIGURATION.md](CONFIGURATION.md#open_with).
 ## Tray
 `pdfs-tray` starts at login and shows whether files are up to date, syncing, paused or offline.
 Its menu opens the app or the Proton Drive folder, pauses or resumes sync, and stops or connects
 the service. **Hide Tray Icon** removes it until you turn it back on under
 **Preferences → General → Appearance → Show tray icon**.
 GNOME needs the AppIndicator extension to show tray icons.
 ## Preferences
 | Page | Settings |
 |---|---|
 | **General** | Start on login · Proton Drive folder location · upload and download limits · Proton theme, street map for Places, tray icon · language |
 | **Storage** | Cache size limit · clear the cache · files kept available offline |
 The account menu shows storage used and holds **Sign Out…**. Settings not exposed in the app are
 listed in [CONFIGURATION.md](CONFIGURATION.md).
@@ -9,11 +9,11 @@
 # Build + install:   cd packaging && makepkg -fi
 pkgname=proton-drive-linux
-pkgver=2.5.0
+pkgver=2.8.0
 pkgrel=1
 pkgdesc="Unofficial Proton Drive client for Linux: files-on-demand FUSE mount, CLI, GTK4 app + tray"
 arch=('x86_64')
-url="https://github.com/narrrl/proton-drive-linux"
+url="https://proton-drive.narl.io"
 license=('MIT')
 depends=('fuse3' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'perl-image-exiftool')
 makedepends=('cargo' 'git' 'gettext')
@@ -1,8 +1,8 @@
 pkgbase = proton-drive-for-linux-bin
 	pkgdesc = Unofficial Proton Drive client: FUSE files-on-demand mount, CLI, GTK4 app, tray (binaries)
-	pkgver = 2.4.0
+	pkgver = 2.6.1
 	pkgrel = 1
-	url = https://github.com/narrrl/proton-drive-linux
+	url = https://proton-drive.narl.io
 	arch = x86_64
 	license = MIT
 	depends = fuse3
@@ -21,21 +21,21 @@ pkgbase = proton-drive-for-linux-bin
 	optdepends = xdg-utils: "Open folder" action in the tray menu
 	optdepends = fzf: search-as-you-type launcher (pdfs-prompt --fzf)
 	optdepends = foot: terminal that hosts pdfs-prompt --fzf when started from a keybinding
-	provides = proton-drive-for-linux=2.4.0
+	provides = proton-drive-for-linux=2.6.1
-	provides = proton-drive-linux=2.4.0
+	provides = proton-drive-linux=2.6.1
 	provides = pdfs
 	conflicts = proton-drive-linux
 	conflicts = proton-drive-for-linux
 	conflicts = proton-drive-for-linux-git
 	options = !strip
 	options = !debug
-	source = proton-drive-linux-2.4.0-x86_64.tar.gz::https://github.com/narrrl/proton-drive-linux/releases/download/v2.4.0/proton-drive-linux-2.4.0-x86_64.tar.gz
+	source = proton-drive-linux-2.6.1-x86_64.tar.gz::https://github.com/narrrl/proton-drive-linux/releases/download/v2.6.1/proton-drive-linux-2.6.1-x86_64.tar.gz
-	source = io.narl.proton-drive-linux.desktop::https://raw.githubusercontent.com/narrrl/proton-drive-linux/v2.4.0/packaging/io.narl.proton-drive-linux.desktop
+	source = io.narl.proton-drive-linux.desktop::https://raw.githubusercontent.com/narrrl/proton-drive-linux/v2.6.1/packaging/io.narl.proton-drive-linux.desktop
-	source = io.narl.proton-drive-linux-tray.desktop::https://raw.githubusercontent.com/narrrl/proton-drive-linux/v2.4.0/packaging/io.narl.proton-drive-linux-tray.desktop
+	source = io.narl.proton-drive-linux-tray.desktop::https://raw.githubusercontent.com/narrrl/proton-drive-linux/v2.6.1/packaging/io.narl.proton-drive-linux-tray.desktop
-	source = io.narl.proton-drive-linux.svg::https://raw.githubusercontent.com/narrrl/proton-drive-linux/v2.4.0/packaging/io.narl.proton-drive-linux.svg
+	source = io.narl.proton-drive-linux.svg::https://raw.githubusercontent.com/narrrl/proton-drive-linux/v2.6.1/packaging/io.narl.proton-drive-linux.svg
-	source = proton-drive.service::https://raw.githubusercontent.com/narrrl/proton-drive-linux/v2.4.0/packaging/proton-drive.service
+	source = proton-drive.service::https://raw.githubusercontent.com/narrrl/proton-drive-linux/v2.6.1/packaging/proton-drive.service
-	source = LICENSE-2.4.0::https://raw.githubusercontent.com/narrrl/proton-drive-linux/v2.4.0/LICENSE
+	source = LICENSE-2.6.1::https://raw.githubusercontent.com/narrrl/proton-drive-linux/v2.6.1/LICENSE
-	sha256sums = 00446aa9016466827bb0fe5ea1e1d171f478ab4194845f9005b690a05543fcca
+	sha256sums = d5a2ac948314dd2ca156978e862c8b106fcb9b1f5a7da8da62a5992ea345fda4
 	sha256sums = d190d6771fff0b975271fb62fd3fb0fa8bbf17d7278c10853c18557855b0c123
 	sha256sums = 1d95e250370220e3bb6aead6ce34d1d6cc759f42c4803b75f1667e78ff47c6c0
 	sha256sums = e598a93c2715c3a9fdc7fb937902083d4a1135e8fbdfe6fe7e37f0383ebbd828
@@ -1,11 +1,11 @@
 # Maintainer: Nils Pukropp <contact@narl.io>
 pkgname=proton-drive-for-linux-bin
-pkgver=2.4.0
+pkgver=2.6.1
 pkgrel=1
 pkgdesc="Unofficial Proton Drive client: FUSE files-on-demand mount, CLI, GTK4 app, tray (binaries)"
 arch=('x86_64')
-url="https://github.com/narrrl/proton-drive-linux"
+url="https://proton-drive.narl.io"
 license=('MIT')
 depends=('fuse3' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc'
         'hicolor-icon-theme')
@@ -31,7 +31,7 @@ source=("proton-drive-linux-$pkgver-x86_64.tar.gz::$url/releases/download/$_tag/
        "io.narl.proton-drive-linux.svg::$_raw/packaging/io.narl.proton-drive-linux.svg"
        "proton-drive.service::$_raw/packaging/proton-drive.service"
        "LICENSE-$pkgver::$_raw/LICENSE")
-sha256sums=('00446aa9016466827bb0fe5ea1e1d171f478ab4194845f9005b690a05543fcca'
+sha256sums=('d5a2ac948314dd2ca156978e862c8b106fcb9b1f5a7da8da62a5992ea345fda4'
            'd190d6771fff0b975271fb62fd3fb0fa8bbf17d7278c10853c18557855b0c123'
            '1d95e250370220e3bb6aead6ce34d1d6cc759f42c4803b75f1667e78ff47c6c0'
            'e598a93c2715c3a9fdc7fb937902083d4a1135e8fbdfe6fe7e37f0383ebbd828'
@@ -1,8 +1,8 @@
 pkgbase = proton-drive-for-linux-git
 	pkgdesc = Unofficial Proton Drive client: FUSE files-on-demand mount, CLI, GTK4 app, tray (git)
-	pkgver = 2.4.0.r0.gda35a05
+	pkgver = 2.6.1.r0.g6f100db
 	pkgrel = 1
-	url = https://github.com/narrrl/proton-drive-linux
+	url = https://proton-drive.narl.io
 	arch = x86_64
 	license = MIT
 	makedepends = cargo
@@ -24,8 +24,8 @@ pkgbase = proton-drive-for-linux-git
 	optdepends = xdg-utils: "Open folder" action in the tray menu
 	optdepends = fzf: search-as-you-type launcher (pdfs-prompt --fzf)
 	optdepends = foot: terminal that hosts pdfs-prompt --fzf when started from a keybinding
-	provides = proton-drive-for-linux=2.4.0.r0.gda35a05
+	provides = proton-drive-for-linux=2.6.1.r0.g6f100db
-	provides = proton-drive-linux=2.4.0.r0.gda35a05
+	provides = proton-drive-linux=2.6.1.r0.g6f100db
 	provides = pdfs
 	conflicts = proton-drive-linux
 	conflicts = proton-drive-for-linux
@@ -1,11 +1,11 @@
 # Maintainer: Nils Pukropp <contact@narl.io>
 pkgname=proton-drive-for-linux-git
-pkgver=2.4.0.r0.gda35a05
+pkgver=2.6.1.r0.g6f100db
 pkgrel=1
 pkgdesc="Unofficial Proton Drive client: FUSE files-on-demand mount, CLI, GTK4 app, tray (git)"
 arch=('x86_64')
-url="https://github.com/narrrl/proton-drive-linux"
+url="https://proton-drive.narl.io"
 license=('MIT')
 depends=('fuse3' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc'
         'hicolor-icon-theme')
@@ -1,8 +1,8 @@
 pkgbase = proton-drive-for-linux
 	pkgdesc = Unofficial Proton Drive client: files-on-demand FUSE mount, CLI, GTK4 app and tray
-	pkgver = 2.4.0
+	pkgver = 2.6.1
 	pkgrel = 1
-	url = https://github.com/narrrl/proton-drive-linux
+	url = https://proton-drive.narl.io
 	arch = x86_64
 	license = MIT
 	makedepends = cargo
@@ -23,13 +23,13 @@ pkgbase = proton-drive-for-linux
 	optdepends = xdg-utils: "Open folder" action in the tray menu
 	optdepends = fzf: search-as-you-type launcher (pdfs-prompt --fzf)
 	optdepends = foot: terminal that hosts pdfs-prompt --fzf when started from a keybinding
-	provides = proton-drive-linux=2.4.0
+	provides = proton-drive-linux=2.6.1
 	provides = pdfs
 	conflicts = proton-drive-linux
 	conflicts = proton-drive-for-linux-bin
 	conflicts = proton-drive-for-linux-git
 	options = !lto
-	source = proton-drive-for-linux-2.4.0.tar.gz::https://github.com/narrrl/proton-drive-linux/archive/refs/tags/v2.4.0.tar.gz
+	source = proton-drive-for-linux-2.6.1.tar.gz::https://github.com/narrrl/proton-drive-linux/archive/refs/tags/v2.6.1.tar.gz
-	sha256sums = ae0f6daec257e9f7ba464ed6385bab7ac99f4247db0176296b2a58f703c24799
+	sha256sums = 6adc21c47744709ea789dfc95733bcc065d6b90a6ea3f6a43cccfa802b0a1600
 pkgname = proton-drive-for-linux
@@ -1,11 +1,11 @@
 # Maintainer: Nils Pukropp <contact@narl.io>
 pkgname=proton-drive-for-linux
-pkgver=2.4.0
+pkgver=2.6.1
 pkgrel=1
 pkgdesc="Unofficial Proton Drive client: files-on-demand FUSE mount, CLI, GTK4 app and tray"
 arch=('x86_64')
-url="https://github.com/narrrl/proton-drive-linux"
+url="https://proton-drive.narl.io"
 license=('MIT')
 depends=('fuse3' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc'
         'hicolor-icon-theme')
@@ -23,7 +23,7 @@ conflicts=('proton-drive-linux' 'proton-drive-for-linux-bin' 'proton-drive-for-l
 # LTO has broken GTK/Rust links for this workspace; the release profile keeps it off.
 options=('!lto')
 source=("$pkgname-$pkgver.tar.gz::$url/archive/refs/tags/v$pkgver.tar.gz")
-sha256sums=('ae0f6daec257e9f7ba464ed6385bab7ac99f4247db0176296b2a58f703c24799')
+sha256sums=('6adc21c47744709ea789dfc95733bcc065d6b90a6ea3f6a43cccfa802b0a1600')
 _srcname="proton-drive-linux-$pkgver"
@@ -14,7 +14,7 @@ Version:        %{version}
 Release:        1%{?dist}
 Summary:        Unofficial Proton Drive client for Linux (FUSE, CLI, GTK4 app + tray)
 License:        MIT
-URL:            https://github.com/narrrl/proton-drive-linux
+URL:            https://proton-drive.narl.io
 ExclusiveArch:  x86_64
 BuildRequires:  cargo
@@ -60,12 +60,18 @@ test -n "%{?git_dir}" || (echo 'Pass --define "git_dir $PWD" from the repo root'
 test -f %{git_dir}/Cargo.toml
 cp -a %{git_dir}/LICENSE .
 %build
 # The release workflow has already built target/release and passes --define "prebuilt 1".
 # rpmbuild exports its own compiler flags, which would make cargo rebuild everything.
 %if 0%{?prebuilt}
 test -x %{git_dir}/target/release/pdfs
 %else
 cd %{git_dir}
 cargo build --release --locked \
  --bin pdfs \
  --bin pdfs-tray \
  --bin pdfs-app \
  --bin pdfs-prompt
 %endif
 %install
 rel=%{git_dir}/target/release
@@ -28,6 +28,8 @@ crates/pdfs-gui/src/app/widgets/thumbnails.rs
 crates/pdfs-gui/src/app/widgets/versions_dialog.rs
 crates/pdfs-gui/src/dmenu.rs
 crates/pdfs-gui/src/fzf.rs
 crates/pdfs-gui/src/hud/mod.rs
 crates/pdfs-gui/src/hud/preview.rs
 crates/pdfs-gui/src/i18n.rs
 crates/pdfs-gui/src/main.rs
 crates/pdfs-gui/src/prompt.rs
@@ -4,20 +4,28 @@ set -Eeuo pipefail
 usage() {
    cat >&2 <<'EOF'
-usage: scripts/fuse-acceptance.sh [--offline-only] [OPTION ...]
+usage: scripts/fuse-acceptance.sh [OPTION ...]
       scripts/fuse-acceptance.sh --offline-only [OPTION ...]
       scripts/fuse-acceptance.sh --live MOUNTPOINT [MOUNTPOINT ...] [OPTION ...]
       scripts/fuse-acceptance.sh --managed-live EMPTY_DIR EMPTY_DIR [OPTION ...]
       scripts/fuse-acceptance.sh MOUNTPOINT [MOUNTPOINT ...]  # compatibility
-The local reference suite always runs first and requires no account; the mount
+With no mode, everything runs on the signed-in account: My files, then two
-is then diffed against its recorded behaviour. --live runs the same contract on
+sync folders it registers itself, through every pairing of on-demand and
-each mount. Set PDFS_ACCEPTANCE_CONVERGENCE=1 only when all live mountpoints
+mirror, with moves and copies between them. Everything it creates is removed
 afterwards, on failure and on Ctrl-C too, and permanently deleted from the
 trash; a run that was killed is cleaned up by the next one.
 --offline-only runs only the local reference suite, which needs no account.
 It always runs first; every mount is diffed against its recorded behaviour.
 --live runs the same contract on each given mount. Set PDFS_ACCEPTANCE_CONVERGENCE=1 only when all live mountpoints
 show the same remote folder.
 Options are forwarded to the Python runner. The useful ones:
  --list                  print every case and the targets it runs against
  --timeout SECONDS       per-case limit (default 180); a hung case dumps stacks
  --fail-fast             stop at the first failure instead of continuing
  --quick                 one on-demand/mirror pairing instead of all four
  --report-json PATH      machine-readable results and recorded observations
  --report-junit PATH     JUnit XML for CI
  --budget SECONDS        report any case slower than this
@@ -45,8 +53,11 @@ collect_paths() {
 case "${1:-}" in
    -h|--help) usage ;;
-    --offline-only|"")
+    "")
-        shift || true
+        exec "${runner[@]}" --account
        ;;
    --offline-only)
        shift
        exec "${runner[@]}" "$@"
        ;;
    --live)
@@ -60,10 +71,13 @@ case "${1:-}" in
        first="$1"; second="$2"; shift 2
        exec "${runner[@]}" --managed-live "$first" "$second" "$@"
        ;;
-    --*)
+    --account)
        # Bare options with no mode: an offline run with those options.
        exec "${runner[@]}" "$@"
        ;;
    --*)
        # Bare options with no mode: an account run with those options.
        exec "${runner[@]}" --account "$@"
        ;;
    *)
        collect_paths "$@"
        ;;
@@ -0,0 +1,134 @@
 #!/usr/bin/env bash
 # Publish the user documentation in docs/ to the GitHub wiki.
 #
 # The pages in docs/ are the source of truth; the wiki is a generated copy for
 # people who look there first. Each run clones the wiki, replaces the pages
 # listed below, rewrites links between them to wiki page names and every other
 # repository link to an absolute GitHub URL, regenerates Home and _Sidebar, and
 # commits. Nothing is pushed without --push.
 #
 # GitHub creates the wiki repository only when the first page is saved, so
 # create any page once in the web UI before the first run.
 #
 # usage: scripts/publish-wiki.sh [--push] [WORKDIR]
 set -euo pipefail
 repo_url="https://github.com/narrrl/proton-drive-linux"
 wiki_remote="git@github.com:narrrl/proton-drive-linux.wiki.git"
 push=0
 if [ "${1:-}" = "--push" ]; then
  push=1
  shift
 fi
 root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 workdir="${1:-$(mktemp -d)}"
 wiki="$workdir/wiki"
 if [ -d "$wiki/.git" ]; then
  git -C "$wiki" pull --ff-only --quiet
 else
  git clone --quiet "$wiki_remote" "$wiki"
 fi
 rev="$(git -C "$root" rev-parse --short HEAD)"
 version="$(grep -m1 '^version' "$root/Cargo.toml" | cut -d'"' -f2)"
 python3 - "$root" "$wiki" "$repo_url" "$version" <<'EOF'
 import pathlib
 import re
 import sys
 root, wiki, repo_url, version = sys.argv[1:]
 root = pathlib.Path(root)
 wiki = pathlib.Path(wiki)
 # docs/ file -> wiki page name, in sidebar order.
 PAGES = {
    "INSTALL.md": "Installation",
    "USER_GUIDE.md": "User-Guide",
    "CLI.md": "Command-Line-Reference",
    "CONFIGURATION.md": "Configuration",
    "TROUBLESHOOTING.md": "Troubleshooting",
    "RECOVERY.md": "Recovery",
 }
 LINK = re.compile(r"(\]\()([^)\s]+)(\))")
 def rewrite(target: str) -> str:
    if re.match(r"^[a-z]+:|^#", target):
        return target
    path, _, anchor = target.partition("#")
    anchor = f"#{anchor}" if anchor else ""
    if path in PAGES:
        return PAGES[path] + anchor
    # Anything else is a file in the repository: link to it on GitHub.
    resolved = (root / "docs" / path).resolve().relative_to(root)
    kind = "tree" if (root / resolved).is_dir() else "blob"
    return f"{repo_url}/{kind}/main/{resolved}{anchor}"
 def convert(text: str) -> str:
    return LINK.sub(lambda m: m.group(1) + rewrite(m.group(2)) + m.group(3), text)
 note = (
    "<!-- Generated from docs/ in the repository by scripts/publish-wiki.sh."
    " Edit the source there; changes made here are overwritten. -->\n\n"
 )
 for source, page in PAGES.items():
    text = (root / "docs" / source).read_text()
    (wiki / f"{page}.md").write_text(note + convert(text))
 def title(source: str) -> str:
    return (root / "docs" / source).read_text().splitlines()[0].lstrip("# ").strip()
 home = [
    note,
    "# Proton Drive for Linux\n\n",
    "An unofficial Proton Drive client for the Linux desktop: your files as a folder that ",
    "downloads on demand, synced local folders, Photos, sharing, a GTK4 app with tray and search ",
    "launcher, and a scriptable CLI.\n\n",
    f"This wiki mirrors the documentation of version {version}. The source, releases and issue ",
    f"tracker are in the [repository]({repo_url}).\n\n",
    "## Pages\n\n",
 ]
 home += [f"- [{title(source)}]({page})\n" for source, page in PAGES.items()]
 home += [
    "\n## More\n\n",
    f"- [Changelog]({repo_url}/blob/main/docs/CHANGELOG.md)\n",
    f"- [Architecture]({repo_url}/blob/main/docs/ARCHITECTURE.md)\n",
    f"- [Contributing]({repo_url}/blob/main/CONTRIBUTING.md)\n",
    f"- [Report a problem]({repo_url}/issues/new/choose)\n",
 ]
 (wiki / "Home.md").write_text("".join(home))
 sidebar = ["**[Home](Home)**\n\n"]
 sidebar += [f"- [{title(source)}]({page})\n" for source, page in PAGES.items()]
 sidebar += [
    "\n---\n\n",
    f"[Releases]({repo_url}/releases) · [Issues]({repo_url}/issues)\n",
 ]
 (wiki / "_Sidebar.md").write_text("".join(sidebar))
 EOF
 cd "$wiki"
 git add -A
 if git diff --cached --quiet; then
  echo "Wiki is already up to date."
  exit 0
 fi
 git commit --quiet -m "Update from docs at $rev"
 git show --stat --format='%s' HEAD
 if [ "$push" = 1 ]; then
  git push --quiet
  echo "Pushed to $wiki_remote."
 else
  echo "Committed in $wiki. Review it, then push from there or re-run with --push."
 fi
Author	SHA1	Message	Date
nvrl	3d6f53c16d	chore(release): 2.8.0	2026-09-30 03:56:47 +02:00
nvrl	8ceee5285b	chore(fuse): log how long each queued upload takes "pending upload landed" now carries upload_ms, the time on the wire, and total_ms, the whole op including the conflict check and gap-fill. A slow drain then shows where its time goes without a profiler.	2026-09-30 03:55:48 +02:00
nvrl	a181f1a5f0	fix(core,fuse): keep working through network drops The mount only ever went from offline to online: nothing marked it offline again, so after the Wi-Fi dropped every create, mkdir, delete and rename called Drive, waited out the SDK's retries for up to two minutes and answered EIO. Background loops kept polling the dead link. Connectivity now lives in pdfs-fuse's new link module and goes both ways. A call that gets no answer (a transport error or a request timeout) marks the mount offline; a probe thread checks every 2 s, backing off to 30 s, and on recovery re-lists folders served from the database, retries failed operations and wakes the drain. Interactive calls get a 20 s deadline, so a dead link costs one slow call instead of many. While offline: - create, mkdir, unlink, rmdir and rename fall back to the offline queue instead of answering EIO; - folders list from the database even when not marked listed, and are re-listed once the link returns; - reads of uncached data wait up to 30 s for the link, then retry once within the 120 s read deadline; - statfs serves the last quota instead of fetching, and quota refreshes are single-flight; - the event and photo event loops wait for the link instead of polling. A create whose request timed out may have landed anyway. When the drain replays it and finds a same-named twin of the same kind, created within the last two minutes and still empty, it adopts that node instead of making a conflict copy. The drain also leaves alone a name still held by a queued trash.	2026-09-30 03:25:00 +02:00
nvrl	7251f00e91	chore(deps): require proton SDK 0.7.1 0.7.1 sends TCP keepalives on its connections, so a link that dies silently is noticed instead of leaving a request waiting on a dead socket until its timeout.	2026-09-30 03:25:00 +02:00
nvrl	cb38f79aa3	fix(fuse,scripts): log why a create finds no parent and fit the metadata floor to FUSE A create that answered ENOENT left no trace in the log. It now warns when the parent folder is no longer known, and when the parent left the tree while its children were being listed, naming the parent inode and the new name. The acceptance script's metadata throughput floor was 20 operations per second, which a FUSE mount cannot reach: each create and unlink waits for Drive before it returns, about 350 ms apiece. On a FUSE mount the floor is now 3 operations per second; other paths keep 20. The mount type is read from /proc/self/mountinfo.	2026-09-29 21:22:54 +02:00
nvrl	54e9921efb	fix(fuse): stop reads deadlocking on size upgrades and retry stale renames A read that settles a provisional size invalidated the file's page cache while the kernel held that read's page lock, so the worker waited on itself forever (B110). Size upgrades now invalidate attributes only. Renaming a node right after renaming it could be refused by Drive as out of date, because the name hash read just before still held the old name. Every remote rename now goes through Core::rename_remote, which retries InvalidRequirements for up to ten seconds (B111).	2026-09-29 19:47:20 +02:00
nvrl	f252b09757	fix(fuse): keep the size of a file open for writing across re-listings B109: an online create seals an empty file on Drive, and until the last close the written bytes live only in the open handle. A re-listing of the parent, a size upgrade or a create landing re-interned the node with Drive's empty size, the kernel capped reads at that size, and SQLite reported "database disk image is malformed". State::keep_open_write_size now carries the handle's size and local mtime over in all three places. The acceptance script waits for My files to mount after a daemon restart instead of failing at once.	2026-09-29 16:49:13 +02:00
nvrl	a2992b3b9d	fix(core,fuse): keep replaced and vanished files from failing saves, reads and syncs Fixes from the account acceptance runs: - B104: a reader open across a rename-over keeps working; the replaced node is unlinked like any other open file instead of forgotten. - B105: a drain worker holding a revision withdrawn by an unlink no longer uploads it as a recovered-… conflict copy (Db::op_exists). - B106: an open victim's queued ops are withdrawn at trash time, so a repeated editor save no longer fails with AlreadyExists; the staged blob goes with the last close. - B107: a remote read gives up after 120 s with EIO instead of hanging its caller; the timer is built inside the runtime. - B108: a mirror upload whose local file was deleted after the scan is skipped rather than counted as an error. The acceptance script reports the failing line for non-assert errors, ignores queue ops that predate the run, purges with delete-forever first, and diagnoses a malformed SQLite database against a local replay.	2026-09-29 16:20:51 +02:00
nvrl	7b67db5ced	fix(core,fuse,cli): harden writes, trash and cleanup found by account acceptance runs The FUSE acceptance suite now runs on the signed-in account by default and cleans up after itself; its first live runs found three daemon bugs. - B101: a pwrite past EOF now authors the hole it leaves, so truncated bytes no longer come back from the base. A write attached to a create while that create uploads becomes a revision of the real uid instead of being dropped. - B102: removing a folder drops the queued revisions of files below it, found through the node tree, with their blobs and in-flight uploads. `pdfs rm` now drops queued ops too. - B103: each server call of a trash refresh times out after 120 s, so one hung call can no longer freeze the trash listing until restart. Acceptance suite: account mode with a manifest, lock and reaper; cleanup by uid; queued ops naming a test root count as leftovers; new edge-case, throughput and B100/B101 cases; the wide-directory case is split from the deep tree and gets a doubled budget. Adds `pdfs trash --json`.	2026-09-29 10:09:44 +02:00
nvrl	84c9ade8e3	fix(fuse): settle provisional sizes before reads and write opens A file listed by the cheap enumeration reports its ciphertext size until the size upgrade lands. Since B84 a read on that size fails with EIO, and a write open started its handle at it. Reads and write opens now fetch the real size first. A folder past the size-upgrade cap is queued instead of dropped, so a large copy no longer leaves most folders provisional (B100).	2026-09-29 07:37:41 +02:00
nvrl	9e26cd0285	chore(release): 2.7.0	2026-09-29 05:30:38 +02:00
nvrl	73e60f1151	chore: point homepage metadata at proton-drive.narl.io The About dialog's website link, the README, and the package metadata (Cargo, PKGBUILDs, AUR .SRCINFO, .deb, .rpm) now use the project homepage. Source code, issue, and release links stay on GitHub.	2026-09-29 05:30:38 +02:00
nvrl	088e8f3b0d	test(acceptance): cover moves between locations in the managed matrix Every managed mode pair now also moves trees between the two folders in both directions, moves several sources in one command, and passes a tree through My files and out again. Each case waits for Drive before and after, then checks the tree is only at the destination, byte for byte, with no conflict copies. Refusal cases cover a taken name, a folder into itself, a mirror source holding a symlink, and an on-demand file still open for writing.	2026-09-29 00:38:40 +02:00
nvrl	261d5dbf84	feat(core,fuse,cli): reuse cached content and take several sources in moves - A mirror download first copies the file out of the content cache when the same revision is cached whole or block by block, so moving a file out of an on-demand folder into a mirror costs no traffic for what was already read. - `pdfs move a b c DEST` moves every source, reports each failure and exits non-zero if any failed. - Mirror-to-mirror moves rename with RENAME_NOREPLACE, so a name that appeared at the destination after the check is never overwritten. - The local copy a move out of a mirror drops is checked again just before it is deleted; anything written into it meanwhile keeps the copy and is uploaded as new by the next pass.	2026-09-29 00:38:40 +02:00
nvrl	5f9d07aff1	feat(fuse,core,cli,gui): move between locations without transferring content A move request with two absolute paths is resolved against every location (My files, on-demand and mirror synced folders) and made as a server-side move_node. The local side is levelled afterwards: mounts forget and re-list, a mirror folder renames its copy and baseline along or drops the copy once Drive holds it. Anything only this disk holds is refused up front: queued ops, open writes, unsynced or ignored mirror files and symlinks. The GUI Move dialog gains a top-level list of locations.	2026-09-29 00:26:56 +02:00
nvrl	3fb7b9be6b	chore(release): 2.6.2	2026-09-28 23:58:26 +02:00
nvrl	6c3a50ce7f	fix(gui): let the Sync page use the full width The transfer label did not ellipsize, so a long file name set the column's minimum width and pushed it past the clamp. The page width changed with every file. The label now ellipsizes in the middle, and the Sync page drops the clamp so Overview and Folders fill the space next to the sidebar.	2026-09-28 23:58:26 +02:00
nvrl	f8304a0e86	fix(gui): keep Albums and Places selected when returning to Photos Every visit to the Photos page loaded the timeline, and a finished timeline load always shows the timeline. Leaving Albums or Places and coming back therefore showed the timeline under the Albums or Places toggle. A visit now reloads the view the toggle selects. An open album or place still loads its photos as before.	2026-09-28 23:58:26 +02:00
Nils Pukropp	e63f39f8c2	chore(aur): update packages to 2.6.1	2026-09-28 21:44:18 +00:00
nvrl	6f100dbe5e	chore(images) updated prompt image	2026-09-28 23:35:53 +02:00
nvrl	7c5ef269cd	chore(release): 2.6.1	2026-09-28 23:35:14 +02:00
nvrl	f13b6fc0ef	feat(gui): add pdfs-prompt --preload for session autostart --preload registers the resident GTK launcher and realizes its window without showing it, so the first shortcut opens it as fast as later ones. When a launcher is already running it exits without activating it. The application hold now happens in startup, which only the primary instance runs. Taken before registration, it also kept every remote invocation alive after it had forwarded its activation.	2026-09-28 23:35:14 +02:00
nvrl	3d61fc637b	ci(release): reuse cached builds from main The release job never hit a cache: its rust-cache key contained the job name, tags cannot restore caches of earlier tags, and rpmbuild rebuilt the whole workspace under its own compiler flags. CI on main now saves shared debug and release caches that the release workflow restores. Quality gates and the package build run in parallel, and the GitHub release is created once both pass. The RPM spec skips its cargo build when the caller passes --define "prebuilt 1".	2026-09-28 23:26:24 +02:00
Nils Pukropp	889b2aa4a9	chore(aur): update packages to 2.6.0	2026-09-28 21:22:30 +00:00
nvrl	8bd3867cb3	fix(gui): keep the launcher preview at its fixed width A wrapping label asks for its whole text on one line as its natural width, so a long location in the preview pane widened it, squeezed the results list and stretched the window. Cap the preview labels' natural width, limit detail values to three lines with a tooltip for the full location, and keep the pane from taking extra width.	2026-09-28 23:04:48 +02:00
nvrl	9577387c2f	chore(release): 2.6.0	2026-09-28 22:57:28 +02:00
nvrl	7a087b8827	feat(gui): rewrite the search launcher with a preview pane The launcher (pdfs-prompt) now follows the app's theme: the theme code moved into a shared theme.rs, the prompt's stylesheet lives in resources/prompt.css on the libadwaita palette, the Proton-purple accent pin is gone, and every activation re-reads the Proton theme and open_with settings so changes in the app apply without restarting the launcher. The window is rebuilt in src/hud/: - one list with Recent, Pinned and Best matches sections; a click selects, a double-click or Enter opens, focus stays in the entry - rows show a thumbnail, the name with its matched characters in bold, location, sync badge, size and age - a preview pane with a large thumbnail, type, size, modified date, location and availability, plus Open (Enter), Show in Folder (Ctrl+Enter, via FileManager1) and Copy Path (Ctrl+C / Ctrl+Shift+C) - thumbnails from the freedesktop cache, local decoding (written back to the shared cache) or the daemon, on two worker threads - a history of opened files that fills the Recent section and adds a frecency bonus to search ranking - the mount check before opening a Drive file runs off the main thread with a 2 s timeout, and Escape cancels a slow open - rows can be dragged out as files - the search debounce drops to 80 ms New strings are translated in every catalog.	2026-09-28 22:53:46 +02:00
nvrl	7099106802	docs: show the Places map screenshot Rename photos_mpa.png to photos_map.png and add it to the README screenshot table.	2026-09-28 22:10:14 +02:00
nvrl	43385d36ee	chore(images) added up to date images	2026-09-28 22:09:07 +02:00
nvrl	4b97f401cb	docs: refresh screenshots Replace the Photos screenshot with one of placeholder stock photos, add Sync, conflict history and Computers screenshots, and drop the retired Activity, Settings, Shared and restore-devices images from the README.	2026-09-28 22:08:16 +02:00
nvrl	af869944cf	docs: restructure and update documentation for 2.5.0 Split the README into a short front page and task-oriented pages under docs/: installation, user guide, CLI reference, configuration and troubleshooting, with an index in docs/README.md. Rewrite RECOVERY.md around Continue This Backup Here and Restore Folders, and DEVELOPMENT.md around running, debugging and releasing from source. Bring ARCHITECTURE.md up to date with the read path, push events, the thread map, conflict copies and the machine profile, and move the feature design notes there. Collect planned work in ROADMAP.md. Link the threat model from SECURITY.md and the translation rules from CONTRIBUTING.md. Add scripts/publish-wiki.sh, which mirrors the user pages to the GitHub wiki with rewritten links and only pushes with --push.	2026-09-28 20:04:22 +02:00
Nils Pukropp	4b90abf3b5	chore(aur): update packages to 2.5.0	2026-09-28 16:56:58 +00:00