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);
+    }
+}