diff --git a/CLAUDE.md b/CLAUDE.md
index c82af3f..899773b 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -45,104 +45,130 @@ Application self-hosted de gestion de bibliothèque personnelle, à héberger su
 | AOT WebAssembly | **Désactivé par défaut**, à réévaluer après mesure | Le mode interprété devrait suffire (~5-10 ms/frame estimés) ; ne pas payer le coût de build avant d'avoir constaté un problème |
 | Hébergement | YunoHost, installation **native** (pas Docker) | YunoHost déconseille Docker pour ses apps (moins fiable, plus lourd) ; installation native = meilleures perfs sur petit matériel |
 | Packaging YunoHost | S'inspirer de [`radarr_ynh`](https://github.com/YunoHost-Apps/radarr_ynh) | Radarr est aussi en .NET, packagé sans Docker sur YunoHost. Leur `manifest.toml` montre un déploiement **self-contained** (`dotnet publish -r linux-x64 --self-contained`), donc pas besoin d'installer `dotnet-runtime` via apt côté serveur — le binaire embarque son propre runtime |
-| Scan ISBN | **ZXing.Net** (C#, Apache 2.0) exécuté dans le WASM ; le JS ne fournit que les pixels caméra | Décodage en C#, réutilisable hors navigateur si le projet évolue en scanner de bibliothèque. Voir la section dédiée ci-dessous |
+| Scan ISBN | **zbar** (LGPL-2.1) compilé en WebAssembly, via les assets du paquet `ZBar.Blazor` ; notre JS garde la caméra | ZXing.Net **ne lisait pas** des codes-barres que zbar lit sur le même livre (2026-08-19). Plus léger de surcroît. Voir la section dédiée ci-dessous |
 | Consultation hors-ligne | **Instantanés JSON en IndexedDB**, lecture seule, implémenté le 2026-08-18 | Le besoin est de **consulter la bibliothèque existante** sans réseau, pas d'enrichir de nouveaux livres. Voir « Stratégie hors-ligne » |
 
-## Scan du code-barres — ZXing.Net (décision actée)
+## Scan du code-barres — zbar (décision actée le 2026-08-19)
 
-Le décodage EAN-13 se fait en **C# avec [ZXing.Net](https://www.nuget.org/packages/ZXing.Net)** (`micjahn`, Apache 2.0), et non avec une bibliothèque JS type `html5-qrcode`.
+Le décodage EAN-13 se fait par **[zbar](https://github.com/mchehab/zbar) compilé en
+WebAssembly**, appelé depuis `wwwroot/js/scanner-camera.js`. Les assets viennent du paquet
+NuGet [`ZBar.Blazor`](https://www.nuget.org/packages/ZBar.Blazor) (LGPL-2.1).
 
-### Pourquoi
+### Pourquoi ZXing.Net a été abandonné
 
-- **Réutilisable hors navigateur.** Si le projet évolue vers un scanner de bibliothèque (app native, scan en masse, décodage d'une photo côté serveur), le code de décodage se transpose tel quel. Une bibliothèque JS serait à réécrire intégralement.
-- **Un seul langage**, cohérent avec le reste de la stack.
-- L'argument « offline » n'entre **pas** en compte ici : `html5-qrcode` fonctionne aussi hors-ligne (fichier JS servi par la PWA, aucun appel réseau). Ce n'est pas un critère de départage.
+**Constat d'usage** : l'ISBN `9782846391009` n'était pas décodé par l'application, alors qu'il
+l'était par une application d'essai utilisant zbar, **sur le même livre et le même appareil**.
 
-### Mesures réelles (validées sur .NET 10, publish Blazor WASM OK)
+⚠️ **Le raisonnement qui avait écarté cette piste était faux, et la faute est instructive.**
+Ce fichier concluait que « le décodeur n'y est pour rien » à partir de mesures de **vitesse**
+(4-6 ms/frame en WASM interprété). Or **la vitesse ne dit rien du taux de réussite** : un
+décodeur peut être rapide et rater. Les mesures ne pouvaient pas soutenir cette conclusion.
 
-| Mesure | Résultat |
-|---|---|
-| Décodage EAN-13 propre (380×160) | 0,04 ms/frame |
-| **Pire cas** : frame 640×480 bruitée sans code-barres (échec) | 0,53 ms/frame |
-| Poids de l'assembly `zxing.wasm` seul | +192 Ko (brotli) |
+Ne jamais reconduire ce raccourci : pour juger un décodeur, il faut mesurer **ce qu'il lit**,
+pas ce qu'il coûte.
 
-Le pire cas est le chiffre qui gouverne le framerate : la majorité des frames caméra ne contiennent pas de code-barres lisible, et c'est l'échec de décodage qui coûte le plus cher.
+### Ce qui est établi, et ce qui ne l'est pas
 
-### Mesures en WASM réel — faites le 2026-08-18, phase scan
+**Établi** : zbar lit ce code-barres, ZXing.Net ne le lit pas, dans les mêmes conditions.
 
-L'estimation « ~5-10 ms/frame en interprété » ci-dessus n'était qu'une extrapolation. Elle a
-été **vérifiée dans un vrai navigateur** (Chromium 148, x86_64 de bureau), sur le publish
-`Release` du client, en appelant le décodeur depuis la console via `BancEssaiScan` :
+**Non établi** : que le moteur soit *seul* en cause. L'ancienne implémentation ne faisait pas que
+décoder, elle **recadrait** sur la bande centrale (45 % de la hauteur) après réduction à 640 px,
+pour limiter ce qui traversait le pont JS→C#. Ce recadrage était la seconde cause possible.
+La bascule l'a supprimé — l'image entière est désormais analysée, à 960 px de large — donc la
+question ne se pose plus.
 
-| Configuration | Pire cas 640×288 (bande visée) | Pire cas 640×480 |
+### Ce que la bascule change dans le code
+
+| | Avant (ZXing.Net) | Après (zbar) |
 |---|---|---|
-| Publish `Release`, interprété | **4,4 – 6,4 ms/frame** | 6,7 – 7,8 ms/frame |
-| Build `Debug`, interprété | 17,7 ms/frame | 28,7 ms/frame |
+| Décodage | C#, `IsbnScanner.TryDecode` | JS, `window.zbar.scanImageData` |
+| Pixels sur le pont JS→C# | **un `byte[]` par frame** | aucun — seule la valeur décodée passe |
+| Zone analysée | bande centrale, 640 px | image entière, 960 px |
+| Caméra | `scanner-camera.js` | `scanner-camera.js`, **inchangé** |
 
-**L'estimation était bonne** : le mode interprété tient largement les 10-15 fps visés (une
-frame toutes les 80 ms n'utilise que ~6 % du budget). **Aucune raison d'activer l'AOT** —
-il reste à confirmer sur un téléphone, sensiblement plus lent qu'un x86_64 de bureau.
+`IsbnScanner.cs`, `BancEssaiScan.cs` et `IsbnScannerTests.cs` ont disparu.
 
-⚠️ Ne jamais juger la fluidité sur un build `Debug` : il est **4 à 5× plus lent** que le
-`Release`, de quoi conclure à tort qu'il faut l'AOT.
+⚠️ **Coût assumé : six tests de décodage en moins.** Ils s'exécutaient en C# sur des images
+générées ; le décodeur étant maintenant en JS, ils n'ont plus d'équivalent dans xUnit. Le
+décodage a été vérifié dans le navigateur, sur un EAN-13 rendu en canvas — `9782846391009`
+ressort bien en `ZBAR_EAN13`. C'est une vérification, pas un garde-fou permanent.
 
-### ⚠️ Le surcoût de payload réel est bien supérieur à 192 Ko
+### ⚠️ On n'utilise PAS le composant `ZBarCamera` du paquet — et il ne faut pas y revenir
 
-Mesuré par différence entre deux publish `Release` complets (somme brotli de `_framework`) :
-**+351 Ko** au total, dont ~4,7 Ko de code applicatif. Le coût imputable à ZXing.Net est donc
-d'environ **+346 Ko brotli**, soit **1,8× le poids de son propre assembly**. Le surplus vient
-des assemblies BCL que le trimmer ne peut plus retirer :
+Son `camera.js` ouvre la caméra lui-même et **avale les erreurs** :
 
-| Assembly | Delta brotli |
-|---|---|
-| `zxing.wasm` | +192 495 o |
-| `System.Text.RegularExpressions` | +91 237 o (de 7 Ko à 98 Ko : ZXing utilise Regex, tout le moteur reste) |
-| `System.Runtime.Numerics` | +30 701 o (nouveau) |
-| `System.Private.CoreLib` | +17 586 o |
-| divers (`Threading`, `Collections`, `InteropServices`…) | ~14 Ko |
-
-Ne pas reprendre « +192 Ko » comme coût du scan : c'est le poids de l'assembly, pas celui
-de la fonctionnalité.
-
-### Pièges à connaître
-
-- **Le JS interop ne disparaît pas.** `getUserMedia` et `<canvas>`/`getImageData` sont des API web sans équivalent C#. Prévoir ~30 lignes de JS maison dont le seul rôle est de pousser un `byte[]` vers C#. Toute la logique de décodage reste en C#.
-- **Ne pas perdre de temps à essayer de réduire la taille via un reader ciblé.** Remplacer `MultiFormatReader` par `EAN13Reader` pour aider le trimmer **ne change rien** : mesuré à 192 495 octets à l'octet près dans les deux cas. ZXing.Net n'est pas trim-friendly.
-- `RGBLuminanceSource` accepte directement le buffer RGBA du canvas (`BitmapFormat.RGBA32`) — **aucune bibliothèque d'image nécessaire** (pas de SkiaSharp ni ImageSharp).
-- Le scan caméra exige **HTTPS** (garanti par YunoHost en prod ; en dev, `localhost` est considéré comme sûr). Corollaire vérifié : tester le scan depuis un téléphone en pointant l'IP locale du PC (`http://192.168.x.x`) **échouera toujours** — ce n'est pas un contexte sécurisé. Le composant détecte ce cas et le dit explicitement.
-- **Une `DOMException` perd son `name` en traversant le pont JS→C#** : `getUserMedia` refusé remonte en C# sous la forme « Permission denied undefined », sans `NotAllowedError`. Or c'est ce nom qui distingue « permission refusée » de « pas de caméra » de « caméra occupée ». Le JS doit donc **attraper l'erreur et renvoyer un code de statut** ; parser le message côté C# ne marche pas.
-- **L'import du module JS se fait sur un chemin nu** (`./js/scanner-camera.js`). Il a longtemps porté une chaîne de requête `?m=1` : l'import map généré par Blazor réécrivait le chemin vers un nom empreinté que l'API hôte ne servait pas (elle utilise `UseStaticFiles`, qui ignore les points d'entrée empreintés), et l'import partait en 404. Depuis que les empreintes WASM sont désactivées (voir « Empreintes WASM désactivées »), **il n'y a plus d'import map du tout** et le contournement a été retiré. Vérifié en développement et sur le publish self-contained : le module se charge dans les deux cas.
-
-### Squelette validé
-
-```csharp
-using ZXing;
-using ZXing.Common;
-
-public static class IsbnScanner
-{
-    static readonly MultiFormatReader Reader = new()
-    {
-        Hints = new Dictionary<DecodeHintType, object>
-        {
-            [DecodeHintType.POSSIBLE_FORMATS] = new List<BarcodeFormat>
-            {
-                BarcodeFormat.EAN_13, BarcodeFormat.EAN_8,
-            },
-            [DecodeHintType.TRY_HARDER] = true,
-        },
-    };
-
-    /// rgba : buffer brut issu de ctx.getImageData(...).data
-    public static string? TryDecode(byte[] rgba, int width, int height)
-    {
-        var source = new RGBLuminanceSource(
-            rgba, width, height, RGBLuminanceSource.BitmapFormat.RGBA32);
-        return Reader.decode(new BinaryBitmap(new HybridBinarizer(source)))?.Text;
-    }
-}
+```js
+navigator.mediaDevices.getUserMedia(constraints).then(...).catch(function (error) {
+    console.log(error);   // et c'est tout
+});
 ```
 
+On perdrait d'un coup :
+
+- les messages qui distinguent **permission refusée**, **aucune caméra**, **caméra occupée** et
+  **contexte non sécurisé** — ce que ce fichier documente comme durement acquis (une
+  `DOMException` perd son `name` en traversant le pont, d'où les codes de statut) ;
+- `facingMode: { ideal: 'environment' }`, donc la **caméra arrière** sur téléphone : le composant
+  demande `{ video: true }`, c'est-à-dire la caméra frontale par défaut ;
+- l'indication de résolution `1280×720`.
+
+Le paquet est donc référencé **pour ses assets statiques seulement** (`zbar.js`, `zbar.wasm`).
+Vérifié après bascule : caméra refusée → « L'accès à la caméra a été refusé… », message intact.
+
+### `zbar.wasm` est chargé à la demande, pas au démarrage
+
+`scanner-camera.js` injecte `_content/ZBar.Blazor/zbar.js` **à la première ouverture du
+scanner**. Personne ne télécharge 139 Ko pour consulter sa bibliothèque.
+
+⚠️ `zbar.js` **n'est pas un module ES** : il pose `window.zbar`. D'où l'injection d'une balise
+`<script>` plutôt qu'un `import()`.
+
+### Poids : mesuré par comparaison de deux publish complets
+
+Somme brotli, `MaBibli.Api` publié en `Release`, avant et après :
+
+| | ZXing.Net | zbar |
+|---|---|---|
+| `_framework` (téléchargé au démarrage) | 3 281 558 o | **2 978 700 o** |
+| `_content` (à la demande) | 0 | 146 841 o |
+| **Total** | 3 281 558 o | **3 125 541 o** |
+
+**−152 Kio au total, et −296 Kio au démarrage.** L'écart ne vient pas du moteur mais de la
+**traîne** que ZXing.Net imposait au trimmer :
+
+| Assembly | ZXing.Net | zbar |
+|---|---|---|
+| `zxing.wasm` | 192 495 o | absent |
+| `System.Text.RegularExpressions` | 98 374 o | **7 137 o** |
+| `System.Runtime.Numerics` | 30 701 o | absent |
+| `ZBar.Blazor` (assembly .NET, inutilisé mais embarqué) | absent | 21 232 o |
+
+`System.Text.RegularExpressions` retombe à sa taille trimmée parce que plus rien n'utilise
+`Regex` : c'est ZXing qui l'imposait. ⚠️ L'assembly `ZBar.Blazor` est embarqué bien qu'aucun de
+ses types ne soit utilisé — 21 Ko dont on se passerait, mais le paquet reste la manière propre
+d'obtenir `zbar.wasm` et sa licence.
+
+**Leçon confirmée, dans les deux sens** : le coût d'une bibliothèque n'est pas le poids de son
+assembly. Toujours comparer deux publish.
+
+### Ce qui reste vrai de l'ancienne section
+
+- Le scan caméra exige **HTTPS** (garanti par YunoHost ; `localhost` est considéré comme sûr).
+  Tester depuis un téléphone en pointant l'IP locale du PC (`http://192.168.x.x`) **échouera
+  toujours** — ce n'est pas un contexte sécurisé, et le composant le dit.
+- **Une `DOMException` perd son `name` en traversant le pont JS→C#.** Le JS doit renvoyer un
+  code de statut ; parser le message côté C# ne marche pas.
+- **L'import du module se fait sur un chemin nu** (`./js/scanner-camera.js`), les empreintes WASM
+  étant désactivées (voir « Empreintes WASM désactivées »).
+
+### Ce que zbar apporte en plus
+
+- Il remonte le **format** du symbole (`ZBAR_EAN13`, `ZBAR_ISBN13`, `ZBAR_EAN5`…), là où nous
+  déduisons le type du préfixe.
+- Il décode les **add-ons EAN-2 (numéro de parution) et EAN-5 (prix)** imprimés à côté du code
+  principal. ⚠️ `decoder()` les **écarte** : ce ne sont pas le code du livre. L'EAN-2 deviendra
+  utile le jour où les périodiques seront catalogués.
+
 ## Saisie d'un code-barres — décisions actées le 2026-08-18 (2ᵉ série)
 
 ### La douchette USB est le vrai remède au scan raté sur PC
diff --git a/IDEES.md b/IDEES.md
index 46c430f..5b0060d 100644
--- a/IDEES.md
+++ b/IDEES.md
@@ -59,101 +59,22 @@ ce qui suit est la matière brute, classée par sujet, avec ce que le diagnostic
 
 ### Le scan caméra rate souvent sur ordinateur
 
-**La douchette USB est faite** (voir `CLAUDE.md`, « La douchette USB est le vrai remède ») :
-champ focalisé à l'ouverture, validation sur `Entrée`. Reste à confirmer en usage réel qu'elle
-suffit.
+**Deux remèdes appliqués**, tous deux dans `CLAUDE.md` : la **douchette USB** (champ focalisé,
+validation sur `Entrée`) et surtout la **bascule de ZXing.Net vers zbar** — c'était bien le
+décodeur, contrairement à ce qu'on avait conclu de mesures de vitesse.
 
-Si elle ne suffit pas, pistes non traitées : choisir la caméra quand il y en a plusieurs,
-demander une résolution plus haute, exposer un curseur de zoom/torche là où l'API le permet,
-et laisser **déposer une photo** du code-barres à décoder (ZXing lit un fichier aussi bien
-qu'une frame).
+Reste à confirmer en usage réel. Si cela ne suffisait toujours pas : choisir la caméra quand il
+y en a plusieurs, exposer un curseur de zoom/torche là où l'API le permet, et laisser **déposer
+une photo** du code-barres à décoder.
 
-### ISBN `9782846391009` : le scan n'aboutit pas
+### ISBN `9782846391009` : résolu — c'était le décodeur
 
-**La donnée existe pourtant côté BnF** — vérifié le 2026-08-18 :
+Le livre existe bien à la BnF : l'échec était **au décodage de l'image**. Confirmé le
+2026-08-19 — zbar lit ce code-barres, ZXing.Net ne le lisait pas, sur le même appareil et le
+même livre. La bascule est faite (voir `CLAUDE.md`).
 
-```
-bib.isbn all "9782846391009"  → 1 notice
-  dc:title   = La thérapie émotivo-rationnelle / Albert Ellis et Robert A. Harper
-  dc:creator = Ellis, Albert (1913-2007). Auteur du texte
-  dc:creator = Harper, Robert A. (1915-2004). Auteur du texte
-(la forme ISBN-10 « 2846391009 » ne renvoie rien : ici c'est bien l'ISBN-13 qui indexe)
-```
-
-L'échec est donc **au décodage de l'image**, pas au lookup. Rejoint le point ci-dessus.
-⚠️ À reproduire en saisissant l'ISBN à la main avant de conclure : si la saisie manuelle échoue
-aussi, le défaut est ailleurs et ce diagnostic tombe.
-
-## Choix de la bibliothèque de lecture de code-barres — à trancher
-
-**Constat qui rouvre le sujet, 2026-08-19.** L'ISBN `9782846391009` n'est pas décodé par
-l'application, alors qu'il l'est par une application d'essai (`~/Code/TestBarcode`) sur le
-**même appareil et le même livre**, avec **ZBar**.
-
-⚠️ **Le raisonnement qui écartait ce sujet était faux.** `CLAUDE.md` conclut que « le décodeur
-n'y est pour rien » à partir de mesures de **vitesse** (4-6 ms/frame en WASM interprété). Or la
-vitesse ne dit **rien du taux de réussite** : un décodeur peut être rapide et rater. Les mesures
-existantes ne pouvaient donc pas soutenir cette conclusion, et l'essai la contredit.
-
-### Ce que l'essai établit, et ce qu'il n'établit pas
-
-**Établi** : ZBar lit ce code-barres, ZXing.Net (portage C#) ne le lit pas, dans les mêmes
-conditions physiques.
-
-**Non établi** : que le moteur soit seul en cause. Notre implémentation ne fait pas que décoder,
-elle **prétraite** — réduction à 640 px de large, puis **recadrage sur la bande centrale**
-(`PartHauteur = 0,45`). ZBar, lui, analyse l'image entière. Deux causes candidates cohabitent
-donc, et l'essai ne les sépare pas :
-
-1. le moteur (ZXing.Net est un portage d'une version ancienne de ZXing, réputé moins robuste que
-   `zbar` ou que `zxing-js`) ;
-2. notre prétraitement (bande trop étroite, ou résolution insuffisante pour la largeur de module
-   à la distance de prise de vue).
-
-Adopter ZBar rendrait la seconde question sans objet : le composant gère lui-même la caméra et
-l'image.
-
-### Le poids : mesuré, et à l'inverse de ce qu'on croyait
-
-Somme brotli réelle du publish `Release` de l'application d'essai :
-
-| Fichier | brotli |
-|---|---|
-| `zbar.wasm` (moteur C compilé) | 138 938 o |
-| `ZBar.Blazor.<empreinte>.wasm` (assembly .NET) | 21 232 o |
-| `zbar.js` | 5 247 o |
-| `camera.js` + `image.js` + `scanner.js` | 2 457 o |
-| CSS isolé | 199 o |
-| **Total ZBar** | **≈ 168 Ko** |
-
-À comparer au coût de ZXing.Net **déjà documenté dans `CLAUDE.md`** : **≈ 346 Ko brotli**, dont
-seulement 192 Ko d'assembly — le reste étant les assemblies BCL que le trimmer ne peut plus
-retirer (`System.Text.RegularExpressions` passant de 7 à 98 Ko parce que ZXing utilise Regex,
-plus `System.Runtime.Numerics`).
-
-Vérifié dans le publish d'essai : `System.Text.RegularExpressions` y pèse **7 137 o**, et
-`System.Runtime.Numerics` est **absent**. ZBar ne traîne pas cette queue.
-
-**Le remplacement allégerait donc l'application d'environ 180 Ko brotli**, au lieu de l'alourdir.
-⚠️ Chiffre à confirmer par une comparaison de deux publish de *notre* application, comme l'a été
-celui de ZXing.Net : le coût d'une bibliothèque n'est pas le poids de son assembly.
-
-### Ce qu'on perdrait
-
-- **Le décodage quitte le C#.** C'est l'argument qui avait fait retenir ZXing.Net : « réutilisable
-  hors navigateur si le projet évolue en scanner de bibliothèque ». Cet usage est **hypothétique
-  et n'a jamais été exercé** ; il se paie aujourd'hui en codes-barres non lus.
-- **`IsbnScanner`, `BancEssaiScan`, `ScannerCodeBarres` et `wwwroot/js/scanner-camera.js`**
-  disparaîtraient au profit du composant `ZBarCamera`.
-- **Une dépendance jeune** : `ZBar.Blazor` 1.1.0. À regarder avant de s'engager (maintenance,
-  licence, taille de la communauté).
-
-### Ce qu'on gagnerait, au-delà du code lu
-
-- **Le format est remonté** (`ISBN_13` vs `EAN_13`), là où nous le déduisons du préfixe.
-- **Les add-ons EAN-5 (prix) et EAN-2 (numéro) sont décodés** et rattachables au code principal —
-  l'EAN-2 est précisément ce qui accompagne les périodiques en `977`.
-- **Plus de pipeline image maison** à entretenir (capture, réduction, recadrage, `RGBLuminanceSource`).
+⚠️ **À confirmer avec le livre en main** : la vérification faite jusqu'ici porte sur un EAN-13
+rendu en canvas, pas sur une image de caméra.
 
 ---
 
@@ -181,28 +102,23 @@ quand même ? »), plutôt que l'index unique qui interdirait le second exemplai
 d'envies, elle, refuse — mais elle décrit une envie, pas un objet, et deux exemplaires d'une
 envie n'ont pas de sens.
 
-## À l'ajout d'un livre, retirer l'envie correspondante
+## À l'ajout d'un livre, signaler l'envie correspondante
 
-Demandé : si le livre ajouté figure dans la liste d'envies, l'en retirer.
+**Décidé le 2026-08-19 : on ne supprime rien, on signale.** La liste d'envies marque l'entrée
+« déjà au catalogue ».
 
-⚠️ **La difficulté est la portée, pas le rapprochement.** Le catalogue est **commun**, la liste
-d'envies est **personnelle** — ce sont les deux portées que `CLAUDE.md` oppose explicitement.
-« Retirer l'envie » n'a donc pas une seule réponse :
+Pourquoi pas la suppression, qui était la demande initiale :
 
-- **la sienne uniquement** : simple, sûr, ne franchit aucune frontière. Mais si Camille souhaitait
-  le livre et que Mathieu l'ajoute, Camille garde une envie pour un livre que le foyer possède.
-- **celle de tout le monde** : cohérent avec « le livre est commun », mais **modifie
-  silencieusement la liste d'un autre**, et lui fait perdre sa note (« demandé à Noël »). L'API
-  ne sait pas — délibérément — écrire dans la liste d'autrui : ce serait une brèche à ouvrir
-  dans un invariant tenu jusqu'ici.
-- **ne rien supprimer, mais signaler** : la liste d'envies marque l'entrée « déjà au catalogue ».
-  Non destructif, respecte la frontière, et l'écran de bibliographie sait déjà distinguer
-  `Possede` de `Souhaite`.
+- le catalogue est **commun**, la liste d'envies **personnelle**. Supprimer l'envie d'un autre
+  modifierait sa liste en silence et lui ferait perdre sa note (« demandé à Noël ») ; l'API ne
+  sait pas — délibérément — écrire dans la liste d'autrui, et l'ouvrir serait une brèche dans un
+  invariant tenu partout ailleurs ;
+- le rapprochement se fait par `CleOeuvre` + auteur, donc **faillible** (titre retraduit, tome,
+  intégrale — voir `CLAUDE.md`). Une suppression fondée sur un rapprochement faux est
+  irréversible ; un signalement se corrige d'un coup d'œil.
 
-⚠️ Le rapprochement se ferait par `CleOeuvre` + auteur, avec les mêmes limites que la
-bibliographie (titre retraduit, tome, intégrale — voir `CLAUDE.md`). Une suppression sur un
-rapprochement faillible est **irréversible** ; un signalement ne l'est pas. C'est un argument de
-poids pour la troisième voie.
+Reste à implémenter : le marquage dans `SouhaitDto`, calculé comme l'est déjà `Possede` dans la
+bibliographie, et son rendu sur l'écran des envies.
 
 ## Bandes dessinées et magazines
 
@@ -222,24 +138,57 @@ rien.
 Champs propres à la BD (série, tome, scénariste/dessinateur) : à ne faire que si le besoin se
 confirme. Le modèle actuel met tous les auteurs dans `LivreAuteur` sans distinguer les rôles.
 
-### Les magazines : cela rouvre une décision actée
+### Les magazines : une fiche par revue, les numéros à l'intérieur
 
-⚠️ `CLAUDE.md` (lot 1) écarte **délibérément** le catalogage des périodiques : « le modèle de
-données n'a ni numéro ni date de parution, et les deux chiffres de parution du code ne sont pas
-exploitables comme numéro fiable — douze numéros d'un même magazine partagent leur ISSN et
-créeraient douze fiches identiques ». Le scan d'un code `977` nomme donc la revue et bascule sur
-la saisie manuelle, **sans** l'ISBN.
+⚠️ Rouvre la décision du lot 1, qui écartait le catalogage des périodiques faute de modèle.
+Le modèle est maintenant choisi.
 
-Les supporter vraiment demande de lever exactement ce qui avait motivé le refus :
+**Décidé le 2026-08-19 : une fiche par REVUE**, et dans sa page, la sélection d'un numéro
+précis. C'est exactement ce qui évite le défaut redouté — douze numéros d'un même magazine ne
+font plus douze fiches identiques, puisqu'ils partagent la fiche de leur revue.
 
-- un **ISSN** distinct de l'ISBN (le ranger dans `Livre.Isbn` casserait tout lookup ultérieur) ;
-- un **numéro** et une **date de parution**, seuls capables de distinguer deux exemplaires ;
-- de décider si un magazine est **une fiche par numéro** ou **une fiche par revue avec des
-  numéros rattachés** — c'est le vrai choix de modélisation, et il change la migration ;
-- de reprendre le flux `977` pour qu'il crée au lieu d'expliquer.
+Ce que cela demande :
 
-À trancher avant tout code. Le reste (filtres, prêts, hors-ligne) suit mécaniquement une fois le
-modèle arrêté.
+- un **ISSN** sur la fiche de revue, distinct de l'ISBN. ⚠️ Ranger un code `977` dans
+  `Livre.Isbn` casserait tout lookup ultérieur sur cette fiche ;
+- une table de **numéros** rattachés à la revue, portant au minimum un numéro et une date de
+  parution ;
+- reprendre le flux `977` : il nomme aujourd'hui la revue et bascule sur la saisie manuelle, il
+  devra créer ou compléter la fiche puis proposer d'ajouter le numéro scanné. ⚠️ Les deux
+  chiffres de parution du code-barres **ne sont pas un numéro fiable** ; l'add-on **EAN-2**, que
+  zbar sait maintenant décoder, est le bon candidat — à vérifier sur des magazines réels ;
+- décider ce qu'un **prêt** signifie pour une revue : on prête un numéro, pas un abonnement.
+
+## Sagas et cycles : plusieurs livres, un ordre de lecture
+
+Demandé le 2026-08-19. Cas donné : [Drizzt Do'Urden](https://fr.wikipedia.org/wiki/Drizzt_Do%27Urden)
+— **plusieurs regroupements de plusieurs livres, à lire dans un ordre précis**. Vaut pour les
+romans comme pour les BD.
+
+C'est la première demande du projet qui porte sur une **relation entre livres** plutôt que sur
+un livre. Ce que le cas Drizzt impose, et qu'un simple champ « série » ne couvrirait pas :
+
+- **Deux niveaux.** *La Légende de Drizzt* regroupe plusieurs trilogies (*L'Elfe noir*,
+  *La Séquence de l'Icewind Dale*…) : un cycle contient des séries, qui contiennent des tomes.
+  Un champ texte plat perdrait ce regroupement.
+- **L'ordre de lecture n'est pas l'ordre de publication.** *L'Elfe noir* est une préquelle écrite
+  après. C'est précisément l'information qu'on vient chercher : elle doit être **stockée**, pas
+  déduite de l'année.
+- **Un livre peut appartenir à plusieurs regroupements** (une intégrale, une série, un cycle).
+- **Ce qu'on possède est partiel.** L'intérêt de l'écran est de montrer les trous — « il vous
+  manque le tome 3 » — comme la bibliographie montre déjà ce qui manque d'un auteur.
+
+Questions à trancher avant tout modèle :
+
+- **D'où viennent les séries ?** La BnF ne les expose pas de façon exploitable en Dublin Core.
+  Saisie à la main, déduction depuis le titre (« Tome 3 »), ou source tierce ?
+- **Portée** : commune au foyer, comme le catalogue, ou personnelle ? L'ordre de lecture est une
+  propriété de l'œuvre et non du lecteur — donc commune, a priori.
+- **Les tomes non possédés** existent-ils en base, ou sont-ils seulement affichés ? S'ils
+  existent, ils ressemblent beaucoup à des envies, et il faudra dire comment les deux cohabitent.
+
+⚠️ Ne pas confondre avec le regroupement d'œuvres de la bibliographie (`CleOeuvre`), qui réunit
+les **rééditions d'un même titre**. Ici, ce sont des titres **différents** qui se suivent.
 
 ## Auteurs et bibliographie
 
diff --git a/MaBibli.Client/Composants/ScannerCodeBarres.razor b/MaBibli.Client/Composants/ScannerCodeBarres.razor
index 1fae9bc..6c98284 100644
--- a/MaBibli.Client/Composants/ScannerCodeBarres.razor
+++ b/MaBibli.Client/Composants/ScannerCodeBarres.razor
@@ -1,15 +1,16 @@
 @*
     Scan du code-barres ISBN par la caméra.
 
-    Le JS (wwwroot/js/scanner-camera.js) ne fait QUE fournir des pixels : tout le décodage
-    est en C# via ZXing.Net (IsbnScanner), conformément à la décision actée dans CLAUDE.md.
+    Le décodage se fait dans wwwroot/js/scanner-camera.js, par zbar compilé en WebAssembly.
+    ⚠️ Il était en C# (ZXing.Net) jusqu'au 2026-08-19 : voir CLAUDE.md, ZXing.Net ne lisait pas
+    des codes-barres que zbar lit sur le même livre. Ce composant ne voit plus passer un seul
+    pixel — seulement la valeur décodée.
 
     On ne décode pas à chaque frame de la caméra : la cadence est volontairement limitée
     (voir IntervalleMs). 10-15 images/s suffisent largement pour scanner un livre tenu à la
     main, et cela ménage la batterie du téléphone.
 *@
 @using System.Diagnostics
-@using MaBibli.Client.Scan
 @using MaBibli.Shared.Isbn
 @implements IAsyncDisposable
 @inject IJSRuntime JS
@@ -44,9 +45,9 @@
 
         @if (_framesDecodees > 0)
         {
-            @* Mesure réelle en WASM interprété : CLAUDE.md ne dispose que d'une estimation
-               (~5-10 ms/frame extrapolés du JIT x64). Cette ligne donne le chiffre constaté
-               sur l'appareil de l'utilisateur, seul moyen de décider d'activer l'AOT. *@
+            @* Mesure sur l'appareil de l'utilisateur. ⚠️ Elle porte maintenant sur la capture,
+               le décodage zbar ET l'aller-retour d'interopérabilité : elle n'est pas comparable
+               aux chiffres ZXing.Net de CLAUDE.md, qui ne mesuraient que le décodage C#. *@
             <p class="message-discret scanner-mesure">
                 Décodage : @_msMoyen.ToString("0.0") ms/frame en moyenne (@_framesDecodees frames)
             </p>
@@ -76,12 +77,13 @@
     // ~12 images/s : bien assez pour scanner, et deux fois moins de travail que 25 fps.
     private const int IntervalleMs = 80;
 
-    // La frame est réduite avant transfert : un 1280×720 en RGBA pèse 3,6 Mo à traverser
-    // le pont JS→C# à chaque itération. 640 px de large suffisent à lire un EAN-13.
-    private const int LargeurMax = 640;
-
-    // Seule la bande centrale est décodée : c'est là que l'utilisateur vise.
-    private const double PartHauteur = 0.45;
+    // L'image est réduite avant décodage. Elle ne traverse plus le pont JS→C# — c'est zbar,
+    // côté JS, qui la lit — mais 960 px de large restent un bon compromis entre le détail
+    // nécessaire à un EAN-13 dense et le temps de décodage.
+    //
+    // ⚠️ Plus large qu'avec ZXing.Net (640 px), et surtout l'image ENTIÈRE est analysée : le
+    // recadrage sur la bande centrale n'existait que pour alléger le transfert de pixels.
+    private const int LargeurMax = 960;
 
     private ElementReference _video;
     private IJSObjectReference? _module;
@@ -165,16 +167,8 @@
                     return;
                 }
 
-                var dimensions = await _module.InvokeAsync<int[]?>("capturer", LargeurMax, PartHauteur);
-                if (dimensions is null)
-                {
-                    continue;  // vidéo pas encore prête
-                }
-
-                var pixels = await _module.InvokeAsync<byte[]>("pixels");
-
                 var depart = Stopwatch.GetTimestamp();
-                var code = IsbnScanner.TryDecode(pixels, dimensions[0], dimensions[1]);
+                var code = await _module.InvokeAsync<string?>("decoder", LargeurMax);
                 _totalMs += Stopwatch.GetElapsedTime(depart).TotalMilliseconds;
                 _framesDecodees++;
 
diff --git a/MaBibli.Client/MaBibli.Client.csproj b/MaBibli.Client/MaBibli.Client.csproj
index 64b7478..ce41d66 100644
--- a/MaBibli.Client/MaBibli.Client.csproj
+++ b/MaBibli.Client/MaBibli.Client.csproj
@@ -18,8 +18,20 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="10.0.8" />
     <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.DevServer" Version="10.0.8" PrivateAssets="all" />
-    <!-- Décodage EAN-13 en C# (Apache 2.0). Le JS ne fournit que les pixels de la caméra. -->
-    <PackageReference Include="ZXing.Net" Version="0.16.11" />
+    <!--
+      Décodage des codes-barres : moteur zbar (LGPL-2.1) compilé en WebAssembly.
+
+      ⚠️ Le paquet est référencé pour ses ASSETS STATIQUES (_content/ZBar.Blazor/zbar.js et
+      zbar.wasm), pas pour ses composants Blazor. Son composant ZBarCamera ouvre lui-même la
+      caméra et AVALE les erreurs (« catch { console.log(error) } ») : on perdrait les messages
+      qui distinguent permission refusée, absence de caméra, caméra occupée et contexte non
+      sécurisé — précisément ce que CLAUDE.md documente comme durement acquis. On garde donc
+      notre scanner-camera.js et on n'emprunte que le décodeur.
+
+      Remplace ZXing.Net, qui ne lisait pas certains codes-barres pourtant lus par zbar sur le
+      même livre et le même appareil (voir CLAUDE.md).
+    -->
+    <PackageReference Include="ZBar.Blazor" Version="1.1.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/MaBibli.Client/Scan/BancEssaiScan.cs b/MaBibli.Client/Scan/BancEssaiScan.cs
deleted file mode 100644
index 1ee0f0c..0000000
--- a/MaBibli.Client/Scan/BancEssaiScan.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-using System.Diagnostics;
-using Microsoft.JSInterop;
-
-namespace MaBibli.Client.Scan;
-
-/// <summary>
-/// Mesure du coût réel du décodage <b>dans le navigateur</b>.
-///
-/// CLAUDE.md ne dispose que de chiffres JIT x64 (0,53 ms/frame dans le pire cas) et d'une
-/// extrapolation non vérifiée pour le WASM interprété (~5-10 ms/frame). Ce banc d'essai
-/// donne le chiffre constaté, sur la machine de l'utilisateur, sans caméra ni code-barres.
-///
-/// On mesure volontairement le <b>pire cas</b> — une frame de bruit sans code-barres —
-/// car c'est l'échec de décodage qui coûte le plus cher, et la quasi-totalité des frames
-/// d'une caméra sont dans ce cas. C'est donc lui qui gouverne le framerate atteignable.
-///
-/// Depuis la console du navigateur :
-/// <code>await DotNet.invokeMethodAsync('MaBibli.Client', 'MesurerScan', 640, 288, 20)</code>
-/// </summary>
-public static class BancEssaiScan
-{
-    [JSInvokable("MesurerScan")]
-    public static double MesurerPireCasMs(int largeur, int hauteur, int iterations)
-    {
-        var rgba = new byte[largeur * hauteur * 4];
-        new Random(1234).NextBytes(rgba);
-
-        // Un tour à blanc : la première exécution paie l'initialisation de ZXing,
-        // qui n'a rien à voir avec le coût par frame en régime établi.
-        IsbnScanner.TryDecode(rgba, largeur, hauteur);
-
-        var depart = Stopwatch.GetTimestamp();
-        for (var i = 0; i < iterations; i++)
-        {
-            IsbnScanner.TryDecode(rgba, largeur, hauteur);
-        }
-
-        return Stopwatch.GetElapsedTime(depart).TotalMilliseconds / iterations;
-    }
-}
diff --git a/MaBibli.Client/Scan/IsbnScanner.cs b/MaBibli.Client/Scan/IsbnScanner.cs
deleted file mode 100644
index bbae909..0000000
--- a/MaBibli.Client/Scan/IsbnScanner.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-using ZXing;
-using ZXing.Common;
-
-namespace MaBibli.Client.Scan;
-
-/// <summary>
-/// Décodage d'un code-barres EAN-13 / EAN-8 à partir d'un buffer de pixels RGBA.
-///
-/// Décision actée dans CLAUDE.md : le décodage reste **entièrement en C#** (ZXing.Net),
-/// le JavaScript ne sert qu'à fournir les pixels de la caméra. Cette classe ne dépend
-/// donc ni du navigateur, ni de Blazor : elle est réutilisable telle quelle hors WASM
-/// (app native, décodage d'une photo côté serveur, scan en masse).
-/// </summary>
-public static class IsbnScanner
-{
-    // ZXing.Net n'est pas thread-safe sur ce lecteur, mais le WASM est mono-thread
-    // et la boucle de scan est séquentielle : une instance partagée suffit et évite
-    // de reconstruire les hints à chaque frame.
-    private static readonly MultiFormatReader Reader = new()
-    {
-        Hints = new Dictionary<DecodeHintType, object>
-        {
-            [DecodeHintType.POSSIBLE_FORMATS] = new List<BarcodeFormat>
-            {
-                BarcodeFormat.EAN_13, BarcodeFormat.EAN_8,
-            },
-            [DecodeHintType.TRY_HARDER] = true,
-        },
-    };
-
-    /// <summary>
-    /// Tente de décoder un code-barres. Renvoie le texte brut du code, ou <c>null</c>
-    /// si la frame n'en contient aucun de lisible — cas très majoritaire en usage réel.
-    /// </summary>
-    /// <param name="rgba">Buffer brut issu de <c>ctx.getImageData(...).data</c> (4 octets par pixel).</param>
-    public static string? TryDecode(byte[] rgba, int largeur, int hauteur)
-    {
-        ArgumentNullException.ThrowIfNull(rgba);
-
-        if (largeur <= 0 || hauteur <= 0 || rgba.Length < largeur * hauteur * 4)
-        {
-            return null;
-        }
-
-        // RGBLuminanceSource consomme directement le buffer du canvas :
-        // aucune bibliothèque d'image nécessaire (ni SkiaSharp, ni ImageSharp).
-        var source = new RGBLuminanceSource(
-            rgba, largeur, hauteur, RGBLuminanceSource.BitmapFormat.RGBA32);
-
-        // La version .NET de ZXing renvoie null sur échec (pas d'exception).
-        return Reader.decode(new BinaryBitmap(new HybridBinarizer(source)))?.Text;
-    }
-}
diff --git a/MaBibli.Client/wwwroot/js/scanner-camera.js b/MaBibli.Client/wwwroot/js/scanner-camera.js
index 897c43b..f2474a2 100644
--- a/MaBibli.Client/wwwroot/js/scanner-camera.js
+++ b/MaBibli.Client/wwwroot/js/scanner-camera.js
@@ -1,12 +1,41 @@
-// Rôle unique de ce fichier : ouvrir la caméra et fournir des pixels à C#.
-// AUCUN décodage ici — il est fait par ZXing.Net côté C# (décision actée dans CLAUDE.md).
-// getUserMedia et canvas/getImageData n'ont pas d'équivalent C#, d'où ces quelques lignes.
+// Rôle de ce fichier : ouvrir la caméra ET décoder les codes-barres avec zbar.
+//
+// ⚠️ Le décodage était en C# (ZXing.Net) jusqu'au 2026-08-19. Il en est sorti parce que
+// ZXing.Net ne lisait pas des codes-barres que zbar lit, sur le même livre et le même
+// appareil (voir CLAUDE.md). Conséquence heureuse : les pixels ne traversent plus le pont
+// JS→C#, seule la valeur décodée le fait.
+//
+// On n'utilise PAS le composant ZBarCamera du paquet : il ouvre la caméra lui-même et avale
+// les erreurs, alors que les messages ci-dessous sont ce qui permet à l'utilisateur de savoir
+// ce qui lui manque. On n'emprunte au paquet que zbar.js et zbar.wasm.
 
 let flux = null;
 let video = null;
 let canvas = null;
 let ctx = null;
-let derniersPixels = null;
+let scanner = null;
+
+// Chargé à la première ouverture du scanner, pas au démarrage de l'application : zbar.wasm
+// pèse ~139 Ko brotli, que personne n'a à télécharger pour consulter sa bibliothèque.
+const CHEMIN_ZBAR = '_content/ZBar.Blazor/zbar.js';
+
+let chargementZbar = null;
+
+function chargerZbar() {
+    if (window.zbar) return Promise.resolve();
+
+    // zbar.js n'est pas un module ES : il pose window.zbar. D'où l'injection de balise
+    // plutôt qu'un import().
+    chargementZbar ??= new Promise((resolve, reject) => {
+        const balise = document.createElement('script');
+        balise.src = CHEMIN_ZBAR;
+        balise.onload = resolve;
+        balise.onerror = () => reject(new Error('zbar.js introuvable'));
+        document.head.appendChild(balise);
+    });
+
+    return chargementZbar;
+}
 
 // getUserMedia exige un contexte sécurisé : HTTPS, ou localhost.
 // Une IP de réseau local (192.168.x.x) en http NE l'est PAS — piège classique en dev.
@@ -44,6 +73,14 @@ export async function demarrer(element) {
                 return 'erreur:' + (e.name || 'Error') + ' — ' + (e.message || '');
         }
     }
+
+    try {
+        await chargerZbar();
+        scanner = await window.zbar.ZBarScanner.create();
+    } catch (e) {
+        return 'erreur:Decodeur — ' + (e.message || 'zbar indisponible');
+    }
+
     video.srcObject = flux;
     video.setAttribute('playsinline', '');
     await video.play();
@@ -52,25 +89,32 @@ export async function demarrer(element) {
     return 'ok';
 }
 
-// Capture une frame et la garde en mémoire. Renvoie [largeur, hauteur], ou null si
-// la vidéo n'est pas encore prête. Les pixels se récupèrent ensuite via pixels().
-export function capturer(largeurMax, partHauteur) {
-    if (!video || !ctx || video.readyState < 2 || !video.videoWidth) return null;
+// Capture une image et la décode. Renvoie le premier code lu, ou null.
+//
+// ⚠️ L'image ENTIÈRE est analysée, contrairement à la version ZXing.Net qui n'envoyait que la
+// bande centrale (45 % de la hauteur) pour limiter ce qui traversait le pont. Ce recadrage était
+// l'une des deux causes possibles des codes non lus ; le décodage étant maintenant côté JS, il
+// n'a plus de raison d'être.
+export async function decoder(largeurMax) {
+    if (!video || !ctx || !scanner || video.readyState < 2 || !video.videoWidth) return null;
+
     const echelle = Math.min(1, largeurMax / video.videoWidth);
     const l = Math.round(video.videoWidth * echelle);
     const h = Math.round(video.videoHeight * echelle);
     if (canvas.width !== l || canvas.height !== h) { canvas.width = l; canvas.height = h; }
     ctx.drawImage(video, 0, 0, l, h);
-    // On ne renvoie que la bande centrale, celle que l'utilisateur vise : moins de pixels
-    // à transférer et à décoder, donc moins de travail par frame côté C#.
-    const hb = Math.max(1, Math.round(h * partHauteur));
-    const y = Math.round((h - hb) / 2);
-    derniersPixels = new Uint8Array(ctx.getImageData(0, y, l, hb).data.buffer);
-    return [l, hb];
-}
 
-export function pixels() {
-    return derniersPixels;
+    const symboles = await window.zbar.scanImageData(ctx.getImageData(0, 0, l, h), scanner);
+    if (!symboles || symboles.length === 0) return null;
+
+    // Les add-ons EAN-2 (numéro de parution) et EAN-5 (prix) sont imprimés à côté du code
+    // principal et remontent comme des symboles distincts : ils ne sont pas ce qu'on cherche.
+    const principal = symboles.find(s => {
+        const type = window.zbar.ZBarSymbolType[s.type];
+        return type !== 'ZBAR_EAN2' && type !== 'ZBAR_EAN5';
+    });
+
+    return principal ? principal.decode() : null;
 }
 
 // Libérer la caméra : sinon le voyant reste allumé et la batterie se vide,
@@ -78,5 +122,6 @@ export function pixels() {
 export function arreter() {
     if (flux) { flux.getTracks().forEach(t => t.stop()); flux = null; }
     if (video) { video.srcObject = null; video = null; }
-    canvas = null; ctx = null; derniersPixels = null;
+    if (scanner) { scanner.destroy(); scanner = null; }
+    canvas = null; ctx = null;
 }
diff --git a/MaBibli.Tests/IsbnScannerTests.cs b/MaBibli.Tests/IsbnScannerTests.cs
deleted file mode 100644
index 1b824f1..0000000
--- a/MaBibli.Tests/IsbnScannerTests.cs
+++ /dev/null
@@ -1,102 +0,0 @@
-using MaBibli.Client.Scan;
-using ZXing.Common;
-using ZXing.OneD;
-
-namespace MaBibli.Tests;
-
-/// <summary>
-/// Tests du décodage pur (aucune caméra, aucun navigateur) : on encode un EAN-13 avec
-/// ZXing, on le convertit en buffer RGBA comme le ferait <c>getImageData</c>, et on
-/// vérifie le trajet aller-retour. Aucune image externe n'est nécessaire.
-/// </summary>
-public class IsbnScannerTests
-{
-    // Les ISBN de vérification du projet (voir CLAUDE.md).
-    [Theory]
-    [InlineData("9782070612758")]  // Le Petit Prince
-    [InlineData("9782253004226")]  // Germinal
-    [InlineData("9782080704092")]  // Le Horla
-    [InlineData("9780262033848")]  // Introduction to Algorithms
-    public void Decode_un_EAN13_genere(string isbn)
-    {
-        var (rgba, largeur, hauteur) = ImageEan13(isbn);
-
-        Assert.Equal(isbn, IsbnScanner.TryDecode(rgba, largeur, hauteur));
-    }
-
-    [Fact]
-    public void Decode_aussi_un_EAN8()
-    {
-        // Pas un ISBN, mais le format est dans les hints : le décodeur doit le lire,
-        // c'est la couche appelante qui écarte les codes non-ISBN.
-        var matrice = new EAN8Writer().encode("96385074", ZXing.BarcodeFormat.EAN_8, 260, 160);
-        var (rgba, largeur, hauteur) = VersRgba(matrice);
-
-        Assert.Equal("96385074", IsbnScanner.TryDecode(rgba, largeur, hauteur));
-    }
-
-    [Fact]
-    public void Renvoie_null_sur_une_frame_sans_code_barres()
-    {
-        // Cas très majoritaire en usage réel : la caméra filme autre chose.
-        // ZXing doit rendre null, jamais lever d'exception.
-        const int largeur = 640, hauteur = 480;
-        var rgba = new byte[largeur * hauteur * 4];
-        var alea = new Random(1234);
-        alea.NextBytes(rgba);
-
-        Assert.Null(IsbnScanner.TryDecode(rgba, largeur, hauteur));
-    }
-
-    [Fact]
-    public void Renvoie_null_sur_une_image_uniforme()
-    {
-        var rgba = new byte[320 * 200 * 4];
-        Array.Fill(rgba, (byte)255);
-
-        Assert.Null(IsbnScanner.TryDecode(rgba, 320, 200));
-    }
-
-    [Theory]
-    [InlineData(0, 100)]
-    [InlineData(100, 0)]
-    [InlineData(-5, 100)]
-    public void Renvoie_null_sur_des_dimensions_absurdes(int largeur, int hauteur)
-        => Assert.Null(IsbnScanner.TryDecode(new byte[4000], largeur, hauteur));
-
-    [Fact]
-    public void Renvoie_null_si_le_buffer_est_trop_court()
-    {
-        // Une frame tronquée ne doit pas faire tomber la boucle de scan.
-        Assert.Null(IsbnScanner.TryDecode(new byte[100], 640, 480));
-    }
-
-    private static (byte[] Rgba, int Largeur, int Hauteur) ImageEan13(string isbn)
-        => VersRgba(new EAN13Writer().encode(isbn, ZXing.BarcodeFormat.EAN_13, 380, 160));
-
-    /// <summary>
-    /// Convertit une BitMatrix en buffer RGBA, exactement la forme que le canvas
-    /// du navigateur fournit à C# (4 octets par pixel, opaque).
-    /// </summary>
-    private static (byte[] Rgba, int Largeur, int Hauteur) VersRgba(BitMatrix matrice)
-    {
-        var largeur = matrice.Width;
-        var hauteur = matrice.Height;
-        var rgba = new byte[largeur * hauteur * 4];
-
-        for (var y = 0; y < hauteur; y++)
-        {
-            for (var x = 0; x < largeur; x++)
-            {
-                var valeur = matrice[x, y] ? (byte)0 : (byte)255;
-                var i = ((y * largeur) + x) * 4;
-                rgba[i] = valeur;
-                rgba[i + 1] = valeur;
-                rgba[i + 2] = valeur;
-                rgba[i + 3] = 255;
-            }
-        }
-
-        return (rgba, largeur, hauteur);
-    }
-}