Phase 7: E2EE support

Implements PLAN.md Phase 7: the server half of end-to-end encryption.
Devices upload identity, one-time and fallback keys; other devices query
and claim them, across servers too, and every one-time key is handed out
exactly once. Cross-signing, signature uploads, device list tracking and
server-side key backup complete the set.

internal/keyserver is the component. Keys are stored in canonical JSON
so that re-uploading the same key is a byte comparison, and signatures
uploaded later are kept apart from the key they sign and merged in on
read, so a key's own JSON stays what its owner uploaded. Device keys must
be for the caller's own device; cross-signing keys must be the
uploader's, carry the right usage and, for self- and user-signing keys,
be signed by the master key. Signatures are verified against the key as
stored. Replacing a master key asks for the password; a first upload or
an upload of the keys already stored does not, as the spec allows. A
signature of another user's master key is shown only to the user who
made it and never federated.

Every write that changes what /keys/query answers moves the device list
stream in the same transaction, one position per device, and wakes the
syncs of everyone sharing a room. The stream is the sixth field of a sync
token; older tokens still parse. The syncapi works out device_lists
changed and left from the stream and from membership moves in the
window, skipping invites and knocks, and reports
device_one_time_keys_count and device_unused_fallback_key_types, the
latter as [] when empty. GET /keys/changes uses the same logic.

Over federation: /user/keys/query, /user/keys/claim and
/user/devices/{userId}, and m.device_list_update and m.signing_key_update
both ways. Remote keys are not cached; an update about a remote user
sharing a room moves them in the stream so local clients re-query.
Device display names are not sent to other servers. With federation off,
remote users are reported in failures at once.

Deleting a device deletes its keys, through a new userapi
DeviceObserver. Key backup keeps the better copy of each session by the
spec's rule, never reuses a deleted version's number, and answers writes
to a stale version with M_WRONG_ROOM_KEYS_VERSION.

Storage is migration 0008 for sqlite and postgres, with a PocketBase
stub. The Complement target sets gain the key, device list, fallback,
cross-signing and backup tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

server/internal/syncapi/syncapi.go

@@ -16,18 +16,20 @@
 // What this package owns instead is everything the roomserver has no
 // opinion about:
 //
-//   - Stream tokens: a position in each of the five streams a response
+//   - Stream tokens: a position in each of the six streams a response
 //     carries, in one opaque string (token.go).
 //   - The notifier: waking a client blocked in a long poll the moment
 //     something concerns it, rather than when its timeout expires
 //     (notifier.go).
 //   - Filters: what a client asked to be left out (filter.go).
-//   - The ephemeral and device streams: typing, receipts, presence and
-//     to-device messages, none of which are events in a room.
+//   - The ephemeral and device streams: typing, receipts, presence,
+//     to-device messages and device list changes, none of which are
+//     events in a room.
 //
-// Phase 4 of PLAN.md. What it does not do yet is notification counts, which
-// need push rules (Phase 8), and device list tracking, which needs the
-// keyserver (Phase 7); both are named in docs/sync.md as the gaps they are.
+// Phase 4 of PLAN.md, with device lists from Phase 7: the keyserver writes
+// the device list stream, and this package works out which of its changes
+// concern whom (devicelists.go). What it does not do yet is notification
+// counts, which need push rules (Phase 8); docs/sync.md names that gap.
 package syncapi
 
 import (
@@ -72,11 +74,20 @@ type Accounts interface {
 	Devices(ctx context.Context, localpart string) ([]storage.Device, error)
 }
 
+// Keys is the part of the keyserver a sync reads: a device's key counts,
+// and the device list stream. *keyserver.API satisfies it.
+type Keys interface {
+	OneTimeKeyCounts(ctx context.Context, userID, deviceID string) (map[string]int, error)
+	UnusedFallbackKeyTypes(ctx context.Context, userID, deviceID string) ([]string, error)
+	DeviceListChanges(ctx context.Context, userIDs []string, from, to int64) ([]storage.DeviceListChange, error)
+}
+
 // API is the syncapi component.
 type API struct {
 	serverName string
 	rooms      *roomserver.API
 	accounts   Accounts
+	keys       Keys
 	store      storage.SyncStore
 	notifier   *Notifier
 	typing     *typingTracker
@@ -111,6 +122,10 @@ type Options struct {
 	// Accounts is the userapi.
 	Accounts Accounts
 
+	// Keys is the keyserver. Nil leaves the key counts out of a sync and
+	// both device lists empty.
+	Keys Keys
+
 	// Store is the sync half of storage.
 	Store storage.SyncStore
 
@@ -190,6 +205,7 @@ func New(opts Options) (*API, error) {
 		serverName:      opts.ServerName,
 		rooms:           opts.Rooms,
 		accounts:        opts.Accounts,
+		keys:            opts.Keys,
 		store:           opts.Store,
 		notifier:        opts.Notifier,
 		typing:          newTypingTracker(opts.TypingTimeout, opts.Notifier, opts.Now),