Traiter les retours d'usage du 2026-08-18 (2ᵉ série)

Six lots, issus d'IDEES.md. Les décisions actées sont reportées dans
CLAUDE.md, et les entrées traitées retirées d'IDEES.md.

1. Douchette USB, ISSN et enchaînement du scan
   - Champ ISBN focalisé à l'ouverture : c'est tout ce qu'exige une
     douchette USB, qui se présente au système comme un clavier. Remède
     au scan caméra, qui rate sur la webcam d'un PC (optique, pas
     décodage).
   - Un EAN en 977 est un périodique : il porte un ISSN, donc un titre de
     revue. Intercepté AVANT la validation ISBN (c'est un EAN-13
     parfaitement valide), l'ISSN est déduit du code puis nommé via
     bib.issn. Auparavant la cascade s'exécutait en entier pour finir sur
     « aucun résultat ».
   - L'enchaînement après scan existait déjà mais était invisible : une
     étape « Recherche » affiche désormais le code interrogé.

2. ISBN affichés avec des tirets
   Tables extraites du RangeMessage.xml officiel — plusieurs tranches ne
   sont pas celles qu'on suppose. Le francophone est découpé en entier,
   ailleurs on s'arrête au groupe et à la clé : aucune coupure fausse.
   Corrige au passage l'export CSV, où un ISBN nu était lu comme un
   nombre par Excel.

3. Hors-ligne : la liste d'envies
   ListerSouhaitsAsync était le seul point de lecture hors du dispositif
   hors-ligne, d'où le « 404 Not Found » brut à l'écran. Cinquième
   instantané, écritures refusées, plus aucun message HTTP. Même défaut
   corrigé sur la bibliographie.

4. Navigation par onglets
   Catalogue / Auteurs / Prêts / Envies dans MainLayout ; les barres
   d'actions ne portent plus que des actions. Filtres repliés derrière un
   bouton compteur, ligne « format » masquée quand le fonds n'a qu'un
   format. Une seule entrée d'ajout, désactivée hors-ligne — pas masquée.

5. Liste d'envies : ordre, recherche, couvertures
   Migration RangDesEnvies. Le remplissage reconduit l'ordre affiché
   jusqu'ici : sans lui, les listes existantes se seraient réordonnées
   toutes seules. Réordonnancement par flèches et glisser-déposer (le
   drag & drop HTML5 ne marche pas au doigt). Ajout dans son propre
   écran, avec recherche par titre (bib.title) et couvertures enfin
   alimentées.

6. Bibliographie : une source muette n'est pas une liste vide
   L'écran affichait « BnF injoignable » PUIS « la BnF ne connaît aucun
   livre de cet auteur » — la seconde phrase étant fausse. Les deux cas
   s'excluent désormais, et un bouton Réessayer est offert.

   Vérifié en exécution : le diagnostic d'IDEES.md était faux sur un
   point. Robert A. Harper a bien 7 œuvres à la BnF (85 notices
   annoncées) ; c'était le même délai dépassé observé deux fois, pris
   pour deux causes distinctes.

380 tests, dont un qui applique réellement la migration (EnsureCreated
n'en joue aucune) et un qui verrouille les messages atteignant
l'utilisateur.

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

MaBibli.Api/Services/Isbn/BnfClient.cs

@@ -21,6 +21,28 @@ public interface IBnfClient
     /// </remarks>
     Task<(ResultatBibliographie Resultat, string? Avertissement)> RechercherParAuteurAsync(
         string auteur, CancellationToken ct = default);
+
+    /// <summary>
+    /// Interroge le SRU <b>par ISSN</b> pour nommer un périodique.
+    /// </summary>
+    /// <remarks>
+    /// Sert uniquement à dire à l'utilisateur ce qu'il a scanné quand le code-barres porte le
+    /// préfixe <c>977</c> : rien n'est catalogué à partir de là. Une BnF injoignable renvoie
+    /// <c>null</c> et un avertissement — l'écran dira alors « un magazine, titre inconnu »
+    /// plutôt que de laisser croire à un échec de recherche de livre.
+    /// </remarks>
+    Task<(PeriodiqueDetecte? Periodique, string? Avertissement)> RechercherPeriodiqueAsync(
+        string issn, CancellationToken ct = default);
+
+    /// <summary>
+    /// Interroge le SRU <b>par titre</b>, éventuellement restreint à un auteur.
+    /// </summary>
+    /// <remarks>
+    /// Sert l'ajout à la liste d'envies quand on n'a pas le livre en main : on souhaite une
+    /// œuvre dont on connaît le titre, rarement l'ISBN.
+    /// </remarks>
+    Task<(IReadOnlyList<CandidatLivre> Candidats, string? Avertissement)> RechercherParTitreAsync(
+        string titre, string? auteur, CancellationToken ct = default);
 }
 
 /// <summary>
@@ -70,6 +92,106 @@ public sealed class BnfClient(HttpClient http, ILogger<BnfClient> logger) : IBnf
         }
     }
 
+    public async Task<(PeriodiqueDetecte? Periodique, string? Avertissement)> RechercherPeriodiqueAsync(
+        string issn, CancellationToken ct = default)
+    {
+        if (string.IsNullOrWhiteSpace(issn))
+        {
+            return (null, null);
+        }
+
+        // bib.issn, vérifié le 2026-08-18 : l'ISSN doit porter son tiret (« 2466-6718 »),
+        // forme canonique sous laquelle la BnF l'indexe.
+        var url = "api/SRU"
+                  + "?version=1.2"
+                  + "&operation=searchRetrieve"
+                  + $"&query={Uri.EscapeDataString($"bib.issn all \"{issn}\"")}"
+                  + "&recordSchema=dublincore"
+                  + "&maximumRecords=1";
+
+        try
+        {
+            using var reponse = await http.GetAsync(url, ct);
+            if (!reponse.IsSuccessStatusCode)
+            {
+                logger.LogWarning("BnF a répondu {Code} pour l'ISSN {Issn}", (int)reponse.StatusCode, issn);
+                return (null, $"La BnF a répondu {(int)reponse.StatusCode} pour l'ISSN {issn}.");
+            }
+
+            var xml = await reponse.Content.ReadAsStringAsync(ct);
+            return (BnfSruParser.ParserPeriodique(xml, issn), null);
+        }
+        catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException)
+        {
+            logger.LogWarning(ex, "BnF injoignable pour l'ISSN {Issn}", issn);
+            return (null, $"BnF injoignable ({ex.GetType().Name}) pour l'ISSN {issn}.");
+        }
+        catch (System.Xml.XmlException ex)
+        {
+            logger.LogWarning(ex, "Réponse BnF illisible pour l'ISSN {Issn}", issn);
+            return (null, $"Réponse BnF illisible pour l'ISSN {issn}.");
+        }
+    }
+
+    /// <summary>Notices rendues par une recherche par titre : de quoi choisir sans faire défiler.</summary>
+    public const int NoticesRecherche = 20;
+
+    public async Task<(IReadOnlyList<CandidatLivre> Candidats, string? Avertissement)> RechercherParTitreAsync(
+        string titre, string? auteur, CancellationToken ct = default)
+    {
+        if (string.IsNullOrWhiteSpace(titre))
+        {
+            return ([], null);
+        }
+
+        // Les deux index se combinent en CQL par « and ». L'auteur est facultatif : sans lui la
+        // recherche porte sur le seul titre, ce qui suffit pour un titre un peu distinctif.
+        var cql = $"bib.title all \"{Echapper(titre)}\"";
+        if (!string.IsNullOrWhiteSpace(auteur))
+        {
+            cql += $" and bib.author all \"{Echapper(auteur)}\"";
+        }
+
+        var url = "api/SRU"
+                  + "?version=1.2"
+                  + "&operation=searchRetrieve"
+                  + $"&query={Uri.EscapeDataString(cql)}"
+                  + "&recordSchema=dublincore"
+                  + $"&maximumRecords={NoticesRecherche}";
+
+        try
+        {
+            using var reponse = await http.GetAsync(url, ct);
+            if (!reponse.IsSuccessStatusCode)
+            {
+                logger.LogWarning("BnF a répondu {Code} pour le titre {Titre}", (int)reponse.StatusCode, titre);
+                return ([], $"La BnF a répondu {(int)reponse.StatusCode} pour « {titre} ».");
+            }
+
+            var xml = await reponse.Content.ReadAsStringAsync(ct);
+            return (BnfBibliographieParser.ParserRecherche(xml), null);
+        }
+        catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException)
+        {
+            logger.LogWarning(ex, "BnF injoignable pour le titre {Titre}", titre);
+            return ([], $"BnF injoignable ({ex.GetType().Name}) pour « {titre} ».");
+        }
+        catch (System.Xml.XmlException ex)
+        {
+            logger.LogWarning(ex, "Réponse BnF illisible pour le titre {Titre}", titre);
+            return ([], $"Réponse BnF illisible pour « {titre} ».");
+        }
+    }
+
+    /// <summary>
+    /// Neutralise les guillemets d'un terme de recherche, qui délimitent la valeur en CQL.
+    /// </summary>
+    /// <remarks>
+    /// Un titre contenant un guillemet fermerait la chaîne et rendrait la requête invalide —
+    /// « L'homme qui plantait des arbres » n'en a pas, mais rien ne l'interdit à un utilisateur.
+    /// </remarks>
+    private static string Echapper(string terme) => terme.Trim().Replace("\"", " ");
+
     /// <summary>
     /// Notices lues par page, et nombre de pages : au plus <b>200 notices</b>.
     /// </summary>
@@ -109,23 +231,62 @@ public sealed class BnfClient(HttpClient http, ILogger<BnfClient> logger) : IBnf
             var lues = pages.Where(p => p is not null).Select(p => p!).ToList();
             if (lues.Count == 0)
             {
-                return (new ResultatBibliographie(), $"La BnF n'a pas répondu pour « {auteur} ».");
+                return Echec(EtatSourceBibliographie.Injoignable, auteur);
             }
 
             return (Fusionner(lues), null);
         }
+        // ⚠️ Le délai dépassé se distingue de l'injoignable, et ce n'est pas du détail : c'est
+        // le cas remonté en usage, et le seul qui vaille la peine d'être retenté tout de suite.
+        // HttpClient l'annonce par une TaskCanceledException dont l'exception interne est un
+        // TimeoutException — sans ce test, il se confondrait avec une annulation de l'appelant.
+        catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
+        {
+            logger.LogWarning(ex, "Délai dépassé par la BnF pour l'auteur {Auteur}", auteur);
+            return Echec(EtatSourceBibliographie.DelaiDepasse, auteur);
+        }
         catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException)
         {
             logger.LogWarning(ex, "BnF injoignable pour l'auteur {Auteur}", auteur);
-            return (new ResultatBibliographie(), $"BnF injoignable ({ex.GetType().Name}) pour « {auteur} ».");
+            return Echec(EtatSourceBibliographie.Injoignable, auteur);
         }
         catch (System.Xml.XmlException ex)
         {
             logger.LogWarning(ex, "Réponse BnF illisible pour l'auteur {Auteur}", auteur);
-            return (new ResultatBibliographie(), $"Réponse BnF illisible pour « {auteur} ».");
+            return Echec(EtatSourceBibliographie.ReponseIllisible, auteur);
         }
     }
 
+    /// <summary>
+    /// Motif <b>lisible</b> d'une bibliographie que la BnF n'a pas pu fournir.
+    /// </summary>
+    /// <remarks>
+    /// ⚠️ Public parce que ce texte <b>atteint l'utilisateur</b> : c'est un contrat d'interface,
+    /// pas un détail d'implémentation, et il est verrouillé par des tests. Il ne contient aucun
+    /// nom de classe .NET — « BnF injoignable (TaskCanceledException) » est ce qui s'affichait
+    /// avant, et « TaskCanceledException » ne veut rien dire pour qui range ses livres.
+    /// <para>
+    /// Les trois motifs se distinguent parce qu'ils n'appellent pas la même chose : un délai
+    /// dépassé se retente tout de suite, une réponse illisible non.
+    /// </para>
+    /// </remarks>
+    public static string MotifDeSourceMuette(EtatSourceBibliographie etat, string auteur) =>
+        etat switch
+        {
+            EtatSourceBibliographie.DelaiDepasse =>
+                $"La BnF n'a pas répondu à temps pour « {auteur} ». Son catalogue est parfois lent ;"
+                + " réessayer suffit le plus souvent.",
+            EtatSourceBibliographie.ReponseIllisible =>
+                $"La BnF a répondu quelque chose d'inexploitable pour « {auteur} ».",
+            _ =>
+                $"La BnF n'a pas pu être jointe pour « {auteur} ». Vérifiez votre connexion,"
+                + " ou réessayez plus tard.",
+        };
+
+    /// <summary>Résultat d'une interrogation qui n'a pas abouti : aucune notice, et son motif.</summary>
+    private static (ResultatBibliographie, string?) Echec(EtatSourceBibliographie etat, string auteur) =>
+        (new ResultatBibliographie { Etat = etat }, MotifDeSourceMuette(etat, auteur));
+
     private async Task<ResultatBibliographie?> LirePageAsync(
         string auteur, int premiereNotice, CancellationToken ct)
     {