@@ -123,6 +123,30 @@ distributed by their own registries, not redistributed inside our binaries.
   so nothing of PipeWire's ships inside our installers beyond the compiled
   result of its headers (inline functions and struct layouts).
 
+## Fonts — Inter, Lora, Oswald, Caveat, IBM Plex Mono
+
+- **Components**: the Regular and Bold `.ttf` of each family, under
+  `resources/fonts/`.
+- **Used by**: the native compositor, which draws captions and annotations with
+  these files and nothing else (it registers them privately at start and never
+  reads the fonts installed on the machine), and the editor's font picker.
+- **License**: **SIL Open Font License 1.1** — <https://openfontlicense.org>.
+  Each family's copyright notice and licence text ship beside its files as
+  `<Family>-OFL.txt`, as the licence requires.
+- **Unmodified**: every file is redistributed exactly as upstream publishes it,
+  which is also why the Reserved Font Names "Lora" and "Plex" are kept.
+- **Upstream**:
+  - Inter — Copyright 2016 The Inter Project Authors. `extras/ttf/` of the v4.1
+    release, <https://github.com/rsms/inter/releases/tag/v4.1>.
+  - Lora 3.021 — Copyright 2011 The Lora Project Authors. `fonts/ttf/` of
+    <https://github.com/cyrealtype/Lora-Cyrillic> at `2d53b449b6`.
+  - Oswald 4.103 — Copyright 2016 The Oswald Project Authors. `fonts/ttf/` of
+    <https://github.com/googlefonts/OswaldFont> at `89795261ac`.
+  - Caveat 2.000 — Copyright 2014 The Caveat Project Authors. `fonts/ttf/` of
+    <https://github.com/googlefonts/caveat> at `59745e818e`.
+  - IBM Plex Mono 2.3 — Copyright © 2017 IBM Corp. `ofl/ibmplexmono/` of
+    <https://github.com/google/fonts> at `23e54b51dd`.
+
 ## OpenScreen native helpers
 
 `wgc-capture` (Windows Graphics Capture), the ScreenCaptureKit helper (macOS),
 
@@ -50,6 +50,7 @@ pub mod scene;
 // indépendant du choix de packaging d'ONNX Runtime.
 pub mod segmentation;
 pub mod text_anim;
+pub mod text_fonts;
 pub mod text_plate;
 pub(crate) mod timeline_walk;
 
 
@@ -0,0 +1,100 @@
+//! Les polices du texte (sous-titres et annotations) : celles que l'app embarque, et elles seules.
+//!
+//! Les trois backends cherchaient la famille demandée parmi les polices INSTALLÉES sur la
+//! machine, alors que l'app proposait des familles qu'elle n'installait nulle part. Sur une
+//! machine qui ne les avait pas, chaque choix retombait sur la même police de repli, et changer
+//! de police ne changeait rien à l'écran.
+//!
+//! 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.
+//!
+//! 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.
+
+use std::path::{Path, PathBuf};
+
+/// Posée par l'app : le dossier des polices embarquées.
+pub const FONTS_DIR_ENV: &str = "OPENSCREEN_FONTS_DIR";
+
+/// Les fichiers de police embarqués, ou aucun si l'app n'a pas indiqué leur dossier.
+pub fn embedded_font_files() -> Vec<PathBuf> {
+    std::env::var_os(FONTS_DIR_ENV)
+        .map(|dir| font_files_in(Path::new(&dir)))
+        .unwrap_or_default()
+}
+
+/// Les `.ttf` et `.otf` de `dir`, triés. Le dossier porte aussi les licences OFL, qui ne sont
+/// pas des polices. Un dossier illisible donne une liste vide : mieux vaut les polices du
+/// système que pas de texte du tout.
+pub fn font_files_in(dir: &Path) -> Vec<PathBuf> {
+    let mut files: Vec<PathBuf> = std::fs::read_dir(dir)
+        .into_iter()
+        .flatten()
+        .flatten()
+        .map(|entry| entry.path())
+        .filter(|path| {
+            let ext = path.extension().and_then(|ext| ext.to_str()).unwrap_or_default();
+            ext.eq_ignore_ascii_case("ttf") || ext.eq_ignore_ascii_case("otf")
+        })
+        .collect();
+    files.sort();
+    files
+}
+
+/// `public/fonts` du dépôt, pour les tests des trois backends.
+#[cfg(test)]
+pub(crate) fn repo_fonts_dir() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR")).join("../../public/fonts")
+}
+
+/// Les familles embarquées, telles que l'app les stocke. Miroir de `TEXT_FONT_FAMILIES`
+/// (`src/lib/textFonts.ts`), dont le test vérifie que chaque fichier porte bien ce nom.
+#[cfg(test)]
+pub(crate) const SHIPPED_FAMILIES: [&str; 5] =
+    ["Inter", "Lora", "Oswald", "Caveat", "IBM Plex Mono"];
+
+/// Chaque famille se voit : deux familles se confondent quand elles dessinent le même bloc,
+/// même largeur ET même hauteur à 2 % près, et un repli commun les confondrait toutes. La
+/// largeur seule ne suffit pas : Inter et Lora ne diffèrent que d'1 % sur « Hamburgefonstiv ».
+#[cfg(test)]
+pub(crate) fn assert_distinct_blocks(blocks: &[(&str, f32, f32)]) {
+    let close = |a: f32, b: f32| (a - b).abs() <= a.min(b) * 0.02;
+    for (i, (a, wa, ha)) in blocks.iter().enumerate() {
+        for (b, wb, hb) in &blocks[i + 1..] {
+            assert!(
+                !(close(*wa, *wb) && close(*ha, *hb)),
+                "{a} et {b} dessinent le même bloc : {blocks:?}"
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn only_the_font_files_of_the_directory_are_registered() {
+        let dir = repo_fonts_dir();
+        let files = font_files_in(&dir);
+        // Régulier et gras de chaque famille : les deux graisses qu'un contrôle peut produire.
+        assert_eq!(files.len(), SHIPPED_FAMILIES.len() * 2, "{files:?}");
+        assert!(files.iter().all(|f| f.extension().is_some_and(|e| e == "ttf")));
+        // Les licences sont bien là, et bien écartées.
+        let licences = std::fs::read_dir(&dir)
+            .unwrap()
+            .flatten()
+            .filter(|e| e.path().extension().is_some_and(|x| x == "txt"))
+            .count();
+        assert_eq!(licences, SHIPPED_FAMILIES.len());
+    }
+
+    #[test]
+    fn a_missing_directory_means_system_fonts_not_a_failure() {
+        assert!(font_files_in(Path::new("/definitely/not/a/fonts/dir")).is_empty());
+    }
+}
@@ -111,10 +111,23 @@ 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]) {
+    for path in files {
+        if let Err(e) = font_system.db_mut().load_font_file(path) {
+            eprintln!("[text] police non chargee ({e}) : {}", path.display());
+        }
+    }
+}
+
 impl TextRasterizer {
     pub fn new() -> Result<TextRasterizer> {
+        let mut font_system = FontSystem::new();
+        load_fonts(&mut font_system, &crate::text_fonts::embedded_font_files());
         Ok(TextRasterizer {
-            font_system: RefCell::new(FontSystem::new()),
+            font_system: RefCell::new(font_system),
             swash_cache: RefCell::new(SwashCache::new()),
         })
     }
@@ -436,6 +449,49 @@ mod tests {
             .collect()
     }
 
+    /// Chaque famille embarquee est celle que cosmic-text dessine, dans les deux graisses
+    /// 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);
+        for family in crate::text_fonts::SHIPPED_FAMILIES {
+            for weight in [Weight::NORMAL, Weight::BOLD] {
+                let query = Query {
+                    families: &[Family::Name(family)],
+                    weight,
+                    stretch: Stretch::Normal,
+                    style: Style::Normal,
+                };
+                let id = font_system
+                    .db()
+                    .query(&query)
+                    .unwrap_or_else(|| panic!("{family} introuvable"));
+                // Un vrai fichier de cette graisse, pas le regulier epaissi ou non.
+                assert_eq!(font_system.db().face(id).unwrap().weight, weight, "{family}");
+            }
+        }
+
+        let raster = TextRasterizer {
+            font_system: RefCell::new(font_system),
+            swash_cache: RefCell::new(SwashCache::new()),
+        };
+        let mut blocks = Vec::new();
+        for family in crate::text_fonts::SHIPPED_FAMILIES {
+            let mut s = spec("Hamburgefonstiv", "left");
+            s.font_family = family.to_owned();
+            s.font_size_px = 100.0;
+            s.box_px = [1600, 200];
+            let atlas = raster.build_atlas(&s).expect("atlas").pixels;
+            let (cols, rows) = (ink_cols(&atlas, 1600), ink_rows(&atlas, 1600, 0, 1600));
+            let (w, h) = (cols[cols.len() - 1] - cols[0] + 1, rows[rows.len() - 1] - rows[0] + 1);
+            blocks.push((family, w as f32, h as f32));
+        }
+        crate::text_fonts::assert_distinct_blocks(&blocks);
+    }
+
     #[test]
     fn the_plate_hugs_the_text_instead_of_filling_the_box() {
         // LE bug des sous-titres sous Linux. La plaque etait le quad de la boite
 
@@ -34,6 +34,7 @@
 use crate::d3d::Gpu;
 use anyhow::{anyhow, bail, Result};
 use std::ffi::c_void;
+use std::path::PathBuf;
 
 /// Spécification d'un texte à rastériser. Mêmes champs que `text_windows::TextSpec`
 /// — le moteur macOS les consomme via `cache_key` pour déterminer si une re-rastérisation
@@ -141,6 +142,8 @@ const K_CT_PARAGRAPH_STYLE_SPECIFIER_ALIGNMENT: u32 = 0;
 /// `CTFontSymbolicTraits` : italique / gras.
 const K_CT_FONT_TRAIT_ITALIC: u32 = 1 << 0;
 const K_CT_FONT_TRAIT_BOLD: u32 = 1 << 1;
+/// `kCTFontManagerScopeProcess` : la police n'existe que pour ce processus, rien n'est installé.
+const K_CT_FONT_MANAGER_SCOPE_PROCESS: u32 = 1;
 
 #[repr(C)]
 #[derive(Clone, Copy)]
@@ -174,6 +177,12 @@ extern "C" {
         str_: CFTypeRef,
         attributes: CFTypeRef,
     ) -> CFTypeRef;
+    fn CFURLCreateFromFileSystemRepresentation(
+        alloc: CFTypeRef,
+        buffer: *const u8,
+        buf_len: CFIndex,
+        is_directory: u8,
+    ) -> CFTypeRef;
     static kCFTypeDictionaryKeyCallBacks: c_void;
     static kCFTypeDictionaryValueCallBacks: c_void;
 }
@@ -231,6 +240,11 @@ extern "C" {
         frame_attributes: CFTypeRef,
     ) -> CFTypeRef;
     fn CTFrameDraw(frame: CFTypeRef, context: CFTypeRef);
+    fn CTFontManagerRegisterFontsForURL(
+        font_url: CFTypeRef,
+        scope: u32,
+        error: *mut CFTypeRef,
+    ) -> bool;
 
     static kCTFontAttributeName: CFTypeRef;
     static kCTForegroundColorAttributeName: CFTypeRef;
@@ -406,13 +420,46 @@ unsafe fn cf_string(s: &str) -> Option<CFOwned> {
     ))
 }
 
+/// Rend `files` (`crate::text_fonts`) visibles de CoreText pour CE processus seulement :
+/// `CTFontCreateWithName` les trouve ensuite par leur nom de famille, sans que rien ne soit
+/// installé sur la machine.
+///
+/// Un fichier refusé ne coûte que sa police : le texte retombe sur celles du système. Un
+/// fichier déjà enregistré est refusé aussi, et reste utilisable.
+unsafe fn register_fonts(files: &[PathBuf]) {
+    use std::os::unix::ffi::OsStrExt;
+    for path in files {
+        let bytes = path.as_os_str().as_bytes();
+        let Some(url) = CFOwned::new(CFURLCreateFromFileSystemRepresentation(
+            std::ptr::null(),
+            bytes.as_ptr(),
+            bytes.len() as CFIndex,
+            0,
+        )) else {
+            continue;
+        };
+        let registered = CTFontManagerRegisterFontsForURL(
+            url.get(),
+            K_CT_FONT_MANAGER_SCOPE_PROCESS,
+            std::ptr::null_mut(),
+        );
+        if !registered {
+            eprintln!("[text] police non enregistrée (ou déjà) : {}", path.display());
+        }
+    }
+}
+
 /// Rastériseur de texte macOS. Pas d'état persistant : CoreText et CoreGraphics sont
 /// prêts dès le link des frameworks (côté Windows, `TextRasterizer::new` alloue les
 /// factories DirectWrite/Direct2D — d'où le `Result` conservé pour la symétrie).
 pub struct TextRasterizer;
 
 impl TextRasterizer {
     pub fn new() -> Result<TextRasterizer> {
+        // Une fois par processus : l'enregistrement vaut pour tout CoreText, alors que chaque
+        // compositeur (preview, export) crée son rastériseur.
+        static REGISTER: std::sync::Once = std::sync::Once::new();
+        REGISTER.call_once(|| unsafe { register_fonts(&crate::text_fonts::embedded_font_files()) });
         Ok(TextRasterizer)
     }
 
@@ -739,6 +786,80 @@ mod tests {
         (x0, y0, x1, y1)
     }
 
+    #[link(name = "CoreText", kind = "framework")]
+    extern "C" {
+        fn CTFontCopyFamilyName(font: CFTypeRef) -> CFTypeRef;
+        fn CTFontGetSymbolicTraits(font: CFTypeRef) -> u32;
+    }
+
+    #[link(name = "CoreFoundation", kind = "framework")]
+    extern "C" {
+        fn CFStringGetCString(
+            string: CFTypeRef,
+            buffer: *mut std::ffi::c_char,
+            buffer_size: CFIndex,
+            encoding: u32,
+        ) -> u8;
+    }
+
+    /// Le nom de famille que CoreText a réellement résolu pour `font`.
+    unsafe fn family_of(font: CFTypeRef) -> String {
+        let name = CFOwned::new(CTFontCopyFamilyName(font)).expect("CTFontCopyFamilyName");
+        let mut buf = [0 as std::ffi::c_char; 256];
+        let ok = CFStringGetCString(
+            name.get(),
+            buf.as_mut_ptr(),
+            buf.len() as CFIndex,
+            K_CF_STRING_ENCODING_UTF8,
+        );
+        assert_ne!(ok, 0, "CFStringGetCString");
+        std::ffi::CStr::from_ptr(buf.as_ptr()).to_string_lossy().into_owned()
+    }
+
+    /// Chaque famille embarquée est celle que CoreText dessine. `CTFontCreateWithName` ne
+    /// renvoie jamais NULL pour un nom inconnu : il retombe en silence sur une autre police,
+    /// donc seul le nom de famille RÉSOLU dit si la bonne a été prise.
+    #[test]
+    fn every_shipped_family_draws_from_its_own_files() {
+        unsafe {
+            register_fonts(&crate::text_fonts::font_files_in(&crate::text_fonts::repo_fonts_dir()));
+            for family in crate::text_fonts::SHIPPED_FAMILIES {
+                let name = cf_string(family).unwrap();
+                let font = CFOwned::new(CTFontCreateWithName(name.get(), 40.0, std::ptr::null()))
+                    .unwrap();
+                assert_eq!(family_of(font.get()), family);
+                let traits = CTFontGetSymbolicTraits(font.get());
+                assert_eq!(traits & K_CT_FONT_TRAIT_BOLD, 0, "{family} : le régulier sort gras");
+                // Le réglage Gras prend un vrai fichier gras de la MÊME famille.
+                let bold = CFOwned::new(CTFontCreateCopyWithSymbolicTraits(
+                    font.get(),
+                    0.0,
+                    std::ptr::null(),
+                    K_CT_FONT_TRAIT_BOLD,
+                    K_CT_FONT_TRAIT_BOLD | K_CT_FONT_TRAIT_ITALIC,
+                ))
+                .unwrap_or_else(|| panic!("{family} : pas de gras"));
+                assert_eq!(family_of(bold.get()), family);
+                assert_ne!(CTFontGetSymbolicTraits(bold.get()) & K_CT_FONT_TRAIT_BOLD, 0);
+            }
+        }
+
+        // Et chaque famille se voit, à l'encre dessinée.
+        let mut blocks = Vec::new();
+        for family in crate::text_fonts::SHIPPED_FAMILIES {
+            let mut s = spec("Hamburgefonstiv");
+            s.font_family = family.into();
+            s.font_size_px = 100.0;
+            s.box_px = [1600, 200];
+            let Some((px, w, h)) = raster_bgra(&s) else {
+                return;
+            };
+            let (x0, y0, x1, y1) = ink_bounds(&px, w, h);
+            blocks.push((family, (x1 - x0 + 1) as f32, (y1 - y0 + 1) as f32));
+        }
+        crate::text_fonts::assert_distinct_blocks(&blocks);
+    }
+
     /// Le texte n'est pas retourné. Le test regarde où est l'encre plutôt que de faire
     /// confiance au sens du CTM : c'est la seule façon de distinguer « bien orienté » de
     /// « retourné », et le retournement était un vrai bug de ce fichier.