fix(player): preserve the forced-subtitle class across episode boundaries

Plex treats a subtitle stream as forced when its title says "Forced" even
with the API flag unset. Every forced comparison now uses that effective
forced-ness on both sides: the match scorer, the low-metadata hard gate,
the Jellyfin OnlyForced/Smart profile modes, and stream-index negotiation.

Carrying a track choice into the next episode no longer reuses the
same-item identity matchers. A sealed SubtitlePreference (off / track
reference / semantic intent) replaces the id-'navigation' pseudo-track
through the whole preference channel, and cross-item intents hard-require
language and forced-class parity. When the next episode has no track of
the same class, the intent declines and selection falls through to the
server's own per-episode choice instead of latching onto a full track by
position and persisting that mistake back to the server.

Intents wait for pending native tracks under the same catalog-completeness
rule as source ids, so an early decline cannot retire the selection
listener before the real track arrives.

Ref #1716

lib/screens/video_player/parts/episode_navigation.dart

@@ -14,7 +14,7 @@ Future<bool> deferTranscodeSubtitleSelection({
   required bool Function() shouldContinue,
 }) async {
   final deferredTrack = PlaybackSubtitleResolver.subtitleTrackForSource(sourceTrack, sidecar: sourceSidecar);
-  trackManager.preferredSubtitleTrack = deferredTrack;
+  trackManager.preferredSubtitleTrack = SubtitlePreference.track(deferredTrack);
   // Persist first: the screen callback routes to onSubtitleTrackSelectedByUser,
   // which invalidates the pending selection. Arming before that would retire the
   // deferred pass we depend on to apply this choice once mpv discovers the sidecar.
@@ -248,10 +248,12 @@ extension _VideoPlayerEpisodeNavigationMethods on VideoPlayerScreenState {
     final effectiveAudioStreamId = newAudioStreamId ?? _selectedAudioStreamId;
     final currentSubtitleChoice = _selectedSourceSubtitleChoiceForControls(_sourceSubtitleTracksForControls());
     final preferredSubtitleTrackForReload = newSubtitleChoice == null
-        ? _playbackSession?.subtitleSelection.primaryTrack
+        ? SubtitlePreference.trackOrNull(_playbackSession?.subtitleSelection.primaryTrack)
         : newSubtitleChoice.isOff
-        ? SubtitleTrack.off
-        : PlaybackSubtitleResolver.preferredTrackForSource(_currentMediaInfo, newSubtitleChoice.sourceStreamId!);
+        ? const SubtitlePreference.off()
+        : SubtitlePreference.trackOrNull(
+            PlaybackSubtitleResolver.preferredTrackForSource(_currentMediaInfo, newSubtitleChoice.sourceStreamId!),
+          );
     final effectiveMediaSourceId = newMediaIndex != null
         ? PlaybackSession.mediaSourceIdForIndex(_availableVersions, effectiveMediaIndex) ?? _requestedMediaSourceId
         : _requestedMediaSourceId;
@@ -417,9 +419,9 @@ extension _VideoPlayerEpisodeNavigationMethods on VideoPlayerScreenState {
     Duration? resumePosition,
     bool preserveCurrentTrackSelection = false,
     AudioTrack? preservedAudioTrack,
-    SubtitleTrack? preservedSubtitleTrack,
-    SubtitleTrack? preservedSecondarySubtitleTrack,
-    SubtitleTrack? preferredSubtitleTrackOverride,
+    SubtitlePreference? preservedSubtitleTrack,
+    SubtitlePreference? preservedSecondarySubtitleTrack,
+    SubtitlePreference? preferredSubtitleTrackOverride,
     bool startPaused = false,
     bool useCurrentAudioStreamSelection = true,
     bool showErrorUi = true,
@@ -473,9 +475,12 @@ extension _VideoPlayerEpisodeNavigationMethods on VideoPlayerScreenState {
           : null;
       final currentSubtitleTrack =
           preferredSubtitleTrackOverride ??
-          (preserveCurrentTrackSelection ? preservedSubtitleTrack ?? currentPlayer.state.track.subtitle : null);
+          (preserveCurrentTrackSelection
+              ? preservedSubtitleTrack ?? SubtitlePreference.trackOrNull(currentPlayer.state.track.subtitle)
+              : null);
       final currentSecondarySubtitleTrack = preserveCurrentTrackSelection
-          ? preservedSecondarySubtitleTrack ?? currentPlayer.state.track.secondarySubtitle
+          ? preservedSecondarySubtitleTrack ??
+                SubtitlePreference.trackOrNull(currentPlayer.state.track.secondarySubtitle)
           : null;
       final wasPlayingBeforeReload = _playbackIntentShouldPlay;
       var didOpenReplacement = false;
@@ -545,7 +550,7 @@ extension _VideoPlayerEpisodeNavigationMethods on VideoPlayerScreenState {
           (selectedMediaSourceId == null || selectedMediaSourceId == previousMediaSourceId);
       final initializationSubtitleTrack = preservesRequestedSubtitleSource
           ? currentSubtitleTrack
-          : PlaybackSubtitleResolver.preferenceWithoutSourceIdentity(currentSubtitleTrack);
+          : SubtitlePreference.demoteToIntent(currentSubtitleTrack);
       try {
         // Eager identity-only: the loading UI shows the new title immediately,
         // while the selection/source state flips with the session commit at
@@ -757,8 +762,8 @@ extension _VideoPlayerEpisodeNavigationMethods on VideoPlayerScreenState {
           plexClient: plexClient,
           getProfileSettings: () => userProfileProvider.profileSettings,
           preferredAudioTrack: currentAudioTrack,
-          preferredSubtitleTrack: subtitleSelection.primaryTrack,
-          preferredSecondarySubtitleTrack: subtitleSelection.secondaryTrack,
+          preferredSubtitleTrack: SubtitlePreference.trackOrNull(subtitleSelection.primaryTrack),
+          preferredSecondarySubtitleTrack: SubtitlePreference.trackOrNull(subtitleSelection.secondaryTrack),
         );
         _trackManager = trackManager;
         trackManager.cacheExternalSubtitles(subtitleSelection.sidecarsAtOpen);

lib/screens/video_player/parts/lifecycle.dart

@@ -319,8 +319,8 @@ extension _VideoPlayerLifecycleMethods on VideoPlayerScreenState {
       resumePosition: resumePosition,
       preserveCurrentTrackSelection: true,
       preservedAudioTrack: audioTrack,
-      preservedSubtitleTrack: subtitleTrack,
-      preservedSecondarySubtitleTrack: secondarySubtitleTrack,
+      preservedSubtitleTrack: SubtitlePreference.trackOrNull(subtitleTrack),
+      preservedSecondarySubtitleTrack: SubtitlePreference.trackOrNull(secondarySubtitleTrack),
       startPaused: true,
       reason: 'TV background suspend restore',
     );

lib/screens/video_player/parts/playback_open.dart

@@ -83,8 +83,8 @@ extension _VideoPlayerOpenMethods on VideoPlayerScreenState {
     required MediaItem metadata,
     required PlaybackInitializationResult result,
     AudioTrack? preferredAudioTrack,
-    SubtitleTrack? preferredSubtitleTrack,
-    SubtitleTrack? preferredSecondarySubtitleTrack,
+    SubtitlePreference? preferredSubtitleTrack,
+    SubtitlePreference? preferredSecondarySubtitleTrack,
     bool preserveSubtitleSourceIdentity = true,
   }) async {
     await _waitForProfileSettingsIfNeeded();
@@ -440,8 +440,8 @@ extension _VideoPlayerOpenMethods on VideoPlayerScreenState {
     required PlexClient? plexClient,
     required MediaServerUserProfile? Function() getProfileSettings,
     AudioTrack? preferredAudioTrack,
-    SubtitleTrack? preferredSubtitleTrack,
-    SubtitleTrack? preferredSecondarySubtitleTrack,
+    SubtitlePreference? preferredSubtitleTrack,
+    SubtitlePreference? preferredSecondarySubtitleTrack,
   }) {
     return TrackManager(
       player: forPlayer,

lib/screens/video_player/parts/playback_start.dart

@@ -346,8 +346,8 @@ extension _VideoPlayerPlaybackStartMethods on VideoPlayerScreenState {
           plexClient: mediaClient is PlexClient ? mediaClient : null,
           getProfileSettings: () => context.read<UserProfileProvider>().profileSettings,
           preferredAudioTrack: _preferredAudioTrack,
-          preferredSubtitleTrack: subtitleSelection.primaryTrack,
-          preferredSecondarySubtitleTrack: subtitleSelection.secondaryTrack,
+          preferredSubtitleTrack: SubtitlePreference.trackOrNull(subtitleSelection.primaryTrack),
+          preferredSecondarySubtitleTrack: SubtitlePreference.trackOrNull(subtitleSelection.secondaryTrack),
         );
 
         // Store only the active sidecars for re-use after backend fallback.

lib/screens/video_player_screen.dart

@@ -62,6 +62,7 @@ import '../services/display_mode_service.dart';
 import '../services/media_control_router.dart';
 import '../services/settings_service.dart';
 import '../services/sleep_timer_service.dart';
+import '../services/subtitle_preference.dart';
 import '../services/track_manager.dart';
 import '../services/track_selection_service.dart';
 import '../services/ambient_lighting_service.dart';
@@ -137,39 +138,27 @@ bool shouldAutoStartReloadedMedia({
 /// Builds an item-agnostic subtitle preference for an episode replacement.
 ///
 /// Source ids and sidecar URIs belong to the current media item. Only the
-/// committed semantic choice may cross the item boundary; native state is a
-/// fallback for sessions created before source-backed selection was recorded.
-SubtitleTrack? subtitlePreferenceForItemChange({
+/// committed semantic choice — a [SubtitleIntent] — may cross the item
+/// boundary; native state is a fallback for sessions created before
+/// source-backed selection was recorded.
+SubtitlePreference? subtitlePreferenceForItemChange({
   required bool hasCommittedSelection,
   required SubtitleTrack? committedTrack,
   required SubtitleTrack? nativeTrack,
 }) {
-  SubtitleTrack? normalize(SubtitleTrack? track, {required bool preserveOff}) {
+  SubtitlePreference? normalize(SubtitleTrack? track, {required bool preserveOff}) {
     if (track == null) return null;
-    if (track.id == SubtitleTrack.off.id) return preserveOff ? SubtitleTrack.off : null;
+    if (track.id == SubtitleTrack.off.id) return preserveOff ? const SubtitlePreference.off() : null;
 
-    final hasSemanticMetadata =
-        (track.title?.isNotEmpty ?? false) ||
-        (track.language?.isNotEmpty ?? false) ||
-        (track.codec?.isNotEmpty ?? false);
-    if (!hasSemanticMetadata) return null;
-
-    return SubtitleTrack(
-      id: 'navigation',
-      title: track.title,
-      language: track.language,
-      codec: track.codec,
-      isDefault: track.isDefault,
-      isForced: track.isForced,
-      isExternal: track.isExternal,
-    );
+    final intent = SubtitleIntent.fromTrack(track);
+    return intent == null ? null : SubtitlePreference.intent(intent);
   }
 
   if (!hasCommittedSelection) {
     return normalize(nativeTrack, preserveOff: true);
   }
 
-  if (committedTrack == null) return SubtitleTrack.off;
+  if (committedTrack == null) return const SubtitlePreference.off();
 
   final committedPreference = normalize(committedTrack, preserveOff: true);
   if (committedPreference != null) return committedPreference;
@@ -377,8 +366,8 @@ class VideoPlayerScreenState extends State<VideoPlayerScreen> with WidgetsBindin
   late TranscodeQualityPreset _selectedQualityPreset;
   int? _selectedAudioStreamId;
   AudioTrack? _preferredAudioTrack;
-  SubtitleTrack? _preferredSubtitleTrack;
-  SubtitleTrack? _preferredSecondarySubtitleTrack;
+  SubtitlePreference? _preferredSubtitleTrack;
+  SubtitlePreference? _preferredSecondarySubtitleTrack;
   bool _serverSupportsTranscoding = false;
   // Kicked off early in the player initialization attempt for online non-live playback so
   // the metadata fetch (and transcode-decision HTTP, if non-original preset)
@@ -788,8 +777,8 @@ class VideoPlayerScreenState extends State<VideoPlayerScreen> with WidgetsBindin
     _playbackTranscodeSessionId = generateSessionIdentifier();
     _selectedAudioStreamId = widget.selectedAudioStreamId;
     _preferredAudioTrack = widget.preferredAudioTrack;
-    _preferredSubtitleTrack = widget.preferredSubtitleTrack;
-    _preferredSecondarySubtitleTrack = widget.preferredSecondarySubtitleTrack;
+    _preferredSubtitleTrack = SubtitlePreference.trackOrNull(widget.preferredSubtitleTrack);
+    _preferredSecondarySubtitleTrack = SubtitlePreference.trackOrNull(widget.preferredSecondarySubtitleTrack);
     _selectedQualityPreset = widget.selectedQualityPreset ?? TranscodeQualityPreset.original;
 
     _playNextCancelFocusNode = FocusNode(debugLabel: 'PlayNextCancel');
@@ -811,10 +800,7 @@ class VideoPlayerScreenState extends State<VideoPlayerScreen> with WidgetsBindin
       );
     }
     if (_preferredSubtitleTrack != null) {
-      final subtitleDesc = _preferredSubtitleTrack!.id == "no"
-          ? "OFF"
-          : "${_preferredSubtitleTrack!.title ?? _preferredSubtitleTrack!.id} (${_preferredSubtitleTrack!.language ?? "unknown"})";
-      appLogger.d('Preferred subtitle track: $subtitleDesc');
+      appLogger.d('Preferred subtitle track: $_preferredSubtitleTrack');
     }
 
     try {

lib/services/jellyfin_client.dart

@@ -62,6 +62,7 @@ import 'jellyfin_playback_urls.dart';
 import 'jellyfin_trickplay_service.dart';
 import 'playback_initialization_types.dart';
 import 'scrub_preview_source.dart';
+import 'subtitle_preference.dart';
 import 'track_selection_service.dart';
 import '../mpv/mpv.dart';
 

lib/services/jellyfin_client/parts/playback.dart

@@ -298,41 +298,31 @@ mixin _JellyfinPlaybackMethods on _JellyfinClientInternals {
     return mediaInfo.audioTracks.any((track) => track.id == explicit) ? explicit : null;
   }
 
-  int? _validJellyfinSubtitleStreamId(SubtitleTrack? preferred, MediaSourceInfo mediaInfo) {
-    if (preferred == null) return null;
-    if (preferred.id == SubtitleTrack.off.id) return -1;
-
-    var semanticPreference = preferred;
-    const sourcePrefix = 'source:';
-    if (preferred.id.startsWith(sourcePrefix)) {
-      semanticPreference = SubtitleTrack(
-        id: 'navigation',
-        title: preferred.title,
-        language: preferred.language,
-        codec: preferred.codec,
-        isDefault: preferred.isDefault,
-        isForced: preferred.isForced,
-        isExternal: preferred.isExternal,
-        isContainer: preferred.isContainer,
-      );
-      final explicit = int.tryParse(preferred.id.substring(sourcePrefix.length));
-      if (explicit != null) {
-        final exactSource = mediaInfo.subtitleTracks.where((track) => track.id == explicit).firstOrNull;
-        if (exactSource != null) {
-          // A source id is authoritative only within one item. When semantic
-          // metadata is available, prefer the best current-source row so a
-          // reused stream index cannot override a better title/codec match.
-          final semanticMatch = findPlexTrackForMpvSubtitle(semanticPreference, mediaInfo.subtitleTracks);
-          final hasLanguage = preferred.language?.isNotEmpty ?? false;
-          if (!hasLanguage || (semanticMatch?.id == explicit && preferred.isForced == exactSource.forced)) {
-            return explicit;
+  int? _validJellyfinSubtitleStreamId(SubtitlePreference? preferred, MediaSourceInfo mediaInfo) {
+    switch (preferred) {
+      case null:
+        return null;
+      case SubtitleOffPreference():
+        return -1;
+      case SubtitleIntentPreference(:final intent):
+        return findSourceTrackForIntent(intent, mediaInfo.subtitleTracks)?.id;
+      case SubtitleTrackPreference(:final track):
+        const sourcePrefix = 'source:';
+        final intent = SubtitleIntent.fromTrack(track);
+        if (track.id.startsWith(sourcePrefix)) {
+          final explicit = int.tryParse(track.id.substring(sourcePrefix.length));
+          if (explicit != null && mediaInfo.subtitleTracks.any((row) => row.id == explicit)) {
+            // A source id is authoritative only within one item. When semantic
+            // metadata is available, re-derive the row through the hard-gated
+            // intent match so a reused stream index cannot cross language or
+            // forced-ness classes (#1716).
+            final hasLanguage = intent?.language?.isNotEmpty ?? false;
+            if (!hasLanguage) return explicit;
+            return findSourceTrackForIntent(intent!, mediaInfo.subtitleTracks)?.id;
           }
-          return semanticMatch?.id;
         }
-      }
+        return intent == null ? null : findSourceTrackForIntent(intent, mediaInfo.subtitleTracks)?.id;
     }
-
-    return findPlexTrackForMpvSubtitle(semanticPreference, mediaInfo.subtitleTracks)?.id;
   }
 
   Map<String, dynamic>? _selectNegotiatedMediaSource(Object? sources, String? selectedSourceId) {

lib/services/playback_initialization_types.dart

@@ -6,6 +6,7 @@ import '../media/media_version.dart';
 import '../models/audio_quality_preset.dart';
 import '../models/transcode_quality_preset.dart';
 import '../mpv/mpv.dart';
+import 'subtitle_preference.dart';
 
 /// Inputs for [MediaServerClient.getPlaybackInitialization]. Most fields
 /// are backend-specific knobs (transcode preset, audio stream, session ids).
@@ -44,7 +45,7 @@ class PlaybackInitializationOptions {
   /// Preferred subtitle carried across navigation/reloads. Backends that put
   /// embedded subtitles in the rendition can use this during negotiation;
   /// sidecar-capable backends keep subtitle delivery independent.
-  final SubtitleTrack? preferredSubtitleTrack;
+  final SubtitlePreference? preferredSubtitleTrack;
 
   /// Plex transcode `X-Plex-Session-Identifier`. Required for Plex transcode.
   final String? sessionIdentifier;

lib/services/playback_subtitle_resolver.dart

@@ -4,7 +4,9 @@ import '../media/media_item.dart';
 import '../media/media_server_user_profile.dart';
 import '../media/media_source_info.dart';
 import '../mpv/mpv.dart';
+import '../utils/subtitle_forced_semantics.dart';
 import 'playback_initialization_types.dart';
+import 'subtitle_preference.dart';
 import 'track_selection_service.dart';
 
 /// A source-catalog subtitle choice.
@@ -84,53 +86,57 @@ class PlaybackSubtitleSelection {
 class PlaybackSubtitleResolver {
   const PlaybackSubtitleResolver._();
 
-  /// Removes a per-source ID while retaining the semantic identity needed to
-  /// carry a subtitle choice across items or media sources.
-  static SubtitleTrack? preferenceWithoutSourceIdentity(SubtitleTrack? preferred) {
-    if (preferred == null || preferred.id == SubtitleTrack.off.id || !preferred.id.startsWith('source:')) {
-      return preferred;
-    }
-    return SubtitleTrack(
-      id: 'navigation',
-      title: preferred.title,
-      language: preferred.language,
-      codec: preferred.codec,
-      isDefault: preferred.isDefault,
-      isForced: preferred.isForced,
-      isExternal: preferred.isExternal,
-      isContainer: preferred.isContainer,
-    );
-  }
-
-  static SubtitleTrack? _sourceBackedPreference(
-    SubtitleTrack? preferred,
+  static SubtitlePreference? _sourceBackedPreference(
+    SubtitlePreference? preferred,
     MediaSourceInfo? mediaInfo,
     List<_SubtitleCandidate> candidates, {
     required bool preserveSourceIdentity,
   }) {
-    if (preferred == null || preferred.id == SubtitleTrack.off.id) return preferred;
-
-    var semanticPreference = preferred;
-    if (preferred.id.startsWith('source:')) {
-      if (preserveSourceIdentity) {
-        final sourceStreamId = int.tryParse(preferred.id.substring('source:'.length));
-        final exactCandidate = candidates.where((candidate) => candidate.sourceStreamId == sourceStreamId).firstOrNull;
-        if (exactCandidate != null) return exactCandidate.track;
-      } else {
-        semanticPreference = preferenceWithoutSourceIdentity(preferred)!;
+    SubtitlePreference resolveIntent(SubtitleIntentPreference preference) {
+      final row = findSourceTrackForIntent(preference.intent, mediaInfo?.subtitleTracks ?? const <MediaSubtitleTrack>[]);
+      if (row != null) {
+        for (final candidate in candidates) {
+          if (candidate.sourceStreamId == row.id) return SubtitlePreference.track(candidate.track);
+        }
       }
+      // Keep the declined intent: selectSubtitleTrack's intent branch and the
+      // priority ladder decide (falling to the server's own selection).
+      return preference;
     }
 
-    final sourceMatch = findPlexTrackForMpvSubtitle(
-      semanticPreference,
-      mediaInfo?.subtitleTracks ?? const <MediaSubtitleTrack>[],
-    );
-    if (sourceMatch == null) return semanticPreference;
-
-    for (final candidate in candidates) {
-      if (candidate.sourceStreamId == sourceMatch.id) return candidate.track;
+    // Crossing an item/source boundary strips identity from every reference.
+    final pref = preserveSourceIdentity ? preferred : SubtitlePreference.demoteToIntent(preferred);
+    switch (pref) {
+      case null || SubtitleOffPreference():
+        return pref;
+      case SubtitleIntentPreference():
+        return resolveIntent(pref);
+      case SubtitleTrackPreference(:final track):
+        if (track.id.startsWith('source:')) {
+          final sourceStreamId = int.tryParse(track.id.substring('source:'.length));
+          final exactCandidate = candidates
+              .where((candidate) => candidate.sourceStreamId == sourceStreamId)
+              .firstOrNull;
+          if (exactCandidate != null) return SubtitlePreference.track(exactCandidate.track);
+          // The row vanished from this source: the id is stale, so only its
+          // semantics may carry forward (hard-gated, unlike the old fuzzy
+          // rematch — a class-crossing lookalike must not inherit the id).
+          final demoted = SubtitlePreference.demoteToIntent(pref);
+          return demoted is SubtitleIntentPreference ? resolveIntent(demoted) : demoted;
+        }
+        // Same-item raw native/uri reference: identity-match it back to this
+        // item's own rows so the selection is source-backed where possible.
+        final sourceMatch = findPlexTrackForMpvSubtitle(
+          track,
+          mediaInfo?.subtitleTracks ?? const <MediaSubtitleTrack>[],
+        );
+        if (sourceMatch != null) {
+          for (final candidate in candidates) {
+            if (candidate.sourceStreamId == sourceMatch.id) return SubtitlePreference.track(candidate.track);
+          }
+        }
+        return pref;
     }
-    return semanticPreference;
   }
 
   static PlaybackSubtitleSelection resolve({
@@ -139,8 +145,8 @@ class PlaybackSubtitleResolver {
     required List<PlaybackSubtitleSidecar> sidecars,
     MediaServerUserProfile? profileSettings,
     AudioTrack? preferredAudioTrack,
-    SubtitleTrack? preferredSubtitleTrack,
-    SubtitleTrack? preferredSecondarySubtitleTrack,
+    SubtitlePreference? preferredSubtitleTrack,
+    SubtitlePreference? preferredSecondarySubtitleTrack,
     bool preserveSourceIdentity = true,
   }) {
     final candidates = <_SubtitleCandidate>[];
@@ -199,8 +205,12 @@ class PlaybackSubtitleResolver {
       candidates,
       preserveSourceIdentity: preserveSourceIdentity,
     );
-    if (secondaryPreference != null && secondaryPreference.id != SubtitleTrack.off.id) {
-      final secondary = service.findBestSubtitleMatch(availableTracks, secondaryPreference);
+    if (secondaryPreference != null && secondaryPreference is! SubtitleOffPreference) {
+      final secondary = switch (secondaryPreference) {
+        SubtitleOffPreference() => null,
+        SubtitleTrackPreference(:final track) => service.findBestSubtitleMatch(availableTracks, track),
+        SubtitleIntentPreference(:final intent) => findNativeTrackForIntent(intent, availableTracks),
+      };
       secondaryCandidate = candidates
           .where((candidate) => candidate.track.id == secondary?.id && candidate.track.id != primary.id)
           .firstOrNull;
@@ -233,7 +243,9 @@ class PlaybackSubtitleResolver {
       language: playable?.language ?? sourceTrack.languageCode ?? sourceTrack.language,
       codec: playable?.codec ?? sourceTrack.codec,
       isDefault: sourceTrack.selected,
-      isForced: sourceTrack.forced,
+      // Effective forced-ness: an intent captured from this committed track
+      // must stay in the same class as the row it came from (#1716).
+      isForced: sourceTrack.effectiveForced,
       isExternal: playable != null,
       isContainer: playable?.isContainer ?? false,
       uri: playable?.uri,

lib/services/subtitle_preference.dart

@@ -0,0 +1,131 @@
+import '../mpv/mpv.dart';
+import '../utils/subtitle_forced_semantics.dart';
+
+/// Item-agnostic semantic subtitle intent.
+///
+/// [language] and [forced] are hard matching requirements — an intent only
+/// resolves to a track of the same language AND the same forced-ness class,
+/// otherwise resolution declines and the selection ladder falls back to the
+/// server's own per-item choice (#1716/#1717). [forced] is EFFECTIVE
+/// forced-ness (flag OR title-says-forced), captured once at the boundary.
+final class SubtitleIntent {
+  final String? language;
+  final bool forced;
+
+  /// Tiebreakers between same-class candidates, and log diagnostics.
+  final String? title;
+  final String? codec;
+  final bool isExternal;
+
+  const SubtitleIntent({this.language, required this.forced, this.title, this.codec, this.isExternal = false});
+
+  /// Null when [track] is null/off or carries no semantic metadata at all —
+  /// an intent that can never resolve is not worth carrying.
+  static SubtitleIntent? fromTrack(SubtitleTrack? track) {
+    if (track == null || track.id == SubtitleTrack.off.id) return null;
+    final hasSemanticMetadata =
+        (track.title?.isNotEmpty ?? false) ||
+        (track.language?.isNotEmpty ?? false) ||
+        (track.codec?.isNotEmpty ?? false);
+    if (!hasSemanticMetadata) return null;
+    return SubtitleIntent(
+      language: track.language,
+      forced: track.effectiveForced,
+      title: track.title,
+      codec: track.codec,
+      isExternal: track.isExternal,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      other is SubtitleIntent &&
+      other.language == language &&
+      other.forced == forced &&
+      other.title == title &&
+      other.codec == codec &&
+      other.isExternal == isExternal;
+
+  @override
+  int get hashCode => Object.hash(language, forced, title, codec, isExternal);
+
+  @override
+  String toString() => 'SubtitleIntent($language, forced: $forced, title: $title, codec: $codec)';
+}
+
+/// What the next open/selection pass should aim for, subtitle-wise.
+///
+/// [SubtitlePreference.track] is an identity reference (`source:` row, sidecar
+/// URI, or raw native track) valid only within the current item and media
+/// source. [SubtitlePreference.intent] carries semantics alone and is the only
+/// form that may cross an item/source boundary — see [demoteToIntent].
+sealed class SubtitlePreference {
+  const SubtitlePreference();
+
+  const factory SubtitlePreference.off() = SubtitleOffPreference;
+  const factory SubtitlePreference.track(SubtitleTrack track) = SubtitleTrackPreference;
+  const factory SubtitlePreference.intent(SubtitleIntent intent) = SubtitleIntentPreference;
+
+  /// Identity-ref wrapper: null stays null, the off sentinel becomes [off].
+  static SubtitlePreference? trackOrNull(SubtitleTrack? track) {
+    if (track == null) return null;
+    if (track.id == SubtitleTrack.off.id) return const SubtitlePreference.off();
+    return SubtitlePreference.track(track);
+  }
+
+  /// Crossing an item/source boundary: identity references lose their meaning
+  /// there, so every track reference becomes a semantic intent (or null when
+  /// it has no semantics). Off and existing intents pass through.
+  static SubtitlePreference? demoteToIntent(SubtitlePreference? preference) {
+    switch (preference) {
+      case null || SubtitleOffPreference() || SubtitleIntentPreference():
+        return preference;
+      case SubtitleTrackPreference(:final track):
+        final intent = SubtitleIntent.fromTrack(track);
+        return intent == null ? null : SubtitlePreference.intent(intent);
+    }
+  }
+}
+
+final class SubtitleOffPreference extends SubtitlePreference {
+  const SubtitleOffPreference();
+
+  @override
+  bool operator ==(Object other) => other is SubtitleOffPreference;
+
+  @override
+  int get hashCode => (SubtitleOffPreference).hashCode;
+
+  @override
+  String toString() => 'SubtitlePreference.off';
+}
+
+final class SubtitleTrackPreference extends SubtitlePreference {
+  final SubtitleTrack track;
+
+  const SubtitleTrackPreference(this.track);
+
+  @override
+  bool operator ==(Object other) => other is SubtitleTrackPreference && other.track == track;
+
+  @override
+  int get hashCode => track.hashCode;
+
+  @override
+  String toString() => 'SubtitlePreference.track(${track.id})';
+}
+
+final class SubtitleIntentPreference extends SubtitlePreference {
+  final SubtitleIntent intent;
+
+  const SubtitleIntentPreference(this.intent);
+
+  @override
+  bool operator ==(Object other) => other is SubtitleIntentPreference && other.intent == intent;
+
+  @override
+  int get hashCode => intent.hashCode;
+
+  @override
+  String toString() => 'SubtitlePreference.intent($intent)';
+}

lib/services/track_manager.dart

@@ -8,6 +8,7 @@ import '../media/media_item.dart';
 import '../media/media_server_user_profile.dart';
 import '../media/media_source_info.dart';
 import '../services/settings_service.dart';
+import '../services/subtitle_preference.dart';
 import '../services/track_selection_service.dart';
 import '../utils/app_logger.dart';
 import '../utils/track_label_builder.dart';
@@ -50,8 +51,8 @@ class TrackManager {
   MediaItem metadata;
   MediaSourceInfo? mediaInfo;
   AudioTrack? preferredAudioTrack;
-  SubtitleTrack? preferredSubtitleTrack;
-  SubtitleTrack? preferredSecondarySubtitleTrack;
+  SubtitlePreference? preferredSubtitleTrack;
+  SubtitlePreference? preferredSecondarySubtitleTrack;
 
   // ── Internal state ─────────────────────────────────────────────────
 

lib/services/track_selection_service.dart

@@ -9,6 +9,8 @@ import '../media/media_source_info.dart';
 import '../utils/future_extensions.dart';
 import '../utils/app_logger.dart';
 import '../utils/language_codes.dart';
+import '../utils/subtitle_forced_semantics.dart';
+import 'subtitle_preference.dart';
 
 // These functions match MPV tracks to Plex tracks by properties (language,
 // codec, title, etc.) instead of list index, since the two may be ordered
@@ -34,7 +36,7 @@ int _scoreSubtitleMatch(SubtitleTrack mpvTrack, MediaSubtitleTrack plexTrack, {r
 
   score += _titleScore(mpvTrack.title, plexTrack.title, plexTrack.displayTitle);
 
-  if (mpvTrack.isForced == plexTrack.forced) {
+  if (mpvTrack.effectiveForced == plexTrack.effectiveForced) {
     score += 2;
   }
 
@@ -130,7 +132,7 @@ bool _lowMetadataSubtitleFactsAreCompatible(SubtitleTrack mpvTrack, MediaSubtitl
     return false;
   }
 
-  return mpvTrack.isForced == plexTrack.forced;
+  return mpvTrack.effectiveForced == plexTrack.effectiveForced;
 }
 
 int _scoreLowMetadataSubtitleFacts(SubtitleTrack mpvTrack, MediaSubtitleTrack plexTrack) {
@@ -152,7 +154,7 @@ int _scoreLowMetadataSubtitleFacts(SubtitleTrack mpvTrack, MediaSubtitleTrack pl
       _titleScore(mpvTrack.title, plexTrack.title, plexTrack.displayTitle) > 0) {
     score += 3;
   }
-  if (mpvTrack.isForced == plexTrack.forced) score += 2;
+  if (mpvTrack.effectiveForced == plexTrack.effectiveForced) score += 2;
   return score;
 }
 
@@ -341,6 +343,54 @@ MediaSubtitleTrack? findPlexTrackForMpvSubtitle(
   );
 }
 
+/// Find the source-catalog row that serves a cross-item subtitle intent.
+///
+/// Identity matching ([findPlexTrackForMpvSubtitle]) answers "which row IS
+/// this track"; this answers "which row of a DIFFERENT item serves the same
+/// intent". Language and effective forced-ness are hard requirements: the
+/// intent's class is preserved or the match declines, so the selection ladder
+/// can fall back to the server's own per-item choice (#1716/#1717).
+MediaSubtitleTrack? findSourceTrackForIntent(SubtitleIntent intent, List<MediaSubtitleTrack> sourceTracks) {
+  MediaSubtitleTrack? bestMatch;
+  var bestScore = -1;
+  for (final row in sourceTracks) {
+    if (!_languagesMatch(intent.language, row.languageCode ?? row.language)) continue;
+    if (row.effectiveForced != intent.forced) continue;
+
+    var score = 0;
+    if (_subtitleCodecsMatch(intent.codec, row.codec)) score += 5;
+    score += _titleScore(intent.title, row.title, row.displayTitle);
+    if (intent.isExternal == row.isExternal) score += 1;
+    if (score > bestScore) {
+      bestScore = score;
+      bestMatch = row;
+    }
+  }
+  return bestMatch;
+}
+
+/// Native-track twin of [findSourceTrackForIntent], for catalogs the source
+/// side cannot describe (legacy offline sidecars) and late-arriving tracks.
+SubtitleTrack? findNativeTrackForIntent(SubtitleIntent intent, List<SubtitleTrack> tracks) {
+  SubtitleTrack? bestMatch;
+  var bestScore = -1;
+  for (final track in tracks) {
+    if (track.id == SubtitleTrack.auto.id || track.id == SubtitleTrack.off.id) continue;
+    if (!_languagesMatch(intent.language, track.language)) continue;
+    if (track.effectiveForced != intent.forced) continue;
+
+    var score = 0;
+    if (_subtitleCodecsMatch(intent.codec, track.codec)) score += 5;
+    score += _titleScore(intent.title, track.title, null);
+    if (intent.isExternal == track.isExternal) score += 1;
+    if (score > bestScore) {
+      bestScore = score;
+      bestMatch = track;
+    }
+  }
+  return bestMatch;
+}
+
 /// Find the MPV audio track that matches a Plex audio track
 AudioTrack? findMpvTrackForPlexAudio(
   MediaAudioTrack plexTrack,
@@ -642,7 +692,7 @@ class TrackSelectionService {
     MediaServerUserProfile profile, {
     bool forcedOnly = false,
   }) {
-    final candidates = forcedOnly ? availableTracks.where((track) => track.isForced).toList() : availableTracks;
+    final candidates = forcedOnly ? availableTracks.where((track) => track.effectiveForced).toList() : availableTracks;
     if (candidates.isEmpty) return null;
 
     final preferredLanguages = _buildPreferredLanguages(profile, isAudio: false);
@@ -675,7 +725,7 @@ class TrackSelectionService {
 
   SubtitleTrack? _findForcedSubtitleTrack(List<SubtitleTrack> availableTracks) {
     for (final track in availableTracks) {
-      if (track.isForced) return track;
+      if (track.effectiveForced) return track;
     }
     return null;
   }
@@ -931,30 +981,57 @@ class TrackSelectionService {
   /// nothing at all.
   TrackSelectionResult<SubtitleTrack>? selectSubtitleTrack(
     List<SubtitleTrack> availableTracks,
-    SubtitleTrack? preferredSubtitleTrack,
+    SubtitlePreference? preference,
     AudioTrack? selectedAudioTrack, {
     bool waitForPendingSource = true,
   }) {
-    // Priority 1: Try preferred track from navigation
-    if (preferredSubtitleTrack != null) {
-      if (preferredSubtitleTrack.id == 'no') {
+    // Priority 1: the caller's preference — an identity reference into this
+    // item, or a semantic intent carried across an item boundary.
+    switch (preference) {
+      case null:
+        break;
+      case SubtitleOffPreference():
         return TrackSelectionResult(SubtitleTrack.off, TrackSelectionPriority.navigation);
-      } else if (availableTracks.isNotEmpty) {
-        final subtitleToSelect = findBestSubtitleMatch(availableTracks, preferredSubtitleTrack);
-        if (subtitleToSelect != null) {
-          return TrackSelectionResult(subtitleToSelect, TrackSelectionPriority.navigation);
+      case SubtitleTrackPreference(:final track):
+        if (track.id == 'no') {
+          return TrackSelectionResult(SubtitleTrack.off, TrackSelectionPriority.navigation);
         }
-      }
-      if (waitForPendingSource && preferredSubtitleTrack.id.startsWith('source:')) {
-        // Only a row this catalog actually advertises can still show up
-        // natively. An id the catalog does not carry — a stale preference from
-        // another media source — resolves the same way on every retry, so
-        // waiting for it would defer selection forever.
-        final sourceTrack = _sourceSubtitleTrack(preferredSubtitleTrack.id);
-        if (sourceTrack != null && !_hasCompleteDirectSourceCatalogFor(sourceTrack, availableTracks)) {
-          return null;
+        if (availableTracks.isNotEmpty) {
+          final subtitleToSelect = findBestSubtitleMatch(availableTracks, track);
+          if (subtitleToSelect != null) {
+            return TrackSelectionResult(subtitleToSelect, TrackSelectionPriority.navigation);
+          }
         }
-      }
+        if (waitForPendingSource && track.id.startsWith('source:')) {
+          // Only a row this catalog actually advertises can still show up
+          // natively. An id the catalog does not carry — a stale preference
+          // from another media source — resolves the same way on every retry,
+          // so waiting for it would defer selection forever.
+          final sourceTrack = _sourceSubtitleTrack(track.id);
+          if (sourceTrack != null && !_hasCompleteDirectSourceCatalogFor(sourceTrack, availableTracks)) {
+            return null;
+          }
+        }
+      case SubtitleIntentPreference(:final intent):
+        if (availableTracks.isNotEmpty) {
+          final match = findNativeTrackForIntent(intent, availableTracks);
+          if (match != null) {
+            return TrackSelectionResult(match, TrackSelectionPriority.navigation);
+          }
+        }
+        if (waitForPendingSource) {
+          // Mirror of the source-id rule above: only an intent this catalog
+          // can actually serve may still show up natively. A class-preserving
+          // row proves the catalog can serve it; an incomplete direct catalog
+          // means its native track may not have arrived yet. An unservable
+          // intent resolves the same way on every retry — decline immediately
+          // and let the ladder decide.
+          final servableRow = findSourceTrackForIntent(intent, plexMediaInfo?.subtitleTracks ?? const []);
+          if (servableRow != null && !_hasCompleteDirectSourceCatalogFor(servableRow, availableTracks)) {
+            return null;
+          }
+        }
+        appLogger.d('Subtitle intent declined: $intent');
     }
 
     // Priority 2: Trust the server's selected track. Plex computes this from
@@ -1029,8 +1106,8 @@ class TrackSelectionService {
   /// Select and apply audio and subtitle tracks based on preferences
   Future<bool> selectAndApplyTracks({
     AudioTrack? preferredAudioTrack,
-    SubtitleTrack? preferredSubtitleTrack,
-    SubtitleTrack? preferredSecondarySubtitleTrack,
+    SubtitlePreference? preferredSubtitleTrack,
+    SubtitlePreference? preferredSecondarySubtitleTrack,
     double? defaultPlaybackSpeed,
     Function(AudioTrack)? onAudioTrackChanged,
     Function(SubtitleTrack)? onSubtitleTrackChanged,
@@ -1113,11 +1190,17 @@ class TrackSelectionService {
     }
 
     // Apply preferred secondary subtitle track if provided (mpv-only)
-    if (preferredSecondarySubtitleTrack != null &&
-        preferredSecondarySubtitleTrack.id != 'no' &&
+    final secondaryPreference = preferredSecondarySubtitleTrack;
+    if (secondaryPreference != null &&
+        secondaryPreference is! SubtitleOffPreference &&
         player.supportsSecondarySubtitles &&
         realSubtitleTracks.isNotEmpty) {
-      final secondaryMatch = findBestSubtitleMatch(realSubtitleTracks, preferredSecondarySubtitleTrack);
+      final secondaryMatch = switch (secondaryPreference) {
+        SubtitleOffPreference() => null,
+        SubtitleTrackPreference(:final track) =>
+          track.id == 'no' ? null : findBestSubtitleMatch(realSubtitleTracks, track),
+        SubtitleIntentPreference(:final intent) => findNativeTrackForIntent(intent, realSubtitleTracks),
+      };
       if (secondaryMatch != null && secondaryMatch.id != 'no') {
         appLogger.d(
           'Secondary subtitle: ${secondaryMatch.title ?? secondaryMatch.language ?? "Track ${secondaryMatch.id}"}',

lib/utils/subtitle_forced_semantics.dart

@@ -0,0 +1,16 @@
+import '../media/media_source_info.dart';
+import '../mpv/mpv.dart';
+import 'track_label_builder.dart';
+
+/// Effective forced-ness, mirroring server behavior (#1716/#1717): a subtitle
+/// stream counts as forced when its flag is set OR its title says "forced".
+/// Every forced comparison must use these getters on BOTH sides — the raw
+/// flags stay untouched so parsing and the file-info UI keep server truth.
+
+extension MediaSubtitleTrackForcedSemantics on MediaSubtitleTrack {
+  bool get effectiveForced => forced || titleSaysForced(title) || titleSaysForced(displayTitle);
+}
+
+extension SubtitleTrackForcedSemantics on SubtitleTrack {
+  bool get effectiveForced => isForced || titleSaysForced(title);
+}

lib/utils/track_label_builder.dart

@@ -115,6 +115,11 @@ Set<String> _subtitleCodecAliases(String? codec) {
 
 String _metadataToken(String value) => value.trim().toUpperCase().replaceAll(RegExp(r'[^A-Z0-9]+'), '_');
 
+/// Whether a track title declares the stream forced ("FR Forced [ASS]",
+/// "French (Forced)"). Whole-token match, so "unforced" does not qualify.
+/// Plex itself treats such streams as forced even when the API flag is false.
+bool titleSaysForced(String? value) => _metadataToken(value ?? '').split('_').contains('FORCED');
+
 class TrackLabelBuilder {
   TrackLabelBuilder._();
 
@@ -161,7 +166,7 @@ class TrackLabelBuilder {
       techParts: [if (codec != null && codec.isNotEmpty) CodecUtils.formatSubtitleCodec(codec)],
       fallbackPrefix: 'Track',
       index: index,
-      forced: forced || _saysForced(cleanedTitle),
+      forced: forced || titleSaysForced(cleanedTitle),
     );
   }
 
@@ -195,7 +200,7 @@ class TrackLabelBuilder {
       primary = '$fallbackPrefix ${index + 1}';
     }
 
-    if (forced && !_saysForced(primary)) {
+    if (forced && !titleSaysForced(primary)) {
       primary = '$primary (Forced)';
     }
 
@@ -203,8 +208,6 @@ class TrackLabelBuilder {
     return TrackLabel(primary, secondaryParts.isEmpty ? null : secondaryParts.join(' · '));
   }
 
-  static bool _saysForced(String? value) => _metadataToken(value ?? '').split('_').contains('FORCED');
-
   static bool _restatesLanguage(String title, String languageDisplay, List<String?> rawLanguageValues) {
     final normalized = title.trim().toLowerCase();
     if (normalized == languageDisplay.trim().toLowerCase()) return true;