Skip to content

PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust

M2: address CJK viewer review and sync main

songzhihui46fbb73d1a73
diff --cc AGENTS.md
index 1cb3e1c34,0665ad1d3..904c179a3
--- a/AGENTS.md
+++ b/AGENTS.md
@@@ -71,7 -71,6 +71,7 @@@ Anything else is forbidden, including a
- Font assets shared by the Crafting Apps, including every Japanese font, live in [`storytold/craft-fonts`](https://github.com/storytold/craft-fonts), not here. **Never commit a font file to this repository**; adding a font means adding it to craft-fonts. (The Latin UI fonts already in `assets/fonts/` — Inter, JetBrains Mono, Dancing Script — stay.) Team members: the shared rules are in [craftrules `standards/fonts.md`](https://github.com/storytold/craftrules/blob/main/standards/fonts.md) (internal).
- craft-fonts is an **optional build input**, never a Cargo dependency: `CRAFT_FONTS_DIR=<checkout> cargo build` makes `crates/fonts/build.rs` embed its fonts as `pdfcraft_fonts::CRAFT_FONTS`. Without it PdfCraft builds, tests and runs, but has no Japanese face (Japanese UI text shows replacement boxes, and writing Japanese into a PDF returns a clear error). Release builds always set it (`.github/workflows/release.yml`), and `ATTRIBUTION.toml` lists it as a `[[build_input]]`.
- The desktop app may read one font **already installed on the user's machine** at runtime, as the last interface fallback for characters no embedded face has (`crates/ui-egui/src/system_fonts.rs`). That font is never embedded, shipped, committed or copied, and never appears in published screenshots (`PDFCRAFT_SYSTEM_FONTS=0`, which `cargo xtask screenshots` sets). It is not a way around §1.2: nothing from it may enter a PDF, a package or the repository.
- - The page viewer may also draw a CID font of an Adobe CJK collection (Japan1, GB1, CNS1, Korea1) that a PDF does **not embed** with one face already installed on the machine (`crates/render/src/system_font.rs`), **on screen only**. `RenderConfig::system_fonts` is off by default and is set only for the pool that draws the viewer (`display_config` in `crates/engine/src/lib.rs`), so exports, printing, OCR and the automation tools never use it. Like the interface font it is read at runtime and never embedded, shipped, committed or copied; Noto CJK and Source Han are never candidates (§1.1), nor is any Adobe family; and `PDFCRAFT_SYSTEM_FONTS=0` turns it off. It is not a way around §1.2 either: nothing drawn with it may be saved or printed.
++- The page viewer may also draw a CID font of an Adobe CJK collection (Japan1, GB1, CNS1, Korea1) that a PDF does **not embed** with one face already installed on the machine (`crates/render/src/system_font.rs`), **on screen only**. `RenderConfig::system_fonts` is off by default and is enabled only for on-screen viewer and preview rasters (`RenderConfig::on_screen`, used by the engine viewer, Combine thumbnails and accessibility figure previews), so exports, printing, OCR and the automation tools never use it. Like the interface font it is read at runtime and never embedded, shipped, committed or copied; Noto CJK and Source Han are never candidates (§1.1), nor is any Adobe family; and `PDFCRAFT_SYSTEM_FONTS=0` turns it off. It is not a way around §1.2 either: nothing drawn with it may be saved or printed.
### 1.5 Procedure for adding or changing an asset
diff --cc ROADMAP.md
index a984ca53e,27c8e1b6b..6dbd60d6d
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@@ -1,5 -1,5 +1,7 @@@
# PdfCraft roadmap
++> **Last reviewed:** 2026-10-23 · **Last updated:** 2026-10-23 · **Change:** minor (M2, PR #4172: extend on-screen CJK fallback to Combine thumbnails and figure previews; recognise FangSong and subset-prefixed Founder names; estimates unchanged)
++
**Stage: alpha** · next: beta, ~25% (ready for real work 50% → 75%) and ~400–700 h away
> **Last reviewed:** 2026-10-22 · **Last updated:** 2026-10-22 · **Change:** minor (M14, #3558: rebase guarded macOS per-file association recovery onto current main; estimates unchanged)
@@@ -688,3 -686,3 +690,5 @@@ Newest first: the date, what moved, an
- **2026-10-21 (M4, #3865):** A new bookmark records where the reader is: the top-left of the selected text, or the top of the window, as `/XYZ left top null` (zoom kept), instead of the page top (`Edit::AddBookmark` takes `left` and `top`; `bookmark_add` takes `top` and `left`; `PageInfo::xyz_for_view`).
- **2026-10-18 (renderer, hayro patches 19/35):** A mesh shading (types 4–7) is sampled over its own triangles instead of the whole path: a BricsCAD plan with 310 one-triangle `sh` fills took 2 s per 1024 px tile at every zoom (and hit the 20 s watchdog on a busy machine); now about 70 ms, so zooming into dense topology drawings stays fluid. Estimates unchanged.
++
++- **2026-10-23 (M2, PR #4172):** Combine thumbnails and accessibility figure previews use the viewer's display-only CJK fallback. Windows family matching includes FangSong and subset-prefixed Founder names. Export, print, OCR and automation remain off by default; estimates unchanged.
diff --cc crates/engine/src/lib.rs
index 5a698fd7d,f257865d3..951918ba2
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@@ -1074,14 -1074,6 +1074,14 @@@ fn set_default_layer_state(cos: &mut pd
cos.set(root_ref, Object::Dict(root));
}
+/// The configuration of the pool that draws the viewer: the document's own, plus installed CJK
+/// fonts for fonts a PDF does not embed (`RenderConfig::system_fonts`). Exports, printing, OCR and
+/// the automation tools render with the document's configuration itself, so nothing drawn with an
+/// installed font is saved or printed (AGENTS.md §1.2, §1.4).
+fn display_config(config: &RenderConfig) -> RenderConfig {
- RenderConfig { system_fonts: true, ..config.clone() }
++ config.clone().on_screen()
+}
+
/// Render `doc` with the layer visibility in its `info.layers`.
fn use_layer_choices(doc: &mut Document) {
let overrides: Vec<(i32, i32, bool)> = doc.info.layers.iter().map(|l| (l.id.0 as i32, l.id.1 as i32, l.visible)).collect();
diff --cc crates/render/src/raster.rs
index 0a2fc29e0,1f8d2f19e..7fbb85edd
--- a/crates/render/src/raster.rs
+++ b/crates/render/src/raster.rs
@@@ -71,17 -71,11 +71,26 @@@ pub struct RenderConfig
/// The page clears to transparent instead of white (or the reading background): for a page
/// holding only what is laid over another raster, such as a comment while it is dragged.
pub transparent: bool,
+ /// Draw a CID font of an Adobe CJK collection that the PDF does not embed with one face already
- /// installed on this machine (see `system_font`). Off by default and on only for the pool that
- /// draws the viewer: exports, printing and OCR render without it, so nothing drawn with an
++ /// installed on this machine (see `system_font`). Off by default and on only for on-screen
++ /// viewer and preview rasters: exports, printing and OCR render without it, so nothing drawn with an
+ /// installed font is saved or printed (AGENTS.md §1.2, §1.4).
+ pub system_fonts: bool,
}
impl RenderConfig {
++ /// This configuration for a raster that is only shown on screen (the viewer, Combine
++ /// thumbnails, figure previews): installed CJK faces may draw fonts the PDF doesn't embed.
++ /// Never use it for anything that can be saved, printed, recognised or returned to an agent
++ /// (AGENTS.md §1.2, §1.4).
++ #[must_use]
++ pub fn on_screen(self) -> Self {
++ Self { system_fonts: true, ..self }
++ }
++
fn settings(&self) -> InterpreterSettings {
let standard = InterpreterSettings::default().font_resolver;
+ let system_fonts = self.system_fonts;
InterpreterSettings {
ocg_overrides: self.layers.clone(),
hide_comments: self.hide_comments,
@@@ -7699,76 -7683,6 +7708,79 @@@ trailer << /Root 1 0 R >
}
}
+ /// Chinese and Korean CID fonts that aren't embedded (Adobe-CNS1 `MSung-Light`, Adobe-GB1
+ /// `STSong-Light`, Adobe-Korea1 `HYGoThic-Medium`; Acrobat also writes Japanese `KozGoPr6N`
+ /// text boxes without the font) drew nothing, because craft-fonts has only Japanese faces.
+ /// They now draw in a face already installed on the machine, read at runtime. A machine
+ /// without such a face draws nothing, as before, so each check is skipped there.
+ #[test]
+ fn non_embedded_chinese_and_korean_cid_fonts_draw_with_an_installed_face() {
+ use hayro::hayro_interpret::font::FallbackFontQuery;
+ use hayro::hayro_interpret::hayro_cmap::CharacterCollection;
+ // (base font, collection, ordering, encoding, encoded text, descendant subtype)
+ let cases = [
+ ("MSung-Light", CidFamily::AdobeCNS1, "CNS1", "UniCNS-UCS2-H", "7E419AD45B57", "CIDFontType0"), // 繁體字
+ ("STSong-Light", CidFamily::AdobeGB1, "GB1", "UniGB-UCS2-H", "72698D448DF7", "CIDFontType0"), // 物资跷
+ ("HYGoThic-Medium", CidFamily::AdobeKorea1, "Korea1", "UniKS-UCS2-H", "D55CAE00", "CIDFontType0"), // 한글
+ // The real Windows book uses non-embedded TrueType CID fonts and a legacy GBK CMap,
+ // without ToUnicode. These bytes encode 中文; they are not Unicode code points.
+ ("SimSun", CidFamily::AdobeGB1, "GB1", "GBK-EUC-H", "D6D0CEC4", "CIDFontType2"),
+ ("SimHei", CidFamily::AdobeGB1, "GB1", "GBK-EUC-H", "D6D0CEC4", "CIDFontType2"),
+ ("KaiTi", CidFamily::AdobeGB1, "GB1", "GBK-EUC-H", "D6D0CEC4", "CIDFontType2"),
++ ("FangSong", CidFamily::AdobeGB1, "GB1", "GBK-EUC-H", "D6D0CEC4", "CIDFontType2"),
++ ("ABCDEF+FZSSK--GBK1-0", CidFamily::AdobeGB1, "GB1", "GBK-EUC-H", "D6D0CEC4", "CIDFontType2"),
++ ("ABCDEF+FZFSK--GBK1-0", CidFamily::AdobeGB1, "GB1", "GBK-EUC-H", "D6D0CEC4", "CIDFontType2"),
+ ];
+ for (base_font, family, ordering, encoding, code, subtype) in cases {
+ let query = FontQuery::Fallback(FallbackFontQuery {
+ post_script_name: Some(base_font.into()),
+ character_collection: Some(CharacterCollection { family, supplement: 2 }),
+ ..FallbackFontQuery::default()
+ });
+ if super::system_fallback(&query).is_none() {
+ eprintln!("no installed face for {base_font} (or PDFCRAFT_SYSTEM_FONTS=0): skipped");
+ continue;
+ }
+ let content = format!("BT /F1 40 Tf 5 15 Td <{code}> Tj ET");
+ let pdf = format!(
+ "%PDF-1.7
+1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj
+2 0 obj << /Type /Pages /Kids [3 0 R] /Count 1 >> endobj
+3 0 obj << /Type /Page /Parent 2 0 R /MediaBox [0 0 200 60] /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >> endobj
+4 0 obj << /Length {} >> stream
+{content}
+endstream endobj
+5 0 obj << /Type /Font /Subtype /Type0 /BaseFont /{base_font} /Encoding /{encoding} /DescendantFonts [6 0 R] >> endobj
+6 0 obj << /Type /Font /Subtype /{subtype} /BaseFont /{base_font} /CIDSystemInfo << /Registry (Adobe) /Ordering ({ordering}) /Supplement 2 >>
+ /FontDescriptor 7 0 R /DW 1000 >> endobj
+7 0 obj << /Type /FontDescriptor /FontName /{base_font} /Flags 6 /FontBBox [0 -141 1000 859] /ItalicAngle 0 /Ascent 859 /Descent -141 /CapHeight 700 /StemV 80 >> endobj
+trailer << /Root 1 0 R >>
+%%EOF",
+ content.len()
+ );
+ let pdf = Arc::new(pdf.into_bytes());
+ let ink = |config: RenderConfig| {
+ let mut r = PageRenderer::new(pdf.clone(), config);
+ let p = r.render(RenderRequest { page: 0, kind: RequestKind::Pixels, tile: None, scale: 1.0, tag: 0, ..Default::default() });
+ assert!(p.error.is_none(), "{base_font}: {:?}", p.error);
+ p.rgba.as_chunks::<4>().0.iter().filter(|c| c[0] < 128).count()
+ };
+ // Two to four glyphs at 40 pt cover several hundred dark pixels; a blank run has none.
+ let shown = ink(RenderConfig { system_fonts: true, ..RenderConfig::default() });
+ assert!(shown > 300, "{base_font}: the text is drawn ({shown} dark pixels)");
+ // Off by default: exports, printing and OCR render without an installed font, so
+ // nothing drawn with one can be saved (AGENTS.md §1.2, §1.4).
+ let saved = ink(RenderConfig::default());
+ assert!(saved < 50, "{base_font}: not drawn without system_fonts ({saved} dark pixels)");
+ if encoding == "GBK-EUC-H" {
+ let mut renderer = PageRenderer::new(pdf, RenderConfig { system_fonts: true, ..Default::default() });
+ let text = renderer.render(RenderRequest { page: 0, kind: RequestKind::Text, ..Default::default() });
+ assert!(text.error.is_none(), "{base_font}: {:?}", text.error);
+ assert_eq!(text.text.unwrap().plain_text().trim(), "中文", "the fallback preserves GBK text mapping");
+ }
+ }
+ }
+
/// Half-width katakana are common in Japanese documents set in a non-embedded Mincho font
/// such as HeiseiMin-W3. The Mincho substitute must have those glyphs: one that lacks them
/// (Shippori Mincho) draws them as .notdef.
diff --cc crates/render/src/system_font.rs
index 626b3d10e,000000000..a5db18dfc
mode 100644,000000..100644
--- a/crates/render/src/system_font.rs
+++ b/crates/render/src/system_font.rs
@@@ -1,438 -1,0 +1,496 @@@
+//! Installed CJK faces for CID fonts a PDF doesn't embed.
+//!
+//! Acrobat and other tools often write Chinese, Japanese or Korean text with one of the Adobe
+//! collections (Adobe-Japan1, GB1, CNS1, Korea1) and a font name such as `KozGoPr6N-Medium` or
+//! `MSung-Light` without embedding the font. hayro maps those CIDs to Unicode itself, but it needs
+//! a face to draw them with; without one the text is blank. The craft-fonts Japanese faces come
+//! first (see `japanese_fallback` in `raster.rs`); this module is the last resort: one face
+//! already installed on this machine, used for the viewer only (`RenderConfig::system_fonts`, off
+//! for exports, printing and OCR). It is read at runtime and never embedded or shipped
+//! (AGENTS.md §1.4), Noto CJK and Source Han are left out on purpose (§1.1), and
+//! `PDFCRAFT_SYSTEM_FONTS=0` turns it off, as for the interface font.
+
+use std::collections::HashMap;
+use std::io::Read as _;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex, OnceLock, PoisonError};
+
+use hayro::hayro_interpret::font::{FallbackFontQuery, FontData};
+use hayro::hayro_interpret::hayro_cmap::CidFamily;
+use skrifa::MetadataProvider as _;
+use skrifa::string::StringId;
+
+/// Larger files are not read: a font path is still untrusted input. CJK system faces are big
+/// collections (PingFang is tens of megabytes).
+const MAX_BYTES: u64 = 96 << 20;
+/// Faces tried in a collection (`.ttc`).
+const MAX_FACES: u32 = 32;
+/// Downloaded font assets looked at per kind on macOS.
+const MAX_ASSETS: usize = 512;
+
+/// The writing system a character collection is for.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+enum Script {
+ Japanese,
+ SimplifiedChinese,
+ TraditionalChinese,
+ Korean,
+}
+
+impl Script {
+ fn of(family: &CidFamily) -> Option<Self> {
+ match family {
+ CidFamily::AdobeJapan1 => Some(Self::Japanese),
+ CidFamily::AdobeGB1 => Some(Self::SimplifiedChinese),
+ CidFamily::AdobeCNS1 => Some(Self::TraditionalChinese),
+ CidFamily::AdobeKorea1 => Some(Self::Korean),
+ CidFamily::AdobeIdentity | CidFamily::Custom { .. } => None,
+ }
+ }
+
+ /// A character the face must have to be worth using. Each is common and not shared by the
+ /// other scripts' faces: 物 (Japanese; also Chinese, so it only rules out Latin-only faces),
+ /// 欢 (Simplified only), 說 (Traditional only), 한 (Hangul).
+ fn probe(self) -> char {
+ match self {
+ Self::Japanese => '\u{7269}',
+ Self::SimplifiedChinese => '\u{6B22}',
+ Self::TraditionalChinese => '\u{8AAA}',
+ Self::Korean => '\u{D55C}',
+ }
+ }
+}
+
+/// One installed file and the words (in a face's family name) that pick the face for the right
+/// region out of a collection that holds several (PingFang SC, TC and HK share one file).
+struct Candidate {
+ path: PathBuf,
+ region: &'static [&'static str],
+}
+
- /// Keep named Windows body, heading and calligraphic faces distinct. A cache keyed only
- /// by script and weight would make the first Chinese font on a page stand in for all three.
++/// Keep named Windows body, heading, calligraphic and FangSong faces distinct. A cache keyed only
++/// by script and weight would make the first Chinese font on a page stand in for all of them.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+enum ChineseFamily {
+ Default,
+ Song,
+ Hei,
+ Kai,
++ FangSong,
+}
+
+impl ChineseFamily {
++ /// The family a font name asks for: the Windows and Founder (方正) names that Chinese PDFs,
++ /// CNKI papers in particular, use without embedding the font. FangSong is tested first, as
++ /// its names contain "song" too. Founder PostScript names are matched by prefix (`FZSSK--GBK1-0`
++ /// is 方正书宋, `FZXBSK--GBK1-0` 方正小标宋, `FZHTK--GBK1-0` 方正黑体, `FZKTK--GBK1-0` 方正楷体,
++ /// `FZFSK--GBK1-0` 方正仿宋).
+ fn of(name: &str) -> Self {
++ // PDF subset names prepend six uppercase ASCII letters and '+'. Match the actual
++ // PostScript name so Founder prefixes work for subsets too.
++ let name = match name.split_once('+') {
++ Some((tag, family)) if tag.len() == 6 && tag.bytes().all(|b| b.is_ascii_uppercase()) => family,
++ _ => name,
++ };
+ let name = name.to_ascii_lowercase();
- if ["simsun", "stsong", "songti", "宋体"].iter().any(|hint| name.contains(hint)) {
++ let has = |hints: &[&str]| hints.iter().any(|hint| name.contains(hint));
++ let starts = |prefixes: &[&str]| prefixes.iter().any(|p| name.starts_with(p));
++ if has(&["fangsong", "simfang", "仿宋"]) || starts(&["fzfs"]) {
++ Self::FangSong
++ } else if has(&["simsun", "stsong", "songti", "song", "宋"]) || starts(&["fzss", "fzbs", "fzxbs", "fzcs"]) {
+ Self::Song
- } else if ["simhei", "stheiti", "黑体"].iter().any(|hint| name.contains(hint)) {
++ } else if has(&["simhei", "stheiti", "stxihei", "heiti", "黑"]) || starts(&["fzht", "fzhei", "fzlth", "fzdh"]) {
+ Self::Hei
- } else if ["kaiti", "stkaiti", "楷体"].iter().any(|hint| name.contains(hint)) {
++ } else if has(&["kaiti", "stkaiti", "kai", "楷"]) || starts(&["fzkt", "fzkai"]) {
+ Self::Kai
+ } else {
+ Self::Default
+ }
+ }
+}
+
+/// The installed face to draw a CID font of `query`'s collection with, as `(data, face index)`.
+/// `None` when it is turned off, the collection isn't one of the four, or nothing fits.
+pub(crate) fn fallback(query: &FallbackFontQuery) -> Option<(FontData, u32)> {
+ if cfg!(target_arch = "wasm32") || std::env::var_os("PDFCRAFT_SYSTEM_FONTS").is_some_and(|v| v == "0") {
+ return None;
+ }
+ let script = Script::of(&query.character_collection.as_ref()?.family)?;
+ let bold = query.is_bold || query.font_weight >= 600;
+ let family = ChineseFamily::of(query.post_script_name.as_deref().unwrap_or_default());
+ /// A face file and the index of the chosen face in it, or `None` when nothing fits.
+ type Face = Option<(Arc<Vec<u8>>, u32)>;
+ type Faces = HashMap<(Script, bool, ChineseFamily), Face>;
+ static CACHE: Mutex<Option<Faces>> = Mutex::new(None);
+ let mut cache = CACHE.lock().unwrap_or_else(PoisonError::into_inner);
+ let found = cache.get_or_insert_with(HashMap::new).entry((script, bold, family)).or_insert_with(|| {
+ candidates(script, family, bold).iter().find_map(|c| {
+ read(c, script.probe(), bold).inspect(|(_, index)| {
+ log::info!("CJK font fallback for {script:?}/{family:?}: {} (face {index})", c.path.display());
+ })
+ })
+ });
+ found.as_ref().map(|(bytes, index)| (Arc::clone(bytes) as FontData, *index))
+}
+
+fn read(candidate: &Candidate, probe: char, bold: bool) -> Option<(Arc<Vec<u8>>, u32)> {
+ let bytes = file_bytes(&candidate.path)?;
+ let index = pick_face(&bytes, probe, candidate.region, bold)?;
+ Some((bytes, index))
+}
+
+/// The bytes of an installed font file, read once for the whole process and shared: a collection
+/// such as `PingFang.ttc` is tens of megabytes and is the candidate of several scripts and both
+/// weights, so the per-script cache keeps only a handle and a face index. A file that cannot be
+/// used is remembered too, so it is not tried again for every script or family.
+fn file_bytes(path: &Path) -> Option<Arc<Vec<u8>>> {
+ /// The bytes of each file tried, or `None` for one that cannot be used.
+ type Files = HashMap<PathBuf, Option<Arc<Vec<u8>>>>;
+ static FILES: Mutex<Option<Files>> = Mutex::new(None);
+ let mut files = FILES.lock().unwrap_or_else(PoisonError::into_inner);
+ files.get_or_insert_with(HashMap::new).entry(path.to_path_buf()).or_insert_with(|| read_file(path, MAX_BYTES).map(Arc::new)).clone()
+}
+
+/// A regular file of at most `max` bytes, or `None`: a font path is untrusted input.
+fn read_file(path: &Path, max: u64) -> Option<Vec<u8>> {
+ // Reject special files before opening them (in particular a FIFO can block on open).
+ let meta = std::fs::metadata(path).ok()?;
+ if !meta.is_file() || meta.len() > max {
+ return None;
+ }
+ let file = std::fs::File::open(path).ok()?;
+ let meta = file.metadata().ok()?;
+ if !meta.is_file() || meta.len() > max {
+ return None;
+ }
+ // Bound the actual read too: the file can grow after the metadata check.
+ let mut bytes = Vec::new();
+ file.take(max.saturating_add(1)).read_to_end(&mut bytes).ok()?;
+ (bytes.len() as u64 <= max).then_some(bytes)
+}
+
+/// The best face of the file that parses and maps `probe`: the region's face when the file has
+/// one, then the regular (or, for bold text, the semibold or bold) weight, then the first.
+fn pick_face(bytes: &[u8], probe: char, region: &[&str], bold: bool) -> Option<u32> {
+ let mut best: Option<(u32, u32)> = None;
+ for index in 0..MAX_FACES {
+ let Ok(font) = skrifa::FontRef::from_index(bytes, index) else { continue };
+ if font.charmap().map(probe).is_none() {
+ continue;
+ }
+ let names = |id: StringId| font.localized_strings(id).map(|s| s.chars().collect::<String>()).collect::<Vec<_>>();
+ let family = names(StringId::FAMILY_NAME).join(" ");
+ let style = names(StringId::SUBFAMILY_NAME).join(" ").to_ascii_lowercase();
+ let mut score = 1;
+ if region.iter().any(|r| family.split_whitespace().any(|w| w == *r)) {
+ score += 4;
+ }
+ let weighty = style.contains("bold") || style.contains("semibold") || style.contains("heavy");
+ let plain = style.is_empty() || style.contains("regular") || style.contains("normal") || style.contains("medium") && !bold;
+ if (bold && weighty) || (!bold && plain && !weighty) {
+ score += 2;
+ }
+ if best.is_none_or(|(_, s)| score > s) {
+ best = Some((index, score));
+ }
+ }
+ best.map(|(index, _)| index)
+}
+
+fn candidates(script: Script, family: ChineseFamily, bold: bool) -> Vec<Candidate> {
+ let region: &'static [&'static str] = match script {
+ Script::Japanese => &["JP", "Japanese"],
+ Script::SimplifiedChinese => &["SC", "GB"],
+ Script::TraditionalChinese => &["TC", "HK", "CNS"],
+ Script::Korean => &["KR", "Korean"],
+ };
+ let files: Vec<PathBuf> = if cfg!(windows) {
+ let dir = windows_fonts();
+ let names: &[&str] = match script {
+ Script::Japanese => &["YuGothR.ttc", "meiryo.ttc", "msgothic.ttc"],
+ Script::SimplifiedChinese => match family {
+ ChineseFamily::Song => &["simsun.ttc", "msyh.ttc", "msjh.ttc"],
+ ChineseFamily::Hei => &["simhei.ttf", "msyh.ttc", "simsun.ttc", "msjh.ttc"],
+ ChineseFamily::Kai => &["simkai.ttf", "simsun.ttc", "msyh.ttc", "msjh.ttc"],
++ ChineseFamily::FangSong => &["simfang.ttf", "simsun.ttc", "msyh.ttc", "msjh.ttc"],
+ ChineseFamily::Default if bold => &["msyhbd.ttc", "msyh.ttc", "simsun.ttc", "msjh.ttc"],
+ ChineseFamily::Default => &["msyh.ttc", "simsun.ttc", "msjh.ttc"],
+ },
+ Script::TraditionalChinese => &["msjh.ttc", "mingliu.ttc", "msyh.ttc"],
+ Script::Korean => &["malgun.ttf", "gulim.ttc"],
+ };
+ names.iter().map(|f| dir.join(f)).collect()
+ } else if cfg!(target_os = "macos") {
+ let names: &[&str] = match script {
+ Script::Japanese => &["ヒラギノ角ゴシック W3.ttc", "Hiragino Sans GB.ttc", "PingFang.ttc"],
+ Script::SimplifiedChinese => &["PingFang.ttc", "Hiragino Sans GB.ttc", "STHeiti Light.ttc"],
+ Script::TraditionalChinese => &["PingFang.ttc", "STHeiti Light.ttc", "Hiragino Sans GB.ttc"],
+ Script::Korean => &["AppleSDGothicNeo.ttc", "AppleGothic.ttf", "PingFang.ttc"],
+ };
+ // The system folder first, then the downloaded font assets: on recent macOS a face such as
+ // PingFang lives in `/System/Library/AssetsV2/com_apple_MobileAsset_Font*/<id>.asset/AssetData`.
+ let mut dirs = vec![PathBuf::from("/System/Library/Fonts")];
+ dirs.extend(macos_font_asset_dirs().iter().cloned());
+ names.iter().flat_map(|f| dirs.iter().map(move |d| d.join(f))).collect()
+ } else {
+ let names: &[&str] = match script {
+ Script::Korean => {
+ &["truetype/nanum/NanumGothic.ttf", "nanum/NanumGothic.ttf", "truetype/baekmuk/gulim.ttf", "truetype/unfonts-core/UnDotum.ttf"]
+ }
+ Script::Japanese => &[
+ "truetype/fonts-japanese-gothic.ttf",
+ "ipa-gothic/ipag.ttf",
+ "truetype/takao-gothic/TakaoGothic.ttf",
+ "truetype/vlgothic/VL-Gothic-Regular.ttf",
+ ],
+ Script::SimplifiedChinese | Script::TraditionalChinese => &[
+ "truetype/wqy/wqy-microhei.ttc",
+ "wenquanyi/wqy-microhei/wqy-microhei.ttc",
+ "wqy-microhei/wqy-microhei.ttc",
+ "truetype/wqy/wqy-zenhei.ttc",
+ "wenquanyi/wqy-zenhei/wqy-zenhei.ttc",
+ "wqy-zenhei/wqy-zenhei.ttc",
+ "truetype/droid/DroidSansFallbackFull.ttf",
+ "google-droid-sans-fonts/DroidSansFallbackFull.ttf",
+ "truetype/arphic/uming.ttc",
+ "arphic-uming/uming.ttc",
+ ],
+ };
+ ["/usr/share/fonts", "/usr/local/share/fonts"].iter().flat_map(|dir| names.iter().map(move |f| Path::new(dir).join(f))).collect()
+ };
+ files.into_iter().map(|path| Candidate { path, region }).collect()
+}
+
+/// The `AssetData` folders of the downloaded font assets of macOS, found once. The ids in their
+/// names change with each asset version, so they are listed rather than named; at most
+/// [`MAX_ASSETS`] are looked at.
+fn macos_font_asset_dirs() -> &'static [PathBuf] {
+ static DIRS: OnceLock<Vec<PathBuf>> = OnceLock::new();
+ DIRS.get_or_init(|| {
+ let root = Path::new("/System/Library/AssetsV2");
+ let Ok(kinds) = std::fs::read_dir(root) else { return Vec::new() };
+ let mut dirs = Vec::new();
+ for kind in kinds.flatten().filter(|k| k.file_name().to_string_lossy().starts_with("com_apple_MobileAsset_Font")) {
+ let Ok(assets) = std::fs::read_dir(kind.path()) else { continue };
+ for asset in assets.flatten().take(MAX_ASSETS) {
+ let data = asset.path().join("AssetData");
+ if data.is_dir() {
+ dirs.push(data);
+ }
+ }
+ }
+ dirs
+ })
+}
+
+fn windows_fonts() -> PathBuf {
+ let dir = std::env::var_os("WINDIR").or_else(|| std::env::var_os("SystemRoot")).map_or_else(|| PathBuf::from(r"C:\Windows"), PathBuf::from);
+ dir.join("Fonts")
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ const SCRIPTS: [Script; 4] = [Script::Japanese, Script::SimplifiedChinese, Script::TraditionalChinese, Script::Korean];
+
+ #[test]
+ fn chinese_family_hints_include_subset_and_localized_names() {
+ for name in ["SimSun", "ABCDEF+SimSun", "STSong-Light", "宋体"] {
+ assert_eq!(ChineseFamily::of(name), ChineseFamily::Song, "{name}");
+ }
+ for name in ["SimHei", "STHeiti", "黑体"] {
+ assert_eq!(ChineseFamily::of(name), ChineseFamily::Hei, "{name}");
+ }
+ for name in ["KaiTi", "STKaiti", "楷体"] {
+ assert_eq!(ChineseFamily::of(name), ChineseFamily::Kai, "{name}");
+ }
+ assert_eq!(ChineseFamily::of("Helvetica"), ChineseFamily::Default);
++ assert_eq!(ChineseFamily::of("MicrosoftYaHei"), ChineseFamily::Default);
++ }
++
++ /// FangSong names contain "song" and must not become Song; Founder (方正) names in CNKI papers
++ /// pick the matching installed family instead of YaHei for everything (#3587).
++ #[test]
++ fn fangsong_and_founder_names_pick_their_family() {
++ for name in ["FangSong", "FangSong_GB2312", "STFangsong", "SimFang", "仿宋", "FZFSK--GBK1-0", "ABCDEF+FZFSK--GBK1-0"] {
++ assert_eq!(ChineseFamily::of(name), ChineseFamily::FangSong, "{name}");
++ }
++ for name in ["FZSSK--GBK1-0", "FZBSK--GBK1-0", "FZXBSK--GBK1-0", "FZShuSong-Z01", "STZhongsong", "NSimSun", "ABCDEF+FZSSK--GBK1-0"] {
++ assert_eq!(ChineseFamily::of(name), ChineseFamily::Song, "{name}");
++ }
++ for name in ["FZHTK--GBK1-0", "FZLTHJW--GB1-0", "STXihei", "ABCDEF+FZHTK--GBK1-0"] {
++ assert_eq!(ChineseFamily::of(name), ChineseFamily::Hei, "{name}");
++ }
++ for name in ["FZKTK--GBK1-0", "KaiTi_GB2312", "ABCDEF+FZKTK--GBK1-0"] {
++ assert_eq!(ChineseFamily::of(name), ChineseFamily::Kai, "{name}");
++ }
++ }
++
++ /// Every family has a Windows list that ends in faces any Chinese Windows has, so a missing
++ /// named face still draws the text.
++ #[cfg(windows)]
++ #[test]
++ fn every_windows_chinese_family_falls_back_to_common_faces() {
++ for family in [ChineseFamily::Default, ChineseFamily::Song, ChineseFamily::Hei, ChineseFamily::Kai, ChineseFamily::FangSong] {
++ let list = candidates(Script::SimplifiedChinese, family, false);
++ assert!(list.iter().any(|c| c.path.ends_with("msyh.ttc")), "{family:?}");
++ }
++ let fangsong = candidates(Script::SimplifiedChinese, ChineseFamily::FangSong, false);
++ assert!(fangsong.first().is_some_and(|c| c.path.ends_with("simfang.ttf")));
+ }
+
+ #[test]
+ fn broken_and_missing_files_are_skipped() {
+ assert_eq!(pick_face(b"", '\u{7269}', &[], false), None);
+ assert_eq!(pick_face(b"not a font at all", '\u{7269}', &[], false), None);
+ assert_eq!(pick_face(&[0u8; 4096], '\u{7269}', &[], false), None);
+ let missing = Candidate { path: PathBuf::from("definitely/not/here.ttc"), region: &[] };
+ assert!(read(&missing, '\u{7269}', false).is_none());
+ // A directory is not a font.
+ let dir = Candidate { path: std::env::temp_dir(), region: &[] };
+ assert!(read(&dir, '\u{7269}', false).is_none());
+ }
+
+ /// The files are bounded by `max`: a larger one is not read.
+ #[test]
+ fn a_file_over_the_cap_is_not_read() {
+ let inter = Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/fonts/Inter-Regular.ttf"));
+ assert!(read_file(inter, MAX_BYTES).is_some());
+ assert!(read_file(inter, 1024).is_none());
+ }
+
+ /// Two faces drawn from one installed file (two scripts, or regular and bold) hold the same
+ /// bytes, not a copy each; a file that can't be used is remembered as unusable.
+ #[test]
+ fn one_installed_file_is_read_once_and_shared() {
+ let inter = Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/fonts/Inter-Regular.ttf"));
+ let first = file_bytes(inter).expect("readable");
+ let second = file_bytes(inter).expect("readable");
+ assert!(Arc::ptr_eq(&first, &second), "one allocation for the file");
+ let missing = Path::new("definitely/not/here.ttc");
+ assert!(file_bytes(missing).is_none() && file_bytes(missing).is_none());
+ }
+
+ #[test]
+ fn a_latin_face_is_rejected_for_every_script() {
+ let inter = include_bytes!("../../../assets/fonts/Inter-Regular.ttf");
+ for script in SCRIPTS {
+ assert_eq!(pick_face(inter, script.probe(), &[], false), None, "{script:?}");
+ }
+ assert_eq!(pick_face(inter, 'A', &[], false), Some(0));
+ }
+
+ #[test]
+ fn candidates_are_absolute_font_files_without_adobe_designs() {
+ for script in SCRIPTS {
+ let list = candidates(script, ChineseFamily::Default, false);
+ assert!(!list.is_empty(), "{script:?}");
+ for c in list {
+ assert!(c.path.is_absolute(), "{}", c.path.display());
+ assert!(c.path.extension().is_some_and(|e| e == "ttf" || e == "ttc"), "{}", c.path.display());
+ let name = c.path.to_string_lossy().to_lowercase();
+ assert!(
+ !["notosanscjk", "notoserifcjk", "sourcehan", "source-han", "adobe", "kozuka", "minion"].iter().any(|b| name.contains(b)),
+ "{name}"
+ );
+ }
+ }
+ }
+
+ #[test]
+ fn only_the_four_adobe_collections_have_a_script() {
+ assert_eq!(Script::of(&CidFamily::AdobeCNS1), Some(Script::TraditionalChinese));
+ assert_eq!(Script::of(&CidFamily::AdobeGB1), Some(Script::SimplifiedChinese));
+ assert_eq!(Script::of(&CidFamily::AdobeKorea1), Some(Script::Korean));
+ assert_eq!(Script::of(&CidFamily::AdobeJapan1), Some(Script::Japanese));
+ assert_eq!(Script::of(&CidFamily::AdobeIdentity), None);
+ }
+
+ /// A real Windows GBK book names these faces. Replacing both with YaHei hides the
+ /// distinction between serif body text and sans headings even when the exact face exists.
+ #[cfg(windows)]
+ #[test]
+ fn windows_preserves_installed_chinese_document_families() {
+ use hayro::hayro_interpret::hayro_cmap::CharacterCollection;
- for (name, file) in [("SimSun", "simsun.ttc"), ("SimHei", "simhei.ttf"), ("KaiTi", "simkai.ttf")] {
++ for (name, expected, file) in [
++ ("SimSun", "SimSun", "simsun.ttc"),
++ ("SimHei", "SimHei", "simhei.ttf"),
++ ("KaiTi", "KaiTi", "simkai.ttf"),
++ ("FangSong", "FangSong", "simfang.ttf"),
++ ("ABCDEF+FZSSK--GBK1-0", "SimSun", "simsun.ttc"),
++ ("ABCDEF+FZHTK--GBK1-0", "SimHei", "simhei.ttf"),
++ ("ABCDEF+FZKTK--GBK1-0", "KaiTi", "simkai.ttf"),
++ ("ABCDEF+FZFSK--GBK1-0", "FangSong", "simfang.ttf"),
++ ] {
+ if !windows_fonts().join(file).is_file() {
+ continue;
+ }
+ let query = FallbackFontQuery {
+ post_script_name: Some(name.into()),
+ character_collection: Some(CharacterCollection { family: CidFamily::AdobeGB1, supplement: 4 }),
+ ..FallbackFontQuery::default()
+ };
+ let (bytes, index) = fallback(&query).expect("installed Chinese font");
+ let font = skrifa::FontRef::from_index(bytes.as_ref().as_ref(), index).unwrap();
+ let names: Vec<String> = font.localized_strings(StringId::POSTSCRIPT_NAME).map(|n| n.chars().collect()).collect();
- assert!(names.iter().any(|n| n.eq_ignore_ascii_case(name)), "{name} resolved to {names:?}");
++ assert!(names.iter().any(|n| n.eq_ignore_ascii_case(expected)), "{name} resolved to {names:?}, expected {expected}");
+ }
+ }
+
+ /// On a Mac the face for Traditional Chinese is the TC one of PingFang, not the first of the
+ /// collection (which is another region's), and it maps a character only Traditional has.
+ #[cfg(target_os = "macos")]
+ #[test]
+ fn macos_picks_the_regional_pingfang_face() {
+ // Found where this macOS keeps it: the system folder, or the downloaded font assets.
+ let path = candidates(Script::TraditionalChinese, ChineseFamily::Default, false)
+ .into_iter()
+ .map(|c| c.path)
+ .find(|p| p.file_name().is_some_and(|n| n == "PingFang.ttc") && p.is_file());
+ let Some(bytes) = path.and_then(|p| std::fs::read(p).ok()) else {
+ eprintln!("PingFang is not installed here: skipped");
+ return;
+ };
+ for (script, region) in [(Script::TraditionalChinese, "TC"), (Script::SimplifiedChinese, "SC")] {
+ let index = pick_face(&bytes, script.probe(), &[region], false).expect("PingFang covers it");
+ let font = skrifa::FontRef::from_index(&bytes, index).unwrap();
+ let family: String = font.localized_strings(StringId::FAMILY_NAME).next().unwrap().chars().collect();
+ assert!(family.contains(region), "{script:?} got {family:?}");
+ }
+ }
+ /// A face that this macOS keeps only in its downloaded font assets (PingFang, on recent
+ /// versions) is among the candidates. The assets are searched here on their own, not by the
+ /// code under test; where there are none, nothing is checked.
+ #[cfg(target_os = "macos")]
+ #[test]
+ fn macos_candidates_include_a_pingfang_that_lives_in_the_font_assets() {
+ fn find(dir: &Path, name: &str, depth: u32) -> Option<PathBuf> {
+ for entry in std::fs::read_dir(dir).ok()?.flatten() {
+ let path = entry.path();
+ if path.file_name().is_some_and(|n| n == name) && path.is_file() {
+ return Some(path);
+ }
+ if depth > 0
+ && path.is_dir()
+ && !path.is_symlink()
+ && let Some(found) = find(&path, name, depth - 1)
+ {
+ return Some(found);
+ }
+ }
+ None
+ }
+ let Some(asset) = find(Path::new("/System/Library/AssetsV2"), "PingFang.ttc", 3) else {
+ eprintln!("no PingFang in the font assets here: skipped");
+ return;
+ };
+ for script in [Script::SimplifiedChinese, Script::TraditionalChinese] {
+ assert!(
+ candidates(script, ChineseFamily::Default, false).iter().any(|c| c.path == asset),
+ "{script:?}: {} is not a candidate",
+ asset.display()
+ );
+ }
+ }
+}
diff --cc crates/ui-egui/src/a11y_ui.rs
index 2130c927a,2130c927a..8dc348812
--- a/crates/ui-egui/src/a11y_ui.rs
+++ b/crates/ui-egui/src/a11y_ui.rs
@@@ -542,7 -542,7 +542,9 @@@ fn figure_picture(ctx: &egui::Context,
w: (w * scale).ceil().max(1.0) as u32,
h: (h * scale).ceil().max(1.0) as u32,
};
-- let config = pdfcraft_render::RenderConfig { password: doc.password.as_deref().map(std::sync::Arc::from), ..Default::default() };
++ // The picture is only shown in the panel, so it draws like the viewer (installed CJK faces
++ // for fonts the PDF doesn't embed); nothing is saved from it (AGENTS.md §1.4).
++ let config = pdfcraft_render::RenderConfig { password: doc.password.as_deref().map(std::sync::Arc::from), ..Default::default() }.on_screen();
let mut r = pdfcraft_render::PageRenderer::new(doc.bytes.clone(), config);
let out = r.render(pdfcraft_render::RenderRequest {
page,
diff --cc crates/ui-egui/src/combine_grid.rs
index ee3b03f69,ee3b03f69..40c871953
--- a/crates/ui-egui/src/combine_grid.rs
+++ b/crates/ui-egui/src/combine_grid.rs
@@@ -373,7 -373,7 +373,7 @@@ impl Thumbs
waiting = true;
break;
}
-- let config = RenderConfig { password: w.password, ..Default::default() };
++ let config = thumbnail_config(w.password);
#[cfg(test)]
let pool = if self.inline { RenderPool::new_inline(w.bytes, config) } else { RenderPool::new(w.bytes, 1, config).without_replacements() };
#[cfg(not(test))]
@@@ -423,6 -423,6 +423,13 @@@
}
}
++/// The render configuration of a Combine thumbnail. Thumbnails are only shown on screen, so
++/// installed CJK faces may draw fonts a PDF doesn't embed, as in the viewer; the combined file
++/// itself is written from the original bytes and never from these rasters (AGENTS.md §1.4).
++fn thumbnail_config(password: Option<Arc<str>>) -> RenderConfig {
++ RenderConfig { password, ..Default::default() }.on_screen()
++}
++
/// A rendered thumbnail as a texture, and its size in bytes. A raster that doesn't add up, or is
/// larger than a thumbnail can be (or than the GPU accepts), is refused, never uploaded.
fn texture(
@@@ -1355,6 -1355,6 +1362,16 @@@ mod tests
use super::*;
use crate::combine_ui::{moved_order, step_to};
++ /// Combine thumbnails are on-screen rasters: like the viewer, they may draw a non-embedded
++ /// CJK font with an installed face, and they keep the file's password.
++ #[test]
++ fn thumbnails_use_the_on_screen_configuration() {
++ let config = thumbnail_config(Some(Arc::from("secret")));
++ assert!(config.system_fonts, "Combine thumbnails draw non-embedded CJK text like the viewer");
++ assert_eq!(config.password.as_deref(), Some("secret"));
++ assert!(!RenderConfig::default().system_fonts, "anything else stays off by default");
++ }
++
#[test]
fn long_names_keep_their_extension_and_whole_characters() {
let fits = |n: usize| move |s: &str| s.chars().count() <= n;
diff --cc docs/development.md
index 4851f77ee,1c6cce6a9..43f0ceba9
--- a/docs/development.md
+++ b/docs/development.md
@@@ -133,7 -133,7 +133,7 @@@ copies retain their current preference
| `PDFCRAFT_TITLEBAR` | Linux: `app` draws PdfCraft's own title bar (window buttons in the tab strip, in the order of GNOME's `button-layout`, and resize edges); `system` keeps the frame winit or the desktop draws; unset, PdfCraft draws its own when the Wayland compositor draws no frames (GNOME), and leaves it to the desktop otherwise (KDE, Sway, Hyprland, X11). Where PdfCraft draws it, Preferences ▸ Use system title bar switches back to winit's frame without a restart; `system` also hides that option |
| `PDFCRAFT_BUILD_LABEL` | Build time: a label for a local or patched build (letters, digits, inner dots), shown after the version in `--version`, About and the log (`0.7.1 (titlebar)`). `packaging/linux/package.sh` also puts it in the file names and the .rpm/.deb release (`1.titlebar`), which upgrades over the release of the same version |
| `CRAFT_FONTS_DIR` | Build time: a [craft-fonts](https://github.com/storytold/craft-fonts) checkout to embed (Japanese fonts) |
- | `PDFCRAFT_SYSTEM_FONTS` | `0` disables installed-font fallback for both interface text and non-embedded CJK page text in the desktop viewer (`cargo xtask screenshots` sets it). Document fallback is display-only: exports, printing, OCR and automation retain the bundled-font path. |
-| `PDFCRAFT_SYSTEM_FONTS` | `0` stops the desktop app from using an installed font for characters its embedded fonts lack (`cargo xtask screenshots` sets it) |
++| `PDFCRAFT_SYSTEM_FONTS` | `0` disables installed-font fallback for both interface text and non-embedded CJK page text in the desktop viewer, Combine thumbnails and accessibility figure previews (`cargo xtask screenshots` sets it). Document fallback is display-only: exports, printing, OCR and automation retain the bundled-font path. |
| `FONTCONFIG_FILE` | On Linux/Unix, the Fontconfig configuration file used to discover installed UI fallback fonts (default: `/etc/fonts/fonts.conf`); relative filenames are resolved under `FONTCONFIG_PATH` |
| `FONTCONFIG_PATH` | Directory for a relative `FONTCONFIG_FILE` (default: `/etc/fonts`; the first entry of a search path is used) |
diff --cc docs/roadmap.md
index 2b290575c,92d91503b..5f96e0f43
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@@ -1,5 -1,5 +1,7 @@@
# PdfCraft roadmap: milestones and what's next
++> **Last reviewed:** 2026-10-23 · **Last updated:** 2026-10-23 · **Change:** minor (M2, PR #4172: CJK fallback in Combine thumbnails and figure previews; FangSong and subset-prefixed Founder family matching; estimates unchanged)
++
> **Last reviewed:** 2026-10-22 · **Last updated:** 2026-10-22 · **Change:** minor (M14, #3558: rebase guarded macOS per-file association recovery onto current main; estimates unchanged)
> **Last reviewed:** 2026-10-20 · **Last updated:** 2026-10-20 · **Change:** minor (M12 #3673: Character encoding accepts Identity-H/V with Adobe CJK collections; estimates unchanged)
@@@ -155,7 -149,7 +157,7 @@@ total matches the parity estimate
|---|---|---|---|---|---|
| M0 | Skeleton: workspace, xtask gates, CI | 15–30 | 98% | 1–2 | GitHub workflow, `deny.toml` (licence audit of every dependency), parity checklist (826 features, `xtask parity`) done. Missing: remaining crate stubs, testkit/oracle crates |
| M1 | COS: filters, crypt, parser, xref, writer | 120–200 | 80% | 20–40 | Done:<br>- filters and crypt: every standard-security revision R2–R6 (RC4, AES-128/256), SASLprep, permissions, creating encryption;<br>- cos: parse and repair (including invalid xref object-number ranges), decoded-stream limits including unfiltered data, decrypt on load, re-encrypt on save, incremental and full writing.<br>Corpus: open/edit/save passes on 958 files, and all 7 password-protected files open.<br>Full saves now pack objects into compressed object streams. An unchanged incremental save of a classic table writes a zero-length cross-reference subsection instead of a section with no subsections (#1339). A full rewrite keeps unknown trailer entries, including objects reachable only from them (#1338). Fuzzing runs nightly (`xtask fuzz`). Raw-deflate fallback preserves decoding-limit errors, including through tolerant COS stream decoding. Done since: #2658: macOS atomic saves retain destination extended attributes, including Finder tags, and reject partial resource-fork reads after size changes. Metadata failures retain the original PDF and unsaved edit. Missing: ≥ 250 tests, own image codecs |
- | M2 | Model, render, text | 200–350 | 15% | 130–230 | hayro bootstrap renderer (vendored patches); inspector predictor scratch is bounded by available input, and JPX sample rescaling handles 1–32 bits safely. Text extraction reaches word-F1 0.98 against pdftotext. Short same-line redraws split before placement rather than interleaving. Missing: model crate, fonts, DisplayList, renderer independent of hayro. Inspector page-label traversal and output are resource-bounded, with physical-number fallback warnings. Packed TIFF-predictor RGB rows retain later rows in decoding and rendering. Page marks, added content and print output retain small page-unit transform coefficients when serialized. Forms without Resources use page Properties for ActualText and layer visibility; own dictionaries stop fallback. Oversized missing inline-image samples, including header and terminator overhead, no longer pin the content window (#3107 / PR #3438); normal large streamed images retain deterministic sample boundaries. Radial luminosity fades have synthetic coverage for the existing #2132 mask guard, including per-pixel references, antialiased clips, previews, scales and tiles; no additional production fix was needed. Dotted TOC leaders no longer inflate letter tracking or hide word spaces (#3086); phrase search and selection are covered. Short tracked ellipses retain their gap samples and remain searchable. Missing spacing glyphs in non-embedded Japanese CID substitutes render blank without changing PDF advances or Unicode (#3601). The desktop viewer can use installed CJK fonts, including Windows GBK Song/Hei/Kai faces, without changing export or print font policy (#234, continuation of #1567). |
-| M2 | Model, render, text | 200–350 | 15% | 130–230 | hayro bootstrap renderer (vendored patches); inspector predictor scratch is bounded by available input, and JPX sample rescaling handles 1–32 bits safely. Text extraction reaches word-F1 0.98 against pdftotext. Short same-line redraws split before placement rather than interleaving. Missing: model crate, fonts, DisplayList, renderer independent of hayro. Inspector page-label traversal and output are resource-bounded, with physical-number fallback warnings. Packed TIFF-predictor RGB rows retain later rows in decoding and rendering. Page marks, added content and print output retain small page-unit transform coefficients when serialized. Forms without Resources use page Properties for ActualText and layer visibility; own dictionaries stop fallback. Oversized missing inline-image samples, including header and terminator overhead, no longer pin the content window (#3107 / PR #3438); normal large streamed images retain deterministic sample boundaries. Radial luminosity fades have synthetic coverage for the existing #2132 mask guard, including per-pixel references, antialiased clips, previews, scales and tiles; no additional production fix was needed. Dotted TOC leaders no longer inflate letter tracking or hide word spaces (#3086); phrase search and selection are covered. Short tracked ellipses retain their gap samples and remain searchable. Missing spacing glyphs in non-embedded Japanese CID substitutes render blank without changing PDF advances or Unicode (#3601). |
++| M2 | Model, render, text | 200–350 | 15% | 130–230 | hayro bootstrap renderer (vendored patches); inspector predictor scratch is bounded by available input, and JPX sample rescaling handles 1–32 bits safely. Text extraction reaches word-F1 0.98 against pdftotext. Short same-line redraws split before placement rather than interleaving. Missing: model crate, fonts, DisplayList, renderer independent of hayro. Inspector page-label traversal and output are resource-bounded, with physical-number fallback warnings. Packed TIFF-predictor RGB rows retain later rows in decoding and rendering. Page marks, added content and print output retain small page-unit transform coefficients when serialized. Forms without Resources use page Properties for ActualText and layer visibility; own dictionaries stop fallback. Oversized missing inline-image samples, including header and terminator overhead, no longer pin the content window (#3107 / PR #3438); normal large streamed images retain deterministic sample boundaries. Radial luminosity fades have synthetic coverage for the existing #2132 mask guard, including per-pixel references, antialiased clips, previews, scales and tiles; no additional production fix was needed. Dotted TOC leaders no longer inflate letter tracking or hide word spaces (#3086); phrase search and selection are covered. Short tracked ellipses retain their gap samples and remain searchable. Missing spacing glyphs in non-embedded Japanese CID substitutes render blank without changing PDF advances or Unicode (#3601). The desktop viewer can use installed CJK fonts, including Windows GBK Song/Hei/Kai/FangSong and subset-prefixed Founder names; Combine thumbnails and accessibility figure previews use the same display-only fallback, without changing export or print font policy (#234, continuation of #1567, review #4172). |
| M2 | Model, render, text | 200–350 | 15% | 130–230 | hayro bootstrap renderer (vendored patches); inspector predictor scratch is bounded by available input, and JPX sample rescaling handles 1–32 bits safely. Text extraction reaches word-F1 0.98 against pdftotext. Short same-line redraws split before placement rather than interleaving. Missing: model crate, fonts, DisplayList, renderer independent of hayro. Inspector page-label traversal and output are resource-bounded, with physical-number fallback warnings. Packed TIFF-predictor RGB rows retain later rows in decoding and rendering. The renderer keeps its one-point crop-size floor in physical points after UserUnit scaling, with regression coverage for crop origins, rotations and f32 reciprocal rounding. Existing unit policy and nearly-zero fallback are retained. |
| M2 | Model, render, text | 200–350 | 15% | 130–230 | hayro bootstrap renderer (vendored patches); inspector predictor scratch is bounded by available input, and JPX sample rescaling handles 1–32 bits safely. Text extraction reaches word-F1 0.98 against pdftotext. Short same-line redraws split before placement rather than interleaving. Missing: model crate, fonts, DisplayList, renderer independent of hayro. Inspector page-label traversal and output are resource-bounded, with physical-number fallback warnings |
| M3 | Viewer app (native + web) | 80–150 | 90% | 10–20 | Acrobat-style shell, find, select, panels, tiles, web build, UI control channel for agents (opt-in). #3808: the Pages inspector offers a 50–150% thumbnail slider and buttons, also available through `ui.set`. Missing: 60 fps test on a 500-page document, snapshot tests of every panel<br>Done since: fit visible, document title in the window; Linux middle-button scrolling; shared three-state theme preferences in the toolbar, View menu and control channel; numeric Linux portal events and idle wakeups completing #881, with native appearance inheritance retained (#446); late browser startup downloads preserve the current document and Save target (#171). Selected-text Copy in Edit and the canvas context menu is covered by focused regressions and native clipboard checks (#1225); document copy restrictions apply to the floating action too. #1364 candidate: absolute local GoToR links ask before target access; headless callers explicitly opt in. Native-opening candidate: chosen tools survive preparation and password retries; startup intake waits for pending preparation. Page-label navigation displays logical labels, retains the current page on unchanged submission and refreshes focused same-document replacements; clean file-watcher reload preserves the chosen scrolling mode, preventing a Single Page reader from jumping to page 1 during replacement. Synthetic control regressions cover these behaviors. #3149: page-list changes discard render demand based on old geometry; actual raster dimensions are checked against the GPU limit before upload. Synthetic crash and continued-rendering regressions cover the replacement path. Save-prompt shortcuts yield to dialogs above them; stacked link-consent UI regression covers Escape and Return. Comment hover follows individual marked lines and original annotation paint order (#3541/#3620), independently of spatial inspection sorting; synthetic rotation, differing-upper-edge overlap and unchanged-document regressions. Optional page gaps join page edges without cropping PDF margins; current-document toggle, persisted default and UI control options are covered by viewer tests. Gap changes in Organize Pages preserve document scroll position, and both comparison panes follow menu and control choices. |
@@@ -238,6 -232,6 +240,8 @@@ M2 (renderer), M7 (content editing), M1
## Revision history
++**2026-10-23 · minor:** M2/PR #4172: display-only CJK fallback covers Combine thumbnails and accessibility figure previews. Windows family matching includes FangSong and subset-prefixed Founder names. Export, print, OCR and automation policy and readiness estimates are unchanged.
++
**2026-10-20 · minor:** M2/#3601: substitute-font spacing aliases preserve blank ink, original `/W` and `/DW` advances, and Unicode extraction. Synthetic renderer regressions cover the reported Japanese CID fixture. Estimates unchanged.
**2026-10-15 · minor:** M14/#2383 candidate: GPU device requests clamp unsupported limits while retaining the adapter texture extent. Synthetic V3D/downlevel regressions and Windows GPU-required tests pass; Raspberry Pi hardware remains unverified. Estimates unchanged.
diff --cc parity/acrobat-features.toml
index 9afb691b3,6a2d0ccf9..00078ca81
--- a/parity/acrobat-features.toml
+++ b/parity/acrobat-features.toml
@@@ -782,8 -782,8 +782,8 @@@ milestone = "M2
status = "partial"
commands = []
tools = []
-evidence = ["crates/render/src/raster.rs::huge_cid_width_ranges_terminate", "crates/render/src/raster.rs::non_embedded_japanese_cid_fonts_draw_with_a_craft_fonts_face", "crates/render/src/raster.rs::mincho_substitute_covers_half_width_katakana", "crates/render/src/text.rs::identity_to_unicode_names_give_text", "crates/fonts/src/pdf.rs::identity_to_unicode_names_read_codes_as_unicode"]
-notes = "CID-to-Unicode tables are M2.4; a non-embedded Adobe-Japan1 font is drawn in a craft-fonts Japanese face (Mincho or Gothic by name; BIZ UDMincho for Mincho, which covers half-width katakana) when built with craft-fonts; non-embedded GB1, CNS1 and Korea1 fonts still draw nothing (no allowed face); a `/ToUnicode` given as the name `/Identity-H` or `/Identity-V` (WSCAD) reads codes as Unicode for selection, search and editing, without control characters"
+evidence = ["crates/render/src/raster.rs::huge_cid_width_ranges_terminate", "crates/render/src/raster.rs::non_embedded_japanese_cid_fonts_draw_with_a_craft_fonts_face", "crates/render/src/raster.rs::mincho_substitute_covers_half_width_katakana", "crates/render/src/raster.rs::non_embedded_chinese_and_korean_cid_fonts_draw_with_an_installed_face", "crates/engine/src/tests.rs::installed_cjk_fonts_draw_in_the_viewer_but_not_in_an_export", "crates/render/src/text.rs::identity_to_unicode_names_give_text", "crates/fonts/src/pdf.rs::identity_to_unicode_names_read_codes_as_unicode"]
- notes = "CID-to-Unicode tables are M2.4; a non-embedded Adobe-Japan1 font is drawn in a craft-fonts Japanese face (Mincho or Gothic by name; BIZ UDMincho for Mincho, which covers half-width katakana) when built with craft-fonts; the desktop viewer can fall back to an installed CJK face for GB1, CNS1, Korea1 and Japan1, including GBK-EUC-H TrueType CID fonts without ToUnicode. Windows preserves installed SimSun, SimHei and KaiTi families. System faces are display-only, disabled by PDFCRAFT_SYSTEM_FONTS=0, and not used by export, printing, OCR or automation; machines without a candidate and web builds remain unsupported. A `/ToUnicode` given as the name `/Identity-H` or `/Identity-V` (WSCAD) reads codes as Unicode for selection, search and editing, without control characters"
++notes = "CID-to-Unicode tables are M2.4; a non-embedded Adobe-Japan1 font is drawn in a craft-fonts Japanese face (Mincho or Gothic by name; BIZ UDMincho for Mincho, which covers half-width katakana) when built with craft-fonts; the desktop viewer can fall back to an installed CJK face for GB1, CNS1, Korea1 and Japan1, including GBK-EUC-H TrueType CID fonts without ToUnicode. Windows preserves installed SimSun, SimHei, KaiTi and FangSong families, including subset-prefixed Founder aliases. Combine thumbnails and accessibility figure previews use the same on-screen fallback. System faces are display-only, disabled by PDFCRAFT_SYSTEM_FONTS=0, and not used by export, printing, OCR or automation; machines without a candidate and web builds remain unsupported. A `/ToUnicode` given as the name `/Identity-H` or `/Identity-V` (WSCAD) reads codes as Unicode for selection, search and editing, without control characters"
[[feature]]
id = "view.render-image-codecs"