DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
QA1: retry missing font fallbacks after a rescan
sanyamsingh00110e18bac2720
diff --git a/ROADMAP.md b/ROADMAP.mdindex 821728bf7..c8d261f09 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -9,6 +9,10 @@DesignCraft aims at full Adobe InDesign parity — and to be better: faster, open (documented JSON format + IDML), scriptable by agents (MCP), and available on the web.+## Recent improvements (2026-10-08)++- QA1: Font rescans retry missing glyphs and fallback families after new fonts arrive; a controlled Linux regression covers older in-flight misses after a rescan.+## Status (2026-10-01)**Working today**diff --git a/crates/fonts/src/fontdb.rs b/crates/fonts/src/fontdb.rsindex 14441e144..7d0c902c3 100644--- a/crates/fonts/src/fontdb.rs+++ b/crates/fonts/src/fontdb.rs@@ -341,17 +341,28 @@ pub struct FontDb {/// System fallback state: enabled, and characters no system font covers.#[cfg(not(target_arch = "wasm32"))]sys: Mutex<SysFallback>,+ /// Pause one fallback after copying catalog paths, with no database locks held.+ #[cfg(all(test, target_os = "linux"))]+ fallback_snapshot_hook: Mutex<Option<FallbackSnapshotHook>>,}#[cfg(not(target_arch = "wasm32"))]#[derive(Default)]struct SysFallback {enabled: bool,+ /// Rescan generation: an older in-flight lookup must not restore a cleared miss.+ generation: u64,misses: std::collections::HashSet<char>,/// CJK chain families already looked up in the catalog (loaded, or not installed).chain_tried: std::collections::HashSet<&'static str>,}+#[cfg(all(test, target_os = "linux"))]+struct FallbackSnapshotHook {+ reached: std::sync::mpsc::SyncSender<()>,+ resume: Arc<std::sync::Barrier>,+}+/// Families tried (when installed) for characters the loaded fonts lack: CJK, symbols, emoji.#[cfg(not(target_arch = "wasm32"))]const SYSTEM_FALLBACKS: &[&str] = &[@@ -784,6 +795,8 @@ impl FontDb {cataloged: std::sync::OnceLock::new(),#[cfg(not(target_arch = "wasm32"))]sys: Mutex::new(SysFallback { enabled: true, ..Default::default() }),+ #[cfg(all(test, target_os = "linux"))]+ fallback_snapshot_hook: Mutex::new(None),}}@@ -900,7 +913,14 @@ impl FontDb {// The first scan, or a rescan once it is done (never both at once).let mut first = None;self.cataloged.get_or_init(|| first = Some(self.scan_font_dirs()));- first.unwrap_or_else(|| self.scan_font_dirs())+ let count = first.unwrap_or_else(|| self.scan_font_dirs());+ // Retry characters and CJK chain families that newly installed fonts can now cover.+ // Reset outside scan_font_dirs: a chain lookup can hold sys during the initial scan.+ let mut sys = self.sys.lock().unwrap_or_else(|e| e.into_inner());+ sys.generation = sys.generation.wrapping_add(1);+ sys.misses.clear();+ sys.chain_tried.clear();+ count}#[cfg(not(target_arch = "wasm32"))]@@ -1100,12 +1120,13 @@ impl FontDb {if c.is_control() || c.is_whitespace() {return false;}- {+ let generation = {let sys = self.sys.lock().unwrap_or_else(|e| e.into_inner());if !sys.enabled || sys.misses.contains(&c) {return false;}- }+ sys.generation+ };let covered = |db: &FontDb| db.read_faces().iter().any(|f| f.covers(c));let cataloged: Vec<String> = self.read_catalog().iter().map(|e| e.family.clone()).collect();for fam in SYSTEM_FALLBACKS {@@ -1119,6 +1140,14 @@ impl FontDb {let mut paths: Vec<std::path::PathBuf> = self.catalog.read().unwrap_or_else(|e| e.into_inner()).iter().map(|e| e.path.clone()).collect();paths.sort();paths.dedup();+ #[cfg(all(test, target_os = "linux"))]+ {+ let hook = self.fallback_snapshot_hook.lock().unwrap_or_else(|e| e.into_inner()).take();+ if let Some(hook) = hook {+ let _ = hook.reached.send(());+ hook.resume.wait();+ }+ }for p in paths {if std::fs::metadata(&p).map(|m| m.len() > 40 << 20).unwrap_or(true) {continue;@@ -1130,7 +1159,10 @@ impl FontDb {return true;}}- self.sys.lock().unwrap_or_else(|e| e.into_inner()).misses.insert(c);+ let mut sys = self.sys.lock().unwrap_or_else(|e| e.into_inner());+ if sys.generation == generation {+ sys.misses.insert(c);+ }false}diff --git a/crates/fonts/src/tests_sysfonts.rs b/crates/fonts/src/tests_sysfonts.rsindex a9cda7cdc..9b6d4b0e0 100644--- a/crates/fonts/src/tests_sysfonts.rs+++ b/crates/fonts/src/tests_sysfonts.rs@@ -164,3 +164,82 @@ fn font_menus_group_installed_and_loaded_fonts_without_loading_them() {assert_eq!(infos.iter().filter(|i| i.family == "Groups Mincho").count(), 1);let _ = std::fs::remove_dir_all(&dir);}++#[test]+fn rescanning_retries_missing_glyphs_and_absent_fallback_families() {+ use crate::testing::font_with;+ let dir = font_dir("rescan-fallback-ttf");+ // Only synthetic TTF files in this folder are scanned. Keep the loaded Latin fallback+ // alone so optional craft-fonts cannot provide the characters used by this fixture.+ let db = FontDb::with_font_dirs(vec![dir.clone()]);+ db.faces.write().unwrap().retain(|f| f.family == FALLBACK_FAMILY);+ let c = '\u{1e900}';+ assert!(db.fallback_for(c, 0, None).is_none());+ // A loaded non-chain face supplies Hangul while all installed Korean chain faces are absent.+ db.add_font(font_with("Earlier Korean Fallback", &['가']).unwrap());+ let chain_family = "Noto Serif CJK KR";+ assert!(!db.has_family(chain_family));+ assert_eq!(db.fallback_for('가', 0, Some("ko")).unwrap().family, "Earlier Korean Fallback");+ let family = "Installed After Glyph Miss";+ std::fs::write(dir.join("Later.ttf"), font_with(family, &[c]).unwrap()).unwrap();+ std::fs::write(dir.join("LaterKorean.ttf"), font_with(chain_family, &['가']).unwrap()).unwrap();+ // Before an explicit rescan, both fallbacks still use the previous catalog.+ assert!(db.fallback_for(c, 0, None).is_none());+ assert_eq!(db.fallback_for('가', 0, Some("ko")).unwrap().family, "Earlier Korean Fallback");+ assert_eq!(db.load_system_fonts(), 4);+ assert!(db.has_family(family) && db.has_family(chain_family));+ assert_eq!(db.fallback_for(c, 0, None).unwrap().family, family);+ assert_eq!(db.fallback_for('가', 0, Some("ko")).unwrap().family, chain_family);+ std::fs::remove_dir_all(dir).unwrap();+}++#[cfg(target_os = "linux")]+#[test]+fn a_rescan_does_not_cache_an_older_in_flight_glyph_miss() {+ use crate::testing::font_with;+ use std::sync::{Barrier, mpsc};+ use std::time::Duration;++ let dir = font_dir("rescan-in-flight-ttf");+ let db = Arc::new(FontDb::with_font_dirs(vec![dir.clone()]));+ // Optional craft-fonts must not supply the test glyph from an already loaded face.+ db.faces.write().unwrap().retain(|f| f.family == FALLBACK_FAMILY);+ let c = '\u{1e900}';+ let family = "Installed During Glyph Lookup";+ let font = font_with(family, &[c]).unwrap();+ assert!(db.read_faces().iter().all(|f| !f.covers(c)));+ assert_eq!(db.load_system_fonts(), 2);++ let deadline = Duration::from_secs(10);+ let (reached_tx, reached_rx) = mpsc::sync_channel(1);+ let resume = Arc::new(Barrier::new(2));+ *db.fallback_snapshot_hook.lock().unwrap() = Some(FallbackSnapshotHook { reached: reached_tx, resume: resume.clone() });+ let (lookup_tx, lookup_rx) = mpsc::sync_channel(1);+ let lookup_db = db.clone();+ let lookup = std::thread::spawn(move || {+ let face = lookup_db.fallback_for(c, 0, None).map(|f| f.family.clone());+ let _ = lookup_tx.send(face);+ });+ reached_rx.recv_timeout(deadline).expect("the lookup must reach its old catalog snapshot");++ // Finish the rescan while the old lookup is paused. A timeout also detects accidentally+ // holding sys/catalog locks at the hook; release the lookup before reporting that failure.+ let (scan_tx, scan_rx) = mpsc::sync_channel(1);+ let scan_db = db.clone();+ let scan = std::thread::spawn(move || {+ let result = std::fs::write(dir.join("Later.ttf"), font).map(|()| scan_db.load_system_fonts());+ let _ = scan_tx.send(result);+ });+ let scanned = scan_rx.recv_timeout(deadline);+ resume.wait();+ let old_face = lookup_rx.recv_timeout(deadline).expect("the old lookup must finish after release");+ lookup.join().unwrap();+ assert_eq!(scanned.expect("the rescan must finish before releasing the old lookup").unwrap(), 3);+ scan.join().unwrap();+ assert!(old_face.is_none(), "the paused lookup only searched the old paths");+ assert!(db.has_family(family));+ assert!(!db.is_loaded(family), "a rescan catalogs the font without loading it");+ // The old miss must not hide the new catalog entry; no second rescan is performed.+ assert_eq!(db.fallback_for(c, 0, None).unwrap().family, family);+ std::fs::remove_dir_all(db.font_dirs.first().unwrap()).unwrap();+}