@@ -7,10 +7,10 @@
 //!
 //! Les fichiers vivent dans `public/fonts`. L'app pose `OPENSCREEN_FONTS_DIR` sur leur dossier
 //! avant de charger l'addon (`compositorViewService.ts`, même contrat que `ORT_DYLIB_PATH`), et
-//! chaque backend les enregistre pour ce processus seulement, sans rien installer : collection
-//! privée pour DirectWrite, portée processus pour CoreText, base `fontdb` pour cosmic-text.
-//! Sur macOS et Linux, une police installée qui porte le même nom peut passer devant la nôtre :
-//! c'est alors la même famille dans une autre version, jamais un repli.
+//! chaque backend les charge pour ce processus seulement, sans rien installer. Et nos fichiers
+//! gagnent toujours contre une police installée du même nom, sinon le rendu dépendrait encore
+//! de la machine : collection privée pour DirectWrite, descripteurs tirés des fichiers pour
+//! CoreText, faces homonymes du système retirées de la base `fontdb` pour cosmic-text.
 //!
 //! Sans la variable (POC, addon chargé hors de l'app), la liste est vide et le texte se dessine
 //! avec les polices du système, comme avant.
 
@@ -111,21 +111,51 @@ pub struct TextRasterizer {
     swash_cache: RefCell<SwashCache>,
 }
 
-/// Ajoute `files` (`crate::text_fonts`) a la base `fontdb` de ce rasteriseur, sans rien
-/// installer sur la machine. Un fichier illisible ne coute que sa police : le texte retombe
-/// sur celles du systeme.
-fn load_fonts(font_system: &mut FontSystem, files: &[std::path::PathBuf]) {
+/// Ajoute `files` (`crate::text_fonts`) a `db`, sans rien installer sur la machine, et
+/// retire de `db` toute autre face qui porte le nom d'une famille embarquee.
+///
+/// Le retrait est ce qui fait gagner nos fichiers. Une police installee du meme nom (Inter
+/// est courante sous Linux) passait devant la notre : `fontdb` ne documente aucune priorite
+/// entre deux faces egales, et en pratique la premiere chargee, celle du systeme, l'emportait.
+/// Le rendu dependait alors a nouveau de la machine. Sans face concurrente, il n'y a plus
+/// d'ordre dont dependre. Les autres familles du systeme restent, pour le repli des
+/// ecritures que nos polices ne couvrent pas.
+///
+/// Un fichier illisible ne coute que sa police : sa famille retombe sur celles du systeme.
+fn with_embedded_fonts(
+    mut db: cosmic_text::fontdb::Database,
+    files: &[std::path::PathBuf],
+) -> cosmic_text::fontdb::Database {
+    let before: std::collections::HashSet<_> = db.faces().map(|f| f.id).collect();
     for path in files {
-        if let Err(e) = font_system.db_mut().load_font_file(path) {
+        if let Err(e) = db.load_font_file(path) {
             eprintln!("[text] police non chargee ({e}) : {}", path.display());
         }
     }
+    let shipped: std::collections::HashSet<String> = db
+        .faces()
+        .filter(|f| !before.contains(&f.id))
+        .flat_map(|f| f.families.iter().map(|(name, _)| name.to_lowercase()))
+        .collect();
+    let shadowed: Vec<_> = db
+        .faces()
+        .filter(|f| before.contains(&f.id))
+        .filter(|f| f.families.iter().any(|(name, _)| shipped.contains(&name.to_lowercase())))
+        .map(|f| f.id)
+        .collect();
+    for id in shadowed {
+        db.remove_face(id);
+    }
+    db
 }
 
 impl TextRasterizer {
     pub fn new() -> Result<TextRasterizer> {
-        let mut font_system = FontSystem::new();
-        load_fonts(&mut font_system, &crate::text_fonts::embedded_font_files());
+        // Reconstruit le `FontSystem` sur la base modifiee, plutot que de la retoucher en
+        // place : il indexe ses faces (monospace, repli) a la construction.
+        let (locale, db) = FontSystem::new().into_locale_and_db();
+        let db = with_embedded_fonts(db, &crate::text_fonts::embedded_font_files());
+        let font_system = FontSystem::new_with_locale_and_db(locale, db);
         Ok(TextRasterizer {
             font_system: RefCell::new(font_system),
             swash_cache: RefCell::new(SwashCache::new()),
@@ -453,10 +483,29 @@ mod tests {
     /// qu'un controle peut produire, et deux familles ne se confondent jamais a l'ecran.
     #[test]
     fn every_shipped_family_draws_from_its_own_files() {
-        use cosmic_text::fontdb::{Family, Query, Stretch, Style, Weight};
-        let mut font_system = FontSystem::new();
-        let files = crate::text_fonts::font_files_in(&crate::text_fonts::repo_fonts_dir());
-        load_fonts(&mut font_system, &files);
+        use cosmic_text::fontdb::{Database, Family, Query, Source, Stretch, Style, Weight};
+        let repo = crate::text_fonts::repo_fonts_dir();
+        let files = crate::text_fonts::font_files_in(&repo);
+
+        // La collision : une police « installee » qui porte EXACTEMENT les memes familles,
+        // graisses et styles, chargee AVANT les notres comme `FontSystem::new` le fait des
+        // polices du systeme. Ce sont nos fichiers, copies ailleurs : seul le chemin distingue
+        // le gagnant.
+        let system =
+            std::env::temp_dir().join(format!("openscreen-sysfonts-{}", std::process::id()));
+        std::fs::create_dir_all(&system).unwrap();
+        let mut db = Database::new();
+        db.load_system_fonts();
+        for file in &files {
+            let copy = system.join(file.file_name().unwrap());
+            std::fs::copy(file, &copy).unwrap();
+            db.load_font_file(&copy).unwrap();
+        }
+        let db = with_embedded_fonts(db, &files);
+        let font_system = FontSystem::new_with_locale_and_db("en-US".into(), db);
+        std::fs::remove_dir_all(&system).ok();
+
+        let repo = std::fs::canonicalize(&repo).unwrap();
         for family in crate::text_fonts::SHIPPED_FAMILIES {
             for weight in [Weight::NORMAL, Weight::BOLD] {
                 let query = Query {
@@ -469,8 +518,17 @@ mod tests {
                     .db()
                     .query(&query)
                     .unwrap_or_else(|| panic!("{family} introuvable"));
+                let face = font_system.db().face(id).unwrap();
                 // Un vrai fichier de cette graisse, pas le regulier epaissi ou non.
-                assert_eq!(font_system.db().face(id).unwrap().weight, weight, "{family}");
+                assert_eq!(face.weight, weight, "{family}");
+                // Et c'est NOTRE fichier, pas la face du systeme qui porte le meme nom.
+                let path = match &face.source {
+                    Source::File(p) | Source::SharedFile(p, _) => p.clone(),
+                    Source::Binary(_) => panic!("{family} : face sans fichier"),
+                };
+                let path = std::fs::canonicalize(&path).unwrap_or(path);
+                let from = path.display();
+                assert!(path.starts_with(&repo), "{family} {weight:?} tire de {from}");
             }
         }