fix: repair red master CI introduced by 4.3.0

tests: 4.3.0 deliberately expanded the macOS/iOS serif + sans-serif lists (Times New Roman; .AppleSystemUIFont/.SFUIText/.SFUI-Regular/Helvetica), mirrored in config.rs's iOS common_font_families, but left test_operating_system_font_expansion asserting the old lists. Update the assertions to match.

ffi + examples: the shared-cache refactor renamed FontSource -> OwnedFontSource and FcFontRegistry::into_fc_font_cache -> shared_cache, and list()/get_metadata_by_id() now return owned FcPattern. Update src/ffi.rs and the examples (incl. &pattern borrow in debug_azul_fonts). FFI ABI is unchanged.

wasm: FontBytes::Mmapped wrapped mmapio::Mmap but was gated only on std; mmapio is target-gated off wasm, so the variant referenced a missing crate on wasm32. Gate the variant + its match arms on not(target_family="wasm").

warnings: pattern_from_filename was gated std while its sole caller build_from_filenames is std+not(parsing), so --all-features flagged it dead and tripped rust.yml's zero-warning gate. Match the gate.

Verified locally: full feature matrix, cross targets (wasm32-{unknown,wasip1}, aarch64-apple-ios{,-sim}, aarch64-linux-android), --features ffi build, and the --all-features no-warnings gate.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: fschutt

examples/debug_azul_fonts.rs

@@ -31,7 +31,7 @@ fn main() {
                     oblique: PatternMatch::False,
                     ..Default::default()
                 },
-                pattern,
+                &pattern,
             );
             println!(
                 "  id={} name={:?} family={:?} italic={:?} bold={:?} weight={:?} stretch={:?} style_score={} subfamily={:?}",
@@ -74,7 +74,7 @@ fn main() {
                         oblique: PatternMatch::False,
                         ..Default::default()
                     },
-                    pattern,
+                    &pattern,
                 );
                 println!(
                     "    [{}] id={} name={:?} family={:?} italic={:?} bold={:?} weight={:?} style_score={} subfamily={:?}",

examples/integration_api.rs

@@ -103,10 +103,10 @@ fn main() {
                 .unwrap_or("?");
             if let Some(source) = cache.get_font_by_id(font_id) {
                 match source {
-                    rust_fontconfig::FontSource::Disk(path) => {
+                    rust_fontconfig::OwnedFontSource::Disk(path) => {
                         println!("  {} -> {}", name, path.path);
                     }
-                    rust_fontconfig::FontSource::Memory(font) => {
+                    rust_fontconfig::OwnedFontSource::Memory(font) => {
                         println!("  {} -> memory (id: {})", name, font.id);
                     }
                 }

examples/query.rs

@@ -31,8 +31,8 @@ fn main() {
         }
         if let Some(source) = cache.get_font_by_id(&result.id) {
             match source {
-                rust_fontconfig::FontSource::Disk(path) => println!("  Path: {}", path.path),
-                rust_fontconfig::FontSource::Memory(font) => {
+                rust_fontconfig::OwnedFontSource::Disk(path) => println!("  Path: {}", path.path),
+                rust_fontconfig::OwnedFontSource::Memory(font) => {
                     println!("  Memory font: {}", font.id)
                 }
             }

examples/registry.rs

@@ -137,8 +137,8 @@ fn main() {
 
     // Step 7: Snapshot to FcFontCache for text resolution
     let t6 = Instant::now();
-    let new_cache = registry.into_fc_font_cache();
-    println!("  7. into_fc_font_cache()        {:>10?}", t6.elapsed());
+    let new_cache = registry.shared_cache();
+    println!("  7. shared_cache()              {:>10?}", t6.elapsed());
 
     let new_resolved = new_chain.resolve_text(&new_cache, test_text);
     print!("     Text '{}': ", test_text);

src/ffi.rs

@@ -918,7 +918,7 @@ pub extern "C" fn fc_cache_get_font_path(
         let id_rust = FontId::from_fontid_c(&*id);
 
         match cache.get_font_by_id(&id_rust) {
-            Some(FontSource::Disk(path)) => {
+            Some(OwnedFontSource::Disk(path)) => {
                 let path_c = FcFontPathC {
                     path: CString::new(path.path.clone())
                         .unwrap_or_default()
@@ -928,7 +928,7 @@ pub extern "C" fn fc_cache_get_font_path(
 
                 Box::into_raw(Box::new(path_c))
             }
-            Some(FontSource::Memory(font)) => {
+            Some(OwnedFontSource::Memory(font)) => {
                 // For memory fonts, return a special path
                 let path_c = FcFontPathC {
                     path: CString::new(format!("memory:{}", font.id))
@@ -1626,7 +1626,7 @@ pub extern "C" fn fc_registry_query(
 
         match registry.query(&pattern_rust) {
             Some(match_obj) => {
-                let cache = registry.into_fc_font_cache();
+                let cache = registry.shared_cache();
                 let match_c = font_match_to_c(&cache, &match_obj);
                 Box::into_raw(Box::new(match_c))
             }
@@ -1760,7 +1760,7 @@ pub extern "C" fn fc_registry_snapshot(
     }
     unsafe {
         let registry = &*registry;
-        let cache = registry.into_fc_font_cache();
+        let cache = registry.shared_cache();
         Box::into_raw(Box::new(cache))
     }
 }

src/lib.rs

@@ -1344,7 +1344,9 @@ pub enum FontBytes {
     /// fallback when mmap is unavailable.
     Owned(std::sync::Arc<[u8]>),
     /// File-backed mmap. Read-only; pages are demand-loaded by the
-    /// kernel.
+    /// kernel. Absent on wasm targets, where `mmapio` is unavailable
+    /// (the optional dep is gated to `cfg(not(target_family="wasm"))`).
+    #[cfg(not(target_family = "wasm"))]
     Mmapped(mmapio::Mmap),
 }
 
@@ -1355,6 +1357,7 @@ impl FontBytes {
     pub fn as_slice(&self) -> &[u8] {
         match self {
             FontBytes::Owned(arc) => arc,
+            #[cfg(not(target_family = "wasm"))]
             FontBytes::Mmapped(m) => &m[..],
         }
     }
@@ -1382,6 +1385,7 @@ impl core::fmt::Debug for FontBytes {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let kind = match self {
             FontBytes::Owned(_) => "Owned",
+            #[cfg(not(target_family = "wasm"))]
             FontBytes::Mmapped(_) => "Mmapped",
         };
         write!(f, "FontBytes::{}({} bytes)", kind, self.as_slice().len())
@@ -4818,7 +4822,11 @@ fn detect_monospace(
 ///
 /// Uses [`config::tokenize_font_stem`] and [`config::FONT_STYLE_TOKENS`]
 /// to extract the family name and detect style hints from the filename.
-#[cfg(feature = "std")]
+///
+/// Only compiled for the filename-only (`not(parsing)`) scan path — its
+/// sole caller is [`FcFontCache::build_from_filenames`]. With `parsing`
+/// on, allsorts reads real metadata and this fallback is unused.
+#[cfg(all(feature = "std", not(feature = "parsing")))]
 fn pattern_from_filename(path: &std::path::Path) -> Option<FcPattern> {
     let ext = path.extension()?.to_str()?.to_lowercase();
     match ext.as_str() {

tests/tests.rs

@@ -22,11 +22,11 @@ fn test_operating_system_font_expansion() {
     let macos_os = OperatingSystem::MacOS;
     assert_eq!(
         macos_os.get_serif_fonts(no_ranges),
-        vec!["Times", "New York", "Palatino"].iter().map(|s| s.to_string()).collect::<Vec<_>>()
+        vec!["Times New Roman", "Times", "New York", "Palatino"].iter().map(|s| s.to_string()).collect::<Vec<_>>()
     );
     assert_eq!(
         macos_os.get_sans_serif_fonts(no_ranges),
-        vec!["San Francisco", "Helvetica Neue", "Lucida Grande"]
+        vec!["San Francisco", ".AppleSystemUIFont", ".SFUIText", ".SFUI-Regular", "Helvetica Neue", "Helvetica", "Lucida Grande"]
             .iter().map(|s| s.to_string()).collect::<Vec<_>>()
     );
     assert_eq!(
@@ -53,8 +53,8 @@ fn test_operating_system_font_expansion() {
     let expanded = expand_font_families(&families, OperatingSystem::MacOS, no_ranges);
     assert_eq!(expanded[0], "Arial");
     assert_eq!(expanded[1], "San Francisco");
-    assert_eq!(expanded[2], "Helvetica Neue");
-    assert_eq!(expanded[3], "Lucida Grande");
+    assert_eq!(expanded[2], ".AppleSystemUIFont");
+    assert_eq!(expanded[3], ".SFUIText");
 
     // Test non-generic family (should pass through unchanged)
     let specific = vec!["MyCustomFont".to_string()];