Feat/factchat bridge v0.7.13 12

.github/workflows/ci.yml

@@ -83,6 +83,9 @@ jobs:
       - name: Format check
         run: cargo fmt --all -- --check
 
+      - name: Renderer overfit guard
+        run: python3 scripts/check_renderer_overfit.py
+
       - name: Build
         run: cargo build --verbose
 

.github/workflows/render-diff.yml

@@ -10,6 +10,8 @@ on:
       - 'src/renderer/**'
       - 'src/document_core/queries/rendering.rs'
       - 'src/wasm_api.rs'
+      - 'scripts/check_renderer_overfit.py'
+      - 'scripts/renderer_overfit_baseline.txt'
       - 'rhwp-studio/**'
       - '.github/workflows/render-diff.yml'
   workflow_dispatch:
@@ -93,6 +95,9 @@ jobs:
           node --check e2e/canvas-render-diff.test.mjs
           node --check e2e/run-render-diff.mjs
 
+      - name: Renderer overfit guard
+        run: python3 scripts/check_renderer_overfit.py
+
       - name: Run canvas visual diff
         working-directory: rhwp-studio
         env:

Cargo.toml

@@ -17,6 +17,13 @@ path = "src/main.rs"
 name = "font-metric-gen"
 path = "src/tools/font_metric_gen.rs"
 
+# === [Mindlogic — fidelity corpus integration tests] ===
+# Lives under tests/integration/ (Cargo's default discovery picks up
+# only top-level tests/*.rs; nested files need an explicit entry).
+[[test]]
+name = "test_fidelity_corpus"
+path = "tests/integration/test_fidelity_corpus.rs"
+
 [dependencies]
 wasm-bindgen = "0.2"
 cfb = "0.14"

examples/diag_empty_para_trap.rs

@@ -0,0 +1,168 @@
+// Diagnose the insertFootnote/insertEquation 'unreachable' trap on form_19's
+// empty body paragraph by emulating the agent-bridge call sequence natively.
+use rhwp::model::control::Control;
+use rhwp::wasm_api::HwpDocument;
+use std::panic::{catch_unwind, AssertUnwindSafe};
+
+fn load() -> HwpDocument {
+    let bytes = std::fs::read("samples/form_19_empty_para.hwpx").expect("read fixture");
+    HwpDocument::from_bytes(&bytes).expect("parse")
+}
+
+fn step(name: &str, f: impl FnOnce()) {
+    match catch_unwind(AssertUnwindSafe(f)) {
+        Ok(()) => println!("  ok    {name}"),
+        Err(e) => {
+            let msg = e
+                .downcast_ref::<String>()
+                .cloned()
+                .or_else(|| e.downcast_ref::<&str>().map(|s| s.to_string()))
+                .unwrap_or_else(|| "<non-string panic>".into());
+            println!("  PANIC {name}: {msg}");
+        }
+    }
+}
+
+fn main() {
+    let doc = load();
+    {
+        let document = doc.document();
+        let section = &document.sections[0];
+        println!("paragraphs: {}", section.paragraphs.len());
+        for (pi, para) in section.paragraphs.iter().enumerate().take(12) {
+            let has_table = para.controls.iter().any(|c| matches!(c, Control::Table(_)));
+            let kinds: Vec<&str> = para
+                .controls
+                .iter()
+                .map(|c| match c {
+                    Control::Table(_) => "Table",
+                    Control::Shape(_) => "Shape",
+                    Control::Footnote(_) => "Footnote",
+                    Control::Bookmark(_) => "Bookmark",
+                    Control::AutoNumber(_) => "AutoNumber",
+                    _ => "Other",
+                })
+                .collect();
+            println!(
+                "  p{pi}: table={has_table} text={:?} chars(text)={} char_count={} offsets={} controls={:?} linesegs={}",
+                para.text.chars().take(30).collect::<String>(),
+                para.text.chars().count(),
+                para.char_count,
+                para.char_offsets.len(),
+                kinds,
+                para.line_segs.len(),
+            );
+        }
+    }
+
+    // The probe's P_TEXT actually resolves to an empty-text TABLE-HOSTING
+    // paragraph: both form_19 paragraphs host tables, the probe splits p0 to
+    // manufacture a text para at p1, and P_TEXT = s0:p2 = the shifted
+    // original p1 (table host, text="", char_offsets=[]).
+    let p_text = 1usize; // pristine-doc equivalent: the second table para
+    println!("P_TEXT equivalent = s0:p{p_text} (table host, empty text)");
+
+    println!("--- footnote sequence (bridge emulation, offset 0, with inner text) ---");
+    let mut d = load();
+    step("beginBatch", || {
+        d.begin_batch().unwrap();
+    });
+    let mut ctrl_idx = 0usize;
+    step("insertFootnote(sec=0, para=P_TEXT, offset=0)", || {
+        let r = d.insert_footnote_native(0, p_text, 0).expect("insert");
+        println!("        -> {r}");
+        ctrl_idx = r
+            .split("\"controlIdx\":")
+            .nth(1)
+            .and_then(|s| s.split([',', '}']).next())
+            .and_then(|s| s.parse().ok())
+            .unwrap_or(0);
+    });
+    step("insertTextInFootnote(..., inner=0, off=0)", || {
+        let r = d
+            .insert_text_in_footnote_native(0, p_text, ctrl_idx, 0, 0, "프로브 각주")
+            .expect("insert text in footnote");
+        println!("        -> {r}");
+    });
+    step("endBatch", || {
+        d.end_batch().unwrap();
+    });
+    step("render all pages", || {
+        for pg in 0..d.page_count() {
+            d.render_page_svg(pg).unwrap();
+        }
+    });
+    step("snapshot save+restore", || {
+        let id = d.save_snapshot();
+        d.restore_snapshot(id).unwrap();
+    });
+
+    println!("--- equation sequence (offset 0) ---");
+    let mut d2 = load();
+    step("beginBatch", || {
+        d2.begin_batch().unwrap();
+    });
+    step("insertEquation(sec=0, para=P_TEXT, offset=0)", || {
+        let r = d2
+            .insert_equation_native(0, p_text, 0, "a^2+b^2=c^2", 1200, 0)
+            .expect("insert equation");
+        println!("        -> {r}");
+    });
+    step("endBatch", || {
+        d2.end_batch().unwrap();
+    });
+    step("render all pages", || {
+        for pg in 0..d2.page_count() {
+            d2.render_page_svg(pg).unwrap();
+        }
+    });
+    step("snapshot save+restore", || {
+        let id = d2.save_snapshot();
+        d2.restore_snapshot(id).unwrap();
+    });
+
+    println!("--- exact probe emulation: split p0, text at p1, footnote at p2 off 0 ---");
+    let mut d3 = load();
+    step("splitParagraph(p0 at end) + insertText(p1)", || {
+        let len = {
+            let para = &d3.document().sections[0].paragraphs[0];
+            para.text.chars().count() as u32
+        };
+        d3.split_paragraph(0, 0, len).unwrap();
+        d3.insert_text(0, 1, 0, "프로브 텍스트 문단").unwrap();
+    });
+    step("beginBatch", || {
+        d3.begin_batch().unwrap();
+    });
+    let mut ctrl_idx3 = 0usize;
+    step("insertFootnote(sec=0, para=2, offset=0)", || {
+        let r = d3.insert_footnote_native(0, 2, 0).expect("insert");
+        println!("        -> {r}");
+        ctrl_idx3 = r
+            .split("\"controlIdx\":")
+            .nth(1)
+            .and_then(|s| s.split([',', '}']).next())
+            .and_then(|s| s.parse().ok())
+            .unwrap_or(0);
+    });
+    step("insertTextInFootnote(..., inner=0, off=0)", || {
+        let r = d3
+            .insert_text_in_footnote_native(0, 2, ctrl_idx3, 0, 0, "프로브 각주")
+            .expect("insert text in footnote");
+        println!("        -> {r}");
+    });
+    step("endBatch", || {
+        d3.end_batch().unwrap();
+    });
+    step("render all pages", || {
+        for pg in 0..d3.page_count() {
+            d3.render_page_svg(pg).unwrap();
+        }
+    });
+    step("snapshot save+restore", || {
+        let id = d3.save_snapshot();
+        d3.restore_snapshot(id).unwrap();
+    });
+
+    println!("done");
+}

examples/edit_textloss_scan.rs

@@ -0,0 +1,76 @@
+//! Scan: for each input doc, compare <hp:t> char counts between the no-edit
+//! export (raw pass-through) and an edited export (forced re-serialize).
+//! Any deficit beyond the inserted text = content destroyed by edit-path
+//! re-serialization.
+//!
+//!   cargo run --release --example edit_textloss_scan -- <doc.hwpx> [...]
+
+use std::env;
+use std::fs;
+
+use rhwp::document_core::DocumentCore;
+
+fn t_chars(bytes: &[u8]) -> usize {
+    let cursor = std::io::Cursor::new(bytes);
+    let mut zip = zip::ZipArchive::new(cursor).expect("zip");
+    let mut total = 0usize;
+    let names: Vec<String> = (0..zip.len())
+        .map(|i| zip.by_index(i).unwrap().name().to_string())
+        .filter(|n| n.starts_with("Contents/section") && n.ends_with(".xml"))
+        .collect();
+    for n in names {
+        use std::io::Read;
+        let mut xml = String::new();
+        zip.by_name(&n).unwrap().read_to_string(&mut xml).unwrap();
+        let mut rest = xml.as_str();
+        while let Some(i) = rest.find("<hp:t>") {
+            rest = &rest[i + 6..];
+            if let Some(j) = rest.find("</hp:t>") {
+                total += rest[..j].chars().count();
+                rest = &rest[j..];
+            } else {
+                break;
+            }
+        }
+    }
+    total
+}
+
+fn main() {
+    const INS: &str = "probe ";
+    for path in env::args().skip(1) {
+        let data = match fs::read(&path) {
+            Ok(d) => d,
+            Err(e) => { println!("{path}: READ ERR {e}"); continue; }
+        };
+        let core = match DocumentCore::from_bytes(&data) {
+            Ok(c) => c,
+            Err(e) => { println!("{path}: PARSE ERR {e:?}"); continue; }
+        };
+        let dump = env::var("DUMP_DIR").ok();
+        let stem = std::path::Path::new(&path)
+            .file_stem()
+            .map(|s| s.to_string_lossy().to_string())
+            .unwrap_or_else(|| "doc".into());
+        let base_bytes = match core.export_hwpx_native() { Ok(b) => b, Err(e) => { println!("{path}: EXPORT ERR {e:?}"); continue; } };
+        if let Some(ref d) = dump { let _ = fs::write(format!("{d}/{stem}.base.hwpx"), &base_bytes); }
+        let base = t_chars(&base_bytes);
+
+        let mut core = DocumentCore::from_bytes(&data).expect("parse2");
+        if core.insert_text_native(0, 0, 0, INS).is_err() {
+            println!("{path}: EDIT ERR");
+            continue;
+        }
+        match core.export_hwpx_native() {
+            Ok(b) => {
+                if let Some(ref d) = dump { let _ = fs::write(format!("{d}/{stem}.edited.hwpx"), &b); }
+                let after = t_chars(&b);
+                let expected = base + INS.chars().count();
+                let delta = after as i64 - expected as i64;
+                let flag = if delta < 0 { "LOSS" } else { "ok" };
+                println!("{path}: base={base} after={after} delta_vs_expected={delta} {flag}");
+            }
+            Err(e) => println!("{path}: EXPORT2 ERR {e:?}"),
+        }
+    }
+}

examples/fuzz_empty_para_inserts.rs

@@ -0,0 +1,79 @@
+// Corpus-wide regression fuzz for the ctrl_data_records trap family:
+// for every .hwpx in samples/corpus_tmp/, insert a footnote and an equation
+// at offset 0 of each of the first paragraphs (covers p0 sectiondef hosts,
+// table hosts, and plain text paras), then render every page and round-trip
+// a snapshot. Any panic = the 'unreachable' WASM trap shape. Exits non-zero
+// if anything fails.
+use rhwp::wasm_api::HwpDocument;
+use std::panic::{catch_unwind, AssertUnwindSafe};
+
+fn main() {
+    let dir = "samples/corpus_tmp";
+    let mut files: Vec<_> = std::fs::read_dir(dir)
+        .expect("read corpus dir")
+        .filter_map(|e| e.ok())
+        .map(|e| e.path())
+        .filter(|p| p.extension().map(|x| x == "hwpx").unwrap_or(false))
+        .collect();
+    files.sort();
+    assert!(!files.is_empty(), "no corpus files in {dir}");
+
+    let mut failures = 0usize;
+    let mut checks = 0usize;
+    for path in &files {
+        let name = path.file_name().unwrap().to_string_lossy().to_string();
+        let bytes = match std::fs::read(path) {
+            Ok(b) => b,
+            Err(e) => {
+                println!("FAIL read {name}: {e}");
+                failures += 1;
+                continue;
+            }
+        };
+        let para_count = match catch_unwind(AssertUnwindSafe(|| {
+            HwpDocument::from_bytes(&bytes)
+                .map(|d| d.document().sections[0].paragraphs.len())
+        })) {
+            Ok(Ok(n)) => n,
+            Ok(Err(e)) => {
+                println!("SKIP parse {name}: {e:?}");
+                continue;
+            }
+            Err(_) => {
+                println!("FAIL parse-panic {name}");
+                failures += 1;
+                continue;
+            }
+        };
+
+        for para in 0..para_count.min(4) {
+            for op in ["footnote", "equation"] {
+                checks += 1;
+                let bytes = bytes.clone();
+                let ok = catch_unwind(AssertUnwindSafe(|| {
+                    let mut doc = HwpDocument::from_bytes(&bytes).unwrap();
+                    let res = match op {
+                        "footnote" => doc.insert_footnote_native(0, para, 0),
+                        _ => doc.insert_equation_native(0, para, 0, "a^2+b^2=c^2", 1200, 0),
+                    };
+                    res.expect("insert");
+                    for pg in 0..doc.page_count() {
+                        doc.render_page_svg(pg).expect("render");
+                    }
+                    let id = doc.save_snapshot();
+                    doc.restore_snapshot(id).expect("restore");
+                }))
+                .is_ok();
+                if !ok {
+                    println!("FAIL {op} {name} p{para}");
+                    failures += 1;
+                }
+            }
+        }
+        println!("ok   {name} ({} paras probed)", para_count.min(4));
+    }
+    println!("---\n{checks} insert checks over {} docs, {failures} failures", files.len());
+    if failures > 0 {
+        std::process::exit(1);
+    }
+}