R3 two-factor in decePub: an authenticator app set up in Settings, its code asked for at sign-in

Completion program R3, with PrivaPub's TOTP routes of the same release.

- Settings, the login: TotpEditor turns two-factor sign-in on (the password, then the QR code, the secret and the
  otpauth:// link, then the app's first code; the ten recovery codes shown once with Copy), shows how many recovery
  codes are left (warned at three), and turns it off with the password and a code, asked first.
- Turning it on, like a password change, ends every other session: AuthService.ContinueSession takes the new JWT and
  exchanges the persona's token again.
- Sign-in: PrivaPub's 428 keeps the name and password and asks for the six digits (DOtp), or a recovery code instead;
  a wrong code says so; Back returns to the password.
- window.copyText (main.js) through AppStatusService.CopyText.
- 29 keys in both resx files; CLAUDE.md follows.

Verified: dotnet build decePubClient.csproj -c Release (0 errors, no new warnings).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WpVCoDeM1qUTRp4fXQdfof

.gitea/workflows/deploy.yml

@@ -55,6 +55,9 @@ jobs:
             [ -e "$W/$f" ] || { echo "::error::publish output is missing $f"; exit 1; }
           done
           ls "$W/_framework" | grep -q '\.wasm$' || { echo "::error::no .wasm in _framework"; exit 1; }
+          for f in appsettings.Development.json appsettings.Pasture.json; do
+            [ ! -e "$W/$f" ] || { echo "::error::publish output holds $f, which points the app at a test server"; exit 1; }
+          done
           echo "publish OK, $(du -sh "$W" | cut -f1)"
 
       - name: Snapshot the live directory

.gitignore

@@ -367,3 +367,4 @@ FodyWeavers.xsd
 # Tailwind standalone + daisyUI downloads (tools/tailwind.sh) and the CSS they generate
 .tools/
 wwwroot/css/app.css
+

CLAUDE.md

@@ -14,8 +14,6 @@ columns: navigation, the feed with a tab per kind of feed, and a 3D globe that f
 in tooltips wherever there is data. Development builds point at a local PrivaPub on `http://127.0.0.1:6970`
 (`wwwroot/appsettings.Development.json`, never published).
 
-`Docs/Insomnia_APIs.json` is an old API collection for a localhost backend. Don't treat it as PrivaPub's API.
-
 ## Sibling repo dependency
 
 The project references `../SocialPub/PrivaPub.ClientModels/PrivaPub.ClientModels.csproj`, so SocialPub must be
@@ -43,7 +41,23 @@ dotnet run                                             # dev server: https://loc
 dotnet publish decePubClient.csproj -c Release -o publish   # static site lands in publish/wwwroot
 ```
 
-`global.json` pins SDK 10.0.100 with `rollForward: latestFeature`. There are no tests and no linter.
+`global.json` pins SDK 10.0.100 with `rollForward: latestFeature`. There is no linter.
+
+## Verifying
+
+There is no test project (owner decision 2026-10-17: `tests/e2e` was removed, as was SocialPub's `PrivaPub.Tests`). Don't
+add one back unless asked. Verify by building, running against a local PrivaPub, and in SocialPub's pasture:
+
+```sh
+dotnet publish decePubClient.csproj -c Release -p:WasmApplicationEnvironmentName=Pasture -o publish
+../SocialPub/tools/pasture/run.sh up gts decepub   # serves publish/wwwroot as https://decepub.test (peers/decepub.sh)
+```
+
+- Blazor on .NET 10 ignores the `Blazor-Environment` header, so the environment is chosen at publish time:
+  `wwwroot/appsettings.Pasture.json` (API `https://privapub.test`) is published only then, and the deploy fails if it
+  ever ships.
+- A browser reaches `*.test` through the pasture's Caddy on `127.0.0.1:6443` (Chromium: `--host-resolver-rules="MAP *.test
+  127.0.0.1:6443"`), and must accept the pasture's CA.
 
 ## CSS: Tailwind 4 + daisyUI 5, vendored, offline
 
@@ -67,7 +81,7 @@ without network access. NuGet restore still uses nuget.org.
   clean-clone publish would ship `app.css` without its `.gz`/`.br` copies and outside `service-worker-assets.js`.
   The deploy workflow checks for `css/app.css.gz`.
 - `bash tools/tailwind.sh watch` rebuilds the CSS live next to `dotnet watch`.
-- Tailwind scans every file `.gitignore` doesn't exclude (minus `tools/`, `wwwroot/vendor/`, `Docs/`), and only
+- Tailwind scans every file `.gitignore` doesn't exclude (minus `tools/` and `wwwroot/vendor/`), and only
   generates the classes it finds written out **whole**. Never build a class name by concatenation or interpolation (`"btn-" + size`, `$"btn-{size}"`). Write
   every variant as a literal, e.g. in a switch arm.
 
@@ -87,6 +101,14 @@ Ionicons 4.5 (`wwwroot/vendor/ionicons.min.css`, `<i class="ion-md-...">`) is lo
   - picking a hue leaves grey.
 - `AppStatusService.IsDarkTheme()` tells which variant is showing.
 - Settings → General edits every theme setting. NavMenu's toggle and slider are shortcuts to the dark and hue ones.
+  The other sections of Settings belong to the login or the persona (see **Settings** under PrivaPub wiring).
+- **The theme is the login's** while `PageSettings.SyncWithLogin` is on (the default; Settings → General turns it off
+  for this device). `CascadingState` takes the login's theme (`ViewUserSettings`; never its language, which would reload
+  the app) at sign-in from the `JwtUser` (`SignedIn`, which Login, Setup and Join call instead of `LoadSession`) and at
+  start-up from `/clientapi/user/settings`, once `savedAt` says a client saved one; while none did, it gives the login
+  this device's. `UpdatePageSettings` saves them to `/clientapi/user/update/settings` 1.5 s after the last change, one
+  save waiting at a time, only when they differ from what the login is known to keep (so taking them never sends them
+  back), with the language as two letters and the icons' hue at 25; a failure is logged, never shown.
 - `Styles/neo.css` holds the neumorphic layer:
   - `neo-raised` / `neo-inset` / `neo-flat`, with sizes `neo-2xs` / `neo-xs` / `neo-sm` / `neo-md` (these replace the
     old `neomorph is-nxsmall` classes);
@@ -95,9 +117,62 @@ Ionicons 4.5 (`wwwroot/vendor/ionicons.min.css`, `<i class="ion-md-...">`) is lo
     in sublayers of `utilities`, so these overrides beat **every** daisyUI rule. Each override must exclude the
     daisyUI variants it shouldn't touch, e.g. `:not(:where(.btn-ghost, .btn-link, ...))`, and call sites drop a neo
     shadow with `shadow-none!`.
+  - Selectors are an inset well; a checked checkbox is filled and raised like a primary button (daisyUI fills one only
+    for a colour variant, and without one drew a tick on nothing), and a checked radio's dot is the primary colour. A
+    file input's own button (Choose File, Browse…) is raised like the app's buttons.
 - Never write `@utility collapse`. It brings back Tailwind's own `collapse` utility (`visibility: collapse`), and
   every collapse disappears.
 
+## Phones
+
+Below `md` the app is laid out for a phone, and a touch screen gets thumb-sized targets. The rules:
+- **Width and pointer are separate.**
+  - Layout differences between a phone and a desktop use the width variants at the call site (`max-md:`, `md:`).
+  - How big a thing is to a finger uses the pointer: `Styles/touch.css` under `@media (pointer: coarse)`, and
+    `pointer-coarse:` at a call site.
+  - A mouse matches none of it, so desktop keeps daisyUI's sizes.
+  - A window at most 30rem tall (a phone held sideways) is the `short:` variant.
+- **`touch.css`** is plain CSS in Tailwind's utilities layer, so like `neo.css` it beats daisyUI's sublayers. It sets
+  daisyUI's own size variables:
+  - buttons, tabs, inputs, selects and file inputs are 44px tall;
+  - extra small buttons and the badges that act are 36px, with a transparent `::after` that reaches 44 (5px around
+    the padding box);
+  - checkboxes and radios are 24px, toggles and range thumbs 28;
+  - field text is 16px, so iOS doesn't zoom into a focused field.
+
+  Its `touch-target` utility gives a small link or button a 44px hit area. It can't be used on something that clips
+  its own overflow (a `truncate`d name takes `pointer-coarse:py-3.5` instead), nor on a daisyUI tooltip, which draws
+  its arrow with `::after` (NerdTip takes minimum sizes).
+- **Every target has a 44px hit area on touch,** with 8px between targets in a row (`pointer-coarse:gap-2`).
+- **Overlays on a phone rise from the bottom.**
+  - `DModal Placement="ResponsiveBottom"` is a sheet below md and a centred dialog from md. Every DModal has a visible
+    close button (`ShowClose`, named by `CloseText`).
+  - `DDropdown SheetOnNarrow` turns its content into a bottom sheet.
+  - `Components/PhoneSheet.razor` shows what opens in place on a desktop (the composer, a reply, a quote, an edit) as a
+    sheet on a phone.
+  - All are capped by `dvh`, and the app itself is `h-dvh`.
+- **The Back button closes the newest open overlay** instead of leaving the page.
+  - Overlays register through `IDOverlayHost` (`Components/Daisy`, cascaded from `MainLayout`):
+    - `DModal` and `DDropdown` through the cascade;
+    - the nav menu, `PhoneSheet` and the full-screen globe through `Services/OverlayService.cs`.
+  - `main.js` marks a real Back press (a capture-phase `popstate`), since Blazor can't tell it from the app's own
+    navigation, which closes every overlay and goes on.
+  - No history entries are pushed.
+- **What can't be undone asks first** through `Services/ConfirmService.cs` (`Ask`, shown by `ConfirmHost` in
+  `MainLayout`): deleting a post, taking it off a wall, muting, blocking, leaving a group, dropping a scheduled post and
+  signing out.
+- **On a touch screen:**
+  - a tap on a post opens its thread (`main.js`, `data-thread` on the card, its `data-thread-link`), and cards are
+    pinned to the globe with a mouse only;
+  - a tap on a nerd-stats trigger opens its rows in a sheet (`NerdTip`, `AppStatusService.CanHover`);
+  - pictures open in `Components/MediaViewer.razor`.
+- **The feed on a phone:**
+  - a card's actions are five equal cells (Reply, Boost, Favourite, React, More). Bookmark, the thread and the nerd
+    stats' Details are in More, and the author's picture is in the header;
+  - a new post starts from a floating button;
+  - the globe's banner opens full screen, and a phone held sideways opens it full screen from the tabs;
+  - the feed tabs show their names and fade at the edge where more wait (`edge-fade-x`, `data-scroll-x`).
+
 ## daisyUI Blazor components (`Components/Daisy/`)
 
 Every daisyUI component has a `D`-prefixed wrapper (`DButton`, `DModal`, `DDropdown`, `DInput`, ...), grouped by
@@ -144,7 +219,7 @@ supplies:
 - `AfterRenderAsyncJobs`, run once after the next render;
 - `WhenOnline` / `StartOnlinePolling`.
 
-`PagesBase` is an empty subclass of it that nothing uses. Never redeclare the base's members in a component.
+Never redeclare the base's members in a component.
 
 **UI feedback.**
 - `Services/ToastService.cs` is the snackbar: the SUtility extensions `AddResponseError(WebResult)` (silent on
@@ -153,6 +228,7 @@ supplies:
   messages.
 - `Components/ErrorViewer.razor` shows in-page errors: the cascading `EditContext`'s validation messages,
   `AdditionalError` and `AdditionalErrors`.
+- `ConfirmService` asks before what can't be undone (see **Phones**).
 
 **HTTP (`Services/IHttpService.cs`).**
 - Routes are constants in `Models/APIs.cs` (b2b.next naming: `GET_`/`POST_`/`DELETE_`, `_M_` for routes built from
@@ -162,10 +238,12 @@ supplies:
 - It also picks the JSON: `SUtility.MastodonSerializer` (snake_case, `MastodonJsonContext`) for `api/` and `oauth/`,
   `SUtility.DefaultSerializer` (camelCase, enums by name like PrivaPub, `ClientJsonContext`) for `clientapi/`. A payload
   can be an object (JSON), name/value pairs (a form) or a `Func<HttpContent>` (multipart), built once per attempt.
-- Auth levels: `Get` / `Post` / `Delete` need credentials and end the session when PrivaPub refuses them; `GetAnon` /
-  `PostAnon` add them when there are some; `*TotallyAnon` send none (the login must not carry a JWT: PrivaPub
-  redirects it).
+- Auth levels: `Get` / `Post` / `Put` / `Patch` / `Delete` need credentials and end the session when PrivaPub refuses
+  them; `GetAnon` adds them when there are some; `*TotallyAnon` send none (the login and the password recovery must
+  not carry a JWT: PrivaPub redirects them).
 - `retryOnError` backoff: 1, 2, 4, 8, 16, 29 s, then 60 s, for at most 10 minutes.
+- Each request has its own timeout (`Measure`): 100 s, or 10 minutes for a multipart body (an upload); the
+  `HttpClient`'s own is off.
 - Failures never throw. They come back as responses carrying an invalid `WebResult`, with an `ErrorCode` from
   `Models/FailureCodes.cs`; a cancelled request comes back as HTTP 410.
 - Read failures with `ReadWebResult` (it understands `WebResult`, validation ProblemDetails and Mastodon's
@@ -179,12 +257,156 @@ supplies:
 - **One sign-in** (`Services/AuthService.cs`, `Pages/Login.razor`): the root signs in on `/clientapi/user/login`, then
   each persona the client uses gets its own Mastodon token in exchange for the JWT (PrivaPub's `PersonaExchange`,
   RFC 8693 on `/oauth/token`, first-party client id `AppConfiguration:ClientId`). `AuthData` keeps the JWT and the
-  persona tokens; logout revokes every persona token, then forgets the session and IndexedDB.
+  persona tokens; logout revokes every persona token, ends this device's session (`/clientapi/user/logout`), then
+  forgets the session.
+  - **Sessions:** "Sign out everywhere" (`AuthService.LogoutEverywhere`, `/clientapi/user/logout/everywhere`) ends every
+    session of the login, this one too, and PrivaPub revokes every persona's token with them, so the client only forgets
+    its own and signs out. A password change, and turning two-factor sign-in on, end every other session and revoke every
+    persona token, this device's too: `AuthService.ChangePassword` and `TotpEnable` keep the new `JwtUser` PrivaPub
+    answers with (`ContinueSession`), drop the stored persona tokens and exchange one for the current persona at once
+    (the others when next used), so the device stays signed in.
+  - **Two-factor sign-in** (TOTP, `/clientapi/user/totp/*`): with it on, a right password is answered with a 428
+    (`AuthService.NeedsOneTimeCode`). Login keeps the name and the password in the form, out of sight, and sends it again
+    with `LoginForm.OneTimeCode`: the authenticator app's six digits (`DOtp`, `data-login-code`) or, after "Use a recovery
+    code instead", a recovery code like `abcde-fghjk` (a text field, `data-login-recovery`). A wrong code is a 400, like a
+    wrong password, with PrivaPub's message. It is turned on and off in Settings (`TotpEditor`, see **Settings**).
+- **The ways in** (sign-up is closed on PrivaPub; owner decision 2026-10-16):
+  - **Setup** (`Pages/Setup.razor` at `/setup`): while PrivaPub has no administrator (`/clientapi/user/setup`), the first
+    login is made there, first come, first served, with its first persona. It becomes the administrator, and setup
+    closes for good. Login offers it while it waits.
+  - **Invitations** (`Pages/Join.razor` at `/join?code=`): a group's invitation makes a login whose first persona joins
+    the group (`/clientapi/user/invitation/signup`). Login links there, and a group's page shows the link with its code.
+  - Both sign in at once like Login (`AuthService.SetUp` / `Join`, sent with no credentials). A login without a
+    persona is sent from Login to Settings to make one.
+  - **A forgotten password** (`Pages/PasswordRecovery.razor` at `/password-recovery`, linked from Login): the login's
+    name or its address asks for a link (`/clientapi/user/recover/password`), and the page shows PrivaPub's answer, the
+    same sentence for everyone, so it never tells whether a login or an address exists. PrivaPub mails only a verified
+    address. The link comes back as `/password-recovery?rc=`: the page keeps the code, takes it out of the address bar
+    and the history at once (`replace`), checks it (`/recover/valid`, the code as a JSON string), and sets the new
+    password with it (`/recover/update/password`), which ends every session of the login; then the reader signs in.
+    All of it goes with no credentials.
 - **Services** (`Services/`): `TimelineService` (every feed as `FeedPage`s of `FeedPost`s, paged by `max_id`/`min_id`;
   circles are read as ids from `/clientapi` and hydrated through `/api/v1/statuses?id[]=`; located posts come from
   `/clientapi/post/nearby` and have no Mastodon actions), `StatusService` (publish, favourite, boost, bookmark, delete,
-  threads, mute, block; located and group posts go through `/clientapi/post/insert`), `MediaService` (uploads),
-  `GroupService`, `InstanceService` and `ProvenanceService`.
+  threads, mute, block, poll votes, emoji reactions through Pleroma's `/api/v1/pleroma/statuses/:id/reactions`, joining and
+  leaving remote events through `/api/privapub/v1/statuses/:id/join|leave`; located and group posts go through
+  `/clientapi/post/insert`, and a located post's author deletes it through `/clientapi/post/delete`, its card's one action), `AccountService` (profiles, relationships, follow,
+  block, mute, follow requests, `/api/v2/search`, whose handles and URLs PrivaPub resolves), `ListService` (the
+  persona's lists and their members; members are only accounts it follows, found with `accounts/search?following=true`),
+  `FilterService` (the persona's v2 filters, their keywords and filtered posts), `DiscoveryService` (hashtags and
+  following them, trends, the directory), `PortabilityService` (Mastodon's CSV exports and imports), `AdminService`
+  (`/clientapi/moderator` and `/clientapi/admin`), `MediaService` (uploads), `GroupService`, `InstanceService` and
+  `ProvenanceService`.
+- **Reactions and votes are public** (owner decision, PrivaPub's ROADMAP): before a persona's first reaction or poll
+  vote, `PublicNoticeService` asks it once (`PublicNoticeHost` in `MainLayout`) and remembers the persona in
+  localStorage (`PublicActionNotices`). Anything else that makes a persona's act visible to others gets the same notice,
+  with its own `PublicAct`: joining an event (owner decision 2026-10-05) is asked once more, since the event's server
+  shows who takes part. An event card shows the persona's participation (`privapub.event.participation`: pending,
+  accepted, rejected) with Join or Leave, except for events by invitation or taken on another site (`join_mode`).
+- **What a card shows of other platforms:** custom emoji (`Helpers/CustomEmojis.cs`: a post's or account's `:shortcode:`
+  in its text, name, warning, bio and fields, as the picture the server listed, never inside a tag), a threadiverse
+  post's downvotes next to its favourites, blurhash placeholders until a picture loads (`wwwroot/js/blurhash.js`
+  paints any `[data-blurhash]`: a picture's until it loads, again when its source changes, and for good behind the
+  sensitive-media button), a picture's focal point (`object-position`), and an event's online link, participants and
+  status. A picture, video or sound that fails to load says "Media unavailable" with "Open original"
+  (`data-media-unavailable`), and a gifv plays only on a tap under `prefers-reduced-motion`.
+- **Profiles and search** (`Pages/Profile.razor` at `/account/{id}`, `Pages/Search.razor` at `/search?q=`): a card's
+  author and a notification's account open the profile in the app; "Open original" is the only way to the remote site.
+  A profile shows the posts the account pins above its posts (`pinned=true`: what an account elsewhere features); the
+  persona pins and unpins its own public and unlisted posts from the card's menu.
+  An account that moved says where to (`Account.Moved`, which PrivaPub fills once the new account names the old one),
+  linking the new account's profile.
+  Another's profile and posts can be reported (`Components/ReportDialog.razor`, `/api/v1/reports`): a category, words,
+  and for a remote account a copy to its server, which PrivaPub sends from its own actor, never naming the persona.
+  Who liked or boosted a post opens from its card's menu (`Components/InteractedByDialog.razor`).
+- **Walls** (Smithereen's, FEP-400e): a post written on someone's wall says whose (`privapub.wall`, `data-wall`, linking
+  that profile); one written on the persona's own wall is taken off from the card's menu (`DELETE` on the status, which
+  PrivaPub turns into a `Remove` that Smithereen takes for a deletion). Only the persona's followers may write there.
+  A card in a fixed-height flex column with `overflow-hidden` needs `flex-none`, or it collapses to nothing.
+- **Groups** (`Pages/Groups.razor` at `/groups`): the persona's communities and circles (`GroupService`, `/clientapi/group`):
+  made (a circle unless it is a community, with an invitation code and an optional password), joined by invitation and
+  left; the ones it runs edited, their invitation shown, the requests to join let in or declined, members taken out.
+  Only a group's owner and moderators see who is in it.
+- **Lists** (`Pages/Lists.razor` at `/lists`): made, renamed, given a replies policy and made exclusive (their members
+  leave the home feed) there, filled from the accounts the persona follows; a followed account's profile has a Lists
+  menu too. A list is read as the feed's Lists tab (`FeedFilter.ListId`). Lists never leave PrivaPub.
+- **Filters** (`Pages/Filters.razor` at `/filters`, linked from Settings): PrivaPub marks every status with the filters it
+  matches (`Status.Filtered`), whatever their context; a page tells each card where it is (`Content.FilterIn`: home and
+  lists, notifications, public feeds, threads around the opened post, profiles; none for favourites, bookmarks,
+  conversations and search), and the card leaves the post out (hide), folds it behind the filter's title (warn) or blurs
+  its media (blur).
+- **Articles** fold in a feed (`Content.IsFoldedArticle`): an Article or a Page with its title, or a titled post longer
+  than a few paragraphs (WriteFreely sends Notes with a name), shows its cover, its excerpt and a Read button; the
+  post opened in its thread shows whole.
+- **The composer** (`Components/Composer.razor`) writes a post, a reply (`InReplyTo`), a quote (`Quoting`, offered on a
+  card when the server says the persona may quote it) or an edit of the persona's own post (`Editing`); a post can hold
+  a poll instead of media.
+  - **Media are uploaded as soon as they are picked** (`Services/MediaService.cs`, `Models/UploadMedia.cs`):
+    - each is streamed from the browser's file, and only a 320 px thumbnail (`RequestImageFileAsync`) is kept to show it;
+    - each shows its state (`data-upload-state`: uploading, processing, ready, or failed with Retry);
+    - audio and video PrivaPub answers 202 for are followed (`GET /api/v1/media/:id`, 206 until ready);
+    - the ids are kept, so a post that fails never uploads its media again;
+    - the types and sizes accepted are PrivaPub's own (`/api/v2/instance`, `MediaService.Limits`);
+    - a description changed after the upload is PUT before the post.
+  - **Alt text:** publishing a picture without a description asks once (`data-alt-reminder`, "Publish anyway"), unless
+    the reader turned `PageSettings.RemindAltText` off in Settings → General.
+  - **Edits send the whole post, as Mastodon wants it:** its words and warning from `/source`, its own language and
+    sensitive flag, the media it keeps or adds (`media_ids`; removing them all is `[]`), and the descriptions changed
+    (`media_attributes`). Its visibility and poll stay.
+  - A new post's media are sensitive when the persona's "always mark media as sensitive" (`source.sensitive`) says so.
+  A mention or hashtag being written at the end of the words is offered what PrivaPub already knows
+  (`/api/v2/search`, never resolving), once typing pauses.
+  An edited post's card says so, and its versions open from there (`/statuses/:id/history`, newest first; PrivaPub
+  keeps a remote post's earlier versions from its edits and from Pleroma's `formerRepresentations`).
+- **Threads** (`Pages/Thread.razor` at `/expand/{id}`): opening a remote thread makes PrivaPub read its replies
+  from their servers (its FEP-7888 `context`, else `replies`), so the page reads the thread again after 4 and 15 seconds
+  and adds what was found, in the thread's order.
+- **Interaction policies** (GoToSocial's, and FEP-5624's `canReply` on a PeerTube video whose comments are moderated): a
+  reply or boost whose target's author must approve it shows so on its card (`privapub.approval`: pending, then nothing
+  once approved, or rejected); one the policy shuts out is refused by PrivaPub (422) and shown as an error.
+- **Settings** (`Pages/Settings.razor`, `Components/Settings/`): the login itself (`AccountEditor`: its email address
+  (`/clientapi/user/account`), set only with the password and a 6-digit code mailed to the new address (`/user/email`,
+  then `/email/verify` through `DOtp`; the old `/user/update` is refused), shown verified or not and with an address
+  waiting for its code, and removed with the password (`/email/remove`); a wrong password is PrivaPub's 403, read as
+  such; its password changed; its two-factor sign-in (`TotpEditor`, a block of AccountEditor that reads the login itself:
+  turned on with the password (`/totp/setup`), which shows the secret as a QR image, as selectable text and as an
+  `otpauth://` link an authenticator app opens, then the app's first code (`/totp/enable`, a 409 once the hour-long
+  setup expired), after which the ten recovery codes are shown once, with Copy (`AppStatusService.CopyText`) and "I saved
+  them"; on, it shows how many recovery codes are left, warns from three down, and is turned off, asked first, with the
+  password and a code from the app or a recovery code (`/totp/disable`)); every session of it ended ("Sign out
+  everywhere", see **One sign-in**); or the whole of it
+  deleted, every persona with it, through `/clientapi/user/update/password` and `/clientapi/user/delete`; the client then
+  signs out), the persona's profile (`ProfileEditor`:
+  `update_credentials` as multipart, its words as written from `Account.Source`, pictures (streamed from the file,
+  and removed with `DELETE /api/v1/profile/avatar|header`), fields, locked, bot,
+  discoverable, indexable and posting defaults; the composer starts a new post at its default visibility), its mutes,
+  blocks and blocked servers (`MutesAndBlocks`), and `DataTransfer`: follows, lists, blocks, mutes, blocked servers
+  and bookmarks exported and imported as the CSV files Mastodon writes, so a persona moves between servers. An import
+  resolves each row through PrivaPub and acts one row at a time; it can be stopped. Above it, `PersonaArchivePanel`
+  (`ArchiveService`, `/clientapi/persona/{id}/archive`; owner decision 2026-10-07): the persona's whole archive made on
+  PrivaPub in Mastodon's layout and downloaded through a link; and an archive (its own, or Mastodon's) uploaded in pieces
+  by `js/transfer.js` and imported into it, the parts chosen (likes, located and scheduled posts off unless ticked),
+  with progress, a report and Stop. Imported posts are delivered to no one.
+- **Administration** (`Pages/Administration.razor`, `Components/Admin/`, for moderators): reports, then for
+  administrators the servers blocked for everyone, the federation statistics and the backups. PrivaPub has no admin list
+  of users, and adding an admin endpoint waits for the owner, so the Users section stays empty.
+- **Backups** (`Components/Admin/BackupsPanel.razor`, `/clientapi/admin/backups`; owner decision 2026-10-07): the server's
+  backups (nightly, before each deploy, made here, uploaded), with what runs and the last restore's report.
+  - A download asks for the password and gives a link good for ten minutes, a plain anchor, so the browser saves the tar
+    to disk.
+  - An upload never passes through .NET's memory: `wwwroot/js/transfer.js` PUTs `file.slice` pieces at the offset PrivaPub
+    has, and carries on from what PrivaPub says after a refused or lost piece.
+  - A restore asks for the password and the server's host typed out, and says what it means. PrivaPub stops, restores as
+    it starts again and ends every session, so the page shows it restarting until the ended session sends it to sign in.
+- **Notification policy** (`Components/Settings/NotificationPolicyEditor.razor`, in Settings and at `/notifications/filtered`):
+  what notifications from people the persona does not follow, people who do not follow it, new accounts, private
+  mentions it did not ask for and limited accounts become (accept, filter, drop; `/api/v2/notifications/policy`), and the
+  filtered ones, one request per account, let in (with that account from then on) or dismissed. The Notifications tab
+  links there while requests wait.
+- **Scheduled posts** (`Pages/Scheduled.razor` at `/scheduled`): the composer's clock button gives a Mastodon API post a
+  time (`scheduled_at`, at least five minutes ahead; located and group posts have none); the page moves or drops them.
+- **Explore** (`Pages/Explore.razor` at `/explore`): trending hashtags, posts and links (PrivaPub's, from public posts
+  it holds), the directory, and the hashtags the persona follows. A hashtag's feed tab follows it too.
 - **Mastodon DTOs** are client-side, in `Models/Mastodon/` (snake_case). `/clientapi` DTOs come from
   `PrivaPub.ClientModels`.
 - **Where a post is** (`InstanceService.Locate`, `Models/FeedPost.cs`): its own place (Pixelfed's, `privapub.place`),
@@ -195,35 +417,75 @@ supplies:
   are read on the first hover and kept for the session. PrivaPub's own host is the signed-in persona's account host,
   since the API may be reached under another name.
 - **The feed page** (`Pages/Index.razor`): `FeedTabs`, `Content` (the card, which does its own actions), `Composer`,
-  `GlobePanel`. Older pages load as the end comes near (`wwwroot/js/feed.js`); newer ones are polled every 45 s while
-  the page is visible (PrivaPub has no streaming) and wait behind a "new" button.
+  `GlobePanel`. Leaving it keeps the feed in `Services/FeedMemory.cs` (its posts, waiting posts, cursors and scroll,
+  ten minutes, for the same feed of the same persona), so coming back from a thread or a profile shows it again at once
+  without reading it anew. Older pages load as the end comes near (`wwwroot/js/feed.js`). Newer ones come through PrivaPub's
+  streaming API (`Services/StreamingService.cs`: one WebSocket, the persona's token as its protocol, never in a URL)
+  for home, lists, local, federated, hashtags and notifications, and wait behind a "new" button; a deletion or an edit
+  it tells applies at once. Other feeds, and any feed while the stream is down, are polled every 45 s while visible.
+  - **At volume:** the list is a `<Virtualize>` (only the cards near the view are rendered), and a card re-renders only
+    when its own events run or its render key changes (`Content.RenderKey`: the post, its status, notification,
+    conversation, place, grouping, where it is shown, the persona and the connection). Anything that changes what a
+    card shows from outside it must replace one of those objects or be added to the key; mutating one in place leaves the
+    card as it was. Without these a feed took seven minutes to reach a thousand cards and held 900 MB at two thousand.
 - **The globe** (`wwwroot/js/globe.js`, an ES module imported by `GlobePanel`) runs on globe.gl, vendored in
-  `wwwroot/vendor/globe/` with its textures (`SOURCES.md` has versions, licences and hashes; the service worker never
-  precaches it). It looks at the spherical mean of the located posts in view, pulses and draws an arc to a hovered
-  post, follows the theme (day/night texture), honours `prefers-reduced-motion` and pauses while hidden. CDN-fronted
-  posts are labels per CDN on a ring at 68°N, never a place; hovering one draws its arc there and a ring where the server
-  was before the CDN. The posts'
-  places reach it in one call per feed change; cards are matched by `data-post-id`.
+  `wwwroot/vendor/globe/` with its textures and `countries.json` (`SOURCES.md` has versions, licences and hashes; the
+  service worker never precaches it). It looks at the spherical mean of the located posts in view, pulses and draws an
+  arc to a hovered post, honours `prefers-reduced-motion`, and draws only while something moves (idle, it costs no GPU
+  time; `wake()` before anything that animates).
+  - **Map.** Each pixel computes its own map coordinates from its point on the sphere (`sharpen`), so the poles don't
+    pinch; the maps wrap horizontally and get 8× anisotropic filtering (`keepSharp`). The day texture is NASA's, its
+    seam repaired by `tools/globe/prepare-day-texture.py` (dev-only, needs Pillow).
+  - **Sun.** `wwwroot/js/sun.js` (pure functions of a date: the subsolar point, Earth–Sun distance, seasons, a place's
+    elevation, phase of the day, solar time and day length) lights the globe in the shader: the day map shaded by the
+    Sun's height and distance, city lights on the night side, a twilight blend between. It shows now (refreshed every
+    30 s), or the moment of the hovered, focused or pinned post (`data-post-at` on the card; a click pins a card,
+    `data-globe-pinned`), and tells `GlobePanel` through `SunChanged`, which shows the moment and its phase at the panel's
+    top and keeps the Sun's numbers as screen-reader text (`aria-describedby`). The theme changes only the atmosphere and
+    the points.
+  - **Instruments** (`wwwroot/js/instruments.js`; owner decision 2026-10-06: the nerd stats drawn where they belong, not
+    a table). The globe has no tooltip. What it draws:
+    - the Sun: its ray and bead over the subsolar point, the day/night line and the twilights, the declination, the
+      noon and midnight meridian, and its analemma at this hour to the next equinox or solstice;
+    - a focused post's place: its horizon, its Sun's height and its day lit on its latitude;
+    - the tropics, the polar circles and the CDN ring;
+    - the view's centre and spread, and rings around the posts in view;
+    - a small orrery in the top left corner, re-anchored to the camera before each render.
+
+    The numbers are chips in a DOM overlay (`.globe-instruments`, `aria-hidden`), placed after each frame globe.gl renders
+    (`scene.onAfterRender`), clear of each other, the moment's caption, the orrery and the legend. The frame rate is a
+    ring around the globe; what is left is a legend in the bottom left. Geometry changes only inside a wake globe.js
+    already made, so an idle globe still draws nothing.
+    - three.js's classes come from objects globe.gl made (`classesOf`), never `window.THREE`, since that would mix two
+      copies. three.js sets its `is*` flags on instances, so the lookup checks instances. globe.gl adds its globe on its
+      first update, after `new Globe()`, so the parts are built before the first render that finds it. Without the
+      classes, only the ring and the legend remain.
+    - A canvas under 320px tall (a phone's banner) gets the day/night line and the subsolar point only; full screen
+      gets everything.
+  - **Countries.** Land borders as thin paths, and names placed by `placeLabels`: largest countries first, once they
+    span enough pixels, away from the globe's edge and clear of each other, in the reader's language
+    (`Intl.DisplayNames`). `countries.json` is built by `tools/globe/prepare-countries.py` from world-atlas (Natural
+    Earth). The label renderer owns `display`, so labels hide through `visibility`.
+  - CDN-fronted posts are labels per CDN on a ring at 68°N, never a place; hovering one draws its arc there and a ring
+    where the server was before the CDN. The posts' places reach it in one call per feed change; cards are matched by
+    `data-post-id`.
 - **Nerd stats** (`Components/Nerd/NerdTip.razor`, rows from `NerdRow`): a post's ids, times and provenance (read on
   hover), its author and server with the server's changes of place and CDN week by week, its place or its CDN (how
-  PrivaPub found it, the place before it, the CDN's servers week by week), media and counts; the feed's paging and last request; the globe's camera,
-  points and frame rate.
+  PrivaPub found it, the place before it, the CDN's servers week by week), media and counts; the feed's paging and last
+  request. The globe's are its instruments (see **The globe**), with no tooltip and no poll.
 
 **Localization (`Services/CoalescingStringLocalizer.cs`).**
 - Lookup order: this repo's `Resources/AllStrings.resx` (+ `.it.resx`), then `FieldsNameResource`, then
   `ErrorsResource`.
 - A missing key renders as the key itself, formatted with its arguments, so a typo fails silently.
-- The class lives in namespace `collAnon.Client.Services`, a leftover from another project.
-- `Resources/ErrorMessages.resx` is read by `[Required]` / `[StringLength]` through `ErrorMessageResourceType`. A new key
-  needs its `public static string` property in `ErrorMessages.Designer.cs` too, or validation throws at runtime.
+- `Resources/ErrorMessages.resx` is read by `[Required]` / `[StringLength]` through `ErrorMessageResourceType`, and by the
+  D fields' parse errors (`DInputBase`, `DCalendar`) through the static `ErrorMessages.InvalidValue` / `InvalidDate`. A new
+  key needs its `public static string` property in `ErrorMessages.Designer.cs` too, or validation throws at runtime.
 
-**Client storage** comes in two layers:
-- **localStorage** (Blazored.LocalStorage, camelCase JSON) holds `AuthData`, `PublicCacheData`, `FeedFilter` and the
-  server cache `ServerInfos`, keyed by `nameof(Type)`.
-- **IndexedDB** (DnetIndexedDb, database `data`) is reached through `IStorage`. Its schema is declared in
-  `GenericExtensions.AddIndexedDb()`, and you must bump `WithVersion` when you change it.
-- The schema is at version 3: the `ClientLogs` store that `IStorage.AddLog` writes (version 2 added it; version 3 left
-  the mock feed's `Message` store out).
+**Client storage** is localStorage (Blazored.LocalStorage, camelCase JSON): `AuthData`, `PublicCacheData`, `FeedFilter`
+and the server cache `ServerInfos`, keyed by `nameof(Type)`. There is no IndexedDB: `ILoggingService` writes to the
+browser console only, and `main.js` deletes the database (`data`) where the client once kept its log, wherever a browser
+still holds it.
 
 **Auth.** `TokenAuthStateProvider` holds `AuthData` (localStorage, cached in memory) and builds the auth state from
 it: the root's name, its policies as claims, and the current persona. Pages that need a session carry
@@ -233,10 +495,12 @@ it: the root's name, its policies as claims, and the current persona. Pages that
 - `wwwroot/main.js` defines `window.*` helpers. `Services/AppStatusService.cs` calls them, mostly through the
   synchronous `IJSInProcessRuntime`.
 - Each helper reports its errors back through `window.logFromJs`.
-- The other scripts (IndexedDB, HeadElement, rxjs) are loaded by `<script>` tags in `wwwroot/index.html`; the feed's
+- The other scripts (`js/theme.js`, HeadElement's, `vendor/cally.js`, `js/blurhash.js`) are loaded by `<script>` tags in
+  `wwwroot/index.html`; the feed's
   modules (`js/feed.js`, `js/globe.js`) are imported on demand through `IJSObjectReference`.
 
-**PWA.** Published builds use `wwwroot/service-worker.published.js`, and `service-worker.js` is the dev version.
+**PWA.** Published builds use `wwwroot/service-worker.published.js`, and `service-worker.js` is the dev version. The
+published worker names its cache after the assets manifest's version, so each publish drops the previous cache.
 
 ## Development rules
 

ClientJsonContext.cs

@@ -3,6 +3,7 @@
 using decePubClient.Models;
 
 using PrivaPub.ClientModels;
+using PrivaPub.ClientModels.Admin;
 using PrivaPub.ClientModels.Group;
 using PrivaPub.ClientModels.Post;
 using PrivaPub.ClientModels.User;
@@ -22,22 +23,66 @@ namespace decePubClient;
 [JsonSerializable(typeof(PageSettings))]
 [JsonSerializable(typeof(AuthData))]
 [JsonSerializable(typeof(FeedFilter))]
+[JsonSerializable(typeof(PublicActionNotices))]
 [JsonSerializable(typeof(ServerInfo))]
 [JsonSerializable(typeof(List<ServerInfo>))]
 [JsonSerializable(typeof(UploadMedia))]
-[JsonSerializable(typeof(ClientLogs))]
-[JsonSerializable(typeof(ClientLogException))]
 [JsonSerializable(typeof(ValidationErrors))]
 [JsonSerializable(typeof(WebResult))]
 [JsonSerializable(typeof(LoginForm))]
+[JsonSerializable(typeof(SetupForm))]
+[JsonSerializable(typeof(InvitationLoginForm))]
+[JsonSerializable(typeof(ViewServerSetup))]
+[JsonSerializable(typeof(UserPasswordForm))]
+[JsonSerializable(typeof(RemoveSelfForm))]
+[JsonSerializable(typeof(PasswordRecoveryForm))]
+[JsonSerializable(typeof(NewPasswordForm))]
+[JsonSerializable(typeof(ViewAccount))]
+[JsonSerializable(typeof(EmailChangeForm))]
+[JsonSerializable(typeof(EmailCodeForm))]
+[JsonSerializable(typeof(PasswordForm))]
+[JsonSerializable(typeof(TotpCodeForm))]
+[JsonSerializable(typeof(TotpDisableForm))]
+[JsonSerializable(typeof(ViewTotpSetup))]
+[JsonSerializable(typeof(ViewTotpEnabled))]
+[JsonSerializable(typeof(ViewUserSettings))]
+// recover/valid takes the code as a JSON string ([FromBody] string) and answers a JSON bool
+[JsonSerializable(typeof(string))]
+[JsonSerializable(typeof(bool))]
 [JsonSerializable(typeof(JwtUser))]
 [JsonSerializable(typeof(ViewAvatar))]
 [JsonSerializable(typeof(List<ViewAvatar>))]
+[JsonSerializable(typeof(InsertAvatarForm))]
 [JsonSerializable(typeof(ViewGroup))]
 [JsonSerializable(typeof(List<ViewGroup>))]
+[JsonSerializable(typeof(ViewGroupMember))]
+[JsonSerializable(typeof(List<ViewGroupMember>))]
+[JsonSerializable(typeof(InsertGroupForm))]
+[JsonSerializable(typeof(UpdateGroupForm))]
+[JsonSerializable(typeof(JoinGroupForm))]
+[JsonSerializable(typeof(GroupMembershipForm))]
 [JsonSerializable(typeof(ViewPost))]
 [JsonSerializable(typeof(List<ViewPost>))]
 [JsonSerializable(typeof(InsertPostForm))]
+[JsonSerializable(typeof(DeletePostForm))]
+[JsonSerializable(typeof(ViewReport))]
+[JsonSerializable(typeof(List<ViewReport>))]
+[JsonSerializable(typeof(DomainBlockForm))]
+[JsonSerializable(typeof(ViewDomainBlock))]
+[JsonSerializable(typeof(List<ViewDomainBlock>))]
+[JsonSerializable(typeof(ViewStatisticsOverview))]
+[JsonSerializable(typeof(ViewHostsPage))]
+[JsonSerializable(typeof(ViewCrawler))]
+[JsonSerializable(typeof(ViewBackups))]
+[JsonSerializable(typeof(ViewBackup))]
+[JsonSerializable(typeof(BackupPasswordForm))]
+[JsonSerializable(typeof(RestoreBackupForm))]
+[JsonSerializable(typeof(ViewBackupTicket))]
+[JsonSerializable(typeof(ViewBackupUpload))]
+[JsonSerializable(typeof(ViewPersonaArchive))]
+[JsonSerializable(typeof(ImportPersonaArchiveForm))]
+[JsonSerializable(typeof(ViewArchiveTicket))]
+[JsonSerializable(typeof(ViewArchiveUpload))]
 public partial class ClientJsonContext : JsonSerializerContext
 {
 }

Components/Admin/BackupsPanel.razor

@@ -0,0 +1,448 @@
+@inherits LocalizableComponentBase
+@implements IAsyncDisposable
+
+@* The server's backups (/clientapi/admin/backups; owner decision 2026-10-07): made nightly, before each deploy and here,
+   downloaded as one tar through a link good for ten minutes, uploaded again in pieces straight from the browser
+   (js/transfer.js, never through .NET's memory), and restored: PrivaPub stops, restores the backup as it starts again,
+   and everyone signs in again. A restore never undoes what protects. *@
+<div class="flex flex-col gap-3 w-full" data-backups>
+	@if (IsLoading)
+	{
+		<p class="flex w-full items-center justify-center gap-2">
+			<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+			@Localizer["loading"]
+		</p>
+	}
+	else if (restarting is not null)
+	{
+		<DAlert Color="DAlertColor.Warning" data-backup-restarting>
+			<span>@Localizer["PrivaPub is restarting to restore {0}. Everyone, you included, signs in again once it is back.", restarting]</span>
+		</DAlert>
+	}
+	else
+	{
+		<div class="flex flex-wrap items-center gap-2 pointer-coarse:gap-2">
+			<DButton Size="DSize.Sm" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || backups.Running is not null || busy)" OnClick="BackUp" data-backup-now>
+				<i class="ion-md-archive"></i> @Localizer["Back up now"]
+			</DButton>
+			@if (backups.Running is { } running)
+			{
+				<span class="inline-flex items-center gap-2 text-sm" data-backup-running>
+					<DLoading Size="DSize.Xs" LabelText="@Localizer["loading"]" />
+					@(running == "restore" ? Localizer["A restore is running."] : Localizer["A backup is running."])
+				</span>
+			}
+			<span class="ml-auto text-xs opacity-70">@Localizer["{0} free on the server's disk", backups.FreeBytes.GetFileSize(Localizer)]</span>
+		</div>
+
+		@if (backups.Waiting is { } waiting)
+		{
+			<DAlert Color="@(waiting.Error is null ? DAlertColor.Warning : DAlertColor.Error)" data-backup-waiting>
+				<span>
+					@Localizer["The restore of {0}, asked for by {1}, is {2}.", waiting.Backup, waiting.RequestedBy, Localizer[waiting.State]]
+					@if (waiting.Error is { Length: > 0 } error)
+					{
+						<br /><span class="text-xs">@error</span>
+					}
+				</span>
+			</DAlert>
+		}
+
+		@if (backups.LastRestore is { } last)
+		{
+			<div class="flex flex-col gap-1 p-3 rounded-xl neo-inset neo-2xs text-sm" data-last-restore>
+				@if (last.Abandoned)
+				{
+					<p><b>@Localizer["The last restore, of {0}, was abandoned; nothing changed.", last.Backup]</b></p>
+					<p class="text-xs">@last.Error</p>
+				}
+				else
+				{
+					<p>
+						<b>@Localizer["Restored {0}", last.Backup]</b>
+						<span class="text-xs opacity-70" title="@last.RestoredAt.ToLocalTime().ToString(SUtility.dateTimeFormatExt)">@last.RestoredAt.GetPassedTime(Localizer)</span>
+						<span class="text-xs opacity-70">@Localizer["asked for by {0}", last.RequestedBy]</span>
+					</p>
+					<p class="text-xs">@Localizer["{0} documents in {1} collections; {2} media files brought back, {3} missing.", last.Documents, last.Collections, last.MediaRestored, last.MediaMissing]</p>
+					<p class="text-xs">@Localizer["Deleted again: {0} logins, {1} personas, {2} groups, {3} posts. Kept from since: {4} blocks, mutes, reports and other protective acts.", last.RootsDeleted, last.PersonasDeleted, last.GroupsDeleted, last.PostsDeleted, last.ProtectiveKept]</p>
+					@if (last.RootsTombstoned.Count + last.PersonasTombstoned.Count + last.GroupsTombstoned.Count > 0)
+					{
+						<p class="text-xs" data-last-restore-tombstoned>
+							@Localizer["Made after the backup, now deleted with their names kept: {0}.", string.Join(", ", last.RootsTombstoned.Concat(last.PersonasTombstoned).Concat(last.GroupsTombstoned))]
+						</p>
+					}
+					<p class="text-xs opacity-70">@Localizer["{0} posts made since answer as deleted; {1} media went to the trash; {2} sessions ended. The server as it was before is the backup {3}.", last.PostsGone, last.MediaTrashed, last.SessionsEnded, last.PreRestore]</p>
+				}
+			</div>
+		}
+
+		<div class="flex flex-col gap-2 p-3 rounded-xl neo-inset neo-2xs">
+			<p class="text-sm">@Localizer["Upload a backup downloaded from here (a .tar file):"]</p>
+			<div class="flex flex-wrap items-center gap-2 pointer-coarse:gap-2">
+				<DFileInput Size="DSize.Sm" Accept=".tar,application/x-tar" OnChange="Picked" class="flex-1 min-w-48" disabled="@(IsDefaultDisabled || uploading)"
+							data-backup-upload />
+				<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || uploading || pickedName is null)" OnClick="Upload" data-backup-upload-start>
+					<i class="ion-md-cloud-upload"></i> @Localizer["Upload"]
+				</DButton>
+			</div>
+			@if (uploading)
+			{
+				<DProgress Value="@uploadedPercent" Max="100" Color="DColor.Primary" data-backup-upload-progress />
+				<p class="text-xs opacity-70">@Localizer["{0} of {1}", uploaded.GetFileSize(Localizer), uploadSize.GetFileSize(Localizer)]</p>
+			}
+		</div>
+
+		@if (backups.Backups.Count == 0)
+		{
+			<p class="text-sm opacity-70">@Localizer["No backup yet."]</p>
+		}
+
+		@foreach (var backup in backups.Backups)
+		{
+			<div class="flex flex-col gap-1 p-2 rounded-lg neo-raised neo-2xs" data-backup="@backup.Id">
+				<div class="flex flex-wrap items-center gap-2 pointer-coarse:gap-2">
+					<b class="min-w-0 truncate" title="@backup.Id">@backup.CreatedAt.ToLocalTime().ToString(SUtility.dateTimeFormatExt)</b>
+					<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft" Color="@KindColor(backup.Kind)">@KindName(backup.Kind)</DBadge>
+					<span class="text-xs opacity-70">@backup.CreatedAt.GetPassedTime(Localizer)</span>
+					<span class="text-xs">@((backup.Bytes + backup.MediaBytes).GetFileSize(Localizer))</span>
+				</div>
+				<p class="text-xs opacity-70">
+					@Localizer["{0} documents in {1} collections", backup.Documents, backup.Collections];
+					@(backup.DbOnly
+						? Localizer["{0} media files listed, kept by the nightly backups", backup.MediaFiles]
+						: Localizer["{0} media files ({1})", backup.MediaFiles, backup.MediaBytes.GetFileSize(Localizer)])
+					@if (backup.MediaMissing > 0)
+					{
+						<span>; @Localizer["{0} missing", backup.MediaMissing]</span>
+					}
+					@if (!backup.Consistent)
+					{
+						<span>; @Localizer["not read at one instant"]</span>
+					}
+				</p>
+				@if (backup.RootsDeletedSince > 0)
+				{
+					<p class="text-xs">@Localizer["{0} logins were deleted since; a restore deletes them again.", backup.RootsDeletedSince]</p>
+				}
+				<div class="flex flex-wrap justify-end gap-2 pointer-coarse:gap-2">
+					<DButton Size="DSize.Sm" Disabled="@IsDefaultDisabled" OnClick="() => AskDownload(backup)" data-backup-download>
+						<i class="ion-md-download"></i> @Localizer["Download"]
+					</DButton>
+					<DButton Size="DSize.Sm" Color="DColor.Warning" Disabled="@(IsDefaultDisabled || backup.NotRestorable is not null || backups.Running is not null || backups.Waiting is not null)"
+							 OnClick="() => AskRestore(backup)" data-backup-restore>
+						<i class="ion-md-refresh"></i> @Localizer["Restore"]
+					</DButton>
+					<DButton Size="DSize.Sm" Color="DColor.Error" Disabled="@(IsDefaultDisabled || busy)" OnClick="() => Delete(backup)" data-backup-delete>
+						<i class="ion-md-trash"></i> @Localizer["Delete"]
+					</DButton>
+				</div>
+			</div>
+		}
+	}
+</div>
+
+<DModal Placement="DModalPlacement.ResponsiveBottom" IsOpen="@(downloading is not null)" IsOpenChanged="open => { if (!open) CloseDownload(); }"
+		CloseText="@Localizer["Close"]" data-backup-download-dialog>
+	<Heading>@Localizer["Download a backup"]</Heading>
+	<ChildContent>
+		@if (ticket is null)
+		{
+			<p class="text-sm">@Localizer["It holds every persona's private keys and private posts: keep it where only you can read it. Your password, to get a link:"]</p>
+			<DInput TValue="string" type="password" @bind-Value="password" Immediate="true" autocomplete="current-password" maxlength="200"
+					placeholder="@Localizer["Password"]" data-backup-password />
+			<ErrorViewer AdditionalError="@dialogError" />
+		}
+		else
+		{
+			<p class="text-sm">@Localizer["The link works for ten minutes, for this backup only."]</p>
+			<a class="btn btn-primary btn-sm self-start" href="@ticket" data-backup-link>
+				<i class="ion-md-download"></i> @Localizer["Download {0}", ticketSize.GetFileSize(Localizer)]
+			</a>
+		}
+	</ChildContent>
+	<Actions>
+		<DButton Size="DSize.Sm" OnClick="CloseDownload" data-backup-dialog-close>@Localizer["Close"]</DButton>
+		@if (ticket is null)
+		{
+			<DButton Size="DSize.Sm" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || busy || string.IsNullOrEmpty(password))" OnClick="Download" data-backup-confirm>
+				@Localizer["Get the link"]
+			</DButton>
+		}
+	</Actions>
+</DModal>
+
+<DModal Placement="DModalPlacement.ResponsiveBottom" IsOpen="@(restoring is not null)" IsOpenChanged="open => { if (!open) CloseRestore(); }"
+		CloseText="@Localizer["Close"]" data-backup-restore-dialog>
+	<Heading>@Localizer["Restore the backup of {0}?", restoring?.CreatedAt.ToLocalTime().ToString(SUtility.dateTimeFormatExt) ?? ""]</Heading>
+	<ChildContent>
+		<div class="flex flex-col gap-2 text-sm">
+			<p>@Localizer["PrivaPub stops, restores this backup and starts again, in a few minutes. Everyone signs in again."]</p>
+			<p>@Localizer["What was made since is lost: posts, edits, follows asked for, settings. What protects is not: deletions, blocks, mutes, server blocks, reports, filters and reserved names made since stay, and followers stay as they are now. Logins, personas and groups made since are deleted, keeping their names."]</p>
+			@if (restoring?.RootsDeletedSince > 0)
+			{
+				<p>@Localizer["{0} logins were deleted since; a restore deletes them again.", restoring.RootsDeletedSince]</p>
+			}
+			<DInput TValue="string" type="password" @bind-Value="password" Immediate="true" autocomplete="current-password" maxlength="200"
+					placeholder="@Localizer["Password"]" data-backup-password />
+			<DInput TValue="string" @bind-Value="typedHost" Immediate="true" autocomplete="off" maxlength="253"
+					placeholder="@Localizer["Type {0} to confirm", backups.Host ?? ""]" data-backup-host />
+			<ErrorViewer AdditionalError="@dialogError" />
+		</div>
+	</ChildContent>
+	<Actions>
+		<DButton Size="DSize.Sm" OnClick="CloseRestore">@Localizer["Cancel"]</DButton>
+		<DButton Size="DSize.Sm" Color="DColor.Error"
+				 Disabled="@(IsDefaultDisabled || busy || string.IsNullOrEmpty(password) || !string.Equals(typedHost?.Trim(), backups.Host, StringComparison.OrdinalIgnoreCase))"
+				 OnClick="Restore" data-backup-confirm>
+			@Localizer["Restore"]
+		</DButton>
+	</Actions>
+</DModal>
+
+@code {
+	[Inject] AdminService AdminService { get; set; }
+	[Inject] ConfirmService Confirm { get; set; }
+	[Inject] TokenAuthStateProvider AuthStateProvider { get; set; }
+	[Inject] AppConfiguration Configuration { get; set; }
+	[Inject] IJSRuntime JS { get; set; }
+
+	const string UploadInput = "input[data-backup-upload]";
+	static readonly TimeSpan PollEvery = TimeSpan.FromSeconds(3);
+
+	ViewBackups backups = new();
+	bool busy;
+	string restarting;
+	ViewBackup downloading;
+	ViewBackup restoring;
+	string password;
+	string typedHost;
+	string ticket;
+	long ticketSize;
+	string dialogError;
+	string pickedName;
+	bool uploading;
+	long uploaded;
+	long uploadSize;
+	double uploadedPercent;
+	IJSObjectReference transfer;
+	DotNetObjectReference<BackupsPanel> self;
+	CancellationTokenSource polling;
+
+	protected override async Task OnInitializedAsync()
+	{
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+		IsLoading = false;
+	}
+
+	async Task LoadData()
+	{
+		backups = await AdminService.Backups() ?? backups;
+		if (backups.Running is not null || backups.Waiting is not null)
+			Poll();
+	}
+
+	// while something runs, the list is read again every few seconds; a restore ends the session, and with it this page
+	void Poll()
+	{
+		if (polling is not null)
+			return;
+		polling = new();
+		var token = polling.Token;
+		_ = Task.Run(async () =>
+		{
+			using var timer = new PeriodicTimer(PollEvery);
+			while (await timer.WaitForNextTickAsync(token))
+			{
+				var read = await AdminService.Backups(token);
+				if (read is not null)
+					backups = read;
+				await InvokeAsync(StateHasChanged);
+				if (restarting is null && read is not null && read.Running is null && read.Waiting is null)
+					break;
+			}
+			polling = null;
+		}, token);
+	}
+
+	static DColor KindColor(string kind) => kind switch
+	{
+		"nightly" => DColor.Neutral,
+		"manual" => DColor.Primary,
+		"pre-deploy" => DColor.Info,
+		"pre-restore" => DColor.Warning,
+		"uploaded" => DColor.Accent,
+		_ => DColor.Neutral
+	};
+
+	string KindName(string kind) => kind switch
+	{
+		"nightly" => Localizer["Nightly"],
+		"manual" => Localizer["Made by hand"],
+		"pre-deploy" => Localizer["Before a deploy"],
+		"pre-restore" => Localizer["Before a restore"],
+		"uploaded" => Localizer["Uploaded"],
+		_ => kind
+	};
+
+	async Task BackUp()
+	{
+		busy = true;
+		var result = await AdminService.BackUp();
+		busy = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		backups.Running = "backup";
+		Toast.AddResponseSuccess(Localizer["The backup has started."]);
+		Poll();
+	}
+
+	async Task Delete(ViewBackup backup)
+	{
+		if (!await Confirm.Ask(Localizer["Delete this backup?"], Localizer["Its files are deleted; the server itself is untouched."], Localizer["Delete"], true))
+			return;
+		busy = true;
+		var result = await AdminService.DeleteBackup(backup.Id);
+		busy = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		backups.Backups = [.. backups.Backups.Where(b => b.Id != backup.Id)];
+	}
+
+	void AskDownload(ViewBackup backup)
+	{
+		(password, ticket, dialogError) = (null, null, null);
+		downloading = backup;
+	}
+
+	void CloseDownload() => (downloading, password, ticket, dialogError) = (null, null, null, null);
+
+	async Task Download()
+	{
+		busy = true;
+		var result = await AdminService.BackupTicket(downloading.Id, password);
+		busy = false;
+		if (result.IsInvalid)
+		{
+			dialogError = result.ErrorMessage;
+			return;
+		}
+
+		var granted = (ViewBackupTicket)result.Data;
+		ticket = new Uri(ApiBase, granted.Url).AbsoluteUri;
+		ticketSize = granted.Bytes;
+		password = null;
+		dialogError = null;
+	}
+
+	void AskRestore(ViewBackup backup)
+	{
+		(password, typedHost, dialogError) = (null, null, null);
+		restoring = backup;
+	}
+
+	void CloseRestore() => (restoring, password, typedHost, dialogError) = (null, null, null, null);
+
+	async Task Restore()
+	{
+		busy = true;
+		var asked = restoring;
+		var result = await AdminService.RestoreBackup(asked.Id, new RestoreBackupForm { Password = password, Host = typedHost?.Trim() });
+		busy = false;
+		if (result.IsInvalid)
+		{
+			dialogError = result.ErrorMessage;
+			return;
+		}
+
+		CloseRestore();
+		restarting = asked.Id;
+		Poll();
+	}
+
+	Uri ApiBase => new(string.IsNullOrEmpty(Configuration.ApiBaseAddress) ? Navigation.BaseUri : Configuration.ApiBaseAddress);
+
+	void Picked(InputFileChangeEventArgs e) => pickedName = e.FileCount > 0 ? e.File.Name : null;
+
+	async Task Upload()
+	{
+		transfer ??= await JS.InvokeAsync<IJSObjectReference>("import", "./js/transfer.js");
+		self ??= DotNetObjectReference.Create(this);
+		var started = await AdminService.StartBackupUpload();
+		if (started.IsInvalid)
+		{
+			Toast.AddResponseError(started);
+			return;
+		}
+
+		var upload = (ViewBackupUpload)started.Data;
+		(uploading, uploaded, uploadSize, uploadedPercent) = (true, 0, 0, 0);
+		var endpoint = new Uri(ApiBase, APIs.ClientApi.PUT_M_AdminBackupUpload(upload.Id)).AbsoluteUri;
+		var sent = await transfer.InvokeAsync<UploadOutcome>("upload", UploadInput, endpoint, await AuthStateProvider.GetToken(), upload.ChunkBytes, self);
+		if (!sent.Ok)
+		{
+			uploading = false;
+			await AdminService.CancelBackupUpload(upload.Id);
+			Toast.AddResponseError(Localizer["The upload failed: {0}", sent.Error ?? sent.Status.ToString()]);
+			return;
+		}
+
+		var finished = await AdminService.FinishBackupUpload(upload.Id);
+		uploading = false;
+		if (finished.IsInvalid)
+		{
+			Toast.AddResponseError(finished);
+			return;
+		}
+
+		var backup = (ViewBackup)finished.Data;
+		backups.Backups = [.. backups.Backups.Append(backup).OrderByDescending(b => b.CreatedAt)];
+		pickedName = null;
+		Toast.AddResponseSuccess(Localizer["The backup {0} was uploaded.", backup.Id]);
+	}
+
+	[JSInvokable]
+	public Task Progress(long received, long total)
+	{
+		(uploaded, uploadSize) = (received, total);
+		uploadedPercent = total == 0 ? 100 : 100.0 * received / total;
+		return InvokeAsync(StateHasChanged);
+	}
+
+	sealed class UploadOutcome
+	{
+		public bool Ok { get; set; }
+		public int Status { get; set; }
+		public string Error { get; set; }
+	}
+
+	public async ValueTask DisposeAsync()
+	{
+		polling?.Cancel();
+		self?.Dispose();
+		if (transfer is null)
+			return;
+		try
+		{
+			await transfer.DisposeAsync();
+		}
+		catch (JSDisconnectedException)
+		{
+		}
+	}
+}

Components/Admin/ReportsPanel.razor

@@ -0,0 +1,138 @@
+@inherits LocalizableComponentBase
+
+@* The reports moderators handle (/clientapi/moderator/reports): from someone here (never said who) or from another
+   server, about an account and some of its posts; resolved here. *@
+<div class="flex flex-col gap-3 w-full" data-reports>
+	<DToggle LabelText="@Localizer["Show the resolved ones"]" Value="resolved" ValueChanged="ShowResolved" ValueExpression="() => resolved" />
+
+	@if (IsLoading)
+	{
+		<p class="flex w-full items-center justify-center gap-2">
+			<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+			@Localizer["loading"]
+		</p>
+	}
+	else if (reports.Count == 0)
+	{
+		<p class="text-sm opacity-70">@(resolved ? Localizer["No resolved report."] : Localizer["No open report."])</p>
+	}
+
+	@foreach (var report in reports)
+	{
+		<article class="flex flex-col gap-2 p-3 rounded-xl neo-raised neo-xs" data-report-id="@report.ID">
+			<div class="flex flex-wrap items-center gap-2">
+				<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft" Color="DColor.Warning">@CategoryName(report.Category)</DBadge>
+				@if (report.Forwarded)
+				{
+					<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft">@Localizer["Forwarded"]</DBadge>
+				}
+				<span class="text-xs opacity-70" title="@report.CreatedAt.ToLocalTime().ToString(SUtility.dateTimeFormat)">
+					@report.CreatedAt.GetPassedTime(Localizer)
+				</span>
+				<span class="flex-1"></span>
+				@if (!report.IsResolved)
+				{
+					<DButton Size="DSize.Sm" Color="DColor.Success" Disabled="@(IsDefaultDisabled || busy.Contains(report.ID))" OnClick="() => Resolve(report)"
+							 data-report-resolve>
+						<i class="ion-md-checkmark"></i><span>@Localizer["Resolve"]</span>
+					</DButton>
+				}
+				else if (report.ResolvedAt is { } resolvedAt)
+				{
+					<span class="text-xs opacity-70">@Localizer["Resolved {0}", resolvedAt.GetPassedTime(Localizer)]</span>
+				}
+			</div>
+			<p class="text-sm">
+				<b>@Localizer["About"]</b>
+				@if (report.TargetAccountId is { Length: > 0 } targetId)
+				{
+					<a class="link link-hover break-all" href="@($"account/{Uri.EscapeDataString(targetId)}")">@report.TargetActorURI</a>
+				}
+				else
+				{
+					<span class="break-all">@report.TargetActorURI</span>
+				}
+			</p>
+			<p class="text-sm">
+				<b>@Localizer["From"]</b>
+				<span class="break-all">@(report.Reporter == "local" ? Localizer["someone here"] : report.Reporter)</span>
+			</p>
+			@if (report.Comment is { Length: > 0 } comment)
+			{
+				<p class="text-sm whitespace-pre-line rounded-lg neo-inset neo-2xs p-2">@comment</p>
+			}
+			@if (report.PostIds.Count > 0 || report.ObjectURIs.Count > 0)
+			{
+				<div class="flex flex-wrap gap-2 text-xs">
+					@foreach (var postId in report.PostIds)
+					{
+						<a class="link" href="@($"expand/{Uri.EscapeDataString(postId)}")">@Localizer["Post {0}", postId]</a>
+					}
+					@* a report from another server names posts by their ids there when we hold none of them *@
+					@if (report.PostIds.Count == 0)
+					{
+						@foreach (var uri in report.ObjectURIs)
+						{
+							<span class="break-all opacity-70">@uri</span>
+						}
+					}
+				</div>
+			}
+		</article>
+	}
+</div>
+
+@code {
+	[Inject] AdminService AdminService { get; set; }
+
+	List<ViewReport> reports = [];
+	bool resolved;
+	HashSet<string> busy = [];
+
+	protected override async Task OnInitializedAsync()
+	{
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+		IsLoading = false;
+	}
+
+	async Task LoadData() => reports = await AdminService.Reports(resolved);
+
+	async Task ShowResolved(bool value)
+	{
+		resolved = value;
+		IsLoading = true;
+		await LoadData();
+		IsLoading = false;
+	}
+
+	string CategoryName(string category) => category switch
+	{
+		"spam" => Localizer["Spam"],
+		"legal" => Localizer["Illegal"],
+		"violation" => Localizer["Breaks the rules"],
+		_ => Localizer["Other"]
+	};
+
+	async Task Resolve(ViewReport report)
+	{
+		busy.Add(report.ID);
+		var result = await AdminService.Resolve(report.ID);
+		busy.Remove(report.ID);
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		reports.Remove(report);
+		Toast.AddResponseSuccess(Localizer["Report resolved."]);
+	}
+}

Components/Admin/ServerBlocksPanel.razor

@@ -0,0 +1,122 @@
+@inherits LocalizableComponentBase
+
+@* Servers blocked for everyone here (/clientapi/admin/domainblocks): suspended (nothing from or to them) or silenced
+   (kept out of the public feeds), their media refused or not, with a comment for the public and one for the admins. *@
+<div class="flex flex-col gap-3 w-full" data-server-blocks>
+	<EditForm Model="form" OnValidSubmit="Block" class="flex flex-col gap-2 p-3 rounded-xl neo-inset neo-2xs">
+		<DataAnnotationsValidator />
+		<div class="flex flex-wrap gap-2 items-center">
+			<DInput TValue="string" class="flex-1 min-w-48" @bind-Value="form.Domain" Immediate="true" autocomplete="off" maxlength="253"
+					placeholder="@Localizer["A server, e.g. example.social"]" data-server-block-domain>
+				<Prefix><i class="ion-md-globe"></i></Prefix>
+			</DInput>
+			<DToggle LabelText="@Localizer["Suspend (otherwise silence)"]" @bind-Value="form.Suspend" />
+			<DToggle LabelText="@Localizer["Refuse its media"]" @bind-Value="form.RejectMedia" />
+		</div>
+		<DInput TValue="string" @bind-Value="form.PublicComment" Immediate="true" autocomplete="off" maxlength="1000"
+				placeholder="@Localizer["Why, for everyone to read"]" />
+		<DInput TValue="string" @bind-Value="form.PrivateComment" Immediate="true" autocomplete="off" maxlength="1000"
+				placeholder="@Localizer["Why, for the admins only"]" />
+		<ErrorViewer />
+		<DButton Type="submit" Size="DSize.Sm" Color="DColor.Error" class="self-end"
+				 Disabled="@(IsDefaultDisabled || isSaving || string.IsNullOrWhiteSpace(form.Domain))">
+			@Localizer["Block server"]
+		</DButton>
+	</EditForm>
+
+	@if (IsLoading)
+	{
+		<p class="flex w-full items-center justify-center gap-2">
+			<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+			@Localizer["loading"]
+		</p>
+	}
+	else if (blocks.Count == 0)
+	{
+		<p class="text-sm opacity-70">@Localizer["No server is blocked."]</p>
+	}
+
+	@foreach (var block in blocks)
+	{
+		<div class="flex flex-col gap-1 p-2 rounded-lg neo-raised neo-2xs" data-server-block="@block.Domain">
+			<div class="flex flex-wrap items-center gap-2">
+				<b class="flex-1 min-w-0 truncate">@block.Domain</b>
+				<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft" Color="@(block.Severity == "Suspend" ? DColor.Error : DColor.Warning)">
+					@(block.Severity == "Suspend" ? Localizer["Suspended"] : Localizer["Silenced"])
+				</DBadge>
+				@if (block.RejectMedia)
+				{
+					<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft">@Localizer["Media refused"]</DBadge>
+				}
+				<span class="text-xs opacity-70" title="@block.CreatedAt.ToLocalTime().ToString(SUtility.dateTimeFormat)">@block.CreatedAt.GetPassedTime(Localizer)</span>
+				<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || busy.Contains(block.Domain))" OnClick="() => Unblock(block)">
+					@Localizer["Unblock"]
+				</DButton>
+			</div>
+			@if (block.PublicComment is { Length: > 0 } publicComment)
+			{
+				<p class="text-xs">@publicComment</p>
+			}
+			@if (block.PrivateComment is { Length: > 0 } privateComment)
+			{
+				<p class="text-xs opacity-70"><i class="ion-md-lock"></i> @privateComment</p>
+			}
+		</div>
+	}
+</div>
+
+@code {
+	[Inject] AdminService AdminService { get; set; }
+
+	List<ViewDomainBlock> blocks = [];
+	DomainBlockForm form = new();
+	bool isSaving;
+	HashSet<string> busy = [];
+
+	protected override async Task OnInitializedAsync()
+	{
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+		IsLoading = false;
+	}
+
+	async Task LoadData() => blocks = await AdminService.ServerBlocks();
+
+	async Task Block()
+	{
+		isSaving = true;
+		var result = await AdminService.BlockServer(form);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		var block = (ViewDomainBlock)result.Data;
+		blocks = [.. blocks.Where(b => b.Domain != block.Domain).Append(block).OrderBy(b => b.Domain, StringComparer.Ordinal)];
+		form = new();
+		Toast.AddResponseSuccess(Localizer["{0} is blocked.", block.Domain]);
+	}
+
+	async Task Unblock(ViewDomainBlock block)
+	{
+		busy.Add(block.Domain);
+		var result = await AdminService.UnblockServer(block.Domain);
+		busy.Remove(block.Domain);
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		blocks.Remove(block);
+	}
+}

Components/Admin/StatisticsPanel.razor

@@ -0,0 +1,209 @@
+@inherits LocalizableComponentBase
+
+@* PrivaPub's federation statistics (/clientapi/admin/statistics): the last days at a glance, the servers exchanged with
+   (by traffic, failures, latency or name, 50 a page) and how far the crawler got. Counted per server, never per account. *@
+<div class="flex flex-col gap-4 w-full" data-statistics>
+	<div class="flex flex-wrap gap-2 items-end">
+		<label class="flex flex-col gap-1 text-sm">
+			<span>@Localizer["Period"]</span>
+			<DSelect TValue="int" Size="DSize.Sm" Value="days" ValueChanged="ChangeDays" ValueExpression="() => days">
+				@foreach (var period in Periods)
+				{
+					<option value="@period">@Localizer["{0} days", period]</option>
+				}
+			</DSelect>
+		</label>
+		<label class="flex flex-col gap-1 text-sm">
+			<span>@Localizer["Servers by"]</span>
+			<DSelect TValue="string" Size="DSize.Sm" Value="sort" ValueChanged="ChangeSort" ValueExpression="() => sort">
+				<option value="traffic">@Localizer["Traffic"]</option>
+				<option value="failures">@Localizer["Failures"]</option>
+				<option value="latency">@Localizer["Latency"]</option>
+				<option value="host">@Localizer["Name"]</option>
+			</DSelect>
+		</label>
+	</div>
+
+	@if (IsLoading)
+	{
+		<p class="flex w-full items-center justify-center gap-2">
+			<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+			@Localizer["loading"]
+		</p>
+	}
+	else if (overview is null)
+	{
+		<p class="text-sm opacity-70">@Localizer["The statistics could not be read."]</p>
+	}
+	else
+	{
+		<DStats class="w-full overflow-x-auto neo-raised neo-xs" data-statistics-overview data-scroll-x>
+			<DStat>
+				<Heading>@Localizer["Deliveries that arrived"]</Heading>
+				<ChildContent>@(overview.DeliverySuccess is { } success ? $"{success * 100:0.#}%" : "—")</ChildContent>
+				<Desc>@Localizer["p50 {0} ms, p95 {1} ms", Ms(overview.DeliveryLatencyMs.P50), Ms(overview.DeliveryLatencyMs.P95)]</Desc>
+			</DStat>
+			<DStat>
+				<Heading><span class="capitalize">@Localizer["servers"]</span></Heading>
+				<ChildContent>@overview.Hosts.Active</ChildContent>
+				<Desc>@Localizer["{0} known", overview.Hosts.Known]</Desc>
+			</DStat>
+			<DStat>
+				<Heading>@Localizer["Accounts seen"]</Heading>
+				<ChildContent>@overview.Accounts</ChildContent>
+				<Desc>@Localizer["ledger {0} written, {1} dropped", overview.Ledger.Written, overview.Ledger.Dropped]</Desc>
+			</DStat>
+		</DStats>
+
+		<div class="flex flex-wrap gap-4 text-xs">
+			@foreach (var (title, counts) in Outcomes)
+			{
+				<div class="flex flex-col gap-1 min-w-40">
+					<b class="text-sm">@title</b>
+					@foreach (var (outcome, count) in counts.OrderByDescending(c => c.Value))
+					{
+						<span class="flex justify-between gap-4 tabular-nums"><span>@outcome</span><span>@count</span></span>
+					}
+				</div>
+			}
+		</div>
+
+		@if (hosts is not null)
+		{
+			<DTable Size="DSize.Xs" Zebra="true" WrapperClass="max-h-[28rem] rounded-xl neo-inset neo-2xs" data-statistics-hosts>
+				<thead>
+					<tr>
+						<th>@Localizer["server"]</th>
+						<th>@Localizer["software"]</th>
+						<th class="text-right">@Localizer["In"]</th>
+						<th class="text-right">@Localizer["Out"]</th>
+						<th class="text-right">@Localizer["Refused"]</th>
+						<th class="text-right">@Localizer["Failures"]</th>
+						<th class="text-right">p50</th>
+						<th>@Localizer["Delivery"]</th>
+					</tr>
+				</thead>
+				<tbody>
+					@foreach (var host in hosts.Hosts)
+					{
+						<tr data-statistics-host="@host.Host">
+							<td class="max-w-48 truncate">@host.Host</td>
+							<td>@host.Software @host.Version</td>
+							<td class="text-right tabular-nums">@host.In</td>
+							<td class="text-right tabular-nums">@host.Out</td>
+							<td class="text-right tabular-nums">@host.Refused</td>
+							<td class="text-right tabular-nums">@host.Failures</td>
+							<td class="text-right tabular-nums">@Ms(host.LatencyP50)</td>
+							<td>
+								@if (host.Delivery?.UnavailableUntil is { } until && until > DateTime.UtcNow)
+								{
+									<DBadge Size="DSize.Xs" Color="DColor.Error" title="@until.ToLocalTime().ToString(SUtility.dateTimeFormat)">@Localizer["paused"]</DBadge>
+								}
+								else if (host.Delivery?.ConsecutiveFailures > 0)
+								{
+									<DBadge Size="DSize.Xs" Color="DColor.Warning">@Localizer["{0} failing", host.Delivery.ConsecutiveFailures]</DBadge>
+								}
+							</td>
+						</tr>
+					}
+				</tbody>
+			</DTable>
+			@if (hosts.Total > PageSize)
+			{
+				<DPagination Size="DSize.Xs" Count="@((hosts.Total + PageSize - 1) / PageSize)" Current="page" CurrentChanged="ChangePage"
+							 PreviousAriaLabel="@Localizer["Previous page"]" NextAriaLabel="@Localizer["Next page"]" />
+			}
+			<p class="text-xs opacity-70">@hosts.Attribution</p>
+		}
+
+		@if (crawler is not null)
+		{
+			<div class="flex flex-col gap-1 text-xs" data-statistics-crawler>
+				<b class="text-sm">@Localizer["Crawler"]</b>
+				<span>
+					@(crawler.Enabled ? Localizer["on"] : Localizer["off"]) ·
+					@Localizer["{0} servers touched, {1} only crawled, {2} due, {3} refuse robots", crawler.Touched, crawler.Crawled, crawler.Due, crawler.RobotsDisallowed]
+				</span>
+				@foreach (var host in crawler.Recent)
+				{
+					<span class="flex flex-wrap gap-2">
+						<span class="truncate max-w-48">@host.Host</span>
+						<span class="opacity-70">@host.Software</span>
+						@if (host.LastCrawledAt is { } crawled)
+						{
+							<span class="opacity-70">@crawled.GetPassedTime(Localizer)</span>
+						}
+						@if (host.CrawlError is { Length: > 0 } crawlError)
+						{
+							<span class="text-error">@crawlError</span>
+						}
+					</span>
+				}
+			</div>
+		}
+	}
+</div>
+
+@code {
+	[Inject] AdminService AdminService { get; set; }
+
+	const int PageSize = 50;
+	static readonly int[] Periods = [1, 7, 30, 90];
+
+	ViewStatisticsOverview overview;
+	ViewHostsPage hosts;
+	ViewCrawler crawler;
+	int days = 30;
+	string sort = "traffic";
+	int page = 1;
+
+	(string Title, Dictionary<string, long> Counts)[] Outcomes =>
+	[
+		(Localizer["Received"], overview.Inbound),
+		(Localizer["Delivered"], overview.Outbound),
+		(Localizer["Channels"], overview.Channels)
+	];
+
+	protected override async Task OnInitializedAsync()
+	{
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+		IsLoading = false;
+	}
+
+	async Task LoadData()
+	{
+		overview = await AdminService.Overview(days);
+		hosts = await AdminService.Hosts(days, sort, page);
+		crawler = await AdminService.Crawler();
+	}
+
+	static string Ms(int? value) => value?.ToString() ?? "—";
+
+	async Task ChangeDays(int value)
+	{
+		days = value;
+		page = 1;
+		await LoadData();
+	}
+
+	async Task ChangeSort(string value)
+	{
+		sort = value;
+		page = 1;
+		hosts = await AdminService.Hosts(days, sort, page);
+	}
+
+	async Task ChangePage(int value)
+	{
+		page = value;
+		hosts = await AdminService.Hosts(days, sort, page);
+	}
+}

Components/Composer.razor

@@ -1,8 +1,14 @@
+@using System.Text.RegularExpressions
 @inherits LocalizableComponentBase
 
 @* A new post or a reply, as the current persona. Through the Mastodon API it is plain text with a content warning, a
    visibility and media (each uploaded first, with its alt text). A located post is text only, kept within its range of
-   this device's position and never federated; a group post goes to the group. Both of those go through /clientapi. *@
+   this device's position and never federated; a group post goes to the group. Both of those go through /clientapi.
+   A Mastodon API post can wait for a time instead (scheduled_at, at least five minutes ahead); /scheduled lists those.
+   It can hold a poll instead of media, quote a post (Quoting), or be the persona's own post edited (Editing: its words,
+   warning, media and their descriptions change; its visibility and poll stay). A file is uploaded as soon as it is
+   picked, streamed from the browser's file, and shows its state (uploading, processing, ready, failed with Retry); its
+   id is kept, so a post that fails never uploads it again. What the server takes (types, sizes) comes from it. *@
 <EditForm Model="form" OnValidSubmit="Publish" class="flex flex-col gap-3">
 	<DataAnnotationsValidator />
 
@@ -13,38 +19,127 @@
 			<Prefix><i class="ion-md-warning text-warning"></i></Prefix>
 		</DInput>
 	}
-	<div class="relative">
-		<DTextarea TValue="string" @bind-Value="form.Content" Immediate="true"
+	<div class="flex flex-col gap-1">
+		<DTextarea @ref="textarea" TValue="string" @bind-Value="form.Content" @bind-Value:after="Typed" Immediate="true"
 				   class="@(form.HasContentWarning ? "w-full rounded-b-[1.4rem] rounded-t-lg" : "w-full rounded-[1.4rem]")" maxlength="@ComposeForm.MaxContentLength" autocomplete="off"
-				   placeholder="@(InReplyTo is null ? Localizer["What's happening?"] : Localizer["Reply to {0}", "@" + InReplyTo.Account?.Acct])" rows="3" />
-		<span class="absolute text-xs opacity-50 right-3 bottom-2">@ContentLength/@ComposeForm.MaxContentLength</span>
+				   placeholder="@Placeholder" rows="3" data-compose />
+		@* under the words, not over their last line *@
+		<span class="self-end text-xs opacity-50 tabular-nums">@ContentLength/@ComposeForm.MaxContentLength</span>
 	</div>
+	@if (suggestedAccounts.Count > 0 || suggestedTags.Count > 0)
+	{
+		<div class="flex flex-wrap gap-2" data-suggestions>
+			@foreach (var account in suggestedAccounts)
+			{
+				<DButton Size="DSize.Xs" class="max-w-full" KeepFocus="true" OnClick="@(() => Complete("@" + account.Acct))" data-suggestion="@("@" + account.Acct)">
+					@* alt="": the handle is next to it. *@
+					<img alt="" class="h-4 w-4 flex-none rounded-full object-cover" src="@(account.Avatar ?? "imgs/icon-192.png")" />
+					<span class="truncate">@("@" + account.Acct)</span>
+				</DButton>
+			}
+			@foreach (var tag in suggestedTags)
+			{
+				<DButton Size="DSize.Xs" KeepFocus="true" OnClick="@(() => Complete("#" + tag.Name))" data-suggestion="@("#" + tag.Name)">#@tag.Name</DButton>
+			}
+		</div>
+	}
+
+	@if (Quoting is not null)
+	{
+		<Content Post="FeedPost.Of(Quoting)" Compact="true" CssContainer="opacity-90" />
+	}
+
+	@if (form.HasPoll)
+	{
+		<div class="flex flex-col gap-2 rounded-xl p-3 neo-inset neo-2xs" data-poll-editor>
+			@for (var i = 0; i < form.PollOptions.Count; i++)
+			{
+				var index = i;
+				<div class="flex items-center gap-2">
+					<input type="text" class="input input-sm flex-1" maxlength="100" autocomplete="off" placeholder="@Localizer["Choice {0}", index + 1]"
+						   value="@form.PollOptions[index]" @onchange="@((ChangeEventArgs e) => form.PollOptions[index] = e.Value?.ToString())" />
+					@if (form.PollOptions.Count > 2)
+					{
+						<DButton Size="DSize.Xs" OnClick="() => form.PollOptions.RemoveAt(index)" title="@Localizer["Remove"]"><i class="ion-md-close"></i></DButton>
+					}
+				</div>
+			}
+			<div class="flex flex-wrap items-center gap-2">
+				@if (form.PollOptions.Count < 4)
+				{
+					<DButton Size="DSize.Xs" OnClick="() => form.PollOptions.Add(string.Empty)"><i class="ion-md-add"></i><span>@Localizer["Add a choice"]</span></DButton>
+				}
+				<DSelect TValue="int" Size="DSize.Xs" class="w-auto" @bind-Value="form.PollExpiresIn" aria-label="@Localizer["Poll length"]">
+					@foreach (var (seconds, label) in PollLengths)
+					{
+						<option value="@seconds">@label</option>
+					}
+				</DSelect>
+				<label class="label text-xs">
+					<input type="checkbox" class="checkbox checkbox-xs" checked="@form.PollMultiple" @onchange="@((ChangeEventArgs e) => form.PollMultiple = e.Value is true)" />
+					<span>@Localizer["Several choices"]</span>
+				</label>
+			</div>
+		</div>
+	}
 
 	@if (form.Media.Count > 0)
 	{
-		<div class="flex flex-col gap-2">
+		<div class="flex flex-col gap-2" data-compose-media>
 			@foreach (var media in form.Media)
 			{
-				<div class="flex w-full items-center gap-3 rounded-xl p-2 md:p-3 neo-raised neo-2xs">
-					@if (media.Base64Preview is { Length: > 0 } preview && media.ContentType.StartsWith("image"))
+				<div class="flex w-full items-center gap-3 rounded-xl p-2 md:p-3 neo-raised neo-2xs" data-upload-state="@media.State.ToString().ToLowerInvariant()">
+					@if (media.Preview is { Length: > 0 } preview)
 					{
 						<img alt="@media.AltText" class="object-cover rounded-lg max-h-20 max-w-24 flex-none" src="@preview" />
 					}
 					else
 					{
-						<i class="text-2xl @form.MediaType.GetMediaTypeIcon()"></i>
+						<i class="text-2xl @(media.ContentType?.StartsWith("video/") == true ? "ion-md-videocam" : media.ContentType?.StartsWith("audio/") == true ? "ion-md-musical-notes" : "ion-md-image")"></i>
 					}
 					<div class="flex flex-col flex-1 min-w-0 gap-1">
-						<p class="text-xs break-all"><b>@media.FileName</b> · @media.ContentType · @media.Size.GetFileSize(Localizer)</p>
-						<DTextarea TValue="string" @bind-Value="media.AltText" Size="DSize.Sm" class="w-full rounded-lg!" autocomplete="off" maxlength="1500"
-								   placeholder="@Localizer["Alternative text"]" rows="1" />
+						<p class="text-xs break-all"><b>@media.FileName</b>@(media.Size > 0 ? $" · {media.Size.GetFileSize(Localizer)}" : null)</p>
+						<p class="inline-flex items-center gap-2 text-xs">
+							@switch (media.State)
+							{
+								case UploadState.Uploading:
+									<DLoading Size="DSize.Xs" LabelText="@Localizer["Uploading"]" /><span>@Localizer["Uploading"]</span>
+									break;
+								case UploadState.Processing:
+									<DLoading Size="DSize.Xs" LabelText="@Localizer["Processing"]" /><span>@Localizer["Processing"]</span>
+									break;
+								case UploadState.Failed:
+									<i class="ion-md-alert text-error"></i><span class="text-error break-words">@media.Error</span>
+									@if (media.File is not null)
+									{
+										<DButton Size="DSize.Xs" OnClick="() => Retry(media)" data-upload-retry>@Localizer["Retry"]</DButton>
+									}
+									break;
+								default:
+									<i class="ion-md-checkmark text-success"></i><span>@Localizer["Ready"]</span>
+									break;
+							}
+						</p>
+						<DTextarea TValue="string" @bind-Value="media.AltText" @bind-Value:after="() => altTextConfirmed = false" Size="DSize.Sm"
+								   class="@(AskingAltText && Undescribed(media) ? "w-full rounded-lg! textarea-warning" : "w-full rounded-lg!")" autocomplete="off" maxlength="1500"
+								   placeholder="@Localizer["Alternative text"]" rows="1" data-alt-text />
 					</div>
-					<DButton Size="DSize.Sm" class="self-start" OnClick="() => form.Media.Remove(media)" title="@Localizer["Delete"]">
+					<DButton Size="DSize.Sm" class="self-start" OnClick="() => Remove(media)" title="@Localizer["Delete"]" aria-label="@Localizer["Delete"]">
 						<i class="ion-md-trash text-base text-error"></i>
 					</DButton>
 				</div>
 			}
 		</div>
+		@if (AskingAltText)
+		{
+			<DAlert Color="DAlertColor.Warning" Variant="DAlertVariant.Soft" class="text-sm" data-alt-reminder>
+				<span>@Localizer["{0} of the pictures have no description, which people who can't see them rely on.", form.Media.Count(Undescribed)]</span>
+				<div class="flex flex-wrap gap-2">
+					<DButton Size="DSize.Sm" OnClick="() => askingAltText = false">@Localizer["Describe them"]</DButton>
+					<DButton Size="DSize.Sm" OnClick="PublishAnyway" data-alt-publish-anyway>@Localizer["Publish anyway"]</DButton>
+				</div>
+			</DAlert>
+		}
 	}
 
 	@if (form.IsLocated)
@@ -69,34 +164,47 @@
 
 	<div class="flex flex-wrap items-center justify-between gap-2">
 		<div class="flex flex-wrap items-center gap-2">
-			@if (!form.IsLocated && GroupId is null)
+			@if (!form.IsLocated && GroupId is null && Editing is null)
 			{
-				<DDropdown @bind-IsOpen="form.IsScopeOptionsOpen" TriggerClass="@(form.IsScopeOptionsOpen ? "btn btn-sm btn-active" : "btn btn-sm")"
-						   ContentClass="mt-2 flex gap-2 p-2 rounded-box" title="@Localizer["Message scope type: {0}", Localizer[form.MessageType.ToString()]]">
+				<DDropdown @bind-IsOpen="form.IsScopeOptionsOpen" TriggerClass="@(form.IsScopeOptionsOpen ? "btn btn-sm btn-active" : "btn btn-sm")" SheetOnNarrow="true"
+						   ContentClass="mt-2 flex flex-col gap-2 p-2 rounded-box" title="@Localizer["Message scope type: {0}", Localizer[form.Visibility.ToString()]]"
+						   aria-label="@Localizer["Message scope type: {0}", Localizer[form.Visibility.ToString()]]">
 					<Trigger>
-						<i class="@form.MessageType.GetMessageTypeIcon() text-base"></i>
+						<i class="@form.Visibility.GetVisibilityIcon() text-base" aria-hidden="true"></i>
 					</Trigger>
 					<ChildContent>
-						@foreach (var messageType in Enum.GetValues<MessageType>())
+						@foreach (var visibility in Enum.GetValues<Visibility>())
 						{
-							<DButton Size="DSize.Sm" Active="form.MessageType == messageType" OnClick="() => SetMessageType(messageType)" title="@Localizer[messageType.ToString()]">
-								<i class="@messageType.GetMessageTypeIcon() text-base"></i>
+							<DButton Size="DSize.Sm" class="justify-start whitespace-nowrap" Active="form.Visibility == visibility" OnClick="() => SetVisibility(visibility)">
+								<i class="@visibility.GetVisibilityIcon() text-base" aria-hidden="true"></i>
+								<span>@Localizer[visibility.ToString()]</span>
 							</DButton>
 						}
 					</ChildContent>
 				</DDropdown>
 			}
 
+			@if (!form.IsLocated && GroupId is null && Editing is null)
+			{
+				@* the language the post is written in, as each language names itself *@
+				<DSelect TValue="string" Size="DSize.Sm" class="w-auto" @bind-Value="form.Language" title="@Localizer["Language"]" data-compose-language>
+					@foreach (var (languageCode, languageName) in Languages.All)
+					{
+						<option value="@languageCode">@languageName</option>
+					}
+				</DSelect>
+			}
+
 			<DButton Size="DSize.Sm" Active="form.HasContentWarning" OnClick="() => form.HasContentWarning = !form.HasContentWarning" title="@Localizer["Content warning"]">
 				<i class="ion-md-warning text-base"></i>
 			</DButton>
 
-			@if (!form.IsLocated && GroupId is null)
+			@if (!form.IsLocated && GroupId is null && !form.HasPoll)
 			{
 				@* A label styled as a button opens the hidden file input. *@
 				<label class="btn btn-sm @(form.Media.Count >= MaximumFileCount ? "btn-disabled" : null)" title="@Localizer["Attach"]">
 					<InputFile accept="@AcceptedFileTypes" class="hidden" multiple="@(form.MediaType is MediaType.Images)" OnChange="OnFileChange"
-							   disabled="@(form.Media.Count >= MaximumFileCount)" />
+							   disabled="@(form.Media.Count >= MaximumFileCount)" data-attach />
 					<i class="ion-md-attach text-base"></i>
 					@if (form.Media.Count != 0)
 					{
@@ -115,12 +223,26 @@
 				</DSelect>
 			}
 
-			@if (InReplyTo is null && GroupId is null)
+			@if (!form.IsLocated && GroupId is null && Editing is null && form.Media.Count == 0)
+			{
+				<DButton Size="DSize.Sm" Active="form.HasPoll" OnClick="() => form.HasPoll = !form.HasPoll" title="@Localizer["Poll"]" data-poll-toggle>
+					<i class="ion-md-stats text-base"></i>
+				</DButton>
+			}
+
+			@if (InReplyTo is null && GroupId is null && Editing is null && Quoting is null)
 			{
 				<DButton Size="DSize.Sm" Active="form.IsLocated" OnClick="ToggleLocated" title="@Localizer["Located post"]">
 					<i class="ion-md-locate text-base"></i>
 				</DButton>
 			}
+
+			@if (!form.IsLocated && GroupId is null && Editing is null)
+			{
+				<DButton Size="DSize.Sm" Active="form.IsScheduled" OnClick="ToggleScheduled" title="@Localizer["Publish later"]" data-schedule>
+					<i class="ion-md-time text-base"></i>
+				</DButton>
+			}
 		</div>
 
 		<DButton Size="DSize.Sm" Type="submit" Color="DColor.Primary" Disabled="IsDefaultDisabled || isPublishing || (form.IsLocated && form.Latitude is null)">
@@ -128,14 +250,28 @@
 			{
 				<DLoading Size="DSize.Xs" LabelText="@Localizer["loading"]" />
 			}
-			<span>@Localizer[InReplyTo is null ? "Post" : "Reply"]</span>
-			<i class="ion-md-send"></i>
+			<span>@SubmitLabel</span>
+			<i class="@(form.IsScheduled ? "ion-md-time" : "ion-md-send")"></i>
 		</DButton>
 	</div>
+
+	@if (form.IsScheduled && !form.IsLocated && GroupId is null)
+	{
+		<div class="flex flex-wrap items-center gap-2 text-sm">
+			<label class="flex flex-wrap items-center gap-2">
+				<span>@Localizer["Publish it on"]</span>
+				<DInput TValue="string" type="datetime-local" Size="DSize.Sm" class="w-auto" @bind-Value="form.ScheduledAt" autocomplete="off"
+						min="@DateTime.Now.AddMinutes(6).ToString("yyyy-MM-ddTHH:mm")" data-schedule-at />
+			</label>
+			<a class="link text-xs" href="scheduled">@Localizer["Scheduled posts"]</a>
+		</div>
+	}
 </EditForm>
 
 @code {
 	[Inject] StatusService StatusService { get; set; }
+	[Inject] MediaService MediaService { get; set; }
+	[Inject] AccountService AccountService { get; set; }
 	[Inject] ILoggingService Logger { get; set; }
 	[Inject] IJSRuntime JS { get; set; }
 
@@ -143,48 +279,182 @@
 	[Parameter] public Status InReplyTo { get; set; }
 	/// <summary>The community or circle the post is for.</summary>
 	[Parameter] public string GroupId { get; set; }
+	/// <summary>The post this one quotes (shown under the words).</summary>
+	[Parameter] public Status Quoting { get; set; }
+	/// <summary>The persona's own post being edited: its words come from /source, and saving replaces them.</summary>
+	[Parameter] public Status Editing { get; set; }
 	/// <summary>The published post, to show it; a located or group post comes back as null (it is not on the Mastodon API).</summary>
 	[Parameter] public EventCallback<FeedPost> OnPublished { get; set; }
 
 	ComposeForm form = new();
 	List<string> fileErrors = [];
+	// what the words end with while a mention or a hashtag is being written: its sign and what follows it
+	static readonly Regex Typing = new(@"(?:^|\s)([@#])([\p{L}\p{N}_][\p{L}\p{N}_.\-]*(?:@[\p{L}\p{N}.\-]*)?)$", RegexOptions.Compiled);
+	List<Account> suggestedAccounts = [];
+	List<StatusTag> suggestedTags = [];
+	// the newest lookup: an older one's answer comes too late to show
+	int suggesting;
 	string error;
 	bool isPublishing;
 
 	int ContentLength => form.Content?.Length ?? 0;
 
+	// what is being written, once typing pauses, among the accounts and hashtags this server knows
+	async Task Typed()
+	{
+		var typed = Typing.Match(form.Content ?? "");
+		var lookup = ++suggesting;
+		if (!typed.Success || typed.Groups[2].Length < 2)
+		{
+			suggestedAccounts = [];
+			suggestedTags = [];
+			return;
+		}
+		await Task.Delay(300);
+		if (lookup != suggesting)
+			return;
+		var hashtags = typed.Groups[1].Value == "#";
+		var found = await AccountService.Suggest(typed.Groups[2].Value, hashtags);
+		if (lookup != suggesting)
+			return;
+		suggestedAccounts = hashtags ? [] : [.. found.Accounts.Take(5)];
+		suggestedTags = hashtags ? [.. found.Hashtags.Take(5)] : [];
+	}
+
+	// the mention or hashtag being written, written out
+	void Complete(string written)
+	{
+		var typed = Typing.Match(form.Content ?? "");
+		suggesting++;
+		suggestedAccounts = [];
+		suggestedTags = [];
+		if (!typed.Success)
+			return;
+		form.Content = form.Content[..typed.Groups[1].Index] + written + " ";
+		focusPending = true;
+	}
+
+	string Placeholder => Editing is not null ? Localizer["Edit your post"]
+		: Quoting is not null ? Localizer["Say something about it"]
+		: InReplyTo is null ? Localizer["What's happening?"]
+		: Localizer["Reply to {0}", "@" + InReplyTo.Account?.Acct];
+
+	string SubmitLabel => Editing is not null ? Localizer["Save"]
+		: form.IsScheduled ? Localizer["Schedule"]
+		: Quoting is not null ? Localizer["Quote"]
+		: Localizer[InReplyTo is null ? "Post" : "Reply"];
+
+	(int Seconds, string Label)[] PollLengths =>
+	[
+		(300, Localizer["5 minutes"]), (1800, Localizer["30 minutes"]), (3600, Localizer["1 hour"]), (21600, Localizer["6 hours"]),
+		(86400, Localizer["1 day"]), (259200, Localizer["3 days"]), (604800, Localizer["7 days"])
+	];
+
 	int MaximumFileCount => form.MediaType is MediaType.Images ? 4 : 1;
 
-	long MaximumFileSize => form.MediaType switch
+	// what the server takes: its types and sizes (/api/v2/instance), its defaults until they are read
+	MediaConfiguration limits = new();
+	// before publishing pictures without a description, asked once (the reader's setting); "Publish anyway" goes on
+	bool askingAltText;
+	bool altTextConfirmed;
+
+	bool AskingAltText => askingAltText && form.Media.Any(Undescribed);
+
+	static bool Undescribed(UploadMedia media) => media.ContentType?.StartsWith("image/") == true && string.IsNullOrWhiteSpace(media.AltText);
+
+	long MaximumFileSize(string type) => type.StartsWith("image/") ? limits.ImageSizeLimit : limits.VideoSizeLimit;
+
+	bool OfKind(string type) => form.MediaType switch
 	{
-		MediaType.Images => 16_777_216,
-		MediaType.Audio => 41_943_040,
-		_ => 99_614_720
+		MediaType.Images => type.StartsWith("image/"),
+		MediaType.Video => type.StartsWith("video/"),
+		_ => type.StartsWith("audio/")
 	};
 
-	string AcceptedFileTypes => form.MediaType switch
+	// the server's types of the kind chosen, and the extensions a file picker may know them by
+	string AcceptedFileTypes => string.Join(",", limits.SupportedMimeTypes.Where(OfKind).Concat(Extensions.Where(e => OfKind(e.Value)).Select(e => e.Key)));
+
+	static readonly Dictionary<string, string> Extensions = new(StringComparer.OrdinalIgnoreCase)
 	{
-		MediaType.Images => ".jpg,.jpeg,.png,.gif,.webp,.avif",
-		MediaType.Video => ".mp4,.m4v,.webm,.mov",
-		MediaType.Audio => ".mp3,.ogg,.oga,.opus,.wav,.flac,.m4a",
-		_ => default
+		[".jpg"] = "image/jpeg", [".jpeg"] = "image/jpeg", [".png"] = "image/png", [".gif"] = "image/gif", [".webp"] = "image/webp",
+		[".avif"] = "image/avif", [".mp4"] = "video/mp4", [".m4v"] = "video/mp4", [".mov"] = "video/quicktime", [".webm"] = "video/webm",
+		[".mp3"] = "audio/mpeg", [".ogg"] = "audio/ogg", [".oga"] = "audio/ogg", [".opus"] = "audio/ogg", [".wav"] = "audio/wav",
+		[".flac"] = "audio/flac", [".m4a"] = "audio/mp4"
 	};
 
-	protected override void OnInitialized()
+	// what a file is: the browser's word, else its extension's
+	static string TypeOf(IBrowserFile file) => file.ContentType is { Length: > 0 } type ? type.ToLowerInvariant()
+		: Extensions.GetValueOrDefault(Path.GetExtension(file.Name) ?? string.Empty);
+
+	// a new post starts in the language the persona chose in Settings, else in the reader's
+	string DefaultLanguage => CascadingState.Persona?.Source?.Language is { Length: > 0 } chosen ? chosen
+		: System.Globalization.CultureInfo.CurrentUICulture.TwoLetterISOLanguageName;
+
+	// a new post starts with the visibility the persona chose in Settings
+	Visibility DefaultVisibility => CascadingState.Persona?.Source?.Privacy switch
+	{
+		"private" => Visibility.FollowersOnly,
+		"unlisted" => Visibility.Unlisted,
+		_ => Visibility.Public
+	};
+
+	DTextarea<string> textarea;
+	// the words take the focus when the composer opens, and again after a suggestion is picked
+	bool focusPending = true;
+
+	protected override async Task OnAfterRenderAsync(bool firstRender)
+	{
+		if (!focusPending)
+			return;
+		focusPending = false;
+		await textarea.Element.FocusAsync();
+	}
+
+	protected override async Task OnInitializedAsync()
 	{
-		IsLoading = false;
 		form.GroupId = GroupId;
+		form.Visibility = DefaultVisibility;
+		form.Language = DefaultLanguage;
+		form.Sensitive = CascadingState.Persona?.Source?.Sensitive == true;
+		form.QuotedStatusId = Quoting?.Id;
+		limits = await MediaService.Limits();
+		if (Editing is not null)
+		{
+			var source = await StatusService.Source(Editing.Id);
+			form.Content = source?.Text;
+			form.HasContentWarning = source?.SpoilerText is { Length: > 0 };
+			form.SpoilerText = source?.SpoilerText;
+			// the post as it is: its language, its sensitive flag and its media, which the edit sends back
+			form.Language = Editing.Language ?? form.Language;
+			form.Sensitive = Editing.Sensitive;
+			form.Media = [.. Editing.MediaAttachments.Select(m => new UploadMedia
+			{
+				Id = m.Id,
+				State = UploadState.Ready,
+				Posted = true,
+				AltText = m.Description,
+				SentAltText = m.Description,
+				Preview = m.Type is "image" or "gifv" or "video" ? m.PreviewUrl : null,
+				ContentType = m.Type switch { "image" => "image/jpeg", "video" or "gifv" => "video/mp4", "audio" => "audio/mpeg", _ => null },
+				FileName = Path.GetFileName(m.Url ?? string.Empty)
+			})];
+			if (form.Media.FirstOrDefault()?.ContentType is { } kind)
+				form.MediaType = kind.StartsWith("video/") ? MediaType.Video : kind.StartsWith("audio/") ? MediaType.Audio : MediaType.Images;
+		}
+		IsLoading = false;
 		if (InReplyTo is null)
 			return;
 
 		form.InReplyToId = InReplyTo.Id;
-		form.MessageType = InReplyTo.Visibility switch
+		form.Visibility = InReplyTo.Visibility switch
 		{
-			"direct" => MessageType.Direct,
-			"private" => MessageType.FollowersOnly,
-			"unlisted" => MessageType.Unlisted,
-			_ => MessageType.Public
+			"direct" => Visibility.Direct,
+			"private" => Visibility.FollowersOnly,
+			"unlisted" => Visibility.Unlisted,
+			_ => Visibility.Public
 		};
+		// a reply is written in its thread's language, as a rule
+		form.Language = InReplyTo.Language is { Length: 2 } language && Languages.All.Any(l => l.Code == language) ? language : form.Language;
 		form.HasContentWarning = InReplyTo.SpoilerText is { Length: > 0 };
 		form.SpoilerText = InReplyTo.SpoilerText;
 		var mentions = InReplyTo.Mentions.Select(m => m.Acct).Prepend(InReplyTo.Account?.Acct)
@@ -192,12 +462,20 @@
 		form.Content = string.Join(' ', mentions) is { Length: > 0 } prefix ? prefix + " " : null;
 	}
 
-	void SetMessageType(MessageType messageType)
+	void SetVisibility(Visibility visibility)
 	{
-		form.MessageType = messageType;
+		form.Visibility = visibility;
 		form.IsScopeOptionsOpen = false;
 	}
 
+	// a scheduled post starts an hour ahead, which the reader moves as it likes
+	void ToggleScheduled()
+	{
+		form.IsScheduled = !form.IsScheduled;
+		if (form.IsScheduled && string.IsNullOrEmpty(form.ScheduledAt))
+			form.ScheduledAt = DateTime.Now.AddHours(1).ToString("yyyy-MM-ddTHH:mm");
+	}
+
 	async Task ToggleLocated()
 	{
 		form.IsLocated = !form.IsLocated;
@@ -227,40 +505,121 @@
 
 		foreach (var file in eventArgs.GetMultipleFiles(MaximumFileCount))
 		{
-			if (file.Size > MaximumFileSize)
+			var type = TypeOf(file);
+			if (type is null || !limits.SupportedMimeTypes.Contains(type) || !OfKind(type))
+			{
+				fileErrors.Add(Localizer["\"{0}\" is not a kind of file this server takes.", file.Name]);
+				continue;
+			}
+			if (file.Size > MaximumFileSize(type))
 			{
 				fileErrors.Add(Localizer["Supplied file \"{0}\" with size {1} exceeds the maximum of {2}.", file.Name,
-					file.Size.GetFileSize(Localizer), MaximumFileSize.GetFileSize(Localizer)]);
+					file.Size.GetFileSize(Localizer), MaximumFileSize(type).GetFileSize(Localizer)]);
 				continue;
 			}
 
-			if (await ReadFile(file) is { } media)
+			// the post's at once, and uploading (a publish meanwhile waits for it); its small picture follows
+			var media = new UploadMedia { File = file, FileName = file.Name, ContentType = type, Size = file.Size };
 			form.Media.Add(media);
-			else
-				fileErrors.Add(Localizer["The file \"{0}\" could not be read.", file.Name]);
+			altTextConfirmed = false;
+			Start(media);
+			if (type.StartsWith("image/"))
+				media.Preview = await Thumbnail(file);
 		}
 	}
 
-	/// <summary>Reads a picked file into memory; null when the browser can't read it (logged).</summary>
-	async Task<UploadMedia> ReadFile(IBrowserFile file, CancellationToken cancellationToken = default)
+	// a small picture of it, which the browser makes (nothing of the whole file stays in memory); none when it can't
+	async Task<string> Thumbnail(IBrowserFile file)
 	{
 		try
 		{
-			using var memoryStream = new MemoryStream();
-			await using var fileStream = file.OpenReadStream(MaximumFileSize, cancellationToken);
-			await fileStream.CopyToAsync(memoryStream, cancellationToken);
-			var media = new UploadMedia { FileName = file.Name, ContentType = file.ContentType, Size = file.Size, Blob = memoryStream.ToArray() };
-			if (file.ContentType.StartsWith("image"))
-				media.Base64Preview = $"data:{media.ContentType};base64,{Convert.ToBase64String(media.Blob)}";
-			return media;
+			var small = await file.RequestImageFileAsync("image/jpeg", 320, 320);
+			await using var stream = small.OpenReadStream(2 * 1024 * 1024);
+			using var buffer = new MemoryStream();
+			await stream.CopyToAsync(buffer);
+			return $"data:image/jpeg;base64,{Convert.ToBase64String(buffer.ToArray())}";
 		}
 		catch (Exception ex)
 		{
-			await Logger.ProcessError(ex, $"{nameof(Composer)}.{nameof(ReadFile)}:{file.Name}", cancellationToken);
+			await Logger.ProcessWarning($"No preview of {file.Name}: {ex.Message}", $"{nameof(Composer)}.{nameof(Thumbnail)}");
 			return default;
 		}
 	}
 
+	void Start(UploadMedia media)
+	{
+		media.Cancel = new();
+		media.State = UploadState.Uploading;
+		media.Error = default;
+		media.Done = Upload(media, media.Cancel.Token);
+	}
+
+	// uploads it, then follows what the server still processes (audio and video) until it is ready or refused
+	async Task Upload(UploadMedia media, CancellationToken cancellationToken)
+	{
+		var uploaded = await MediaService.Upload(media, MaximumFileSize(media.ContentType), cancellationToken);
+		if (cancellationToken.IsCancellationRequested)
+			return;
+		if (uploaded.IsInvalid)
+		{
+			media.State = UploadState.Failed;
+			media.Error = uploaded.ErrorMessage;
+			await InvokeAsync(StateHasChanged);
+			return;
+		}
+		var attachment = (MediaAttachment)uploaded.Data;
+		media.Id = attachment.Id;
+		media.SentAltText = attachment.Description;
+		media.State = attachment.Url is null ? UploadState.Processing : UploadState.Ready;
+		await InvokeAsync(StateHasChanged);
+		while (media.State == UploadState.Processing && !cancellationToken.IsCancellationRequested)
+		{
+			try
+			{
+				await Task.Delay(2000, cancellationToken);
+			}
+			catch (OperationCanceledException)
+			{
+				return;
+			}
+			var processed = await MediaService.Get(media.Id, cancellationToken);
+			if (cancellationToken.IsCancellationRequested)
+				return;
+			if (processed.IsInvalid)
+			{
+				media.State = UploadState.Failed;
+				media.Error = processed.ErrorMessage;
+			}
+			else if (processed.Data is MediaAttachment)
+				media.State = UploadState.Ready;
+			await InvokeAsync(StateHasChanged);
+		}
+	}
+
+	// a failed upload again, from the same file (the browser can still read it unless files were picked since)
+	void Retry(UploadMedia media) => Start(media);
+
+	void Remove(UploadMedia media)
+	{
+		media.Cancel?.Cancel();
+		form.Media.Remove(media);
+	}
+
+	// the reader chose to publish its pictures without descriptions
+	async Task PublishAnyway()
+	{
+		altTextConfirmed = true;
+		askingAltText = false;
+		await Publish();
+	}
+
+	public override async ValueTask DisposeAsync()
+	{
+		foreach (var media in form.Media)
+			media.Cancel?.Cancel();
+		await base.DisposeAsync();
+	}
+
 	async Task Publish()
 	{
 		error = default;
@@ -269,12 +628,54 @@
 			error = Localizer["Missing content, either message or media"];
 			return;
 		}
+		if (form.HasPoll && form.PollOptions.Count(o => !string.IsNullOrWhiteSpace(o)) < 2)
+		{
+			error = Localizer["A poll needs two choices at least."];
+			return;
+		}
+		if (!altTextConfirmed && CascadingState.PublicCacheData.PageSettings.RemindAltText && form.Media.Any(Undescribed))
+		{
+			askingAltText = true;
+			return;
+		}
+		// what is still uploading or processing is waited for
+		if (form.Media.Any(m => m.State is UploadState.Uploading or UploadState.Processing))
+		{
+			isPublishing = true;
+			await Task.WhenAll(form.Media.Select(m => m.Done));
+			isPublishing = false;
+		}
+		if (Editing is not null)
+		{
+			isPublishing = true;
+			var edited = await StatusService.Edit(Editing.Id, form);
+			isPublishing = false;
+			if (edited.IsInvalid)
+			{
+				error = edited.ErrorMessage;
+				return;
+			}
+			Toast.AddResponseSuccess(Localizer["Saved."]);
+			await OnPublished.InvokeAsync(FeedPost.Of((Status)edited.Data));
+			return;
+		}
 		if (CascadingState.PersonaId is null)
 		{
 			error = Localizer["Choose a persona first."];
 			return;
 		}
 
+		if (form.IsScheduled && form.ScheduledAtUtc is not { } at)
+		{
+			error = Localizer["Choose when to publish it."];
+			return;
+		}
+		if (form.ScheduledAtUtc < DateTime.UtcNow.AddMinutes(5))
+		{
+			error = Localizer["A post is scheduled at least five minutes ahead."];
+			return;
+		}
+
 		isPublishing = true;
 		var result = await StatusService.Publish(form, CascadingState.PersonaId);
 		isPublishing = false;
@@ -284,9 +685,17 @@
 			return;
 		}
 
+		if (result.Data is ScheduledStatus scheduled)
+		{
+			Toast.AddResponseSuccess(Localizer["Scheduled for {0}.", scheduled.ScheduledAt.ToLocalTime().ToString(SUtility.dateTimeFormatExt)]);
+			form = new() { GroupId = GroupId, Visibility = DefaultVisibility, Language = DefaultLanguage };
+			await OnPublished.InvokeAsync(null);
+			return;
+		}
+
 		Toast.AddResponseSuccess(form.IsLocated ? Localizer["Located post published."] : Localizer["Published."]);
 		var published = result.Data as FeedPost;
-		form = new() { GroupId = GroupId };
+		form = new() { GroupId = GroupId, Visibility = DefaultVisibility, Language = DefaultLanguage };
 		await OnPublished.InvokeAsync(published);
 	}
 

Components/ConfirmHost.razor

@@ -0,0 +1,40 @@
+@inherits LocalizableComponentBase
+@implements IDisposable
+
+@* The question ConfirmService asks before what can't be undone, in MainLayout: a sheet from the bottom on a phone, a
+   dialog in the middle from md. Closing it in any way answers no. *@
+<DModal Placement="DModalPlacement.ResponsiveBottom" IsOpen="Confirm.IsAsking" IsOpenChanged="Closed" CloseText="@Localizer["Close"]" data-confirm>
+	<Heading>@Confirm.Heading</Heading>
+	<ChildContent>
+		@if (Confirm.Text is { Length: > 0 } text)
+		{
+			<p class="text-sm">@text</p>
+		}
+	</ChildContent>
+	<Actions>
+		<DButton class="max-md:flex-1" OnClick="() => Confirm.Answer(false)" data-confirm-no>@Localizer["Cancel"]</DButton>
+		<DButton class="max-md:flex-1" Color="@(Confirm.Danger ? DColor.Error : DColor.Primary)" OnClick="() => Confirm.Answer(true)" data-confirm-yes>
+			@Confirm.ConfirmText
+		</DButton>
+	</Actions>
+</DModal>
+
+@code {
+	[Inject] ConfirmService Confirm { get; set; }
+
+	protected override void OnInitialized()
+	{
+		Confirm.Changed += Refresh;
+		IsLoading = false;
+	}
+
+	void Refresh() => InvokeAsync(StateHasChanged);
+
+	void Closed(bool open)
+	{
+		if (!open)
+			Confirm.Answer(false);
+	}
+
+	public void Dispose() => Confirm.Changed -= Refresh;
+}

Components/Daisy/Actions/DButton.razor

@@ -3,7 +3,8 @@
 @* daisyUI Button: https://daisyui.com/components/button/ . Renders an <a> when Href is set. *@
 @if (Href is null)
 {
-	<button @attributes="AdditionalAttributes" type="@Type" class="@CssClass" disabled="@Disabled" @onclick="OnClick">
+	<button @attributes="AdditionalAttributes" type="@Type" class="@CssClass" disabled="@Disabled" @onclick="OnClick"
+			@onmousedown:preventDefault="KeepFocus">
 		@ChildContent
 	</button>
 }
@@ -27,6 +28,8 @@ else
 	[Parameter] public string Type { get; set; } = "button";
 	[Parameter] public string Href { get; set; }
 	[Parameter] public EventCallback<MouseEventArgs> OnClick { get; set; }
+	/// <summary>Pressing it doesn't take the focus from where it is (a chip that writes into a focused textarea).</summary>
+	[Parameter] public bool KeepFocus { get; set; }
 
 	string CssClass => Cx("btn", ColorClass, VariantClass, SizeClass, ShapeClass,
 		Active ? "btn-active" : null, Disabled && Href is not null ? "btn-disabled" : null, Class);

Components/Daisy/Actions/DDropdown.razor

@@ -1,19 +1,24 @@
 @inherits DComponentBase
+@implements IDisposable
 
 @* daisyUI Dropdown: https://daisyui.com/components/dropdown/ . The open state lives in C# (@bind-IsOpen):
    dropdown-open shows the content and dropdown-close keeps the focus-within rule from showing it while closed.
    While open, a transparent full-screen layer under the content closes it on an outside click; Escape closes it
-   too. With Hover the CSS hover rule opens it instead. *@
+   too. With Hover the CSS hover rule opens it instead. Opening moves the focus into the content (Blazor's FocusAsync),
+   which also scrolls a menu cut off by its scroller into view; Escape or an outside click gives it back to the trigger.
+   SheetOnNarrow makes the content a sheet rising from the bottom of a phone's screen (below md), over a dimmed page. *@
 <div @attributes="AdditionalAttributes" class="@CssClass" @onkeydown="OnKeyDown">
-	<div role="button" tabindex="0" class="@TriggerClass" aria-haspopup="true" aria-expanded="@(IsOpen ? "true" : "false")"
+	<div @ref="trigger" role="button" tabindex="0" class="@TriggerClass" aria-haspopup="true" aria-expanded="@(IsOpen ? "true" : "false")"
 		 @onclick="Toggle">
 		@Trigger
 	</div>
 	@if (IsOpen)
 	{
-		<div class="fixed inset-0 z-[998] cursor-default" aria-hidden="true" @onclick="Close"></div>
+		<div class="@(SheetOnNarrow ? "fixed inset-0 z-[998] cursor-default max-md:bg-black/40" : "fixed inset-0 z-[998] cursor-default")"
+			 aria-hidden="true" @onclick="Close"></div>
 	}
-	<div tabindex="-1" class="@Cx("dropdown-content z-[999]", ContentClass)" @onclick="OnContentClick">
+	<div @ref="content" tabindex="-1" class="@Cx("dropdown-content z-[999]", SheetOnNarrow ? Sheet : null, ContentClass)"
+		 data-sheet="@(SheetOnNarrow ? "" : null)" @onclick="OnContentClick">
 		@ChildContent
 	</div>
 </div>
@@ -31,6 +36,21 @@
 	[Parameter] public bool CloseOnContentClick { get; set; }
 	[Parameter] public string TriggerClass { get; set; }
 	[Parameter] public string ContentClass { get; set; }
+	/// <summary>Below md, the content is a sheet at the bottom of the screen instead of hanging from the trigger.</summary>
+	[Parameter] public bool SheetOnNarrow { get; set; }
+
+	const string Sheet = "max-md:fixed max-md:inset-x-0 max-md:bottom-0 max-md:top-auto max-md:m-0 max-md:w-full max-md:max-h-[80dvh] "
+		+ "max-md:overflow-y-auto max-md:overscroll-contain max-md:rounded-b-none max-md:translate-none max-md:scale-100 "
+		+ "max-md:p-3 max-md:pb-[max(0.75rem,env(safe-area-inset-bottom))]";
+
+	/// <summary>Where it says it is open, so the Back button closes it (cascaded by the app; none, none said).</summary>
+	[CascadingParameter] IDOverlayHost Overlays { get; set; }
+
+	ElementReference trigger;
+	ElementReference content;
+	IDisposable overlay;
+	bool focusContent;
+	bool focusTrigger;
 
 	string CssClass => Cx("dropdown", PlacementClass, AlignClass,
 		IsOpen ? "dropdown-open" : Hover ? "dropdown-hover" : "dropdown-close", Class);
@@ -50,17 +70,54 @@
 		_ => null
 	};
 
-	Task Toggle() => SetOpen(!IsOpen);
+	protected override void OnParametersSet() => TrackOverlay();
 
-	Task Close() => SetOpen(false);
-
-	Task OnContentClick() => CloseOnContentClick ? SetOpen(false) : Task.CompletedTask;
-
-	Task OnKeyDown(KeyboardEventArgs e) => e.Key == "Escape" && IsOpen ? SetOpen(false) : Task.CompletedTask;
-
-	async Task SetOpen(bool isOpen)
+	void TrackOverlay()
 	{
+		if (IsOpen && overlay is null)
+			overlay = Overlays?.Open(() => InvokeAsync(async () =>
+			{
+				await SetOpen(false, true);
+				StateHasChanged();
+			}));
+		else if (!IsOpen && overlay is not null)
+		{
+			overlay.Dispose();
+			overlay = null;
+		}
+	}
+
+	public void Dispose() => overlay?.Dispose();
+
+	protected override async Task OnAfterRenderAsync(bool firstRender)
+	{
+		if (focusContent)
+		{
+			focusContent = false;
+			await content.FocusAsync();
+		}
+		if (focusTrigger)
+		{
+			focusTrigger = false;
+			await trigger.FocusAsync();
+		}
+	}
+
+	Task Toggle() => SetOpen(!IsOpen, IsOpen);
+
+	Task Close() => SetOpen(false, true);
+
+	// (a menu item may open a dialog, which takes the focus itself: the trigger doesn't take it back)
+	Task OnContentClick() => CloseOnContentClick ? SetOpen(false, false) : Task.CompletedTask;
+
+	Task OnKeyDown(KeyboardEventArgs e) => e.Key == "Escape" && IsOpen ? SetOpen(false, true) : Task.CompletedTask;
+
+	async Task SetOpen(bool isOpen, bool giveFocusBack)
+	{
+		focusContent = isOpen && !IsOpen;
+		focusTrigger = !isOpen && IsOpen && giveFocusBack;
 		IsOpen = isOpen;
+		TrackOverlay();
 		await IsOpenChanged.InvokeAsync(isOpen);
 	}
 }

Components/Daisy/Actions/DModal.razor

@@ -1,14 +1,32 @@
 @inherits DComponentBase
+@implements IDisposable
 
 @* daisyUI Modal: https://daisyui.com/components/modal/ . Always rendered; the open state lives in C# (@bind-IsOpen)
    and shows as modal-open. On opening, the box takes the focus (Blazor's FocusAsync) so that Escape, handled on the
-   root, closes it; the backdrop button stretches over the area outside the box and closes it on click. *@
+   root, closes it; the backdrop button stretches over the area outside the box and closes it on click, and a visible
+   close button (ShowClose, named by CloseText) sits beside the heading, which stays in view while the box scrolls. *@
 <div @attributes="AdditionalAttributes" role="dialog" aria-modal="true" aria-labelledby="@(Heading is null ? null : uid)"
 	 class="@CssClass" @onkeydown="OnKeyDown">
 	<div @ref="box" tabindex="-1" class="@Cx("modal-box focus:outline-none", BoxClass)">
+		@if (Heading is not null || ShowClose)
+		{
+			<div class="sticky top-0 z-10 flex items-start gap-3 bg-base-100">
 				@if (Heading is not null)
 				{
-			<h3 id="@uid" class="text-lg font-bold">@Heading</h3>
+					<h3 id="@uid" class="flex-1 min-w-0 text-lg font-bold">@Heading</h3>
+				}
+				else
+				{
+					<span class="flex-1"></span>
+				}
+				@if (ShowClose)
+				{
+					<button type="button" class="btn btn-sm btn-circle btn-ghost flex-none" aria-label="@CloseText" title="@CloseText"
+							@onclick="Close" data-modal-close>
+						<span aria-hidden="true">✕</span>
+					</button>
+				}
+			</div>
 		}
 		@ChildContent
 		@if (Actions is not null)
@@ -35,11 +53,17 @@
 	[Parameter] public DModalPlacement Placement { get; set; }
 	/// <summary>Close on a click outside the box (renders the modal-backdrop).</summary>
 	[Parameter] public bool CloseOnBackdrop { get; set; } = true;
-	/// <summary>Text of the invisible backdrop button, read by screen readers.</summary>
+	/// <summary>Name of the close button and of the invisible backdrop button, read by screen readers.</summary>
 	[Parameter] public string CloseText { get; set; } = "close";
+	/// <summary>A visible close button beside the heading.</summary>
+	[Parameter] public bool ShowClose { get; set; } = true;
 	[Parameter] public string BoxClass { get; set; }
 
+	/// <summary>Where it says it is open, so the Back button closes it (cascaded by the app; none, none said).</summary>
+	[CascadingParameter] IDOverlayHost Overlays { get; set; }
+
 	readonly string uid = "d" + Guid.NewGuid().ToString("N")[..8];
+	IDisposable overlay;
 	ElementReference box;
 	bool wasOpen;
 	bool focusPending;
@@ -52,6 +76,7 @@
 		DModalPlacement.Bottom => "modal-bottom",
 		DModalPlacement.Start => "modal-start",
 		DModalPlacement.End => "modal-end",
+		DModalPlacement.ResponsiveBottom => "modal-bottom md:modal-middle",
 		_ => null
 	};
 
@@ -60,8 +85,26 @@
 		if (IsOpen && !wasOpen)
 			focusPending = true;
 		wasOpen = IsOpen;
+		TrackOverlay();
 	}
 
+	void TrackOverlay()
+	{
+		if (IsOpen && overlay is null)
+			overlay = Overlays?.Open(() => InvokeAsync(async () =>
+			{
+				await SetOpen(false);
+				StateHasChanged();
+			}));
+		else if (!IsOpen && overlay is not null)
+		{
+			overlay.Dispose();
+			overlay = null;
+		}
+	}
+
+	public void Dispose() => overlay?.Dispose();
+
 	protected override async Task OnAfterRenderAsync(bool firstRender)
 	{
 		if (!focusPending)
@@ -78,6 +121,7 @@
 	{
 		IsOpen = isOpen;
 		wasOpen = isOpen;
+		TrackOverlay();
 		await IsOpenChanged.InvokeAsync(isOpen);
 	}
 }

Components/Daisy/Actions/DModalEnums.cs

@@ -7,5 +7,7 @@ public enum DModalPlacement
 	Top,
 	Bottom,
 	Start,
-	End
+	End,
+	/// <summary>A sheet rising from the bottom below md (phones), in the middle from md.</summary>
+	ResponsiveBottom
 }

Components/Daisy/DInputBase.cs

@@ -1,5 +1,7 @@
 using System.Globalization;
 
+using decePubClient.Resources;
+
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Forms;
 
@@ -39,7 +41,7 @@ public abstract class DInputBase<TValue> : InputBase<TValue>
 			return true;
 		}
 
-		validationErrorMessage = $"The {DisplayName ?? FieldIdentifier.FieldName} field is not valid.";
+		validationErrorMessage = string.Format(ErrorMessages.InvalidValue, DisplayName ?? FieldIdentifier.FieldName);
 		return false;
 	}
 }

Components/Daisy/DataDisplay/DTable.razor

@@ -2,10 +2,11 @@
 
 @* daisyUI Table: https://daisyui.com/components/table/ . ChildContent is the <thead>/<tbody>/<tfoot> markup. Class and
    the other attributes go on the <table>; with Scroll (the default) it sits in an overflow-x-auto div, whose classes
-   are WrapperClass (pinned rows need it to have a height, e.g. h-96). *@
+   are WrapperClass (pinned rows need it to have a height, e.g. h-96); it is marked as a strip that scrolls sideways on
+   purpose (data-scroll-x), which the phone tests allow. *@
 @if (Scroll)
 {
-	<div class="@Cx("overflow-x-auto", WrapperClass)">
+	<div class="@Cx("overflow-x-auto", WrapperClass)" data-scroll-x>
 		<table @attributes="AdditionalAttributes" class="@CssClass">@ChildContent</table>
 	</div>
 }

Components/Daisy/DataInput/DCalendar.razor

@@ -32,7 +32,7 @@
 			result = date;
 			return true;
 		}
-		validationErrorMessage = $"The {DisplayName ?? FieldIdentifier.FieldName} field is not a valid date.";
+		validationErrorMessage = string.Format(ErrorMessages.InvalidDate, DisplayName ?? FieldIdentifier.FieldName);
 		return false;
 	}
 

Components/Daisy/DataInput/DTextarea.razor

@@ -3,10 +3,13 @@
 
 @* daisyUI Textarea: https://daisyui.com/components/textarea/ . Blazor sets the textarea's value property, so the bound
    value is the content; rows, placeholder and the like pass through. *@
-<textarea @attributes="InputAttributes" class="@CssClassFull" name="@NameAttribute" value="@CurrentValueAsString"
+<textarea @ref="Element" @attributes="InputAttributes" class="@CssClassFull" name="@NameAttribute" value="@CurrentValueAsString"
 		  @oninput="OnInput" @onchange="OnChange" aria-invalid="@(IsInvalid ? "true" : null)"></textarea>
 
 @code {
+	/// <summary>The textarea itself, for focusing it.</summary>
+	public ElementReference Element { get; private set; }
+
 	[Parameter] public DColor Color { get; set; }
 	[Parameter] public DSize Size { get; set; }
 	[Parameter] public bool Ghost { get; set; }

Components/Daisy/IDOverlayHost.cs

@@ -0,0 +1,11 @@
+namespace decePubClient.Components.Daisy;
+
+/// <summary>
+/// Where an open overlay (a dialog, a menu, a sheet) says it is open, so that the phone's Back button closes it instead
+/// of leaving the page: Open registers how to close it and returns what ends the registration once it is closed. The
+/// app cascades one (OverlayService, from MainLayout); a component without one simply doesn't register.
+/// </summary>
+public interface IDOverlayHost
+{
+	IDisposable Open(Func<Task> close);
+}

Components/Daisy/Navigation/DTab.razor

@@ -9,6 +9,8 @@
 	[Parameter] public RenderFragment ChildContent { get; set; }
 	[Parameter] public bool Disabled { get; set; }
 	[Parameter] public string Class { get; set; }
+	/// <summary>The tab's name for a screen reader and as its tooltip, when its Header shows only an icon.</summary>
+	[Parameter] public string AccessibleName { get; set; }
 
 	protected override void OnInitialized()
 	{

Components/Daisy/Navigation/DTabs.razor

@@ -12,6 +12,7 @@
 		var index = i;
 		var tab = tabs[i];
 		<button type="button" role="tab" aria-selected="@(index == Active ? "true" : "false")" disabled="@tab.Disabled"
+				aria-label="@tab.AccessibleName" title="@tab.AccessibleName"
 				class="@Cx("tab", index == Active ? "tab-active" : null, tab.Disabled ? "tab-disabled" : null, tab.Class)"
 				@onclick="() => Select(index)">
 			@tab.Header

Components/Feed/FeedTabs.razor

@@ -1,18 +1,30 @@
 @inherits LocalizableComponentBase
 
 @* The feed page's tabs, one per kind of feed, scrolling sideways on narrow screens. Groups adds a choice of the
-   persona's communities and circles, Tag the hashtag being followed. The stats icon shows how the current feed was
+   persona's communities and circles, Lists a choice of its lists (made and filled on /lists), Tag the hashtag being
+   read, with its week and a button to follow it (its public posts then come home). The stats icon shows how the current feed was
    read; the buttons on the right open the composer and, on narrow screens, the globe. *@
 <div class="flex flex-col gap-2">
 	<div class="flex items-center gap-2 min-w-0">
-		<div class="flex-1 min-w-0 overflow-x-auto">
-			<DTabs Active="ActiveIndex" ActiveChanged="Select" Variant="DTabsVariant.Box" Size="DSize.Sm" ContentClass="hidden" class="flex-nowrap w-max">
+		@* a sideways strip on a phone, every tab named, the selected one brought into view and the edges faded where more
+		   tabs wait; from md only the selected tab shows its name until xl *@
+		<div @ref="strip" class="flex-1 min-w-0 overflow-x-auto max-md:edge-fade-x" data-scroll-x>
+			<DTabs Active="ActiveIndex" ActiveChanged="Select" Variant="DTabsVariant.Box" Size="DSize.Sm" ContentClass="hidden" class="flex-nowrap w-max"
+				   aria-label="@Localizer["Feeds"]">
 				@foreach (var type in Types)
 				{
-					<DTab Class="gap-1 whitespace-nowrap">
+					<DTab Class="gap-1 whitespace-nowrap" AccessibleName="@TabName(type)">
 						<Header>
 							<i class="@type.GetTimelineTypeIcon()" aria-hidden="true"></i>
-							<span class="@(type == Filter.TimelineType ? null : "hidden xl:inline")">@TabName(type)</span>
+							<span class="@(type == Filter.TimelineType ? null : "hidden max-md:inline xl:inline")">@TabName(type)</span>
+							@if (type is TimelineType.Notifications && UnreadNotifications > 0)
+							{
+								<DBadge Size="DSize.Xs" Color="DColor.Primary" title="@Localizer["{0} unread", UnreadNotifications]" data-unread>@UnreadNotifications</DBadge>
+							}
+							else if (type is TimelineType.Direct && UnreadConversations > 0)
+							{
+								<DBadge Size="DSize.Xs" Color="DColor.Primary" title="@Localizer["{0} unread", UnreadConversations]" data-unread-conversations>@UnreadConversations</DBadge>
+							}
 						</Header>
 					</DTab>
 				}
@@ -21,10 +33,15 @@
 		<NerdTip Heading="@Localizer["Feed"]" Rows="Stats" Placement="DTooltipPlacement.Bottom" Align="DTooltipAlign.End">
 			<i class="ion-md-stats opacity-50" aria-label="@Localizer["Feed"]"></i>
 		</NerdTip>
-		<DButton Size="DSize.Sm" class="lg:hidden" Active="Filter.ShowGlobe" OnClick="ToggleGlobe" title="@Localizer["Globe"]">
+		<DButton Size="DSize.Sm" class="lg:hidden max-lg:short:hidden" Active="Filter.ShowGlobe" OnClick="ToggleGlobe" title="@Localizer["Globe"]">
 			<i class="ion-md-planet text-base"></i>
 		</DButton>
-		<DButton Size="DSize.Sm" Active="IsComposing" OnClick="() => OnCompose.InvokeAsync()" title="@Localizer["Post"]">
+		@* a phone held sideways has no room for the banner: the globe opens full screen *@
+		<DButton Size="DSize.Sm" class="hidden max-lg:short:inline-flex" OnClick="() => OnGlobeFull.InvokeAsync()" title="@Localizer["Open the globe full screen"]"
+				 data-globe-full>
+			<i class="ion-md-planet text-base"></i>
+		</DButton>
+		<DButton Size="DSize.Sm" class="hidden md:inline-flex" Active="IsComposing" OnClick="() => OnCompose.InvokeAsync()" title="@Localizer["Post"]">
 			<i class="ion-md-create text-base"></i>
 			<span class="hidden sm:inline">@Localizer["Post"]</span>
 		</DButton>
@@ -49,35 +66,116 @@
 			</DSelect>
 		}
 	}
+	else if (Filter.TimelineType is TimelineType.Lists)
+	{
+		<div class="flex flex-wrap items-center gap-2">
+			@if (Lists.Count == 0)
+			{
+				<p class="text-xs opacity-70">@Localizer["This persona has no list yet."]</p>
+			}
+			else
+			{
+				<DSelect TValue="string" Size="DSize.Sm" class="w-full sm:w-auto" Value="Filter.ListId" ValueChanged="SelectList" ValueExpression="() => Filter.ListId">
+					<Prefix><i class="ion-md-list"></i></Prefix>
+					<ChildContent>
+						@foreach (var list in Lists)
+						{
+							<option value="@list.Id">@list.Title</option>
+						}
+					</ChildContent>
+				</DSelect>
+			}
+			<a class="btn btn-sm" href="lists"><i class="ion-md-create"></i><span>@Localizer["Manage lists"]</span></a>
+		</div>
+	}
 	else if (Filter.TimelineType is TimelineType.Tag)
 	{
-		<p class="text-sm inline-flex items-center gap-2"><i class="ion-md-pricetag"></i><b>#@Filter.Tag</b></p>
+		<div class="flex flex-wrap items-center gap-2 text-sm">
+			<i class="ion-md-pricetag"></i><b>#@Filter.Tag</b>
+			@if (tag is not null)
+			{
+				<span class="text-xs opacity-70 tabular-nums">@Localizer["{0} posts this week, {1} people today", tag.WeekUses, tag.TodayAccounts]</span>
+				<DButton Size="DSize.Xs" Color="@(tag.Following == true ? DColor.Neutral : DColor.Primary)" Disabled="@(IsDefaultDisabled || isFollowing)"
+						 OnClick="ToggleTagFollow" data-tag-follow>
+					<span>@(tag.Following == true ? Localizer["Stop following #{0}", tag.Name] : Localizer["Follow #{0}", tag.Name])</span>
+				</DButton>
+			}
+		</div>
 	}
 </div>
 
 @code {
 	[Parameter, EditorRequired] public FeedFilter Filter { get; set; }
 	[Parameter] public List<ViewGroup> Groups { get; set; } = [];
+	[Parameter] public List<MastodonList> Lists { get; set; } = [];
+	/// <summary>Groups of notifications newer than the persona's marker; a badge on the Notifications tab.</summary>
+	[Parameter] public int UnreadNotifications { get; set; }
+	/// <summary>How many of the newest direct conversations hold a message the persona has not read.</summary>
+	[Parameter] public int UnreadConversations { get; set; }
 	[Parameter] public IEnumerable<NerdRow> Stats { get; set; } = [];
 	[Parameter] public bool IsComposing { get; set; }
 	[Parameter] public EventCallback OnCompose { get; set; }
+	/// <summary>Opens the globe full screen (a phone held sideways, which has no room for its banner).</summary>
+	[Parameter] public EventCallback OnGlobeFull { get; set; }
 	/// <summary>Raised after Filter changed (tab, group or globe).</summary>
 	[Parameter] public EventCallback<FeedFilter> OnChanged { get; set; }
 
 	static readonly TimelineType[] Always =
 	[
 		TimelineType.Home, TimelineType.Local, TimelineType.Federation, TimelineType.Nearby, TimelineType.Groups, TimelineType.Direct,
-		TimelineType.Notifications, TimelineType.Favourites, TimelineType.Bookmarks
+		TimelineType.Notifications, TimelineType.Favourites, TimelineType.Bookmarks, TimelineType.Lists
 	];
 
 	List<TimelineType> Types => Filter.Tag is { Length: > 0 } ? [.. Always, TimelineType.Tag] : [.. Always];
 
 	int ActiveIndex => Types.IndexOf(Filter.TimelineType);
 
+	ElementReference strip;
+	int revealed = -1;
+
+	protected override void OnAfterRender(bool firstRender)
+	{
+		if (ActiveIndex == revealed)
+			return;
+		revealed = ActiveIndex;
+		CascadingState.Status.RevealActive(strip);
+	}
+
 	ViewGroup SelectedGroup => Groups.FirstOrDefault(g => g.Id == Filter.GroupId);
 
+	[Inject] DiscoveryService DiscoveryService { get; set; }
+
+	Tag tag;
+	string loadedTag;
+	bool isFollowing;
+
 	protected override void OnInitialized() => IsLoading = false;
 
+	// the hashtag being read: its week and whether the persona follows it, read again when it changes
+	protected override async Task OnParametersSetAsync()
+	{
+		var wanted = Filter.TimelineType is TimelineType.Tag ? Filter.Tag : null;
+		if (wanted == loadedTag)
+			return;
+		loadedTag = wanted;
+		tag = wanted is { Length: > 0 } ? await DiscoveryService.Tag(wanted) : null;
+	}
+
+	async Task ToggleTagFollow()
+	{
+		isFollowing = true;
+		var result = await DiscoveryService.FollowTag(tag.Name, tag.Following != true);
+		isFollowing = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		tag = (Tag)result.Data;
+		Toast.AddResponseSuccess(tag.Following == true ? Localizer["Following #{0}: its public posts come home.", tag.Name] : Localizer["No longer following #{0}.", tag.Name]);
+	}
+
 	string TabName(TimelineType type) => type switch
 	{
 		TimelineType.Federation => Localizer["Federated"],
@@ -90,6 +188,14 @@
 		Filter.TimelineType = Types[index];
 		if (Filter.TimelineType is TimelineType.Groups && SelectedGroup is null)
 			Filter.GroupId = Groups.FirstOrDefault()?.Id;
+		if (Filter.TimelineType is TimelineType.Lists && Lists.All(l => l.Id != Filter.ListId))
+			Filter.ListId = Lists.FirstOrDefault()?.Id;
+		await OnChanged.InvokeAsync(Filter);
+	}
+
+	async Task SelectList(string listId)
+	{
+		Filter.ListId = listId;
 		await OnChanged.InvokeAsync(Filter);
 	}
 

Components/Feed/GlobePanel.razor

@@ -1,30 +1,60 @@
 @inherits LocalizableComponentBase
+@using System.Globalization
 
 @* The feed's 3D globe (wwwroot/js/globe.js on the vendored globe.gl): it looks at the average place of the posts in
-   view and shows where a hovered post is. The posts' places go to the module in one call whenever they change; the
-   corner shows the camera and the frame rate, its tooltip the rest of the globe's numbers. *@
-<div class="relative w-full h-full">
-	<div @ref="element" class="absolute inset-0" aria-label="@Localizer["Globe of the posts in view"]" role="img"></div>
-
-	<div class="absolute left-2 bottom-2 flex items-center gap-2 text-[10px] font-mono opacity-70 pointer-events-auto">
-		<NerdTip Heading="@Localizer["Globe"]" Rows="StatsRows()" Placement="DTooltipPlacement.Top" Align="DTooltipAlign.Start">
-			<span class="badge badge-ghost badge-xs gap-1">
-				<i class="ion-md-planet"></i>
-				@if (stats is { Error: null } live)
+   view and shows where a hovered post is, lit by the Sun of now or of the moment the hovered, focused or pinned post
+   was written. Its nerd stats are drawn in the scene (wwwroot/js/instruments.js: the Sun, the day/night line, the place,
+   the view, the year, an orrery, the frame rate as a ring), in the reader's language (InstrumentKeys); the caption at
+   the top says the moment, and a screen reader gets the Sun's numbers and the view as text. The posts' places go to the
+   module in one call whenever they change; the module calls SunChanged when the Sun's moment changes, and nothing is
+   polled. The globe is isolated: its labels carry z-indexes by depth. Below lg the globe is a banner the page shows
+   above the feed: a tap opens it full screen (Expanded, which the page lays out), and its close button or Escape
+   brings the feed back. *@
+<div class="relative w-full h-full" tabindex="-1" @onkeydown="OnKeyDown" data-globe-state="@State">
+	<div @ref="element" class="absolute inset-0 isolate" aria-label="@Localizer["Globe of the posts in view"]" role="img"
+		 aria-describedby="@($"{uid}-sun {uid}-view")"></div>
+	@* what the instruments draw, as text for a screen reader: the Sun's numbers, and the view (globe.js writes it) *@
+	<dl id="@($"{uid}-sun")" class="sr-only">
+		@if (sun is not null)
 		{
-					<span>@Fixed(live.Latitude), @Fixed(live.Longitude) · @Fixed(live.Altitude) · @live.Fps fps</span>
+			@foreach (var row in SunRows(sun).Where(row => !string.IsNullOrEmpty(row.Value)))
+			{
+				<dt>@row.Label</dt>
+				<dd>@row.Value</dd>
 			}
-				else if (stats?.Error is { Length: > 0 })
+		}
+	</dl>
+	<p id="@($"{uid}-view")" class="sr-only" data-globe-view-description></p>
+
+	@* the moment the Sun is shown at: now, or the focused post's *@
+	@if (sun is not null)
 	{
-					<span>@Localizer["The globe could not start."]</span>
+		<p class="absolute left-1/2 -translate-x-1/2 top-2 z-10 max-w-[70%] truncate text-[11px] pointer-coarse:text-xs leading-tight rounded-box px-2 py-1 bg-base-100/70 backdrop-blur-sm neo-raised neo-2xs pointer-events-none"
+		   data-globe-moment>
+			<i class="@SunIcon(sun)" aria-hidden="true"></i>
+			<span>@(sun.Now ? Localizer["Now"] : Localizer["When it was written"]) · @LocalTime(sun.At)</span>
+		</p>
+	}
+	else if (error is { Length: > 0 })
+	{
+		<p class="absolute left-2 bottom-2 z-10 text-xs rounded-box px-2 py-1 bg-base-100/70" role="status">@Localizer["The globe could not start."]</p>
+	}
+
+	@if (Expanded)
+	{
+		<button @ref="closeButton" type="button" class="btn btn-circle btn-sm absolute right-3 top-[max(0.75rem,env(safe-area-inset-top))] z-20"
+				aria-label="@Localizer["Close"]" title="@Localizer["Close"]" @onclick="Close" data-globe-close>
+			<i class="ion-md-close" aria-hidden="true"></i>
+		</button>
 	}
 	else
 	{
-					<span>@Localizer["loading"]…</span>
+		<button @ref="expandButton" type="button" class="absolute inset-0 z-20 lg:hidden cursor-zoom-in" aria-label="@Localizer["Open the globe full screen"]"
+				title="@Localizer["Open the globe full screen"]" @onclick="Open" data-globe-expand>
+			<i class="ion-md-expand absolute right-3 bottom-3 text-lg rounded-full bg-base-100/70 p-1" aria-hidden="true"></i>
+		</button>
 	}
-			</span>
-		</NerdTip>
-	</div>
+
 </div>
 
 @code {
@@ -34,30 +64,104 @@
 	/// <summary>The id of the element that scrolls the feed's cards.</summary>
 	[Parameter, EditorRequired] public string ScrollContainerId { get; set; }
 	[Parameter] public List<FeedPost> Posts { get; set; } = [];
+	/// <summary>Open full screen (a phone's banner tapped); the page lays the globe out over everything.</summary>
+	[Parameter] public bool Expanded { get; set; }
+	[Parameter] public EventCallback<bool> ExpandedChanged { get; set; }
+
+	[Inject] OverlayService Overlays { get; set; }
+
+	ElementReference closeButton;
+	ElementReference expandButton;
+	IDisposable overlay;
+	bool focusClose;
+	bool focusExpand;
+
+	string State => error is { Length: > 0 } ? "error" : sun is null ? "loading" : "live";
+
+	// what the instruments drawn in the scene say (wwwroot/js/instruments.js), in the reader's language
+	static readonly string[] InstrumentKeys =
+	[
+		"subsolar point", "declination", "axial tilt", "irradiance", "elevation", "day length",
+		"golden hour", "civil twilight", "nautical twilight", "astronomical twilight", "daylight", "night", "morning", "evening",
+		"spring", "summer", "autumn", "winter", "March equinox", "June solstice", "September equinox", "December solstice",
+		"{0} in {1} days", "{0} in the north, {1} in the south", "solar time {0}", "{0}, {1}", "camera", "in view", "placed",
+		"centre of view", "spread", "points", "posts", "servers", "CDN groups", "paused", "idle", "auto-rotate", "countries",
+		"borders", "lines", "day/night line", "solar noon", "solar midnight", "Tropic of Cancer", "Tropic of Capricorn",
+		"Arctic Circle", "Antarctic Circle", "this hour, all year", "the Sun never sets", "the Sun never rises", "perihelion",
+		"aphelion", "not to scale", "day map", "day and night maps", "{0}× anisotropic"
+	];
+
+	async Task Open()
+	{
+		focusClose = true;
+		await ExpandedChanged.InvokeAsync(true);
+	}
+
+	async Task Close()
+	{
+		focusExpand = true;
+		await ExpandedChanged.InvokeAsync(false);
+	}
+
+	Task OnKeyDown(KeyboardEventArgs e) => e.Key == "Escape" && Expanded ? Close() : Task.CompletedTask;
 
 	ElementReference element;
 	IJSObjectReference module;
-	PeriodicTimer statsTimer;
+	DotNetObjectReference<GlobePanel> reference;
 	readonly CancellationTokenSource cancellation = new();
-	string sentFingerprint;
-	GlobeStats stats;
+	int? sentFingerprint;
+	// the posts are looked at again only when the feed hands them over, never on the panel's own renders
+	bool postsHandedOver = true;
+	SunStats sun;
+	string error;
+	readonly string uid = "g" + Guid.NewGuid().ToString("N")[..8];
 
 	protected override void OnInitialized() => IsLoading = false;
 
+	protected override void OnParametersSet()
+	{
+		postsHandedOver = true;
+		// full screen, the Back button closes it
+		if (Expanded && overlay is null)
+			overlay = Overlays.Open(() => InvokeAsync(Close));
+		else if (!Expanded && overlay is not null)
+		{
+			overlay.Dispose();
+			overlay = null;
+		}
+	}
+
 	protected override async Task OnAfterRenderAsync(bool firstRender)
 	{
+		if (focusClose && Expanded)
+		{
+			focusClose = false;
+			await closeButton.FocusAsync();
+		}
+		if (focusExpand && !Expanded)
+		{
+			focusExpand = false;
+			await expandButton.FocusAsync(preventScroll: true);
+		}
 		await base.OnAfterRenderAsync(firstRender);
 		try
 		{
 			if (firstRender)
 			{
 				module = await JS.InvokeAsync<IJSObjectReference>("import", "./js/globe.js");
-				await module.InvokeVoidAsync("create", element, ScrollContainerId);
-				statsTimer = new(TimeSpan.FromSeconds(1));
-				_ = ReadStats(cancellation.Token);
+				reference = DotNetObjectReference.Create(this);
+				await module.InvokeVoidAsync("create", element, ScrollContainerId, reference, new
+				{
+					Language = CultureInfo.CurrentUICulture.TwoLetterISOLanguageName,
+					Labels = InstrumentKeys.ToDictionary(key => key, key => (string)Localizer[key])
+				});
 			}
+			if (postsHandedOver)
+			{
+				postsHandedOver = false;
 				await SendPosts();
 			}
+		}
 		catch (JSDisconnectedException)
 		{
 		}
@@ -75,7 +179,17 @@
 
 		var located = Posts.Where(p => p.Location is not null).ToList();
 		var self = InstanceService.Known(InstanceService.SelfHost);
-		var fingerprint = string.Join('|', located.Select(p => $"{p.Key}:{p.Location.Latitude}:{p.Location.Longitude}:{p.Location.CdnKey}")) + $"#{self?.Geo?.Latitude}";
+		// a hash, not a string of every place: a feed of thousands is looked at on every page it loads
+		var hash = new HashCode();
+		foreach (var post in located)
+		{
+			hash.Add(post.Key);
+			hash.Add(post.Location.Latitude);
+			hash.Add(post.Location.Longitude);
+			hash.Add(post.Location.CdnKey);
+		}
+		hash.Add(self?.Geo?.Latitude);
+		var fingerprint = hash.ToHashCode();
 		if (fingerprint == sentFingerprint)
 			return;
 		sentFingerprint = fingerprint;
@@ -100,15 +214,18 @@
 			: null;
 	}
 
-	async Task ReadStats(CancellationToken cancellationToken)
+	/// <summary>The globe started, or its Sun moved to another moment (now, or a post's): the caption and the screen
+	/// reader's text follow. Nothing is read otherwise: the numbers are drawn in the scene (instruments.js).</summary>
+	[JSInvokable]
+	public async Task SunChanged()
 	{
+		if (module is null)
+			return;
+
 		try
 		{
-			while (await statsTimer.WaitForNextTickAsync(cancellationToken))
-			{
-				stats = await module.InvokeAsync<GlobeStats>("stats", cancellationToken);
-				await InvokeAsync(StateHasChanged);
-			}
+			sun = await module.InvokeAsync<SunStats>("sunStats", cancellation.Token);
+			StateHasChanged();
 		}
 		catch (OperationCanceledException)
 		{
@@ -118,31 +235,84 @@
 		}
 	}
 
-	IEnumerable<NerdRow> StatsRows()
+	/// <summary>The globe could not start (no WebGL, its library failed to load).</summary>
+	[JSInvokable]
+	public void GlobeFailed(string message)
 	{
-		if (stats is null)
-			yield break;
-		yield return NerdRow.Of(Localizer["camera"], $"{Fixed(stats.Latitude)}, {Fixed(stats.Longitude)} @ {Fixed(stats.Altitude)}");
-		yield return NerdRow.Of(Localizer["in view"], $"{stats.VisibleLocated}/{stats.Visible} {Localizer["placed"]}");
-		yield return NerdRow.Of(Localizer["centre of view"], stats.CentroidLatitude is { } latitude ? $"{Fixed(latitude)}, {Fixed(stats.CentroidLongitude)}" : null);
-		yield return NerdRow.Of(Localizer["spread"], stats.SpreadKm > 0 ? $"{stats.SpreadKm:N0} km" : null);
-		yield return NerdRow.Of(Localizer["points"], $"{stats.Points} ({stats.Posts} {Localizer["posts"]}, {stats.Servers} {Localizer["servers"]})");
-		yield return NerdRow.Of(Localizer["CDN groups"], stats.CdnGroups > 0 ? stats.CdnGroups : null);
-		yield return NerdRow.Of(Localizer["hovered"], stats.Hovered is { } hovered ? $"{hovered} ({stats.Arcs} {Localizer["arcs"]}, {stats.Rings} {Localizer["rings"]})" : null);
-		yield return NerdRow.Of("fps", stats.Paused ? Localizer["paused"] : stats.Fps.ToString());
-		yield return NerdRow.Of(Localizer["auto-rotate"], stats.AutoRotate);
-		yield return NerdRow.Of(Localizer["texture"], stats.Texture is { } texture ? $"{texture} 4096×2048" : null);
-		yield return NerdRow.Of("WebGL", stats.Renderer);
-		yield return NerdRow.Of(Localizer["error"], stats.Error);
+		error = message;
+		StateHasChanged();
 	}
 
-	static string Fixed(double? value) => value?.ToString("0.##", System.Globalization.CultureInfo.InvariantCulture) ?? "–";
+	IEnumerable<NerdRow> SunRows(SunStats sun)
+	{
+		yield return NerdRow.Of(Localizer["moment"], DateTime.Parse(sun.At, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal));
+		yield return NerdRow.Of(Localizer["subsolar point"], $"{Fixed(sun.Latitude)}, {Fixed(sun.Longitude)}");
+		yield return NerdRow.Of(Localizer["declination"], $"{Fixed(sun.Latitude)}°");
+		yield return NerdRow.Of(Localizer["axial tilt"], $"{Fixed(sun.Obliquity)}°");
+		yield return NerdRow.Of(Localizer["ecliptic longitude"], $"{Fixed(sun.EclipticLongitude)}°");
+		yield return NerdRow.Of(Localizer["Earth–Sun distance"],
+			$"{sun.Distance.ToString("0.00000", CultureInfo.InvariantCulture)} AU ({sun.Distance * 149_597_870.7:N0} km)");
+		yield return NerdRow.Of(Localizer["irradiance"],
+			$"{sun.Irradiance * 1361:0} W/m² ({Math.Round((sun.Irradiance - 1) * 100, 1).ToString("+0.0;-0.0;0.0", CultureInfo.InvariantCulture)}%)");
+		yield return NerdRow.Of(Localizer["Place"], sun.Place is { } place ? $"{place} ({Fixed(sun.PlaceLatitude)}, {Fixed(sun.PlaceLongitude)})" : null);
+		yield return NerdRow.Of(Localizer["elevation"], sun.Elevation is { } elevation ? $"{Fixed(elevation)}°" : null);
+		yield return NerdRow.Of(Localizer["day length"], sun.DayLength is { } hours ? NerdRow.Duration(TimeSpan.FromHours(hours)) : null);
+		yield return NerdRow.Of(Localizer["seasons"], $"{Localizer["{0} in the north, {1} in the south", Localizer[SeasonName(sun.SeasonNorth)], Localizer[SeasonName(sun.SeasonSouth)]]}");
+		yield return NerdRow.Of(Localizer["next"], sun.NextEvent is { } next ? Localizer["{0} in {1} days", Localizer[EventName(next)], sun.NextEventDays] : null);
+	}
+
+	static string Fixed(double? value) => value?.ToString("0.##", CultureInfo.InvariantCulture) ?? "–";
+
+	/// <summary>The Sun's moment in the reader's time zone.</summary>
+	static string LocalTime(string at) =>
+		DateTimeOffset.TryParse(at, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out var time)
+			? time.ToLocalTime().ToString(SUtility.dateTimeFormatExt, CultureInfo.InvariantCulture)
+			: at;
+
+	static string SunIcon(SunStats sun) => sun.Phase switch
+	{
+		"day" => "ion-md-sunny",
+		"golden" => "ion-md-partly-sunny",
+		"civil" or "nautical" or "astronomical" => "ion-md-cloudy-night",
+		"night" => "ion-md-moon",
+		_ => "ion-md-time"
+	};
+
+	string PhaseName(string phase, bool? morning) => phase switch
+	{
+		"day" => Localizer["daylight"],
+		"night" => Localizer["night"],
+		_ => Localizer["{0}, {1}", Localizer[phase switch
+		{
+			"golden" => "golden hour",
+			"civil" => "civil twilight",
+			"nautical" => "nautical twilight",
+			_ => "astronomical twilight"
+		}], Localizer[morning == true ? "morning" : "evening"]]
+	};
+
+	static string SeasonName(string season) => season switch
+	{
+		"spring" => "spring",
+		"summer" => "summer",
+		"autumn" => "autumn",
+		_ => "winter"
+	};
+
+	static string EventName(string next) => next switch
+	{
+		"march-equinox" => "March equinox",
+		"june-solstice" => "June solstice",
+		"september-equinox" => "September equinox",
+		_ => "December solstice"
+	};
 
 	public override async ValueTask DisposeAsync()
 	{
+		overlay?.Dispose();
 		await cancellation.CancelAsync();
 		cancellation.Dispose();
-		statsTimer?.Dispose();
+		reference?.Dispose();
 		try
 		{
 			if (module is not null)
@@ -162,28 +332,30 @@
 
 	sealed record GlobeSelf(double Lat, double Lng, string Label, string Host);
 
-	sealed class GlobeStats
+	/// <summary>The Sun of the globe's moment (wwwroot/js/sun.js); the place fields are null without a focused located post.</summary>
+	sealed class SunStats
 	{
-		public double? Latitude { get; set; }
-		public double? Longitude { get; set; }
-		public double? Altitude { get; set; }
-		public int Visible { get; set; }
-		public int VisibleLocated { get; set; }
-		public double? CentroidLatitude { get; set; }
-		public double? CentroidLongitude { get; set; }
-		public double SpreadKm { get; set; }
-		public int Points { get; set; }
-		public int Posts { get; set; }
-		public int Servers { get; set; }
-		public int CdnGroups { get; set; }
-		public int Fps { get; set; }
-		public string Renderer { get; set; }
-		public string Texture { get; set; }
-		public bool AutoRotate { get; set; }
-		public bool Paused { get; set; }
-		public string Hovered { get; set; }
-		public int Arcs { get; set; }
-		public int Rings { get; set; }
-		public string Error { get; set; }
+		public string At { get; set; }
+		public bool Now { get; set; }
+		public double Latitude { get; set; }
+		public double Longitude { get; set; }
+		public double Distance { get; set; }
+		public double Irradiance { get; set; }
+		public double EclipticLongitude { get; set; }
+		public double Obliquity { get; set; }
+		public string Place { get; set; }
+		public double? PlaceLatitude { get; set; }
+		public double? PlaceLongitude { get; set; }
+		public double? Elevation { get; set; }
+		public string Phase { get; set; }
+		public bool? Morning { get; set; }
+		public string SolarTime { get; set; }
+		public double? DayLength { get; set; }
+		public string Season { get; set; }
+		public string Hemisphere { get; set; }
+		public string SeasonNorth { get; set; }
+		public string SeasonSouth { get; set; }
+		public string NextEvent { get; set; }
+		public int? NextEventDays { get; set; }
 	}
 }

Components/InteractedByDialog.razor

@@ -0,0 +1,59 @@
+@inherits LocalizableComponentBase
+
+@* Who liked a post, or boosted it (/api/v1/statuses/:id/favourited_by, reblogged_by): the accounts PrivaPub knows to
+   have done so, newest first, each opening its profile. *@
+<DModal Placement="DModalPlacement.ResponsiveBottom" IsOpen="true" IsOpenChanged="Closed" CloseText="@Localizer["Close"]" data-interacted-by="@(Boosts ? "boosts" : "likes")">
+	<Heading>@(Boosts ? Localizer["Boosted by"] : Localizer["Liked by"])</Heading>
+	<ChildContent>
+		@if (IsLoading)
+		{
+			<p class="flex items-center gap-2 mt-3"><DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />@Localizer["loading"]</p>
+		}
+		else if (accounts.Count == 0)
+		{
+			<p class="text-sm opacity-70 mt-3">@Localizer["Nobody this server knows of."]</p>
+		}
+		<div class="flex flex-col gap-2 mt-3">
+			@foreach (var account in accounts)
+			{
+				<a class="flex items-center gap-3 p-2 rounded-xl neo-raised neo-2xs min-w-0" href="@($"account/{Uri.EscapeDataString(account.Id)}")" data-account="@account.Acct">
+					@* alt="": the name is next to it. *@
+					<img alt="" class="h-9 w-9 flex-none object-cover rounded-full" src="@(account.Avatar ?? "imgs/icon-192.png")" />
+					<span class="flex flex-col min-w-0">
+						<b class="truncate">@CustomEmojis.Text(account.Name, account.Emojis)</b>
+						<span class="text-xs opacity-70 truncate">@("@" + account.Acct)</span>
+					</span>
+				</a>
+			}
+		</div>
+	</ChildContent>
+</DModal>
+
+@code {
+	[Inject] StatusService StatusService { get; set; }
+
+	[Parameter, EditorRequired] public string StatusId { get; set; }
+	/// <summary>Who boosted it, rather than who liked it.</summary>
+	[Parameter] public bool Boosts { get; set; }
+	[Parameter] public EventCallback OnClosed { get; set; }
+
+	List<Account> accounts = [];
+
+	protected override async Task OnInitializedAsync()
+	{
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+		IsLoading = false;
+	}
+
+	async Task LoadData() => accounts = await StatusService.InteractedBy(StatusId, Boosts);
+
+	Task Closed(bool open) => open ? Task.CompletedTask : OnClosed.InvokeAsync();
+}

Components/MediaViewer.razor

@@ -0,0 +1,75 @@
+@inherits LocalizableComponentBase
+
+@* A post's pictures, one at a time, in the app (a picture used to open its file in a new tab, leaving it): the whole
+   screen on a phone, a large dialog from md, with its alt text, the previous and next one (buttons, or the arrow
+   keys), and the original in a new tab for whoever wants the file. *@
+<DModal Placement="DModalPlacement.ResponsiveBottom" IsOpen="true" IsOpenChanged="Closed" CloseText="@Localizer["Close"]"
+		BoxClass="w-full max-w-none h-dvh max-h-dvh rounded-none p-3 md:h-auto md:max-h-[90dvh] md:max-w-5xl md:rounded-box md:p-4" data-media-viewer>
+	<Heading>
+		<span class="text-sm font-normal opacity-70">@Localizer["Picture {0} of {1}", index + 1, Pictures.Count]</span>
+	</Heading>
+	<ChildContent>
+		<div class="flex flex-col gap-3 mt-2" @onkeydown="OnKeyDown">
+			<figure class="flex flex-col gap-2 min-h-0">
+				<img alt="@Current.Description" class="w-full max-h-[calc(100dvh-11rem)] md:max-h-[70dvh] object-contain rounded-lg" src="@Current.Url"
+					 data-blurhash="@Current.Blurhash" />
+				@if (Current.Description is { Length: > 0 } description)
+				{
+					<figcaption class="text-sm opacity-80 break-words">@description</figcaption>
+				}
+			</figure>
+			<div class="flex items-center justify-between gap-2">
+				@if (Pictures.Count > 1)
+				{
+					<DButton Shape="DButtonShape.Circle" Disabled="index == 0" OnClick="Previous" aria-label="@Localizer["Previous picture"]"
+							 title="@Localizer["Previous picture"]" data-picture-previous>
+						<i class="ion-md-arrow-back" aria-hidden="true"></i>
+					</DButton>
+				}
+				<a class="btn btn-sm mx-auto" href="@Current.Url" target="_blank" rel="noopener noreferrer">
+					<i class="ion-md-open" aria-hidden="true"></i>
+					<span>@Localizer["Open original"]</span>
+				</a>
+				@if (Pictures.Count > 1)
+				{
+					<DButton Shape="DButtonShape.Circle" Disabled="index == Pictures.Count - 1" OnClick="Next" aria-label="@Localizer["Next picture"]"
+							 title="@Localizer["Next picture"]" data-picture-next>
+						<i class="ion-md-arrow-forward" aria-hidden="true"></i>
+					</DButton>
+				}
+			</div>
+		</div>
+	</ChildContent>
+</DModal>
+
+@code {
+	/// <summary>The post's pictures, in its order.</summary>
+	[Parameter, EditorRequired] public List<MediaAttachment> Pictures { get; set; } = [];
+	/// <summary>The one opened.</summary>
+	[Parameter] public int Start { get; set; }
+	[Parameter] public EventCallback OnClose { get; set; }
+
+	int index;
+
+	MediaAttachment Current => Pictures[Math.Clamp(index, 0, Pictures.Count - 1)];
+
+	protected override void OnInitialized()
+	{
+		index = Math.Clamp(Start, 0, Math.Max(0, Pictures.Count - 1));
+		IsLoading = false;
+	}
+
+	void Previous() => index = Math.Max(0, index - 1);
+
+	void Next() => index = Math.Min(Pictures.Count - 1, index + 1);
+
+	void OnKeyDown(KeyboardEventArgs e)
+	{
+		if (e.Key == "ArrowLeft")
+			Previous();
+		else if (e.Key == "ArrowRight")
+			Next();
+	}
+
+	Task Closed(bool open) => open ? Task.CompletedTask : OnClose.InvokeAsync();
+}

Components/Nerd/NerdRows.razor

@@ -0,0 +1,30 @@
+@inherits LocalizableComponentBase
+
+@* A block of nerd stats: a monospace list of label/value rows under its heading, rows with no value left out; in a
+   NerdTip's tooltip, in the sheet a tap opens on a touch screen, and in a card's Details on a phone. *@
+<div class="nerd-stats flex flex-col gap-1 text-left font-mono text-[11px] max-md:text-xs leading-tight max-w-80">
+	@if (Heading is { Length: > 0 })
+	{
+		<p class="font-bold opacity-80">@Heading</p>
+	}
+	<dl class="grid grid-cols-[auto_minmax(0,1fr)] gap-x-2 gap-y-0.5">
+		@foreach (var row in Rows.Where(row => !string.IsNullOrEmpty(row.Value)))
+		{
+			<dt class="opacity-60 whitespace-nowrap">@row.Label</dt>
+			<dd class="break-all">@row.Value</dd>
+		}
+	</dl>
+	@if (Pending)
+	{
+		<p class="opacity-60">@Localizer["loading"]…</p>
+	}
+</div>
+
+@code {
+	[Parameter] public string Heading { get; set; }
+	[Parameter] public IEnumerable<NerdRow> Rows { get; set; } = [];
+	/// <summary>Shown under the rows while the stats being read on demand arrive.</summary>
+	[Parameter] public bool Pending { get; set; }
+
+	protected override void OnInitialized() => IsLoading = false;
+}

Components/Nerd/NerdTip.razor

@@ -1,10 +1,32 @@
 @inherits LocalizableComponentBase
 
-@* Nerd stats on hover or focus: a DTooltip whose content is a monospace list of label/value rows. OnOpen runs on the
-   first hover or focus, for stats read on demand (a post's provenance); rows with no value are left out. *@
-<DTooltip Placement="Placement" Align="Align" class="@Class" TipContent="Body" @onmouseenter="Open" @onfocusin="Open">
+@* Nerd stats on hover or focus: a DTooltip whose content is the rows (NerdRows). A touch screen has no hover, so there
+   a tap opens the same rows in a sheet from the bottom (TapOpens; not for a trigger that is a link itself, the
+   pictures). OnOpen runs on the first hover, focus or tap, for stats read on demand (a post's provenance). *@
+@if (TapOpens)
+{
+	@* (on touch the trigger is at least 44px: daisyUI's tooltip draws its arrow with ::after, so padding-free min sizes) *@
+	<DTooltip Placement="Placement" Align="Align" class="@($"{Class} pointer-coarse:inline-flex pointer-coarse:items-center pointer-coarse:min-h-11 pointer-coarse:min-w-11")"
+			  TipContent="Body" @onmouseenter="Open" @onfocusin="Open" @onclick="Tap"
+			  tabindex="0" role="button" aria-haspopup="dialog" aria-label="@Heading">
 		@ChildContent
-</DTooltip>
+	</DTooltip>
+}
+else
+{
+	<DTooltip Placement="Placement" Align="Align" class="@Class" TipContent="Body" @onmouseenter="Open" @onfocusin="Open">
+		@ChildContent
+	</DTooltip>
+}
+@if (isSheetOpen)
+{
+	<DModal Placement="DModalPlacement.ResponsiveBottom" IsOpen="true" IsOpenChanged="open => isSheetOpen = open" CloseText="@Localizer["Close"]" data-nerd-sheet>
+		<Heading>@Heading</Heading>
+		<ChildContent>
+			<NerdRows Rows="Rows" Pending="Pending" />
+		</ChildContent>
+	</DModal>
+}
 
 @code {
 	[Parameter] public RenderFragment ChildContent { get; set; }
@@ -16,8 +38,19 @@
 	[Parameter] public DTooltipPlacement Placement { get; set; }
 	[Parameter] public DTooltipAlign Align { get; set; }
 	[Parameter] public string Class { get; set; }
+	/// <summary>A tap opens the rows in a sheet where the screen has no hover.</summary>
+	[Parameter] public bool TapOpens { get; set; } = true;
 
 	bool opened;
+	bool isSheetOpen;
+
+	async Task Tap()
+	{
+		if (CascadingState.Status.CanHover())
+			return;
+		isSheetOpen = true;
+		await Open();
+	}
 
 	protected override void OnInitialized() => IsLoading = false;
 
@@ -29,21 +62,5 @@
 		await OnOpen.InvokeAsync();
 	}
 
-	RenderFragment Body => @<div class="nerd-stats flex flex-col gap-1 text-left font-mono text-[11px] leading-tight max-w-80">
-		@if (Heading is { Length: > 0 })
-		{
-			<p class="font-bold opacity-80">@Heading</p>
-		}
-		<dl class="grid grid-cols-[auto_minmax(0,1fr)] gap-x-2 gap-y-0.5">
-			@foreach (var row in Rows.Where(row => !string.IsNullOrEmpty(row.Value)))
-			{
-				<dt class="opacity-60 whitespace-nowrap">@row.Label</dt>
-				<dd class="break-all">@row.Value</dd>
-			}
-		</dl>
-		@if (Pending)
-		{
-			<p class="opacity-60">@Localizer["loading"]…</p>
-		}
-	</div>;
+	RenderFragment Body => @<NerdRows Heading="@Heading" Rows="Rows" Pending="Pending" />;
 }

Components/PhoneSheet.razor

@@ -0,0 +1,59 @@
+@inherits LocalizableComponentBase
+
+@* What opens in place on a desktop (the composer at the top of the feed, a reply under its post) and as a sheet from the
+   bottom of a phone's screen (below md), over a dimmed page, with its heading and a close button; a tap outside it or
+   Escape closes it too. Class is the inline look from md (padding, a raised panel). *@
+@if (IsOpen)
+{
+	<div class="max-md:fixed max-md:inset-0 max-md:z-[60] max-md:flex max-md:flex-col max-md:justify-end" @onkeydown="OnKeyDown">
+		<div class="md:hidden absolute inset-0 bg-black/40" aria-hidden="true" @onclick="Close"></div>
+		<div class="@($"relative max-md:max-h-[85dvh] max-md:overflow-y-auto max-md:overscroll-contain max-md:rounded-t-box max-md:bg-base-100 max-md:p-4 max-md:pb-[max(1rem,env(safe-area-inset-bottom))] {Class}")"
+			 data-sheet>
+			<div class="md:hidden flex items-center gap-3 mb-3">
+				<b class="flex-1 min-w-0 truncate">@Heading</b>
+				<button type="button" class="btn btn-sm btn-circle btn-ghost flex-none" aria-label="@Localizer["Close"]" title="@Localizer["Close"]"
+						@onclick="Close" data-sheet-close>
+					<i class="ion-md-close" aria-hidden="true"></i>
+				</button>
+			</div>
+			@ChildContent
+		</div>
+	</div>
+}
+
+@code {
+	[Parameter] public bool IsOpen { get; set; }
+	[Parameter] public EventCallback OnClose { get; set; }
+	/// <summary>The sheet's heading on a phone.</summary>
+	[Parameter] public string Heading { get; set; }
+	[Parameter] public RenderFragment ChildContent { get; set; }
+	[Parameter] public string Class { get; set; }
+
+	[Inject] OverlayService Overlays { get; set; }
+
+	IDisposable overlay;
+
+	protected override void OnInitialized() => IsLoading = false;
+
+	// open, the Back button closes it
+	protected override void OnParametersSet()
+	{
+		if (IsOpen && overlay is null)
+			overlay = Overlays.Open(() => InvokeAsync(Close));
+		else if (!IsOpen && overlay is not null)
+		{
+			overlay.Dispose();
+			overlay = null;
+		}
+	}
+
+	public override async ValueTask DisposeAsync()
+	{
+		overlay?.Dispose();
+		await base.DisposeAsync();
+	}
+
+	Task Close() => OnClose.InvokeAsync();
+
+	Task OnKeyDown(KeyboardEventArgs e) => e.Key == "Escape" ? Close() : Task.CompletedTask;
+}

Components/PublicNoticeHost.razor

@@ -0,0 +1,40 @@
+@inherits LocalizableComponentBase
+@implements IDisposable
+
+@* The one-time notice before a persona's first reaction or poll vote, and before it first joins an event
+   (PublicNoticeService), in MainLayout. *@
+<DModal Placement="DModalPlacement.ResponsiveBottom" IsOpen="Notices.IsAsking" IsOpenChanged="Closed" CloseOnBackdrop="false" CloseText="@Localizer["Close"]"
+		data-public-notice>
+	<Heading>@(Notices.Act == PublicAct.Participation ? Localizer["Joining an event is public"] : Localizer["Reactions and votes are public"])</Heading>
+	<ChildContent>
+		<p class="text-sm">
+			@(Notices.Act == PublicAct.Participation
+				? Localizer["The event's server shows who takes part, {0} included. Your other personas are never named.", CascadingState.Persona?.Name ?? ""]
+				: Localizer["Anyone who can see the post can see that {0} reacted to it or voted in it. Your other personas are never named.", CascadingState.Persona?.Name ?? ""])
+		</p>
+	</ChildContent>
+	<Actions>
+		<DButton Size="DSize.Sm" OnClick="() => Notices.Answer(false)">@Localizer["Cancel"]</DButton>
+		<DButton Size="DSize.Sm" Color="DColor.Primary" OnClick="() => Notices.Answer(true)" data-public-notice-yes>@Localizer["Continue"]</DButton>
+	</Actions>
+</DModal>
+
+@code {
+	[Inject] PublicNoticeService Notices { get; set; }
+
+	protected override void OnInitialized()
+	{
+		Notices.Changed += Refresh;
+		IsLoading = false;
+	}
+
+	void Refresh() => InvokeAsync(StateHasChanged);
+
+	void Closed(bool open)
+	{
+		if (!open)
+			Notices.Answer(false);
+	}
+
+	public void Dispose() => Notices.Changed -= Refresh;
+}

Components/ReportDialog.razor

@@ -0,0 +1,65 @@
+@inherits LocalizableComponentBase
+
+@* Reports an account, and the post it was opened from, to the persona's server's moderators (/api/v1/reports).
+   Forwarded, a remote account's server gets the report too, from PrivaPub's own actor: it never names the persona. *@
+<DModal Placement="DModalPlacement.ResponsiveBottom" IsOpen="true" IsOpenChanged="Closed" CloseText="@Localizer["Close"]" data-report-dialog>
+	<Heading>@Localizer["Report {0}", Account.Name]</Heading>
+	<ChildContent>
+		<EditForm Model="form" OnValidSubmit="Send" class="flex flex-col gap-3 mt-3">
+			<DataAnnotationsValidator />
+			<ErrorViewer AdditionalError="@error" />
+			<DSelect TValue="ReportCategory" @bind-Value="form.Category" data-report-category>
+				<option value="@ReportCategory.Spam">@Localizer[nameof(ReportCategory.Spam)]</option>
+				<option value="@ReportCategory.Legal">@Localizer[nameof(ReportCategory.Legal)]</option>
+				<option value="@ReportCategory.Other">@Localizer[nameof(ReportCategory.Other)]</option>
+			</DSelect>
+			<DTextarea TValue="string" @bind-Value="form.Comment" Immediate="true" rows="3" autocomplete="off" maxlength="@ReportForm.CommentLength"
+					   placeholder="@Localizer["What is wrong with it?"]" data-report-comment />
+			@if (Host is { } host)
+			{
+				<DCheckbox @bind-Value="form.Forward" LabelText="@Localizer["Send a copy to {0}", host]" data-report-forward />
+				<p class="text-xs opacity-70">@Localizer["The copy comes from the server, never from you."]</p>
+			}
+			<div class="flex justify-end gap-2">
+				<DButton OnClick="() => Closed(false)" data-report-cancel>@Localizer["Cancel"]</DButton>
+				<DButton Type="submit" Color="DColor.Error" Disabled="@(IsDefaultDisabled || isSending)" data-report-send>@Localizer["Report"]</DButton>
+			</div>
+		</EditForm>
+	</ChildContent>
+</DModal>
+
+@code {
+	[Inject] AccountService AccountService { get; set; }
+
+	[Parameter, EditorRequired] public Account Account { get; set; }
+	/// <summary>The post it was opened from, sent with the report.</summary>
+	[Parameter] public Status Post { get; set; }
+	[Parameter] public EventCallback OnClosed { get; set; }
+
+	ReportForm form = new();
+	bool isSending;
+	string error;
+
+	// the account's own server, for a remote account
+	string Host => Account.Acct?.Split('@') is [_, { Length: > 0 } host] ? host : null;
+
+	protected override void OnInitialized() => IsLoading = false;
+
+	async Task Send()
+	{
+		isSending = true;
+		error = null;
+		var result = await AccountService.Report(Account.Id, Post is null ? [] : [Post.Id], form.Comment, form.Category, Host is not null && form.Forward);
+		isSending = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		Toast.AddResponseSuccess(Localizer["Report sent to the moderators."]);
+		await OnClosed.InvokeAsync();
+	}
+
+	Task Closed(bool open) => open ? Task.CompletedTask : OnClosed.InvokeAsync();
+}

Components/Settings/AccountEditor.razor

@@ -0,0 +1,315 @@
+@inherits LocalizableComponentBase
+
+@* The login itself (the root, /clientapi/user): its email address, changed only with the password and a code sent to the
+   new one, since a forgotten password is recovered through it; its password changed (every other session ends, this
+   device's goes on with a new JWT); its two-factor sign-in (TotpEditor); every session of it ended at once; or the whole
+   of it deleted, every persona with it.
+   Deleting it deletes everything public its personas had, and PrivaPub tells the servers that hold it. *@
+<div class="flex flex-col gap-4 w-full" data-account>
+	<div class="flex flex-col gap-2 p-3 rounded-xl neo-inset neo-2xs" data-account-email>
+		<b class="text-sm">@Localizer["Email address"]</b>
+		@if (IsLoading)
+		{
+			<DLoading Variant="DLoadingVariant.Dots" Size="DSize.Sm" LabelText="@Localizer["loading"]" />
+		}
+		else if (account is not null)
+		{
+			@if (account.Email is { Length: > 0 } email)
+			{
+				<p class="flex flex-wrap items-center gap-2 text-sm">
+					<span class="break-all" data-account-email-address>@email</span>
+					@if (account.IsEmailValidated)
+					{
+						<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft" Color="DColor.Success" data-account-email-verified>@Localizer["verified"]</DBadge>
+					}
+					else
+					{
+						<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft" Color="DColor.Warning" data-account-email-unverified>@Localizer["not verified"]</DBadge>
+					}
+				</p>
+				@if (!account.IsEmailValidated)
+				{
+					<p class="text-xs opacity-70">@Localizer["Only a verified address can recover a forgotten password."]</p>
+				}
+			}
+			else
+			{
+				<p class="text-sm" data-account-email-none>@Localizer["No email address yet: without one, a forgotten password can't be recovered."]</p>
+			}
+
+			@if (account.PendingEmail is { Length: > 0 } pending && !isChangingEmail)
+			{
+				<EditForm Model="code" OnValidSubmit="VerifyEmail" class="flex flex-col gap-2" data-account-email-code>
+					<DataAnnotationsValidator />
+					@if (codeSentence is not null)
+					{
+						<p class="text-sm opacity-70">@codeSentence</p>
+					}
+					<p class="text-sm break-all">@Localizer["Enter the code sent to {0}.", pending]</p>
+					<DOtp @bind-Value="code.Code" Immediate="true" aria-label="@Localizer["Code"]" data-account-email-code-digits />
+					<ErrorViewer />
+					<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary" class="self-end" Disabled="@(IsDefaultDisabled || isSaving)" data-account-email-verify>
+						<i class="ion-md-checkmark"></i><span>@Localizer["Verify"]</span>
+					</DButton>
+				</EditForm>
+			}
+
+			@if (isChangingEmail)
+			{
+				<EditForm Model="change" OnValidSubmit="ChangeEmail" class="flex flex-col gap-2" data-account-email-change>
+					<DataAnnotationsValidator />
+					<DInput TValue="string" Type="email" @bind-Value="change.Email" Immediate="true" autocomplete="email" inputmode="email" autocapitalize="none"
+							spellcheck="false" placeholder="@Localizer["New email address"]" data-account-email-new />
+					<DInput TValue="string" Type="password" @bind-Value="change.Password" Immediate="true" autocomplete="current-password"
+							placeholder="@Localizer["Current password"]" data-account-email-password />
+					<ErrorViewer />
+					<div class="flex flex-wrap justify-end gap-2 pointer-coarse:gap-2">
+						<DButton Size="DSize.Sm" OnClick="CloseEmailForms">@Localizer["Cancel"]</DButton>
+						<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || isSaving)" data-account-email-send>
+							<i class="ion-md-mail"></i><span>@Localizer["Send the code"]</span>
+						</DButton>
+					</div>
+				</EditForm>
+			}
+			else if (isRemovingEmail)
+			{
+				<EditForm Model="emailRemoval" OnValidSubmit="RemoveEmail" class="flex flex-col gap-2" data-account-email-remove>
+					<DataAnnotationsValidator />
+					<DInput TValue="string" Type="password" @bind-Value="emailRemoval.Password" Immediate="true" autocomplete="current-password"
+							placeholder="@Localizer["Current password"]" data-account-email-remove-password />
+					<ErrorViewer />
+					<div class="flex flex-wrap justify-end gap-2 pointer-coarse:gap-2">
+						<DButton Size="DSize.Sm" OnClick="CloseEmailForms">@Localizer["Cancel"]</DButton>
+						<DButton Type="submit" Size="DSize.Sm" Color="DColor.Error" Disabled="@(IsDefaultDisabled || isSaving)" data-account-email-remove-confirm>
+							<i class="ion-md-trash"></i><span>@Localizer["Remove the address"]</span>
+						</DButton>
+					</div>
+				</EditForm>
+			}
+			else
+			{
+				<div class="flex flex-wrap justify-end gap-2 pointer-coarse:gap-2">
+					@if (account.Email is { Length: > 0 })
+					{
+						<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="OpenEmailRemoval" data-account-email-remove-open>
+							<i class="ion-md-trash"></i><span>@Localizer["Remove the address"]</span>
+						</DButton>
+					}
+					<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="OpenEmailChange" data-account-email-change-open>
+						<i class="ion-md-create"></i><span>@(account.Email is { Length: > 0 } ? Localizer["Change"] : Localizer["Add an address"])</span>
+					</DButton>
+				</div>
+			}
+		}
+	</div>
+
+	<EditForm Model="password" OnValidSubmit="ChangePassword" class="flex flex-col gap-2 p-3 rounded-xl neo-inset neo-2xs" data-account-password>
+		<DataAnnotationsValidator />
+		<b class="text-sm">@Localizer["Change the password"]</b>
+		<p class="text-xs opacity-70">@Localizer["Every other device signed in to this login is signed out."]</p>
+		<DInput TValue="string" type="password" @bind-Value="password.OldPassword" Immediate="true" autocomplete="current-password"
+				placeholder="@Localizer["Current password"]" data-account-current />
+		<div class="flex flex-wrap gap-2">
+			<DInput TValue="string" type="password" class="flex-1 min-w-40" @bind-Value="password.NewPassword" Immediate="true" autocomplete="new-password"
+					placeholder="@Localizer["New password"]" data-account-new />
+			<DInput TValue="string" type="password" class="flex-1 min-w-40" @bind-Value="password.RepeatedPassword" Immediate="true" autocomplete="new-password"
+					placeholder="@Localizer["Repeat the new password"]" data-account-repeat />
+		</div>
+		<ErrorViewer />
+		<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary" class="self-end" Disabled="@(IsDefaultDisabled || isSaving)" data-account-password-save>
+			<i class="ion-md-key"></i><span>@Localizer["Change the password"]</span>
+		</DButton>
+	</EditForm>
+
+	<TotpEditor />
+
+	<div class="flex flex-col gap-2 p-3 rounded-xl neo-inset neo-2xs" data-account-everywhere>
+		<b class="text-sm">@Localizer["Sign out everywhere"]</b>
+		<p class="text-sm">@Localizer["Every device signed in to this login signs out, this one too, with every persona: for a lost device, or a session that isn't yours."]</p>
+		<DButton Size="DSize.Sm" Color="DColor.Warning" class="self-end" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="LogoutEverywhere" data-account-everywhere-confirm>
+			<i class="ion-md-log-out"></i><span>@Localizer["Sign out everywhere"]</span>
+		</DButton>
+	</div>
+
+	<EditForm Model="removal" OnValidSubmit="Delete" class="flex flex-col gap-2 p-3 rounded-xl neo-inset neo-2xs" data-account-delete>
+		<DataAnnotationsValidator />
+		<b class="text-sm text-error">@Localizer["Delete this login"]</b>
+		<p class="text-sm">@Localizer["Every persona of this login goes with it, and everything public they had, here and on the servers that hold it. It cannot be undone."]</p>
+		<DInput TValue="string" type="password" @bind-Value="removal.Password" Immediate="true" autocomplete="current-password"
+				placeholder="@Localizer["Current password"]" data-account-delete-password />
+		<DCheckbox @bind-Value="understood" Size="DSize.Sm" LabelText="@Localizer["I understand: delete this login and every persona of it"]" data-account-delete-understood />
+		<ErrorViewer />
+		<DButton Type="submit" Size="DSize.Sm" Color="DColor.Error" class="self-end" Disabled="@(IsDefaultDisabled || isSaving || !understood)" data-account-delete-confirm>
+			<i class="ion-md-trash"></i><span>@Localizer["Delete it for good"]</span>
+		</DButton>
+	</EditForm>
+</div>
+
+@code {
+	[Inject] AuthService AuthService { get; set; }
+	[Inject] ConfirmService Confirm { get; set; }
+
+	/// <summary>The login as PrivaPub describes it; null until read, or when it couldn't be (the email block stays empty).</summary>
+	ViewAccount account;
+	EmailChangeForm change = new();
+	EmailCodeForm code = new();
+	PasswordForm emailRemoval = new();
+	UserPasswordForm password = new();
+	RemoveSelfForm removal = new();
+	/// <summary>PrivaPub's answer to the change asked here, the same whether or not the address is free.</summary>
+	string codeSentence;
+	bool isChangingEmail;
+	bool isRemovingEmail;
+	bool understood;
+	bool isSaving;
+
+	protected override async Task OnInitializedAsync()
+	{
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+		IsLoading = false;
+	}
+
+	async Task LoadData() => account = await AuthService.Account();
+
+	void OpenEmailChange()
+	{
+		change = new();
+		isRemovingEmail = false;
+		isChangingEmail = true;
+	}
+
+	void OpenEmailRemoval()
+	{
+		emailRemoval = new();
+		isChangingEmail = false;
+		isRemovingEmail = true;
+	}
+
+	void CloseEmailForms()
+	{
+		isChangingEmail = false;
+		isRemovingEmail = false;
+	}
+
+	async Task ChangeEmail()
+	{
+		isSaving = true;
+		change.Email = change.Email.Trim();
+		var result = await AuthService.ChangeEmail(change);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		codeSentence = result.Data is string { Length: > 0 } said
+			? said
+			: Localizer["If that address can be used, a code is on its way to it. It works for one hour."];
+		// as PrivaPub keeps it while it waits for its code
+		account.PendingEmail = change.Email.ToLowerInvariant();
+		change = new();
+		code = new();
+		isChangingEmail = false;
+	}
+
+	async Task VerifyEmail()
+	{
+		isSaving = true;
+		var result = await AuthService.VerifyEmail(code.Code.Trim());
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			// five wrong codes, or an hour, and the address no longer waits
+			account = await AuthService.Account() ?? account;
+			return;
+		}
+
+		account = result.Data as ViewAccount ?? await AuthService.Account();
+		code = new();
+		codeSentence = default;
+		Toast.AddResponseSuccess(Localizer["Email address verified."]);
+	}
+
+	async Task RemoveEmail()
+	{
+		if (!await Confirm.Ask(Localizer["Remove the email address?"], Localizer["Without one, a forgotten password can't be recovered."],
+				Localizer["Remove the address"], true))
+			return;
+
+		isSaving = true;
+		var result = await AuthService.RemoveEmail(emailRemoval.Password);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		account = result.Data as ViewAccount ?? await AuthService.Account();
+		emailRemoval = new();
+		codeSentence = default;
+		isRemovingEmail = false;
+		Toast.AddResponseSuccess(Localizer["Email address removed."]);
+	}
+
+	async Task ChangePassword()
+	{
+		isSaving = true;
+		// the session goes on with the JWT PrivaPub answers with, and the persona with a new token
+		var result = await AuthService.ChangePassword(password);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		password = new();
+		Toast.AddResponseSuccess(Localizer["Password changed."]);
+	}
+
+	async Task LogoutEverywhere()
+	{
+		if (!await Confirm.Ask(Localizer["Sign out everywhere?"],
+				Localizer["Every device and every persona of this login signs out, this one too. Signing in again takes the password."],
+				Localizer["Sign out everywhere"], true))
+			return;
+
+		isSaving = true;
+		var result = await AuthService.LogoutEverywhere();
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		await CascadingState.SignOut();
+		Navigation.NavigateTo("login");
+	}
+
+	async Task Delete()
+	{
+		isSaving = true;
+		var result = await AuthService.DeleteAccount(removal);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		await CascadingState.SignOut();
+		Navigation.NavigateTo("login");
+	}
+}

Components/Settings/DataTransfer.razor

@@ -0,0 +1,156 @@
+@inherits LocalizableComponentBase
+
+@* The persona's follows, lists, blocks, mutes, blocked servers and bookmarks, exported and imported as the CSV files
+   Mastodon writes, which most fediverse servers read too: a persona moves here from another server, or away, with what
+   it gathered there. An import acts one row at a time, through PrivaPub, and can be stopped. *@
+<div class="flex flex-col gap-5 w-full">
+	<section class="flex flex-col gap-2" data-export>
+		<h3 class="font-semibold text-sm">@Localizer["Export"]</h3>
+		<p class="text-sm opacity-70">@Localizer["Files in Mastodon's format, which most fediverse servers import."]</p>
+		<div class="flex flex-wrap gap-2">
+			@foreach (var data in Kinds)
+			{
+				<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || exporting is not null || importing is not null)" OnClick="() => Export(data)"
+						 data-export-kind="@data">
+					@if (exporting == data)
+					{
+						<DLoading Size="DSize.Xs" LabelText="@Localizer["loading"]" />
+					}
+					else
+					{
+						<i class="ion-md-download"></i>
+					}
+					<span>@Name(data)</span>
+				</DButton>
+			}
+		</div>
+	</section>
+
+	<section class="flex flex-col gap-2" data-import>
+		<h3 class="font-semibold text-sm">@Localizer["Import"]</h3>
+		<div class="flex flex-wrap gap-2 items-end">
+			<label class="flex flex-col gap-1 text-sm">
+				<span>@Localizer["What the file holds"]</span>
+				<DSelect TValue="PortableData" Size="DSize.Sm" @bind-Value="importKind" disabled="@(importing is not null)" data-import-kind>
+					@foreach (var data in Kinds)
+					{
+						<option value="@data">@Name(data)</option>
+					}
+				</DSelect>
+			</label>
+			<DFileInput Size="DSize.Sm" Accept=".csv,text/csv" OnChange="Pick" disabled="@(importing is not null)" data-import-file />
+			@if (importing is null)
+			{
+				<DButton Size="DSize.Sm" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || file is null || exporting is not null)" OnClick="Import"
+						 data-import-start>
+					<i class="ion-md-cloud-upload"></i><span>@Localizer["Import"]</span>
+				</DButton>
+			}
+			else
+			{
+				<DButton Size="DSize.Sm" Color="DColor.Warning" OnClick="Stop">@Localizer["Stop"]</DButton>
+			}
+		</div>
+		@if (report is not null)
+		{
+			<div class="flex flex-col gap-1" data-import-report>
+				<DProgress class="w-full max-w-md" Value="@(report.Done + report.Failed.Count)" Max="@Math.Max(1, report.Total)" />
+				<span class="text-sm tabular-nums">
+					@Localizer["{0} of {1} done, {2} could not be.", report.Done, report.Total, report.Failed.Count]
+				</span>
+				<ErrorViewer AdditionalErrors="report.Failed" />
+			</div>
+		}
+	</section>
+</div>
+
+@code {
+	[Inject] PortabilityService PortabilityService { get; set; }
+	[Inject] IBlazorDownloadFileService DownloadFile { get; set; }
+	[Inject] ILoggingService Logger { get; set; }
+
+	// an export file of 5000 rows stays well under this
+	const long MaximumFileSize = 4 * 1024 * 1024;
+	static readonly PortableData[] Kinds = Enum.GetValues<PortableData>();
+
+	PortableData? exporting;
+	PortableData? importing;
+	PortableData importKind = PortableData.Follows;
+	string file;
+	ImportReport report;
+	CancellationTokenSource stopping;
+
+	protected override void OnInitialized() => IsLoading = false;
+
+	string Name(PortableData data) => data switch
+	{
+		PortableData.Follows => Localizer["Follows"],
+		PortableData.Lists => Localizer["Lists"],
+		PortableData.Blocks => Localizer["Blocked accounts"],
+		PortableData.Mutes => Localizer["Muted accounts"],
+		PortableData.ServerBlocks => Localizer["Blocked servers"],
+		_ => Localizer["Bookmarks"]
+	};
+
+	async Task Export(PortableData data)
+	{
+		exporting = data;
+		var result = await PortabilityService.Export(data, CascadingState.PersonaId);
+		exporting = null;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		await DownloadFile.DownloadFileAsync(PortabilityService.FileName(data), (byte[])result.Data, "text/csv");
+	}
+
+	async Task Pick(InputFileChangeEventArgs eventArgs)
+	{
+		file = null;
+		report = null;
+		if (eventArgs.File.Size > MaximumFileSize)
+		{
+			Toast.AddWarning(Localizer["Supplied file \"{0}\" with size {1} exceeds the maximum of {2}.", eventArgs.File.Name,
+				eventArgs.File.Size.GetFileSize(Localizer), MaximumFileSize.GetFileSize(Localizer)]);
+			return;
+		}
+
+		try
+		{
+			using var reader = new StreamReader(eventArgs.File.OpenReadStream(MaximumFileSize));
+			file = await reader.ReadToEndAsync();
+		}
+		catch (Exception ex)
+		{
+			await Logger.ProcessError(ex, $"{nameof(DataTransfer)}.{nameof(Pick)}:{eventArgs.File.Name}");
+			Toast.AddWarning(Localizer["The file \"{0}\" could not be read.", eventArgs.File.Name]);
+		}
+	}
+
+	async Task Import()
+	{
+		importing = importKind;
+		stopping = new();
+		report = new();
+		var progress = new Progress<ImportReport>(step =>
+		{
+			report = step;
+			StateHasChanged();
+		});
+		report = await PortabilityService.Import(importKind, file, progress, stopping.Token);
+		importing = null;
+		stopping.Dispose();
+		stopping = null;
+		Toast.AddResponseSuccess(Localizer["{0} of {1} done, {2} could not be.", report.Done, report.Total, report.Failed.Count]);
+	}
+
+	void Stop() => stopping?.Cancel();
+
+	public override async ValueTask DisposeAsync()
+	{
+		stopping?.Cancel();
+		await base.DisposeAsync();
+	}
+}

Components/Settings/MutesAndBlocks.razor

@@ -0,0 +1,229 @@
+@inherits LocalizableComponentBase
+
+@* The accounts the current persona muted or blocked (/api/v1/mutes, /api/v1/blocks), and the servers it blocked
+   (/api/v1/domain_blocks), each one undone here. A server blocked hides everything from it and removes the persona's
+   followers there. *@
+@if (IsLoading)
+{
+	<p class="flex w-full items-center justify-center gap-2">
+		<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+		@Localizer["loading"]
+	</p>
+}
+else
+{
+	<div class="flex flex-col gap-5 w-full">
+		<section class="flex flex-col gap-2" data-mutes>
+			<h3 class="font-semibold text-sm">@Localizer["Muted accounts"]</h3>
+			@if (mutes.Count == 0)
+			{
+				<p class="text-sm opacity-70">@Localizer["Nobody is muted."]</p>
+			}
+			@foreach (var account in mutes)
+			{
+				<div class="flex items-center gap-2 min-w-0" data-account-id="@account.Id">
+					<img class="size-8 rounded-full object-cover" src="@account.Avatar" alt="" />
+					<a class="flex-1 min-w-0 truncate link link-hover" href="@($"account/{Uri.EscapeDataString(account.Id)}")">
+						<b>@account.Name</b> <span class="text-xs opacity-70">@@@account.Acct</span>
+					</a>
+					<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || busy.Contains(account.Id))" OnClick="() => Undo(account, AccountAction.Unmute)">
+						@Localizer["Unmute"]
+					</DButton>
+				</div>
+			}
+			@if (mutesMaxId is not null)
+			{
+				<DButton Size="DSize.Sm" class="self-start" Disabled="IsDefaultDisabled" OnClick="MoreMutes">@Localizer["Load more"]</DButton>
+			}
+		</section>
+
+		<section class="flex flex-col gap-2" data-blocks>
+			<h3 class="font-semibold text-sm">@Localizer["Blocked accounts"]</h3>
+			@if (blocks.Count == 0)
+			{
+				<p class="text-sm opacity-70">@Localizer["Nobody is blocked."]</p>
+			}
+			@foreach (var account in blocks)
+			{
+				<div class="flex items-center gap-2 min-w-0" data-account-id="@account.Id">
+					<img class="size-8 rounded-full object-cover" src="@account.Avatar" alt="" />
+					<a class="flex-1 min-w-0 truncate link link-hover" href="@($"account/{Uri.EscapeDataString(account.Id)}")">
+						<b>@account.Name</b> <span class="text-xs opacity-70">@@@account.Acct</span>
+					</a>
+					<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || busy.Contains(account.Id))" OnClick="() => Undo(account, AccountAction.Unblock)">
+						@Localizer["Unblock"]
+					</DButton>
+				</div>
+			}
+			@if (blocksMaxId is not null)
+			{
+				<DButton Size="DSize.Sm" class="self-start" Disabled="IsDefaultDisabled" OnClick="MoreBlocks">@Localizer["Load more"]</DButton>
+			}
+		</section>
+
+		<section class="flex flex-col gap-2" data-domain-blocks>
+			<h3 class="font-semibold text-sm">@Localizer["Blocked servers"]</h3>
+			<EditForm Model="draft" OnValidSubmit="BlockDomain" class="flex flex-wrap gap-2 items-center">
+				<DInput TValue="string" class="flex-1 min-w-48" @bind-Value="draft.Domain" Immediate="true" autocomplete="off" maxlength="253"
+						placeholder="@Localizer["A server, e.g. example.social"]" data-domain-new>
+					<Prefix><i class="ion-md-globe"></i></Prefix>
+				</DInput>
+				<DButton Type="submit" Size="DSize.Sm" Color="DColor.Error" Disabled="@(IsDefaultDisabled || string.IsNullOrWhiteSpace(draft.Domain) || busy.Contains(Domain(draft.Domain)))">
+					@Localizer["Block server"]
+				</DButton>
+			</EditForm>
+			@if (domains.Count == 0)
+			{
+				<p class="text-sm opacity-70">@Localizer["No server is blocked."]</p>
+			}
+			@foreach (var domain in domains)
+			{
+				<div class="flex items-center gap-2 min-w-0" data-domain="@domain">
+					<i class="ion-md-globe opacity-70"></i>
+					<span class="flex-1 min-w-0 truncate">@domain</span>
+					<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || busy.Contains(domain))" OnClick="() => UnblockDomain(domain)">
+						@Localizer["Unblock"]
+					</DButton>
+				</div>
+			}
+		</section>
+	</div>
+}
+
+@code {
+	[Inject] AccountService AccountService { get; set; }
+
+	sealed class DomainDraft
+	{
+		public string Domain { get; set; }
+	}
+
+	List<Account> mutes = [];
+	List<Account> blocks = [];
+	List<string> domains = [];
+	string mutesMaxId;
+	string blocksMaxId;
+	DomainDraft draft = new();
+	// the accounts and servers whose undo is on its way
+	HashSet<string> busy = [];
+	string loadedPersonaId;
+
+	protected override async Task OnParametersSetAsync()
+	{
+		if (CascadingState.PersonaId == loadedPersonaId)
+			return;
+		loadedPersonaId = CascadingState.PersonaId;
+
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+		IsLoading = false;
+	}
+
+	async Task LoadData()
+	{
+		mutes = [];
+		blocks = [];
+		mutesMaxId = null;
+		blocksMaxId = null;
+		await Task.WhenAll(MoreMutes(), MoreBlocks());
+		domains = await AccountService.DomainBlocks();
+	}
+
+	async Task MoreMutes()
+	{
+		var result = await AccountService.Mutes(mutesMaxId);
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		var page = (AccountPage)result.Data;
+		mutes.AddRange(page.Accounts.Where(a => mutes.All(m => m.Id != a.Id)));
+		mutesMaxId = page.MaxId;
+	}
+
+	async Task MoreBlocks()
+	{
+		var result = await AccountService.Blocks(blocksMaxId);
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		var page = (AccountPage)result.Data;
+		blocks.AddRange(page.Accounts.Where(a => blocks.All(b => b.Id != a.Id)));
+		blocksMaxId = page.MaxId;
+	}
+
+	async Task Undo(Account account, AccountAction action)
+	{
+		busy.Add(account.Id);
+		var result = await AccountService.Act(account.Id, action);
+		busy.Remove(account.Id);
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		if (action is AccountAction.Unmute)
+			mutes.RemoveAll(m => m.Id == account.Id);
+		else
+			blocks.RemoveAll(b => b.Id == account.Id);
+	}
+
+	// what a person types as a server (a URL, a handle's host, any case) as the bare host PrivaPub keys it by
+	static string Domain(string typed)
+	{
+		var text = typed?.Trim().TrimStart('@') ?? "";
+		if (Uri.TryCreate(text.Contains("://") ? text : "https://" + text, UriKind.Absolute, out var uri))
+			text = uri.Host;
+		return text.ToLowerInvariant();
+	}
+
+	async Task BlockDomain()
+	{
+		var domain = Domain(draft.Domain);
+		if (domain.Length == 0 || domains.Contains(domain))
+		{
+			draft = new();
+			return;
+		}
+
+		busy.Add(domain);
+		var result = await AccountService.BlockDomain(domain);
+		busy.Remove(domain);
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		draft = new();
+		domains = [.. domains.Append(domain).Order()];
+		Toast.AddResponseSuccess(Localizer["{0} is blocked.", domain]);
+	}
+
+	async Task UnblockDomain(string domain)
+	{
+		busy.Add(domain);
+		var result = await AccountService.UnblockDomain(domain);
+		busy.Remove(domain);
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		domains.Remove(domain);
+	}
+}

Components/Settings/NotificationPolicyEditor.razor

@@ -0,0 +1,149 @@
+@using Microsoft.AspNetCore.Components.Rendering
+@inherits LocalizableComponentBase
+
+@* The persona's notification policy (/api/v2/notifications/policy): what notifications from people it does not follow,
+   people who do not follow it, new accounts, private mentions it did not ask for and accounts this server limits become.
+   Filtered ones wait in a request per account (/api/v1/notifications/requests), let in (with that account from then
+   on) or dismissed here. *@
+@if (IsLoading)
+{
+	<p class="flex w-full items-center justify-center gap-2">
+		<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+		@Localizer["loading"]
+	</p>
+}
+else
+{
+	<div class="flex flex-col gap-4" data-notification-policy>
+		<EditForm Model="policy" OnValidSubmit="Save" class="flex flex-col gap-2">
+			<label class="flex flex-wrap items-center justify-between gap-2">
+				<span class="text-sm">@Localizer["People you don't follow"]</span>
+				<DSelect TValue="string" Size="DSize.Sm" class="w-40" @bind-Value="policy.ForNotFollowing" data-policy="for_not_following">@Actions</DSelect>
+			</label>
+			<label class="flex flex-wrap items-center justify-between gap-2">
+				<span class="text-sm">@Localizer["People who don't follow you"]</span>
+				<DSelect TValue="string" Size="DSize.Sm" class="w-40" @bind-Value="policy.ForNotFollowers" data-policy="for_not_followers">@Actions</DSelect>
+			</label>
+			<label class="flex flex-wrap items-center justify-between gap-2">
+				<span class="text-sm">@Localizer["New accounts"]</span>
+				<DSelect TValue="string" Size="DSize.Sm" class="w-40" @bind-Value="policy.ForNewAccounts" data-policy="for_new_accounts">@Actions</DSelect>
+			</label>
+			<label class="flex flex-wrap items-center justify-between gap-2">
+				<span class="text-sm">@Localizer["Private mentions you did not ask for"]</span>
+				<DSelect TValue="string" Size="DSize.Sm" class="w-40" @bind-Value="policy.ForPrivateMentions" data-policy="for_private_mentions">@Actions</DSelect>
+			</label>
+			<label class="flex flex-wrap items-center justify-between gap-2">
+				<span class="text-sm">@Localizer["Accounts this server limits"]</span>
+				<DSelect TValue="string" Size="DSize.Sm" class="w-40" @bind-Value="policy.ForLimitedAccounts" data-policy="for_limited_accounts">@Actions</DSelect>
+			</label>
+			<p class="text-xs opacity-70">@Localizer["Filtered notifications wait below, one request per account; dropped ones are never kept."]</p>
+			<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary" class="self-start" Disabled="@(IsDefaultDisabled || isSaving)" data-policy-save>
+				@Localizer["Save"]
+			</DButton>
+		</EditForm>
+
+		<section class="flex flex-col gap-2" data-notification-requests>
+			<h3 class="font-semibold text-sm">@Localizer["Filtered notifications"]</h3>
+			@if (requests.Count == 0)
+			{
+				<p class="text-sm opacity-70">@Localizer["No filtered notifications."]</p>
+			}
+			@foreach (var request in requests)
+			{
+				<div class="flex flex-col gap-2 p-3 rounded-xl neo-raised neo-2xs min-w-0" data-request="@request.Account.Acct">
+					<div class="flex flex-wrap items-center gap-3 min-w-0">
+						<a class="flex items-center gap-3 min-w-0 flex-1" href="@($"account/{Uri.EscapeDataString(request.Account.Id)}")">
+							@* alt="": the name is next to it. *@
+							<img alt="" class="h-9 w-9 flex-none object-cover rounded-full" src="@(request.Account.Avatar ?? "imgs/icon-192.png")" />
+							<span class="flex flex-col min-w-0">
+								<b class="truncate">@CustomEmojis.Text(request.Account.Name, request.Account.Emojis)</b>
+								<span class="text-xs opacity-70 truncate">@("@" + request.Account.Acct)</span>
+							</span>
+						</a>
+						<DBadge Size="DSize.Sm">@Localizer["{0} notifications", request.NotificationsCount]</DBadge>
+						<DButton Size="DSize.Sm" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || busy.Contains(request.Id))"
+								 OnClick="@(() => Answer(request, true))" data-request-accept>@Localizer["Let in"]</DButton>
+						<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || busy.Contains(request.Id))"
+								 OnClick="@(() => Answer(request, false))" data-request-dismiss>@Localizer["Dismiss"]</DButton>
+					</div>
+					@if (request.LastStatus?.Content is { Length: > 0 } content)
+					{
+						<div class="post-content text-sm opacity-80 break-words line-clamp-3">@((MarkupString)CustomEmojis.Html(content, request.LastStatus.Emojis))</div>
+					}
+				</div>
+			}
+		</section>
+	</div>
+}
+
+@code {
+	[Inject] TimelineService TimelineService { get; set; }
+
+	NotificationPolicy policy = new();
+
+	// what a notification can become, the same for every rule
+	void Actions(RenderTreeBuilder __builder)
+	{
+		<option value="accept">@Localizer["Accept"]</option>
+		<option value="filter">@Localizer["Filter"]</option>
+		<option value="drop">@Localizer["Drop"]</option>
+	}
+	List<NotificationRequest> requests = [];
+	// the requests whose answer is on its way
+	HashSet<string> busy = [];
+	bool isSaving;
+	string loadedPersonaId;
+
+	protected override async Task OnParametersSetAsync()
+	{
+		if (CascadingState.PersonaId == loadedPersonaId)
+			return;
+		loadedPersonaId = CascadingState.PersonaId;
+
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+		IsLoading = false;
+	}
+
+	async Task LoadData()
+	{
+		policy = await TimelineService.NotificationPolicy() ?? new();
+		requests = await TimelineService.NotificationRequests();
+	}
+
+	async Task Save()
+	{
+		isSaving = true;
+		var result = await TimelineService.SetNotificationPolicy(policy);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		policy = (NotificationPolicy)result.Data ?? policy;
+		Toast.AddResponseSuccess(Localizer["Notification policy saved."]);
+	}
+
+	async Task Answer(NotificationRequest request, bool accept)
+	{
+		busy.Add(request.Id);
+		var result = await TimelineService.AnswerNotificationRequest(request.Id, accept);
+		busy.Remove(request.Id);
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		requests.Remove(request);
+	}
+}

Components/Settings/PersonaArchivePanel.razor

@@ -0,0 +1,364 @@
+@inherits LocalizableComponentBase
+@implements IAsyncDisposable
+
+@* The persona's whole archive (/clientapi/persona/{id}/archive; owner decision 2026-10-07): made on PrivaPub in Mastodon's
+   layout and downloaded through a link, or another archive (its own, or Mastodon's) uploaded in pieces straight from
+   the picked file (js/transfer.js) and imported into it, the parts chosen. Imported posts are delivered to no one. *@
+<div class="flex flex-col gap-5 w-full" data-archive>
+	<section class="flex flex-col gap-2" data-archive-export>
+		<h3 class="font-semibold text-sm">@Localizer["This persona's archive"]</h3>
+		<p class="text-sm opacity-70">@Localizer["Everything the persona posted, with its pictures, what it follows, blocks and mutes, its lists, bookmarks and filters, in the archive Mastodon makes. Nothing of your login or your other personas."]</p>
+		<div class="flex flex-wrap items-center gap-2 pointer-coarse:gap-2">
+			<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || busy || state.ExportState is "queued" or "running")" OnClick="Export" data-archive-make>
+				@if (state.ExportState is "queued" or "running")
+				{
+					<DLoading Size="DSize.Xs" LabelText="@Localizer["loading"]" />
+				}
+				else
+				{
+					<i class="ion-md-archive"></i>
+				}
+				<span>@Localizer["Make the archive"]</span>
+			</DButton>
+			@if (state.ExportState == "ready")
+			{
+				@if (link is null)
+				{
+					<DButton Size="DSize.Sm" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || busy)" OnClick="Link" data-archive-get-link>
+						<i class="ion-md-download"></i> @Localizer["Get the link"]
+					</DButton>
+				}
+				else
+				{
+					<a class="btn btn-primary btn-sm" href="@link" data-archive-link>
+						<i class="ion-md-download"></i> @Localizer["Download {0}", state.ExportBytes.GetFileSize(Localizer)]
+					</a>
+				}
+				<span class="text-xs opacity-70" title="@state.ExportReadyAt?.ToLocalTime().ToString(SUtility.dateTimeFormatExt)">
+					@Localizer["Made {0}; kept until {1}.", state.ExportReadyAt?.GetPassedTime(Localizer) ?? "", state.ExportExpiresAt?.ToLocalTime().ToString(SUtility.dateTimeFormatExt) ?? ""]
+				</span>
+			}
+		</div>
+		@if (state.ExportState == "failed")
+		{
+			<ErrorViewer AdditionalError="@Localizer["The archive could not be made: {0}", state.ExportError ?? ""]" />
+		}
+	</section>
+
+	<section class="flex flex-col gap-2" data-archive-import>
+		<h3 class="font-semibold text-sm">@Localizer["Restore an archive into this persona"]</h3>
+		<p class="text-sm opacity-70">@Localizer["An archive made here, or by Mastodon. Its posts arrive on this persona's profile without being sent to anyone; follows are asked again."]</p>
+		<DFileInput Size="DSize.Sm" Accept=".zip,application/zip" OnChange="Picked" disabled="@(IsDefaultDisabled || Importing)" data-archive-file />
+		<div class="flex flex-wrap gap-x-4 gap-y-2 pointer-coarse:gap-2">
+			@foreach (var part in Parts)
+			{
+				<DCheckbox Value="@chosen.Contains(part)" ValueChanged="on => Choose(part, on)" ValueExpression="() => chosenFlag" Size="DSize.Sm"
+						   LabelText="@PartName(part)" disabled="@(IsDefaultDisabled || Importing)" data-archive-part="@part" />
+			}
+		</div>
+		<p class="text-xs opacity-70">@Localizer["Liking again tells each post's author; located and scheduled posts come from PrivaPub's archives only."]</p>
+		<div class="flex flex-wrap items-center gap-2 pointer-coarse:gap-2">
+			@if (!Importing)
+			{
+				<DButton Size="DSize.Sm" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || busy || pickedName is null || chosen.Count == 0)" OnClick="Import"
+						 data-archive-import-start>
+					<i class="ion-md-cloud-upload"></i> @Localizer["Import"]
+				</DButton>
+			}
+			else
+			{
+				<DButton Size="DSize.Sm" Color="DColor.Warning" Disabled="@(state.ImportState is not ("queued" or "running"))" OnClick="Stop" data-archive-stop>
+					@Localizer["Stop"]
+				</DButton>
+			}
+		</div>
+		@if (uploading)
+		{
+			<DProgress class="w-full max-w-md" Value="@uploadedPercent" Max="100" Color="DColor.Primary" />
+			<span class="text-xs opacity-70">@Localizer["Sending {0} of {1}", uploaded.GetFileSize(Localizer), uploadSize.GetFileSize(Localizer)]</span>
+		}
+		@if (state.ImportState is not (null or "none"))
+		{
+			<div class="flex flex-col gap-1" data-archive-report data-archive-state="@state.ImportState">
+				@if (state.ImportState is "queued" or "running")
+				{
+					<DProgress class="w-full max-w-md" Value="@state.ImportDone" Max="@Math.Max(1, state.ImportTotal)" />
+				}
+				<span class="text-sm">
+					@(state.ImportState switch
+					{
+						"queued" => Localizer["Waiting to start."],
+						"running" => Localizer["Importing: {0} of {1} read.", state.ImportDone, state.ImportTotal],
+						"done" => Localizer["Imported."],
+						"stopped" => Localizer["Stopped."],
+						_ => Localizer["The import failed: {0}", state.ImportError ?? ""]
+					})
+				</span>
+				@if (state.ImportFrom is { Length: > 0 } from)
+				{
+					<span class="text-xs opacity-70">@(state.ImportSameActor ? Localizer["From this persona's own archive."] : Localizer["From {0}.", from])</span>
+				}
+				<ul class="text-xs tabular-nums">
+					@foreach (var (what, count) in state.ImportCounts.OrderBy(c => c.Key, StringComparer.Ordinal))
+					{
+						<li data-archive-count="@what">@count × @CountName(what)</li>
+					}
+				</ul>
+			</div>
+		}
+	</section>
+</div>
+
+@code {
+	[Inject] ArchiveService Archives { get; set; }
+	[Inject] TokenAuthStateProvider AuthStateProvider { get; set; }
+	[Inject] AppConfiguration Configuration { get; set; }
+	[Inject] IJSRuntime JS { get; set; }
+
+	const string FileInput = "input[data-archive-file]";
+	static readonly TimeSpan PollEvery = TimeSpan.FromSeconds(3);
+	static readonly string[] Parts = ["posts", "profile", "follows", "blocks", "mutes", "domainblocks", "lists", "bookmarks", "filters", "tags",
+		"notificationpolicy", "pins", "located", "scheduled", "likes"];
+
+	ViewPersonaArchive state = new();
+	string loadedFor;
+	HashSet<string> chosen = ["posts", "follows", "blocks", "mutes", "domainblocks", "lists", "bookmarks", "filters", "tags", "pins"];
+	bool chosenFlag;
+	bool busy;
+	string link;
+	string pickedName;
+	bool uploading;
+	long uploaded;
+	long uploadSize;
+	double uploadedPercent;
+	IJSObjectReference transfer;
+	DotNetObjectReference<PersonaArchivePanel> self;
+	CancellationTokenSource polling;
+
+	bool Importing => uploading || state.ImportState is "queued" or "running";
+
+	protected override async Task OnInitializedAsync()
+	{
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+		IsLoading = false;
+	}
+
+	// another persona: its own archive
+	protected override async Task OnParametersSetAsync()
+	{
+		if (!IsLoading && loadedFor != CascadingState.PersonaId)
+			await LoadData();
+	}
+
+	async Task LoadData()
+	{
+		loadedFor = CascadingState.PersonaId;
+		link = null;
+		if (loadedFor is null)
+			return;
+		state = await Archives.State(loadedFor) ?? new ViewPersonaArchive();
+		if (state.ExportState is "queued" or "running" || state.ImportState is "queued" or "running")
+			Poll();
+	}
+
+	void Poll()
+	{
+		if (polling is not null)
+			return;
+		polling = new();
+		var token = polling.Token;
+		var persona = loadedFor;
+		_ = Task.Run(async () =>
+		{
+			using var timer = new PeriodicTimer(PollEvery);
+			while (await timer.WaitForNextTickAsync(token))
+			{
+				if (persona != loadedFor)
+					break;
+				if (await Archives.State(persona, token) is { } read)
+					state = read;
+				await InvokeAsync(StateHasChanged);
+				if (state.ExportState is not ("queued" or "running") && state.ImportState is not ("queued" or "running"))
+					break;
+			}
+			polling = null;
+		}, token);
+	}
+
+	string PartName(string part) => part switch
+	{
+		"posts" => Localizer["Posts and their pictures"],
+		"profile" => Localizer["Profile: name, words, fields, pictures"],
+		"follows" => Localizer["Follows, asked again"],
+		"blocks" => Localizer["Blocks"],
+		"mutes" => Localizer["Mutes"],
+		"domainblocks" => Localizer["Blocked servers"],
+		"lists" => Localizer["Lists"],
+		"bookmarks" => Localizer["Bookmarks"],
+		"filters" => Localizer["Filters"],
+		"tags" => Localizer["Followed hashtags"],
+		"notificationpolicy" => Localizer["Notification policy"],
+		"pins" => Localizer["Pinned posts"],
+		"located" => Localizer["Located posts"],
+		"scheduled" => Localizer["Scheduled posts"],
+		"likes" => Localizer["Likes, given again"],
+		_ => part
+	};
+
+	string CountName(string what) => what switch
+	{
+		"posts" => Localizer["posts imported"],
+		"posts already here" => Localizer["posts already here"],
+		"posts deleted here" => Localizer["posts deleted here, left deleted"],
+		"boosts skipped" => Localizer["boosts left out"],
+		"direct or circle posts skipped" => Localizer["private posts left out"],
+		"not the archive's own" => Localizer["posts by others left out"],
+		"not a post" => Localizer["other items left out"],
+		"media" => Localizer["pictures and files imported"],
+		"media not in the archive" => Localizer["pictures not in the archive"],
+		"media refused" => Localizer["pictures refused"],
+		"located posts" => Localizer["located posts imported"],
+		"located posts already here" => Localizer["located posts already here"],
+		"scheduled posts" => Localizer["scheduled posts imported"],
+		"scheduled posts past or refused" => Localizer["scheduled posts past or refused"],
+		"followed hashtags" => Localizer["hashtags followed"],
+		"notification policy" => Localizer["notification policy set"],
+		"filters" => Localizer["filters imported"],
+		"pins" => Localizer["posts pinned"],
+		"blocked servers" => Localizer["servers blocked"],
+		"blocks" => Localizer["accounts blocked"],
+		"mutes" => Localizer["accounts muted"],
+		"follows" => Localizer["follows asked"],
+		"lists" => Localizer["lists made"],
+		"list members" => Localizer["list members added"],
+		"list members not followed" => Localizer["list members not followed"],
+		"bookmarks" => Localizer["bookmarks imported"],
+		"likes" => Localizer["likes given"],
+		"profile" => Localizer["profile updated"],
+		"pictures refused" => Localizer["pictures refused"],
+		_ when what.EndsWith(" not found", StringComparison.Ordinal) => Localizer["not found: {0}", what[..^" not found".Length]],
+		_ when what.EndsWith(" skipped", StringComparison.Ordinal) => Localizer["already there: {0}", what[..^" skipped".Length]],
+		_ => what
+	};
+
+	void Choose(string part, bool on)
+	{
+		if (on)
+			chosen.Add(part);
+		else
+			chosen.Remove(part);
+	}
+
+	void Picked(InputFileChangeEventArgs e) => pickedName = e.FileCount > 0 ? e.File.Name : null;
+
+	Uri ApiBase => new(string.IsNullOrEmpty(Configuration.ApiBaseAddress) ? Navigation.BaseUri : Configuration.ApiBaseAddress);
+
+	async Task Export()
+	{
+		busy = true;
+		var result = await Archives.Export(loadedFor);
+		busy = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		state = (ViewPersonaArchive)result.Data;
+		link = null;
+		Poll();
+	}
+
+	async Task Link()
+	{
+		busy = true;
+		var result = await Archives.Ticket(loadedFor);
+		busy = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		link = new Uri(ApiBase, ((ViewArchiveTicket)result.Data).Url).AbsoluteUri;
+	}
+
+	async Task Import()
+	{
+		transfer ??= await JS.InvokeAsync<IJSObjectReference>("import", "./js/transfer.js");
+		self ??= DotNetObjectReference.Create(this);
+		var started = await Archives.StartUpload();
+		if (started.IsInvalid)
+		{
+			Toast.AddResponseError(started);
+			return;
+		}
+
+		var upload = (ViewArchiveUpload)started.Data;
+		(uploading, uploaded, uploadSize, uploadedPercent) = (true, 0, 0, 0);
+		var endpoint = new Uri(ApiBase, APIs.ClientApi.PUT_M_PersonaArchiveUpload(upload.Id)).AbsoluteUri;
+		var sent = await transfer.InvokeAsync<UploadOutcome>("upload", FileInput, endpoint, await AuthStateProvider.GetToken(), upload.ChunkBytes, self);
+		uploading = false;
+		if (!sent.Ok)
+		{
+			await Archives.CancelUpload(upload.Id);
+			Toast.AddResponseError(Localizer["The upload failed: {0}", sent.Error ?? sent.Status.ToString()]);
+			return;
+		}
+
+		var asked = await Archives.Import(loadedFor, new ImportPersonaArchiveForm { UploadId = upload.Id, Parts = [.. Parts.Where(chosen.Contains)] });
+		if (asked.IsInvalid)
+		{
+			Toast.AddResponseError(asked);
+			return;
+		}
+
+		state = (ViewPersonaArchive)asked.Data;
+		Poll();
+	}
+
+	async Task Stop()
+	{
+		var result = await Archives.Stop(loadedFor);
+		if (result.IsInvalid)
+			Toast.AddResponseError(result);
+	}
+
+	[JSInvokable]
+	public Task Progress(long received, long total)
+	{
+		(uploaded, uploadSize) = (received, total);
+		uploadedPercent = total == 0 ? 100 : 100.0 * received / total;
+		return InvokeAsync(StateHasChanged);
+	}
+
+	sealed class UploadOutcome
+	{
+		public bool Ok { get; set; }
+		public int Status { get; set; }
+		public string Error { get; set; }
+	}
+
+	public async ValueTask DisposeAsync()
+	{
+		polling?.Cancel();
+		self?.Dispose();
+		if (transfer is null)
+			return;
+		try
+		{
+			await transfer.DisposeAsync();
+		}
+		catch (JSDisconnectedException)
+		{
+		}
+	}
+}

Components/Settings/PersonasEditor.razor

@@ -0,0 +1,78 @@
+@inherits LocalizableComponentBase
+
+@* The root's personas (/clientapi/avatar/private): each one used in turn, and a new one made. Personas are never linked
+   to one another: no server, PrivaPub's included, shows that they share a root. *@
+<div class="flex flex-col gap-4 w-full" data-personas>
+	<div class="flex flex-col gap-2">
+		@foreach (var persona in CascadingState.Personas)
+		{
+			<div class="flex items-center gap-2 min-w-0" data-persona="@persona.UserName">
+				<img class="size-8 rounded-full object-cover" src="@(persona.PictureURL ?? "imgs/icon-192.png")" alt="" />
+				<span class="flex-1 min-w-0 truncate"><b>@(persona.Name ?? persona.UserName)</b> <span class="text-xs opacity-70">@persona.Handle</span></span>
+				@if (persona.Id == CascadingState.PersonaId)
+				{
+					<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft" Color="DColor.Primary">@Localizer["in use"]</DBadge>
+				}
+				else
+				{
+					<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || switching is not null)" OnClick="() => Use(persona)">@Localizer["Use"]</DButton>
+				}
+			</div>
+		}
+	</div>
+
+	<EditForm Model="form" OnValidSubmit="Create" class="flex flex-col gap-2 p-3 rounded-xl neo-inset neo-2xs" data-persona-new>
+		<DataAnnotationsValidator />
+		<b class="text-sm">@Localizer["A new persona"]</b>
+		<div class="flex flex-wrap gap-2">
+			<DInput TValue="string" class="flex-1 min-w-40" @bind-Value="form.UserName" Immediate="true" autocomplete="off"
+					maxlength="@PrivaPub.ClientModels.Constants.MaxAvatarNameLength" placeholder="@Localizer["user name (a-z, 0-9, _)"]" data-persona-username>
+				<Prefix>@@</Prefix>
+			</DInput>
+			<DInput TValue="string" class="flex-1 min-w-40" @bind-Value="form.Name" Immediate="true" autocomplete="off"
+					maxlength="@PrivaPub.ClientModels.Constants.MaxAvatarNameLength" placeholder="@Localizer["Display name"]" data-persona-name />
+		</div>
+		<DTextarea @bind-Value="form.Biography" Immediate="true" rows="3" autocomplete="off" maxlength="@ProfileForm.NoteLength"
+				   placeholder="@Localizer["Biography"]" data-persona-biography />
+		<ErrorViewer />
+		<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary" class="self-end" Disabled="@(IsDefaultDisabled || isSaving)" data-persona-create>
+			<i class="ion-md-person-add"></i><span>@Localizer["Make the persona"]</span>
+		</DButton>
+	</EditForm>
+</div>
+
+@code {
+	[Inject] AuthService AuthService { get; set; }
+
+	InsertAvatarForm form = new();
+	bool isSaving;
+	string switching;
+
+	protected override void OnInitialized() => IsLoading = false;
+
+	async Task Use(ViewAvatar persona)
+	{
+		switching = persona.Id;
+		var result = await CascadingState.SwitchPersona(persona.Id);
+		switching = null;
+		if (result.IsInvalid)
+			Toast.AddResponseError(result);
+	}
+
+	async Task Create()
+	{
+		isSaving = true;
+		form.UserName = form.UserName?.Trim().TrimStart('@').ToLowerInvariant();
+		var result = await AuthService.CreatePersona(form);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		form = new();
+		await CascadingState.ReloadPersonas();
+		Toast.AddResponseSuccess(Localizer["Persona made."]);
+	}
+}

Components/Settings/ProfileEditor.razor

@@ -0,0 +1,257 @@
+@inherits LocalizableComponentBase
+
+@* The current persona's profile (/api/v1/accounts/update_credentials): its pictures, name, biography and fields as it
+   wrote them, whether it approves followers by hand, is a bot, is listed and searchable, and how its new posts start.
+   PrivaPub tells the persona's followers' servers of the change. *@
+@if (IsLoading)
+{
+	<p class="flex w-full items-center justify-center gap-2">
+		<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+		@Localizer["loading"]
+	</p>
+}
+else if (account is null)
+{
+	<p class="w-full text-center"><i class="ion-ios-remove-circle-outline"></i> @Localizer["No persona"]</p>
+}
+else
+{
+	<EditForm Model="form" OnValidSubmit="Save" class="flex flex-col gap-4 w-full" data-profile-editor>
+		<div class="relative w-full">
+			<img class="w-full h-28 md:h-36 object-cover rounded-xl" src="@(form.Header?.Preview ?? account.Header)" alt="@Localizer["Header"]" />
+			<img class="absolute -bottom-6 left-4 size-20 rounded-full object-cover neo-raised neo-xs" src="@(form.Avatar?.Preview ?? account.Avatar)"
+				 alt="@Localizer["Avatar"]" />
+		</div>
+		<div class="flex flex-wrap gap-3 pt-6">
+			<div class="flex flex-col gap-1 text-sm">
+				<label class="flex flex-col gap-1">
+					<span>@Localizer["Avatar"]</span>
+					<DFileInput Size="DSize.Sm" Accept="@PictureTypes" OnChange="e => Pick(e, true)" data-profile-avatar />
+				</label>
+				@if (HasOwn(account.Avatar) && form.Avatar is null)
+				{
+					<DButton Size="DSize.Xs" class="self-start" Disabled="IsDefaultDisabled || isSaving" OnClick="() => RemovePicture(true)" data-profile-avatar-remove>
+						<i class="ion-md-trash text-error"></i><span>@Localizer["Remove the avatar"]</span>
+					</DButton>
+				}
+			</div>
+			<div class="flex flex-col gap-1 text-sm">
+				<label class="flex flex-col gap-1">
+					<span>@Localizer["Header"]</span>
+					<DFileInput Size="DSize.Sm" Accept="@PictureTypes" OnChange="e => Pick(e, false)" data-profile-header />
+				</label>
+				@if (HasOwn(account.Header) && form.Header is null)
+				{
+					<DButton Size="DSize.Xs" class="self-start" Disabled="IsDefaultDisabled || isSaving" OnClick="() => RemovePicture(false)" data-profile-header-remove>
+						<i class="ion-md-trash text-error"></i><span>@Localizer["Remove the header"]</span>
+					</DButton>
+				}
+			</div>
+		</div>
+
+		<label class="flex flex-col gap-1 max-w-md">
+			<span class="text-sm">@Localizer["Display name"]</span>
+			<DInput TValue="string" @bind-Value="form.DisplayName" Immediate="true" autocomplete="off" maxlength="@ProfileForm.DisplayNameLength"
+					data-profile-name />
+		</label>
+		<label class="flex flex-col gap-1">
+			<span class="text-sm">@Localizer["Biography"]</span>
+			<DTextarea @bind-Value="form.Note" Immediate="true" rows="4" autocomplete="off" maxlength="@ProfileForm.NoteLength" data-profile-note />
+			<span class="text-xs opacity-70 tabular-nums self-end">@(form.Note?.Length ?? 0)/@ProfileForm.NoteLength</span>
+		</label>
+
+		<fieldset class="flex flex-col gap-2">
+			<legend class="text-sm font-semibold pb-1">@Localizer["Profile fields"]</legend>
+			@foreach (var field in form.Fields)
+			{
+				<div class="flex flex-wrap gap-2" data-profile-field="@form.Fields.IndexOf(field)">
+					<DInput TValue="string" class="flex-1 min-w-36" @bind-Value="field.Name" Immediate="true" autocomplete="off"
+							maxlength="@ProfileForm.FieldLength" placeholder="@Localizer["Label"]" />
+					<DInput TValue="string" class="flex-[2] min-w-48" @bind-Value="field.Value" Immediate="true" autocomplete="off"
+							maxlength="@ProfileForm.FieldLength" placeholder="@Localizer["Content"]" />
+				</div>
+			}
+		</fieldset>
+
+		<div class="flex flex-col gap-3">
+			<DToggle LabelText="@Localizer["Approve followers by hand"]" @bind-Value="form.Locked" data-profile-locked />
+			<DToggle LabelText="@Localizer["This persona is automated (a bot)"]" @bind-Value="form.Bot" />
+			<DToggle LabelText="@Localizer["List it in the directory and suggest it to others"]" @bind-Value="form.Discoverable" />
+			<DToggle LabelText="@Localizer["Let its public posts be found by search"]" @bind-Value="form.Indexable" />
+		</div>
+
+		<fieldset class="flex flex-wrap gap-4">
+			<legend class="text-sm font-semibold pb-1">@Localizer["New posts"]</legend>
+			<label class="flex flex-col gap-1 text-sm">
+				<span>@Localizer["Visibility"]</span>
+				<DSelect TValue="Visibility" Size="DSize.Sm" @bind-Value="form.Privacy" data-profile-privacy>
+					@foreach (var type in Visibilities)
+					{
+						<option value="@type">@Localizer[type.ToString()]</option>
+					}
+				</DSelect>
+			</label>
+			<label class="flex flex-col gap-1 text-sm">
+				<span>@Localizer["Language"]</span>
+				<DSelect TValue="string" Size="DSize.Sm" @bind-Value="form.Language">
+					<option value="">—</option>
+					@foreach (var (languageCode, languageName) in Languages.All)
+					{
+						<option value="@languageCode">@languageName</option>
+					}
+				</DSelect>
+			</label>
+			<label class="flex flex-col gap-1 text-sm">
+				<span>@Localizer["Who may quote them"]</span>
+				<DSelect TValue="QuotePolicy" Size="DSize.Sm" @bind-Value="form.QuotePolicy">
+					@foreach (var policy in Enum.GetValues<QuotePolicy>())
+					{
+						<option value="@policy">@QuotePolicyName(policy)</option>
+					}
+				</DSelect>
+			</label>
+			<DToggle class="self-end" LabelText="@Localizer["Mark media as sensitive"]" @bind-Value="form.Sensitive" />
+		</fieldset>
+
+		<ErrorViewer AdditionalErrors="pictureErrors" />
+
+		<div class="flex flex-wrap gap-2 justify-end">
+			<DButton Size="DSize.Sm" OnClick="Reset" Disabled="@(IsDefaultDisabled || isSaving)">@Localizer["Reset"]</DButton>
+			<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || isSaving)" data-profile-save>
+				<i class="ion-md-checkmark"></i><span>@Localizer["Save"]</span>
+			</DButton>
+		</div>
+	</EditForm>
+}
+
+@code {
+	[Inject] AccountService AccountService { get; set; }
+	[Inject] MediaService MediaService { get; set; }
+	[Inject] AuthService AuthService { get; set; }
+	[Inject] ILoggingService Logger { get; set; }
+
+	static readonly Visibility[] Visibilities = [Visibility.Public, Visibility.Unlisted, Visibility.FollowersOnly];
+
+	Account account;
+	ProfileForm form = new();
+	string loadedPersonaId;
+	bool isSaving;
+	List<string> pictureErrors = [];
+	// the picture types the server takes, read with the account
+	List<string> pictureTypes = ["image/jpeg", "image/png", "image/gif", "image/webp"];
+
+	string PictureTypes => string.Join(",", pictureTypes);
+
+	// a picture of its own, not the server's default
+	static bool HasOwn(string url) => url is { Length: > 0 } && !url.Contains("/missing-", StringComparison.Ordinal);
+
+	protected override async Task OnParametersSetAsync()
+	{
+		if (CascadingState.PersonaId == loadedPersonaId)
+			return;
+		loadedPersonaId = CascadingState.PersonaId;
+
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+		IsLoading = false;
+	}
+
+	async Task LoadData()
+	{
+		// the account as the persona sees itself, with its Source
+		account = await AuthService.CurrentAccount();
+		pictureTypes = [.. (await MediaService.Limits()).SupportedMimeTypes.Where(t => t.StartsWith("image/"))];
+		Reset();
+	}
+
+	void Reset()
+	{
+		pictureErrors = [];
+		form = account is null ? new() : ProfileForm.Of(account);
+	}
+
+	string QuotePolicyName(QuotePolicy policy) => policy switch
+	{
+		QuotePolicy.Followers => Localizer["Its followers"],
+		QuotePolicy.Nobody => Localizer["Nobody"],
+		_ => Localizer["Anyone"]
+	};
+
+	async Task Pick(InputFileChangeEventArgs eventArgs, bool isAvatar)
+	{
+		pictureErrors = [];
+		var file = eventArgs.File;
+		if (!pictureTypes.Contains(file.ContentType))
+		{
+			pictureErrors.Add(Localizer["\"{0}\" is not a kind of file this server takes.", file.Name]);
+			return;
+		}
+		if (file.Size > ProfileForm.MaximumPictureSize)
+		{
+			pictureErrors.Add(Localizer["Supplied file \"{0}\" with size {1} exceeds the maximum of {2}.", file.Name,
+				file.Size.GetFileSize(Localizer), ProfileForm.MaximumPictureSize.GetFileSize(Localizer)]);
+			return;
+		}
+
+		// the file is sent as it is when saving, and is the form's at once (a save meanwhile sends it); only a small picture
+		// of it is kept to show it, made afterwards, and PrivaPub decides about a file the browser can't draw
+		var picture = new UploadMedia { File = file, FileName = file.Name, ContentType = file.ContentType, Size = file.Size };
+		if (isAvatar)
+			form.Avatar = picture;
+		else
+			form.Header = picture;
+		try
+		{
+			var small = await file.RequestImageFileAsync("image/jpeg", isAvatar ? 240 : 900, isAvatar ? 240 : 300);
+			await using var stream = small.OpenReadStream(4 * 1024 * 1024);
+			using var buffer = new MemoryStream();
+			await stream.CopyToAsync(buffer);
+			picture.Preview = $"data:image/jpeg;base64,{Convert.ToBase64String(buffer.ToArray())}";
+		}
+		catch (Exception ex)
+		{
+			await Logger.ProcessWarning(ex.Message, $"{nameof(ProfileEditor)}.{nameof(Pick)}:{file.Name}");
+		}
+	}
+
+	async Task RemovePicture(bool avatar)
+	{
+		isSaving = true;
+		var result = await AccountService.RemovePicture(avatar);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		// the rest of the form stays as being written: it shows the server's pictures, which are the account's
+		account = (Account)result.Data;
+		CascadingState.PersonaChanged(account);
+		Toast.AddResponseSuccess(avatar ? Localizer["Avatar removed."] : Localizer["Header removed."]);
+	}
+
+	async Task Save()
+	{
+		isSaving = true;
+		var result = await AccountService.UpdateProfile(form);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		account = (Account)result.Data;
+		CascadingState.PersonaChanged(account);
+		Reset();
+		Toast.AddResponseSuccess(Localizer["Profile saved."]);
+	}
+}

Components/Settings/TotpEditor.razor

@@ -0,0 +1,306 @@
+@inherits LocalizableComponentBase
+
+@* Two-factor sign-in (TOTP, /clientapi/user/totp), a block of the login's settings (AccountEditor). Off: turned on with
+   the password (setup), then the secret shown as a QR code, as text and as an otpauth:// link an authenticator app opens,
+   and the app's first code (enable); then the ten recovery codes, shown this once. Turning it on ends every other session
+   and every persona token, this device's too, and AuthService.TotpEnable goes on with the JWT PrivaPub answers. On: the
+   recovery codes left, and turned off with the password and a code from the app or a recovery code, asked first. *@
+<div class="flex flex-col gap-2 p-3 rounded-xl neo-inset neo-2xs" data-totp>
+	<p class="flex flex-wrap items-center gap-2">
+		<b class="text-sm">@Localizer["Two-factor sign-in"]</b>
+		@if (account is { TwoFactorEnabled: true })
+		{
+			<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft" Color="DColor.Success" data-totp-on>@Localizer["active"]</DBadge>
+		}
+		else if (account is not null)
+		{
+			<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft" data-totp-off>@Localizer["not active"]</DBadge>
+		}
+	</p>
+
+	@if (IsLoading)
+	{
+		<DLoading Variant="DLoadingVariant.Dots" Size="DSize.Sm" LabelText="@Localizer["loading"]" />
+	}
+	else if (recoveryCodes.Count > 0)
+	{
+		<div class="flex flex-col gap-3" data-totp-codes>
+			<DAlert Color="DAlertColor.Success" Variant="DAlertVariant.Soft" role="status">
+				<Icon><i class="ion-md-checkmark-circle text-xl" aria-hidden="true"></i></Icon>
+				<ChildContent>@Localizer["Two-factor sign-in is on. Every other device signed in to this login was signed out."]</ChildContent>
+			</DAlert>
+			<p class="text-sm">
+				<b>@Localizer["Save these recovery codes now: they won't be shown again."]</b>
+				@Localizer["Each one signs you in once in place of the app's code, if you lose your phone."]
+			</p>
+			<ol class="grid grid-cols-2 gap-x-4 gap-y-1 p-3 rounded-lg neo-inset neo-2xs font-mono text-sm select-all" data-totp-recovery-codes>
+				@foreach (var recoveryCode in recoveryCodes)
+				{
+					<li>@recoveryCode</li>
+				}
+			</ol>
+			<div class="flex flex-wrap justify-end gap-2 pointer-coarse:gap-2">
+				<DButton Size="DSize.Sm" OnClick="CopyCodes" data-totp-copy>
+					<i class="ion-md-copy"></i><span>@Localizer["Copy"]</span>
+				</DButton>
+				<DButton Size="DSize.Sm" Color="DColor.Primary" OnClick="CodesSaved" data-totp-saved>
+					<i class="ion-md-checkmark"></i><span>@Localizer["I saved them"]</span>
+				</DButton>
+			</div>
+		</div>
+	}
+	else if (account is { TwoFactorEnabled: true })
+	{
+		<p class="text-sm">@Localizer["Signing in takes the password and a code from your authenticator app, or one of your recovery codes."]</p>
+		<p class="text-sm" data-totp-codes-left>@Localizer["Recovery codes left: {0}", account.RecoveryCodesLeft]</p>
+		@if (account.RecoveryCodesLeft <= FewRecoveryCodes)
+		{
+			<DAlert Color="DAlertColor.Warning" Variant="DAlertVariant.Soft" role="status" data-totp-codes-few>
+				<Icon><i class="ion-md-warning text-xl" aria-hidden="true"></i></Icon>
+				<ChildContent>@Localizer["Few recovery codes are left: turn two-factor sign-in off and on again for ten new ones."]</ChildContent>
+			</DAlert>
+		}
+
+		@if (isDisabling)
+		{
+			<EditForm Model="disable" OnValidSubmit="Disable" class="flex flex-col gap-2" data-totp-disable>
+				<DataAnnotationsValidator />
+				<DInput TValue="string" Type="password" @bind-Value="disable.Password" Immediate="true" autocomplete="current-password"
+						placeholder="@Localizer["Current password"]" data-totp-disable-password />
+				@if (disableWithRecoveryCode)
+				{
+					<DInput TValue="string" @bind-Value="disable.Code" Immediate="true" required="@true" autocomplete="one-time-code" inputmode="text"
+							autocapitalize="none" spellcheck="false" placeholder="@Localizer["Recovery code"]" data-totp-disable-recovery />
+				}
+				else
+				{
+					<span class="text-sm">@Localizer["Code from the authenticator app"]</span>
+					<DOtp @bind-Value="disable.Code" Immediate="true" aria-label="@Localizer["Code from the authenticator app"]" data-totp-disable-code />
+				}
+				<DButton Variant="DButtonVariant.Link" Size="DSize.Sm" class="self-start" OnClick="ToggleDisableRecoveryCode" data-totp-disable-use-recovery>
+					@(disableWithRecoveryCode ? Localizer["Use the authenticator app instead"] : Localizer["Use a recovery code instead"])
+				</DButton>
+				<ErrorViewer />
+				<div class="flex flex-wrap justify-end gap-2 pointer-coarse:gap-2">
+					<DButton Size="DSize.Sm" OnClick="CloseForms">@Localizer["Cancel"]</DButton>
+					<DButton Type="submit" Size="DSize.Sm" Color="DColor.Error" Disabled="@(IsDefaultDisabled || isSaving)" data-totp-disable-confirm>
+						<i class="ion-md-unlock"></i><span>@Localizer["Turn off"]</span>
+					</DButton>
+				</div>
+			</EditForm>
+		}
+		else
+		{
+			<DButton Size="DSize.Sm" class="self-end" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="OpenDisable" data-totp-disable-open>
+				<i class="ion-md-unlock"></i><span>@Localizer["Turn off"]</span>
+			</DButton>
+		}
+	}
+	else if (account is not null)
+	{
+		<p class="text-sm">@Localizer["Signing in takes a code from an authenticator app on your phone as well as the password, so a stolen password isn't enough."]</p>
+
+		@if (setup is not null)
+		{
+			<div class="flex flex-col gap-3" data-totp-scan>
+				<p class="text-sm">@Localizer["Scan this QR code with your authenticator app, or type the key into it."]</p>
+				<img src="@setup.QrDataUri" alt="@Localizer["QR code of the key, for your authenticator app"]"
+					 class="self-center w-48 h-48 p-2 rounded-lg bg-white" data-totp-qr />
+				<div class="flex flex-col gap-1">
+					<span class="text-sm">@Localizer["Key"]</span>
+					<code class="p-2 rounded-lg neo-inset neo-2xs font-mono text-sm break-all select-all" data-totp-secret>@setup.Secret</code>
+				</div>
+				@* an <a href> to otpauth://, which a phone with an authenticator app opens in it *@
+				<DButton Href="@setup.OtpAuthUri" Size="DSize.Sm" class="self-center" data-totp-uri>
+					<i class="ion-md-open"></i><span>@Localizer["Open in the authenticator app"]</span>
+				</DButton>
+				<EditForm Model="enable" OnValidSubmit="Enable" class="flex flex-col gap-2" data-totp-enable-form>
+					<DataAnnotationsValidator />
+					<span class="text-sm">@Localizer["Then enter the 6-digit code the app shows."]</span>
+					<DOtp @bind-Value="enable.Code" Immediate="true" aria-label="@Localizer["Code from the authenticator app"]" data-totp-code />
+					<ErrorViewer />
+					<p class="text-xs opacity-70">@Localizer["Every other device signed in to this login is signed out."]</p>
+					<div class="flex flex-wrap justify-end gap-2 pointer-coarse:gap-2">
+						<DButton Size="DSize.Sm" OnClick="CloseForms">@Localizer["Cancel"]</DButton>
+						<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || isSaving)" data-totp-enable>
+							<i class="ion-md-lock"></i><span>@Localizer["Turn on"]</span>
+						</DButton>
+					</div>
+				</EditForm>
+			</div>
+		}
+		else if (isAskingPassword)
+		{
+			<EditForm Model="setupPassword" OnValidSubmit="Setup" class="flex flex-col gap-2" data-totp-setup>
+				<DataAnnotationsValidator />
+				<DInput TValue="string" Type="password" @bind-Value="setupPassword.Password" Immediate="true" autocomplete="current-password"
+						placeholder="@Localizer["Current password"]" data-totp-setup-password />
+				<ErrorViewer />
+				<div class="flex flex-wrap justify-end gap-2 pointer-coarse:gap-2">
+					<DButton Size="DSize.Sm" OnClick="CloseForms">@Localizer["Cancel"]</DButton>
+					<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || isSaving)" data-totp-setup-confirm>
+						<i class="ion-md-arrow-forward"></i><span>@Localizer["Continue"]</span>
+					</DButton>
+				</div>
+			</EditForm>
+		}
+		else
+		{
+			<DButton Size="DSize.Sm" Color="DColor.Primary" class="self-end" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="OpenSetup"
+					 data-totp-setup-open>
+				<i class="ion-md-lock"></i><span>@Localizer["Turn on two-factor sign-in"]</span>
+			</DButton>
+		}
+	}
+</div>
+
+@code {
+	[Inject] AuthService AuthService { get; set; }
+	[Inject] ConfirmService Confirm { get; set; }
+
+	/// <summary>From this many recovery codes left down, the block warns.</summary>
+	const int FewRecoveryCodes = 3;
+
+	/// <summary>The login as PrivaPub describes it; null until read, or when it couldn't be (the block stays empty).</summary>
+	ViewAccount account;
+	PasswordForm setupPassword = new();
+	/// <summary>What the authenticator app needs while PrivaPub waits for its first code (an hour); null otherwise.</summary>
+	ViewTotpSetup setup;
+	TotpCodeForm enable = new();
+	TotpDisableForm disable = new();
+	/// <summary>The recovery codes PrivaPub made as two-factor sign-in was turned on, shown this once; empty otherwise.</summary>
+	List<string> recoveryCodes = [];
+	bool isAskingPassword;
+	bool isDisabling;
+	/// <summary>Turned off with a recovery code (two groups of five letters and digits), not the app's six digits.</summary>
+	bool disableWithRecoveryCode;
+	bool isSaving;
+
+	protected override async Task OnInitializedAsync()
+	{
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+		IsLoading = false;
+	}
+
+	async Task LoadData() => account = await AuthService.Account();
+
+	void OpenSetup()
+	{
+		setupPassword = new();
+		isAskingPassword = true;
+	}
+
+	void OpenDisable()
+	{
+		disable = new();
+		disableWithRecoveryCode = false;
+		isDisabling = true;
+	}
+
+	/// <summary>Back to the block's state; a setup PrivaPub keeps expires by itself after an hour.</summary>
+	void CloseForms()
+	{
+		isAskingPassword = false;
+		isDisabling = false;
+		setup = default;
+		setupPassword = new();
+		enable = new();
+		disable = new();
+	}
+
+	void ToggleDisableRecoveryCode()
+	{
+		disableWithRecoveryCode = !disableWithRecoveryCode;
+		disable.Code = default;
+	}
+
+	async Task Setup()
+	{
+		isSaving = true;
+		var result = await AuthService.TotpSetup(setupPassword.Password);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			// a 409: two-factor sign-in was turned on meanwhile, from another device
+			if (result.StatusCode is (int)System.Net.HttpStatusCode.Conflict)
+			{
+				CloseForms();
+				account = await AuthService.Account() ?? account;
+			}
+			return;
+		}
+
+		setup = result.Data as ViewTotpSetup;
+		setupPassword = new();
+		enable = new();
+		isAskingPassword = false;
+	}
+
+	async Task Enable()
+	{
+		isSaving = true;
+		// every other session ends here, and this device goes on with a new JWT and a new token for the persona
+		var result = await AuthService.TotpEnable(enable.Code.Trim());
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			enable = new();
+			// a 409: the setup expired (an hour), so it begins again with the password
+			if (result.StatusCode is (int)System.Net.HttpStatusCode.Conflict)
+			{
+				CloseForms();
+				account = await AuthService.Account() ?? account;
+				isAskingPassword = account is { TwoFactorEnabled: false };
+			}
+			return;
+		}
+
+		recoveryCodes = result.Data as List<string> ?? [];
+		setup = default;
+		enable = new();
+		account.TwoFactorEnabled = true;
+		account.RecoveryCodesLeft = recoveryCodes.Count;
+	}
+
+	async Task CopyCodes()
+	{
+		// a refusal is reported by main.js; the codes can still be selected and copied by hand
+		if (!await CascadingState.Status.CopyText(string.Join('\n', recoveryCodes)))
+			return;
+
+		Toast.AddResponseSuccess(Localizer["Recovery codes copied."]);
+	}
+
+	void CodesSaved() => recoveryCodes = [];
+
+	async Task Disable()
+	{
+		if (!await Confirm.Ask(Localizer["Turn off two-factor sign-in?"],
+				Localizer["Signing in takes only the password again, and the recovery codes stop working."], Localizer["Turn off"], true))
+			return;
+
+		isSaving = true;
+		var result = await AuthService.TotpDisable(disable.Password, disable.Code.Trim());
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			disable.Code = default;
+			return;
+		}
+
+		account = result.Data as ViewAccount ?? await AuthService.Account();
+		CloseForms();
+		Toast.AddResponseSuccess(Localizer["Two-factor sign-in is off."]);
+	}
+}

Components/ToastHost.razor

@@ -3,7 +3,8 @@
 @* Shows ToastService's messages at the bottom end of the screen. Placed once, in MainLayout. *@
 @if (Toast.Messages.Count > 0)
 {
-	<DToast class="z-[1000]">
+	@* (on a phone above the round New post button) *@
+	<DToast class="z-[1000] max-md:bottom-20">
 		@foreach (var message in Toast.Messages)
 		{
 			<DAlert @key="message.Id" Color="ColorOf(message.Severity)" class="max-w-sm">

Docs/Insomnia_APIs.json

@@ -1,704 +0,0 @@
-{
-	"_type": "export",
-	"__export_format": 4,
-	"__export_date": "2022-02-14T20:02:43.810Z",
-	"__export_source": "insomnia.desktop.app:v2021.7.2",
-	"resources": [
-		{
-			"_id": "req_db7df93225be442e89a167ae594c5551",
-			"parentId": "fld_2fca219979e448c997a6788d2b539ee7",
-			"modified": 1644868863001,
-			"created": 1643816994345,
-			"url": "https://localhost:5000/api/v1/message/add",
-			"name": "Add message",
-			"description": "rootMessageId => un susseguirsi di risposte ad un messaggio si portera' dietro sempre l'id del messaggio di partenza\n\ntitle => titolo opzionale\n\ncontent => testo del messaggio, con supporto di markdown\n\nResponse JSON:\n\n>\t\t{\n>\t\t\t\"user\": {\n\t\t\t\t\"userId\": \"guid/uuid/whatever\",\n\t\t\t\t\"userName\": \"@loosy@letsrulethe.world\",\n\t\t\t\t\"displayName\": \"loosy\",\n\t\t\t\t\"pictureUrl\": \"https://...\",\n\t\t\t\t\"backgroundUrl\": \"https://...\",\n\t\t\t\t\"profileUrl\": \"https://...\"\n\t\t\t},\n\t\t\t\"messageType\": \"1||2||3||4\",//Direct,FollowersOnly,Unlisted,Public\n\t\t\t\"rootMessageId\": null,\n\t\t\t\"messageId\": \"guid/uuid/whatever\",\n\t\t\t\"title\": \"...\",\n\t\t\t\"content\": \"...\",\n\t\t\t\"isFavourite\": false,\n\t\t\t\"isBoosted\": false,\n\t\t\t\"media\": [{\n\t\t\t\t\t\"fileName\": \"ciao.png\",\n\t\t\t\t\t\"altText\": \"descrizione immagine\",\n\t\t\t\t\t\"contentType\": \"image/png\",\n\t\t\t\t\t\"url\": \"https://bbs.keinpfusch.net/files/webpublic-ee9faea1-6786-4bf4-9a42-7a1f07de2dc5\"\n\t\t\t}],\n\t\t\t\"createdAt\": \"UTC or ticks\"\n>\t\t}\n",
-			"method": "POST",
-			"body": {
-				"mimeType": "application/json",
-				"text": " {\n\t\"contentType\": \"1||2||3\",//PlainText,HTML,Markdown\n\t\"messageType\": \"1||2||3||4\",//Direct,FollowersOnly,Unlisted,Public,\n\t\"mediaType\": \"1||2||3||4\",//Images,Video,Audio,Documents\n\t\"rootMessageId\": null,\n\t\"title\": \"...\",\n\t\"content\": \"...\",\n\t\"media\": [{\n\t\t\"fileName\": \"ciao.png\",\n    \"altText\": \"descrizione opzionale immagine\",\n\t\t\"contentType\": \"image/png\",//mime\n\t\t\"blob\": [23,33,11,...]//byteArray || base64?\n\t}],\n\t\"createdAt\": \"UTC or ticks\"\n}\n\n"
-			},
-			"parameters": [],
-			"headers": [
-				{
-					"name": "Content-Type",
-					"value": "application/json",
-					"id": "pair_b95faf0515f9453595110e7895330c5f"
-				}
-			],
-			"authentication": {},
-			"metaSortKey": -1643816957190,
-			"isPrivate": false,
-			"settingStoreCookies": true,
-			"settingSendCookies": true,
-			"settingDisableRenderRequestBody": false,
-			"settingEncodeUrl": true,
-			"settingRebuildPath": true,
-			"settingFollowRedirects": "global",
-			"_type": "request"
-		},
-		{
-			"_id": "fld_2fca219979e448c997a6788d2b539ee7",
-			"parentId": "wrk_da47ff9b3d7f40f3bef9e90b46d6610b",
-			"modified": 1643829443147,
-			"created": 1643816769446,
-			"name": "APIs",
-			"description": "",
-			"environment": {},
-			"environmentPropertyOrder": {},
-			"metaSortKey": -1643816769446,
-			"_type": "request_group"
-		},
-		{
-			"_id": "wrk_da47ff9b3d7f40f3bef9e90b46d6610b",
-			"parentId": null,
-			"modified": 1608987862911,
-			"created": 1608987862911,
-			"name": "Insomnia",
-			"description": "",
-			"scope": "collection",
-			"_type": "workspace"
-		},
-		{
-			"_id": "req_b33056a8e8a64c838662a60a4909537c",
-			"parentId": "fld_2fca219979e448c997a6788d2b539ee7",
-			"modified": 1643829255295,
-			"created": 1643817054991,
-			"url": "https://localhost:5000/api/v1/message/messageId/delete",
-			"name": "Remove message",
-			"description": "[queryParam] messageId => id del messaggio da eliminare\n\nResponse 200\n",
-			"method": "DELETE",
-			"body": {},
-			"parameters": [],
-			"headers": [],
-			"authentication": {
-				"type": "oauth2",
-				"grantType": "authorization_code"
-			},
-			"metaSortKey": -1643816957177.5,
-			"isPrivate": false,
-			"settingStoreCookies": true,
-			"settingSendCookies": true,
-			"settingDisableRenderRequestBody": false,
-			"settingEncodeUrl": true,
-			"settingRebuildPath": true,
-			"settingFollowRedirects": "global",
-			"_type": "request"
-		},
-		{
-			"_id": "req_95c442071ee247f1a97d823c6e503db2",
-			"parentId": "fld_2fca219979e448c997a6788d2b539ee7",
-			"modified": 1644868763642,
-			"created": 1643816956965,
-			"url": "https://localhost:5000/api/v1/messages",
-			"name": "Get messages list",
-			"description": "Response JSON:\n>\t\t[\n>\t\t\t{\n>\t\t\t\t\"user\": {\n>\t\t\t\t\t\"userId\": \"guid/uuid/whatever\",\n>\t\t\t\t\t\"userName\": \"@loosy@letsrulethe.world\",\n>\t\t\t\t\t\"displayName\": \"loosy\",\n>\t\t\t\t\t\"pictureUrl\": \"https://...\",\n>\t\t\t\t\t\"backgroundUrl\": \"https://...\",\n>\t\t\t\t\t\"profileUrl\": \"https://...\"\n>\t\t\t\t},\n>\t\t\t\t\"messageType\": \"1||2||3||4\",//Direct,FollowersOnly,Unlisted,Public\n>\t\t\t\t\"rootMessageId\": null,\n>\t\t\t\t\"messageId\": \"guid/uuid/whatever\",\n>\t\t\t\t\"title\": \"...\",\n>\t\t\t\t\"content\": \"...\",\n>\t\t\t\t\"isFavourite\": false,\n>\t\t\t\t\"isBoosted\": false,\n>\t\t\t\t\"media\": [{\n>\t\t\t\t\t\"fileName\": \"ciao.png\",\n>\t\t\t\t\t\"altText\": \"descrizione immagine\",\n>\t\t\t\t\t\"contentType\": \"image/png\",\n>\t\t\t\t\t\"url\": \"https://bbs.keinpfusch.net/files/webpublic-ee9faea1-6786-4bf4-9a42-7a1f07de2dc5\"\n>\t\t\t\t}],\n>\t\t\t\t\"createdAt\": \"UTC or ticks\"\n>\t\t\t}, {...}\n>\t\t]",
-			"method": "GET",
-			"body": {},
-			"parameters": [
-				{
-					"id": "pair_6e5222c6a78341bbb24f9b18d236df6c",
-					"name": "since",
-					"value": "UTC/ticks/messageId?",
-					"description": ""
-				}
-			],
-			"headers": [],
-			"authentication": {},
-			"metaSortKey": -1643816956965,
-			"isPrivate": false,
-			"settingStoreCookies": true,
-			"settingSendCookies": true,
-			"settingDisableRenderRequestBody": false,
-			"settingEncodeUrl": true,
-			"settingRebuildPath": true,
-			"settingFollowRedirects": "global",
-			"_type": "request"
-		},
-		{
-			"_id": "env_b33db616c4a51618900a0a3da66d2d7b6ebaec2b",
-			"parentId": "wrk_da47ff9b3d7f40f3bef9e90b46d6610b",
-			"modified": 1642377560788,
-			"created": 1608987862952,
-			"name": "Base Environment",
-			"data": {},
-			"dataPropertyOrder": {},
-			"color": null,
-			"isPrivate": false,
-			"metaSortKey": 1608987862952,
-			"_type": "environment"
-		},
-		{
-			"_id": "jar_b33db616c4a51618900a0a3da66d2d7b6ebaec2b",
-			"parentId": "wrk_da47ff9b3d7f40f3bef9e90b46d6610b",
-			"modified": 1642378408249,
-			"created": 1608987862953,
-			"name": "Default Jar",
-			"cookies": [
-				{
-					"key": "oc_sessionPassphrase",
-					"value": "nMmK2Vb0FhKNaSQiPteel3EhA5swjs9%2FYJwU79BzPrq1cgNmCdL2w88ktlfpy8BXU1Yuj7MKSmCLNYMB0NIDFZ%2B7AnbhqpW0am5cFolB4eRzT2uSUSg16nKnAPVXAkGa",
-					"domain": "nuvola.xyz",
-					"path": "/",
-					"secure": true,
-					"httpOnly": true,
-					"extensions": [ "SameSite=Lax" ],
-					"hostOnly": true,
-					"creation": "2021-05-04T10:48:03.279Z",
-					"lastAccessed": "2021-05-04T10:48:03.279Z",
-					"id": "06476282363234076"
-				},
-				{
-					"key": "occ7de4yt74j",
-					"value": "dsleqfmojuisnmgcq63p0nrk77",
-					"domain": "nuvola.xyz",
-					"path": "/",
-					"secure": true,
-					"httpOnly": true,
-					"extensions": [ "SameSite=Lax" ],
-					"hostOnly": true,
-					"creation": "2021-05-04T10:48:03.279Z",
-					"lastAccessed": "2021-05-04T11:01:42.224Z",
-					"id": "9557040429295196"
-				},
-				{
-					"key": "__Host-nc_sameSiteCookielax",
-					"value": "true",
-					"expires": "2100-12-31T23:59:59.000Z",
-					"domain": "nuvola.xyz",
-					"path": "/",
-					"secure": true,
-					"httpOnly": true,
-					"extensions": [ "SameSite=lax" ],
-					"hostOnly": true,
-					"creation": "2021-05-04T10:48:03.280Z",
-					"lastAccessed": "2021-05-04T10:48:03.280Z",
-					"id": "4410522677170672"
-				},
-				{
-					"key": "__Host-nc_sameSiteCookiestrict",
-					"value": "true",
-					"expires": "2100-12-31T23:59:59.000Z",
-					"domain": "nuvola.xyz",
-					"path": "/",
-					"secure": true,
-					"httpOnly": true,
-					"extensions": [ "SameSite=strict" ],
-					"hostOnly": true,
-					"creation": "2021-05-04T10:48:03.280Z",
-					"lastAccessed": "2021-05-04T10:48:03.280Z",
-					"id": "7173600438498109"
-				},
-				{
-					"key": "cookie_test",
-					"value": "test",
-					"expires": "2021-05-04T11:49:33.000Z",
-					"maxAge": 3600,
-					"domain": "nuvola.xyz",
-					"path": "/apps/dashboard",
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2021-05-04T10:49:20.818Z",
-					"lastAccessed": "2021-05-04T10:49:33.582Z",
-					"id": "3533626334860853"
-				},
-				{
-					"key": "nc_username",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "nuvola.xyz",
-					"path": "/apps/dashboard",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2021-05-04T10:49:20.818Z",
-					"lastAccessed": "2021-05-04T10:49:33.582Z",
-					"id": "06043516223469947"
-				},
-				{
-					"key": "nc_token",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "nuvola.xyz",
-					"path": "/apps/dashboard",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2021-05-04T10:49:20.819Z",
-					"lastAccessed": "2021-05-04T10:49:33.582Z",
-					"id": "1905708786875855"
-				},
-				{
-					"key": "nc_session_id",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "nuvola.xyz",
-					"path": "/apps/dashboard",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2021-05-04T10:49:20.819Z",
-					"lastAccessed": "2021-05-04T10:49:33.582Z",
-					"id": "4672408440036"
-				},
-				{
-					"key": "nc_username",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "nuvola.xyz",
-					"path": "/",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"creation": "2021-05-04T10:49:20.819Z",
-					"lastAccessed": "2021-05-04T11:01:42.224Z",
-					"id": "7693972008479257"
-				},
-				{
-					"key": "nc_token",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "nuvola.xyz",
-					"path": "/",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"creation": "2021-05-04T10:49:20.819Z",
-					"lastAccessed": "2021-05-04T11:01:42.224Z",
-					"id": "9731704342625882"
-				},
-				{
-					"key": "nc_session_id",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "nuvola.xyz",
-					"path": "/",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"creation": "2021-05-04T10:49:20.819Z",
-					"lastAccessed": "2021-05-04T11:01:42.224Z",
-					"id": "3557084085645068"
-				},
-				{
-					"key": "cookie_test",
-					"value": "test",
-					"expires": "2021-05-04T11:51:28.000Z",
-					"maxAge": 3600,
-					"domain": "nuvola.xyz",
-					"path": "/remote.php/dav/files",
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2021-05-04T10:51:28.651Z",
-					"lastAccessed": "2021-05-04T10:51:28.651Z",
-					"id": "8645799753636227"
-				},
-				{
-					"key": "nc_username",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "nuvola.xyz",
-					"path": "/remote.php/dav/files",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2021-05-04T10:51:44.619Z",
-					"lastAccessed": "2021-05-04T10:51:44.619Z",
-					"id": "9029869294914612"
-				},
-				{
-					"key": "nc_token",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "nuvola.xyz",
-					"path": "/remote.php/dav/files",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2021-05-04T10:51:44.619Z",
-					"lastAccessed": "2021-05-04T10:51:44.619Z",
-					"id": "6422488233461934"
-				},
-				{
-					"key": "nc_session_id",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "nuvola.xyz",
-					"path": "/remote.php/dav/files",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2021-05-04T10:51:44.619Z",
-					"lastAccessed": "2021-05-04T10:51:44.619Z",
-					"id": "7557066093242031"
-				},
-				{
-					"key": "cookie_test",
-					"value": "test",
-					"expires": "2021-05-04T12:01:26.000Z",
-					"maxAge": 3600,
-					"domain": "nuvola.xyz",
-					"path": "/index.php/login",
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2021-05-04T11:01:26.192Z",
-					"lastAccessed": "2021-05-04T11:01:26.192Z",
-					"id": "7093910949861533"
-				},
-				{
-					"key": "nc_username",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "nuvola.xyz",
-					"path": "/index.php/login",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2021-05-04T11:01:42.223Z",
-					"lastAccessed": "2021-05-04T11:01:42.223Z",
-					"id": "677709203943275"
-				},
-				{
-					"key": "nc_token",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "nuvola.xyz",
-					"path": "/index.php/login",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2021-05-04T11:01:42.224Z",
-					"lastAccessed": "2021-05-04T11:01:42.224Z",
-					"id": "9477816718956802"
-				},
-				{
-					"key": "nc_session_id",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "nuvola.xyz",
-					"path": "/index.php/login",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2021-05-04T11:01:42.224Z",
-					"lastAccessed": "2021-05-04T11:01:42.224Z",
-					"id": "41804757195232756"
-				},
-				{
-					"key": "oc_sessionPassphrase",
-					"value": "pUIH26mXSdmGTfubB4dUzw8F8MQsUHdwnHCeo7ElPWIGDxXte2XC1M0EMyN5eriarJcMmkfh4kSGFI9%2BRcs%2BHt2gdDygddkz5I7Tl8KtjkwC%2BawIYuL8z3lobWTL%2BCy%2B",
-					"domain": "cloud.zigzag.academy",
-					"path": "/",
-					"secure": true,
-					"httpOnly": true,
-					"extensions": [ "SameSite=Lax" ],
-					"hostOnly": true,
-					"creation": "2022-01-17T00:03:10.727Z",
-					"lastAccessed": "2022-01-17T00:03:10.727Z",
-					"id": "06313521114695941"
-				},
-				{
-					"key": "__Host-nc_sameSiteCookielax",
-					"value": "true",
-					"expires": "2100-12-31T23:59:59.000Z",
-					"domain": "cloud.zigzag.academy",
-					"path": "/",
-					"secure": true,
-					"httpOnly": true,
-					"extensions": [ "SameSite=lax" ],
-					"hostOnly": true,
-					"creation": "2022-01-17T00:03:10.728Z",
-					"lastAccessed": "2022-01-17T00:03:10.728Z",
-					"id": "860532957782806"
-				},
-				{
-					"key": "__Host-nc_sameSiteCookiestrict",
-					"value": "true",
-					"expires": "2100-12-31T23:59:59.000Z",
-					"domain": "cloud.zigzag.academy",
-					"path": "/",
-					"secure": true,
-					"httpOnly": true,
-					"extensions": [ "SameSite=strict" ],
-					"hostOnly": true,
-					"creation": "2022-01-17T00:03:10.728Z",
-					"lastAccessed": "2022-01-17T00:03:10.728Z",
-					"id": "31117326197847706"
-				},
-				{
-					"key": "ocl7d3yrw74j",
-					"value": "uecghev7rleu4uptmruhptuvto",
-					"domain": "cloud.zigzag.academy",
-					"path": "/",
-					"secure": true,
-					"httpOnly": true,
-					"extensions": [ "SameSite=Lax" ],
-					"hostOnly": true,
-					"creation": "2022-01-17T00:03:10.728Z",
-					"lastAccessed": "2022-01-17T00:13:28.249Z",
-					"id": "5917940161261273"
-				},
-				{
-					"key": "cookie_test",
-					"value": "test",
-					"expires": "2022-01-17T01:03:09.000Z",
-					"maxAge": 3600,
-					"domain": "cloud.zigzag.academy",
-					"path": "/index.php/login",
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2022-01-17T00:03:10.728Z",
-					"lastAccessed": "2022-01-17T00:03:10.728Z",
-					"id": "009292942805962934"
-				},
-				{
-					"key": "nc_username",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "cloud.zigzag.academy",
-					"path": "/index.php/login/v2",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2022-01-17T00:04:18.252Z",
-					"lastAccessed": "2022-01-17T00:04:18.252Z",
-					"id": "5470762369580981"
-				},
-				{
-					"key": "nc_token",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "cloud.zigzag.academy",
-					"path": "/index.php/login/v2",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2022-01-17T00:04:18.252Z",
-					"lastAccessed": "2022-01-17T00:04:18.252Z",
-					"id": "4385020724400406"
-				},
-				{
-					"key": "nc_session_id",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "cloud.zigzag.academy",
-					"path": "/index.php/login/v2",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2022-01-17T00:04:18.253Z",
-					"lastAccessed": "2022-01-17T00:04:18.253Z",
-					"id": "05297254853120181"
-				},
-				{
-					"key": "nc_username",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "cloud.zigzag.academy",
-					"path": "/",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"creation": "2022-01-17T00:04:18.253Z",
-					"lastAccessed": "2022-01-17T00:12:52.404Z",
-					"id": "46009278671166176"
-				},
-				{
-					"key": "nc_token",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "cloud.zigzag.academy",
-					"path": "/",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"creation": "2022-01-17T00:04:18.253Z",
-					"lastAccessed": "2022-01-17T00:12:52.404Z",
-					"id": "05812364381235913"
-				},
-				{
-					"key": "nc_session_id",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "cloud.zigzag.academy",
-					"path": "/",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"creation": "2022-01-17T00:04:18.253Z",
-					"lastAccessed": "2022-01-17T00:12:52.404Z",
-					"id": "3772361407666647"
-				},
-				{
-					"key": "cookie_test",
-					"value": "test",
-					"expires": "2022-01-17T01:05:17.000Z",
-					"maxAge": 3600,
-					"domain": "cloud.zigzag.academy",
-					"path": "/apps/files",
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2022-01-17T00:05:18.388Z",
-					"lastAccessed": "2022-01-17T00:05:18.388Z",
-					"id": "08277815359810625"
-				},
-				{
-					"key": "nc_username",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "cloud.zigzag.academy",
-					"path": "/apps/files",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2022-01-17T00:05:18.388Z",
-					"lastAccessed": "2022-01-17T00:05:18.388Z",
-					"id": "7962572269421415"
-				},
-				{
-					"key": "nc_token",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "cloud.zigzag.academy",
-					"path": "/apps/files",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2022-01-17T00:05:18.388Z",
-					"lastAccessed": "2022-01-17T00:05:18.388Z",
-					"id": "8604909194077435"
-				},
-				{
-					"key": "nc_session_id",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "cloud.zigzag.academy",
-					"path": "/apps/files",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2022-01-17T00:05:18.388Z",
-					"lastAccessed": "2022-01-17T00:05:18.388Z",
-					"id": "6043027104701622"
-				},
-				{
-					"key": "cookie_test",
-					"value": "test",
-					"expires": "2022-01-17T01:11:28.000Z",
-					"maxAge": 3600,
-					"domain": "cloud.zigzag.academy",
-					"path": "/ocs/v1.php/cloud",
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2022-01-17T00:11:28.872Z",
-					"lastAccessed": "2022-01-17T00:11:28.872Z",
-					"id": "014769824799037545"
-				},
-				{
-					"key": "nc_username",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "cloud.zigzag.academy",
-					"path": "/ocs/v1.php/cloud",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2022-01-17T00:12:52.404Z",
-					"lastAccessed": "2022-01-17T00:12:52.404Z",
-					"id": "7141536696124962"
-				},
-				{
-					"key": "nc_token",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "cloud.zigzag.academy",
-					"path": "/ocs/v1.php/cloud",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2022-01-17T00:12:52.404Z",
-					"lastAccessed": "2022-01-17T00:12:52.404Z",
-					"id": "08455474112707173"
-				},
-				{
-					"key": "nc_session_id",
-					"value": "deleted",
-					"expires": "1970-01-01T00:00:01.000Z",
-					"maxAge": 0,
-					"domain": "cloud.zigzag.academy",
-					"path": "/ocs/v1.php/cloud",
-					"secure": true,
-					"httpOnly": true,
-					"hostOnly": true,
-					"pathIsDefault": true,
-					"creation": "2022-01-17T00:12:52.404Z",
-					"lastAccessed": "2022-01-17T00:12:52.404Z",
-					"id": "141765916939931"
-				}
-			],
-			"_type": "cookie_jar"
-		},
-		{
-			"_id": "spc_f832b28de5204b4a88374d08ba93a8e2",
-			"parentId": "wrk_da47ff9b3d7f40f3bef9e90b46d6610b",
-			"modified": 1608987862912,
-			"created": 1608987862912,
-			"fileName": "Insomnia",
-			"contents": "",
-			"contentType": "yaml",
-			"_type": "api_spec"
-		},
-		{
-			"_id": "env_77dfa781871a430f8e5014b07c9f9061",
-			"parentId": "env_b33db616c4a51618900a0a3da66d2d7b6ebaec2b",
-			"modified": 1642377578797,
-			"created": 1642377566379,
-			"name": "Nextcloud API",
-			"data": {},
-			"dataPropertyOrder": {},
-			"color": null,
-			"isPrivate": false,
-			"metaSortKey": 1642377566379,
-			"_type": "environment"
-		}
-	]
-}

Extensions/ExtensionMethods.cs

@@ -1,22 +1,15 @@
 using Blazored.LocalStorage;
 
-using collAnon.Client.Services;
-
 using decePubClient.Helpers;
 using decePubClient.Models;
 using decePubClient.Models.Mastodon;
 using decePubClient.Services;
 
-using Markdig;
-
 using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.WebAssembly.Hosting;
 
 using PrivaPub.ClientModels;
 
-using System.Collections.Specialized;
-using System.ComponentModel;
 using System.Globalization;
 using System.Net;
 using System.Net.Http.Json;
@@ -28,24 +21,6 @@ namespace decePubClient.Extensions
 {
 	public static partial class ExtensionMethods
 	{
-		#region Navigation Manager
-
-		public static NameValueCollection QueryString(this NavigationManager navigationManager) =>
-				HttpUtility.ParseQueryString(new Uri(navigationManager.Uri).Query);
-
-		public static string QueryString(this NavigationManager navigationManager, string key) =>
-				navigationManager.QueryString()[key];
-
-		public static T QueryString<T>(this NavigationManager navigationManager, string key)
-		{
-			var value = navigationManager.QueryString()[key];
-			if (!TypeDescriptor.GetConverter(typeof(T)).IsValid(value))
-				return default;
-			return (T)Convert.ChangeType(value, typeof(T));
-		}
-
-		#endregion Navigation Manager
-
 		#region Setups
 
 		/// <summary>The languages with resources (Resources/AllStrings.*.resx); any other browser language gets English.</summary>
@@ -82,30 +57,6 @@ namespace decePubClient.Extensions
 
 		#endregion Setups
 
-		public static string GetLogLevelClass(this string logType) => logType switch
-		{
-			"Debug" => "text-base-content/60",
-			"Information" => "text-info",
-			"Warning" => "text-warning",
-			"Error" => "text-error",
-			"Fatal" => "text-error font-bold",
-			_ => string.Empty
-		};
-
-
-		#region Formats
-
-		public static MarkdownPipeline Pipeline =>
-				 new MarkdownPipelineBuilder().UseGenericAttributes().Build();
-
-		public static string ToJson(this object value) =>
-				 JsonSerializer.Serialize(value);
-
-		public static string ToBase64PngImage(this string base64Image) =>
-				$"data:image/png;base64,{base64Image}";
-
-		#endregion Formats
-
 		#region Models
 
 		public static string ToString(this WebResult webResult, CoalescingStringLocalizer localizer) =>
@@ -240,25 +191,6 @@ namespace decePubClient.Extensions
 			}
 		}
 
-		public static string Timeframe(this DateTime creationDate, CoalescingStringLocalizer localizer)
-		{
-			var timeframe = DateTime.Now - creationDate.ToLocalTime();
-			switch ((int)timeframe.TotalHours)
-			{
-				case >= 24:
-					return localizer["{0} day/s", (int)timeframe.TotalDays];
-
-				case >= 1 and < 24:
-					return localizer["{0} hour/s", (int)timeframe.TotalHours];
-
-				case 0:
-					return localizer["{0} minute/s", (int)timeframe.TotalMinutes];
-
-				default:
-					return string.Empty;
-			}
-		}
-
 		public static AuthorizationPolicy IsAdminPolicy() =>
 				new AuthorizationPolicyBuilder().RequireAuthenticatedUser()
 						.RequireClaim(Policies.IsAdmin, "true")

Extensions/GenericExtensions.cs

@@ -1,5 +1,4 @@
-using collAnon.Client.Services;
-using System.Collections.Specialized;
+using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Globalization;
 using System.Reflection;
@@ -12,12 +11,6 @@ using decePubClient.Models.Types;
 using decePubClient.Resources;
 using decePubClient.Services;
 
-using DnetIndexedDb;
-using DnetIndexedDb.Fluent;
-using DnetIndexedDb.Models;
-
-using Markdig;
-
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.WebAssembly.Hosting;
 using Microsoft.Extensions.Localization;
@@ -26,26 +19,6 @@ namespace decePubClient.Extensions;
 
 public static class GenericExtensions
 {
-	public static IServiceCollection AddIndexedDb(this IServiceCollection services)
-	{
-		return services.AddIndexedDbDatabase<IndexedDb>(options =>
-		{
-			var model = new IndexedDbDatabaseModel()
-				.WithName("data")
-				.WithVersion(3)
-				.WithModelId(1);
-
-			// IStorage.AddLog numbers entries itself (max key + 1), so the key is Id rather than generated. Version 2
-			// added this store; version 3 left the mock feed's Message store out of the model.
-			model.AddStore(nameof(ClientLogs))
-				.WithKey(nameof(ClientLogs.Id))
-				.AddUniqueIndex(nameof(ClientLogs.Id))
-				.AddIndex(nameof(ClientLogs.TimeStamp));
-
-			options.UseDatabase(model);
-		});
-	}
-
 	public static string GetPassedTime(this DateTime dateTime, CoalescingStringLocalizer localizer)
 	{
 		var timeframe = DateTime.Now - dateTime.ToLocalTime();
@@ -57,23 +30,32 @@ public static class GenericExtensions
 		};
 	}
 
+	// a count as a phone's narrow action buttons show it: 999, 1.2k, 12k, 1.2M
+	public static string Compact(this int count) => count switch
+	{
+		< 1000 => count.ToString(CultureInfo.CurrentCulture),
+		< 10_000 => (count / 1000d).ToString("0.#", CultureInfo.CurrentCulture) + "k",
+		< 1_000_000 => (count / 1000).ToString(CultureInfo.CurrentCulture) + "k",
+		_ => (count / 1_000_000d).ToString("0.#", CultureInfo.CurrentCulture) + "M"
+	};
+
 	public static string GetFileSize(this long size, CoalescingStringLocalizer localizer) => size switch
 	{
 		>= 1_048_576 => localizer["{0}MB", size / 1_048_576],
 		_ => localizer["{0}KB", size / 1_024]
 	};
 
-	public static string GetMessageTypeIcon(this MessageType messageType)
+	public static string GetVisibilityIcon(this Visibility visibility)
 	{
-		switch (messageType)
+		switch (visibility)
 		{
-			case MessageType.Public:
+			case Visibility.Public:
 				return "ion-md-globe";
-			case MessageType.Unlisted:
+			case Visibility.Unlisted:
 				return "ion-md-unlock";
-			case MessageType.FollowersOnly:
+			case Visibility.FollowersOnly:
 				return "ion-md-lock";
-			case MessageType.Direct:
+			case Visibility.Direct:
 				return "ion-md-paper-plane";
 			default:
 				return default;
@@ -92,6 +74,7 @@ public static class GenericExtensions
 		TimelineType.Favourites => "ion-md-heart",
 		TimelineType.Bookmarks => "ion-md-bookmark",
 		TimelineType.Tag => "ion-md-pricetag",
+		TimelineType.Lists => "ion-md-list",
 		_ => default
 	};
 

Helpers/CustomEmojis.cs

@@ -0,0 +1,47 @@
+using System.Net;
+using System.Text.RegularExpressions;
+
+using decePubClient.Models.Mastodon;
+
+using Microsoft.AspNetCore.Components;
+
+namespace decePubClient.Helpers
+{
+	/// <summary>
+	/// A post's or an account's custom emoji (`:shortcode:` among its <c>emojis</c>) shown as their pictures. The shortcode
+	/// stays as the picture's alt text, so it is what a screen reader reads and what is copied. Only shortcodes the
+	/// server listed for that post or account are replaced, and only with an http(s) picture.
+	/// </summary>
+	public static partial class CustomEmojis
+	{
+		[GeneratedRegex(@":([A-Za-z0-9_+-]{1,64}):")]
+		private static partial Regex Shortcode();
+
+		[GeneratedRegex(@"(<[^>]*>)")]
+		private static partial Regex Tag();
+
+		/// <summary>Plain text (a name, a content warning): escaped, then its shortcodes as pictures.</summary>
+		public static MarkupString Text(string text, IReadOnlyCollection<CustomEmoji> emojis) =>
+			new(Replace(WebUtility.HtmlEncode(text ?? string.Empty), emojis));
+
+		/// <summary>HTML the server sanitized: the shortcodes in its text, never inside a tag.</summary>
+		public static string Html(string html, IReadOnlyCollection<CustomEmoji> emojis) =>
+			emojis.Count == 0 || string.IsNullOrEmpty(html)
+				? html
+				: string.Concat(Tag().Split(html).Select(part => part.StartsWith('<') ? part : Replace(part, emojis)));
+
+		static string Replace(string text, IReadOnlyCollection<CustomEmoji> emojis)
+		{
+			if (emojis.Count == 0 || !text.Contains(':'))
+				return text;
+			var known = new Dictionary<string, string>(StringComparer.Ordinal);
+			foreach (var emoji in emojis)
+				if (!string.IsNullOrEmpty(emoji.Shortcode) && Uri.TryCreate(emoji.Url, UriKind.Absolute, out var url)
+					&& url.Scheme is "https" or "http")
+					known.TryAdd(emoji.Shortcode, url.AbsoluteUri);
+			return Shortcode().Replace(text, match => known.TryGetValue(match.Groups[1].Value, out var url)
+				? $"<img class=\"custom-emoji\" src=\"{WebUtility.HtmlEncode(url)}\" alt=\"{match.Value}\" title=\"{match.Value}\" draggable=\"false\" />"
+				: match.Value);
+		}
+	}
+}

Helpers/Languages.cs

@@ -0,0 +1,18 @@
+namespace decePubClient.Helpers
+{
+	/// <summary>The languages a post can be marked as written in: ISO 639-1 codes and each language's own name.</summary>
+	public static class Languages
+	{
+		public static readonly IReadOnlyList<(string Code, string Name)> All =
+		[
+			("ar", "العربية"), ("bg", "Български"), ("ca", "Català"), ("cs", "Čeština"), ("cy", "Cymraeg"), ("da", "Dansk"),
+			("de", "Deutsch"), ("el", "Ελληνικά"), ("en", "English"), ("eo", "Esperanto"), ("es", "Español"), ("et", "Eesti"),
+			("eu", "Euskara"), ("fa", "فارسی"), ("fi", "Suomi"), ("fr", "Français"), ("ga", "Gaeilge"), ("gl", "Galego"),
+			("he", "עברית"), ("hi", "हिन्दी"), ("hr", "Hrvatski"), ("hu", "Magyar"), ("id", "Bahasa Indonesia"), ("is", "Íslenska"),
+			("it", "Italiano"), ("ja", "日本語"), ("ko", "한국어"), ("lt", "Lietuvių"), ("lv", "Latviešu"), ("nl", "Nederlands"),
+			("no", "Norsk"), ("pl", "Polski"), ("pt", "Português"), ("ro", "Română"), ("ru", "Русский"), ("sk", "Slovenčina"),
+			("sl", "Slovenščina"), ("sr", "Српски"), ("sv", "Svenska"), ("th", "ไทย"), ("tr", "Türkçe"), ("uk", "Українська"),
+			("vi", "Tiếng Việt"), ("zh", "中文")
+		];
+	}
+}

Helpers/SUtility.cs

@@ -1,6 +1,5 @@
 using System.Net;
 using System.Net.Http.Json;
-using System.Net.Mail;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using System.Text.Json.Serialization.Metadata;
@@ -108,58 +107,5 @@ namespace decePubClient.Helpers
 
 		public static T IfTrueThen<T>(bool conditionIsTrue, T ifTrue, T ifFalse = default) =>
 			conditionIsTrue ? ifTrue : ifFalse;
-
-		public static bool TimeBetween(this DateTime datetime, TimeSpan start, TimeSpan end)
-		{
-			// convert datetime to a TimeSpan
-			var now = datetime.TimeOfDay;
-			// see if start comes before end
-			if (start < end)
-				return start <= now && now <= end;
-			// start is after end, so do the inverse comparison
-			return !(end < now && now < start);
-		}
-
-		public static string GetFileIcon(string fileName)
-		{
-			switch (Path.GetExtension(fileName))
-			{
-				case ".odp":
-				case ".pptx":
-					return "file-powerpoint";
-
-				case ".ods":
-				case ".xlsx":
-					return "file-excel";
-
-				case ".odt":
-				case ".docx":
-					return "file-word";
-
-				case ".pdf":
-					return "file-pdf";
-
-				case ".jpg":
-				case ".jpeg":
-				case ".png":
-					return "file-image";
-
-				default:
-					return "file";
-			}
-		}
-
-		public static bool IsValidEmail(string email)
-		{
-			try
-			{
-				var addr = new MailAddress(email);
-				return addr.Address == email;
-			}
-			catch
-			{
-				return false;
-			}
-		}
 	}
 }

LayerComponents/CascadingState.razor

@@ -3,7 +3,8 @@
 @* The app-wide state, cascaded to every page and component (LocalizableComponentBase.CascadingState): the saved
    PublicCacheData with its theme settings, the session (the root's personas and the Mastodon account of the one the
    client acts as), and whether the app is online, polled every 10 seconds. A change re-renders every subscriber; pages
-   compare PersonaId to reload what belongs to the persona. *@
+   compare PersonaId to reload what belongs to the persona. With PageSettings.SyncWithLogin the theme is the login's:
+   taken at sign-in and at start-up, saved there a moment after it changes here. *@
 <CascadingValue IsFixed=false Value=this>
 	@ChildContent
 </CascadingValue>
@@ -11,6 +12,8 @@
 @code {
 	/// <summary>How often the JWT's expiry is checked; AuthService renews it two days before.</summary>
 	static readonly TimeSpan RefreshInterval = TimeSpan.FromHours(1);
+	/// <summary>How long a change of the page settings waits before it is saved as the login's: a slider sends many.</summary>
+	static readonly TimeSpan SettingsSaveDelay = TimeSpan.FromMilliseconds(1500);
 
 	[Parameter] public RenderFragment ChildContent { get; set; }
 	[Inject] ILocalStorageService Storage { get; set; }
@@ -27,6 +30,8 @@
 	public PublicCacheData PublicCacheData { get; private set; } = new();
 	/// <summary>Whether a root is signed in (its JWT is still valid).</summary>
 	public bool IsSignedIn { get; private set; }
+	/// <summary>The session has been read once: from then on a null PersonaId means the login has no persona, not "not yet".</summary>
+	public bool IsSessionLoaded { get; private set; }
 	/// <summary>The root's login name, shown to its owner only.</summary>
 	public string RootUserName { get; private set; }
 	/// <summary>The root's personas.</summary>
@@ -40,6 +45,11 @@
 	PeriodicTimer onlineTimer;
 	PeriodicTimer refreshTimer;
 	readonly CancellationTokenSource disposeCancellation = new();
+	/// <summary>What the login is known to keep, as LoginFingerprint reads it (null when unknown), so settings that already
+	/// match it, the login's own just taken among them, aren't saved again.</summary>
+	(string, short, short, bool, bool, bool, bool)? loginSettings;
+	/// <summary>The one save of the page settings waiting for SettingsSaveDelay to pass.</summary>
+	CancellationTokenSource pendingSettingsSave;
 
 	protected override async Task OnInitializedAsync()
 	{
@@ -57,6 +67,8 @@
 			_ = PollOnline(cancellationToken);
 
 			await LoadSession(cancellationToken);
+			if (IsSignedIn && IsOnline && PublicCacheData.PageSettings.SyncWithLogin)
+				await KeepThemeWithLogin(await AuthService.Settings(cancellationToken), cancellationToken);
 			refreshTimer = new(RefreshInterval);
 			_ = KeepSessionFresh(cancellationToken);
 		}
@@ -75,13 +87,98 @@
 		StateHasChanged();
 	}
 
-	/// <summary>Changes the page settings, then saves and applies them like UpdatePublicCache.</summary>
+	/// <summary>Changes the page settings, then saves and applies them like UpdatePublicCache, and saves them as the
+	/// login's a moment later (SaveSettingsSoon).</summary>
 	public ValueTask UpdatePageSettings(Action<PageSettings> change, CancellationToken cancellationToken = default)
 	{
 		change(PublicCacheData.PageSettings);
+		SaveSettingsSoon();
 		return UpdatePublicCache(PublicCacheData, cancellationToken);
 	}
 
+	/// <summary>
+	/// Reads the session a login, a setup or an invitation has just started (AuthService keeps its JWT, which carries the
+	/// login's settings), then keeps the theme with the login's (KeepThemeWithLogin).
+	/// </summary>
+	public async Task SignedIn(JwtUser jwtUser, CancellationToken cancellationToken = default)
+	{
+		loginSettings = null;
+		await LoadSession(cancellationToken);
+		await KeepThemeWithLogin(jwtUser?.UserSettings, cancellationToken);
+	}
+
+	/// <summary>
+	/// When this device keeps its theme with the login: takes the login's theme (never its language, which would reload the
+	/// app) once a client saved one, or gives the login this device's while none did. Unknown settings change nothing.
+	/// </summary>
+	async Task KeepThemeWithLogin(ViewUserSettings settings, CancellationToken cancellationToken)
+	{
+		if (settings is null || !IsSignedIn || !PublicCacheData.PageSettings.SyncWithLogin)
+			return;
+
+		if (settings.SavedAt is null)
+		{
+			SaveSettingsSoon();
+			return;
+		}
+
+		PublicCacheData.PageSettings.TakeLoginTheme(settings);
+		// as the login keeps them now, so taking them isn't followed by saving them back
+		loginSettings = LoginFingerprint(PublicCacheData.PageSettings.ToLoginSettings());
+		await UpdatePublicCache(PublicCacheData, cancellationToken);
+	}
+
+	/// <summary>
+	/// Saves the page settings as the login's once SettingsSaveDelay passed without another change: signed in, with
+	/// SyncWithLogin, and only when they differ from what the login is known to keep. One save waits at a time; a failure
+	/// is logged (AuthService.SaveSettings), never shown.
+	/// </summary>
+	void SaveSettingsSoon()
+	{
+		CancelSettingsSave();
+		var settings = PublicCacheData.PageSettings;
+		if (!IsSignedIn || !settings.SyncWithLogin || LoginFingerprint(settings.ToLoginSettings()) == loginSettings)
+			return;
+
+		pendingSettingsSave = new();
+		_ = SaveSettingsLater(pendingSettingsSave.Token);
+	}
+
+	async Task SaveSettingsLater(CancellationToken cancellationToken)
+	{
+		try
+		{
+			await Task.Delay(SettingsSaveDelay, cancellationToken);
+		}
+		catch (OperationCanceledException)
+		{
+			return;
+		}
+
+		if (!IsSignedIn)
+			return;
+
+		var settings = PublicCacheData.PageSettings.ToLoginSettings();
+		var result = await AuthService.SaveSettings(settings, cancellationToken);
+		if (result.IsInvalid)
+			return;
+
+		loginSettings = LoginFingerprint(settings);
+	}
+
+	void CancelSettingsSave()
+	{
+		var pending = pendingSettingsSave;
+		pendingSettingsSave = null;
+		pending?.Cancel();
+		pending?.Dispose();
+	}
+
+	/// <summary>What of the login's settings this client reads and writes: not the icons' hue, nor when they were saved.</summary>
+	static (string, short, short, bool, bool, bool, bool) LoginFingerprint(ViewUserSettings settings) =>
+		(settings.LanguageCode, settings.LightThemeIndexColour, settings.DarkThemeIndexColour, settings.PreferSystemTheming,
+			settings.ThemeIsDarkMode, settings.ThemeIsLightGray, settings.ThemeIsDarkGray);
+
 	/// <summary>
 	/// Reads the session after start-up or a login: renews the JWT when it is about to expire, lists the personas and
 	/// acts as the last one used (the first one otherwise).
@@ -93,6 +190,7 @@
 		if (!IsSignedIn)
 		{
 			ClearSession();
+			IsSessionLoaded = true;
 			StateHasChanged();
 			return;
 		}
@@ -105,11 +203,16 @@
 		{
 			PersonaId = null;
 			Persona = null;
+			IsSessionLoaded = true;
 			StateHasChanged();
 			return;
 		}
 
+		// loaded once the persona is known (or couldn't be used): a page rendered while it is switched to would otherwise
+		// see a loaded session without one, and the feed would say it is empty
 		await SwitchPersona(personaId, cancellationToken);
+		IsSessionLoaded = true;
+		StateHasChanged();
 	}
 
 	/// <summary>Acts as another of the root's personas; every page showing persona data reloads.</summary>
@@ -127,9 +230,33 @@
 		return result;
 	}
 
+	/// <summary>Reads the root's personas again, after one was made.</summary>
+	public async Task ReloadPersonas(CancellationToken cancellationToken = default)
+	{
+		Personas = await AuthService.Personas(cancellationToken);
+		StateHasChanged();
+	}
+
+	/// <summary>The current persona's account as PrivaPub describes it after the persona edited its profile; the persona
+	/// chooser shows the new name and picture too.</summary>
+	public void PersonaChanged(Account account)
+	{
+		if (account is null || PersonaId is null)
+			return;
+
+		Persona = account;
+		if (Personas.FirstOrDefault(p => p.Id == PersonaId) is { } persona)
+		{
+			persona.Name = account.DisplayName;
+			persona.PictureURL = account.Avatar;
+		}
+		StateHasChanged();
+	}
+
 	/// <summary>Revokes the persona tokens, ends the session and forgets the local data.</summary>
 	public async Task SignOut(CancellationToken cancellationToken = default)
 	{
+		CancelSettingsSave();
 		await AuthService.Logout(cancellationToken);
 		ClearSession();
 		StateHasChanged();
@@ -137,6 +264,8 @@
 
 	void ClearSession()
 	{
+		CancelSettingsSave();
+		loginSettings = null;
 		IsSignedIn = false;
 		RootUserName = null;
 		Personas = [];
@@ -205,6 +334,7 @@
 	{
 		await disposeCancellation.CancelAsync();
 		disposeCancellation.Dispose();
+		CancelSettingsSave();
 		onlineTimer?.Dispose();
 		refreshTimer?.Dispose();
 		cascadingStateReference?.Dispose();

LayerComponents/LocalizableComponentBase.cs

@@ -1,5 +1,3 @@
-using collAnon.Client.Services;
-
 using decePubClient.Services;
 
 using Microsoft.AspNetCore.Components;

LayerComponents/PagesBase.cs

@@ -1,6 +0,0 @@
-namespace decePubClient.LayerComponents
-{
-	public class PagesBase : LocalizableComponentBase
-	{
-	}
-}

MastodonJsonContext.cs

@@ -17,7 +17,11 @@ namespace decePubClient;
 [JsonSerializable(typeof(Account))]
 [JsonSerializable(typeof(List<Account>))]
 [JsonSerializable(typeof(Relationship))]
+[JsonSerializable(typeof(List<Relationship>))]
+[JsonSerializable(typeof(List<string>))]
+[JsonSerializable(typeof(SearchResults))]
 [JsonSerializable(typeof(MediaAttachment))]
+[JsonSerializable(typeof(InstanceV2))]
 [JsonSerializable(typeof(Notification))]
 [JsonSerializable(typeof(List<Notification>))]
 [JsonSerializable(typeof(Conversation))]
@@ -31,6 +35,30 @@ namespace decePubClient;
 [JsonSerializable(typeof(TokenResponse))]
 [JsonSerializable(typeof(MastodonError))]
 [JsonSerializable(typeof(PostStatusForm))]
+[JsonSerializable(typeof(StatusEditForm))]
+[JsonSerializable(typeof(StatusSource))]
+[JsonSerializable(typeof(List<StatusEdit>))]
+[JsonSerializable(typeof(ReportRequest))]
+[JsonSerializable(typeof(NotificationPolicy))]
+[JsonSerializable(typeof(List<NotificationRequest>))]
+[JsonSerializable(typeof(Poll))]
+[JsonSerializable(typeof(PollVoteForm))]
+[JsonSerializable(typeof(MastodonList))]
+[JsonSerializable(typeof(List<MastodonList>))]
+[JsonSerializable(typeof(ListAccountsForm))]
+[JsonSerializable(typeof(Filter))]
+[JsonSerializable(typeof(List<Filter>))]
+[JsonSerializable(typeof(FilterForm))]
+[JsonSerializable(typeof(FilterStatus))]
+[JsonSerializable(typeof(ScheduledStatus))]
+[JsonSerializable(typeof(List<ScheduledStatus>))]
+[JsonSerializable(typeof(ScheduleForm))]
+[JsonSerializable(typeof(Tag))]
+[JsonSerializable(typeof(List<Tag>))]
+[JsonSerializable(typeof(List<TrendLink>))]
+[JsonSerializable(typeof(GroupedNotifications))]
+[JsonSerializable(typeof(MarkersForm))]
+[JsonSerializable(typeof(UnreadCount))]
 public partial class MastodonJsonContext : JsonSerializerContext
 {
 }

Models/APIs.cs

@@ -9,19 +9,70 @@ public static class APIs
 {
 	public const string ClientApiPrefix = "clientapi/";
 	public const string MastodonPrefix = "api/";
-	public const string OAuthPrefix = "oauth/";
 
 	public static class ClientApi
 	{
 		public const string POST_Login = "clientapi/user/login";
+		public const string GET_Setup = "clientapi/user/setup";
+		public const string POST_Setup = "clientapi/user/setup";
+		public const string POST_InvitationSignUp = "clientapi/user/invitation/signup";
 		public const string GET_Logout = "clientapi/user/logout";
 		public const string GET_SniffAgain = "clientapi/user/sniff/again";
-		public const string GET_CurrentVersion = "clientapi/data/current-version";
+		public const string POST_UpdatePassword = "clientapi/user/update/password";
+		public const string POST_LogoutEverywhere = "clientapi/user/logout/everywhere";
+		public const string POST_RecoverPassword = "clientapi/user/recover/password";
+		public const string POST_RecoverValid = "clientapi/user/recover/valid";
+		public const string POST_RecoverUpdatePassword = "clientapi/user/recover/update/password";
+		public const string GET_Account = "clientapi/user/account";
+		public const string POST_Email = "clientapi/user/email";
+		public const string POST_EmailVerify = "clientapi/user/email/verify";
+		public const string POST_EmailRemove = "clientapi/user/email/remove";
+		public const string POST_TotpSetup = "clientapi/user/totp/setup";
+		public const string POST_TotpEnable = "clientapi/user/totp/enable";
+		public const string POST_TotpDisable = "clientapi/user/totp/disable";
+		public const string GET_UserSettings = "clientapi/user/settings";
+		public const string POST_UpdateUserSettings = "clientapi/user/update/settings";
+		public const string POST_DeleteAccount = "clientapi/user/delete";
 		public const string GET_Personas = "clientapi/avatar/private/list";
+		public const string POST_InsertPersona = "clientapi/avatar/private/insert";
 		public const string GET_Groups = "clientapi/group/list";
+		public const string GET_GroupMembers = "clientapi/group/members";
+		public const string POST_InsertGroup = "clientapi/group/insert";
+		public const string POST_UpdateGroup = "clientapi/group/update";
+		public const string POST_JoinGroup = "clientapi/group/join";
+		public const string POST_LeaveGroup = "clientapi/group/leave";
+		public const string POST_ApproveGroupMember = "clientapi/group/approve";
+		public const string POST_RejectGroupMember = "clientapi/group/reject";
+		public const string POST_RemoveGroupMember = "clientapi/group/remove";
 		public const string GET_Posts = "clientapi/post/list";
 		public const string GET_Nearby = "clientapi/post/nearby";
 		public const string POST_InsertPost = "clientapi/post/insert";
+		public const string POST_DeletePost = "clientapi/post/delete";
+		public const string GET_ModeratorReports = "clientapi/moderator/reports";
+		public static string POST_M_ResolveReport(string reportId) => $"clientapi/moderator/reports/{Uri.EscapeDataString(reportId)}/resolve";
+		public const string GET_AdminDomainBlocks = "clientapi/admin/domainblocks/list";
+		public const string POST_AdminDomainBlock = "clientapi/admin/domainblocks/insert";
+		public static string POST_M_AdminDomainUnblock(string domain) => $"clientapi/admin/domainblocks/delete?domain={Uri.EscapeDataString(domain)}";
+		public const string GET_StatisticsOverview = "clientapi/admin/statistics/overview";
+		public const string GET_StatisticsHosts = "clientapi/admin/statistics/hosts";
+		public const string GET_StatisticsCrawler = "clientapi/admin/statistics/crawler";
+		public const string GET_AdminBackups = "clientapi/admin/backups";
+		public const string POST_AdminBackup = "clientapi/admin/backups";
+		public static string DELETE_M_AdminBackup(string id) => $"clientapi/admin/backups/{Uri.EscapeDataString(id)}";
+		public static string POST_M_AdminBackupTicket(string id) => $"clientapi/admin/backups/{Uri.EscapeDataString(id)}/ticket";
+		public static string POST_M_AdminBackupRestore(string id) => $"clientapi/admin/backups/{Uri.EscapeDataString(id)}/restore";
+		public const string POST_AdminBackupUpload = "clientapi/admin/backups/uploads";
+		public static string PUT_M_AdminBackupUpload(string id) => $"clientapi/admin/backups/uploads/{Uri.EscapeDataString(id)}";
+		public static string POST_M_AdminBackupUploadFinish(string id) => $"clientapi/admin/backups/uploads/{Uri.EscapeDataString(id)}/finish";
+		public static string DELETE_M_AdminBackupUpload(string id) => $"clientapi/admin/backups/uploads/{Uri.EscapeDataString(id)}";
+		public static string GET_M_PersonaArchive(string personaId) => $"clientapi/persona/{Uri.EscapeDataString(personaId)}/archive";
+		public static string POST_M_PersonaArchive(string personaId) => $"clientapi/persona/{Uri.EscapeDataString(personaId)}/archive";
+		public static string POST_M_PersonaArchiveTicket(string personaId) => $"clientapi/persona/{Uri.EscapeDataString(personaId)}/archive/ticket";
+		public static string POST_M_PersonaArchiveImport(string personaId) => $"clientapi/persona/{Uri.EscapeDataString(personaId)}/archive/import";
+		public static string POST_M_PersonaArchiveImportStop(string personaId) => $"clientapi/persona/{Uri.EscapeDataString(personaId)}/archive/import/stop";
+		public const string POST_PersonaArchiveUpload = "clientapi/persona/archive/uploads";
+		public static string PUT_M_PersonaArchiveUpload(string id) => $"clientapi/persona/archive/uploads/{Uri.EscapeDataString(id)}";
+		public static string DELETE_M_PersonaArchiveUpload(string id) => $"clientapi/persona/archive/uploads/{Uri.EscapeDataString(id)}";
 	}
 
 	public static class OAuth
@@ -36,6 +87,12 @@ public static class APIs
 	public static class Mastodon
 	{
 		public const string GET_VerifyCredentials = "api/v1/accounts/verify_credentials";
+		public const string PATCH_UpdateCredentials = "api/v1/accounts/update_credentials";
+		public const string GET_Mutes = "api/v1/mutes";
+		public const string GET_Blocks = "api/v1/blocks";
+		public const string GET_DomainBlocks = "api/v1/domain_blocks";
+		public const string POST_DomainBlocks = "api/v1/domain_blocks";
+		public const string DELETE_DomainBlocks = "api/v1/domain_blocks";
 		public const string GET_HomeTimeline = "api/v1/timelines/home";
 		public const string GET_PublicTimeline = "api/v1/timelines/public";
 		public const string GET_Statuses = "api/v1/statuses";
@@ -43,27 +100,81 @@ public static class APIs
 		public const string GET_Favourites = "api/v1/favourites";
 		public const string GET_Bookmarks = "api/v1/bookmarks";
 		public const string GET_Conversations = "api/v1/conversations";
-		public const string GET_Notifications = "api/v1/notifications";
+		public static string POST_M_ReadConversation(string conversationId) => $"api/v1/conversations/{Uri.EscapeDataString(conversationId)}/read";
+		public static string DELETE_M_Conversation(string conversationId) => $"api/v1/conversations/{Uri.EscapeDataString(conversationId)}";
 		public const string POST_Media = "api/v2/media";
+		public static string GET_M_Media(string mediaId) => $"api/v1/media/{Uri.EscapeDataString(mediaId)}";
+		public static string PUT_M_Media(string mediaId) => $"api/v1/media/{Uri.EscapeDataString(mediaId)}";
+		public const string GET_InstanceV2 = "api/v2/instance";
+		public const string DELETE_ProfileAvatar = "api/v1/profile/avatar";
+		public const string DELETE_ProfileHeader = "api/v1/profile/header";
+		public const string GET_AccountLookup = "api/v1/accounts/lookup";
+		public const string GET_Relationships = "api/v1/accounts/relationships";
+		public const string GET_FollowRequests = "api/v1/follow_requests";
+		public const string GET_Search = "api/v2/search";
 
 		public static string GET_M_TagTimeline(string tag) => $"api/v1/timelines/tag/{Uri.EscapeDataString(tag)}";
 		public static string GET_M_Account(string accountId) => $"api/v1/accounts/{Uri.EscapeDataString(accountId)}";
 		public static string GET_M_AccountStatuses(string accountId) => $"api/v1/accounts/{Uri.EscapeDataString(accountId)}/statuses";
+		public static string GET_M_AccountFollowing(string accountId) => $"api/v1/accounts/{Uri.EscapeDataString(accountId)}/following";
 		public static string GET_M_Status(string statusId) => $"api/v1/statuses/{Uri.EscapeDataString(statusId)}";
 		public static string GET_M_Context(string statusId) => $"api/v1/statuses/{Uri.EscapeDataString(statusId)}/context";
 		public static string DELETE_M_Status(string statusId) => $"api/v1/statuses/{Uri.EscapeDataString(statusId)}";
 		public static string POST_M_StatusAction(string statusId, string action) => $"api/v1/statuses/{Uri.EscapeDataString(statusId)}/{action}";
 		public static string POST_M_AccountAction(string accountId, string action) => $"api/v1/accounts/{Uri.EscapeDataString(accountId)}/{action}";
+		public static string M_Reaction(string statusId, string emoji) =>
+			$"api/v1/pleroma/statuses/{Uri.EscapeDataString(statusId)}/reactions/{Uri.EscapeDataString(emoji)}";
+		public static string POST_M_PollVotes(string pollId) => $"api/v1/polls/{Uri.EscapeDataString(pollId)}/votes";
+		public static string POST_M_FollowRequest(string accountId, string answer) => $"api/v1/follow_requests/{Uri.EscapeDataString(accountId)}/{answer}";
+		public const string GET_Lists = "api/v1/lists";
+		public const string POST_List = "api/v1/lists";
+		public const string GET_AccountSearch = "api/v1/accounts/search";
+		public static string PUT_M_List(string listId) => $"api/v1/lists/{Uri.EscapeDataString(listId)}";
+		public static string DELETE_M_List(string listId) => $"api/v1/lists/{Uri.EscapeDataString(listId)}";
+		public static string M_ListAccounts(string listId) => $"api/v1/lists/{Uri.EscapeDataString(listId)}/accounts";
+		public static string GET_M_AccountLists(string accountId) => $"api/v1/accounts/{Uri.EscapeDataString(accountId)}/lists";
+		public static string GET_M_ListTimeline(string listId) => $"api/v1/timelines/list/{Uri.EscapeDataString(listId)}";
+		public const string GET_ScheduledStatuses = "api/v1/scheduled_statuses";
+		public static string GET_M_StatusSource(string statusId) => $"api/v1/statuses/{Uri.EscapeDataString(statusId)}/source";
+		public static string GET_M_StatusHistory(string statusId) => $"api/v1/statuses/{Uri.EscapeDataString(statusId)}/history";
+		public static string GET_M_FavouritedBy(string statusId) => $"api/v1/statuses/{Uri.EscapeDataString(statusId)}/favourited_by";
+		public static string GET_M_RebloggedBy(string statusId) => $"api/v1/statuses/{Uri.EscapeDataString(statusId)}/reblogged_by";
+		public const string POST_Reports = "api/v1/reports";
+		public const string GET_NotificationPolicy = "api/v2/notifications/policy";
+		public const string PATCH_NotificationPolicy = "api/v2/notifications/policy";
+		public const string GET_NotificationRequests = "api/v1/notifications/requests";
+		public static string POST_M_NotificationRequest(string requestId, bool accept) =>
+			$"api/v1/notifications/requests/{Uri.EscapeDataString(requestId)}/{(accept ? "accept" : "dismiss")}";
+		public static string PUT_M_Status(string statusId) => $"api/v1/statuses/{Uri.EscapeDataString(statusId)}";
+		public const string GET_FollowedTags = "api/v1/followed_tags";
+		public const string GET_GroupedNotifications = "api/v2/notifications";
+		public const string GET_UnreadNotifications = "api/v2/notifications/unread_count";
+		public const string POST_Markers = "api/v1/markers";
+		public const string GET_TrendingTags = "api/v1/trends/tags";
+		public const string GET_TrendingStatuses = "api/v1/trends/statuses";
+		public const string GET_TrendingLinks = "api/v1/trends/links";
+		public const string GET_Directory = "api/v1/directory";
+		public static string GET_M_Tag(string name) => $"api/v1/tags/{Uri.EscapeDataString(name)}";
+		public static string POST_M_TagAction(string name, string action) => $"api/v1/tags/{Uri.EscapeDataString(name)}/{action}";
+		public static string PUT_M_ScheduledStatus(string id) => $"api/v1/scheduled_statuses/{Uri.EscapeDataString(id)}";
+		public static string DELETE_M_ScheduledStatus(string id) => $"api/v1/scheduled_statuses/{Uri.EscapeDataString(id)}";
+		public const string GET_Filters = "api/v2/filters";
+		public const string POST_Filter = "api/v2/filters";
+		public static string PUT_M_Filter(string filterId) => $"api/v2/filters/{Uri.EscapeDataString(filterId)}";
+		public static string DELETE_M_Filter(string filterId) => $"api/v2/filters/{Uri.EscapeDataString(filterId)}";
+		public static string POST_M_FilterStatus(string filterId) => $"api/v2/filters/{Uri.EscapeDataString(filterId)}/statuses";
+		public static string DELETE_M_FilterStatus(string filterStatusId) => $"api/v2/filters/statuses/{Uri.EscapeDataString(filterStatusId)}";
 	}
 
 	public static class PrivaPub
 	{
 		public const string GET_Instances = "api/privapub/v1/instances";
-		public const string GET_Cdns = "api/privapub/v1/cdns";
 
 		public static string GET_M_InstanceHistory(string host) => $"api/privapub/v1/instances/{Uri.EscapeDataString(host)}/history";
 		public static string GET_M_Cdn(string key) => $"api/privapub/v1/cdns/{Uri.EscapeDataString(key)}";
 
 		public static string GET_M_Provenance(string statusId) => $"api/privapub/v1/statuses/{Uri.EscapeDataString(statusId)}/provenance";
+		public static string POST_M_Join(string statusId) => $"api/privapub/v1/statuses/{Uri.EscapeDataString(statusId)}/join";
+		public static string POST_M_Leave(string statusId) => $"api/privapub/v1/statuses/{Uri.EscapeDataString(statusId)}/leave";
 	}
 }

Models/AppConfiguration.cs

@@ -2,7 +2,6 @@ namespace decePubClient.Models;
 
 public class AppConfiguration
 {
-	public string Version { get; set; }
 	public string ApiBaseAddress { get; set; }
 	/// <summary>PrivaPub's first-party application, the only one allowed to exchange the root JWT for persona tokens.</summary>
 	public string ClientId { get; set; } = "decepub";

Models/ClientLogs.cs

@@ -1,37 +0,0 @@
-namespace decePubClient.Models
-{
-	public class ClientLogs
-	{
-		public long Id { get; set; }
-		public string Where { get; set; }
-		public string WarningMessage { get; set; }
-		public ClientLogException Exception { get; set; }
-		public DateTime TimeStamp { get; set; } = DateTime.Now;
-		/// <summary>The entry as HTML for a log viewer: the warning text, or the exception's details.</summary>
-		public string ErrorMessage()
-		{
-			if (Exception is null)
-				return WarningMessage;
-
-			var details = @$"<b>Type</b>: {Exception.Type ?? "N/A"} <b>HelpLink</b>: {Exception.HelpLink ?? "N/A"} <b>HResult</b>: {Exception.HResult ?? "N/A"}<br>
-<b>Source</b>: {Exception.Source ?? "N/A"} <b>StackTrace</b>: {Exception.StackTrace ?? "N/A"} <b>MemberName</b>: {Exception.TargetSiteName ?? "N/A"}<br>
-<b>Message</b>: {Exception.Message ?? "N/A"}";
-			if (Exception.InnerExceptionMessage is null)
-				return details;
-
-			return $"{details}<br>\n<b>InnerExceptionMessage</b>:{Exception.InnerExceptionMessage}";
-		}
-	}
-
-	public class ClientLogException
-	{
-		public string Type { get; set; }
-		public string HelpLink { get; set; }
-		public string HResult { get; set; }
-		public string Source { get; set; }
-		public string StackTrace { get; set; }
-		public string TargetSiteName { get; set; }
-		public string Message { get; set; }
-		public string InnerExceptionMessage { get; set; }
-	}
-}

Models/ComposeForm.cs

@@ -22,8 +22,10 @@ public class ComposeForm
 	public string GroupId { get; set; }
 
 	[Required(ErrorMessageResourceName = ValidationNames.Required, ErrorMessageResourceType = typeof(ErrorMessages))]
-	public MessageType MessageType { get; set; } = MessageType.Public;
+	public Visibility Visibility { get; set; } = Visibility.Public;
 	public bool HasContentWarning { get; set; }
+	// its media marked sensitive without a warning: the persona's default ("always mark media as sensitive"), or the post's own when edited
+	public bool Sensitive { get; set; }
 	[StringLength(500, ErrorMessageResourceName = ValidationNames.MaxLength, ErrorMessageResourceType = typeof(ErrorMessages))]
 	public string SpoilerText { get; set; }
 	[StringLength(MaxContentLength, ErrorMessageResourceName = ValidationNames.MaxLength, ErrorMessageResourceType = typeof(ErrorMessages))]
@@ -37,17 +39,37 @@ public class ComposeForm
 	public double? Latitude { get; set; }
 	public double? Longitude { get; set; }
 
+	/// <summary>A poll instead of media: two to four choices, open ExpiresIn seconds, one choice or several.</summary>
+	public bool HasPoll { get; set; }
+	public List<string> PollOptions { get; set; } = ["", ""];
+	public int PollExpiresIn { get; set; } = 86400;
+	public bool PollMultiple { get; set; }
+
+	/// <summary>The language the post is written in (ISO 639-1); null leaves it to PrivaPub.</summary>
+	public string Language { get; set; }
+
+	/// <summary>The post this one quotes.</summary>
+	public string QuotedStatusId { get; set; }
+
+	/// <summary>Whether the post waits for ScheduledAt (a datetime-local value, the reader's own time) instead of going now.</summary>
+	public bool IsScheduled { get; set; }
+	public string ScheduledAt { get; set; }
+
+	/// <summary>When the post is to be published, in UTC, or null when it goes now or ScheduledAt is not a time.</summary>
+	public DateTime? ScheduledAtUtc => IsScheduled && DateTime.TryParse(ScheduledAt, System.Globalization.CultureInfo.InvariantCulture,
+		System.Globalization.DateTimeStyles.AssumeLocal, out var local) ? local.ToUniversalTime() : null;
+
 	[JsonIgnore, Bindable(false)]
 	public MediaType MediaType { get; set; } = MediaType.Images;
 	[JsonIgnore, Bindable(false)]
 	public bool IsScopeOptionsOpen { get; set; }
 
-	/// <summary>The Mastodon visibility of MessageType.</summary>
-	public string Visibility => MessageType switch
+	/// <summary>The Mastodon visibility of Visibility.</summary>
+	public string MastodonVisibility => Visibility switch
 	{
-		MessageType.Direct => "direct",
-		MessageType.FollowersOnly => "private",
-		MessageType.Unlisted => "unlisted",
+		Visibility.Direct => "direct",
+		Visibility.FollowersOnly => "private",
+		Visibility.Unlisted => "unlisted",
 		_ => "public"
 	};
 }

Models/FeedFilter.cs

@@ -8,6 +8,8 @@ public class FeedFilter
 	public TimelineType TimelineType { get; set; } = TimelineType.Home;
 	/// <summary>The community or circle the Groups tab shows.</summary>
 	public string GroupId { get; set; }
+	/// <summary>The persona's list the Lists tab shows.</summary>
+	public string ListId { get; set; }
 	/// <summary>The hashtag the Tag tab shows, without #.</summary>
 	public string Tag { get; set; }
 	/// <summary>Whether the globe is open where it can be closed (narrow screens).</summary>

Models/FeedPost.cs

@@ -17,7 +17,11 @@ public class FeedPost
 	/// <summary>The post shown; null for a notification without one (a follow).</summary>
 	public Status Status { get; set; }
 	public Account BoostedBy { get; init; }
-	public Notification Notification { get; init; }
+	public Notification Notification { get; set; }
+	/// <summary>For a notification standing for a group (likes of one post, follows of one hour): how many, and a few of
+	/// the accounts, newest first.</summary>
+	public int GroupCount { get; set; } = 1;
+	public List<Account> GroupAccounts { get; set; } = [];
 	public Conversation Conversation { get; init; }
 	/// <summary>A located post: within its range of the reader, never on the Mastodon API.</summary>
 	public bool Located { get; init; }
@@ -30,6 +34,11 @@ public class FeedPost
 
 	public string Host => Author?.Host;
 
+	/// <summary>When the post was written (for a follow, when it happened), in UTC; the globe shows the Sun of that moment.</summary>
+	public DateTime? WrittenAt => (Status?.CreatedAt ?? Notification?.CreatedAt) is { } at
+		? (at.Kind == DateTimeKind.Unspecified ? DateTime.SpecifyKind(at, DateTimeKind.Utc) : at.ToUniversalTime())
+		: null;
+
 	public bool IsOwnedBy(string personaId) => personaId is not null && Status?.Account?.Id == personaId;
 
 	public static FeedPost Of(Status status) => status.Reblog is { } original
@@ -38,12 +47,38 @@ public class FeedPost
 
 	public static FeedPost Of(Notification notification) => new()
 	{
-		Key = notification.Id,
+		Key = notification.GroupKey ?? notification.Id,
 		CursorId = notification.Id,
 		Status = notification.Status?.Reblog ?? notification.Status,
-		Notification = notification
+		Notification = notification,
+		GroupAccounts = notification.Account is null ? [] : [notification.Account]
 	};
 
+	/// <summary>A group of notifications as one item: its newest notification, how many it holds, and a few accounts.</summary>
+	public static FeedPost Of(NotificationGroup group, IReadOnlyDictionary<string, Account> accounts, IReadOnlyDictionary<string, Status> statuses)
+	{
+		var sample = group.SampleAccountIds.Select(accounts.GetValueOrDefault).Where(a => a is not null).ToList();
+		var status = group.StatusId is null ? null : statuses.GetValueOrDefault(group.StatusId);
+		return new()
+		{
+			Key = group.GroupKey,
+			CursorId = group.MostRecentNotificationId,
+			Status = status?.Reblog ?? status,
+			Notification = new Notification
+			{
+				Id = group.MostRecentNotificationId,
+				Type = group.Type,
+				CreatedAt = group.LatestPageNotificationAt,
+				Account = sample.FirstOrDefault(),
+				Status = status,
+				Emoji = group.Emoji,
+				GroupKey = group.GroupKey
+			},
+			GroupCount = Math.Max(1, group.NotificationsCount),
+			GroupAccounts = sample
+		};
+	}
+
 	public static FeedPost Of(Conversation conversation) => new()
 	{
 		Key = conversation.Id,

Models/Mastodon/Account.cs

@@ -25,6 +25,15 @@ public class Account
 	public string LastStatusAt { get; set; }
 	public List<CustomEmoji> Emojis { get; set; } = [];
 	public List<AccountField> Fields { get; set; } = [];
+	/// <summary>The account it moved to (PrivaPub shows it once the new account names this one among its aliases).</summary>
+	public Account Moved { get; set; }
+	/// <summary>Whether it is listed in the directory and suggested; null when its server does not say.</summary>
+	public bool? Discoverable { get; set; }
+	/// <summary>Whether its public posts may be found by full-text search.</summary>
+	public bool? Indexable { get; set; }
+	/// <summary>The persona's own account only (verify_credentials, update_credentials): its profile as written and its
+	/// posting defaults.</summary>
+	public AccountSource Source { get; set; }
 
 	/// <summary>The account's server: the host of its ActivityPub id.</summary>
 	public string Host => System.Uri.TryCreate(Uri, UriKind.Absolute, out var uri) ? uri.Host.ToLowerInvariant() : default;
@@ -33,6 +42,27 @@ public class Account
 	public string Name => string.IsNullOrWhiteSpace(DisplayName) ? Username : DisplayName;
 }
 
+public class AccountSource
+{
+	/// <summary>The biography as written, before PrivaPub renders it.</summary>
+	public string Note { get; set; }
+	public List<AccountField> Fields { get; set; } = [];
+	/// <summary>The default visibility of a new post: public, unlisted or private.</summary>
+	public string Privacy { get; set; }
+	public bool Sensitive { get; set; }
+	public string Language { get; set; }
+	/// <summary>Who may quote the persona's posts: public, followers or nobody.</summary>
+	public string QuotePolicy { get; set; }
+	public int FollowRequestsCount { get; set; }
+}
+
+/// <summary>A page of accounts (mutes, blocks), and the cursor of the next one: null at the end.</summary>
+public class AccountPage
+{
+	public List<Account> Accounts { get; set; } = [];
+	public string MaxId { get; set; }
+}
+
 public class AccountField
 {
 	public string Name { get; set; }
@@ -53,6 +83,20 @@ public class Relationship
 	public bool Following { get; set; }
 	public bool FollowedBy { get; set; }
 	public bool Blocking { get; set; }
+	public bool BlockedBy { get; set; }
 	public bool Muting { get; set; }
+	public bool MutingNotifications { get; set; }
+	public bool ShowingReblogs { get; set; }
+	public bool Notifying { get; set; }
 	public bool Requested { get; set; }
+	public bool RequestedBy { get; set; }
+	public bool DomainBlocking { get; set; }
+}
+
+/// <summary>/api/v2/search: what matched, a remote handle or URL resolved by PrivaPub.</summary>
+public class SearchResults
+{
+	public List<Account> Accounts { get; set; } = [];
+	public List<Status> Statuses { get; set; } = [];
+	public List<StatusTag> Hashtags { get; set; } = [];
 }

Models/Mastodon/Discovery.cs

@@ -0,0 +1,33 @@
+namespace decePubClient.Models.Mastodon;
+
+/// <summary>A hashtag as PrivaPub describes it: its last week of use in public posts it holds, and whether the persona
+/// follows it (null when nobody is signed in).</summary>
+public class Tag
+{
+	public string Name { get; set; }
+	public string Url { get; set; }
+	public List<TagDay> History { get; set; } = [];
+	public bool? Following { get; set; }
+
+	public int WeekUses => History.Sum(h => h.UsesCount);
+	public int TodayAccounts => History.FirstOrDefault()?.AccountsCount ?? 0;
+}
+
+/// <summary>One day of a tag's or a link's use; Mastodon sends the numbers as strings, the day as unix time.</summary>
+public class TagDay
+{
+	public string Day { get; set; }
+	public string Uses { get; set; }
+	public string Accounts { get; set; }
+
+	public int UsesCount => int.TryParse(Uses, out var n) ? n : 0;
+	public int AccountsCount => int.TryParse(Accounts, out var n) ? n : 0;
+}
+
+/// <summary>A link many authors shared this week: its preview card with its days.</summary>
+public class TrendLink : PreviewCard
+{
+	public List<TagDay> History { get; set; } = [];
+
+	public int WeekAccounts => History.Sum(h => h.AccountsCount);
+}

Models/Mastodon/Filter.cs

@@ -0,0 +1,80 @@
+using System.Text.Json.Serialization;
+
+namespace decePubClient.Models.Mastodon;
+
+/// <summary>A persona's filter (Mastodon's v2 filters): words and posts it would rather not see in some contexts, to be
+/// warned about, hidden or blurred. Statuses carry the filters they match (Status.Filtered); the client applies the
+/// context and the action.</summary>
+public class Filter
+{
+	public string Id { get; set; }
+	public string Title { get; set; }
+	public List<FilterContext> Context { get; set; } = [];
+	public DateTime? ExpiresAt { get; set; }
+	public FilterAction FilterAction { get; set; } = FilterAction.Warn;
+	public List<FilterKeyword> Keywords { get; set; } = [];
+	public List<FilterStatus> Statuses { get; set; } = [];
+
+	public bool IsActive => ExpiresAt is null || ExpiresAt > DateTime.UtcNow;
+}
+
+public class FilterKeyword
+{
+	public string Id { get; set; }
+	public string Keyword { get; set; }
+	public bool WholeWord { get; set; }
+}
+
+public class FilterStatus
+{
+	public string Id { get; set; }
+	public string StatusId { get; set; }
+}
+
+public class FilterResult
+{
+	public Filter Filter { get; set; }
+	public List<string> KeywordMatches { get; set; } = [];
+	public List<string> StatusMatches { get; set; } = [];
+}
+
+/// <summary>Where a filter applies; a card is told which of these it is shown in.</summary>
+[JsonConverter(typeof(JsonStringEnumConverter<FilterContext>))]
+public enum FilterContext
+{
+	[JsonStringEnumMemberName("home")] Home,
+	[JsonStringEnumMemberName("notifications")] Notifications,
+	[JsonStringEnumMemberName("public")] Public,
+	[JsonStringEnumMemberName("thread")] Thread,
+	[JsonStringEnumMemberName("account")] Account
+}
+
+[JsonConverter(typeof(JsonStringEnumConverter<FilterAction>))]
+public enum FilterAction
+{
+	/// <summary>The post is folded behind the filter's title.</summary>
+	[JsonStringEnumMemberName("warn")] Warn,
+	/// <summary>The post is not shown at all.</summary>
+	[JsonStringEnumMemberName("hide")] Hide,
+	/// <summary>The post's media are blurred, as sensitive media are.</summary>
+	[JsonStringEnumMemberName("blur")] Blur
+}
+
+/// <summary>What making or changing a filter sends; ExpiresIn 0 means never.</summary>
+public class FilterForm
+{
+	public string Title { get; set; }
+	public List<FilterContext> Context { get; set; } = [];
+	public FilterAction FilterAction { get; set; } = FilterAction.Warn;
+	public int? ExpiresIn { get; set; }
+	public List<FilterKeywordForm> KeywordsAttributes { get; set; } = [];
+}
+
+public class FilterKeywordForm
+{
+	public string Id { get; set; }
+	public string Keyword { get; set; }
+	public bool WholeWord { get; set; }
+	[JsonPropertyName("_destroy")]
+	public bool? Destroy { get; set; }
+}

Models/Mastodon/InstanceV2.cs

@@ -0,0 +1,23 @@
+namespace decePubClient.Models.Mastodon;
+
+/// <summary>/api/v2/instance, the part the client reads: what an upload may be.</summary>
+public class InstanceV2
+{
+	public InstanceConfiguration Configuration { get; set; } = new();
+}
+
+public class InstanceConfiguration
+{
+	public MediaConfiguration MediaAttachments { get; set; } = new();
+}
+
+/// <summary>The types an upload may have and how big it may be, as the server enforces them.</summary>
+public class MediaConfiguration
+{
+	public List<string> SupportedMimeTypes { get; set; } = [];
+	public long ImageSizeLimit { get; set; }
+	public long VideoSizeLimit { get; set; }
+	public long ImageMatrixLimit { get; set; }
+	public long VideoMatrixLimit { get; set; }
+	public int VideoFrameRateLimit { get; set; }
+}

Models/Mastodon/MastodonList.cs

@@ -0,0 +1,29 @@
+using System.Text.Json.Serialization;
+
+namespace decePubClient.Models.Mastodon;
+
+/// <summary>A persona's list of accounts it follows (Mastodon's List): read as its own feed, and when exclusive kept out of
+/// the home feed. Lists are the persona's own; PrivaPub never federates them.</summary>
+public class MastodonList
+{
+	public string Id { get; set; }
+	public string Title { get; set; }
+	public ListRepliesPolicy RepliesPolicy { get; set; } = ListRepliesPolicy.List;
+	public bool Exclusive { get; set; }
+}
+
+/// <summary>Which replies a list's feed shows besides its members' replies to themselves and to the persona.</summary>
+[JsonConverter(typeof(JsonStringEnumConverter<ListRepliesPolicy>))]
+public enum ListRepliesPolicy
+{
+	/// <summary>Replies to any account the persona follows.</summary>
+	[JsonStringEnumMemberName("followed")] Followed,
+	/// <summary>Replies to the list's members.</summary>
+	[JsonStringEnumMemberName("list")] List,
+	[JsonStringEnumMemberName("none")] None
+}
+
+public class ListAccountsForm
+{
+	public List<string> AccountIds { get; set; } = [];
+}

Models/Mastodon/Notification.cs

@@ -12,6 +12,45 @@ public class Notification
 	public Account Account { get; set; }
 	public Status Status { get; set; }
 	public string Emoji { get; set; }
+	/// <summary>The group it belongs to (likes and boosts of one post, follows within an hour), or ungrouped-{id}.</summary>
+	public string GroupKey { get; set; }
+}
+
+/// <summary>/api/v2/notifications: notifications folded into groups, with the accounts and posts they name.</summary>
+public class GroupedNotifications
+{
+	public List<Account> Accounts { get; set; } = [];
+	public List<Status> Statuses { get; set; } = [];
+	public List<NotificationGroup> NotificationGroups { get; set; } = [];
+}
+
+public class NotificationGroup
+{
+	public string GroupKey { get; set; }
+	public int NotificationsCount { get; set; }
+	public string Type { get; set; }
+	public string MostRecentNotificationId { get; set; }
+	public string PageMinId { get; set; }
+	public string PageMaxId { get; set; }
+	public DateTime LatestPageNotificationAt { get; set; }
+	public List<string> SampleAccountIds { get; set; } = [];
+	public string StatusId { get; set; }
+	public string Emoji { get; set; }
+}
+
+public class MarkersForm
+{
+	public MarkerForm Notifications { get; set; }
+}
+
+public class MarkerForm
+{
+	public string LastReadId { get; set; }
+}
+
+public class UnreadCount
+{
+	public int Count { get; set; }
 }
 
 /// <summary>A direct conversation: its participants and its last post.</summary>

Models/Mastodon/PrivaPubApi.cs

@@ -176,4 +176,117 @@ public class PostStatusForm
 	public string SpoilerText { get; set; }
 	public string Visibility { get; set; }
 	public string Language { get; set; }
+	/// <summary>When the post is to be published (ISO 8601, at least five minutes ahead); null posts it now.</summary>
+	public string ScheduledAt { get; set; }
+	public PollForm Poll { get; set; }
+	public string QuotedStatusId { get; set; }
+}
+
+public class PollForm
+{
+	public List<string> Options { get; set; } = [];
+	public int ExpiresIn { get; set; }
+	public bool Multiple { get; set; }
+}
+
+/// <summary>What an edit sends, the whole post as Mastodon wants it: the words, their warning and sensitive flag, the
+/// post's language, the media it keeps (media_ids) and the descriptions changed (media_attributes).</summary>
+public class StatusEditForm
+{
+	public string Status { get; set; }
+	public string SpoilerText { get; set; }
+	public bool Sensitive { get; set; }
+	public string Language { get; set; }
+	public List<string> MediaIds { get; set; } = [];
+	public List<MediaAttributeForm> MediaAttributes { get; set; } = [];
+}
+
+/// <summary>A posted attachment's new description, sent with the edit.</summary>
+public class MediaAttributeForm
+{
+	public string Id { get; set; }
+	public string Description { get; set; }
+}
+
+/// <summary>/api/v1/statuses/:id/source: the author's own text of a post, to edit it.</summary>
+public class StatusSource
+{
+	public string Id { get; set; }
+	public string Text { get; set; }
+	public string SpoilerText { get; set; }
+}
+
+/// <summary>/api/v2/notifications/policy: what notifications from people the persona does not follow, people who do not
+/// follow it, new accounts, unasked private mentions and limited accounts become: accept, filter or drop.</summary>
+public class NotificationPolicy
+{
+	public string ForNotFollowing { get; set; }
+	public string ForNotFollowers { get; set; }
+	public string ForNewAccounts { get; set; }
+	public string ForPrivateMentions { get; set; }
+	public string ForLimitedAccounts { get; set; }
+	public NotificationPolicySummary Summary { get; set; }
+}
+
+public class NotificationPolicySummary
+{
+	public int PendingRequestsCount { get; set; }
+	public int PendingNotificationsCount { get; set; }
+}
+
+/// <summary>/api/v1/notifications/requests: the notifications the policy filtered from one account, waiting to be let in
+/// (and that account from then on) or dismissed.</summary>
+public class NotificationRequest
+{
+	public string Id { get; set; }
+	public DateTime CreatedAt { get; set; }
+	public DateTime UpdatedAt { get; set; }
+	/// <summary>A number, as a string (Mastodon's).</summary>
+	public string NotificationsCount { get; set; }
+	public Account Account { get; set; }
+	public Status LastStatus { get; set; }
+}
+
+/// <summary>/api/v1/reports: an account, and some of its posts, reported to the persona's server's moderators; forwarded,
+/// a remote account's server gets it too, from the server's own actor.</summary>
+public class ReportRequest
+{
+	public string AccountId { get; set; }
+	public List<string> StatusIds { get; set; } = [];
+	public string Comment { get; set; }
+	/// <summary>spam, legal or other.</summary>
+	public string Category { get; set; }
+	public bool Forward { get; set; }
+}
+
+/// <summary>/api/v1/statuses/:id/history: one version of a post, the oldest first and the one showing last.</summary>
+public class StatusEdit
+{
+	public string Content { get; set; }
+	public string SpoilerText { get; set; }
+	public bool Sensitive { get; set; }
+	public DateTime CreatedAt { get; set; }
+	public List<CustomEmoji> Emojis { get; set; } = [];
+}
+
+/// <summary>A post waiting for its time (/api/v1/scheduled_statuses).</summary>
+public class ScheduledStatus
+{
+	public string Id { get; set; }
+	public DateTime ScheduledAt { get; set; }
+	public ScheduledParams Params { get; set; } = new();
+	public List<MediaAttachment> MediaAttachments { get; set; } = [];
+}
+
+public class ScheduledParams
+{
+	public string Text { get; set; }
+	public string SpoilerText { get; set; }
+	public string Visibility { get; set; }
+	public string InReplyToId { get; set; }
+}
+
+public class ScheduleForm
+{
+	public string ScheduledAt { get; set; }
 }

Models/Mastodon/PrivaPubStatus.cs

@@ -5,6 +5,11 @@ public class PrivaPubStatus
 {
 	/// <summary>The ActivityPub type of a remote object: Note, Article, Page, Video, Audio, Event, Question…</summary>
 	public string ObjectType { get; set; }
+	/// <summary>Its community's moderators locked it: PrivaPub refuses a reply.</summary>
+	public bool Locked { get; set; }
+	/// <summary>The persona's reply or boost of a post whose author must approve it first (GoToSocial's interaction
+	/// policies): "pending" until the author answers, "rejected" if they refuse; null otherwise.</summary>
+	public string Approval { get; set; }
 	public string Title { get; set; }
 	public string Excerpt { get; set; }
 	public string Cover { get; set; }
@@ -16,6 +21,8 @@ public class PrivaPubStatus
 	/// <summary>A remote post's own place (Pixelfed's location), shown only.</summary>
 	public PrivaPubPlace Place { get; set; }
 	public PrivaPubVotes Votes { get; set; }
+	/// <summary>Whose wall it was written on (Smithereen's walls, FEP-400e), when not its author's own.</summary>
+	public Account Wall { get; set; }
 }
 
 public class PrivaPubSource
@@ -68,9 +75,13 @@ public class PrivaPubEvent
 	public string TimeZone { get; set; }
 	public List<PrivaPubPlace> Places { get; set; } = [];
 	public string OnlineUrl { get; set; }
+	/// <summary>Mobilizon's: "free", "restricted" (the organiser approves), "invite" or "external" (not joined from here).</summary>
+	public string JoinMode { get; set; }
 	public int? Participants { get; set; }
 	public int? Capacity { get; set; }
 	public string Status { get; set; }
+	/// <summary>The persona's own: "pending", "accepted" or "rejected"; null when it has not joined.</summary>
+	public string Participation { get; set; }
 }
 
 public class PrivaPubPlace

Models/Mastodon/Status.cs

@@ -40,7 +40,13 @@ public class Status
 	public string Text { get; set; }
 	public PrivaPubStatus Privapub { get; set; }
 	public Quote Quote { get; set; }
+	/// <summary>Emoji reactions (PrivaPub sends Pleroma's and Misskey's forms as one list).</summary>
+	public List<EmojiReaction> EmojiReactions { get; set; } = [];
+	/// <summary>The persona's filters this post matches, whatever their context (the card picks those of where it is).</summary>
+	public List<FilterResult> Filtered { get; set; } = [];
 	public int QuotesCount { get; set; }
+	/// <summary>Who may quote it: CurrentUser is automatic, manual (asked) or denied for the persona.</summary>
+	public QuoteApproval QuoteApproval { get; set; }
 }
 
 public class StatusMention
@@ -85,9 +91,28 @@ public class Poll
 	public int VotesCount { get; set; }
 	public int? VotersCount { get; set; }
 	public bool? Voted { get; set; }
+	/// <summary>The options the current persona chose (indexes).</summary>
+	public List<int> OwnVotes { get; set; } = [];
 	public List<PollOption> Options { get; set; } = [];
 }
 
+public class EmojiReaction
+{
+	/// <summary>The emoji itself, or a custom emoji's shortcode.</summary>
+	public string Name { get; set; }
+	public int Count { get; set; }
+	/// <summary>Whether the current persona reacted with it.</summary>
+	public bool Me { get; set; }
+	/// <summary>A custom emoji's image, through PrivaPub's proxy.</summary>
+	public string Url { get; set; }
+}
+
+/// <summary>POST /api/v1/polls/{id}/votes.</summary>
+public class PollVoteForm
+{
+	public List<int> Choices { get; set; } = [];
+}
+
 public class PollOption
 {
 	public string Title { get; set; }
@@ -107,3 +132,10 @@ public class PreviewCard
 	public int Height { get; set; }
 	public string Blurhash { get; set; }
 }
+
+public class QuoteApproval
+{
+	public List<string> Automatic { get; set; } = [];
+	public List<string> Manual { get; set; } = [];
+	public string CurrentUser { get; set; }
+}

Models/PageSettings.cs

@@ -1,5 +1,6 @@
 
 using PrivaPub.ClientModels.Resources;
+using PrivaPub.ClientModels.User;
 
 using System.ComponentModel.DataAnnotations;
 
@@ -10,20 +11,19 @@ namespace decePubClient.Models
 		[Required(ErrorMessageResourceName = "Required", ErrorMessageResourceType = typeof(ErrorsResource)),
 		 Display(Name = "LanguageId", ResourceType = typeof(FieldsNameResource))]
 		public string CurrentLanguageCode { get; set; } = "en";
-		//public bool NativeNotificationsEnabled { get; set; } = false;
 		[Range(0, 359, ErrorMessageResourceName = nameof(Range), ErrorMessageResourceType = typeof(ErrorsResource))]
 		public short LightThemeIndexColour { get; set; } = 25;
 		[Range(0, 359, ErrorMessageResourceName = nameof(Range), ErrorMessageResourceType = typeof(ErrorsResource))]
 		public short DarkThemeIndexColour { get; set; } = 215;
-		[Range(-2, 359, ErrorMessageResourceName = nameof(Range), ErrorMessageResourceType = typeof(ErrorsResource))]
-		public short IconsThemeIndexColour { get; set; } = 25;
 
 		public bool PreferSystemTheming { get; set; } = true;
 		public bool ThemeIsDarkMode { get; set; } = false;
 		public bool ThemeIsLightGray { get; set; } = true;
 		public bool ThemeIsDarkGray { get; set; } = false;
-		
-		public bool ShowDonatorBadge { get; set; } = false;
+		// before publishing pictures without a description, the composer asks once
+		public bool RemindAltText { get; set; } = true;
+		// the theme is the login's (PrivaPub's user settings): taken at sign-in, saved there whenever it changes here
+		public bool SyncWithLogin { get; set; } = true;
 
 		// How the theme flags combine is in wwwroot/js/theme.js: with PreferSystemTheming the OS picks light or dark;
 		// otherwise ThemeIsDarkGray, then ThemeIsLightGray, then ThemeIsDarkMode decide; either grey flag drops the
@@ -59,5 +59,33 @@ namespace decePubClient.Models
 				LightThemeIndexColour = hue;
 			SetGray(false, isDark);
 		}
+
+		/// <summary>
+		/// These settings as the login keeps them: the language as the two letters of the culture the app runs in
+		/// (ExtensionMethods.ToCulture: "it" is it-IT, anything else en-GB), the icons' hue at its default, since the client
+		/// has no such setting.
+		/// </summary>
+		public ViewUserSettings ToLoginSettings() => new()
+		{
+			LanguageCode = CurrentLanguageCode is "it" ? "it" : "en",
+			LightThemeIndexColour = LightThemeIndexColour,
+			DarkThemeIndexColour = DarkThemeIndexColour,
+			IconsThemeIndexColour = DefaultLightThemeIndexColour,
+			PreferSystemTheming = PreferSystemTheming,
+			ThemeIsDarkMode = ThemeIsDarkMode,
+			ThemeIsLightGray = ThemeIsLightGray,
+			ThemeIsDarkGray = ThemeIsDarkGray
+		};
+
+		/// <summary>Takes the login's theme; its language stays this device's, since changing it reloads the app.</summary>
+		public void TakeLoginTheme(ViewUserSettings settings)
+		{
+			LightThemeIndexColour = Math.Clamp(settings.LightThemeIndexColour, (short)0, (short)359);
+			DarkThemeIndexColour = Math.Clamp(settings.DarkThemeIndexColour, (short)0, (short)359);
+			PreferSystemTheming = settings.PreferSystemTheming;
+			ThemeIsDarkMode = settings.ThemeIsDarkMode;
+			ThemeIsLightGray = settings.ThemeIsLightGray;
+			ThemeIsDarkGray = settings.ThemeIsDarkGray;
+		}
 	}
 }

Models/ProfileForm.cs

@@ -0,0 +1,105 @@
+using decePubClient.Models.Mastodon;
+using decePubClient.Models.Types;
+
+namespace decePubClient.Models
+{
+	/// <summary>
+	/// The persona's profile as Settings edits it, which is what update_credentials takes: the words as written (its
+	/// account's Source), the flags, the posting defaults, and a new avatar or header when one was picked. Fields always
+	/// holds FieldCount rows; a row without a name is dropped.
+	/// </summary>
+	public class ProfileForm
+	{
+		public const int FieldCount = 4;
+		public const int DisplayNameLength = 30;
+		public const int NoteLength = 500;
+		public const int FieldLength = 255;
+
+		public string DisplayName { get; set; }
+		public string Note { get; set; }
+		public bool Locked { get; set; }
+		public bool Bot { get; set; }
+		public bool Discoverable { get; set; }
+		public bool Indexable { get; set; }
+		public Visibility Privacy { get; set; } = Visibility.Public;
+		public bool Sensitive { get; set; }
+		public string Language { get; set; }
+		public QuotePolicy QuotePolicy { get; set; } = QuotePolicy.Public;
+		public List<AccountField> Fields { get; set; } = [];
+		public UploadMedia Avatar { get; set; }
+		public UploadMedia Header { get; set; }
+
+		public static ProfileForm Of(Account account)
+		{
+			var source = account.Source ?? new();
+			var fields = source.Fields.Count > 0 ? source.Fields : account.Fields;
+			return new()
+			{
+				DisplayName = account.DisplayName,
+				Note = source.Note,
+				Locked = account.Locked,
+				Bot = account.Bot,
+				Discoverable = account.Discoverable == true,
+				Indexable = account.Indexable == true,
+				Privacy = source.Privacy switch
+				{
+					"private" => Visibility.FollowersOnly,
+					"unlisted" => Visibility.Unlisted,
+					_ => Visibility.Public
+				},
+				Sensitive = source.Sensitive,
+				Language = source.Language,
+				QuotePolicy = source.QuotePolicy switch
+				{
+					"followers" => QuotePolicy.Followers,
+					"nobody" => QuotePolicy.Nobody,
+					_ => QuotePolicy.Public
+				},
+				Fields = [.. fields.Take(FieldCount).Select(f => new AccountField { Name = f.Name, Value = f.Value }),
+					.. Enumerable.Range(0, Math.Max(0, FieldCount - fields.Count)).Select(_ => new AccountField())]
+			};
+		}
+
+		/// <summary>The form as update_credentials reads it, with the pictures as files.</summary>
+		public MultipartFormDataContent Content()
+		{
+			var content = new MultipartFormDataContent
+			{
+				{ new StringContent(DisplayName?.Trim() ?? ""), "display_name" },
+				{ new StringContent(Note ?? ""), "note" },
+				{ new StringContent(Flag(Locked)), "locked" },
+				{ new StringContent(Flag(Bot)), "bot" },
+				{ new StringContent(Flag(Discoverable)), "discoverable" },
+				{ new StringContent(Flag(Indexable)), "indexable" },
+				{ new StringContent(Privacy switch { Visibility.FollowersOnly => "private", Visibility.Unlisted => "unlisted", _ => "public" }), "source[privacy]" },
+				{ new StringContent(Flag(Sensitive)), "source[sensitive]" },
+				{ new StringContent(Language ?? ""), "source[language]" },
+				{ new StringContent(QuotePolicy switch { QuotePolicy.Followers => "followers", QuotePolicy.Nobody => "nobody", _ => "public" }), "source[quote_policy]" }
+			};
+			// every row is sent, so a row emptied here is removed there
+			for (var i = 0; i < Fields.Count; i++)
+			{
+				content.Add(new StringContent(Fields[i].Name?.Trim() ?? ""), $"fields_attributes[{i}][name]");
+				content.Add(new StringContent(Fields[i].Value?.Trim() ?? ""), $"fields_attributes[{i}][value]");
+			}
+			if (Avatar is not null)
+				content.Add(Picture(Avatar), "avatar", Avatar.FileName);
+			if (Header is not null)
+				content.Add(Picture(Header), "header", Header.FileName);
+			return content;
+		}
+
+		static string Flag(bool value) => value ? "true" : "false";
+
+		// PrivaPub keeps pictures up to this size and resizes them
+		public const long MaximumPictureSize = 20 * 1024 * 1024;
+
+		// streamed from the browser's file, read again for each attempt
+		static StreamContent Picture(UploadMedia media)
+		{
+			var picture = new StreamContent(media.File.OpenReadStream(MaximumPictureSize));
+			picture.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(media.ContentType);
+			return picture;
+		}
+	}
+}

Models/PublicActionNotices.cs

@@ -0,0 +1,19 @@
+namespace decePubClient.Models;
+
+/// <summary>
+/// The personas already told that an act of theirs is public (owner decision, PrivaPub's ROADMAP: each persona is told
+/// once, before its first one): reactions and poll votes, and joining an event. Kept in localStorage under its type name.
+/// </summary>
+public class PublicActionNotices
+{
+	/// <summary>Told about reactions and poll votes.</summary>
+	public List<string> PersonaIds { get; set; } = [];
+	/// <summary>Told about joining events.</summary>
+	public List<string> EventPersonaIds { get; set; } = [];
+}
+
+public enum PublicAct
+{
+	Reaction = 0,
+	Participation = 1
+}

Models/PublicCacheData.cs

@@ -1,17 +1,7 @@
-using BlazorZXingJs;
-
-using System.Collections.ObjectModel;
-
-namespace decePubClient.Models
+namespace decePubClient.Models
 {
 	public class PublicCacheData
 	{
-		public IReadOnlyList<ViewLanguage> Languages { get; set; } = [];
-		public List<MediaDeviceInfo> QrCodeDevices { get; set; } = [];
-		public string LastPage { get; set; }
-		public string CurrentSubPage { get; set; }
 		public PageSettings PageSettings { get; set; } = new();
-		public bool ShowLogs { get; set; } = false;
-		public IReadOnlyDictionary<string, string> Policies { get; set; } = ReadOnlyDictionary<string, string>.Empty;
 	}
 }

Models/ReportForm.cs

@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations;
+
+using decePubClient.Models.Types;
+using decePubClient.Resources;
+
+namespace decePubClient.Models;
+
+/// <summary>A report of an account, and of the post it was made from, as the report dialog edits it.</summary>
+public class ReportForm
+{
+	public const int CommentLength = 1000;
+
+	public ReportCategory Category { get; set; } = ReportCategory.Other;
+	[StringLength(CommentLength, ErrorMessageResourceName = ValidationNames.MaxLength, ErrorMessageResourceType = typeof(ErrorMessages))]
+	public string Comment { get; set; }
+	/// <summary>A copy to a remote account's own server, from PrivaPub's actor.</summary>
+	public bool Forward { get; set; } = true;
+}

Models/SettingsOptions.cs

@@ -1,7 +0,0 @@
-namespace decePubClient.Models
-{
-	public class SettingsOptions
-	{
-		public bool IsOpen { get; set; }
-	}
-}

Models/Types/MessageType.cs

@@ -1,10 +0,0 @@
-namespace decePubClient.Models.Types
-{
-	public enum MessageType
-	{
-		Direct = 1,
-		FollowersOnly,
-		Unlisted,
-		Public
-	}
-}

Models/Types/QuotePolicy.cs

@@ -0,0 +1,10 @@
+namespace decePubClient.Models.Types
+{
+	/// <summary>Who may quote a persona's posts (Mastodon's quote_policy).</summary>
+	public enum QuotePolicy
+	{
+		Public = 1,
+		Followers,
+		Nobody
+	}
+}

Models/Types/ReportCategory.cs

@@ -0,0 +1,10 @@
+namespace decePubClient.Models.Types
+{
+	/// <summary>Why an account is reported (Mastodon's categories, without its server rules, which PrivaPub has none of).</summary>
+	public enum ReportCategory
+	{
+		Other = 0,
+		Spam = 1,
+		Legal = 2
+	}
+}

Models/Types/TimelineType.cs

@@ -12,6 +12,7 @@ namespace decePubClient.Models.Types
 		Notifications,
 		Favourites,
 		Bookmarks,
-		Tag
+		Tag,
+		Lists
 	}
 }

Models/Types/Visibility.cs

@@ -0,0 +1,11 @@
+namespace decePubClient.Models.Types
+{
+	/// <summary>Who a post is for; the members are resource keys too (Localizer[value.ToString()]).</summary>
+	public enum Visibility
+	{
+		Direct = 1,
+		FollowersOnly,
+		Unlisted,
+		Public
+	}
+}

Models/UploadMedia.cs

@@ -1,17 +1,48 @@
-using System.ComponentModel;
+using System.ComponentModel;
 using System.Text.Json.Serialization;
 
+using Microsoft.AspNetCore.Components.Forms;
+
 namespace decePubClient.Models;
 
+public enum UploadState
+{
+	Uploading,
+	Processing,
+	Ready,
+	Failed
+}
+
+/// <summary>
+/// A file attached in the composer. It is uploaded as soon as it is picked, streamed from the browser's file (nothing of
+/// it is kept but a small preview), and its id is kept, so a post that fails never sends it again.
+/// </summary>
 public class UploadMedia
 {
 	public string ContentType { get; set; }
 	public string FileName { get; set; }
 	public string AltText { get; set; }
-	public byte[] Blob { get; set; } = [];
+	public long Size { get; set; }
 
 	[JsonIgnore, Bindable(false)]
-	public string Base64Preview { get; set; }
+	public IBrowserFile File { get; set; }
+	/// <summary>A small picture of it (a thumbnail the browser made), or for media already posted its server's preview.</summary>
 	[JsonIgnore, Bindable(false)]
-	public long Size { get; set; }
+	public string Preview { get; set; }
+	[JsonIgnore, Bindable(false)]
+	public UploadState State { get; set; }
+	[JsonIgnore, Bindable(false)]
+	public string Id { get; set; }
+	[JsonIgnore, Bindable(false)]
+	public string Error { get; set; }
+	/// <summary>The description the server holds: a different one is sent before the post.</summary>
+	[JsonIgnore, Bindable(false)]
+	public string SentAltText { get; set; }
+	/// <summary>Already on the post being edited: its description changes through the edit.</summary>
+	[JsonIgnore, Bindable(false)]
+	public bool Posted { get; set; }
+	[JsonIgnore, Bindable(false)]
+	public CancellationTokenSource Cancel { get; set; }
+	[JsonIgnore, Bindable(false)]
+	public Task Done { get; set; } = Task.CompletedTask;
 }

Models/VConstants.cs

@@ -1,7 +0,0 @@
-namespace decePubClient.Models
-{
-	public static class VConstants
-	{
-		public const string HideClass = "hidden";
-	}
-}

Models/ViewLanguage.cs

@@ -1,8 +0,0 @@
-namespace decePubClient.Models
-{
-	public class ViewLanguage
-	{
-		public string Name { get; set; }
-		public string International2Code { get; set; }
-	}
-}

Pages/Administration.razor

@@ -1,7 +1,12 @@
 @page "/administration"
+@attribute [Authorize(Policy = Policies.IsModerator)]
 @inherits LocalizableComponentBase
 
-<Title>@Localizer["Settings"]</Title>
+<Title>@Localizer["Administration"]</Title>
+
+@* Moderators handle reports; administrators also block servers for everyone, read the federation statistics, and back
+   up and restore the server. The
+   other sections wait for PrivaPub endpoints that do not exist yet. *@
 
 <section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
 
@@ -25,18 +30,57 @@
 		<DCollapse Icon="DCollapseIcon.Arrow">
 			<Header>
 				<p class="inline-flex items-center gap-2">
-					<i class="ion-md-albums text-xl"></i> <span>@Localizer["Reports"]</span>
+					<i class="ion-md-flag text-xl"></i> <span>@Localizer["Reports"]</span>
 				</p>
 			</Header>
 			<ChildContent>
 				<div class="block w-full p-3 md:p-4">
-					<p class="w-full text-center text-lg">
-						<i class="ion-ios-remove-circle-outline"></i> @Localizer["Empty"]
-					</p>
+					<ReportsPanel />
 				</div>
 			</ChildContent>
 		</DCollapse>
 
+		<AuthorizeView Policy="@Policies.IsAdmin">
+			<DCollapse Icon="DCollapseIcon.Arrow">
+				<Header>
+					<p class="inline-flex items-center gap-2">
+						<i class="ion-md-globe text-xl"></i> <span>@Localizer["Blocked servers"]</span>
+					</p>
+				</Header>
+				<ChildContent>
+					<div class="block w-full p-3 md:p-4">
+						<ServerBlocksPanel />
+					</div>
+				</ChildContent>
+			</DCollapse>
+
+			<DCollapse Icon="DCollapseIcon.Arrow">
+				<Header>
+					<p class="inline-flex items-center gap-2">
+						<i class="ion-md-stats text-xl"></i> <span>@Localizer["Statistics"]</span>
+					</p>
+				</Header>
+				<ChildContent>
+					<div class="block w-full p-3 md:p-4">
+						<StatisticsPanel />
+					</div>
+				</ChildContent>
+			</DCollapse>
+
+			<DCollapse Icon="DCollapseIcon.Arrow">
+				<Header>
+					<p class="inline-flex items-center gap-2">
+						<i class="ion-md-archive text-xl"></i> <span>@Localizer["Backups"]</span>
+					</p>
+				</Header>
+				<ChildContent>
+					<div class="block w-full p-3 md:p-4">
+						<BackupsPanel />
+					</div>
+				</ChildContent>
+			</DCollapse>
+		</AuthorizeView>
+
 		<DCollapse Icon="DCollapseIcon.Arrow">
 			<Header>
 				<p class="inline-flex items-center gap-2">

Pages/Explore.razor

@@ -0,0 +1,283 @@
+@page "/explore"
+@attribute [Authorize]
+@inherits LocalizableComponentBase
+<Title>@Localizer["Explore"]</Title>
+
+@* What there is to find on PrivaPub: the hashtags, posts and links being talked about (from public posts it already
+   holds; PrivaPub fetches nothing for them), the directory of accounts that let themselves be discovered, and the
+   hashtags the persona follows. A hashtag opens as a tab of the feed; a link goes out to its site. *@
+<section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
+	<div class="flex flex-col gap-4 p-4 md:p-5 w-full h-full absolute overflow-y-auto">
+
+		<div class="flex items-center gap-2">
+			<i class="ion-md-compass text-lg"></i>
+			<h1 class="font-bold truncate">@Localizer["Explore"]</h1>
+		</div>
+
+		<div @ref="strip" class="overflow-x-auto flex-none max-md:edge-fade-x" data-scroll-x>
+			<DTabs Active="(int)tab" ActiveChanged="SelectTab" Variant="DTabsVariant.Box" Size="DSize.Sm" ContentClass="hidden" class="flex-nowrap w-max"
+				   aria-label="@Localizer["Explore"]">
+				<DTab><Header><i class="ion-md-pricetag"></i> @Localizer["Hashtags"]</Header></DTab>
+				<DTab><Header><i class="ion-md-flame"></i> @Localizer["Popular posts"]</Header></DTab>
+				<DTab><Header><i class="ion-md-link"></i> @Localizer["Shared links"]</Header></DTab>
+				<DTab><Header><i class="ion-md-people"></i> @Localizer["People"]</Header></DTab>
+				<DTab><Header><i class="ion-md-bookmarks"></i> @Localizer["Followed hashtags"]</Header></DTab>
+			</DTabs>
+		</div>
+
+		@if (IsLoading)
+		{
+			<p class="flex w-full items-center justify-center gap-2">
+				<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+				@Localizer["loading"]
+			</p>
+		}
+		else if (tab is ExploreTab.Hashtags or ExploreTab.Followed)
+		{
+			@if (tags.Count == 0)
+			{
+				<p class="w-full text-center" data-feed-empty>
+					<i class="ion-ios-remove-circle-outline"></i> @(tab is ExploreTab.Followed ? Localizer["This persona follows no hashtag yet."] : Localizer["Nothing is trending yet."])
+				</p>
+			}
+			<div class="flex flex-col gap-2">
+				@foreach (var item in tags)
+				{
+					<div class="flex flex-wrap items-center gap-3 p-3 rounded-xl neo-raised neo-2xs" data-tag="@item.Name">
+						<button type="button" class="flex flex-col items-start justify-center min-w-0 flex-1 text-left pointer-coarse:min-h-11" @onclick="() => OpenTag(item.Name)">
+							<b class="truncate">#@item.Name</b>
+							<span class="text-xs opacity-70 tabular-nums">@Localizer["{0} posts this week, {1} people today", item.WeekUses, item.TodayAccounts]</span>
+						</button>
+						<span class="flex items-end gap-px h-6" aria-hidden="true">
+							@foreach (var day in Enumerable.Reverse(item.History))
+							{
+								<span class="w-1.5 rounded-sm bg-primary/60" style="@($"height:{Bar(day.UsesCount, item)}%")"></span>
+							}
+						</span>
+						<DButton Size="DSize.Xs" Color="@(item.Following == true ? DColor.Neutral : DColor.Primary)" Disabled="@(IsDefaultDisabled || isActing)"
+								 OnClick="@(() => ToggleFollow(item))">
+							<span>@(item.Following == true ? Localizer["Unfollow"] : Localizer["Follow"])</span>
+						</DButton>
+					</div>
+				}
+			</div>
+		}
+		else if (tab is ExploreTab.Posts)
+		{
+			@if (posts.Count == 0)
+			{
+				<p class="w-full text-center" data-feed-empty><i class="ion-ios-remove-circle-outline"></i> @Localizer["Nothing is trending yet."]</p>
+			}
+			<div class="flex flex-col gap-4">
+				@foreach (var post in posts)
+				{
+					<Content @key="post.Key" Post="post" FilterIn="FilterContext.Public" OnTag="OpenTag" />
+				}
+			</div>
+		}
+		else if (tab is ExploreTab.Links)
+		{
+			@if (links.Count == 0)
+			{
+				<p class="w-full text-center" data-feed-empty><i class="ion-ios-remove-circle-outline"></i> @Localizer["Nothing is trending yet."]</p>
+			}
+			<div class="flex flex-col gap-3">
+				@foreach (var link in links)
+				{
+					<a class="flex gap-3 p-3 rounded-xl neo-raised neo-2xs min-w-0" href="@link.Url" target="_blank" rel="noopener noreferrer" data-link="@link.Url">
+						@if (link.Image is { Length: > 0 } image)
+						{
+							@* alt="": the title is next to it. *@
+							<img alt="" loading="lazy" class="h-16 w-24 flex-none object-cover rounded-lg" src="@image" />
+						}
+						<span class="flex flex-col min-w-0 gap-1">
+							<b class="text-sm break-words">@link.Title</b>
+							@if (link.Description is { Length: > 0 } description)
+							{
+								<span class="text-xs opacity-80 line-clamp-2">@description</span>
+							}
+							<span class="text-xs opacity-60">@link.ProviderName · @Localizer["{0} people this week", link.WeekAccounts]</span>
+						</span>
+					</a>
+				}
+			</div>
+		}
+		else
+		{
+			<div class="flex flex-wrap items-center gap-3">
+				<DSelect TValue="DirectoryOrder" Size="DSize.Sm" class="w-auto" Value="order" ValueChanged="ChangeOrder" ValueExpression="() => order">
+					<option value="@DirectoryOrder.Active">@Localizer["Recently active"]</option>
+					<option value="@DirectoryOrder.New">@Localizer["Newcomers"]</option>
+				</DSelect>
+				<label class="label text-sm">
+					<input type="checkbox" class="checkbox checkbox-sm" checked="@localOnly" @onchange="ToggleLocal" />
+					<span>@Localizer["Only this server"]</span>
+				</label>
+			</div>
+			@if (people.Count == 0)
+			{
+				<p class="w-full text-center" data-feed-empty><i class="ion-ios-remove-circle-outline"></i> @Localizer["Empty"]</p>
+			}
+			<div class="flex flex-col gap-2">
+				@foreach (var account in people)
+				{
+					<a class="flex items-center gap-3 p-3 rounded-xl neo-raised neo-2xs min-w-0" href="@($"account/{Uri.EscapeDataString(account.Id)}")" data-account="@account.Id">
+						@* alt="": the name is next to it. *@
+						<img alt="" class="h-10 w-10 flex-none object-cover rounded-full" src="@(account.Avatar ?? "imgs/icon-192.png")" />
+						<span class="flex flex-col min-w-0">
+							<b class="truncate">@account.Name</b>
+							<span class="text-xs opacity-70 truncate">@("@" + account.Acct)</span>
+						</span>
+					</a>
+				}
+				@if (morePeople)
+				{
+					<DButton Size="DSize.Sm" class="self-center" Disabled="@(IsDefaultDisabled || isActing)" OnClick="LoadMorePeople">@Localizer["Load more"]</DButton>
+				}
+			</div>
+		}
+	</div>
+</section>
+
+@code {
+	ElementReference strip;
+	int revealed = -1;
+
+	protected override void OnAfterRender(bool firstRender)
+	{
+		if ((int)tab == revealed)
+			return;
+		revealed = (int)tab;
+		CascadingState.Status.RevealActive(strip);
+	}
+
+	enum ExploreTab
+	{
+		Hashtags,
+		Posts,
+		Links,
+		People,
+		Followed
+	}
+
+	[Inject] DiscoveryService DiscoveryService { get; set; }
+	[Inject] InstanceService InstanceService { get; set; }
+	[Inject] ILocalStorageService LocalStorage { get; set; }
+
+	ExploreTab tab = ExploreTab.Hashtags;
+	List<Tag> tags = [];
+	List<FeedPost> posts = [];
+	List<TrendLink> links = [];
+	List<Account> people = [];
+	DirectoryOrder order = DirectoryOrder.Active;
+	bool localOnly;
+	bool morePeople;
+	bool isActing;
+	string loadedPersonaId;
+
+	static int Bar(int uses, Tag tag) => tag.History.Max(h => h.UsesCount) is > 0 and var most ? Math.Max(8, uses * 100 / most) : 8;
+
+	// The persona changed (NavMenu's switcher): what it follows is another persona's.
+	protected override async Task OnParametersSetAsync()
+	{
+		if (CascadingState.PersonaId is null)
+		{
+			IsLoading = false;
+			return;
+		}
+		if (CascadingState.PersonaId == loadedPersonaId)
+			return;
+		loadedPersonaId = CascadingState.PersonaId;
+
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+	}
+
+	async Task LoadData()
+	{
+		IsLoading = true;
+		switch (tab)
+		{
+			case ExploreTab.Hashtags:
+				tags = await DiscoveryService.TrendingTags();
+				break;
+			case ExploreTab.Followed:
+				tags = await DiscoveryService.FollowedTags();
+				break;
+			case ExploreTab.Posts:
+				posts = [.. (await DiscoveryService.TrendingStatuses()).Select(FeedPost.Of)];
+				await InstanceService.Resolve(posts.Select(p => p.Host).Append(InstanceService.SelfHost));
+				InstanceService.Locate(posts);
+				break;
+			case ExploreTab.Links:
+				links = await DiscoveryService.TrendingLinks();
+				break;
+			default:
+				people = await DiscoveryService.Directory(order, localOnly, 0);
+				morePeople = people.Count == DiscoveryService.DirectoryPage;
+				break;
+		}
+		IsLoading = false;
+	}
+
+	async Task SelectTab(int index)
+	{
+		tab = (ExploreTab)index;
+		await LoadData();
+	}
+
+	async Task ChangeOrder(DirectoryOrder value)
+	{
+		order = value;
+		await LoadData();
+	}
+
+	async Task ToggleLocal(ChangeEventArgs e)
+	{
+		localOnly = e.Value is true;
+		await LoadData();
+	}
+
+	async Task LoadMorePeople()
+	{
+		isActing = true;
+		var known = people.Select(a => a.Id).ToHashSet();
+		var page = await DiscoveryService.Directory(order, localOnly, people.Count);
+		isActing = false;
+		people.AddRange(page.Where(a => known.Add(a.Id)));
+		morePeople = page.Count == DiscoveryService.DirectoryPage;
+	}
+
+	async Task ToggleFollow(Tag item)
+	{
+		isActing = true;
+		var result = await DiscoveryService.FollowTag(item.Name, item.Following != true);
+		isActing = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		item.Following = ((Tag)result.Data).Following;
+		if (tab is ExploreTab.Followed && item.Following != true)
+			tags.Remove(item);
+		Toast.AddResponseSuccess(item.Following == true ? Localizer["Following #{0}: its public posts come home.", item.Name] : Localizer["No longer following #{0}.", item.Name]);
+	}
+
+	async Task OpenTag(string tagName)
+	{
+		var filter = await LocalStorage.GetItemAsync<FeedFilter>(nameof(FeedFilter)) ?? new();
+		filter.Tag = tagName;
+		filter.TimelineType = TimelineType.Tag;
+		await LocalStorage.SetItemAsync(nameof(FeedFilter), filter);
+		Navigation.NavigateTo("");
+	}
+}

Pages/FilteredNotifications.razor

@@ -0,0 +1,20 @@
+@page "/notifications/filtered"
+@attribute [Authorize]
+@inherits LocalizableComponentBase
+<Title>@Localizer["Filtered notifications"]</Title>
+
+@* The persona's notification policy and the requests it filtered, as in Settings; the Notifications tab links here when
+   requests are waiting. *@
+<section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
+	<div class="flex flex-col gap-4 p-4 md:p-5 w-full h-full absolute overflow-y-auto">
+		<div class="flex items-center gap-2">
+			<i class="ion-md-notifications-off text-lg"></i>
+			<h1 class="font-bold truncate">@Localizer["Filtered notifications"]</h1>
+		</div>
+		<NotificationPolicyEditor />
+	</div>
+</section>
+
+@code {
+	protected override void OnInitialized() => IsLoading = false;
+}

Pages/Filters.razor

@@ -0,0 +1,399 @@
+@page "/filters"
+@attribute [Authorize]
+@inherits LocalizableComponentBase
+<Title>@Localizer["Filters"]</Title>
+
+@* The current persona's filters (/api/v2/filters): words, phrases and posts it would rather not see, where (home and
+   lists, notifications, the public feeds, threads, profiles), how (folded behind the filter's title, left out, or with
+   media blurred) and until when. PrivaPub marks every post with the filters it matches; the cards apply them
+   (Content.FilterIn). Filters are the persona's own and never leave PrivaPub. *@
+<section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
+	<div class="flex flex-col gap-4 p-4 md:p-5 w-full h-full absolute overflow-y-auto">
+
+		<div class="flex items-center gap-2">
+			<i class="ion-md-funnel text-lg"></i>
+			<h1 class="font-bold truncate">@Localizer["Filters"]</h1>
+		</div>
+
+		<EditForm Model="draft" OnValidSubmit="Create" class="flex flex-wrap gap-2 items-center">
+			<DInput TValue="string" class="flex-1 min-w-48" @bind-Value="draft.Title" Immediate="true" autocomplete="off" maxlength="200"
+					placeholder="@Localizer["A new filter's title"]" data-filter-new>
+				<Prefix><i class="ion-md-add"></i></Prefix>
+			</DInput>
+			<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || isSaving || string.IsNullOrWhiteSpace(draft.Title))">
+				<span>@Localizer["Make a filter"]</span>
+			</DButton>
+		</EditForm>
+
+		@if (IsLoading)
+		{
+			<p class="flex w-full items-center justify-center gap-2">
+				<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+				@Localizer["loading"]
+			</p>
+		}
+		else if (filters.Count == 0)
+		{
+			<p class="w-full text-center" data-feed-empty><i class="ion-ios-remove-circle-outline"></i> @Localizer["This persona has no filter yet."]</p>
+		}
+
+		<div class="flex flex-col gap-3">
+			@foreach (var filter in filters)
+			{
+				<article class="flex flex-col gap-3 p-3 md:p-4 rounded-xl neo-raised neo-xs" data-filter-id="@filter.Id">
+					<div class="flex flex-wrap items-center gap-2">
+						<b class="flex-1 min-w-0 truncate">@filter.Title</b>
+						<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft">@ActionName(filter.FilterAction)</DBadge>
+						@if (!filter.IsActive)
+						{
+							<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft" Color="DColor.Warning">@Localizer["Expired"]</DBadge>
+						}
+						else if (filter.ExpiresAt is { } expires)
+						{
+							<span class="text-xs opacity-70" title="@NerdRow.Time(expires)">@Localizer["until {0}", expires.ToLocalTime().ToString(SUtility.dateTimeFormatExt)]</span>
+						}
+						<span class="text-xs opacity-70 tabular-nums">@Localizer["{0} words, {1} posts", filter.Keywords.Count, filter.Statuses.Count]</span>
+						<DButton Size="DSize.Sm" Active="@(open?.Id == filter.Id)" OnClick="@(() => Toggle(filter))" title="@Localizer["Edit"]">
+							<i class="ion-md-create"></i><span class="hidden sm:inline">@Localizer["Edit"]</span>
+						</DButton>
+					</div>
+
+					@if (open?.Id == filter.Id)
+					{
+						<EditForm Model="edit" OnValidSubmit="Save" class="flex flex-col gap-3">
+							<DInput TValue="string" class="w-full" @bind-Value="edit.Title" Immediate="true" autocomplete="off" maxlength="200"
+									aria-label="@Localizer["Title"]" data-filter-title />
+
+							<fieldset class="flex flex-wrap gap-x-4 gap-y-2">
+								<legend class="text-sm font-semibold pb-1">@Localizer["Where"]</legend>
+								@foreach (var context in Contexts)
+								{
+									<label class="label text-sm">
+										<input type="checkbox" class="checkbox checkbox-sm" checked="@edit.Contexts.Contains(context)"
+											   @onchange="@((ChangeEventArgs e) => ToggleContext(context, e.Value is true))" />
+										<span>@ContextName(context)</span>
+									</label>
+								}
+							</fieldset>
+
+							<div class="flex flex-wrap gap-2 items-center">
+								<DSelect TValue="FilterAction" Size="DSize.Sm" class="w-full sm:w-auto" @bind-Value="edit.Action" aria-label="@Localizer["How"]">
+									<Prefix><i class="ion-md-funnel"></i></Prefix>
+									<ChildContent>
+										@foreach (var action in Actions)
+										{
+											<option value="@action">@ActionText(action)</option>
+										}
+									</ChildContent>
+								</DSelect>
+								<DSelect TValue="int" Size="DSize.Sm" class="w-full sm:w-auto" @bind-Value="edit.ExpiresIn" aria-label="@Localizer["Expires"]">
+									<Prefix><i class="ion-md-time"></i></Prefix>
+									<ChildContent>
+										@foreach (var (seconds, label) in Expiries)
+										{
+											<option value="@seconds">@label</option>
+										}
+									</ChildContent>
+								</DSelect>
+							</div>
+
+							<h2 class="font-semibold text-sm">@Localizer["Words"]</h2>
+							<div class="flex flex-col gap-2" data-filter-keywords>
+								@foreach (var row in edit.Keywords.Where(k => !k.Removed))
+								{
+									<div class="flex flex-wrap items-center gap-2" data-keyword="@row.Keyword">
+										<span class="flex-1 min-w-0 break-words text-sm">@row.Keyword</span>
+										<label class="label text-xs">
+											<input type="checkbox" class="checkbox checkbox-xs" checked="@row.WholeWord" @onchange="@((ChangeEventArgs e) => row.WholeWord = e.Value is true)" />
+											<span>@Localizer["Whole word"]</span>
+										</label>
+										<DButton Size="DSize.Xs" OnClick="@(() => RemoveKeyword(row))" title="@Localizer["Remove"]">
+											<i class="ion-md-close"></i><span class="hidden sm:inline">@Localizer["Remove"]</span>
+										</DButton>
+									</div>
+								}
+								<div class="flex flex-wrap gap-2 items-center">
+									<DInput TValue="string" class="flex-1 min-w-48" @bind-Value="edit.NewKeyword" Immediate="true" autocomplete="off" maxlength="100"
+											placeholder="@Localizer["A word or a phrase"]" data-filter-keyword-new />
+									<DButton Size="DSize.Sm" Disabled="@(string.IsNullOrWhiteSpace(edit.NewKeyword))" OnClick="AddKeyword">
+										<i class="ion-md-add"></i><span>@Localizer["Add"]</span>
+									</DButton>
+								</div>
+							</div>
+
+							@if (filter.Statuses.Count > 0)
+							{
+								<h2 class="font-semibold text-sm">@Localizer["Posts filtered one by one"]</h2>
+								<div class="flex flex-col gap-1">
+									@foreach (var item in filter.Statuses)
+									{
+										<div class="flex items-center gap-2 text-sm">
+											<a class="link flex-1 min-w-0 truncate" href="@($"expand/{Uri.EscapeDataString(item.StatusId)}")">@item.StatusId</a>
+											<DButton Size="DSize.Xs" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="@(() => RemoveStatus(filter, item))">
+												<i class="ion-md-close"></i><span class="hidden sm:inline">@Localizer["Remove"]</span>
+											</DButton>
+										</div>
+									}
+								</div>
+							}
+
+							<div class="flex flex-wrap gap-2">
+								<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary"
+										 Disabled="@(IsDefaultDisabled || isSaving || string.IsNullOrWhiteSpace(edit.Title) || edit.Contexts.Count == 0)">
+									<i class="ion-md-checkmark"></i><span>@Localizer["Save"]</span>
+								</DButton>
+								@if (isConfirmingDelete)
+								{
+									<DButton Size="DSize.Sm" Color="DColor.Error" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="Delete">
+										<i class="ion-md-trash"></i><span>@Localizer["Delete it for good"]</span>
+									</DButton>
+									<DButton Size="DSize.Sm" OnClick="() => isConfirmingDelete = false">@Localizer["Cancel"]</DButton>
+								}
+								else
+								{
+									<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="() => isConfirmingDelete = true">
+										<i class="ion-md-trash text-error"></i><span>@Localizer["Delete"]</span>
+									</DButton>
+								}
+							</div>
+						</EditForm>
+					}
+				</article>
+			}
+		</div>
+	</div>
+</section>
+
+@code {
+	const int KeepExpiry = -1;
+	static readonly FilterContext[] Contexts = [FilterContext.Home, FilterContext.Notifications, FilterContext.Public, FilterContext.Thread, FilterContext.Account];
+	static readonly FilterAction[] Actions = [FilterAction.Warn, FilterAction.Hide, FilterAction.Blur];
+
+	[Inject] FilterService FilterService { get; set; }
+
+	List<Filter> filters = [];
+	TitleForm draft = new();
+	FilterEdit edit = new();
+	Filter open;
+	string loadedPersonaId;
+	bool isSaving;
+	bool isConfirmingDelete;
+
+	(int Seconds, string Label)[] Expiries =>
+	[
+		(KeepExpiry, Localizer["Keep its expiry"]),
+		(0, Localizer["Never expires"]),
+		(1800, Localizer["Expires in 30 minutes"]),
+		(3600, Localizer["Expires in 1 hour"]),
+		(43200, Localizer["Expires in 12 hours"]),
+		(86400, Localizer["Expires in 1 day"]),
+		(604800, Localizer["Expires in 1 week"])
+	];
+
+	string ContextName(FilterContext context) => context switch
+	{
+		FilterContext.Home => Localizer["Home and lists"],
+		FilterContext.Notifications => Localizer["Notifications"],
+		FilterContext.Public => Localizer["Public feeds"],
+		FilterContext.Thread => Localizer["Threads"],
+		_ => Localizer["Profiles"]
+	};
+
+	string ActionName(FilterAction action) => action switch
+	{
+		FilterAction.Hide => Localizer["Hide"],
+		FilterAction.Blur => Localizer["Blur"],
+		_ => Localizer["Warn"]
+	};
+
+	string ActionText(FilterAction action) => action switch
+	{
+		FilterAction.Hide => Localizer["Leave the post out"],
+		FilterAction.Blur => Localizer["Blur its media"],
+		_ => Localizer["Fold the post behind the filter's title"]
+	};
+
+	// The persona changed (NavMenu's switcher): its filters are another persona's.
+	protected override async Task OnParametersSetAsync()
+	{
+		if (CascadingState.PersonaId is null)
+		{
+			IsLoading = false;
+			return;
+		}
+		if (CascadingState.PersonaId == loadedPersonaId)
+			return;
+		loadedPersonaId = CascadingState.PersonaId;
+
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+	}
+
+	async Task LoadData()
+	{
+		IsLoading = true;
+		open = null;
+		filters = await FilterService.All();
+		IsLoading = false;
+	}
+
+	// a new filter applies everywhere and warns until it is told otherwise
+	async Task Create()
+	{
+		isSaving = true;
+		var result = await FilterService.Save(null, new FilterForm { Title = draft.Title.Trim(), Context = [.. Contexts], FilterAction = FilterAction.Warn });
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		var filter = (Filter)result.Data;
+		filters.Add(filter);
+		draft = new();
+		Toast.AddResponseSuccess(Localizer["Filter {0} made.", filter.Title]);
+		Toggle(filter);
+	}
+
+	void Toggle(Filter filter)
+	{
+		isConfirmingDelete = false;
+		if (open?.Id == filter.Id)
+		{
+			open = null;
+			return;
+		}
+
+		open = filter;
+		edit = new FilterEdit
+		{
+			Title = filter.Title,
+			Contexts = [.. filter.Context],
+			Action = filter.FilterAction,
+			ExpiresIn = KeepExpiry,
+			Keywords = [.. filter.Keywords.Select(k => new KeywordRow { Id = k.Id, Keyword = k.Keyword, WholeWord = k.WholeWord, WasWholeWord = k.WholeWord })]
+		};
+	}
+
+	void ToggleContext(FilterContext context, bool on)
+	{
+		if (on)
+			edit.Contexts.Add(context);
+		else
+			edit.Contexts.Remove(context);
+	}
+
+	void AddKeyword()
+	{
+		var keyword = edit.NewKeyword?.Trim();
+		if (string.IsNullOrEmpty(keyword) || edit.Keywords.Any(k => !k.Removed && string.Equals(k.Keyword, keyword, StringComparison.OrdinalIgnoreCase)))
+			return;
+		edit.Keywords.Add(new KeywordRow { Keyword = keyword, WholeWord = true });
+		edit.NewKeyword = null;
+	}
+
+	void RemoveKeyword(KeywordRow row)
+	{
+		if (row.Id is null)
+			edit.Keywords.Remove(row);
+		else
+			row.Removed = true;
+	}
+
+	async Task Save()
+	{
+		AddKeyword();
+		var form = new FilterForm
+		{
+			Title = edit.Title.Trim(),
+			Context = [.. Contexts.Where(edit.Contexts.Contains)],
+			FilterAction = edit.Action,
+			ExpiresIn = edit.ExpiresIn == KeepExpiry ? null : edit.ExpiresIn,
+			KeywordsAttributes =
+			[
+				.. edit.Keywords.Where(k => k.Id is not null && k.Removed).Select(k => new FilterKeywordForm { Id = k.Id, Destroy = true }),
+				.. edit.Keywords.Where(k => k.Id is not null && !k.Removed && k.WholeWord != k.WasWholeWord)
+					.Select(k => new FilterKeywordForm { Id = k.Id, Keyword = k.Keyword, WholeWord = k.WholeWord }),
+				.. edit.Keywords.Where(k => k.Id is null).Select(k => new FilterKeywordForm { Keyword = k.Keyword, WholeWord = k.WholeWord })
+			]
+		};
+		isSaving = true;
+		var result = await FilterService.Save(open.Id, form);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		var saved = (Filter)result.Data;
+		var index = filters.FindIndex(f => f.Id == saved.Id);
+		if (index >= 0)
+			filters[index] = saved;
+		open = null;
+		Toast.AddResponseSuccess(Localizer["Filter {0} saved.", saved.Title]);
+	}
+
+	async Task Delete()
+	{
+		isSaving = true;
+		var result = await FilterService.Delete(open.Id);
+		isSaving = false;
+		isConfirmingDelete = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		filters.RemoveAll(f => f.Id == open.Id);
+		Toast.AddResponseSuccess(Localizer["Filter {0} deleted.", open.Title]);
+		open = null;
+	}
+
+	async Task RemoveStatus(Filter filter, FilterStatus item)
+	{
+		isSaving = true;
+		var result = await FilterService.RemoveStatus(item.Id);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		filter.Statuses.Remove(item);
+	}
+
+	sealed class TitleForm
+	{
+		public string Title { get; set; }
+	}
+
+	sealed class FilterEdit
+	{
+		public string Title { get; set; }
+		public HashSet<FilterContext> Contexts { get; set; } = [];
+		public FilterAction Action { get; set; } = FilterAction.Warn;
+		public int ExpiresIn { get; set; } = KeepExpiry;
+		public List<KeywordRow> Keywords { get; set; } = [];
+		public string NewKeyword { get; set; }
+	}
+
+	sealed class KeywordRow
+	{
+		public string Id { get; set; }
+		public string Keyword { get; set; }
+		public bool WholeWord { get; set; }
+		public bool WasWholeWord { get; set; }
+		public bool Removed { get; set; }
+	}
+}

Pages/Groups.razor

@@ -0,0 +1,375 @@
+@page "/groups"
+@attribute [Authorize]
+@inherits LocalizableComponentBase
+<Title>@Localizer["Groups"]</Title>
+
+@* The current persona's communities and circles (/clientapi/group): made, joined by invitation, and left; for the ones
+   it runs, edited, their invitation shown, the requests to join answered and members taken out. A circle's members are
+   never shown to anyone but its owner and moderators, here as on every server. *@
+<section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
+	<div class="flex flex-col gap-4 p-4 md:p-5 w-full h-full absolute overflow-y-auto">
+
+		<div class="flex items-center gap-2">
+			<i class="ion-md-people text-lg"></i>
+			<h1 class="font-bold truncate">@Localizer["Groups"]</h1>
+		</div>
+
+		<div class="grid grid-cols-1 lg:grid-cols-2 gap-3">
+			<EditForm Model="draft" OnValidSubmit="Create" class="flex flex-col gap-2 p-3 rounded-xl neo-raised neo-xs" data-group-new>
+				<DataAnnotationsValidator />
+				<b class="text-sm">@Localizer["A new group"]</b>
+				<div class="flex flex-wrap gap-2">
+					<DInput TValue="string" class="flex-1 min-w-40" @bind-Value="draft.UserName" Immediate="true" autocomplete="off" maxlength="32"
+							placeholder="@Localizer["user name (a-z, 0-9, _)"]" data-group-username>
+						<Prefix>@@</Prefix>
+					</DInput>
+					<DInput TValue="string" class="flex-1 min-w-40" @bind-Value="draft.Name" Immediate="true" autocomplete="off" maxlength="64"
+							placeholder="@Localizer["Name"]" data-group-name />
+				</div>
+				<DTextarea @bind-Value="draft.Description" Immediate="true" rows="2" autocomplete="off" maxlength="2000" placeholder="@Localizer["Description"]" />
+				<DToggle Size="DSize.Sm" @bind-Value="draft.IsCommunity" LabelText="@Localizer["A community, open to the fediverse (otherwise a private circle)"]" data-group-community />
+				@if (draft.IsCommunity)
+				{
+					<DSelect TValue="string" Size="DSize.Sm" @bind-Value="draft.PostingPolicy" aria-label="@Localizer["Who may post"]">
+						<Prefix><i class="ion-md-create"></i></Prefix>
+						<ChildContent>
+							@foreach (var policy in PostingPolicies)
+							{
+								<option value="@policy">@PolicyName(policy)</option>
+							}
+						</ChildContent>
+					</DSelect>
+					<DToggle Size="DSize.Sm" @bind-Value="draft.IsDiscoverable" LabelText="@Localizer["Listed and found in searches"]" />
+				}
+				<DToggle Size="DSize.Sm" @bind-Value="draft.ManuallyApprovesMembers" LabelText="@Localizer["Approve members from elsewhere by hand"]" />
+				<DInput TValue="string" type="password" @bind-Value="draft.InvitationPassword" Immediate="true" autocomplete="new-password" maxlength="128"
+						placeholder="@Localizer["Invitation password (optional)"]" />
+				<ErrorViewer />
+				<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary" class="self-end" Disabled="@(IsDefaultDisabled || isSaving)" data-group-create>
+					<i class="ion-md-add"></i><span>@Localizer["Make the group"]</span>
+				</DButton>
+			</EditForm>
+
+			<EditForm Model="joining" OnValidSubmit="Join" class="flex flex-col gap-2 p-3 rounded-xl neo-raised neo-xs" data-group-join>
+				<b class="text-sm">@Localizer["Join by invitation"]</b>
+				<DInput TValue="string" @bind-Value="joining.InvitationCode" Immediate="true" autocomplete="off" maxlength="64"
+						placeholder="@Localizer["Invitation code"]" data-group-code>
+					<Prefix><i class="ion-md-key"></i></Prefix>
+				</DInput>
+				<DInput TValue="string" type="password" @bind-Value="joining.InvitationPassword" Immediate="true" autocomplete="current-password" maxlength="128"
+						placeholder="@Localizer["Invitation password, if it has one"]" />
+				<DButton Type="submit" Size="DSize.Sm" class="self-end" Disabled="@(IsDefaultDisabled || isSaving || string.IsNullOrWhiteSpace(joining.InvitationCode))" data-group-join-submit>
+					<i class="ion-md-log-in"></i><span>@Localizer["Join"]</span>
+				</DButton>
+			</EditForm>
+		</div>
+
+		@if (IsLoading)
+		{
+			<p class="flex w-full items-center justify-center gap-2">
+				<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+				@Localizer["loading"]
+			</p>
+		}
+		else if (groups.Count == 0)
+		{
+			<p class="w-full text-center" data-feed-empty><i class="ion-ios-remove-circle-outline"></i> @Localizer["This persona is in no group yet."]</p>
+		}
+
+		<div class="flex flex-col gap-3">
+			@foreach (var group in groups)
+			{
+				<article class="flex flex-col gap-3 p-3 md:p-4 rounded-xl neo-raised neo-xs" data-group-id="@group.Id">
+					<div class="flex flex-wrap items-center gap-2">
+						<i class="@(group.IsCommunity ? "ion-md-globe" : "ion-md-lock") text-lg"></i>
+						<span class="flex flex-col min-w-0 flex-1">
+							<b class="truncate">@(group.Name ?? group.UserName)</b>
+							<span class="text-xs opacity-70 truncate">@("@" + group.Handle)</span>
+						</span>
+						<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft">@(group.IsCommunity ? Localizer["Community"] : Localizer["Circle"])</DBadge>
+						<span class="text-sm tabular-nums opacity-70" title="@Localizer["Members"]"><i class="ion-md-person"></i> @group.MembersCount</span>
+						@if (group.IsOwner)
+						{
+							<DButton Size="DSize.Sm" Active="@(open?.Id == group.Id)" OnClick="@(() => Toggle(group))" data-group-manage>
+								<i class="ion-md-settings"></i><span class="hidden sm:inline">@Localizer["Manage"]</span>
+							</DButton>
+						}
+						else
+						{
+							<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="@(() => Leave(group))" data-group-leave>
+								<i class="ion-md-exit"></i><span>@Localizer["Leave"]</span>
+							</DButton>
+						}
+					</div>
+
+					@if (open?.Id == group.Id)
+					{
+						@if (group.InvitationCode is { Length: > 0 } invitation)
+						{
+							<div class="flex flex-col gap-1 text-sm">
+								<span>@Localizer["Invitation code"]@(group.IsPasswordRequired ? " · " + Localizer["it asks for a password"] : null)</span>
+								<input class="input input-sm w-full font-mono text-xs" value="@invitation" readonly autocomplete="off" onfocus="this.select()"
+									   aria-label="@Localizer["Invitation code"]" data-group-invitation />
+								<span>@Localizer["Invitation link, for someone without a login here"]</span>
+								<input class="input input-sm w-full font-mono text-xs" value="@($"{Navigation.BaseUri}join?code={Uri.EscapeDataString(invitation)}")" readonly
+									   autocomplete="off" onfocus="this.select()" aria-label="@Localizer["Invitation link, for someone without a login here"]" data-group-invitation-link />
+							</div>
+						}
+
+						<EditForm Model="edit" OnValidSubmit="Save" class="flex flex-col gap-2">
+							<DInput TValue="string" @bind-Value="edit.Name" Immediate="true" autocomplete="off" maxlength="64" aria-label="@Localizer["Name"]" />
+							<DTextarea @bind-Value="edit.Description" Immediate="true" rows="2" autocomplete="off" maxlength="2000" aria-label="@Localizer["Description"]" />
+							@if (group.IsCommunity)
+							{
+								<DSelect TValue="string" Size="DSize.Sm" @bind-Value="edit.PostingPolicy" aria-label="@Localizer["Who may post"]">
+									<Prefix><i class="ion-md-create"></i></Prefix>
+									<ChildContent>
+										@foreach (var policy in PostingPolicies)
+										{
+											<option value="@policy">@PolicyName(policy)</option>
+										}
+									</ChildContent>
+								</DSelect>
+								<DToggle Size="DSize.Sm" @bind-Value="editDiscoverable" LabelText="@Localizer["Listed and found in searches"]" />
+							}
+							<DToggle Size="DSize.Sm" @bind-Value="editApproves" LabelText="@Localizer["Approve members from elsewhere by hand"]" />
+							<DInput TValue="string" type="password" @bind-Value="edit.InvitationPassword" Immediate="true" autocomplete="new-password" maxlength="128"
+									placeholder="@Localizer["A new invitation password"]" />
+							@if (group.IsPasswordRequired)
+							{
+								<DToggle Size="DSize.Sm" @bind-Value="edit.RemoveInvitationPassword" LabelText="@Localizer["Remove the invitation password"]" />
+							}
+							<DToggle Size="DSize.Sm" @bind-Value="edit.RegenerateInvitationCode" LabelText="@Localizer["A new invitation code (the old one stops working)"]" />
+							<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary" class="self-end" Disabled="@(IsDefaultDisabled || isSaving)" data-group-save>
+								<i class="ion-md-checkmark"></i><span>@Localizer["Save"]</span>
+							</DButton>
+						</EditForm>
+
+						<h2 class="font-semibold text-sm">@Localizer["Members"] <span class="opacity-60 tabular-nums">@members.Count(m => !m.IsPending)</span></h2>
+						<div class="flex flex-col gap-2" data-group-members>
+							@foreach (var member in members.OrderBy(m => m.IsPending ? 0 : 1).ThenBy(m => m.Since))
+							{
+								<div class="flex flex-wrap items-center gap-3 min-w-0" data-member="@member.ActorUri" data-pending="@(member.IsPending ? "true" : "false")">
+									@* alt="": the name is next to it. *@
+									<img alt="" class="h-8 w-8 flex-none object-cover rounded-full" src="@(member.PictureUrl ?? "imgs/icon-192.png")" />
+									<span class="flex flex-col min-w-0 flex-1">
+										<b class="truncate text-sm">@(member.Name ?? member.Handle)</b>
+										<span class="text-xs opacity-70 truncate">@("@" + member.Handle)</span>
+									</span>
+									@if (member.IsPending)
+									{
+										<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft" Color="DColor.Warning">@Localizer["asks to join"]</DBadge>
+										<DButton Size="DSize.Xs" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="@(() => Answer(member, true))" data-member-approve>
+											<i class="ion-md-checkmark"></i><span>@Localizer["Let in"]</span>
+										</DButton>
+										<DButton Size="DSize.Xs" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="@(() => Answer(member, false))" data-member-reject>
+											<i class="ion-md-close"></i><span>@Localizer["Decline"]</span>
+										</DButton>
+									}
+									else if (member.Role == "owner")
+									{
+										<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft" Color="DColor.Primary">@Localizer["owner"]</DBadge>
+									}
+									else
+									{
+										<DButton Size="DSize.Xs" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="@(() => Remove(member))" title="@Localizer["Take out of the group"]" data-member-remove>
+											<i class="ion-md-remove-circle"></i><span class="hidden sm:inline">@Localizer["Take out"]</span>
+										</DButton>
+									}
+								</div>
+							}
+						</div>
+					}
+				</article>
+			}
+		</div>
+	</div>
+</section>
+
+@code {
+	static readonly string[] PostingPolicies = ["followers", "anyone", "moderators"];
+
+	[Inject] GroupService GroupService { get; set; }
+	[Inject] ConfirmService Confirm { get; set; }
+
+	List<ViewGroup> groups = [];
+	List<ViewGroupMember> members = [];
+	InsertGroupForm draft = new() { PostingPolicy = "followers" };
+	JoinGroupForm joining = new();
+	UpdateGroupForm edit = new();
+	bool editDiscoverable;
+	bool editApproves;
+	ViewGroup open;
+	string loadedPersonaId;
+	bool isSaving;
+
+	string PolicyName(string policy) => policy switch
+	{
+		"anyone" => Localizer["Anyone may post"],
+		"moderators" => Localizer["Only its moderators post"],
+		_ => Localizer["Its followers post"]
+	};
+
+	// The persona changed (NavMenu's switcher): its groups are another persona's.
+	protected override async Task OnParametersSetAsync()
+	{
+		if (CascadingState.PersonaId is null)
+		{
+			IsLoading = false;
+			return;
+		}
+		if (CascadingState.PersonaId == loadedPersonaId)
+			return;
+		loadedPersonaId = CascadingState.PersonaId;
+
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+	}
+
+	async Task LoadData()
+	{
+		IsLoading = true;
+		open = null;
+		members = [];
+		// (the forms are the persona's: validated as they are filled, so they name it from the start)
+		draft.AvatarId = CascadingState.PersonaId;
+		joining.AvatarId = CascadingState.PersonaId;
+		groups = await GroupService.List(CascadingState.PersonaId);
+		IsLoading = false;
+	}
+
+	async Task Create()
+	{
+		if (!draft.IsCommunity)
+			draft.IsDiscoverable = false;
+		isSaving = true;
+		var result = await GroupService.Insert(draft);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		var group = (ViewGroup)result.Data;
+		draft = new() { AvatarId = CascadingState.PersonaId, PostingPolicy = "followers" };
+		Toast.AddResponseSuccess(Localizer["{0} made.", group.Name ?? group.UserName]);
+		await LoadData();
+		if (groups.FirstOrDefault(g => g.Id == group.Id) is { } made)
+			await Toggle(made);
+	}
+
+	async Task Join()
+	{
+		isSaving = true;
+		var result = await GroupService.Join(joining);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		var group = (ViewGroup)result.Data;
+		joining = new() { AvatarId = CascadingState.PersonaId };
+		Toast.AddResponseSuccess(Localizer["You joined {0}.", group.Name ?? group.UserName]);
+		await LoadData();
+	}
+
+	async Task Leave(ViewGroup group)
+	{
+		if (!await Confirm.Ask(Localizer["Leave {0}?", group.Name ?? group.UserName], null, Localizer["Leave"], true))
+			return;
+		isSaving = true;
+		var result = await GroupService.Leave(CascadingState.PersonaId, group.Id);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		groups.Remove(group);
+		Toast.AddResponseSuccess(Localizer["You left {0}.", group.Name ?? group.UserName]);
+	}
+
+	async Task Toggle(ViewGroup group)
+	{
+		if (open?.Id == group.Id)
+		{
+			open = null;
+			members = [];
+			return;
+		}
+
+		open = group;
+		edit = new UpdateGroupForm { AvatarId = CascadingState.PersonaId, GroupId = group.Id, Name = group.Name, Description = group.Description, PostingPolicy = group.PostingPolicy };
+		editDiscoverable = group.IsDiscoverable;
+		editApproves = group.ManuallyApprovesMembers;
+		members = await GroupService.Members(CascadingState.PersonaId, group.Id);
+	}
+
+	async Task Save()
+	{
+		edit.IsDiscoverable = open.IsCommunity ? editDiscoverable : null;
+		edit.ManuallyApprovesMembers = editApproves;
+		if (string.IsNullOrEmpty(edit.InvitationPassword))
+			edit.InvitationPassword = null;
+		isSaving = true;
+		var result = await GroupService.Update(edit);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		var updated = (ViewGroup)result.Data;
+		var index = groups.FindIndex(g => g.Id == updated.Id);
+		if (index >= 0)
+			groups[index] = updated;
+		open = updated;
+		edit.InvitationPassword = null;
+		edit.RemoveInvitationPassword = false;
+		edit.RegenerateInvitationCode = false;
+		Toast.AddResponseSuccess(Localizer["Saved."]);
+	}
+
+	async Task Answer(ViewGroupMember member, bool approve)
+	{
+		isSaving = true;
+		var result = approve
+			? await GroupService.Approve(CascadingState.PersonaId, open.Id, member.ActorUri)
+			: await GroupService.Reject(CascadingState.PersonaId, open.Id, member.ActorUri);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		members = await GroupService.Members(CascadingState.PersonaId, open.Id);
+	}
+
+	async Task Remove(ViewGroupMember member)
+	{
+		isSaving = true;
+		var result = await GroupService.Remove(CascadingState.PersonaId, open.Id, member.ActorUri);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		members.Remove(member);
+		Toast.AddResponseSuccess(Localizer["{0} is out of the group.", member.Name ?? member.Handle]);
+	}
+}

Pages/Index.razor

@@ -7,27 +7,46 @@
 
 @* The feed page, the middle and right of three columns (NavMenu is the left): the feed with a tab per kind of feed,
    and the globe, which follows the posts in view (GlobePanel). Below lg the globe is a banner above the feed, closed by
-   default on phones. Pages of older posts load as the end comes near (wwwroot/js/feed.js); newer ones are polled every
-   45 seconds while the page is visible and shown on request, because PrivaPub has no streaming. *@
+   default on phones. Pages of older posts load as the end comes near (wwwroot/js/feed.js). Newer ones come through
+   PrivaPub's streaming API (StreamingService) for the feeds it streams, and are polled every 45 seconds while the page
+   is visible otherwise, or while the stream is down; either way they wait behind the "new" button. A deletion or an edit
+   the stream tells is applied at once. *@
 <div class="flex flex-col lg:grid lg:grid-cols-[minmax(0,1fr)_minmax(320px,42%)] gap-3 md:gap-4 w-full h-full">
 
-	<aside class="@(Filter.ShowGlobe ? "block" : "hidden") lg:block lg:order-last relative h-56 sm:h-64 lg:h-full flex-none min-h-0 rounded-xl neo-raised neo-xs overflow-hidden">
-		<GlobePanel @ref="globe" ScrollContainerId="@ScrollId" Posts="posts" />
+	@* full screen over everything once a phone's banner is tapped; the feed underneath stays as it was, out of reach *@
+	<aside class="@GlobeClass" role="@(globeExpanded ? "dialog" : null)" aria-modal="@(globeExpanded ? "true" : null)"
+		   aria-label="@(globeExpanded ? Localizer["Globe"] : null)">
+		<GlobePanel @ref="globe" ScrollContainerId="@ScrollId" Posts="posts" @bind-Expanded="globeExpanded" />
 	</aside>
 
-	<section class="flex flex-col gap-3 min-h-0 flex-1 lg:h-full">
-		<FeedTabs Filter="Filter" Groups="groups" Stats="FeedStats()" IsComposing="isComposing" OnCompose="() => isComposing = !isComposing"
+	<section class="flex flex-col gap-3 min-h-0 flex-1 lg:h-full" inert="@globeExpanded">
+		@if (!isComposing)
+		{
+			@* on a phone a new post starts from a button under the thumb; from md, from the feed's tabs *@
+			<DButton Shape="DButtonShape.Circle" Size="DSize.Lg" Color="DColor.Primary" OnClick="ToggleCompose"
+					 class="md:hidden fixed right-4 bottom-[max(1rem,env(safe-area-inset-bottom))] z-30" aria-label="@Localizer["New post"]"
+					 title="@Localizer["New post"]" data-compose-open>
+				<i class="ion-md-create text-xl" aria-hidden="true"></i>
+			</DButton>
+		}
+		<FeedTabs Filter="Filter" Groups="groups" Lists="lists" UnreadNotifications="unreadNotifications" UnreadConversations="unreadConversations" Stats="FeedStats()" IsComposing="isComposing" OnCompose="ToggleCompose" OnGlobeFull="() => globeExpanded = true"
 				  OnChanged="ChangeFeed" />
 
 		<div class="relative flex-1 min-h-0 neo-inset neo-xs rounded-xl">
-			<div id="@ScrollId" class="absolute inset-0 overflow-y-auto p-3 md:p-4">
-				<div class="flex flex-col gap-4">
+			@* (on a phone the bottom stays clear of the New post button) *@
+			<div id="@ScrollId" class="absolute inset-0 overflow-y-auto p-3 max-md:pb-24 md:p-4">
+				<div class="flex flex-col gap-4" data-feed-count="@posts.Count">
 
-					@if (isComposing)
-					{
-						<div class="p-3 md:p-4 rounded-xl neo-raised neo-xs">
+					<PhoneSheet IsOpen="isComposing" OnClose="() => isComposing = false" Heading="@Localizer["New post"]" Class="md:p-4 md:rounded-xl md:neo-raised md:neo-xs">
 						<Composer GroupId="@(Filter.TimelineType is TimelineType.Groups ? Filter.GroupId : null)" OnPublished="Published" />
-						</div>
+					</PhoneSheet>
+
+					@if (Filter.TimelineType is TimelineType.Notifications && filteredRequests > 0)
+					{
+						<a class="btn btn-sm self-center" href="notifications/filtered" data-filtered-requests>
+							<i class="ion-md-notifications-off"></i>
+							<span>@Localizer["{0} filtered, waiting for you", filteredRequests]</span>
+						</a>
 					}
 
 					@if (pending.Count > 0)
@@ -67,15 +86,15 @@
 					}
 					else if (posts.Count == 0)
 					{
-						<p class="w-full text-center text-lg">
+						<p class="w-full text-center text-lg" data-feed-empty>
 							<i class="ion-ios-remove-circle-outline"></i> @Localizer["Empty"]
 						</p>
 					}
 
-					@foreach (var post in posts)
-					{
-						<Content @key="post.Key" Post="post" OnDeleted="Remove" OnReplied="Replied" OnTag="OpenTag" />
-					}
+					@* only the cards near the view are rendered: a feed of thousands stays as light as one of forty *@
+					<Virtualize Items="posts" Context="post" ItemSize="320" OverscanCount="8">
+						<Content @key="post.Key" Post="post" FilterIn="FilterIn" OnDeleted="Remove" OnReplied="Replied" OnTag="OpenTag" />
+					</Virtualize>
 
 					<div id="@SentinelId" class="flex justify-center min-h-8 text-xs opacity-60">
 						@if (isLoadingMore)
@@ -103,24 +122,44 @@
 	[Inject] IJSRuntime JS { get; set; }
 	[Inject] TimelineService TimelineService { get; set; }
 	[Inject] GroupService GroupService { get; set; }
+	[Inject] ListService ListService { get; set; }
+	[Inject] StreamingService Streaming { get; set; }
 	[Inject] InstanceService InstanceService { get; set; }
 	[Inject] RequestStats RequestStats { get; set; }
+	[Inject] FeedMemory Memory { get; set; }
 
 	FeedFilter Filter { get; set; } = new();
 	List<FeedPost> posts = [];
 	List<FeedPost> pending = [];
 	List<ViewGroup> groups = [];
+	List<MastodonList> lists = [];
+	int unreadNotifications;
+	// the requests the persona's notification policy filtered, shown on the Notifications tab
+	int filteredRequests;
+	int unreadConversations;
 	string maxId;
 	string minId;
 	string loadError;
 	bool isLoadingMore;
 	bool isComposing;
+	bool globeExpanded;
+
+	// a phone's banner (none when the phone is held sideways: the feed would have no room), the column from lg, or
+	// full screen
+	string GlobeClass => globeExpanded
+		? "fixed inset-0 z-[70] block h-dvh w-full overflow-hidden bg-base-100"
+		: Filter.ShowGlobe
+			? "block max-lg:short:hidden lg:block lg:order-last relative h-56 sm:h-64 lg:h-full flex-none min-h-0 rounded-xl neo-raised neo-xs overflow-hidden"
+			: "hidden lg:block lg:order-last relative h-56 sm:h-64 lg:h-full flex-none min-h-0 rounded-xl neo-raised neo-xs overflow-hidden";
 	(double Latitude, double Longitude)? position;
 	string positionError;
 	string loadedPersonaId;
+	bool waitingForPersona;
 	FeedQuery lastQuery;
 	DateTime? lastPollAt;
 	TimeSpan? lastLoadTook;
+	// the scroll a recalled feed goes back to, once rendered
+	double? recalledScroll;
 
 	GlobePanel globe;
 	IJSObjectReference feedModule;
@@ -131,6 +170,7 @@
 
 	protected override async Task OnInitializedAsync()
 	{
+		Streaming.Received += OnStream;
 		Filter = await LocalStorage.GetItemAsync<FeedFilter>(nameof(FeedFilter)) ?? new() { ShowGlobe = !CascadingState.Status.IsMobileMedia() };
 		if (Filter.TimelineType is TimelineType.Tag && Filter.Tag is not { Length: > 0 })
 			Filter.TimelineType = TimelineType.Home;
@@ -143,20 +183,57 @@
 			return;
 		}
 
+		// (while the session is still being read the persona isn't known yet: the feed is loading, not empty)
 		if (CascadingState.PersonaId is null)
 		{
-			IsLoading = false;
+			waitingForPersona = !CascadingState.IsSessionLoaded;
+			IsLoading = waitingForPersona;
 			return;
 		}
 
+		if (await Recall())
+			return;
 		await Reload();
 	}
 
-	// The persona changed (NavMenu's switcher): everything on the page belongs to the old one.
+	/// <summary>Shows the feed again as the reader left it, when it is the same feed of the same persona and recent.</summary>
+	async Task<bool> Recall()
+	{
+		if (!Memory.Holds(CascadingState.PersonaId))
+			return false;
+		groups = Memory.Groups;
+		lists = Memory.Lists;
+		if (Query != Memory.Query)
+			return false;
+
+		loadCancellation = new();
+		posts = Memory.Posts;
+		pending = Memory.Pending;
+		minId = Memory.MinId;
+		maxId = Memory.MaxId;
+		recalledScroll = Memory.ScrollTop;
+		loadedPersonaId = CascadingState.PersonaId;
+		lastQuery = Query;
+		IsLoading = false;
+		Memory.Forget();
+		await Streaming.Follow(StreamOf(Filter), loadCancellation.Token);
+		await ReadNotifications(loadCancellation.Token);
+		return true;
+	}
+
+	// The persona is known (the session was read after the page opened) or changed (NavMenu's switcher): everything on the
+	// page belongs to it.
 	protected override async Task OnParametersSetAsync()
 	{
-		if (CascadingState.PersonaId is null || CascadingState.PersonaId == loadedPersonaId || IsLoading && loadedPersonaId is null)
+		if (waitingForPersona && CascadingState.IsSessionLoaded && CascadingState.PersonaId is null)
+		{
+			waitingForPersona = false;
+			IsLoading = false;
 			return;
+		}
+		if (CascadingState.PersonaId is null || CascadingState.PersonaId == loadedPersonaId || IsLoading && loadedPersonaId is null && !waitingForPersona)
+			return;
+		waitingForPersona = false;
 		await Reload();
 	}
 
@@ -168,13 +245,25 @@
 
 		reference = DotNetObjectReference.Create(this);
 		feedModule = await JS.InvokeAsync<IJSObjectReference>("import", "./js/feed.js");
+		if (recalledScroll is { } top)
+			await feedModule.InvokeVoidAsync("scrollToOffset", ScrollId, top);
 		await feedModule.InvokeVoidAsync("observeEnd", reference, SentinelId, ScrollId);
 		pollTimer = new(PollInterval);
 		_ = PollNewer(pageCancellation.Token);
 	}
 
+	/// <summary>Which of the persona's filters apply to this feed: home's for home and lists, public's for the shared
+	/// feeds, none for the persona's own collections (favourites, bookmarks) and conversations.</summary>
+	FilterContext? FilterIn => Filter.TimelineType switch
+	{
+		TimelineType.Home or TimelineType.Lists => FilterContext.Home,
+		TimelineType.Local or TimelineType.Federation or TimelineType.Tag or TimelineType.Nearby or TimelineType.Groups => FilterContext.Public,
+		TimelineType.Notifications => FilterContext.Notifications,
+		_ => null
+	};
+
 	FeedQuery Query => new(Filter.TimelineType, CascadingState.PersonaId, Filter.GroupId, groups.FirstOrDefault(g => g.Id == Filter.GroupId)?.IsCommunity == true,
-		Filter.Tag, position?.Latitude, position?.Longitude);
+		Filter.Tag, position?.Latitude, position?.Longitude, Filter.ListId);
 
 	/// <summary>Reads the first page of the current feed again, and the persona's groups.</summary>
 	async Task Reload()
@@ -193,11 +282,16 @@
 
 		if (CascadingState.PersonaId != loadedPersonaId)
 		{
+			// a stream is the persona's: another one opens its own
+			await Streaming.Stop();
 			groups = await GroupService.List(CascadingState.PersonaId, cancellationToken);
+			lists = await ListService.All(cancellationToken);
 			loadedPersonaId = CascadingState.PersonaId;
 		}
 		if (Filter.TimelineType is TimelineType.Groups && groups.All(g => g.Id != Filter.GroupId))
 			Filter.GroupId = groups.FirstOrDefault()?.Id;
+		if (Filter.TimelineType is TimelineType.Lists && lists.All(l => l.Id != Filter.ListId))
+			Filter.ListId = lists.FirstOrDefault()?.Id;
 		lastQuery = Query;
 		if (Filter.TimelineType is TimelineType.Nearby && position is null)
 		{
@@ -223,6 +317,8 @@
 		maxId = page.MaxId;
 		minId = page.MinId;
 		lastPollAt = DateTime.UtcNow;
+		await Streaming.Follow(StreamOf(Filter), cancellationToken);
+		await ReadNotifications(cancellationToken);
 		StateHasChanged();
 		await Locate(posts, cancellationToken);
 		if (feedModule is not null)
@@ -275,7 +371,14 @@
 		{
 			while (await pollTimer.WaitForNextTickAsync(cancellationToken))
 			{
-				if (IsLoading || CascadingState.IsOffline || minId is null || Filter.TimelineType is TimelineType.Nearby or TimelineType.Direct
+				// no stream tells of direct messages: their tab's badge is counted again on every tick
+				if (!IsLoading && CascadingState.IsOnline && Filter.TimelineType is not TimelineType.Direct
+					&& await TimelineService.UnreadConversations(cancellationToken) is var unread && unread != unreadConversations)
+				{
+					unreadConversations = unread;
+					await InvokeAsync(StateHasChanged);
+				}
+				if (IsLoading || CascadingState.IsOffline || minId is null || Streaming.IsOpen || Filter.TimelineType is TimelineType.Nearby
 					|| Filter.TimelineType is TimelineType.Groups && groups.FirstOrDefault(g => g.Id == Filter.GroupId)?.IsCommunity != true
 					|| !await feedModule.InvokeAsync<bool>("isVisible", cancellationToken))
 					continue;
@@ -287,9 +390,15 @@
 					continue;
 
 				var known = posts.Concat(pending).Select(p => p.Key).ToHashSet();
-				var newer = ((FeedPage)result.Data).Posts.Where(p => known.Add(p.Key)).ToList();
+				var page = ((FeedPage)result.Data).Posts;
+				// a conversation with a newer message is the same item, moved up with its new message
+				var newer = Filter.TimelineType is TimelineType.Direct
+					? page.Where(p => posts.Concat(pending).All(shown => shown.Key != p.Key || shown.CursorId != p.CursorId)).ToList()
+					: page.Where(p => known.Add(p.Key)).ToList();
 				if (newer.Count == 0)
 					continue;
+				posts.RemoveAll(p => newer.Any(n => n.Key == p.Key));
+				pending.RemoveAll(p => newer.Any(n => n.Key == p.Key));
 
 				pending.InsertRange(0, newer);
 				await InvokeAsync(StateHasChanged);
@@ -307,11 +416,93 @@
 		}
 	}
 
+	/// <summary>On the Notifications tab, what is shown is read (the marker moves to the newest); elsewhere the tab's badge
+	/// counts what is unread.</summary>
+	async Task ReadNotifications(CancellationToken cancellationToken)
+	{
+		unreadConversations = await TimelineService.UnreadConversations(cancellationToken);
+		if (Filter.TimelineType is not TimelineType.Notifications)
+		{
+			unreadNotifications = await TimelineService.UnreadNotifications(cancellationToken);
+			return;
+		}
+		var newest = posts.Concat(pending).Select(p => p.Notification?.Id).Where(id => id is not null).Max(StringComparer.Ordinal);
+		if (newest is not null)
+			await TimelineService.ReadNotificationsUpTo(newest, cancellationToken);
+		unreadNotifications = 0;
+		filteredRequests = (await TimelineService.NotificationPolicy(cancellationToken))?.Summary?.PendingRequestsCount ?? 0;
+	}
+
+	/// <summary>The stream that tells this feed's new posts, or null for a feed PrivaPub does not stream.</summary>
+	static StreamSubscription StreamOf(FeedFilter filter) => filter.TimelineType switch
+	{
+		TimelineType.Home => new("user"),
+		TimelineType.Local => new("public:local"),
+		TimelineType.Federation => new("public:remote"),
+		TimelineType.Notifications => new("user:notification"),
+		TimelineType.Tag when filter.Tag is { Length: > 0 } tag => new("hashtag", Tag: tag),
+		TimelineType.Lists when filter.ListId is { Length: > 0 } list => new("list", List: list),
+		_ => null
+	};
+
+	/// <summary>What the stream tells: a new post or notification waits behind the "new" button; a deletion or an edit is
+	/// applied where the post is.</summary>
+	async Task OnStream(StreamMessage message)
+	{
+		switch (message.Event)
+		{
+			case "update" when message.Status is { } status && Filter.TimelineType is not TimelineType.Notifications:
+				var post = FeedPost.Of(status);
+				if (posts.Concat(pending).Any(p => p.Key == post.Key))
+					return;
+				pending.Insert(0, post);
+				break;
+			case "notification" when message.Notification is { } notification && Filter.TimelineType is TimelineType.Notifications:
+				// a notification of a group already shown joins it, and the group waits on top as new
+				var key = notification.GroupKey ?? notification.Id;
+				var group = pending.FirstOrDefault(p => p.Key == key) ?? posts.FirstOrDefault(p => p.Key == key);
+				if (group is null)
+				{
+					pending.Insert(0, FeedPost.Of(notification));
+					break;
+				}
+				group.GroupCount++;
+				group.Notification = notification;
+				group.GroupAccounts = [.. group.GroupAccounts.Prepend(notification.Account).Where(a => a is not null).DistinctBy(a => a.Id).Take(8)];
+				if (posts.Remove(group))
+					pending.Insert(0, group);
+				break;
+			case "notification" when Filter.TimelineType is not TimelineType.Notifications:
+				unreadNotifications++;
+				break;
+			case "delete" when message.DeletedId is { } id:
+				posts.RemoveAll(p => p.Key == id || p.Status?.Id == id);
+				pending.RemoveAll(p => p.Key == id || p.Status?.Id == id);
+				break;
+			case "status.update" when message.Status is { } edited:
+				foreach (var shown in posts.Concat(pending).Where(p => p.Status?.Id == edited.Id))
+					shown.Status = edited;
+				break;
+			default:
+				return;
+		}
+		await InvokeAsync(StateHasChanged);
+	}
+
+	// a composer that opens shows at the top of the feed, where it is, however far down the feed was read
+	async Task ToggleCompose()
+	{
+		isComposing = !isComposing;
+		if (isComposing && feedModule is not null)
+			await feedModule.InvokeVoidAsync("scrollToTop", ScrollId);
+	}
+
 	async Task ShowPending()
 	{
 		var shown = pending;
 		pending = [];
 		posts.InsertRange(0, shown);
+		await ReadNotifications(loadCancellation?.Token ?? default);
 		minId = shown.FirstOrDefault()?.CursorId ?? minId;
 		await feedModule.InvokeVoidAsync("scrollToTop", ScrollId);
 		await Locate(shown, loadCancellation?.Token ?? default);
@@ -385,6 +576,7 @@
 		yield return NerdRow.Of("max_id", maxId ?? (posts.Count > 0 ? Localizer["end"] : null));
 		yield return NerdRow.Of(Localizer["first page"], lastLoadTook is { } took ? NerdRow.Duration(took) : null);
 		yield return NerdRow.Of(Localizer["polled"], lastPollAt is { } polled ? NerdRow.Duration(DateTime.UtcNow - polled) + " " + Localizer["ago"] : null);
+		yield return NerdRow.Of(Localizer["stream"], Streaming.IsOpen ? Localizer["open"] : Localizer["closed, polling"]);
 		yield return NerdRow.Of(Localizer["poll every"], NerdRow.Duration(PollInterval));
 		yield return NerdRow.Of(Localizer["placed"], posts.Count > 0 ? $"{posts.Count(p => p.Location is not null)}/{posts.Count}" : null);
 		if (RequestStats.Latest(1).FirstOrDefault() is { } last)
@@ -397,6 +589,9 @@
 
 	public override async ValueTask DisposeAsync()
 	{
+		Streaming.Received -= OnStream;
+		await Remember();
+		await Streaming.Stop();
 		await pageCancellation.CancelAsync();
 		pageCancellation.Dispose();
 		loadCancellation?.Cancel();
@@ -416,6 +611,24 @@
 		await base.DisposeAsync();
 	}
 
+	/// <summary>Keeps the feed for the way back (FeedMemory), when it shows something worth keeping.</summary>
+	async Task Remember()
+	{
+		if (IsLoading || loadError is { Length: > 0 } || posts.Count == 0 || CascadingState.PersonaId is null
+			|| Filter.TimelineType is TimelineType.Nearby)
+			return;
+		var scrollTop = 0d;
+		try
+		{
+			if (feedModule is not null)
+				scrollTop = await feedModule.InvokeAsync<double>("scrollOffset", ScrollId);
+		}
+		catch (JSDisconnectedException)
+		{
+		}
+		Memory.Save(Query, posts, pending, groups, lists, minId, maxId, scrollTop);
+	}
+
 	sealed class GeoAnswer
 	{
 		public double? Latitude { get; set; }

Pages/Join.razor

@@ -0,0 +1,123 @@
+@page "/join"
+@inherits LocalizableComponentBase
+<Title>@Localizer["Join with an invitation"]</Title>
+
+@* A new login through a group's invitation (PrivaPub's /clientapi/user/invitation/signup): sign-up is otherwise closed,
+   so this is how everyone but the first administrator arrives. Its first persona joins the group. A group's page links
+   here with the code (?code=). *@
+<section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
+
+	<div class="flex flex-col items-center gap-6 p-4 md:p-5 w-full h-full absolute overflow-y-auto">
+
+		@if (CascadingState.IsSignedIn)
+		{
+			<div class="flex flex-col gap-3 w-full max-w-sm mt-6 md:mt-16 p-5 rounded-xl neo-raised neo-sm" data-join-signed-in>
+				<h1 class="text-xl font-bold">@Localizer["You are signed in"]</h1>
+				<p class="text-sm">@Localizer["A persona of yours joins a group by its invitation in Groups."]</p>
+				<DButton Href="groups" Color="DColor.Primary">@Localizer["Groups"]</DButton>
+			</div>
+		}
+		else
+		{
+			<EditForm Model="form" OnValidSubmit="SignUp" class="flex flex-col gap-4 w-full max-w-sm mt-6 md:mt-16 p-5 rounded-xl neo-raised neo-sm" data-join>
+				<DataAnnotationsValidator />
+				<h1 class="text-xl font-bold">@Localizer["Join with an invitation"]</h1>
+				<p class="text-sm opacity-70">@Localizer["A group's invitation makes your login here, and your first persona joins the group."]</p>
+
+				<label class="flex flex-col gap-1">
+					<span class="text-sm">@Localizer["Invitation code"]</span>
+					<DInput TValue="string" class="w-full font-mono text-xs" @bind-Value="form.InvitationCode" autocomplete="off" autocapitalize="none" spellcheck="false"
+							maxlength="@PrivaPub.ClientModels.Constants.GroupInvitationLength" data-join-code />
+				</label>
+				<DInput TValue="string" Type="password" class="w-full" @bind-Value="form.InvitationPassword" autocomplete="off"
+						placeholder="@Localizer["Invitation password, if it has one"]" data-join-code-password />
+
+				<b class="text-sm">@Localizer["Your login"]</b>
+				<label class="flex flex-col gap-1">
+					<span class="text-sm">@Localizer["Username"]</span>
+					<DInput TValue="string" class="w-full" @bind-Value="form.UserName" autocomplete="username" autocapitalize="none" spellcheck="false" data-join-username>
+						<Prefix><i class="ion-md-person"></i></Prefix>
+					</DInput>
+				</label>
+				<label class="flex flex-col gap-1">
+					<span class="text-sm">@Localizer["Password"]</span>
+					<DInput TValue="string" Type="password" class="w-full" @bind-Value="form.Password" autocomplete="new-password" data-join-password>
+						<Prefix><i class="ion-md-key"></i></Prefix>
+					</DInput>
+				</label>
+				<label class="flex flex-col gap-1">
+					<span class="text-sm">@Localizer["Repeat the password"]</span>
+					<DInput TValue="string" Type="password" class="w-full" @bind-Value="repeatedPassword" autocomplete="new-password" data-join-repeat>
+						<Prefix><i class="ion-md-key"></i></Prefix>
+					</DInput>
+				</label>
+
+				<b class="text-sm">@Localizer["Your first persona"]</b>
+				<p class="text-xs opacity-70">@Localizer["Others see your personas, never your login."]</p>
+				<DInput TValue="string" class="w-full" @bind-Value="form.AvatarUserName" autocomplete="off" autocapitalize="none" spellcheck="false"
+						maxlength="@PrivaPub.ClientModels.Constants.MaxAvatarNameLength" placeholder="@Localizer["user name (a-z, 0-9, _)"]" data-join-persona-username>
+					<Prefix>@@</Prefix>
+				</DInput>
+				<DInput TValue="string" class="w-full" @bind-Value="form.AvatarName" autocomplete="off" maxlength="64"
+						placeholder="@Localizer["Display name"]" data-join-persona-name />
+
+				<ErrorViewer AdditionalError="@error" />
+
+				<DButton Type="submit" Color="DColor.Primary" Disabled="IsDefaultDisabled || isWorking" data-join-submit>
+					@if (isWorking)
+					{
+						<DLoading Size="DSize.Sm" LabelText="@Localizer["loading"]" />
+					}
+					<span>@Localizer["Join"]</span>
+				</DButton>
+				<a class="link text-sm self-center touch-target" href="login">@Localizer["I have a login: sign in"]</a>
+			</EditForm>
+		}
+
+	</div>
+
+</section>
+
+@code {
+	[Inject] AuthService AuthService { get; set; }
+
+	readonly InvitationLoginForm form = new();
+	string repeatedPassword;
+	string error;
+	bool isWorking;
+
+	[SupplyParameterFromQuery] public string Code { get; set; }
+
+	protected override void OnInitialized()
+	{
+		form.InvitationCode = Code?.Trim();
+		IsLoading = false;
+	}
+
+	async Task SignUp()
+	{
+		error = default;
+		if (form.Password != repeatedPassword)
+		{
+			error = Localizer["The two passwords don't match."];
+			return;
+		}
+
+		isWorking = true;
+		form.InvitationCode = form.InvitationCode?.Trim();
+		form.InvitationPassword = string.IsNullOrEmpty(form.InvitationPassword) ? null : form.InvitationPassword;
+		form.AvatarUserName = form.AvatarUserName?.Trim().TrimStart('@').ToLowerInvariant();
+		var result = await AuthService.Join(form);
+		if (result.IsInvalid)
+		{
+			isWorking = false;
+			error = result.ErrorMessage;
+			return;
+		}
+
+		await CascadingState.SignedIn(result.Data as JwtUser);
+		isWorking = false;
+		Toast.AddResponseSuccess(Localizer["Welcome: your persona is in the group."]);
+		Navigation.NavigateTo("");
+	}
+}

Pages/Lists.razor

@@ -0,0 +1,334 @@
+@page "/lists"
+@attribute [Authorize]
+@inherits LocalizableComponentBase
+<Title>@Localizer["Lists"]</Title>
+
+@* The current persona's lists (/api/v1/lists): made, renamed, set to show which replies and whether their members stay
+   out of the home feed, and deleted; their members added from the accounts the persona follows (PrivaPub accepts no
+   others, and drops a member when the follow ends) and removed. A list is read as a tab of the feed page. Lists are
+   the persona's own and never leave PrivaPub. *@
+<section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
+	<div class="flex flex-col gap-4 p-4 md:p-5 w-full h-full absolute overflow-y-auto">
+
+		<div class="flex items-center gap-2">
+			<i class="ion-md-list text-lg"></i>
+			<h1 class="font-bold truncate">@Localizer["Lists"]</h1>
+		</div>
+
+		<EditForm Model="draft" OnValidSubmit="Create" class="flex flex-wrap gap-2 items-center">
+			<DInput TValue="string" class="flex-1 min-w-48" @bind-Value="draft.Title" Immediate="true" autocomplete="off" maxlength="200"
+					placeholder="@Localizer["A new list's title"]" data-list-new>
+				<Prefix><i class="ion-md-add"></i></Prefix>
+			</DInput>
+			<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || isSaving || string.IsNullOrWhiteSpace(draft.Title))">
+				<span>@Localizer["Make a list"]</span>
+			</DButton>
+		</EditForm>
+
+		@if (IsLoading)
+		{
+			<p class="flex w-full items-center justify-center gap-2">
+				<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+				@Localizer["loading"]
+			</p>
+		}
+		else if (lists.Count == 0)
+		{
+			<p class="w-full text-center" data-feed-empty><i class="ion-ios-remove-circle-outline"></i> @Localizer["This persona has no list yet."]</p>
+		}
+
+		<div class="flex flex-col gap-3">
+			@foreach (var list in lists)
+			{
+				<article class="flex flex-col gap-3 p-3 md:p-4 rounded-xl neo-raised neo-xs" data-list-id="@list.Id">
+					<div class="flex flex-wrap items-center gap-2">
+						<b class="flex-1 min-w-0 truncate">@list.Title</b>
+						@if (list.Exclusive)
+						{
+							<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft" title="@Localizer["Its members stay out of the home feed."]">
+								<i class="ion-md-eye-off"></i> @Localizer["Exclusive"]
+							</DBadge>
+						}
+						<DButton Size="DSize.Sm" OnClick="@(() => Read(list))" title="@Localizer["Read the list"]">
+							<i class="ion-md-paper"></i><span class="hidden sm:inline">@Localizer["Read the list"]</span>
+						</DButton>
+						<DButton Size="DSize.Sm" Active="@(open?.Id == list.Id)" OnClick="@(() => Toggle(list))" title="@Localizer["Edit"]">
+							<i class="ion-md-create"></i><span class="hidden sm:inline">@Localizer["Edit"]</span>
+						</DButton>
+					</div>
+
+					@if (open?.Id == list.Id)
+					{
+						<EditForm Model="edit" OnValidSubmit="Save" class="flex flex-col gap-3">
+							<div class="flex flex-wrap gap-2 items-center">
+								<DInput TValue="string" class="flex-1 min-w-48" @bind-Value="edit.Title" Immediate="true" autocomplete="off" maxlength="200"
+										aria-label="@Localizer["Title"]" data-list-title />
+								<DSelect TValue="ListRepliesPolicy" Size="DSize.Sm" class="w-full sm:w-auto" @bind-Value="edit.RepliesPolicy">
+									<Prefix><i class="ion-md-undo"></i></Prefix>
+									<ChildContent>
+										@foreach (var policy in Policies)
+										{
+											<option value="@policy">@PolicyName(policy)</option>
+										}
+									</ChildContent>
+								</DSelect>
+							</div>
+							<DToggle Size="DSize.Sm" @bind-Value="edit.Exclusive" LabelText="@Localizer["Keep its members out of the home feed"]" />
+							<div class="flex flex-wrap gap-2">
+								<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || isSaving || string.IsNullOrWhiteSpace(edit.Title))">
+									<i class="ion-md-checkmark"></i><span>@Localizer["Save"]</span>
+								</DButton>
+								@if (isConfirmingDelete)
+								{
+									<DButton Size="DSize.Sm" Color="DColor.Error" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="Delete">
+										<i class="ion-md-trash"></i><span>@Localizer["Delete it for good"]</span>
+									</DButton>
+									<DButton Size="DSize.Sm" OnClick="() => isConfirmingDelete = false">@Localizer["Cancel"]</DButton>
+								}
+								else
+								{
+									<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="() => isConfirmingDelete = true">
+										<i class="ion-md-trash text-error"></i><span>@Localizer["Delete"]</span>
+									</DButton>
+								}
+							</div>
+						</EditForm>
+
+						<h2 class="font-semibold text-sm">@Localizer["Members"] <span class="opacity-60 tabular-nums">@members.Count</span></h2>
+						<div class="flex flex-col gap-2" data-list-members>
+							@if (members.Count == 0)
+							{
+								<p class="text-sm opacity-70">@Localizer["Nobody is in this list yet."]</p>
+							}
+							@foreach (var account in members)
+							{
+								<div class="flex items-center gap-3 min-w-0" data-member-id="@account.Id">
+									@* alt="": the name is next to it. *@
+									<img alt="" class="h-8 w-8 flex-none object-cover rounded-full" src="@(account.Avatar ?? "imgs/icon-192.png")" />
+									<a class="flex flex-col min-w-0 flex-1" href="@($"account/{Uri.EscapeDataString(account.Id)}")">
+										<b class="truncate text-sm">@account.Name</b>
+										<span class="text-xs opacity-70 truncate">@("@" + account.Acct)</span>
+									</a>
+									<DButton Size="DSize.Xs" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="@(() => SetMember(account, false))"
+											 title="@Localizer["Remove from the list"]">
+										<i class="ion-md-close"></i><span class="hidden sm:inline">@Localizer["Remove"]</span>
+									</DButton>
+								</div>
+							}
+						</div>
+
+						<EditForm Model="find" OnValidSubmit="Find" class="flex flex-wrap gap-2 items-center">
+							<DInput TValue="string" class="flex-1 min-w-48" @bind-Value="find.Query" Immediate="true" autocomplete="off" type="search"
+									placeholder="@Localizer["Find accounts you follow"]" data-list-find>
+								<Prefix><i class="ion-md-search"></i></Prefix>
+							</DInput>
+							<DButton Type="submit" Size="DSize.Sm" Disabled="@(IsDefaultDisabled || isFinding || string.IsNullOrWhiteSpace(find.Query))">
+								@if (isFinding)
+								{
+									<DLoading Size="DSize.Xs" LabelText="@Localizer["loading"]" />
+								}
+								<span>@Localizer["Search"]</span>
+							</DButton>
+						</EditForm>
+						@if (found is not null)
+						{
+							<div class="flex flex-col gap-2" data-list-found>
+								@if (Candidates.Count == 0)
+								{
+									<p class="text-sm opacity-70">@Localizer["Only accounts you follow can join a list, and none of them matches."]</p>
+								}
+								@foreach (var account in Candidates)
+								{
+									<div class="flex items-center gap-3 min-w-0" data-candidate-id="@account.Id">
+										@* alt="": the name is next to it. *@
+										<img alt="" class="h-8 w-8 flex-none object-cover rounded-full" src="@(account.Avatar ?? "imgs/icon-192.png")" />
+										<span class="flex flex-col min-w-0 flex-1">
+											<b class="truncate text-sm">@account.Name</b>
+											<span class="text-xs opacity-70 truncate">@("@" + account.Acct)</span>
+										</span>
+										<DButton Size="DSize.Xs" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="@(() => SetMember(account, true))">
+											<i class="ion-md-add"></i><span>@Localizer["Add"]</span>
+										</DButton>
+									</div>
+								}
+							</div>
+						}
+					}
+				</article>
+			}
+		</div>
+	</div>
+</section>
+
+@code {
+	static readonly ListRepliesPolicy[] Policies = [ListRepliesPolicy.List, ListRepliesPolicy.Followed, ListRepliesPolicy.None];
+
+	[Inject] ListService ListService { get; set; }
+	[Inject] ILocalStorageService LocalStorage { get; set; }
+
+	List<MastodonList> lists = [];
+	MastodonList draft = new();
+	MastodonList edit = new();
+	MastodonList open;
+	List<Account> members = [];
+	List<Account> found;
+	SearchForm find = new();
+	string loadedPersonaId;
+	bool isSaving;
+	bool isFinding;
+	bool isConfirmingDelete;
+
+	List<Account> Candidates => found.Where(a => members.All(m => m.Id != a.Id)).ToList();
+
+	string PolicyName(ListRepliesPolicy policy) => policy switch
+	{
+		ListRepliesPolicy.Followed => Localizer["Replies to anyone you follow"],
+		ListRepliesPolicy.None => Localizer["No replies"],
+		_ => Localizer["Replies to the list's members"]
+	};
+
+	// The persona changed (NavMenu's switcher): its lists are another persona's.
+	protected override async Task OnParametersSetAsync()
+	{
+		if (CascadingState.PersonaId is null)
+		{
+			IsLoading = false;
+			return;
+		}
+		if (CascadingState.PersonaId == loadedPersonaId)
+			return;
+		loadedPersonaId = CascadingState.PersonaId;
+
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+	}
+
+	async Task LoadData()
+	{
+		IsLoading = true;
+		open = null;
+		members = [];
+		found = null;
+		lists = await ListService.All();
+		IsLoading = false;
+	}
+
+	async Task Create()
+	{
+		isSaving = true;
+		var result = await ListService.Save(new MastodonList { Title = draft.Title });
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		var list = (MastodonList)result.Data;
+		lists.Add(list);
+		lists = [.. lists.OrderBy(l => l.Title, StringComparer.CurrentCultureIgnoreCase)];
+		draft = new();
+		Toast.AddResponseSuccess(Localizer["List {0} made.", list.Title]);
+		await Toggle(list);
+	}
+
+	async Task Toggle(MastodonList list)
+	{
+		isConfirmingDelete = false;
+		found = null;
+		find = new();
+		if (open?.Id == list.Id)
+		{
+			open = null;
+			members = [];
+			return;
+		}
+
+		open = list;
+		edit = new MastodonList { Id = list.Id, Title = list.Title, RepliesPolicy = list.RepliesPolicy, Exclusive = list.Exclusive };
+		members = await ListService.Members(list.Id);
+	}
+
+	async Task Save()
+	{
+		isSaving = true;
+		var result = await ListService.Save(edit);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		var saved = (MastodonList)result.Data;
+		var index = lists.FindIndex(l => l.Id == saved.Id);
+		if (index >= 0)
+			lists[index] = saved;
+		open = saved;
+		Toast.AddResponseSuccess(Localizer["List {0} saved.", saved.Title]);
+	}
+
+	async Task Delete()
+	{
+		isSaving = true;
+		var result = await ListService.Delete(open.Id);
+		isSaving = false;
+		isConfirmingDelete = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		lists.RemoveAll(l => l.Id == open.Id);
+		Toast.AddResponseSuccess(Localizer["List {0} deleted.", open.Title]);
+		open = null;
+		members = [];
+	}
+
+	async Task Find()
+	{
+		isFinding = true;
+		found = await ListService.FindFollowed(find.Query);
+		isFinding = false;
+	}
+
+	async Task SetMember(Account account, bool member)
+	{
+		isSaving = true;
+		var result = await ListService.SetMember(open.Id, account.Id, member);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		if (member)
+			members.Add(account);
+		else
+			members.RemoveAll(m => m.Id == account.Id);
+		Toast.AddResponseSuccess(member ? Localizer["{0} added to {1}.", account.Name, open.Title] : Localizer["{0} removed from {1}.", account.Name, open.Title]);
+	}
+
+	async Task Read(MastodonList list)
+	{
+		var filter = await LocalStorage.GetItemAsync<FeedFilter>(nameof(FeedFilter)) ?? new();
+		filter.TimelineType = TimelineType.Lists;
+		filter.ListId = list.Id;
+		await LocalStorage.SetItemAsync(nameof(FeedFilter), filter);
+		Navigation.NavigateTo("");
+	}
+
+	sealed class SearchForm
+	{
+		public string Query { get; set; }
+	}
+}

Pages/Login.razor

@@ -3,16 +3,57 @@
 <Title>@Localizer["Login"]</Title>
 
 @* One sign-in for both of PrivaPub's APIs: the root signs in here, then picks the persona to act as when it has more than
-   one (CascadingState.LoadSession picks the last one used, or the only one). *@
+   one (CascadingState.LoadSession picks the last one used, or the only one). A server without an administrator offers
+   its setup (Setup); anyone else joins through a group's invitation (Join). A forgotten password is recovered through
+   the login's verified address (PasswordRecovery). With two-factor sign-in on, PrivaPub answers a right password with a
+   428, and the same form goes again with the authenticator app's six digits or a recovery code (LoginForm.OneTimeCode). *@
 <section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
 
 	<div class="flex flex-col items-center gap-6 p-4 md:p-5 w-full h-full absolute overflow-y-auto">
 
 		@if (!CascadingState.IsSignedIn)
 		{
-			<EditForm Model="form" OnValidSubmit="SignIn" class="flex flex-col gap-4 w-full max-w-sm mt-6 md:mt-16 p-5 rounded-xl neo-raised neo-sm">
+			<div class="flex flex-col gap-4 w-full max-w-sm mt-6 md:mt-16">
+				@if (setupPending)
+				{
+					<a href="setup" class="flex items-center gap-3 w-full p-4 rounded-xl neo-raised neo-sm ring-2 ring-primary" data-setup-offer>
+						<i class="ion-md-construct text-2xl text-primary" aria-hidden="true"></i>
+						<span class="flex flex-col">
+							<b>@Localizer["This server has no administrator yet"]</b>
+							<span class="text-sm">@Localizer["Set it up: the first login made becomes its administrator."]</span>
+						</span>
+					</a>
+				}
+				<EditForm Model="form" OnValidSubmit="SignIn" class="flex flex-col gap-4 w-full p-5 rounded-xl neo-raised neo-sm">
 					<DataAnnotationsValidator />
 					<h1 class="text-xl font-bold">@Localizer["Sign in to PrivaPub"]</h1>
+					@if (needsCode)
+					{
+						@* The name and the password stay in the form, out of sight, and go again with the code. *@
+						<p class="text-sm" data-login-code-asked>@Localizer["Enter the code from your authenticator app, or a recovery code."]</p>
+						@if (useRecoveryCode)
+						{
+							<label class="flex flex-col gap-1">
+								<span class="text-sm">@Localizer["Recovery code"]</span>
+								<DInput TValue="string" class="w-full" @bind-Value="form.OneTimeCode" required="@true" autocomplete="one-time-code" inputmode="text"
+										autocapitalize="none" spellcheck="false" data-login-recovery>
+									<Prefix><i class="ion-md-key"></i></Prefix>
+								</DInput>
+							</label>
+						}
+						else
+						{
+							<div class="flex flex-col gap-1">
+								<span class="text-sm">@Localizer["Code from the authenticator app"]</span>
+								<DOtp @bind-Value="form.OneTimeCode" Immediate="true" aria-label="@Localizer["Code from the authenticator app"]" data-login-code />
+							</div>
+						}
+						<DButton Variant="DButtonVariant.Link" Size="DSize.Sm" class="self-center" OnClick="ToggleRecoveryCode" data-login-use-recovery>
+							@(useRecoveryCode ? Localizer["Use the authenticator app instead"] : Localizer["Use a recovery code instead"])
+						</DButton>
+					}
+					else
+					{
 						<p class="text-sm opacity-70">@Localizer["One login for all of your personas: each one is signed in separately and never linked to the others."]</p>
 
 						<label class="flex flex-col gap-1">
@@ -27,6 +68,7 @@
 								<Prefix><i class="ion-md-key"></i></Prefix>
 							</DInput>
 						</label>
+					}
 
 					<ErrorViewer AdditionalError="@error" />
 
@@ -37,13 +79,28 @@
 						}
 						<span>@Localizer["Login"]</span>
 					</DButton>
+					@if (needsCode)
+					{
+						<DButton Variant="DButtonVariant.Ghost" Size="DSize.Sm" class="self-center" Disabled="isWorking" OnClick="Back" data-login-back>
+							<i class="ion-md-arrow-back"></i><span>@Localizer["Back"]</span>
+						</DButton>
+					}
+					else
+					{
+						<a class="link text-sm self-center touch-target" href="password-recovery" data-recovery-offer>@Localizer["Forgot your password?"]</a>
+					}
 				</EditForm>
+				<p class="text-sm text-center">
+					@Localizer["Have an invitation?"] <a class="link touch-target" href="join" data-join-offer>@Localizer["Join with an invitation"]</a>
+				</p>
+			</div>
 		}
 		else if (CascadingState.Personas.Count == 0)
 		{
-			<div class="flex flex-col gap-3 w-full max-w-sm mt-6 md:mt-16 p-5 rounded-xl neo-raised neo-sm">
+			<div class="flex flex-col gap-3 w-full max-w-sm mt-6 md:mt-16 p-5 rounded-xl neo-raised neo-sm" data-no-persona>
 				<h1 class="text-xl font-bold">@Localizer["No persona yet"]</h1>
-				<p class="text-sm">@Localizer["This login has no persona to act as. Create one on PrivaPub first."]</p>
+				<p class="text-sm">@Localizer["This login has no persona to act as yet: make one in Settings."]</p>
+				<DButton Href="settings" Color="DColor.Primary">@Localizer["Settings"]</DButton>
 				<DButton OnClick="SignOut">@Localizer["Logout"]</DButton>
 			</div>
 		}
@@ -81,25 +138,58 @@
 	readonly LoginForm form = new();
 	string error;
 	bool isWorking;
+	bool setupPending;
+	/// <summary>PrivaPub asked for a code (its 428): the password was right, and two-factor sign-in is on.</summary>
+	bool needsCode;
+	/// <summary>The code asked for is a recovery code (two groups of five letters and digits), not the app's six digits.</summary>
+	bool useRecoveryCode;
 
 	[SupplyParameterFromQuery] public string ReturnUrl { get; set; }
 
-	protected override void OnInitialized() => IsLoading = false;
+	protected override async Task OnInitializedAsync()
+	{
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+		IsLoading = false;
+	}
+
+	async Task LoadData() => setupPending = !CascadingState.IsSignedIn && await AuthService.SetupPending();
 
 	async Task SignIn()
 	{
 		error = default;
 		isWorking = true;
+		form.OneTimeCode = needsCode ? form.OneTimeCode?.Trim() : default;
 		var result = await AuthService.Login(form);
-		if (result.IsInvalid)
+		if (AuthService.NeedsOneTimeCode(result))
 		{
-			error = result.ErrorMessage;
+			needsCode = true;
+			form.OneTimeCode = default;
 			isWorking = false;
 			return;
 		}
 
-		await CascadingState.LoadSession();
+		if (result.IsInvalid)
+		{
+			// a wrong code is PrivaPub's 400, like a wrong password, with its own message; the code is typed again
+			error = result.ErrorMessage;
+			form.OneTimeCode = default;
 			isWorking = false;
+			return;
+		}
+
+		await CascadingState.SignedIn(result.Data as JwtUser);
+		isWorking = false;
+		needsCode = false;
+		useRecoveryCode = false;
+		form.OneTimeCode = default;
 		if (CascadingState.Personas.Count == 1 && CascadingState.Persona is not null)
 			Continue();
 	}
@@ -119,6 +209,23 @@
 		Continue();
 	}
 
+	void ToggleRecoveryCode()
+	{
+		useRecoveryCode = !useRecoveryCode;
+		form.OneTimeCode = default;
+		error = default;
+	}
+
+	/// <summary>Back to the name and the password, for another login: the password is typed again.</summary>
+	void Back()
+	{
+		needsCode = false;
+		useRecoveryCode = false;
+		form.OneTimeCode = default;
+		form.Password = default;
+		error = default;
+	}
+
 	async Task SignOut() => await CascadingState.SignOut();
 
 	/// <summary>Back where the reader was sent from, never off the app.</summary>

Pages/PasswordRecovery.razor

@@ -0,0 +1,216 @@
+@page "/password-recovery"
+@inherits LocalizableComponentBase
+<Title>@Localizer["Forgot your password?"]</Title>
+
+@* A forgotten password (PrivaPub's /clientapi/user/recover): the login's name, or its verified address, asks for a link,
+   and PrivaPub answers everyone with the same sentence, so the page never tells whether a login or an address exists.
+   The link comes back here with its code (?rc=), which leaves the address bar and the history at once and stays in the
+   page; a new password set with it ends every session the login had, and the reader signs in with it. *@
+<section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
+
+	<div class="flex flex-col items-center gap-6 p-4 md:p-5 w-full h-full absolute overflow-y-auto">
+
+		@if (CascadingState.IsSignedIn)
+		{
+			<div class="flex flex-col gap-3 w-full max-w-sm mt-6 md:mt-16 p-5 rounded-xl neo-raised neo-sm" data-recovery-signed-in>
+				<h1 class="text-xl font-bold">@Localizer["You are signed in"]</h1>
+				<DButton Href="" Color="DColor.Primary">@Localizer["Home"]</DButton>
+			</div>
+		}
+		else if (recoveryCode is null && sentence is not null)
+		{
+			<div class="flex flex-col gap-3 w-full max-w-sm mt-6 md:mt-16 p-5 rounded-xl neo-raised neo-sm" data-recovery-sent>
+				<h1 class="text-xl font-bold">@Localizer["Check your inbox"]</h1>
+				<p class="text-sm">@sentence</p>
+				<DButton Href="login" Color="DColor.Primary">@Localizer["Login"]</DButton>
+			</div>
+		}
+		else if (recoveryCode is null)
+		{
+			<EditForm Model="request" OnValidSubmit="Request" class="flex flex-col gap-4 w-full max-w-sm mt-6 md:mt-16 p-5 rounded-xl neo-raised neo-sm" data-recovery-request>
+				<DataAnnotationsValidator />
+				<h1 class="text-xl font-bold">@Localizer["Forgot your password?"]</h1>
+				<p class="text-sm opacity-70">@Localizer["Give your login's username or its email address: if the login has a verified address, a link to choose a new password is sent to it."]</p>
+
+				<label class="flex flex-col gap-1">
+					<span class="text-sm">@Localizer["Username"]</span>
+					<DInput TValue="string" class="w-full" Value="request.UserName" ValueChanged="v => request.UserName = NullIfBlank(v)" ValueExpression="() => request.UserName"
+							Immediate="true" disabled="@request.IsUsernameDisabled" autocomplete="username" autocapitalize="none" spellcheck="false" data-recovery-username>
+						<Prefix><i class="ion-md-person"></i></Prefix>
+					</DInput>
+				</label>
+				<span class="text-sm text-center opacity-70">@Localizer["or"]</span>
+				<label class="flex flex-col gap-1">
+					<span class="text-sm">@Localizer["Email address"]</span>
+					<DInput TValue="string" Type="email" class="w-full" Value="request.Email" ValueChanged="v => request.Email = NullIfBlank(v)" ValueExpression="() => request.Email"
+							Immediate="true" disabled="@request.IsEmailDisabled" autocomplete="email" inputmode="email" autocapitalize="none" spellcheck="false" data-recovery-email>
+						<Prefix><i class="ion-md-mail"></i></Prefix>
+					</DInput>
+				</label>
+
+				<ErrorViewer AdditionalError="@error" />
+
+				<DButton Type="submit" Color="DColor.Primary" Disabled="IsDefaultDisabled || isWorking" data-recovery-submit>
+					@if (isWorking)
+					{
+						<DLoading Size="DSize.Sm" LabelText="@Localizer["loading"]" />
+					}
+					<span>@Localizer["Send the recovery link"]</span>
+				</DButton>
+				<a class="link text-sm self-center touch-target" href="login">@Localizer["I remember it: sign in"]</a>
+			</EditForm>
+		}
+		else if (IsLoading)
+		{
+			<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+		}
+		else if (isCodeValid is false)
+		{
+			<div class="flex flex-col gap-3 w-full max-w-sm mt-6 md:mt-16 p-5 rounded-xl neo-raised neo-sm" data-recovery-invalid>
+				<h1 class="text-xl font-bold">@Localizer["This recovery link doesn't work"]</h1>
+				<p class="text-sm">@Localizer["A link works for one hour, and only once. Ask for a new one."]</p>
+				<DButton Color="DColor.Primary" OnClick="AskAgain" data-recovery-again>@Localizer["Ask for a new link"]</DButton>
+			</div>
+		}
+		else
+		{
+			@* also while the code couldn't be checked (offline, or the check failed): the answer to the new password says *@
+			<EditForm Model="newPassword" OnValidSubmit="Recover" class="flex flex-col gap-4 w-full max-w-sm mt-6 md:mt-16 p-5 rounded-xl neo-raised neo-sm" data-recovery-new>
+				<DataAnnotationsValidator />
+				<h1 class="text-xl font-bold">@Localizer["Choose a new password"]</h1>
+				<p class="text-sm opacity-70">@Localizer["Every device signed in to this login is signed out."]</p>
+
+				<label class="flex flex-col gap-1">
+					<span class="text-sm">@Localizer["New password"]</span>
+					<DInput TValue="string" Type="password" class="w-full" @bind-Value="newPassword.NewPassword" autocomplete="new-password" data-recovery-password>
+						<Prefix><i class="ion-md-key"></i></Prefix>
+					</DInput>
+				</label>
+				<label class="flex flex-col gap-1">
+					<span class="text-sm">@Localizer["Repeat the new password"]</span>
+					<DInput TValue="string" Type="password" class="w-full" @bind-Value="newPassword.RepeatedPassword" autocomplete="new-password" data-recovery-repeat>
+						<Prefix><i class="ion-md-key"></i></Prefix>
+					</DInput>
+				</label>
+
+				<ErrorViewer AdditionalError="@error" />
+
+				<DButton Type="submit" Color="DColor.Primary" Disabled="IsDefaultDisabled || isWorking" data-recovery-new-submit>
+					@if (isWorking)
+					{
+						<DLoading Size="DSize.Sm" LabelText="@Localizer["loading"]" />
+					}
+					<span>@Localizer["Change the password"]</span>
+				</DButton>
+			</EditForm>
+		}
+
+	</div>
+
+</section>
+
+@code {
+	[Inject] AuthService AuthService { get; set; }
+
+	readonly PasswordRecoveryForm request = new();
+	NewPasswordForm newPassword = new();
+	/// <summary>The code of the link the page was opened from, kept here once it left the address bar.</summary>
+	string recoveryCode;
+	/// <summary>Whether the code works: null until PrivaPub said.</summary>
+	bool? isCodeValid;
+	/// <summary>PrivaPub's answer to a request, the same for everyone.</summary>
+	string sentence;
+	string error;
+	bool isWorking;
+
+	[SupplyParameterFromQuery(Name = "rc")] public string LinkCode { get; set; }
+
+	protected override async Task OnInitializedAsync()
+	{
+		if (LinkCode is { Length: > 0 } code)
+		{
+			recoveryCode = code.Trim();
+			newPassword.RecoveryCode = recoveryCode;
+			// the code is as good as the password for an hour: out of the address bar and the history at once
+			Navigation.NavigateTo("password-recovery", replace: true);
+		}
+
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+		IsLoading = false;
+	}
+
+	async Task LoadData()
+	{
+		if (recoveryCode is null)
+			return;
+
+		var result = await AuthService.CheckRecoveryCode(recoveryCode);
+		if (result.IsInvalid)
+		{
+			error = result.ErrorMessage;
+			return;
+		}
+
+		isCodeValid = result.Data is true;
+	}
+
+	static string NullIfBlank(string value) => string.IsNullOrWhiteSpace(value) ? null : value;
+
+	async Task Request()
+	{
+		error = default;
+		isWorking = true;
+		request.UserName = request.UserName?.Trim();
+		request.Email = request.Email?.Trim().ToLowerInvariant();
+		var result = await AuthService.RequestRecovery(request);
+		isWorking = false;
+		if (result.IsInvalid)
+		{
+			error = result.ErrorMessage;
+			return;
+		}
+
+		sentence = result.Data is string { Length: > 0 } said
+			? said
+			: Localizer["If that account has an email address, a recovery link is on its way. It works for one hour."];
+	}
+
+	void AskAgain()
+	{
+		recoveryCode = null;
+		isCodeValid = null;
+		newPassword = new();
+		error = default;
+	}
+
+	async Task Recover()
+	{
+		error = default;
+		isWorking = true;
+		var result = await AuthService.Recover(newPassword);
+		isWorking = false;
+		if (result.StatusCode is (int)System.Net.HttpStatusCode.NotFound)
+		{
+			// used or expired meanwhile
+			isCodeValid = false;
+			return;
+		}
+
+		if (result.IsInvalid)
+		{
+			error = result.ErrorMessage;
+			return;
+		}
+
+		Toast.AddResponseSuccess(Localizer["Password changed: sign in with the new one."]);
+		Navigation.NavigateTo("login");
+	}
+}

Pages/Profile.razor

@@ -0,0 +1,378 @@
+@page "/account/{accountId}"
+@attribute [Authorize]
+@inherits LocalizableComponentBase
+<Title>@(account?.Name ?? Localizer["Profile"])</Title>
+
+@* An account as the current persona sees it (/api/v1/accounts/{id}): its header, bio and fields, its counts, what it is
+   to the persona (following, followed by, requested, blocked, muted) with the actions that change it, and its posts,
+   page by page, as posts only, posts and replies, or media. A remote account's profile comes from what PrivaPub knows,
+   never from its server directly. *@
+<section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
+	<div class="flex flex-col gap-4 p-4 md:p-5 w-full h-full absolute overflow-y-auto">
+
+		<div class="flex items-center gap-2">
+			<DButton Size="DSize.Sm" OnClick="Back" title="@Localizer["Back"]">
+				<i class="ion-md-arrow-back"></i>
+			</DButton>
+			<h1 class="font-bold truncate">@Localizer["Profile"]</h1>
+		</div>
+
+		@if (IsLoading)
+		{
+			<p class="flex w-full items-center justify-center gap-2">
+				<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+				@Localizer["loading"]
+			</p>
+		}
+		else if (account is null)
+		{
+			<p class="w-full text-center text-lg">
+				<i class="ion-ios-remove-circle-outline"></i> @Localizer["This account doesn't exist."]
+			</p>
+		}
+		else
+		{
+			@if (account.Moved is { } moved)
+			{
+				<p class="flex flex-wrap items-center gap-2 p-3 rounded-xl neo-inset neo-2xs text-sm" data-moved>
+					<i class="ion-md-swap"></i>
+					<span>@Localizer["{0} has moved to", account.Name]</span>
+					<a class="link font-semibold" href="@($"account/{Uri.EscapeDataString(moved.Id)}")">@("@" + moved.Acct)</a>
+				</p>
+			}
+			@* not overflow-hidden: the Lists menu hangs out of it; the header picture takes the card's top corners itself *@
+			<article class="flex flex-none flex-col rounded-xl neo-raised neo-xs" data-account-id="@account.Id">
+				<div class="h-28 md:h-40 bg-base-200 bg-cover bg-center rounded-t-xl" style="@HeaderStyle"></div>
+				<div class="flex flex-wrap items-end gap-3 px-4 -mt-10">
+					@* alt="": the name is next to it. *@
+					<img alt="" class="h-20 w-20 md:h-24 md:w-24 flex-none object-cover rounded-full neo-raised neo-2xs bg-base-100"
+						 src="@(account.Avatar ?? "imgs/icon-192.png")" />
+					<div class="flex flex-col min-w-0 flex-1 pb-1">
+						<b class="text-lg truncate">@CustomEmojis.Text(account.Name, account.Emojis)</b>
+						<span class="text-sm opacity-70 truncate">@("@" + FullAcct)</span>
+					</div>
+					@if (!IsOwn)
+					{
+						<div class="flex flex-wrap gap-2 pb-1">
+							@if (relationship?.FollowedBy == true)
+							{
+								<DBadge Size="DSize.Sm" class="self-center">@Localizer["Follows you"]</DBadge>
+							}
+							@if (relationship?.Blocking != true)
+							{
+								<DButton Size="DSize.Sm" Color="@(relationship?.Following == true || relationship?.Requested == true ? DColor.Neutral : DColor.Primary)"
+										 Disabled="@(IsDefaultDisabled || isActing || relationship is null)" OnClick="ToggleFollow">
+									@FollowLabel
+								</DButton>
+							}
+							@if (relationship?.Following == true)
+							{
+								<DDropdown @bind-IsOpen="isListMenuOpen" Align="DDropdownAlign.End" TriggerClass="btn btn-sm" SheetOnNarrow="true"
+										   ContentClass="mt-2 flex flex-col gap-2 p-3 rounded-box w-64 bg-base-100 neo-raised neo-xs z-20" title="@Localizer["Lists"]">
+									<Trigger>
+										<i class="ion-md-list"></i><span>@Localizer["Lists"]</span>
+									</Trigger>
+									<ChildContent>
+										@if (allLists.Count == 0)
+										{
+											<p class="text-xs opacity-70">@Localizer["This persona has no list yet."]</p>
+										}
+										@foreach (var list in allLists)
+										{
+											<label class="label text-sm" data-list-id="@list.Id">
+												<input type="checkbox" class="checkbox checkbox-sm" checked="@inLists.Contains(list.Id)" disabled="@(IsDefaultDisabled || isActing)"
+													   @onchange="@((ChangeEventArgs e) => SetListMember(list, e.Value is true))" />
+												<span class="truncate">@list.Title</span>
+											</label>
+										}
+										<a class="btn btn-xs" href="lists"><i class="ion-md-create"></i><span>@Localizer["Manage lists"]</span></a>
+									</ChildContent>
+								</DDropdown>
+							}
+							<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || isActing || relationship is null)"
+									 OnClick="@(() => Do(relationship?.Muting == true ? AccountAction.Unmute : AccountAction.Mute))">
+								<i class="@(relationship?.Muting == true ? "ion-md-eye" : "ion-md-eye-off")"></i>
+								<span>@(relationship?.Muting == true ? Localizer["Unmute"] : Localizer["Mute"])</span>
+							</DButton>
+							<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || isActing || relationship is null)"
+									 OnClick="@(() => Do(relationship?.Blocking == true ? AccountAction.Unblock : AccountAction.Block))">
+								<i class="ion-md-remove-circle text-error"></i>
+								<span>@(relationship?.Blocking == true ? Localizer["Unblock"] : Localizer["Block"])</span>
+							</DButton>
+							<DButton Size="DSize.Sm" Disabled="IsDefaultDisabled" OnClick="@(() => isReporting = true)" data-report>
+								<i class="ion-md-flag text-warning"></i>
+								<span>@Localizer["Report"]</span>
+							</DButton>
+						</div>
+						@if (isReporting)
+						{
+							<ReportDialog Account="account" OnClosed="@(() => isReporting = false)" />
+						}
+					}
+				</div>
+
+				<div class="flex flex-wrap gap-2 px-4 pt-2">
+					@if (account.Locked)
+					{
+						<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft"><i class="ion-md-lock"></i> @Localizer["Locked account"]</DBadge>
+					}
+					@if (account.Bot)
+					{
+						<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft"><i class="ion-md-cog"></i> @Localizer["Bot"]</DBadge>
+					}
+					@if (account.Group)
+					{
+						<DBadge Size="DSize.Sm" Variant="DBadgeVariant.Soft"><i class="ion-md-people"></i> @Localizer["Groups"]</DBadge>
+					}
+				</div>
+
+				@if (!string.IsNullOrWhiteSpace(account.Note))
+				{
+					<div class="post-content px-4 pt-3 text-sm md:text-base break-words">@((MarkupString)CustomEmojis.Html(account.Note, account.Emojis))</div>
+				}
+
+				@if (account.Fields.Count > 0)
+				{
+					<dl class="grid grid-cols-[minmax(0,10rem)_minmax(0,1fr)] gap-x-3 gap-y-1 px-4 pt-3 text-sm">
+						@foreach (var field in account.Fields)
+						{
+							<dt class="font-semibold truncate">@CustomEmojis.Text(field.Name, account.Emojis)</dt>
+							<dd class="post-content break-words min-w-0">@((MarkupString)CustomEmojis.Html(field.Value, account.Emojis))</dd>
+						}
+					</dl>
+				}
+
+				<div class="flex flex-wrap gap-4 px-4 py-3 text-sm tabular-nums">
+					<span><b>@account.StatusesCount</b> @Localizer["posts"]</span>
+					<span><b>@account.FollowingCount</b> @Localizer["following"]</span>
+					<span><b>@account.FollowersCount</b> @Localizer["followers"]</span>
+				</div>
+			</article>
+
+			<DTabs Active="(int)tab" ActiveChanged="SelectTab" Variant="DTabsVariant.Box" Size="DSize.Sm" ContentClass="hidden">
+				<DTab><Header><span class="capitalize">@Localizer["posts"]</span></Header></DTab>
+				<DTab><Header>@Localizer["Posts and replies"]</Header></DTab>
+				<DTab><Header>@Localizer["Media"]</Header></DTab>
+			</DTabs>
+
+			<div class="flex flex-col gap-4">
+				@if (tab is ProfileTab.Posts && pinned.Count > 0)
+				{
+					<div class="flex flex-col gap-4" data-pinned>
+						<span class="badge badge-ghost gap-1 self-start"><i aria-hidden="true" class="ion-md-pin"></i>@Localizer["Pinned"]</span>
+						@foreach (var post in pinned)
+						{
+							<Content @key="post.Key" Post="post" FilterIn="FilterContext.Account" OnDeleted="Remove" OnTag="OpenTag" />
+						}
+					</div>
+				}
+				@foreach (var post in posts.Where(p => tab is not ProfileTab.Posts || !pinnedKeys.Contains(p.Key)))
+				{
+					<Content @key="post.Key" Post="post" FilterIn="FilterContext.Account" OnDeleted="Remove" OnTag="OpenTag" />
+				}
+				@if (posts.Count == 0 && !isLoadingMore)
+				{
+					<p class="w-full text-center" data-feed-empty><i class="ion-ios-remove-circle-outline"></i> @Localizer["Empty"]</p>
+				}
+				@if (maxId is not null)
+				{
+					<DButton Size="DSize.Sm" class="self-center" Disabled="@(IsDefaultDisabled || isLoadingMore)" OnClick="LoadMore">
+						@if (isLoadingMore)
+						{
+							<DLoading Size="DSize.Xs" LabelText="@Localizer["loading"]" />
+						}
+						<span>@Localizer["Load more"]</span>
+					</DButton>
+				}
+			</div>
+		}
+	</div>
+</section>
+
+@code {
+	[Inject] AccountService AccountService { get; set; }
+	[Inject] ConfirmService Confirm { get; set; }
+	[Inject] ListService ListService { get; set; }
+	[Inject] InstanceService InstanceService { get; set; }
+	[Inject] ILocalStorageService LocalStorage { get; set; }
+	[Inject] IJSRuntime JS { get; set; }
+
+	[Parameter] public string AccountId { get; set; }
+
+	Account account;
+	Relationship relationship;
+	List<FeedPost> posts = [];
+	List<FeedPost> pinned = [];
+	HashSet<string> pinnedKeys = [];
+	ProfileTab tab = ProfileTab.Posts;
+	string maxId;
+	string loadedId;
+	string loadedPersonaId;
+	bool isActing;
+	bool isLoadingMore;
+	bool isListMenuOpen;
+	bool isReporting;
+	List<MastodonList> allLists = [];
+	HashSet<string> inLists = [];
+
+	bool IsOwn => account is not null && account.Id == CascadingState.PersonaId;
+
+	string FullAcct => account.Acct.Contains('@') ? account.Acct : $"{account.Acct}@{account.Host}";
+
+	string HeaderStyle => string.IsNullOrEmpty(account?.Header) ? null : $"background-image:url('{account.Header}')";
+
+	string FollowLabel => relationship switch
+	{
+		{ Following: true } => Localizer["Unfollow"],
+		{ Requested: true } => Localizer["Cancel the request"],
+		_ => Localizer["Follow"]
+	};
+
+	protected override async Task OnParametersSetAsync()
+	{
+		if (AccountId == loadedId && CascadingState.PersonaId == loadedPersonaId)
+			return;
+		loadedId = AccountId;
+		loadedPersonaId = CascadingState.PersonaId;
+
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+	}
+
+	async Task LoadData()
+	{
+		IsLoading = true;
+		account = await AccountService.Get(AccountId);
+		if (account is null)
+		{
+			IsLoading = false;
+			return;
+		}
+		relationship = account.Id == CascadingState.PersonaId ? null : await AccountService.Relationship(account.Id);
+		await LoadLists();
+		pinned = await AccountService.Pinned(account.Id);
+		pinnedKeys = [.. pinned.Select(p => p.Key)];
+		posts = [];
+		maxId = null;
+		IsLoading = false;
+		await LoadPage();
+	}
+
+	/// <summary>The persona's lists and which of them hold the account, for an account the persona follows.</summary>
+	async Task LoadLists()
+	{
+		if (relationship?.Following != true)
+		{
+			allLists = [];
+			inLists = [];
+			return;
+		}
+		allLists = await ListService.All();
+		inLists = [.. (await ListService.Of(account.Id)).Select(l => l.Id)];
+	}
+
+	async Task SetListMember(MastodonList list, bool member)
+	{
+		isActing = true;
+		var result = await ListService.SetMember(list.Id, account.Id, member);
+		isActing = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		if (member)
+			inLists.Add(list.Id);
+		else
+			inLists.Remove(list.Id);
+		Toast.AddResponseSuccess(member ? Localizer["{0} added to {1}.", account.Name, list.Title] : Localizer["{0} removed from {1}.", account.Name, list.Title]);
+	}
+
+	async Task LoadPage()
+	{
+		isLoadingMore = true;
+		var result = await AccountService.Statuses(account.Id, tab, maxId);
+		isLoadingMore = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		var page = (FeedPage)result.Data;
+		var known = posts.Select(p => p.Key).ToHashSet();
+		posts.AddRange(page.Posts.Where(p => !known.Contains(p.Key)));
+		maxId = page.MaxId;
+		await InstanceService.Resolve(page.Posts.Select(p => p.Host).Append(InstanceService.SelfHost));
+		InstanceService.Locate(page.Posts);
+	}
+
+	async Task LoadMore() => await LoadPage();
+
+	async Task SelectTab(int index)
+	{
+		tab = (ProfileTab)index;
+		posts = [];
+		maxId = null;
+		await LoadPage();
+	}
+
+	async Task ToggleFollow() =>
+		await Do(relationship is { Following: true } or { Requested: true } ? AccountAction.Unfollow : AccountAction.Follow);
+
+	async Task Do(AccountAction action)
+	{
+		var name = account.Name ?? account.Acct;
+		if (action is AccountAction.Block or AccountAction.Mute
+			&& !await Confirm.Ask(action == AccountAction.Block ? Localizer["Block {0}?", name] : Localizer["Mute {0}?", name], null,
+				Localizer[action == AccountAction.Block ? "Block" : "Mute"], action == AccountAction.Block))
+			return;
+		isActing = true;
+		var result = await AccountService.Act(account.Id, action);
+		isActing = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		relationship = (Relationship)result.Data ?? relationship;
+		if (action is AccountAction.Follow or AccountAction.Unfollow)
+			await LoadLists();
+		Toast.AddResponseSuccess(action switch
+		{
+			AccountAction.Follow when relationship?.Requested == true => Localizer["Asked {0} to accept you.", account.Name],
+			AccountAction.Follow => Localizer["Following {0}.", account.Name],
+			AccountAction.Unfollow => Localizer["{0} unfollowed.", account.Name],
+			AccountAction.Block => Localizer["{0} blocked.", account.Name],
+			AccountAction.Unblock => Localizer["{0} unblocked.", account.Name],
+			AccountAction.Mute => Localizer["{0} muted.", account.Name],
+			_ => Localizer["{0} unmuted.", account.Name]
+		});
+	}
+
+	void Remove(FeedPost post)
+	{
+		posts.RemoveAll(p => p.Key == post.Key);
+		pinned.RemoveAll(p => p.Key == post.Key);
+	}
+
+	async Task OpenTag(string tagName)
+	{
+		var filter = await LocalStorage.GetItemAsync<FeedFilter>(nameof(FeedFilter)) ?? new();
+		filter.Tag = tagName;
+		filter.TimelineType = TimelineType.Tag;
+		await LocalStorage.SetItemAsync(nameof(FeedFilter), filter);
+		Navigation.NavigateTo("");
+	}
+
+	async Task Back() => await JS.InvokeVoidAsync("history.back");
+}

Pages/Scheduled.razor

@@ -0,0 +1,147 @@
+@page "/scheduled"
+@attribute [Authorize]
+@inherits LocalizableComponentBase
+<Title>@Localizer["Scheduled posts"]</Title>
+
+@* The current persona's posts waiting for their time (/api/v1/scheduled_statuses): moved to another time, or dropped so
+   they are never published. The composer schedules them. *@
+<section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
+	<div class="flex flex-col gap-4 p-4 md:p-5 w-full h-full absolute overflow-y-auto">
+
+		<div class="flex items-center gap-2">
+			<i class="ion-md-time text-lg"></i>
+			<h1 class="font-bold truncate">@Localizer["Scheduled posts"]</h1>
+		</div>
+
+		@if (IsLoading)
+		{
+			<p class="flex w-full items-center justify-center gap-2">
+				<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+				@Localizer["loading"]
+			</p>
+		}
+		else if (scheduled.Count == 0)
+		{
+			<p class="w-full text-center" data-feed-empty><i class="ion-ios-remove-circle-outline"></i> @Localizer["Nothing is waiting to be published."]</p>
+		}
+
+		<div class="flex flex-col gap-3">
+			@foreach (var item in scheduled)
+			{
+				<article class="flex flex-col gap-2 p-3 md:p-4 rounded-xl neo-raised neo-xs" data-scheduled-id="@item.Id">
+					<div class="flex flex-wrap items-center gap-2 text-sm">
+						<i class="ion-md-time"></i>
+						<b>@item.ScheduledAt.ToLocalTime().ToString(SUtility.dateTimeFormatExt)</b>
+						<span class="opacity-70">@VisibilityName(item.Params.Visibility)</span>
+						@if (item.MediaAttachments.Count > 0)
+						{
+							<span class="opacity-70"><i class="ion-md-images"></i> @item.MediaAttachments.Count</span>
+						}
+					</div>
+					@if (item.Params.SpoilerText is { Length: > 0 } warning)
+					{
+						<p class="text-sm"><i class="ion-md-warning text-warning"></i> @warning</p>
+					}
+					<p class="text-sm whitespace-pre-wrap break-words">@item.Params.Text</p>
+					<div class="flex flex-wrap items-center gap-2">
+						<input type="datetime-local" class="input input-sm w-auto" autocomplete="off" aria-label="@Localizer["Publish it on"]"
+							   value="@(moves.GetValueOrDefault(item.Id) ?? item.ScheduledAt.ToLocalTime().ToString("yyyy-MM-ddTHH:mm"))"
+							   @onchange="@((ChangeEventArgs e) => moves[item.Id] = e.Value?.ToString())" />
+						<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || isSaving || !moves.ContainsKey(item.Id))" OnClick="@(() => Move(item))">
+							<i class="ion-md-checkmark"></i><span>@Localizer["Move"]</span>
+						</DButton>
+						<DButton Size="DSize.Sm" Disabled="@(IsDefaultDisabled || isSaving)" OnClick="@(() => Drop(item))">
+							<i class="ion-md-trash text-error"></i><span>@Localizer["Never publish it"]</span>
+						</DButton>
+					</div>
+				</article>
+			}
+		</div>
+	</div>
+</section>
+
+@code {
+	[Inject] StatusService StatusService { get; set; }
+	[Inject] ConfirmService Confirm { get; set; }
+
+	List<ScheduledStatus> scheduled = [];
+	readonly Dictionary<string, string> moves = [];
+	string loadedPersonaId;
+	bool isSaving;
+
+	string VisibilityName(string visibility) => visibility switch
+	{
+		"unlisted" => Localizer["Unlisted"],
+		"private" => Localizer["Followers only"],
+		"direct" => Localizer["Direct"],
+		_ => Localizer["Public"]
+	};
+
+	// The persona changed (NavMenu's switcher): its scheduled posts are another persona's.
+	protected override async Task OnParametersSetAsync()
+	{
+		if (CascadingState.PersonaId is null)
+		{
+			IsLoading = false;
+			return;
+		}
+		if (CascadingState.PersonaId == loadedPersonaId)
+			return;
+		loadedPersonaId = CascadingState.PersonaId;
+
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+	}
+
+	async Task LoadData()
+	{
+		IsLoading = true;
+		moves.Clear();
+		scheduled = await StatusService.Scheduled();
+		IsLoading = false;
+	}
+
+	async Task Move(ScheduledStatus item)
+	{
+		if (!DateTime.TryParse(moves[item.Id], System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.AssumeLocal, out var local))
+			return;
+		isSaving = true;
+		var result = await StatusService.Reschedule(item.Id, local.ToUniversalTime());
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		var moved = (ScheduledStatus)result.Data;
+		moves.Remove(item.Id);
+		item.ScheduledAt = moved.ScheduledAt;
+		scheduled = [.. scheduled.OrderBy(s => s.ScheduledAt)];
+		Toast.AddResponseSuccess(Localizer["Scheduled for {0}.", moved.ScheduledAt.ToLocalTime().ToString(SUtility.dateTimeFormatExt)]);
+	}
+
+	async Task Drop(ScheduledStatus item)
+	{
+		if (!await Confirm.Ask(Localizer["Never publish this post?"], null, Localizer["Never publish it"], true))
+			return;
+		isSaving = true;
+		var result = await StatusService.Unschedule(item.Id);
+		isSaving = false;
+		if (result.IsInvalid)
+		{
+			Toast.AddResponseError(result);
+			return;
+		}
+
+		scheduled.Remove(item);
+		Toast.AddResponseSuccess(Localizer["It will not be published."]);
+	}
+}

Pages/Search.razor

@@ -0,0 +1,132 @@
+@page "/search"
+@attribute [Authorize]
+@inherits LocalizableComponentBase
+<Title>@Localizer["Search"]</Title>
+
+@* Accounts, posts and hashtags (/api/v2/search). A handle (name@host) or a post's address is resolved by PrivaPub,
+   which fetches it from its server if it has not met it yet; the browser never contacts another server. *@
+<section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
+	<div class="flex flex-col gap-4 p-4 md:p-5 w-full h-full absolute overflow-y-auto">
+
+		<EditForm Model="form" OnValidSubmit="Run" class="flex flex-wrap gap-2 items-center">
+			<DInput TValue="string" class="flex-1 min-w-48" @bind-Value="form.Query" autocomplete="off" type="search"
+					placeholder="@Localizer["Search accounts, posts and tags, or paste an address"]">
+				<Prefix><i class="ion-md-search"></i></Prefix>
+			</DInput>
+			<DButton Type="submit" Size="DSize.Sm" Color="DColor.Primary" Disabled="@(IsDefaultDisabled || isSearching)">
+				@if (isSearching)
+				{
+					<DLoading Size="DSize.Xs" LabelText="@Localizer["loading"]" />
+				}
+				<span>@Localizer["Search"]</span>
+			</DButton>
+		</EditForm>
+
+		@if (searched)
+		{
+			@if (results.Accounts.Count == 0 && results.Statuses.Count == 0 && results.Hashtags.Count == 0)
+			{
+				<p class="w-full text-center"><i class="ion-ios-remove-circle-outline"></i> @Localizer["Nothing found."]</p>
+			}
+
+			@if (results.Accounts.Count > 0)
+			{
+				<h2 class="font-bold">@Localizer["Accounts"]</h2>
+				<div class="flex flex-col gap-2">
+					@foreach (var account in results.Accounts)
+					{
+						<a class="flex items-center gap-3 p-3 rounded-xl neo-raised neo-2xs min-w-0" href="@($"account/{Uri.EscapeDataString(account.Id)}")">
+							@* alt="": the name is next to it. *@
+							<img alt="" class="h-10 w-10 flex-none object-cover rounded-full" src="@(account.Avatar ?? "imgs/icon-192.png")" />
+							<span class="flex flex-col min-w-0">
+								<b class="truncate">@account.Name</b>
+								<span class="text-xs opacity-70 truncate">@("@" + account.Acct)</span>
+							</span>
+						</a>
+					}
+				</div>
+			}
+
+			@if (results.Hashtags.Count > 0)
+			{
+				<h2 class="font-bold">@Localizer["Hashtags"]</h2>
+				<div class="flex flex-wrap gap-2">
+					@foreach (var tag in results.Hashtags)
+					{
+						<DButton Size="DSize.Sm" OnClick="@(() => OpenTag(tag.Name))">#@tag.Name</DButton>
+					}
+				</div>
+			}
+
+			@if (results.Statuses.Count > 0)
+			{
+				<h2 class="font-bold">@Localizer["Posts and replies"]</h2>
+				<div class="flex flex-col gap-4">
+					@foreach (var post in statuses)
+					{
+						<Content @key="post.Key" Post="post" OnTag="OpenTag" />
+					}
+				</div>
+			}
+		}
+	</div>
+</section>
+
+@code {
+	[Inject] AccountService AccountService { get; set; }
+	[Inject] InstanceService InstanceService { get; set; }
+	[Inject] ILocalStorageService LocalStorage { get; set; }
+
+	[SupplyParameterFromQuery(Name = "q")] public string Q { get; set; }
+
+	sealed class SearchForm
+	{
+		public string Query { get; set; }
+	}
+
+	SearchForm form = new();
+	SearchResults results = new();
+	List<FeedPost> statuses = [];
+	bool searched;
+	bool isSearching;
+
+	protected override async Task OnInitializedAsync()
+	{
+		IsLoading = false;
+		if (string.IsNullOrWhiteSpace(Q))
+			return;
+		form.Query = Q;
+		await Run();
+	}
+
+	async Task Run()
+	{
+		if (string.IsNullOrWhiteSpace(form.Query))
+			return;
+		isSearching = true;
+		// a handle or an address is something to resolve; plain words only search what PrivaPub already holds
+		var resolve = form.Query.Contains('@') || form.Query.StartsWith("http", StringComparison.OrdinalIgnoreCase);
+		results = await AccountService.Search(form.Query, resolve);
+		statuses = [.. results.Statuses.Select(FeedPost.Of)];
+		searched = true;
+		isSearching = false;
+		await InstanceService.Resolve(statuses.Select(p => p.Host).Append(InstanceService.SelfHost));
+		InstanceService.Locate(statuses);
+		// a handle opens its account's profile, whatever else matched
+		var handle = form.Query.Trim().TrimStart('@');
+		if (form.Query.Contains('@') && results.Accounts.FirstOrDefault(a => string.Equals(a.Acct, handle, StringComparison.OrdinalIgnoreCase)
+				|| string.Equals($"{a.Acct}@{InstanceService.SelfHost}", handle, StringComparison.OrdinalIgnoreCase)) is { } exact)
+			Navigation.NavigateTo($"account/{Uri.EscapeDataString(exact.Id)}");
+		else if (results.Accounts.Count == 1 && results.Statuses.Count == 0 && form.Query.Contains('@'))
+			Navigation.NavigateTo($"account/{Uri.EscapeDataString(results.Accounts[0].Id)}");
+	}
+
+	async Task OpenTag(string tagName)
+	{
+		var filter = await LocalStorage.GetItemAsync<FeedFilter>(nameof(FeedFilter)) ?? new();
+		filter.Tag = tagName;
+		filter.TimelineType = TimelineType.Tag;
+		await LocalStorage.SetItemAsync(nameof(FeedFilter), filter);
+		Navigation.NavigateTo("");
+	}
+}

Pages/Settings.razor

@@ -21,6 +21,13 @@
 							 ValueChanged="v => Update(s => s.SetDarkMode(v))" ValueExpression="() => IsDark" />
 					<DToggle LabelText="@Localizer["Grey"]" Value="IsGray"
 							 ValueChanged="v => Update(s => s.SetGray(v, IsDark))" ValueExpression="() => IsGray" />
+					@* The theme is the login's: taken at sign-in, saved to it as it changes here (CascadingState.SaveSettingsSoon). *@
+					<DToggle LabelText="@Localizer["Keep the theme the same on every device signed in to this login"]" Value="CascadingState.PublicCacheData.PageSettings.SyncWithLogin"
+							 ValueChanged="v => Update(s => s.SyncWithLogin = v)" ValueExpression="() => CascadingState.PublicCacheData.PageSettings.SyncWithLogin"
+							 data-sync-with-login />
+					<DToggle LabelText="@Localizer["Remind me to describe pictures before publishing"]" Value="CascadingState.PublicCacheData.PageSettings.RemindAltText"
+							 ValueChanged="v => Update(s => s.RemindAltText = v)" ValueExpression="() => CascadingState.PublicCacheData.PageSettings.RemindAltText"
+							 data-remind-alt-text />
 					<label class="flex flex-col gap-2 max-w-md">
 						<span class="text-sm">@Localizer["Language"]</span>
 						@* Language names stay in their own language. Changing it reloads the app with the new culture. *@
@@ -46,6 +53,60 @@
 			</ChildContent>
 		</DCollapse>
 
+		<DCollapse Icon="DCollapseIcon.Arrow">
+			<Header>
+				<p class="inline-flex items-center gap-2">
+					<i class="ion-md-funnel text-xl"></i> <span>@Localizer["Filters"]</span>
+				</p>
+			</Header>
+			<ChildContent>
+				<div class="flex flex-wrap items-center gap-3 w-full p-3 md:p-4">
+					<p class="flex-1 min-w-48 text-sm">@Localizer["Words, phrases and posts this persona would rather not see, and where."]</p>
+					<a class="btn btn-sm" href="filters"><i class="ion-md-funnel"></i><span>@Localizer["Manage filters"]</span></a>
+				</div>
+			</ChildContent>
+		</DCollapse>
+
+		<DCollapse Icon="DCollapseIcon.Arrow">
+			<Header>
+				<p class="inline-flex items-center gap-2" data-settings-account>
+					<i class="ion-md-key text-xl"></i> <span>@Localizer["Login"]</span>
+				</p>
+			</Header>
+			<ChildContent>
+				<div class="block w-full p-3 md:p-4">
+					@if (CascadingState.IsSignedIn)
+					{
+						<AccountEditor />
+					}
+					else
+					{
+						<a class="link" href="login">@Localizer["Sign in to PrivaPub"]</a>
+					}
+				</div>
+			</ChildContent>
+		</DCollapse>
+
+		<DCollapse Icon="DCollapseIcon.Arrow">
+			<Header>
+				<p class="inline-flex items-center gap-2">
+					<i class="ion-md-people text-xl"></i> <span>@Localizer["Personas"]</span>
+				</p>
+			</Header>
+			<ChildContent>
+				<div class="block w-full p-3 md:p-4">
+					@if (CascadingState.IsSignedIn)
+					{
+						<PersonasEditor />
+					}
+					else
+					{
+						<a class="link" href="login">@Localizer["Sign in to PrivaPub"]</a>
+					}
+				</div>
+			</ChildContent>
+		</DCollapse>
+
 		<DCollapse Icon="DCollapseIcon.Arrow">
 			<Header>
 				<p class="inline-flex items-center gap-2">
@@ -54,9 +115,14 @@
 			</Header>
 			<ChildContent>
 				<div class="block w-full p-3 md:p-4">
-					<p class="w-full text-center text-lg">
-						<i class="ion-ios-remove-circle-outline"></i> @Localizer["Empty"]
-					</p>
+					@if (CascadingState.IsSignedIn)
+					{
+						<ProfileEditor />
+					}
+					else
+					{
+						<a class="link" href="login">@Localizer["Sign in to PrivaPub"]</a>
+					}
 				</div>
 			</ChildContent>
 		</DCollapse>
@@ -69,9 +135,37 @@
 			</Header>
 			<ChildContent>
 				<div class="block w-full p-3 md:p-4">
-					<p class="w-full text-center text-lg">
-						<i class="ion-ios-remove-circle-outline"></i> @Localizer["Empty"]
+					@if (CascadingState.IsSignedIn)
+					{
+						<div class="flex flex-col gap-6">
+							<PersonaArchivePanel />
+							<DataTransfer />
+						</div>
+					}
+					else
+					{
+						<a class="link" href="login">@Localizer["Sign in to PrivaPub"]</a>
+					}
+				</div>
+			</ChildContent>
+		</DCollapse>
+
+		<DCollapse Icon="DCollapseIcon.Arrow">
+			<Header>
+				<p class="inline-flex items-center gap-2">
+					<i class="ion-md-notifications text-xl"></i> <span>@Localizer["Notifications"]</span>
 				</p>
+			</Header>
+			<ChildContent>
+				<div class="block w-full p-3 md:p-4">
+					@if (CascadingState.IsSignedIn)
+					{
+						<NotificationPolicyEditor />
+					}
+					else
+					{
+						<a class="link" href="login">@Localizer["Sign in to PrivaPub"]</a>
+					}
 				</div>
 			</ChildContent>
 		</DCollapse>
@@ -84,9 +178,14 @@
 			</Header>
 			<ChildContent>
 				<div class="block w-full p-3 md:p-4">
-					<p class="w-full text-center text-lg">
-						<i class="ion-ios-remove-circle-outline"></i> @Localizer["Empty"]
-					</p>
+					@if (CascadingState.IsSignedIn)
+					{
+						<MutesAndBlocks />
+					}
+					else
+					{
+						<a class="link" href="login">@Localizer["Sign in to PrivaPub"]</a>
+					}
 				</div>
 			</ChildContent>
 		</DCollapse>

Pages/Setup.razor

@@ -0,0 +1,137 @@
+@page "/setup"
+@inherits LocalizableComponentBase
+<Title>@Localizer["Set up PrivaPub"]</Title>
+
+@* The server's first login, made while it has no administrator (PrivaPub's /clientapi/user/setup; owner decision 2026-10-16,
+   first come, first served): it becomes the administrator, with its first persona, and setup closes for good. Everyone
+   else joins through a group's invitation (Join). *@
+<section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
+
+	<div class="flex flex-col items-center gap-6 p-4 md:p-5 w-full h-full absolute overflow-y-auto">
+
+		@if (IsLoading)
+		{
+			<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
+		}
+		else if (CascadingState.IsSignedIn)
+		{
+			<div class="flex flex-col gap-3 w-full max-w-sm mt-6 md:mt-16 p-5 rounded-xl neo-raised neo-sm">
+				<h1 class="text-xl font-bold">@Localizer["You are signed in"]</h1>
+				<DButton Href="" Color="DColor.Primary">@Localizer["Home"]</DButton>
+			</div>
+		}
+		else if (!isPending)
+		{
+			<div class="flex flex-col gap-3 w-full max-w-sm mt-6 md:mt-16 p-5 rounded-xl neo-raised neo-sm" data-setup-done>
+				<h1 class="text-xl font-bold">@Localizer["This server is set up"]</h1>
+				<p class="text-sm">@Localizer["It has an administrator already: sign in, or join with a group's invitation."]</p>
+				<div class="flex flex-wrap gap-2 pointer-coarse:gap-2">
+					<DButton Href="login" Color="DColor.Primary">@Localizer["Login"]</DButton>
+					<DButton Href="join">@Localizer["Join with an invitation"]</DButton>
+				</div>
+			</div>
+		}
+		else
+		{
+			<EditForm Model="form" OnValidSubmit="SetUp" class="flex flex-col gap-4 w-full max-w-sm mt-6 md:mt-16 p-5 rounded-xl neo-raised neo-sm" data-setup>
+				<DataAnnotationsValidator />
+				<h1 class="text-xl font-bold">@Localizer["Set up PrivaPub"]</h1>
+				<p class="text-sm opacity-70">@Localizer["This server has no administrator yet. The first login made here becomes it, with its first persona; after that, joining takes a group's invitation."]</p>
+
+				<b class="text-sm">@Localizer["Your login"]</b>
+				<label class="flex flex-col gap-1">
+					<span class="text-sm">@Localizer["Username"]</span>
+					<DInput TValue="string" class="w-full" @bind-Value="form.UserName" autocomplete="username" autocapitalize="none" spellcheck="false" data-setup-username>
+						<Prefix><i class="ion-md-person"></i></Prefix>
+					</DInput>
+				</label>
+				<label class="flex flex-col gap-1">
+					<span class="text-sm">@Localizer["Password"]</span>
+					<DInput TValue="string" Type="password" class="w-full" @bind-Value="form.Password" autocomplete="new-password" data-setup-password>
+						<Prefix><i class="ion-md-key"></i></Prefix>
+					</DInput>
+				</label>
+				<label class="flex flex-col gap-1">
+					<span class="text-sm">@Localizer["Repeat the password"]</span>
+					<DInput TValue="string" Type="password" class="w-full" @bind-Value="repeatedPassword" autocomplete="new-password" data-setup-repeat>
+						<Prefix><i class="ion-md-key"></i></Prefix>
+					</DInput>
+				</label>
+
+				<b class="text-sm">@Localizer["Your first persona"]</b>
+				<p class="text-xs opacity-70">@Localizer["Others see your personas, never your login."]</p>
+				<DInput TValue="string" class="w-full" @bind-Value="form.AvatarUserName" autocomplete="off" autocapitalize="none" spellcheck="false"
+						maxlength="@PrivaPub.ClientModels.Constants.MaxAvatarNameLength" placeholder="@Localizer["user name (a-z, 0-9, _)"]" data-setup-persona-username>
+					<Prefix>@@</Prefix>
+				</DInput>
+				<DInput TValue="string" class="w-full" @bind-Value="form.AvatarName" autocomplete="off" maxlength="64"
+						placeholder="@Localizer["Display name"]" data-setup-persona-name />
+
+				<ErrorViewer AdditionalError="@error" />
+
+				<DButton Type="submit" Color="DColor.Primary" Disabled="IsDefaultDisabled || isWorking" data-setup-submit>
+					@if (isWorking)
+					{
+						<DLoading Size="DSize.Sm" LabelText="@Localizer["loading"]" />
+					}
+					<span>@Localizer["Set up PrivaPub"]</span>
+				</DButton>
+			</EditForm>
+		}
+
+	</div>
+
+</section>
+
+@code {
+	[Inject] AuthService AuthService { get; set; }
+
+	readonly SetupForm form = new();
+	string repeatedPassword;
+	string error;
+	bool isPending;
+	bool isWorking;
+
+	protected override async Task OnInitializedAsync()
+	{
+		if (CascadingState.IsOffline)
+		{
+			WhenOnline(LoadData);
+			StartOnlinePolling();
+			IsLoading = false;
+			return;
+		}
+
+		await LoadData();
+		IsLoading = false;
+	}
+
+	async Task LoadData() => isPending = await AuthService.SetupPending();
+
+	async Task SetUp()
+	{
+		error = default;
+		if (form.Password != repeatedPassword)
+		{
+			error = Localizer["The two passwords don't match."];
+			return;
+		}
+
+		isWorking = true;
+		form.AvatarUserName = form.AvatarUserName?.Trim().TrimStart('@').ToLowerInvariant();
+		var result = await AuthService.SetUp(form);
+		if (result.IsInvalid)
+		{
+			isWorking = false;
+			// set up meanwhile: the page says so
+			isPending = result.StatusCode != (int)System.Net.HttpStatusCode.Forbidden;
+			error = result.ErrorMessage;
+			return;
+		}
+
+		await CascadingState.SignedIn(result.Data as JwtUser);
+		isWorking = false;
+		Toast.AddResponseSuccess(Localizer["PrivaPub is set up: you are its administrator."]);
+		Navigation.NavigateTo("");
+	}
+}

Pages/Thread.razor

@@ -4,7 +4,9 @@
 <Title>@Localizer["Thread"]</Title>
 
 @* A post with its thread (/api/v1/statuses/{id}/context): the posts it answers above, the post, the answers below.
-   The cards do their own actions; a reply or a deletion updates the thread here. *@
+   The cards do their own actions; a reply or a deletion updates the thread here. The persona's thread filters apply
+   to the posts around the one it opened, never to that one. Opening a remote thread makes PrivaPub read its replies
+   from their servers, so the thread is read twice more, a few seconds later, and what was found joins it. *@
 <section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
 	<div class="flex flex-col gap-4 p-4 md:p-5 w-full h-full absolute overflow-y-auto">
 
@@ -32,14 +34,14 @@
 		{
 			@foreach (var post in ancestors)
 			{
-				<Content @key="post.Key" Post="post" CssContainer="ml-6 w-auto" OnDeleted="Remove" OnReplied="Replied" OnTag="OpenTag" />
+				<Content @key="post.Key" Post="post" CssContainer="ml-6 max-w-[calc(100%-1.5rem)]" FilterIn="FilterContext.Thread" OnDeleted="Remove" OnReplied="Replied" OnTag="OpenTag" />
 			}
 
 			<Content @key="current.Key" Post="current" Highlighted="true" IncludeExpand="false" OnDeleted="Remove" OnReplied="Replied" OnTag="OpenTag" />
 
 			@foreach (var post in descendants)
 			{
-				<Content @key="post.Key" Post="post" CssContainer="ml-6 w-auto" OnDeleted="Remove" OnReplied="Replied" OnTag="OpenTag" />
+				<Content @key="post.Key" Post="post" CssContainer="ml-6 max-w-[calc(100%-1.5rem)]" FilterIn="FilterContext.Thread" OnDeleted="Remove" OnReplied="Replied" OnTag="OpenTag" />
 			}
 		}
 	</div>
@@ -53,10 +55,14 @@
 
 	[Parameter] public string StatusId { get; set; }
 
+	// when the thread is read again, after PrivaPub has had time to fetch the replies held on other servers
+	static readonly TimeSpan[] Rereads = [TimeSpan.FromSeconds(4), TimeSpan.FromSeconds(15)];
+
 	FeedPost current;
 	List<FeedPost> ancestors = [];
 	List<FeedPost> descendants = [];
 	string loadedId;
+	CancellationTokenSource rereading;
 
 	protected override async Task OnParametersSetAsync()
 	{
@@ -77,6 +83,9 @@
 
 	async Task LoadData()
 	{
+		rereading?.Cancel();
+		rereading?.Dispose();
+		rereading = null;
 		IsLoading = true;
 		var status = await StatusService.Get(StatusId);
 		if (status is null)
@@ -95,6 +104,42 @@
 		var all = ancestors.Append(current).Concat(descendants).ToList();
 		await InstanceService.Resolve(all.Select(p => p.Host).Append(InstanceService.SelfHost));
 		InstanceService.Locate(all);
+
+		if (new[] { current, ancestors.FirstOrDefault() }.Any(p => p is not null && p.Host != InstanceService.SelfHost))
+		{
+			rereading = new();
+			_ = Reread(status.Id, rereading.Token);
+		}
+	}
+
+	// the answers PrivaPub found since, in the thread's order; the cards already shown stay as they are, and one the
+	// thread no longer lists (a reply just made, not yet in it) stays at the end
+	async Task Reread(string statusId, CancellationToken cancellationToken)
+	{
+		foreach (var pause in Rereads)
+		{
+			try
+			{
+				await Task.Delay(pause, cancellationToken);
+			}
+			catch (OperationCanceledException)
+			{
+				return;
+			}
+			var context = await StatusService.Context(statusId, cancellationToken);
+			if (cancellationToken.IsCancellationRequested || context is null)
+				return;
+			var shown = descendants.ToDictionary(p => p.Key);
+			var found = context.Descendants.Where(s => !shown.ContainsKey(s.Id)).Select(FeedPost.Of).ToList();
+			if (found.Count == 0)
+				continue;
+			var listed = context.Descendants.Select(s => s.Id).ToHashSet();
+			descendants = [.. context.Descendants.Select(s => shown.GetValueOrDefault(s.Id) ?? found.First(p => p.Key == s.Id)),
+				.. descendants.Where(p => !listed.Contains(p.Key))];
+			await InstanceService.Resolve(found.Select(p => p.Host));
+			InstanceService.Locate(found);
+			await InvokeAsync(StateHasChanged);
+		}
 	}
 
 	void Remove(FeedPost post)
@@ -127,4 +172,14 @@
 	}
 
 	async Task Back() => await JS.InvokeVoidAsync("history.back");
+
+	public override async ValueTask DisposeAsync()
+	{
+		if (rereading is not null)
+		{
+			await rereading.CancelAsync();
+			rereading.Dispose();
+		}
+		await base.DisposeAsync();
+	}
 }

Program.cs

@@ -11,7 +11,6 @@ using Toolbelt.Blazor.Extensions.DependencyInjection;
 using Microsoft.AspNetCore.Components.Authorization;
 using Microsoft.AspNetCore.Components.Web;
 using PrivaPub.ClientModels;
-using collAnon.Client.Services;
 
 var builder = WebAssemblyHostBuilder.CreateDefault(args);
 builder.RootComponents.Add<App>("#app");
@@ -40,7 +39,19 @@ builder.Services.AddOptions()
 	.AddScoped<RequestStats>()
 	.AddScoped<AuthService>()
 	.AddScoped<TimelineService>()
+	.AddScoped<FeedMemory>()
 	.AddScoped<StatusService>()
+	.AddScoped<AccountService>()
+	.AddScoped<PortabilityService>()
+	.AddScoped<AdminService>()
+	.AddScoped<ArchiveService>()
+	.AddScoped<ListService>()
+	.AddScoped<FilterService>()
+	.AddScoped<DiscoveryService>()
+	.AddScoped<StreamingService>()
+	.AddScoped<PublicNoticeService>()
+	.AddScoped<ConfirmService>()
+	.AddScoped<OverlayService>()
 	.AddScoped<MediaService>()
 	.AddScoped<GroupService>()
 	.AddScoped<InstanceService>()
@@ -51,15 +62,15 @@ builder.Services.AddOptions()
 	.AddTransient<IHttpService, HttpService>()
 	.AddHeadElementHelper(options => options.DisableClientScriptAutoInjection = true)
 	.AddLocalization()
-	.AddTransient<IStorage, Storage>()
-	.AddLogging(lb => lb.SetMinimumLevel(LogLevel.Debug))
-	.AddIndexedDb();
+	.AddLogging(lb => lb.SetMinimumLevel(LogLevel.Debug));
 
 var apiBaseAddress = builder.Configuration["AppConfiguration:ApiBaseAddress"];
 builder.Services.AddHttpClient("default", client =>
 {
 	client.BaseAddress = new Uri(string.IsNullOrEmpty(apiBaseAddress) ? builder.HostEnvironment.BaseAddress : apiBaseAddress.TrimEnd('/') + "/");
 	client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+	// each request has its own timeout (HttpService.Measure): an upload may take minutes, anything else 100 s
+	client.Timeout = Timeout.InfiniteTimeSpan;
 });
 
 builder.Services.AddSingleton(serviceProvider =>

Resources/ErrorMessages.Designer.cs

@@ -60,6 +60,24 @@ namespace decePubClient.Resources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to The {0} field is not a valid date..
+        /// </summary>
+        public static string InvalidDate {
+            get {
+                return ResourceManager.GetString("InvalidDate", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The {0} field is not valid..
+        /// </summary>
+        public static string InvalidValue {
+            get {
+                return ResourceManager.GetString("InvalidValue", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to The field {0} can be at most {1} characters long..
         /// </summary>

Resources/ErrorMessages.it.resx

@@ -41,6 +41,12 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
+  <data name="InvalidDate" xml:space="preserve">
+    <value>Il campo {0} non è una data valida.</value>
+  </data>
+  <data name="InvalidValue" xml:space="preserve">
+    <value>Il campo {0} non è valido.</value>
+  </data>
   <data name="MaxLength" xml:space="preserve">
     <value>Il campo {0} può contenere al massimo {1} caratteri.</value>
   </data>