feat(emby): add Emby as a MediaBrowser backend alongside Jellyfin

Emby is Jellyfin's upstream ancestor and speaks a near-identical MediaBrowser
API, so the existing Jellyfin stack is parameterised by a `MediaBrowserDialect`
rather than forked. `JellyfinClient`, its auth service, endpoint discovery, LAN
discovery, and the add/edit connection screens all take the dialect and keep one
implementation; `MediaBackend.emby` and `ConnectionKind.emby` carry it through
the neutral models, the Drift `kind` discriminator, downloads, and caches.

Every divergence below was measured against a live Emby 4.9.5 server, not
inferred from documentation, and each is documented at its capability getter.
Jellyfin's request strings stay byte-identical so nothing about its behaviour
changes.

Routes and auth
- Emby only accepts the pre-10.9 user-scoped item routes (`/Users/{id}/Items/…`,
  `/Users/{id}/PlayedItems/…`, `/Users/{id}/FavoriteItems/…`); the unprefixed
  forms Jellyfin 10.11 added return 404.
- The API is also served under a legacy `/emby` prefix, and both dialects accept
  the token as `X-Emby-Token` or `api_key=`.
- Emby answers only its own LAN discovery datagram ("who is EmbyServer?") and
  ignores Jellyfin's; its default HTTPS port is 8920.
- No `/QuickConnect` route exists, so Quick Connect stays Jellyfin-only.

Row fields Emby withholds
- `ProductionYear`, `OfficialRating`, `PremiereDate` and `DateCreated` are absent
  from list rows unless named in `Fields`, which would otherwise strip the year
  and age-rating badge from every card in the app.
- `UserData.LastPlayedDate` never appears on a list row under `Fields=UserData`,
  `EnableUserData=true` or the user-scoped `Ids=` form — only on the single-item
  detail route, or when the Emby-specific `UserDataLastPlayedDate` token is
  requested. Without it every recency-ordered surface silently degrades to
  library-add time, and `JellyfinApiCache.applyWatchState` stamps
  `DateTime.now()` on watched rows, so an offline watch-state pull would rewrite
  the cached play time of everything it walked.

Continue Watching and Next Up
- Emby computes Next Up per series only: the library-wide `/Shows/NextUp` query
  returns nothing under every parameter combination tried. The shelf is
  therefore reconstructed from a played-episode recency scan plus one
  `/Shows/NextUp?SeriesId=` per distinct series, bounded by a shared wall clock
  that covers the scan as well — per-request timeouts cannot bound the pass
  because `MediaServerHttpClient` times the connect and receive phases
  independently. Rows are stamped with their series' newest play from the same
  response that ordered them, so no per-series enrichment request is needed.
- `/Shows/NextUp` ignores `NextUpDateCutoff`, and no server-side played-date
  filter exists to delegate to (`MinDatePlayed` and `MinDateLastPlayed` are
  ignored; `MinDateLastSaved`, `MinDateCreated` and `MinPremiereDate` filter
  unrelated dates), so the 365-day window is applied to the scanned dates.
- The resume route returns items with no saved position, including plain next
  episodes, so the Emby resume leg reads from `/Items?Filters=IsResumable`.
- Emby is ahead of Jellyfin in one place: `/Users/{id}/Items/{id}/HideFromResume`
  makes Continue Watching removal a real capability.

Everything else
- `/Sessions/Playing` and `/Sessions/Playing/Progress` reject a body with no
  `PlaySessionId` (HTTP 400), so playback reporting always sends one.
- Passing any `MediaTypes` value to the playlist query returns an empty list.
- There is no aggregate `/Items/Filters` route; the four filter facets are
  reassembled from `/Genres`, `/OfficialRatings`, `/Studios` and `/Tags`.
- Metadata writes take name-pair lists (`Genres: [{'Name': 'Action'}]`); the
  plain string array is accepted and then silently discarded.
- Custom artwork uploads must be base64 text, not raw bytes — which was broken
  for Jellyfin too and is fixed for both.
- Trickplay, media segments and lyrics 404 on Emby, so scrub previews are absent
  and intro/credit markers fall back to chapter names.

Verified against a local Emby 4.9.5 and a Jellyfin 10.11.11 control server:
onboarding, browse, detail, playable stream URLs serving real bytes, subtitle
sidecars, watch-state write and restore, hubs, cross-server aggregation and
search across both backends simultaneously.

test/connection/connection_models_test.dart

@@ -1,6 +1,7 @@
 import 'package:flutter_test/flutter_test.dart';
 import 'package:plezy/connection/connection.dart';
 import 'package:plezy/media/media_backend.dart';
+import 'package:plezy/media/media_browser_dialect.dart';
 
 /// Backend-agnostic [Connection] sealed-class tests. The
 /// `connection_registry_test` already covers DB persistence; these focus on
@@ -16,12 +17,22 @@ void main() {
     });
 
     test('fromId throws on unknown id (no silent fallback)', () {
-      expect(() => ConnectionKind.fromId('emby'), throwsA(isA<ArgumentError>()));
+      expect(() => ConnectionKind.fromId('kodi'), throwsA(isA<ArgumentError>()));
     });
 
     test('backend mapping is total', () {
       expect(ConnectionKind.plex.backend, MediaBackend.plex);
       expect(ConnectionKind.jellyfin.backend, MediaBackend.jellyfin);
+      expect(ConnectionKind.emby.backend, MediaBackend.emby);
+    });
+
+    test('dialect maps only the MediaBrowser kinds and round-trips', () {
+      expect(ConnectionKind.plex.dialect, isNull);
+      expect(ConnectionKind.jellyfin.dialect, MediaBrowserDialect.jellyfin);
+      expect(ConnectionKind.emby.dialect, MediaBrowserDialect.emby);
+      for (final dialect in MediaBrowserDialect.values) {
+        expect(ConnectionKind.fromDialect(dialect).dialect, dialect);
+      }
     });
   });
 
@@ -178,9 +189,59 @@ void main() {
     });
 
     test('kind and backend match Jellyfin', () {
+      expect(base.dialect, MediaBrowserDialect.jellyfin);
       expect(base.kind, ConnectionKind.jellyfin);
       expect(base.backend, MediaBackend.jellyfin);
     });
+
+    test('an Emby dialect drives kind, backend and the persisted discriminator', () {
+      final emby = base.copyWith(dialect: MediaBrowserDialect.emby);
+
+      expect(emby.kind, ConnectionKind.emby);
+      expect(emby.kind.id, 'emby');
+      expect(emby.backend, MediaBackend.emby);
+      // The dialect lives in the `connections.kind` column, never in the
+      // encrypted config payload, so exactly one discriminator is on disk.
+      expect(emby.toConfigJson().containsKey('dialect'), isFalse);
+    });
+
+    test('fromConfigJson restores the dialect handed in by the registry', () {
+      final restored = JellyfinConnection.fromConfigJson(
+        id: 'srv-1/user-1',
+        json: base.toConfigJson(),
+        status: ConnectionStatus.online,
+        createdAt: base.createdAt,
+        dialect: MediaBrowserDialect.emby,
+      );
+
+      expect(restored.dialect, MediaBrowserDialect.emby);
+      expect(restored.kind, ConnectionKind.emby);
+      expect(restored.accessToken, 'tok-abc');
+    });
+
+    test('fromConfigJson defaults to Jellyfin for rows written before Emby support', () {
+      final restored = JellyfinConnection.fromConfigJson(
+        id: 'legacy',
+        json: const {'baseUrl': 'https://jellyfin.example.com'},
+        status: ConnectionStatus.unknown,
+        createdAt: DateTime.utc(2026),
+      );
+
+      expect(restored.dialect, MediaBrowserDialect.jellyfin);
+      expect(restored.kind, ConnectionKind.jellyfin);
+    });
+
+    test('empty-payload serverName falls back to the dialect product name', () {
+      final emby = JellyfinConnection.fromConfigJson(
+        id: 'orphan',
+        json: const {},
+        status: ConnectionStatus.unknown,
+        createdAt: DateTime.utc(2026),
+        dialect: MediaBrowserDialect.emby,
+      );
+
+      expect(emby.serverName, 'Emby');
+    });
   });
 
   group('PlexAccountConnection serialization', () {

test/connection/connection_registry_test.dart

@@ -6,6 +6,7 @@ import 'package:flutter_test/flutter_test.dart';
 import 'package:plezy/connection/connection.dart';
 import 'package:plezy/connection/connection_registry.dart';
 import 'package:plezy/database/app_database.dart';
+import 'package:plezy/media/media_browser_dialect.dart';
 import 'package:plezy/services/credential_vault.dart';
 import 'package:plezy/services/plex_auth_service.dart';
 
@@ -34,6 +35,21 @@ JellyfinConnection _jellyfin({String id = 'srv-1', String userName = 'edde', int
   );
 }
 
+JellyfinConnection _emby({String id = 'emby-1', String accessToken = 'emby-token', int createdAtMs = 1_000_000}) {
+  return JellyfinConnection(
+    id: id,
+    baseUrl: 'https://emby.local',
+    serverName: 'Emby Home',
+    serverMachineId: 'emby-machine-$id',
+    userId: 'user-$id',
+    userName: 'edde',
+    accessToken: accessToken,
+    deviceId: 'dev-1',
+    dialect: MediaBrowserDialect.emby,
+    createdAt: DateTime.fromMillisecondsSinceEpoch(createdAtMs),
+  );
+}
+
 PlexAccountConnection _plex({String id = 'plex-1'}) {
   return PlexAccountConnection(
     id: id,
@@ -105,18 +121,49 @@ void main() {
       expect((jelly as JellyfinConnection).baseUrl, 'https://jellyfin.local');
     });
 
+    test('Emby upsert preserves its persisted discriminator and connection dialect', () async {
+      await registry.upsert(_emby(id: 'e'));
+
+      final restored = await registry.get('e') as JellyfinConnection;
+      final row = await (db.select(db.connections)..where((table) => table.id.equals('e'))).getSingle();
+
+      expect(restored.dialect, MediaBrowserDialect.emby);
+      expect(restored.kind, ConnectionKind.emby);
+      expect(restored.kind.id, 'emby');
+      expect(row.kind, 'emby');
+    });
+
+    test('Jellyfin and Emby rows coexist and round-trip to their own dialects', () async {
+      await registry.upsert(_jellyfin(id: 'j'));
+      await registry.upsert(_emby(id: 'e'));
+
+      final jellyfin = await registry.get('j') as JellyfinConnection;
+      final emby = await registry.get('e') as JellyfinConnection;
+      final rows = await db.select(db.connections).get();
+      final kindById = {for (final row in rows) row.id: row.kind};
+
+      expect(jellyfin.dialect, MediaBrowserDialect.jellyfin);
+      expect(jellyfin.kind, ConnectionKind.jellyfin);
+      expect(emby.dialect, MediaBrowserDialect.emby);
+      expect(emby.kind, ConnectionKind.emby);
+      expect(kindById, {'j': 'jellyfin', 'e': 'emby'});
+    });
+
     test('upsert encrypts tokens at rest and decrypts on read', () async {
       await registry.upsert(_plex(id: 'p'));
       await registry.upsert(_jellyfin(id: 'j'));
+      await registry.upsert(_emby(id: 'e', accessToken: 'emby-raw-token'));
 
       final rows = await db.select(db.connections).get();
       expect(rows.singleWhere((r) => r.id == 'p').configJson, isNot(contains('tok-p')));
       expect(rows.singleWhere((r) => r.id == 'p').configJson, isNot(contains('server-token-p')));
       expect(rows.singleWhere((r) => r.id == 'j').configJson, isNot(contains('tok-j')));
+      expect(rows.singleWhere((r) => r.id == 'e').configJson, isNot(contains('emby-raw-token')));
 
       expect((await registry.get('p') as PlexAccountConnection).accountToken, 'tok-p');
       expect((await registry.get('p') as PlexAccountConnection).servers.single.accessToken, 'server-token-p');
       expect((await registry.get('j') as JellyfinConnection).accessToken, 'tok-j');
+      expect((await registry.get('e') as JellyfinConnection).accessToken, 'emby-raw-token');
     });
 
     test('read migrates legacy plaintext Plex server tokens', () async {