HTML import: bold header cells, cell alignment and the region paper (#1381) (#1494)

* #1381: WIP * #1381: HTML import: bold <th>, cell text-align, region paper for HTML/MD/TXT Header cells are bold unless their own CSS says otherwise. text-align on a td/th, or inherited from its tr/row group/table, aligns the cell's paragraphs; a paragraph's own alignment wins, and a table's align attribute (which places the table) no longer counts. Files that give no page size (HTML, Markdown, plain text) open on the region's paper, as a new blank document does: file.open uses the session's region, wordcraft-cli reads the system region the way the app does (Region::from_locale_vars, shared with ui-egui). Tables size to that page. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * #1381: the CLI uses the system region everywhere; help mentions WORDCRAFT_REGION Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Dmitrii Khlapov <19991457+dkhlapov@users.noreply.github.com> Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Brandon Thomas <echelon@gmail.com>
2026-10-24 10:27:44 -06:00 · 2026-10-14 13:58:14 -04:00
parent 686f71cabb
commit bf2bd69470
16 changed files with 397 additions and 44 deletions
@@ -5133,6 +5133,7 @@ name = "wordcraft-cli"
 version = "0.7.0"
 dependencies = [
 "serde_json",
+ "sys-locale",
 "wordcraft-doc",
 "wordcraft-engine",
 "wordcraft-mcp",
@@ -2,7 +2,7 @@

 **Stage: alpha** · next: beta, ~15 points (60% → 75% ready for real work) and ~150–230 h away

-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** trivial (progress log: rounded rectangle corners, #1476; previously trivial: progress log: Save As type list, #1399; previously trivial: progress log: privacy options on save, #1062; previously trivial: progress log: equation pictures in theme colours on Windows, #1002; previously trivial: symbol fonts, #776; previously trivial: the save prompt answers from the keyboard, #861; previously trivial: table column and row markers on the rulers, #700; previously trivial: table borders and the resize handle drag on the page, #217; previously trivial: formatting revisions landed, #41; previously trivial: Draw tab ink, #307, and Draw Table and Eraser, #303, landed: catalog 402/434; previously minor: readiness table with hours per audience; full number back to the additive weighted sum, 60%; mainstream and essentials numbers added; alpha gate checked; previously major: full re-measure against Word for Mac 16.113.4; restructured to the craftrules progress-docs standard) · **Target:** Microsoft Word (Microsoft 365) for Mac 16.113.4
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** trivial (progress log: HTML table cells and region paper for opened HTML, #1381; previously trivial: progress log: rounded rectangle corners, #1476; previously trivial: progress log: Save As type list, #1399; previously trivial: progress log: privacy options on save, #1062; previously trivial: progress log: equation pictures in theme colours on Windows, #1002; previously trivial: symbol fonts, #776; previously trivial: the save prompt answers from the keyboard, #861; previously trivial: table column and row markers on the rulers, #700; previously trivial: table borders and the resize handle drag on the page, #217; previously trivial: formatting revisions landed, #41; previously trivial: Draw tab ink, #307, and Draw Table and Eraser, #303, landed: catalog 402/434; previously minor: readiness table with hours per audience; full number back to the additive weighted sum, 60%; mainstream and essentials numbers added; alpha gate checked; previously major: full re-measure against Word for Mac 16.113.4; restructured to the craftrules progress-docs standard) · **Target:** Microsoft Word (Microsoft 365) for Mac 16.113.4

 > **Printing update:** 2026-10-12 · direct desktop printing through craft-print; details below.

@@ -152,6 +152,7 @@ Ranked, to beta (detail and remaining milestones in [docs/roadmap.md](docs/roadm
 | 2026-10-13 | Interface size means what it says (#822): a chosen size is absolute, as in PhotoCraft and PdfCraft, so "100%" is one screen pixel per point even where the system reports 200 % (a bare window manager on X11, where winit guesses the scale from the monitor's DPI). The new default, Auto, keeps the system's display scale and its menu entry shows the size it draws at; sizes run 75–300 %. A saved size from before stays the same if it was the default (now Auto) and becomes absolute otherwise |
 | 2026-10-13 | Copying an equation also puts MathML in HTML on the clipboard beside the linear text like `y=2x_s` (#816; Word/LibreOffice paste not yet verified; OMML is #1297). HTML export writes equations as MathML too, and opening or pasting HTML with MathML gives equations back |
 | 2026-10-13 | The Equation tab's galleries, structure buttons and symbols keep the theme's colours on Windows: their pictures share a few textures written in place (no wipe of pictures already on screen, room for the built-ins at high display scales), instead of hundreds of small textures freed in bulk, which on DirectX 12 showed inverted, red or teal tiles (#1002) |
+| 2026-10-14 | HTML import (#1381): header cells (`<th>`) are bold unless their own CSS says otherwise, and `text-align` on a cell, its row, row group or table aligns the cell's paragraphs (a paragraph's own alignment wins), so `wordcraft-cli convert page.html out.docx` writes the bold header and `w:jc` right-aligned cells. HTML, Markdown and plain text, which give no page size, open on the region's paper (A4 in Italy, Letter in the US) like a new blank document, in the app and in `wordcraft-cli`; documents with their own page size keep it |
 | 2026-10-13 | Full screen (#980): F11, or View › Window › Full Screen, fills the screen with the window (⌃⌘F on macOS); F11 again or Escape gives back the window as it was. Next Field, which Word puts on F11, keeps Word's Alt+F1 and Alt+Shift+F1 (and Shift+F11). The web app leaves full screen to the browser's own F11 |
 | 2026-10-13 | Double-clicking the top or bottom margin of a page creates its header or footer when it has none and puts the caret in it, as in Word (#960): the one that page shows (different first page, odd and even pages), only in Print Layout; one left empty is taken away again when you leave it, so nothing empty is saved. `insert.editHeader`/`insert.editFooter` take `{"page"}` for agents |
 | 2026-10-13 | Alt+numpad character codes, as in Word on Windows (#961): hold Alt, type a decimal code, release Alt — `0233` → é (Windows-1252), `233` → Θ (OEM code page 437; 850 in Western European locales and English outside the US), codes above 255 are Unicode (`8364` → €). Not on macOS; `text.typeCode` for agents |
@@ -317,6 +318,7 @@ Ranked, to beta (detail and remaining milestones in [docs/roadmap.md](docs/roadm
 | 2026-10-13 | trivial | Progress log: the caret contrasts with its background (#299) |
 | 2026-10-13 | trivial | Progress log: clicks on ribbon chrome keep typing in the document (#1093) |
 | 2026-10-13 | trivial | Progress log: dragged shapes wrap in their new column (#884) |
+| 2026-10-14 | trivial | Progress log: HTML header cells, cell alignment and region paper for opened HTML/Markdown/text (#1381) |
 | 2026-10-13 | trivial | Progress log: full screen on F11 (#980) |
 | 2026-10-13 | trivial | Progress log: interface audit back in CI (#1128) |
 | 2026-10-13 | trivial | Progress log: double-click the margin to create and edit a header or footer (#960) |
@@ -20,3 +20,4 @@ wordcraft-render = { workspace = true }
 wordcraft-mcp = { workspace = true }
 wordcraft-zotero = { workspace = true }
 serde_json = { workspace = true }
+sys-locale = "0.3"
@@ -43,15 +43,36 @@ USAGE:
                                              addNote, refresh, removeCodes, setDocPrefs
                                              (--cmd runs first, e.g. --cmd caret.docEnd)
  wordcraft-cli --version
+
+Paper: documents created here, and HTML, Markdown and text files (which give no page size), use
+the system region's paper (A4, or Letter in the US and other Letter regions), read from
+LC_ALL / LC_PAPER / LANG or the platform. Set WORDCRAFT_REGION=en-US (or another tag) for the
+same output on every machine.
 ";

 fn open(path: &str) -> Result<Session, String> {
-    let doc = wordcraft_engine::io::open_path(std::path::Path::new(path))?;
-    let mut s = Session::new(doc);
+    // A file that gives no page size (HTML, Markdown, plain text) opens on the system region's
+    // paper, as in the app: A4 in Italy, Letter in the US (#1381).
+    let region = system_region();
+    let (doc, _) = wordcraft_engine::io::open_path_in(std::path::Path::new(path), None, &region)?;
+    let mut s = session(doc);
    s.path = Some(path.into());
    Ok(s)
 }

+/// A headless session in the system region: every way the CLI starts one gives `file.new` the
+/// same paper (#1381).
+fn session(doc: wordcraft_doc::Document) -> Session {
+    let mut s = Session::new(doc);
+    s.system_region = system_region();
+    s
+}
+
+/// The system region, read as the app reads it (locale variables, else the platform's locale).
+fn system_region() -> wordcraft_engine::Region {
+    wordcraft_engine::Region::from_locale_vars(|name| std::env::var(name).ok(), sys_locale::get_locale)
+}
+
 /// The body text for `text`: the plain-text export, so list items keep their bullet or number label.
 fn listed_text(doc: &wordcraft_doc::Document) -> Result<String, String> {
    let bytes = wordcraft_engine::io::save_bytes("out.txt", doc)?;
@@ -245,11 +266,11 @@ fn run(args: &[String]) -> Result<(), Failure> {
            let mut s = match (arg_value(&rest, "--file"), arg_value(&rest, "--template")) {
                (Some(f), _) => open(&f)?,
                (None, Some(t)) => {
-                    let mut s = Session::new(wordcraft_doc::Document::new());
+                    let mut s = session(wordcraft_doc::Document::new());
                    s.run("file.new", &json!({"template": t})).map_err(|e| e.to_string())?;
                    s
                }
-                _ => Session::new(wordcraft_doc::Document::new()),
+                _ => session(wordcraft_doc::Document::new()),
            };
            if let Some(name) = arg_value(&rest, "--author") {
                set_author(&mut s, &name)?;
@@ -291,7 +312,7 @@ fn run(args: &[String]) -> Result<(), Failure> {
        }
        "commands" => {
            validate_options("commands", &rest, COMMANDS_OPTIONS)?;
-            let s = Session::new(wordcraft_doc::Document::new());
+            let s = session(wordcraft_doc::Document::new());
            if rest.iter().any(|a| a == "--json") {
                let list = serde_json::to_string_pretty(&s.registry.describe()).unwrap_or_default();
                write_stdout(|o| writeln!(o, "{list}"))
@@ -306,7 +327,7 @@ fn run(args: &[String]) -> Result<(), Failure> {
        }
        "parity" => {
            validate_options("parity", &rest, PARITY_OPTIONS)?;
-            let s = Session::new(wordcraft_doc::Document::new());
+            let s = session(wordcraft_doc::Document::new());
            let p = wordcraft_engine::catalog::parity(&s.registry);
            if rest.iter().any(|a| a == "--markdown") {
                write_stdout(|o| write!(o, "{}", parity_markdown(&p)))
@@ -0,0 +1,53 @@
+//! `wordcraft-cli convert page.html out.docx` puts an HTML file, which gives no page size, on the
+//! system region's paper, as the app does: A4 in Italy, Letter in the US (#1381).
+
+use std::process::Command;
+
+const HTML: &str = "<html><body><h2>Premessa</h2><table border=1><thead><tr><th>Indicatore</th><th>Valore</th></tr></thead>\
+<tbody><tr><td>Audit</td><td style=\"text-align:right;\">4</td></tr></tbody></table></body></html>";
+
+/// Run the CLI in `region` with `args` (`{src}` is the sample HTML, `{out}` a JSON file it
+/// writes) and read back the page size of the JSON it saved.
+fn page_size_of(region: &str, args: &[&str]) -> (f64, f64) {
+    let dir = std::env::temp_dir().join(format!("wordcraft-cli-region-{region}-{}-{}", args.len(), std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let (src, out) = (dir.join("page.html"), dir.join("out.json"));
+    std::fs::write(&src, HTML).unwrap();
+    let args: Vec<String> = args.iter().map(|a| a.replace("{src}", &src.to_string_lossy()).replace("{out}", &out.to_string_lossy())).collect();
+    let run = Command::new(env!("CARGO_BIN_EXE_wordcraft-cli")).args(&args).env("WORDCRAFT_REGION", region).env_remove("LC_ALL").output().unwrap();
+    assert!(run.status.success(), "{args:?}: {}", String::from_utf8_lossy(&run.stderr));
+    let doc: serde_json::Value = serde_json::from_slice(&std::fs::read(&out).unwrap()).unwrap();
+    let _ = std::fs::remove_dir_all(&dir);
+    let sp = &doc["lastSection"];
+    (sp["pageW"].as_f64().unwrap(), sp["pageH"].as_f64().unwrap())
+}
+
+/// Convert the sample to JSON in `region` and read back the page size.
+fn page_size(region: &str) -> (f64, f64) {
+    page_size_of(region, &["convert", "{src}", "{out}"])
+}
+
+fn is_a4((w, h): (f64, f64)) -> bool {
+    (w - 595.28).abs() < 0.01 && (h - 841.89).abs() < 0.01
+}
+
+#[test]
+fn html_converts_onto_the_region_paper() {
+    let (w, h) = page_size("it-IT");
+    assert!(is_a4((w, h)), "A4 in Italy: {w} x {h}");
+    assert_eq!(page_size("en-US"), (612.0, 792.0), "Letter in the US");
+}
+
+#[test]
+fn every_run_session_follows_the_region() {
+    // `run --file`, `run --template` and a bare `run` all start a session in the system region,
+    // so `file.new` gives the same paper whichever way the session began.
+    for args in [
+        &["run", "--cmd", "file.new", "--save", "{out}"][..],
+        &["run", "--template", "blank", "--save", "{out}"][..],
+        &["run", "--file", "{src}", "--cmd", "file.new", "--save", "{out}"][..],
+    ] {
+        assert!(is_a4(page_size_of("it-IT", args)), "A4 in Italy: {args:?} gave {:?}", page_size_of("it-IT", args));
+        assert_eq!(page_size_of("en-US", args), (612.0, 792.0), "Letter in the US: {args:?}");
+    }
+}
@@ -174,9 +174,9 @@ fn open(s: &mut Session, v: &Value) -> CmdResult {
    let password = p::str(v, "password");
    let (mut doc, encrypted) = if let Some(data) = p::str(v, "data") {
        let bytes = super::insert::base64_decode(data).ok_or_else(|| CmdError::Params("bad base64".into()))?;
-        crate::io::open_bytes_with(path, &bytes, password).map_err(CmdError::Failed)?
+        crate::io::open_bytes_in(path, &bytes, password, &s.region()).map_err(CmdError::Failed)?
    } else {
-        crate::io::open_path_with(std::path::Path::new(path), password).map_err(CmdError::Failed)?
+        crate::io::open_path_in(std::path::Path::new(path), password, &s.region()).map_err(CmdError::Failed)?
    };
    // Plain text and Markdown carry no language: they are in the editing language.
    let ext = std::path::Path::new(path).extension().and_then(|e| e.to_str()).unwrap_or("").to_ascii_lowercase();
@@ -107,7 +107,21 @@ pub fn open_bytes(name: &str, bytes: &[u8]) -> Result<Document, String> {
 /// whether the file was encrypted. Without the password needed the error satisfies
 /// [`needs_password`]; with a wrong one, [`wrong_password`].
 pub fn open_bytes_with(name: &str, bytes: &[u8], password: Option<&str>) -> Result<(Document, bool), String> {
-    let (doc, encrypted) = read_bytes(name, bytes, password)?;
+    open_bytes_in(name, bytes, password, &wordcraft_geom::Region::default())
+}
+
+/// The page a file that gives no page size (plain text, Markdown, HTML) opens on: `region`'s
+/// paper, as a new blank document (#838, #1381), with the default margins.
+pub fn region_page(region: &wordcraft_geom::Region) -> wordcraft_doc::SectionProps {
+    let (_, w, h) = region.paper();
+    wordcraft_doc::SectionProps { page_w: w, page_h: h, ..Default::default() }
+}
+
+/// [`open_bytes_with`] in `region`: a file that gives no page size opens on the region's paper
+/// (see [`region_page`]); a document with its own page size keeps it.
+pub fn open_bytes_in(name: &str, bytes: &[u8], password: Option<&str>, region: &wordcraft_geom::Region) -> Result<(Document, bool), String> {
+    let page = region_page(region);
+    let (doc, encrypted) = read_bytes(name, bytes, password, &page)?;
    load_embedded_fonts(&doc);
    Ok((doc, encrypted))
 }
@@ -122,7 +136,7 @@ fn load_embedded_fonts(doc: &Document) {
    }
 }

-fn read_bytes(name: &str, bytes: &[u8], password: Option<&str>) -> Result<(Document, bool), String> {
+fn read_bytes(name: &str, bytes: &[u8], password: Option<&str>, page: &wordcraft_doc::SectionProps) -> Result<(Document, bool), String> {
    let ext = ext_of(name);
    if matches!(ext.as_str(), "docx" | "docm" | "dotx" | "dotm" | "doc" | "dot") && wordcraft_docx::is_encrypted(bytes) {
        let mut doc = wordcraft_docx::read_with_password(bytes, password).map_err(|e| e.to_string())?;
@@ -130,15 +144,15 @@ fn read_bytes(name: &str, bytes: &[u8], password: Option<&str>) -> Result<(Docum
        return Ok((doc, true));
    }
    if ext.is_empty() || signature_contradicts(&ext, bytes) {
-        return open_by_content(name, &ext, bytes, password);
+        return open_by_content(name, &ext, bytes, password, page);
    }
    let mut doc = match ext.as_str() {
        // Plain text goes through the formats importer: BOMs, unmarked UTF-16, Windows-1252.
-        "txt" | "text" | "" => wordcraft_formats::txt::import(bytes),
+        "txt" | "text" | "" => wordcraft_formats::txt::import_on(bytes, page),
        "json" => serde_json::from_slice::<Document>(bytes).map_err(|e| format!("{name}: {e}"))?,
-        other => match crate::io_ext::open(other, bytes) {
+        other => match crate::io_ext::open(other, bytes, page) {
            Some(r) => r?,
-            None => return open_by_content(name, other, bytes, password),
+            None => return open_by_content(name, other, bytes, password, page),
        },
    };
    doc.ensure_nonempty();
@@ -211,7 +225,13 @@ fn signature_contradicts(ext: &str, bytes: &[u8]) -> bool {
 /// opened by what it holds, as Word does: a Word document or RTF file by its signature, any
 /// other text through the plain-text import with encoding detection (#569). Anything else is
 /// refused with a clear error rather than shown as garbage.
-fn open_by_content(name: &str, ext: &str, bytes: &[u8], password: Option<&str>) -> Result<(Document, bool), String> {
+fn open_by_content(
+    name: &str,
+    ext: &str,
+    bytes: &[u8],
+    password: Option<&str>,
+    page: &wordcraft_doc::SectionProps,
+) -> Result<(Document, bool), String> {
    const ZIP: &[u8] = b"PK\x03\x04";
    const OLE: &[u8] = &[0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1];
    let (mut doc, encrypted) = if bytes.starts_with(OLE) && wordcraft_docx::is_encrypted(bytes) {
@@ -223,7 +243,7 @@ fn open_by_content(name: &str, ext: &str, bytes: &[u8], password: Option<&str>)
    } else if bytes.starts_with(b"{\\rtf") {
        (wordcraft_formats::rtf::import(bytes)?, false)
    } else if wordcraft_formats::txt::is_text(bytes) {
-        (wordcraft_formats::txt::import(bytes), false)
+        (wordcraft_formats::txt::import_on(bytes, page), false)
    } else if ext.is_empty() {
        return Err(format!("{name}: not a document or text file WordCraft can open"));
    } else {
@@ -272,6 +292,12 @@ pub fn open_path(path: &std::path::Path) -> Result<Document, String> {
 /// [`open_path`] for a file that may be password-protected (see [`open_bytes_with`]).
 #[cfg(not(target_arch = "wasm32"))]
 pub fn open_path_with(path: &std::path::Path, password: Option<&str>) -> Result<(Document, bool), String> {
+    open_path_in(path, password, &wordcraft_geom::Region::default())
+}
+
+/// [`open_path_with`] in `region` (see [`open_bytes_in`]).
+#[cfg(not(target_arch = "wasm32"))]
+pub fn open_path_in(path: &std::path::Path, password: Option<&str>, region: &wordcraft_geom::Region) -> Result<(Document, bool), String> {
    crate::file_access::check_read(&path.to_string_lossy())?;
    let meta = std::fs::metadata(path).map_err(|e| format!("{}: {e}", path.display()))?;
    if meta.len() > 2 << 30 {
@@ -282,12 +308,13 @@ pub fn open_path_with(path: &std::path::Path, password: Option<&str>) -> Result<
    if matches!(ext_of(&name).as_str(), "html" | "htm" | "xhtml") {
        // Pictures referenced by a relative path load from beside the HTML file.
        let images = LocalImages::new(path.parent().unwrap_or(std::path::Path::new("")));
-        let mut doc = wordcraft_formats::html::import_with(&wordcraft_formats::html::decode(&bytes), &|src| images.load(src));
+        let html = wordcraft_formats::html::decode(&bytes);
+        let mut doc = wordcraft_formats::html::import_on(&html, &|src| images.load(src), &region_page(region));
        fit_pictures(&mut doc);
        doc.ensure_nonempty();
        return Ok((doc, false));
    }
-    open_bytes_with(&name, &bytes, password)
+    open_bytes_in(&name, &bytes, password, region)
 }

 /// The pictures an HTML file names by a path relative to its folder.
@@ -451,6 +478,11 @@ pub fn open_path_with(path: &std::path::Path, _password: Option<&str>) -> Result
    Err(format!("{}: files are opened through the browser on the web", path.display()))
 }

+#[cfg(target_arch = "wasm32")]
+pub fn open_path_in(path: &std::path::Path, password: Option<&str>, _region: &wordcraft_geom::Region) -> Result<(Document, bool), String> {
+    open_path_with(path, password)
+}
+
 pub fn save_path(path: &std::path::Path, doc: &Document) -> Result<(), String> {
    save_path_with(path, doc, None, &ExportOptions::default())
 }
@@ -2,15 +2,16 @@

 use wordcraft_doc::Document;

-/// Open a format other than plain text / JSON.
-pub fn open(ext: &str, bytes: &[u8]) -> Option<Result<Document, String>> {
+/// Open a format other than plain text / JSON; files that give no page size (Markdown, HTML)
+/// start on `page`.
+pub fn open(ext: &str, bytes: &[u8], page: &wordcraft_doc::SectionProps) -> Option<Result<Document, String>> {
    match ext {
        "docx" | "docm" | "dotx" | "dotm" => Some(wordcraft_docx::read(bytes).map_err(|e| e.to_string())),
        "doc" | "dot" => Some(wordcraft_docbin::read(bytes).map_err(|e| e.to_string())),
        // Word XML Document (Flat OPC) or Word 2003 XML, told apart by the root element.
        "xml" => Some(wordcraft_docx::read_xml(bytes).map_err(|e| e.to_string())),
        // HTML, Markdown, ODT, RTF…: pictures fit the text width (see `io::fit_pictures`).
-        other => wordcraft_formats::import(other, bytes).map(|r| {
+        other => wordcraft_formats::import_on(other, bytes, page).map(|r| {
            r.map(|mut doc| {
                crate::io::fit_pictures(&mut doc);
                doc
@@ -5389,6 +5389,111 @@ fn insert_picture_takes_a_windows_metafile() {
    let _ = std::fs::remove_dir_all(&dir);
 }

+/// #1381: the reporter's sample HTML (synthetic, 1.7 KB).
+const SAMPLE_1381: &str = r##"<html><head><meta charset="utf-8"><title>Testo iniziale</title></head><body>
+<h2 style="color:#1c3a70;">Premessa</h2>
+<p>Il presente documento descrive l&rsquo;organizzazione della <strong>struttura sanitaria di prova</strong> e le misure
+adottate per la <em>gestione del rischio clinico</em>. I contenuti sono <span style="color:#c00000;">sintetici</span>
+e servono solo a verificare la resa della conversione.</p>
+<p style="text-align:justify;">Le attività sono svolte secondo le raccomandazioni ministeriali vigenti e sono oggetto
+di revisione annuale da parte del comitato per la valutazione dei sinistri.</p>
+<ul>
+<li>Identificazione dei rischi per reparto</li>
+<li>Analisi degli eventi avversi e dei <em>near miss</em>
+<ul><li>segnalazione spontanea</li><li>revisione delle cartelle cliniche</li></ul></li>
+<li>Piano annuale di miglioramento</li>
+</ul>
+<ol>
+<li>Raccolta delle segnalazioni</li>
+<li>Classificazione dell&rsquo;evento</li>
+<li>Azioni correttive</li>
+</ol>
+<table border="1" cellpadding="4" cellspacing="0" style="width:100%;border-collapse:collapse;">
+<thead><tr style="background-color:#e8f0fa;"><th>Indicatore</th><th>Valore atteso</th><th>Valore rilevato</th></tr></thead>
+<tbody>
+<tr><td>Segnalazioni analizzate entro 30 giorni</td><td style="text-align:right;">&ge; 90%</td><td style="text-align:right;">93%</td></tr>
+<tr><td>Audit clinici svolti</td><td style="text-align:right;">4</td><td style="text-align:right;">5</td></tr>
+<tr><td colspan="2">Totale azioni correttive aperte</td><td style="text-align:right;">12</td></tr>
+</tbody></table>
+<p style="font-size:9pt;color:#595959;">Fonte: elaborazione interna su dati sintetici.</p>
+</body></html>"##;
+
+/// The first table's grid width in points.
+fn first_table_width(doc: &wordcraft_doc::Document) -> f32 {
+    doc.body.iter().find_map(|b| if let wordcraft_doc::Block::Table(t) = &**b { Some(t.grid.iter().sum::<f32>()) } else { None }).unwrap()
+}
+
+#[test]
+fn opened_html_text_and_markdown_get_the_region_paper() {
+    // #1381: a file that gives no page size opens on the region's paper, as a new blank document
+    // does (#838): A4 in Italy, Letter in the US. Tables fit that page.
+    let dir = std::env::temp_dir().join(format!("wordcraft-region-paper-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let html = dir.join("S05.html");
+    std::fs::write(&html, SAMPLE_1381).unwrap();
+    for (tag, size) in [("it-IT", (595.28, 841.89)), ("en-US", (612.0, 792.0))] {
+        let mut s = s();
+        s.system_region = wordcraft_geom::Region::from_tag(tag);
+        // By path (pictures load from beside the file) and by bytes (the web, MCP).
+        run(&mut s, "file.open", json!({"path": html.to_string_lossy()}));
+        let sp = s.doc.last_section.clone();
+        assert_eq!((sp.page_w, sp.page_h), size, "{tag}: HTML by path");
+        assert!(first_table_width(&s.doc) <= sp.text_width() + 0.5, "{tag}: the table fits the page");
+        for (name, body) in [("S05.html", SAMPLE_1381), ("notes.txt", "Hello"), ("notes.md", "# Title\n\n|a|b|\n|-|-|\n|1|2|\n")] {
+            let data = crate::cmd::insert::base64_encode(body.as_bytes());
+            run(&mut s, "file.open", json!({"path": name, "data": data}));
+            let sp = &s.doc.last_section;
+            assert_eq!((sp.page_w, sp.page_h), size, "{tag}: {name}");
+        }
+    }
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn opened_documents_with_their_own_page_size_keep_it() {
+    // #1381: only files without a page size take the region's paper.
+    for (w, h) in [(500.0, 700.0), (612.0, 792.0)] {
+        let mut doc = wordcraft_doc::Document::from_text("Own size");
+        doc.last_section.page_w = w;
+        doc.last_section.page_h = h;
+        for name in ["own.docx", "own.rtf", "own.odt"] {
+            let bytes = crate::io::save_bytes(name, &doc).unwrap();
+            let mut s = s();
+            s.system_region = wordcraft_geom::Region::from_tag("it-IT");
+            run(&mut s, "file.open", json!({"path": name, "data": crate::cmd::insert::base64_encode(&bytes)}));
+            let sp = &s.doc.last_section;
+            assert_eq!((sp.page_w.round(), sp.page_h.round()), (w, h), "{name}");
+        }
+    }
+}
+
+#[test]
+fn html_converted_to_docx_keeps_bold_headers_and_right_aligned_cells() {
+    // #1381: `wordcraft-cli convert S05.html out.docx`: the <th> runs are bold and the
+    // `text-align:right` cells' paragraphs carry `w:jc w:val="right"`.
+    use std::io::Read;
+    let mut s = s();
+    run(&mut s, "file.open", json!({"path": "S05.html", "data": crate::cmd::insert::base64_encode(SAMPLE_1381.as_bytes())}));
+    let bytes = crate::io::save_bytes("out.docx", &s.doc).unwrap();
+    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
+    let mut xml = String::new();
+    zip.by_name("word/document.xml").unwrap().read_to_string(&mut xml).unwrap();
+    let cell = |text: &str| {
+        let at = xml.find(&format!(">{text}<")).unwrap_or_else(|| panic!("{text} in {xml}"));
+        let start = xml[..at].rfind("<w:tc>").or_else(|| xml[..at].rfind("<w:tc ")).unwrap();
+        let end = at + xml[at..].find("</w:tc>").unwrap();
+        xml[start..end].to_string()
+    };
+    for head in ["Indicatore", "Valore atteso", "Valore rilevato"] {
+        assert!(cell(head).contains("<w:b/>"), "{head}: {}", cell(head));
+    }
+    for right in ["93%", "4", "5", "12"] {
+        assert!(cell(right).contains(r#"<w:jc w:val="right"/>"#), "{right}: {}", cell(right));
+    }
+    let left = cell("Audit clinici svolti");
+    assert!(!left.contains(r#"<w:jc w:val="right"/>"#) && !left.contains("<w:b/>"), "{left}");
+}
+
 #[test]
 fn exported_page_images_draw_headers_at_full_strength() {
    // file.exportPng (and `wordcraft-cli render`) drew headers and footers dimmed, as the screen
@@ -607,7 +607,22 @@ impl<'r> Builder<'r> {
            let mut lists = 0usize;
            for (i, e) in self.stack.iter().enumerate().rev() {
                match e.kind {
-                    ElKind::Cell | ElKind::Table => break,
+                    ElKind::Cell => {
+                        // CSS inherits `text-align` from the cell, its row, row group and table
+                        // (#1381); the paragraph's own (found above) wins.
+                        if p.align.is_none() {
+                            p.align = self.stack.get(..=i).and_then(|outer| {
+                                outer
+                                    .iter()
+                                    .rev()
+                                    .take_while(|o| o.kind != ElKind::Table)
+                                    .chain(outer.iter().rev().find(|o| o.kind == ElKind::Table))
+                                    .find_map(|o| o.align)
+                            });
+                        }
+                        break;
+                    }
+                    ElKind::Table => break,
                    ElKind::Heading(n) if p.kind == Kind::Normal => p.kind = Kind::Heading(n.clamp(1, 6)),
                    ElKind::Pre if p.kind == Kind::Normal => p.kind = Kind::Code,
                    ElKind::Quote if p.kind == Kind::Normal => p.kind = Kind::Quote,
@@ -979,7 +994,8 @@ impl<'r> Builder<'r> {
        let mut preserve = self.preserve();
        let mut page_break = false;
        match name {
-            "b" | "strong" => fmt.bold = true,
+            // A header cell is bold, as in browsers and Word, unless its own CSS says otherwise.
+            "b" | "strong" | "th" => fmt.bold = true,
            "i" | "em" | "cite" | "var" | "dfn" | "address" => fmt.italic = true,
            "u" | "ins" => fmt.underline = true,
            "s" | "strike" | "del" => fmt.strike = true,
@@ -1010,7 +1026,9 @@ impl<'r> Builder<'r> {
            }
            _ => {}
        }
-        if let Some(a) = attr(attrs, "align") {
+        // `align` on a table is about where the table sits (not imported); it doesn't align the
+        // text in its cells.
+        if let Some(a) = attr(attrs, "align").filter(|_| kind != ElKind::Table) {
            align = match a.to_ascii_lowercase().as_str() {
                "center" | "middle" => Some(Align::Center),
                "right" => Some(Align::Right),
@@ -1237,6 +1255,12 @@ pub fn import_with(s: &str, images: ImageLoader) -> Document {
    model::to_doc(&parse_with(s, images))
 }

+/// [`import_with`] onto `page` (its size and margins), which tables size to: HTML gives no page
+/// size, so the caller picks it (the region's paper, #1381).
+pub fn import_on(s: &str, images: ImageLoader, page: &wordcraft_doc::SectionProps) -> Document {
+    model::to_doc_in(&parse_with(s, images), page.clone())
+}
+
 // ---------------------------------------------------------------------------------------------
 // Export

@@ -1683,6 +1707,71 @@ mod tests {
        assert!(p.text().ends_with("l\nn"));
    }

+    /// The paragraphs of every cell of the first table, row by row.
+    fn cell_paras(f: &Flow) -> Vec<Vec<Vec<Para>>> {
+        let Some(FBlock::Table(t)) = f.blocks.iter().find(|b| matches!(b, FBlock::Table(_))) else { panic!("no table") };
+        t.rows
+            .iter()
+            .map(|r| {
+                r.iter().map(|c| c.blocks.iter().filter_map(|b| if let FBlock::Para(p) = b { Some(p.clone()) } else { None }).collect()).collect()
+            })
+            .collect()
+    }
+
+    fn all_bold(p: &Para) -> bool {
+        !p.inlines.is_empty() && p.inlines.iter().all(|i| matches!(i, Inline::Text(_, f) if f.bold))
+    }
+
+    fn any_bold(p: &Para) -> bool {
+        p.inlines.iter().any(|i| matches!(i, Inline::Text(_, f) if f.bold))
+    }
+
+    #[test]
+    fn header_cells_are_bold_unless_their_css_says_otherwise() {
+        // #1381: a <th> is bold, as in browsers and Word; `font-weight:normal` on it or inside it wins.
+        let f = parse(
+            "<table><thead><tr><th>Head</th><th style='font-weight:normal'>Plain</th><th><span style='font-weight:400'>Inner</span></th></tr></thead><tbody><tr><td>a<td>b<td>c</tbody></table>",
+        );
+        let rows = cell_paras(&f);
+        assert!(all_bold(&rows[0][0][0]), "{:?}", rows[0][0]);
+        assert!(!any_bold(&rows[0][1][0]), "{:?}", rows[0][1]);
+        assert!(!any_bold(&rows[0][2][0]), "{:?}", rows[0][2]);
+        assert!(!any_bold(&rows[1][0][0]), "td stays regular");
+    }
+
+    #[test]
+    fn cell_text_align_reaches_the_cell_paragraphs() {
+        // #1381: `text-align` on a td/th, or inherited from its tr/thead/tbody/table, aligns the
+        // cell's paragraphs; a paragraph's own text-align inside the cell wins.
+        let f = parse(
+            "<table style='text-align:center'><tbody style='text-align:justify'><tr style='text-align:right'>\
+             <td style='text-align:right;'>r</td><td>inherited</td><td style='text-align:right'><p style='text-align:center'>own</p></td>\
+             <td align=right>attr</td></tr><tr><td>body</td></tr></tbody><tr><td>table</td></tr></table>",
+        );
+        let rows = cell_paras(&f);
+        assert_eq!(rows[0][0][0].align, Some(Align::Right), "td style");
+        assert_eq!(rows[0][1][0].align, Some(Align::Right), "from tr");
+        assert_eq!(rows[0][2][0].align, Some(Align::Center), "own paragraph wins");
+        assert_eq!(rows[0][3][0].align, Some(Align::Right), "align attribute");
+        assert_eq!(rows[1][0][0].align, Some(Align::Justify), "from tbody");
+        assert_eq!(rows[2][0][0].align, Some(Align::Center), "from table");
+        // `align` on a table places the table; it doesn't align the text in its cells.
+        let f = parse("<table align=center><tr><td>x</td></tr></table>");
+        assert_eq!(cell_paras(&f)[0][0][0].align, None);
+    }
+
+    #[test]
+    fn reporter_sample_header_bold_and_right_aligned_cells() {
+        // #1381: the reporter's table.
+        let f = parse(
+            "<table border=\"1\" style=\"width:100%;border-collapse:collapse;\">\n<thead><tr style=\"background-color:#e8f0fa;\"><th>Indicatore</th><th>Valore atteso</th></tr></thead>\n<tbody>\n<tr><td>Audit</td><td style=\"text-align:right;\">4</td></tr>\n</tbody></table>",
+        );
+        let rows = cell_paras(&f);
+        assert!(all_bold(&rows[0][0][0]) && all_bold(&rows[0][1][0]), "{:?}", rows[0]);
+        assert_eq!(rows[1][1][0].align, Some(Align::Right));
+        assert_eq!(rows[1][0][0].align, None);
+    }
+
    #[test]
    fn entities() {
        assert_eq!(unescape("a &lt;b&gt; &#65;&#x42; &bogus; &"), "a <b> AB &bogus; &");
@@ -43,6 +43,21 @@ pub fn import(ext: &str, bytes: &[u8]) -> Option<Result<Document, String>> {
    }))
 }

+/// [`import`] onto `page` (its size and margins) for the formats whose files give no page size:
+/// plain text, Markdown and HTML start on it, and their tables size to it (#1381). The other
+/// formats keep the page their file gives.
+pub fn import_on(ext: &str, bytes: &[u8], page: &wordcraft_doc::SectionProps) -> Option<Result<Document, String>> {
+    let ext = ext.trim_start_matches('.').to_ascii_lowercase();
+    let mut doc = match ext.as_str() {
+        "txt" | "text" => txt::import_on(bytes, page),
+        "md" | "markdown" => markdown::import_on(&txt::decode(bytes), page),
+        "html" | "htm" | "xhtml" => html::import_on(&html::decode(bytes), &|_| None, page),
+        _ => return import(&ext, bytes),
+    };
+    doc.ensure_nonempty();
+    Some(Ok(doc))
+}
+
 /// Export `doc` in the format named by `ext`. `None` = not our format.
 pub fn export(ext: &str, doc: &Document) -> Option<Result<Vec<u8>, String>> {
    let ext = ext.trim_start_matches('.').to_ascii_lowercase();
@@ -25,6 +25,11 @@ pub fn import(text: &str) -> Document {
    model::to_doc(&parse(text))
 }

+/// [`import`] onto `page`: Markdown gives no page size (#1381).
+pub fn import_on(text: &str, page: &wordcraft_doc::SectionProps) -> Document {
+    model::to_doc_in(&parse(text), page.clone())
+}
+
 /// Parse Markdown text into the flow model.
 pub fn parse(text: &str) -> model::Flow {
    let text = text.strip_prefix('\u{FEFF}').unwrap_or(text);
@@ -89,6 +89,13 @@ pub fn import(bytes: &[u8]) -> Document {
    Document::from_text(&clean)
 }

+/// [`import`] onto `page`: plain text gives no page size (#1381).
+pub fn import_on(bytes: &[u8], page: &wordcraft_doc::SectionProps) -> Document {
+    let mut doc = import(bytes);
+    doc.last_section = page.clone();
+    doc
+}
+
 fn blocks_text(blocks: &[FBlock], out: &mut Vec<String>, lists: &mut ListCounter, depth: usize) {
    for b in blocks {
        match b {
@@ -119,6 +119,20 @@ impl Region {
        self
    }

+    /// The system region from the locale variables `var` reads (the process environment) and,
+    /// when none is set, the platform's first preferred locale `platform` gives. One tag for
+    /// everything first (`WORDCRAFT_REGION`, then `LC_ALL`); otherwise Unix sets each convention
+    /// on its own: numbers (`LC_NUMERIC`, else `LANG`), paper (`LC_PAPER`) and measurement
+    /// (`LC_MEASUREMENT`). Empty, `C` and `POSIX` values count as unset.
+    pub fn from_locale_vars(var: impl Fn(&str) -> Option<String>, platform: impl FnOnce() -> Option<String>) -> Region {
+        let var = |name: &str| var(name).filter(|v| usable_locale(v));
+        if let Some(tag) = var("WORDCRAFT_REGION").or_else(|| var("LC_ALL")) {
+            return Region::from_tag(&tag);
+        }
+        let base = var("LC_NUMERIC").or_else(|| var("LANG")).unwrap_or_else(|| platform().unwrap_or_default());
+        Region::from_tag(&base).with_paper_and_measurement(var("LC_PAPER").as_deref(), var("LC_MEASUREMENT").as_deref())
+    }
+
    /// Does a new document start on US Letter here (otherwise A4)?
    pub fn uses_letter(&self) -> bool {
        self.letter.unwrap_or_else(|| LETTER.contains(&self.territory.as_str()))
@@ -151,6 +165,12 @@ impl Region {
    }
 }

+/// A locale variable that names a locale (not empty, `C` or `POSIX`).
+fn usable_locale(v: &str) -> bool {
+    let v = v.trim();
+    !v.is_empty() && !v.eq_ignore_ascii_case("c") && !v.eq_ignore_ascii_case("posix") && !v.starts_with("C.")
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -195,4 +215,18 @@ mod tests {
        assert_eq!(Region::from_tag("pl-PL").with_paper_and_measurement(Some(""), Some("junk")).paper().0, "Letter", "junk is en-US");
        assert_eq!(us.format(Unit::Inches, 90.0), "1.25\"");
    }
+
+    #[test]
+    fn region_from_locale_variables() {
+        // #1381: the CLI and the app read the system region the same way.
+        let env = |pairs: &'static [(&'static str, &'static str)]| move |n: &str| pairs.iter().find(|(k, _)| *k == n).map(|(_, v)| v.to_string());
+        let none = || None;
+        assert_eq!(Region::from_locale_vars(env(&[("LANG", "it_IT.UTF-8")]), none).paper().0, "A4");
+        assert_eq!(Region::from_locale_vars(env(&[("LANG", "en_US.UTF-8")]), none).paper().0, "Letter");
+        assert_eq!(Region::from_locale_vars(env(&[("LANG", "it_IT.UTF-8"), ("LC_ALL", "en_US")]), none).paper().0, "Letter");
+        assert_eq!(Region::from_locale_vars(env(&[("LANG", "en_US"), ("WORDCRAFT_REGION", "de-DE")]), none).territory, "DE");
+        assert_eq!(Region::from_locale_vars(env(&[("LANG", "en_US"), ("LC_PAPER", "it_IT")]), none).paper().0, "A4");
+        assert_eq!(Region::from_locale_vars(env(&[("LANG", "C.UTF-8")]), || Some("it-IT".into())).territory, "IT");
+        assert_eq!(Region::from_locale_vars(env(&[]), none), Region::default());
+    }
 }
@@ -294,23 +294,9 @@ pub fn system_region() -> wordcraft_engine::Region {
    if cfg!(test) {
        return wordcraft_engine::Region::default();
    }
-    let var = |name: &str| std::env::var(name).ok().filter(|v| usable_locale(v));
-    // One tag for everything: an explicit override, or `LC_ALL`.
-    if let Some(tag) = var("WORDCRAFT_REGION").or_else(|| var("LC_ALL")) {
-        return wordcraft_engine::Region::from_tag(&tag);
-    }
-    // Unix sets each convention on its own: numbers (`LC_NUMERIC`, else `LANG`), paper
-    // (`LC_PAPER`) and measurement (`LC_MEASUREMENT`). Elsewhere, and when none is set, the
-    // platform's first preferred locale (on macOS it carries the region, as in `en-PL`; on the web
-    // it is the browser's language).
-    let base = var("LC_NUMERIC").or_else(|| var("LANG")).unwrap_or_else(|| sys_locale::get_locale().unwrap_or_default());
-    wordcraft_engine::Region::from_tag(&base).with_paper_and_measurement(var("LC_PAPER").as_deref(), var("LC_MEASUREMENT").as_deref())
-}
-
-/// A locale variable that names a locale (not empty, `C` or `POSIX`).
-fn usable_locale(v: &str) -> bool {
-    let v = v.trim();
-    !v.is_empty() && !v.eq_ignore_ascii_case("c") && !v.eq_ignore_ascii_case("posix") && !v.starts_with("C.")
+    // The environment's locale variables (Unix), else the platform's first preferred locale (on
+    // macOS it carries the region, as in `en-PL`; on the web it is the browser's language).
+    wordcraft_engine::Region::from_locale_vars(|name| std::env::var(name).ok(), sys_locale::get_locale)
 }

 thread_local! {
@@ -1,6 +1,6 @@
 # File-format parity with Microsoft Word

-> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-14 · **Change:** trivial (rounded rectangles keep their own corner radius, #1476; previously trivial: RTF import keeps sections, #1378; previously trivial: VML text boxes keep their internal margins, fit to their text and vertical alignment; hidden drawings not shown; previously trivial: equations as MathML in HTML export, copy and paste, #816; previously trivial: symbol-font text exported as Unicode, #776; previously trivial: text-box margins, Resize shape to fit text and freeforms in groups, #743; previously trivial: formatted paste from the system clipboard's HTML and RTF, #687; previously trivial: independent complex-script formatting inheritance and round-trip regression tests; previously trivial: import/export fixes for TXT, RTF, ODT, HTML and LaTeX, #433–#440; previously major: first version; every format Word reads or writes, measured from the readers and writers on origin/main) · **Target:** Microsoft Word (Microsoft 365) for Mac 16.113.4, plus Word for Windows' extra formats
+> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-14 · **Change:** trivial (HTML header cells bold, cell `text-align` kept, and HTML/Markdown/text open on the region's paper, #1381; previously trivial: rounded rectangles keep their own corner radius, #1476; previously trivial: RTF import keeps sections, #1378; previously trivial: VML text boxes keep their internal margins, fit to their text and vertical alignment; hidden drawings not shown; previously trivial: equations as MathML in HTML export, copy and paste, #816; previously trivial: symbol-font text exported as Unicode, #776; previously trivial: text-box margins, Resize shape to fit text and freeforms in groups, #743; previously trivial: formatted paste from the system clipboard's HTML and RTF, #687; previously trivial: independent complex-script formatting inheritance and round-trip regression tests; previously trivial: import/export fixes for TXT, RTF, ODT, HTML and LaTeX, #433–#440; previously major: first version; every format Word reads or writes, measured from the readers and writers on origin/main) · **Target:** Microsoft Word (Microsoft 365) for Mac 16.113.4, plus Word for Windows' extra formats

 Every format Word opens or saves, what WordCraft does with it, and how it's tested. Fidelity is the
 share of a typical real-world file's content and formatting that survives (read: shows correctly;
@@ -28,7 +28,7 @@ Weights are the share of a Word user's file traffic (estimate). Read/write: ✅
 | `.rtf` Rich Text Format | 3% | R/W | 🟡 | 🟡 | ~50% | 10–15 | `crates/formats/src/tests.rs` | ~1,500 lines: text, character/paragraph formatting, styles, lists, tables, pictures (`\shppict`, #154), fields, bookmarks. 8-bit text in the document's code page (`\ansicpg`) or the current font's (`\fcharset`, `\cpg`): Cyrillic, Central European, Greek, Turkish, Hebrew, Arabic, Baltic, Vietnamese, Thai (was Windows-1252 only). Pasted from the system clipboard where the platform offers it (Windows, Wayland) when there is no HTML (#687). Sections on import (#1378): each `\sect` ends a section with its own page size and orientation, margins, header/footer distance, columns, break type, page-number restart, start and format, title page and headers/footers (those it leaves out link to the previous); export still writes one section. Thin: comments, notes, revisions, section export, RTL |
 | `.odt` OpenDocument Text | 2% | R/W | 🟡 | 🟡 | ~50% | 8–12 | `crates/formats/src/tests.rs` | Styles, lists (#87), tables, pictures, headers/footers, page breaks (#86), page size, orientation and margins (#810). No footnotes, comments, tracked changes, fields or RTL |
 | `.txt` Plain text | 2% | R/W | ✅ | ✅ | ~95% | 1–2 | unit tests | Encoding detection. Files with other extensions (`.m3u`/`.m3u8` playlists, logs, config files, no extension) open as text when they are text, Word and RTF files by their signature; binary files are refused (#569). A Word or RTF extension that contradicts the content also opens by signature, as in Word: RTF saved as `.doc` (hh.ru résumés, accounting exports), a `.docx` renamed `.doc`, a Word 97-2003 file renamed `.docx`. Word's encoding choice dialog and line-ending options missing; such files save only through Save As |
-| `.htm/.html` Web Page and Web Page, Filtered | 1% | R/W | 🟡 | 🟡 | ~60% | 6–10 | `crates/formats/src/tests.rs` | Tables (#102), relative pictures embedded (#113), missing `</head>` tolerated (#154). No Word "Web Page" (with `_files` folder) round-trip. The same reader takes HTML from the system clipboard: Paste keeps another program's formatting (a Word document, a web page; Windows' "HTML Format" header understood), Merge Formatting keeps its emphasis (#687). Equations are written as MathML (with the linear format as a UnicodeMath annotation) and read back from MathML: our annotation, else the presentation elements, else a TeX annotation (#816) |
+| `.htm/.html` Web Page and Web Page, Filtered | 1% | R/W | 🟡 | 🟡 | ~60% | 6–10 | `crates/formats/src/tests.rs` | Tables (#102), relative pictures embedded (#113), missing `</head>` tolerated (#154). Header cells (`<th>`) bold unless their CSS says otherwise; `text-align` on a cell, or inherited from its row, row group or table, aligns the cell's paragraphs (#1381). HTML gives no page size, so it opens on the region's paper (A4 or Letter), as Markdown and plain text do; `@page` isn't read (#1381). No Word "Web Page" (with `_files` folder) round-trip. The same reader takes HTML from the system clipboard: Paste keeps another program's formatting (a Word document, a web page; Windows' "HTML Format" header understood), Merge Formatting keeps its emphasis (#687). Equations are written as MathML (with the linear format as a UnicodeMath annotation) and read back from MathML: our annotation, else the presentation elements, else a TeX annotation (#816) |
 | `.mht/.mhtml` Single File Web Page | <1% | R/W | ❌ | ❌ | 0% | 3–5 | — | |
 | `.xml` Word XML Document (Flat OPC) | <1% | R/W | ✅ | ✅ | ~65% | — | `crates/docx/tests/word_xml.rs`, `roundtrip.rs` (`flat_opc_round_trip_equals_docx`) | The DOCX package in one XML file, read and written by the DOCX code (#548); File › Export › Word XML Document. `.xml` files are told apart by their root element |
 | `.xml` Word 2003 XML (WordprocessingML 2003) | <1% | R/W | 🟡 | 🟡 | ~55% | 1–2 | `crates/docx/tests/word_xml.rs` | Opened by rewriting it as a package for the DOCX reader (#548): styles, default fonts, lists, tables, sections, headers/footers, footnotes/endnotes, comments, bookmarks, tracked insertions/deletions, hyperlinks, `w:binData` pictures, document properties. Not read: formatting changes, `w:docPr` settings, smart tags. Written (#1081) by rewriting the DOCX writer's package into the 2003 vocabulary (`crates/docx/src/wordml2003_write.rs`, `crates/docx/tests/wordml2003_write.rs`): core properties, styles (document defaults folded into Normal), lists, text and paragraph/character formatting, tables, hyperlinks, footnotes/endnotes inline, headers/footers in the section properties, bookmarks, comments and tracked insertions/deletions as `aml:annotation`, section page setup, and PNG/JPEG/GIF/BMP/EMF/WMF pictures as `w:pict` with `w:binData`. **Dropped on write:** shapes, text boxes, groups, charts, SmartArt, ink, equations, OLE objects, picture crop, rotation and floating position (pictures become inline), content-control wrappers (their content stays), formatting-change tracking, theme colours/fonts, custom XML, macros, even/odd header setting. File › Export › Word 2003 XML Document, `file.save`/`file.saveAs` with `format: "wordml2003"`, `wordcraft-cli convert … --format wordml2003`; a plain save over a 2003 file keeps that format. Never opened in Word yet (written from the published schemas; needs a tester) |
@@ -169,6 +169,7 @@ raise readiness estimates. No Word-derived files are fixtures.
 | 2026-10-13 | trivial | Remove personal information / Remove date and time settings kept and honoured on save: anonymous annotation authors, no creator or last-modified-by, no annotation dates (#1062) |
 | 2026-10-12 | trivial | Direct run-level `w:contentPart` InkML keeps its relationship, content type and bytes through DOCX edits and repeated saves; nested group/canvas ink and native rendering remain missing |
 | 2026-10-13 | trivial | HTML export writes equations as MathML instead of linear text, and HTML import (open and paste) reads `<math>` back into equations; a copy holding an equation puts that HTML on the system clipboard: MathML in HTML on the clipboard (Word/LibreOffice paste not yet verified; OMML is #1297) (#816) |
+| 2026-10-14 | trivial | HTML: `<th>` bold, cell `text-align` (own or inherited) reaches the cell's paragraphs; HTML, Markdown and plain text open on the region's paper, in the app and `wordcraft-cli` (#1381) |
 | 2026-10-13 | trivial | PDF export draws horizontal and vertical lines inside groups (#1474) |
 | 2026-10-14 | trivial | RTF import keeps sections: page size and orientation, margins, columns, break type, page numbering and each section's headers and footers (#1378) |
 | 2026-10-12 | trivial | Paste keeps the formatting of HTML and RTF on the system clipboard; Paste Special lists them and pictures (#687, #833) |