dsh-office-kit 0.4.3 → 0.4.4

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-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.4",
   "description": "Office documents, PDF, presentations, and spreadsheets for DeepSeek Harness",
   "author": "Hairy",
   "license": "MIT",

package/python/office_cli.py

@@ -278,10 +278,42 @@ 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 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.
 
@@ -769,8 +801,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 +820,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 +1459,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":