dsh-office-kit 0.4.3 → 0.4.5

package/assets/skills/excel-live-control/SKILL.md

@@ -1,5 +1,5 @@
 ---
-description: Drive a workbook that is already open in Excel or WPS Spreadsheets on Windows over COM: read cells, write values and formulas, style ranges, add charts and tables, recalculate, save, and report the exact ranges touched.
+description: 'Drive a workbook that is already open in Excel or WPS Spreadsheets on Windows over COM: read cells, write values and formulas, style ranges, add charts and tables, recalculate, save, and report the exact ranges touched.'
 ---
 
 # Live spreadsheets (Excel / WPS)

package/assets/skills/office-documents/scripts/add_tracked_replacements.py

@@ -137,9 +137,10 @@ def main(argv: list[str] | None = None) -> int:
             print("error: %s" % exc, file=sys.stderr)
             return 2
         hits = 0
-        for paragraph in doc.paragraphs():
-            if tracked_replace(paragraph, old, new, args.author, stamp, counter):
-                hits += 1
+        for part in doc.text_parts():
+            for paragraph in doc.paragraphs(part):
+                if tracked_replace(paragraph, old, new, args.author, stamp, counter):
+                    hits += 1
         applied.append({"old": old, "new": new, "paragraphs": hits})
 
     settings = doc.xml("word/settings.xml")

package/assets/skills/office-documents/scripts/docx_kit.py

@@ -250,7 +250,7 @@ class Docx:
         while self.exists("word/%s%d.xml" % (kind, index)):
             index += 1
         part = "word/%s%d.xml" % (kind, index)
-        root = etree.Element(q(kind), nsmap={"w": W, "r": R, "wp": WP, "v": V})
+        root = etree.Element(q("hdr" if kind == "header" else "ftr"), nsmap={"w": W, "r": R, "wp": WP, "v": V})
         etree.SubElement(etree.SubElement(root, q("p")), q("r"))
         self.set_xml(part, root)
         self.ensure_override(part, CT_BY_REL[rel_type])
@@ -459,45 +459,86 @@ def add_bookmark(parent, name: str, ident: int) -> None:
 
 # -- watermarks -------------------------------------------------------------
 
-_WATERMARK_SHAPETYPE = """<v:shapetype xmlns:v="urn:schemas-microsoft-com:vml" id="_x0000_t136" coordsize="21600,21600" adj="10800" path="m@7,l@8,m@5,21600l@11,21600e"><v:formulas><v:f eqn="sum #0 0 10800"/><v:f eqn="prod #0 2 1"/><v:f eqn="sum 21600 0 @1"/><v:f eqn="sum 0 0 @2"/><v:f eqn="sum 21600 0 @3"/><v:f eqn="if @0 @3 0"/><v:f eqn="if @0 21600 @1"/><v:f eqn="if @0 0 @2"/><v:f eqn="if @0 @4 21600"/><v:f eqn="mid @5 @6"/><v:f eqn="mid @8 @5"/><v:f eqn="mid @7 @8"/><v:f eqn="mid @6 @7"/><v:f eqn="sum @6 0 @5"/></v:formulas><v:path textpathok="t"/><v:textpath on="t" fitshape="t"/><v:handles><v:h position="#0,bottomRight" xrange="6629,14971"/></v:handles></v:shapetype>"""
-
-_WATERMARK_STYLE = (
-    "position:absolute;margin-left:0;margin-top:0;width:468pt;height:117pt;"
-    "rotation:-45;z-index:-251658752;mso-position-horizontal:center;"
-    "mso-position-horizontal-relative:margin;mso-position-vertical:center;"
-    "mso-position-vertical-relative:margin"
-)
+WATERMARK_DESCR = "DSH Office watermark"
+
+_WATERMARK_ANCHOR = """<wp:anchor xmlns:wp="%(wp)s" xmlns:a="%(a)s" xmlns:w="%(w)s" xmlns:wps="%(wps)s"
+  distT="0" distB="0" distL="0" distR="0" simplePos="0" relativeHeight="251658240"
+  behindDoc="1" locked="0" layoutInCell="1" allowOverlap="1">
+  <wp:simplePos x="0" y="0"/>
+  <wp:positionH relativeFrom="page"><wp:align>center</wp:align></wp:positionH>
+  <wp:positionV relativeFrom="page"><wp:align>center</wp:align></wp:positionV>
+  <wp:extent cx="5486400" cy="1371600"/>
+  <wp:effectExtent l="0" t="0" r="0" b="0"/>
+  <wp:wrapNone/>
+  <wp:docPr id="%(id)d" name="PowerPlusWaterMarkObject%(id)d" descr="%(descr)s"/>
+  <wp:cNvGraphicFramePr/>
+  <a:graphic><a:graphicData uri="%(wps)s"><wps:wsp>
+    <wps:cNvSpPr/>
+    <wps:spPr>
+      <a:xfrm rot="-2700000"><a:off x="0" y="0"/><a:ext cx="5486400" cy="1371600"/></a:xfrm>
+      <a:prstGeom prst="rect"><a:avLst/></a:prstGeom>
+      <a:noFill/><a:ln><a:noFill/></a:ln>
+    </wps:spPr>
+    <wps:txbx><w:txbxContent><w:p><w:pPr><w:jc w:val="center"/></w:pPr>
+      <w:r><w:rPr><w:color w:val="%(color)s"/><w:sz w:val="120"/></w:rPr><w:t>%(text)s</w:t></w:r>
+    </w:p></w:txbxContent></wps:txbx>
+    <wps:bodyPr vert="horz" wrap="square" lIns="0" tIns="0" rIns="0" bIns="0"
+      anchor="ctr" anchorCtr="0"><a:noAutofit/></wps:bodyPr>
+  </wps:wsp></a:graphicData></a:graphic>
+</wp:anchor>"""
+
+_WPS_NS = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape"
 
 
 def watermark_paragraph(text: str, ident: int = 1, color: str = "#C0C0C0"):
-    """A header paragraph holding one VML text watermark."""
+    """A header paragraph holding one DrawingML text watermark.
+
+    Word stores watermarks as VML, but VML shapes are routinely dropped by other
+    renderers, so the shape here is DrawingML (wps) and marked with a stable
+    ``descr`` so it can be found and removed again.
+    """
+    from xml.sax.saxutils import escape
+
+    color = color.lstrip("#").upper() or "C0C0C0"
     paragraph = etree.Element(q("p"))
     run = etree.SubElement(paragraph, q("r"))
     run_props = etree.SubElement(run, q("rPr"))
     etree.SubElement(run_props, q("noProof"))
-    pict = etree.SubElement(run, q("pict"))
-    pict.append(etree.fromstring(_WATERMARK_SHAPETYPE))
-    shape = etree.SubElement(pict, q("shape", V))
-    shape.set("id", "WaterMarkObject%d" % ident)
-    shape.set("type", "#_x0000_t136")
-    shape.set("style", _WATERMARK_STYLE)
-    shape.set("fillcolor", color)
-    shape.set("stroked", "f")
-    textpath = etree.SubElement(shape, q("textpath", V))
-    textpath.set("style", 'font-family:"Calibri";font-size:1pt')
-    textpath.set("string", text)
+    drawing = etree.SubElement(run, q("drawing"))
+    anchor = etree.fromstring(_WATERMARK_ANCHOR % {
+        "wp": WP,
+        "a": A,
+        "w": W,
+        "wps": _WPS_NS,
+        "id": ident,
+        "descr": WATERMARK_DESCR,
+        "color": color,
+        "text": escape(str(text)),
+    })
+    drawing.append(anchor)
     return paragraph
 
 
+def _paragraph_above(node):
+    while node is not None and node.tag != q("p"):
+        node = node.getparent()
+    return node
+
+
 def watermark_texts(doc: Docx) -> list[dict]:
-    """Every VML text watermark in the headers, with the paragraph that holds it."""
+    """Every VML or DrawingML text watermark in the headers, with its paragraph."""
     found = []
     for part in doc.names("word/header"):
-        for textpath in doc.xml(part).iter(q("textpath", V)):
-            paragraph = textpath
-            while paragraph is not None and paragraph.tag != q("p"):
-                paragraph = paragraph.getparent()
-            found.append({"part": part, "text": textpath.get("string"), "paragraph": paragraph})
+        root = doc.xml(part)
+        for textpath in root.iter(q("textpath", V)):
+            text = textpath.get("string")
+            if text:
+                found.append({"part": part, "kind": "vml", "text": text, "paragraph": _paragraph_above(textpath)})
+        for pr in root.iter(q("docPr", WP)):
+            if pr.get("descr") != WATERMARK_DESCR:
+                continue
+            text = "".join(node.text or "" for node in pr.getparent().iter(q("t")))
+            found.append({"part": part, "kind": "drawingml", "text": text, "paragraph": _paragraph_above(pr)})
     return found
 
 

package/assets/skills/office-documents/scripts/heading_audit.py

@@ -58,7 +58,8 @@ def main(argv: list[str] | None = None) -> int:
     for index, paragraph in enumerate(doc.paragraphs(), start=1):
         text = kit.paragraph_text(paragraph).strip()
         level = kit.heading_level(paragraph)
-        if level == 0:
+        style = (kit.paragraph_style(paragraph) or "").strip().lower()
+        if style == "title":
             outline.append({"index": index, "style": "Title", "text": text})
             continue
         if level:
@@ -71,9 +72,7 @@ def main(argv: list[str] | None = None) -> int:
             if manual_heading(paragraph):
                 findings.append({"kind": "manual_formatting", "index": index, "text": text})
             previous = level
-        elif not text:
-            continue
-        elif manual_heading(paragraph) and len(text) <= 120:
+        elif text and manual_heading(paragraph) and len(text) <= 120:
             findings.append({"kind": "heading_not_styled", "index": index, "text": text})
 
     counts = {}

package/assets/skills/office-documents/scripts/internal_nav.py

@@ -131,8 +131,10 @@ def main(argv: list[str] | None = None) -> int:
         body.insert(position + offset, node)
 
     if not args.no_back_to_toc:
+        anchors = {entry["anchor"] for entry in headings}
         for paragraph_node in list(body.iter(kit.q("p"))):
-            if any(entry["anchor"] == name for entry in headings for name in (paragraph_node.find(kit.q("bookmarkStart")).get(kit.q("name")),) if paragraph_node.find(kit.q("bookmarkStart")) is not None):
+            start = paragraph_node.find(kit.q("bookmarkStart"))
+            if start is not None and start.get(kit.q("name")) in anchors:
                 back = paragraph("Caption")
                 back.append(link_run("Back to contents", TOC_BOOKMARK))
                 paragraph_node.addnext(back)

package/assets/skills/office-documents/scripts/merge_docx_append.py

@@ -173,6 +173,101 @@ def remap_relationships(base: kit.Docx, append: kit.Docx, nodes: list) -> int:
     return copied
 
 
+NOTE_PARTS = (
+    ("word/footnotes.xml", kit.REL_FOOTNOTES, "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml", kit.q("footnote"), (kit.q("footnoteReference"),)),
+    ("word/endnotes.xml", kit.REL_ENDNOTES, "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml", kit.q("endnote"), (kit.q("endnoteReference"),)),
+    ("word/comments.xml", kit.REL_COMMENTS, "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml", kit.q("comment"), (kit.q("commentReference"), kit.q("commentRangeStart"), kit.q("commentRangeEnd"))),
+)
+
+
+def remap_part_relationships(base: kit.Docx, append: kit.Docx, append_part: str, base_part: str, nodes: list) -> int:
+    """Remap r:embed/r:id/r:link inside nodes, copying targets into the base package."""
+    source_rels = {entry["id"]: entry for entry in append.relationships(append_part)}
+    attributes = (kit.q("embed", kit.R), kit.q("id", kit.R), kit.q("link", kit.R))
+    mapping = {}
+    copied = 0
+    for node in nodes:
+        for element in node.iter():
+            for attribute in attributes:
+                rid = element.get(attribute)
+                if not rid:
+                    continue
+                if rid not in mapping:
+                    rel = source_rels.get(rid)
+                    if rel is None:
+                        mapping[rid] = rid
+                        continue
+                    if rel["mode"] == "External":
+                        mapping[rid] = base.ensure_rel(base_part, rel["type"], rel["target"], external=True)
+                    elif append.exists(rel["resolved"]):
+                        target = copy_part(base, append, rel["resolved"])
+                        relative = posixpath.relpath(target, posixpath.dirname(base_part))
+                        mapping[rid] = base.ensure_rel(base_part, rel["type"], relative)
+                        copied += 1
+                    else:
+                        mapping[rid] = rid
+                element.set(attribute, mapping[rid])
+    return copied
+
+
+def merge_note_part(base: kit.Docx, append: kit.Docx, part: str, rel_type: str, content_type: str, note_tag: str) -> dict[str, str]:
+    """Merge a footnotes/endnotes/comments part into the base, returning old→new ids."""
+    if not append.exists(part):
+        return {}
+    source_root = append.xml(part)
+    if base.exists(part):
+        target_root = base.xml(part)
+    else:
+        target_root = etree.Element(source_root.tag, nsmap=source_root.nsmap)
+        for note in source_root.findall(note_tag):
+            raw = note.get(kit.q("id"))
+            if raw is not None and raw.lstrip("-").isdigit() and int(raw) <= 0:
+                target_root.append(etree.fromstring(etree.tostring(note)))
+        base.set_xml(part, target_root)
+        base.ensure_override(part, content_type)
+        base.ensure_rel("word/document.xml", rel_type, posixpath.relpath(part, "word"))
+
+    used = {
+        int(node.get(kit.q("id")))
+        for node in target_root.findall(note_tag)
+        if (node.get(kit.q("id")) or "").lstrip("-").isdigit()
+    }
+    next_id = max(used, default=0) + 1
+    mapping: dict[str, str] = {}
+    for note in source_root.findall(note_tag):
+        raw = note.get(kit.q("id"))
+        if raw is None or not raw.lstrip("-").isdigit() or int(raw) <= 0:
+            continue
+        clone = etree.fromstring(etree.tostring(note))
+        clone.set(kit.q("id"), str(next_id))
+        remap_part_relationships(base, append, part, part, [clone])
+        target_root.append(clone)
+        mapping[raw] = str(next_id)
+        next_id += 1
+    return mapping
+
+
+def bind_note_references(clones: list, ref_tags: tuple, mapping: dict[str, str], target_exists: bool) -> int:
+    """Point body references at the merged notes; drop references that have no note."""
+    dropped = 0
+    for clone in clones:
+        for ref_tag in ref_tags:
+            for element in list(clone.iter(ref_tag)):
+                raw = element.get(kit.q("id"))
+                if raw is None:
+                    continue
+                if raw in mapping:
+                    element.set(kit.q("id"), mapping[raw])
+                elif target_exists and raw.isdigit() and int(raw) <= 0:
+                    continue
+                else:
+                    parent = element.getparent()
+                    if parent is not None:
+                        parent.remove(element)
+                        dropped += 1
+    return dropped
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description="Append one .docx body to another, copying media, numbering and styles.")
     parser.add_argument("base", help="Document to append to")
@@ -220,6 +315,13 @@ def main(argv: list[str] | None = None) -> int:
                 if num_id is not None and num_id.get(kit.q("val")) in number_map:
                     num_id.set(kit.q("val"), number_map[num_id.get(kit.q("val"))])
     media_copied = remap_relationships(base, append, clones)
+    notes_merged = 0
+    references_dropped = 0
+    for part, rel_type, content_type, note_tag, ref_tags in NOTE_PARTS:
+        exists = append.exists(part)
+        mapping = merge_note_part(base, append, part, rel_type, content_type, note_tag) if exists else {}
+        notes_merged += len(mapping)
+        references_dropped += bind_note_references(clones, ref_tags, mapping, exists)
     copy_defaults(base, append)
 
     body = base.body()
@@ -237,6 +339,8 @@ def main(argv: list[str] | None = None) -> int:
             "styles_copied": styles_copied,
             "media_copied": media_copied,
             "numbering_remapped": len(number_map),
+            "notes_merged": notes_merged,
+            "references_dropped": references_dropped,
         }
     )
     return 0

package/assets/skills/office-documents/scripts/table_geometry.py

@@ -98,7 +98,11 @@ def fix_table(table, target: int) -> None:
     if not columns:
         columns = [1]
     total = sum(columns) or len(columns)
-    scaled = [max(1, round(target * value / total)) for value in columns]
+    scaled = [max(1, target * value // total) for value in columns]
+    remainder = target - sum(scaled)
+    order = sorted(range(len(columns)), key=lambda index: (target * columns[index]) % total, reverse=True)
+    for index in range(max(0, remainder)):
+        scaled[order[index % len(order)]] += 1
     grid = table.find(kit.q("tblGrid"))
     if grid is None:
         grid = etree.Element(kit.q("tblGrid"))
@@ -163,8 +167,14 @@ def main(argv: list[str] | None = None) -> int:
             fix_table(table, target)
         out = args.out or args.docx
         doc.save(out)
-        kit.emit({"ok": True, "fixed": True, "output": str(Path(out)), "tables": len(tables), "text_width": target, "findings": findings})
-        return 0
+        remaining = []
+        for index, info in enumerate((table_info(table) for table in tables), start=1):
+            if info["grid_total"] and info["grid_total"] > target:
+                remaining.append({"kind": "grid_wider_than_text", "table": index, "grid_total": info["grid_total"], "text_width": target})
+            if info["layout"] != "fixed":
+                remaining.append({"kind": "not_fixed_layout", "table": index})
+        kit.emit({"ok": not remaining, "fixed": True, "output": str(Path(out)), "tables": len(tables), "text_width": target, "findings": remaining})
+        return 0 if not remaining else 1
 
     kit.emit({"ok": not findings, "text_width": target, "tables": rows, "findings": findings})
     return 1 if findings else 0

package/assets/skills/office-documents/scripts/watermark_add.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python
-"""Add a diagonal text watermark to the page background.
+"""Add a text watermark to the page background.
 
-The watermark is a VML text shape in the default header, which is how Word has
-stored them since the 2007 file format: it survives conversion, prints on every
-page, and can be removed again by deleting the header shape.
+The watermark is a DrawingML text box in the default header: Word rotates it
+-45 degrees, while VML-only renderers that drop VML shapes still show the mark.
+It prints behind the body on every page and can be removed again by deleting
+the header paragraph.
 
 Exit codes: 0 success, 2 bad input.
 """
@@ -26,7 +27,7 @@ for _stream in (sys.stdout, sys.stderr):
 
 
 def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description="Add a VML text watermark to the document header.")
+    parser = argparse.ArgumentParser(description="Add a DrawingML text watermark to the document header.")
     parser.add_argument("input_docx", help="Input .docx")
     parser.add_argument("--out", required=True, help="Output .docx")
     parser.add_argument("--text", required=True, help="Watermark text, e.g. CONFIDENTIAL")

package/assets/skills/office-documents/scripts/watermark_audit_remove.py

@@ -1,8 +1,10 @@
 #!/usr/bin/env python
-"""Find and remove VML text watermarks from headers.
+"""Find and remove text watermarks from headers.
 
-A watermark that was meant for a draft can end up in a signed document, and it is
-invisible in text extraction because it lives in a shape, not in a paragraph run.
+Both DrawingML watermarks (what ``watermark_add.py`` writes) and legacy VML
+``v:textpath`` shapes are detected. A watermark that was meant for a draft can
+end up in a signed document, and it is invisible in text extraction because it
+lives in a shape, not in a paragraph run.
 
 Exit codes: 0 clean, 1 watermarks found (report mode), 2 bad input.
 """
@@ -25,7 +27,7 @@ for _stream in (sys.stdout, sys.stderr):
 
 
 def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description="Report or remove watermarks stored as VML shapes in headers.")
+    parser = argparse.ArgumentParser(description="Report or remove watermarks stored as DrawingML or VML shapes in headers.")
     parser.add_argument("input_docx", help="Input .docx")
     parser.add_argument("--mode", choices=("report", "remove"), default="report")
     parser.add_argument("--contains", default=None, help="Only match watermarks containing this text")

package/assets/skills/office-documents/tasks/watermarks_background.md

@@ -1,14 +1,14 @@
 # Watermarks and background marks
 
-A Word watermark is not its own element: it is a VML shape (`v:shape` with `v:textpath`) inside a header part, behind the text. That is why it disappears when the header is replaced and can differ per section.
+A text watermark is a shape inside a header part, behind the body text: Word writes legacy VML (`v:shape` with `v:textpath`), while `watermark_add.py` writes DrawingML (`wps:wsp`) because VML is routinely dropped by non-Word renderers. That is why a watermark disappears when the header is replaced and can differ per section.
 
 ## Add
 
 ```bash
-"<python>" "<skill>/scripts/watermark_add.py" "<file.docx>" --out "<file-draft.docx" --text "DRAFT"
+"<python>" "<skill>/scripts/watermark_add.py" "<file.docx>" --out "<file-draft.docx>" --text "DRAFT"
 ```
 
-Writes the shape into the default header: light grey, rotated -45°, behind the body. The script refuses to add a second watermark when it finds one, so remove the old one first. For a mark on every page across sections, each section's header needs the shape — loop over the sections.
+Writes the shape into the default header: light grey, centred on the page, tagged with `descr="DSH Office watermark"`. Word rotates it -45°; renderers that ignore the rotation still show a horizontal mark, so it is always visible. The script refuses to add a second watermark when it finds one, so remove the old one first. For a mark on every page across sections, each section's header needs the shape — loop over the sections.
 
 ## Find and remove
 
@@ -17,15 +17,15 @@ Writes the shape into the default header: light grey, rotated -45°, behind the
 "<python>" "<skill>/scripts/watermark_audit_remove.py" "<file.docx>" --mode remove --out "<file-clean.docx"
 ```
 
-The report lists every VML text path and the part it lives in, and exits 1 when any watermark exists. `--contains` narrows it to a substring, for the "template says Company Confidential" case. Remove deletes the enclosing paragraph from the header.
+The report lists every DrawingML watermark and every legacy VML text path, with the part it lives in, and exits 1 when any watermark exists. `--contains` narrows it to a substring, for the "template says Company Confidential" case. Remove deletes the enclosing paragraph from the header.
 
 ## Verify
 
-Render and read the pages: the mark sits behind the text, inside the page, on every expected page. A watermark missing on page two means that section has a different header.
+Render and read the pages: the mark sits behind the text, inside the page, on every expected page. A light grey drawing that covers a line of body text is still a defect; a mark missing on page two means that section has a different header.
 
 ## Pitfalls
 
 - A watermark in a "different first page" header shows only on page one.
 - Removing the header paragraph can leave an empty header that adds vertical space — check the top margin.
-- An image watermark is `v:imagedata`, not a text path, so the report will not name it; inspect the header XML.
+- An image watermark is `v:imagedata`, not a text shape, so the report will not name it; inspect the header XML.
 - A watermark is not security (`tasks/protection_restrict_editing.md`).

package/assets/skills/office-pdf/scripts/forms.py

@@ -15,6 +15,7 @@ Exit codes: 0 success, 1 bad arguments, 2 unreadable input or write failure,
 from __future__ import annotations
 
 import argparse
+import io
 import json
 import sys
 from pathlib import Path
@@ -31,6 +32,8 @@ except ImportError:  # pragma: no cover - pypdf is a required dependency
     IndirectObject = None  # type: ignore[assignment]
     NameObject = None  # type: ignore[assignment]
 
+from pdf_fonts import find_cjk_font, has_non_latin, register_cjk_font
+
 
 def emit(value, out=None):
     text = json.dumps(value, ensure_ascii=False, indent=2, default=str)
@@ -49,6 +52,114 @@ def fail(message, code=1, detail=None):
     raise SystemExit(code)
 
 
+def rebuild_cjk_appearances(path, values, font_file):
+    """Replace the appearance of text widgets whose value is non-Latin.
+
+    pypdf can only generate appearance streams with the base-14 fonts, so a
+    Chinese value would paint as question marks even though /V is correct.
+    Each such widget gets a fresh form XObject drawn with a real CJK font,
+    with the field border and background kept.
+    """
+    from pypdf import PdfReader, PdfWriter
+    from pypdf.generic import ArrayObject, DictionaryObject, FloatObject, NameObject, NumberObject, StreamObject
+    from reportlab.lib.colors import Color
+    from reportlab.pdfbase import pdfmetrics
+    from reportlab.pdfgen import canvas as rl_canvas
+
+    reader = PdfReader(str(path))
+    report = inspect_document(reader)
+    targets = []
+    for widget in report["widgets"]:
+        name = widget["name"]
+        value = values.get(name)
+        if not has_non_latin(value) or widget["field_type"] != "/Tx":
+            continue
+        rect = widget["rect"]
+        if len(rect) != 4:
+            continue
+        width = float(rect[2]) - float(rect[0])
+        height = float(rect[3]) - float(rect[1])
+        if width <= 1 or height <= 1:
+            continue
+        targets.append({"page": widget["page"], "name": name, "value": value, "width": width, "height": height})
+    if not targets:
+        return []
+
+    try:
+        font_path = find_cjk_font(font_file)
+    except FileNotFoundError as exc:
+        fail(str(exc), code=2)
+    if font_path is None:
+        fail("values contain non-Latin text but no CJK font was found; pass --font-file", code=2)
+    try:
+        font_name = register_cjk_font(font_path, "FormCJK")
+    except Exception as exc:
+        fail(f"cannot use font file {font_path}: {exc}", code=2)
+
+    overlay = io.BytesIO()
+    page = rl_canvas.Canvas(overlay)
+    for target in targets:
+        width, height = target["width"], target["height"]
+        page.setPageSize((width, height))
+        page.setFillColor(Color(1, 1, 1))
+        page.rect(0, 0, width, height, stroke=0, fill=1)
+        page.setStrokeColor(Color(0.55, 0.55, 0.55))
+        page.setLineWidth(0.5)
+        page.rect(0.25, 0.25, width - 0.5, height - 0.5, stroke=1, fill=0)
+        size = min(10.0, max(height - 3, 4.0))
+        while size > 4 and pdfmetrics.stringWidth(target["value"], font_name, size) > width - 4:
+            size -= 0.5
+        page.setFillColor(Color(0, 0, 0))
+        page.setFont(font_name, size)
+        baseline = (height - size) / 2 + size * 0.22
+        page.drawString(2, baseline, target["value"])
+        page.showPage()
+    page.save()
+    overlay.seek(0)
+    overlay_reader = PdfReader(overlay)
+
+    writer = PdfWriter()
+    writer.clone_document_from_reader(reader)
+    original_pages = len(writer.pages)
+    writer.append(overlay_reader)
+    appended = writer.pages[original_pages:]
+
+    for index, target in enumerate(targets):
+        overlay_page = appended[index]
+        contents = overlay_page.get_contents()
+        data = contents.get_data() if contents is not None else b""
+        resources = overlay_page.get("/Resources")
+        stream = StreamObject()
+        stream.set_data(data)
+        stream[NameObject("/Type")] = NameObject("/XObject")
+        stream[NameObject("/Subtype")] = NameObject("/Form")
+        stream[NameObject("/FormType")] = NumberObject(1)
+        stream[NameObject("/BBox")] = ArrayObject(
+            [FloatObject(0), FloatObject(0), FloatObject(target["width"]), FloatObject(target["height"])]
+        )
+        if resources is not None:
+            stream[NameObject("/Resources")] = resources
+        reference = writer._add_object(stream)
+        page = writer.pages[target["page"] - 1]
+        for annotation in page.get("/Annots") or []:
+            obj = annotation.get_object()
+            if obj.get("/Subtype") != "/Widget":
+                continue
+            parent = obj.get("/Parent")
+            source = parent.get_object() if parent is not None else obj
+            tag = obj.get("/T") or source.get("/T")
+            if str(tag) != target["name"]:
+                continue
+            obj[NameObject("/AP")] = DictionaryObject({NameObject("/N"): reference})
+            break
+
+    while len(writer.pages) > original_pages:
+        writer.remove_page(len(writer.pages) - 1)
+    with open(path, "wb") as handle:
+        writer.write(handle)
+    return [target["name"] for target in targets]
+
+
 def ref_id(node):
     if isinstance(node, IndirectObject):
         return node.idnum
@@ -285,6 +396,85 @@ def values_for_field(field, value):
     return str(value)
 
 
+def flatten_widgets(path):
+    """Paint every widget appearance into page content and drop the form."""
+    from pypdf import PdfReader, PdfWriter
+    from pypdf.generic import ArrayObject, DictionaryObject, FloatObject, NameObject, StreamObject
+
+    reader = PdfReader(str(path))
+    writer = PdfWriter()
+    writer.clone_document_from_reader(reader)
+
+    for page in writer.pages:
+        annotations = page.get("/Annots")
+        if not annotations:
+            continue
+        resources = page.get("/Resources")
+        if resources is None:
+            resources = DictionaryObject()
+            page[NameObject("/Resources")] = resources
+        resources = resources.get_object()
+        xobjects = resources.get("/XObject")
+        if xobjects is None:
+            xobjects = DictionaryObject()
+            resources[NameObject("/XObject")] = xobjects
+        xobjects = xobjects.get_object()
+
+        calls = []
+        for index, annotation in enumerate(annotations):
+            widget = annotation.get_object()
+            if widget.get("/Subtype") != "/Widget":
+                continue
+            normal = widget.get("/AP")
+            if normal is None:
+                continue
+            normal = normal.get_object().get("/N")
+            if normal is None:
+                continue
+            normal = normal.get_object()
+            if not hasattr(normal, "get_data"):
+                if not hasattr(normal, "keys"):
+                    continue
+                state = widget.get("/AS")
+                if state is None or normal.get(state) is None:
+                    continue
+                normal = normal[state].get_object()
+            if not hasattr(normal, "get_data"):
+                continue
+            name = NameObject(f"/DSCJK{index}")
+            xobjects[name] = normal.indirect_reference or normal
+            rect = [float(value) for value in widget.get("/Rect") or []]
+            bbox = [float(value) for value in normal.get("/BBox") or []]
+            if len(rect) != 4 or len(bbox) != 4:
+                continue
+            x, y, x2, y2 = rect[0], rect[1], rect[2], rect[3]
+            width = x2 - x
+            height = y2 - y
+            box_width = bbox[2] - bbox[0] or width
+            box_height = bbox[3] - bbox[1] or height
+            calls.append(
+                f"q {width / box_width:.6f} 0 0 {height / box_height:.6f} {x:.4f} {y:.4f} cm {name} Do Q"
+            )
+        if not calls:
+            continue
+        stream = StreamObject()
+        stream.set_data("\n".join(calls).encode("latin-1"))
+        reference = writer._add_object(stream)
+        existing = page.get("/Contents")
+        if existing is None:
+            page[NameObject("/Contents")] = reference
+        elif hasattr(existing, "get_data"):
+            page[NameObject("/Contents")] = ArrayObject([existing.indirect_reference or existing, reference])
+        else:
+            page[NameObject("/Contents")] = ArrayObject([*existing, reference])
+
+    for page in writer.pages:
+        page[NameObject("/Annots")] = ArrayObject()
+    writer.root_object.pop(NameObject("/AcroForm"), None)
+    with open(path, "wb") as handle:
+        writer.write(handle)
+
+
 def write_fill(args, values):
     from pypdf import PdfReader, PdfWriter
 
@@ -332,16 +522,28 @@ def write_fill(args, values):
         payload = current
     payload = {name: values_for_field(fields[name], value) for name, value in payload.items()}
 
-    writer.update_page_form_field_values(None, payload, auto_regenerate=False, flatten=args.flatten)
-    sync_button_states(writer)
-    if args.flatten:
-        writer.remove_annotations(subtypes="/Widget")
-        writer.root_object.pop(NameObject("/AcroForm"), None)
+    cjk_values = {name: value for name, value in expected.items() if has_non_latin(value)}
+    flatten = args.flatten
+    if flatten and cjk_values:
+        # pypdf can only flatten with base-14 fonts; keep the widgets, give them
+        # real CJK appearances, then paint every appearance into the page.
+        writer.update_page_form_field_values(None, payload, auto_regenerate=False, flatten=False)
+        sync_button_states(writer)
+    else:
+        writer.update_page_form_field_values(None, payload, auto_regenerate=False, flatten=flatten)
+        sync_button_states(writer)
+        if flatten:
+            writer.remove_annotations(subtypes="/Widget")
+            writer.root_object.pop(NameObject("/AcroForm"), None)
 
     args.out.parent.mkdir(parents=True, exist_ok=True)
     with open(args.out, "wb") as handle:
         writer.write(handle)
 
+    cjk_rendered = rebuild_cjk_appearances(args.out, expected, args.font_file)
+    if flatten and cjk_values:
+        flatten_widgets(args.out)
+
     checks = verify(args.out, expected, flatten=args.flatten)
     rendered = render(args.out, args.render_dir, args.dpi)
 
@@ -351,6 +553,7 @@ def write_fill(args, values):
         "output": str(args.out),
         "flatten": args.flatten,
         "reattached_fields": reattached,
+        "cjk_appearance_fields": cjk_rendered,
         "written": expected,
         "checks": checks,
         "rendered_pages": rendered,
@@ -517,6 +720,7 @@ def main():
         help='JSON object of {field: value}; accepts a file path, inline JSON, or "-" for stdin',
     )
     fill_parser.add_argument("--flatten", action="store_true", help="Paint values and remove every widget")
+    fill_parser.add_argument("--font-file", help="TTF/OTF/TTC file used to paint non-Latin values")
     fill_parser.add_argument("--no-reattach", action="store_true", help="Do not repair widgets missing from /AcroForm/Fields")
     fill_parser.add_argument("--allow-ambiguous", action="store_true", help="Fill even when widget and field views disagree")
     fill_parser.add_argument("--render-dir", help="Rasterise the result here for a visual check")

package/assets/skills/office-pdf/scripts/pdf_fonts.py

@@ -0,0 +1,67 @@
+"""Font handling shared by the PDF scripts.
+
+reportlab's base-14 fonts cover Latin-1 only, so a Chinese, Japanese, or Korean
+stamp or form value needs a real font file. These helpers find one, or report
+that the caller must pass --font-file.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+CJK_FONT_CANDIDATES = {
+    "win32": [
+        "C:/Windows/Fonts/msyh.ttc",
+        "C:/Windows/Fonts/msyhbd.ttc",
+        "C:/Windows/Fonts/simhei.ttf",
+        "C:/Windows/Fonts/simsun.ttc",
+    ],
+    "linux": [
+        "/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc",
+        "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",
+        "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc",
+        "/usr/share/fonts/opentype/noto/NotoSerifCJK-Regular.ttc",
+    ],
+    "darwin": [
+        "/System/Library/Fonts/PingFang.ttc",
+        "/System/Library/Fonts/STHeiti Medium.ttc",
+        "/System/Library/Fonts/Hiragino Sans GB.ttc",
+    ],
+}
+
+
+def has_non_latin(text) -> bool:
+    """True when text needs a font beyond the base-14 Latin sets."""
+    return isinstance(text, str) and any(ord(character) > 0xFF for character in text)
+
+
+def find_cjk_font(explicit=None) -> Path | None:
+    """Return a usable CJK font path, honouring an explicit path first."""
+    if explicit:
+        path = Path(explicit).expanduser()
+        if not path.is_file():
+            raise FileNotFoundError(f"font file not found: {path}")
+        return path
+    override = os.environ.get("DSH_OFFICE_CJK_FONT")
+    if override and Path(override).expanduser().is_file():
+        return Path(override).expanduser()
+    platform_key = "win32" if sys.platform.startswith("win") else "darwin" if sys.platform == "darwin" else "linux"
+    for candidate in CJK_FONT_CANDIDATES[platform_key]:
+        path = Path(candidate)
+        if path.is_file():
+            return path
+    return None
+
+
+def register_cjk_font(path: Path, name: str) -> str:
+    """Register a TTF/OTF/TTC file with reportlab and return the resource name."""
+    from reportlab.pdfbase import pdfmetrics
+    from reportlab.pdfbase.ttfonts import TTFont
+
+    kwargs = {}
+    if path.suffix.lower() in {".ttc", ".otc", ".dfont"}:
+        kwargs["subfontIndex"] = 0
+    pdfmetrics.registerFont(TTFont(name, str(path), **kwargs))
+    return name

package/assets/skills/office-pdf/scripts/stamp_overlay.py

@@ -28,6 +28,8 @@ from pypdf import PdfReader, PdfWriter
 from reportlab.lib.colors import HexColor
 from reportlab.pdfgen import canvas
 
+from pdf_fonts import find_cjk_font, has_non_latin, register_cjk_font
+
 try:
     import pymupdf
 except ImportError:  # pragma: no cover - PyMuPDF is a required dependency
@@ -90,7 +92,8 @@ def main():
         default="bottom-center",
         help="Anchor of the stamp (default: bottom-center)",
     )
-    parser.add_argument("--font", default="Helvetica", help="reportlab base-14 font name (default: Helvetica)")
+    parser.add_argument("--font", default="Helvetica", help="reportlab font name (default: Helvetica)")
+    parser.add_argument("--font-file", help="TTF/OTF/TTC file used for the stamp; required for CJK unless a system font is found")
     parser.add_argument("--font-size", type=float, default=9.0, help="Font size in points (default: 9)")
     parser.add_argument("--color", default="#666666", help="Hex text colour (default: #666666)")
     parser.add_argument("--margin", type=float, default=28.0, help="Page-edge margin in points (default: 28)")
@@ -127,6 +130,22 @@ def main():
     page_count = len(reader.pages)
     selected = parse_pages(args.pages, page_count)
 
+    sample = args.text.format(page=1, pages=page_count)
+    font_name = args.font
+    font_file = None
+    if args.font_file or has_non_latin(sample):
+        try:
+            path = find_cjk_font(args.font_file)
+        except FileNotFoundError as exc:
+            fail(str(exc), code=2)
+        if path is None:
+            fail("stamp text needs a font beyond the base-14 Latin sets; pass --font-file with a CJK-capable TTF/TTC", code=2)
+        try:
+            font_name = register_cjk_font(path, "StampCJK")
+        except Exception as exc:
+            fail(f"cannot use font file {path}: {exc}", code=2)
+        font_file = str(path)
+
     writer = PdfWriter()
     stamped = []
     for index, page in enumerate(reader.pages, start=1):
@@ -138,9 +157,9 @@ def main():
             buffer = io.BytesIO()
             stamp = canvas.Canvas(buffer, pagesize=(width, height))
             stamp.setFillColor(colour)
-            stamp.setFont(args.font, args.font_size)
+            stamp.setFont(font_name, args.font_size)
             stamp.setFillAlpha(args.opacity)
-            text_width = stamp.stringWidth(label, args.font, args.font_size)
+            text_width = stamp.stringWidth(label, font_name, args.font_size)
             anchor = POSITIONS[args.position]
             if anchor == "left":
                 x = args.margin
@@ -185,7 +204,8 @@ def main():
         "pages": page_count,
         "stamped_pages": stamped,
         "position": args.position,
-        "font": args.font,
+        "font": font_name,
+        "font_file": font_file,
         "font_size": args.font_size,
         "color": args.color,
         "rendered_pages": rendered,

package/assets/skills/office-pdf/tasks/forms.md

@@ -55,6 +55,15 @@ Radio groups fail most: pypdf updates the group `/V` but leaves the old button's
 
 Flatten when the file must stay uneditable: fill with `flatten=True` (the value is painted into page content), remove every widget annotation (`subtypes="/Widget"`), and drop `/AcroForm` from the catalog. Then confirm no `/Widget` and no `/AcroForm` remain; otherwise readers still treat the file as editable.
 
+## Non-Latin values
+
+pypdf's appearance writer encodes WinAnsi, so a Chinese, Japanese, or Korean value lands in `/V` but the widget paints `?` or falls back to Helvetica. The script detects non-Latin values, registers a system CJK font (YaHei, WenQuanYi, PingFang, Noto) or the `--font-file` you pass, draws the value with reportlab, and replaces `/AP /N` with that form; the field names it repainted are listed as `cjk_appearance_fields`. `--flatten` paints those streams into the page content before stripping the widgets. Verify `/V` plus the render: the subset font has no ToUnicode map, so a text dump of the appearance is not reliable evidence.
+
+```bash
+"<python>" "<skill>/scripts/forms.py" fill --input "<form.pdf>" --out "<filled.pdf>" \
+  --values '{"full_name": "张伟"}' --font-file "C:/Windows/Fonts/msyh.ttc" --render-dir "<render>"
+```
+
 ## What cannot be filled, and the fix
 
 - **No appearance stream and a broken `/DA`**: the reader may not show a new value. Render after filling; if invisible, rebuild that widget's appearance with reportlab and merge it over the page.

package/assets/skills/office-pdf/tasks/stamp.md

@@ -52,7 +52,8 @@ Use each page's own `mediabox` when sizes may mix; a stamp drawn for A4 lands in
 - **Existing footers**: check the bottom margin first; the render is the proof, not the coordinate math. If a page number is already there, skip the stamp or use the opposite side.
 - **Rotated pages**: a `/Rotate 90` page renders sideways, so text drawn unrotated appears rotated. Rotate the stamp (`c.rotate(90)`, adjusting the origin), or rotate the page back first.
 - **Repeated stamping**: merging the same overlay twice doubles the opacity at the same position; re-run from the original input when iterating.
-- **Fonts**: Helvetica handles Latin; a CJK stamp needs a registered TTF, or the text renders as blank boxes. Check the render.
+- **Fonts**: Helvetica handles Latin; for CJK the script registers a system CJK font (YaHei, WenQuanYi, PingFang, Noto) and reports it as `font_file`. Pass `--font-file` with a specific TTF/OTF/TTC when the host has none; without one it exits 2 instead of drawing blank boxes. Check the render.
+- **Font files**: a `.ttc` collection needs its first face; the script handles that. Keep `--font` at its default when passing `--font-file` — the file overrides the base-14 name.
 - **Opacity**: `setFillAlpha` works only in viewers that honour transparency groups; a stamp that must show on any viewer is safer at full opacity.
 
 ## Verify

package/assets/skills/office-presentations/container_tools/preview_render.py

@@ -19,6 +19,7 @@ Exit codes: 0 ok, 2 unreadable input, 3 nothing rasterised.
 from __future__ import annotations
 
 import json
+import math
 import sys
 from pathlib import Path
 from typing import Any
@@ -254,7 +255,9 @@ def _draw_chart(page, shape, rect: fitz.Rect, slide_no: int, notes: list[dict[st
         for index, value in enumerate(values):
             sweep = 360.0 * abs(value) / total
             shade = shades[index % len(shades)]
-            page.draw_pie(center, radius, fitz.Point(radius * 1.0, 0), start, start + sweep, color=RULE, fill=(shade, shade, shade * 0.95 + 0.05), width=0.6)
+            # PyMuPDF 1.28 dropped Page.draw_pie; draw_sector has been stable since 1.16.
+            edge = fitz.Point(center.x + radius * math.cos(math.radians(start)), center.y + radius * math.sin(math.radians(start)))
+            page.draw_sector(center, edge, sweep, color=RULE, fill=(shade, shade, shade * 0.95 + 0.05), width=0.6)
             start += sweep
         return
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-office-kit",
   "type": "module",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "Office documents, PDF, presentations, and spreadsheets for DeepSeek Harness",
   "author": "Hairy",
   "license": "MIT",

package/python/office_cli.py

@@ -278,10 +278,130 @@ def export_pdf(input_path: Path, out_dir: Path, dpi: int) -> dict[str, Any]:
         fail(f"the LibreOffice kit reported a PDF export for {input_path.name} but wrote none")
     return {
         "pdf": str(produced),
+        "backend": report.get("backend"),
         "missing_fonts": [str(name) for name in report.get("missingFonts") or []],
     }
 
 
+def xlsx_render(input_path: Path, out_dir: Path, dpi: int) -> dict[str, Any]:
+    """Render a workbook through PDF, because the kit's direct render prints ranges only.
+
+    The direct xlsx render path rasterises each used range and drops charts, images
+    and print areas; converting first lays the sheet out the way the app prints it.
+    """
+    converted = export_pdf(input_path, out_dir, dpi)
+    pages = rasterize_pdf(converted["pdf"], out_dir, dpi)
+    missing = converted["missing_fonts"]
+    warnings = glyph_warnings(missing)
+    report_warnings(warnings)
+    return {
+        "ok": True,
+        "kind": "xlsx",
+        "command": "render",
+        "input": str(input_path),
+        "renderer": "libreoffice-kit",
+        "engine": converted.get("backend"),
+        "page_count": len(pages),
+        "pages": pages,
+        "images": [
+            {"page": index, "sheet": None, "range": None, "path": path}
+            for index, path in enumerate(pages, start=1)
+        ],
+        "pdf": converted["pdf"],
+        "missing_fonts": missing,
+        "glyph_fallback": bool(missing),
+        "warnings": warnings,
+    }
+
+
+def docx_used_fonts(path: Path) -> set[str]:
+    """Font names the document actually applies.
+
+    The kit reports every font in the package, including latent styles inherited
+    from python-docx's template (e.g. Courier in the unused MacroText style), so
+    a document with no Courier text still warns about it. Keep only fonts that
+    appear on a run, in a referenced style, in the defaults, or in the theme.
+    """
+    import zipfile
+
+    from lxml import etree
+
+    w = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}"
+    fonts: set[str] = set()
+    styles: dict[str, tuple[set[str], str | None]] = {}
+    referenced: set[str] = set()
+    theme_fonts: set[str] = set()
+
+    def rfonts(element) -> set[str]:
+        found = set()
+        for node in element.iter(f"{w}rFonts"):
+            for attribute in ("ascii", "hAnsi", "eastAsia", "cs"):
+                value = node.get(f"{w}{attribute}")
+                if value:
+                    found.add(value)
+        return found
+
+    with zipfile.ZipFile(path) as archive:
+        names = set(archive.namelist())
+
+        def load(name: str):
+            return etree.fromstring(archive.read(name))
+
+        if "word/styles.xml" in names:
+            root = load("word/styles.xml")
+            defaults = root.find(f"{w}docDefaults")
+            if defaults is not None:
+                fonts.update(rfonts(defaults))
+            for style in root.iter(f"{w}style"):
+                style_id = style.get(f"{w}styleId")
+                based_on = style.find(f"{w}basedOn")
+                styles[style_id] = (rfonts(style), based_on.get(f"{w}val") if based_on is not None else None)
+
+        for name in names:
+            if not name.startswith("word/") or not name.endswith(".xml"):
+                continue
+            if name.startswith(("word/styles", "word/theme/")):
+                continue
+            root = load(name)
+            fonts.update(rfonts(root))
+            for tag in ("pStyle", "rStyle", "tblStyle"):
+                for element in root.iter(f"{w}{tag}"):
+                    value = element.get(f"{w}val")
+                    if value:
+                        referenced.add(value)
+
+        if "word/theme/theme1.xml" in names:
+            theme = load("word/theme/theme1.xml")
+            for tag in ("majorFont", "minorFont"):
+                for element in theme.iter(tag):
+                    latin = element.find("latin")
+                    if latin is not None and latin.get("typeface"):
+                        theme_fonts.add(latin.get("typeface"))
+
+    pending = list(referenced)
+    seen = set()
+    while pending:
+        style_id = pending.pop()
+        if style_id in seen:
+            continue
+        seen.add(style_id)
+        entry = styles.get(style_id)
+        if entry is None:
+            continue
+        style_fonts, based_on = entry
+        fonts.update(style_fonts)
+        if based_on:
+            pending.append(based_on)
+    return fonts | theme_fonts
+
+
+def filter_missing_fonts(input_path: Path, kind: str, missing: list[str]) -> list[str]:
+    if kind != "docx" or not missing:
+        return missing
+    used = {name.lower() for name in docx_used_fonts(input_path)}
+    return [name for name in missing if name.lower() in used]
+
+
 def render_office(input_path: Path, kind: str, out_dir: Path, dpi: int, emit_pdf: bool = False) -> dict[str, Any]:
     """Rasterise an Office file page by page through the kit.
 
@@ -314,7 +434,7 @@ def render_office(input_path: Path, kind: str, out_dir: Path, dpi: int, emit_pdf
     shutil.rmtree(staging, ignore_errors=True)
     if not images:
         fail(f"the LibreOffice kit rendered no pages for {input_path.name}")
-    missing = [str(name) for name in report.get("missingFonts") or []]
+    missing = filter_missing_fonts(input_path, kind, [str(name) for name in report.get("missingFonts") or []])
     warnings = glyph_warnings(missing)
     report_warnings(warnings)
     result: dict[str, Any] = {
@@ -333,10 +453,11 @@ def render_office(input_path: Path, kind: str, out_dir: Path, dpi: int, emit_pdf
     if emit_pdf:
         converted = export_pdf(input_path, out_dir, dpi)
         result["pdf"] = converted["pdf"]
-        if not missing and converted["missing_fonts"]:
-            result["missing_fonts"] = converted["missing_fonts"]
+        converted_missing = filter_missing_fonts(input_path, kind, converted["missing_fonts"])
+        if not missing and converted_missing:
+            result["missing_fonts"] = converted_missing
             result["glyph_fallback"] = True
-            result["warnings"] = glyph_warnings(converted["missing_fonts"])
+            result["warnings"] = glyph_warnings(converted_missing)
             report_warnings(result["warnings"])
     return result
 
@@ -769,8 +890,8 @@ def _pdf_flowables(blocks: Iterable[dict[str, Any]], font: str, counters: dict[s
 
     styles = getSampleStyleSheet()
     body = ParagraphStyle("OfficeBody", parent=styles["BodyText"], fontName=font, fontSize=10.5, leading=15)
-    heading1 = ParagraphStyle("OfficeH1", parent=styles["Heading1"], fontName=font, fontSize=18, leading=24)
-    heading2 = ParagraphStyle("OfficeH2", parent=styles["Heading2"], fontName=font, fontSize=14, leading=20)
+    heading1 = ParagraphStyle("OfficeH1", parent=styles["Heading1"], fontName=font, fontSize=18, leading=24, spaceBefore=16, spaceAfter=8)
+    heading2 = ParagraphStyle("OfficeH2", parent=styles["Heading2"], fontName=font, fontSize=14, leading=20, spaceBefore=12, spaceAfter=6)
     title = ParagraphStyle("OfficeTitle", parent=styles["Title"], fontName=font, fontSize=22, leading=28)
     flowables = []
     for block in blocks:
@@ -788,8 +909,8 @@ def _pdf_flowables(blocks: Iterable[dict[str, Any]], font: str, counters: dict[s
             flowables.append(Paragraph(escape(str(block.get("text", ""))), body))
             counters["paragraphs"] += 1
         elif block_type in {"bullets", "numbered"}:
-            for item in block.get("items", []):
-                prefix = "• " if block_type == "bullets" else "1. "
+            for index, item in enumerate(block.get("items", []), start=1):
+                prefix = "• " if block_type == "bullets" else f"{index}. "
                 flowables.append(Paragraph(prefix + escape(str(item)), body))
                 counters["list_items"] += 1
         elif block_type == "table":
@@ -1427,6 +1548,8 @@ def main() -> None:
             out_dir = Path(args.out_dir)
             if args.format == "pdf":
                 result = pdf_render(input_path, out_dir, args.dpi)
+            elif args.format == "xlsx":
+                result = xlsx_render(input_path, out_dir, args.dpi)
             else:
                 result = render_office(input_path, args.format, out_dir, args.dpi, emit_pdf=bool(getattr(args, "pdf", False)))
         elif args.command == "recalc":