react-native-ensys-camera-x 1.0.7

package/android/src/main/java/com/customcamera/OfficeDocumentConverter.kt

@@ -0,0 +1,2791 @@
+package com.customcamera
+
+import android.util.Base64
+import android.util.Xml
+import org.xmlpull.v1.XmlPullParser
+import java.io.File
+import java.io.InputStream
+import java.util.zip.ZipFile
+
+/**
+ * Native, dependency-free office-document → HTML conversion pipeline (the "reader/extractor/
+ * formatter" of the in-app preview). Each converter parses the format's REAL internal structure
+ * (OOXML / ODF XML inside the zip container, RTF control words, CSV records) with only Android
+ * SDK primitives — java.util.zip + XmlPullParser + Base64 — and emits fidelity-focused HTML/CSS
+ * that the locked preview WebView (JavaScript off, network blocked, navigation blocked) lays out
+ * with its Chromium engine.
+ *
+ * Fidelity model: the ORIGINAL geometry travels through — page width/height/margins (DOCX/ODT,
+ * from the section properties, in true points), slide dimensions and absolute shape positions
+ * (PPTX, from EMUs), column widths / row heights / merged regions (XLSX/ODS), font names/sizes/
+ * colors, alignment, indents, line/paragraph spacing, table grids, borders, shading, and images
+ * at their authored display size (inlined as data URIs so the locked WebView needs no file
+ * access). Where the source font isn't installed on the device, the ORIGINAL family name is
+ * emitted first so an equivalent installed face is used before falling back per CSS.
+ *
+ * Honest limits (engine-level, not fixable by parsing): automatic pagination (where Word breaks
+ * a page mid-flow) and glyph-exact line breaking depend on the original layout engine + exact
+ * font metrics, so continuous content renders as one flowing sheet per EXPLICIT page break with
+ * the true page width and margins. Binary-era DOC/PPT/XLS and Apple PAGES are proprietary binary
+ * formats that require a full engine (LibreOffice-class) to read — they are not handled here and
+ * keep the informational-card fallback.
+ */
+internal object OfficeDocumentConverter {
+
+  class Conversion(val html: String, val pageCount: Int)
+
+  /** [kind] is the preview kind routed from JS (docx/xlsx/odt/ods/rtf/csv/epub). */
+  fun convert(file: File, kind: String): Conversion = when (kind) {
+    "docx" -> DocxConverter(file).convert()
+    "xlsx" -> XlsxConverter(file).convert()
+    "odt" -> OdtConverter(file).convert()
+    "ods" -> OdsConverter(file).convert()
+    "rtf" -> RtfConverter(file).convert()
+    "csv" -> CsvConverter(file).convert()
+    "epub" -> EpubConverter(file).convert()
+    else -> throw IllegalArgumentException("Unsupported office kind: $kind")
+  }
+}
+
+/** Shared parsing/formatting helpers for every office converter. */
+internal object Ox {
+  /** Per-image and total caps keep data-URI inlining bounded on low-RAM devices. */
+  const val MAX_IMAGE_BYTES = 4 * 1024 * 1024
+  const val MAX_TOTAL_IMAGE_BYTES = 24 * 1024 * 1024
+
+  /**
+   * Cap on the DISPLAYED page margins (DOCX/ODT/RTF). Authored one-inch print margins read
+   * as huge blank bands around a phone-scaled page. Converters shrink the sheet by exactly
+   * the amount the margins shrink, so the CONTENT box keeps its authored width — identical
+   * line lengths and wrapping — while the whole layout scales larger on screen.
+   */
+  const val MAX_DISPLAY_MARGIN_PT = 20f
+
+  fun esc(s: String): String = buildString(s.length + 16) {
+    for (c in s) when (c) {
+      '&' -> append("&")
+      '<' -> append("&lt;")
+      '>' -> append("&gt;")
+      '"' -> append("&quot;")
+      else -> append(c)
+    }
+  }
+
+  fun parser(input: InputStream): XmlPullParser =
+    Xml.newPullParser().apply {
+      // Namespace prefixes are matched by local name (see [local]) — cheaper and resilient to
+      // producers that bind non-standard prefixes.
+      setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, false)
+      setInput(input, null)
+    }
+
+  fun local(p: XmlPullParser): String = p.name?.substringAfterLast(':') ?: ""
+
+  fun attr(p: XmlPullParser, name: String): String? {
+    for (i in 0 until p.attributeCount) {
+      val an = p.getAttributeName(i)
+      if (an == name || an.substringAfterLast(':') == name) return p.getAttributeValue(i)
+    }
+    return null
+  }
+
+  /** Skips the current element including all children (parser positioned ON its START_TAG). */
+  fun skip(p: XmlPullParser) {
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> depth++
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> return
+      }
+    }
+  }
+
+  /** All character data inside the current element (which may contain child tags to flatten). */
+  fun elementText(p: XmlPullParser): String {
+    val sb = StringBuilder()
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> depth++
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.TEXT -> sb.append(p.text)
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return sb.toString()
+  }
+
+  // ── Units ─────────────────────────────────────────────────────────
+  fun twipsToPt(v: String?): Float? = v?.toFloatOrNull()?.let { it / 20f }
+  fun halfPtToPt(v: String?): Float? = v?.toFloatOrNull()?.let { it / 2f }
+  fun emuToPt(v: String?): Float? = v?.toLongOrNull()?.let { it / 12700f }
+
+  /** Compact CSS number: 12 → "12", 12.5 → "12.5". */
+  fun n(v: Float): String =
+    if (v == v.toLong().toFloat()) v.toLong().toString() else String.format("%.2f", v)
+
+  // ── Zip access ────────────────────────────────────────────────────
+  fun zipBytes(zip: ZipFile, path: String, cap: Int = Int.MAX_VALUE): ByteArray? {
+    val entry = zip.getEntry(path) ?: return null
+    if (entry.size in 1..Long.MAX_VALUE && entry.size > cap) return null
+    zip.getInputStream(entry).use { stream ->
+      val out = java.io.ByteArrayOutputStream(minOf(entry.size.toInt().coerceAtLeast(1024), 1 shl 20))
+      val buf = ByteArray(64 * 1024)
+      var total = 0
+      while (true) {
+        val read = stream.read(buf)
+        if (read == -1) break
+        total += read
+        if (total > cap) return null
+        out.write(buf, 0, read)
+      }
+      return out.toByteArray()
+    }
+  }
+
+  fun zipStream(zip: ZipFile, path: String): InputStream? =
+    zip.getEntry(path)?.let { zip.getInputStream(it) }
+
+  /** Resolves [target] relative to the directory of [basePart], normalizing `..` segments. */
+  fun resolveZipPath(basePart: String, target: String): String {
+    if (target.startsWith("/")) return target.trimStart('/')
+    val stack = ArrayDeque<String>()
+    val baseDir = basePart.substringBeforeLast('/', "")
+    if (baseDir.isNotEmpty()) baseDir.split('/').forEach { stack.addLast(it) }
+    for (seg in target.split('/')) {
+      when (seg) {
+        "", "." -> {}
+        ".." -> stack.removeLastOrNull()
+        else -> stack.addLast(seg)
+      }
+    }
+    return stack.joinToString("/")
+  }
+
+  /** OPC relationships: rId → target path resolved against [partPath]'s directory. */
+  fun parseRels(zip: ZipFile, partPath: String): Map<String, String> {
+    val relsPath = resolveZipPath(partPath, "_rels/${partPath.substringAfterLast('/')}.rels")
+    val stream = zipStream(zip, relsPath) ?: return emptyMap()
+    val out = HashMap<String, String>()
+    stream.use { s ->
+      val p = parser(s)
+      while (p.next() != XmlPullParser.END_DOCUMENT) {
+        if (p.eventType == XmlPullParser.START_TAG && local(p) == "Relationship") {
+          val id = attr(p, "Id")
+          val target = attr(p, "Target")
+          if (id != null && target != null) out[id] = resolveZipPath(partPath, target)
+        }
+      }
+    }
+    return out
+  }
+
+  // ── Images ────────────────────────────────────────────────────────
+  fun mimeForName(name: String): String = when (name.substringAfterLast('.', "").lowercase()) {
+    "png" -> "image/png"
+    "jpg", "jpeg" -> "image/jpeg"
+    "gif" -> "image/gif"
+    "bmp" -> "image/bmp"
+    "webp" -> "image/webp"
+    "svg" -> "image/svg+xml"
+    "emf", "wmf" -> "image/x-emf" // WebView can't decode these; caller may skip
+    else -> "application/octet-stream"
+  }
+
+  fun dataUri(bytes: ByteArray, mime: String): String =
+    "data:$mime;base64," + Base64.encodeToString(bytes, Base64.NO_WRAP)
+
+  // ── Document shell ────────────────────────────────────────────────
+  /**
+   * Wraps converted content in the standard preview shell. [contentWidthPt] drives the
+   * viewport width so the WebView's overview mode scales the TRUE-dimension layout to fit the
+   * screen exactly like a PDF page (pinch-zoom stays available for reading at 100%).
+   */
+  fun shell(contentWidthPt: Float, extraCss: String, body: String): String {
+    val viewportPx = (contentWidthPt * 4f / 3f).toInt().coerceAtLeast(320)
+    return "<!DOCTYPE html><html><head><meta charset=\"utf-8\"/>" +
+      "<meta name=\"viewport\" content=\"width=$viewportPx\"/>" +
+      "<style>" +
+      "html,body{margin:0;padding:0;background:#3A3D45;}" +
+      "*{box-sizing:border-box;}" +
+      // Edge-to-edge: the viewport is exactly the sheet width, so the page fills the preview
+      // with no dark bands around it. Sheets keep only a thin separator BETWEEN each other.
+      ".sheet{background:#FFFFFF;margin:0 auto;overflow:hidden;}" +
+      ".sheet+.sheet{margin-top:6pt;}" +
+      "p{margin:0;padding:0;}" +
+      "table{border-spacing:0;}" +
+      "img{max-width:100%;}" +
+      extraCss +
+      "</style></head><body>$body</body></html>"
+  }
+
+  /** Roman numeral / letter list markers shared by DOCX + ODF numbering. */
+  fun formatOrdinal(value: Int, fmt: String): String = when (fmt) {
+    "lowerLetter", "a" -> letter(value).lowercase()
+    "upperLetter", "A" -> letter(value)
+    "lowerRoman", "i" -> roman(value).lowercase()
+    "upperRoman", "I" -> roman(value)
+    else -> value.toString()
+  }
+
+  private fun letter(value: Int): String {
+    var v = value
+    val sb = StringBuilder()
+    while (v > 0) {
+      v--
+      sb.insert(0, ('A' + (v % 26)))
+      v /= 26
+    }
+    return sb.toString()
+  }
+
+  private fun roman(value: Int): String {
+    if (value <= 0 || value > 3999) return value.toString()
+    val symbols = listOf(
+      1000 to "M", 900 to "CM", 500 to "D", 400 to "CD", 100 to "C", 90 to "XC",
+      50 to "L", 40 to "XL", 10 to "X", 9 to "IX", 5 to "V", 4 to "IV", 1 to "I"
+    )
+    var v = value
+    val sb = StringBuilder()
+    for ((num, sym) in symbols) {
+      while (v >= num) {
+        sb.append(sym)
+        v -= num
+      }
+    }
+    return sb.toString()
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// DOCX (WordprocessingML)
+// ═══════════════════════════════════════════════════════════════════
+
+internal class DocxConverter(private val file: File) {
+
+  // Effective run formatting after style-chain resolution. Null = inherit.
+  private class RunProps {
+    var bold: Boolean? = null
+    var italic: Boolean? = null
+    var underline: Boolean? = null
+    var strike: Boolean? = null
+    var caps: Boolean? = null
+    var smallCaps: Boolean? = null
+    var vertAlign: String? = null
+    var sizePt: Float? = null
+    var color: String? = null
+    var highlight: String? = null
+    var shading: String? = null
+    var font: String? = null
+
+    fun overlayOn(base: RunProps?): RunProps {
+      val out = RunProps()
+      out.bold = bold ?: base?.bold
+      out.italic = italic ?: base?.italic
+      out.underline = underline ?: base?.underline
+      out.strike = strike ?: base?.strike
+      out.caps = caps ?: base?.caps
+      out.smallCaps = smallCaps ?: base?.smallCaps
+      out.vertAlign = vertAlign ?: base?.vertAlign
+      out.sizePt = sizePt ?: base?.sizePt
+      out.color = color ?: base?.color
+      out.highlight = highlight ?: base?.highlight
+      out.shading = shading ?: base?.shading
+      out.font = font ?: base?.font
+      return out
+    }
+  }
+
+  private class ParaProps {
+    var styleId: String? = null
+    var align: String? = null
+    var leftPt: Float? = null
+    var rightPt: Float? = null
+    var firstLinePt: Float? = null
+    var hangingPt: Float? = null
+    var beforePt: Float? = null
+    var afterPt: Float? = null
+    var lineCss: String? = null
+    var shading: String? = null
+    var pageBreakBefore = false
+    var numId: String? = null
+    var ilvl = 0
+    var runStyleId: String? = null
+
+    fun overlayOn(base: ParaProps?): ParaProps {
+      val out = ParaProps()
+      out.styleId = styleId ?: base?.styleId
+      out.align = align ?: base?.align
+      out.leftPt = leftPt ?: base?.leftPt
+      out.rightPt = rightPt ?: base?.rightPt
+      out.firstLinePt = firstLinePt ?: base?.firstLinePt
+      out.hangingPt = hangingPt ?: base?.hangingPt
+      out.beforePt = beforePt ?: base?.beforePt
+      out.afterPt = afterPt ?: base?.afterPt
+      out.lineCss = lineCss ?: base?.lineCss
+      out.shading = shading ?: base?.shading
+      out.pageBreakBefore = pageBreakBefore || (base?.pageBreakBefore ?: false)
+      out.numId = numId ?: base?.numId
+      out.ilvl = if (numId != null) ilvl else (base?.takeIf { it.numId != null }?.ilvl ?: ilvl)
+      out.runStyleId = runStyleId ?: base?.runStyleId
+      return out
+    }
+  }
+
+  private class Style(val id: String) {
+    var basedOn: String? = null
+    var pPr = ParaProps()
+    var rPr = RunProps()
+    /** Table styles: tblPr > tblBorders resolved to CSS, for tables referencing this style. */
+    var tblBorderCss: String? = null
+  }
+
+  private class NumLevel(val numFmt: String, val lvlText: String, val start: Int, val indentPt: Float?)
+
+  private class Section {
+    var pageWPt = 612f   // US Letter defaults
+    var pageHPt = 792f
+    var marTopPt = 72f
+    var marBottomPt = 72f
+    var marLeftPt = 72f
+    var marRightPt = 72f
+    var columns = 1
+    var columnGapPt = 36f
+    var headerPart: String? = null
+    var footerPart: String? = null
+  }
+
+  private lateinit var zip: ZipFile
+  private var rels: Map<String, String> = emptyMap()
+  private val styles = HashMap<String, Style>()
+  private var docDefaultsR = RunProps()
+  private var docDefaultsP = ParaProps()
+  private var defaultParaStyleId: String? = null
+  private val numToAbstract = HashMap<String, String>()
+  private val abstractLevels = HashMap<String, HashMap<Int, NumLevel>>()
+  private val listCounters = HashMap<String, IntArray>()
+  private val section = Section()
+  private var imageBudget = Ox.MAX_TOTAL_IMAGE_BYTES
+  private var sheetCount = 0
+
+  fun convert(): OfficeDocumentConverter.Conversion {
+    ZipFile(file).use { z ->
+      zip = z
+      rels = Ox.parseRels(z, "word/document.xml")
+      parseStyles()
+      parseNumbering()
+      scanSection()
+      val fontFaceCss = extractEmbeddedFonts()
+
+      val headerHtml = section.headerPart?.let { renderAuxPart(it) } ?: ""
+      val footerHtml = section.footerPart?.let { renderAuxPart(it) } ?: ""
+
+      val sheets = ArrayList<StringBuilder>()
+      sheets.add(StringBuilder())
+      Ox.zipStream(z, "word/document.xml")?.use { stream ->
+        val p = Ox.parser(stream)
+        // Advance into <w:body>, then stream its block-level children.
+        while (p.next() != XmlPullParser.END_DOCUMENT) {
+          if (p.eventType == XmlPullParser.START_TAG && Ox.local(p) == "body") {
+            renderBlocks(p, "body") { pageBreak, html ->
+              if (pageBreak && sheets.last().isNotEmpty()) sheets.add(StringBuilder())
+              sheets.last().append(html)
+            }
+            break
+          }
+        }
+      } ?: throw java.io.IOException("word/document.xml missing")
+
+      sheetCount = sheets.size
+      // Cap the displayed margins: the sheet shrinks by the same amount the margins do, so
+      // the content box (and therefore line wrapping) keeps its exact authored width while
+      // wasting far less of the phone screen on blank print margins.
+      val dispMarT = minOf(section.marTopPt, Ox.MAX_DISPLAY_MARGIN_PT)
+      val dispMarB = minOf(section.marBottomPt, Ox.MAX_DISPLAY_MARGIN_PT)
+      val dispMarL = minOf(section.marLeftPt, Ox.MAX_DISPLAY_MARGIN_PT)
+      val dispMarR = minOf(section.marRightPt, Ox.MAX_DISPLAY_MARGIN_PT)
+      val dispPageW = section.pageWPt - (section.marLeftPt - dispMarL) - (section.marRightPt - dispMarR)
+      val dispPageH = section.pageHPt - (section.marTopPt - dispMarT) - (section.marBottomPt - dispMarB)
+      val body = StringBuilder()
+      for ((index, sheet) in sheets.withIndex()) {
+        body.append("<div class=\"sheet docx\" style=\"width:")
+          .append(Ox.n(dispPageW)).append("pt;")
+        // Sheets size to their content: automatic pagination is unknowable here, so padding
+        // them to a full authored page height would append a large blank band under the
+        // final line of a short page.
+        body.append("padding:").append(Ox.n(dispMarT)).append("pt ")
+          .append(Ox.n(dispMarR)).append("pt ").append(Ox.n(dispMarB))
+          .append("pt ").append(Ox.n(dispMarL)).append("pt;\">")
+        if (headerHtml.isNotEmpty()) body.append("<div class=\"hdr\">").append(headerHtml).append("</div>")
+        if (section.columns > 1) {
+          body.append("<div style=\"column-count:").append(section.columns)
+            .append(";column-gap:").append(Ox.n(section.columnGapPt)).append("pt;\">")
+        }
+        body.append(sheet)
+        if (section.columns > 1) body.append("</div>")
+        if (footerHtml.isNotEmpty()) body.append("<div class=\"ftr\">").append(footerHtml).append("</div>")
+        body.append("</div>")
+      }
+
+      val defaultFont = docDefaultsR.font ?: "Calibri"
+      val defaultSize = docDefaultsR.sizePt ?: 11f
+      val css =
+        fontFaceCss +
+          ".docx{font-family:'${defaultFont.replace("'", "")}',sans-serif;" +
+          "font-size:${Ox.n(defaultSize)}pt;color:#000;line-height:1.15;" +
+          "display:flex;flex-direction:column;}" +
+          ".docx .ftr{margin-top:auto;}" +
+          ".docx td,.docx th{vertical-align:top;}"
+      return OfficeDocumentConverter.Conversion(
+        Ox.shell(dispPageW, css, body.toString()),
+        sheetCount
+      )
+    }
+  }
+
+  // ── styles.xml ───────────────────────────────────────────────────
+  private fun parseStyles() {
+    Ox.zipStream(zip, "word/styles.xml")?.use { stream ->
+      val p = Ox.parser(stream)
+      while (p.next() != XmlPullParser.END_DOCUMENT) {
+        if (p.eventType != XmlPullParser.START_TAG) continue
+        when (Ox.local(p)) {
+          "rPrDefault" -> {
+            // Contains one rPr with the document-wide run defaults.
+            var depth = 1
+            while (depth > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG -> if (Ox.local(p) == "rPr") { parseRunProps(p, docDefaultsR) } else depth++
+                XmlPullParser.END_TAG -> depth--
+              }
+            }
+          }
+          "pPrDefault" -> {
+            var depth = 1
+            while (depth > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG -> if (Ox.local(p) == "pPr") { parseParaProps(p, docDefaultsP) } else depth++
+                XmlPullParser.END_TAG -> depth--
+              }
+            }
+          }
+          "style" -> {
+            val type = Ox.attr(p, "type")
+            val id = Ox.attr(p, "styleId")
+            val isDefault = Ox.attr(p, "default") == "1" || Ox.attr(p, "default") == "true"
+            if (id == null) { Ox.skip(p); continue }
+            if (type == "paragraph" && isDefault) defaultParaStyleId = id
+            val style = Style(id)
+            var depth = 1
+            while (depth > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG -> when (Ox.local(p)) {
+                  "basedOn" -> { style.basedOn = Ox.attr(p, "val"); Ox.skip(p) }
+                  "pPr" -> parseParaProps(p, style.pPr)
+                  "rPr" -> parseRunProps(p, style.rPr)
+                  "tblPr" -> {
+                    var tDepth = 1
+                    while (tDepth > 0) {
+                      when (p.next()) {
+                        XmlPullParser.START_TAG ->
+                          if (Ox.local(p) == "tblBorders") style.tblBorderCss = parseBordersToCss(p)
+                          else Ox.skip(p)
+                        XmlPullParser.END_TAG -> tDepth--
+                        XmlPullParser.END_DOCUMENT -> return
+                      }
+                    }
+                  }
+                  else -> Ox.skip(p)
+                }
+                XmlPullParser.END_TAG -> depth--
+              }
+            }
+            styles[id] = style
+          }
+        }
+      }
+    }
+  }
+
+  /** Chain-resolved paragraph props for a style id (basedOn ancestors underneath). */
+  private fun resolveStyleP(id: String?, guard: Int = 0): ParaProps? {
+    if (id == null || guard > 8) return null
+    val style = styles[id] ?: return null
+    return style.pPr.overlayOn(resolveStyleP(style.basedOn, guard + 1))
+  }
+
+  private fun resolveStyleR(id: String?, guard: Int = 0): RunProps? {
+    if (id == null || guard > 8) return null
+    val style = styles[id] ?: return null
+    return style.rPr.overlayOn(resolveStyleR(style.basedOn, guard + 1))
+  }
+
+  /** Chain-resolved tblBorders CSS for a table style id (nearest declaration wins). */
+  private fun resolveTableStyleBorders(id: String?, guard: Int = 0): String? {
+    if (id == null || guard > 8) return null
+    val style = styles[id] ?: return null
+    return style.tblBorderCss ?: resolveTableStyleBorders(style.basedOn, guard + 1)
+  }
+
+  // ── numbering.xml ────────────────────────────────────────────────
+  private fun parseNumbering() {
+    Ox.zipStream(zip, "word/numbering.xml")?.use { stream ->
+      val p = Ox.parser(stream)
+      var currentAbstract: String? = null
+      while (p.next() != XmlPullParser.END_DOCUMENT) {
+        if (p.eventType != XmlPullParser.START_TAG) continue
+        when (Ox.local(p)) {
+          "abstractNum" -> currentAbstract = Ox.attr(p, "abstractNumId")
+          "lvl" -> {
+            val abs = currentAbstract ?: continue
+            val ilvl = Ox.attr(p, "ilvl")?.toIntOrNull() ?: continue
+            var numFmt = "decimal"
+            var lvlText = "%1."
+            var start = 1
+            var indentPt: Float? = null
+            var depth = 1
+            while (depth > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG -> when (Ox.local(p)) {
+                  "numFmt" -> { Ox.attr(p, "val")?.let { numFmt = it }; Ox.skip(p) }
+                  "lvlText" -> { Ox.attr(p, "val")?.let { lvlText = it }; Ox.skip(p) }
+                  "start" -> { Ox.attr(p, "val")?.toIntOrNull()?.let { start = it }; Ox.skip(p) }
+                  "ind" -> { indentPt = Ox.twipsToPt(Ox.attr(p, "left")); Ox.skip(p) }
+                  else -> Ox.skip(p)
+                }
+                XmlPullParser.END_TAG -> depth--
+              }
+            }
+            abstractLevels.getOrPut(abs) { HashMap() }[ilvl] = NumLevel(numFmt, lvlText, start, indentPt)
+          }
+          "num" -> {
+            val numId = Ox.attr(p, "numId")
+            var abstractId: String? = null
+            var depth = 1
+            while (depth > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG ->
+                  if (Ox.local(p) == "abstractNumId") { abstractId = Ox.attr(p, "val"); Ox.skip(p) } else Ox.skip(p)
+                XmlPullParser.END_TAG -> depth--
+              }
+            }
+            if (numId != null && abstractId != null) numToAbstract[numId] = abstractId
+          }
+        }
+      }
+    }
+  }
+
+  // ── Embedded fonts (word/fonts/*.odttf) ─────────────────────────
+  /**
+   * DOCX embeds fonts as obfuscated TTFs: the first 32 bytes are XORed with the GUID from the
+   * fontTable relationship key. De-obfuscating restores a normal TTF, which is emitted as an
+   * inline @font-face so text renders in the AUTHOR'S actual face — the strongest fidelity
+   * lever available when the device lacks the font. Size-capped; failures fall back to the
+   * family-name match already emitted per run.
+   */
+  private fun extractEmbeddedFonts(): String {
+    val MAX_FONT_BYTES = 2 * 1024 * 1024
+    var budget = 6 * 1024 * 1024
+    val css = StringBuilder()
+    Ox.zipStream(zip, "word/fontTable.xml")?.use { stream ->
+      val fontRels = Ox.parseRels(zip, "word/fontTable.xml")
+      val p = Ox.parser(stream)
+      var family: String? = null
+      while (p.next() != XmlPullParser.END_DOCUMENT) {
+        if (p.eventType != XmlPullParser.START_TAG) continue
+        when (Ox.local(p)) {
+          "font" -> family = Ox.attr(p, "name")
+          "embedRegular" -> {
+            val rid = Ox.attr(p, "id")
+            val key = Ox.attr(p, "fontKey")
+            val fam = family
+            if (rid != null && fam != null && budget > 0) {
+              val target = fontRels[rid]
+              val bytes = target?.let { Ox.zipBytes(zip, it, minOf(MAX_FONT_BYTES, budget)) }
+              if (bytes != null && bytes.size > 32) {
+                deobfuscateFont(bytes, key)
+                budget -= bytes.size
+                css.append("@font-face{font-family:'").append(fam.replace("'", ""))
+                  .append("';src:url(data:font/ttf;base64,")
+                  .append(Base64.encodeToString(bytes, Base64.NO_WRAP))
+                  .append(");}")
+              }
+            }
+          }
+        }
+      }
+    }
+    return css.toString()
+  }
+
+  /** XORs the first 32 bytes with the reversed GUID bytes per the ODTTF obfuscation spec. */
+  private fun deobfuscateFont(bytes: ByteArray, fontKey: String?) {
+    val hex = fontKey?.replace("{", "")?.replace("}", "")?.replace("-", "") ?: return
+    if (hex.length != 32) return
+    val guid = ByteArray(16)
+    for (i in 0 until 16) {
+      guid[i] = ((hex[i * 2].digitToIntOrNull(16) ?: return) * 16 +
+        (hex[i * 2 + 1].digitToIntOrNull(16) ?: return)).toByte()
+    }
+    for (i in 0 until 32) {
+      bytes[i] = (bytes[i].toInt() xor guid[15 - (i % 16)].toInt()).toByte()
+    }
+  }
+
+  // ── sectPr pre-scan (page geometry + header/footer refs) ────────
+  private fun scanSection() {
+    Ox.zipStream(zip, "word/document.xml")?.use { stream ->
+      val p = Ox.parser(stream)
+      while (p.next() != XmlPullParser.END_DOCUMENT) {
+        if (p.eventType != XmlPullParser.START_TAG) continue
+        when (Ox.local(p)) {
+          "pgSz" -> {
+            Ox.twipsToPt(Ox.attr(p, "w"))?.let { section.pageWPt = it }
+            Ox.twipsToPt(Ox.attr(p, "h"))?.let { section.pageHPt = it }
+          }
+          "pgMar" -> {
+            Ox.twipsToPt(Ox.attr(p, "top"))?.let { section.marTopPt = it }
+            Ox.twipsToPt(Ox.attr(p, "bottom"))?.let { section.marBottomPt = it }
+            Ox.twipsToPt(Ox.attr(p, "left"))?.let { section.marLeftPt = it }
+            Ox.twipsToPt(Ox.attr(p, "right"))?.let { section.marRightPt = it }
+          }
+          "cols" -> {
+            Ox.attr(p, "num")?.toIntOrNull()?.let { section.columns = it.coerceIn(1, 8) }
+            Ox.twipsToPt(Ox.attr(p, "space"))?.let { section.columnGapPt = it }
+          }
+          "headerReference" ->
+            if (Ox.attr(p, "type") == "default") section.headerPart = rels[Ox.attr(p, "id")]
+          "footerReference" ->
+            if (Ox.attr(p, "type") == "default") section.footerPart = rels[Ox.attr(p, "id")]
+        }
+      }
+    }
+  }
+
+  /** Renders a header/footer part with the same paragraph pipeline (its own rels for images). */
+  private fun renderAuxPart(part: String): String {
+    val partRels = Ox.parseRels(zip, part)
+    val sb = StringBuilder()
+    Ox.zipStream(zip, part)?.use { stream ->
+      val p = Ox.parser(stream)
+      while (p.next() != XmlPullParser.END_DOCUMENT) {
+        if (p.eventType == XmlPullParser.START_TAG && (Ox.local(p) == "hdr" || Ox.local(p) == "ftr")) {
+          renderBlocks(p, Ox.local(p), overrideRels = partRels) { _, html -> sb.append(html) }
+          break
+        }
+      }
+    }
+    return sb.toString()
+  }
+
+  // ── Block-level content ─────────────────────────────────────────
+  /**
+   * Streams the children of the container element the parser is positioned ON, emitting one
+   * HTML chunk per block. [emit]'s pageBreak flag is true when the chunk must start a new sheet.
+   */
+  private fun renderBlocks(
+    p: XmlPullParser,
+    containerLocal: String,
+    overrideRels: Map<String, String>? = null,
+    emit: (pageBreak: Boolean, html: String) -> Unit
+  ) {
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "p" -> {
+            val (html, breakBefore) = renderParagraph(p, overrideRels)
+            emit(breakBefore, html)
+          }
+          "tbl" -> emit(false, renderTable(p, overrideRels))
+          "sdt" -> { /* structured document tag: descend transparently */ }
+          "sdtContent" -> { /* children stream through this loop */ }
+          "sectPr" -> Ox.skip(p)
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == containerLocal || Ox.local(p) == "sdt" || Ox.local(p) == "sdtContent") {
+          if (Ox.local(p) == containerLocal) depth--
+        }
+        XmlPullParser.END_DOCUMENT -> return
+      }
+    }
+  }
+
+  // ── Paragraphs & runs ────────────────────────────────────────────
+  /** Returns the paragraph HTML and whether a page break must occur BEFORE it. */
+  private fun renderParagraph(p: XmlPullParser, overrideRels: Map<String, String>?): Pair<String, Boolean> {
+    val direct = ParaProps()
+    val runs = StringBuilder()
+    var sawPageBreak = false
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "pPr" -> parseParaProps(p, direct)
+          "r" -> {
+            val (html, pageBreak) = renderRun(p, direct, overrideRels)
+            runs.append(html)
+            sawPageBreak = sawPageBreak || pageBreak
+          }
+          "hyperlink", "smartTag", "sdt", "sdtContent", "ins" -> { /* stream children */ }
+          "del" -> Ox.skip(p) // deleted (tracked-changes) content is not part of the document
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == "p") depth--
+        XmlPullParser.END_DOCUMENT -> return "" to false
+      }
+    }
+
+    val styleP = resolveStyleP(direct.styleId ?: defaultParaStyleId)
+    val eff = direct.overlayOn(styleP?.overlayOn(docDefaultsP))
+
+    val css = StringBuilder()
+    eff.align?.let {
+      val a = when (it) { "both", "distribute" -> "justify"; "start" -> "left"; "end" -> "right"; else -> it }
+      css.append("text-align:").append(a).append(";")
+    }
+    var leftPt = eff.leftPt ?: 0f
+    // A numbered/bulleted paragraph inherits its level indent when it has no direct indent.
+    val marker = listMarker(eff)
+    if (marker != null && eff.leftPt == null) leftPt = marker.second
+    if (leftPt != 0f) css.append("margin-left:").append(Ox.n(leftPt)).append("pt;")
+    eff.rightPt?.takeIf { it != 0f }?.let { css.append("margin-right:").append(Ox.n(it)).append("pt;") }
+    eff.beforePt?.takeIf { it != 0f }?.let { css.append("margin-top:").append(Ox.n(it)).append("pt;") }
+    eff.afterPt?.takeIf { it != 0f }?.let { css.append("margin-bottom:").append(Ox.n(it)).append("pt;") }
+    eff.firstLinePt?.let { css.append("text-indent:").append(Ox.n(it)).append("pt;") }
+    eff.hangingPt?.let { css.append("text-indent:-").append(Ox.n(it)).append("pt;padding-left:").append(Ox.n(it)).append("pt;") }
+    eff.lineCss?.let { css.append(it) }
+    eff.shading?.let { css.append("background-color:#").append(it).append(";") }
+
+    val markerHtml = marker?.first ?: ""
+    // An empty paragraph still occupies one line, exactly like Word.
+    val content = if (runs.isEmpty() && markerHtml.isEmpty()) "&nbsp;" else markerHtml + runs
+    return "<p style=\"$css\">$content</p>" to (eff.pageBreakBefore || sawPageBreak)
+  }
+
+  /** Marker html + level indent (pt) for a numbered paragraph, advancing this list's counter. */
+  private fun listMarker(eff: ParaProps): Pair<String, Float>? {
+    val numId = eff.numId ?: return null
+    if (numId == "0") return null
+    val abs = numToAbstract[numId] ?: return null
+    val level = abstractLevels[abs]?.get(eff.ilvl) ?: return null
+    val counters = listCounters.getOrPut(numId) { IntArray(9) { -1 } }
+    val text: String
+    if (level.numFmt == "bullet") {
+      text = when {
+        level.lvlText.isEmpty() -> "•"
+        // Wingdings/Symbol private-use glyphs render as tofu — normalize to standard bullets.
+        level.lvlText[0].code >= 0xE000 || level.lvlText[0].code == 0xF0B7 -> "•"
+        level.lvlText == "o" -> "◦"
+        else -> level.lvlText
+      }
+    } else {
+      if (counters[eff.ilvl] < 0) counters[eff.ilvl] = level.start - 1
+      counters[eff.ilvl]++
+      for (deeper in eff.ilvl + 1 until 9) counters[deeper] = -1
+      var t = level.lvlText
+      for (i in 1..9) {
+        val counterValue = if (counters[i - 1] >= 0) counters[i - 1] else 1
+        t = t.replace("%$i", Ox.formatOrdinal(counterValue, level.numFmt))
+      }
+      text = t
+    }
+    val indent = level.indentPt ?: (18f + eff.ilvl * 18f)
+    val html = "<span style=\"display:inline-block;min-width:18pt;margin-left:-18pt;\">${Ox.esc(text)}&nbsp;</span>"
+    return html to indent
+  }
+
+  /** Returns run HTML and whether the run contained an explicit page break. */
+  private fun renderRun(
+    p: XmlPullParser,
+    paraDirect: ParaProps,
+    overrideRels: Map<String, String>?
+  ): Pair<String, Boolean> {
+    val direct = RunProps()
+    var directStyleId: String? = null
+    val text = StringBuilder()
+    var pageBreak = false
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "rPr" -> directStyleId = parseRunProps(p, direct)
+          "t" -> text.append(Ox.esc(Ox.elementText(p)))
+          "tab" -> { text.append("<span style=\"display:inline-block;width:36pt;\"></span>"); Ox.skip(p) }
+          "br" -> {
+            if (Ox.attr(p, "type") == "page") pageBreak = true else text.append("<br/>")
+            Ox.skip(p)
+          }
+          "drawing", "pict", "object" -> {
+            text.append(renderImage(p, overrideRels))
+            // renderImage consumes to the END of the element it was called on.
+          }
+          "noBreakHyphen" -> { text.append("&#8209;"); Ox.skip(p) }
+          "sym" -> {
+            val ch = Ox.attr(p, "char")?.toIntOrNull(16)
+            if (ch != null) text.append("&#${if (ch >= 0xF000) ch - 0xF000 else ch};")
+            Ox.skip(p)
+          }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == "r") depth--
+        XmlPullParser.END_DOCUMENT -> return "" to pageBreak
+      }
+    }
+    if (text.isEmpty()) return "" to pageBreak
+    // Effective chain: doc defaults ← paragraph style rPr ← character style ← direct rPr.
+    val paraStyleR = resolveStyleR(paraDirect.styleId ?: defaultParaStyleId)
+    val charStyleR = resolveStyleR(directStyleId)
+    val eff = direct.overlayOn(charStyleR?.overlayOn(paraStyleR?.overlayOn(docDefaultsR)) ?: paraStyleR ?: docDefaultsR)
+
+    val css = StringBuilder()
+    eff.font?.let { css.append("font-family:'").append(it.replace("'", "")).append("';") }
+    eff.sizePt?.let { css.append("font-size:").append(Ox.n(it)).append("pt;") }
+    if (eff.bold == true) css.append("font-weight:bold;")
+    if (eff.italic == true) css.append("font-style:italic;")
+    val deco = ArrayList<String>()
+    if (eff.underline == true) deco.add("underline")
+    if (eff.strike == true) deco.add("line-through")
+    if (deco.isNotEmpty()) css.append("text-decoration:").append(deco.joinToString(" ")).append(";")
+    eff.color?.takeIf { it != "auto" }?.let { css.append("color:#").append(it).append(";") }
+    eff.highlight?.let { css.append("background-color:").append(highlightColor(it)).append(";") }
+    eff.shading?.let { css.append("background-color:#").append(it).append(";") }
+    if (eff.caps == true) css.append("text-transform:uppercase;")
+    if (eff.smallCaps == true) css.append("font-variant:small-caps;")
+    when (eff.vertAlign) {
+      "superscript" -> css.append("vertical-align:super;font-size:smaller;")
+      "subscript" -> css.append("vertical-align:sub;font-size:smaller;")
+    }
+    val html = if (css.isEmpty()) text.toString() else "<span style=\"$css\">$text</span>"
+    return html to pageBreak
+  }
+
+  /** DrawingML/VML image: consumes the element, emits an <img> at its authored size. */
+  private fun renderImage(p: XmlPullParser, overrideRels: Map<String, String>?): String {
+    var relId: String? = null
+    var widthPt: Float? = null
+    var heightPt: Float? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "extent" -> {
+            widthPt = Ox.emuToPt(Ox.attr(p, "cx"))
+            heightPt = Ox.emuToPt(Ox.attr(p, "cy"))
+          }
+          "blip" -> Ox.attr(p, "embed")?.let { relId = it }
+          "imagedata" -> Ox.attr(p, "id")?.let { relId = it } // VML legacy
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> return ""
+      }
+    }
+    val target = (overrideRels ?: rels)[relId ?: return ""] ?: return ""
+    val mime = Ox.mimeForName(target)
+    if (mime == "image/x-emf" || mime == "application/octet-stream") return ""
+    if (imageBudget <= 0) return ""
+    val bytes = Ox.zipBytes(zip, target, minOf(Ox.MAX_IMAGE_BYTES, imageBudget)) ?: return ""
+    imageBudget -= bytes.size
+    val size = StringBuilder()
+    widthPt?.let { size.append("width:").append(Ox.n(it)).append("pt;") }
+    heightPt?.let { size.append("height:").append(Ox.n(it)).append("pt;") }
+    return "<img style=\"$size\" src=\"${Ox.dataUri(bytes, mime)}\"/>"
+  }
+
+  // ── Tables ───────────────────────────────────────────────────────
+  private class DocxCell {
+    var html = StringBuilder()
+    var colspan = 1
+    var rowspan = 1
+    var vMergeContinue = false
+    var css = StringBuilder()
+  }
+
+  private fun renderTable(p: XmlPullParser, overrideRels: Map<String, String>?): String {
+    val colWidthsPt = ArrayList<Float>()
+    val rows = ArrayList<ArrayList<DocxCell>>()
+    val rowHeights = ArrayList<Float?>()
+    // Borders come ONLY from the document: direct tblBorders, else the referenced table
+    // style's tblBorders (chain-resolved). A table that declares neither is genuinely
+    // borderless in Word (layout tables!) and must not be painted with an artificial grid —
+    // that was the "unwanted rectangular boxes" artifact.
+    var tableBorderCss: String? = null
+    var tableStyleBorderCss: String? = null
+    var tableShading: String? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "tblStyle" -> { tableStyleBorderCss = resolveTableStyleBorders(Ox.attr(p, "val")); Ox.skip(p) }
+          "gridCol" -> { Ox.twipsToPt(Ox.attr(p, "w"))?.let { colWidthsPt.add(it) }; Ox.skip(p) }
+          "tblBorders" -> { tableBorderCss = parseBordersToCss(p) }
+          "shd" -> { Ox.attr(p, "fill")?.takeIf { it != "auto" }?.let { tableShading = it }; Ox.skip(p) }
+          "tr" -> {
+            val row = ArrayList<DocxCell>()
+            var rowHeight: Float? = null
+            var trDepth = 1
+            while (trDepth > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG -> when (Ox.local(p)) {
+                  "trHeight" -> { rowHeight = Ox.twipsToPt(Ox.attr(p, "val")); Ox.skip(p) }
+                  "tc" -> row.add(parseTableCell(p, tableBorderCss ?: tableStyleBorderCss ?: "", overrideRels))
+                  "tblPrEx" -> Ox.skip(p)
+                }
+                XmlPullParser.END_TAG -> if (Ox.local(p) == "tr") trDepth--
+                XmlPullParser.END_DOCUMENT -> return ""
+              }
+            }
+            rows.add(row)
+            rowHeights.add(rowHeight)
+          }
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == "tbl") depth--
+        XmlPullParser.END_DOCUMENT -> return ""
+      }
+    }
+
+    // Resolve vertical merges into rowspans (vMerge "restart" starts, bare vMerge continues).
+    for (rowIndex in rows.indices) {
+      var gridCol = 0
+      for (cell in rows[rowIndex]) {
+        if (!cell.vMergeContinue) {
+          var span = 1
+          var below = rowIndex + 1
+          while (below < rows.size) {
+            val target = cellAtGridColumn(rows[below], gridCol)
+            if (target != null && target.vMergeContinue) { span++; below++ } else break
+          }
+          cell.rowspan = span
+        }
+        gridCol += cell.colspan
+      }
+    }
+
+    val totalW = colWidthsPt.sum().takeIf { it > 0f }
+    val sb = StringBuilder("<table style=\"table-layout:fixed;border-collapse:collapse;")
+    totalW?.let { sb.append("width:").append(Ox.n(it)).append("pt;") }
+    tableShading?.let { sb.append("background-color:#").append(it).append(";") }
+    sb.append("\">")
+    if (colWidthsPt.isNotEmpty()) {
+      sb.append("<colgroup>")
+      for (w in colWidthsPt) sb.append("<col style=\"width:").append(Ox.n(w)).append("pt;\"/>")
+      sb.append("</colgroup>")
+    }
+    for ((rowIndex, row) in rows.withIndex()) {
+      sb.append("<tr")
+      rowHeights[rowIndex]?.let { sb.append(" style=\"height:").append(Ox.n(it)).append("pt;\"") }
+      sb.append(">")
+      for (cell in row) {
+        if (cell.vMergeContinue) continue
+        sb.append("<td")
+        if (cell.colspan > 1) sb.append(" colspan=\"").append(cell.colspan).append("\"")
+        if (cell.rowspan > 1) sb.append(" rowspan=\"").append(cell.rowspan).append("\"")
+        sb.append(" style=\"").append(cell.css).append("\">")
+        sb.append(if (cell.html.isEmpty()) "&nbsp;" else cell.html)
+        sb.append("</td>")
+      }
+      sb.append("</tr>")
+    }
+    sb.append("</table>")
+    return sb.toString()
+  }
+
+  private fun cellAtGridColumn(row: List<DocxCell>, gridCol: Int): DocxCell? {
+    var col = 0
+    for (cell in row) {
+      if (col == gridCol) return cell
+      col += cell.colspan
+      if (col > gridCol) return null
+    }
+    return null
+  }
+
+  private fun parseTableCell(
+    p: XmlPullParser,
+    inheritedBorderCss: String,
+    overrideRels: Map<String, String>?
+  ): DocxCell {
+    val cell = DocxCell()
+    var borderCss: String? = null
+    var padCss = "padding:2pt 5.4pt;" // Word default cell margins (108 twips sides)
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "tcPr" -> {
+            var prDepth = 1
+            while (prDepth > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG -> when (Ox.local(p)) {
+                  "gridSpan" -> { Ox.attr(p, "val")?.toIntOrNull()?.let { cell.colspan = it.coerceAtLeast(1) }; Ox.skip(p) }
+                  "vMerge" -> { cell.vMergeContinue = Ox.attr(p, "val")?.equals("restart") != true; Ox.skip(p) }
+                  "shd" -> { Ox.attr(p, "fill")?.takeIf { it != "auto" }?.let { cell.css.append("background-color:#$it;") }; Ox.skip(p) }
+                  "vAlign" -> { Ox.attr(p, "val")?.let { cell.css.append("vertical-align:${if (it == "center") "middle" else it};") }; Ox.skip(p) }
+                  "tcBorders" -> borderCss = parseBordersToCss(p)
+                  "tcMar" -> { padCss = parseCellMargins(p); }
+                  "tcW" -> Ox.skip(p) // colgroup already carries the grid widths
+                  else -> Ox.skip(p)
+                }
+                XmlPullParser.END_TAG -> if (Ox.local(p) == "tcPr") prDepth--
+                XmlPullParser.END_DOCUMENT -> return cell
+              }
+            }
+          }
+          "p" -> cell.html.append(renderParagraph(p, overrideRels).first)
+          "tbl" -> cell.html.append(renderTable(p, overrideRels))
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == "tc") depth--
+        XmlPullParser.END_DOCUMENT -> return cell
+      }
+    }
+    cell.css.append(borderCss ?: inheritedBorderCss).append(padCss)
+    return cell
+  }
+
+  /** w:tblBorders / w:tcBorders → per-side CSS. Parser positioned ON the borders element. */
+  private fun parseBordersToCss(p: XmlPullParser): String {
+    val css = StringBuilder()
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> {
+          val side = when (Ox.local(p)) {
+            "top" -> "border-top"
+            "bottom" -> "border-bottom"
+            "left", "start", "insideV" -> "border-left"
+            "right", "end" -> "border-right"
+            else -> null
+          }
+          if (side != null) {
+            val style = when (Ox.attr(p, "val")) {
+              "nil", "none" -> "none"
+              "dashed", "dashSmallGap" -> "dashed"
+              "dotted" -> "dotted"
+              "double" -> "double"
+              else -> "solid"
+            }
+            // w:sz is in eighths of a point.
+            val sz = (Ox.attr(p, "sz")?.toFloatOrNull() ?: 4f) / 8f
+            val color = Ox.attr(p, "color")?.takeIf { it != "auto" } ?: "000000"
+            if (style == "none") css.append("$side:none;")
+            else css.append("$side:${Ox.n(sz.coerceAtLeast(0.5f))}pt $style #$color;")
+          }
+          Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return css.toString()
+  }
+
+  private fun parseCellMargins(p: XmlPullParser): String {
+    var top = 2f; var bottom = 2f; var left = 5.4f; var right = 5.4f
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> {
+          val v = Ox.twipsToPt(Ox.attr(p, "w"))
+          when (Ox.local(p)) {
+            "top" -> v?.let { top = it }
+            "bottom" -> v?.let { bottom = it }
+            "left", "start" -> v?.let { left = it }
+            "right", "end" -> v?.let { right = it }
+          }
+          Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return "padding:${Ox.n(top)}pt ${Ox.n(right)}pt ${Ox.n(bottom)}pt ${Ox.n(left)}pt;"
+  }
+
+  // ── Property parsers ─────────────────────────────────────────────
+  /** Parser positioned ON <w:pPr>; consumes it. */
+  private fun parseParaProps(p: XmlPullParser, out: ParaProps) {
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "pStyle" -> { out.styleId = Ox.attr(p, "val"); Ox.skip(p) }
+          "jc" -> { out.align = Ox.attr(p, "val"); Ox.skip(p) }
+          "ind" -> {
+            Ox.twipsToPt(Ox.attr(p, "left") ?: Ox.attr(p, "start"))?.let { out.leftPt = it }
+            Ox.twipsToPt(Ox.attr(p, "right") ?: Ox.attr(p, "end"))?.let { out.rightPt = it }
+            Ox.twipsToPt(Ox.attr(p, "firstLine"))?.let { out.firstLinePt = it }
+            Ox.twipsToPt(Ox.attr(p, "hanging"))?.let { out.hangingPt = it }
+            Ox.skip(p)
+          }
+          "spacing" -> {
+            Ox.twipsToPt(Ox.attr(p, "before"))?.let { out.beforePt = it }
+            Ox.twipsToPt(Ox.attr(p, "after"))?.let { out.afterPt = it }
+            val line = Ox.attr(p, "line")?.toFloatOrNull()
+            if (line != null) {
+              out.lineCss = when (Ox.attr(p, "lineRule")) {
+                "exact" -> "line-height:${Ox.n(line / 20f)}pt;"
+                "atLeast" -> "line-height:${Ox.n(line / 20f)}pt;"
+                else -> "line-height:${Ox.n(line / 240f)};" // "auto": 240 twips = single
+              }
+            }
+            Ox.skip(p)
+          }
+          "shd" -> { Ox.attr(p, "fill")?.takeIf { it != "auto" }?.let { out.shading = it }; Ox.skip(p) }
+          "pageBreakBefore" -> { out.pageBreakBefore = Ox.attr(p, "val") != "0"; Ox.skip(p) }
+          "numPr" -> {
+            var numDepth = 1
+            while (numDepth > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG -> when (Ox.local(p)) {
+                  "ilvl" -> { Ox.attr(p, "val")?.toIntOrNull()?.let { out.ilvl = it.coerceIn(0, 8) }; Ox.skip(p) }
+                  "numId" -> { out.numId = Ox.attr(p, "val"); Ox.skip(p) }
+                  else -> Ox.skip(p)
+                }
+                XmlPullParser.END_TAG -> numDepth--
+                XmlPullParser.END_DOCUMENT -> return
+              }
+            }
+          }
+          "rPr" -> Ox.skip(p) // paragraph-mark run props — not content formatting
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == "pPr") depth--
+        XmlPullParser.END_DOCUMENT -> return
+      }
+    }
+  }
+
+  /** Parser positioned ON <w:rPr>; consumes it. Returns the character style id if present. */
+  private fun parseRunProps(p: XmlPullParser, out: RunProps): String? {
+    var styleId: String? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> {
+          val toggleOn = Ox.attr(p, "val").let { it == null || it == "1" || it == "true" || it == "on" }
+          when (Ox.local(p)) {
+            "rStyle" -> styleId = Ox.attr(p, "val")
+            "b" -> out.bold = toggleOn
+            "i" -> out.italic = toggleOn
+            "strike" -> out.strike = toggleOn
+            "caps" -> out.caps = toggleOn
+            "smallCaps" -> out.smallCaps = toggleOn
+            "u" -> out.underline = Ox.attr(p, "val") != "none"
+            "vertAlign" -> out.vertAlign = Ox.attr(p, "val")
+            "sz" -> Ox.halfPtToPt(Ox.attr(p, "val"))?.let { out.sizePt = it }
+            "color" -> Ox.attr(p, "val")?.let { out.color = it }
+            "highlight" -> out.highlight = Ox.attr(p, "val")
+            "shd" -> Ox.attr(p, "fill")?.takeIf { it != "auto" }?.let { out.shading = it }
+            "rFonts" -> out.font = Ox.attr(p, "ascii") ?: Ox.attr(p, "hAnsi") ?: Ox.attr(p, "cs")
+          }
+          Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == "rPr") depth--
+        XmlPullParser.END_DOCUMENT -> return styleId
+      }
+    }
+    return styleId
+  }
+
+  private fun highlightColor(name: String): String = when (name) {
+    "yellow" -> "#FFFF00"; "green" -> "#00FF00"; "cyan" -> "#00FFFF"; "magenta" -> "#FF00FF"
+    "blue" -> "#0000FF"; "red" -> "#FF0000"; "darkBlue" -> "#00008B"; "darkCyan" -> "#008B8B"
+    "darkGreen" -> "#006400"; "darkMagenta" -> "#8B008B"; "darkRed" -> "#8B0000"
+    "darkYellow" -> "#808000"; "darkGray" -> "#A9A9A9"; "lightGray" -> "#D3D3D3"; "black" -> "#000000"
+    else -> "transparent"
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// XLSX (SpreadsheetML)
+// ═══════════════════════════════════════════════════════════════════
+
+/**
+ * Renders every worksheet as a paper sheet with the TRUE grid geometry: authored column widths
+ * (Excel "character" units → pt), row heights (already pt), merged regions as col/rowspans, and
+ * per-cell font/fill/border/alignment resolved through styles.xml cellXfs. Values are shown as
+ * stored (with builtin date formats converted from serials), matching what Excel displays for
+ * everything but custom number-format masks.
+ */
+internal class XlsxConverter(private val file: File) {
+
+  private class CellStyle {
+    var fontCss: String = ""
+    var fillCss: String = ""
+    var borderCss: String = ""
+    var alignCss: String = ""
+    var numFmtId: Int = 0
+    var wrap = false
+  }
+
+  private lateinit var zip: ZipFile
+  private val sharedStrings = ArrayList<String>()
+  private val cellStyles = ArrayList<CellStyle>()
+
+  companion object {
+    /** Excel column-width unit ≈ one '0' glyph ≈ 7px @96dpi = 5.25pt. */
+    private const val CHAR_TO_PT = 5.25f
+    private const val DEFAULT_COL_PT = 8.43f * CHAR_TO_PT
+    private const val DEFAULT_ROW_PT = 15f
+    private const val MAX_ROWS = 2000
+    private const val MAX_COLS = 256
+  }
+
+  fun convert(): OfficeDocumentConverter.Conversion {
+    ZipFile(file).use { z ->
+      zip = z
+      parseSharedStrings()
+      parseStyles()
+      val sheets = sheetParts()
+      if (sheets.isEmpty()) throw java.io.IOException("No worksheets")
+      val body = StringBuilder()
+      var maxSheetWidthPt = 0f
+      for ((name, part) in sheets) {
+        val (html, widthPt) = renderSheet(name, part, showTitle = sheets.size > 1)
+        body.append(html)
+        if (widthPt > maxSheetWidthPt) maxSheetWidthPt = widthPt
+      }
+      val css =
+        ".xlsx{font-family:Calibri,sans-serif;font-size:11pt;color:#000;padding:6pt;}" +
+          ".xlsx table{table-layout:fixed;border-collapse:collapse;}" +
+          ".xlsx td{border:0.5pt solid #D0D0D0;padding:0 2.4pt;overflow:hidden;" +
+          "white-space:nowrap;vertical-align:bottom;}" +
+          ".xlsx td.wrap{white-space:normal;word-wrap:break-word;}" +
+          ".sheetName{font-weight:bold;font-size:10pt;color:#444;padding:2pt 0 4pt 0;}" +
+          ".truncNote{font-size:9pt;color:#888;padding:4pt 0;}"
+      return OfficeDocumentConverter.Conversion(
+        Ox.shell(maxSheetWidthPt.coerceIn(360f, 1600f) + 24f, css, body.toString()),
+        sheets.size
+      )
+    }
+  }
+
+  /** workbook.xml sheet order → (visible name, worksheet part path). */
+  private fun sheetParts(): List<Pair<String, String>> {
+    val rels = Ox.parseRels(zip, "xl/workbook.xml")
+    val out = ArrayList<Pair<String, String>>()
+    Ox.zipStream(zip, "xl/workbook.xml")?.use { stream ->
+      val p = Ox.parser(stream)
+      while (p.next() != XmlPullParser.END_DOCUMENT) {
+        if (p.eventType == XmlPullParser.START_TAG && Ox.local(p) == "sheet") {
+          val name = Ox.attr(p, "name") ?: "Sheet"
+          val target = rels[Ox.attr(p, "id")]
+          // Hidden sheets are not part of what the user sees in Excel.
+          if (target != null && Ox.attr(p, "state") != "hidden") out.add(name to target)
+        }
+      }
+    }
+    return out
+  }
+
+  private fun parseSharedStrings() {
+    Ox.zipStream(zip, "xl/sharedStrings.xml")?.use { stream ->
+      val p = Ox.parser(stream)
+      while (p.next() != XmlPullParser.END_DOCUMENT) {
+        if (p.eventType == XmlPullParser.START_TAG && Ox.local(p) == "si") {
+          // Rich-text runs flatten to their concatenated text; formatting inside a shared
+          // string is per-run and rare in previews.
+          val sb = StringBuilder()
+          var depth = 1
+          while (depth > 0) {
+            when (p.next()) {
+              XmlPullParser.START_TAG -> if (Ox.local(p) == "t") sb.append(Ox.elementText(p)) else depth++
+              XmlPullParser.END_TAG -> depth--
+              XmlPullParser.END_DOCUMENT -> break
+            }
+          }
+          sharedStrings.add(sb.toString())
+        }
+      }
+    }
+  }
+
+  // ── styles.xml → resolved per-xf CSS ─────────────────────────────
+  private fun parseStyles() {
+    val fonts = ArrayList<String>()
+    val fills = ArrayList<String>()
+    val borders = ArrayList<String>()
+    Ox.zipStream(zip, "xl/styles.xml")?.use { stream ->
+      val p = Ox.parser(stream)
+      var inCellXfs = false
+      while (p.next() != XmlPullParser.END_DOCUMENT) {
+        when (p.eventType) {
+          XmlPullParser.START_TAG -> when (Ox.local(p)) {
+            "font" -> fonts.add(parseFont(p))
+            "fill" -> fills.add(parseFill(p))
+            "border" -> borders.add(parseBorder(p))
+            "cellXfs" -> inCellXfs = true
+            "xf" -> if (inCellXfs) {
+              val style = CellStyle()
+              style.numFmtId = Ox.attr(p, "numFmtId")?.toIntOrNull() ?: 0
+              fonts.getOrNull(Ox.attr(p, "fontId")?.toIntOrNull() ?: -1)?.let { style.fontCss = it }
+              fills.getOrNull(Ox.attr(p, "fillId")?.toIntOrNull() ?: -1)?.let { style.fillCss = it }
+              borders.getOrNull(Ox.attr(p, "borderId")?.toIntOrNull() ?: -1)?.let { style.borderCss = it }
+              var depth = 1
+              while (depth > 0) {
+                when (p.next()) {
+                  XmlPullParser.START_TAG -> if (Ox.local(p) == "alignment") {
+                    Ox.attr(p, "horizontal")?.let { style.alignCss += "text-align:$it;" }
+                    Ox.attr(p, "vertical")?.let {
+                      style.alignCss += "vertical-align:${if (it == "center") "middle" else it};"
+                    }
+                    if (Ox.attr(p, "wrapText") == "1" || Ox.attr(p, "wrapText") == "true") style.wrap = true
+                    Ox.skip(p)
+                  } else Ox.skip(p)
+                  XmlPullParser.END_TAG -> depth--
+                  XmlPullParser.END_DOCUMENT -> break
+                }
+              }
+              cellStyles.add(style)
+            } else Ox.skip(p)
+          }
+          XmlPullParser.END_TAG -> if (Ox.local(p) == "cellXfs") inCellXfs = false
+        }
+      }
+    }
+  }
+
+  /** ARGB "FFRRGGBB" → #RRGGBB (theme/indexed colors have no static value here → null). */
+  private fun argb(p: XmlPullParser): String? =
+    Ox.attr(p, "rgb")?.takeIf { it.length == 8 }?.substring(2)?.let { "#$it" }
+
+  private fun parseFont(p: XmlPullParser): String {
+    val css = StringBuilder()
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> {
+          when (Ox.local(p)) {
+            "b" -> css.append("font-weight:bold;")
+            "i" -> css.append("font-style:italic;")
+            "u" -> css.append("text-decoration:underline;")
+            "strike" -> css.append("text-decoration:line-through;")
+            "sz" -> Ox.attr(p, "val")?.toFloatOrNull()?.let { css.append("font-size:${Ox.n(it)}pt;") }
+            "name" -> Ox.attr(p, "val")?.let { css.append("font-family:'${it.replace("'", "")}';") }
+            "color" -> argb(p)?.let { css.append("color:$it;") }
+          }
+          Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return css.toString()
+  }
+
+  private fun parseFill(p: XmlPullParser): String {
+    var css = ""
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "patternFill" -> if (Ox.attr(p, "patternType") == "none") { Ox.skip(p) } // stay transparent
+          "fgColor" -> { argb(p)?.let { css = "background-color:$it;" }; Ox.skip(p) }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return css
+  }
+
+  private fun parseBorder(p: XmlPullParser): String {
+    val css = StringBuilder()
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> {
+          val side = when (Ox.local(p)) {
+            "left" -> "border-left"; "right" -> "border-right"
+            "top" -> "border-top"; "bottom" -> "border-bottom"
+            else -> null
+          }
+          if (side != null && Ox.attr(p, "style") != null) {
+            val bs = when (Ox.attr(p, "style")) {
+              "dashed", "mediumDashed" -> "dashed"; "dotted" -> "dotted"; "double" -> "double"
+              "medium" -> "solid"; "thick" -> "solid"; else -> "solid"
+            }
+            val w = when (Ox.attr(p, "style")) { "medium" -> "1.5pt"; "thick" -> "2pt"; else -> "0.5pt" }
+            // A border element's color child (if any) is inside — cheap scan.
+            var color = "#000000"
+            var sideDepth = 1
+            while (sideDepth > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG -> { if (Ox.local(p) == "color") argb(p)?.let { color = it }; Ox.skip(p) }
+                XmlPullParser.END_TAG -> sideDepth--
+                XmlPullParser.END_DOCUMENT -> break
+              }
+            }
+            css.append("$side:$w $bs $color;")
+          } else Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return css.toString()
+  }
+
+  // ── Worksheet ────────────────────────────────────────────────────
+  private class Cell(val html: String, val css: String, val wrap: Boolean) {
+    var colspan = 1
+    var rowspan = 1
+    var covered = false
+  }
+
+  private fun renderSheet(name: String, part: String, showTitle: Boolean): Pair<String, Float> {
+    val colWidthPt = HashMap<Int, Float>()   // 0-based col → pt
+    val rows = LinkedHashMap<Int, HashMap<Int, Cell>>() // 0-based row → col → cell
+    val rowHeightPt = HashMap<Int, Float>()
+    val merges = ArrayList<IntArray>() // [r1, c1, r2, c2]
+    var maxCol = 0
+    var maxRow = -1
+    var truncated = false
+
+    Ox.zipStream(zip, part)?.use { stream ->
+      val p = Ox.parser(stream)
+      var currentRow = -1
+      while (p.next() != XmlPullParser.END_DOCUMENT) {
+        if (p.eventType != XmlPullParser.START_TAG) continue
+        when (Ox.local(p)) {
+          "col" -> {
+            val min = Ox.attr(p, "min")?.toIntOrNull() ?: continue
+            val max = Ox.attr(p, "max")?.toIntOrNull() ?: min
+            val w = Ox.attr(p, "width")?.toFloatOrNull() ?: continue
+            for (c in (min - 1) until max.coerceAtMost(MAX_COLS)) colWidthPt[c] = w * CHAR_TO_PT
+          }
+          "row" -> {
+            currentRow = (Ox.attr(p, "r")?.toIntOrNull() ?: (currentRow + 2)) - 1
+            if (currentRow >= MAX_ROWS) { truncated = true; Ox.skip(p); continue }
+            Ox.attr(p, "ht")?.toFloatOrNull()?.let { rowHeightPt[currentRow] = it }
+            if (currentRow > maxRow) maxRow = currentRow
+          }
+          "c" -> {
+            if (currentRow < 0 || currentRow >= MAX_ROWS) { Ox.skip(p); continue }
+            val ref = Ox.attr(p, "r")
+            val col = ref?.let { colOfRef(it) } ?: ((rows[currentRow]?.size ?: 0))
+            if (col >= MAX_COLS) { truncated = true; Ox.skip(p); continue }
+            val type = Ox.attr(p, "t") ?: "n"
+            val styleIndex = Ox.attr(p, "s")?.toIntOrNull() ?: -1
+            var value: String? = null
+            var inlineStr: String? = null
+            var depth = 1
+            while (depth > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG -> when (Ox.local(p)) {
+                  "v" -> value = Ox.elementText(p)
+                  "is" -> inlineStr = Ox.elementText(p)
+                  "f" -> Ox.skip(p) // formula text — the cached <v> is what Excel shows
+                  else -> Ox.skip(p)
+                }
+                XmlPullParser.END_TAG -> depth--
+                XmlPullParser.END_DOCUMENT -> break
+              }
+            }
+            val style = cellStyles.getOrNull(styleIndex)
+            val display = displayValue(type, value, inlineStr, style?.numFmtId ?: 0)
+            if (display != null || style != null) {
+              val css = StringBuilder()
+              style?.let {
+                css.append(it.fontCss).append(it.fillCss).append(it.borderCss).append(it.alignCss)
+              }
+              // Numbers right-align by default in Excel; text left-aligns.
+              if (style?.alignCss?.contains("text-align") != true && type == "n" && display != null) {
+                css.append("text-align:right;")
+              }
+              rows.getOrPut(currentRow) { HashMap() }[col] =
+                Cell(display?.let { Ox.esc(it) } ?: "", css.toString(), style?.wrap == true)
+              if (col > maxCol) maxCol = col
+              if (currentRow > maxRow) maxRow = currentRow
+            }
+          }
+          "mergeCell" -> {
+            Ox.attr(p, "ref")?.let { ref ->
+              val parts = ref.split(':')
+              if (parts.size == 2) {
+                val r1 = rowOfRef(parts[0]); val c1 = colOfRef(parts[0])
+                val r2 = rowOfRef(parts[1]); val c2 = colOfRef(parts[1])
+                if (r1 >= 0 && c1 >= 0 && r2 >= r1 && c2 >= c1) merges.add(intArrayOf(r1, c1, r2, c2))
+              }
+            }
+          }
+        }
+      }
+    } ?: throw java.io.IOException("$part missing")
+
+    // Apply merged regions: anchor gets the span, covered cells drop out of the row.
+    for (m in merges) {
+      val (r1, c1, r2, c2) = m
+      if (r1 >= MAX_ROWS || c1 >= MAX_COLS) continue
+      val anchorRow = rows.getOrPut(r1) { HashMap() }
+      val anchor = anchorRow[c1] ?: Cell("", "", false).also { anchorRow[c1] = it }
+      anchor.colspan = (c2 - c1 + 1).coerceAtMost(MAX_COLS - c1)
+      anchor.rowspan = (r2 - r1 + 1).coerceAtMost(MAX_ROWS - r1)
+      for (r in r1..r2.coerceAtMost(MAX_ROWS - 1)) for (c in c1..c2.coerceAtMost(MAX_COLS - 1)) {
+        if (r == r1 && c == c1) continue
+        rows.getOrPut(r) { HashMap() }.getOrPut(c) { Cell("", "", false) }.covered = true
+      }
+      if (c2 > maxCol) maxCol = c2.coerceAtMost(MAX_COLS - 1)
+      if (r2 > maxRow) maxRow = r2.coerceAtMost(MAX_ROWS - 1)
+    }
+
+    var totalWidthPt = 0f
+    for (c in 0..maxCol) totalWidthPt += colWidthPt[c] ?: DEFAULT_COL_PT
+
+    val sb = StringBuilder("<div class=\"sheet xlsx\" style=\"width:")
+      .append(Ox.n(totalWidthPt + 12f)).append("pt;\">")
+    if (showTitle) sb.append("<div class=\"sheetName\">").append(Ox.esc(name)).append("</div>")
+    sb.append("<table><colgroup>")
+    for (c in 0..maxCol) {
+      sb.append("<col style=\"width:").append(Ox.n(colWidthPt[c] ?: DEFAULT_COL_PT)).append("pt;\"/>")
+    }
+    sb.append("</colgroup>")
+    for (r in 0..maxRow) {
+      val height = rowHeightPt[r] ?: DEFAULT_ROW_PT
+      sb.append("<tr style=\"height:").append(Ox.n(height)).append("pt;\">")
+      val rowCells = rows[r]
+      for (c in 0..maxCol) {
+        val cell = rowCells?.get(c)
+        if (cell?.covered == true) continue
+        sb.append("<td")
+        if (cell != null) {
+          if (cell.colspan > 1) sb.append(" colspan=\"").append(cell.colspan).append("\"")
+          if (cell.rowspan > 1) sb.append(" rowspan=\"").append(cell.rowspan).append("\"")
+          if (cell.wrap) sb.append(" class=\"wrap\"")
+          if (cell.css.isNotEmpty()) sb.append(" style=\"").append(cell.css).append("\"")
+        }
+        sb.append(">").append(cell?.html?.ifEmpty { "" } ?: "").append("</td>")
+      }
+      sb.append("</tr>")
+    }
+    sb.append("</table>")
+    if (truncated) {
+      sb.append("<div class=\"truncNote\">" + Localization.getString("previewTruncatedRowsCols", "Preview truncated — showing first {0} rows / {1} columns", MAX_ROWS, MAX_COLS) + "</div>")
+    }
+    sb.append("</div>")
+    return sb.toString() to (totalWidthPt + 12f)
+  }
+
+  /** "BC12" → 0-based column 54. */
+  private fun colOfRef(ref: String): Int {
+    var col = 0
+    for (ch in ref) {
+      if (ch in 'A'..'Z') col = col * 26 + (ch - 'A' + 1)
+      else if (ch in 'a'..'z') col = col * 26 + (ch - 'a' + 1)
+      else break
+    }
+    return col - 1
+  }
+
+  private fun rowOfRef(ref: String): Int {
+    val digits = ref.dropWhile { it.isLetter() }
+    return (digits.toIntOrNull() ?: 0) - 1
+  }
+
+  private fun displayValue(type: String, v: String?, inlineStr: String?, numFmtId: Int): String? {
+    if (inlineStr != null) return inlineStr
+    if (v == null) return null
+    return when (type) {
+      "s" -> sharedStrings.getOrNull(v.toIntOrNull() ?: -1) ?: ""
+      "str", "inlineStr" -> v
+      "b" -> if (v == "1") "TRUE" else "FALSE"
+      "e" -> v // error literal (#DIV/0! etc.) is stored as shown
+      else -> formatNumber(v, numFmtId)
+    }
+  }
+
+  /** Builtin date/time formats convert the Excel serial; other numbers trim float noise. */
+  private fun formatNumber(v: String, numFmtId: Int): String {
+    val serial = v.toDoubleOrNull() ?: return v
+    val isDate = numFmtId in 14..17 || numFmtId == 22
+    val isTime = numFmtId in 18..21 || numFmtId in 45..47
+    if (isDate || isTime) {
+      // Excel epoch 1899-12-30 (with the fictional 1900 leap day already absorbed).
+      val millis = ((serial - 25569.0) * 86400000.0).toLong()
+      val cal = java.util.Calendar.getInstance(java.util.TimeZone.getTimeZone("UTC"))
+      cal.timeInMillis = millis
+      return if (isDate) {
+        String.format(
+          "%02d/%02d/%04d",
+          cal.get(java.util.Calendar.MONTH) + 1,
+          cal.get(java.util.Calendar.DAY_OF_MONTH),
+          cal.get(java.util.Calendar.YEAR)
+        )
+      } else {
+        String.format(
+          "%02d:%02d:%02d",
+          cal.get(java.util.Calendar.HOUR_OF_DAY),
+          cal.get(java.util.Calendar.MINUTE),
+          cal.get(java.util.Calendar.SECOND)
+        )
+      }
+    }
+    // Strip trailing ".0" and float noise the way the Excel grid does.
+    return if (serial == serial.toLong().toDouble()) serial.toLong().toString()
+    else String.format("%.10g", serial).trimEnd('0').trimEnd('.')
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// PPTX (PresentationML)
+// ═══════════════════════════════════════════════════════════════════
+
+// ═══════════════════════════════════════════════════════════════════
+// ODF shared (ODT + ODS) — automatic-style resolution
+// ═══════════════════════════════════════════════════════════════════
+
+/**
+ * ODF keeps formatting in named "automatic styles" inside content.xml (and page geometry in
+ * styles.xml master pages). This base collects style-name → CSS maps that both the text and
+ * spreadsheet converters resolve at render time, honoring parent-style-name chains.
+ */
+internal abstract class OdfConverterBase(protected val file: File) {
+
+  protected class OdfStyle {
+    var parent: String? = null
+    var family: String? = null
+    var textCss = ""       // fo:* text properties
+    var paraCss = ""       // fo:* paragraph properties
+    var cellCss = ""       // table-cell properties
+    var colWidthPt: Float? = null
+    var rowHeightPt: Float? = null
+    var pageBreakBefore = false
+  }
+
+  protected lateinit var zip: ZipFile
+  protected val odfStyles = HashMap<String, OdfStyle>()
+  protected var imageBudget = Ox.MAX_TOTAL_IMAGE_BYTES
+
+  // Page geometry from styles.xml master page layout (defaults: A4 with 2cm margins).
+  protected var pageWPt = 595f
+  protected var pageHPt = 842f
+  protected var marTopPt = 56.7f
+  protected var marBottomPt = 56.7f
+  protected var marLeftPt = 56.7f
+  protected var marRightPt = 56.7f
+
+  /** "1.25cm" / "12pt" / "0.5in" / "3mm" → pt. */
+  protected fun lenToPt(v: String?): Float? {
+    if (v == null) return null
+    val num = v.takeWhile { it.isDigit() || it == '.' || it == '-' }.toFloatOrNull() ?: return null
+    return when {
+      v.endsWith("cm") -> num * 28.3465f
+      v.endsWith("mm") -> num * 2.83465f
+      v.endsWith("in") -> num * 72f
+      v.endsWith("pt") -> num
+      v.endsWith("pc") -> num * 12f
+      v.endsWith("px") -> num * 0.75f
+      else -> num
+    }
+  }
+
+  /** Parses <style:style>/<style:page-layout> children of the element the parser is ON. */
+  protected fun collectStyles(p: XmlPullParser, containerLocal: String) {
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "style" -> {
+            val name = Ox.attr(p, "name")
+            if (name == null) { Ox.skip(p); continue }
+            val style = OdfStyle()
+            style.parent = Ox.attr(p, "parent-style-name")
+            style.family = Ox.attr(p, "family")
+            var sDepth = 1
+            while (sDepth > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG -> when (Ox.local(p)) {
+                  "text-properties" -> { style.textCss = odfTextCss(p); Ox.skip(p) }
+                  "paragraph-properties" -> { style.paraCss = odfParaCss(p, style); Ox.skip(p) }
+                  "table-cell-properties" -> { style.cellCss = odfCellCss(p); Ox.skip(p) }
+                  "table-column-properties" -> { style.colWidthPt = lenToPt(Ox.attr(p, "column-width")); Ox.skip(p) }
+                  "table-row-properties" -> { style.rowHeightPt = lenToPt(Ox.attr(p, "row-height")); Ox.skip(p) }
+                  else -> Ox.skip(p)
+                }
+                XmlPullParser.END_TAG -> sDepth--
+                XmlPullParser.END_DOCUMENT -> return
+              }
+            }
+            odfStyles[name] = style
+          }
+          "page-layout" -> {
+            var plDepth = 1
+            while (plDepth > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG -> if (Ox.local(p) == "page-layout-properties") {
+                  lenToPt(Ox.attr(p, "page-width"))?.let { pageWPt = it }
+                  lenToPt(Ox.attr(p, "page-height"))?.let { pageHPt = it }
+                  lenToPt(Ox.attr(p, "margin-top"))?.let { marTopPt = it }
+                  lenToPt(Ox.attr(p, "margin-bottom"))?.let { marBottomPt = it }
+                  lenToPt(Ox.attr(p, "margin-left"))?.let { marLeftPt = it }
+                  lenToPt(Ox.attr(p, "margin-right"))?.let { marRightPt = it }
+                  Ox.skip(p)
+                } else Ox.skip(p)
+                XmlPullParser.END_TAG -> plDepth--
+                XmlPullParser.END_DOCUMENT -> return
+              }
+            }
+          }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == containerLocal) depth--
+        XmlPullParser.END_DOCUMENT -> return
+      }
+    }
+  }
+
+  /** Reads automatic styles + page layout from both styles.xml and content.xml. */
+  protected fun parseAllStyles() {
+    for (part in listOf("styles.xml", "content.xml")) {
+      Ox.zipStream(zip, part)?.use { stream ->
+        val p = Ox.parser(stream)
+        while (p.next() != XmlPullParser.END_DOCUMENT) {
+          if (p.eventType != XmlPullParser.START_TAG) continue
+          when (Ox.local(p)) {
+            "automatic-styles", "styles" -> collectStyles(p, Ox.local(p))
+          }
+        }
+      }
+    }
+  }
+
+  private fun odfTextCss(p: XmlPullParser): String {
+    val css = StringBuilder()
+    Ox.attr(p, "font-name")?.let { css.append("font-family:'${it.replace("'", "")}';") }
+    Ox.attr(p, "font-family")?.let { css.append("font-family:'${it.replace("'", "")}';") }
+    Ox.attr(p, "font-size")?.let { fs -> lenToPt(fs)?.let { css.append("font-size:${Ox.n(it)}pt;") } }
+    Ox.attr(p, "font-weight")?.takeIf { it == "bold" || (it.toIntOrNull() ?: 0) >= 600 }
+      ?.let { css.append("font-weight:bold;") }
+    Ox.attr(p, "font-style")?.takeIf { it == "italic" || it == "oblique" }
+      ?.let { css.append("font-style:italic;") }
+    if (Ox.attr(p, "text-underline-style")?.let { it != "none" } == true) css.append("text-decoration:underline;")
+    if (Ox.attr(p, "text-line-through-style")?.let { it != "none" } == true) css.append("text-decoration:line-through;")
+    Ox.attr(p, "color")?.let { css.append("color:$it;") }
+    Ox.attr(p, "background-color")?.takeIf { it != "transparent" }?.let { css.append("background-color:$it;") }
+    when (Ox.attr(p, "text-position")?.substringBefore(' ')) {
+      "super" -> css.append("vertical-align:super;font-size:smaller;")
+      "sub" -> css.append("vertical-align:sub;font-size:smaller;")
+    }
+    return css.toString()
+  }
+
+  private fun odfParaCss(p: XmlPullParser, style: OdfStyle): String {
+    val css = StringBuilder()
+    Ox.attr(p, "text-align")?.let {
+      css.append("text-align:${when (it) { "end" -> "right"; "start" -> "left"; else -> it }};")
+    }
+    lenToPt(Ox.attr(p, "margin-left"))?.let { css.append("margin-left:${Ox.n(it)}pt;") }
+    lenToPt(Ox.attr(p, "margin-right"))?.let { css.append("margin-right:${Ox.n(it)}pt;") }
+    lenToPt(Ox.attr(p, "margin-top"))?.let { css.append("margin-top:${Ox.n(it)}pt;") }
+    lenToPt(Ox.attr(p, "margin-bottom"))?.let { css.append("margin-bottom:${Ox.n(it)}pt;") }
+    lenToPt(Ox.attr(p, "text-indent"))?.let { css.append("text-indent:${Ox.n(it)}pt;") }
+    Ox.attr(p, "line-height")?.let { lh ->
+      if (lh.endsWith("%")) lh.dropLast(1).toFloatOrNull()?.let { css.append("line-height:${Ox.n(it / 100f)};") }
+      else lenToPt(lh)?.let { css.append("line-height:${Ox.n(it)}pt;") }
+    }
+    Ox.attr(p, "background-color")?.takeIf { it != "transparent" }?.let { css.append("background-color:$it;") }
+    if (Ox.attr(p, "break-before") == "page") style.pageBreakBefore = true
+    return css.toString()
+  }
+
+  private fun odfCellCss(p: XmlPullParser): String {
+    val css = StringBuilder()
+    Ox.attr(p, "background-color")?.takeIf { it != "transparent" }?.let { css.append("background-color:$it;") }
+    Ox.attr(p, "border")?.let { css.append("border:${odfBorder(it)};") }
+    Ox.attr(p, "border-top")?.let { css.append("border-top:${odfBorder(it)};") }
+    Ox.attr(p, "border-bottom")?.let { css.append("border-bottom:${odfBorder(it)};") }
+    Ox.attr(p, "border-left")?.let { css.append("border-left:${odfBorder(it)};") }
+    Ox.attr(p, "border-right")?.let { css.append("border-right:${odfBorder(it)};") }
+    Ox.attr(p, "vertical-align")?.let {
+      css.append("vertical-align:${if (it == "middle") "middle" else it};")
+    }
+    lenToPt(Ox.attr(p, "padding"))?.let { css.append("padding:${Ox.n(it)}pt;") }
+    return css.toString()
+  }
+
+  /** "0.5pt solid #000000" stays; "none" → none. */
+  private fun odfBorder(v: String): String = if (v == "none") "none" else v
+
+  /** Chain-resolved CSS for a style name: parents first, own properties override. */
+  protected fun styleCss(name: String?, pick: (OdfStyle) -> String, guard: Int = 0): String {
+    if (name == null || guard > 8) return ""
+    val style = odfStyles[name] ?: return ""
+    return styleCss(style.parent, pick, guard + 1) + pick(style)
+  }
+
+  protected fun styleOf(name: String?): OdfStyle? = name?.let { odfStyles[it] }
+
+  /** draw:image inside a frame — inlines the picture at the frame's authored size. */
+  protected fun renderOdfImage(href: String?, wPt: Float?, hPt: Float?): String {
+    if (href == null || href.startsWith("http")) return ""
+    val path = href.trimStart('.', '/')
+    val mime = Ox.mimeForName(path)
+    if (mime == "image/x-emf" || mime == "application/octet-stream") return ""
+    if (imageBudget <= 0) return ""
+    val bytes = Ox.zipBytes(zip, path, minOf(Ox.MAX_IMAGE_BYTES, imageBudget)) ?: return ""
+    imageBudget -= bytes.size
+    val size = StringBuilder()
+    wPt?.let { size.append("width:${Ox.n(it)}pt;") }
+    hPt?.let { size.append("height:${Ox.n(it)}pt;") }
+    return "<img style=\"$size\" src=\"${Ox.dataUri(bytes, mime)}\"/>"
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// ODT (OpenDocument Text)
+// ═══════════════════════════════════════════════════════════════════
+
+/**
+ * True page geometry from the master page layout; paragraphs/spans resolve their automatic
+ * styles (alignment, indents, spacing, fonts, colors), tables carry column widths and cell
+ * styles, lists render with their level markers, images inline at authored frame size, and
+ * hard page breaks (fo:break-before) start a new sheet.
+ */
+internal class OdtConverter(file: File) : OdfConverterBase(file) {
+
+  fun convert(): OfficeDocumentConverter.Conversion {
+    ZipFile(file).use { z ->
+      zip = z
+      parseAllStyles()
+      val sheets = ArrayList<StringBuilder>()
+      sheets.add(StringBuilder())
+      Ox.zipStream(z, "content.xml")?.use { stream ->
+        val p = Ox.parser(stream)
+        while (p.next() != XmlPullParser.END_DOCUMENT) {
+          if (p.eventType == XmlPullParser.START_TAG && Ox.local(p) == "text" ) {
+            // office:text — the document body container.
+            renderBody(p) { pageBreak, html ->
+              if (pageBreak && sheets.last().isNotEmpty()) sheets.add(StringBuilder())
+              sheets.last().append(html)
+            }
+            break
+          }
+        }
+      } ?: throw java.io.IOException("content.xml missing")
+
+      val body = StringBuilder()
+      // Same display-margin cap as DOCX: content box keeps its authored width.
+      val dMarT = minOf(marTopPt, Ox.MAX_DISPLAY_MARGIN_PT)
+      val dMarB = minOf(marBottomPt, Ox.MAX_DISPLAY_MARGIN_PT)
+      val dMarL = minOf(marLeftPt, Ox.MAX_DISPLAY_MARGIN_PT)
+      val dMarR = minOf(marRightPt, Ox.MAX_DISPLAY_MARGIN_PT)
+      val dPageW = pageWPt - (marLeftPt - dMarL) - (marRightPt - dMarR)
+      val dPageH = pageHPt - (marTopPt - dMarT) - (marBottomPt - dMarB)
+      for ((index, sheet) in sheets.withIndex()) {
+        body.append("<div class=\"sheet odt\" style=\"width:").append(Ox.n(dPageW)).append("pt;")
+        // All sheets size to content — automatic pagination is unknowable, and padding the
+        // interior sheets to a full authored page height only adds blank bands on short pages.
+        body.append("padding:")
+          .append(Ox.n(dMarT)).append("pt ").append(Ox.n(dMarR)).append("pt ")
+          .append(Ox.n(dMarB)).append("pt ").append(Ox.n(dMarL)).append("pt;\">")
+          .append(sheet).append("</div>")
+      }
+      val css =
+        ".odt{font-family:'Liberation Serif',serif;font-size:12pt;color:#000;line-height:1.15;}" +
+          ".odt table{border-collapse:collapse;table-layout:fixed;}" +
+          ".odt td{border:0.5pt solid #999;padding:1pt 2pt;vertical-align:top;}"
+      return OfficeDocumentConverter.Conversion(
+        Ox.shell(dPageW, css, body.toString()),
+        sheets.size
+      )
+    }
+  }
+
+  private fun renderBody(p: XmlPullParser, emit: (Boolean, String) -> Unit) {
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "p", "h" -> {
+            val styleName = Ox.attr(p, "style-name")
+            val breakBefore = styleOf(styleName)?.pageBreakBefore == true ||
+              generateSequence(styleOf(styleName)?.parent) { styleOf(it)?.parent }
+                .take(8).any { styleOf(it)?.pageBreakBefore == true }
+            emit(breakBefore, renderParagraph(p, styleName))
+          }
+          "list" -> emit(false, renderList(p, level = 0))
+          "table" -> emit(false, renderTable(p))
+          "section" -> { /* transparent container — children stream through */ }
+          "soft-page-break" -> Ox.skip(p) // layout hint from the producing app, not authored
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == "text" || Ox.local(p) == "section") {
+          if (Ox.local(p) == "text") depth--
+        }
+        XmlPullParser.END_DOCUMENT -> return
+      }
+    }
+  }
+
+  /** text:p / text:h — the parser is ON the element; consumes it. */
+  private fun renderParagraph(p: XmlPullParser, styleName: String?): String {
+    val content = renderInline(p, Ox.local(p))
+    val css = styleCss(styleName, { it.paraCss }) + styleCss(styleName, { it.textCss })
+    val body = if (content.isEmpty()) "&nbsp;" else content
+    return "<p style=\"$css\">$body</p>"
+  }
+
+  /** Inline content of a paragraph-like element until its END_TAG. */
+  private fun renderInline(p: XmlPullParser, containerLocal: String): String {
+    val sb = StringBuilder()
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "span" -> {
+            val css = styleCss(Ox.attr(p, "style-name"), { it.textCss })
+            val inner = renderInline(p, "span")
+            sb.append(if (css.isEmpty()) inner else "<span style=\"$css\">$inner</span>")
+          }
+          "a" -> sb.append(renderInline(p, "a")) // keep link text, drop navigation
+          "s" -> {
+            val count = Ox.attr(p, "c")?.toIntOrNull() ?: 1
+            repeat(count.coerceIn(1, 100)) { sb.append("&nbsp;") }
+            Ox.skip(p)
+          }
+          "tab" -> { sb.append("<span style=\"display:inline-block;width:36pt;\"></span>"); Ox.skip(p) }
+          "line-break" -> { sb.append("<br/>"); Ox.skip(p) }
+          "frame" -> sb.append(renderFrame(p))
+          "note" -> Ox.skip(p) // footnote body would inline mid-text — drop like a print preview margin note
+          else -> { /* descend transparently to catch nested text */ }
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == containerLocal) depth--
+        XmlPullParser.TEXT -> sb.append(Ox.esc(p.text))
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return sb.toString()
+  }
+
+  /** draw:frame → its draw:image at the frame's svg:width/height. */
+  private fun renderFrame(p: XmlPullParser): String {
+    val wPt = lenToPt(Ox.attr(p, "width"))
+    val hPt = lenToPt(Ox.attr(p, "height"))
+    var html = ""
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> if (Ox.local(p) == "image") {
+          html = renderOdfImage(Ox.attr(p, "href"), wPt, hPt)
+          Ox.skip(p)
+        } else Ox.skip(p)
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return html
+  }
+
+  private fun renderList(p: XmlPullParser, level: Int): String {
+    val sb = StringBuilder()
+    var depth = 1
+    var itemIndex = 0
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "list-item" -> {
+            itemIndex++
+            sb.append(renderListItem(p, level, itemIndex))
+          }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == "list") depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return sb.toString()
+  }
+
+  private fun renderListItem(p: XmlPullParser, level: Int, index: Int): String {
+    val sb = StringBuilder()
+    val indentPt = 18f + level * 18f
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "p", "h" -> {
+            val styleName = Ox.attr(p, "style-name")
+            val content = renderInline(p, Ox.local(p))
+            val css = styleCss(styleName, { it.paraCss }) + styleCss(styleName, { it.textCss })
+            sb.append("<p style=\"margin-left:${Ox.n(indentPt)}pt;$css\">")
+              // Without the list-style definition chain, bullets are the faithful default —
+              // LibreOffice's own default list style is bullet at every level.
+              .append("<span style=\"display:inline-block;min-width:14pt;\">•</span>")
+              .append(if (content.isEmpty()) "&nbsp;" else content)
+              .append("</p>")
+          }
+          "list" -> sb.append(renderList(p, level + 1))
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == "list-item") depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return sb.toString()
+  }
+
+  private fun renderTable(p: XmlPullParser): String {
+    val colWidths = ArrayList<Float?>()
+    val rowsHtml = StringBuilder()
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "table-column" -> {
+            val repeat = Ox.attr(p, "number-columns-repeated")?.toIntOrNull() ?: 1
+            val w = styleOf(Ox.attr(p, "style-name"))?.colWidthPt
+            repeat(repeat.coerceIn(1, 64)) { colWidths.add(w) }
+            Ox.skip(p)
+          }
+          "table-row" -> rowsHtml.append(renderTableRow(p))
+          "table-header-rows" -> { /* descend — rows inside stream through this loop */ }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == "table") depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    val total = colWidths.filterNotNull().sum().takeIf { it > 0 }
+    val sb = StringBuilder("<table style=\"")
+    total?.let { sb.append("width:${Ox.n(it)}pt;") }
+    sb.append("\">")
+    if (colWidths.any { it != null }) {
+      sb.append("<colgroup>")
+      for (w in colWidths) {
+        sb.append(if (w != null) "<col style=\"width:${Ox.n(w)}pt;\"/>" else "<col/>")
+      }
+      sb.append("</colgroup>")
+    }
+    sb.append(rowsHtml).append("</table>")
+    return sb.toString()
+  }
+
+  private fun renderTableRow(p: XmlPullParser): String {
+    val sb = StringBuilder("<tr")
+    styleOf(Ox.attr(p, "style-name"))?.rowHeightPt?.let {
+      sb.append(" style=\"height:${Ox.n(it)}pt;\"")
+    }
+    sb.append(">")
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "table-cell" -> {
+            val spanCols = Ox.attr(p, "number-columns-spanned")?.toIntOrNull() ?: 1
+            val spanRows = Ox.attr(p, "number-rows-spanned")?.toIntOrNull() ?: 1
+            val css = styleCss(Ox.attr(p, "style-name"), { it.cellCss })
+            val inner = StringBuilder()
+            var cDepth = 1
+            while (cDepth > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG -> when (Ox.local(p)) {
+                  "p", "h" -> inner.append(renderParagraph(p, Ox.attr(p, "style-name")))
+                  "table" -> inner.append(renderTable(p))
+                  "list" -> inner.append(renderList(p, 0))
+                  else -> Ox.skip(p)
+                }
+                XmlPullParser.END_TAG -> if (Ox.local(p) == "table-cell") cDepth--
+                XmlPullParser.END_DOCUMENT -> break
+              }
+            }
+            sb.append("<td")
+            if (spanCols > 1) sb.append(" colspan=\"$spanCols\"")
+            if (spanRows > 1) sb.append(" rowspan=\"$spanRows\"")
+            if (css.isNotEmpty()) sb.append(" style=\"$css\"")
+            sb.append(">").append(inner.ifEmpty { "&nbsp;" }).append("</td>")
+          }
+          "covered-table-cell" -> Ox.skip(p) // consumed by a spanning neighbour
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == "table-row") depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    sb.append("</tr>")
+    return sb.toString()
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// ODS (OpenDocument Spreadsheet)
+// ═══════════════════════════════════════════════════════════════════
+
+/**
+ * Grid with authored column widths / row heights from automatic styles, cell backgrounds,
+ * borders, fonts and merged regions (number-columns/rows-spanned). Values render from the
+ * calculated office:value attributes exactly as the sheet displays them.
+ */
+internal class OdsConverter(file: File) : OdfConverterBase(file) {
+
+  companion object {
+    private const val MAX_ROWS = 2000
+    private const val MAX_COLS = 256
+    private const val DEFAULT_COL_PT = 48f
+    private const val DEFAULT_ROW_PT = 14f
+  }
+
+  fun convert(): OfficeDocumentConverter.Conversion {
+    ZipFile(file).use { z ->
+      zip = z
+      parseAllStyles()
+      val body = StringBuilder()
+      var sheetCount = 0
+      var maxWidthPt = 360f
+      Ox.zipStream(z, "content.xml")?.use { stream ->
+        val p = Ox.parser(stream)
+        while (p.next() != XmlPullParser.END_DOCUMENT) {
+          if (p.eventType == XmlPullParser.START_TAG && Ox.local(p) == "table") {
+            sheetCount++
+            val name = Ox.attr(p, "name") ?: "Sheet$sheetCount"
+            val (html, widthPt) = renderSheet(p, name)
+            body.append(html)
+            if (widthPt > maxWidthPt) maxWidthPt = widthPt
+          }
+        }
+      } ?: throw java.io.IOException("content.xml missing")
+      if (sheetCount == 0) throw java.io.IOException("No sheets")
+      val css =
+        ".ods{font-family:'Liberation Sans',sans-serif;font-size:10pt;color:#000;padding:6pt;}" +
+          ".ods table{table-layout:fixed;border-collapse:collapse;}" +
+          ".ods td{border:0.5pt solid #D0D0D0;padding:0 2pt;overflow:hidden;" +
+          "white-space:nowrap;vertical-align:bottom;}" +
+          ".sheetName{font-weight:bold;font-size:10pt;color:#444;padding:2pt 0 4pt 0;}" +
+          ".truncNote{font-size:9pt;color:#888;padding:4pt 0;}"
+      return OfficeDocumentConverter.Conversion(
+        Ox.shell(maxWidthPt.coerceIn(360f, 1600f) + 24f, css, body.toString()),
+        sheetCount
+      )
+    }
+  }
+
+  /** Parser is ON <table:table>; consumes it. */
+  private fun renderSheet(p: XmlPullParser, name: String): Pair<String, Float> {
+    val colWidths = ArrayList<Float>()
+    val rowsHtml = StringBuilder()
+    var rowCount = 0
+    var truncated = false
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "table-column" -> {
+            val repeatCols = (Ox.attr(p, "number-columns-repeated")?.toIntOrNull() ?: 1)
+            // A trailing repeated column definition can claim thousands of columns; clamp to
+            // the remaining room (which may already be zero).
+            val room = (MAX_COLS - colWidths.size).coerceAtLeast(0)
+            val w = styleOf(Ox.attr(p, "style-name"))?.colWidthPt ?: DEFAULT_COL_PT
+            repeat(minOf(repeatCols.coerceAtLeast(1), room)) { colWidths.add(w) }
+            Ox.skip(p)
+          }
+          "table-row" -> {
+            if (rowCount >= MAX_ROWS) { truncated = true; Ox.skip(p); continue }
+            val repeatRows = (Ox.attr(p, "number-rows-repeated")?.toIntOrNull() ?: 1).coerceIn(1, 100)
+            val rowHtml = renderRow(p)
+            // Empty repeated filler rows (common trailing artifact) contribute once, not N times.
+            val times = if (rowHtml.second) 1 else repeatRows
+            repeat(times.coerceAtMost(MAX_ROWS - rowCount)) {
+              rowsHtml.append(rowHtml.first)
+              rowCount++
+            }
+          }
+          "table-header-rows" -> { /* descend */ }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == "table") depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    val totalWidth = colWidths.sum().coerceAtLeast(DEFAULT_COL_PT)
+    val sb = StringBuilder("<div class=\"sheet ods\" style=\"width:")
+      .append(Ox.n(totalWidth + 12f)).append("pt;\">")
+      .append("<div class=\"sheetName\">").append(Ox.esc(name)).append("</div>")
+      .append("<table><colgroup>")
+    for (w in colWidths) sb.append("<col style=\"width:${Ox.n(w)}pt;\"/>")
+    sb.append("</colgroup>").append(rowsHtml).append("</table>")
+    if (truncated) sb.append("<div class=\"truncNote\">" + Localization.getString("previewTruncatedRows", "Preview truncated — showing first {0} rows", MAX_ROWS) + "</div>")
+    sb.append("</div>")
+    return sb.toString() to (totalWidth + 12f)
+  }
+
+  /** Returns (rowHtml, isEmpty). Parser is ON <table:table-row>; consumes it. */
+  private fun renderRow(p: XmlPullParser): Pair<String, Boolean> {
+    val sb = StringBuilder("<tr")
+    styleOf(Ox.attr(p, "style-name"))?.rowHeightPt?.let { sb.append(" style=\"height:${Ox.n(it)}pt;\"") }
+      ?: sb.append(" style=\"height:${Ox.n(DEFAULT_ROW_PT)}pt;\"")
+    sb.append(">")
+    var isEmpty = true
+    var colCount = 0
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "table-cell" -> {
+            if (colCount >= MAX_COLS) { Ox.skip(p); continue }
+            val repeatCells = (Ox.attr(p, "number-columns-repeated")?.toIntOrNull() ?: 1)
+              .coerceIn(1, MAX_COLS - colCount)
+            val spanCols = Ox.attr(p, "number-columns-spanned")?.toIntOrNull() ?: 1
+            val spanRows = Ox.attr(p, "number-rows-spanned")?.toIntOrNull() ?: 1
+            val css = styleCss(Ox.attr(p, "style-name"), { it.cellCss }) +
+              styleCss(Ox.attr(p, "style-name"), { it.textCss })
+            val valueType = Ox.attr(p, "value-type")
+            // Calculated/typed value attribute is what the grid displays for non-strings.
+            val typedValue = Ox.attr(p, "value") ?: Ox.attr(p, "date-value") ?: Ox.attr(p, "time-value")
+            val inner = StringBuilder()
+            var cDepth = 1
+            while (cDepth > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG -> if (Ox.local(p) == "p") {
+                  if (inner.isNotEmpty()) inner.append("<br/>")
+                  inner.append(Ox.esc(Ox.elementText(p)))
+                } else Ox.skip(p)
+                XmlPullParser.END_TAG -> if (Ox.local(p) == "table-cell") cDepth--
+                XmlPullParser.END_DOCUMENT -> break
+              }
+            }
+            val display = if (inner.isNotEmpty()) inner.toString()
+            else typedValue?.let { Ox.esc(trimFloat(it)) } ?: ""
+            if (display.isNotEmpty()) isEmpty = false
+            val alignCss = if (css.contains("text-align")) ""
+            else if (valueType == "float" || valueType == "currency" || valueType == "percentage") "text-align:right;"
+            else ""
+            repeat(repeatCells) {
+              sb.append("<td")
+              if (spanCols > 1) sb.append(" colspan=\"$spanCols\"")
+              if (spanRows > 1) sb.append(" rowspan=\"$spanRows\"")
+              val fullCss = css + alignCss
+              if (fullCss.isNotEmpty()) sb.append(" style=\"$fullCss\"")
+              sb.append(">").append(display).append("</td>")
+              colCount++
+            }
+          }
+          "covered-table-cell" -> {
+            // Placeholder under a merged anchor — no <td> emitted.
+            Ox.skip(p)
+          }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> if (Ox.local(p) == "table-row") depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    sb.append("</tr>")
+    return sb.toString() to isEmpty
+  }
+
+  private fun trimFloat(v: String): String {
+    val d = v.toDoubleOrNull() ?: return v
+    return if (d == d.toLong().toDouble()) d.toLong().toString() else v
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// RTF
+// ═══════════════════════════════════════════════════════════════════
+
+/**
+ * Streaming RTF control-word interpreter with a proper group state stack — \b \i \ul \strike,
+ * \fs (half-points), \cfN against the color table, \fN against the font table, paragraph
+ * alignment (\ql \qc \qr \qj), first-line/left indents (\fiN \liN twips), \page as a hard
+ * sheet break, and \'hh / \uN unicode escapes. Paper geometry honors \paperwN \paperhN and
+ * margin control words when present (US Letter + 1in otherwise, RTF's own defaults).
+ */
+internal class RtfConverter(private val file: File) {
+
+  private class State {
+    var bold = false
+    var italic = false
+    var underline = false
+    var strike = false
+    var fontSizePt = 12f
+    var colorIndex = -1
+    var fontIndex = -1
+    fun copy(): State = State().also {
+      it.bold = bold; it.italic = italic; it.underline = underline; it.strike = strike
+      it.fontSizePt = fontSizePt; it.colorIndex = colorIndex; it.fontIndex = fontIndex
+    }
+  }
+
+  private val colorTable = ArrayList<String>()
+  private val fontTable = HashMap<Int, String>()
+
+  companion object {
+    private const val MAX_RTF_BYTES = 4 * 1024 * 1024
+  }
+
+  fun convert(): OfficeDocumentConverter.Conversion {
+    val raw = file.readBytes().let { if (it.size > MAX_RTF_BYTES) it.copyOf(MAX_RTF_BYTES) else it }
+    val text = String(raw, Charsets.ISO_8859_1) // RTF is 7-bit with \'hh escapes for high bytes
+    if (!text.startsWith("{\\rtf")) throw java.io.IOException("Not an RTF file")
+
+    var paperWPt = 612f; var paperHPt = 792f
+    var marLPt = 72f; var marRPt = 72f; var marTPt = 72f; var marBPt = 72f
+
+    val sheets = ArrayList<StringBuilder>()
+    sheets.add(StringBuilder())
+    val para = StringBuilder()       // runs of the current paragraph
+    val run = StringBuilder()        // visible text of the current run
+    var state = State()
+    val stack = ArrayDeque<State>()
+    var paraAlign = "left"
+    var paraFiPt = 0f
+    var paraLiPt = 0f
+
+    /** Closes the current run into the paragraph with the active character CSS. */
+    fun flushRun() {
+      if (run.isEmpty()) return
+      val css = StringBuilder()
+      if (state.bold) css.append("font-weight:bold;")
+      if (state.italic) css.append("font-style:italic;")
+      val deco = ArrayList<String>()
+      if (state.underline) deco.add("underline")
+      if (state.strike) deco.add("line-through")
+      if (deco.isNotEmpty()) css.append("text-decoration:${deco.joinToString(" ")};")
+      css.append("font-size:${Ox.n(state.fontSizePt)}pt;")
+      colorTable.getOrNull(state.colorIndex)?.let { css.append("color:$it;") }
+      fontTable[state.fontIndex]?.let { css.append("font-family:'${it.replace("'", "")}';") }
+      para.append("<span style=\"$css\">").append(run).append("</span>")
+      run.setLength(0)
+    }
+
+    fun flushPara() {
+      flushRun()
+      val css = StringBuilder("text-align:$paraAlign;")
+      if (paraLiPt != 0f) css.append("margin-left:${Ox.n(paraLiPt)}pt;")
+      if (paraFiPt != 0f) css.append("text-indent:${Ox.n(paraFiPt)}pt;")
+      sheets.last().append("<p style=\"$css\">")
+        .append(if (para.isEmpty()) "&nbsp;" else para.toString())
+        .append("</p>")
+      para.setLength(0)
+    }
+
+    var i = 0
+    var skipGroupDepth = 0           // inside \fonttbl/\colortbl/\pict/\*-destination
+    var pendingColorRed = -1; var pendingColorGreen = -1; var pendingColorBlue = -1
+    var inColorTable = false
+    var inFontTable = false
+    var fontTableIndex = -1
+    val fontNameBuf = StringBuilder()
+    var uSkip = 1                    // \ucN — ANSI fallback chars to skip after \uN
+
+    while (i < text.length) {
+      val c = text[i]
+      when {
+        c == '{' -> {
+          if (skipGroupDepth > 0) skipGroupDepth++
+          else stack.addLast(state.copy())
+          i++
+        }
+        c == '}' -> {
+          if (skipGroupDepth > 0) {
+            skipGroupDepth--
+            if (skipGroupDepth == 0) { inColorTable = false; inFontTable = false }
+          } else {
+            if (inFontTable && fontTableIndex >= 0 && fontNameBuf.isNotEmpty()) {
+              fontTable[fontTableIndex] = fontNameBuf.toString().trimEnd(';').trim()
+              fontNameBuf.setLength(0)
+            }
+            flushRun()
+            state = stack.removeLastOrNull() ?: State()
+          }
+          i++
+        }
+        c == '\\' -> {
+          i++
+          if (i >= text.length) break
+          val next = text[i]
+          if (next == '\'') {
+            // Hex escape → ISO-8859-1 char.
+            val hex = text.substring(i + 1, minOf(i + 3, text.length))
+            hex.toIntOrNull(16)?.let { code ->
+              val ch = code.toChar()
+              if (inFontTable) fontNameBuf.append(ch)
+              else if (skipGroupDepth == 0) run.append(Ox.esc(ch.toString()))
+            }
+            i += 3
+          } else if (!next.isLetter()) {
+            // Escaped literal / special: \\ \{ \} \~ \- \*
+            when (next) {
+              '\\', '{', '}' -> if (skipGroupDepth == 0) run.append(Ox.esc(next.toString()))
+              '~' -> if (skipGroupDepth == 0) run.append("&nbsp;")
+              '*' -> if (skipGroupDepth == 0 && !inColorTable && !inFontTable) skipGroupDepth = 1
+            }
+            i++
+          } else {
+            // Control word: letters + optional signed numeric parameter + optional space.
+            val wordStart = i
+            while (i < text.length && text[i].isLetter()) i++
+            val word = text.substring(wordStart, i)
+            var param: Int? = null
+            if (i < text.length && (text[i] == '-' || text[i].isDigit())) {
+              val numStart = i
+              if (text[i] == '-') i++
+              while (i < text.length && text[i].isDigit()) i++
+              param = text.substring(numStart, i).toIntOrNull()
+            }
+            if (i < text.length && text[i] == ' ') i++
+            if (skipGroupDepth > 0 && !inColorTable && !inFontTable) continue
+
+            when (word) {
+              "par" -> flushPara()
+              "page" -> { flushPara(); sheets.add(StringBuilder()) }
+              "pard" -> { paraAlign = "left"; paraFiPt = 0f; paraLiPt = 0f }
+              "plain" -> { flushRun(); state = State() }
+              "b" -> { flushRun(); state.bold = param != 0 }
+              "i" -> { flushRun(); state.italic = param != 0 }
+              "ul" -> { flushRun(); state.underline = param != 0 }
+              "ulnone" -> { flushRun(); state.underline = false }
+              "strike" -> { flushRun(); state.strike = param != 0 }
+              "fs" -> { flushRun(); param?.let { state.fontSizePt = it / 2f } }
+              "cf" -> { flushRun(); state.colorIndex = param ?: -1 }
+              "f" -> {
+                if (inFontTable) {
+                  if (fontTableIndex >= 0 && fontNameBuf.isNotEmpty()) {
+                    fontTable[fontTableIndex] = fontNameBuf.toString().trimEnd(';').trim()
+                    fontNameBuf.setLength(0)
+                  }
+                  fontTableIndex = param ?: -1
+                } else { flushRun(); state.fontIndex = param ?: -1 }
+              }
+              "ql" -> paraAlign = "left"
+              "qc" -> paraAlign = "center"
+              "qr" -> paraAlign = "right"
+              "qj" -> paraAlign = "justify"
+              "fi" -> paraFiPt = (param ?: 0) / 20f
+              "li" -> paraLiPt = (param ?: 0) / 20f
+              "paperw" -> param?.let { paperWPt = it / 20f }
+              "paperh" -> param?.let { paperHPt = it / 20f }
+              "margl" -> param?.let { marLPt = it / 20f }
+              "margr" -> param?.let { marRPt = it / 20f }
+              "margt" -> param?.let { marTPt = it / 20f }
+              "margb" -> param?.let { marBPt = it / 20f }
+              "line" -> run.append("<br/>")
+              "tab" -> run.append("<span style=\"display:inline-block;width:36pt;\"></span>")
+              "u" -> {
+                // \uN — signed 16-bit unicode, then skip \uc ANSI fallback chars.
+                param?.let { code ->
+                  val cp = if (code < 0) code + 65536 else code
+                  run.append("&#$cp;")
+                }
+                var skipped = 0
+                while (skipped < uSkip && i < text.length) {
+                  if (text[i] == '\\' && i + 1 < text.length && text[i + 1] == '\'') { i += 4; skipped++ }
+                  else if (text[i] != '{' && text[i] != '}' && text[i] != '\\') { i++; skipped++ }
+                  else break
+                }
+              }
+              "uc" -> uSkip = param ?: 1
+              "fonttbl" -> { inFontTable = true; skipGroupDepth = 1 }
+              "colortbl" -> { inColorTable = true; skipGroupDepth = 1 }
+              "red" -> pendingColorRed = param ?: 0
+              "green" -> pendingColorGreen = param ?: 0
+              "blue" -> pendingColorBlue = param ?: 0
+              "pict", "object", "header", "footer", "footnote", "info", "stylesheet" ->
+                if (skipGroupDepth == 0) skipGroupDepth = 1
+              "fnil", "froman", "fswiss", "fmodern", "fscript", "fdecor", "ftech" -> {} // font family class markers
+            }
+          }
+        }
+        c == ';' && inColorTable -> {
+          // Color entries terminate with ';'. An entry with no \red… is the auto color.
+          colorTable.add(
+            if (pendingColorRed >= 0)
+              String.format("#%02X%02X%02X", pendingColorRed, pendingColorGreen.coerceAtLeast(0), pendingColorBlue.coerceAtLeast(0))
+            else "#000000"
+          )
+          pendingColorRed = -1; pendingColorGreen = -1; pendingColorBlue = -1
+          i++
+        }
+        c == '\r' || c == '\n' -> i++
+        else -> {
+          if (inFontTable) fontNameBuf.append(c)
+          else if (skipGroupDepth == 0) run.append(Ox.esc(c.toString()))
+          i++
+        }
+      }
+    }
+    flushPara()
+
+    val body = StringBuilder()
+    // Same display-margin cap as DOCX: content box keeps its authored width.
+    val dMarT = minOf(marTPt, Ox.MAX_DISPLAY_MARGIN_PT)
+    val dMarB = minOf(marBPt, Ox.MAX_DISPLAY_MARGIN_PT)
+    val dMarL = minOf(marLPt, Ox.MAX_DISPLAY_MARGIN_PT)
+    val dMarR = minOf(marRPt, Ox.MAX_DISPLAY_MARGIN_PT)
+    val dPaperW = paperWPt - (marLPt - dMarL) - (marRPt - dMarR)
+    val dPaperH = paperHPt - (marTPt - dMarT) - (marBPt - dMarB)
+    for ((index, sheet) in sheets.withIndex()) {
+      if (sheet.isEmpty() && sheets.size > 1) continue
+      body.append("<div class=\"sheet rtf\" style=\"width:${Ox.n(dPaperW)}pt;")
+      // All sheets size to content (see DOCX) — no full-page blank band under the end.
+      body.append("padding:${Ox.n(dMarT)}pt ${Ox.n(dMarR)}pt ${Ox.n(dMarB)}pt ${Ox.n(dMarL)}pt;\">")
+        .append(sheet).append("</div>")
+    }
+    val css = ".rtf{font-family:'Times New Roman',serif;font-size:12pt;color:#000;line-height:1.15;}"
+    return OfficeDocumentConverter.Conversion(
+      Ox.shell(dPaperW, css, body.toString()),
+      sheets.size
+    )
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// CSV
+// ═══════════════════════════════════════════════════════════════════
+
+/**
+ * RFC-4180 state-machine parse (quoted fields, embedded delimiters/newlines, "" escapes) with
+ * , ; and TAB delimiter sniffing. The grid renders like a spreadsheet: per-column widths sized
+ * from the longest content (clamped), header row bolded when it looks like one, numbers
+ * right-aligned — the closest visual to opening the file in Excel/Calc.
+ */
+internal class CsvConverter(private val file: File) {
+
+  companion object {
+    private const val MAX_CSV_BYTES = 2 * 1024 * 1024
+    private const val MAX_ROWS = 3000
+    private const val MIN_COL_PT = 36f
+    private const val MAX_COL_PT = 240f
+    private const val CHAR_PT = 5.1f // ≈ average glyph advance at 10pt sans
+  }
+
+  fun convert(): OfficeDocumentConverter.Conversion {
+    val raw = file.readBytes().let { if (it.size > MAX_CSV_BYTES) it.copyOf(MAX_CSV_BYTES) else it }
+    val truncatedBytes = file.length() > MAX_CSV_BYTES
+    var text = String(raw, Charsets.UTF_8).removePrefix("")
+    if (truncatedBytes) text = text.substringBeforeLast('\n') // drop the torn last record
+
+    val delimiter = sniffDelimiter(text)
+    val rows = parse(text, delimiter)
+    if (rows.isEmpty()) throw java.io.IOException("Empty CSV")
+    val truncatedRows = rows.size > MAX_ROWS
+    val visible = if (truncatedRows) rows.subList(0, MAX_ROWS) else rows
+
+    val colCount = visible.maxOf { it.size }.coerceAtMost(256)
+    val widths = FloatArray(colCount) { MIN_COL_PT }
+    for (row in visible) {
+      for (ci in 0 until minOf(row.size, colCount)) {
+        val w = (row[ci].length * CHAR_PT + 8f).coerceIn(MIN_COL_PT, MAX_COL_PT)
+        if (w > widths[ci]) widths[ci] = w
+      }
+    }
+
+    // Header heuristic: first row all non-empty, non-numeric, and a later row has a number.
+    val first = visible.first()
+    val headerLikely = first.isNotEmpty() && first.all { it.isNotBlank() && it.toDoubleOrNull() == null } &&
+      visible.drop(1).take(20).any { row -> row.any { it.toDoubleOrNull() != null } }
+
+    val sb = StringBuilder("<div class=\"sheet csv\" style=\"width:${Ox.n(widths.sum() + 12f)}pt;\">")
+    sb.append("<table><colgroup>")
+    for (w in widths) sb.append("<col style=\"width:${Ox.n(w)}pt;\"/>")
+    sb.append("</colgroup>")
+    for ((ri, row) in visible.withIndex()) {
+      sb.append("<tr>")
+      for (ci in 0 until colCount) {
+        val value = row.getOrNull(ci) ?: ""
+        val numeric = value.isNotEmpty() && value.toDoubleOrNull() != null
+        sb.append("<td")
+        val css = StringBuilder()
+        if (ri == 0 && headerLikely) css.append("font-weight:bold;background-color:#EFEFEF;")
+        if (numeric) css.append("text-align:right;")
+        if (css.isNotEmpty()) sb.append(" style=\"$css\"")
+        sb.append(">").append(Ox.esc(value)).append("</td>")
+      }
+      sb.append("</tr>")
+    }
+    sb.append("</table>")
+    if (truncatedRows || truncatedBytes) {
+      sb.append("<div class=\"truncNote\">" + Localization.getString("previewTruncatedNotice", "Preview truncated") + "</div>")
+    }
+    sb.append("</div>")
+
+    val css =
+      ".csv{font-family:'Roboto',sans-serif;font-size:10pt;color:#000;padding:6pt;}" +
+        ".csv table{table-layout:fixed;border-collapse:collapse;}" +
+        ".csv td{border:0.5pt solid #D0D0D0;padding:1pt 3pt;overflow:hidden;white-space:nowrap;}" +
+        ".truncNote{font-size:9pt;color:#888;padding:4pt 0;}"
+    return OfficeDocumentConverter.Conversion(
+      Ox.shell((widths.sum() + 24f).coerceIn(360f, 1600f), css, sb.toString()),
+      0
+    )
+  }
+
+  /** Counts candidate delimiters outside quotes on the first lines; most frequent wins. */
+  private fun sniffDelimiter(text: String): Char {
+    val head = text.take(4096)
+    var comma = 0; var semi = 0; var tab = 0
+    var inQuotes = false
+    for (c in head) {
+      when {
+        c == '"' -> inQuotes = !inQuotes
+        inQuotes -> {}
+        c == ',' -> comma++
+        c == ';' -> semi++
+        c == '\t' -> tab++
+      }
+    }
+    return when {
+      tab > comma && tab > semi -> '\t'
+      semi > comma -> ';'
+      else -> ','
+    }
+  }
+
+  private fun parse(text: String, delimiter: Char): List<List<String>> {
+    val rows = ArrayList<List<String>>()
+    val row = ArrayList<String>()
+    val field = StringBuilder()
+    var inQuotes = false
+    var i = 0
+    while (i < text.length) {
+      val c = text[i]
+      when {
+        inQuotes -> when {
+          c == '"' && i + 1 < text.length && text[i + 1] == '"' -> { field.append('"'); i++ }
+          c == '"' -> inQuotes = false
+          else -> field.append(c)
+        }
+        c == '"' && field.isEmpty() -> inQuotes = true
+        c == delimiter -> { row.add(field.toString()); field.setLength(0) }
+        c == '\n' || c == '\r' -> {
+          if (c == '\r' && i + 1 < text.length && text[i + 1] == '\n') i++
+          row.add(field.toString()); field.setLength(0)
+          // Skip fully blank records (common trailing newline artifacts).
+          if (row.any { it.isNotEmpty() }) rows.add(ArrayList(row))
+          row.clear()
+          if (rows.size > MAX_ROWS + 1) return rows
+        }
+        else -> field.append(c)
+      }
+      i++
+    }
+    if (field.isNotEmpty() || row.isNotEmpty()) {
+      row.add(field.toString())
+      if (row.any { it.isNotEmpty() }) rows.add(row)
+    }
+    return rows
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// EPUB
+// ═══════════════════════════════════════════════════════════════════
+
+/**
+ * Real EPUB structure walk: META-INF/container.xml → OPF package → spine order → XHTML chapters
+ * concatenated as book "sheets", with the publication's own CSS inlined (author styling is the
+ * fidelity) and images swapped to data URIs so the locked WebView renders them offline.
+ */
+internal class EpubConverter(private val file: File) {
+
+  private var imageBudget = Ox.MAX_TOTAL_IMAGE_BYTES
+
+  companion object {
+    private const val MAX_CHAPTERS = 60
+    private const val MAX_CHAPTER_BYTES = 1 shl 20
+    private const val MAX_CSS_BYTES = 256 * 1024
+  }
+
+  fun convert(): OfficeDocumentConverter.Conversion {
+    ZipFile(file).use { zip ->
+      val opfPath = findOpfPath(zip) ?: throw java.io.IOException("No OPF package")
+      // Manifest: id → (href, media-type); spine: ordered idrefs.
+      val manifest = HashMap<String, Pair<String, String>>()
+      val spine = ArrayList<String>()
+      Ox.zipStream(zip, opfPath)?.use { stream ->
+        val p = Ox.parser(stream)
+        while (p.next() != XmlPullParser.END_DOCUMENT) {
+          if (p.eventType != XmlPullParser.START_TAG) continue
+          when (Ox.local(p)) {
+            "item" -> {
+              val id = Ox.attr(p, "id"); val href = Ox.attr(p, "href")
+              val type = Ox.attr(p, "media-type") ?: ""
+              if (id != null && href != null) manifest[id] = Ox.resolveZipPath(opfPath, href) to type
+            }
+            "itemref" -> Ox.attr(p, "idref")?.let { spine.add(it) }
+          }
+        }
+      } ?: throw java.io.IOException("OPF unreadable")
+
+      // Publication CSS: all manifest text/css entries, size-capped, @import/url(fonts) left
+      // as-is (the locked WebView simply won't fetch them).
+      val cssBundle = StringBuilder()
+      for ((_, entry) in manifest) {
+        if (entry.second == "text/css" && cssBundle.length < MAX_CSS_BYTES) {
+          Ox.zipBytes(zip, entry.first, MAX_CSS_BYTES)?.let {
+            cssBundle.append(String(it, Charsets.UTF_8)).append('\n')
+          }
+        }
+      }
+
+      val body = StringBuilder()
+      var chapters = 0
+      var truncated = false
+      for (idref in spine) {
+        if (chapters >= MAX_CHAPTERS) { truncated = true; break }
+        val entry = manifest[idref] ?: continue
+        if (!entry.second.contains("html")) continue
+        val bytes = Ox.zipBytes(zip, entry.first, MAX_CHAPTER_BYTES) ?: continue
+        chapters++
+        body.append("<div class=\"chapter\">")
+          .append(inlineImages(extractBody(String(bytes, Charsets.UTF_8)), zip, entry.first))
+          .append("</div>")
+      }
+      if (chapters == 0) throw java.io.IOException("No readable chapters")
+      if (truncated) body.append("<div class=\"truncNote\">" + Localization.getString("previewTruncatedChapters", "Preview truncated — first {0} chapters", MAX_CHAPTERS) + "</div>")
+
+      // 384pt ≈ a paperback text block; the shell scales it to screen width.
+      val css =
+        ".chapter{background:#FFFFFF;color:#000;padding:24pt 28pt;margin:8pt auto;width:384pt;" +
+          "box-shadow:0 1pt 4pt rgba(0,0,0,0.4);font-family:'Georgia',serif;font-size:11pt;line-height:1.5;}" +
+          ".chapter img{max-width:100%;height:auto;}" +
+          ".truncNote{color:#AAA;text-align:center;font-size:9pt;padding:6pt;}" +
+          // Publication CSS last so author rules win over the chapter defaults.
+          cssBundle.toString()
+      return OfficeDocumentConverter.Conversion(
+        Ox.shell(440f, css, body.toString()),
+        chapters
+      )
+    }
+  }
+
+  private fun findOpfPath(zip: ZipFile): String? {
+    Ox.zipStream(zip, "META-INF/container.xml")?.use { stream ->
+      val p = Ox.parser(stream)
+      while (p.next() != XmlPullParser.END_DOCUMENT) {
+        if (p.eventType == XmlPullParser.START_TAG && Ox.local(p) == "rootfile") {
+          return Ox.attr(p, "full-path")
+        }
+      }
+    }
+    return null
+  }
+
+  /** Contents of <body>…</body> with scripts stripped (the WebView blocks JS anyway). */
+  private fun extractBody(xhtml: String): String {
+    val bodyStart = xhtml.indexOf("<body", ignoreCase = true)
+    val contentStart = if (bodyStart >= 0) xhtml.indexOf('>', bodyStart) + 1 else 0
+    val bodyEnd = xhtml.lastIndexOf("</body>", ignoreCase = true)
+    val content = if (contentStart in 1 until bodyEnd) xhtml.substring(contentStart, bodyEnd) else xhtml
+    return content.replace(Regex("<script[\\s\\S]*?</script>", RegexOption.IGNORE_CASE), "")
+  }
+
+  /** Rewrites <img src>/xlink:href relative paths into data URIs from the zip. */
+  private fun inlineImages(html: String, zip: ZipFile, chapterPath: String): String =
+    Regex("(src|xlink:href)\\s*=\\s*\"([^\"]+)\"").replace(html) { match ->
+      val attr = match.groupValues[1]
+      val href = match.groupValues[2]
+      if (href.startsWith("http") || href.startsWith("data:")) return@replace match.value
+      val resolved = Ox.resolveZipPath(chapterPath, href)
+      val mime = Ox.mimeForName(resolved)
+      if (!mime.startsWith("image/") || mime == "image/x-emf") return@replace match.value
+      if (imageBudget <= 0) return@replace match.value
+      val bytes = Ox.zipBytes(zip, resolved, minOf(Ox.MAX_IMAGE_BYTES, imageBudget))
+        ?: return@replace match.value
+      imageBudget -= bytes.size
+      "$attr=\"${Ox.dataUri(bytes, mime)}\""
+    }
+}