# Platform flags

Things known or suspected to behave differently outside Windows, plus deployment gotchas that
have already cost time once. Development is Windows-first, but **the full test suite now runs on
Linux in CI on every change**, so a Linux claim here is usually a measurement now rather than a
suspicion. **macOS is still untested**, and anything marked *unverified* has not run on the platform
in question and must not be assumed to work.

Each entry says what the risk is, why it matters, and what to do about it. Delete an entry when it
has been verified or made moot — not when it merely stops being convenient.

## Cryptography

**`ChaCha20Poly1305.IsSupported` is false on macOS**, and on Windows builds before 10.0.20142.
This is why the client uses NSec (libsodium) rather than the BCL for content encryption; see
docs/crypto.md §1. *Already mitigated* — but if a BCL AEAD path is ever added as a fallback it
**must** gate on `IsSupported` rather than assuming availability, or the client will fail to open
any vault on macOS.

**Argon2id timings are measured on one Windows machine only.** 256 MiB with t=4 took 323 ms here.
The floor and ceiling in `EnrollmentLimits` were chosen against that number. *Unverified
elsewhere:* recalibrate on the slowest target platform before recommending a default profile,
because a cost that is comfortable on a desktop can make unlock unusable on a low-power laptop —
and the parameters are stored per user at enrollment, so a bad default is a per-user migration.

**libsodium ships native binaries per RID.** This complicates single-file and AOT publishing, and
on macOS every native library (`libsodium`, `libSkiaSharp`, `libHarfBuzzSharp`, `libe_sqlite3`)
must be signed **individually** with `--options runtime --timestamp` before the bundle is signed,
or notarization fails with an error that does not name the offending file.

## Desktop client

**The local pane's roots bar is built differently per platform, and has to be.** On Windows it is the
ready drives, from `DriveInfo.GetDrives`. On Unix that same call answers with every mount the kernel
holds — around forty on an ordinary laptop, counting `/proc`, `/sys/fs/bpf`, one per installed snap and
`/run/user/1000/doc` — and the transfers screen draws a button per root, so the bar ran to roughly five
thousand pixels inside an eight-hundred pixel window. *Fixed* in `LocalDirectory.Roots`, which on Unix
returns the root, the user's home, and whatever is mounted under `/run/media/<user>`, `/media`, `/mnt`
or `/Volumes`. Do not try to filter `GetDrives` instead: `DriveType` reports `Fixed` for `/` and `/home`
but also for every squashfs snap, for `efivarfs` and for `tracefs`, while `/boot/efi` comes back
`Removable`, and `DriveFormat` would need a hand-kept list of every virtual filesystem Linux may grow.
Found by the layout suite on its first Linux run, which is the argument for that suite existing.

**The WebView runs on Windows.** `Avalonia.Controls.WebView` 12.0.1 (MIT, no licence key) hosts the
terminal page: WebView2 launches, navigates to the loopback page, runs its JavaScript and completes the
WebSocket handshake. Verified by observing an established TCP connection from `msedgewebview2` to the data
plane port.

Note precisely what that evidence covers, because it was once stretched to cover more: every clause above
is about the process and the socket. It says nothing about how the control **composites** with
Avalonia-drawn content, which is the axis on which it does not behave like an ordinary control — see the
next entry.

**A native child window cannot be covered by Avalonia content, on any platform that hosts it windowed.**
`NativeWebView` attaches a real Win32 child HWND through `NativeControlHost` — on Windows the backend
creates a `WS_CHILD` holder window and `SetParent`s WebView2's HWND into it — and a child window paints
above everything its parent draws, whatever the visual tree's z-order says. This is by design and
acknowledged upstream: *"NativeControlHost places native controls over Avalonia content just like WPF one
does. So it suffers from the same airspace problem"* (Avalonia's maintainer,
[#6605](https://github.com/AvaloniaUI/Avalonia/issues/6605), still open). Reproduced in a 60-line standalone
app with no DodoSSH code: a `340,*` grid, a `NativeWebView` in column 1 and an opaque `Border` as a later
`Panel` sibling renders the overlay sliced dead on x=340.

Layering a screen over the terminal therefore does nothing: the WebView's rectangle stays on top. In this
shell that sliced the setup
and unlock cards at the terminal column's left edge, put every one of their buttons inside the WebView's
rectangle at the window's default width — so the flow could only be completed by keyboard — and handed
Win32 focus to WebView2 on any click in that region, which makes a text box stop accepting keystrokes with
no visible cause. That last symptom is the focus asymmetry documented further down, not a separate fault:
focus crosses into the WebView readily and does not come back on its own.

The fix is to collapse the control, not to cover it: `IsVisible="{Binding IsUnlocked}"` on the
`NativeWebView`. That is safe, and this is the part worth recording, because the opposite was asserted here
for a while:

- `NativeControlHost` creates the native attachment from **attach to the visual tree**, not from layout and
  not from visibility. Its `UpdateHost` never reads `IsEffectivelyVisible`; only
  `TryUpdateNativeControlPosition` does, choosing `HideWithSize` over `ShowInBounds`.
- `NativeWebView` stashes a `Source` assigned before its adapter exists and replays it once created, so
  navigation is never lost to ordering. The shell already depends on that replay.
- So a collapsed WebView still starts WebView2, still loads the page and still lets the renderer attach its
  socket. Measured on Windows in a harness mirroring the data plane's handshake, with `IsVisible=false` set
  before the window was ever shown: adapter created, `GET /`, then **the WebSocket 101 sent** — the moment
  `RendererAttached` fires — followed by frames arriving over the socket, all while hidden. A cold WebView2
  profile behaves the same. Revealing it recomputes bounds within about 7 ms, on one `ResizeObserver`
  callback, over the same socket.

  It must be `IsVisible`, not removal from the tree. Detaching runs `DestroyNativeControl` and takes the
  whole WebView2 process tree with it, so conditional content or a template swap would pay a cold start on
  every unlock. Hiding merely does
  `SetWindowPos(holder, …, SWP_HIDEWINDOW)`. Negative `Margin` also works as a runtime toggle;
  `RenderTransform` does **not**, because `NativeControlHost` never watches it.

  Note the earlier version of this bullet cited "35 `msedgewebview2` processes" as the confirmation. A
  process count cannot show that a socket was accepted — it is the same shape of mistake as the one
  described below, one level down.

The previous version of this entry claimed the reverse — that hiding it would mean never realising it — and
cited the `msedgewebview2` connection as verification. That observation was made while the overlay was
showing but, because of the airspace behaviour above, the WebView was in fact uncovered and in plain view.
It confirmed only that a *visible* WebView is realised, which nobody disputed, and could not discriminate
the case it was attached to. A process-level check cannot verify a rendering claim; that needs a
screenshot, and this defect shipped because one was never taken.

**What the first connection after unlocking actually depends on** is the `await
workspace.WaitForRendererAsync(cancellationToken)` in `VaultViewModel.ConnectAsync`, because
`TerminalDataPlane.SendAsync` drops frames when no renderer is attached rather than queueing them. That
await is the invariant; the control's visibility is not.

It is now bounded — `TerminalWorkspaceOptions.RendererTimeout`, 15 s, plus the command's own token —
because whether the renderer attaches at all depends on a runtime this application does not install. A
missing or policy-blocked Evergreen runtime, or an AppContainer that cannot reach loopback, previously
left Connect waiting forever with `IsBusy` stuck and nothing on screen to explain it. The gate is
unchanged; only the wait is. Why 15 s and not less: attaching is near-instant in the normal case (the page
attaches while the unlock screen is still up), but a cold WebView2 profile creates a user-data directory
and starts its process tree first, and reporting a broken runtime to someone whose runtime was merely slow
is the worse error. The timeout is caught in `VaultViewModel` and reported as a message naming WebView2,
because `TimeoutException.Message` is "The operation has timed out" and names nothing.

**Hiding the WebView does not pause it.** With the holder window hidden, the page keeps
`visibilityState: "visible"` and `requestAnimationFrame` keeps firing at roughly 115/s — Chromium does not
treat a hidden child HWND as a hidden page. That is *why* the handshake completes while collapsed, so it is
load-bearing rather than merely wasteful, but it means a locked DodoSSH is still animating a full-size
off-screen page. Worth revisiting if idle power ever matters.

**A degenerate pane size reaches the remote pty.** The fit addon floors its proposal at 2 columns by 1 row
rather than refusing, so any path that fits a terminal with almost no viewport sends `window-change` for a
2x1 window and permanently mangles the wrapped scrollback. Reachable today by minimising, and — once splits
land — by dragging a splitter to the edge. `terminal.js` now skips the fit below 40 px in either axis.
Related, and now fixed: the conflict log was an `ItemsControl` with no `ScrollViewer` and no `MaxHeight` on
an `Auto` row, so enough conflicts squeezed the row below it toward nothing. It survived that long because
it lived in `MainWindow.axaml`, which no test can lay out. Moving it into `HostsScreen.axaml` — a
`UserControl`, and therefore measurable — is what surfaced it; it now has both, and
`TheHostsScreenFitsWithAConflictLogTooLongToShow` fails without them.

**Keyboard focus crosses into the WebView by itself and does not come back.** This is the asymmetry to
know; the connect-focus bug that led here was only its first symptom. Measured on Windows with a harness
that reports `GetFocus()`, the class name of the window holding it, and the page's own
`document.hasFocus()` at each step.

- **Into the page: nothing custom is needed.** `NativeWebView` overrides `Focusable` to true and its
  `OnGotFocus` calls the adapter's `Focus()`, which on Windows is
  `ICoreWebView2Controller::MoveFocus(PROGRAMMATIC)`. A plain Avalonia `Terminal.Focus()` therefore moves
  real Win32 focus to the `Chrome_WidgetWin_1` child and the page reports `hasFocus: true`. No `SetFocus`
  P/Invoke and no COM work — the package version of this entry that assumed otherwise was wrong. The
  control also replays a `Focus()` that arrived before its adapter existed, and re-asserts itself: while
  it holds Win32 focus its `GotFocus` handler pulls Avalonia's *logical* focus back onto the control. Worth
  stating positively, because the reasonable guess before measuring — that crossing into a child HWND must
  need `SetFocus` — is the wrong way round: it is the return trip that needs it.
- **Out of the page: the package does nothing at all.** `OnLostFocus` calls the adapter's `ResignFocus()`,
  and on Windows that method is **empty**. So `someTextBox.Focus()` moves Avalonia's focused element while
  Win32 focus stays on WebView2: a text box with a caret that silently receives nothing. `Window.Activate()`
  and `Window.Focus()` were both measured and neither recovers it. The hand-back has to be
  `SetFocus(topLevelHwnd)` — see `Views/NativeKeyboardFocus.cs`. A real mouse click *does* recover it,
  because Avalonia's window sets focus on pointer input, which is exactly why this is invisible to anyone
  who clicks before typing.
- **Collapsing the control does not release the keyboard.** With `IsVisible=false` the holder window is
  hidden but Win32 focus stays on it — measured as focus held by a window reporting `visible=False`, with
  Avalonia's focused element becoming `(none)`. So locking the vault after touching the terminal left the
  unlock passphrase box eating keystrokes. The lock path now hands the keyboard back and focuses that box.
- **`Focus()` on a collapsed control is a no-op and is not replayed on reveal.** Order matters: reveal,
  then focus. Focus does survive a lock/unlock cycle when done that way.
- **There is no Tab-out.** The package subscribes `ICoreWebView2Controller::add_MoveFocusRequested` and its
  handler body is empty, so WebView2's request to move focus off itself is discarded; xterm eats Tab
  anyway. The way out is `Ctrl+Shift+F6`, intercepted in `terminal.js` and sent to the host as a web
  message — measured arriving verbatim in `WebMessageReceivedEventArgs.Body`. It has to be handled in the
  page, because once the child window owns Win32 focus Avalonia sees no key events and no `KeyBinding`
  could fire. Not Escape, and not a bare F6: both are keys a TUI legitimately binds, and Ctrl+Shift is the
  range terminal emulators conventionally keep for themselves.

None of this is covered by a test, and cannot be here: headless Avalonia has no native window, so a
headless test renders and focuses correctly and would confirm the wrong belief. What the suite covers is
the plumbing that drives it — that connecting asks for focus once per session, that a failed connect does
not, and that locking stops the forwarding.

**The lock/unlock cycle does not resize the pane at all, and the 40 px guard is not what makes it safe.**
Measured on Windows with a live shell, against a real `sshd` in a container, in a harness mirroring
`MainWindow.axaml`'s `340,*` grid: with the `NativeWebView` collapsed by `IsVisible=false`, the page still
reports `paneWidth: 840, paneHeight: 760`, unchanged `cols`/`rows`, and `visibilityState: "visible"`.
Hiding is `SetWindowPos(holder, …, SWP_HIDEWINDOW)`, which does not resize the holder, so no
`ResizeObserver` callback fires, no fit runs, and **no `window-change` reaches the remote** — before,
during or after the cycle. `stty size` on the remote answered `50 118` both before locking and after
unlocking, and the renderer's own buffer came back byte for byte, wrapped lines included.

The guard's irrelevance here was established rather than assumed: the same run with
`MINIMUM_FITTABLE_PIXELS` patched to `0` — the guard fully disabled — produced an identical clean result.
So the guard is still worth keeping for the paths it was written for, minimising and a splitter dragged to
the edge, but it is **not** on the lock path and must not be cited as the reason locking is safe. It was
described that way when it landed.

Two further results from the same harness, both about the deliberate decision that shells outlive a lock
(README, `MainWindowViewModel.LockAsync`):

- **A collapsed WebView is not typed into.** With the harness confirmed as the foreground window and all
  twelve injected `SendInput` events accepted, not one character of the probe reached the remote pty, and a
  `Ctrl-U` afterwards answered `BEL` — nothing was sitting in the remote's line editor either. So the lock
  screen is a real input barrier even though the session behind it is live, and that is what makes
  surviving the lock defensible rather than merely convenient. The *mechanism* is not what this run
  concluded: it read the result as a hidden `WS_CHILD` window being ineligible for keyboard focus, but the
  focus entry above measured Win32 focus still held by the hidden holder window, and the lock path now
  moves the keyboard off it deliberately. Take the barrier as measured here and the reason from there —
  which also means the barrier is something the lock path maintains, not something the platform guarantees.
- **The session survives the cycle in the real control, not only in tests.** `LiveSessionCount` was 1
  before, during and after, and the shell accepted a command again immediately on unlock.

*Suspected, seen once, not reproduced:* on the first run — before the harness learned to wait for the
window's scale to settle — the window opened at 2558x1367 px and the page reported a 2202x1328 pane
(312x88 characters) for a window 1180 logical units wide, which looks like physical pixels arriving where
CSS pixels were expected. A later re-push to 1177x672 then reflowed the wrapped line and split it in two.
Both events straddled a DPI settle rather than the lock, and three later runs at `RenderScaling 1.00`
never showed it. If a user reports mangled scrollback after moving the window between displays of
different scale, start here.

**WebView2 will not initialise when the host executable sits under a very long path.**
`CreateCoreWebView2Environment` fails with `COMException 0x80080005 CO_E_SERVER_EXEC_FAILURE` ("Server
execution failed") and the terminal never appears. Hit while building the harness above: the same binary
that failed from a ~230-character directory ran first time from `%TEMP%\h`. The exact threshold was not
established and the mechanism is unconfirmed — the user data folder is created beside the executable by
default and the browser process is launched with paths derived from it, so `MAX_PATH` is the obvious
suspect. Relevant to packaging: an installer that lands under a deep per-user path would break the
terminal with an error that names nothing.

**The Windows app manifest must declare a `supportedOS` list.** Without it the process reports a
downlevel Windows version and Avalonia's native control host fails outright — *"Unable to create child
window for native control host"* — so the WebView, and therefore the terminal, does not start at all.
`[STAThread]` on `Main` is equally mandatory: WebView2 checks the apartment state and refuses to
initialise on an MTA thread.

**WebView2 spawns a process tree, not a process.** Around 35 processes were observed for one embedded
view. That is the concrete reason the design uses one WebView hosting N terminals rather than one per
tab: twenty tabs would mean twenty of those trees.

**The Linux WebView needs `ExperimentalOffscreen`, or the terminal is blank.** This entry used to predict
that WPE (`libwpewebkit-2.0`) would be the Linux backend and be too rarely installed; the prediction was
wrong in its details and right about the outcome. Measured on Fedora 44 with
`Avalonia.Controls.WebView` 12.0.1, by a spike that hosts a `NativeWebView` and reads `AdapterInfo`:

- The adapter is **WebKitGTK 2.52.5**, not WPE, and it reports `IsSupported = True`. Fedora packages no
  WPE WebKit at all — `dnf search wpe` returns a computer-algebra package and nothing else — so the WPE
  path is not merely rare there, it is unavailable.
- In its default mode that adapter reports **`SupportedScenarios = NativeDialog`**: a window of its own,
  and nothing that can be hosted in place. The same under X11 and under Wayland, so this is the adapter's
  answer rather than a session-type problem.
- Setting **`ExperimentalOffscreen`** on `GtkWebViewEnvironmentRequestedEventArgs` changes the same
  adapter's answer to **`OffscreenRenderer`** — the compositor-drawn mode, which is what
  `NativeWebViewCompositorHost` (mentioned below as an unknown) exists to host. `MainWindow` sets it; see
  `OnTerminalEnvironmentRequested`, which is a no-op on Windows and macOS by type rather than by OS check.
- In both modes the page loads and `InvokeScript` answers, which is the trap: **the failure has no
  diagnostics.** Everything except the pixels works, so it reads as the terminal being broken rather than
  as the host having nowhere to draw. `AdapterInfo.SupportedScenarios` is the thing to look at first.

*Still unverified:* whether the offscreen mode actually paints, and how it behaves for input, IME and
resizing. The spike could not answer it — an XWayland root capture is black under a Wayland compositor
and `RenderTargetBitmap` does not capture a compositor surface — so it needs eyes on a running client.
macOS 15 remains untested entirely.

`ITerminalHost` was supposed to be the seam that keeps a backend swap cheap, and it is **declared but not
implemented** — nothing in the application uses it, and the view navigates `NativeWebView.Source` directly.
Swapping backends today means editing `MainWindow.axaml` and its code-behind. That is a small job, but do
not plan around a seam that is currently only a file.

**`Avalonia.Diagnostics` has no 12.x release** (latest is 11.3.18), so the developer tools overlay is
unavailable on Avalonia 12. Development-only, so nothing ships differently — but debugging a layout
problem currently means reasoning rather than inspecting.

**The xterm bundles are vendored, not built.** `@xterm/xterm` 6.0.0 with the fit and webgl addons, all
MIT, committed as UMD bundles under `WebAssets/vendor` and embedded as Avalonia resources. No npm or
esbuild step, so a clean clone builds with the .NET SDK alone. The cost is that upgrades are a manual
re-download; the licence and versions are recorded here so that stays visible.

**Bracketed paste is the renderer's to decide, and it is why snippets go through a frame.** xterm tracks
`\e[?2004h` from the remote's own output and `Terminal.paste(text)` wraps the text in paste markers only
when the mode is on — which is what makes a shell treat embedded newlines as text rather than as "run
this". The host process cannot make that decision: `TerminalDataPlane` moves opaque bytes and never parses
output, so writing a snippet straight into the pump would mean guessing, and guessing wrong executes every
line of a multi-line command. Hence `TerminalServerOpcode.Paste`. Two consequences worth keeping:

- The Enter for a snippet marked as running goes through `Terminal.input('\r')`, **outside** the wrapper. A
  `\r` appended to the pasted text is bracketed with it and arrives as a literal character, so nothing runs.
- Against a remote with bracketed paste *off* — a raw `sh`, or a session inside an editor — a multi-line
  snippet does run line by line, and nothing can prevent that. It is a property of the terminal protocol,
  not of this client, which is why the screen says "types this into whatever is there".

Both methods were confirmed present on the public API of the vendored `@xterm/xterm` 6.0.0 bundle before
being written against; neither is reachable from any test in this repository, so they are in
`docs/manual-checks.md` as checks 3.6–3.8.

**SSH.NET's `window-change` is verified working** as of 2025.1.0 — resolved, not a flag.
`ShellStream.ChangeWindowSize(columns, rows, width, height)` exists and the remote genuinely
observes it: `PtyAndResizeSpikeTests` reads `stty size` back from a real sshd after resizing, and
repeated resizes each take effect. The `IChannelSession` fallback is not needed. That suite stays
in place as a regression guard, because an upgrade that silently stopped sending the request would
present as wrapped output only after a resize — easy to misattribute to the terminal emulator.

**`ShellStream.Write` buffers and requires an explicit `Flush`.** Without one a keystroke is accepted,
reported as written, and never reaches the remote — the terminal displays output perfectly and simply
stops responding to input. SSH.NET's own `WriteLine` flushes, which is why a spike that used it never
hit this. `SshNetShellSession.WriteAsync` now flushes per write; batching would be wrong anyway, since
a terminal has to put a keystroke on the wire immediately.

**`ShellStream` does not override `ReadAsync`.** The base `Stream` implementation therefore runs
the blocking `Read` on a thread-pool thread, so every open session parks one thread for as long as
it is idle. Fine for the handful of tabs M1 targets; revisit before advertising many concurrent
sessions, since the fix is either an upstream change or driving `IChannelSession` directly.

**A passphrase supplied for an unprotected private key is silently ignored, not refused.**
`PrivateKeyFile(stream, passphrase)` on an unencrypted PKCS#1 RSA key loads it and the connection
authenticates exactly as if no passphrase had been given — measured against a real `sshd` in
`KeyAuthenticationTests.APassphraseOnAnUnprotectedKey_IsIgnoredRatherThanRefused`, which was written
expecting the opposite and corrected to match. Two consequences, and the second is the one that bites: a
stray passphrase does no harm, so nothing downstream needs to defend against it; but equally nothing
downstream will *report* one, so if a user swears they set a passphrase and the key opens without it, no
error will ever say so. Only established for that armour and that algorithm; whether the OpenSSH format's
`none` cipher path behaves the same way is untested. `SshKeySecret.Passphrase` still normalises an empty
string to null, for the reasons stated there — one representation of one state — and not for this.

**SSH.NET cannot share one connection between `SshClient` and `SftpClient`.** A shell plus SFTP to
the same host means two TCP connections, two authentications and — later — two relay sockets.
Connect SFTP lazily and reuse the cached decrypted credential so the user is not prompted twice.

**Agent forwarding is de-scoped from v1.** It needs an upstream SSH.NET change. A vault-backed
agent of our own plus ProxyJump covers the real use cases.

**The SSH suite pulls `linuxserver/openssh-server` from Docker Hub**, which is rate-limited for
unauthenticated pulls. If CI starts failing on image pulls rather than on tests, that is why.

**MSIX packaging is ruled out, not merely deprioritised.** A packaged app runs WebView2 in an
AppContainer where loopback connections are blocked without a `CheckNetIsolation` exemption. The
terminal data plane *is* a loopback WebSocket, so MSIX would break the product outright. Velopack
for Windows/macOS/AppImage; Flatpak and deb/rpm defer updates to the package manager.

**Linux ships AppImage and Flatpak first**, specifically so the WebKit runtime is bundled rather
than assumed present on the user's machine.

**Opening the system browser depends on the platform handler.** `SystemBrowserLauncher` uses
`UseShellExecute`, which delegates to `ShellExecute` on Windows, `open` on macOS and `xdg-open` on
Linux. *Unverified off Windows:* `xdg-open` comes from `xdg-utils`, which is not guaranteed on a
minimal desktop or inside a Flatpak sandbox — where the portal is the correct route instead. If
sign-in silently does nothing on Linux, this is the first thing to check. `IBrowserLauncher` exists
so a platform-specific opener can be substituted without touching the flow.

## Identity provider

**A loopback redirect URI must be registered without a port, not with a wildcard port.** Keycloak — and
providers implementing RFC 8252 §7.3 generally — ignores the port when the registered redirect URI's host
is a loopback literal, which is what lets a native client bind an ephemeral port. Registering
`http://127.0.0.1:*/callback` looks more explicit and is *broken*: the `*` is parsed as a literal port and
every real authorization request comes back `400 Invalid parameter: redirect_uri`. Keycloak's wildcard
support is trailing-only, so a `*` in the middle of a URI never means what it looks like.

Register `http://127.0.0.1/callback`. Keep the path — it is the part that stops another process on the
machine having an authorization code delivered to a different endpoint. `Oidc:LoopbackRedirectPattern`,
which the server advertises through `/.well-known/dodossh-configuration`, says the same thing so an
operator configuring a different provider copies something that works.

Found by running the sign-in against a real Keycloak; every test until then used a stub that accepted
whatever it was given.

**Keycloak marks its session cookies `Secure` even over plain HTTP**, because `SameSite=None` is only
legal alongside `Secure`. A spec-conformant HTTP client therefore refuses to store them from an `http://`
origin — .NET's `CookieContainer` drops every one silently — and the login form POST then comes back
`400` with no explanation at all. Browsers complete the flow because they treat loopback as a trustworthy
origin and make the exception.

This does not affect the product: the client uses the system browser, which makes that exception. It does
affect any non-browser automation against a development Keycloak, which has to carry the cookies by hand
(see `ScriptedBrowser`) or be given HTTPS. Two hours of "the credentials must be wrong".

**A user declared in a realm import gets no roles unless `realmRoles` says so** — not even the realm's own
`default-roles-<realm>` composite, which Keycloak grants automatically to a user created through the admin
API or the registration form. The realm file's `alice` and `bob` therefore had no role mappings at all, and
because `offline_access` lives inside that composite and the desktop client requests that scope, the very
first sign-in died at the token exchange with `400 Offline tokens not allowed for the user or client`. The
authorization succeeds and the failure lands one step later, which makes it read like a client bug.

Add `"realmRoles": ["default-roles-dodossh"]` to every user the file declares. And note the asymmetry,
because it is what let this ship: `DodoSSH.SystemTests` used to create its own account through the admin
API, so it exercised a provisioning path no real user takes and passed while the documented `alice` could
not sign in at all. The suite now signs in as the realm's own account, and removing these roles fails it.

**Keycloak rejects unknown fields in a realm file.** `RealmRepresentation` deserialises with
`FAIL_ON_UNKNOWN_PROPERTIES` enabled, so a `"_comment"` key — the usual way to annotate JSON that has no
comment syntax — does not merely get ignored: the import throws
`Unrecognized field ... not marked as ignorable` and **the container refuses to start at all**. Explanations
about the realm belong here or in the compose file, never in the realm JSON.

**`--import-realm` skips a realm that already exists.** Editing `deploy/keycloak/realm-dodossh.json` and
running `docker compose restart keycloak` therefore changes nothing, and the stale configuration keeps
being served — which reads exactly like the edit being wrong. `start-dev` keeps its state in an H2
database inside the container, so the realm has to be recreated along with it:
`docker compose rm -sf keycloak && docker compose up -d keycloak`. Cost an otherwise inexplicable
debugging detour.

`DodoSSH.SystemTests` is immune to this by construction — its Keycloak is created and destroyed per run —
which is a second reason the end-to-end suite starts its own containers rather than reusing the developer's
stack. Editing the realm file and rerunning the suite always tests the edit.

## Local cache

**The cache location is per-OS and must stay non-roaming.** `ClientPaths` chooses it:
`%LOCALAPPDATA%\DodoSSH` on Windows, `~/Library/Application Support/DodoSSH` on macOS,
`$XDG_DATA_HOME/dodossh` or `~/.local/share/dodossh` on Linux. It must **not** land anywhere that syncs
to a cloud drive or roams: two machines writing one SQLite file through a file-sync client corrupts it,
and the whole point of the outbox is that each machine has its own. That is also why Windows uses
`%LOCALAPPDATA%` and not `%APPDATA%`, which roams in a domain environment.

The platform branches are explicit rather than delegating to
`Environment.SpecialFolder.LocalApplicationData` everywhere, because on macOS the runtime maps that to
`~/.local/share` rather than to `~/Library/Application Support`. *Verified on Windows only* — the client
created `%LOCALAPPDATA%\DodoSSH\cache.db` and migrated it on first launch. The macOS and Linux branches
are reasoned, not run.

**SQLite timestamps are stored as integers, deliberately.** EF's default `DateTimeOffset` mapping for
SQLite is a text form it then refuses to order or compare, so any query that sorts or filters by time
throws at execution rather than at model build. `UnixMillisecondsConverter` is applied as a convention
so a timestamp added later cannot be the one left unconverted. This is provider behaviour, not
platform behaviour, but it cost a debugging session and will again if the converter is removed.

**The cache is three files, not one.** EF Core's SQLite provider puts the database in WAL mode, which is
the right mode here — a background sync pass writes while the interface reads, and under the default
rollback journal those reads would fail busy — but it means `cache.db` is accompanied by `cache.db-wal`
and `cache.db-shm`. Any backup, export or uninstall routine that touches only `cache.db` is wrong.
Verified by launching the client and reading `PRAGMA journal_mode`, after a comment in the code claimed
the opposite.

**Pooled SQLite connections keep the file open after the last context is disposed.** On Windows that
means locked, so the application cannot delete or replace its own cache and a test cannot clean up after
itself. `ClientCacheFactory.Dispose` clears the pool for exactly this reason; removing that line makes
the failure appear only on Windows.

**No SQLCipher, on any platform.** The rows are already ciphertext from the server, so an encrypted
database file would protect bytes that are protected already at the cost of a native dependency and a
licence obligation — and `bundle_e_sqlcipher` was deprecated in SQLitePCLRaw 3.0. The consequence to
be honest about: the cache offers no protection against another process running as the same user. See
`LocalCacheProtector` for what it does and does not defend against.

## Build and CI

**The layout suite needs two unrelated things on a bare image, and each hides the other.** Both were
found the slow way, one per CI run, because the first masks the second entirely.

The first is `libfontconfig`. Avalonia's headless renderer is Skia, and the `libSkiaSharp.so` the test
project copies into its own output links against it; without it the native library never loads and all
69 tests fail inside `HeadlessUnitTestSession` with a `TypeInitializationException` on
`SkiaSharp.SKImageInfo` naming none of their actual subjects. The CI job installs the package.

The second only becomes visible once the first is fixed, and is not about a package at all. Avalonia
takes its default font family from the platform, and on an image with no fonts installed there is no
answer — `FontManager` throws "Default font family name can't be null or empty" during
`AppBuilder.SetupUnsafe`, again before any test body runs and again for all 69. `WithInterFont` does not
help by itself: it registers a collection without naming a default. Both `Program.BuildAvaloniaApp` and
the layout suite's `HeadlessApp` now set `FontManagerOptions.DefaultFamilyName` to
`avares://Avalonia.Fonts.Inter/Assets#Inter` explicitly, which owes the host nothing because the font
travels in the package.

Pinning it is worth more than the CI fix. A suite that measures text was taking its metrics from
whatever the machine happened to have — Segoe UI on Windows, DejaVu on Linux — and reporting both as
one number. *Verified* on Alpine musl with `fc-list` returning zero and on a Fedora desktop with 595
fonts, which now agree. **Unverified on Windows:** the pinning changed the metrics there too, so a
tight assertion could conceivably have moved.

**The end-to-end suite must state its plaintext exemption rather than inherit it.** `ServerConnection`
allows an `http` OIDC authority only when it is loopback, which is a sound rule the suite cannot lean
on: Testcontainers reports the host the container is actually reachable at, so running the tests
directly gives `localhost` and passes, while running them *inside* a container — which is what a
containerised CI runner does — gives the bridge gateway `172.17.0.1` and is refused. That refusal is
the product being correct; a client that quietly accepted plaintext metadata from a routable address
would be a real weakness. `M1VerticalSliceTests` therefore passes `configureOidc` to set
`RequireHttpsMetadata = false` for the throwaway Keycloak it starts itself, and the rule stays as strict
as it was for everyone else.

**Integration tests need a Docker daemon** (Testcontainers). They run on `ubuntu-latest` in CI.
macOS runners have no Docker daemon, and the Windows CI job is deliberately build-only. So
anything proved by an integration test is proved on Linux only — which is the right place for
server code, and no coverage at all for client platform behaviour.

**The end-to-end suite launches the API's own launcher executable**, falling back to `dotnet exec` on the
assembly. The fallback exists for one reason: a checkout or artefact copy that lost the execute bit
produces a `Win32Exception` on Linux and nothing whatsoever on Windows. *Verified on Windows only* — the
launcher path is what runs here, so the fallback itself is reasoned rather than exercised. If the suite
fails in CI with a permission error before any container work, that is the path to look at.

**It also depends on `Server:PublicBaseUrl` being knowable before startup.** The port is chosen by binding
a loopback socket and releasing it, because the API reads that URL at startup and advertises it to clients,
so it cannot be discovered from Kestrel afterwards. The window for another process to take the port is a
few milliseconds; if the suite ever fails with an address-in-use, this is why, and a retry is the fix
rather than a redesign.

**`[CallerFilePath]` is rewritten to `/_/...` under `ContinuousIntegrationBuild`.** Any test that
locates a fixture by source path passes locally and fails in CI. Copy fixtures to the output
directory and read them via `AppContext.BaseDirectory` instead; `GoldenVectorTests` shows the
pattern.

**Formatting fails the build rather than a separate step.** `IDE0055` is an error in
`.editorconfig` and `EnforceCodeStyleInBuild` is on, so `dotnet build` reports misformatted code
the way it reports a type error. CI used to run `dotnet format --verify-no-changes` as well; it
was removed for spending minutes to reach a verdict the build reaches anyway. `dotnet format` is
still how to *fix* what the build complains about — it just no longer gates anything itself.

## Deployment

**PostgreSQL 18 moved its data directory** to `/var/lib/postgresql`, not `/var/lib/postgresql/data`
as in 17 and earlier. A compose file carried over from an older version silently gets an empty
volume — the database appears to work and loses everything on restart. Relevant to any compose
file other than `deploy/docker-compose.dev.yml`, which is already correct.

**Keycloak in the dev stack listens on host port 18080, not 8080.** On this machine an unrelated
Apache Tomcat holds `127.0.0.1:8080`, and a loopback-specific bind wins over Docker's `0.0.0.0`
publish when resolving `localhost` — so every realm request returned 404 while the container
looked healthy. If discovery fails against a locally-published container, check for another
process bound specifically to loopback before suspecting the container.

**A path prefix in the server URL is silently discarded.** The client uses the typed address only as
`HttpClient.BaseAddress` and every request path is root-absolute (`/api/v1/meta`,
`/.well-known/dodossh-configuration`, …), so `https://example.test/dodossh` reaches
`https://example.test/api/v1/...` and the prefix is dropped without a word. That rules out hosting DodoSSH
under a sub-path — which is exactly what a reverse proxy in front of several services usually does. Nothing
trims or normalises the typed URL either, and it is the raw string, not the parsed form, that becomes the
local cache's identity. The server already publishes a canonical `apiBaseUrl` in its discovery document
that the client could normalise against and currently ignores.

**`Sync:CursorSigningKey` generates an ephemeral per-process key when unset.** Fine for a single
node; on a multi-node deployment cursors issued by one node are rejected by another, so clients
resync from the beginning repeatedly. Must be configured explicitly before running more than one
instance. `WarnOnRiskyConfiguration` logs this at startup.

**Rate limiting is not implemented yet** (M2). `POST /api/v1/me/enrollment` and the sync endpoints
are reachable by any authenticated caller at any rate. Enrollment requires a valid access token
and is idempotent, so the exposure is resource consumption rather than a credential-guessing
surface — but it is still an unmetered write path.

**`/api/v1/me` does not update `last_seen_at_utc`.** Deliberate: a GET that writes on every call is
a smell, and nothing depends on the value yet. Revisit when device management lands, since that is
the first feature that needs it.