From fd6438b912933970c927c8393be30d74682eec13 Mon Sep 17 00:00:00 2001
From: mathieu <mathieu@limonier.be>
Date: Mon, 17 Aug 2026 22:55:07 +0200
Subject: [PATCH] Phase 3 : CRUD des livres, statuts de lecture et identite
 SSOwat

API
- CRUD complet sur /api/livres : liste filtrable (format, statut) et
  cherchable (titre, auteur), consultation, creation, modification,
  changement de statut isole, suppression.
- Aucune lecture ne filtre sur AjoutePar : la bibliotheque est commune au
  foyer. Le critere n'existe meme pas dans CritereLivres, pour qu'on ne
  puisse pas s'en servir par inadvertance. Deux tests verrouillent
  l'invariant, dont un par reflexion sur le type des criteres.
- AjoutePar est renseigne par le serveur a la creation, jamais par le
  client, et n'est pas reecrit a l'edition (pas plus que DateAjout).
- Identite lue dans les en-tetes SSOwat (YNH_USER, YNH_USER_EMAIL,
  YNH_USER_FULLNAME), avec repli sur un utilisateur simule configure en
  developpement uniquement. Sans en-tete ni simulation, l'identite reste
  inconnue plutot qu'inventee. Expose par GET /api/moi.
- Migration appliquee au demarrage : pas d'etape manuelle a l'installation.

Interface Blazor, pensee mobile d'abord
- Catalogue unique (physiques et numeriques melanges, distingues par le
  format) avec recherche, filtres et changement de statut directement dans
  la liste.
- Ajout par ISBN : quand la cascade rend plusieurs notices, un ecran de
  choix les presente en mettant en avant editeur et annee, seuls elements
  qui les departagent. Le formulaire reste ensuite entierement modifiable.
- Ajout manuel, edition, suppression avec confirmation explicite.
- Couvertures : l'URL OpenLibrary n'est jamais validee par un appel
  prealable (502 intermittents mesures en phase 2) ; un attribut onerror
  masque l'image cassee et laisse apparaitre un substitut.

Decisions prises la ou CLAUDE.md etait muet
- Tri alphabetique par titre.
- Un ISBN saisi doit etre valide, mais reste facultatif.
- Ecran de choix affiche seulement a partir de deux candidats.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 MaBibli.Api/Endpoints/LivresEndpoints.cs      | 135 +++++++
 MaBibli.Api/Program.cs                        |  18 +
 .../Services/Catalogue/ServiceCatalogue.cs    | 195 ++++++++++
 .../Identite/FournisseurUtilisateur.cs        |  97 +++++
 MaBibli.Api/appsettings.Development.json      |   9 +
 MaBibli.Client/Composants/Couverture.razor    |  35 ++
 .../Composants/FormulaireLivre.razor          | 112 ++++++
 MaBibli.Client/Composants/Libelles.cs         |  31 ++
 MaBibli.Client/Layout/MainLayout.razor        |  36 +-
 MaBibli.Client/Layout/MainLayout.razor.css    | 100 ++----
 MaBibli.Client/Layout/NavMenu.razor           |  29 --
 MaBibli.Client/Layout/NavMenu.razor.css       |  83 -----
 MaBibli.Client/Pages/AjoutIsbn.razor          | 214 +++++++++++
 MaBibli.Client/Pages/AjoutManuel.razor        |  44 +++
 MaBibli.Client/Pages/Catalogue.razor          | 201 +++++++++++
 MaBibli.Client/Pages/EditionLivre.razor       | 143 ++++++++
 MaBibli.Client/Pages/Home.razor               |   7 -
 MaBibli.Client/Program.cs                     |   1 +
 MaBibli.Client/Services/ServiceLivresApi.cs   | 145 ++++++++
 MaBibli.Client/_Imports.razor                 |   5 +
 MaBibli.Client/wwwroot/css/app.css            | 338 +++++++++++++++++-
 MaBibli.Shared/Catalogue/CritereLivres.cs     |  23 ++
 MaBibli.Shared/Catalogue/FiltreLivres.cs      |  55 +++
 MaBibli.Shared/Dtos/EnregistrementLivre.cs    |  34 ++
 MaBibli.Shared/Dtos/LivreDto.cs               |  34 ++
 MaBibli.Shared/Dtos/UtilisateurCourant.cs     |  30 ++
 MaBibli.Tests/FiltreLivresTests.cs            | 150 ++++++++
 MaBibli.Tests/FournisseurUtilisateurTests.cs  | 110 ++++++
 MaBibli.Tests/ServiceCatalogueTests.cs        | 219 ++++++++++++
 29 files changed, 2430 insertions(+), 203 deletions(-)
 create mode 100644 MaBibli.Api/Endpoints/LivresEndpoints.cs
 create mode 100644 MaBibli.Api/Services/Catalogue/ServiceCatalogue.cs
 create mode 100644 MaBibli.Api/Services/Identite/FournisseurUtilisateur.cs
 create mode 100644 MaBibli.Client/Composants/Couverture.razor
 create mode 100644 MaBibli.Client/Composants/FormulaireLivre.razor
 create mode 100644 MaBibli.Client/Composants/Libelles.cs
 delete mode 100644 MaBibli.Client/Layout/NavMenu.razor
 delete mode 100644 MaBibli.Client/Layout/NavMenu.razor.css
 create mode 100644 MaBibli.Client/Pages/AjoutIsbn.razor
 create mode 100644 MaBibli.Client/Pages/AjoutManuel.razor
 create mode 100644 MaBibli.Client/Pages/Catalogue.razor
 create mode 100644 MaBibli.Client/Pages/EditionLivre.razor
 delete mode 100644 MaBibli.Client/Pages/Home.razor
 create mode 100644 MaBibli.Client/Services/ServiceLivresApi.cs
 create mode 100644 MaBibli.Shared/Catalogue/CritereLivres.cs
 create mode 100644 MaBibli.Shared/Catalogue/FiltreLivres.cs
 create mode 100644 MaBibli.Shared/Dtos/EnregistrementLivre.cs
 create mode 100644 MaBibli.Shared/Dtos/LivreDto.cs
 create mode 100644 MaBibli.Shared/Dtos/UtilisateurCourant.cs
 create mode 100644 MaBibli.Tests/FiltreLivresTests.cs
 create mode 100644 MaBibli.Tests/FournisseurUtilisateurTests.cs
 create mode 100644 MaBibli.Tests/ServiceCatalogueTests.cs

diff --git a/MaBibli.Api/Endpoints/LivresEndpoints.cs b/MaBibli.Api/Endpoints/LivresEndpoints.cs
new file mode 100644
index 0000000..2a63bcb
--- /dev/null
+++ b/MaBibli.Api/Endpoints/LivresEndpoints.cs
@@ -0,0 +1,135 @@
+using MaBibli.Api.Services.Catalogue;
+using MaBibli.Api.Services.Identite;
+using MaBibli.Shared.Catalogue;
+using MaBibli.Shared.Dtos;
+using MaBibli.Shared.Entites;
+
+namespace MaBibli.Api.Endpoints;
+
+public static class LivresEndpoints
+{
+    /// <summary>
+    /// CRUD du catalogue.
+    /// </summary>
+    /// <remarks>
+    /// <b>Aucune lecture ne filtre sur <c>AjoutePar</c></b> : la bibliothèque est commune.
+    /// Ce champ n'est même pas acceptable en paramètre de requête, précisément pour qu'on ne
+    /// puisse pas s'en servir comme d'un cloisonnement par inadvertance.
+    /// </remarks>
+    public static IEndpointRouteBuilder MapLivresEndpoints(this IEndpointRouteBuilder routes)
+    {
+        var groupe = routes.MapGroup("/api/livres").WithTags("Livres");
+
+        groupe.MapGet("/", async (
+                string? recherche,
+                Format? format,
+                Statut? statut,
+                IServiceCatalogue service,
+                CancellationToken ct) =>
+            {
+                var criteres = new CritereLivres
+                {
+                    Recherche = recherche,
+                    Format = format,
+                    Statut = statut,
+                };
+
+                return Results.Ok(await service.ListerAsync(criteres, ct));
+            })
+            .WithName("ListerLivres")
+            .WithSummary("Liste le catalogue, filtrable par format et statut, cherchable sur titre et auteur.")
+            .WithDescription(
+                "Catalogue unique : physiques et numériques cohabitent, distingués par leur format. "
+                + "La bibliothèque est commune — la liste n'est jamais restreinte à l'utilisateur courant.")
+            .Produces<IReadOnlyList<LivreDto>>();
+
+        groupe.MapGet("/{id:int}", async (int id, IServiceCatalogue service, CancellationToken ct) =>
+            {
+                var livre = await service.ObtenirAsync(id, ct);
+                return livre is null ? Results.NotFound() : Results.Ok(livre);
+            })
+            .WithName("ObtenirLivre")
+            .Produces<LivreDto>()
+            .Produces(StatusCodes.Status404NotFound);
+
+        groupe.MapPost("/", async (
+                EnregistrementLivre saisie,
+                IServiceCatalogue service,
+                IFournisseurUtilisateur utilisateurs,
+                CancellationToken ct) =>
+            {
+                // AjoutePar vient du serveur, pas de la charge utile.
+                var utilisateur = utilisateurs.Obtenir();
+                var resultat = await service.CreerAsync(saisie, utilisateur.Identifiant, ct);
+
+                return resultat.Erreur is not null
+                    ? Results.BadRequest(new { erreur = resultat.Erreur })
+                    : Results.Created($"/api/livres/{resultat.Livre!.Id}", resultat.Livre);
+            })
+            .WithName("CreerLivre")
+            .WithSummary("Ajoute un livre. « AjoutePar » est déterminé par le serveur.")
+            .Produces<LivreDto>(StatusCodes.Status201Created)
+            .Produces(StatusCodes.Status400BadRequest);
+
+        groupe.MapPut("/{id:int}", async (
+                int id,
+                EnregistrementLivre saisie,
+                IServiceCatalogue service,
+                CancellationToken ct) =>
+            {
+                var resultat = await service.ModifierAsync(id, saisie, ct);
+
+                if (resultat.EstIntrouvable)
+                {
+                    return Results.NotFound();
+                }
+
+                return resultat.Erreur is not null
+                    ? Results.BadRequest(new { erreur = resultat.Erreur })
+                    : Results.Ok(resultat.Livre);
+            })
+            .WithName("ModifierLivre")
+            .WithSummary("Modifie un livre. « AjoutePar » et « DateAjout » restent inchangés.")
+            .Produces<LivreDto>()
+            .Produces(StatusCodes.Status400BadRequest)
+            .Produces(StatusCodes.Status404NotFound);
+
+        groupe.MapPatch("/{id:int}/statut", async (
+                int id,
+                ChangementStatut changement,
+                IServiceCatalogue service,
+                CancellationToken ct) =>
+            {
+                var livre = await service.ChangerStatutAsync(id, changement.Statut, ct);
+                return livre is null ? Results.NotFound() : Results.Ok(livre);
+            })
+            .WithName("ChangerStatutLivre")
+            .WithSummary("Change le seul statut de lecture — l'action la plus fréquente.")
+            .Produces<LivreDto>()
+            .Produces(StatusCodes.Status404NotFound);
+
+        groupe.MapDelete("/{id:int}", async (int id, IServiceCatalogue service, CancellationToken ct) =>
+            {
+                var supprime = await service.SupprimerAsync(id, ct);
+                return supprime ? Results.NoContent() : Results.NotFound();
+            })
+            .WithName("SupprimerLivre")
+            .Produces(StatusCodes.Status204NoContent)
+            .Produces(StatusCodes.Status404NotFound);
+
+        return routes;
+    }
+
+    /// <summary>Expose l'identité de la personne connectée, pour affichage côté client.</summary>
+    public static IEndpointRouteBuilder MapIdentiteEndpoints(this IEndpointRouteBuilder routes)
+    {
+        routes.MapGet("/api/moi", (IFournisseurUtilisateur utilisateurs) =>
+                Results.Ok(utilisateurs.Obtenir()))
+            .WithName("UtilisateurCourant")
+            .WithTags("Identité")
+            .WithSummary("Identité lue dans les en-têtes SSOwat, ou utilisateur simulé en développement.")
+            .Produces<UtilisateurCourant>();
+
+        return routes;
+    }
+}
diff --git a/MaBibli.Api/Program.cs b/MaBibli.Api/Program.cs
index d143c55..4280c74 100644
--- a/MaBibli.Api/Program.cs
+++ b/MaBibli.Api/Program.cs
@@ -1,5 +1,7 @@
 using MaBibli.Api.Data;
 using MaBibli.Api.Endpoints;
+using MaBibli.Api.Services.Catalogue;
+using MaBibli.Api.Services.Identite;
 using MaBibli.Api.Services.Isbn;
 using Microsoft.EntityFrameworkCore;
 
@@ -10,6 +12,14 @@ builder.Services.AddOpenApi();
 builder.Services.AddDbContext<MaBibliDbContext>(options =>
     options.UseSqlite(builder.Configuration.GetConnectionString("MaBibli")));
 
+builder.Services.AddScoped<IServiceCatalogue, ServiceCatalogue>();
+
+// Identité : lue dans les en-têtes injectés par SSOwat, avec repli sur un utilisateur simulé
+// configuré en développement (il n'y a pas de portail YunoHost en local).
+builder.Services.AddHttpContextAccessor();
+builder.Services.Configure<OptionsIdentite>(builder.Configuration.GetSection(OptionsIdentite.Section));
+builder.Services.AddScoped<IFournisseurUtilisateur, FournisseurUtilisateurSsowat>();
+
 // Lookup ISBN : clients typés via IHttpClientFactory (pas de HttpClient instancié à la main).
 // Timeout court : une source lente ne doit pas bloquer la cascade, l'appelant bascule sur la suivante.
 var timeoutSources = TimeSpan.FromSeconds(10);
@@ -32,6 +42,12 @@ builder.Services.AddScoped<IIsbnLookupService, IsbnLookupService>();
 
 var app = builder.Build();
 
+// Une seule base SQLite, migrée au démarrage : pas d'étape manuelle à l'installation YunoHost.
+using (var portee = app.Services.CreateScope())
+{
+    portee.ServiceProvider.GetRequiredService<MaBibliDbContext>().Database.Migrate();
+}
+
 if (app.Environment.IsDevelopment())
 {
     app.MapOpenApi();
@@ -43,6 +59,8 @@ app.UseBlazorFrameworkFiles();
 app.UseStaticFiles();
 
 app.MapIsbnEndpoints();
+app.MapLivresEndpoints();
+app.MapIdentiteEndpoints();
 
 app.MapFallbackToFile("index.html");
 
diff --git a/MaBibli.Api/Services/Catalogue/ServiceCatalogue.cs b/MaBibli.Api/Services/Catalogue/ServiceCatalogue.cs
new file mode 100644
index 0000000..23ab8dc
--- /dev/null
+++ b/MaBibli.Api/Services/Catalogue/ServiceCatalogue.cs
@@ -0,0 +1,195 @@
+using MaBibli.Api.Data;
+using MaBibli.Shared.Catalogue;
+using MaBibli.Shared.Dtos;
+using MaBibli.Shared.Entites;
+using MaBibli.Shared.Isbn;
+using Microsoft.EntityFrameworkCore;
+
+namespace MaBibli.Api.Services.Catalogue;
+
+/// <summary>Issue d'une écriture : soit le livre, soit un message d'erreur destiné à l'utilisateur.</summary>
+public readonly record struct ResultatEcriture(LivreDto? Livre, string? Erreur)
+{
+    public static ResultatEcriture Ok(LivreDto livre) => new(livre, null);
+
+    public static ResultatEcriture Invalide(string message) => new(null, message);
+
+    /// <summary>Ni livre ni erreur : la ressource demandée n'existe pas.</summary>
+    public static readonly ResultatEcriture Introuvable = new(null, null);
+
+    public bool EstIntrouvable => Livre is null && Erreur is null;
+}
+
+public interface IServiceCatalogue
+{
+    Task<IReadOnlyList<LivreDto>> ListerAsync(CritereLivres criteres, CancellationToken ct = default);
+
+    Task<LivreDto?> ObtenirAsync(int id, CancellationToken ct = default);
+
+    Task<ResultatEcriture> CreerAsync(EnregistrementLivre saisie, string? ajoutePar, CancellationToken ct = default);
+
+    Task<ResultatEcriture> ModifierAsync(int id, EnregistrementLivre saisie, CancellationToken ct = default);
+
+    Task<LivreDto?> ChangerStatutAsync(int id, Statut statut, CancellationToken ct = default);
+
+    Task<bool> SupprimerAsync(int id, CancellationToken ct = default);
+}
+
+/// <summary>
+/// CRUD du catalogue de livres — physiques et numériques confondus, distingués par
+/// <see cref="Format"/>. Il n'y a qu'un seul catalogue.
+/// </summary>
+public sealed class ServiceCatalogue(MaBibliDbContext db) : IServiceCatalogue
+{
+    public async Task<IReadOnlyList<LivreDto>> ListerAsync(
+        CritereLivres criteres, CancellationToken ct = default)
+    {
+        // AsNoTracking : lecture pure. Et surtout : AUCUN filtre sur AjoutePar,
+        // la bibliothèque est commune à tout le foyer (CLAUDE.md).
+        var requete = FiltreLivres.Appliquer(db.Livres.AsNoTracking(), criteres);
+
+        var livres = await requete.ToListAsync(ct);
+        return livres.Select(Projeter).ToList();
+    }
+
+    public async Task<LivreDto?> ObtenirAsync(int id, CancellationToken ct = default)
+    {
+        var livre = await db.Livres.AsNoTracking().FirstOrDefaultAsync(l => l.Id == id, ct);
+        return livre is null ? null : Projeter(livre);
+    }
+
+    public async Task<ResultatEcriture> CreerAsync(
+        EnregistrementLivre saisie, string? ajoutePar, CancellationToken ct = default)
+    {
+        if (Valider(saisie, out var isbn, out var erreur) is false)
+        {
+            return ResultatEcriture.Invalide(erreur!);
+        }
+
+        var livre = new Livre
+        {
+            Isbn = isbn,
+            Titre = saisie.Titre.Trim(),
+            Auteur = Vide(saisie.Auteur),
+            Editeur = Vide(saisie.Editeur),
+            Format = saisie.Format,
+            Statut = saisie.Statut,
+            CoverUrl = Vide(saisie.CoverUrl),
+            DateAjout = DateTime.UtcNow,
+
+            // Renseigné par le serveur à partir de l'utilisateur authentifié, jamais par le client.
+            AjoutePar = ajoutePar,
+        };
+
+        db.Livres.Add(livre);
+        await db.SaveChangesAsync(ct);
+
+        return ResultatEcriture.Ok(Projeter(livre));
+    }
+
+    public async Task<ResultatEcriture> ModifierAsync(
+        int id, EnregistrementLivre saisie, CancellationToken ct = default)
+    {
+        var livre = await db.Livres.FirstOrDefaultAsync(l => l.Id == id, ct);
+        if (livre is null)
+        {
+            return ResultatEcriture.Introuvable;
+        }
+
+        if (Valider(saisie, out var isbn, out var erreur) is false)
+        {
+            return ResultatEcriture.Invalide(erreur!);
+        }
+
+        livre.Isbn = isbn;
+        livre.Titre = saisie.Titre.Trim();
+        livre.Auteur = Vide(saisie.Auteur);
+        livre.Editeur = Vide(saisie.Editeur);
+        livre.Format = saisie.Format;
+        livre.Statut = saisie.Statut;
+        livre.CoverUrl = Vide(saisie.CoverUrl);
+
+        // DateAjout et AjoutePar ne sont jamais réécrits : ce sont des traces de la saisie
+        // d'origine, pas des champs éditables.
+
+        await db.SaveChangesAsync(ct);
+        return ResultatEcriture.Ok(Projeter(livre));
+    }
+
+    public async Task<LivreDto?> ChangerStatutAsync(int id, Statut statut, CancellationToken ct = default)
+    {
+        var livre = await db.Livres.FirstOrDefaultAsync(l => l.Id == id, ct);
+        if (livre is null)
+        {
+            return null;
+        }
+
+        livre.Statut = statut;
+        await db.SaveChangesAsync(ct);
+        return Projeter(livre);
+    }
+
+    public async Task<bool> SupprimerAsync(int id, CancellationToken ct = default)
+    {
+        var livre = await db.Livres.FirstOrDefaultAsync(l => l.Id == id, ct);
+        if (livre is null)
+        {
+            return false;
+        }
+
+        db.Livres.Remove(livre);
+        await db.SaveChangesAsync(ct);
+        return true;
+    }
+
+    /// <summary>
+    /// Contrôles minimaux : un titre, et un ISBN qui tienne debout s'il est fourni.
+    /// </summary>
+    /// <remarks>
+    /// L'ISBN est facultatif (livres anciens, tirages sans ISBN) mais, s'il est saisi, il doit
+    /// être valide : un ISBN faux est pire que pas d'ISBN, il empêcherait tout rapprochement
+    /// futur avec les catalogues.
+    /// </remarks>
+    private static bool Valider(EnregistrementLivre saisie, out string? isbn, out string? erreur)
+    {
+        isbn = null;
+        erreur = null;
+
+        if (string.IsNullOrWhiteSpace(saisie.Titre))
+        {
+            erreur = "Le titre est obligatoire.";
+            return false;
+        }
+
+        if (!string.IsNullOrWhiteSpace(saisie.Isbn))
+        {
+            var normalise = IsbnUtils.Normaliser(saisie.Isbn);
+            if (!IsbnUtils.EstValide(normalise))
+            {
+                erreur = $"« {saisie.Isbn} » n'est pas un ISBN valide. Laissez le champ vide si le livre n'en a pas.";
+                return false;
+            }
+
+            isbn = normalise;
+        }
+
+        return true;
+    }
+
+    private static string? Vide(string? valeur) =>
+        string.IsNullOrWhiteSpace(valeur) ? null : valeur.Trim();
+
+    private static LivreDto Projeter(Livre livre) => new()
+    {
+        Id = livre.Id,
+        Isbn = livre.Isbn,
+        Titre = livre.Titre,
+        Auteur = livre.Auteur,
+        Editeur = livre.Editeur,
+        Format = livre.Format,
+        Statut = livre.Statut,
+        CoverUrl = livre.CoverUrl,
+        DateAjout = livre.DateAjout,
+        AjoutePar = livre.AjoutePar,
+    };
+}
diff --git a/MaBibli.Api/Services/Identite/FournisseurUtilisateur.cs b/MaBibli.Api/Services/Identite/FournisseurUtilisateur.cs
new file mode 100644
index 0000000..f82c34c
--- /dev/null
+++ b/MaBibli.Api/Services/Identite/FournisseurUtilisateur.cs
@@ -0,0 +1,97 @@
+using MaBibli.Shared.Dtos;
+
+namespace MaBibli.Api.Services.Identite;
+
+public interface IFournisseurUtilisateur
+{
+    /// <summary>Identité de la requête en cours, jamais <c>null</c> (au pire <see cref="UtilisateurCourant.Anonyme"/>).</summary>
+    UtilisateurCourant Obtenir();
+}
+
+/// <summary>
+/// Options de l'identité, section <c>Identite</c> de la configuration.
+/// </summary>
+public sealed class OptionsIdentite
+{
+    public const string Section = "Identite";
+
+    /// <summary>
+    /// Utilisateur simulé en développement, où SSOwat n'existe pas.
+    /// </summary>
+    /// <remarks>
+    /// CLAUDE.md : « prévoir un utilisateur simulé plutôt que de désactiver l'auth ».
+    /// Il n'est utilisé que si les en-têtes SSOwat sont absents, et n'est renseigné que dans
+    /// <c>appsettings.Development.json</c> — en production, aucune valeur, donc aucun repli.
+    /// </remarks>
+    public string? UtilisateurSimule { get; set; }
+
+    public string? EmailSimule { get; set; }
+
+    public string? NomCompletSimule { get; set; }
+}
+
+/// <summary>
+/// Lit l'identité dans les en-têtes HTTP injectés par SSOwat.
+/// </summary>
+/// <remarks>
+/// nginx authentifie le visiteur via le portail YunoHost puis pousse <c>YNH_USER</c>,
+/// <c>YNH_USER_EMAIL</c> et <c>YNH_USER_FULLNAME</c>. L'application se contente de les lire.
+/// <para>
+/// ⚠️ Ces en-têtes ne sont dignes de confiance que parce que le service n'écoute que sur
+/// <c>127.0.0.1</c> derrière nginx : exposé directement, n'importe qui pourrait forger
+/// <c>YNH_USER</c>. Cette contrainte se règle dans <c>systemd.service</c> / <c>nginx.conf</c>,
+/// qui vivent dans le dépôt <c>mabibli_ynh</c> (phase 7) — pas ici.
+/// </para>
+/// </remarks>
+public sealed class FournisseurUtilisateurSsowat(
+    IHttpContextAccessor accesseur,
+    Microsoft.Extensions.Options.IOptions<OptionsIdentite> options) : IFournisseurUtilisateur
+{
+    public const string EnteteUtilisateur = "YNH_USER";
+    public const string EnteteEmail = "YNH_USER_EMAIL";
+    public const string EnteteNomComplet = "YNH_USER_FULLNAME";
+
+    public UtilisateurCourant Obtenir()
+    {
+        var entetes = accesseur.HttpContext?.Request.Headers;
+        var identifiant = Valeur(entetes, EnteteUtilisateur);
+
+        if (identifiant is not null)
+        {
+            return new UtilisateurCourant
+            {
+                Identifiant = identifiant,
+                Email = Valeur(entetes, EnteteEmail),
+                NomComplet = Valeur(entetes, EnteteNomComplet),
+                Simule = false,
+            };
+        }
+
+        var simule = options.Value;
+        if (!string.IsNullOrWhiteSpace(simule.UtilisateurSimule))
+        {
+            return new UtilisateurCourant
+            {
+                Identifiant = simule.UtilisateurSimule,
+                Email = simule.EmailSimule,
+                NomComplet = simule.NomCompletSimule,
+                Simule = true,
+            };
+        }
+
+        // Ni en-tête, ni utilisateur simulé : on n'invente pas d'identité.
+        // Le livre sera enregistré sans traçabilité plutôt que sous un faux nom.
+        return UtilisateurCourant.Anonyme;
+    }
+
+    private static string? Valeur(IHeaderDictionary? entetes, string nom)
+    {
+        if (entetes is null || !entetes.TryGetValue(nom, out var valeurs))
+        {
+            return null;
+        }
+
+        var valeur = valeurs.ToString().Trim();
+        return valeur.Length == 0 ? null : valeur;
+    }
+}
diff --git a/MaBibli.Api/appsettings.Development.json b/MaBibli.Api/appsettings.Development.json
index 0c208ae..8f42b21 100644
--- a/MaBibli.Api/appsettings.Development.json
+++ b/MaBibli.Api/appsettings.Development.json
@@ -4,5 +4,14 @@
       "Default": "Information",
       "Microsoft.AspNetCore": "Warning"
     }
+  },
+
+  // En développement il n'y a pas de SSOwat pour injecter YNH_USER : on simule un utilisateur
+  // plutôt que de désactiver l'authentification (CLAUDE.md). Aucune valeur équivalente en
+  // production : sans en-tête et sans simulation, l'identité reste inconnue.
+  "Identite": {
+    "UtilisateurSimule": "dev",
+    "EmailSimule": "dev@localhost",
+    "NomCompletSimule": "Utilisateur de développement"
   }
 }
diff --git a/MaBibli.Client/Composants/Couverture.razor b/MaBibli.Client/Composants/Couverture.razor
new file mode 100644
index 0000000..d214628
--- /dev/null
+++ b/MaBibli.Client/Composants/Couverture.razor
@@ -0,0 +1,35 @@
+@*
+    Couverture d'un livre, avec substitut.
+
+    Les URL de couverture OpenLibrary renvoient des 502 intermittents (mesuré en phase 2 :
+    200, 200, puis 502 sur le même ISBN). On ne valide donc JAMAIS l'URL par un appel préalable :
+    on l'affiche, et si l'image casse, l'attribut onerror la masque et laisse apparaître le
+    substitut qui se trouve déjà dessous. Aucun aller-retour serveur, aucun état C# à gérer.
+
+    @key sur l'img : si l'URL change, Blazor recrée l'élément au lieu de réutiliser celui que
+    le onerror a marqué comme cassé.
+*@
+<div class="couverture @Classe">
+    <span class="couverture-substitut" aria-hidden="true">@Initiale</span>
+
+    @if (!string.IsNullOrWhiteSpace(Url))
+    {
+        <img @key="Url"
+             class="couverture-image"
+             src="@Url"
+             alt="Couverture de @Titre"
+             loading="lazy"
+             onerror="this.classList.add('image-cassee')" />
+    }
+</div>
+
+@code {
+    [Parameter] public string? Url { get; set; }
+
+    [Parameter] public string? Titre { get; set; }
+
+    [Parameter] public string? Classe { get; set; }
+
+    private string Initiale =>
+        string.IsNullOrWhiteSpace(Titre) ? "?" : Titre.Trim()[..1].ToUpperInvariant();
+}
diff --git a/MaBibli.Client/Composants/FormulaireLivre.razor b/MaBibli.Client/Composants/FormulaireLivre.razor
new file mode 100644
index 0000000..ff71d64
--- /dev/null
+++ b/MaBibli.Client/Composants/FormulaireLivre.razor
@@ -0,0 +1,112 @@
+@*
+    Formulaire d'une fiche livre, partagé par l'ajout (ISBN ou manuel) et l'édition.
+
+    Le pré-remplissage par ISBN est une AIDE, pas une contrainte : tous les champs restent
+    modifiables, et une fiche incomplète peut toujours être complétée à la main (CLAUDE.md).
+*@
+<div class="formulaire">
+    @if (!string.IsNullOrEmpty(Saisie.CoverUrl) || !string.IsNullOrWhiteSpace(Saisie.Titre))
+    {
+        <div class="formulaire-apercu">
+            <Couverture Url="@Saisie.CoverUrl" Titre="@Saisie.Titre" Classe="couverture-moyenne" />
+        </div>
+    }
+
+    <label class="champ">
+        <span class="champ-libelle">Titre <span class="obligatoire" aria-hidden="true">*</span></span>
+        <input class="champ-saisie" type="text" @bind="Saisie.Titre" @bind:event="oninput"
+               placeholder="Titre du livre" autocomplete="off" />
+    </label>
+
+    <label class="champ">
+        <span class="champ-libelle">Auteur</span>
+        <input class="champ-saisie" type="text" @bind="Saisie.Auteur" @bind:event="oninput"
+               placeholder="Prénom Nom" autocomplete="off" />
+    </label>
+
+    <label class="champ">
+        <span class="champ-libelle">Éditeur</span>
+        <input class="champ-saisie" type="text" @bind="Saisie.Editeur" @bind:event="oninput"
+               autocomplete="off" />
+    </label>
+
+    <label class="champ">
+        <span class="champ-libelle">ISBN <span class="champ-aide">(facultatif)</span></span>
+        <input class="champ-saisie" type="text" inputmode="numeric" @bind="Saisie.Isbn" @bind:event="oninput"
+               placeholder="978…" autocomplete="off" />
+    </label>
+
+    <fieldset class="champ">
+        <legend class="champ-libelle">Format</legend>
+        <div class="segments">
+            @foreach (var format in Formats)
+            {
+                <button type="button"
+                        class="segment @(Saisie.Format == format ? "segment-actif" : null)"
+                        @onclick="() => Saisie.Format = format">
+                    @Libelles.Format(format)
+                </button>
+            }
+        </div>
+    </fieldset>
+
+    <fieldset class="champ">
+        <legend class="champ-libelle">Statut de lecture</legend>
+        <div class="segments">
+            @foreach (var statut in Statuts)
+            {
+                <button type="button"
+                        class="segment @(Saisie.Statut == statut ? "segment-actif" : null)"
+                        @onclick="() => Saisie.Statut = statut">
+                    @Libelles.Statut(statut)
+                </button>
+            }
+        </div>
+    </fieldset>
+
+    <label class="champ">
+        <span class="champ-libelle">URL de couverture</span>
+        <input class="champ-saisie" type="url" @bind="Saisie.CoverUrl" @bind:event="oninput"
+               placeholder="https://…" autocomplete="off" />
+    </label>
+
+    @if (!string.IsNullOrEmpty(Erreur))
+    {
+        <p class="message-erreur" role="alert">@Erreur</p>
+    }
+
+    <div class="actions-formulaire">
+        <button type="button" class="bouton bouton-principal"
+                disabled="@(EnCours || string.IsNullOrWhiteSpace(Saisie.Titre))"
+                @onclick="Valider">
+            @(EnCours ? "Enregistrement…" : LibelleValidation)
+        </button>
+
+        @if (OnAnnuler.HasDelegate)
+        {
+            <button type="button" class="bouton bouton-discret" disabled="@EnCours"
+                    @onclick="OnAnnuler">
+                Annuler
+            </button>
+        }
+    </div>
+</div>
+
+@code {
+    private static readonly Format[] Formats = Enum.GetValues<Format>();
+    private static readonly Statut[] Statuts = Enum.GetValues<Statut>();
+
+    [Parameter, EditorRequired] public EnregistrementLivre Saisie { get; set; } = new();
+
+    [Parameter] public string LibelleValidation { get; set; } = "Enregistrer";
+
+    [Parameter] public string? Erreur { get; set; }
+
+    [Parameter] public bool EnCours { get; set; }
+
+    [Parameter] public EventCallback OnValider { get; set; }
+
+    [Parameter] public EventCallback OnAnnuler { get; set; }
+
+    private Task Valider() => OnValider.InvokeAsync();
+}
diff --git a/MaBibli.Client/Composants/Libelles.cs b/MaBibli.Client/Composants/Libelles.cs
new file mode 100644
index 0000000..bc4a453
--- /dev/null
+++ b/MaBibli.Client/Composants/Libelles.cs
@@ -0,0 +1,31 @@
+using MaBibli.Shared.Entites;
+
+namespace MaBibli.Client.Composants;
+
+/// <summary>Libellés français des énumérations, au même endroit pour toute l'interface.</summary>
+public static class Libelles
+{
+    public static string Format(Format format) => format switch
+    {
+        MaBibli.Shared.Entites.Format.Physique => "Physique",
+        MaBibli.Shared.Entites.Format.Numerique => "Numérique",
+        _ => format.ToString(),
+    };
+
+    public static string Statut(Statut statut) => statut switch
+    {
+        MaBibli.Shared.Entites.Statut.ALire => "À lire",
+        MaBibli.Shared.Entites.Statut.EnCours => "En cours",
+        MaBibli.Shared.Entites.Statut.Lu => "Lu",
+        _ => statut.ToString(),
+    };
+
+    /// <summary>Classe CSS associée au statut, pour la pastille de couleur.</summary>
+    public static string ClasseStatut(Statut statut) => statut switch
+    {
+        MaBibli.Shared.Entites.Statut.ALire => "statut-a-lire",
+        MaBibli.Shared.Entites.Statut.EnCours => "statut-en-cours",
+        MaBibli.Shared.Entites.Statut.Lu => "statut-lu",
+        _ => string.Empty,
+    };
+}
diff --git a/MaBibli.Client/Layout/MainLayout.razor b/MaBibli.Client/Layout/MainLayout.razor
index 76eb725..d27de9c 100644
--- a/MaBibli.Client/Layout/MainLayout.razor
+++ b/MaBibli.Client/Layout/MainLayout.razor
@@ -1,16 +1,26 @@
 @inherits LayoutComponentBase
-<div class="page">
-    <div class="sidebar">
-        <NavMenu />
-    </div>
+@inject ServiceLivresApi Api
 
-    <main>
-        <div class="top-row px-4">
-            <a href="https://learn.microsoft.com/aspnet/core/" target="_blank">About</a>
-        </div>
+@* Mise en page pensée mobile d'abord : un bandeau, une colonne, rien à gauche.
+   Le PC hérite de la même colonne, simplement centrée et limitée en largeur. *@
+<header class="bandeau">
+    <a class="marque" href="">MaBibli</a>
 
-        <article class="content px-4">
-            @Body
-        </article>
-    </main>
-</div>
+    @if (_utilisateur?.Identifiant is not null)
+    {
+        <span class="utilisateur" title="@(_utilisateur.Simule ? "Utilisateur simulé (développement)" : "Connecté via le portail YunoHost")">
+            @_utilisateur.Affichage@(_utilisateur.Simule ? " (dev)" : "")
+        </span>
+    }
+</header>
+
+<main class="contenu">
+    @Body
+</main>
+
+@code {
+    private UtilisateurCourant? _utilisateur;
+
+    protected override async Task OnInitializedAsync()
+        => _utilisateur = await Api.ObtenirUtilisateurAsync();
+}
diff --git a/MaBibli.Client/Layout/MainLayout.razor.css b/MaBibli.Client/Layout/MainLayout.razor.css
index ecf25e5..252cba0 100644
--- a/MaBibli.Client/Layout/MainLayout.razor.css
+++ b/MaBibli.Client/Layout/MainLayout.razor.css
@@ -1,77 +1,37 @@
-.page {
-    position: relative;
-    display: flex;
-    flex-direction: column;
-}
-
-main {
-    flex: 1;
-}
-
-.sidebar {
-    background-image: linear-gradient(180deg, rgb(5, 39, 103) 0%, #3a0647 70%);
-}
-
-.top-row {
-    background-color: #f7f7f7;
-    border-bottom: 1px solid #d6d5d5;
-    justify-content: flex-end;
-    height: 3.5rem;
+.bandeau {
+    position: sticky;
+    top: 0;
+    z-index: 10;
     display: flex;
     align-items: center;
+    justify-content: space-between;
+    gap: 0.75rem;
+    padding: 0.75rem 1rem;
+    background: #1b3a5c;
+    color: #fff;
 }
 
-    .top-row ::deep a, .top-row ::deep .btn-link {
-        white-space: nowrap;
-        margin-left: 1.5rem;
-        text-decoration: none;
-    }
-
-    .top-row ::deep a:hover, .top-row ::deep .btn-link:hover {
-        text-decoration: underline;
-    }
-
-    .top-row ::deep a:first-child {
-        overflow: hidden;
-        text-overflow: ellipsis;
-    }
-
-@media (max-width: 640.98px) {
-    .top-row {
-        justify-content: space-between;
-    }
-
-    .top-row ::deep a, .top-row ::deep .btn-link {
-        margin-left: 0;
-    }
+.marque {
+    color: #fff;
+    font-size: 1.15rem;
+    font-weight: 600;
+    text-decoration: none;
 }
 
-@media (min-width: 641px) {
-    .page {
-        flex-direction: row;
-    }
-
-    .sidebar {
-        width: 250px;
-        height: 100vh;
-        position: sticky;
-        top: 0;
-    }
-
-    .top-row {
-        position: sticky;
-        top: 0;
-        z-index: 1;
-    }
-
-    .top-row.auth ::deep a:first-child {
-        flex: 1;
-        text-align: right;
-        width: 0;
-    }
-
-    .top-row, article {
-        padding-left: 2rem !important;
-        padding-right: 1.5rem !important;
-    }
+.utilisateur {
+    font-size: 0.8rem;
+    opacity: 0.85;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    max-width: 55%;
+}
+
+.contenu {
+    display: block;
+    width: 100%;
+    max-width: 46rem;
+    margin: 0 auto;
+    /* Marge basse généreuse : les actions flottantes ne doivent pas masquer le dernier livre. */
+    padding: 1rem 1rem 6rem;
 }
diff --git a/MaBibli.Client/Layout/NavMenu.razor b/MaBibli.Client/Layout/NavMenu.razor
deleted file mode 100644
index dd40b84..0000000
--- a/MaBibli.Client/Layout/NavMenu.razor
+++ /dev/null
@@ -1,29 +0,0 @@
-<div class="top-row ps-3 navbar navbar-dark">
-    <div class="container-fluid">
-        <a class="navbar-brand" href="">MaBibli</a>
-        <button title="Navigation menu" class="navbar-toggler" @onclick="ToggleNavMenu">
-            <span class="navbar-toggler-icon"></span>
-        </button>
-    </div>
-</div>
-
-<div class="@NavMenuCssClass nav-scrollable" @onclick="ToggleNavMenu">
-    <nav class="nav flex-column">
-        <div class="nav-item px-3">
-            <NavLink class="nav-link" href="" Match="NavLinkMatch.All">
-                <span class="bi bi-house-door-fill-nav-menu" aria-hidden="true"></span> Home
-            </NavLink>
-        </div>
-    </nav>
-</div>
-
-@code {
-    private bool collapseNavMenu = true;
-
-    private string? NavMenuCssClass => collapseNavMenu ? "collapse" : null;
-
-    private void ToggleNavMenu()
-    {
-        collapseNavMenu = !collapseNavMenu;
-    }
-}
diff --git a/MaBibli.Client/Layout/NavMenu.razor.css b/MaBibli.Client/Layout/NavMenu.razor.css
deleted file mode 100644
index 617b89c..0000000
--- a/MaBibli.Client/Layout/NavMenu.razor.css
+++ /dev/null
@@ -1,83 +0,0 @@
-.navbar-toggler {
-    background-color: rgba(255, 255, 255, 0.1);
-}
-
-.top-row {
-    min-height: 3.5rem;
-    background-color: rgba(0,0,0,0.4);
-}
-
-.navbar-brand {
-    font-size: 1.1rem;
-}
-
-.bi {
-    display: inline-block;
-    position: relative;
-    width: 1.25rem;
-    height: 1.25rem;
-    margin-right: 0.75rem;
-    top: -1px;
-    background-size: cover;
-}
-
-.bi-house-door-fill-nav-menu {
-    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' fill='white' class='bi bi-house-door-fill' viewBox='0 0 16 16'%3E%3Cpath d='M6.5 14.5v-3.505c0-.245.25-.495.5-.495h2c.25 0 .5.25.5.5v3.5a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5v-7a.5.5 0 0 0-.146-.354L13 5.793V2.5a.5.5 0 0 0-.5-.5h-1a.5.5 0 0 0-.5.5v1.293L8.354 1.146a.5.5 0 0 0-.708 0l-6 6A.5.5 0 0 0 1.5 7.5v7a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5Z'/%3E%3C/svg%3E");
-}
-
-.bi-plus-square-fill-nav-menu {
-    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' fill='white' class='bi bi-plus-square-fill' viewBox='0 0 16 16'%3E%3Cpath d='M2 0a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V2a2 2 0 0 0-2-2H2zm6.5 4.5v3h3a.5.5 0 0 1 0 1h-3v3a.5.5 0 0 1-1 0v-3h-3a.5.5 0 0 1 0-1h3v-3a.5.5 0 0 1 1 0z'/%3E%3C/svg%3E");
-}
-
-.bi-list-nested-nav-menu {
-    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' fill='white' class='bi bi-list-nested' viewBox='0 0 16 16'%3E%3Cpath fill-rule='evenodd' d='M4.5 11.5A.5.5 0 0 1 5 11h10a.5.5 0 0 1 0 1H5a.5.5 0 0 1-.5-.5zm-2-4A.5.5 0 0 1 3 7h10a.5.5 0 0 1 0 1H3a.5.5 0 0 1-.5-.5zm-2-4A.5.5 0 0 1 1 3h10a.5.5 0 0 1 0 1H1a.5.5 0 0 1-.5-.5z'/%3E%3C/svg%3E");
-}
-
-.nav-item {
-    font-size: 0.9rem;
-    padding-bottom: 0.5rem;
-}
-
-    .nav-item:first-of-type {
-        padding-top: 1rem;
-    }
-
-    .nav-item:last-of-type {
-        padding-bottom: 1rem;
-    }
-
-    .nav-item ::deep a {
-        color: #d7d7d7;
-        border-radius: 4px;
-        height: 3rem;
-        display: flex;
-        align-items: center;
-        line-height: 3rem;
-    }
-
-.nav-item ::deep a.active {
-    background-color: rgba(255,255,255,0.37);
-    color: white;
-}
-
-.nav-item ::deep a:hover {
-    background-color: rgba(255,255,255,0.1);
-    color: white;
-}
-
-@media (min-width: 641px) {
-    .navbar-toggler {
-        display: none;
-    }
-
-    .collapse {
-        /* Never collapse the sidebar for wide screens */
-        display: block;
-    }
-
-    .nav-scrollable {
-        /* Allow sidebar to scroll for tall menus */
-        height: calc(100vh - 3.5rem);
-        overflow-y: auto;
-    }
-}
diff --git a/MaBibli.Client/Pages/AjoutIsbn.razor b/MaBibli.Client/Pages/AjoutIsbn.razor
new file mode 100644
index 0000000..c37479c
--- /dev/null
+++ b/MaBibli.Client/Pages/AjoutIsbn.razor
@@ -0,0 +1,214 @@
+@page "/ajout/isbn"
+@inject ServiceLivresApi Api
+@inject NavigationManager Navigation
+
+<PageTitle>MaBibli — ajouter par ISBN</PageTitle>
+
+<h1 class="titre-page">Ajouter par ISBN</h1>
+
+@if (_etape == Etape.Saisie)
+{
+    <p class="message-discret">
+        Saisissez l'ISBN imprimé sur le livre. Le scan par la caméra arrivera plus tard.
+    </p>
+
+    <div class="barre-recherche">
+        <input class="champ-saisie" type="text" inputmode="numeric" placeholder="978…"
+               @bind="_isbn" @bind:event="oninput" @onkeydown="SurTouche"
+               aria-label="ISBN" autocomplete="off" />
+    </div>
+
+    <div class="actions-formulaire">
+        <button type="button" class="bouton bouton-principal"
+                disabled="@(_chargement || string.IsNullOrWhiteSpace(_isbn))"
+                @onclick="ChercherAsync">
+            @(_chargement ? "Recherche…" : "Chercher")
+        </button>
+        <a class="bouton bouton-discret" href="ajout/manuel">Saisir à la main</a>
+    </div>
+}
+
+@if (_erreur is not null)
+{
+    <p class="message-erreur" role="alert">@_erreur</p>
+}
+
+@foreach (var avertissement in _avertissements)
+{
+    <p class="message-avertissement">@avertissement</p>
+}
+
+@if (_etape == Etape.Choix)
+{
+    @* Décision actée dans CLAUDE.md : plusieurs notices pour un même ISBN (rééditions
+       successives partageant l'ISBN), on ne choisit JAMAIS à la place de l'utilisateur.
+       Les candidats partagent titre et auteur : ce sont l'éditeur et l'année qui départagent,
+       donc ils sont mis en avant. *@
+    <p class="message-discret">
+        @_candidats.Count notices correspondent à cet ISBN. Elles se distinguent par l'éditeur et l'année.
+    </p>
+
+    <ul class="liste-candidats">
+        @foreach (var (candidat, index) in _candidats.Select((c, i) => (c, i)))
+        {
+            <li class="carte-candidat" @key="index">
+                <Couverture Url="@candidat.CoverUrl" Titre="@candidat.Titre" Classe="couverture-petite" />
+
+                <div class="carte-corps">
+                    <p class="carte-titre">@candidat.Titre</p>
+                    @if (!string.IsNullOrWhiteSpace(candidat.Auteur))
+                    {
+                        <p class="carte-auteur">@candidat.Auteur</p>
+                    }
+
+                    <p class="candidat-distinction">
+                        <span class="candidat-editeur">@(candidat.Editeur ?? "éditeur inconnu")</span>
+                        <span class="candidat-annee">@(candidat.Annee ?? "année inconnue")</span>
+                    </p>
+
+                    <p class="carte-details">
+                        <span class="etiquette">@candidat.Source</span>
+                        @if (!string.IsNullOrWhiteSpace(candidat.IsbnInterroge))
+                        {
+                            <span>trouvé via @candidat.IsbnInterroge</span>
+                        }
+                    </p>
+
+                    <button type="button" class="bouton bouton-principal"
+                            @onclick="() => Choisir(candidat)">
+                        Choisir cette édition
+                    </button>
+                </div>
+            </li>
+        }
+    </ul>
+
+    <div class="actions-formulaire">
+        <button type="button" class="bouton bouton-discret" @onclick="Recommencer">Aucune : saisir à la main</button>
+    </div>
+}
+
+@if (_etape == Etape.Formulaire)
+{
+    <p class="message-discret">
+        Vérifiez et complétez la fiche : tout reste modifiable.
+    </p>
+
+    <FormulaireLivre Saisie="_saisie"
+                     LibelleValidation="Ajouter au catalogue"
+                     Erreur="@_erreurFormulaire"
+                     EnCours="_enregistrement"
+                     OnValider="EnregistrerAsync"
+                     OnAnnuler="Recommencer" />
+}
+
+@code {
+    private enum Etape { Saisie, Choix, Formulaire }
+
+    private Etape _etape = Etape.Saisie;
+    private string _isbn = string.Empty;
+    private bool _chargement;
+    private bool _enregistrement;
+    private string? _erreur;
+    private string? _erreurFormulaire;
+    private IReadOnlyList<CandidatLivre> _candidats = [];
+    private IReadOnlyList<string> _avertissements = [];
+    private EnregistrementLivre _saisie = new();
+
+    private async Task SurTouche(KeyboardEventArgs e)
+    {
+        if (e.Key == "Enter" && !string.IsNullOrWhiteSpace(_isbn))
+        {
+            await ChercherAsync();
+        }
+    }
+
+    private async Task ChercherAsync()
+    {
+        _chargement = true;
+        _erreur = null;
+        _avertissements = [];
+
+        try
+        {
+            var resultat = await Api.ChercherIsbnAsync(_isbn.Trim());
+
+            if (resultat is null)
+            {
+                _erreur = $"« {_isbn} » n'est pas un ISBN valide.";
+                return;
+            }
+
+            _avertissements = resultat.Avertissements;
+            _candidats = resultat.Candidats;
+
+            if (_candidats.Count == 0)
+            {
+                // Aucune notice : on ne bloque pas, le formulaire manuel reste la porte de sortie.
+                _erreur = "Aucune notice trouvée pour cet ISBN. Complétez la fiche à la main.";
+                _saisie = new EnregistrementLivre { Isbn = resultat.IsbnDemande };
+                _etape = Etape.Formulaire;
+                return;
+            }
+
+            if (_candidats.Count == 1)
+            {
+                Choisir(_candidats[0]);
+                return;
+            }
+
+            _etape = Etape.Choix;
+        }
+        catch (Exception ex)
+        {
+            _erreur = $"La recherche a échoué : {ex.Message}";
+        }
+        finally
+        {
+            _chargement = false;
+        }
+    }
+
+    private void Choisir(CandidatLivre candidat)
+    {
+        _saisie = new EnregistrementLivre
+        {
+            Isbn = _isbn.Trim(),
+            Titre = candidat.Titre,
+            Auteur = candidat.Auteur,
+            Editeur = candidat.Editeur,
+            CoverUrl = candidat.CoverUrl,
+            Format = Format.Physique,
+            Statut = Statut.ALire,
+        };
+
+        _erreur = null;
+        _etape = Etape.Formulaire;
+    }
+
+    private void Recommencer()
+    {
+        _etape = Etape.Saisie;
+        _erreur = null;
+        _erreurFormulaire = null;
+        _candidats = [];
+    }
+
+    private async Task EnregistrerAsync()
+    {
+        _enregistrement = true;
+        _erreurFormulaire = null;
+
+        var resultat = await Api.CreerAsync(_saisie);
+
+        _enregistrement = false;
+
+        if (!resultat.EstOk)
+        {
+            _erreurFormulaire = resultat.Erreur;
+            return;
+        }
+
+        Navigation.NavigateTo("/");
+    }
+}
diff --git a/MaBibli.Client/Pages/AjoutManuel.razor b/MaBibli.Client/Pages/AjoutManuel.razor
new file mode 100644
index 0000000..7c70759
--- /dev/null
+++ b/MaBibli.Client/Pages/AjoutManuel.razor
@@ -0,0 +1,44 @@
+@page "/ajout/manuel"
+@inject ServiceLivresApi Api
+@inject NavigationManager Navigation
+
+<PageTitle>MaBibli — saisie manuelle</PageTitle>
+
+<h1 class="titre-page">Saisie manuelle</h1>
+
+<p class="message-discret">
+    Pour les livres sans ISBN, ou dont aucune notice ne convient. L'ISBN reste facultatif.
+</p>
+
+<FormulaireLivre Saisie="_saisie"
+                 LibelleValidation="Ajouter au catalogue"
+                 Erreur="@_erreur"
+                 EnCours="_enregistrement"
+                 OnValider="EnregistrerAsync"
+                 OnAnnuler="Retour" />
+
+@code {
+    private readonly EnregistrementLivre _saisie = new();
+    private bool _enregistrement;
+    private string? _erreur;
+
+    private async Task EnregistrerAsync()
+    {
+        _enregistrement = true;
+        _erreur = null;
+
+        var resultat = await Api.CreerAsync(_saisie);
+
+        _enregistrement = false;
+
+        if (!resultat.EstOk)
+        {
+            _erreur = resultat.Erreur;
+            return;
+        }
+
+        Navigation.NavigateTo("/");
+    }
+
+    private void Retour() => Navigation.NavigateTo("/");
+}
diff --git a/MaBibli.Client/Pages/Catalogue.razor b/MaBibli.Client/Pages/Catalogue.razor
new file mode 100644
index 0000000..44f6595
--- /dev/null
+++ b/MaBibli.Client/Pages/Catalogue.razor
@@ -0,0 +1,201 @@
+@page "/"
+@inject ServiceLivresApi Api
+@implements IDisposable
+
+<PageTitle>MaBibli — catalogue</PageTitle>
+
+<h1 class="titre-page">Catalogue</h1>
+
+<div class="barre-recherche">
+    <input class="champ-saisie" type="search" placeholder="Titre ou auteur…"
+           value="@_recherche" @oninput="SurRecherche" aria-label="Rechercher un livre" />
+</div>
+
+<div class="filtres">
+    <div class="segments" role="group" aria-label="Filtrer par format">
+        <button type="button" class="segment @(_format is null ? "segment-actif" : null)"
+                @onclick="() => FiltrerFormat(null)">Tous</button>
+        @foreach (var format in Enum.GetValues<Format>())
+        {
+            <button type="button" class="segment @(_format == format ? "segment-actif" : null)"
+                    @onclick="() => FiltrerFormat(format)">@Libelles.Format(format)</button>
+        }
+    </div>
+
+    <div class="segments" role="group" aria-label="Filtrer par statut">
+        <button type="button" class="segment @(_statut is null ? "segment-actif" : null)"
+                @onclick="() => FiltrerStatut(null)">Tous</button>
+        @foreach (var statut in Enum.GetValues<Statut>())
+        {
+            <button type="button" class="segment @(_statut == statut ? "segment-actif" : null)"
+                    @onclick="() => FiltrerStatut(statut)">@Libelles.Statut(statut)</button>
+        }
+    </div>
+</div>
+
+@if (_erreur is not null)
+{
+    <p class="message-erreur" role="alert">@_erreur</p>
+}
+
+@if (_chargement && _livres is null)
+{
+    <p class="message-discret">Chargement…</p>
+}
+else if (_livres is { Count: 0 })
+{
+    <p class="message-discret">
+        @(EstFiltre ? "Aucun livre ne correspond à cette recherche." : "La bibliothèque est vide. Ajoutez un premier livre.")
+    </p>
+}
+else if (_livres is not null)
+{
+    <p class="compteur">@_livres.Count livre@(_livres.Count > 1 ? "s" : "")</p>
+
+    <ul class="liste-livres">
+        @foreach (var livre in _livres)
+        {
+            <li class="carte-livre" @key="livre.Id">
+                <Couverture Url="@livre.CoverUrl" Titre="@livre.Titre" Classe="couverture-petite" />
+
+                <div class="carte-corps">
+                    <a class="carte-titre" href="@($"livres/{livre.Id}")">@livre.Titre</a>
+
+                    @if (!string.IsNullOrWhiteSpace(livre.Auteur))
+                    {
+                        <p class="carte-auteur">@livre.Auteur</p>
+                    }
+
+                    <p class="carte-details">
+                        <span class="etiquette">@Libelles.Format(livre.Format)</span>
+                        @if (!string.IsNullOrWhiteSpace(livre.Editeur))
+                        {
+                            <span>@livre.Editeur</span>
+                        }
+                    </p>
+
+                    @* Changement de statut : action la plus fréquente, donc directement dans la liste. *@
+                    <div class="segments segments-compacts" role="group" aria-label="Statut de lecture">
+                        @foreach (var statut in Enum.GetValues<Statut>())
+                        {
+                            <button type="button"
+                                    class="segment @Libelles.ClasseStatut(statut) @(livre.Statut == statut ? "segment-actif" : null)"
+                                    disabled="@(_statutEnCours == livre.Id)"
+                                    @onclick="() => ChangerStatut(livre, statut)">
+                                @Libelles.Statut(statut)
+                            </button>
+                        }
+                    </div>
+                </div>
+            </li>
+        }
+    </ul>
+}
+
+<nav class="actions-flottantes">
+    <a class="bouton bouton-principal" href="ajout/isbn">Ajouter par ISBN</a>
+    <a class="bouton bouton-discret" href="ajout/manuel">Saisie manuelle</a>
+</nav>
+
+@code {
+    private IReadOnlyList<LivreDto>? _livres;
+    private string _recherche = string.Empty;
+    private Format? _format;
+    private Statut? _statut;
+    private bool _chargement;
+    private string? _erreur;
+    private int? _statutEnCours;
+
+    // Une frappe au clavier annule la recherche précédente encore en vol.
+    private CancellationTokenSource _cts = new();
+
+    private bool EstFiltre =>
+        !string.IsNullOrWhiteSpace(_recherche) || _format is not null || _statut is not null;
+
+    protected override Task OnInitializedAsync() => ChargerAsync();
+
+    private async Task SurRecherche(ChangeEventArgs e)
+    {
+        _recherche = e.Value?.ToString() ?? string.Empty;
+        await ChargerAsync();
+    }
+
+    private Task FiltrerFormat(Format? format)
+    {
+        _format = format;
+        return ChargerAsync();
+    }
+
+    private Task FiltrerStatut(Statut? statut)
+    {
+        _statut = statut;
+        return ChargerAsync();
+    }
+
+    private async Task ChargerAsync()
+    {
+        _cts.Cancel();
+        _cts.Dispose();
+        _cts = new CancellationTokenSource();
+        var jeton = _cts.Token;
+
+        _chargement = true;
+        _erreur = null;
+
+        try
+        {
+            var criteres = new CritereLivres { Recherche = _recherche, Format = _format, Statut = _statut };
+            _livres = await Api.ListerAsync(criteres, jeton);
+        }
+        catch (OperationCanceledException)
+        {
+            return; // Une recherche plus récente a pris le relais.
+        }
+        catch (Exception ex)
+        {
+            _erreur = $"Impossible de charger le catalogue : {ex.Message}";
+        }
+        finally
+        {
+            if (!jeton.IsCancellationRequested)
+            {
+                _chargement = false;
+            }
+        }
+    }
+
+    private async Task ChangerStatut(LivreDto livre, Statut statut)
+    {
+        if (livre.Statut == statut)
+        {
+            return;
+        }
+
+        _statutEnCours = livre.Id;
+        var resultat = await Api.ChangerStatutAsync(livre.Id, statut);
+        _statutEnCours = null;
+
+        if (!resultat.EstOk)
+        {
+            _erreur = resultat.Erreur;
+            return;
+        }
+
+        if (_statut is not null)
+        {
+            // Un filtre par statut est actif : le livre vient peut-être de sortir de la sélection,
+            // il faut donc recharger plutôt que corriger la liste en place.
+            await ChargerAsync();
+            return;
+        }
+
+        // Remplacement local : évite de recharger toute la liste pour un seul champ.
+        _livres = _livres!.Select(l => l.Id == livre.Id ? resultat.Valeur! : l).ToList();
+    }
+
+    public void Dispose()
+    {
+        _cts.Cancel();
+        _cts.Dispose();
+    }
+}
diff --git a/MaBibli.Client/Pages/EditionLivre.razor b/MaBibli.Client/Pages/EditionLivre.razor
new file mode 100644
index 0000000..9f9ce39
--- /dev/null
+++ b/MaBibli.Client/Pages/EditionLivre.razor
@@ -0,0 +1,143 @@
+@page "/livres/{Id:int}"
+@inject ServiceLivresApi Api
+@inject NavigationManager Navigation
+
+<PageTitle>MaBibli — fiche du livre</PageTitle>
+
+<h1 class="titre-page">Fiche du livre</h1>
+
+@if (_introuvable)
+{
+    <p class="message-erreur" role="alert">Ce livre n'existe pas (ou plus).</p>
+    <a class="bouton bouton-discret" href="">Retour au catalogue</a>
+}
+else if (_saisie is null)
+{
+    <p class="message-discret">Chargement…</p>
+}
+else
+{
+    <FormulaireLivre Saisie="_saisie"
+                     LibelleValidation="Enregistrer les modifications"
+                     Erreur="@_erreur"
+                     EnCours="_enregistrement"
+                     OnValider="EnregistrerAsync"
+                     OnAnnuler="Retour" />
+
+    @if (_livre is not null)
+    {
+        <p class="message-discret">
+            Ajouté le @_livre.DateAjout.ToLocalTime().ToString("dd/MM/yyyy")
+            @if (!string.IsNullOrWhiteSpace(_livre.AjoutePar))
+            {
+                @($" par {_livre.AjoutePar}")
+            }
+            @* Information de traçabilité, jamais un filtre : la bibliothèque est commune. *@
+        </p>
+    }
+
+    <section class="zone-danger">
+        @if (!_confirmationSuppression)
+        {
+            <button type="button" class="bouton bouton-danger" @onclick="() => _confirmationSuppression = true">
+                Supprimer ce livre
+            </button>
+        }
+        else
+        {
+            <p class="message-avertissement">
+                Supprimer « @_saisie.Titre » définitivement ? L'historique de ses prêts partira avec.
+            </p>
+            <div class="actions-formulaire">
+                <button type="button" class="bouton bouton-danger" disabled="@_suppression" @onclick="SupprimerAsync">
+                    @(_suppression ? "Suppression…" : "Oui, supprimer")
+                </button>
+                <button type="button" class="bouton bouton-discret" disabled="@_suppression"
+                        @onclick="() => _confirmationSuppression = false">
+                    Annuler
+                </button>
+            </div>
+        }
+    </section>
+}
+
+@code {
+    [Parameter] public int Id { get; set; }
+
+    private LivreDto? _livre;
+    private EnregistrementLivre? _saisie;
+    private bool _introuvable;
+    private bool _enregistrement;
+    private bool _suppression;
+    private bool _confirmationSuppression;
+    private string? _erreur;
+
+    protected override async Task OnParametersSetAsync()
+    {
+        _introuvable = false;
+        _saisie = null;
+
+        try
+        {
+            _livre = await Api.ObtenirAsync(Id);
+        }
+        catch (Exception ex)
+        {
+            _erreur = $"Chargement impossible : {ex.Message}";
+            return;
+        }
+
+        if (_livre is null)
+        {
+            _introuvable = true;
+            return;
+        }
+
+        _saisie = new EnregistrementLivre
+        {
+            Isbn = _livre.Isbn,
+            Titre = _livre.Titre,
+            Auteur = _livre.Auteur,
+            Editeur = _livre.Editeur,
+            Format = _livre.Format,
+            Statut = _livre.Statut,
+            CoverUrl = _livre.CoverUrl,
+        };
+    }
+
+    private async Task EnregistrerAsync()
+    {
+        _enregistrement = true;
+        _erreur = null;
+
+        var resultat = await Api.ModifierAsync(Id, _saisie!);
+
+        _enregistrement = false;
+
+        if (!resultat.EstOk)
+        {
+            _erreur = resultat.Erreur;
+            return;
+        }
+
+        Navigation.NavigateTo("/");
+    }
+
+    private async Task SupprimerAsync()
+    {
+        _suppression = true;
+        var erreur = await Api.SupprimerAsync(Id);
+        _suppression = false;
+
+        if (erreur is not null)
+        {
+            _erreur = erreur;
+            _confirmationSuppression = false;
+            return;
+        }
+
+        Navigation.NavigateTo("/");
+    }
+
+    private void Retour() => Navigation.NavigateTo("/");
+}
diff --git a/MaBibli.Client/Pages/Home.razor b/MaBibli.Client/Pages/Home.razor
deleted file mode 100644
index 43c391e..0000000
--- a/MaBibli.Client/Pages/Home.razor
+++ /dev/null
@@ -1,7 +0,0 @@
-@page "/"
-
-<PageTitle>MaBibli</PageTitle>
-
-<h1>MaBibli</h1>
-
-<p>Squelette de l'application. Les fonctionnalités arrivent dans les phases suivantes.</p>
diff --git a/MaBibli.Client/Program.cs b/MaBibli.Client/Program.cs
index 180e393..db6261c 100644
--- a/MaBibli.Client/Program.cs
+++ b/MaBibli.Client/Program.cs
@@ -7,5 +7,6 @@ builder.RootComponents.Add<App>("#app");
 builder.RootComponents.Add<HeadOutlet>("head::after");
 
 builder.Services.AddScoped(sp => new HttpClient { BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) });
+builder.Services.AddScoped<MaBibli.Client.Services.ServiceLivresApi>();
 
 await builder.Build().RunAsync();
diff --git a/MaBibli.Client/Services/ServiceLivresApi.cs b/MaBibli.Client/Services/ServiceLivresApi.cs
new file mode 100644
index 0000000..d9f2dd0
--- /dev/null
+++ b/MaBibli.Client/Services/ServiceLivresApi.cs
@@ -0,0 +1,145 @@
+using System.Net;
+using System.Net.Http.Json;
+using System.Text.Json;
+using MaBibli.Shared.Catalogue;
+using MaBibli.Shared.Dtos;
+using MaBibli.Shared.Entites;
+
+namespace MaBibli.Client.Services;
+
+/// <summary>
+/// Accès à l'API depuis le client Blazor.
+/// </summary>
+/// <remarks>
+/// Aucun cache : la phase 3 suppose le réseau disponible. Le cache hors-ligne est la phase 6.
+/// </remarks>
+public sealed class ServiceLivresApi(HttpClient http)
+{
+    private static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web);
+
+    public async Task<IReadOnlyList<LivreDto>> ListerAsync(CritereLivres criteres, CancellationToken ct = default)
+    {
+        var parametres = new List<string>();
+
+        if (!string.IsNullOrWhiteSpace(criteres.Recherche))
+        {
+            parametres.Add($"recherche={Uri.EscapeDataString(criteres.Recherche.Trim())}");
+        }
+
+        if (criteres.Format is { } format)
+        {
+            parametres.Add($"format={format}");
+        }
+
+        if (criteres.Statut is { } statut)
+        {
+            parametres.Add($"statut={statut}");
+        }
+
+        var url = "api/livres" + (parametres.Count > 0 ? "?" + string.Join('&', parametres) : string.Empty);
+
+        return await http.GetFromJsonAsync<List<LivreDto>>(url, Json, ct) ?? [];
+    }
+
+    public async Task<LivreDto?> ObtenirAsync(int id, CancellationToken ct = default)
+    {
+        var reponse = await http.GetAsync($"api/livres/{id}", ct);
+        return reponse.StatusCode == HttpStatusCode.NotFound
+            ? null
+            : await LireAsync<LivreDto>(reponse, ct);
+    }
+
+    public async Task<ResultatApi<LivreDto>> CreerAsync(EnregistrementLivre saisie, CancellationToken ct = default)
+    {
+        var reponse = await http.PostAsJsonAsync("api/livres", saisie, Json, ct);
+        return await InterpreterAsync<LivreDto>(reponse, ct);
+    }
+
+    public async Task<ResultatApi<LivreDto>> ModifierAsync(int id, EnregistrementLivre saisie, CancellationToken ct = default)
+    {
+        var reponse = await http.PutAsJsonAsync($"api/livres/{id}", saisie, Json, ct);
+        return await InterpreterAsync<LivreDto>(reponse, ct);
+    }
+
+    public async Task<ResultatApi<LivreDto>> ChangerStatutAsync(int id, Statut statut, CancellationToken ct = default)
+    {
+        var reponse = await http.PatchAsJsonAsync(
+            $"api/livres/{id}/statut", new ChangementStatut { Statut = statut }, Json, ct);
+        return await InterpreterAsync<LivreDto>(reponse, ct);
+    }
+
+    public async Task<string?> SupprimerAsync(int id, CancellationToken ct = default)
+    {
+        var reponse = await http.DeleteAsync($"api/livres/{id}", ct);
+        return reponse.IsSuccessStatusCode ? null : await MessageErreurAsync(reponse, ct);
+    }
+
+    public async Task<ResultatLookupIsbn?> ChercherIsbnAsync(string isbn, CancellationToken ct = default)
+    {
+        var reponse = await http.GetAsync($"api/isbn/{Uri.EscapeDataString(isbn)}", ct);
+        return reponse.IsSuccessStatusCode
+            ? await LireAsync<ResultatLookupIsbn>(reponse, ct)
+            : null;
+    }
+
+    public async Task<UtilisateurCourant> ObtenirUtilisateurAsync(CancellationToken ct = default)
+    {
+        try
+        {
+            return await http.GetFromJsonAsync<UtilisateurCourant>("api/moi", Json, ct)
+                   ?? UtilisateurCourant.Anonyme;
+        }
+        catch (HttpRequestException)
+        {
+            return UtilisateurCourant.Anonyme;
+        }
+    }
+
+    private static async Task<T?> LireAsync<T>(HttpResponseMessage reponse, CancellationToken ct)
+    {
+        reponse.EnsureSuccessStatusCode();
+        return await reponse.Content.ReadFromJsonAsync<T>(Json, ct);
+    }
+
+    private static async Task<ResultatApi<T>> InterpreterAsync<T>(HttpResponseMessage reponse, CancellationToken ct)
+    {
+        if (reponse.IsSuccessStatusCode)
+        {
+            var valeur = await reponse.Content.ReadFromJsonAsync<T>(Json, ct);
+            return new ResultatApi<T>(valeur, null);
+        }
+
+        return new ResultatApi<T>(default, await MessageErreurAsync(reponse, ct));
+    }
+
+    /// <summary>Récupère le message d'erreur de l'API pour l'afficher tel quel à l'utilisateur.</summary>
+    private static async Task<string> MessageErreurAsync(HttpResponseMessage reponse, CancellationToken ct)
+    {
+        try
+        {
+            var corps = await reponse.Content.ReadFromJsonAsync<ErreurApi>(Json, ct);
+            if (!string.IsNullOrWhiteSpace(corps?.Erreur))
+            {
+                return corps.Erreur;
+            }
+        }
+        catch (Exception)
+        {
+            // Corps illisible ou vide : on retombe sur le code HTTP.
+        }
+
+        return reponse.StatusCode switch
+        {
+            HttpStatusCode.NotFound => "Ce livre n'existe plus.",
+            _ => $"L'enregistrement a échoué ({(int)reponse.StatusCode}).",
+        };
+    }
+
+    private sealed record ErreurApi(string? Erreur);
+}
+
+/// <summary>Résultat d'un appel d'écriture : la valeur, ou un message d'erreur affichable.</summary>
+public readonly record struct ResultatApi<T>(T? Valeur, string? Erreur)
+{
+    public bool EstOk => Erreur is null;
+}
diff --git a/MaBibli.Client/_Imports.razor b/MaBibli.Client/_Imports.razor
index 904ac57..0ca14fd 100644
--- a/MaBibli.Client/_Imports.razor
+++ b/MaBibli.Client/_Imports.razor
@@ -7,4 +7,9 @@
 @using Microsoft.AspNetCore.Components.WebAssembly.Http
 @using Microsoft.JSInterop
 @using MaBibli.Client
+@using MaBibli.Client.Composants
 @using MaBibli.Client.Layout
+@using MaBibli.Client.Services
+@using MaBibli.Shared.Catalogue
+@using MaBibli.Shared.Dtos
+@using MaBibli.Shared.Entites
diff --git a/MaBibli.Client/wwwroot/css/app.css b/MaBibli.Client/wwwroot/css/app.css
index fe44b1d..a86d6ee 100644
--- a/MaBibli.Client/wwwroot/css/app.css
+++ b/MaBibli.Client/wwwroot/css/app.css
@@ -112,4 +112,340 @@ code {
 
 .form-floating > .form-control-plaintext:focus::placeholder, .form-floating > .form-control:focus::placeholder {
     text-align: start;
-}
\ No newline at end of file
+}
+/* ------------------------------------------------------------------
+   MaBibli — interface du catalogue (phase 3)
+
+   Conçue mobile d'abord : une seule colonne, cibles tactiles d'au moins
+   2,75 rem, aucune règle de largeur en dessous du point de rupture.
+   Le PC n'ajoute qu'une largeur maximale et une grille de cartes.
+   ------------------------------------------------------------------ */
+
+:root {
+    --mb-accent: #1b3a5c;
+    --mb-bord: #dcdcdc;
+    --mb-fond-doux: #f4f5f7;
+    --mb-texte-doux: #5c6470;
+    --mb-danger: #a4242c;
+}
+
+body {
+    background: #fff;
+    color: #1d2129;
+}
+
+.titre-page {
+    font-size: 1.4rem;
+    margin: 0 0 0.75rem;
+}
+
+.message-discret {
+    color: var(--mb-texte-doux);
+    font-size: 0.9rem;
+}
+
+.message-erreur {
+    background: #fdecec;
+    border-left: 3px solid var(--mb-danger);
+    color: #7a1a20;
+    padding: 0.6rem 0.75rem;
+    border-radius: 4px;
+    margin: 0.75rem 0;
+}
+
+.message-avertissement {
+    background: #fff8e1;
+    border-left: 3px solid #c99700;
+    color: #6b5200;
+    padding: 0.6rem 0.75rem;
+    border-radius: 4px;
+    margin: 0.5rem 0;
+    font-size: 0.9rem;
+}
+
+.compteur {
+    color: var(--mb-texte-doux);
+    font-size: 0.85rem;
+    margin: 0.75rem 0 0.25rem;
+}
+
+/* --- Champs de saisie --- */
+
+.barre-recherche {
+    margin-bottom: 0.75rem;
+}
+
+.champ {
+    display: block;
+    margin-bottom: 0.9rem;
+    border: 0;
+    padding: 0;
+}
+
+.champ-libelle {
+    display: block;
+    font-size: 0.85rem;
+    font-weight: 600;
+    margin-bottom: 0.3rem;
+}
+
+.champ-aide,
+.obligatoire {
+    font-weight: 400;
+    color: var(--mb-texte-doux);
+}
+
+.champ-saisie {
+    width: 100%;
+    /* 16px minimum : en dessous, iOS zoome au focus. */
+    font-size: 1rem;
+    padding: 0.7rem 0.75rem;
+    border: 1px solid var(--mb-bord);
+    border-radius: 8px;
+    background: #fff;
+}
+
+.champ-saisie:focus {
+    outline: 2px solid var(--mb-accent);
+    outline-offset: -1px;
+}
+
+/* --- Segments (filtres, format, statut) --- */
+
+.segments {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.35rem;
+    margin-bottom: 0.5rem;
+}
+
+.segment {
+    flex: 1 1 auto;
+    min-height: 2.5rem;
+    padding: 0.4rem 0.7rem;
+    font-size: 0.85rem;
+    border: 1px solid var(--mb-bord);
+    border-radius: 999px;
+    background: #fff;
+    color: #1d2129;
+    cursor: pointer;
+}
+
+.segment-actif {
+    background: var(--mb-accent);
+    border-color: var(--mb-accent);
+    color: #fff;
+}
+
+.segments-compacts .segment {
+    min-height: 2.2rem;
+    font-size: 0.8rem;
+}
+
+.segment.statut-a-lire.segment-actif { background: #6b4fa8; border-color: #6b4fa8; }
+.segment.statut-en-cours.segment-actif { background: #b06b00; border-color: #b06b00; }
+.segment.statut-lu.segment-actif { background: #1f7a44; border-color: #1f7a44; }
+
+/* --- Boutons --- */
+
+.bouton {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-height: 2.75rem;
+    padding: 0.6rem 1rem;
+    border-radius: 8px;
+    border: 1px solid var(--mb-bord);
+    background: #fff;
+    color: #1d2129;
+    font-size: 0.95rem;
+    text-decoration: none;
+    cursor: pointer;
+}
+
+.bouton:disabled {
+    opacity: 0.55;
+    cursor: default;
+}
+
+.bouton-principal {
+    background: var(--mb-accent);
+    border-color: var(--mb-accent);
+    color: #fff;
+}
+
+.bouton-discret {
+    background: var(--mb-fond-doux);
+}
+
+.bouton-danger {
+    background: var(--mb-danger);
+    border-color: var(--mb-danger);
+    color: #fff;
+}
+
+.actions-formulaire {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+    margin: 1rem 0;
+}
+
+.actions-flottantes {
+    position: fixed;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    display: flex;
+    gap: 0.5rem;
+    padding: 0.6rem 1rem calc(0.6rem + env(safe-area-inset-bottom));
+    background: rgba(255, 255, 255, 0.96);
+    border-top: 1px solid var(--mb-bord);
+}
+
+.actions-flottantes .bouton {
+    flex: 1;
+}
+
+/* --- Couvertures --- */
+
+.couverture {
+    position: relative;
+    flex: 0 0 auto;
+    overflow: hidden;
+    border-radius: 6px;
+    background: var(--mb-fond-doux);
+    border: 1px solid var(--mb-bord);
+}
+
+.couverture-petite { width: 3.5rem; height: 5.25rem; }
+.couverture-moyenne { width: 6rem; height: 9rem; }
+
+.couverture-substitut {
+    position: absolute;
+    inset: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1.5rem;
+    font-weight: 700;
+    color: #9aa2ad;
+}
+
+.couverture-image {
+    position: absolute;
+    inset: 0;
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+}
+
+/* Posée par l'attribut onerror : les couvertures OpenLibrary renvoient
+   des 502 intermittents, l'image cassée laisse place au substitut. */
+.couverture-image.image-cassee {
+    display: none;
+}
+
+/* --- Liste de livres --- */
+
+.liste-livres,
+.liste-candidats {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+}
+
+.carte-livre,
+.carte-candidat {
+    display: flex;
+    gap: 0.75rem;
+    padding: 0.75rem 0;
+    border-bottom: 1px solid var(--mb-bord);
+}
+
+.carte-corps {
+    min-width: 0;
+    flex: 1;
+}
+
+.carte-titre {
+    display: block;
+    font-weight: 600;
+    color: #1d2129;
+    text-decoration: none;
+    margin: 0 0 0.15rem;
+}
+
+.carte-auteur {
+    margin: 0 0 0.25rem;
+    color: var(--mb-texte-doux);
+    font-size: 0.9rem;
+}
+
+.carte-details {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.4rem;
+    align-items: center;
+    margin: 0 0 0.5rem;
+    font-size: 0.8rem;
+    color: var(--mb-texte-doux);
+}
+
+.etiquette {
+    background: var(--mb-fond-doux);
+    border-radius: 4px;
+    padding: 0.1rem 0.4rem;
+}
+
+/* --- Choix entre plusieurs notices --- */
+
+/* Les candidats partagent titre et auteur : ce sont l'éditeur et l'année
+   qui les départagent, donc ils sont mis en avant visuellement. */
+.candidat-distinction {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+    margin: 0 0 0.4rem;
+    font-size: 0.9rem;
+}
+
+.candidat-editeur {
+    font-weight: 600;
+}
+
+.candidat-annee {
+    background: #eef2f7;
+    border-radius: 4px;
+    padding: 0.05rem 0.4rem;
+}
+
+/* --- Formulaire --- */
+
+.formulaire-apercu {
+    display: flex;
+    justify-content: center;
+    margin-bottom: 1rem;
+}
+
+.zone-danger {
+    margin-top: 2rem;
+    padding-top: 1rem;
+    border-top: 1px solid var(--mb-bord);
+}
+
+/* --- PC : simple élargissement, la structure mobile ne change pas. --- */
+
+@media (min-width: 48rem) {
+    .actions-flottantes {
+        position: static;
+        padding: 0;
+        margin-top: 1.5rem;
+        background: none;
+        border-top: 0;
+    }
+
+    .actions-flottantes .bouton {
+        flex: 0 0 auto;
+    }
+}
diff --git a/MaBibli.Shared/Catalogue/CritereLivres.cs b/MaBibli.Shared/Catalogue/CritereLivres.cs
new file mode 100644
index 0000000..948f108
--- /dev/null
+++ b/MaBibli.Shared/Catalogue/CritereLivres.cs
@@ -0,0 +1,23 @@
+using MaBibli.Shared.Entites;
+
+namespace MaBibli.Shared.Catalogue;
+
+/// <summary>
+/// Critères de consultation du catalogue.
+/// </summary>
+/// <remarks>
+/// <b>Il n'existe volontairement aucun critère sur <c>AjoutePar</c>.</b> La bibliothèque est
+/// commune à tout le foyer : filtrer les lectures sur ce champ serait un bug de conception.
+/// L'absence de ce critère est l'endroit où l'invariant est le plus visible.
+/// </remarks>
+public record CritereLivres
+{
+    /// <summary>Texte cherché dans le titre <i>ou</i> l'auteur. Insensible à la casse.</summary>
+    public string? Recherche { get; init; }
+
+    /// <summary>Physique ou numérique. <c>null</c> = les deux : le catalogue est unique.</summary>
+    public Format? Format { get; init; }
+
+    /// <summary>Statut de lecture. <c>null</c> = tous.</summary>
+    public Statut? Statut { get; init; }
+}
diff --git a/MaBibli.Shared/Catalogue/FiltreLivres.cs b/MaBibli.Shared/Catalogue/FiltreLivres.cs
new file mode 100644
index 0000000..6020262
--- /dev/null
+++ b/MaBibli.Shared/Catalogue/FiltreLivres.cs
@@ -0,0 +1,55 @@
+using MaBibli.Shared.Entites;
+
+namespace MaBibli.Shared.Catalogue;
+
+/// <summary>
+/// Filtrage, recherche et tri du catalogue.
+/// </summary>
+/// <remarks>
+/// Écrit sur <see cref="IQueryable{T}"/> pour être exécuté par EF Core côté base <b>et</b>
+/// testable en mémoire sur une simple liste, sans base ni réseau.
+/// <para>
+/// La comparaison passe par <c>ToLower()</c> : EF Core la traduit en SQL, et LINQ-to-Objects
+/// lui donne le même comportement insensible à la casse. Les accents ne sont pas normalisés
+/// (« Emile » ne trouve pas « Émile ») — limitation assumée à ce stade.
+/// </para>
+/// </remarks>
+public static class FiltreLivres
+{
+    public static IQueryable<Livre> Appliquer(IQueryable<Livre> source, CritereLivres criteres)
+    {
+        // AUCUN filtre sur AjoutePar : la bibliothèque est commune (CLAUDE.md).
+        // Ce commentaire est là pour qu'une régression future saute aux yeux en relecture.
+
+        if (criteres.Format is { } format)
+        {
+            source = source.Where(l => l.Format == format);
+        }
+
+        if (criteres.Statut is { } statut)
+        {
+            source = source.Where(l => l.Statut == statut);
+        }
+
+        var terme = criteres.Recherche?.Trim();
+        if (!string.IsNullOrEmpty(terme))
+        {
+            var recherche = terme.ToLower();
+            source = source.Where(l =>
+                l.Titre.ToLower().Contains(recherche)
+                || (l.Auteur != null && l.Auteur.ToLower().Contains(recherche)));
+        }
+
+        return Trier(source);
+    }
+
+    /// <summary>
+    /// Tri par titre, puis par identifiant pour rendre l'ordre déterministe.
+    /// </summary>
+    /// <remarks>
+    /// CLAUDE.md ne tranche pas le tri. L'ordre alphabétique a été retenu parce qu'une
+    /// bibliothèque se parcourt par titre ; l'ordre d'ajout n'a d'intérêt que le jour de la saisie.
+    /// </remarks>
+    public static IQueryable<Livre> Trier(IQueryable<Livre> source) =>
+        source.OrderBy(l => l.Titre).ThenBy(l => l.Id);
+}
diff --git a/MaBibli.Shared/Dtos/EnregistrementLivre.cs b/MaBibli.Shared/Dtos/EnregistrementLivre.cs
new file mode 100644
index 0000000..fb088a5
--- /dev/null
+++ b/MaBibli.Shared/Dtos/EnregistrementLivre.cs
@@ -0,0 +1,34 @@
+using MaBibli.Shared.Entites;
+
+namespace MaBibli.Shared.Dtos;
+
+/// <summary>
+/// Charge utile de création et de modification d'un livre.
+/// </summary>
+/// <remarks>
+/// <see cref="Livre.AjoutePar"/> n'y figure pas volontairement : il est déterminé par le serveur
+/// à partir de l'utilisateur authentifié, jamais par le client.
+/// </remarks>
+public record EnregistrementLivre
+{
+    /// <summary>Facultatif : certains livres n'ont pas d'ISBN. Normalisé par le serveur.</summary>
+    public string? Isbn { get; set; }
+
+    public string Titre { get; set; } = string.Empty;
+
+    public string? Auteur { get; set; }
+
+    public string? Editeur { get; set; }
+
+    public Format Format { get; set; }
+
+    public Statut Statut { get; set; }
+
+    public string? CoverUrl { get; set; }
+}
+
+/// <summary>Charge utile du changement de statut de lecture — l'action la plus fréquente.</summary>
+public record ChangementStatut
+{
+    public Statut Statut { get; set; }
+}
diff --git a/MaBibli.Shared/Dtos/LivreDto.cs b/MaBibli.Shared/Dtos/LivreDto.cs
new file mode 100644
index 0000000..cdfb1ce
--- /dev/null
+++ b/MaBibli.Shared/Dtos/LivreDto.cs
@@ -0,0 +1,34 @@
+using MaBibli.Shared.Entites;
+
+namespace MaBibli.Shared.Dtos;
+
+/// <summary>
+/// Un livre tel qu'exposé par l'API. Volontairement sans la collection <c>Prets</c> :
+/// les prêts sont la phase 4.
+/// </summary>
+public record LivreDto
+{
+    public required int Id { get; init; }
+
+    public string? Isbn { get; init; }
+
+    public required string Titre { get; init; }
+
+    public string? Auteur { get; init; }
+
+    public string? Editeur { get; init; }
+
+    public required Format Format { get; init; }
+
+    public required Statut Statut { get; init; }
+
+    public string? CoverUrl { get; init; }
+
+    public required DateTime DateAjout { get; init; }
+
+    /// <summary>
+    /// Qui a saisi le livre. <b>Information d'affichage, pas une frontière</b> :
+    /// la bibliothèque est commune et aucune lecture ne filtre sur ce champ.
+    /// </summary>
+    public string? AjoutePar { get; init; }
+}
diff --git a/MaBibli.Shared/Dtos/UtilisateurCourant.cs b/MaBibli.Shared/Dtos/UtilisateurCourant.cs
new file mode 100644
index 0000000..f12448d
--- /dev/null
+++ b/MaBibli.Shared/Dtos/UtilisateurCourant.cs
@@ -0,0 +1,30 @@
+namespace MaBibli.Shared.Dtos;
+
+/// <summary>
+/// Identité de la personne connectée, telle que fournie par les en-têtes SSOwat de YunoHost.
+/// </summary>
+/// <remarks>
+/// En développement il n'y a pas de SSOwat : un utilisateur simulé est configuré
+/// (<c>Identite:UtilisateurSimule</c>), conformément à CLAUDE.md qui demande de simuler
+/// plutôt que de désactiver l'authentification.
+/// </remarks>
+public record UtilisateurCourant
+{
+    /// <summary><c>YNH_USER</c>. <c>null</c> si l'identité n'a pas pu être déterminée.</summary>
+    public string? Identifiant { get; init; }
+
+    /// <summary><c>YNH_USER_EMAIL</c>.</summary>
+    public string? Email { get; init; }
+
+    /// <summary><c>YNH_USER_FULLNAME</c> — évite une requête LDAP pour l'affichage.</summary>
+    public string? NomComplet { get; init; }
+
+    /// <summary>Vrai si l'identité provient de la configuration de développement, pas de SSOwat.</summary>
+    public bool Simule { get; init; }
+
+    /// <summary>Libellé à afficher, avec repli sur l'identifiant.</summary>
+    public string Affichage =>
+        NomComplet is { Length: > 0 } ? NomComplet : Identifiant ?? "inconnu";
+
+    public static readonly UtilisateurCourant Anonyme = new();
+}
diff --git a/MaBibli.Tests/FiltreLivresTests.cs b/MaBibli.Tests/FiltreLivresTests.cs
new file mode 100644
index 0000000..fe14b9c
--- /dev/null
+++ b/MaBibli.Tests/FiltreLivresTests.cs
@@ -0,0 +1,150 @@
+using MaBibli.Shared.Catalogue;
+using MaBibli.Shared.Entites;
+
+namespace MaBibli.Tests;
+
+/// <summary>
+/// Filtrage et recherche du catalogue. Purement en mémoire : ni base, ni réseau.
+/// </summary>
+public class FiltreLivresTests
+{
+    private static readonly Livre[] Catalogue =
+    [
+        new()
+        {
+            Id = 1, Titre = "Germinal", Auteur = "Émile Zola",
+            Format = Format.Physique, Statut = Statut.Lu, AjoutePar = "mathieu",
+        },
+        new()
+        {
+            Id = 2, Titre = "La Bête humaine", Auteur = "Émile Zola",
+            Format = Format.Numerique, Statut = Statut.ALire, AjoutePar = "camille",
+        },
+        new()
+        {
+            Id = 3, Titre = "Le Horla", Auteur = "Guy de Maupassant",
+            Format = Format.Physique, Statut = Statut.EnCours, AjoutePar = "camille",
+        },
+        new()
+        {
+            Id = 4, Titre = "Bel-Ami", Auteur = null,
+            Format = Format.Numerique, Statut = Statut.Lu, AjoutePar = null,
+        },
+    ];
+
+    private static List<Livre> Filtrer(CritereLivres criteres) =>
+        FiltreLivres.Appliquer(Catalogue.AsQueryable(), criteres).ToList();
+
+    [Fact]
+    public void Sans_critere_tout_le_catalogue_remonte()
+        => Assert.Equal(4, Filtrer(new CritereLivres()).Count);
+
+    [Fact]
+    public void Le_tri_est_alphabetique_sur_le_titre()
+        => Assert.Equal(
+            ["Bel-Ami", "Germinal", "La Bête humaine", "Le Horla"],
+            Filtrer(new CritereLivres()).Select(l => l.Titre));
+
+    [Theory]
+    [InlineData(Format.Physique, 2)]
+    [InlineData(Format.Numerique, 2)]
+    public void Le_filtre_format_ne_garde_que_ce_format(Format format, int attendu)
+    {
+        var resultat = Filtrer(new CritereLivres { Format = format });
+
+        Assert.Equal(attendu, resultat.Count);
+        Assert.All(resultat, l => Assert.Equal(format, l.Format));
+    }
+
+    [Theory]
+    [InlineData(Statut.ALire, 1)]
+    [InlineData(Statut.EnCours, 1)]
+    [InlineData(Statut.Lu, 2)]
+    public void Le_filtre_statut_ne_garde_que_ce_statut(Statut statut, int attendu)
+    {
+        var resultat = Filtrer(new CritereLivres { Statut = statut });
+
+        Assert.Equal(attendu, resultat.Count);
+        Assert.All(resultat, l => Assert.Equal(statut, l.Statut));
+    }
+
+    [Fact]
+    public void La_recherche_porte_sur_le_titre()
+        => Assert.Equal(["Germinal"], Filtrer(new CritereLivres { Recherche = "germ" }).Select(l => l.Titre));
+
+    [Fact]
+    public void La_recherche_porte_aussi_sur_lauteur()
+        => Assert.Equal(
+            ["Germinal", "La Bête humaine"],
+            Filtrer(new CritereLivres { Recherche = "zola" }).Select(l => l.Titre));
+
+    [Theory]
+    [InlineData("HORLA")]
+    [InlineData("horla")]
+    [InlineData("  Horla  ")]
+    public void La_recherche_ignore_la_casse_et_les_espaces_autour(string terme)
+        => Assert.Single(Filtrer(new CritereLivres { Recherche = terme }));
+
+    [Fact]
+    public void Un_livre_sans_auteur_ne_fait_pas_echouer_la_recherche()
+    {
+        // Le livre 4 a Auteur = null : la clause sur l'auteur doit le traverser sans exploser.
+        var resultat = Filtrer(new CritereLivres { Recherche = "bel" });
+
+        Assert.Equal(["Bel-Ami"], resultat.Select(l => l.Titre));
+    }
+
+    [Fact]
+    public void Les_criteres_se_combinent()
+    {
+        var resultat = Filtrer(new CritereLivres
+        {
+            Recherche = "zola",
+            Format = Format.Physique,
+            Statut = Statut.Lu,
+        });
+
+        Assert.Equal(["Germinal"], resultat.Select(l => l.Titre));
+    }
+
+    [Fact]
+    public void Une_recherche_vide_equivaut_a_aucune_recherche()
+    {
+        Assert.Equal(4, Filtrer(new CritereLivres { Recherche = "   " }).Count);
+        Assert.Equal(4, Filtrer(new CritereLivres { Recherche = "" }).Count);
+    }
+
+    /// <summary>
+    /// <b>Invariant le plus important du projet.</b> La bibliothèque est commune au foyer :
+    /// une lecture ne doit JAMAIS être restreinte à ce qu'a saisi l'utilisateur courant.
+    /// Ce test échouerait au moindre filtre ajouté sur <c>AjoutePar</c>.
+    /// </summary>
+    [Fact]
+    public void La_lecture_ne_filtre_jamais_sur_AjoutePar()
+    {
+        var resultat = Filtrer(new CritereLivres());
+
+        // Les livres des trois provenances (deux comptes + un sans trace) sont tous là.
+        Assert.Contains(resultat, l => l.AjoutePar == "mathieu");
+        Assert.Contains(resultat, l => l.AjoutePar == "camille");
+        Assert.Contains(resultat, l => l.AjoutePar is null);
+        Assert.Equal(Catalogue.Length, resultat.Count);
+    }
+
+    /// <summary>
+    /// Second verrou sur le même invariant, par le type : aucun critère de consultation ne doit
+    /// permettre d'exprimer un cloisonnement par utilisateur. Si quelqu'un ajoute une propriété
+    /// « AjoutePar » à <see cref="CritereLivres"/>, ce test le lui rappelle.
+    /// </summary>
+    [Fact]
+    public void Les_criteres_nexposent_aucun_champ_dutilisateur()
+    {
+        var proprietes = typeof(CritereLivres)
+            .GetProperties()
+            .Select(p => p.Name)
+            .ToArray();
+
+        Assert.DoesNotContain(proprietes, nom => nom.Contains("Ajoute", StringComparison.OrdinalIgnoreCase));
+        Assert.DoesNotContain(proprietes, nom => nom.Contains("Utilisateur", StringComparison.OrdinalIgnoreCase));
+    }
+}
diff --git a/MaBibli.Tests/FournisseurUtilisateurTests.cs b/MaBibli.Tests/FournisseurUtilisateurTests.cs
new file mode 100644
index 0000000..203f411
--- /dev/null
+++ b/MaBibli.Tests/FournisseurUtilisateurTests.cs
@@ -0,0 +1,110 @@
+using MaBibli.Api.Services.Identite;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Options;
+
+namespace MaBibli.Tests;
+
+/// <summary>
+/// Lecture de l'identité dans les en-têtes SSOwat, et repli sur l'utilisateur simulé
+/// en développement.
+/// </summary>
+public class FournisseurUtilisateurTests
+{
+    private static FournisseurUtilisateurSsowat Construire(
+        IDictionary<string, string>? entetes = null,
+        OptionsIdentite? options = null)
+    {
+        var contexte = new DefaultHttpContext();
+        foreach (var (nom, valeur) in entetes ?? new Dictionary<string, string>())
+        {
+            contexte.Request.Headers[nom] = valeur;
+        }
+
+        var accesseur = new HttpContextAccessor { HttpContext = contexte };
+        return new FournisseurUtilisateurSsowat(accesseur, Options.Create(options ?? new OptionsIdentite()));
+    }
+
+    [Fact]
+    public void Les_entetes_ssowat_sont_lus()
+    {
+        var fournisseur = Construire(new Dictionary<string, string>
+        {
+            ["YNH_USER"] = "mathieu",
+            ["YNH_USER_EMAIL"] = "mathieu@example.org",
+            ["YNH_USER_FULLNAME"] = "Mathieu L.",
+        });
+
+        var utilisateur = fournisseur.Obtenir();
+
+        Assert.Equal("mathieu", utilisateur.Identifiant);
+        Assert.Equal("mathieu@example.org", utilisateur.Email);
+        Assert.Equal("Mathieu L.", utilisateur.NomComplet);
+        Assert.False(utilisateur.Simule);
+        Assert.Equal("Mathieu L.", utilisateur.Affichage);
+    }
+
+    [Fact]
+    public void Lentete_utilisateur_seul_suffit()
+    {
+        var utilisateur = Construire(new Dictionary<string, string> { ["YNH_USER"] = "camille" }).Obtenir();
+
+        Assert.Equal("camille", utilisateur.Identifiant);
+        Assert.Null(utilisateur.Email);
+        Assert.Equal("camille", utilisateur.Affichage);
+    }
+
+    [Fact]
+    public void Lentete_ssowat_prime_sur_lutilisateur_simule()
+    {
+        // Sur le serveur, une configuration de dev oubliée ne doit jamais masquer l'identité réelle.
+        var fournisseur = Construire(
+            new Dictionary<string, string> { ["YNH_USER"] = "camille" },
+            new OptionsIdentite { UtilisateurSimule = "dev" });
+
+        var utilisateur = fournisseur.Obtenir();
+
+        Assert.Equal("camille", utilisateur.Identifiant);
+        Assert.False(utilisateur.Simule);
+    }
+
+    [Fact]
+    public void Sans_entete_lutilisateur_simule_prend_le_relais()
+    {
+        var fournisseur = Construire(options: new OptionsIdentite
+        {
+            UtilisateurSimule = "dev",
+            EmailSimule = "dev@localhost",
+            NomCompletSimule = "Utilisateur de développement",
+        });
+
+        var utilisateur = fournisseur.Obtenir();
+
+        Assert.Equal("dev", utilisateur.Identifiant);
+        Assert.Equal("Utilisateur de développement", utilisateur.NomComplet);
+        Assert.True(utilisateur.Simule);
+    }
+
+    [Fact]
+    public void Sans_entete_ni_simulation_lidentite_reste_inconnue()
+    {
+        // On n'invente pas d'identité : mieux vaut un livre sans traçabilité qu'un faux nom.
+        var utilisateur = Construire().Obtenir();
+
+        Assert.Null(utilisateur.Identifiant);
+        Assert.False(utilisateur.Simule);
+        Assert.Equal("inconnu", utilisateur.Affichage);
+    }
+
+    [Fact]
+    public void Un_entete_vide_est_traite_comme_absent()
+    {
+        var fournisseur = Construire(
+            new Dictionary<string, string> { ["YNH_USER"] = "   " },
+            new OptionsIdentite { UtilisateurSimule = "dev" });
+
+        var utilisateur = fournisseur.Obtenir();
+
+        Assert.Equal("dev", utilisateur.Identifiant);
+        Assert.True(utilisateur.Simule);
+    }
+}
diff --git a/MaBibli.Tests/ServiceCatalogueTests.cs b/MaBibli.Tests/ServiceCatalogueTests.cs
new file mode 100644
index 0000000..0d1648a
--- /dev/null
+++ b/MaBibli.Tests/ServiceCatalogueTests.cs
@@ -0,0 +1,219 @@
+using MaBibli.Api.Data;
+using MaBibli.Api.Services.Catalogue;
+using MaBibli.Shared.Catalogue;
+using MaBibli.Shared.Dtos;
+using MaBibli.Shared.Entites;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+
+namespace MaBibli.Tests;
+
+/// <summary>
+/// CRUD du catalogue, sur une base SQLite <b>en mémoire</b> : même moteur qu'en production,
+/// aucun fichier, aucun réseau.
+/// </summary>
+public class ServiceCatalogueTests : IDisposable
+{
+    private readonly SqliteConnection _connexion;
+    private readonly MaBibliDbContext _db;
+    private readonly ServiceCatalogue _service;
+
+    public ServiceCatalogueTests()
+    {
+        // La connexion doit rester ouverte : SQLite détruit une base « :memory: » à sa fermeture.
+        _connexion = new SqliteConnection("Data Source=:memory:");
+        _connexion.Open();
+
+        var options = new DbContextOptionsBuilder<MaBibliDbContext>()
+            .UseSqlite(_connexion)
+            .Options;
+
+        _db = new MaBibliDbContext(options);
+        _db.Database.EnsureCreated();
+
+        _service = new ServiceCatalogue(_db);
+    }
+
+    private static EnregistrementLivre Saisie(
+        string titre,
+        string? auteur = null,
+        string? isbn = null,
+        Format format = Format.Physique,
+        Statut statut = Statut.ALire) => new()
+    {
+        Titre = titre,
+        Auteur = auteur,
+        Isbn = isbn,
+        Format = format,
+        Statut = statut,
+    };
+
+    [Fact]
+    public async Task Creer_enregistre_le_livre_et_trace_lauteur_de_la_saisie()
+    {
+        var resultat = await _service.CreerAsync(Saisie("Germinal", "Émile Zola"), "mathieu");
+
+        Assert.Null(resultat.Erreur);
+        var livre = resultat.Livre!;
+        Assert.True(livre.Id > 0);
+        Assert.Equal("Germinal", livre.Titre);
+        Assert.Equal("mathieu", livre.AjoutePar);
+        Assert.NotEqual(default, livre.DateAjout);
+    }
+
+    [Fact]
+    public async Task Creer_normalise_lisbn()
+    {
+        var resultat = await _service.CreerAsync(Saisie("Germinal", isbn: "978-2-253-00422-6"), "mathieu");
+
+        Assert.Equal("9782253004226", resultat.Livre!.Isbn);
+    }
+
+    [Fact]
+    public async Task Creer_refuse_un_titre_vide()
+    {
+        var resultat = await _service.CreerAsync(Saisie("   "), "mathieu");
+
+        Assert.Null(resultat.Livre);
+        Assert.NotNull(resultat.Erreur);
+    }
+
+    [Fact]
+    public async Task Creer_refuse_un_isbn_invalide_mais_accepte_labsence_disbn()
+    {
+        var invalide = await _service.CreerAsync(Saisie("Sans titre", isbn: "1234567890123"), "mathieu");
+        Assert.Null(invalide.Livre);
+        Assert.NotNull(invalide.Erreur);
+
+        // Certains livres n'ont pas d'ISBN : l'absence doit rester parfaitement légitime.
+        var sansIsbn = await _service.CreerAsync(Saisie("Carnet de famille"), "mathieu");
+        Assert.Null(sansIsbn.Erreur);
+        Assert.Null(sansIsbn.Livre!.Isbn);
+    }
+
+    [Fact]
+    public async Task Le_catalogue_est_unique_physiques_et_numeriques_cohabitent()
+    {
+        await _service.CreerAsync(Saisie("Papier", format: Format.Physique), "mathieu");
+        await _service.CreerAsync(Saisie("Epub", format: Format.Numerique), "mathieu");
+
+        var tout = await _service.ListerAsync(new CritereLivres());
+        Assert.Equal(2, tout.Count);
+
+        var numeriques = await _service.ListerAsync(new CritereLivres { Format = Format.Numerique });
+        Assert.Equal(["Epub"], numeriques.Select(l => l.Titre));
+    }
+
+    [Fact]
+    public async Task La_recherche_traverse_bien_SQLite()
+    {
+        await _service.CreerAsync(Saisie("Germinal", "Émile Zola"), "mathieu");
+        await _service.CreerAsync(Saisie("Le Horla", "Guy de Maupassant"), "mathieu");
+
+        var parAuteur = await _service.ListerAsync(new CritereLivres { Recherche = "maupassant" });
+        Assert.Equal(["Le Horla"], parAuteur.Select(l => l.Titre));
+
+        var parTitre = await _service.ListerAsync(new CritereLivres { Recherche = "GERMI" });
+        Assert.Equal(["Germinal"], parTitre.Select(l => l.Titre));
+    }
+
+    /// <summary>
+    /// <b>Invariant central</b> : la bibliothèque est commune. Des livres saisis par des comptes
+    /// différents doivent tous ressortir, quelle que soit la personne qui consulte.
+    /// </summary>
+    [Fact]
+    public async Task La_liste_renvoie_les_livres_de_tous_les_utilisateurs()
+    {
+        await _service.CreerAsync(Saisie("Livre de Mathieu"), "mathieu");
+        await _service.CreerAsync(Saisie("Livre de Camille"), "camille");
+        await _service.CreerAsync(Saisie("Livre anonyme"), null);
+
+        var tout = await _service.ListerAsync(new CritereLivres());
+
+        Assert.Equal(3, tout.Count);
+        Assert.Contains(tout, l => l.AjoutePar == "mathieu");
+        Assert.Contains(tout, l => l.AjoutePar == "camille");
+        Assert.Contains(tout, l => l.AjoutePar is null);
+    }
+
+    [Fact]
+    public async Task Modifier_ne_reecrit_ni_AjoutePar_ni_DateAjout()
+    {
+        var cree = (await _service.CreerAsync(Saisie("Titre initial", "Auteur"), "camille")).Livre!;
+
+        var modifie = await _service.ModifierAsync(cree.Id, new EnregistrementLivre
+        {
+            Titre = "Titre corrigé",
+            Auteur = "Auteur corrigé",
+            Format = Format.Numerique,
+            Statut = Statut.Lu,
+        });
+
+        Assert.Null(modifie.Erreur);
+        Assert.Equal("Titre corrigé", modifie.Livre!.Titre);
+        Assert.Equal(Format.Numerique, modifie.Livre.Format);
+
+        // La trace de la saisie d'origine survit à l'édition, y compris par quelqu'un d'autre.
+        Assert.Equal("camille", modifie.Livre.AjoutePar);
+        Assert.Equal(cree.DateAjout, modifie.Livre.DateAjout);
+    }
+
+    [Fact]
+    public async Task Modifier_un_livre_inexistant_est_signale_comme_introuvable()
+    {
+        var resultat = await _service.ModifierAsync(4242, Saisie("Fantôme"));
+
+        Assert.True(resultat.EstIntrouvable);
+    }
+
+    [Fact]
+    public async Task Changer_le_statut_ne_touche_que_le_statut()
+    {
+        var cree = (await _service.CreerAsync(Saisie("Germinal", "Émile Zola"), "mathieu")).Livre!;
+
+        var apres = await _service.ChangerStatutAsync(cree.Id, Statut.EnCours);
+
+        Assert.NotNull(apres);
+        Assert.Equal(Statut.EnCours, apres!.Statut);
+        Assert.Equal(cree.Titre, apres.Titre);
+        Assert.Equal(cree.Auteur, apres.Auteur);
+        Assert.Equal(cree.AjoutePar, apres.AjoutePar);
+    }
+
+    [Fact]
+    public async Task Changer_le_statut_dun_livre_inexistant_renvoie_null()
+        => Assert.Null(await _service.ChangerStatutAsync(4242, Statut.Lu));
+
+    [Fact]
+    public async Task Supprimer_retire_le_livre_du_catalogue()
+    {
+        var cree = (await _service.CreerAsync(Saisie("À jeter"), "mathieu")).Livre!;
+
+        Assert.True(await _service.SupprimerAsync(cree.Id));
+        Assert.Null(await _service.ObtenirAsync(cree.Id));
+        Assert.Empty(await _service.ListerAsync(new CritereLivres()));
+
+        // Seconde suppression : plus rien à supprimer.
+        Assert.False(await _service.SupprimerAsync(cree.Id));
+    }
+
+    [Fact]
+    public async Task Obtenir_renvoie_la_fiche_complete()
+    {
+        var cree = (await _service.CreerAsync(
+            Saisie("Le Horla", "Guy de Maupassant", "9782080704092"), "mathieu")).Livre!;
+
+        var relu = await _service.ObtenirAsync(cree.Id);
+
+        Assert.NotNull(relu);
+        Assert.Equal("Le Horla", relu!.Titre);
+        Assert.Equal("9782080704092", relu.Isbn);
+    }
+
+    public void Dispose()
+    {
+        _db.Dispose();
+        _connexion.Dispose();
+        GC.SuppressFinalize(this);
+    }
+}