sioul_app/

backend.rs

// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright © 2026 Aurélien Pierre

//! The object behind the window.
//!
//! It hands QML the core's views as JSON (`sioul_core::view`), already in your
//! language, and runs everything slow on background threads: fetching mail,
//! finding servers, testing logins. Results come back to Qt's thread through
//! `qt_thread().queue`. Each mail account has a watcher that keeps its inbox
//! open with IDLE, so a verified code becomes a notification within seconds.

use cxx_qt::{CxxQtType, Threading};
use cxx_qt_lib::QString;
use jiff::Zoned;
use sioul_core::budget::{self, Ledger, MailLine};
use sioul_core::card::ImapOrigin;
use sioul_core::projects::ProjectStore;
use sioul_core::config::{self, Account, Config, Priority, Security};
use sioul_core::i18n::{self, Translator};
use sioul_core::porch::{self, KnownSenders, SenderList, Triaged};
use sioul_core::state::{MoneyState, PorchState};
use sioul_core::{maildir, reading, view};
use crate::{crypto, gmail, mail, pim, securitykey, work};
use sioul_sync::antivirus::{self, Verdict};
use sioul_sync::{Control, Learned, Report, SyncError, notify, secret};
use std::collections::{BTreeMap, BTreeSet};
use std::hash::{Hash, Hasher};
use std::path::{Path, PathBuf};
use std::pin::Pin;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex, OnceLock};

#[cxx_qt::bridge]
pub mod qobject {
    // SAFETY: cxx checks these declarations against the headers they include, when it builds; the types are cxx-qt-lib's.
    unsafe extern "C++" {
        include!("cxx-qt-lib/qstring.h");
        type QString = cxx_qt_lib::QString;
    }

    #[auto_cxx_name]
    extern "RustQt" {
        #[qobject]
        #[qml_element]
        #[qproperty(QString, porch)]
        #[qproperty(QString, budgets)]
        #[qproperty(QString, accounts)]
        #[qproperty(QString, blocked)]
        #[qproperty(QString, status)]
        #[qproperty(bool, busy)]
        #[qproperty(QString, found)]
        #[qproperty(QString, scouted)]
        #[qproperty(bool, scouting)]
        #[qproperty(QString, form_error)]
        #[qproperty(bool, form_busy)]
        #[qproperty(QString, mail_accounts)]
        #[qproperty(QString, mail_folder)]
        #[qproperty(QString, drafts)]
        // The Mail page's search by conditions: its sentence, what the servers said, the rows (`mailsearch`).
        #[qproperty(QString, mail_search)]
        #[qproperty(QString, undo_line)]
        #[qproperty(QString, contacts)]
        // The Contacts page's duplicates (`duplicates::find`), looked for off the window's thread when asked.
        #[qproperty(QString, duplicates)]
        #[qproperty(QString, agenda)]
        // Two events at once in the next two weeks (`pim::overlaps`), made with the agenda, off the window's thread.
        #[qproperty(QString, overlaps)]
        // The Health page, the Porch's doses (today's not marked yet, and those due
        // while Sioul was closed: `health::missed`), today's meals and naps
        // (`health::show_health`), made off the window's thread: they read the
        // doses' record and your other devices' claims.
        #[qproperty(QString, health_view)]
        #[qproperty(QString, missed_view)]
        #[qproperty(QString, needs_view)]
        #[qproperty(QString, tasks)]
        #[qproperty(QString, notes)]
        #[qproperty(QString, focus_session)]
        #[qproperty(QString, reading)]
        #[qproperty(bool, realtime)]
        // Put away on a phone (in the background): the pages' clocks and reloads stop until it is back.
        #[qproperty(bool, away)]
        #[qproperty(QString, mode)]
        #[qproperty(QString, forecast)]
        #[qproperty(QString, places_found)]
        type Sioul = super::SioulRust;

        /// A sentence of the interface, in your language.
        #[qinvokable]
        fn text(self: &Sioul, id: &QString) -> QString;

        /// The same, with one named argument.
        #[qinvokable]
        fn text_with(self: &Sioul, id: &QString, name: &QString, value: &QString) -> QString;

        /// A counted message, its plural chosen by `n` (`$n`, `$count`, `$countf`…: `Translator::counted`).
        #[qinvokable]
        fn text_counted(self: &Sioul, id: &QString, n: i32) -> QString;

        /// A sentence with several arguments, given as a JSON object of names and values.
        #[qinvokable]
        fn text_args(self: &Sioul, id: &QString, args: &QString) -> QString;

        /// Shows what is on disk, then starts a watcher per mail account.
        #[qinvokable]
        fn start(self: Pin<&mut Sioul>);

        /// Computes the views again: windows open and close, codes expire.
        #[qinvokable]
        fn refresh(self: Pin<&mut Sioul>);

        /// Fetches mail now, and restarts watchers that stopped.
        #[qinvokable]
        fn sync_now(self: Pin<&mut Sioul>);

        /// Opens the Porch outside an admin window, until "Done for now".
        #[qinvokable]
        fn open_anyway(self: Pin<&mut Sioul>);

        /// Closes the Porch on what it shows.
        #[qinvokable]
        fn done(self: Pin<&mut Sioul>);

        /// Reads a message for the reading pane off the window's thread, so
        /// that a large or hostile one never holds the window (and the
        /// doses' reminders with it): `message_read` brings it.
        #[qinvokable]
        fn read_message(self: Pin<&mut Sioul>, key: &QString);

        /// Has the antivirus check an attachment, then opens it with the desktop's application.
        #[qinvokable]
        fn open_attachment(self: Pin<&mut Sioul>, key: &QString, index: i32);

        /// Has the antivirus check an attachment, then copies it into the downloads folder.
        #[qinvokable]
        fn save_attachment(self: Pin<&mut Sioul>, key: &QString, index: i32);

        /// Opens, saves (1) or keeps as a paper (2) an attachment without a check: there is no antivirus,
        /// and you said to go on.
        #[qinvokable]
        fn attachment_unchecked(self: Pin<&mut Sioul>, key: &QString, index: i32, what: i32);

        /// Has the antivirus check an attachment, then keeps it in the papers wallet; `paper_kept` follows.
        #[qinvokable]
        fn keep_attachment_as_paper(self: Pin<&mut Sioul>, key: &QString, index: i32);

        /// Whether attachments open here without an antivirus check: a phone has
        /// none Sioul can call (`attachments`); the Reader says so.
        #[qinvokable]
        fn attachments_unscanned(self: &Sioul) -> bool;

        /// The papers wallet, as JSON (`papers::view`).
        #[qinvokable]
        fn papers(self: &Sioul) -> QString;

        /// A paper saved (new when `id` is empty) from the form's JSON; returns what went wrong, else "".
        #[qinvokable]
        fn save_paper(self: Pin<&mut Sioul>, id: &QString, edit: &QString) -> QString;

        /// A paper taken out of the wallet, its file left where it is; returns what went wrong, else "".
        #[qinvokable]
        fn remove_paper(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// A paper's renewal planned as a task; returns what went wrong, else "".
        #[qinvokable]
        fn plan_renewal(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// Lets a sender in: they leave the screener.
        #[qinvokable]
        fn let_in(self: Pin<&mut Sioul>, address: &QString);

        /// Blocks an address, or `@domain`: their mail is set aside for good.
        #[qinvokable]
        fn block(self: Pin<&mut Sioul>, entry: &QString);

        /// Blocks an address, or `@domain`, from one of their messages (its
        /// file, `key`): as `block`, and the message goes into the spam filter's label log.
        #[qinvokable]
        fn block_from(self: Pin<&mut Sioul>, entry: &QString, key: &QString);

        /// Out of the blocked list; written neutral when a category or a domain would still block it.
        #[qinvokable]
        fn unblock(self: Pin<&mut Sioul>, entry: &QString);

        /// An address or a pattern marked "safe", "neutral", "restricted" or
        /// "blocked", out of the three other lists; "": out of every list, its
        /// categories, else its domain, deciding (docs/porch.md).
        #[qinvokable]
        fn set_standing(self: Pin<&mut Sioul>, entry: &QString, standing: &QString);

        /// Who an address is: "safe", "neutral", "restricted", "blocked" or "stranger".
        #[qinvokable]
        fn standing(self: &Sioul, address: &QString) -> QString;

        /// "Their mail" for a person (`addresses`: a JSON array of theirs, or
        /// one): where they stand and why, the choices with their times (`senders`).
        #[qinvokable]
        fn standing_of(self: &Sioul, addresses: &QString) -> QString;

        /// "Their mail" chosen for every address given (a JSON array, or one):
        /// a list's name, or "" for "As their categories say".
        #[qinvokable]
        fn set_standing_of(self: Pin<&mut Sioul>, addresses: &QString, standing: &QString);

        /// "Their list" for a contact's card (`key`: its file): who they are,
        /// why, the choices, their addresses and numbers with lists of their own (`senders`).
        #[qinvokable]
        fn person_of(self: &Sioul, key: &QString) -> QString;

        /// "Their list" chosen for a contact's card, all their addresses and
        /// numbers: a list's name, or "" for "As their categories say".
        #[qinvokable]
        fn set_person(self: Pin<&mut Sioul>, key: &QString, standing: &QString);

        /// Writes the line a message about money stands for into a budget.
        #[qinvokable]
        fn add_mail_line(self: Pin<&mut Sioul>, key: &QString, budget: &QString);

        /// Leaves a message about money out of the budgets.
        #[qinvokable]
        fn ignore_mail_line(self: Pin<&mut Sioul>, key: &QString);

        /// Finds the IMAP server of an address; the answer comes in `found`.
        #[qinvokable]
        fn discover(self: Pin<&mut Sioul>, address: &QString);

        /// An account switched on or off: off, it keeps its settings and is
        /// neither synced nor shown. Returns what went wrong, if anything.
        #[qinvokable]
        fn set_account_enabled(self: Pin<&mut Sioul>, id: &QString, on: bool) -> QString;

        /// What the server of an address offers (mail, calendars and contacts,
        /// a Nextcloud's apps), into `scouted`, as JSON.
        #[qinvokable]
        fn scout_account(self: Pin<&mut Sioul>, address: &QString);

        /// Mail added to an address that has calendars and contacts already, with their password.
        #[qinvokable]
        fn add_mail_like(self: Pin<&mut Sioul>, address: &QString, host: &QString, port: i32, security: &QString, login: &QString);

        /// Tests the login, keeps the password in the keyring, adds the account.
        #[qinvokable]
        fn add_account(self: Pin<&mut Sioul>, address: &QString, host: &QString, port: i32, security: &QString, login: &QString, password: &QString);

        /// Adds a web-only mailbox.
        #[qinvokable]
        fn add_portal(self: Pin<&mut Sioul>, name: &QString, url: &QString);

        /// Removes an account and its password; its mail stays on disk.
        #[qinvokable]
        fn remove_account(self: Pin<&mut Sioul>, id: &QString);

        /// An account's password given on this device (one come from another
        /// device arrives without it): tested with its server, then kept;
        /// `account_password_done` says how it went.
        #[qinvokable]
        fn set_account_password(self: Pin<&mut Sioul>, id: &QString, password: &QString);

        /// Ranks an account's mail: "above", "average" or "below".
        #[qinvokable]
        fn set_priority(self: Pin<&mut Sioul>, id: &QString, priority: &QString);

        /// Shows a folder of an account: the last two weeks, or `all`; `query` searches it.
        #[qinvokable]
        fn open_folder(self: Pin<&mut Sioul>, account: &QString, folder: &QString, all: bool, query: &QString);

        /// A message was opened: it is marked read.
        #[qinvokable]
        fn opened(self: Pin<&mut Sioul>, key: &QString);

        /// Does something to a message: "read", "unread", "flag", "unflag" at once;
        /// "archive", "trash", "junk", "not-junk", "not-spam" (mail set aside as
        /// spam, back in its lane), "move" (to `target`) after ten seconds to undo.
        #[qinvokable]
        fn act(self: Pin<&mut Sioul>, key: &QString, action: &QString, target: &QString);

        /// The same act on several messages (a JSON list of keys), under one "Undo".
        #[qinvokable]
        fn act_many(self: Pin<&mut Sioul>, keys: &QString, action: &QString);

        /// Messages (a JSON list of keys) into a folder of an account, theirs or another.
        #[qinvokable]
        fn move_messages(self: Pin<&mut Sioul>, keys: &QString, account: &QString, folder: &QString);

        /// Searches the mail by conditions (`mailsearch::Search`, as JSON): the
        /// mail here at once, the servers after a pause in typing, or at once
        /// (`now`); `mailSearch` follows.
        #[qinvokable]
        fn search_mail(self: Pin<&mut Sioul>, search: &QString, now: bool);

        /// Closes the search: the page shows its folder again.
        #[qinvokable]
        fn clear_mail_search(self: Pin<&mut Sioul>);

        /// Brings a message the search found on its server only here; `mailSearch` then names its file.
        #[qinvokable]
        fn bring_message(self: Pin<&mut Sioul>, key: &QString);

        /// What the search's column offers (fields, comparisons, your addresses and folders), as JSON.
        #[qinvokable]
        fn mail_search_fields(self: &Sioul) -> QString;

        /// Leaves the list a message comes from (docs/client.md, "Unsubscribing"):
        /// one click or a message after ten seconds to undo; returns the web page
        /// to open in the browser when the list takes it only there, else "".
        #[qinvokable]
        fn unsubscribe(self: Pin<&mut Sioul>, key: &QString) -> QString;

        /// Cancels the newest act still waiting.
        #[qinvokable]
        fn undo(self: Pin<&mut Sioul>);

        /// The window closes: what waits is done now.
        #[qinvokable]
        fn flush(self: Pin<&mut Sioul>);

        /// Starts a draft ("new", "reply", "reply-all", "forward"); returns its name, or "" when it cannot.
        #[qinvokable]
        fn compose(self: Pin<&mut Sioul>, kind: &QString, key: &QString, account: &QString) -> QString;

        /// A draft as the writing window shows it, as JSON.
        #[qinvokable]
        fn draft(self: &Sioul, id: &QString) -> QString;

        /// Saves what the writing window holds (JSON); returns "Saved at 14:02", or what went wrong.
        #[qinvokable]
        fn save_draft(self: Pin<&mut Sioul>, edit: &QString) -> QString;

        /// Attaches a file (a `file://` URL); returns what went wrong, if anything.
        #[qinvokable]
        fn attach(self: Pin<&mut Sioul>, id: &QString, url: &QString) -> QString;

        /// Takes an attachment off a draft: one added, or one a forward carries.
        #[qinvokable]
        fn detach(self: Pin<&mut Sioul>, id: &QString, index: i32, forwarded: bool);

        /// What the Markdown becomes, for the preview.
        #[qinvokable]
        fn preview(self: &Sioul, markdown: &QString) -> QString;

        /// Sends after ten seconds to undo; returns what stops it now, else "".
        #[qinvokable]
        fn send(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// Deletes a draft after ten seconds to undo.
        #[qinvokable]
        fn discard(self: Pin<&mut Sioul>, id: &QString);

        /// The writing window closed.
        #[qinvokable]
        fn draft_closed(self: Pin<&mut Sioul>, id: &QString);

        /// Where a message is: its account and folder, as JSON.
        #[qinvokable]
        fn place(self: &Sioul, key: &QString) -> QString;

        /// The message as it came, for "Show the source".
        #[qinvokable]
        fn source(self: &Sioul, key: &QString) -> QString;

        /// Your name as recipients see it, and your signature.
        #[qinvokable]
        fn set_writing(self: Pin<&mut Sioul>, id: &QString, name: &QString, signature: &QString);

        /// For development and documentation: the folder in `SIOUL_GRAB`, where
        /// the window saves each page as an image before quitting; empty otherwise.
        #[qinvokable]
        fn grab_folder(self: &Sioul) -> QString;

        /// Shows the contacts matching `query` (names, addresses, numbers, organisations).
        #[qinvokable]
        fn search_contacts(self: Pin<&mut Sioul>, query: &QString);

        /// A contact, every field, as JSON; empty when it cannot be read.
        #[qinvokable]
        fn contact(self: &Sioul, key: &QString) -> QString;

        /// Saves the contact form (JSON); an empty key makes a new contact.
        /// Returns {"key": …} or {"error": …}.
        #[qinvokable]
        fn save_contact(self: Pin<&mut Sioul>, key: &QString, edit: &QString) -> QString;

        /// Deletes a contact after ten seconds to undo.
        #[qinvokable]
        fn delete_contact(self: Pin<&mut Sioul>, key: &QString);

        /// Shows the contacts of one category only; empty: all of them.
        #[qinvokable]
        fn show_contacts_category(self: Pin<&mut Sioul>, category: &QString);

        /// Looks for duplicates in the contacts, off the window's thread: they come in `duplicates`.
        #[qinvokable]
        fn find_duplicates(self: Pin<&mut Sioul>);

        /// Takes the duplicates off these cards (a JSON list of their files), one
        /// write each; returns what went wrong, else "".
        #[qinvokable]
        fn clean_contacts(self: Pin<&mut Sioul>, keys: &QString) -> QString;

        /// Merges two cards, `lead` keeping its name, the other deleted; returns {"key"} or {"error"}.
        #[qinvokable]
        fn merge_contacts(self: Pin<&mut Sioul>, lead: &QString, other: &QString) -> QString;

        /// Two cards are not one person: never offered again; returns what went wrong, else "".
        #[qinvokable]
        fn not_same_contacts(self: Pin<&mut Sioul>, first: &QString, second: &QString) -> QString;

        /// Puts the cards back as they were before what was done (`duplicates`' "done"); returns what went wrong, else "".
        #[qinvokable]
        fn undo_contacts(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// Shows `days` days of the agenda from `from` ("2026-10-05"; empty: today).
        #[qinvokable]
        fn show_days(self: Pin<&mut Sioul>, from: &QString, days: i32, upcoming: bool);

        /// The calendars a new event can go into, as JSON.
        #[qinvokable]
        fn calendars(self: &Sioul) -> QString;

        /// An event as its form shows it, as JSON. Not `event`, which would hide QObject::event.
        #[qinvokable]
        fn event_form(self: &Sioul, key: &QString) -> QString;

        /// Saves the event form (JSON); an empty key makes a new event in `calendar`.
        /// Returns what went wrong, else "".
        #[qinvokable]
        fn save_event(self: Pin<&mut Sioul>, key: &QString, edit: &QString, calendar: &QString) -> QString;

        /// An event's reminder before it, the occurrence starting at `start`,
        /// as its details say it: JSON {line, remind, writable} (docs/reminders.md).
        #[qinvokable]
        fn event_reminder(self: &Sioul, key: &QString, start: f64) -> QString;

        /// The choices of an event's reminder before it, JSON [{value, label}];
        /// `current` among them when it is another time.
        #[qinvokable]
        fn reminder_choices(self: &Sioul, current: &QString) -> QString;

        /// An event's own reminder changed for every time it comes ("" as
        /// usual, "none", "15"); returns what went wrong, else "".
        #[qinvokable]
        fn set_event_reminder(self: Pin<&mut Sioul>, key: &QString, value: &QString) -> QString;

        /// Deletes an event, or only the occurrence starting at `start`, after ten seconds to undo.
        #[qinvokable]
        fn delete_event(self: Pin<&mut Sioul>, key: &QString, start: f64, only_this: bool);

        /// An event dragged: its occurrence starting at `start` now from
        /// `new_start` to `new_end` (Unix seconds), that time alone or every
        /// time; "Undo" offered. Returns what went wrong, else "".
        #[qinvokable]
        fn move_event(self: Pin<&mut Sioul>, key: &QString, start: f64, new_start: f64, new_end: f64, only_this: bool) -> QString;

        /// Addresses from the contacts for what is typed in an address field, as JSON.
        #[qinvokable]
        fn completions(self: &Sioul, typed: &QString) -> QString;

        /// The contact with this address, by file; empty when none.
        #[qinvokable]
        fn contact_for(self: &Sioul, address: &QString) -> QString;

        /// Makes a contact of a sender.
        #[qinvokable]
        fn add_sender(self: Pin<&mut Sioul>, name: &QString, address: &QString);

        /// Answers an invitation: "accepted", "tentative", "declined"; "add" or "remove" for events sent without a question.
        #[qinvokable]
        fn answer_invitation(self: Pin<&mut Sioul>, key: &QString, answer: &QString);

        /// How far back mail and the agenda reach, in weeks; 0 for everything.
        #[qinvokable]
        fn history_weeks(self: &Sioul) -> i32;

        /// The hour the day and week planning open on.
        #[qinvokable]
        fn day_start(self: &Sioul) -> i32;

        /// Sets how far back mail and the agenda reach; the older mail comes at the next fetch.
        #[qinvokable]
        fn set_history(self: Pin<&mut Sioul>, weeks: i32);

        /// Adds a contacts-and-calendars account (CardDAV, CalDAV); the server address may be empty.
        #[qinvokable]
        fn add_dav(self: Pin<&mut Sioul>, address: &QString, url: &QString, login: &QString, password: &QString);

        /// Adds a Google account with your OAuth client: Google's page opens in
        /// the browser, Sioul waits for its answer. `again`: an account's id, signed in again.
        #[qinvokable]
        fn add_google(self: Pin<&mut Sioul>, address: &QString, client_id: &QString, client_secret: &QString, again: &QString);

        /// Stops waiting for Google's page.
        #[qinvokable]
        fn cancel_google(self: Pin<&mut Sioul>);

        /// Adds an address's Google mail signed in on Google's page, with a
        /// key of your own (given, else kept on this device), or signs its
        /// account in again (`again`: its id). IMAP and SMTP then take an
        /// access token (XOAUTH2): no password (docs/google.md, "Mail").
        #[qinvokable]
        fn add_google_mail(self: Pin<&mut Sioul>, address: &QString, client_id: &QString, client_secret: &QString, again: &QString);

        /// Your OpenPGP keys and others', as JSON.
        #[qinvokable]
        fn pgp_keys(self: &Sioul) -> QString;

        /// Makes a key for one of your addresses.
        #[qinvokable]
        fn pgp_generate(self: Pin<&mut Sioul>, address: &QString);

        /// Imports keys from a file (`file://`); returns what went wrong, else "".
        #[qinvokable]
        fn pgp_import(self: Pin<&mut Sioul>, url: &QString, passphrase: &QString) -> QString;

        /// Saves a public key into the downloads folder.
        #[qinvokable]
        fn pgp_export(self: Pin<&mut Sioul>, fingerprint: &QString);

        /// Saves a copy of the revocation certificate of a key made here into the downloads folder.
        #[qinvokable]
        fn pgp_save_revocation(self: Pin<&mut Sioul>, fingerprint: &QString);

        /// Removes a key; yours are kept aside, never deleted.
        #[qinvokable]
        fn pgp_remove(self: Pin<&mut Sioul>, fingerprint: &QString);

        /// Looks up the keys a draft's recipients miss (their domain, then keys.openpgp.org).
        #[qinvokable]
        fn pgp_lookup(self: Pin<&mut Sioul>, draft: &QString);

        /// The security key that signs a draft at Send, as JSON {ident, label},
        /// or {expired} when its certificate expired; "" when it is signed
        /// another way, or not at all.
        #[qinvokable]
        fn security_key_for_draft(self: &Sioul, id: &QString) -> QString;

        /// Signs a draft with your security key, then sends it after ten
        /// seconds to undo; `pin` as typed, or "" for the one held. What the
        /// band shows comes in `security_key_changed`, for the draft's id.
        #[qinvokable]
        fn sign_and_send(self: Pin<&mut Sioul>, id: &QString, pin: &QString);

        /// "Open with your security key": `pin` as typed, or "" for the one
        /// held. What the band shows comes in `security_key_changed`, for the message's key.
        #[qinvokable]
        fn open_with_security_key(self: Pin<&mut Sioul>, key: &QString, pin: &QString);

        /// "Not now": the band stops waiting for the security key.
        #[qinvokable]
        fn security_key_not_now(self: Pin<&mut Sioul>, context: &QString);

        /// "Let GnuPG release it": GnuPG's smart card daemon stopped. JSON {line, done}.
        #[qinvokable]
        fn let_gnupg_release(self: Pin<&mut Sioul>) -> QString;

        /// Your security keys, as JSON, for Accounts ▸ Encryption.
        #[qinvokable]
        fn security_keys(self: &Sioul) -> QString;

        /// "Use a security key": reads the key plugged in, without its PIN.
        #[qinvokable]
        fn read_security_key(self: Pin<&mut Sioul>);

        /// "Look for it", "Look for a newer version": the key's certificate,
        /// looked up now that you asked; `ident` empty for the key just read.
        #[qinvokable]
        fn find_security_key_certificate(self: Pin<&mut Sioul>, ident: &QString);

        /// "Import a file…": the key's certificate from a file (`file://`).
        #[qinvokable]
        fn import_security_key_certificate(self: Pin<&mut Sioul>, ident: &QString, url: &QString);

        /// "Import from GnuPG": the key's certificate as your GnuPG keeps it;
        /// `ident` empty for the key just read.
        #[qinvokable]
        fn import_security_key_from_gnupg(self: Pin<&mut Sioul>, ident: &QString);

        /// "Renew for two years": GnuPG renews the key, its pinentry asking the PIN.
        #[qinvokable]
        fn renew_security_key(self: Pin<&mut Sioul>, ident: &QString);

        /// "Send it to keys.openpgp.org", pressed once its sentence was read.
        #[qinvokable]
        fn send_security_key_to_keys_openpgp(self: Pin<&mut Sioul>, ident: &QString);

        /// "Forget the PIN now".
        #[qinvokable]
        fn forget_security_key_pin(self: Pin<&mut Sioul>);

        /// "Stop using this security key".
        #[qinvokable]
        fn stop_using_security_key(self: Pin<&mut Sioul>, ident: &QString);

        /// The task page's choices: the list grouped "project" or "list", done tasks, a search, one project.
        #[qinvokable]
        fn show_tasks(self: Pin<&mut Sioul>, by: &QString, done: bool, query: &QString, project_id: &QString);

        /// Tasks of one kind ("call"…) and one category only; "" for all. Kept for next time.
        #[qinvokable]
        fn filter_tasks(self: Pin<&mut Sioul>, kind: &QString, category: &QString);

        /// Asleep, the tasks all the same ("Show anyway"), until the page is left.
        #[qinvokable]
        fn show_tasks_anyway(self: Pin<&mut Sioul>, on: bool);

        /// Reads tasks and notes again and shows them.
        #[qinvokable]
        fn refresh_work(self: Pin<&mut Sioul>);

        /// One task in full, with its steps and what it is tied to, as JSON.
        #[qinvokable]
        fn task(self: &Sioul, uid: &QString) -> QString;

        /// The form of a task not made yet, as `task` gives one (without a card):
        /// blank, or what Add ▾ makes from `from` (a message's `key`, an
        /// occurrence's `start`); in `list`, else the usual list. Nothing is
        /// written: `save_task` with an empty UID makes it. Or {"error"}.
        #[qinvokable]
        fn new_task_form(self: &Sioul, from: &QString, key: &QString, start: f64, list: &QString) -> QString;

        /// Saves the task form (JSON); an empty UID makes a new task in `list`.
        /// Returns {"uid": …} or {"error": …}.
        #[qinvokable]
        fn save_task(self: Pin<&mut Sioul>, uid: &QString, edit: &QString, list: &QString) -> QString;

        /// What a typed line says (its chips), before it becomes a task, as JSON.
        #[qinvokable]
        fn capture(self: &Sioul, line: &QString) -> QString;

        /// A task from a typed line; a step of `parent` when given. Returns {"uid"} or {"error"}.
        #[qinvokable]
        fn add_task(self: Pin<&mut Sioul>, line: &QString, parent: &QString, list: &QString) -> QString;

        /// "completed", "in-process", "needs-action", "cancelled"; returns what it changed, in a sentence.
        #[qinvokable]
        fn set_task_status(self: Pin<&mut Sioul>, uid: &QString, status: &QString) -> QString;

        /// How a task was, felt: today's rating ({cognitive, emotional, anxiety,
        /// body, gain}, null for unsaid), written alone; returns what went wrong, else "".
        #[qinvokable]
        fn set_felt(self: Pin<&mut Sioul>, uid: &QString, felt: &QString) -> QString;

        /// The task waits for `other`, or no longer; with `gap_minutes`, that long
        /// after `other` is done (`work::set_waits`). Returns what went wrong, else "".
        #[qinvokable]
        fn set_waits(self: Pin<&mut Sioul>, uid: &QString, other: &QString, wait: bool, gap_minutes: i32) -> QString;

        /// Puts a task off until tomorrow.
        #[qinvokable]
        fn not_now(self: Pin<&mut Sioul>, uid: &QString);

        /// How today is: "clear", "haze", "fog".
        #[qinvokable]
        fn set_weather(self: Pin<&mut Sioul>, weather: &QString);

        /// Deletes a task after ten seconds to undo.
        #[qinvokable]
        fn delete_task(self: Pin<&mut Sioul>, uid: &QString);

        /// A task pinned to a time ("2026-10-06T14:30"), its time block (an
        /// event) made or moved there, as long as it is, else as the plan lays
        /// it; or left to the plan (""), its blocks to come taken away; "Undo"
        /// offered. Returns what went wrong, else "".
        #[qinvokable]
        fn set_task_at(self: Pin<&mut Sioul>, uid: &QString, at: &QString) -> QString;

        /// A task pinned to a time ("2026-10-06T14:30") for `minutes` (0: as
        /// long as its block is, else as the plan lays it): "Do at…", or a step
        /// dragged in the day view (docs/tasks.md, "Pinned to a time"); "Undo"
        /// offered. Returns what went wrong, else "".
        #[qinvokable]
        fn pin_task(self: Pin<&mut Sioul>, uid: &QString, at: &QString, minutes: i32) -> QString;

        /// Open tasks whose title holds `query`, `except` left out, as JSON.
        #[qinvokable]
        fn search_tasks(self: &Sioul, query: &QString, except: &QString) -> QString;

        /// Makes a task list in an account ("local": kept here only); returns "account/id", or what went wrong.
        #[qinvokable]
        fn new_list(self: Pin<&mut Sioul>, account: &QString, name: &QString) -> QString;

        /// The accounts a task list can be made in, as JSON.
        #[qinvokable]
        fn list_accounts(self: &Sioul) -> QString;

        /// Starts a focus session on a task.
        #[qinvokable]
        fn focus_start(self: Pin<&mut Sioul>, uid: &QString, minutes: i32);

        /// Pauses the focus session, or goes on.
        #[qinvokable]
        fn focus_pause(self: Pin<&mut Sioul>);

        /// More minutes for the focus session.
        #[qinvokable]
        fn focus_extend(self: Pin<&mut Sioul>, minutes: i32);

        /// Ends the focus session, kept with where you stopped; returns what it changed.
        #[qinvokable]
        fn focus_stop(self: Pin<&mut Sioul>, done: bool, note: &QString) -> QString;

        /// Shows the notes matching `query`.
        #[qinvokable]
        fn search_notes(self: Pin<&mut Sioul>, query: &QString);

        /// One note: text, HTML, tags, checkboxes, what is tied to it, as JSON.
        #[qinvokable]
        fn note(self: &Sioul, path: &QString) -> QString;

        /// Saves a note read as `stamp` (its "stamp" in `note`); returns JSON
        /// {problem, stamp, path, kept}: when the file changed meanwhile, this
        /// version went beside it, at `path`, and `kept` says so.
        #[qinvokable]
        fn save_note(self: Pin<&mut Sioul>, path: &QString, text: &QString, stamp: &QString) -> QString;

        /// A new note in the notes folder, linking `links` (a JSON list); returns its path.
        #[qinvokable]
        fn create_note(self: Pin<&mut Sioul>, title: &QString, links: &QString) -> QString;

        /// What a thing is tied to, both ways, as JSON.
        #[qinvokable]
        fn related(self: &Sioul, uri: &QString) -> QString;

        /// Ties two things, in the one that can hold the link, else locally; returns what the line says.
        #[qinvokable]
        fn link_things(self: Pin<&mut Sioul>, from: &QString, to: &QString) -> QString;

        /// Undoes a tie wherever it is written; returns what the line says.
        #[qinvokable]
        fn unlink_things(self: Pin<&mut Sioul>, from: &QString, to: &QString) -> QString;

        /// Things to tie `from` to, matching `query`, of `kind` ("" for all), as JSON.
        #[qinvokable]
        fn search_things(self: &Sioul, query: &QString, kind: &QString, from: &QString) -> QString;

        /// The address of a thing known by its file or id: "mail" (a message's file), "note", "task", "event", "contact".
        #[qinvokable]
        fn uri_of(self: &Sioul, kind: &QString, id: &QString) -> QString;

        /// Whether a file, by its name, path or address, is one the desktop would start: a program, a script, an installer
        /// (on a phone, Android's installers too).
        #[qinvokable]
        fn is_program(self: &Sioul, name: &QString) -> bool;

        /// The window's first frame drawn: said with how long the start took, when timed (`crate::timing`).
        #[qinvokable]
        fn first_frame(self: &Sioul);

        /// A step of the start, said with how long the start took so far, when timed (`crate::timing`).
        #[qinvokable]
        fn mark(self: &Sioul, what: &QString);

        /// Whether this system keeps accounts Sioul may be shown (Android's: Murena, Google…).
        #[qinvokable]
        fn phone_accounts(self: &Sioul) -> bool;

        /// Android's own chooser of the phone's accounts; the one chosen comes back by `phone_account_chosen`.
        #[qinvokable]
        fn choose_phone_account(self: Pin<&mut Sioul>);

        /// A budget opened: its ledger for the period around `anchor` ("2026-10-05"),
        /// its balance by `step` ("day", "week", "month", "year"), as JSON.
        #[qinvokable]
        fn budget_detail(self: &Sioul, id: &QString, anchor: &QString, step: &QString) -> QString;

        /// A folder kept here, or left on the server only (its copy here goes);
        /// returns what went wrong, else "".
        #[qinvokable]
        fn keep_folder(self: Pin<&mut Sioul>, account: &QString, folder: &QString, kept: bool) -> QString;

        /// A new folder on the server; the status line says how it went.
        #[qinvokable]
        fn create_folder(self: Pin<&mut Sioul>, account: &QString, name: &QString);

        /// An empty folder taken off the server; the status line says how it went.
        #[qinvokable]
        fn delete_folder(self: Pin<&mut Sioul>, account: &QString, folder: &QString);

        /// A noise made here ("white", "pink", "brown"), as a file URL; made the first time.
        #[qinvokable]
        fn noise_url(self: &Sioul, kind: &QString) -> QString;

        /// Your recordings to rest by, from the notes' `sounds` folder, as JSON.
        #[qinvokable]
        fn calm_sounds(self: &Sioul) -> QString;

        /// A task moved to another list ("account/id"), its steps with it; returns
        /// {"uid"}, {"error"}, or {"losses"} to confirm first.
        #[qinvokable]
        fn move_task(self: Pin<&mut Sioul>, uid: &QString, list: &QString, confirmed: bool) -> QString;

        /// A contact moved to another address book ("account/id"); returns {"key"},
        /// {"error"}, or {"losses"} to confirm first.
        #[qinvokable]
        fn move_contact(self: Pin<&mut Sioul>, key: &QString, book: &QString, confirmed: bool) -> QString;

        /// The address books a contact can go into, as JSON.
        #[qinvokable]
        fn address_books(self: &Sioul) -> QString;

        /// Places by name for the weather; the answer comes in `places_found`.
        #[qinvokable]
        fn find_places(self: Pin<&mut Sioul>, name: &QString);

        /// The weather's place; an empty name takes the weather away.
        #[qinvokable]
        fn set_weather_place(self: Pin<&mut Sioul>, name: &QString, latitude: f64, longitude: f64);

        /// The health page: the week of the day shown, the medicines, the prescriptions, as JSON.
        #[qinvokable]
        fn health_page(self: &Sioul) -> QString;

        /// A medicine made (`id` empty) or changed (JSON); returns {"id"} or {"error"}.
        #[qinvokable]
        fn save_medicine(self: Pin<&mut Sioul>, id: &QString, edit: &QString) -> QString;

        /// A prescription made (`id` empty) or changed (JSON); returns {"id"} or {"error"}.
        #[qinvokable]
        fn save_prescription(self: Pin<&mut Sioul>, id: &QString, edit: &QString) -> QString;

        /// "Show to a doctor or pharmacist": a prescription's medicines (its
        /// id), or all those taken now (""), as JSON, read-only.
        #[qinvokable]
        fn health_for_professional(self: &Sioul, prescription: &QString) -> QString;

        /// A medicine or a prescription taken out; returns what went wrong, else "".
        #[qinvokable]
        fn remove_health(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// A prescription's medicines fetched today; returns what went wrong, else "".
        #[qinvokable]
        fn refilled(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// A dose marked taken, or not, as it happens: taken late or early, it
        /// may move the next ones (a medicine counted from its last dose).
        #[qinvokable]
        fn set_dose_taken(self: Pin<&mut Sioul>, key: &QString, taken: bool);

        /// A dose not taken, said afterwards: not asked again.
        #[qinvokable]
        fn dose_not_taken(self: Pin<&mut Sioul>, key: &QString);

        /// A dose taken late, at `time` ("09:30"); taken every few hours, the
        /// next doses come that many hours after it. Returns what went wrong, else "".
        #[qinvokable]
        fn dose_taken_at(self: Pin<&mut Sioul>, key: &QString, time: &QString) -> QString;

        /// What the late dose's question shows, as JSON.
        #[qinvokable]
        fn dose_info(self: &Sioul, key: &QString) -> QString;

        /// Answers that differ on your devices settled as you chose: taken,
        /// or not (docs/health.md, "Doses as records"). Returns what went wrong, else "".
        #[qinvokable]
        fn dose_choose(self: Pin<&mut Sioul>, key: &QString, taken: bool) -> QString;

        /// A device you say is off (`off`), or counted again: not counted for
        /// the doses until it says anything newer (docs/health.md, "Knowing").
        /// Returns what went wrong, else "".
        #[qinvokable]
        fn device_off(self: Pin<&mut Sioul>, id: &QString, off: bool) -> QString;

        /// A device silent for a week, forgotten (Settings ▸ Your folder and sharing).
        #[qinvokable]
        fn device_forget(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// Meals, naps and the night, for the Health page, as JSON.
        #[qinvokable]
        fn needs(self: &Sioul) -> QString;

        /// Meals, naps and the night saved; returns what went wrong, else "".
        #[qinvokable]
        fn save_needs(self: Pin<&mut Sioul>, edit: &QString, shown: &QString) -> QString;

        /// A block skipped today, or not; returns what went wrong, else "".
        #[qinvokable]
        fn skip_need(self: Pin<&mut Sioul>, key: &QString, skip: bool) -> QString;

        /// Today's meals, naps and night as they are now, as JSON.
        #[qinvokable]
        fn needs_today(self: &Sioul) -> QString;

        /// The health views made again, off the window's thread (`healthView`, `missedView`, `needsView`).
        #[qinvokable]
        fn refresh_health(self: Pin<&mut Sioul>);

        /// The Health page shows the week of `day` ("2026-10-07"): made again
        /// off the window's thread, into `healthView`.
        #[qinvokable]
        fn show_health_week(self: Pin<&mut Sioul>, day: &QString);

        /// A day's meal, nap or night changed, that day only (JSON: date, key,
        /// action…; `health::change_need`); returns what went wrong, else "".
        #[qinvokable]
        fn change_need(self: Pin<&mut Sioul>, edit: &QString) -> QString;

        /// The same, by a drag on the timeline: "Undo" offered (`health::drag_need`).
        #[qinvokable]
        fn drag_need(self: Pin<&mut Sioul>, edit: &QString) -> QString;

        /// The Health page's settings (⚙): the pauses, where the errands go, the watch, as JSON.
        #[qinvokable]
        fn health_settings(self: &Sioul) -> QString;

        /// On a phone, Android's page where the alarm at waking is allowed:
        /// "exact" (Alarms & reminders), "screen" (full screen), "notifications" (`wake`).
        #[qinvokable]
        fn wake_settings(self: &Sioul, which: &QString);

        /// On a phone, "Try the alarm": rung ten seconds on, as a waking, the
        /// next waking left as it is; JSON {rings, line, fix, button} (`wake::try_now`).
        #[qinvokable]
        fn try_wake(self: &Sioul) -> QString;

        /// An overlap set aside for good; returns what went wrong, else "".
        #[qinvokable]
        fn set_overlap_aside(self: Pin<&mut Sioul>, key: &QString) -> QString;

        /// A block moved today only: `minutes` more (0: the minutes "Later" moves
        /// it by), or to start at `time` ("13:30"). Returns what went wrong, else "".
        #[qinvokable]
        fn move_need(self: Pin<&mut Sioul>, key: &QString, minutes: i32, time: &QString) -> QString;

        /// The minutes "Later" moves a block by.
        #[qinvokable]
        fn needs_later(self: &Sioul) -> i32;

        /// The Porch's doses, as JSON: {due: today's not marked yet, closed: those
        /// due while Sioul was closed}, each [{key, time, name, dose, late, doubt}].
        #[qinvokable]
        fn missed_doses(self: &Sioul) -> QString;

        /// You are at this window now: what follows you (medicines' reminders) comes here.
        #[qinvokable]
        fn touch(self: Pin<&mut Sioul>);

        /// Put away on a phone: what was marked goes out, and the other devices
        /// learn this one marks nothing until it is back (docs/health.md, "Knowing").
        #[qinvokable]
        fn going_away(self: Pin<&mut Sioul>);

        /// Back on a phone: the claims say so at once, before the next minute.
        #[qinvokable]
        fn back_here(self: Pin<&mut Sioul>);

        /// The pause to move, the chats' limit: "movement.minutes", "chats.enabled"…
        #[qinvokable]
        fn set_health(self: Pin<&mut Sioul>, key: &QString, value: &QString) -> QString;

        /// Minutes of focus before the pause to move; 0 when off.
        #[qinvokable]
        fn movement_minutes(self: &Sioul) -> i32;

        /// One more minute in a chat; whether chats are covered now.
        #[qinvokable]
        fn chat_minute(self: Pin<&mut Sioul>) -> bool;

        /// Whether chats are covered now.
        #[qinvokable]
        fn chats_covered(self: &Sioul) -> bool;

        /// Where a new audio memo is recorded, as a file URL; "" without a notes folder.
        #[qinvokable]
        fn memo_url(self: &Sioul) -> QString;

        /// A memo recorded: the notes are read again; returns its path in the notes.
        #[qinvokable]
        fn memo_recorded(self: Pin<&mut Sioul>, url: &QString) -> QString;

        /// A note (a picture, a PDF, a sound) moved to the vault's trash, "Undo"
        /// offered; returns what went wrong, else "".
        #[qinvokable]
        fn trash_note(self: Pin<&mut Sioul>, path: &QString) -> QString;

        /// A note renamed, what names it following; returns {"path"} or {"error"}.
        #[qinvokable]
        fn rename_note(self: Pin<&mut Sioul>, path: &QString, name: &QString) -> QString;

        /// A new note in a folder ("" for the notes' own); returns its path.
        #[qinvokable]
        fn create_note_in(self: Pin<&mut Sioul>, folder: &QString, title: &QString) -> QString;

        /// A new folder of notes in `parent`; returns what went wrong, else "".
        #[qinvokable]
        fn make_folder(self: Pin<&mut Sioul>, parent: &QString, name: &QString) -> QString;

        /// A folder renamed, its notes and their links following; returns {"path"} or {"error"}.
        #[qinvokable]
        fn rename_folder(self: Pin<&mut Sioul>, path: &QString, name: &QString) -> QString;

        /// An empty folder of notes taken out; returns what went wrong, else "".
        #[qinvokable]
        fn remove_folder(self: Pin<&mut Sioul>, path: &QString) -> QString;

        /// A project taken out of the list; returns what went wrong, else "".
        #[qinvokable]
        fn remove_project(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// A budget made (`id` empty) or changed (JSON); returns {"id"} or {"error"}.
        #[qinvokable]
        fn save_budget(self: Pin<&mut Sioul>, id: &QString, edit: &QString) -> QString;

        /// A budget taken out, by its id; returns what went wrong.
        #[qinvokable]
        fn remove_budget(self: Pin<&mut Sioul>, what: &QString) -> QString;

        /// A line of the budgets' file taken out, by its address and its row
        /// as the page showed it (JSON: day, value, label), found again by
        /// them; returns what went wrong, else "".
        #[qinvokable]
        fn remove_line(self: Pin<&mut Sioul>, uri: &QString, shown: &QString) -> QString;

        /// Notes as a tree of folders, or as one list.
        #[qinvokable]
        fn set_notes_tree(self: Pin<&mut Sioul>, tree: bool);

        /// How a page was left ("sites-narrow", "notes-recent"…), kept between sessions.
        #[qinvokable]
        fn view_flag(self: &Sioul, name: &QString) -> bool;

        #[qinvokable]
        fn set_view_flag(self: Pin<&mut Sioul>, name: &QString, value: bool);


        /// A movement added by hand, once or recurring (JSON); returns what went wrong, else "".
        #[qinvokable]
        fn add_movement(self: Pin<&mut Sioul>, edit: &QString) -> QString;

        /// A project's billable time from one day to another, written as a
        /// spreadsheet (CSV) at a file address; returns what went wrong, else "".
        #[qinvokable]
        fn export_time_csv(self: Pin<&mut Sioul>, project: &QString, from: &QString, to: &QString, target: &QString) -> QString;

        /// Paper letters not done with, as JSON (`letters::view`).
        #[qinvokable]
        fn letters(self: &Sioul) -> QString;

        /// A paper letter's date as a task; returns what went wrong, else "".
        #[qinvokable]
        fn letter_task(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// A paper letter's appointment in the agenda; returns what went wrong, else "".
        #[qinvokable]
        fn letter_event(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// Done with a paper letter: its project set (if `project`), its scan filed; returns what went wrong, else "".
        #[qinvokable]
        fn letter_done(self: Pin<&mut Sioul>, id: &QString, project: &QString) -> QString;

        /// The money watch, as JSON (`bank::view`).
        #[qinvokable]
        fn bank(self: &Sioul) -> QString;

        /// A bank export taken in: {"ok", "said"}.
        #[qinvokable]
        fn import_bank(self: Pin<&mut Sioul>, file: &QString) -> QString;

        /// An export taken in as one bank account's; returns {"ok", "said"}.
        #[qinvokable]
        fn import_bank_into(self: Pin<&mut Sioul>, file: &QString, account: &QString) -> QString;

        /// A bank account made (`id` empty) or changed, from the dialog's JSON; returns what went wrong, if anything.
        #[qinvokable]
        fn save_bank_account(self: Pin<&mut Sioul>, id: &QString, edit: &QString) -> QString;

        #[qinvokable]
        fn remove_bank_account(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// One movement placed by hand: "budget:<id>", "none", or "" (as the rules say).
        #[qinvokable]
        fn place_movement(self: Pin<&mut Sioul>, account: &QString, movement: &QString, choice: &QString) -> QString;

        /// A rule for movements made (`rule` "") or changed (`rule`: the rule as
        /// shown, JSON: named by its id, or its place while it holds the same).
        #[qinvokable]
        fn save_bank_rule(self: Pin<&mut Sioul>, rule: &QString, edit: &QString) -> QString;

        #[qinvokable]
        fn remove_bank_rule(self: Pin<&mut Sioul>, rule: &QString) -> QString;

        /// A reserve made (`id` empty) or changed: its balance, its floor, its delay.
        #[qinvokable]
        fn save_reserve(self: Pin<&mut Sioul>, id: &QString, edit: &QString) -> QString;

        /// Contracts and subscriptions, as JSON (`contracts::view`).
        #[qinvokable]
        fn contracts(self: &Sioul) -> QString;

        /// A contract saved (new when `id` is empty) from the form's JSON; returns what went wrong, else "".
        #[qinvokable]
        fn save_contract(self: Pin<&mut Sioul>, id: &QString, edit: &QString) -> QString;

        /// A contract taken out; returns what went wrong, else "".
        #[qinvokable]
        fn remove_contract(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// The letter that stops a contract, drafted: {"draft"} or {"error"}.
        #[qinvokable]
        fn contract_letter(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// What a mail says of a contract (its subject, its sender), to start the form, as JSON.
        #[qinvokable]
        fn contract_from(self: &Sioul, subject: &QString, from: &QString) -> QString;

        /// The routines, as JSON: the admin window's, then yours (`work::routines`).
        #[qinvokable]
        fn routines(self: &Sioul) -> QString;

        /// A routine saved (new when `id` is empty): its title, its steps one a line, whether it moves on by itself.
        #[qinvokable]
        fn save_routine(self: Pin<&mut Sioul>, id: &QString, title: &QString, steps: &QString, by_itself: bool) -> QString;

        /// A routine taken out.
        #[qinvokable]
        fn remove_routine(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// Sharing with your other computers, as JSON (`share::status`); `folder` is the one being chosen, if any.
        #[qinvokable]
        fn share_status(self: &Sioul, folder: &QString) -> QString;

        /// Starts sharing through a folder, sealed with a passphrase (typed twice the first time); returns what went wrong, else "".
        #[qinvokable]
        fn start_sharing(self: Pin<&mut Sioul>, folder: &QString, passphrase: &QString, again: &QString) -> QString;

        /// Stops sharing on this computer; returns what went wrong, else "".
        #[qinvokable]
        fn stop_sharing(self: Pin<&mut Sioul>) -> QString;

        /// Exchanges with the other computers now.
        #[qinvokable]
        fn share_now(self: Pin<&mut Sioul>);

        /// Folders already shared through by your other devices (they hold a seal), as JSON: ["path", …].
        #[qinvokable]
        fn share_candidates(self: &Sioul) -> QString;

        /// Whether Sioul may read and write your files by their path (Android: "All files access").
        #[qinvokable]
        fn files_access(self: &Sioul) -> bool;

        /// Projects and budgets travel through the sharing too, or not; returns what went wrong, else "".
        #[qinvokable]
        fn set_share_projects(self: Pin<&mut Sioul>, on: bool) -> QString;

        /// A part of what is shared ("settings", "notes"…) switched on or off on this device; returns what went wrong, else "".
        #[qinvokable]
        fn set_share_part(self: Pin<&mut Sioul>, part: &QString, on: bool) -> QString;

        /// On a phone: whether a sync app carries the notes folder, as you
        /// say (Sioul cannot read its settings there). Returns what went wrong, else "".
        #[qinvokable]
        fn set_notes_carried(self: Pin<&mut Sioul>, carried: bool) -> QString;

        /// The versions kept here before other devices' changes whose file's
        /// name holds `filter`, listed off the window's thread: `share_listed`
        /// brings them, as JSON [{"part", "name", "more", "files": [{"file", "shown", "count", "versions": [{"stamp", "when", "size"}]}]}].
        #[qinvokable]
        fn share_history(self: Pin<&mut Sioul>, filter: &QString);

        /// What putting a version back would change, in a sentence, said before it is done.
        #[qinvokable]
        fn share_put_back_preview(self: &Sioul, part: &QString, file: &QString, stamp: &QString) -> QString;

        /// A file put back as it was (`stamp`), the one there now kept too, then
        /// sent, off the window's thread: `share_put_back_done` says how it went.
        #[qinvokable]
        fn share_put_back(self: Pin<&mut Sioul>, part: &QString, file: &QString, stamp: &QString);

        /// The files gone at once from a folder of notes or papers ("files/notes/")
        /// taken out everywhere, as you said; returns what went wrong, else "".
        #[qinvokable]
        fn share_confirm_gone(self: Pin<&mut Sioul>, store: &QString) -> QString;

        /// What switching Notes or Papers on would send, counted off the
        /// window's thread: `share_estimated` brings it.
        #[qinvokable]
        fn share_estimate(self: Pin<&mut Sioul>, part: &QString);

        /// Sioul's own spam filter as the mail settings show it (`spam::status`), as JSON.
        #[qinvokable]
        fn spam_status(self: &Sioul) -> QString;

        /// "Train now", on a computer: the corpus brought up to date, then a
        /// training, off the window's thread; `spam_changed` says how it goes.
        /// Returns why it did not start, else "".
        #[qinvokable]
        fn spam_train(self: Pin<&mut Sioul>) -> QString;

        /// The training running stops at its next step.
        #[qinvokable]
        fn spam_stop(self: Pin<&mut Sioul>);

        /// The mail filters as Mail ▸ ⚙ shows them (`filters::view`): each
        /// filter in words, the addresses, their folders, the editor's words, as JSON.
        #[qinvokable]
        fn mail_filters(self: &Sioul) -> QString;

        /// The list of mail filters written, in its order (JSON, as
        /// `mail_filters` gives them), from the list the editor showed
        /// (`shown`): its change set over the filters as they are now. Returns
        /// what went wrong, else "".
        #[qinvokable]
        fn set_mail_filters(self: Pin<&mut Sioul>, filters: &QString, shown: &QString) -> QString;

        /// One filter being edited, in words: {said, problem, only}, as JSON.
        #[qinvokable]
        fn mail_filter_said(self: &Sioul, filter: &QString) -> QString;

        /// "Try it": what one filter being edited takes in the inboxes now,
        /// counted off the window's thread; `mail_filters_found` brings it.
        #[qinvokable]
        fn mail_filter_try(self: Pin<&mut Sioul>, filter: &QString);

        /// What every filter would do in the inboxes now, read mail included,
        /// found off the window's thread; `mail_filters_found` brings it.
        #[qinvokable]
        fn mail_filters_preview(self: Pin<&mut Sioul>);

        /// What the preview said, done after ten seconds to undo; returns why not, else "".
        #[qinvokable]
        fn mail_filters_run(self: Pin<&mut Sioul>) -> QString;

        /// A new mail filter from a search's conditions ({conditions, match},
        /// MailSearch.qml's "Make it a filter…"), last in the list and opened
        /// in the editor the next time Mail ▸ ⚙ shows it; returns what went wrong, else "".
        #[qinvokable]
        fn new_mail_filter(self: Pin<&mut Sioul>, given: &QString) -> QString;

        /// The other devices' files fetched from the server too, or not, on
        /// this device (docs/database.md); returns what went wrong, else "".
        #[qinvokable]
        fn set_share_backup(self: Pin<&mut Sioul>, on: bool) -> QString;

        /// This device's own files sent to that server too, beside the sync
        /// app, or not, on this device (docs/database.md, "Sent to the server
        /// too"); returns what went wrong, else "".
        #[qinvokable]
        fn set_share_send(self: Pin<&mut Sioul>, on: bool) -> QString;

        /// "Send everything again": this device's files sent to the server
        /// again, whatever was sent before, then the others' fetched; off the
        /// window's thread, said in the panel's status (docs/database.md).
        #[qinvokable]
        fn share_send_again(self: Pin<&mut Sioul>);

        /// The sharing folder's place on the server, given by hand
        /// ("Documents/Sioul", or its address; "" to look for it by itself),
        /// looked at off the window's thread; returns what went wrong, else "".
        #[qinvokable]
        fn share_backup_place(self: Pin<&mut Sioul>, place: &QString) -> QString;

        /// Starts sharing through a folder of an account's files that Sioul
        /// keeps in step itself, no sync app (`account`: its id; `place`:
        /// "Documents/Sioul"), joined or made there, off the window's thread:
        /// `share_started` says how it went.
        #[qinvokable]
        fn start_sharing_on_server(self: Pin<&mut Sioul>, account: &QString, place: &QString, passphrase: &QString, again: &QString);

        /// A folder's own folders, for Sioul's folder browser, as JSON: {"path", "parent", "folders", "readable"}.
        #[qinvokable]
        fn folders_in(self: &Sioul, path: &QString) -> QString;

        /// Android: its own switch for "All files access" (or the older question before Android 11).
        #[qinvokable]
        fn ask_files_access(self: Pin<&mut Sioul>);

        /// A line of the budgets' file changed: label, amount, date; found again
        /// by its address and its row as the page showed it (JSON: day, value,
        /// label). Returns what went wrong, else "".
        #[qinvokable]
        fn change_line(self: Pin<&mut Sioul>, uri: &QString, shown: &QString, label: &QString, amount: f64, date: &QString) -> QString;

        /// The sites kept in Sioul, as JSON.
        #[qinvokable]
        fn site_list(self: &Sioul) -> QString;

        /// A site's notification: shown at once in real time, else kept for the Porch.
        #[qinvokable]
        fn site_notified(self: Pin<&mut Sioul>, id: &QString, title: &QString, text: &QString);

        /// A site opened: what it notified is seen.
        #[qinvokable]
        fn site_seen(self: Pin<&mut Sioul>, id: &QString);

        /// What the sites notified, for the Porch, as JSON.
        #[qinvokable]
        fn site_notices(self: &Sioul) -> QString;

        /// The site a sender's mail announces: {"id", "name"}, else "".
        #[qinvokable]
        fn site_for_sender(self: &Sioul, sender: &QString) -> QString;

        /// A site's setting: "realtime", "muted", "background" (true or false), or "site" (its kind).
        #[qinvokable]
        fn set_site(self: Pin<&mut Sioul>, id: &QString, field: &QString, value: &QString) -> QString;

        /// The sites offered when adding one, for a country and a region ("" for yours): JSON.
        #[qinvokable]
        fn site_presets(self: &Sioul, country: &QString, region: &QString) -> QString;

        /// A site added: {"name", "url", "category", "area", "announced_by"}; returns {"id"} or {"error"}.
        #[qinvokable]
        fn add_site(self: Pin<&mut Sioul>, edit: &QString) -> QString;

        /// The usual sites as a menu: countries, their groups, the sites (JSON).
        #[qinvokable]
        fn site_presets_tree(self: &Sioul) -> QString;

        /// Several usual sites pinned at once (a JSON list); returns {"added", "error"}.
        #[qinvokable]
        fn add_sites(self: Pin<&mut Sioul>, rows: &QString) -> QString;

        /// A site moved one place up (-1) or down (1); returns what went wrong, else "".
        #[qinvokable]
        fn move_site(self: Pin<&mut Sioul>, id: &QString, delta: i32) -> QString;

        /// A site taken out of Sioul; its sign-ins stay in its profile until cleared.
        #[qinvokable]
        fn remove_site(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// Whether this build carries Sioul's own Google key: then no key of your own is needed.
        #[qinvokable]
        fn google_built_in(self: &Sioul) -> bool;

        /// The camera, microphone and speaker of calls in sites, by their names: {"camera", "microphone", "speaker"}.
        #[qinvokable]
        fn call_devices(self: &Sioul) -> QString;

        /// One of them chosen ("camera", "microphone", "speaker"); "" for the system's own.
        #[qinvokable]
        fn set_call_device(self: Pin<&mut Sioul>, which: &QString, name: &QString) -> QString;

        /// The script every site's page runs for its calls (src/calls.js): the
        /// devices chosen, changed during a call; called with the names and a token.
        #[qinvokable]
        fn calls_script(self: &Sioul) -> QString;

        /// "missing", "unauthenticated", "locked" or "unlocked".
        #[qinvokable]
        fn bitwarden_state(self: &Sioul) -> QString;

        /// Unlocks Bitwarden, off the window's thread: a ticket at once, the
        /// answer ({"ok"}, {"factor", "key"}, {"new_device"} or {"error"}) with
        /// `bitwarden_answered` (sites.rs).
        #[qinvokable]
        fn bitwarden_unlock(self: Pin<&mut Sioul>, password: &QString, provider: i32, code: &QString) -> i32;

        /// Locks Bitwarden again: its logins leave memory.
        #[qinvokable]
        fn bitwarden_lock(self: Pin<&mut Sioul>);

        /// Sends the e-mail second step's code, off the window's thread: a
        /// ticket, then what went wrong, else "", with `bitwarden_answered`.
        #[qinvokable]
        fn bitwarden_send_code(self: Pin<&mut Sioul>, password: &QString) -> i32;

        /// Begins a passkey login, off the window's thread: a ticket, then
        /// {"page", "script"} for the key's window, or {"error"}, with `bitwarden_answered`.
        #[qinvokable]
        fn bitwarden_passkey_begin(self: Pin<&mut Sioul>) -> i32;

        /// The key's answer from that window: the vault opened with it, off the
        /// window's thread: a ticket, then {"ok"} or {"error"}, with `bitwarden_answered`.
        #[qinvokable]
        fn bitwarden_passkey(self: Pin<&mut Sioul>, answer: &QString) -> i32;

        /// The vault's logins by site and by user name, for an address (its own
        /// first): {"found": [{"id", "name", "username", "site", "elsewhere"}], "more"} or {"error"};
        /// for a large vault {"later": n}, the answer coming with `bitwarden_found` (sites.rs).
        #[qinvokable]
        fn bitwarden_search(self: Pin<&mut Sioul>, url: &QString, site: &QString, user: &QString) -> QString;

        /// What the vault holds for an address: {"domain", "chosen", "only"} or {"error"} (sites.rs).
        #[qinvokable]
        fn bitwarden_site(self: &Sioul, url: &QString) -> QString;

        /// One login of the vault, for an address: {"username", "password", "code"} or {"error"}.
        #[qinvokable]
        fn bitwarden_login(self: &Sioul, url: &QString, id: &QString) -> QString;

        /// Contacts on the map: {"allowed", "tiles", "pins", "waiting", "locating"}.
        #[qinvokable]
        fn map_view(self: &Sioul) -> QString;

        /// Where one address is: {"lat", "lon"}, else "".
        #[qinvokable]
        fn place_of(self: &Sioul, address: &QString) -> QString;

        /// Allows placing addresses (when `allow`), then places those not asked yet, one a second.
        #[qinvokable]
        fn locate_addresses(self: Pin<&mut Sioul>, allow: bool);

        /// Work time or quiet time again: called each minute; the pages follow when it changes.
        #[qinvokable]
        fn refresh_mode(self: Pin<&mut Sioul>);

        /// Work stays in view for `minutes` more, whatever the hours.
        #[qinvokable]
        fn work_a_while(self: Pin<&mut Sioul>, minutes: i32);

        /// Done for today: the day is closed at once ("Undo" in the status line),
        /// today's tasks flow on, work rests until it comes back. Returns the
        /// screen to show after, as JSON.
        #[qinvokable]
        fn done_for_the_day(self: Pin<&mut Sioul>) -> QString;

        /// The end of the work day ("work") or of the day before sleep
        /// ("night"): the review's sheet, as JSON (`reviews::view`).
        #[qinvokable]
        fn day_review(self: &Sioul, kind: &QString) -> QString;

        /// The review kept, each answer optional ("" for none); the work day
        /// then closed as "Done for today": the screen after it, as JSON, else "".
        #[qinvokable]
        fn close_review(self: Pin<&mut Sioul>, kind: &QString, felt: &QString, mix: &QString, memo: &QString) -> QString;

        /// A day's words on the Health page, and today the button to close it (`reviews::line`).
        #[qinvokable]
        fn day_review_line(self: &Sioul, date: &QString) -> QString;

        /// The first step for when work comes back, in your words.
        #[qinvokable]
        fn set_first_step(self: Pin<&mut Sioul>, text: &QString);

        /// The first step put away.
        #[qinvokable]
        fn clear_first_step(self: Pin<&mut Sioul>);

        /// Back to the usual hours: overrides taken off.
        #[qinvokable]
        fn usual_hours(self: Pin<&mut Sioul>);

        /// "Work now", ticked or not: work shown, whatever the hours, until
        /// you untick it, Sioul closes, or the next working day is over.
        #[qinvokable]
        fn set_work_now(self: Pin<&mut Sioul>, on: bool);

        /// Free time on or off (docs/pauses.md, `pauses::set_free`): on, "true"
        /// when a focus session stopped; off, the line said once on the end of work, else "".
        #[qinvokable]
        fn set_free_time(self: Pin<&mut Sioul>, on: bool) -> QString;

        /// "Keep my usual end": today's end of work stays where it was, no reason asked.
        #[qinvokable]
        fn keep_usual_end(self: Pin<&mut Sioul>);

        /// "Nothing at all" for this free time, or the safe list again.
        #[qinvokable]
        fn set_free_nothing(self: Pin<&mut Sioul>, on: bool);

        /// The Pause: it asks nothing; everything held, on every device (`pauses::press`).
        #[qinvokable]
        fn pause_now(self: Pin<&mut Sioul>);

        /// Back from the pause: the screen after it, as JSON (`pauses::come_back`).
        #[qinvokable]
        fn come_back(self: Pin<&mut Sioul>) -> QString;

        /// Coming back's one offer: tomorrow lighter too.
        #[qinvokable]
        fn lighten_tomorrow(self: Pin<&mut Sioul>);

        /// The last pause's times, forgotten.
        #[qinvokable]
        fn forget_pause(self: Pin<&mut Sioul>);

        /// The pause's screen, as JSON (`pauses::screen`).
        #[qinvokable]
        fn pause_screen(self: &Sioul) -> QString;

        /// The pauses' setup, its do-not-disturb part, as JSON (`pauses::setup`).
        #[qinvokable]
        fn pause_setup(self: &Sioul) -> QString;

        /// A system page the pauses' setup offers ("access", "starred", "plasma": `dnd::open`).
        #[qinvokable]
        fn open_dnd(self: &Sioul, key: &QString);

        /// Do-not-disturb's switch, on every device (`everywhere::toggle`): on for
        /// `minutes` (0: until turned off; -1: until what now is for ends), or off.
        #[qinvokable]
        fn dnd_toggle(self: Pin<&mut Sioul>, on: bool, minutes: i32);

        /// Settings ▸ Do not disturb, its own part, as JSON (`everywhere::setup`).
        #[qinvokable]
        fn dnd_setup(self: &Sioul) -> QString;

        /// An action of that tab (`everywhere::change`): the tab again, as JSON.
        #[qinvokable]
        fn dnd_change(self: Pin<&mut Sioul>, verb: &QString, json: &QString) -> QString;

        /// Settings ▸ Other apps, on a phone, as JSON (`appnotes::setup`).
        #[qinvokable]
        fn app_notes_setup(self: &Sioul) -> QString;

        /// A choice of that tab, or one of Android's pages (`appnotes::change`): the tab again, as JSON.
        #[qinvokable]
        fn app_notes_change(self: &Sioul, verb: &QString, json: &QString) -> QString;

        /// "Let every call through" (docs/android.md, "Calls"; `calls::press`): on
        /// for `minutes` (0: until turned off), or calls screened again; on every device.
        #[qinvokable]
        fn calls_through(self: Pin<&mut Sioul>, on: bool, minutes: i32);

        /// The Porch's list of calls declined on this phone, as JSON (`calls::view`).
        #[qinvokable]
        fn calls_view(self: &Sioul) -> QString;

        /// An action of that list (`calls::act`): {said, url, shared}, as JSON.
        #[qinvokable]
        fn calls_action(self: Pin<&mut Sioul>, verb: &QString, json: &QString) -> QString;

        /// Settings ▸ Calls, on a phone, as JSON (`calls::setup`).
        #[qinvokable]
        fn calls_setup(self: &Sioul) -> QString;

        /// The phone's messages on your computers (`phonemsgs::call`): "view"
        /// (the Porch's section), "seen", "unseen", "block", "setup" (the
        /// phone's tab), "set", "part"; their JSON.
        #[qinvokable]
        fn phone_messages(self: Pin<&mut Sioul>, verb: &QString, json: &QString) -> QString;

        /// texts: read and sent through your phone (`texts::call`): "view",
        /// "conversation", "send", "again", "parts", "media", "save-media", "close", "setup", "ask", "part", "cap"; their JSON.
        #[qinvokable]
        fn texts(self: Pin<&mut Sioul>, verb: &QString, json: &QString) -> QString;

        /// Settings ▸ What reaches you, as JSON (`reaches::view`): the moment
        /// now in sentences, the presets, a card per time, the matrix's grid.
        #[qinvokable]
        fn reaches_view(self: &Sioul) -> QString;

        /// A row of the matrix changed (`row`: "mail.safe", "codes"; `words`: its
        /// words whole, a JSON list; `shown`: its words as the row showed them,
        /// so that only the cells changed are set): what went wrong, else "".
        #[qinvokable]
        fn reaches_set(self: Pin<&mut Sioul>, row: &QString, words: &QString, shown: &QString) -> QString;

        /// A preset chosen ("usual", "quieter", "reachable"): what went wrong, else "".
        #[qinvokable]
        fn reaches_preset(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// How someone reaches you, as JSON (`reaches::person`): a card's file or
        /// UID, or a sender's addresses (a JSON array, or one).
        #[qinvokable]
        fn person_sheet(self: &Sioul, key: &QString, addresses: &QString) -> QString;

        /// A change on a person's sheet (`verb`: "list" or "always"): {sheet, line}, as JSON.
        #[qinvokable]
        fn person_sheet_change(self: Pin<&mut Sioul>, key: &QString, addresses: &QString, verb: &QString, value: &QString) -> QString;

        /// An action of that tab (`calls::setup_change`): the tab again, as JSON.
        #[qinvokable]
        fn calls_setup_change(self: Pin<&mut Sioul>, verb: &QString, json: &QString) -> QString;

        /// The projects, for their list, as JSON.
        #[qinvokable]
        fn project_rows(self: &Sioul) -> QString;

        /// One project's page, as JSON.
        #[qinvokable]
        fn project_page(self: &Sioul, id: &QString) -> QString;

        /// Saves a project from its form (a new one when `id` is empty); returns {"id"} or {"error"}.
        #[qinvokable]
        fn save_project(self: Pin<&mut Sioul>, id: &QString, edit: &QString) -> QString;

        /// The Time page: "week", "month" or "year" around `anchor` ("2026-10-05"), one project or all.
        #[qinvokable]
        fn time_page(self: &Sioul, period: &QString, anchor: &QString, project: &QString) -> QString;

        /// Notes time by hand (JSON: day, at, minutes, project, task, note, unbilled); returns what went wrong.
        #[qinvokable]
        fn note_time(self: Pin<&mut Sioul>, edit: &QString) -> QString;

        /// Takes out time noted by hand; returns what went wrong.
        #[qinvokable]
        fn remove_time(self: Pin<&mut Sioul>, key: &QString) -> QString;

        /// Where you stopped, as JSON: {text, when, task, title}; "null" for none.
        #[qinvokable]
        fn stopped(self: &Sioul) -> QString;

        /// A line left on where you stopped (an empty one: done); returns what went wrong, else "".
        #[qinvokable]
        fn set_stopped(self: Pin<&mut Sioul>, text: &QString) -> QString;

        /// A stretch of time changed once noted (by the timer or by hand): its
        /// day, from, to, what, task, project. Returns what went wrong, else "".
        #[qinvokable]
        fn change_time(self: Pin<&mut Sioul>, key: &QString, edit: &QString) -> QString;

        /// The tasks time can be given to, as JSON: the open ones, and `keep`.
        #[qinvokable]
        fn task_choices(self: &Sioul, keep: &QString) -> QString;

        /// The invoice of a project's unbilled hours: {"number", "html", "pdf"} or {"error"}.
        #[qinvokable]
        fn make_invoice(self: Pin<&mut Sioul>, id: &QString) -> QString;

        /// Invoices made on this computer from now on; returns what to say.
        #[qinvokable]
        fn take_invoices(self: Pin<&mut Sioul>) -> QString;

        /// An invoice made before, to print again: {"html", "pdf"} or {"error"}.
        #[qinvokable]
        fn invoice_again(self: &Sioul, number: &QString) -> QString;

        /// An invoice paid, or not; returns what went wrong.
        #[qinvokable]
        fn set_invoice_paid(self: Pin<&mut Sioul>, number: &QString, paid: bool) -> QString;

        /// Something new tied to `from`: "task", "note", "mail"; returns {"uid"}, {"path"}, {"draft"} or {"error"}.
        #[qinvokable]
        fn make_linked(self: Pin<&mut Sioul>, kind: &QString, from: &QString, key: &QString, start: f64) -> QString;

        /// A task from a message. Returns {"uid"} or {"error"}.
        #[qinvokable]
        fn task_from_mail(self: Pin<&mut Sioul>, key: &QString) -> QString;

        /// A note from a message; returns its path.
        #[qinvokable]
        fn note_from_mail(self: Pin<&mut Sioul>, key: &QString) -> QString;

        /// A note for an event's occurrence starting at `start`; returns its path.
        #[qinvokable]
        fn note_from_event(self: Pin<&mut Sioul>, key: &QString, start: f64) -> QString;

        /// A task to prepare an event. Returns {"uid"} or {"error"}.
        #[qinvokable]
        fn task_from_event(self: Pin<&mut Sioul>, key: &QString, start: f64) -> QString;

        /// A task from a note's checkbox line. Returns {"uid"} or {"error"}.
        #[qinvokable]
        fn task_from_line(self: Pin<&mut Sioul>, path: &QString, line: i32) -> QString;

        /// A draft to the people a task involves; returns its id.
        #[qinvokable]
        fn draft_for_task(self: Pin<&mut Sioul>, uid: &QString) -> QString;

        /// A draft sending a note to its event's guests; returns its id.
        #[qinvokable]
        fn mail_note(self: Pin<&mut Sioul>, path: &QString) -> QString;

        /// A page's settings ("porch", "mail", "agenda", "tasks", "notes", "reading", "contacts", "time", "general"), as JSON.
        #[qinvokable]
        fn settings(self: &Sioul, view: &QString) -> QString;

        /// Changes one setting (its value as JSON); returns what went wrong, else "".
        #[qinvokable]
        fn set_setting(self: Pin<&mut Sioul>, key: &QString, value: &QString) -> QString;

        /// Changes one setting from its row: `shown` the value the row showed,
        /// `value` the new one, both as JSON. A list is the row's change set over
        /// the list as the files hold it now (`settings::change`): an element
        /// another device added meanwhile stays. Returns what went wrong, else "".
        #[qinvokable]
        fn change_setting(self: Pin<&mut Sioul>, key: &QString, shown: &QString, value: &QString) -> QString;

        /// "dark" or "light" when `SIOUL_THEME` forces one, for the window's images; else "" (the setting decides).
        #[qinvokable]
        fn forced_theme(self: &Sioul) -> QString;

        /// Real time on or off: every folder of every address fetched each minute, and the Porch open.
        #[qinvokable]
        fn set_realtime_mode(self: Pin<&mut Sioul>, on: bool);

        /// Images of a phone's screen (`SIOUL_GRAB_PHONE`): its size and its layout.
        #[qinvokable]
        fn grab_phone(self: &Sioul) -> bool;

        /// Which steps the window takes while saving images: `SIOUL_GRAB_STEPS`,
        /// "pages" by default, or "actions" to act on mail and send some (test accounts only).
        #[qinvokable]
        fn grab_steps(self: &Sioul) -> QString;
    }

    #[auto_cxx_name]
    // SAFETY: CXX-Qt makes both sides of these signals and methods from this declaration.
    unsafe extern "RustQt" {
        /// The notification's "copy" button was pressed.
        #[qsignal]
        fn copy_requested(self: Pin<&mut Sioul>, text: QString);

        /// An account was added: the form can be emptied.
        #[qsignal]
        fn account_added(self: Pin<&mut Sioul>);

        /// An account's password given here: kept (`problem` empty), else why not.
        #[qsignal]
        fn account_password_done(self: Pin<&mut Sioul>, id: QString, problem: QString);

        /// Paper letters were read: the Porch shows them again.
        #[qsignal]
        fn letters_changed(self: Pin<&mut Sioul>);

        /// A task just done, whichever way (a list, its panel, the focus window):
        /// the status line offers "How was it?", quietly.
        #[qsignal]
        fn task_done(self: Pin<&mut Sioul>, uid: QString);

        /// Your other devices' changes written here by the sharing: the stores
        /// written, one per line ("data/time/", "state/health-state.toml"…), for
        /// the pages that show them to read again.
        #[qsignal]
        fn shared_in(self: Pin<&mut Sioul>, stores: QString);

        /// The versions kept, listed (`share_history`), as JSON.
        #[qsignal]
        fn share_listed(self: Pin<&mut Sioul>, versions: QString);

        /// A version put back (`share_put_back`): what went wrong, else "".
        #[qsignal]
        fn share_put_back_done(self: Pin<&mut Sioul>, problem: QString);

        /// What switching Notes or Papers on would send (`share_estimate`), as JSON {"part", "text"}.
        #[qsignal]
        fn share_estimated(self: Pin<&mut Sioul>, estimate: QString);

        /// The spam filter's training moved on, or ended: its state, as `spam_status` gives it.
        #[qsignal]
        fn spam_changed(self: Pin<&mut Sioul>, status: QString);

        /// What "Try it" or the mail filters' preview found, as JSON {kind, text, lines, count}.
        #[qsignal]
        fn mail_filters_found(self: Pin<&mut Sioul>, found: QString);

        /// A message read for the reading pane (`read_message`): its key, the
        /// message laid out for reading as JSON (`view::MessageView`; empty
        /// if it cannot be read), and the invitation it carries (JSON; empty
        /// when none).
        #[qsignal]
        fn message_read(self: Pin<&mut Sioul>, key: QString, reading: QString, invitation: QString);

        /// Sharing through a folder Sioul keeps in step with a server itself
        /// (`start_sharing_on_server`): "" when it started, else why not.
        #[qsignal]
        fn share_started(self: Pin<&mut Sioul>, problem: QString);

        /// A reminder's "Open" was pressed: what it is about ("task", "event", "budget"), shown.
        #[qsignal]
        fn reminder_opened(self: Pin<&mut Sioul>, kind: QString, uri: QString, key: QString);

        /// An attachment passed the antivirus: the desktop opens it.
        #[qsignal]
        fn open_url(self: Pin<&mut Sioul>, url: QString);

        /// No antivirus answered, or the file is larger than it scans (`big`):
        /// the window asks before opening or saving, with how to install one.
        #[qsignal]
        fn scan_unavailable(self: Pin<&mut Sioul>, key: QString, index: i32, what: i32, name: QString, hint: QString, big: bool);

        /// An attachment was kept in the papers wallet: the form, to say what it is.
        #[qsignal]
        fn paper_kept(self: Pin<&mut Sioul>, file: QString, title: QString, kind: QString);

        /// A draft's window opens again: "Undo" after sending or discarding.
        /// Also a new draft handed by another application (`outside`).
        #[qsignal]
        fn compose_requested(self: Pin<&mut Sioul>, id: QString);

        /// Files shared from another application came for draft `id`
        /// (`outside`): its window reads its attachments again and says `line`,
        /// a problem when some did not come.
        #[qsignal]
        fn draft_files_arrived(self: Pin<&mut Sioul>, id: QString, line: QString, problem: bool);

        /// Keys were found or made: windows showing them read them again.
        #[qsignal]
        fn keys_changed(self: Pin<&mut Sioul>);

        /// What a security key's band shows now, as JSON {state, line, tries,
        /// warm, action}: for `context`, a draft's id, a message's key, or "setup".
        #[qsignal]
        fn security_key_changed(self: Pin<&mut Sioul>, context: QString, state: QString);

        /// A tie was made or undone: what shows ties reads them again.
        #[qsignal]
        fn links_changed(self: Pin<&mut Sioul>);

        /// Addresses were placed on the map.
        #[qsignal]
        fn places_changed(self: Pin<&mut Sioul>);

        /// A site notified something, or was seen.
        #[qsignal]
        fn sites_changed(self: Pin<&mut Sioul>);

        /// A large vault's search, done off the window's thread: its ticket and its answer (`bitwarden_search`).
        #[qsignal]
        fn bitwarden_found(self: Pin<&mut Sioul>, ticket: i32, found: QString);

        /// Bitwarden's server answered, off the window's thread: the ticket an
        /// unlock, a passkey or a code's sending gave, and its answer.
        #[qsignal]
        fn bitwarden_answered(self: Pin<&mut Sioul>, ticket: i32, answer: QString);

        /// An account chosen among the phone's: its name (an address, usually) and its kind
        /// ("com.google", "e.foundation.webdav.eelo"…); both empty when none was.
        #[qsignal]
        fn phone_account_chosen(self: Pin<&mut Sioul>, name: QString, kind: QString);
    }

    impl cxx_qt::Threading for Sioul {}
}

use qobject::Sioul;
pub(crate) type QtThread = cxx_qt::CxxQtThread<Sioul>;

/// Android: the window waiting for the phone's account chooser to answer.
#[cfg(target_os = "android")]
static PHONE_CHOOSER: std::sync::Mutex<Option<QtThread>> = std::sync::Mutex::new(None);

#[cfg(target_os = "android")]
// SAFETY: declared as android/main.cpp defines them: extern "C", the same types.
unsafe extern "C" {
    /// Opens Android's chooser of the phone's accounts (android/main.cpp).
    fn sioul_android_choose_account();
    /// Whether Sioul may reach your files by their path ("All files access").
    fn sioul_android_files_access() -> bool;
    /// Android's own switch for it.
    fn sioul_android_ask_files_access();
    /// A sync app asked to look for changes now: an explicit broadcast to its
    /// receiver, nothing when it is not installed (android/main.cpp).
    pub(crate) fn sioul_android_broadcast(package: *const std::ffi::c_char, receiver: *const std::ffi::c_char, action: *const std::ffi::c_char);
}

/// Android: the account chosen in the phone's chooser, or two empty texts
/// when none was; called by android/main.cpp, on Android's thread.
///
/// # Safety
/// `name` and `kind` are null, or zero-terminated UTF-8 texts valid for the call.
#[cfg(target_os = "android")]
// SAFETY: no other symbol of the program has this name.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn sioul_android_account_chosen(name: *const std::ffi::c_char, kind: *const std::ffi::c_char) {
    // SAFETY: as the caller promises.
    let read = |text: *const std::ffi::c_char| if text.is_null() { String::new() } else { unsafe { std::ffi::CStr::from_ptr(text) }.to_string_lossy().into_owned() };
    let (name, kind) = (read(name), read(kind));
    let waiting = PHONE_CHOOSER.lock().ok().and_then(|mut w| w.take());
    if let Some(qt) = waiting {
        let _ = qt.queue(move |mut sioul| sioul.as_mut().phone_account_chosen(QString::from(&name), QString::from(&kind)));
    }
}

#[derive(Default)]
pub struct SioulRust {
    porch: QString,
    budgets: QString,
    accounts: QString,
    blocked: QString,
    status: QString,
    busy: bool,
    found: QString,
    scouted: QString,
    scouting: bool,
    form_error: QString,
    form_busy: bool,
    mail_accounts: QString,
    mail_folder: QString,
    drafts: QString,
    mail_search: QString,
    undo_line: QString,
    contacts: QString,
    duplicates: QString,
    agenda: QString,
    overlaps: QString,
    health_view: QString,
    missed_view: QString,
    needs_view: QString,
    tasks: QString,
    notes: QString,
    focus_session: QString,
    reading: QString,
    realtime: bool,
    away: bool,
    mode: QString,
    forecast: QString,
    places_found: QString,
    shared: Arc<Shared>,
}

/// What the background threads and the window share.
#[derive(Default)]
pub(crate) struct Shared {
    /// "Open it anyway", until "Done for now".
    opened_anyway: AtomicBool,
    /// Per account, the last thing its watcher said, and whether it is a problem.
    pub(crate) statuses: Mutex<BTreeMap<String, (String, bool)>>,
    /// Accounts whose password is wanted: none here yet, or refused (`SyncError::wants_password`).
    pub(crate) password_wanted: Mutex<BTreeSet<String>>,
    /// Per account, the newest message the window shows: what "Done for now" closes.
    shown: Mutex<BTreeMap<String, ImapOrigin>>,
    /// The running watchers.
    pub(crate) watchers: Mutex<BTreeMap<String, Arc<Control>>>,
    /// Accounts whose provider id was looked for this session.
    learned: Mutex<BTreeSet<String>>,
    /// Views are computed on threads and may finish out of order: only the newest is shown.
    generation: AtomicU64,
    shown_generation: AtomicU64,
    /// Attachments the antivirus found clean this session, by content.
    clean: Mutex<BTreeSet<u64>>,
    /// The folder the mail page shows.
    pub(crate) open_folder: Mutex<Option<mail::OpenFolder>>,
    /// What waits ten seconds for "Undo".
    pub(crate) pending: Mutex<Vec<Arc<mail::Pending>>>,
    pub(crate) mail_generation: AtomicU64,
    pub(crate) mail_shown_generation: AtomicU64,
    /// When the status line last said what became of something you did: a
    /// routine "Mail fetched at…" does not cover it for a while.
    said_at: Mutex<Option<std::time::Instant>>,
    /// The contacts' search and the agenda's days.
    pub(crate) pim: Mutex<pim::PimState>,
    pub(crate) pim_generation: AtomicU64,
    pub(crate) pim_shown_generation: AtomicU64,
    /// The running syncs of contacts and calendars, by account.
    pub(crate) dav_watchers: Mutex<BTreeMap<String, Arc<Control>>>,
    /// The task and notes pages' choices.
    pub(crate) work: Mutex<work::WorkState>,
    pub(crate) work_generation: AtomicU64,
    pub(crate) work_shown_generation: AtomicU64,
    /// Everything links reach, read after the last change.
    pub(crate) loaded: Mutex<Option<Arc<sioul_core::links::Loaded>>>,
    /// Real time: every folder each minute, the Porch open.
    pub(crate) realtime: AtomicBool,
    /// Addresses are being placed on the map.
    pub(crate) locating: AtomicBool,
    /// Bitwarden's session, once unlocked; in memory only.
    pub(crate) bitwarden: Mutex<Option<crate::sites::Vault>>,
    /// A forecast is being fetched.
    pub(crate) weather_fetching: AtomicBool,
    /// Accounts whose older mail waits for room on the disk, already said.
    pub(crate) held_back: Mutex<std::collections::BTreeSet<String>>,
    /// Cancel on the Google sign-in: its wait for the browser ends.
    pub(crate) google_stop: AtomicBool,
    /// GitHub's issues being brought, when asked.
    pub(crate) github: Mutex<Option<Arc<sioul_sync::Control>>>,
    /// When you were last at this window (Unix seconds): reminders follow you.
    pub(crate) active: std::sync::atomic::AtomicI64,
    /// When the plan was last made again on the clock (Unix seconds), and for which day.
    pub(crate) planned_at: std::sync::atomic::AtomicI64,
    pub(crate) planned_day: std::sync::atomic::AtomicI64,
    /// One computation at a time for each set of pages (`coalesced`).
    views_job: Job,
    pub(crate) mail_job: Job,
    pub(crate) pim_job: Job,
    pub(crate) work_job: Job,
    pub(crate) health_job: Job,
}

/// The plan is made again every twelve hours, and when the day changes: a task
/// not done by its planned day moves on, and what waits for it follows.
const REPLAN_EVERY: i64 = 12 * 3600;

/// How long what you did stays in the status line before routine news.
const SAID_FOR: std::time::Duration = std::time::Duration::from_secs(30);

pub(crate) fn config_path() -> PathBuf {
    config::default_path()
}

pub(crate) fn load_config() -> Config {
    // Read a hundred times a minute: parsed again only when the file changed
    // (its size or its time), as the sharing or another window may change it.
    // A time younger than two seconds is not trusted: two writings of one size
    // within a tick of the clock look alike.
    type Parsed = (PathBuf, u64, std::time::SystemTime, Config);
    static PARSED: Mutex<Option<Parsed>> = Mutex::new(None);
    let path = config_path();
    let settled = |time: &std::time::SystemTime| time.elapsed().is_ok_and(|age| age > std::time::Duration::from_secs(2));
    let stamp = std::fs::metadata(&path).ok().and_then(|m| Some((m.len(), m.modified().ok()?))).filter(|(_, time)| settled(time));
    if let Some((size, time)) = stamp
        && let Ok(parsed) = PARSED.lock()
        && let Some((p, s, t, config)) = parsed.as_ref()
        && *p == path
        && *s == size
        && *t == time
    {
        return config.clone();
    }
    let config = Config::load(&path).unwrap_or_default();
    // The words this program looks for, said once each time the file is read (`words::current`).
    sioul_core::words::set_current(sioul_core::words::Words::of(&config));
    if let (Some((size, time)), Ok(mut parsed)) = (stamp, PARSED.lock()) {
        *parsed = Some((path, size, time, config.clone()));
    }
    config
}

/// One translator for the session: the configuration's language, else the session's.
pub(crate) fn tr() -> &'static Translator {
    static TRANSLATOR: OnceLock<Translator> = OnceLock::new();
    TRANSLATOR.get_or_init(|| Translator::new(&load_config().language.unwrap_or_else(session_language)))
}

/// The session's language: its variables (LC_ALL, LC_MESSAGES, LANG) when it
/// has them, as on Linux; else the system's own setting, as Qt reads it on
/// Windows and macOS, where a window started from the desktop gets none.
fn session_language() -> String {
    let said = ["LC_ALL", "LC_MESSAGES", "LANG"].iter().any(|v| std::env::var(v).is_ok_and(|l| !l.trim().is_empty()));
    if said {
        return i18n::system_language();
    }
    system_locale().unwrap_or_else(i18n::system_language)
}

/// Windows' language for the user ("fr-FR"), as `QLocale::system()` reads it.
#[cfg(windows)]
fn system_locale() -> Option<String> {
    #[link(name = "kernel32")]
    // SAFETY: kernel32's own, as winnls.h declares it: a buffer of UTF-16 and its size in characters, the length written back.
    unsafe extern "system" {
        fn GetUserDefaultLocaleName(name: *mut u16, size: i32) -> i32;
    }
    // LOCALE_NAME_MAX_LENGTH characters, the final zero included.
    let mut name = [0u16; 85];
    // SAFETY: a buffer of `name.len()` UTF-16 characters, as the function asks; it writes no further.
    let written = unsafe { GetUserDefaultLocaleName(name.as_mut_ptr(), name.len() as i32) };
    let length = usize::try_from(written).ok().filter(|n| *n > 1 && *n <= name.len())?;
    Some(String::from_utf16_lossy(&name[..length - 1]))
}

/// The first of the languages chosen in macOS's settings ("fr-FR").
#[cfg(target_os = "macos")]
fn system_locale() -> Option<String> {
    // `defaults` prints them as a list: ( "fr-FR", "en-FR" ).
    let out = std::process::Command::new("defaults").args(["read", "-g", "AppleLanguages"]).output().ok()?;
    String::from_utf8_lossy(&out.stdout).split('"').nth(1).map(str::to_string).filter(|l| !l.is_empty())
}

/// Elsewhere the session's variables say it all.
#[cfg(not(any(windows, target_os = "macos")))]
fn system_locale() -> Option<String> {
    None
}

pub(crate) fn say(id: &str, pairs: &[(&str, String)]) -> String {
    let mut args = i18n::args();
    for (key, value) in pairs {
        // A whole number goes as a number, so that "one" and "other" choose by
        // it ("1 message", "2 messages"); one written otherwise ("007") stays as written.
        match value.parse::<i32>() {
            Ok(n) if n.to_string() == *value => args.set(key.to_string(), n),
            _ => args.set(key.to_string(), value.clone()),
        }
    }
    tr().text(id, Some(&args))
}

pub(crate) fn json(value: &impl serde::Serialize) -> String {
    serde_json::to_string(value).unwrap_or_default()
}

/// A file's address for Qt and the desktop: "file:///home/me/A%20b.pdf", and
/// "file:///C:/Users/me/A%20b.pdf" on Windows; what an address cannot hold as
/// is ("#", "?", spaces, accents) percent-encoded, so the file itself is reached.
pub(crate) fn file_url(path: &Path) -> String {
    fn encoded(path: &str) -> String {
        path.bytes().map(|b| if b.is_ascii_alphanumeric() || b"/-._~!$&'()*+,;=:@".contains(&b) { char::from(b).to_string() } else { format!("%{b:02X}") }).collect()
    }
    let text = path.to_string_lossy().into_owned();
    #[cfg(windows)]
    let text = windows_slashed(&text);
    match text.strip_prefix("//") {
        // "//server/share/…": a network share, its server named (Windows).
        Some(share) if cfg!(windows) => format!("file://{}", encoded(share)),
        _ => format!("file://{}", encoded(&text)),
    }
}

/// A Windows path as an address writes it: "C:\a" → "/C:/a", "\\server\s" →
/// "//server/s", without the "\\?\" `canonicalize` puts in front.
#[cfg(any(windows, test))]
fn windows_slashed(text: &str) -> String {
    let plain = match text.strip_prefix(r"\\?\UNC\") {
        Some(rest) => format!(r"\\{rest}"),
        None => text.strip_prefix(r"\\?\").unwrap_or(text).to_string(),
    };
    let slashed = plain.replace('\\', "/");
    if slashed.starts_with("//") { slashed } else { format!("/{slashed}") }
}

/// Back from an address to a Windows path: "/C:/a" → "C:\a", "server/s" → "\\server\s".
#[cfg(any(windows, test))]
fn windows_path(decoded: &str) -> String {
    let bytes = decoded.as_bytes();
    let path = if bytes.len() >= 3 && bytes[0] == b'/' && bytes[1].is_ascii_alphabetic() && bytes[2] == b':' {
        decoded[1..].to_string()
    } else if decoded.starts_with('/') {
        decoded.to_string()
    } else {
        format!("//{decoded}")
    };
    path.replace('/', "\\")
}

/// The file a `file://` address names (from a file dialog, a drop), its
/// percent-escapes undone; "file:///C:/…" is "C:\…" on Windows. Anything
/// else is a path already.
pub(crate) fn local_path(url: &str) -> PathBuf {
    let Some(rest) = url.strip_prefix("file://") else { return PathBuf::from(url) };
    // "file://localhost/…" is this computer too.
    let rest = rest.strip_prefix("localhost/").map_or_else(|| rest.to_string(), |r| format!("/{r}"));
    let decoded = crate::projects::percent_decoded(&rest);
    #[cfg(windows)]
    let decoded = windows_path(&decoded);
    PathBuf::from(decoded)
}

/// The lock of something done one at a time, when nothing holds it; a panic
/// in an earlier run (bad data in a file) does not stop it for the session.
pub(crate) fn one_at_a_time(lock: &Mutex<()>) -> Option<std::sync::MutexGuard<'_, ()>> {
    match lock.try_lock() {
        Ok(guard) => Some(guard),
        Err(std::sync::TryLockError::Poisoned(poisoned)) => Some(poisoned.into_inner()),
        Err(std::sync::TryLockError::WouldBlock) => None,
    }
}

/// A page computed on a thread, one computation at a time: asked again while
/// one runs, it runs once more after it, with everything changed meanwhile.
/// Fetches and changes ask often; a thread each would pile up on a slow disk.
#[derive(Default)]
pub(crate) struct Job {
    running: AtomicBool,
    again: AtomicBool,
    /// Asked while Sioul was put away: done once it is back.
    deferred: AtomicBool,
}

/// Sioul put away on a phone: the pages are not computed for nobody (Android
/// stops an app that works in the background); each job asked meanwhile runs
/// once when it is back (`back_here`).
pub(crate) static AWAY: AtomicBool = AtomicBool::new(false);

/// Runs `work` on a thread for the job `which` picks out (see `Job`).
pub(crate) fn coalesced(shared: &Arc<Shared>, which: fn(&Shared) -> &Job, work: impl Fn(&Arc<Shared>) + Send + 'static) {
    let job = which(shared);
    if AWAY.load(Ordering::SeqCst) {
        job.deferred.store(true, Ordering::SeqCst);
        return;
    }
    job.again.store(true, Ordering::SeqCst);
    if job.running.swap(true, Ordering::SeqCst) {
        return;
    }
    let shared = Arc::clone(shared);
    std::thread::spawn(move || {
        let job = which(&shared);
        loop {
            while job.again.swap(false, Ordering::SeqCst) {
                // A panic on bad data leaves the next computations free to run.
                let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| work(&shared)));
            }
            job.running.store(false, Ordering::SeqCst);
            // Asked between the two lines above: once more, unless another thread took it.
            if !job.again.load(Ordering::SeqCst) || job.running.swap(true, Ordering::SeqCst) {
                break;
            }
        }
    });
}

/// How long text reads, for the window's theme; and whether the places show their names.
pub(crate) fn reading_json() -> String {
    let config = load_config();
    let reading = config.reading;
    // colour: and the sites' colours, as Settings ▸ Display has them (SitesPage.qml, docs/colour.md).
    serde_json::json!({ "family": reading.family, "size": reading.size, "spacing": reading.spacing, "theme": config.theme.unwrap_or_default(), "places_named": config.places_named, "screen_colours": config.screen_colours.unwrap_or(true), "calmer_colours": config.calmer_colours.unwrap_or_default() }).to_string()
}

/// What the Porch and the budgets read: the configuration and its lists.
struct World {
    config: Config,
    store: Option<ProjectStore>,
    known: SenderList,
    /// Who is safe, neutral or blocked.
    senders: porch::Senders,
}

impl World {
    fn load() -> World {
        let config = load_config();
        World {
            // With the mail tied to projects, so their conversations follow.
            store: config.notes_root_path().and_then(|root| ProjectStore::load(&root).ok()).map(|s| s.with_ties(&sioul_core::links::LocalLinks::load(&sioul_core::links::LocalLinks::default_path()))),
            known: KnownSenders::load(&config.known_senders_path()),
            senders: porch::Senders::load(&config),
            config,
        }
    }

    /// The mail waiting in the Porch; with `state` empty, all the mail kept.
    fn gather(&self, state: &PorchState) -> Vec<Triaged> {
        let now = Zoned::now().timestamp().as_second();
        porch::gather(&self.config.mail_sources(), self.store.as_ref(), &self.known, &self.senders, state, now)
    }

    fn ledger(&self) -> Option<Ledger> {
        // With the bank accounts' movements counted in their budgets.
        self.config.notes_root_path().and_then(|root| Ledger::load_with_bank(&root, &sioul_core::words::Words::of(&self.config)).ok())
    }

    fn ledger_path(&self) -> Option<PathBuf> {
        self.config.notes_root_path().map(|root| root.join(budget::LEDGER))
    }

    /// Every message about money, and what becomes of it.
    fn mail_lines(&self, ledger: &Ledger) -> Vec<MailLine> {
        let ignored = MoneyState::load(&MoneyState::default_path()).ignored;
        budget::mail_lines(ledger, &self.gather(&PorchState::default()), &ignored, &sioul_core::words::Words::of(&self.config))
    }

    /// One message file judged as the Porch judges it, only inside the accounts' own mail.
    fn judge(&self, key: &str) -> Option<(PathBuf, Triaged)> {
        let path = maildir::locate(Path::new(key))?.canonicalize().ok()?;
        let sources = self.config.mail_sources();
        let inside = sources.iter().any(|s| s.folder.canonicalize().is_ok_and(|f| path.starts_with(f)));
        if !inside {
            return None;
        }
        let now = Zoned::now().timestamp().as_second();
        let canonical: Vec<_> = sources
            .into_iter()
            .map(|mut s| {
                s.folder = s.folder.canonicalize().unwrap_or(s.folder);
                s
            })
            .collect();
        let triaged = porch::judge(std::slice::from_ref(&path), &canonical, self.store.as_ref(), &self.known, &porch::Senders::default(), now);
        triaged.into_iter().next().map(|t| (path, t))
    }
}

/// Everything the window shows, computed off Qt's thread.
struct Views {
    porch: String,
    budgets: String,
    accounts: String,
    blocked: String,
    shown: BTreeMap<String, ImapOrigin>,
}

/// Whether Sioul stays off the network: `SIOUL_DEMO` set, for a demo profile
/// and its pictures. Nothing is fetched or sent by itself; what is kept on
/// this computer is shown.
pub(crate) fn offline() -> bool {
    std::env::var_os("SIOUL_DEMO").is_some()
}

/// Where the forecast is kept between fetches (the phone's card reads it too, `homecard`).
pub(crate) fn weather_cache() -> PathBuf {
    config::state_dir().join("weather.json")
}

/// A forecast is kept half an hour.
const WEATHER_FRESH: i64 = 30 * 60;

/// The weather applet, from the forecast kept, fetched again when it is half
/// an hour old; nothing without a place.
pub(crate) fn update_weather(qt: &QtThread, shared: &Arc<Shared>) {
    let config = load_config();
    let (Some(place), Some(latitude), Some(longitude)) = (config.weather.place.clone(), config.weather.latitude, config.weather.longitude) else {
        let _ = qt.queue(|mut sioul| sioul.as_mut().set_forecast(QString::default()));
        return;
    };
    let now = Zoned::now();
    let kept: Option<sioul_core::weather::Forecast> = std::fs::read_to_string(weather_cache()).ok().and_then(|t| serde_json::from_str(&t).ok());
    let shown = move |forecast: &sioul_core::weather::Forecast| {
        let view = sioul_core::weather::view(forecast, &Zoned::now(), tr());
        serde_json::json!({ "place": place, "view": view, "credit": tr().text("weather-credit", None) }).to_string()
    };
    if let Some(forecast) = kept.as_ref() {
        let line = shown(forecast);
        let _ = qt.queue(move |mut sioul| sioul.as_mut().set_forecast(QString::from(&line)));
    }
    let stale = kept.as_ref().is_none_or(|f| now.timestamp().as_second() - f.fetched >= WEATHER_FRESH);
    if !stale || offline() || shared.weather_fetching.swap(true, Ordering::Relaxed) {
        return;
    }
    let (qt, shared) = (qt.clone(), Arc::clone(shared));
    std::thread::spawn(move || {
        if let Ok(forecast) = sioul_sync::weather::forecast(latitude, longitude, Zoned::now().timestamp().as_second()) {
            if let Ok(text) = serde_json::to_string(&forecast) {
                let _ = std::fs::create_dir_all(config::state_dir());
                let _ = std::fs::write(weather_cache(), text);
            }
            // The phone's card shows it too, hour by hour.
            crate::homecard::weather_seen();
            let line = shown(&forecast);
            let _ = qt.queue(move |mut sioul| sioul.as_mut().set_forecast(QString::from(&line)));
        }
        shared.weather_fetching.store(false, Ordering::Relaxed);
    });
}

/// The time now: what it is for, and until when (docs/areas.md; `hours`).
pub(crate) fn mode_now() -> sioul_core::quiet::Mode {
    crate::hours::mode_now()
}

/// Work time or quiet time, as the window shows it.
/// "Work now" taken back, as Sioul starts or closes; the rest of the overrides kept.
fn end_work_now() {
    let path = sioul_core::quiet::Overrides::default_path();
    let mut overrides = sioul_core::quiet::Overrides::load(&path);
    if overrides.work_now.take().is_some()
        && let Err(e) = overrides.save(&path)
    {
        eprintln!("{e}");
    }
}

pub(crate) fn mode_json() -> String {
    let config = load_config();
    let now = Zoned::now();
    let overrides = sioul_core::quiet::Overrides::load(&sioul_core::quiet::Overrides::default_path());
    let mode = crate::hours::mode_at(&now);
    let until = mode.until.as_ref().map(|z| sioul_core::quiet::until_text(tr(), z, &now)).unwrap_or_default();
    let mut args = sioul_core::i18n::args();
    args.set("until", until.clone());
    args.set("label", if mode.label.trim().is_empty() { "none".to_string() } else { mode.label.clone() });
    let reason = serde_json::to_value(&mode.reason).ok().and_then(|v| v.as_str().map(str::to_string)).unwrap_or_default();
    use sioul_core::quiet::Reason;
    let line = match mode.reason {
        Reason::NoHours | Reason::Working => String::new(),
        Reason::TimeOff => tr().text("mode-time-off", Some(&args)),
        Reason::WorkingLate => tr().text("mode-working-late", Some(&args)),
        Reason::WorkNow => tr().text("mode-work-now-line", Some(&args)),
        Reason::AdminTime => tr().text("mode-admin", Some(&args)),
        // A day closed early: when work comes back.
        Reason::DoneForTheDay => tr().text("mode-quiet", Some(&args)),
        // Evenings, days without hours: leisure, until the next change.
        Reason::Evening | Reason::DayOff => tr().text("mode-leisure", Some(&args)),
        Reason::Meal => tr().text("mode-meal", Some(&args)),
        Reason::WindingDown => tr().text("mode-wind-down", Some(&args)),
        Reason::Nap => tr().text("mode-nap", Some(&args)),
        Reason::Sleep => tr().text("mode-sleep", Some(&args)),
        // The pauses (docs/pauses.md): which one, in its own words; the moved end was said once.
        Reason::FreeTime => tr().text(if sioul_core::pause::nothing_now(&overrides, &config.free_time) { "mode-free-time-nothing" } else { "mode-free-time" }, None),
        Reason::Paused => tr().text("mode-paused", None),
        Reason::Extended => String::new(),
    };
    // The day closed today can be taken back, that day only.
    let today = overrides.closed_today(&now);
    // Which hours are set, and the night: the Porch asks for them while they are not.
    let set = |kind: &str| config.windows.iter().any(|w| w.kind() == kind);
    serde_json::json!({
        "quiet": mode.quiet,
        "sleep": mode.sleeps(),
        "time": mode.time.id(),
        "reason": reason,
        "until": until,
        "line": line,
        "hours": !config.week_hours().is_empty(),
        "work_hours": set("work"),
        "admin_hours": set("admin"),
        "night": crate::hours::night_set(),
        "work_now": mode.reason == Reason::WorkNow,
        "today": today,
        // The work day or the day can be closed now (docs/reviews.md); nothing at work or asleep.
        "review": crate::reviews::offer_json(&now, &mode),
        // Free time's choices and today's end of work (docs/pauses.md).
        "pauses": crate::pauses::moment(&config, &overrides, &now),
        // Do-not-disturb on every device (docs/do-not-disturb.md): its switch and where it holds.
        "dnd": crate::everywhere::moment(),
        // "Let every call through", while a phone of yours screens calls (docs/android.md, "Calls").
        "calls": crate::calls::moment()
    })
    .to_string()
}

fn compute(shared: &Shared) -> Views {
    // One look at the mail: the Porch, then the money lines, each message parsed once (`maildir::CardsKept`).
    let _cards = sioul_core::maildir::CardsKept::begin();
    let world = World::load();
    let now = Zoned::now();
    let hidden = mail::hidden_files(shared);
    let mut items = world.gather(&PorchState::load(&PorchState::default_path()));
    items.retain(|t| t.card.path.as_ref().is_none_or(|p| !hidden.contains(p)));
    // The phone's home screen card: the Porch as each coming time will show it (homecard.rs).
    crate::homecard::porch_seen(&items, &world.senders, world.store.as_ref());
    // What reaches you now (docs/attention.md): codes and what you sent
    // yourself always; the rest as its sender's row of the matrix says now
    // (shown, or shown without a word), Always through whatever their row, and
    // as its address is for (an address you did not say: work's) but for your
    // safe senders. No hours set: work and admin together.
    let mode = crate::hours::mode_at(&now);
    {
        let area_of = |t: &sioul_core::porch::Triaged| t.card.account.as_deref().and_then(|id| world.config.account(id)).and_then(|a| a.area.as_deref()).and_then(sioul_core::areas::Area::parse).unwrap_or(sioul_core::areas::Area::WORK);
        let attention = sioul_core::attention::Attention::of(&world.config);
        let moment = crate::hours::attention_at(&mode, &now);
        let always = sioul_core::everywhere::People::load(&sioul_core::everywhere::People::default_path());
        items.retain(|t| attention.mail(t, &world.senders, &always, area_of(t), &moment).shown);
    }
    // Asleep no project shows: what your senders wrote about one comes among the people you know.
    if mode.sleeps() {
        for t in &mut items {
            if matches!(t.lane, sioul_core::porch::Lane::Project(_)) {
                t.lane = sioul_core::porch::Lane::People;
            }
        }
    }
    let opened = shared.opened_anyway.load(Ordering::Relaxed);
    let mut porch = view::porch(&items, &world.config, world.store.as_ref(), tr(), &now, opened || mode.quiet);
    // After a pause, the Porch rests until the next admin hours, unless opened (docs/pauses.md).
    crate::pauses::porch_rests(&mut porch, opened, &now);
    if mode.quiet {
        porch.status = serde_json::from_str::<serde_json::Value>(&mode_json()).ok().and_then(|v| v["line"].as_str().map(str::to_string)).unwrap_or_default();
    }
    // Closed, the Porch shows only codes: "Done for now" has nothing to close.
    let shown = if porch.open { PorchState::newest_shown(&items) } else { BTreeMap::new() };
    let budgets = world.ledger().map_or_else(String::new, |mut ledger| {
        // Budgets as their area goes: leisure money ("personal"), work's, the rest admin.
        if mode.time != sioul_core::areas::Time::Any {
            // "personal" was the word for leisure money before areas had three.
            let area_of = |b: &sioul_core::budget::Budget| match b.area.as_deref() {
                Some("personal") => sioul_core::areas::Area::LEISURE,
                Some(other) => sioul_core::areas::Area::parse(other).unwrap_or(sioul_core::areas::Area::ADMIN),
                None => sioul_core::areas::Area::ADMIN,
            };
            ledger.budgets.retain(|b| sioul_core::areas::in_view(area_of(b), mode.time, mode.week));
        }
        let mail = world.mail_lines(&ledger);
        json(&view::budgets(&ledger, &mail, tr(), now.date()))
    });
    let statuses = shared.statuses.lock().map(|s| s.clone()).unwrap_or_default();
    let wanted = shared.password_wanted.lock().map(|w| w.clone()).unwrap_or_default();
    Views {
        // On a phone, a line on other apps' notifications held and come back (docs/android.md).
        porch: crate::appnotes::with_line(json(&porch)),
        budgets,
        accounts: json(&view::accounts(&world.config, tr(), &statuses, &wanted)),
        blocked: json(&world.senders.blocked.entries()),
        shown,
    }
}

/// Computes the views on a thread and shows them, unless newer ones came first.
pub(crate) fn show(qt: &QtThread, shared: &Arc<Shared>) {
    crate::mailsearch::changed(qt, shared);
    let qt = qt.clone();
    coalesced(shared, |s| &s.views_job, move |shared| {
        // One look at the mail for the Mail page and the Porch: the folder the
        // page shows (the inbox, most often) is parsed once for both, not once
        // each (the owner's question, whether the phone parses each message once).
        let _cards = sioul_core::maildir::CardsKept::begin();
        mail::show_mail_here(&qt, shared);
        let generation = shared.generation.fetch_add(1, Ordering::Relaxed) + 1;
        let views = compute(shared);
        let _ = qt.queue(move |mut sioul| {
            let shared = Arc::clone(&sioul.rust().shared);
            // Only the newest: results queued while the window was frozen (a phone
            // with Sioul in the back) are not applied one after the other at its return.
            if shared.generation.load(Ordering::Relaxed) != generation || shared.shown_generation.fetch_max(generation, Ordering::Relaxed) > generation {
                return;
            }
            if let Ok(mut shown) = shared.shown.lock() {
                *shown = views.shown;
            }
            sioul.as_mut().set_porch(QString::from(&views.porch));
            sioul.as_mut().set_budgets(QString::from(&views.budgets));
            sioul.as_mut().set_accounts(QString::from(&views.accounts));
            sioul.as_mut().set_blocked(QString::from(&views.blocked));
            // Accounts added, renamed or removed: Android's share sheet follows (docs/android.md, "Sharing").
            if cfg!(target_os = "android") {
                std::thread::spawn(|| crate::outside::publish(false));
            }
        });
    });
}

pub(crate) fn set_status(qt: &QtThread, line: String) {
    let _ = qt.queue(move |mut sioul| sioul.as_mut().set_status(QString::from(&line)));
}

/// Says what became of something you did; it stays a while (`SAID_FOR`).
pub(crate) fn tell(qt: &QtThread, shared: &Shared, line: String) {
    if let Ok(mut said) = shared.said_at.lock() {
        *said = Some(std::time::Instant::now());
    }
    set_status(qt, line);
}

/// Starts a watcher for every mail account that has none running.
fn start_watchers(qt: &QtThread, shared: &Arc<Shared>) -> usize {
    if offline() {
        return 0;
    }
    let accounts: Vec<Account> = load_config().accounts.into_iter().filter(Account::syncs).collect();
    let count = accounts.len();
    for account in accounts {
        start_watcher(qt, shared, account);
    }
    count
}

/// Syncs for the accounts not started yet this session: those another device's
/// settings just brought. One that stopped (a password refused) is not tried
/// again here: retries can lock an account.
pub(crate) fn start_new_watchers(qt: &QtThread, shared: &Arc<Shared>) {
    if offline() {
        return;
    }
    let seen = |id: &str| shared.statuses.lock().is_ok_and(|s| s.contains_key(id)) || shared.watchers.lock().is_ok_and(|w| w.contains_key(id)) || shared.dav_watchers.lock().is_ok_and(|w| w.contains_key(id));
    for account in load_config().accounts.into_iter().filter(|a| !seen(&a.id)) {
        if account.is_dav() {
            crate::pim::start_dav_watcher(qt, shared, account);
        } else if account.syncs() {
            start_watcher(qt, shared, account);
        }
    }
}

/// An account's password given on this device: tested with its server (its
/// mail, or its calendars and contacts), kept in the keyring, its sync started
/// again; `account_password_done` says how it went.
fn give_password(qt: &QtThread, shared: &Arc<Shared>, id: String, password: String) {
    let (qt, shared) = (qt.clone(), Arc::clone(shared));
    std::thread::spawn(move || {
        let config = load_config();
        let outcome = match config.every_account().find(|a| a.id == id).cloned() {
            None => Err(say("account-unknown", &[("id", id.clone())])),
            Some(mut account) => {
                let host = account.host.clone().unwrap_or_default();
                let password = sioul_sync::tidy_password(&host, &password);
                // Google's mail signed in with Google, given an app password
                // instead: tried as a password, then kept as one.
                let switched = !account.is_dav() && account.auth.as_deref() == Some("google");
                if switched {
                    account.auth = None;
                }
                let tested = if account.is_dav() {
                    let address = account.address.clone().unwrap_or_default();
                    let login = account.login().unwrap_or(address.as_str()).to_string();
                    sioul_sync::dav::test(&address, &login, &password, account.url.as_deref(), None).map(|_| ())
                } else {
                    sioul_sync::test(&account, &password).map(|_| ())
                };
                tested
                    .and_then(|()| secret::save(&account, &password))
                    .map_err(|e| e.sentence(tr(), &account.id))
                    .and_then(|()| if switched { config::set_auth(&config_path(), &account.id, None) } else { Ok(()) })
                    .map(|()| {
                        if switched {
                            // Its watcher signed in with Google: it goes, another starts below.
                            if let Some(control) = shared.watchers.lock().ok().and_then(|mut w| w.remove(&account.id)) {
                                control.stop();
                            }
                            let _ = sioul_sync::google::revoke_for(sioul_sync::google::Purpose::Mail, account.address.as_deref().unwrap_or(""));
                        }
                        account
                    })
            }
        };
        let problem = match outcome {
            Ok(account) => {
                want_password(&shared, &account.id, None);
                if let Ok(mut statuses) = shared.statuses.lock() {
                    statuses.remove(&account.id);
                }
                if account.is_dav() {
                    crate::pim::start_dav_watcher(&qt, &shared, account);
                } else {
                    start_watcher(&qt, &shared, account);
                }
                String::new()
            }
            Err(e) => e,
        };
        let _ = qt.queue(move |mut sioul| {
            sioul.as_mut().set_form_busy(false);
            if problem.is_empty() {
                sioul.as_mut().set_status(QString::from(&say("account-password-kept", &[("account", id.clone())])));
            }
            sioul.as_mut().account_password_done(QString::from(&id), QString::from(&problem));
        });
        show(&qt, &shared);
    });
}

/// A mail account added: tested with its password (given, or, `None`, the one
/// its address's calendars and contacts use), then kept; its watcher started.
#[allow(clippy::too_many_arguments)]
fn add_mail(qt: &QtThread, shared: &Arc<Shared>, address: String, host: String, port: u16, security: Security, login: String, password: Option<String>) {
    let (qt, shared) = (qt.clone(), Arc::clone(shared));
    std::thread::spawn(move || {
        let config = load_config();
        // The same address may have calendars and contacts already: only its mail counts.
        let outcome = match config.every_account().find(|a| a.address.as_deref() == Some(address.as_str()) && matches!(a.kind, config::AccountKind::Imap | config::AccountKind::Jmap)) {
            Some(existing) => Err(say("account-address-exists", &[("address", address.clone()), ("id", existing.id.clone())])),
            None => {
                let password = match password {
                    Some(p) => Ok(p),
                    None => config
                        .every_account()
                        .find(|a| a.address.as_deref() == Some(address.as_str()) && a.kind == config::AccountKind::Dav)
                        .ok_or_else(|| say("account-unknown", &[("id", address.clone())]))
                        .and_then(|dav| secret::password(dav).map_err(|e| e.sentence(tr(), &dav.id))),
                };
                password.and_then(|password| {
                    let id = config.free_id(&address);
                    let account = Account::imap(&id, &address, &host, port, security, Some(&login));
                    let password = sioul_sync::tidy_password(&host, &password);
                    sioul_sync::test(&account, &password)
                        .and_then(|_| secret::save(&account, &password))
                        .map_err(|e| e.sentence(tr(), &id))
                        .and_then(|()| config::add_imap_account(&config_path(), &account))
                        .map(|()| account)
                })
            }
        };
        let added = outcome.as_ref().ok().map(|a| say("account-added", &[("id", a.id.clone()), ("path", a.maildir_path().display().to_string())]));
        if let Ok(account) = outcome.as_ref() {
            start_watcher(&qt, &shared, account.clone());
        }
        let error = outcome.err();
        let _ = qt.queue(move |mut sioul| {
            sioul.as_mut().set_form_busy(false);
            match (added, error) {
                (Some(line), _) => {
                    sioul.as_mut().set_found(QString::default());
                    sioul.as_mut().set_scouted(QString::default());
                    sioul.as_mut().set_status(QString::from(&line));
                    sioul.as_mut().account_added();
                }
                (None, Some(e)) => sioul.as_mut().set_form_error(QString::from(&e)),
                (None, None) => {}
            }
        });
        show(&qt, &shared);
    });
}

/// The pace of an address: its own, else everyone's.
fn pace_of(config: &Config, account: &Account) -> std::time::Duration {
    let minutes = account.fetch_minutes.or(config.fetch_minutes).unwrap_or(config::DEFAULT_FETCH_MINUTES);
    std::time::Duration::from_secs(u64::from(minutes.max(1)) * 60)
}

/// Gives every running watcher its pace from the configuration, and real time.
pub(crate) fn update_paces(shared: &Shared) {
    let config = load_config();
    let realtime = shared.realtime.load(Ordering::Relaxed);
    let Ok(watchers) = shared.watchers.lock() else { return };
    for account in config.accounts.iter() {
        if let Some(control) = watchers.get(&account.id) {
            control.set_pace(pace_of(&config, account));
            control.set_realtime(realtime);
        }
    }
}

pub(crate) fn start_watcher(qt: &QtThread, shared: &Arc<Shared>, account: Account) {
    let control = Arc::new(Control::default());
    control.set_pace(pace_of(&load_config(), &account));
    control.set_realtime(shared.realtime.load(Ordering::Relaxed));
    {
        let Ok(mut watchers) = shared.watchers.lock() else { return };
        if let Some(running) = watchers.get(&account.id) {
            // Already watching: fetch now instead, a refused password tried again too.
            running.retry();
            return;
        }
        watchers.insert(account.id.clone(), Arc::clone(&control));
    }
    let (qt, shared) = (qt.clone(), Arc::clone(shared));
    std::thread::spawn(move || {
        match secret::password(&account) {
            Ok(password) => sioul_sync::watch(&account, &password, &control, |result| reported(&qt, &shared, &account, result)),
            Err(e) => reported(&qt, &shared, &account, Err(e)),
        }
        // Gone, unless another watcher replaced this one meanwhile.
        if let Ok(mut watchers) = shared.watchers.lock()
            && watchers.get(&account.id).is_some_and(|c| Arc::ptr_eq(c, &control))
        {
            watchers.remove(&account.id);
        }
    });
}

/// Notes whether an account's password is wanted after what its sync said:
/// none here, or refused. Its card then offers to give one.
pub(crate) fn want_password(shared: &Shared, id: &str, error: Option<&SyncError>) {
    if let Ok(mut wanted) = shared.password_wanted.lock() {
        if error.is_some_and(SyncError::wants_password) {
            wanted.insert(id.to_string());
        } else {
            wanted.remove(id);
        }
    }
}

/// What a watcher said: the account's status, the provider's id to learn,
/// notifications for new codes, and the views again.
fn reported(qt: &QtThread, shared: &Arc<Shared>, account: &Account, result: Result<Report, SyncError>) {
    let (line, problem) = match &result {
        Ok(report) if report.first => {
            let mut args = tr().counted(report.new.len());
            args.set("account", account.id.clone());
            args.set("days", account.sync_days.unwrap_or(config::DEFAULT_SYNC_DAYS));
            (tr().text("sync-first", Some(&args)), false)
        }
        Ok(_) => (say("ui-synced-at", &[("time", Zoned::now().strftime("%H:%M").to_string())]), false),
        Err(e) => (e.sentence(tr(), &account.id), true),
    };
    if let Ok(mut statuses) = shared.statuses.lock() {
        statuses.insert(account.id.clone(), (line.clone(), problem));
    }
    want_password(shared, &account.id, result.as_ref().err());
    if let Ok(report) = &result {
        if !report.new.is_empty() {
            learn(qt, shared, &account.id);
            tie_to_projects(&report.new);
        }
        if !report.elsewhere.is_empty() {
            tie_to_projects(&report.elsewhere);
        }
        // Older mail waits for room: said once a session, calmly.
        if report.held_back
            && shared.held_back.lock().is_ok_and(|mut said| said.insert(account.id.clone()))
        {
            let free = sioul_sync::disk::space(&account.maildir_path()).map_or(0, |(free, _)| free);
            set_status(qt, say("sync-held-back", &[("account", account.id.clone()), ("free", tr().decimal((free as f64 / f64::from(1u32 << 30)) as f32))]));
        }
        if !report.first && !report.new.is_empty() {
            notify_codes(qt, &report.new);
            sort_on_server(qt, shared, account, report.new.clone());
            // New mail your lists let through now, once per batch (docs/porch.md,
            // "Notifications"); what your filter flagged or moves is never told; what
            // a mail filter would take waits for it (told after, if it could not act).
            let window = crate::mailnote::Window { qt: qt.clone(), active: shared.active.load(Ordering::Relaxed) };
            crate::mailnote::arrived_in_window(window, &account.id, &report.new, report.first);
        } else if !report.first && sioul_sync::filters::due(account) {
            // Nothing new, but a filter's failure to try again, or another device's mark to look at again.
            sort_on_server(qt, shared, account, Vec::new());
        }
        read_shielded(qt, &account.id);
    }
    // Routine news waits while the line says what became of something you did.
    let recent = shared.said_at.lock().ok().and_then(|s| *s).is_some_and(|at| at.elapsed() < SAID_FOR);
    let quiet = recent && !problem;
    let _ = qt.queue(move |mut sioul| {
        sioul.as_mut().set_busy(false);
        if !quiet {
            sioul.as_mut().set_status(QString::from(&line));
        }
    });
    show(qt, shared);
}

/// After a fetch of `account` (`new`: its inbox's arrivals, maybe none), on a
/// thread of its own (it reaches the server; this is the watcher's): what your
/// own spam filter moves, as you chose, into the Junk folder; then your mail
/// filters (docs/client.md, "Filters"), on the arrivals still unread and what
/// waits for another look, never on what the spam filter reviews. What a filter
/// could not act on is told as new mail, and why said in the status line; the
/// Porch is read again when something moved.
fn sort_on_server(qt: &QtThread, shared: &Arc<Shared>, account: &Account, new: Vec<PathBuf>) {
    let (account, qt, shared) = (account.clone(), qt.clone(), Arc::clone(shared));
    let window = crate::mailnote::Window { qt: qt.clone(), active: shared.active.load(Ordering::Relaxed) };
    std::thread::spawn(move || {
        let moved = crate::spam::after_fetch(&account, &new, false);
        let filtered = crate::filters::after_fetch(&account, &new, false);
        if !filtered.problem.is_empty() {
            set_status(&qt, filtered.problem.clone());
        }
        crate::mailnote::unfiltered_in_window(window, &account.id, &filtered.tell);
        if moved + filtered.acted > 0 {
            show(&qt, &shared);
        }
    });
}

/// Mail just fetched that a project takes, by its routes or its conversation:
/// tied to the project, so its page shows it whatever its routes need, and
/// the replies that come later follow it.
fn tie_to_projects(files: &[PathBuf]) {
    let config = load_config();
    let path = sioul_core::links::LocalLinks::default_path();
    let mut ties = sioul_core::links::LocalLinks::load(&path);
    let before = ties.links.len();
    // GitHub's notification mail, to its issue's task.
    crate::github::tie_mail(&config, files, &mut ties);
    if let Some(store) = config.notes_root_path().and_then(|root| ProjectStore::load(&root).ok()).map(|s| s.with_ties(&ties)) {
        let senders = porch::Senders::load(&config);
        for t in porch::judge(files, &config.mail_sources(), Some(&store), &KnownSenders::default(), &senders, Zoned::now().timestamp().as_second()) {
            if let (porch::Lane::Project(id), Some(mid)) = (&t.lane, t.card.message_id.as_deref()) {
                ties.add(&sioul_core::links::mail_uri(mid), &sioul_core::links::project_uri(id), "project");
            }
        }
    }
    // Only what this added, written under the file's lock over the ties there
    // now: a tie made meanwhile (the window, an agent, the sharing) stays.
    let _ = sioul_core::links::LocalLinks::add_all(&path, &ties.links[before..]);
}

/// A project's routes changed: the mail already here that only its text or an
/// attachment ties to it, tied now, on a thread (routes on the sender and the
/// subject are matched again each time the project shows). Each message as
/// the Porch takes it (`porch::Gate`): never one it sets aside (a blocked
/// sender, forged, a borrowed name, spam a route does not protect).
fn retie_project(id: String) {
    std::thread::spawn(move || {
        let config = load_config();
        let Some(project) = config.notes_root_path().and_then(|root| ProjectStore::load(&root).ok()).and_then(|s| s.get(&id).cloned()) else { return };
        let routes: Vec<&sioul_core::projects::Route> = project.routes.iter().filter(|r| r.needs_body()).collect();
        if routes.is_empty() {
            return;
        }
        let path = sioul_core::links::LocalLinks::default_path();
        let mut ties = sioul_core::links::LocalLinks::load(&path);
        let before = ties.links.len();
        let gate = porch::Gate::load(&config, Zoned::now().timestamp().as_second());
        for account in config.accounts.iter().filter(|a| a.syncs()) {
            let files = sioul_core::mailindex::message_files(&account.maildir_path());
            for mid in gate.routed(&routes, files.iter().map(PathBuf::as_path)) {
                ties.add(&sioul_core::links::mail_uri(&mid), &sioul_core::links::project_uri(&project.id), "project");
            }
        }
        let _ = sioul_core::links::LocalLinks::add_all(&path, &ties.links[before..]);
    });
}

/// A shielded address that allows the AI: what it has not read yet, read now,
/// before the Porch shows it again. Nothing is sent without a key.
fn read_shielded(qt: &QtThread, id: &str) {
    let config = load_config();
    if !config.account(id).is_some_and(|a| a.shield && a.shield_ai) {
        return;
    }
    if let Err(e) = sioul_sync::shield_ai::read_new(&config) {
        set_status(qt, e.sentence(tr(), "Anthropic"));
    }
}

/// Learns the provider's authserv-id once per session, while it is unknown.
fn learn(qt: &QtThread, shared: &Shared, id: &str) {
    if shared.learned.lock().map_or(true, |l| l.contains(id)) {
        return;
    }
    let Some(account) = load_config().account(id).cloned() else { return };
    match sioul_sync::learn_provider(&config_path(), &account) {
        Ok(Learned::TooEarly) => {}
        Ok(learned) => {
            if let Ok(mut done) = shared.learned.lock() {
                done.insert(id.to_string());
            }
            match learned {
                Learned::Id(provider) => set_status(qt, say("sync-learned", &[("account", id.to_string()), ("id", provider)])),
                Learned::Nothing => set_status(qt, say("sync-not-learned", &[("account", id.to_string())])),
                _ => {}
            }
        }
        Err(e) => set_status(qt, e),
    }
}

/// One quiet notification per verified code among new mail, with a copy button.
fn notify_codes(qt: &QtThread, files: &[PathBuf]) {
    // As the matrix of what reaches you says (as usual, at once at any time;
    // "On the Porch only" a choice while you sleep): a code not told waits on the Porch.
    if !crate::hours::comes(sioul_core::attention::Kind::Codes) {
        return;
    }
    let config = load_config();
    let now = Zoned::now().timestamp().as_second();
    let senders = porch::Senders::load(&config);
    // Codes are decided before projects and screening: neither is needed here.
    let judged = porch::judge(files, &config.mail_sources(), None, &KnownSenders::default(), &senders, now);
    for code in view::codes(&judged, tr()) {
        let copy = code.code.clone().map(|text| {
            let qt = qt.clone();
            let action: Box<dyn FnOnce() + Send> = Box::new(move || {
                let _ = qt.queue(move |sioul| sioul.copy_requested(QString::from(&text)));
            });
            (tr().text("notify-copy", None), action)
        });
        if let Err(e) = notify::code(&code.title, &code.body(), copy) {
            set_status(qt, e);
        }
    }
}

/// Where attachments are written to be opened: `<cache>/sioul/attachments/<message>/`.
fn attachment_cache(key: &str) -> PathBuf {
    let mut hasher = std::collections::hash_map::DefaultHasher::new();
    key.hash(&mut hasher);
    config::cache_dir().join("attachments").join(format!("{:016x}", hasher.finish()))
}

/// Attachments written to be opened in an earlier session, taken out of the
/// cache once a day old: a decrypted one would stay readable there otherwise.
fn forget_opened_attachments() {
    let Ok(entries) = std::fs::read_dir(config::cache_dir().join("attachments")) else { return };
    let day = std::time::Duration::from_secs(86_400);
    for entry in entries.filter_map(Result::ok) {
        if entry.metadata().and_then(|m| m.modified()).ok().and_then(|t| t.elapsed().ok()).is_some_and(|age| age > day) {
            let _ = std::fs::remove_dir_all(entry.path());
        }
    }
}

/// A file come by mail marked as the system marks what comes from the
/// Internet: the Mark of the Web on Windows, the quarantine on macOS. Office
/// then opens it in Protected View, Gatekeeper checks it. A disk that cannot
/// keep the mark leaves the file as it is.
fn mark_from_mail(file: &Path) {
    #[cfg(windows)]
    {
        let mut stream = file.as_os_str().to_owned();
        stream.push(":Zone.Identifier");
        let _ = std::fs::write(stream, "[ZoneTransfer]\r\nZoneId=3\r\n");
    }
    #[cfg(target_os = "macos")]
    {
        let stamp = format!("0081;{:x};Sioul;", jiff::Timestamp::now().as_second());
        let _ = std::process::Command::new("xattr").args(["-w", "com.apple.quarantine", &stamp]).arg(file).output();
    }
    #[cfg(not(any(windows, target_os = "macos")))]
    let _ = file;
}

/// The downloads folder the desktop names.
fn downloads() -> PathBuf {
    config::downloads_dir()
}

/// `name`, else "name (2).ext", "name (3).ext"… so nothing is overwritten.
fn free_path(folder: &Path, name: &str) -> PathBuf {
    let wanted = folder.join(name);
    if !wanted.exists() {
        return wanted;
    }
    let (stem, extension) = match name.rsplit_once('.') {
        Some((stem, ext)) if !stem.is_empty() => (stem.to_string(), format!(".{ext}")),
        _ => (name.to_string(), String::new()),
    };
    (2..).map(|n| folder.join(format!("{stem} ({n}){extension}"))).find(|p| !p.exists()).unwrap_or(wanted)
}

/// An attachment's name as one file in a folder. The core takes any path out
/// of it; Windows also reads "C:x" as a drive, "a:b" as a hidden stream and
/// "CON", "NUL"… as devices: those characters become "_", those names get one
/// in front, and the dots and spaces it would drop at the end go.
fn one_file_name(name: &str) -> String {
    let odd = |c: char| matches!(c, '/' | '\\') || (cfg!(windows) && matches!(c, ':' | '<' | '>' | '"' | '|' | '?' | '*'));
    let mut name: String = name.chars().map(|c| if odd(c) { '_' } else { c }).collect();
    if cfg!(windows) {
        name = name.trim_end_matches(['.', ' ']).to_string();
        let stem = name.split('.').next().unwrap_or("").trim_end().to_ascii_uppercase();
        let numbered = stem.len() == 4 && (stem.starts_with("COM") || stem.starts_with("LPT")) && stem.as_bytes()[3].is_ascii_digit();
        if numbered || matches!(stem.as_str(), "CON" | "PRN" | "AUX" | "NUL") {
            name.insert(0, '_');
        }
    }
    if matches!(name.as_str(), "" | "." | "..") { "attachment".into() } else { name }
}

/// What happens to an attachment once the antivirus found it clean. One the
/// desktop would run rather than show (`links::is_program`: programs, scripts,
/// shortcuts, installers, disk images) is only saved.
#[derive(Clone, Copy, PartialEq, Eq)]
enum Afterwards {
    Open,
    Save,
    Paper,
}

impl Afterwards {
    fn of(what: i32) -> Afterwards {
        match what {
            1 => Afterwards::Save,
            2 => Afterwards::Paper,
            _ => Afterwards::Open,
        }
    }
}

/// Writes an attachment to the cache, has the antivirus check it, then opens or
/// saves it; a threat, or no antivirus, and the copy is deleted. On a phone,
/// which has no antivirus Sioul can call, nothing is scanned and nothing
/// claims it: the attachment opens in the app you choose, or Android asks
/// where to save it (`attachments`).
fn checked_attachment(qt: &QtThread, shared: &Arc<Shared>, key: String, index: i32, afterwards: Afterwards, unchecked: bool) {
    let (qt, shared) = (qt.clone(), Arc::clone(shared));
    std::thread::spawn(move || {
        let world = World::load();
        // Set aside, a message's attachments are not opened.
        let judged = world.judge(&key).filter(|(_, t)| t.lane != porch::Lane::SetAside);
        let subject = judged.as_ref().map(|(_, t)| t.card.subject.clone()).unwrap_or_default();
        let found = judged.and_then(|(path, _)| reading::attachment_from(&crypto::readable(&path)?, u32::try_from(index).ok()?));
        let Some((name, bytes)) = found else {
            set_status(&qt, tr().text("ui-attachments-closed", None));
            return;
        };
        let name = one_file_name(&name);
        let phone = crate::attachments::phone();
        // A program is never started from a mail, checked or not: an antivirus
        // may not know a new one yet. Saved, it is yours to run. On a phone,
        // Android's installers too.
        if afterwards != Afterwards::Save && crate::attachments::kept_closed(&name, phone) {
            set_status(&qt, say("attachment-program", &[("name", name)]));
            return;
        }
        let folder = attachment_cache(&key);
        let file = folder.join(&name);
        if std::fs::create_dir_all(&folder).and_then(|()| std::fs::write(&file, &bytes)).is_err() {
            set_status(&qt, say("scan-error", &[("name", name), ("detail", folder.display().to_string())]));
            return;
        }
        mark_from_mail(&file);
        if !phone {
            set_status(&qt, say("scan-running", &[("name", name.clone())]));
        }
        // Keyed anew each session: a file cannot be made to pass for one found clean.
        static KEYS: OnceLock<std::collections::hash_map::RandomState> = OnceLock::new();
        let content = std::hash::BuildHasher::hash_one(KEYS.get_or_init(Default::default), &bytes);
        let known_clean = shared.clean.lock().is_ok_and(|c| c.contains(&content));
        // Opened without a check: you said so, knowing no antivirus is here; or a phone, which has none.
        let verdict = match crate::attachments::check(phone, known_clean, unchecked) {
            crate::attachments::Check::Scan => antivirus::scan(&file),
            crate::attachments::Check::Skip | crate::attachments::Check::Unchecked => Verdict::Clean,
        };
        let line = match verdict {
            Verdict::Clean => {
                if !unchecked
                    && !phone
                    && let Ok(mut clean) = shared.clean.lock()
                {
                    clean.insert(content);
                }
                match afterwards {
                    // Android's own app for it, which you choose; the words say it was not checked.
                    Afterwards::Open if phone => crate::attachments::open(&file, &name),
                    Afterwards::Open => {
                        let url = file_url(&file);
                        let _ = qt.queue(move |sioul| sioul.open_url(QString::from(&url)));
                        say("scan-clean", &[("name", name)])
                    }
                    Afterwards::Paper => {
                        let kept = crate::papers::keep_checked(&file, &name, &subject);
                        let _ = std::fs::remove_file(&file);
                        match kept {
                            Ok((path, title, kind)) => {
                                let _ = qt.queue(move |mut sioul| sioul.as_mut().paper_kept(QString::from(&path), QString::from(&title), QString::from(kind)));
                                say("papers-kept", &[("name", name)])
                            }
                            Err(e) => say("scan-error", &[("name", name), ("detail", e)]),
                        }
                    }
                    // Android's question where: a phone's downloads are not Sioul's to write.
                    Afterwards::Save if phone => crate::attachments::save(&qt, &file, &name),
                    Afterwards::Save => {
                        let target = free_path(&downloads(), &name);
                        let saved = std::fs::create_dir_all(downloads()).and_then(|()| std::fs::copy(&file, &target));
                        let _ = std::fs::remove_file(&file);
                        match saved {
                            Ok(_) => {
                                mark_from_mail(&target);
                                say("ui-saved", &[("path", target.display().to_string())])
                            }
                            Err(e) => say("scan-error", &[("name", name), ("detail", e.to_string())]),
                        }
                    }
                }
            }
            Verdict::Infected(threat) => {
                let _ = std::fs::remove_file(&file);
                say("scan-infected", &[("name", name), ("threat", threat)])
            }
            // No antivirus here, or a file larger than it scans: asked before
            // anything opens, with how to install one, or why it was not scanned.
            Verdict::Unavailable(_) | Verdict::TooBig => {
                let _ = std::fs::remove_file(&file);
                let what = match afterwards {
                    Afterwards::Open => 0,
                    Afterwards::Save => 1,
                    Afterwards::Paper => 2,
                };
                let big = verdict == Verdict::TooBig;
                let (key, hint, shown) = (key.clone(), antivirus::install_hint(), name.clone());
                let _ = qt.queue(move |mut sioul| sioul.as_mut().scan_unavailable(QString::from(&key), index, what, QString::from(&shown), QString::from(&hint), big));
                match verdict {
                    Verdict::Unavailable(problem) => say("scan-unavailable-short", &[("detail", problem)]),
                    _ => say("scan-too-big", &[("name", name)]),
                }
            }
        };
        set_status(&qt, line);
    });
}

/// The settings found, as the form shows them.
#[derive(serde::Serialize)]
struct FoundView {
    host: String,
    port: u16,
    security: &'static str,
    login: String,
    /// "Found: …, from your provider's own settings."
    by: String,
    /// Gmail's app password, or the general advice.
    hint: String,
    /// Where to make an app password, when the provider is known for wanting one.
    help_url: Option<&'static str>,
    /// Google keeps this address's mail (Gmail, Google Workspace): never its
    /// account password there, an app password or Google's own sign-in.
    google: bool,
    /// A Google key of your own is kept on this device for this address.
    google_key: bool,
}

/// A message laid out for reading, as JSON (`view::MessageView`); empty if it
/// cannot be read. Read on a thread of its own (`read_message`).
fn message_json(key: &str) -> String {
    let world = World::load();
    let own = mail::own_addresses(&world.config);
    let shown = world.judge(key).and_then(|(path, triaged)| {
        let raw = std::fs::read(&path).ok()?;
        crypto::learn_autocrypt(&raw, &triaged);
        let (opened, protection) = match crypto::open(&raw) {
            Some((opened, protection)) => (opened, Some(protection)),
            None => (None, None),
        };
        let mut shown = view::message_from(opened.as_deref().unwrap_or(&raw), &path, &triaged, &own, tr(), protection)?;
        shown.role = mail::locate(key).and_then(|(account, file)| sioul_sync::mailbox::folder_of(&account, &file)).map(|f| f.role);
        shown.unsubscribe = mail::unsubscribe_view(&world.config, &triaged);
        Some(shown)
    });
    shown.map_or_else(String::new, |m| json(&m))
}

impl qobject::Sioul {
    pub(crate) fn shared(&self) -> Arc<Shared> {
        Arc::clone(&self.rust().shared)
    }

    fn text(&self, id: &QString) -> QString {
        QString::from(&tr().text(&id.to_string(), None))
    }

    fn text_args(&self, id: &QString, args: &QString) -> QString {
        let given: serde_json::Map<String, serde_json::Value> = serde_json::from_str(&args.to_string()).unwrap_or_default();
        let pairs: Vec<(&str, String)> = given.iter().map(|(k, v)| (k.as_str(), v.as_str().map_or_else(|| v.to_string(), str::to_string))).collect();
        QString::from(&say(&id.to_string(), &pairs))
    }

    fn text_with(&self, id: &QString, name: &QString, value: &QString) -> QString {
        QString::from(&say(&id.to_string(), &[(&name.to_string(), value.to_string())]))
    }

    fn text_counted(&self, id: &QString, n: i32) -> QString {
        QString::from(&tr().text(&id.to_string(), Some(&tr().counted(usize::try_from(n).unwrap_or(0)))))
    }

    fn start(mut self: Pin<&mut Self>) {
        // "Work now" lasts while Sioul is open: a session that ended without saying so ends it.
        end_work_now();
        // Sites an older file kept among the accounts move to their own list, a copy kept beside, made once.
        if let Err(e) = config::migrate_sites_at_start(&config_path()) {
            eprintln!("{e}");
        }
        self.as_mut().set_reading(QString::from(&reading_json()));
        self.as_mut().set_mode(QString::from(&mode_json()));
        // What other applications handed (a share, a mailto: link), made drafts (docs/client.md).
        crate::outside::started(self.as_mut());
        // The pauses' do-not-disturb as they are, a "Pause" pressed on a phone's tile (docs/pauses.md).
        crate::pauses::tick(&self.qt_thread(), &self.shared());
        // Your sites' own icons, from the start rather than at the first minute.
        crate::sites::favicon_tick(&self.qt_thread());
        update_weather(&self.qt_thread(), &self.shared());
        let (qt, shared) = (self.qt_thread(), self.shared());
        // The task pages as you left them.
        if let Ok(mut state) = shared.work.lock() {
            *state = work::WorkState::load();
        }
        show(&qt, &shared);
        pim::show_pim(&qt, &shared);
        work::show_work(&qt, &shared);
        start_watchers(&qt, &shared);
        // Taking pictures of your own pages syncs nothing; the test build does, for its scripted runs.
        if std::env::var_os("SIOUL_GRAB").is_none() || cfg!(feature = "insecure-test-tls") {
            pim::start_dav_watchers(&qt, &shared);
            crate::github::start(&qt, &shared);
        }
        // Sioul's own antivirus signatures, when the system has none: kept current once a day.
        if !offline() {
            std::thread::spawn(|| {
                let _ = antivirus::refresh_signatures();
            });
        }
        // Attachments opened in an earlier session (decrypted ones too) leave the cache.
        forget_opened_attachments();
        // Mail fetched before Sioul checked senders itself is checked once,
        // quietly; the checks ask DNS, so not in a demo.
        if offline() {
            return;
        }
        let (qt, shared) = (qt.clone(), Arc::clone(&shared));
        std::thread::spawn(move || {
            let checked: usize = load_config().mail_sources().iter().map(|s| sioul_sync::verify::verify_folder(&s.folder, false)).sum();
            if checked > 0 {
                show(&qt, &shared);
            }
        });
    }

    fn refresh(self: Pin<&mut Self>) {
        show(&self.qt_thread(), &self.shared());
    }

    /// Everything again: what is on this computer (notes, tasks, the plan,
    /// the weather) read at once; mail, agenda, tasks, contacts and GitHub fetched.
    fn sync_now(mut self: Pin<&mut Self>) {
        let (qt, shared) = (self.qt_thread(), self.shared());
        crate::share::exchange(&qt, &shared);
        show(&qt, &shared);
        pim::show_pim(&qt, &shared);
        work::show_work(&qt, &shared);
        update_weather(&qt, &shared);
        let calendars = pim::start_dav_watchers(&qt, &shared);
        crate::github::start(&qt, &shared);
        if start_watchers(&qt, &shared) == 0 && calendars == 0 {
            self.as_mut().set_status(QString::from(&tr().text("sync-nothing", None)));
            return;
        }
        self.as_mut().set_busy(true);
        self.as_mut().set_status(QString::from(&tr().text("ui-refreshing", None)));
    }

    fn open_anyway(self: Pin<&mut Self>) {
        let shared = self.shared();
        shared.opened_anyway.store(true, Ordering::Relaxed);
        show(&self.qt_thread(), &shared);
    }

    fn done(mut self: Pin<&mut Self>) {
        let shared = self.shared();
        let newest = shared.shown.lock().map(|s| s.clone()).unwrap_or_default();
        let path = PorchState::default_path();
        let mut state = PorchState::load(&path);
        state.close(&newest);
        let line = match state.save(&path) {
            Ok(()) => tr().text(if newest.is_empty() { "done-nothing" } else { "done-closed" }, None),
            Err(e) => e,
        };
        shared.opened_anyway.store(false, Ordering::Relaxed);
        self.as_mut().set_status(QString::from(&line));
        show(&self.qt_thread(), &shared);
    }

    fn read_message(self: Pin<&mut Self>, key: &QString) {
        let (qt, key) = (self.qt_thread(), key.to_string());
        std::thread::spawn(move || {
            // A message that makes the reading fail is one that cannot be read: the pane says so, never waits.
            let reading = std::panic::catch_unwind(|| message_json(&key)).unwrap_or_default();
            let invitation = std::panic::catch_unwind(|| pim::invitation(&key)).unwrap_or_default();
            let _ = qt.queue(move |mut sioul| sioul.as_mut().message_read(QString::from(&key), QString::from(&reading), QString::from(&invitation)));
        });
    }

    fn open_attachment(mut self: Pin<&mut Self>, key: &QString, index: i32) {
        if !crate::attachments::phone() {
            self.as_mut().set_status(QString::from(&tr().text("scan-running-any", None)));
        }
        checked_attachment(&self.qt_thread(), &self.shared(), key.to_string(), index, Afterwards::Open, false);
    }

    fn save_attachment(mut self: Pin<&mut Self>, key: &QString, index: i32) {
        if !crate::attachments::phone() {
            self.as_mut().set_status(QString::from(&tr().text("scan-running-any", None)));
        }
        checked_attachment(&self.qt_thread(), &self.shared(), key.to_string(), index, Afterwards::Save, false);
    }

    fn attachments_unscanned(&self) -> bool {
        crate::attachments::phone()
    }

    fn attachment_unchecked(self: Pin<&mut Self>, key: &QString, index: i32, what: i32) {
        checked_attachment(&self.qt_thread(), &self.shared(), key.to_string(), index, Afterwards::of(what), true);
    }

    fn keep_attachment_as_paper(mut self: Pin<&mut Self>, key: &QString, index: i32) {
        if !crate::attachments::phone() {
            self.as_mut().set_status(QString::from(&tr().text("scan-running-any", None)));
        }
        checked_attachment(&self.qt_thread(), &self.shared(), key.to_string(), index, Afterwards::Paper, false);
    }

    fn papers(&self) -> QString {
        QString::from(&crate::papers::view())
    }

    fn save_paper(self: Pin<&mut Self>, id: &QString, edit: &QString) -> QString {
        QString::from(&crate::papers::save(&id.to_string(), &edit.to_string()))
    }

    fn remove_paper(self: Pin<&mut Self>, id: &QString) -> QString {
        QString::from(&crate::papers::remove(&id.to_string()))
    }

    fn plan_renewal(self: Pin<&mut Self>, id: &QString) -> QString {
        QString::from(&crate::papers::plan_renewal(&self.qt_thread(), &self.shared(), &id.to_string()))
    }

    fn let_in(mut self: Pin<&mut Self>, address: &QString) {
        let address = address.to_string();
        let line = match KnownSenders::let_in(&load_config().known_senders_path(), &address) {
            Ok(()) => say("ui-let-in-done", &[("address", address)]),
            Err(e) => e,
        };
        self.as_mut().set_status(QString::from(&line));
        show(&self.qt_thread(), &self.shared());
    }

    fn block(self: Pin<&mut Self>, entry: &QString) {
        self.set_standing(entry, &QString::from("blocked"));
    }

    fn block_from(self: Pin<&mut Self>, entry: &QString, key: &QString) {
        crate::mail::label_blocked(&key.to_string());
        self.block(entry);
    }

    fn unblock(mut self: Pin<&mut Self>, entry: &QString) {
        let line = crate::senders::unblock(&entry.to_string());
        self.as_mut().set_status(QString::from(&line));
        let (qt, shared) = (self.qt_thread(), self.shared());
        show(&qt, &shared);
        pim::show_pim(&qt, &shared);
    }

    fn set_standing(self: Pin<&mut Self>, entry: &QString, standing: &QString) {
        let entry = entry.to_string().trim().to_ascii_lowercase();
        // One address or pattern: never read as a list.
        self.set_standing_of(&QString::from(&serde_json::json!([entry]).to_string()), standing);
    }

    fn standing(&self, address: &QString) -> QString {
        QString::from(porch::Senders::load(&load_config()).who(&address.to_string()).id())
    }

    fn standing_of(&self, addresses: &QString) -> QString {
        QString::from(&crate::senders::standing_json(&addresses.to_string()))
    }

    fn set_standing_of(mut self: Pin<&mut Self>, addresses: &QString, standing: &QString) {
        let line = crate::senders::set_standing_of(&addresses.to_string(), &standing.to_string());
        if line.is_empty() {
            return;
        }
        self.as_mut().set_status(QString::from(&line));
        let (qt, shared) = (self.qt_thread(), self.shared());
        show(&qt, &shared);
        pim::show_pim(&qt, &shared);
    }

    fn person_of(&self, key: &QString) -> QString {
        QString::from(&crate::senders::person_json(&key.to_string()))
    }

    fn set_person(mut self: Pin<&mut Self>, key: &QString, standing: &QString) {
        let line = crate::senders::set_person(&key.to_string(), &standing.to_string());
        if line.is_empty() {
            return;
        }
        self.as_mut().set_status(QString::from(&line));
        let (qt, shared) = (self.qt_thread(), self.shared());
        show(&qt, &shared);
        pim::show_pim(&qt, &shared);
    }

    fn add_mail_line(mut self: Pin<&mut Self>, key: &QString, budget: &QString) {
        let (key, budget) = (key.to_string(), budget.to_string());
        let world = World::load();
        let outcome = (|| {
            let ledger = world.ledger().ok_or_else(|| tr().text("ui-no-budgets", None))?;
            let path = world.ledger_path().ok_or_else(|| tr().text("ui-no-budgets", None))?;
            let mail = world.mail_lines(&ledger);
            let found = mail.iter().find(|l| l.key == key).ok_or_else(|| tr().text("note-no-amount", None))?;
            let line = found.line(&budget).ok_or_else(|| tr().text("note-no-amount", None))?;
            let origin = say("budget-origin-mail", &[("subject", found.subject.clone()), ("sender", found.sender.clone()), ("date", Zoned::now().date().to_string())]);
            budget::record_line(&path, &line, &origin)?;
            Ok::<String, String>(say("ui-line-added", &[("budget", ledger.budget_title(&budget).to_string())]))
        })();
        let line = outcome.unwrap_or_else(|e| e);
        self.as_mut().set_status(QString::from(&line));
        show(&self.qt_thread(), &self.shared());
    }

    fn ignore_mail_line(mut self: Pin<&mut Self>, key: &QString) {
        let path = MoneyState::default_path();
        let mut state = MoneyState::load(&path);
        state.ignored.insert(key.to_string());
        let line = match state.save(&path) {
            Ok(()) => tr().text("ui-line-ignored", None),
            Err(e) => e,
        };
        self.as_mut().set_status(QString::from(&line));
        show(&self.qt_thread(), &self.shared());
    }

    fn discover(mut self: Pin<&mut Self>, address: &QString) {
        let address = address.to_string().trim().to_ascii_lowercase();
        let qt = self.qt_thread();
        self.as_mut().set_form_busy(true);
        self.as_mut().set_form_error(QString::default());
        self.as_mut().set_found(QString::default());
        std::thread::spawn(move || {
            let result = sioul_sync::discover(&address).map(|found| {
                let server = say(
                    "account-server",
                    &[
                        ("host", found.host.clone()),
                        ("port", found.port.to_string()),
                        ("security", tr().text(&format!("security-{}", found.security.as_str()), None)),
                    ],
                );
                // Gmail, or a domain whose mail Google keeps (its MX), or settings naming Google's server.
                let google = found.by == sioul_sync::FoundBy::Google || found.host.eq_ignore_ascii_case(sioul_sync::discover::GOOGLE_IMAP);
                json(&FoundView {
                    by: say("account-found", &[("server", server), ("by", tr().text(found.by.message_id(), None))]),
                    hint: tr().text(if google { "account-gmail-hint" } else { "account-app-password-hint" }, None),
                    help_url: google.then_some(sioul_sync::GMAIL_APP_PASSWORDS),
                    google,
                    google_key: google && gmail::has_own_key(&address),
                    host: found.host,
                    port: found.port,
                    security: found.security.as_str(),
                    login: found.username,
                })
            });
            let _ = qt.queue(move |mut sioul| {
                sioul.as_mut().set_form_busy(false);
                match result {
                    Ok(found) => sioul.as_mut().set_found(QString::from(&found)),
                    Err(e) => sioul.as_mut().set_form_error(QString::from(&e.sentence(tr(), &address))),
                }
            });
        });
    }

    fn add_account(mut self: Pin<&mut Self>, address: &QString, host: &QString, port: i32, security: &QString, login: &QString, password: &QString) {
        let (address, host, login, password) = (address.to_string().trim().to_ascii_lowercase(), host.to_string().trim().to_string(), login.to_string().trim().to_string(), password.to_string());
        let security = if security.to_string() == "starttls" { Security::Starttls } else { Security::Tls };
        let port = u16::try_from(port).ok().filter(|p| *p > 0).unwrap_or(if security == Security::Tls { 993 } else { 143 });
        self.as_mut().set_form_busy(true);
        self.as_mut().set_form_error(QString::default());
        add_mail(&self.qt_thread(), &self.shared(), address, host, port, security, login, Some(password));
    }

    fn add_mail_like(mut self: Pin<&mut Self>, address: &QString, host: &QString, port: i32, security: &QString, login: &QString) {
        let (address, host, login) = (address.to_string().trim().to_ascii_lowercase(), host.to_string().trim().to_string(), login.to_string().trim().to_string());
        let security = if security.to_string() == "starttls" { Security::Starttls } else { Security::Tls };
        let port = u16::try_from(port).ok().filter(|p| *p > 0).unwrap_or(if security == Security::Tls { 993 } else { 143 });
        self.as_mut().set_form_busy(true);
        self.as_mut().set_form_error(QString::default());
        add_mail(&self.qt_thread(), &self.shared(), address, host, port, security, login, None);
    }

    fn set_account_enabled(mut self: Pin<&mut Self>, id: &QString, on: bool) -> QString {
        let id = id.to_string();
        let config = load_config();
        let Some(account) = config.every_account().find(|a| a.id == id).cloned() else { return QString::from(&say("account-unknown", &[("id", id)])) };
        if let Err(e) = config::set_enabled(&config_path(), &id, on) {
            return QString::from(&e);
        }
        let (qt, shared) = (self.qt_thread(), self.shared());
        if account.kind == config::AccountKind::Dav {
            // Its calendars and address books leave the pages while it is off.
            sioul_core::vdir::set_account_off(&id, !on);
            if on {
                pim::start_dav_watchers(&qt, &shared);
            } else {
                pim::stop_dav_watcher(&shared, &id);
            }
        } else if on {
            start_watchers(&qt, &shared);
        } else if let Some(control) = shared.watchers.lock().ok().and_then(|mut w| w.remove(&id)) {
            control.stop();
        }
        self.as_mut().set_status(QString::from(&say(if on { "account-on" } else { "account-off" }, &[("id", id)])));
        show(&qt, &shared);
        pim::show_pim(&qt, &shared);
        mail::show_mail(&qt, &shared);
        // Its task lists and calendars come or go: the plan follows.
        work::show_work(&qt, &shared);
        QString::default()
    }

    fn scout_account(mut self: Pin<&mut Self>, address: &QString) {
        let address = address.to_string().trim().to_ascii_lowercase();
        let qt = self.qt_thread();
        self.as_mut().set_scouting(true);
        self.as_mut().set_scouted(QString::default());
        std::thread::spawn(move || {
            let config = load_config();
            let mine = |kind: config::AccountKind| config.every_account().find(|a| a.address.as_deref().map(str::to_lowercase).as_deref() == Some(address.as_str()) && a.kind == kind).cloned();
            let (mail_have, dav_have) = (mine(config::AccountKind::Imap), mine(config::AccountKind::Dav));
            // A Nextcloud's apps are asked with the password its calendars use.
            let password = dav_have.as_ref().and_then(|a| secret::password(a).ok());
            let login = dav_have.as_ref().and_then(|a| a.login().map(str::to_string)).unwrap_or_else(|| address.clone());
            let found = sioul_sync::scout::scout(&address, dav_have.as_ref().and_then(|a| a.host.as_deref()), password.as_deref().map(|p| (login.as_str(), p)));
            let mail = found.mail.as_ref().map(|m| {
                let server = say("account-server", &[("host", m.host.clone()), ("port", m.port.to_string()), ("security", tr().text(&format!("security-{}", m.security.as_str()), None))]);
                serde_json::json!({ "host": m.host, "port": m.port, "security": m.security.as_str(), "login": m.username, "line": server, "have": mail_have.as_ref().map(|a| a.id.clone()) })
            });
            let dav = found.dav.as_ref().map(|url| serde_json::json!({ "url": url, "have": dav_have.as_ref().map(|a| a.id.clone()) }));
            let nextcloud = found.nextcloud.as_ref().map(|n| {
                let apps: Vec<serde_json::Value> = n
                    .apps
                    .iter()
                    .filter_map(|a| sioul_sync::scout::known_app(a))
                    .map(|(id, in_sioul)| serde_json::json!({ "id": id, "title": tr().text(&format!("scout-app-{id}"), None), "in_sioul": in_sioul }))
                    .collect();
                serde_json::json!({ "product": n.product, "version": n.version, "server": n.server, "apps": apps, "asked": password.is_some() })
            });
            let answer = serde_json::json!({ "address": address, "mail": mail, "dav": dav, "nextcloud": nextcloud, "dav_password": password.is_some() }).to_string();
            let _ = qt.queue(move |mut sioul| {
                sioul.as_mut().set_scouting(false);
                sioul.as_mut().set_scouted(QString::from(&answer));
            });
        });
    }

    fn add_portal(mut self: Pin<&mut Self>, name: &QString, url: &QString) {
        let (id, url) = (config::slug(&name.to_string()), url.to_string().trim().to_string());
        let config = load_config();
        let outcome = if config.site(&id).is_some() {
            Err(say("account-exists", &[("id", id.clone())]))
        } else if id.is_empty() || !url.starts_with("https://") {
            // A site now, and a site's sign-in never travels in clear.
            Err(tr().text("site-https-only", None))
        } else {
            config::add_site(&config_path(), &id, &name.to_string(), &url).map(|()| say("account-portal-added", &[("id", id.clone()), ("url", url.clone())]))
        };
        match outcome {
            Ok(line) => self.as_mut().set_status(QString::from(&line)),
            Err(e) => self.as_mut().set_form_error(QString::from(&e)),
        }
        show(&self.qt_thread(), &self.shared());
    }

    fn set_account_password(mut self: Pin<&mut Self>, id: &QString, password: &QString) {
        self.as_mut().set_form_busy(true);
        give_password(&self.qt_thread(), &self.shared(), id.to_string(), password.to_string());
    }

    fn remove_account(mut self: Pin<&mut Self>, id: &QString) {
        let id = id.to_string();
        let shared = self.shared();
        if let Some(control) = shared.watchers.lock().ok().and_then(|mut w| w.remove(&id)) {
            control.stop();
        }
        if let Ok(mut statuses) = shared.statuses.lock() {
            statuses.remove(&id);
        }
        let config = load_config();
        // Switched off, an account can be removed all the same.
        let line = match config.every_account().find(|a| a.id == id) {
            None => say("account-unknown", &[("id", id.clone())]),
            Some(account) => {
                if account.is_dav() {
                    pim::stop_dav_watcher(&shared, &id);
                }
                // The keyring keeps one password per login and server: another
                // account on the same (a cPanel host's mail and calendars) keeps it.
                let shared_password = config.every_account().any(|a| a.id != id && a.host == account.host && a.login() == account.login());
                let forgotten = if account.auth.as_deref() == Some("google") {
                    // Google's access goes back to it: the calendars' or the mail's, each its own.
                    let purpose = if account.is_dav() { sioul_sync::google::Purpose::Pim } else { sioul_sync::google::Purpose::Mail };
                    sioul_sync::google::revoke_for(purpose, account.address.as_deref().unwrap_or("")).map_err(|e| e.sentence(tr(), &id))
                } else if (account.syncs() || account.is_dav()) && !shared_password {
                    secret::forget(account).map_err(|e| e.sentence(tr(), &id))
                } else {
                    Ok(())
                };
                match forgotten.and_then(|()| config::remove_account(&config_path(), &id)) {
                    Ok(()) => say("account-removed", &[("id", id.clone()), ("path", account.maildir_path().display().to_string())]),
                    Err(e) => e,
                }
            }
        };
        self.as_mut().set_status(QString::from(&line));
        show(&self.qt_thread(), &shared);
        // Its calendars and task lists gone: the agenda and the plan follow.
        pim::show_pim(&self.qt_thread(), &shared);
        work::show_work(&self.qt_thread(), &shared);
    }

    fn set_priority(mut self: Pin<&mut Self>, id: &QString, priority: &QString) {
        let id = id.to_string();
        let line = match Priority::parse(&priority.to_string()) {
            Some(priority) => match config::set_priority(&config_path(), &id, priority) {
                Ok(()) => say("ui-priority-set", &[("id", id), ("priority", tr().text(&format!("priority-{}", priority.as_str()), None))]),
                Err(e) => e,
            },
            None => return,
        };
        self.as_mut().set_status(QString::from(&line));
        show(&self.qt_thread(), &self.shared());
    }

    fn open_folder(self: Pin<&mut Self>, account: &QString, folder: &QString, all: bool, query: &QString) {
        let shared = self.shared();
        if let Ok(mut open) = shared.open_folder.lock() {
            *open = Some(mail::OpenFolder { account: account.to_string(), folder: folder.to_string(), all, query: query.to_string() });
        }
        mail::show_mail(&self.qt_thread(), &shared);
    }

    fn opened(self: Pin<&mut Self>, key: &QString) {
        mail::opened(&self.qt_thread(), &self.shared(), &key.to_string());
    }

    fn act(self: Pin<&mut Self>, key: &QString, action: &QString, target: &QString) {
        mail::act(&self.qt_thread(), &self.shared(), &key.to_string(), &action.to_string(), &target.to_string());
    }

    fn act_many(self: Pin<&mut Self>, keys: &QString, action: &QString) {
        let keys: Vec<String> = serde_json::from_str(&keys.to_string()).unwrap_or_default();
        mail::act_many(&self.qt_thread(), &self.shared(), &keys, &action.to_string());
    }

    fn move_messages(self: Pin<&mut Self>, keys: &QString, account: &QString, folder: &QString) {
        let keys: Vec<String> = serde_json::from_str(&keys.to_string()).unwrap_or_default();
        mail::move_many(&self.qt_thread(), &self.shared(), &keys, &account.to_string(), &folder.to_string());
    }

    fn unsubscribe(self: Pin<&mut Self>, key: &QString) -> QString {
        let world = World::load();
        let triaged = world.judge(&key.to_string()).map(|(_, triaged)| triaged);
        QString::from(&mail::unsubscribe(&self.qt_thread(), &self.shared(), &world.config, triaged))
    }

    fn undo(mut self: Pin<&mut Self>) {
        if let Some(draft) = mail::undo(&self.qt_thread(), &self.shared()) {
            self.as_mut().compose_requested(QString::from(&draft));
        }
    }

    fn flush(self: Pin<&mut Self>) {
        mail::flush(&self.shared());
        end_work_now();
        securitykey::closing();
    }

    fn compose(mut self: Pin<&mut Self>, kind: &QString, key: &QString, account: &QString) -> QString {
        match mail::compose(&kind.to_string(), &key.to_string(), &account.to_string()) {
            Ok(id) => {
                mail::show_mail(&self.qt_thread(), &self.shared());
                QString::from(&id)
            }
            Err(e) => {
                self.as_mut().set_status(QString::from(&e));
                QString::default()
            }
        }
    }

    fn draft(&self, id: &QString) -> QString {
        QString::from(&mail::draft(&id.to_string()).unwrap_or_default())
    }

    fn save_draft(self: Pin<&mut Self>, edit: &QString) -> QString {
        let line = mail::save_draft(&edit.to_string()).unwrap_or_else(|e| e);
        mail::show_mail(&self.qt_thread(), &self.shared());
        QString::from(&line)
    }

    fn attach(self: Pin<&mut Self>, id: &QString, url: &QString) -> QString {
        QString::from(&mail::attach(&id.to_string(), &url.to_string()).err().unwrap_or_default())
    }

    fn detach(mut self: Pin<&mut Self>, id: &QString, index: i32, forwarded: bool) {
        if let Err(e) = mail::detach(&id.to_string(), usize::try_from(index).unwrap_or(usize::MAX), forwarded) {
            self.as_mut().set_status(QString::from(&e));
        }
    }

    fn preview(&self, markdown: &QString) -> QString {
        QString::from(&sioul_core::compose::markdown_html(&markdown.to_string()))
    }

    fn send(self: Pin<&mut Self>, id: &QString) -> QString {
        QString::from(&mail::send(&self.qt_thread(), &self.shared(), &id.to_string()).unwrap_or_default())
    }

    fn discard(self: Pin<&mut Self>, id: &QString) {
        mail::discard(&self.qt_thread(), &self.shared(), &id.to_string());
    }

    fn draft_closed(self: Pin<&mut Self>, id: &QString) {
        mail::closed(&self.qt_thread(), &self.shared(), &id.to_string());
    }

    fn place(&self, key: &QString) -> QString {
        QString::from(&mail::place(&key.to_string()))
    }

    fn source(&self, key: &QString) -> QString {
        QString::from(&mail::source(&key.to_string()))
    }

    fn set_writing(mut self: Pin<&mut Self>, id: &QString, name: &QString, signature: &QString) {
        let id = id.to_string();
        let line = match config::set_writing(&config_path(), &id, &name.to_string(), &signature.to_string()) {
            Ok(()) => say("ui-writing-saved", &[("id", id)]),
            Err(e) => e,
        };
        self.as_mut().set_status(QString::from(&line));
        show(&self.qt_thread(), &self.shared());
    }

    fn grab_folder(&self) -> QString {
        QString::from(&std::env::var("SIOUL_GRAB").unwrap_or_default())
    }

    fn search_contacts(self: Pin<&mut Self>, query: &QString) {
        let shared = self.shared();
        if let Ok(mut state) = shared.pim.lock() {
            state.query = query.to_string();
        }
        pim::show_pim(&self.qt_thread(), &shared);
    }

    fn contact(&self, key: &QString) -> QString {
        QString::from(&pim::contact(&key.to_string()))
    }

    fn save_contact(self: Pin<&mut Self>, key: &QString, edit: &QString) -> QString {
        let answer = match pim::save_contact(&self.qt_thread(), &self.shared(), &key.to_string(), &edit.to_string()) {
            Ok(key) => serde_json::json!({ "key": key }),
            Err(error) => serde_json::json!({ "error": error }),
        };
        QString::from(&answer.to_string())
    }

    fn delete_contact(self: Pin<&mut Self>, key: &QString) {
        pim::delete_contact(&self.qt_thread(), &self.shared(), &key.to_string());
    }

    fn show_contacts_category(self: Pin<&mut Self>, category: &QString) {
        let shared = self.shared();
        if let Ok(mut state) = shared.pim.lock() {
            state.category = category.to_string();
        }
        pim::show_pim(&self.qt_thread(), &shared);
    }

    fn find_duplicates(self: Pin<&mut Self>) {
        crate::duplicates::find(&self.qt_thread(), &self.shared());
    }

    fn clean_contacts(self: Pin<&mut Self>, keys: &QString) -> QString {
        QString::from(&crate::duplicates::clean(&self.qt_thread(), &self.shared(), &keys.to_string()))
    }

    fn merge_contacts(self: Pin<&mut Self>, lead: &QString, other: &QString) -> QString {
        QString::from(&crate::duplicates::merge(&self.qt_thread(), &self.shared(), &lead.to_string(), &other.to_string()))
    }

    fn not_same_contacts(self: Pin<&mut Self>, first: &QString, second: &QString) -> QString {
        QString::from(&crate::duplicates::not_same(&self.qt_thread(), &self.shared(), &first.to_string(), &second.to_string()))
    }

    fn undo_contacts(self: Pin<&mut Self>, id: &QString) -> QString {
        QString::from(&crate::duplicates::undo(&self.qt_thread(), &self.shared(), &id.to_string()))
    }

    fn show_days(self: Pin<&mut Self>, from: &QString, days: i32, upcoming: bool) {
        let shared = self.shared();
        if let Ok(mut state) = shared.pim.lock() {
            state.from = from.to_string().parse().unwrap_or_else(|_| Zoned::now().date());
            state.days = i64::from(days.clamp(1, 366));
            state.upcoming = upcoming;
        }
        pim::show_pim(&self.qt_thread(), &shared);
    }

    fn calendars(&self) -> QString {
        QString::from(&pim::calendars())
    }

    fn event_form(&self, key: &QString) -> QString {
        QString::from(&pim::event(&key.to_string()))
    }

    fn save_event(self: Pin<&mut Self>, key: &QString, edit: &QString, calendar: &QString) -> QString {
        let result = pim::save_event(&self.qt_thread(), &self.shared(), &key.to_string(), &edit.to_string(), &calendar.to_string());
        QString::from(&result.err().unwrap_or_default())
    }

    fn event_reminder(&self, key: &QString, start: f64) -> QString {
        QString::from(&crate::remind::of_event(&key.to_string(), start as i64))
    }

    fn reminder_choices(&self, current: &QString) -> QString {
        QString::from(&crate::remind::choices(&current.to_string()))
    }

    fn set_event_reminder(self: Pin<&mut Self>, key: &QString, value: &QString) -> QString {
        let result = crate::remind::set_event(&self.qt_thread(), &self.shared(), &key.to_string(), &value.to_string());
        QString::from(&result.err().unwrap_or_default())
    }

    fn move_event(self: Pin<&mut Self>, key: &QString, start: f64, new_start: f64, new_end: f64, only_this: bool) -> QString {
        QString::from(&pim::move_event(&self.qt_thread(), &self.shared(), &key.to_string(), start as i64, new_start as i64, new_end as i64, only_this))
    }

    fn delete_event(self: Pin<&mut Self>, key: &QString, start: f64, only_this: bool) {
        pim::delete_event(&self.qt_thread(), &self.shared(), &key.to_string(), start as i64, only_this);
    }

    fn completions(&self, typed: &QString) -> QString {
        QString::from(&pim::completions(&typed.to_string()))
    }

    fn contact_for(&self, address: &QString) -> QString {
        QString::from(&pim::contact_for(&address.to_string()))
    }

    fn add_sender(mut self: Pin<&mut Self>, name: &QString, address: &QString) {
        if let Err(e) = pim::add_sender(&self.qt_thread(), &self.shared(), &name.to_string(), &address.to_string()) {
            self.as_mut().set_status(QString::from(&e));
        }
    }

    fn answer_invitation(mut self: Pin<&mut Self>, key: &QString, answer: &QString) {
        // Sending waits on the network: on a thread.
        let (qt, shared, key, answer) = (self.qt_thread(), self.shared(), key.to_string(), answer.to_string());
        self.as_mut().set_status(QString::from(&tr().text("invitation-answering", None)));
        std::thread::spawn(move || {
            if let Err(e) = pim::answer(&qt, &shared, &key, &answer) {
                tell(&qt, &shared, e);
            }
        });
    }

    fn history_weeks(&self) -> i32 {
        i32::try_from(load_config().history_weeks.unwrap_or(config::DEFAULT_HISTORY_WEEKS)).unwrap_or(2)
    }

    fn day_start(&self) -> i32 {
        i32::try_from(load_config().agenda.day_start.unwrap_or(7).min(23)).unwrap_or(7)
    }

    fn set_history(mut self: Pin<&mut Self>, weeks: i32) {
        let weeks = u32::try_from(weeks.max(0)).unwrap_or(0);
        let line = match config::set_history(&config_path(), weeks) {
            Ok(()) if weeks == 0 => tr().text("ui-history-everything", None),
            Ok(()) => say("ui-history-set", &[("weeks", weeks.to_string())]),
            Err(e) => e,
        };
        self.as_mut().set_status(QString::from(&line));
        // The watchers fetch now: the older mail comes with this round.
        let (qt, shared) = (self.qt_thread(), self.shared());
        start_watchers(&qt, &shared);
        show(&qt, &shared);
        pim::show_pim(&qt, &shared);
    }

    fn add_dav(mut self: Pin<&mut Self>, address: &QString, url: &QString, login: &QString, password: &QString) {
        self.as_mut().set_form_busy(true);
        self.as_mut().set_form_error(QString::default());
        pim::add_account(&self.qt_thread(), &self.shared(), address.to_string(), url.to_string(), login.to_string(), password.to_string());
    }

    fn add_google(mut self: Pin<&mut Self>, address: &QString, client_id: &QString, client_secret: &QString, again: &QString) {
        self.as_mut().set_form_busy(true);
        self.as_mut().set_form_error(QString::default());
        let again = Some(again.to_string()).filter(|a| !a.is_empty());
        pim::add_google_account(&self.qt_thread(), &self.shared(), address.to_string(), client_id.to_string(), client_secret.to_string(), again);
    }

    fn cancel_google(self: Pin<&mut Self>) {
        self.shared().google_stop.store(true, Ordering::Relaxed);
    }

    fn add_google_mail(mut self: Pin<&mut Self>, address: &QString, client_id: &QString, client_secret: &QString, again: &QString) {
        self.as_mut().set_form_busy(true);
        self.as_mut().set_form_error(QString::default());
        let again = Some(again.to_string()).filter(|a| !a.is_empty());
        gmail::add_google_mail(&self.qt_thread(), &self.shared(), address.to_string(), client_id.to_string(), client_secret.to_string(), again);
    }

    fn pgp_keys(&self) -> QString {
        QString::from(&crypto::keys_view())
    }

    fn pgp_generate(mut self: Pin<&mut Self>, address: &QString) {
        // Making a key takes a moment (its passphrase is hashed with Argon2): on a thread.
        let (qt, shared, address) = (self.qt_thread(), self.shared(), address.to_string());
        self.as_mut().set_status(QString::from(&tr().text("pgp-making", None)));
        std::thread::spawn(move || {
            let line = crypto::generate(&address).unwrap_or_else(|e| e);
            tell(&qt, &shared, line);
            let _ = qt.queue(|mut sioul| sioul.as_mut().keys_changed());
        });
    }

    fn pgp_import(mut self: Pin<&mut Self>, url: &QString, passphrase: &QString) -> QString {
        match crypto::import(&url.to_string(), &passphrase.to_string()) {
            Ok(line) => {
                self.as_mut().set_status(QString::from(&line));
                self.as_mut().keys_changed();
                QString::default()
            }
            Err(e) => QString::from(&e),
        }
    }

    fn pgp_export(mut self: Pin<&mut Self>, fingerprint: &QString) {
        let line = match crypto::export(&fingerprint.to_string(), &downloads()) {
            Ok(path) => say("ui-saved", &[("path", path.display().to_string())]),
            Err(e) => e,
        };
        self.as_mut().set_status(QString::from(&line));
    }

    fn pgp_save_revocation(mut self: Pin<&mut Self>, fingerprint: &QString) {
        let line = match sioul_core::pgp::save_revocation(&fingerprint.to_string(), &downloads()) {
            Ok(path) => say("pgp-revocation-saved", &[("path", path.display().to_string())]),
            Err(e) => e,
        };
        self.as_mut().set_status(QString::from(&line));
    }

    fn pgp_remove(mut self: Pin<&mut Self>, fingerprint: &QString) {
        let line = match sioul_core::pgp::remove(&fingerprint.to_string()) {
            Ok(()) => tr().text("pgp-removed", None),
            Err(e) => e,
        };
        self.as_mut().set_status(QString::from(&line));
        self.as_mut().keys_changed();
    }

    fn pgp_lookup(mut self: Pin<&mut Self>, draft: &QString) {
        let (qt, shared, id) = (self.qt_thread(), self.shared(), draft.to_string());
        self.as_mut().set_status(QString::from(&tr().text("pgp-looking", None)));
        std::thread::spawn(move || {
            let Some(draft) = sioul_core::compose::Draft::by_id(&id) else { return };
            tell(&qt, &shared, crypto::lookup(&draft));
            let _ = qt.queue(|mut sioul| sioul.as_mut().keys_changed());
        });
    }

    fn security_key_for_draft(&self, id: &QString) -> QString {
        QString::from(&securitykey::for_draft(&id.to_string()))
    }

    fn sign_and_send(self: Pin<&mut Self>, id: &QString, pin: &QString) {
        securitykey::sign_and_send(&self.qt_thread(), &self.shared(), &id.to_string(), pin.to_string());
    }

    fn open_with_security_key(self: Pin<&mut Self>, key: &QString, pin: &QString) {
        securitykey::open_message(&self.qt_thread(), &self.shared(), &key.to_string(), pin.to_string());
    }

    fn security_key_not_now(self: Pin<&mut Self>, context: &QString) {
        securitykey::not_now(&context.to_string());
    }

    fn let_gnupg_release(self: Pin<&mut Self>) -> QString {
        QString::from(&securitykey::release())
    }

    fn security_keys(&self) -> QString {
        QString::from(&securitykey::known_view())
    }

    fn read_security_key(self: Pin<&mut Self>) {
        securitykey::read_for_setup(&self.qt_thread());
    }

    fn find_security_key_certificate(self: Pin<&mut Self>, ident: &QString) {
        securitykey::look_for_certificate(&self.qt_thread(), &ident.to_string());
    }

    fn import_security_key_certificate(self: Pin<&mut Self>, ident: &QString, url: &QString) {
        securitykey::import_certificate(&self.qt_thread(), &ident.to_string(), &url.to_string());
    }

    fn import_security_key_from_gnupg(self: Pin<&mut Self>, ident: &QString) {
        securitykey::import_from_gnupg(&self.qt_thread(), &ident.to_string());
    }

    fn renew_security_key(self: Pin<&mut Self>, ident: &QString) {
        securitykey::renew(&self.qt_thread(), &ident.to_string());
    }

    fn send_security_key_to_keys_openpgp(self: Pin<&mut Self>, ident: &QString) {
        securitykey::send_to_keys_openpgp(&self.qt_thread(), &ident.to_string());
    }

    fn forget_security_key_pin(mut self: Pin<&mut Self>) {
        let line = securitykey::forget_pin();
        self.as_mut().set_status(QString::from(&line));
        self.as_mut().keys_changed();
    }

    fn stop_using_security_key(self: Pin<&mut Self>, ident: &QString) {
        securitykey::stop_using(&self.qt_thread(), &self.shared(), &ident.to_string());
    }

    fn show_tasks(self: Pin<&mut Self>, by: &QString, done: bool, query: &QString, project_id: &QString) {
        work::set_view(&self.qt_thread(), &self.shared(), &by.to_string(), done, &query.to_string(), &project_id.to_string());
    }

    fn filter_tasks(self: Pin<&mut Self>, kind: &QString, category: &QString) {
        work::set_filter(&self.qt_thread(), &self.shared(), &kind.to_string(), &category.to_string());
    }

    fn refresh_work(self: Pin<&mut Self>) {
        work::show_work(&self.qt_thread(), &self.shared());
    }

    fn show_tasks_anyway(self: Pin<&mut Self>, on: bool) {
        work::show_anyway(&self.qt_thread(), &self.shared(), on);
    }

    fn task(&self, uid: &QString) -> QString {
        QString::from(&work::task(&self.shared(), &uid.to_string()))
    }

    fn new_task_form(&self, from: &QString, key: &QString, start: f64, list: &QString) -> QString {
        QString::from(&work::new_form(&self.shared(), &from.to_string(), &key.to_string(), start, &list.to_string()))
    }

    fn save_task(self: Pin<&mut Self>, uid: &QString, edit: &QString, list: &QString) -> QString {
        QString::from(&work::save(&self.qt_thread(), &self.shared(), &uid.to_string(), &edit.to_string(), &list.to_string()))
    }

    fn capture(&self, line: &QString) -> QString {
        QString::from(&work::captured(&self.shared(), &line.to_string()))
    }

    fn add_task(self: Pin<&mut Self>, line: &QString, parent: &QString, list: &QString) -> QString {
        QString::from(&work::add(&self.qt_thread(), &self.shared(), &line.to_string(), &parent.to_string(), &list.to_string()))
    }

    fn set_task_status(self: Pin<&mut Self>, uid: &QString, status: &QString) -> QString {
        QString::from(&work::set_status(&self.qt_thread(), &self.shared(), &uid.to_string(), &status.to_string()))
    }

    fn set_felt(self: Pin<&mut Self>, uid: &QString, felt: &QString) -> QString {
        QString::from(&work::set_felt(&self.qt_thread(), &self.shared(), &uid.to_string(), &felt.to_string()))
    }

    fn set_waits(self: Pin<&mut Self>, uid: &QString, other: &QString, wait: bool, gap_minutes: i32) -> QString {
        QString::from(&work::set_waits(&self.qt_thread(), &self.shared(), &uid.to_string(), &other.to_string(), wait, i64::from(gap_minutes)))
    }

    fn not_now(self: Pin<&mut Self>, uid: &QString) {
        work::not_now(&self.qt_thread(), &self.shared(), &uid.to_string());
    }

    fn set_weather(self: Pin<&mut Self>, weather: &QString) {
        work::set_weather(&self.qt_thread(), &self.shared(), &weather.to_string());
        // The morning's weather, kept with the day's reviews.
        crate::reviews::weather_said(sioul_core::today::Weather::parse(&weather.to_string()));
    }

    fn set_task_at(self: Pin<&mut Self>, uid: &QString, at: &QString) -> QString {
        QString::from(&work::set_at(&self.qt_thread(), &self.shared(), &uid.to_string(), &at.to_string(), 0))
    }

    fn pin_task(self: Pin<&mut Self>, uid: &QString, at: &QString, minutes: i32) -> QString {
        QString::from(&work::set_at(&self.qt_thread(), &self.shared(), &uid.to_string(), &at.to_string(), u32::try_from(minutes).unwrap_or(0)))
    }

    fn delete_task(self: Pin<&mut Self>, uid: &QString) {
        work::delete(&self.qt_thread(), &self.shared(), &uid.to_string());
    }

    fn search_tasks(&self, query: &QString, except: &QString) -> QString {
        QString::from(&work::search(&self.shared(), &query.to_string(), &except.to_string()))
    }

    fn new_list(self: Pin<&mut Self>, account: &QString, name: &QString) -> QString {
        QString::from(&work::new_list(&self.qt_thread(), &self.shared(), &account.to_string(), &name.to_string()))
    }

    fn list_accounts(&self) -> QString {
        QString::from(&work::list_accounts())
    }

    fn focus_start(self: Pin<&mut Self>, uid: &QString, minutes: i32) {
        work::focus_start(&self.qt_thread(), &self.shared(), &uid.to_string(), minutes);
    }

    fn focus_pause(self: Pin<&mut Self>) {
        work::focus_pause(&self.qt_thread(), &self.shared());
    }

    fn focus_extend(self: Pin<&mut Self>, minutes: i32) {
        work::focus_extend(&self.qt_thread(), &self.shared(), minutes);
    }

    fn focus_stop(self: Pin<&mut Self>, done: bool, note: &QString) -> QString {
        QString::from(&work::focus_stop(&self.qt_thread(), &self.shared(), done, &note.to_string()))
    }

    fn search_notes(self: Pin<&mut Self>, query: &QString) {
        work::search_notes(&self.qt_thread(), &self.shared(), &query.to_string());
    }

    fn note(&self, path: &QString) -> QString {
        QString::from(&work::note(&self.shared(), &path.to_string()))
    }

    fn save_note(self: Pin<&mut Self>, path: &QString, text: &QString, stamp: &QString) -> QString {
        QString::from(&work::save_note(&self.qt_thread(), &self.shared(), &path.to_string(), &text.to_string(), &stamp.to_string()))
    }

    fn create_note(self: Pin<&mut Self>, title: &QString, links: &QString) -> QString {
        QString::from(&work::create_note(&self.qt_thread(), &self.shared(), &title.to_string(), &links.to_string()))
    }

    fn related(&self, uri: &QString) -> QString {
        QString::from(&work::related(&self.shared(), &uri.to_string()))
    }

    fn link_things(mut self: Pin<&mut Self>, from: &QString, to: &QString) -> QString {
        let line = work::link(&self.qt_thread(), &self.shared(), &from.to_string(), &to.to_string());
        self.as_mut().set_status(QString::from(&line));
        QString::from(&line)
    }

    fn unlink_things(mut self: Pin<&mut Self>, from: &QString, to: &QString) -> QString {
        let line = work::unlink(&self.qt_thread(), &self.shared(), &from.to_string(), &to.to_string());
        self.as_mut().set_status(QString::from(&line));
        QString::from(&line)
    }

    fn search_things(&self, query: &QString, kind: &QString, from: &QString) -> QString {
        QString::from(&work::search_things(&self.shared(), &query.to_string(), &kind.to_string(), &from.to_string()))
    }

    fn uri_of(&self, kind: &QString, id: &QString) -> QString {
        QString::from(&work::uri_of(&kind.to_string(), &id.to_string()))
    }

    fn is_program(&self, name: &QString) -> bool {
        crate::attachments::kept_closed(&name.to_string(), crate::attachments::phone())
    }

    fn first_frame(&self) {
        crate::timing("the first frame drawn");
    }

    fn mark(&self, what: &QString) {
        crate::timing(&what.to_string());
    }

    fn phone_accounts(&self) -> bool {
        cfg!(target_os = "android")
    }

    fn choose_phone_account(self: Pin<&mut Self>) {
        #[cfg(target_os = "android")]
        {
            if let Ok(mut waiting) = PHONE_CHOOSER.lock() {
                *waiting = Some(self.qt_thread());
            }
            // SAFETY: android/main.cpp's, called on Qt's thread; it answers through
            // `sioul_android_account_chosen`, on whatever thread Android gives.
            unsafe { sioul_android_choose_account() };
        }
        #[cfg(not(target_os = "android"))]
        let _ = self;
    }

    fn budget_detail(&self, id: &QString, anchor: &QString, step: &QString) -> QString {
        let world = World::load();
        let today = Zoned::now().date();
        let Some(ledger) = world.ledger() else { return QString::default() };
        let Some(found) = ledger.budgets.iter().find(|b| b.id == id.to_string()) else { return QString::default() };
        let anchor = anchor.to_string().parse().unwrap_or(today);
        QString::from(&json(&view::budget_detail(&ledger, found, anchor, &step.to_string(), tr(), today)))
    }

    fn keep_folder(self: Pin<&mut Self>, account: &QString, folder: &QString, kept: bool) -> QString {
        let (id, folder) = (account.to_string(), folder.to_string());
        // The folder kept or set aside, over the list as the configuration holds it
        // now, read and written under its lock, which the sharing takes too.
        let path = config_path();
        let changed = sioul_core::filelock::with_lock(&path, || {
            let config = config::Config::load(&path)?;
            let Some(account) = config.account(&id).cloned() else { return Ok(None) };
            let mut skipped = account.skip_folders.clone();
            skipped.retain(|f| f != &folder);
            if !kept {
                skipped.push(folder.clone());
            }
            config::set_value(&path, &format!("account.{id}.skip_folders"), &config::SettingValue::Texts(skipped)).map(|()| Some(account))
        });
        let account = match changed {
            Ok(Some(account)) => account,
            Ok(None) => return QString::default(),
            Err(e) => return QString::from(&e),
        };
        let (qt, shared) = (self.qt_thread(), self.shared());
        std::thread::spawn(move || {
            if !kept && let Err(e) = sioul_sync::mailbox::forget_folder(&account, &folder) {
                set_status(&qt, e.sentence(tr(), &account.id));
            }
            if let Some(control) = shared.watchers.lock().ok().and_then(|w| w.get(&account.id).cloned()) {
                control.nudge();
            }
            mail::show_mail(&qt, &shared);
        });
        QString::default()
    }

    fn create_folder(self: Pin<&mut Self>, account: &QString, name: &QString) {
        let (id, name) = (account.to_string(), name.to_string());
        let (qt, shared) = (self.qt_thread(), self.shared());
        std::thread::spawn(move || {
            let Some(account) = load_config().account(&id).cloned() else { return };
            let made = sioul_sync::secret::password(&account).and_then(|p| sioul_sync::mailbox::create_folder(&account, &p, &name));
            match made {
                Ok(()) => tell(&qt, &shared, say("folder-made", &[("name", name.clone())])),
                Err(e) => tell(&qt, &shared, e.sentence(tr(), &account.id)),
            }
            mail::show_mail(&qt, &shared);
        });
    }

    fn delete_folder(self: Pin<&mut Self>, account: &QString, folder: &QString) {
        let (id, folder) = (account.to_string(), folder.to_string());
        let (qt, shared) = (self.qt_thread(), self.shared());
        std::thread::spawn(move || {
            let Some(account) = load_config().account(&id).cloned() else { return };
            let gone = sioul_sync::secret::password(&account).and_then(|p| sioul_sync::mailbox::delete_folder(&account, &p, &folder));
            match gone {
                Ok(()) => tell(&qt, &shared, say("folder-deleted", &[("name", folder.clone())])),
                Err(sioul_sync::SyncError::Message(m)) if m == sioul_sync::mailbox::NOT_EMPTY => tell(&qt, &shared, say("folder-not-empty", &[("name", folder.clone())])),
                Err(e) => tell(&qt, &shared, e.sentence(tr(), &account.id)),
            }
            mail::show_mail(&qt, &shared);
        });
    }

    fn trash_note(self: Pin<&mut Self>, path: &QString) -> QString {
        QString::from(&work::trash_note(&self.qt_thread(), &self.shared(), &path.to_string()))
    }

    fn rename_note(self: Pin<&mut Self>, path: &QString, name: &QString) -> QString {
        QString::from(&work::rename_note(&self.qt_thread(), &self.shared(), &path.to_string(), &name.to_string()))
    }

    fn create_note_in(self: Pin<&mut Self>, folder: &QString, title: &QString) -> QString {
        QString::from(&work::create_note_in(&self.qt_thread(), &self.shared(), &folder.to_string(), &title.to_string()))
    }

    fn make_folder(self: Pin<&mut Self>, parent: &QString, name: &QString) -> QString {
        QString::from(&work::make_folder(&self.qt_thread(), &self.shared(), &parent.to_string(), &name.to_string()))
    }

    fn rename_folder(self: Pin<&mut Self>, path: &QString, name: &QString) -> QString {
        QString::from(&work::rename_folder(&self.qt_thread(), &self.shared(), &path.to_string(), &name.to_string()))
    }

    fn remove_folder(self: Pin<&mut Self>, path: &QString) -> QString {
        QString::from(&work::remove_folder(&self.qt_thread(), &self.shared(), &path.to_string()))
    }

    fn remove_project(self: Pin<&mut Self>, id: &QString) -> QString {
        QString::from(&crate::projects::remove(&self.qt_thread(), &self.shared(), &id.to_string()))
    }

    fn save_budget(self: Pin<&mut Self>, id: &QString, edit: &QString) -> QString {
        QString::from(&crate::projects::save_budget(&self.qt_thread(), &self.shared(), &id.to_string(), &edit.to_string()))
    }

    fn letters(&self) -> QString {
        QString::from(&crate::letters::view())
    }

    fn letter_task(self: Pin<&mut Self>, id: &QString) -> QString {
        QString::from(&crate::letters::make_task(&self.qt_thread(), &self.shared(), &id.to_string()))
    }

    fn letter_event(self: Pin<&mut Self>, id: &QString) -> QString {
        QString::from(&crate::letters::make_event(&self.qt_thread(), &self.shared(), &id.to_string()))
    }

    fn letter_done(self: Pin<&mut Self>, id: &QString, project: &QString) -> QString {
        QString::from(&crate::letters::done(&id.to_string(), &project.to_string()))
    }

    fn bank(&self) -> QString {
        QString::from(&crate::bank::view())
    }

    fn import_bank(self: Pin<&mut Self>, file: &QString) -> QString {
        let (ok, said) = crate::bank::import(&file.to_string());
        // The budgets count the bank accounts' movements.
        show(&self.qt_thread(), &self.shared());
        QString::from(&serde_json::json!({ "ok": ok, "said": said }).to_string())
    }

    fn import_bank_into(self: Pin<&mut Self>, file: &QString, account: &QString) -> QString {
        let (ok, said) = crate::bank::import_into(&file.to_string(), &account.to_string());
        show(&self.qt_thread(), &self.shared());
        QString::from(&serde_json::json!({ "ok": ok, "said": said }).to_string())
    }

    fn save_bank_account(self: Pin<&mut Self>, id: &QString, edit: &QString) -> QString {
        let problem = crate::bank::save_account(&id.to_string(), &edit.to_string());
        show(&self.qt_thread(), &self.shared());
        QString::from(&problem)
    }

    fn remove_bank_account(self: Pin<&mut Self>, id: &QString) -> QString {
        let problem = crate::bank::remove_account(&id.to_string());
        show(&self.qt_thread(), &self.shared());
        QString::from(&problem)
    }

    fn place_movement(self: Pin<&mut Self>, account: &QString, movement: &QString, choice: &QString) -> QString {
        let problem = crate::bank::place_movement(&account.to_string(), &movement.to_string(), &choice.to_string());
        show(&self.qt_thread(), &self.shared());
        QString::from(&problem)
    }

    fn save_bank_rule(self: Pin<&mut Self>, rule: &QString, edit: &QString) -> QString {
        let problem = crate::bank::save_rule(&rule.to_string(), &edit.to_string());
        show(&self.qt_thread(), &self.shared());
        QString::from(&problem)
    }

    fn remove_bank_rule(self: Pin<&mut Self>, rule: &QString) -> QString {
        let problem = crate::bank::remove_rule(&rule.to_string());
        show(&self.qt_thread(), &self.shared());
        QString::from(&problem)
    }

    fn save_reserve(self: Pin<&mut Self>, id: &QString, edit: &QString) -> QString {
        let problem = crate::bank::save_reserve(&id.to_string(), &edit.to_string());
        show(&self.qt_thread(), &self.shared());
        QString::from(&problem)
    }

    fn contracts(&self) -> QString {
        QString::from(&crate::contracts::view())
    }

    fn save_contract(self: Pin<&mut Self>, id: &QString, edit: &QString) -> QString {
        QString::from(&crate::contracts::save(&id.to_string(), &edit.to_string()))
    }

    fn remove_contract(self: Pin<&mut Self>, id: &QString) -> QString {
        QString::from(&crate::contracts::remove(&id.to_string()))
    }

    fn contract_letter(self: Pin<&mut Self>, id: &QString) -> QString {
        QString::from(&crate::contracts::letter(&id.to_string()))
    }

    fn contract_from(&self, subject: &QString, from: &QString) -> QString {
        QString::from(&crate::contracts::from_card(&subject.to_string(), &from.to_string()))
    }

    fn routines(&self) -> QString {
        QString::from(&work::routines(&self.shared()))
    }

    fn save_routine(self: Pin<&mut Self>, id: &QString, title: &QString, steps: &QString, by_itself: bool) -> QString {
        QString::from(&work::save_routine(&id.to_string(), &title.to_string(), &steps.to_string(), by_itself))
    }

    fn remove_routine(self: Pin<&mut Self>, id: &QString) -> QString {
        QString::from(&work::remove_routine(&id.to_string()))
    }

    fn share_status(&self, folder: &QString) -> QString {
        QString::from(&crate::share::status(&folder.to_string()))
    }

    fn start_sharing(self: Pin<&mut Self>, folder: &QString, passphrase: &QString, again: &QString) -> QString {
        let problem = crate::share::start(&folder.to_string(), &passphrase.to_string(), &again.to_string());
        if problem.is_empty() {
            crate::share::exchange(&self.qt_thread(), &self.shared());
        }
        QString::from(&problem)
    }

    fn stop_sharing(self: Pin<&mut Self>) -> QString {
        QString::from(&crate::share::stop())
    }

    fn share_candidates(&self) -> QString {
        QString::from(&json(&crate::share::candidates()))
    }

    fn set_share_projects(self: Pin<&mut Self>, on: bool) -> QString {
        let problem = crate::share::set_projects(on);
        if problem.is_empty() {
            crate::share::exchange(&self.qt_thread(), &self.shared());
        }
        QString::from(&problem)
    }

    fn folders_in(&self, path: &QString) -> QString {
        QString::from(&crate::share::folders_in(&path.to_string()))
    }

    fn files_access(&self) -> bool {
        #[cfg(target_os = "android")]
        {
            // SAFETY: android/main.cpp's, asking Android through Java.
            unsafe { sioul_android_files_access() }
        }
        #[cfg(not(target_os = "android"))]
        true
    }

    fn ask_files_access(self: Pin<&mut Self>) {
        // SAFETY: android/main.cpp's, on Qt's thread.
        #[cfg(target_os = "android")]
        unsafe {
            sioul_android_ask_files_access()
        };
        let _ = self;
    }

    fn share_now(self: Pin<&mut Self>) {
        crate::share::exchange(&self.qt_thread(), &self.shared());
    }

    fn export_time_csv(mut self: Pin<&mut Self>, project: &QString, from: &QString, to: &QString, target: &QString) -> QString {
        match crate::projects::export_time_csv(&self.shared(), &project.to_string(), &from.to_string(), &to.to_string(), &target.to_string()) {
            Ok(path) => {
                self.as_mut().set_status(QString::from(&say("time-exported", &[("path", path)])));
                QString::default()
            }
            Err(e) => QString::from(&e),
        }
    }

    fn change_line(self: Pin<&mut Self>, uri: &QString, shown: &QString, label: &QString, amount: f64, date: &QString) -> QString {
        QString::from(&crate::projects::change_line(&self.qt_thread(), &self.shared(), &uri.to_string(), &shown.to_string(), &label.to_string(), amount, &date.to_string()))
    }

    fn remove_budget(self: Pin<&mut Self>, what: &QString) -> QString {
        QString::from(&crate::projects::remove_budget(&self.qt_thread(), &self.shared(), &what.to_string()))
    }

    fn remove_line(self: Pin<&mut Self>, uri: &QString, shown: &QString) -> QString {
        QString::from(&crate::projects::remove_line(&self.qt_thread(), &self.shared(), &uri.to_string(), &shown.to_string()))
    }

    fn noise_url(&self, kind: &QString) -> QString {
        match sioul_core::sounds::noise_file(&config::cache_dir().join("sounds"), &kind.to_string()) {
            Ok(path) => QString::from(&file_url(&path)),
            Err(_) => QString::default(),
        }
    }

    fn calm_sounds(&self) -> QString {
        QString::from(&work::calm_sounds(&self.shared()))
    }

    fn move_task(self: Pin<&mut Self>, uid: &QString, list: &QString, confirmed: bool) -> QString {
        QString::from(&work::move_task(&self.qt_thread(), &self.shared(), &uid.to_string(), &list.to_string(), confirmed))
    }

    fn move_contact(self: Pin<&mut Self>, key: &QString, book: &QString, confirmed: bool) -> QString {
        QString::from(&pim::move_contact(&self.qt_thread(), &self.shared(), &key.to_string(), &book.to_string(), confirmed))
    }

    fn address_books(&self) -> QString {
        QString::from(&pim::books())
    }

    fn find_places(self: Pin<&mut Self>, name: &QString) {
        let (qt, name) = (self.qt_thread(), name.to_string());
        let language = tr().text("qt-locale", None).chars().take(2).collect::<String>();
        std::thread::spawn(move || {
            let found = sioul_sync::weather::places(&name, &language).map(|p| json(&p)).unwrap_or_else(|e| serde_json::json!({ "error": e.sentence(tr(), "Open-Meteo") }).to_string());
            let _ = qt.queue(move |mut sioul| sioul.as_mut().set_places_found(QString::from(&found)));
        });
    }

    fn set_weather_place(mut self: Pin<&mut Self>, name: &QString, latitude: f64, longitude: f64) {
        let name = name.to_string();
        let path = config_path();
        let written = if name.trim().is_empty() {
            ["weather.place", "weather.latitude", "weather.longitude"].iter().try_for_each(|k| config::set_value(&path, k, &config::SettingValue::Text(String::new())))
        } else {
            config::set_value(&path, "weather.place", &config::SettingValue::Text(name))
                .and_then(|()| config::set_value(&path, "weather.latitude", &config::SettingValue::Float(latitude)))
                .and_then(|()| config::set_value(&path, "weather.longitude", &config::SettingValue::Float(longitude)))
        };
        if let Err(e) = written {
            self.as_mut().set_status(QString::from(&e));
        }
        let _ = std::fs::remove_file(weather_cache());
        self.as_mut().set_forecast(QString::default());
        update_weather(&self.qt_thread(), &self.shared());
        // The phone's card: no place, where to choose one; a new place, its forecast once fetched.
        crate::homecard::weather_seen();
    }

    fn health_page(&self) -> QString {
        QString::from(&crate::health::page())
    }

    fn save_medicine(self: Pin<&mut Self>, id: &QString, edit: &QString) -> QString {
        QString::from(&crate::health::save_medicine(&id.to_string(), &edit.to_string()))
    }

    fn save_prescription(self: Pin<&mut Self>, id: &QString, edit: &QString) -> QString {
        QString::from(&crate::health::save_prescription(&id.to_string(), &edit.to_string()))
    }

    fn health_for_professional(&self, prescription: &QString) -> QString {
        QString::from(&crate::health::for_professional(&prescription.to_string()))
    }

    fn remove_health(self: Pin<&mut Self>, id: &QString) -> QString {
        QString::from(&crate::health::remove(&id.to_string()))
    }

    fn refilled(self: Pin<&mut Self>, id: &QString) -> QString {
        QString::from(&crate::health::refilled(&id.to_string()))
    }

    fn set_dose_taken(self: Pin<&mut Self>, key: &QString, taken: bool) {
        let problem = crate::health::set_taken(&key.to_string(), taken);
        if !problem.is_empty() {
            tell(&self.qt_thread(), &self.shared(), problem);
        }
        // Your other computers know at once.
        crate::share::exchange(&self.qt_thread(), &self.shared());
    }

    fn dose_not_taken(self: Pin<&mut Self>, key: &QString) {
        let problem = crate::health::not_taken(&key.to_string());
        if !problem.is_empty() {
            tell(&self.qt_thread(), &self.shared(), problem);
        }
        crate::share::exchange(&self.qt_thread(), &self.shared());
    }

    fn dose_taken_at(self: Pin<&mut Self>, key: &QString, time: &QString) -> QString {
        let problem = crate::health::taken_late(&key.to_string(), &time.to_string());
        if problem.is_empty() {
            crate::share::exchange(&self.qt_thread(), &self.shared());
        }
        QString::from(&problem)
    }

    fn dose_info(&self, key: &QString) -> QString {
        QString::from(&crate::health::dose_info(&key.to_string()))
    }

    fn dose_choose(self: Pin<&mut Self>, key: &QString, taken: bool) -> QString {
        let problem = crate::health::choose(&key.to_string(), taken);
        // Your other devices know at once; the pages say it.
        crate::share::exchange(&self.qt_thread(), &self.shared());
        crate::health::show_health(&self.qt_thread(), &self.shared());
        QString::from(&problem)
    }

    fn device_off(self: Pin<&mut Self>, id: &QString, off: bool) -> QString {
        let problem = crate::health::device_off(&id.to_string(), off);
        crate::health::show_health(&self.qt_thread(), &self.shared());
        QString::from(&problem)
    }

    fn device_forget(self: Pin<&mut Self>, id: &QString) -> QString {
        QString::from(&crate::health::device_forget(&id.to_string()))
    }

    fn needs(&self) -> QString {
        QString::from(&crate::health::needs_page())
    }

    fn save_needs(self: Pin<&mut Self>, edit: &QString, shown: &QString) -> QString {
        let problem = crate::health::save_needs(&edit.to_string(), &shown.to_string());
        // The plan goes around them at once.
        crate::work::show_work(&self.qt_thread(), &self.shared());
        QString::from(&problem)
    }

    fn skip_need(self: Pin<&mut Self>, key: &QString, skip: bool) -> QString {
        let problem = crate::health::skip_today(&key.to_string(), skip);
        crate::work::show_work(&self.qt_thread(), &self.shared());
        QString::from(&problem)
    }

    fn needs_today(&self) -> QString {
        QString::from(&crate::health::needs_today())
    }

    fn refresh_health(self: Pin<&mut Self>) {
        crate::health::show_health(&self.qt_thread(), &self.shared());
    }

    fn show_health_week(self: Pin<&mut Self>, day: &QString) {
        crate::health::show_week(&day.to_string());
        crate::health::show_health(&self.qt_thread(), &self.shared());
    }

    fn drag_need(self: Pin<&mut Self>, edit: &QString) -> QString {
        let (qt, shared) = (self.qt_thread(), self.shared());
        let problem = crate::health::drag_need(&qt, &shared, &edit.to_string());
        // The plan goes around it as that day has it now; the page shows it.
        work::show_work(&qt, &shared);
        crate::health::show_health(&qt, &shared);
        QString::from(&problem)
    }

    fn change_need(self: Pin<&mut Self>, edit: &QString) -> QString {
        let problem = crate::health::change_need(&edit.to_string());
        // The plan goes around it as that day has it now; the page shows it.
        crate::work::show_work(&self.qt_thread(), &self.shared());
        crate::health::show_health(&self.qt_thread(), &self.shared());
        QString::from(&problem)
    }

    fn health_settings(&self) -> QString {
        QString::from(&crate::health::settings_view())
    }

    fn wake_settings(&self, which: &QString) {
        crate::wake::open_settings(&which.to_string());
    }

    fn try_wake(&self) -> QString {
        QString::from(&crate::wake::try_now())
    }

    fn set_overlap_aside(self: Pin<&mut Self>, key: &QString) -> QString {
        let problem = crate::pim::set_overlap_aside(&key.to_string());
        pim::show_pim(&self.qt_thread(), &self.shared());
        QString::from(&problem)
    }

    fn move_need(self: Pin<&mut Self>, key: &QString, minutes: i32, time: &QString) -> QString {
        let problem = crate::health::move_today(&key.to_string(), i64::from(minutes), &time.to_string());
        // The plan goes around it where it is now.
        crate::work::show_work(&self.qt_thread(), &self.shared());
        QString::from(&problem)
    }

    fn needs_later(&self) -> i32 {
        i32::try_from(crate::health::later_minutes()).unwrap_or(15)
    }

    fn missed_doses(&self) -> QString {
        QString::from(&crate::health::missed())
    }

    // Both off the window's thread: Android waits for the window to answer
    // when it puts Sioul away, and an exchange can take seconds.
    fn going_away(mut self: Pin<&mut Self>) {
        self.as_mut().set_away(true);
        AWAY.store(true, Ordering::SeqCst);
        std::thread::spawn(crate::alarms::schedule);
        // The events' reminders as they are, for Android's alarm clock (`eventalarms`).
        std::thread::spawn(crate::eventalarms::schedule);
        // The home screen's card as Sioul leaves it, drawn at once (homecard.rs).
        crate::homecard::now();
        crate::share::set_shown(false);
        let (qt, shared) = (self.qt_thread(), self.shared());
        std::thread::spawn(move || {
            crate::mail::quiet_watchers(&shared);
            crate::mail::finish_all(&qt, &shared);
            crate::share::closing();
            // The closed claims go up at once.
            crate::share::nudge(&qt, &shared, 0, false);
        });
    }

    fn back_here(mut self: Pin<&mut Self>) {
        self.as_mut().set_away(false);
        AWAY.store(false, Ordering::SeqCst);
        // A dose's reminder tapped while away: its question, at once.
        if let Some(key) = crate::alarms::opened() {
            self.as_mut().reminder_opened(QString::from("dose"), QString::default(), QString::from(&key));
        }
        // An event's reminder or new mail's notification tapped while away: the event, or the Porch.
        if let Some((kind, key)) = crate::eventalarms::opened() {
            self.as_mut().reminder_opened(QString::from(&kind), QString::default(), QString::from(&key));
        }
        // The home screen's card tapped: the Porch or a message on it, Now on
        // its step, the Agenda or an event in it (homecard.rs).
        if let Some((kind, uri, key)) = crate::homecard::opened() {
            self.as_mut().reminder_opened(QString::from(kind), QString::from(&uri), QString::from(&key));
        }
        // What was asked while away, computed once now.
        let (qt, shared) = (self.qt_thread(), self.shared());
        if shared.views_job.deferred.swap(false, Ordering::SeqCst) | shared.mail_job.deferred.swap(false, Ordering::SeqCst) {
            show(&qt, &shared);
        }
        if shared.pim_job.deferred.swap(false, Ordering::SeqCst) {
            pim::show_pim(&qt, &shared);
        }
        if shared.work_job.deferred.swap(false, Ordering::SeqCst) {
            work::show_work(&qt, &shared);
        }
        if shared.health_job.deferred.swap(false, Ordering::SeqCst) {
            crate::health::show_health(&qt, &shared);
        }
        crate::share::set_shown(true);
        // Something shared to Sioul, a mailto: link opened with it: its draft (docs/android.md, "Sharing").
        crate::outside::take(self.as_mut());
        std::thread::spawn(|| crate::outside::publish(true));
        // A "Pause" pressed on the quick-settings tile or the home screen's shortcut (docs/pauses.md).
        crate::pauses::tick(&self.qt_thread(), &self.shared());
        let now = jiff::Timestamp::now().as_second();
        self.shared().active.store(now, std::sync::atomic::Ordering::Relaxed);
        let (qt, shared) = (self.qt_thread(), self.shared());
        std::thread::spawn(move || {
            // A session begins again: up, said to your other devices (docs/database.md, "Devices").
            crate::devices::window_opened();
            let _ = crate::share::keeper("health", sioul_sync::lease::Rule::FollowsYou, now, false);
            // What the other devices marked meanwhile comes down, and is read;
            // mail and calendars fetched now, not when their pauses end.
            crate::share::nudge(&qt, &shared, 0, true);
            crate::mail::wake_watchers(&shared);
        });
    }

    fn touch(self: Pin<&mut Self>) {
        self.shared().active.store(jiff::Timestamp::now().as_second(), std::sync::atomic::Ordering::Relaxed);
    }

    fn set_health(self: Pin<&mut Self>, key: &QString, value: &QString) -> QString {
        QString::from(&crate::health::set_setting(&key.to_string(), &value.to_string()))
    }

    fn movement_minutes(&self) -> i32 {
        crate::health::movement_minutes()
    }

    fn chat_minute(self: Pin<&mut Self>) -> bool {
        crate::health::chat_minute()
    }

    fn chats_covered(&self) -> bool {
        crate::health::chats_covered()
    }

    fn memo_url(&self) -> QString {
        QString::from(&work::memo_url())
    }

    fn memo_recorded(self: Pin<&mut Self>, url: &QString) -> QString {
        let (qt, shared) = (self.qt_thread(), self.shared());
        work::show_work(&qt, &shared);
        QString::from(&work::note_path_of(&url.to_string()))
    }

    fn set_notes_tree(self: Pin<&mut Self>, tree: bool) {
        work::set_notes_tree(&self.qt_thread(), &self.shared(), tree);
    }

    fn view_flag(&self, name: &QString) -> bool {
        work::view_flag(&self.shared(), &name.to_string())
    }

    fn set_view_flag(self: Pin<&mut Self>, name: &QString, value: bool) {
        work::set_view_flag(&self.shared(), &name.to_string(), value);
    }

    fn add_movement(mut self: Pin<&mut Self>, edit: &QString) -> QString {
        #[derive(serde::Deserialize)]
        struct Movement {
            /// "once" or "recurring".
            kind: String,
            budget: String,
            label: String,
            amount: f64,
            #[serde(default)]
            date: String,
            /// Recurring: "month" or "year", the day, the month of a yearly one, from, until.
            #[serde(default)]
            every: String,
            #[serde(default)]
            day: i8,
            #[serde(default)]
            month: Option<i8>,
            #[serde(default)]
            from: String,
            #[serde(default)]
            until: String,
            #[serde(default)]
            estimate: bool,
        }
        let world = World::load();
        let outcome = (|| {
            let movement: Movement = serde_json::from_str(&edit.to_string()).map_err(|e| e.to_string())?;
            let ledger = world.ledger().ok_or_else(|| tr().text("ui-no-budgets", None))?;
            let path = world.ledger_path().ok_or_else(|| tr().text("ui-no-budgets", None))?;
            if movement.amount == 0.0 || !movement.amount.is_finite() {
                return Err(tr().text("budget-add-bad-amount", None));
            }
            let today = Zoned::now().date();
            let origin = say("budget-origin-hand", &[("date", today.to_string())]);
            if movement.kind == "recurring" {
                let preset = budget::PresetEdit {
                    budget: movement.budget.clone(),
                    label: movement.label.clone(),
                    amount: movement.amount,
                    every: movement.every.clone(),
                    day: movement.day,
                    month: movement.month,
                    from: movement.from.clone(),
                    until: movement.until.clone(),
                    estimate: movement.estimate,
                };
                budget::record_preset(&path, &preset, &origin)?;
            } else {
                let date: jiff::civil::Date = movement.date.parse().unwrap_or(today);
                let line = budget::Line {
                    budget: movement.budget.clone(),
                    date,
                    amount: sioul_core::money::Money::from_units(movement.amount),
                    label: movement.label.trim().to_string(),
                    planned: date > today,
                    reserve: None,
                    links: Vec::new(),
                    preset: None,
                };
                budget::record_line(&path, &line, &origin)?;
            }
            Ok::<String, String>(say("budget-added", &[("budget", ledger.budget_title(&movement.budget).to_string())]))
        })();
        let (line, problem) = match outcome {
            Ok(line) => (line, String::new()),
            Err(e) => (e.clone(), e),
        };
        self.as_mut().set_status(QString::from(&line));
        show(&self.qt_thread(), &self.shared());
        QString::from(&problem)
    }

    fn site_list(&self) -> QString {
        QString::from(&crate::sites::list())
    }

    fn site_notified(self: Pin<&mut Self>, id: &QString, title: &QString, text: &QString) {
        crate::sites::notified(&self.qt_thread(), &self.shared(), &id.to_string(), &title.to_string(), &text.to_string());
    }

    fn site_seen(self: Pin<&mut Self>, id: &QString) {
        crate::sites::seen(&self.qt_thread(), &id.to_string());
    }

    fn site_notices(&self) -> QString {
        QString::from(&crate::sites::waiting())
    }

    fn site_for_sender(&self, sender: &QString) -> QString {
        QString::from(&crate::sites::announced_by(&sender.to_string()))
    }

    fn set_site(mut self: Pin<&mut Self>, id: &QString, field: &QString, value: &QString) -> QString {
        let (field, value) = (field.to_string(), value.to_string());
        let setting = match field.as_str() {
            "realtime" | "muted" | "background" | "microphone" | "camera" | "screen" => config::SettingValue::Bool(value == "true"),
            "site" | "area" | "name" => config::SettingValue::Text(value.trim().to_string()),
            // Your categories, as a JSON list of words.
            "categories" => config::SettingValue::Texts(serde_json::from_str::<Vec<String>>(&value).unwrap_or_default().into_iter().map(|c| c.trim().to_string()).filter(|c| !c.is_empty()).collect()),
            // Only an encrypted address: a site's sign-in never travels in clear.
            "url" if value.trim().starts_with("https://") => config::SettingValue::Text(value.trim().to_string()),
            "url" => return QString::from(&tr().text("site-https-only", None)),
            _ => return QString::default(),
        };
        let result = config::set_value(&config_path(), &format!("site.{}.{field}", id), &setting);
        self.as_mut().sites_changed();
        QString::from(&result.err().unwrap_or_default())
    }

    fn site_presets(&self, country: &QString, region: &QString) -> QString {
        QString::from(&crate::sites::presets(&country.to_string(), &region.to_string()))
    }

    fn add_site(mut self: Pin<&mut Self>, edit: &QString) -> QString {
        let answer = crate::sites::add(&edit.to_string());
        self.as_mut().sites_changed();
        QString::from(&answer)
    }

    fn site_presets_tree(&self) -> QString {
        QString::from(&crate::sites::presets_tree())
    }

    fn add_sites(mut self: Pin<&mut Self>, rows: &QString) -> QString {
        let answer = crate::sites::add_many(&rows.to_string());
        self.as_mut().sites_changed();
        QString::from(&answer)
    }

    fn move_site(mut self: Pin<&mut Self>, id: &QString, delta: i32) -> QString {
        let said = crate::sites::move_site(&id.to_string(), i64::from(delta));
        self.as_mut().sites_changed();
        QString::from(&said)
    }

    fn remove_site(mut self: Pin<&mut Self>, id: &QString) -> QString {
        let problem = crate::sites::remove(&id.to_string());
        self.as_mut().sites_changed();
        QString::from(&problem)
    }

    fn google_built_in(&self) -> bool {
        sioul_sync::google::built_in().is_some()
    }

    fn call_devices(&self) -> QString {
        QString::from(&serde_json::to_string(&load_config().calls).unwrap_or_default())
    }

    fn calls_script(&self) -> QString {
        QString::from(include_str!("calls.js"))
    }

    fn set_call_device(mut self: Pin<&mut Self>, which: &QString, name: &QString) -> QString {
        let which = which.to_string();
        if !matches!(which.as_str(), "camera" | "microphone" | "speaker") {
            return QString::default();
        }
        let name = name.to_string().trim().to_string();
        let result = config::set_value(&config_path(), &format!("calls.{which}"), &config::SettingValue::Text(name));
        self.as_mut().sites_changed();
        QString::from(&result.err().unwrap_or_default())
    }

    fn bitwarden_state(&self) -> QString {
        QString::from(&crate::sites::bitwarden_state(&self.shared()))
    }

    fn bitwarden_unlock(self: Pin<&mut Self>, password: &QString, provider: i32, code: &QString) -> i32 {
        let (shared, password, code) = (self.shared(), password.to_string(), code.to_string());
        crate::sites::bitwarden_later(&self.qt_thread(), move || crate::sites::bitwarden_unlock(&shared, &password, provider, &code))
    }

    fn bitwarden_lock(self: Pin<&mut Self>) {
        crate::sites::bitwarden_lock(&self.shared());
    }

    fn bitwarden_send_code(self: Pin<&mut Self>, password: &QString) -> i32 {
        let password = password.to_string();
        crate::sites::bitwarden_later(&self.qt_thread(), move || crate::sites::bitwarden_send_code(&password))
    }

    fn bitwarden_passkey_begin(self: Pin<&mut Self>) -> i32 {
        crate::sites::bitwarden_later(&self.qt_thread(), crate::sites::bitwarden_passkey_begin)
    }

    fn bitwarden_passkey(self: Pin<&mut Self>, answer: &QString) -> i32 {
        let (shared, answer) = (self.shared(), answer.to_string());
        crate::sites::bitwarden_later(&self.qt_thread(), move || crate::sites::bitwarden_passkey(&shared, &answer))
    }

    fn bitwarden_search(self: Pin<&mut Self>, url: &QString, site: &QString, user: &QString) -> QString {
        QString::from(&crate::sites::bitwarden_search(&self.qt_thread(), &self.shared(), &url.to_string(), &site.to_string(), &user.to_string()))
    }

    fn bitwarden_site(&self, url: &QString) -> QString {
        QString::from(&crate::sites::bitwarden_site(&self.shared(), &url.to_string()))
    }

    fn bitwarden_login(&self, url: &QString, id: &QString) -> QString {
        QString::from(&crate::sites::bitwarden_login(&self.shared(), &url.to_string(), &id.to_string()))
    }

    fn map_view(&self) -> QString {
        QString::from(&crate::map::view(&self.shared()))
    }

    fn place_of(&self, address: &QString) -> QString {
        QString::from(&crate::map::place_of(&address.to_string()))
    }

    fn locate_addresses(mut self: Pin<&mut Self>, allow: bool) {
        if allow && !load_config().map.geocode {
            if let Err(e) = config::set_value(&config_path(), "map.geocode", &config::SettingValue::Bool(true)) {
                self.as_mut().set_status(QString::from(&e));
                return;
            }
        }
        crate::map::locate(&self.qt_thread(), &self.shared());
    }

    fn refresh_mode(mut self: Pin<&mut Self>) {
        // Doses to remind, errands to make: off the window's thread.
        let (qt, shared_tick) = (self.qt_thread(), self.shared());
        std::thread::spawn(move || crate::health::tick(&qt, &shared_tick));
        // The time running's notification: what changed elsewhere (another
        // device, the command line), or while a phone had Sioul put away.
        let (qt_time, shared_time) = (self.qt_thread(), self.shared());
        std::thread::spawn(move || crate::timenote::follow(&qt_time, &shared_time));
        // The spam filter trains again by itself, plugged in and idle, on the computer that made its table.
        let qt_spam = self.qt_thread();
        std::thread::spawn(move || crate::spam::by_itself(qt_spam));
        // The pauses: free time ended by itself, the do-not-disturb as the pauses are (docs/pauses.md).
        crate::pauses::tick(&self.qt_thread(), &self.shared());
        // Put away on a phone: the reminders only, and an exchange every five
        // minutes; the rest waits until it is back (Android stops an app that
        // works in the background, and nobody looks at its pages then).
        if *self.as_ref().away() {
            if Zoned::now().minute() % 5 == 0 {
                crate::share::exchange_tick(&self.qt_thread(), &self.shared());
            }
            return;
        }
        // The home screen's card: written again when its first frame ended, or five minutes went by.
        crate::homecard::tick();
        // Something handed by another application while the window stayed shown (split screen).
        crate::outside::take(self.as_mut());
        // The plan, made again on the clock.
        let now = Zoned::now();
        let (stamp, day) = (now.timestamp().as_second(), i64::from(now.date().year()) * 1000 + i64::from(now.date().day_of_year()));
        let shared = self.shared();
        let last = shared.planned_at.load(Ordering::Relaxed);
        if last == 0 {
            shared.planned_at.store(stamp, Ordering::Relaxed);
            shared.planned_day.store(day, Ordering::Relaxed);
        } else if stamp - last >= REPLAN_EVERY || shared.planned_day.load(Ordering::Relaxed) != day {
            // A new day: the agenda and today's overlaps follow it too.
            if shared.planned_day.load(Ordering::Relaxed) != day {
                pim::show_pim(&self.qt_thread(), &shared);
            }
            shared.planned_at.store(stamp, Ordering::Relaxed);
            shared.planned_day.store(day, Ordering::Relaxed);
            work::show_work(&self.qt_thread(), &shared);
        }
        // What changed here goes to your other computers, theirs comes in
        // (left out when a save's exchange just did it: `share::exchange_tick`).
        crate::share::exchange_tick(&self.qt_thread(), &self.shared());
        crate::share::nudge_tick(&self.qt_thread(), &self.shared());
        // Invoices stay with the computer that makes them: its claim renewed,
        // off the window's thread (it reads and writes the sharing folder).
        let shared_invoices = self.shared();
        std::thread::spawn(move || crate::projects::keep_invoices(&shared_invoices));
        // What sites notified, gathered at the times you set.
        crate::sites::gather_tick(&self.qt_thread(), &self.shared());
        // Your sites' own icons, when missing or a week old.
        crate::sites::favicon_tick(&self.qt_thread());
        // Dates coming: told once each.
        crate::remind::tick(&self.qt_thread());
        // Mail that waited for its time, told when the time begins (docs/porch.md, "Notifications").
        crate::mailnote::tick_in_window(crate::mailnote::Window { qt: self.qt_thread(), active: self.shared().active.load(Ordering::Relaxed) });
        // The end of the work day, said once (docs/reviews.md).
        crate::reviews::tick(&self.qt_thread(), &self.shared());
        // Paper letters scanned: read, to wait for the Porch.
        crate::letters::tick(&self.qt_thread(), &self.shared());
        // The weather follows the hours; fetched again when half an hour old.
        update_weather(&self.qt_thread(), &self.shared());
        let line = mode_json();
        if self.as_ref().mode().to_string() != line {
            let was_quiet = self.as_ref().mode().to_string().contains("\"quiet\":true");
            self.as_mut().set_mode(QString::from(&line));
            // Work came or went: what the pages show follows.
            if was_quiet != line.contains("\"quiet\":true") {
                let (qt, shared) = (self.qt_thread(), self.shared());
                show(&qt, &shared);
                work::show_work(&qt, &shared);
            }
        }
    }

    fn work_a_while(self: Pin<&mut Self>, minutes: i32) {
        let until = Zoned::now().timestamp().as_second() + i64::from(minutes.max(1)) * 60;
        self.change_overrides(|o| {
            o.rest_until = None;
            o.work_until = Some(until);
        });
    }

    pub(crate) fn done_for_the_day(mut self: Pin<&mut Self>) -> QString {
        let (qt, shared) = (self.qt_thread(), self.shared());
        let closed = work::closing(&shared);
        let path = sioul_core::quiet::Overrides::default_path();
        let previous = sioul_core::quiet::Overrides::load(&path);
        let mut next = previous.clone();
        next.work_until = None;
        next.rest_until = Some(closed.back.timestamp().as_second());
        next.rest_from = Some(Zoned::now().timestamp().as_second());
        next.first_step = Some(closed.first.text.clone()).filter(|s| !s.is_empty());
        next.first_step_task = Some(closed.first.uid.clone()).filter(|s| !s.is_empty());
        next.first_step_day = Some(closed.back.date());
        if let Err(e) = next.save(&path) {
            self.as_mut().set_status(QString::from(&e));
            return QString::default();
        }
        // A session running stops here, and counts.
        if sioul_core::timelog::running().is_some() {
            work::focus_stop(&qt, &shared, false, "");
        }
        let screen = json(&closed.closing);
        mail::rest(&qt, &shared, previous, next, serde_json::from_str::<serde_json::Value>(&screen).ok().and_then(|v| v["put_away"].as_str().map(str::to_string)).unwrap_or_default());
        self.as_mut().set_mode(QString::from(&mode_json()));
        show(&qt, &shared);
        work::show_work(&qt, &shared);
        QString::from(&screen)
    }

    fn day_review(&self, kind: &QString) -> QString {
        QString::from(&crate::reviews::view(&kind.to_string()))
    }

    fn close_review(self: Pin<&mut Self>, kind: &QString, felt: &QString, mix: &QString, memo: &QString) -> QString {
        crate::reviews::close(self, &kind.to_string(), &felt.to_string(), &mix.to_string(), &memo.to_string())
    }

    fn day_review_line(&self, date: &QString) -> QString {
        QString::from(&crate::reviews::line(&date.to_string()))
    }

    fn set_first_step(self: Pin<&mut Self>, text: &QString) {
        let text = text.to_string().trim().to_string();
        self.change_overrides(|o| {
            if o.first_step.as_deref() != Some(text.as_str()) {
                // Your own words: the task it named may not be the one any more.
                o.first_step_task = None;
                o.first_step = Some(text).filter(|t| !t.is_empty());
            }
        });
    }

    fn clear_first_step(self: Pin<&mut Self>) {
        self.change_overrides(|o| {
            o.first_step = None;
            o.first_step_task = None;
        });
    }

    fn usual_hours(self: Pin<&mut Self>) {
        self.change_overrides(|o| {
            o.work_until = None;
            o.rest_until = None;
            o.work_now = None;
        });
    }

    fn set_work_now(self: Pin<&mut Self>, on: bool) {
        let config = load_config();
        let work: Vec<_> = config.windows.iter().filter(|w| w.kind() == "work").cloned().collect();
        let until = sioul_core::quiet::end_of_next_workday(&work, &config.time_off, &Zoned::now()).timestamp().as_second();
        self.change_overrides(|o| {
            // Unticked: back to the usual hours, a little longer included.
            o.work_until = None;
            if on {
                o.rest_until = None;
                o.work_now = Some(until);
            } else {
                o.work_now = None;
            }
        });
    }

    fn set_free_time(self: Pin<&mut Self>, on: bool) -> QString {
        crate::pauses::set_free(self, on)
    }

    fn keep_usual_end(self: Pin<&mut Self>) {
        crate::pauses::keep_usual_end(self);
    }

    fn set_free_nothing(self: Pin<&mut Self>, on: bool) {
        crate::pauses::set_free_nothing(self, on);
    }

    fn pause_now(self: Pin<&mut Self>) {
        crate::pauses::press(self);
    }

    fn come_back(self: Pin<&mut Self>) -> QString {
        crate::pauses::come_back(self)
    }

    fn lighten_tomorrow(self: Pin<&mut Self>) {
        crate::pauses::lighten_tomorrow(self);
    }

    fn forget_pause(self: Pin<&mut Self>) {
        crate::pauses::forget(self);
    }

    fn pause_screen(&self) -> QString {
        QString::from(&crate::pauses::screen())
    }

    fn pause_setup(&self) -> QString {
        QString::from(&crate::pauses::setup())
    }

    fn open_dnd(&self, key: &QString) {
        crate::dnd::open(&key.to_string());
    }

    fn dnd_toggle(self: Pin<&mut Self>, on: bool, minutes: i32) {
        crate::everywhere::toggle(self, on, minutes);
    }

    fn dnd_setup(&self) -> QString {
        QString::from(&crate::everywhere::setup())
    }

    fn dnd_change(self: Pin<&mut Self>, verb: &QString, json: &QString) -> QString {
        let (answer, changed) = crate::everywhere::change(&verb.to_string(), &json.to_string());
        // The list or a shared setting changed: your other devices told at once.
        if changed {
            crate::share::exchange(&self.qt_thread(), &self.shared());
        }
        QString::from(&answer)
    }

    fn app_notes_setup(&self) -> QString {
        QString::from(&crate::appnotes::setup())
    }

    fn app_notes_change(&self, verb: &QString, json: &QString) -> QString {
        QString::from(&crate::appnotes::change(&verb.to_string(), &json.to_string()))
    }

    fn calls_through(mut self: Pin<&mut Self>, on: bool, minutes: i32) {
        if let Err(e) = crate::calls::press(on, minutes) {
            self.as_mut().set_status(QString::from(&e));
            return;
        }
        // The phone's table at once, the status line again, your other devices told.
        let (qt, shared) = (self.qt_thread(), self.shared());
        std::thread::spawn(move || {
            crate::calls::refresh(true);
            let _ = qt.queue(|mut sioul| sioul.as_mut().set_mode(QString::from(&mode_json())));
            crate::share::exchange(&qt, &shared);
        });
    }

    fn calls_view(&self) -> QString {
        QString::from(&crate::calls::view())
    }

    fn calls_action(self: Pin<&mut Self>, verb: &QString, json: &QString) -> QString {
        let answer = crate::calls::act(&verb.to_string(), &json.to_string());
        // A number blocked: the table at once, your other devices told (the lists travel).
        if answer.contains("\"shared\":true") {
            let (qt, shared) = (self.qt_thread(), self.shared());
            std::thread::spawn(move || {
                crate::calls::refresh(true);
                crate::share::exchange(&qt, &shared);
            });
        }
        QString::from(&answer)
    }

    fn calls_setup(&self) -> QString {
        QString::from(&crate::calls::setup())
    }

    fn phone_messages(self: Pin<&mut Self>, verb: &QString, json: &QString) -> QString {
        let (answer, shared) = crate::phonemsgs::call(&verb.to_string(), &json.to_string());
        // Seen, a number blocked, the part switched: your other devices told at once.
        if shared {
            crate::share::exchange(&self.qt_thread(), &self.shared());
        }
        QString::from(&answer)
    }

    // texts: SMS phase (b).
    fn texts(self: Pin<&mut Self>, verb: &QString, json: &QString) -> QString {
        let (answer, shared) = crate::texts::call(&verb.to_string(), &json.to_string());
        // A text to send, the part switched: your phone told at once.
        if shared {
            crate::share::exchange(&self.qt_thread(), &self.shared());
        }
        QString::from(&answer)
    }

    fn reaches_view(&self) -> QString {
        QString::from(&crate::reaches::view(self.shared().realtime.load(Ordering::Relaxed)))
    }

    fn reaches_set(self: Pin<&mut Self>, row: &QString, words: &QString, shown: &QString) -> QString {
        let problem = crate::reaches::set_row(&row.to_string(), &words.to_string(), &shown.to_string());
        if problem.is_empty() {
            self.attention_changed();
        }
        QString::from(&problem)
    }

    fn reaches_preset(self: Pin<&mut Self>, id: &QString) -> QString {
        let problem = crate::reaches::preset(&id.to_string());
        if problem.is_empty() {
            self.attention_changed();
        }
        QString::from(&problem)
    }

    fn person_sheet(&self, key: &QString, addresses: &QString) -> QString {
        QString::from(&crate::reaches::person(&key.to_string(), &addresses.to_string()))
    }

    fn person_sheet_change(mut self: Pin<&mut Self>, key: &QString, addresses: &QString, verb: &QString, value: &QString) -> QString {
        let answer = crate::reaches::person_change(&key.to_string(), &addresses.to_string(), &verb.to_string(), &value.to_string());
        let line = serde_json::from_str::<serde_json::Value>(&answer).ok().and_then(|a| a["line"].as_str().map(str::to_string)).unwrap_or_default();
        if !line.is_empty() {
            self.as_mut().set_status(QString::from(&line));
        }
        // The lists and the Always through list travel: your other devices told, the pages shown again.
        let (qt, shared) = (self.qt_thread(), self.shared());
        show(&qt, &shared);
        pim::show_pim(&qt, &shared);
        std::thread::spawn(move || {
            crate::calls::refresh(true);
            crate::everywhere::apply();
            crate::share::exchange(&qt, &shared);
        });
        QString::from(&answer)
    }

    /// The matrix changed (Settings ▸ What reaches you): the phone's calls'
    /// table and its modes made again, the status line, the pages shown
    /// again, your other devices told.
    fn attention_changed(mut self: Pin<&mut Self>) {
        self.as_mut().set_mode(QString::from(&mode_json()));
        let (qt, shared) = (self.qt_thread(), self.shared());
        show(&qt, &shared);
        work::show_work(&qt, &shared);
        std::thread::spawn(move || {
            crate::calls::refresh(true);
            crate::everywhere::apply();
            crate::share::exchange(&qt, &shared);
        });
    }

    fn calls_setup_change(self: Pin<&mut Self>, verb: &QString, json: &QString) -> QString {
        QString::from(&crate::calls::setup_change(&verb.to_string(), &json.to_string()))
    }

    /// The overrides changed, then every page shown again for the time it is.
    fn change_overrides(mut self: Pin<&mut Self>, change: impl FnOnce(&mut sioul_core::quiet::Overrides)) {
        let path = sioul_core::quiet::Overrides::default_path();
        let mut overrides = sioul_core::quiet::Overrides::load(&path);
        change(&mut overrides);
        // What the status line said of the time before is old news now.
        let said = overrides.save(&path).err().unwrap_or_default();
        self.as_mut().set_status(QString::from(&said));
        self.as_mut().set_mode(QString::from(&mode_json()));
        let (qt, shared) = (self.qt_thread(), self.shared());
        show(&qt, &shared);
        work::show_work(&qt, &shared);
    }

    fn project_rows(&self) -> QString {
        QString::from(&crate::projects::rows(&self.shared()))
    }

    fn project_page(&self, id: &QString) -> QString {
        QString::from(&crate::projects::page(&self.shared(), &id.to_string()))
    }

    fn save_project(self: Pin<&mut Self>, id: &QString, edit: &QString) -> QString {
        QString::from(&crate::projects::save(&self.qt_thread(), &self.shared(), &id.to_string(), &edit.to_string()))
    }

    fn time_page(&self, period: &QString, anchor: &QString, project: &QString) -> QString {
        QString::from(&crate::projects::time(&self.shared(), &period.to_string(), &anchor.to_string(), &project.to_string()))
    }

    fn note_time(self: Pin<&mut Self>, edit: &QString) -> QString {
        QString::from(&crate::projects::note_time(&self.qt_thread(), &self.shared(), &edit.to_string()))
    }

    fn stopped(&self) -> QString {
        QString::from(&crate::work::stopped(&self.shared()))
    }

    fn set_stopped(self: Pin<&mut Self>, text: &QString) -> QString {
        QString::from(&crate::work::set_stopped(&self.qt_thread(), &self.shared(), &text.to_string()))
    }

    fn change_time(self: Pin<&mut Self>, key: &QString, edit: &QString) -> QString {
        QString::from(&crate::projects::change_time(&self.qt_thread(), &self.shared(), &key.to_string(), &edit.to_string()))
    }

    fn task_choices(&self, keep: &QString) -> QString {
        QString::from(&crate::projects::task_choices(&self.shared(), &keep.to_string()))
    }

    fn remove_time(self: Pin<&mut Self>, key: &QString) -> QString {
        QString::from(&crate::projects::remove_time(&self.qt_thread(), &self.shared(), &key.to_string()))
    }

    fn take_invoices(self: Pin<&mut Self>) -> QString {
        QString::from(&crate::projects::take_invoices(&self.shared()))
    }

    fn make_invoice(self: Pin<&mut Self>, id: &QString) -> QString {
        QString::from(&crate::projects::make_invoice(&self.qt_thread(), &self.shared(), &id.to_string()))
    }

    fn invoice_again(&self, number: &QString) -> QString {
        QString::from(&crate::projects::invoice_again(&number.to_string()))
    }

    fn set_invoice_paid(self: Pin<&mut Self>, number: &QString, paid: bool) -> QString {
        QString::from(&crate::projects::set_paid(&self.qt_thread(), &self.shared(), &number.to_string(), paid))
    }

    fn make_linked(self: Pin<&mut Self>, kind: &QString, from: &QString, key: &QString, start: f64) -> QString {
        QString::from(&work::make_linked(&self.qt_thread(), &self.shared(), &kind.to_string(), &from.to_string(), &key.to_string(), start))
    }

    fn task_from_mail(self: Pin<&mut Self>, key: &QString) -> QString {
        QString::from(&work::task_from_mail(&self.qt_thread(), &self.shared(), &key.to_string()))
    }

    fn note_from_mail(self: Pin<&mut Self>, key: &QString) -> QString {
        QString::from(&work::note_from_mail(&self.qt_thread(), &self.shared(), &key.to_string()))
    }

    fn note_from_event(self: Pin<&mut Self>, key: &QString, start: f64) -> QString {
        QString::from(&work::note_from_event(&self.qt_thread(), &self.shared(), &key.to_string(), start))
    }

    fn task_from_event(self: Pin<&mut Self>, key: &QString, start: f64) -> QString {
        QString::from(&work::task_from_event(&self.qt_thread(), &self.shared(), &key.to_string(), start))
    }

    fn task_from_line(self: Pin<&mut Self>, path: &QString, line: i32) -> QString {
        QString::from(&work::task_from_line(&self.qt_thread(), &self.shared(), &path.to_string(), line))
    }

    fn draft_for_task(self: Pin<&mut Self>, uid: &QString) -> QString {
        QString::from(&work::draft_for_task(&self.qt_thread(), &self.shared(), &uid.to_string()))
    }

    fn mail_note(self: Pin<&mut Self>, path: &QString) -> QString {
        QString::from(&work::mail_note(&self.qt_thread(), &self.shared(), &path.to_string()))
    }

    fn settings(&self, view: &QString) -> QString {
        let config = load_config();
        let lists: Vec<(String, String)> = sioul_core::tasks::lists().into_iter().filter(|c| !c.read_only).map(|c| (format!("{}/{}", c.account, c.id), c.label(&config, tr()))).collect();
        let store = config.notes_root_path().and_then(|root| ProjectStore::load(&root).ok());
        let mut rows = sioul_core::settings::for_view(&view.to_string(), &config, tr(), &lists, store.as_ref());
        // The categories are the tasks': the core does not read them.
        if view.to_string() == "tasks" {
            let categories = work::categories_in_use(&self.shared());
            if !categories.is_empty() {
                let at = rows.iter().position(|r| r.key == "tasks.kind").map_or(rows.len(), |i| i + 1);
                rows.insert(at, sioul_core::settings::categories(tr(), categories));
            }
        }
        // Whether the keyring keeps a key: the core does not read the keyring.
        for row in rows.iter_mut().filter(|r| r.key == "ai_key") {
            row.value = config::SettingValue::Bool(sioul_sync::shield_ai::api_key().is_some());
        }
        for row in rows.iter_mut().filter(|r| r.key == "github_token") {
            row.value = config::SettingValue::Bool(sioul_sync::github::token().is_some());
        }
        // Whether the session starts the reminders' watcher: the desktop's own entry says.
        for row in rows.iter_mut().filter(|r| r.key == "reminders_closed") {
            row.value = config::SettingValue::Bool(crate::remind::background());
        }
        // On a phone, whether Android lets the events' reminders come on time.
        if cfg!(target_os = "android") {
            for row in rows.iter_mut().filter(|r| r.key == "reminders.before_event") {
                row.help = format!("{} {}", row.help, tr().text(if crate::alarms::exact() { "set-reminders-before-exact" } else { "set-reminders-before-inexact" }, None));
            }
        }
        for row in rows.iter_mut().filter(|r| r.key == "passwords_shown") {
            row.value = config::SettingValue::Bool(work::view_flag(&self.shared(), "passwords-shown"));
        }
        // colour: what this screen gets, said under its switch; neither line on a
        // phone, whose sites open in the browser (docs/colour.md).
        if cfg!(target_os = "android") {
            rows.retain(|r| r.key != "screen_colours" && r.key != "calmer_colours");
        }
        #[cfg(not(target_os = "android"))]
        for row in rows.iter_mut().filter(|r| r.key == "screen_colours") {
            use crate::colour::Said;
            let said = match crate::colour::said() {
                Said::Converted(name) if !name.is_empty() => say("colour-said-converted", &[("profile", name)]),
                Said::Converted(_) => tr().text("colour-said-converted-unnamed", None),
                Said::Desktop => tr().text("colour-said-desktop", None),
                Said::Plain => tr().text("colour-said-plain", None),
                Said::Off | Said::Unknown => String::new(),
            };
            if !said.is_empty() {
                row.help = format!("{} {said}", row.help);
            }
        }
        // The phone's home screen card: its details, this device's own (homecard.rs).
        if crate::homecard::has_setting()
            && let Some(at) = rows.iter().position(|r| r.key == "passwords_shown")
        {
            let row = crate::homecard::setting(&rows[at].group, &rows[at].section, !work::view_flag(&self.shared(), crate::homecard::PLAIN));
            rows.insert(at + 1, row);
        }
        QString::from(&json(&rows))
    }

    fn set_setting(self: Pin<&mut Self>, key: &QString, value: &QString) -> QString {
        self.change_setting(key, &QString::default(), value)
    }

    fn change_setting(mut self: Pin<&mut Self>, key: &QString, shown: &QString, value: &QString) -> QString {
        let key = key.to_string();
        // What the row showed: what its change is set over the files from (none: the value as sent).
        // One that does not read is refused, said: never the whole value written over what changed meanwhile.
        let shown: Option<config::SettingValue> = match Some(shown.to_string()).filter(|s| !s.is_empty()).map(|s| serde_json::from_str(&s)) {
            Some(Ok(shown)) => Some(shown),
            Some(Err(e)) => return QString::from(&format!("{key}: {e}")),
            None => None,
        };
        let parsed: Result<config::SettingValue, String> = serde_json::from_str(&value.to_string()).map_err(|e| e.to_string());
        let result = parsed.and_then(|v| match (key.as_str(), v) {
            // The AI's key goes to the keyring, never to the configuration; an empty one is forgotten.
            ("ai_key", config::SettingValue::Text(secret)) => sioul_sync::shield_ai::save_api_key(&secret).map_err(|e| e.sentence(tr(), "Anthropic")),
            ("github_token", config::SettingValue::Text(secret)) => sioul_sync::github::save_token(&secret).map_err(|e| e.sentence(tr(), "GitHub")),
            ("task_categories", config::SettingValue::Rename(change)) => work::rename_category(&self.qt_thread(), &self.shared(), &change.from, &change.to),
            ("reminders_closed", config::SettingValue::Bool(on)) => crate::remind::set_background(on),
            ("passwords_shown", config::SettingValue::Bool(on)) => {
                work::set_view_flag(&self.shared(), "passwords-shown", on);
                Ok(())
            }
            ("home_card_details", config::SettingValue::Bool(on)) => {
                work::set_view_flag(&self.shared(), crate::homecard::PLAIN, !on);
                crate::homecard::now();
                Ok(())
            }
            (_, v) => sioul_core::settings::change(&config_path(), &key, shown.as_ref(), &v),
        });
        if let Err(e) = result {
            return QString::from(&e);
        }
        // What the setting changes is shown again.
        let (qt, shared) = (self.qt_thread(), self.shared());
        if let Some(project) = key.strip_prefix("project.").and_then(|k| k.strip_suffix(".routes")) {
            retie_project(project.to_string());
        }
        // A list, a calendar, an address book renamed or deleted: told to the server now.
        if key == "collections"
            && let Some(account) = serde_json::from_str::<serde_json::Value>(&value.to_string()).ok().and_then(|v| v["from"].as_str().and_then(|f| f.split('/').nth(1)).map(str::to_string))
        {
            pim::nudge(&shared, &account);
        }
        // colour: the sites' colours travel with the reading's settings (docs/colour.md).
        if key.starts_with("reading.") || key == "theme" || key == "places_named" || key == "screen_colours" || key == "calmer_colours" {
            self.as_mut().set_reading(QString::from(&reading_json()));
        }
        if key.contains("fetch_minutes") {
            update_paces(&shared);
        }
        // Hours or days off changed: what the time is for now, and what the Porch asks.
        if key.starts_with("window") || key == "time_off" {
            self.as_mut().set_mode(QString::from(&mode_json()));
        }
        if key.starts_with("mail.") {
            mail::show_mail(&qt, &shared);
        }
        // GitHub: started, brought again, or stopped.
        if key.starts_with("github") {
            if load_config().github.enabled {
                crate::github::start(&qt, &shared);
            } else {
                crate::github::stop(&shared);
            }
        }
        show(&qt, &shared);
        pim::show_pim(&qt, &shared);
        work::show_work(&qt, &shared);
        QString::default()
    }

    fn forced_theme(&self) -> QString {
        QString::from(&std::env::var("SIOUL_THEME").unwrap_or_default())
    }

    fn set_realtime_mode(mut self: Pin<&mut Self>, on: bool) {
        let shared = self.shared();
        shared.realtime.store(on, Ordering::Relaxed);
        shared.opened_anyway.store(on || shared.opened_anyway.load(Ordering::Relaxed), Ordering::Relaxed);
        update_paces(&shared);
        self.as_mut().set_realtime(on);
        let line = tr().text(if on { "realtime-on" } else { "realtime-off" }, None);
        self.as_mut().set_status(QString::from(&line));
        show(&self.qt_thread(), &shared);
    }

    fn grab_phone(&self) -> bool {
        std::env::var_os("SIOUL_GRAB_PHONE").is_some()
    }

    fn grab_steps(&self) -> QString {
        let steps = std::env::var("SIOUL_GRAB_STEPS").unwrap_or_else(|_| "pages".into());
        // The other steps archive, delete and send mail, answer invitations:
        // against test servers, from the test build only. "demo", "phone" and
        // "drag" take pictures alone; "taskform" makes tasks and rates them, "review"
        // closes the day with its review (docs/reviews.md), "site-open", "site-quit" and
        // "site-during" open the test site, close its pages and the window
        // (tools/check-sites.py quit), "site-share" shares its screen (tools/check-sites.py share),
        // "site-devices" changes the devices of its calls (tools/check-sites.py devices),
        // colour: "site-colour" takes its pictures in the screen's colours (tools/check-colour.py),
        // "rail" shows the places with their icons alone and with their
        // names (main.qml), "pauses" free time and the pause (docs/pauses.md), "blocks" a task pinned to a
        // time and left to the plan again (docs/tasks.md), "unsubscribe" a newsletter open
        // with its Unsubscribe button (docs/client.md), "attention" what reaches you, by time,
        // by person, Sioul's own, its exceptions and do not disturb, and a person's sheet
        // (docs/attention.md), "line" the status line with all it
        // may hold, a new draft deleted and taken back (docs/design.md), "share-panel" the
        // sharing's tab before sharing, its two ways (docs/database.md), "share-send" sharing
        // started in the profile, the build, the send's switch and "Send everything again",
        // then "Stop sharing" asking first, cancelled (docs/database.md), "spam" the spam
        // filter's settings and the words it puts beside mail (docs/spam-filter.md), "mail-search" the
        // search by conditions, its results, a selection held over a folder (docs/client.md), "mail-filters"
        // the mail filters in Mail's ⚙, their editor, a run's preview, a search made a filter, "security-key"
        // the setup of the demo's software security key and a message signed at Send with it (docs/client.md),
        // "calls" the calls a phone declined on a computer's Porch and a person's calls of the month (docs/porch.md),
        // "words" Settings ▸ Words, a line's lists changed and taken back (docs/words.md),
        // "health-gpg" a prescription's medicines and their takes as rows, and the security key's
        // GnuPG steps as buttons with their commands to copy (docs/health.md, docs/client.md),
        // "movetask" one of the demo's tasks moved to its other list (docs/tasks.md), "compose"
        // the writing window, an answer and a new message, its drafts made and deleted (docs/building.md),
        // "texts" the Texts page, its conversations and a text's states (docs/texts.md),
        // "ai" Settings ▸ AI agents, a project opened to agents on its page, an agent's text
        // draft in the Texts page used, nothing sent (docs/mcp.md),
        // "health" the Health page, its week, its settings (⚙), a block's menu and its change
        // for one day, closed unsaved (docs/health.md), "tiles" the costs as tiles in a task's
        // form, an event's and "How was it?", at three widths (docs/capacity.md), "attachments"
        // a message's attachments unfolded, a phone's words with "phone", nothing opened (docs/client.md),
        // "projects-file" the projects' file under its first name renamed from Settings
        // (make-demo.py --old-projects, docs/notes-folder.md), "memory" every page as "pages" opens
        // them, then the profile's sites, held at each moment measured (tools/measure-memory.py),
        // "bitwarden-wait" the unlock dialog waiting for Bitwarden, then its answer (no account
        // set: no server asked), "tray" the window hidden as to the tray and brought back,
        // "notes-shared" a note changed on another device while shown, read then typed in
        // (docs/database.md, "Notes"), on a demo profile only.
        if cfg!(feature = "insecure-test-tls") || steps == "demo" || steps == "phone" || steps == "drag" || (["taskform", "review", "site-open", "site-quit", "site-during", "site-share", "site-devices", "site-colour", "rail", "pauses", "blocks", "unsubscribe", "attention", "line", "share-panel", "share-send", "spam", "mail-search", "mail-filters", "security-key", "health-gpg", "calls", "words", "movetask", "compose", "texts", "ai", "health", "tiles", "attachments", "projects-file", "memory", "bitwarden-wait", "tray", "notes-shared"].contains(&steps.as_str()) && offline()) {
            return QString::from(&steps);
        }
        QString::from("pages")
    }
}

// Sharing, part by part, and the versions kept before other devices' changes (`share`).
impl qobject::Sioul {
    fn set_notes_carried(self: Pin<&mut Self>, carried: bool) -> QString {
        QString::from(&crate::share::set_notes_carried(carried))
    }

    fn set_share_part(self: Pin<&mut Self>, part: &QString, on: bool) -> QString {
        let problem = crate::share::set_part(&part.to_string(), on);
        if problem.is_empty() {
            crate::share::exchange(&self.qt_thread(), &self.shared());
        }
        QString::from(&problem)
    }

    fn share_history(self: Pin<&mut Self>, filter: &QString) {
        let (qt, filter) = (self.qt_thread(), filter.to_string());
        std::thread::spawn(move || {
            let listed = crate::share::history(&filter);
            let _ = qt.queue(move |mut sioul| sioul.as_mut().share_listed(QString::from(&listed)));
        });
    }

    fn share_put_back_preview(&self, part: &QString, file: &QString, stamp: &QString) -> QString {
        QString::from(&crate::share::put_back_preview(&part.to_string(), &file.to_string(), &stamp.to_string()))
    }

    fn share_put_back(self: Pin<&mut Self>, part: &QString, file: &QString, stamp: &QString) {
        let (qt, shared) = (self.qt_thread(), self.shared());
        let (part, file, stamp) = (part.to_string(), file.to_string(), stamp.to_string());
        // Off the window's thread: it waits for an exchange running, and copies a file whole.
        std::thread::spawn(move || {
            // Your calendar's item or contact set aside: written back, then sent by its account's sync.
            let problem = if part == sioul_sync::history::ACCOUNTS {
                match crate::share::put_back_item(&file, &stamp) {
                    Ok(account) => {
                        crate::pim::nudge(&shared, &account);
                        String::new()
                    }
                    Err(e) => e,
                }
            } else {
                crate::share::put_back(&part, &file, &stamp)
            };
            let said = if problem.is_empty() { crate::share::put_back_said(&file, &stamp) } else { String::new() };
            let store = crate::share::store_of(&file);
            let done = problem.clone();
            let _ = qt.queue(move |mut sioul| {
                if !said.is_empty() {
                    sioul.as_mut().set_status(QString::from(&said));
                    // The pages showing it read it again.
                    sioul.as_mut().shared_in(QString::from(&store));
                }
                sioul.as_mut().share_put_back_done(QString::from(&done));
            });
            if problem.is_empty() {
                crate::work::show_work(&qt, &shared);
                crate::share::exchange(&qt, &shared);
            }
        });
    }

    fn share_confirm_gone(self: Pin<&mut Self>, store: &QString) -> QString {
        let problem = crate::share::confirm_gone(&store.to_string());
        if problem.is_empty() {
            crate::share::exchange(&self.qt_thread(), &self.shared());
        }
        QString::from(&problem)
    }

    fn share_estimate(self: Pin<&mut Self>, part: &QString) {
        let (qt, part) = (self.qt_thread(), part.to_string());
        std::thread::spawn(move || {
            let counted = crate::share::estimate(&part);
            let _ = qt.queue(move |mut sioul| sioul.as_mut().share_estimated(QString::from(&counted)));
        });
    }

    fn spam_status(&self) -> QString {
        QString::from(&crate::spam::status())
    }

    fn spam_train(self: Pin<&mut Self>) -> QString {
        QString::from(&crate::spam::train(self.qt_thread(), self.shared()))
    }

    fn spam_stop(self: Pin<&mut Self>) {
        crate::spam::stop(self.qt_thread());
    }

    fn mail_filters(&self) -> QString {
        QString::from(&crate::filters::view())
    }

    fn set_mail_filters(self: Pin<&mut Self>, filters: &QString, shown: &QString) -> QString {
        QString::from(&crate::filters::save(&filters.to_string(), &shown.to_string()))
    }

    fn mail_filter_said(&self, filter: &QString) -> QString {
        QString::from(&crate::filters::said(&filter.to_string()))
    }

    fn mail_filter_try(self: Pin<&mut Self>, filter: &QString) {
        crate::filters::try_one(self.qt_thread(), filter.to_string());
    }

    fn mail_filters_preview(self: Pin<&mut Self>) {
        crate::filters::preview(self.qt_thread());
    }

    fn mail_filters_run(self: Pin<&mut Self>) -> QString {
        QString::from(&crate::filters::run(&self.qt_thread(), &self.shared()))
    }

    fn new_mail_filter(self: Pin<&mut Self>, given: &QString) -> QString {
        QString::from(&crate::filters::new_from(&given.to_string()))
    }

    fn set_share_backup(self: Pin<&mut Self>, on: bool) -> QString {
        let problem = crate::share::set_backup(on);
        // Looked for and fetched with the exchange, off the window's thread.
        if problem.is_empty() {
            crate::share::exchange(&self.qt_thread(), &self.shared());
        }
        QString::from(&problem)
    }

    fn set_share_send(self: Pin<&mut Self>, on: bool) -> QString {
        let problem = crate::share::set_send(on);
        // Switched on: what changed here goes with the next exchange, now.
        if problem.is_empty() && on {
            crate::share::exchange(&self.qt_thread(), &self.shared());
        }
        QString::from(&problem)
    }
    fn share_send_again(self: Pin<&mut Self>) {
        crate::share::send_again(&self.qt_thread(), &self.shared());
    }
    fn share_backup_place(self: Pin<&mut Self>, place: &QString) -> QString {
        let problem = crate::share::set_backup_place(&place.to_string());
        if problem.is_empty() {
            crate::share::exchange(&self.qt_thread(), &self.shared());
        }
        QString::from(&problem)
    }

    fn start_sharing_on_server(self: Pin<&mut Self>, account: &QString, place: &QString, passphrase: &QString, again: &QString) {
        crate::share::start_on_server(&self.qt_thread(), &self.shared(), account.to_string(), place.to_string(), passphrase.to_string(), again.to_string());
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn file_addresses_reach_the_file() {
        assert_eq!(file_url(Path::new("/tmp/Réunion #2 100%.pdf")), "file:///tmp/R%C3%A9union%20%232%20100%25.pdf");
        assert_eq!(local_path(&file_url(Path::new("/tmp/Réunion #2 100%.pdf"))), PathBuf::from("/tmp/Réunion #2 100%.pdf"));
        assert_eq!(local_path("file://localhost/tmp/a%20b"), PathBuf::from("/tmp/a b"));
        assert_eq!(local_path("/tmp/plain"), PathBuf::from("/tmp/plain"));
        // Windows' forms, both ways.
        assert_eq!(windows_slashed(r"C:\Users\me\a b.pdf"), "/C:/Users/me/a b.pdf");
        assert_eq!(windows_slashed(r"\\?\C:\Users\me"), "/C:/Users/me");
        assert_eq!(windows_slashed(r"\\server\share\a"), "//server/share/a");
        assert_eq!(windows_slashed(r"\\?\UNC\server\share\a"), "//server/share/a");
        assert_eq!(windows_path("/C:/Users/me/a b.pdf"), r"C:\Users\me\a b.pdf");
        assert_eq!(windows_path("server/share/a"), r"\\server\share\a");
    }

    #[test]
    fn programs_are_not_opened() {
        for name in ["setup.exe", "Facture.PDF.exe", "invoice.exe.", "invoice.exe ", "run.sh", "x.desktop", "a.lnk", "b.js", "c.terminal", "d.iso"] {
            assert!(sioul_core::links::is_program(name), "{name}");
        }
        for name in ["facture.pdf", "photo.jpeg", "notes.txt", "archive.zip", "exe", "README"] {
            assert!(!sioul_core::links::is_program(name), "{name}");
        }
    }

    #[test]
    fn new_sentences_read_in_both_languages() {
        for language in ["en", "fr"] {
            let tr = Translator::new(language);
            for id in ["attachment-program", "budget-origin-mail", "budget-origin-hand", "note-outside-notes", "setting-unknown-key", "reminders-entry-name", "reminders-entry-comment", "bank-rule-gone", "budget-line-gone", "mail-no-such-folder", "mail-not-in-accounts", "mail-move-needs-to", "list-read-only-mark", "import-bad-key"] {
                assert_ne!(tr.text(id, None), id, "{language}: {id}");
            }
        }
    }

    #[test]
    fn attachment_names_stay_in_their_folder() {
        assert_eq!(one_file_name("a/b\\c.pdf"), "a_b_c.pdf");
        assert_eq!(one_file_name(".."), "attachment");
        assert_eq!(one_file_name(""), "attachment");
        if cfg!(windows) {
            assert_eq!(one_file_name("C:evil.txt"), "C_evil.txt");
            assert_eq!(one_file_name("con.txt"), "_con.txt");
        } else {
            assert_eq!(one_file_name("C:evil.txt"), "C:evil.txt");
        }
    }
}