Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
fix(text): make the shipped fonts win over installed ones of the same name
EtienneLescot2fc19a6d1a56
diff --git a/crates/compositor/src/text_fonts.rs b/crates/compositor/src/text_fonts.rsindex 3241b6fcd..c09a8c15e 100644--- a/crates/compositor/src/text_fonts.rs+++ b/crates/compositor/src/text_fonts.rs@@ -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.diff --git a/crates/compositor/src/text_linux.rs b/crates/compositor/src/text_linux.rsindex ad96934f7..8e4c0b418 100644--- a/crates/compositor/src/text_linux.rs+++ b/crates/compositor/src/text_linux.rs@@ -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, ©).unwrap();+ db.load_font_file(©).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}");}}diff --git a/crates/compositor/src/text_macos.rs b/crates/compositor/src/text_macos.rsindex 647c66a5e..0cfd49af5 100644--- a/crates/compositor/src/text_macos.rs+++ b/crates/compositor/src/text_macos.rs@@ -142,8 +142,6 @@ 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)]@@ -183,6 +181,15 @@ extern "C" {buf_len: CFIndex,is_directory: u8,) -> CFTypeRef;+ fn CFRetain(cf: CFTypeRef) -> CFTypeRef;+ fn CFArrayGetCount(array: CFTypeRef) -> CFIndex;+ fn CFArrayGetValueAtIndex(array: CFTypeRef, index: CFIndex) -> CFTypeRef;+ fn CFStringGetCString(+ string: CFTypeRef,+ buffer: *mut std::ffi::c_char,+ buffer_size: CFIndex,+ encoding: u32,+ ) -> u8;static kCFTypeDictionaryKeyCallBacks: c_void;static kCFTypeDictionaryValueCallBacks: c_void;}@@ -240,11 +247,14 @@ extern "C" {frame_attributes: CFTypeRef,) -> CFTypeRef;fn CTFrameDraw(frame: CFTypeRef, context: CFTypeRef);- fn CTFontManagerRegisterFontsForURL(- font_url: CFTypeRef,- scope: u32,- error: *mut CFTypeRef,- ) -> bool;+ fn CTFontManagerCreateFontDescriptorsFromURL(file_url: CFTypeRef) -> CFTypeRef;+ fn CTFontCreateWithFontDescriptor(+ descriptor: CFTypeRef,+ size: CGFloat,+ matrix: *const c_void,+ ) -> CFTypeRef;+ fn CTFontCopyFamilyName(font: CFTypeRef) -> CFTypeRef;+ fn CTFontGetSymbolicTraits(font: CFTypeRef) -> u32;static kCTFontAttributeName: CFTypeRef;static kCTForegroundColorAttributeName: CFTypeRef;@@ -420,47 +430,94 @@ 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.+/// Une police embarquée : sa famille, sa graisse, et le descripteur tiré DE SON FICHIER.+struct ShippedFace {+ family: String,+ bold: bool,+ descriptor: CFOwned,+}++// SAFETY : un `CTFontDescriptor` est immuable, et CoreText le déclare utilisable depuis+// n'importe quel thread. Rien d'autre dans la structure.+unsafe impl Send for ShippedFace {}+unsafe impl Sync for ShippedFace {}++/// Le texte d'une `CFString`, ou une chaîne vide.+unsafe fn cf_string_text(string: CFTypeRef) -> String {+ let mut buf = [0 as std::ffi::c_char; 256];+ let len = buf.len() as CFIndex;+ if CFStringGetCString(string, buf.as_mut_ptr(), len, K_CF_STRING_ENCODING_UTF8) == 0 {+ return String::new();+ }+ std::ffi::CStr::from_ptr(buf.as_ptr()).to_string_lossy().into_owned()+}++/// Les faces de `files` (`crate::text_fonts`), chacune tenue par un descripteur de SON fichier.+///+/// Pas de résolution par nom, et c'est tout l'objet : une police installée qui porte le même+/// nom de famille passerait devant la nôtre (un enregistrement `CTFontManager` en double est+/// même refusé), et le rendu dépendrait à nouveau de la machine. Un descripteur tiré de l'URL+/// désigne ce fichier et aucun autre. Rien n'est enregistré ni installé.///-/// 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]) {+/// Un fichier illisible ne coûte que sa police : sa famille retombe sur `CTFontCreateWithName`.+unsafe fn load_faces(files: &[PathBuf]) -> Vec<ShippedFace> {use std::os::unix::ffi::OsStrExt;+ let mut faces = Vec::new();for path in files {let bytes = path.as_os_str().as_bytes();- let Some(url) = CFOwned::new(CFURLCreateFromFileSystemRepresentation(+ let url = CFOwned::new(CFURLCreateFromFileSystemRepresentation(std::ptr::null(),bytes.as_ptr(),bytes.len() as CFIndex,0,- )) else {+ ));+ let Some(descriptors) =+ url.and_then(|url| CFOwned::new(CTFontManagerCreateFontDescriptorsFromURL(url.get())))+ else {+ eprintln!("[text] police non chargée : {}", path.display());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());+ for i in 0..CFArrayGetCount(descriptors.get()) {+ let descriptor = CFArrayGetValueAtIndex(descriptors.get(), i);+ let Some(probe) =+ CFOwned::new(CTFontCreateWithFontDescriptor(descriptor, 12.0, std::ptr::null()))+ else {+ continue;+ };+ let Some(family) = CFOwned::new(CTFontCopyFamilyName(probe.get())) else {+ continue;+ };+ faces.push(ShippedFace {+ family: cf_string_text(family.get()),+ bold: CTFontGetSymbolicTraits(probe.get()) & K_CT_FONT_TRAIT_BOLD != 0,+ // Le tableau ne fait que prêter ses éléments : on en prend une référence.+ descriptor: CFOwned(CFRetain(descriptor)),+ });}}+ faces}-/// 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;+/// Rastériseur de texte macOS. Pas d'état propre : CoreText et CoreGraphics sont prêts dès+/// le link des frameworks. Il ne tient que les polices embarquées, chargées une fois par+/// processus (chaque compositeur, preview comme export, crée son rastériseur).+pub struct TextRasterizer {+ faces: &'static [ShippedFace],+}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)+ static FACES: std::sync::OnceLock<Vec<ShippedFace>> = std::sync::OnceLock::new();+ let faces = FACES+ .get_or_init(|| unsafe { load_faces(&crate::text_fonts::embedded_font_files()) });+ Ok(TextRasterizer { faces })+ }++ /// La police de `family` à cette taille, tirée du fichier embarqué qui a la graisse+ /// demandée. `None` pour une famille qui ne vient pas de l'app.+ unsafe fn shipped_font(&self, family: &str, bold: bool, size: CGFloat) -> Option<CFOwned> {+ let face = self.faces.iter().find(|f| f.family == family && f.bold == bold)?;+ CFOwned::new(CTFontCreateWithFontDescriptor(face.descriptor.get(), size, std::ptr::null()))}/// Rastérise `spec` dans une `MTLTexture` BGRA8Unorm neuve (alpha prémultiplié).@@ -548,18 +605,28 @@ impl TextRasterizer {cf_string(&spec.content).ok_or_else(|| anyhow!("CFStringCreateWithBytes NULL"))?;// --- police ---- let family = cf_string(&spec.font_family);- let base_font = CFOwned::new(CTFontCreateWithName(- family.as_ref().map(|f| f.get()).unwrap_or(std::ptr::null()),- spec.font_size_px.max(1.0) as CGFloat,- std::ptr::null(),- ))- .ok_or_else(|| anyhow!("CTFontCreateWithName a renvoyé NULL"))?;+ // Une famille embarquée vient de SON fichier, graisse comprise. Les autres, par nom.+ let size = spec.font_size_px.max(1.0) as CGFloat;+ let shipped = self.shipped_font(&spec.font_family, spec.bold, size);+ let base_font = match shipped {+ Some(font) => font,+ None => {+ let family = cf_string(&spec.font_family);+ CFOwned::new(CTFontCreateWithName(+ family.as_ref().map(|f| f.get()).unwrap_or(std::ptr::null()),+ size,+ std::ptr::null(),+ ))+ .ok_or_else(|| anyhow!("CTFontCreateWithName a renvoyé NULL"))?+ }+ };+ let shipped = self.faces.iter().any(|f| f.family == spec.font_family);// Gras/italique : une variante symbolique de la même famille. Si la famille n'a// pas la variante, CoreText renvoie NULL — on garde alors la police de base- // plutôt que d'échouer sur un détail de style.+ // plutôt que d'échouer sur un détail de style. Le gras d'une famille embarquée est+ // déjà son fichier gras.let mut traits = 0u32;- if spec.bold {+ if spec.bold && !shipped {traits |= K_CT_FONT_TRAIT_BOLD;}if spec.italic {@@ -571,7 +638,13 @@ impl TextRasterizer {0.0, // 0 = conserver la taille de la police sourcestd::ptr::null(),traits,- K_CT_FONT_TRAIT_BOLD | K_CT_FONT_TRAIT_ITALIC,+ // Le masque ne touche que ce qu'on demande : l'italique d'une famille+ // embarquée ne doit pas lui retirer son gras.+ if shipped {+ K_CT_FONT_TRAIT_ITALIC+ } else {+ K_CT_FONT_TRAIT_BOLD | K_CT_FONT_TRAIT_ITALIC+ },))} else {None@@ -745,11 +818,17 @@ mod tests {/// Rastérise et rend les octets BGRA, ou `None` si la machine n'a pas de device Metal.fn raster_bgra(spec: &TextSpec) -> Option<(Vec<u8>, usize, usize)> {+ raster_bgra_with(&TextRasterizer::new().expect("TextRasterizer::new"), spec)+ }++ fn raster_bgra_with(+ raster: &TextRasterizer,+ spec: &TextSpec,+ ) -> Option<(Vec<u8>, usize, usize)> {let Ok(gpu) = crate::d3d::Gpu::create(false) else {eprintln!("pas de device Metal — test sauté");return None;};- let raster = TextRasterizer::new().expect("TextRasterizer::new");let tex = unsafe { raster.rasterize(&gpu, spec) }.expect("rasterize");let (w, h) = (spec.box_px[0] as usize, spec.box_px[1] as usize);let mut px = vec![0u8; w * h * 4];@@ -788,59 +867,80 @@ mod tests {#[link(name = "CoreText", kind = "framework")]extern "C" {- fn CTFontCopyFamilyName(font: CFTypeRef) -> CFTypeRef;- fn CTFontGetSymbolicTraits(font: CFTypeRef) -> u32;+ fn CTFontManagerRegisterFontsForURL(+ font_url: CFTypeRef,+ scope: u32,+ error: *mut CFTypeRef,+ ) -> bool;+ fn CTFontCopyAttribute(font: CFTypeRef, attribute: CFTypeRef) -> CFTypeRef;+ static kCTFontURLAttribute: CFTypeRef;}#[link(name = "CoreFoundation", kind = "framework")]extern "C" {- fn CFStringGetCString(- string: CFTypeRef,- buffer: *mut std::ffi::c_char,- buffer_size: CFIndex,- encoding: u32,+ fn CFURLGetFileSystemRepresentation(+ url: CFTypeRef,+ resolve_against_base: u8,+ buffer: *mut u8,+ max_buf_len: CFIndex,) -> 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()+ /// Le fichier d'où CoreText tire réellement `font`.+ unsafe fn file_of(font: CFTypeRef) -> PathBuf {+ use std::os::unix::ffi::OsStrExt;+ let url = CFOwned::new(CTFontCopyAttribute(font, kCTFontURLAttribute)).expect("URL");+ let mut buf = [0u8; 1024];+ let ok = CFURLGetFileSystemRepresentation(url.get(), 1, buf.as_mut_ptr(), 1024);+ assert_ne!(ok, 0, "CFURLGetFileSystemRepresentation");+ let len = buf.iter().position(|b| *b == 0).unwrap();+ let path = PathBuf::from(std::ffi::OsStr::from_bytes(&buf[..len]));+ std::fs::canonicalize(&path).unwrap_or(path)}- /// 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.+ /// Chaque famille embarquée est dessinée depuis SON fichier, même quand une police du+ /// même nom est disponible par ailleurs. La collision est fabriquée : des copies de nos+ /// fichiers, enregistrées pour le processus AVANT, portent exactement les mêmes noms.+ /// Seul le chemin du fichier distingue le gagnant ; famille et graisse n'y suffisent pas.#[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,+ use std::os::unix::ffi::OsStrExt;+ let repo = std::fs::canonicalize(crate::text_fonts::repo_fonts_dir()).unwrap();+ let files = crate::text_fonts::font_files_in(&repo);+ let elsewhere =+ std::env::temp_dir().join(format!("openscreen-sysfonts-{}", std::process::id()));+ std::fs::create_dir_all(&elsewhere).unwrap();+ let raster = unsafe {+ for file in &files {+ let copy = elsewhere.join(file.file_name().unwrap());+ std::fs::copy(file, ©).unwrap();+ let bytes = copy.as_os_str().as_bytes();+ let url = CFOwned::new(CFURLCreateFromFileSystemRepresentation(std::ptr::null(),- K_CT_FONT_TRAIT_BOLD,- K_CT_FONT_TRAIT_BOLD | K_CT_FONT_TRAIT_ITALIC,+ bytes.as_ptr(),+ bytes.len() as CFIndex,+ 0,))- .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);+ .unwrap();+ // 1 = kCTFontManagerScopeProcess.+ CTFontManagerRegisterFontsForURL(url.get(), 1, std::ptr::null_mut());+ }+ TextRasterizer { faces: Box::leak(load_faces(&files).into_boxed_slice()) }+ };++ for family in crate::text_fonts::SHIPPED_FAMILIES {+ for bold in [false, true] {+ let font = unsafe { raster.shipped_font(family, bold, 40.0) }+ .unwrap_or_else(|| panic!("{family} (gras={bold}) non embarquée"));+ unsafe {+ let name = CFOwned::new(CTFontCopyFamilyName(font.get())).unwrap();+ assert_eq!(cf_string_text(name.get()), family);+ let traits = CTFontGetSymbolicTraits(font.get());+ assert_eq!(traits & K_CT_FONT_TRAIT_BOLD != 0, bold, "{family} : graisse");+ let file = file_of(font.get());+ let from = file.display();+ assert!(file.starts_with(&repo), "{family} (gras={bold}) tirée de {from}");+ }}}@@ -851,7 +951,7 @@ mod tests {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 {+ let Some((px, w, h)) = raster_bgra_with(&raster, &s) else {return;};let (x0, y0, x1, y1) = ink_bounds(&px, w, h);diff --git a/electron/native-bridge/services/compositorViewService.test.ts b/electron/native-bridge/services/compositorViewService.test.tsindex 938fb42a7..d6b3aade7 100644--- a/electron/native-bridge/services/compositorViewService.test.ts+++ b/electron/native-bridge/services/compositorViewService.test.ts@@ -318,6 +318,10 @@ describe("CompositorViewService text fonts", () => {afterEach(() => {if (originalResourcesPath) {Object.defineProperty(process, "resourcesPath", originalResourcesPath);+ } else {+ // Absent before the test (plain Node): leaving the temp dir set would point later+ // tests at a directory this hook is about to delete.+ Reflect.deleteProperty(process, "resourcesPath");}if (originalVitePublic === undefined) {Reflect.deleteProperty(process.env, "VITE_PUBLIC");