react-native-ensys-camera-x 1.0.7

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

@@ -0,0 +1,4077 @@
+package com.customcamera
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.RectF
+import android.graphics.Typeface
+import android.text.Layout
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.text.StaticLayout
+import android.text.TextPaint
+import android.text.style.ForegroundColorSpan
+import android.text.style.MetricAffectingSpan
+import android.text.style.StrikethroughSpan
+import android.text.style.UnderlineSpan
+import android.view.View
+import android.view.ViewGroup
+import androidx.recyclerview.widget.RecyclerView
+import org.xmlpull.v1.XmlPullParser
+import java.io.File
+import java.nio.charset.Charset
+import java.util.zip.ZipFile
+import kotlin.math.ceil
+import kotlin.math.max
+import kotlin.math.min
+
+/**
+ * Dedicated PowerPoint preview pipeline:
+ *
+ *   extractor  -> reads PPTX PresentationML or legacy PPT binary data
+ *   formatter  -> normalizes extracted slide data into the preview model
+ *   viewer     -> draws slides directly with Android Canvas inside DocumentPreviewView
+ *
+ * It does not invoke PowerPoint/WPS, online viewers, PDF conversion, fallback cards, or WebView.
+ */
+internal object PowerPointDocumentProcessor {
+  fun process(file: File, kind: String): PowerPointPresentation {
+    val extractor: PowerPointPresentationExtractor = when (kind) {
+      "ppt" -> PptPresentationExtractor()
+      "pptx" -> PptxPresentationExtractor()
+      else -> throw IllegalArgumentException("Unsupported PowerPoint kind: $kind")
+    }
+    return PowerPointPresentationFormatter().format(extractor.extract(file))
+  }
+
+  fun errorPresentation(sourceName: String, message: String): PowerPointPresentation =
+    PowerPointPresentationFormatter().format(
+      RawPowerPointPresentation(
+        sourceName = sourceName,
+        widthPt = DEFAULT_SLIDE_WIDTH_PT,
+        heightPt = DEFAULT_SLIDE_HEIGHT_PT,
+        slides = listOf(
+          RawPowerPointSlide(
+            textRuns = listOf(
+              sourceName.ifBlank { Localization.getString("powerPointPresentationTitle", "PowerPoint presentation") },
+              message
+            )
+          )
+        )
+      )
+    )
+}
+
+internal interface PowerPointPresentationExtractor {
+  fun extract(file: File): RawPowerPointPresentation
+}
+
+internal data class RawPowerPointPresentation(
+  val sourceName: String,
+  val widthPt: Float,
+  val heightPt: Float,
+  val slides: List<RawPowerPointSlide>,
+  /** Every bitmap decoded while extracting — see [PowerPointPresentation.ownedBitmaps]. */
+  val ownedBitmaps: List<Bitmap> = emptyList()
+)
+
+internal data class RawPowerPointSlide(
+  val background: PptFill = PptFill.Solid(Color.WHITE),
+  val elements: List<PowerPointElement> = emptyList(),
+  val textRuns: List<String> = emptyList(),
+  val images: List<Bitmap> = emptyList()
+)
+
+internal data class PowerPointPresentation(
+  val sourceName: String,
+  val widthPt: Float,
+  val heightPt: Float,
+  val slides: List<PowerPointSlide>,
+  /**
+   * EVERY bitmap decoded during extraction, whether or not it ended up drawn.
+   *
+   * The single source of truth for recycling. Walking the element tree instead (as this used to)
+   * silently missed bitmaps reachable only from a fill, and missed the legacy .ppt path's
+   * decoded-but-never-adopted images entirely, leaking them.
+   */
+  private val ownedBitmaps: List<Bitmap> = emptyList()
+) {
+  fun release() {
+    for (bitmap in ownedBitmaps) {
+      if (!bitmap.isRecycled) bitmap.recycle()
+    }
+  }
+}
+
+internal data class PowerPointSlide(
+  val index: Int,
+  val background: PptFill,
+  val elements: List<PowerPointElement>
+)
+
+/**
+ * A DrawingML fill, used for slide backgrounds, shapes and text-box bodies alike.
+ *
+ * Gradients previously had no representation at all, so a `<a:gradFill>` background silently
+ * became flat white and a gradient-filled shape ended up with no fill — at which point the shape
+ * was discarded entirely.
+ */
+internal sealed class PptFill {
+  data class Solid(val color: Int) : PptFill()
+
+  data class Image(val bitmap: Bitmap, val fallbackColor: Int = Color.WHITE) : PptFill()
+
+  /**
+   * Arrays rather than lists to keep shader construction allocation-free. Note this makes the
+   * generated `equals`/`hashCode` identity-based for those fields — fills are never compared.
+   */
+  data class Gradient(
+    val colors: IntArray,
+    val stops: FloatArray,
+    /** `<a:lin ang>` in degrees, clockwise from the +x axis. */
+    val angleDeg: Float,
+    val radial: Boolean
+  ) : PptFill() {
+    /** Cached shader — valid because gradients are built in slide-point space, not pixels. */
+    @Transient
+    var cachedShader: android.graphics.Shader? = null
+
+    @Transient
+    var cachedW: Float = -1f
+
+    @Transient
+    var cachedH: Float = -1f
+  }
+
+  fun bitmapOrNull(): Bitmap? = when (this) {
+    is Image -> bitmap
+    else -> null
+  }
+}
+
+/**
+ * Immutable 2x3 affine in slide-point space, accumulated from enclosing `<p:grpSp>` transforms:
+ * `x' = a*x + c*y + e`, `y' = b*x + d*y + f`.
+ *
+ * Deliberately our own type rather than `android.graphics.Matrix`, so the group-composition maths
+ * — the thing that was silently wrong and put grouped shapes on top of each other — is
+ * unit-testable on a bare JVM, and so nothing mutable leaks into the render model.
+ */
+internal data class Affine(
+  val a: Float, val b: Float, val c: Float,
+  val d: Float, val e: Float, val f: Float
+) {
+  /** `outer ∘ this`: apply this transform first, then [outer]. */
+  fun then(outer: Affine): Affine = Affine(
+    a = outer.a * a + outer.c * b,
+    b = outer.b * a + outer.d * b,
+    c = outer.a * c + outer.c * d,
+    d = outer.b * c + outer.d * d,
+    e = outer.a * e + outer.c * f + outer.e,
+    f = outer.b * e + outer.d * f + outer.f
+  )
+
+  fun isIdentity(): Boolean =
+    a == 1f && b == 0f && c == 0f && d == 1f && e == 0f && f == 0f
+
+  /** Fills a 9-element array in `android.graphics.Matrix` row-major order. */
+  fun toMatrixValues(out: FloatArray) {
+    out[0] = a; out[1] = c; out[2] = e
+    out[3] = b; out[4] = d; out[5] = f
+    out[6] = 0f; out[7] = 0f; out[8] = 1f
+  }
+
+  companion object {
+    val IDENTITY = Affine(1f, 0f, 0f, 1f, 0f, 0f)
+    fun translate(tx: Float, ty: Float) = Affine(1f, 0f, 0f, 1f, tx, ty)
+    fun scale(sx: Float, sy: Float) = Affine(sx, 0f, 0f, sy, 0f, 0f)
+    fun rotate(deg: Float): Affine {
+      val r = Math.toRadians(deg.toDouble())
+      val cos = kotlin.math.cos(r).toFloat()
+      val sin = kotlin.math.sin(r).toFloat()
+      return Affine(cos, sin, -sin, cos, 0f, 0f)
+    }
+  }
+}
+
+internal sealed class PowerPointElement {
+  abstract val bounds: RectF
+  abstract val rotation: Float
+  abstract val flipH: Boolean
+  abstract val flipV: Boolean
+
+  /**
+   * Transform from this element's own coordinate space into slide space, accumulated from every
+   * enclosing group. Identity for shapes sitting directly on the slide. Groups are flattened at
+   * parse time — carrying the transform per element keeps the draw loop and z-order flat.
+   */
+  abstract val parent: Affine
+
+  /** Re-parents this element into an enclosing group's coordinate space. */
+  abstract fun reparent(outer: Affine): PowerPointElement
+
+  data class TextBox(
+    override val bounds: RectF,
+    override val rotation: Float = 0f,
+    val paragraphs: List<PowerPointParagraph>,
+    val fill: PptFill? = null,
+    val stroke: PowerPointStroke? = null,
+    val verticalAnchor: TextVerticalAnchor = TextVerticalAnchor.TOP,
+    val insetLeftPt: Float = 4f,
+    val insetTopPt: Float = 2f,
+    val insetRightPt: Float = 4f,
+    val insetBottomPt: Float = 2f,
+    val shapeType: PowerPointShapeType = PowerPointShapeType.RECT,
+    /** `<a:custGeom>` outline, normalised to 0..1 so one Path serves every drawn size. */
+    val customPath: android.graphics.Path? = null,
+    /**
+     * `<a:normAutofit>`: PowerPoint shrank this text to fit and recorded what it used. Honouring
+     * the recorded values is what stops an un-shrunk title colliding with the body below.
+     * `fontScale == 1 && !autofit` means the deck asked for no shrinking at all.
+     */
+    val autofit: Boolean = false,
+    val fontScale: Float = 1f,
+    val lnSpcReduction: Float = 0f,
+    override val flipH: Boolean = false,
+    override val flipV: Boolean = false,
+    override val parent: Affine = Affine.IDENTITY
+  ) : PowerPointElement() {
+    override fun reparent(outer: Affine) = copy(parent = parent.then(outer))
+  }
+
+  data class Shape(
+    override val bounds: RectF,
+    override val rotation: Float = 0f,
+    val type: PowerPointShapeType = PowerPointShapeType.RECT,
+    val fill: PptFill? = null,
+    val stroke: PowerPointStroke? = null,
+    /** `<a:custGeom>` outline, normalised to 0..1. */
+    val customPath: android.graphics.Path? = null,
+    override val flipH: Boolean = false,
+    override val flipV: Boolean = false,
+    override val parent: Affine = Affine.IDENTITY
+  ) : PowerPointElement() {
+    override fun reparent(outer: Affine) = copy(parent = parent.then(outer))
+  }
+
+  data class Picture(
+    override val bounds: RectF,
+    override val rotation: Float = 0f,
+    val bitmap: Bitmap,
+    /** `<a:srcRect>` crop as fractional insets (l, t, r, b) of the source bitmap, or null. */
+    val srcRect: RectF? = null,
+    override val flipH: Boolean = false,
+    override val flipV: Boolean = false,
+    override val parent: Affine = Affine.IDENTITY
+  ) : PowerPointElement() {
+    override fun reparent(outer: Affine) = copy(parent = parent.then(outer))
+  }
+
+  data class Table(
+    override val bounds: RectF,
+    override val rotation: Float = 0f,
+    val columnsPt: List<Float>,
+    val rows: List<PowerPointTableRow>,
+    override val flipH: Boolean = false,
+    override val flipV: Boolean = false,
+    override val parent: Affine = Affine.IDENTITY
+  ) : PowerPointElement() {
+    override fun reparent(outer: Affine) = copy(parent = parent.then(outer))
+  }
+}
+
+internal data class PowerPointParagraph(
+  val runs: List<PowerPointTextRun>,
+  val align: TextAlign = TextAlign.LEFT,
+  val bullet: String? = null,
+  val level: Int = 0,
+  // Resolved base appearance for this paragraph: the fallback for runs that set nothing of
+  // their own, and the metrics source for the bullet glyph. These are non-null by construction
+  // so the renderer can never reach for a hardcoded 14pt black again.
+  val baseSizePt: Float = DEFAULT_BODY_SIZE_PT,
+  val baseColor: Int = BLACK_ARGB,
+  val baseFontFamily: String? = null,
+  val baseBold: Boolean = false,
+  val baseItalic: Boolean = false,
+  // Paragraph metrics, in points. marL is the TEXT left edge; indent is the bullet's offset
+  // relative to it (negative = hanging). Previously unread, so bullets were faked with two
+  // spaces per level and wrapped lines never lined up under the first.
+  val marLPt: Float = 0f,
+  val indentPt: Float = 0f,
+  /** Line spacing as a multiple (1.0 = single); null means inherit the renderer default. */
+  val lineSpacePct: Float? = null,
+  val spaceBeforePt: Float = 0f,
+  val spaceAfterPt: Float = 0f
+)
+
+internal data class PowerPointTextRun(
+  val text: String,
+  val fontSizePt: Float? = null,
+  val color: Int? = null,
+  val fontFamily: String? = null,
+  // Null means "unspecified" so the layout/master inheritance step can supply a value; a
+  // concrete true/false means the run set it explicitly and must win over inherited defaults.
+  val bold: Boolean? = null,
+  val italic: Boolean? = null,
+  val underline: Boolean? = null,
+  val strike: Boolean? = null,
+  val allCaps: Boolean? = null
+)
+
+internal data class PowerPointStroke(
+  val color: Int = Color.BLACK,
+  val widthPt: Float = 1f
+)
+
+internal data class PowerPointTableRow(
+  val heightPt: Float?,
+  val cells: List<PowerPointTableCell>
+)
+
+internal data class PowerPointTableCell(
+  val paragraphs: List<PowerPointParagraph>,
+  val fillColor: Int? = null,
+  val gridSpan: Int = 1,
+  /** A continuation cell of a horizontal/vertical merge: occupies grid space but draws nothing. */
+  val merged: Boolean = false,
+  // Per-edge borders from <a:tcPr>. Null means the deck specified none for that edge, in which
+  // case the renderer falls back to a neutral hairline so the grid stays readable.
+  val borderLeft: PowerPointStroke? = null,
+  val borderRight: PowerPointStroke? = null,
+  val borderTop: PowerPointStroke? = null,
+  val borderBottom: PowerPointStroke? = null,
+  // OOXML cell inset defaults: 0.1" horizontally, 0.05" vertically.
+  val marginLeftPt: Float = 7.2f,
+  val marginRightPt: Float = 7.2f,
+  val marginTopPt: Float = 3.6f,
+  val marginBottomPt: Float = 3.6f,
+  val anchor: TextVerticalAnchor = TextVerticalAnchor.TOP
+)
+
+/** Everything `<a:tcPr>` contributes to a cell. */
+private data class TableCellProps(
+  val fillColor: Int? = null,
+  val borderLeft: PowerPointStroke? = null,
+  val borderRight: PowerPointStroke? = null,
+  val borderTop: PowerPointStroke? = null,
+  val borderBottom: PowerPointStroke? = null,
+  val marginLeftPt: Float = 7.2f,
+  val marginRightPt: Float = 7.2f,
+  val marginTopPt: Float = 3.6f,
+  val marginBottomPt: Float = 3.6f,
+  val anchor: TextVerticalAnchor = TextVerticalAnchor.TOP
+)
+
+/**
+ * Drawable primitives for `prstGeom` presets.
+ *
+ * Anything not listed still falls back to RECT, which is what PowerPoint does for a closed shape
+ * - but the previous six-entry vocabulary meant stars, arrows, chevrons and polygons all became
+ * solid rectangles, frequently covering slide content.
+ */
+internal enum class PowerPointShapeType {
+  RECT, ROUND_RECT, ELLIPSE, LINE,
+  TRIANGLE, RIGHT_TRIANGLE, DIAMOND, PARALLELOGRAM, TRAPEZOID,
+  PENTAGON, HEXAGON, OCTAGON,
+  STAR4, STAR5, STAR6, STAR8, STAR12, STAR16, STAR24, STAR32,
+  ARROW_RIGHT, ARROW_LEFT, ARROW_UP, ARROW_DOWN, ARROW_LEFT_RIGHT, ARROW_UP_DOWN,
+  CHEVRON, HOME_PLATE, PLUS, CAN, DONUT, FRAME
+}
+internal enum class TextAlign { LEFT, CENTER, RIGHT, JUSTIFY }
+internal enum class TextVerticalAnchor { TOP, MIDDLE, BOTTOM }
+
+// ── DrawingML colour: parse first, resolve later ────────────────────
+//
+// A colour cannot be resolved at parse time: `schemeClr` names go through the slide master's
+// <p:clrMap>, and `phClr` is supplied by whichever style reference is consuming the spec. So
+// parsing produces an unresolved [ColorSpec] and resolution happens at use, against a
+// [ColorContext].
+
+/**
+ * A DrawingML colour before theme / clrMap / phClr resolution.
+ *
+ * [transforms] is kept in DOCUMENT ORDER on purpose: the transforms are not commutative, so
+ * `tint` then `lumMod` is a different colour from `lumMod` then `tint`. The previous code
+ * collapsed lumMod/shade/tint into a single value and applied one formula to all three, which
+ * is why theme-tinted colours came out badly wrong.
+ */
+internal data class ColorSpec(val base: ColorBase, val transforms: List<ColorXf> = emptyList())
+
+internal sealed class ColorBase {
+  /** A literal `srgbClr` / `sysClr` / `prstClr` value, already packed as ARGB. */
+  data class Literal(val argb: Int) : ColorBase()
+  /** A `schemeClr` name (dk1/lt1/accent1/tx1/bg1/…), resolved through the master's clrMap. */
+  data class Scheme(val name: String) : ColorBase()
+  /** `phClr` — the colour handed in by the style reference using this spec. */
+  object Placeholder : ColorBase()
+}
+
+internal sealed class ColorXf {
+  /** Blends toward WHITE. */
+  data class Tint(val v: Float) : ColorXf()
+  /** Blends toward BLACK. */
+  data class Shade(val v: Float) : ColorXf()
+  /** Scales HSL luminance. */
+  data class LumMod(val v: Float) : ColorXf()
+  /** Offsets HSL luminance. */
+  data class LumOff(val v: Float) : ColorXf()
+  /** Scales HSL saturation. */
+  data class SatMod(val v: Float) : ColorXf()
+  data class Alpha(val v: Float) : ColorXf()
+}
+
+/**
+ * The theme palette + colour map a [ColorSpec] resolves against.
+ *
+ * `schemeColors` holds only the twelve real theme slots (dk1/lt1/dk2/lt2/accent1-6/hlink/
+ * folHlink). The `tx1`/`bg1`/`tx2`/`bg2` aliases are deliberately NOT stored there — they are
+ * indirections that must go through [clrMap], and pre-seeding them is exactly what used to make
+ * `tx1` resolve to hardcoded black on every deck.
+ */
+internal class ColorContext(
+  private val schemeColors: Map<String, Int>,
+  private val clrMap: Map<String, String>,
+  val phClr: Int? = null
+) {
+  fun scheme(name: String): Int {
+    val mapped = clrMap[name] ?: name
+    return schemeColors[mapped]
+      ?: schemeColors[name]
+      ?: DEFAULT_SCHEME_COLORS[mapped]
+      ?: DEFAULT_SCHEME_COLORS[name]
+      ?: BLACK_ARGB
+  }
+
+  fun withPlaceholder(color: Int?): ColorContext =
+    if (color == null) this else ColorContext(schemeColors, clrMap, color)
+
+  companion object {
+    /** Identity for everything except the four alias slots, per the OOXML default clrMap. */
+    val DEFAULT_CLR_MAP: Map<String, String> =
+      mapOf("bg1" to "lt1", "tx1" to "dk1", "bg2" to "lt2", "tx2" to "dk2")
+  }
+}
+
+/**
+ * Resolves [ColorSpec]s to packed ARGB ints.
+ *
+ * Intentionally free of `android.graphics` — every channel operation is hand-rolled bit
+ * twiddling — so this, the part of the renderer that is easiest to get subtly wrong, can be
+ * unit-tested on a bare JVM without Robolectric.
+ */
+internal object PptColor {
+  fun resolve(spec: ColorSpec, ctx: ColorContext): Int {
+    var argb = when (val base = spec.base) {
+      is ColorBase.Literal -> base.argb
+      is ColorBase.Scheme -> ctx.scheme(base.name)
+      ColorBase.Placeholder -> ctx.phClr ?: ctx.scheme("tx1")
+    }
+    for (xf in spec.transforms) argb = apply(argb, xf)
+    return argb
+  }
+
+  private fun apply(argb: Int, xf: ColorXf): Int = when (xf) {
+    // ECMA-376 defines tint/shade on LINEAR-light channels. Doing them in gamma-encoded sRGB
+    // (the common shortcut) is visibly too dark for shades in the 20-50% range, which is
+    // precisely the range Office's "Darker 25%" style variants use.
+    is ColorXf.Tint -> mapLinear(argb) { c -> c * xf.v + (1f - xf.v) }
+    is ColorXf.Shade -> mapLinear(argb) { c -> c * xf.v }
+    is ColorXf.LumMod -> mapHsl(argb) { h, s, l -> Triple(h, s, (l * xf.v).coerceIn(0f, 1f)) }
+    is ColorXf.LumOff -> mapHsl(argb) { h, s, l -> Triple(h, s, (l + xf.v).coerceIn(0f, 1f)) }
+    is ColorXf.SatMod -> mapHsl(argb) { h, s, l -> Triple(h, (s * xf.v).coerceIn(0f, 1f), l) }
+    is ColorXf.Alpha -> (argb and 0x00FFFFFF) or (to255(xf.v) shl 24)
+  }
+
+  private inline fun mapLinear(argb: Int, f: (Float) -> Float): Int {
+    val a = (argb ushr 24) and 0xFF
+    val r = linearToSrgb(f(srgbToLinear(((argb ushr 16) and 0xFF) / 255f)))
+    val g = linearToSrgb(f(srgbToLinear(((argb ushr 8) and 0xFF) / 255f)))
+    val b = linearToSrgb(f(srgbToLinear((argb and 0xFF) / 255f)))
+    return pack(a, to255(r), to255(g), to255(b))
+  }
+
+  private inline fun mapHsl(argb: Int, f: (Float, Float, Float) -> Triple<Float, Float, Float>): Int {
+    val a = (argb ushr 24) and 0xFF
+    val r = ((argb ushr 16) and 0xFF) / 255f
+    val g = ((argb ushr 8) and 0xFF) / 255f
+    val b = (argb and 0xFF) / 255f
+    val maxC = maxOf(r, g, b)
+    val minC = minOf(r, g, b)
+    val l = (maxC + minC) / 2f
+    val d = maxC - minC
+    val s = if (d == 0f) 0f else d / (1f - kotlin.math.abs(2f * l - 1f)).coerceAtLeast(1e-6f)
+    val h = when {
+      d == 0f -> 0f
+      maxC == r -> (((g - b) / d) % 6f + 6f) % 6f
+      maxC == g -> (b - r) / d + 2f
+      else -> (r - g) / d + 4f
+    } * 60f
+    val (h2, s2, l2) = f(h, s, l)
+    return hslToArgb(a, h2, s2, l2)
+  }
+
+  private fun hslToArgb(a: Int, h: Float, s: Float, l: Float): Int {
+    val c = (1f - kotlin.math.abs(2f * l - 1f)) * s
+    val hp = ((h % 360f) + 360f) % 360f / 60f
+    val x = c * (1f - kotlin.math.abs(hp % 2f - 1f))
+    val (r1, g1, b1) = when (hp.toInt()) {
+      0 -> Triple(c, x, 0f)
+      1 -> Triple(x, c, 0f)
+      2 -> Triple(0f, c, x)
+      3 -> Triple(0f, x, c)
+      4 -> Triple(x, 0f, c)
+      else -> Triple(c, 0f, x)
+    }
+    val m = l - c / 2f
+    return pack(a, to255(r1 + m), to255(g1 + m), to255(b1 + m))
+  }
+
+  private fun srgbToLinear(c: Float): Float =
+    if (c <= 0.04045f) c / 12.92f
+    else Math.pow(((c + 0.055f) / 1.055f).toDouble(), 2.4).toFloat()
+
+  private fun linearToSrgb(c: Float): Float {
+    val v = c.coerceIn(0f, 1f)
+    return if (v <= 0.0031308f) v * 12.92f
+    else (1.055f * Math.pow(v.toDouble(), 1.0 / 2.4).toFloat() - 0.055f)
+  }
+
+  private fun to255(v: Float): Int = (v * 255f + 0.5f).toInt().coerceIn(0, 255)
+
+  private fun pack(a: Int, r: Int, g: Int, b: Int): Int =
+    (a shl 24) or (r shl 16) or (g shl 8) or b
+}
+
+internal class PowerPointPresentationFormatter {
+  fun format(raw: RawPowerPointPresentation): PowerPointPresentation {
+    val width = raw.widthPt.takeIf { it > 0f } ?: DEFAULT_SLIDE_WIDTH_PT
+    val height = raw.heightPt.takeIf { it > 0f } ?: DEFAULT_SLIDE_HEIGHT_PT
+    val slides = raw.slides.ifEmpty {
+      listOf(
+        RawPowerPointSlide(
+          textRuns = listOf(raw.sourceName.ifBlank { Localization.getString("powerPointPresentationTitle", "PowerPoint presentation") })
+        )
+      )
+    }.mapIndexed { index, rawSlide ->
+      val normalized = ArrayList<PowerPointElement>(rawSlide.elements)
+      appendUnpositionedImages(normalized, rawSlide.images, width, height)
+      appendUnpositionedText(normalized, rawSlide.textRuns, width, height)
+      PowerPointSlide(index + 1, rawSlide.background, normalized)
+    }
+    return PowerPointPresentation(raw.sourceName, width, height, slides, raw.ownedBitmaps)
+  }
+
+  private fun appendUnpositionedImages(
+    out: MutableList<PowerPointElement>,
+    images: List<Bitmap>,
+    widthPt: Float,
+    heightPt: Float
+  ) {
+    if (images.isEmpty()) return
+    val hasPositionedImages = out.any { it is PowerPointElement.Picture }
+    if (hasPositionedImages) return
+    val imageAreaTop = if (out.isEmpty()) heightPt * 0.12f else heightPt * 0.48f
+    val imageAreaHeight = if (out.isEmpty()) heightPt * 0.76f else heightPt * 0.38f
+    val eachHeight = (imageAreaHeight / images.size.coerceAtMost(3)).coerceAtLeast(80f)
+    for ((index, bitmap) in images.take(3).withIndex()) {
+      val rect = fitBitmapRect(
+        bitmap,
+        RectF(widthPt * 0.08f, imageAreaTop + index * eachHeight, widthPt * 0.92f, imageAreaTop + (index + 1) * eachHeight - 8f)
+      )
+      out.add(PowerPointElement.Picture(rect, bitmap = bitmap))
+    }
+  }
+
+  private fun appendUnpositionedText(
+    out: MutableList<PowerPointElement>,
+    textRuns: List<String>,
+    widthPt: Float,
+    heightPt: Float
+  ) {
+    val cleaned = textRuns
+      .map { cleanText(it) }
+      .filter { it.length >= 2 }
+      .distinct()
+      .take(24)
+    if (cleaned.isEmpty()) return
+    val hasText = out.any { it is PowerPointElement.TextBox }
+    if (hasText) return
+
+    val title = cleaned.first()
+    val body = cleaned.drop(1)
+    out.add(
+      PowerPointElement.TextBox(
+        bounds = RectF(widthPt * 0.08f, heightPt * 0.08f, widthPt * 0.92f, heightPt * 0.23f),
+        paragraphs = listOf(
+          PowerPointParagraph(
+            runs = listOf(PowerPointTextRun(title, fontSizePt = 28f, bold = true)),
+            align = TextAlign.CENTER
+          )
+        ),
+        verticalAnchor = TextVerticalAnchor.MIDDLE
+      )
+    )
+    if (body.isNotEmpty()) {
+      out.add(
+        PowerPointElement.TextBox(
+          bounds = RectF(widthPt * 0.1f, heightPt * 0.29f, widthPt * 0.9f, heightPt * 0.9f),
+          paragraphs = body.map {
+            PowerPointParagraph(
+              runs = listOf(PowerPointTextRun(it, fontSizePt = 16f)),
+              bullet = if (body.size > 1) BULLET else null
+            )
+          }
+        )
+      )
+    }
+  }
+
+  private fun fitBitmapRect(bitmap: Bitmap, box: RectF): RectF {
+    if (bitmap.width <= 0 || bitmap.height <= 0) return RectF(box)
+    val bitmapAspect = bitmap.width.toFloat() / bitmap.height.toFloat()
+    val boxAspect = box.width() / box.height()
+    return if (bitmapAspect > boxAspect) {
+      val h = box.width() / bitmapAspect
+      RectF(box.left, box.centerY() - h / 2f, box.right, box.centerY() + h / 2f)
+    } else {
+      val w = box.height() * bitmapAspect
+      RectF(box.centerX() - w / 2f, box.top, box.centerX() + w / 2f, box.bottom)
+    }
+  }
+}
+
+private class PptxPresentationExtractor : PowerPointPresentationExtractor {
+  private lateinit var zip: ZipFile
+  private var imageBudget = Ox.MAX_TOTAL_IMAGE_BYTES
+  // Theme palette + clrMap that every schemeClr resolves against, and the theme's major/minor
+  // latin typefaces that `+mj-lt` / `+mn-lt` font tokens resolve to.
+  private var schemeColors: Map<String, Int> = DEFAULT_SCHEME_COLORS
+  private var clrMapping: Map<String, String> = ColorContext.DEFAULT_CLR_MAP
+  private var colorContext = ColorContext(DEFAULT_SCHEME_COLORS, ColorContext.DEFAULT_CLR_MAP)
+  private var majorLatinFont: String? = null
+  private var minorLatinFont: String? = null
+
+  private fun refreshColorContext() {
+    colorContext = ColorContext(schemeColors, clrMapping)
+  }
+
+  // Presentation slide size (points), used to synthesize default placeholder bands.
+  private var slideWidthPt = DEFAULT_SLIDE_WIDTH_PT
+  private var slideHeightPt = DEFAULT_SLIDE_HEIGHT_PT
+  // Inheritance context for the slide currently being parsed (layout + master placeholders,
+  // master text styles, resolved background). Reset per slide in [parseSlide].
+  private var currentContext: SlideInheritanceContext = SlideInheritanceContext.EMPTY
+  // Relationships of the part currently being parsed, so a <a:blipFill> nested in a shape's
+  // <p:spPr> can resolve its image without threading the map through every parser.
+  private var currentRels: Map<String, String> = emptyMap()
+  // Set while reading a layout/master's decoration graphics: placeholders are excluded (the
+  // slide draws its own) and their text must not pollute the slide's non-blank fallback.
+  private var parsingDecorations = false
+  // Plain text collected while parsing the current slide's shapes; used only as the last-resort
+  // non-blank fallback when no positioned element survived.
+  private val slideTextBucket = ArrayList<String>()
+  // Parsed layouts/masters are shared across slides that reference them — parse each once.
+  private val layoutCache = HashMap<String, ParsedSlidePart>()
+  private val masterCache = HashMap<String, ParsedSlidePart>()
+  // Decoded images, keyed by zip path: dedupes shared artwork and is the recycling manifest.
+  private val imageCache = HashMap<String, Bitmap>()
+
+  override fun extract(file: File): RawPowerPointPresentation {
+    ZipFile(file).use { z ->
+      zip = z
+      // Resolved from the first slide master's relationships where possible; theme1.xml is only
+      // the fallback, since a deck with several masters can reference several theme parts.
+      parseTheme(z, resolveThemePart(z))
+      val (widthPt, heightPt) = readSlideSize(z)
+      slideWidthPt = widthPt
+      slideHeightPt = heightPt
+      val slideParts = slideParts(z)
+      if (slideParts.isEmpty()) throw java.io.IOException("No slides")
+      val slides = slideParts.map { parseSlide(it) }
+      return RawPowerPointPresentation(
+        file.name, widthPt, heightPt, slides, imageCache.values.toList()
+      )
+    }
+  }
+
+  /**
+   * The theme part backing the deck's first slide master, or `ppt/theme/theme1.xml` when the
+   * relationship chain can't be followed. Walking presentation → master → theme matters because
+   * the old hardcoded path silently gave multi-master decks the wrong palette.
+   */
+  private fun resolveThemePart(z: ZipFile): String {
+    return try {
+      val masterPart = Ox.parseRels(z, "ppt/presentation.xml").values
+        .firstOrNull { it.contains("slideMaster", ignoreCase = true) }
+        ?: return DEFAULT_THEME_PART
+      Ox.parseRels(z, masterPart).values
+        .firstOrNull { it.contains("/theme/", ignoreCase = true) || it.contains("theme", ignoreCase = true) }
+        ?: DEFAULT_THEME_PART
+    } catch (_: Throwable) {
+      DEFAULT_THEME_PART
+    }
+  }
+
+  private fun readSlideSize(z: ZipFile): Pair<Float, Float> {
+    var widthPt = DEFAULT_SLIDE_WIDTH_PT
+    var heightPt = DEFAULT_SLIDE_HEIGHT_PT
+    Ox.zipStream(z, "ppt/presentation.xml")?.use { stream ->
+      val p = Ox.parser(stream)
+      while (p.next() != XmlPullParser.END_DOCUMENT) {
+        if (p.eventType == XmlPullParser.START_TAG && Ox.local(p) == "sldSz") {
+          Ox.emuToPt(Ox.attr(p, "cx"))?.let { widthPt = it }
+          Ox.emuToPt(Ox.attr(p, "cy"))?.let { heightPt = it }
+        }
+      }
+    }
+    return widthPt to heightPt
+  }
+
+  private fun slideParts(z: ZipFile): List<String> {
+    val rels = Ox.parseRels(z, "ppt/presentation.xml")
+    val out = ArrayList<String>()
+    Ox.zipStream(z, "ppt/presentation.xml")?.use { stream ->
+      val p = Ox.parser(stream)
+      while (p.next() != XmlPullParser.END_DOCUMENT) {
+        if (p.eventType == XmlPullParser.START_TAG && Ox.local(p) == "sldId") {
+          rels[Ox.attr(p, "r:id")]?.let { out.add(it) }
+        }
+      }
+    }
+    return out
+  }
+
+  private fun parseSlide(part: String): RawPowerPointSlide {
+    currentContext = loadInheritanceContext(part)
+    slideTextBucket.clear()
+    val rels = Ox.parseRels(zip, part)
+    currentRels = rels
+    val elements = ArrayList<PowerPointElement>()
+    var slideBackground: PptFill? = null
+    var showMasterSp = true
+    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)) {
+          // <p:sld showMasterSp="0"> suppresses the inherited background graphics.
+          "sld" -> showMasterSp = Ox.attr(p, "showMasterSp") != "0"
+          "bg" -> slideBackground = parseBackground(p, rels)
+          // Descend ONLY through the shape tree, and structurally. The previous flat scan
+          // matched `sp`/`pic` at any depth, which meant it fell into <p:grpSp> (drawing group
+          // children at raw child-space coordinates) and into <mc:AlternateContent> (drawing
+          // both the Choice and its Fallback, i.e. duplicate overlapping shapes).
+          "spTree" -> walkShapeContainer(p, rels, elements, 0)
+        }
+      }
+    }
+    // Inherited decoration sits UNDER everything the slide itself draws.
+    if (showMasterSp && currentContext.decorations.isNotEmpty()) {
+      elements.addAll(0, currentContext.decorations)
+    }
+    // Background: slide's own bg wins; else inherit layout → master; else white.
+    val background = slideBackground
+      ?: currentContext.background
+      ?: PptFill.Solid(Color.WHITE)
+    // Non-blank guarantee: if nothing positioned survived but the slide had readable text,
+    // hand it to the formatter so it synthesizes a titled text box instead of a blank slide.
+    if (elements.isEmpty() && slideTextBucket.isNotEmpty()) {
+      return RawPowerPointSlide(background = background, textRuns = slideTextBucket.toList())
+    }
+    return RawPowerPointSlide(background = background, elements = elements)
+  }
+
+  // ── Shape-tree traversal ─────────────────────────────────────────
+  //
+  // THE DEPTH CONTRACT, which every parser below obeys:
+  //
+  //   Every parseX/walkX is entered with the parser positioned ON X's START_TAG and returns with
+  //   it positioned ON X's matching END_TAG.
+  //
+  // A container loop therefore only ever observes its DIRECT children, and its `depth` counter
+  // goes 1 -> 0 exactly once, at its own END_TAG. Unknown children are skipped whole with
+  // Ox.skip(p) — never with `depth++`. Descending is opt-in and named, never implicit. The old
+  // `else -> depth++` branches are precisely what let the scan wander into groups,
+  // AlternateContent and <p:style>.
+
+  /**
+   * Walks the direct children of a shape container — `<p:spTree>`, `<p:grpSp>`, or a chosen
+   * `<mc:Choice>`/`<mc:Fallback>` — appending elements in document order (which is z-order).
+   */
+  private fun walkShapeContainer(
+    p: XmlPullParser,
+    rels: Map<String, String>,
+    out: MutableList<PowerPointElement>,
+    depthGuard: Int
+  ) {
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "sp", "cxnSp" -> guarded(p) { parseShape(p)?.let(out::add) }
+          "pic" -> guarded(p) { parsePicture(p, rels)?.let(out::add) }
+          "graphicFrame" -> guarded(p) { parseGraphicFrame(p)?.let(out::add) }
+          "grpSp" -> guarded(p) { parseGroup(p, rels, out, depthGuard + 1) }
+          "AlternateContent" -> guarded(p) { walkAlternateContent(p, rels, out, depthGuard) }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> return
+      }
+    }
+  }
+
+  /**
+   * A `<p:grpSp>`: its children are authored in the group's own CHILD coordinate space, which
+   * must be remapped through the group `<a:xfrm>`'s `chOff`/`chExt` -> `off`/`ext`. Skipping that
+   * remap is what made grouped shapes land in the wrong place and overlap other content.
+   *
+   * Children are buffered and re-parented after the loop rather than relying on `grpSpPr`
+   * preceding them, so a producer that emits them out of order still renders correctly.
+   */
+  private fun parseGroup(
+    p: XmlPullParser,
+    rels: Map<String, String>,
+    out: MutableList<PowerPointElement>,
+    depthGuard: Int
+  ) {
+    if (depthGuard > MAX_GROUP_NESTING) {
+      Ox.skip(p)
+      return
+    }
+    var transform = Affine.IDENTITY
+    val children = ArrayList<PowerPointElement>()
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "grpSpPr" -> transform = parseGroupTransform(p)
+          "sp", "cxnSp" -> guarded(p) { parseShape(p)?.let(children::add) }
+          "pic" -> guarded(p) { parsePicture(p, rels)?.let(children::add) }
+          "graphicFrame" -> guarded(p) { parseGraphicFrame(p)?.let(children::add) }
+          "grpSp" -> guarded(p) { parseGroup(p, rels, children, depthGuard + 1) }
+          "AlternateContent" -> guarded(p) { walkAlternateContent(p, rels, children, depthGuard) }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    if (transform.isIdentity()) out.addAll(children)
+    else children.mapTo(out) { it.reparent(transform) }
+  }
+
+  /** `<p:grpSpPr>` -> the child-space to parent-space mapping declared by its `<a:xfrm>`. */
+  private fun parseGroupTransform(p: XmlPullParser): Affine {
+    var off: RectF? = null
+    var ext: FloatArray? = null
+    var chOff: FloatArray? = null
+    var chExt: FloatArray? = null
+    var rot = 0f
+    var flipH = false
+    var flipV = false
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "xfrm" -> {
+            rot = (Ox.attr(p, "rot")?.toFloatOrNull() ?: 0f) / 60000f
+            flipH = Ox.attr(p, "flipH") == "1"
+            flipV = Ox.attr(p, "flipV") == "1"
+          }
+          "off" -> {
+            val x = Ox.emuToPt(Ox.attr(p, "x")); val y = Ox.emuToPt(Ox.attr(p, "y"))
+            if (x != null && y != null) off = RectF(x, y, x, y)
+            Ox.skip(p)
+          }
+          "ext" -> {
+            val w = Ox.emuToPt(Ox.attr(p, "cx")); val h = Ox.emuToPt(Ox.attr(p, "cy"))
+            if (w != null && h != null) ext = floatArrayOf(w, h)
+            Ox.skip(p)
+          }
+          "chOff" -> {
+            val x = Ox.emuToPt(Ox.attr(p, "x")); val y = Ox.emuToPt(Ox.attr(p, "y"))
+            if (x != null && y != null) chOff = floatArrayOf(x, y)
+            Ox.skip(p)
+          }
+          "chExt" -> {
+            val w = Ox.emuToPt(Ox.attr(p, "cx")); val h = Ox.emuToPt(Ox.attr(p, "cy"))
+            if (w != null && h != null) chExt = floatArrayOf(w, h)
+            Ox.skip(p)
+          }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    val o = off ?: return Affine.IDENTITY
+    val e = ext ?: return Affine.IDENTITY
+    // A group that was never moved or resized after grouping has chOff == off and chExt == ext,
+    // which yields identity — that is exactly why the missing remap was invisible on some decks.
+    val co = chOff ?: floatArrayOf(o.left, o.top)
+    val ce = chExt ?: e
+    val sx = if (ce[0] != 0f) e[0] / ce[0] else 1f
+    val sy = if (ce[1] != 0f) e[1] / ce[1] else 1f
+
+    var m = Affine.translate(-co[0], -co[1]).then(Affine.scale(sx, sy))
+    if (flipH) m = m.then(Affine.scale(-1f, 1f)).then(Affine.translate(e[0], 0f))
+    if (flipV) m = m.then(Affine.scale(1f, -1f)).then(Affine.translate(0f, e[1]))
+    if (rot != 0f) {
+      m = m.then(Affine.translate(-e[0] / 2f, -e[1] / 2f))
+        .then(Affine.rotate(rot))
+        .then(Affine.translate(e[0] / 2f, e[1] / 2f))
+    }
+    return m.then(Affine.translate(o.left, o.top))
+  }
+
+  /**
+   * `<mc:AlternateContent>` offers the same content twice: a `<mc:Choice>` using an extension
+   * namespace, and a `<mc:Fallback>` in plain DrawingML. Exactly ONE must be rendered — walking
+   * both is what produced duplicate, overlapping shapes.
+   *
+   * The parser is forward-only, so the decision is made from `Requires` without look-ahead.
+   * Anything we can't claim to understand (SmartArt's `dsp`, Word shapes' `wps`/`wpg`, …) falls
+   * through to the Fallback, which by construction is plain `p:`/`a:` markup we can draw — and
+   * which the group handling above now positions correctly.
+   */
+  private fun walkAlternateContent(
+    p: XmlPullParser,
+    rels: Map<String, String>,
+    out: MutableList<PowerPointElement>,
+    depthGuard: Int
+  ) {
+    var taken = false
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "Choice" -> {
+            val requires = Ox.attr(p, "Requires")?.trim()?.split(' ')?.filter { it.isNotBlank() }
+            if (!taken && !requires.isNullOrEmpty() && requires.all { it in RENDERABLE_CHOICE_NS }) {
+              taken = true
+              walkShapeContainer(p, rels, out, depthGuard)
+            } else {
+              Ox.skip(p)
+            }
+          }
+          "Fallback" -> if (!taken) {
+            taken = true
+            walkShapeContainer(p, rels, out, depthGuard)
+          } else {
+            Ox.skip(p)
+          }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> return
+      }
+    }
+  }
+
+  /**
+   * Runs a shape handler, and on failure resynchronises to the end of that element instead of
+   * letting the exception abandon the whole slide. Bounds the blast radius of one malformed
+   * shape to that shape.
+   */
+  private inline fun guarded(p: XmlPullParser, body: () -> Unit) {
+    val entryDepth = p.depth
+    try {
+      body()
+    } catch (_: Throwable) {
+      try {
+        while (p.depth >= entryDepth && p.eventType != XmlPullParser.END_DOCUMENT) p.next()
+      } catch (_: Throwable) { /* Parser is unusable; the caller's loop will terminate. */ }
+    }
+  }
+
+  // ── Layout / master inheritance ──────────────────────────────────
+
+  /**
+   * Resolves the slide → slide-layout → slide-master chain for [slidePart] into the placeholder
+   * geometry/text-style/background defaults the slide itself omits. Never throws: any missing or
+   * malformed part degrades to whatever resolved, and ultimately to [SlideInheritanceContext.EMPTY].
+   */
+  private fun loadInheritanceContext(slidePart: String): SlideInheritanceContext {
+    return try {
+      val layoutPart = Ox.parseRels(zip, slidePart).values
+        .firstOrNull { it.contains("slideLayout", ignoreCase = true) }
+        ?: return SlideInheritanceContext.EMPTY
+      val layout = layoutCache.getOrPut(layoutPart) { parseSlidePart(layoutPart, isMaster = false) }
+      val masterPart = Ox.parseRels(zip, layoutPart).values
+        .firstOrNull { it.contains("slideMaster", ignoreCase = true) }
+      val master = masterPart?.let { mp -> masterCache.getOrPut(mp) { parseSlidePart(mp, isMaster = true) } }
+      SlideInheritanceContext(
+        layoutPlaceholders = layout.placeholders,
+        masterPlaceholders = master?.placeholders ?: emptyList(),
+        textStyles = master?.textStyles ?: TextStyles.EMPTY,
+        background = layout.background ?: master?.background,
+        decorations = (master?.decorations ?: emptyList()) + layout.decorations
+      )
+    } catch (_: Throwable) {
+      SlideInheritanceContext.EMPTY
+    }
+  }
+
+  /** Parses a slide layout or master: its placeholder geometry/list-styles, background, and
+   *  (masters only) the `<p:txStyles>` title/body/other default run+paragraph styles. */
+  private fun parseSlidePart(partPath: String, isMaster: Boolean): ParsedSlidePart {
+    val placeholders = ArrayList<StoredPlaceholder>()
+    var background: PptFill? = null
+    var textStyles = TextStyles.EMPTY
+    val rels = Ox.parseRels(zip, partPath)
+    try {
+      Ox.zipStream(zip, partPath)?.use { stream ->
+        val p = Ox.parser(stream)
+        while (p.next() != XmlPullParser.END_DOCUMENT) {
+          if (p.eventType != XmlPullParser.START_TAG) continue
+          when (Ox.local(p)) {
+            "bg" -> background = parseBackground(p, rels)
+            "sp" -> parseLayoutShape(p)?.let { placeholders.add(it) }
+            "txStyles" -> if (isMaster) textStyles = parseTxStyles(p)
+          }
+        }
+      }
+    } catch (_: Throwable) { /* Use whatever parsed before the failure. */ }
+    return ParsedSlidePart(placeholders, background, textStyles, parseDecorations(partPath))
+  }
+
+  /**
+   * The non-placeholder shapes of a layout or master, parsed in their own right so they can be
+   * drawn behind the slide's content.
+   *
+   * Runs with an EMPTY inheritance context: these shapes are not placeholders, so there is
+   * nothing for them to inherit, and using the calling slide's context would be wrong anyway.
+   */
+  private fun parseDecorations(partPath: String): List<PowerPointElement> {
+    val out = ArrayList<PowerPointElement>()
+    val savedContext = currentContext
+    val savedRels = currentRels
+    currentContext = SlideInheritanceContext.EMPTY
+    currentRels = Ox.parseRels(zip, partPath)
+    parsingDecorations = true
+    try {
+      Ox.zipStream(zip, partPath)?.use { stream ->
+        val p = Ox.parser(stream)
+        while (p.next() != XmlPullParser.END_DOCUMENT) {
+          if (p.eventType == XmlPullParser.START_TAG && Ox.local(p) == "spTree") {
+            walkShapeContainer(p, currentRels, out, 0)
+            break
+          }
+        }
+      }
+    } catch (_: Throwable) { /* Decoration is optional - never fail the slide over it. */ } finally {
+      parsingDecorations = false
+      currentContext = savedContext
+      currentRels = savedRels
+    }
+    return out
+  }
+
+  /** A single `<p:sp>` on a layout/master: keeps only placeholders, capturing their geometry
+   *  and any per-level `<a:lstStyle>` run/paragraph defaults. */
+  private fun parseLayoutShape(p: XmlPullParser): StoredPlaceholder? {
+    var placeholder: PowerPointPlaceholder? = null
+    var bounds: RectF? = null
+    var lstStyle: Map<Int, ParaRunDefaults> = emptyMap()
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "ph" -> {
+            placeholder = PowerPointPlaceholder(Ox.attr(p, "type"), Ox.attr(p, "idx"))
+            Ox.skip(p)
+          }
+          "spPr" -> bounds = parseShapeProperties(p).transform?.bounds
+          "lstStyle" -> lstStyle = parseLevelStyles(p)
+          // Named descent: <p:ph> lives under nvSpPr/nvPr and <a:lstStyle> under txBody.
+          "nvSpPr", "nvPr", "txBody" -> depth++
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    val ph = placeholder ?: return null
+    return StoredPlaceholder(ph, PlaceholderInfo(bounds, lstStyle))
+  }
+
+  /** Master `<p:txStyles>` → title/body/other style tables (per outline level). */
+  private fun parseTxStyles(p: XmlPullParser): TextStyles {
+    var title: Map<Int, ParaRunDefaults> = emptyMap()
+    var body: Map<Int, ParaRunDefaults> = emptyMap()
+    var other: Map<Int, ParaRunDefaults> = emptyMap()
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "titleStyle" -> title = parseLevelStyles(p)
+          "bodyStyle" -> body = parseLevelStyles(p)
+          "otherStyle" -> other = parseLevelStyles(p)
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return TextStyles(title, body, other)
+  }
+
+  /** Parses `<a:lvl1pPr>…<a:lvl9pPr>` (in an `lstStyle`/`titleStyle`/`bodyStyle`/`otherStyle`
+   *  container) into a level → [ParaRunDefaults] map. Levels are 0-based (lvl1pPr → 0). */
+  private fun parseLevelStyles(p: XmlPullParser): Map<Int, ParaRunDefaults> {
+    val out = HashMap<Int, ParaRunDefaults>()
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> {
+          val match = LVL_STYLE_REGEX.matchEntire(Ox.local(p))
+          if (match != null) {
+            val level = ((match.groupValues[1].toIntOrNull() ?: 1) - 1).coerceAtLeast(0)
+            out[level] = parseLevelPr(p)
+          } else {
+            Ox.skip(p)
+          }
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return out
+  }
+
+  /** One `<a:lvlNpPr>`: its `<a:defRPr>` run defaults plus paragraph alignment and bullet. */
+  private fun parseLevelPr(p: XmlPullParser): ParaRunDefaults {
+    val align = when (Ox.attr(p, "algn")) {
+      "ctr" -> TextAlign.CENTER
+      "r" -> TextAlign.RIGHT
+      "just" -> TextAlign.JUSTIFY
+      "l" -> TextAlign.LEFT
+      else -> null
+    }
+    val marL = Ox.emuToPt(Ox.attr(p, "marL"))
+    val indent = Ox.emuToPt(Ox.attr(p, "indent"))
+    var run = PowerPointRunProperties()
+    var bullet: String? = null
+    var bulletExplicit = false
+    var lineSpacePct: Float? = null
+    var spaceBefore: Float? = null
+    var spaceAfter: Float? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "defRPr" -> run = parseRunProperties(p)
+          "buChar" -> {
+            bullet = normalizeBullet(Ox.attr(p, "char"))
+            bulletExplicit = true
+            Ox.skip(p)
+          }
+          "buAutoNum" -> {
+            bullet = autoNumberMarker(Ox.attr(p, "type"), Ox.attr(p, "startAt")?.toIntOrNull() ?: 1)
+            bulletExplicit = true
+            Ox.skip(p)
+          }
+          "buNone" -> {
+            bullet = null
+            bulletExplicit = true
+            Ox.skip(p)
+          }
+          "lnSpc" -> lineSpacePct = parseLineSpacing(p)
+          "spcBef" -> spaceBefore = parseSpacing(p)
+          "spcAft" -> spaceAfter = parseSpacing(p)
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return ParaRunDefaults(
+      run, align, bullet, bulletExplicit, marL, indent, lineSpacePct, spaceBefore, spaceAfter
+    )
+  }
+
+  /** Effective per-level defaults for a placeholder: its layout list-style, then the master
+   *  placeholder list-style, then the master's category text style (falling back to level 0). */
+  private fun defaultsFor(
+    level: Int,
+    placeholder: PowerPointPlaceholder?,
+    layoutInfo: PlaceholderInfo?,
+    masterInfo: PlaceholderInfo?
+  ): ParaRunDefaults? {
+    // Non-placeholder shapes still inherit the master's "other" style rather than nothing.
+    val category = if (placeholder == null) {
+      PlaceholderCategory.OTHER
+    } else {
+      phCategory(placeholder.type)
+    }
+    val styles = currentContext.textStyles.forCategory(category)
+    // MERGE field-by-field in precedence order (master txStyles -> master placeholder -> layout
+    // placeholder). Returning the first source that had ANY value - as this used to - meant a
+    // layout that set only alignment threw away the master's font size and colour, which is why
+    // so much text fell back to the renderer's hardcoded default.
+    var out: ParaRunDefaults? = styles[level] ?: styles[0]
+    if (placeholder != null) {
+      masterInfo?.lstStyle?.get(level)?.let { out = it.overlayOn(out) }
+      layoutInfo?.lstStyle?.get(level)?.let { out = it.overlayOn(out) }
+    }
+    return out
+  }
+
+  /** Folds inherited [defaults] into a [RawParagraph]: the slide's own run/paragraph values win;
+   *  gaps are filled from the placeholder's inherited style. */
+  private fun resolveParagraph(
+    raw: RawParagraph,
+    defaults: ParaRunDefaults?,
+    category: PlaceholderCategory = PlaceholderCategory.BODY,
+    styleTextColor: Int? = null
+  ): PowerPointParagraph {
+    val dr = defaults?.run
+    val runs = if (dr == null) raw.runs else raw.runs.map { run ->
+      run.copy(
+        fontSizePt = run.fontSizePt ?: dr.fontSizePt,
+        color = run.color ?: dr.color,
+        fontFamily = run.fontFamily ?: dr.fontFamily,
+        bold = run.bold ?: dr.bold,
+        italic = run.italic ?: dr.italic,
+        underline = run.underline ?: dr.underline,
+        strike = run.strike ?: dr.strike,
+        allCaps = run.allCaps ?: dr.allCaps
+      )
+    }
+    val align = raw.align ?: defaults?.align ?: TextAlign.LEFT
+    val bullet = if (raw.bulletExplicit) raw.bullet else defaults?.bullet
+    // Resolve the paragraph's base appearance once. Order: the inherited placeholder default,
+    // then whatever the paragraph's own first run states, then the OOXML floor for the
+    // placeholder's category (titles are much larger than body text).
+    val first = runs.firstOrNull()
+    val floorSize = when (category) {
+      PlaceholderCategory.TITLE -> DEFAULT_TITLE_SIZE_PT
+      else -> DEFAULT_BODY_SIZE_PT
+    }
+    // Bullet geometry: the deck's own value wins, then the inherited list style, then a
+    // hanging-indent default matching the DOCX preview so the two look like one product.
+    val hasBullet = bullet != null
+    val marL = raw.marLPt ?: defaults?.marLPt
+      ?: if (hasBullet) DEFAULT_BULLET_INDENT_PT * (raw.level + 1) else 0f
+    val indent = raw.indentPt ?: defaults?.indentPt
+      ?: if (hasBullet) -DEFAULT_BULLET_INDENT_PT else 0f
+    val baseSize = dr?.fontSizePt ?: first?.fontSizePt ?: floorSize
+    // A negative value means "a fraction of the font size" (the spcPct form).
+    fun spacingPt(v: Float?): Float = when {
+      v == null -> 0f
+      v < 0f -> -v * baseSize
+      else -> v
+    }
+    return PowerPointParagraph(
+      runs = runs,
+      align = align,
+      bullet = bullet,
+      level = raw.level,
+      baseSizePt = dr?.fontSizePt ?: first?.fontSizePt ?: floorSize,
+      baseColor = dr?.color ?: first?.color ?: styleTextColor ?: defaultTextColor(),
+      baseFontFamily = dr?.fontFamily ?: first?.fontFamily ?: minorLatinFont,
+      baseBold = dr?.bold ?: first?.bold ?: false,
+      baseItalic = dr?.italic ?: first?.italic ?: false,
+      marLPt = marL,
+      indentPt = indent,
+      lineSpacePct = raw.lineSpacePct ?: defaults?.lineSpacePct,
+      spaceBeforePt = spacingPt(raw.spaceBeforePt ?: defaults?.spaceBeforePt),
+      spaceAfterPt = spacingPt(raw.spaceAfterPt ?: defaults?.spaceAfterPt)
+    )
+  }
+
+  /**
+   * The colour text falls back to when nothing in the inheritance chain specifies one: the
+   * theme's mapped `tx1`, which is what PowerPoint uses. Critically this is NOT hardcoded black,
+   * so a dark-master deck gets its light text instead of black-on-dark.
+   */
+  private fun defaultTextColor(): Int = colorContext.scheme("tx1")
+
+  /** A synthesized band for a placeholder whose geometry the deck left entirely to the master
+   *  (title → top, body/subtitle → centre) so inherited text is never dropped. Decorative
+   *  placeholders (footer/date/slide-number) return null and are skipped. */
+  private fun defaultPlaceholderBounds(type: String?): RectF? {
+    val w = slideWidthPt
+    val h = slideHeightPt
+    return when (phCategory(type)) {
+      PlaceholderCategory.TITLE -> RectF(w * 0.06f, h * 0.05f, w * 0.94f, h * 0.22f)
+      PlaceholderCategory.BODY -> RectF(w * 0.06f, h * 0.25f, w * 0.94f, h * 0.92f)
+      PlaceholderCategory.OTHER -> null
+    }
+  }
+
+  private fun parseBackground(p: XmlPullParser, rels: Map<String, String>): PptFill {
+    var color: Int? = null
+    var bitmap: Bitmap? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "solidFill" -> color = resolveColor(parseColorContainer(p))
+          "blipFill" -> bitmap = parseBlipFill(p, rels)
+          // Named descent: the fills sit inside <p:bgPr>.
+          "bgPr" -> depth++
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return bitmap?.let { PptFill.Image(it, color ?: Color.WHITE) }
+      ?: PptFill.Solid(color ?: Color.WHITE)
+  }
+
+  private fun parseShape(p: XmlPullParser): PowerPointElement? {
+    var transform = PowerPointTransform()
+    var fill: PptFill? = null
+    var explicitNoFill = false
+    var stroke: PowerPointStroke? = null
+    var shapeType = PowerPointShapeType.RECT
+    var customPath: android.graphics.Path? = null
+    var textBody = PowerPointTextBody()
+    var placeholder: PowerPointPlaceholder? = null
+    var styleRefs = ShapeStyleRefs()
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          // <p:nvSpPr><p:nvPr><p:ph type=".." idx=".."/> — the placeholder identity that keys
+          // geometry/text-style inheritance from the slide layout and master.
+          "ph" -> {
+            placeholder = PowerPointPlaceholder(Ox.attr(p, "type"), Ox.attr(p, "idx"))
+            Ox.skip(p)
+          }
+          "spPr" -> {
+            val props = parseShapeProperties(p)
+            transform = props.transform ?: transform
+            fill = props.fill
+            explicitNoFill = props.explicitNoFill
+            stroke = props.stroke
+            shapeType = props.shapeType
+            customPath = props.customPath
+          }
+          "style" -> styleRefs = parseShapeStyle(p)
+          "txBody" -> textBody = parseTextBody(p)
+          // Named descent: <p:ph> lives under nvSpPr/nvCxnSpPr -> nvPr.
+          "nvSpPr", "nvCxnSpPr", "nvPr" -> depth++
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+
+    // A layout/master placeholder is only a TEMPLATE for the slide's own shape - drawing it as
+    // decoration would double every title and stamp "Click to edit" prompts onto real slides.
+    if (parsingDecorations && placeholder != null) return null
+
+    // Feed the slide's non-blank safety net with this shape's plain text, whether or not the
+    // element itself survives (e.g. a footer placeholder we later drop for lacking geometry).
+    if (!parsingDecorations) {
+      for (raw in textBody.paragraphs) {
+        val line = raw.runs.joinToString("") { it.text }.replace('\n', ' ').trim()
+        if (line.isNotEmpty()) slideTextBucket.add(line)
+      }
+    }
+
+    // Fall back to the theme style matrix for anything the shape didn't state outright. This is
+    // what stops themed shapes (whose colour lives entirely in <p:style>) from ending up with no
+    // fill and being discarded below. An explicit <a:noFill/> still wins.
+    val effectiveFill = fill
+      ?: if (explicitNoFill) null else styleRefs.fillColor?.let { PptFill.Solid(it) }
+    val effectiveStroke = stroke
+      ?: styleRefs.lineColor?.let { PowerPointStroke(it, 1f) }
+
+    val layoutInfo = placeholder?.let { matchPlaceholder(currentContext.layoutPlaceholders, it) }
+    val masterInfo = placeholder?.let { matchPlaceholder(currentContext.masterPlaceholders, it) }
+    // Geometry: the slide's own xfrm wins; otherwise inherit from the matched layout → master
+    // placeholder; as a last resort synthesize a default band so inherited placeholders that
+    // reference master-only geometry never vanish.
+    val bounds = transform.bounds
+      ?: layoutInfo?.bounds
+      ?: masterInfo?.bounds
+      ?: placeholder?.let { defaultPlaceholderBounds(it.type) }
+
+    if (textBody.paragraphs.isNotEmpty()) {
+      val b = bounds ?: return null
+      val resolved = textBody.paragraphs.map { raw ->
+        resolveParagraph(
+          raw,
+          defaultsFor(raw.level, placeholder, layoutInfo, masterInfo),
+          phCategory(placeholder?.type),
+          // A themed shape carries its text colour in <a:fontRef>; without it, white-on-accent
+          // captions rendered black on a coloured fill.
+          styleRefs.fontColor
+        )
+      }
+      return PowerPointElement.TextBox(
+        bounds = b,
+        rotation = transform.rotation,
+        paragraphs = resolved,
+        fill = effectiveFill,
+        stroke = effectiveStroke,
+        verticalAnchor = textBody.anchor,
+        insetLeftPt = textBody.insetLeftPt,
+        insetTopPt = textBody.insetTopPt,
+        insetRightPt = textBody.insetRightPt,
+        insetBottomPt = textBody.insetBottomPt,
+        shapeType = shapeType,
+        customPath = customPath,
+        autofit = textBody.autofit,
+        fontScale = textBody.fontScale,
+        lnSpcReduction = textBody.lnSpcReduction,
+        flipH = transform.flipH,
+        flipV = transform.flipV
+      )
+    }
+    val b = bounds ?: return null
+    if (effectiveFill == null && effectiveStroke == null) return null
+    return PowerPointElement.Shape(
+      b, transform.rotation, shapeType, effectiveFill, effectiveStroke, customPath,
+      transform.flipH, transform.flipV
+    )
+  }
+
+  private fun parsePicture(p: XmlPullParser, rels: Map<String, String>): PowerPointElement? {
+    var transform = PowerPointTransform()
+    var imageRel: String? = null
+    var srcRect: RectF? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "spPr" -> parseShapeProperties(p).transform?.let { transform = it }
+          "blip" -> {
+            imageRel = Ox.attr(p, "embed")
+            Ox.skip(p)
+          }
+          // Crop, as fractional insets in thousandths of a percent. Ignoring it stretched the
+          // whole source image into a frame that was only meant to show part of it.
+          "srcRect" -> {
+            fun inset(name: String) = (Ox.attr(p, name)?.toFloatOrNull() ?: 0f) / 100000f
+            val r = RectF(inset("l"), inset("t"), inset("r"), inset("b"))
+            if (r.left != 0f || r.top != 0f || r.right != 0f || r.bottom != 0f) srcRect = r
+            Ox.skip(p)
+          }
+          // Named descent: <a:blip>/<a:srcRect> live inside <p:blipFill>.
+          "blipFill" -> depth++
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    val bounds = transform.bounds ?: return null
+    val rel = imageRel ?: return null
+    val bitmap = loadBitmap(rels[rel] ?: return null) ?: return null
+    return PowerPointElement.Picture(
+      bounds, transform.rotation, bitmap, srcRect, transform.flipH, transform.flipV
+    )
+  }
+
+  private fun parseGraphicFrame(p: XmlPullParser): PowerPointElement? {
+    var transform = PowerPointTransform()
+    var table: PowerPointElement.Table? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "xfrm" -> transform = parseTransform(p)
+          "tbl" -> table = parseTable(p, transform)
+          // Named descent: <a:tbl> sits under <a:graphic><a:graphicData>. Charts and SmartArt
+          // land here too and yield no table — they are skipped rather than mis-drawn.
+          "graphic", "graphicData" -> depth++
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return table
+  }
+
+  private fun parseShapeProperties(p: XmlPullParser): PowerPointShapeProperties {
+    var transform: PowerPointTransform? = null
+    var fill: PptFill? = null
+    var explicitNoFill = false
+    var stroke: PowerPointStroke? = null
+    var shapeType = PowerPointShapeType.RECT
+    var customPath: android.graphics.Path? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "xfrm" -> transform = parseTransform(p)
+          "prstGeom" -> {
+            shapeType = mapShapeType(Ox.attr(p, "prst"))
+            Ox.skip(p)
+          }
+          // A hand-edited or imported shape carries its outline explicitly. Without this the
+          // shape fell back to its bounding RECTANGLE, which on a slide full of custom diagram
+          // shapes reads as a wall of solid blocks.
+          "custGeom" -> customPath = parseCustomGeometry(p)
+          "solidFill" -> fill = resolveColor(parseColorContainer(p))?.let { PptFill.Solid(it) }
+          "gradFill" -> fill = parseGradientFill(p)
+          "pattFill" -> fill = parsePatternFill(p)
+          "blipFill" -> fill = parseBlipFill(p, currentRels)?.let { PptFill.Image(it) }
+          "noFill" -> {
+            fill = null
+            explicitNoFill = true
+            Ox.skip(p)
+          }
+          "ln" -> stroke = parseLine(p)
+          // No blind descent here: <a:effectLst>/<a:scene3d> contain their own <a:solidFill>
+          // elements, and falling into them would adopt a shadow's colour as the shape's fill.
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return PowerPointShapeProperties(
+      transform, fill, stroke, shapeType, explicitNoFill, customPath
+    )
+  }
+
+  /**
+   * `<a:custGeom>` -> a Path in NORMALISED 0..1 coordinates.
+   *
+   * Normalising against the path's own `w`/`h` (falling back to the shape extent) means the same
+   * Path can be scaled to whatever rect the shape occupies, including after a group transform.
+   */
+  private fun parseCustomGeometry(p: XmlPullParser): android.graphics.Path? {
+    val out = android.graphics.Path()
+    var pathW = 0f
+    var pathH = 0f
+    var any = false
+    // The pending point list for the current segment: <a:pt> children arrive one at a time.
+    val pts = ArrayList<Float>(6)
+    val arcOval = RectF()
+    var segment = ""
+    var curX = 0f
+    var curY = 0f
+    var arc: FloatArray? = null
+
+    fun nx(v: Float) = if (pathW > 0f) v / pathW else 0f
+    fun ny(v: Float) = if (pathH > 0f) v / pathH else 0f
+
+    fun flush() {
+      when (segment) {
+        "moveTo" -> if (pts.size >= 2) {
+          curX = pts[0]; curY = pts[1]
+          out.moveTo(nx(curX), ny(curY))
+          any = true
+        }
+        "lnTo" -> if (pts.size >= 2) {
+          curX = pts[0]; curY = pts[1]
+          out.lineTo(nx(curX), ny(curY))
+          any = true
+        }
+        "quadBezTo" -> if (pts.size >= 4) {
+          out.quadTo(nx(pts[0]), ny(pts[1]), nx(pts[2]), ny(pts[3]))
+          curX = pts[2]; curY = pts[3]
+          any = true
+        }
+        "cubicBezTo" -> if (pts.size >= 6) {
+          out.cubicTo(
+            nx(pts[0]), ny(pts[1]), nx(pts[2]), ny(pts[3]), nx(pts[4]), ny(pts[5])
+          )
+          curX = pts[4]; curY = pts[5]
+          any = true
+        }
+        "arcTo" -> arc?.let { a ->
+          // <a:arcTo> is relative: the current point lies on the ellipse at stAng, so the centre
+          // is back-computed from it and the sweep drawn from there.
+          val wR = a[0]
+          val hR = a[1]
+          val st = a[2]
+          val sw = a[3]
+          val ccx = curX - wR * kotlin.math.cos(Math.toRadians(st.toDouble())).toFloat()
+          val ccy = curY - hR * kotlin.math.sin(Math.toRadians(st.toDouble())).toFloat()
+          arcOval.set(nx(ccx - wR), ny(ccy - hR), nx(ccx + wR), ny(ccy + hR))
+          out.arcTo(arcOval, st, sw)
+          val end = st + sw
+          curX = ccx + wR * kotlin.math.cos(Math.toRadians(end.toDouble())).toFloat()
+          curY = ccy + hR * kotlin.math.sin(Math.toRadians(end.toDouble())).toFloat()
+          any = true
+        }
+      }
+      pts.clear()
+      arc = null
+      segment = ""
+    }
+
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (val local = Ox.local(p)) {
+          "path" -> {
+            pathW = Ox.attr(p, "w")?.toFloatOrNull() ?: pathW
+            pathH = Ox.attr(p, "h")?.toFloatOrNull() ?: pathH
+            depth++
+          }
+          "pathLst" -> depth++
+          "moveTo", "lnTo", "quadBezTo", "cubicBezTo" -> {
+            flush()
+            segment = local
+            depth++
+          }
+          "arcTo" -> {
+            flush()
+            segment = "arcTo"
+            arc = floatArrayOf(
+              Ox.attr(p, "wR")?.toFloatOrNull() ?: 0f,
+              Ox.attr(p, "hR")?.toFloatOrNull() ?: 0f,
+              (Ox.attr(p, "stAng")?.toFloatOrNull() ?: 0f) / 60000f,
+              (Ox.attr(p, "swAng")?.toFloatOrNull() ?: 0f) / 60000f
+            )
+            Ox.skip(p)
+            flush()
+          }
+          "pt" -> {
+            Ox.attr(p, "x")?.toFloatOrNull()?.let { pts.add(it) }
+            Ox.attr(p, "y")?.toFloatOrNull()?.let { pts.add(it) }
+            Ox.skip(p)
+          }
+          "close" -> {
+            flush()
+            out.close()
+            Ox.skip(p)
+          }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> {
+          // Leaving a segment element commits whatever <a:pt> children it collected.
+          if (segment.isNotEmpty()) flush()
+          depth--
+        }
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    if (!any || pathW <= 0f || pathH <= 0f) return null
+    return out
+  }
+
+  /**
+   * `<a:gradFill>` -> stop colours and the gradient direction.
+   *
+   * Gradients had no representation before, so a gradient-filled shape came out with no fill and
+   * was then discarded outright, and a gradient slide background fell back to flat white.
+   */
+  private fun parseGradientFill(p: XmlPullParser): PptFill? {
+    val stops = ArrayList<Pair<Float, Int>>(4)
+    var angle = 90f
+    var radial = false
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "gs" -> {
+            val pos = (Ox.attr(p, "pos")?.toFloatOrNull() ?: 0f) / 100000f
+            resolveColor(parseColorContainer(p))?.let { stops.add(pos to it) }
+          }
+          "lin" -> {
+            angle = (Ox.attr(p, "ang")?.toFloatOrNull() ?: 5400000f) / 60000f
+            Ox.skip(p)
+          }
+          "path" -> {
+            radial = true
+            Ox.skip(p)
+          }
+          // Named descent: the stops live inside <a:gsLst>.
+          "gsLst" -> depth++
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    if (stops.isEmpty()) return null
+    if (stops.size == 1) return PptFill.Solid(stops[0].second)
+    stops.sortBy { it.first }
+    return PptFill.Gradient(
+      colors = stops.map { it.second }.toIntArray(),
+      stops = stops.map { it.first.coerceIn(0f, 1f) }.toFloatArray(),
+      angleDeg = angle,
+      radial = radial
+    )
+  }
+
+  /**
+   * `<a:pattFill>` approximated as a blend of its foreground and background colours. A faithful
+   * 8x8 tile per preset would be ~40 bit patterns for almost no visual gain at slide scale.
+   */
+  private fun parsePatternFill(p: XmlPullParser): PptFill? {
+    var fg: Int? = null
+    var bg: Int? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "fgClr" -> fg = resolveColor(parseColorContainer(p))
+          "bgClr" -> bg = resolveColor(parseColorContainer(p))
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    val f = fg ?: return bg?.let { PptFill.Solid(it) }
+    val b = bg ?: return PptFill.Solid(f)
+    fun mix(shift: Int) =
+      (((f ushr shift and 0xFF) + (b ushr shift and 0xFF)) / 2) and 0xFF
+    return PptFill.Solid(
+      (0xFF shl 24) or (mix(16) shl 16) or (mix(8) shl 8) or mix(0)
+    )
+  }
+
+  /**
+   * `<p:style>`: a shape's fill/line/text colour by reference into the theme's format scheme.
+   *
+   * Not reading this is why theme-styled shapes rendered with no fill at all and were then
+   * dropped by [parseShape]. We take each reference's own colour, which is what `idx > 0`
+   * resolves to for the overwhelming majority of real decks.
+   */
+  private fun parseShapeStyle(p: XmlPullParser): ShapeStyleRefs {
+    var fill: Int? = null
+    var line: Int? = null
+    var font: Int? = null
+    var fillIdx = 0
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "fillRef" -> {
+            fillIdx = Ox.attr(p, "idx")?.toIntOrNull() ?: 0
+            fill = resolveColor(parseColorContainer(p))
+          }
+          "lnRef" -> line = resolveColor(parseColorContainer(p))
+          "fontRef" -> font = resolveColor(parseColorContainer(p))
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    // idx 0 means "no fill" regardless of the colour carried alongside it.
+    return ShapeStyleRefs(if (fillIdx == 0) null else fill, line, font)
+  }
+
+  private fun parseTransform(p: XmlPullParser): PowerPointTransform {
+    var xPt: Float? = null
+    var yPt: Float? = null
+    var wPt: Float? = null
+    var hPt: Float? = null
+    val rotation = (Ox.attr(p, "rot")?.toFloatOrNull() ?: 0f) / 60000f
+    val flipH = Ox.attr(p, "flipH") == "1"
+    val flipV = Ox.attr(p, "flipV") == "1"
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "off" -> {
+            xPt = Ox.emuToPt(Ox.attr(p, "x"))
+            yPt = Ox.emuToPt(Ox.attr(p, "y"))
+            Ox.skip(p)
+          }
+          "ext" -> {
+            wPt = Ox.emuToPt(Ox.attr(p, "cx"))
+            hPt = Ox.emuToPt(Ox.attr(p, "cy"))
+            Ox.skip(p)
+          }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    val bounds = if (xPt != null && yPt != null && wPt != null && hPt != null) {
+      RectF(xPt!!, yPt!!, xPt!! + wPt!!, yPt!! + hPt!!)
+    } else null
+    return PowerPointTransform(bounds, rotation, flipH, flipV)
+  }
+
+  private fun parseTextBody(p: XmlPullParser): PowerPointTextBody {
+    val paragraphs = ArrayList<RawParagraph>()
+    var anchor = TextVerticalAnchor.TOP
+    var insetLeft = 4f
+    var insetTop = 2f
+    var insetRight = 4f
+    var insetBottom = 2f
+    var autofit = false
+    var fontScale = 1f
+    var lnSpcReduction = 0f
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "bodyPr" -> {
+            anchor = when (Ox.attr(p, "anchor")) {
+              "ctr" -> TextVerticalAnchor.MIDDLE
+              "b" -> TextVerticalAnchor.BOTTOM
+              else -> TextVerticalAnchor.TOP
+            }
+            Ox.emuToPt(Ox.attr(p, "lIns"))?.let { insetLeft = it }
+            Ox.emuToPt(Ox.attr(p, "tIns"))?.let { insetTop = it }
+            Ox.emuToPt(Ox.attr(p, "rIns"))?.let { insetRight = it }
+            Ox.emuToPt(Ox.attr(p, "bIns"))?.let { insetBottom = it }
+            // <a:normAutofit> is a CHILD of bodyPr - skipping the element outright (as before)
+            // threw away the shrink factor PowerPoint had already computed for this box.
+            var bd = 1
+            while (bd > 0) {
+              when (p.next()) {
+                XmlPullParser.START_TAG -> {
+                  if (Ox.local(p) == "normAutofit") {
+                    autofit = true
+                    Ox.attr(p, "fontScale")?.toFloatOrNull()?.let { fontScale = it / 100000f }
+                    Ox.attr(p, "lnSpcReduction")?.toFloatOrNull()
+                      ?.let { lnSpcReduction = it / 100000f }
+                  }
+                  Ox.skip(p)
+                }
+                XmlPullParser.END_TAG -> bd--
+                XmlPullParser.END_DOCUMENT -> bd = 0
+              }
+            }
+          }
+          "p" -> parseTextParagraph(p)?.let { paragraphs.add(it) }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return PowerPointTextBody(
+      paragraphs, anchor, insetLeft, insetTop, insetRight, insetBottom,
+      autofit, fontScale, lnSpcReduction
+    )
+  }
+
+  private fun parseTextParagraph(p: XmlPullParser): RawParagraph? {
+    val runs = ArrayList<PowerPointTextRun>()
+    var align: TextAlign? = null
+    var bullet: String? = null
+    var bulletExplicit = false
+    var level = 0
+    var marL: Float? = null
+    var indent: Float? = null
+    var lineSpacePct: Float? = null
+    var spaceBefore: Float? = null
+    var spaceAfter: Float? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "pPr" -> {
+            val props = parseParagraphProperties(p)
+            align = props.align
+            bullet = props.bullet
+            bulletExplicit = props.bulletExplicit
+            level = props.level
+            marL = props.marLPt
+            indent = props.indentPt
+            lineSpacePct = props.lineSpacePct
+            spaceBefore = props.spaceBeforePt
+            spaceAfter = props.spaceAfterPt
+          }
+          "r" -> parseTextRun(p)?.let { runs.add(it) }
+          "br" -> {
+            runs.add(PowerPointTextRun("\n"))
+            Ox.skip(p)
+          }
+          "fld" -> parseFieldText(p)?.let { if (it.isNotBlank()) runs.add(PowerPointTextRun(it)) }
+          "t" -> {
+            val text = Ox.elementText(p)
+            if (text.isNotBlank()) runs.add(PowerPointTextRun(text))
+          }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    if (runs.isEmpty() && !bulletExplicit) return null
+    return RawParagraph(
+      runs, align, bullet, bulletExplicit, level,
+      marL, indent, lineSpacePct, spaceBefore, spaceAfter
+    )
+  }
+
+  private fun parseParagraphProperties(p: XmlPullParser): PowerPointParagraphProperties {
+    val align = when (Ox.attr(p, "algn")) {
+      "ctr" -> TextAlign.CENTER
+      "r" -> TextAlign.RIGHT
+      "just" -> TextAlign.JUSTIFY
+      "l" -> TextAlign.LEFT
+      else -> null
+    }
+    val level = Ox.attr(p, "lvl")?.toIntOrNull() ?: 0
+    val marL = Ox.emuToPt(Ox.attr(p, "marL"))
+    val indent = Ox.emuToPt(Ox.attr(p, "indent"))
+    var bullet: String? = null
+    var bulletExplicit = false
+    var lineSpacePct: Float? = null
+    var spaceBefore: Float? = null
+    var spaceAfter: Float? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "buChar" -> {
+            bullet = normalizeBullet(Ox.attr(p, "char"))
+            bulletExplicit = true
+            Ox.skip(p)
+          }
+          "buAutoNum" -> {
+            bullet = autoNumberMarker(Ox.attr(p, "type"), Ox.attr(p, "startAt")?.toIntOrNull() ?: 1)
+            bulletExplicit = true
+            Ox.skip(p)
+          }
+          "buNone" -> {
+            bullet = null
+            bulletExplicit = true
+            Ox.skip(p)
+          }
+          "lnSpc" -> lineSpacePct = parseLineSpacing(p)
+          "spcBef" -> spaceBefore = parseSpacing(p)
+          "spcAft" -> spaceAfter = parseSpacing(p)
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return PowerPointParagraphProperties(
+      align, bullet, bulletExplicit, level, marL, indent, lineSpacePct, spaceBefore, spaceAfter
+    )
+  }
+
+  /**
+   * `<a:lnSpc>` -> a line-height multiple. An exact `spcPts` height is carried as a NEGATIVE
+   * value so the renderer can tell the two forms apart without a second field.
+   */
+  private fun parseLineSpacing(p: XmlPullParser): Float? {
+    var pct: Float? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> {
+          val v = Ox.attr(p, "val")?.toFloatOrNull()
+          when (Ox.local(p)) {
+            "spcPct" -> if (v != null) pct = v / 100000f
+            "spcPts" -> if (v != null) pct = -(v / 100f)
+          }
+          Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return pct
+  }
+
+  /**
+   * `<a:spcBef>`/`<a:spcAft>` -> points. A percentage form is carried NEGATIVE (as a fraction of
+   * the font size) and resolved against the paragraph's base size at layout time.
+   */
+  private fun parseSpacing(p: XmlPullParser): Float? {
+    var pts: Float? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> {
+          val v = Ox.attr(p, "val")?.toFloatOrNull()
+          when (Ox.local(p)) {
+            "spcPts" -> if (v != null) pts = v / 100f
+            "spcPct" -> if (v != null) pts = -(v / 100000f)
+          }
+          Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return pts
+  }
+
+  private fun parseTextRun(p: XmlPullParser): PowerPointTextRun? {
+    var props = PowerPointRunProperties()
+    var text = ""
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "rPr" -> props = parseRunProperties(p)
+          "t" -> text = Ox.elementText(p)
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    if (text.isEmpty()) return null
+    return PowerPointTextRun(
+      text = text,
+      fontSizePt = props.fontSizePt,
+      color = props.color,
+      fontFamily = props.fontFamily,
+      bold = props.bold,
+      italic = props.italic,
+      underline = props.underline,
+      strike = props.strike,
+      allCaps = props.allCaps
+    )
+  }
+
+  private fun parseRunProperties(p: XmlPullParser): PowerPointRunProperties {
+    val props = PowerPointRunProperties(
+      fontSizePt = Ox.attr(p, "sz")?.toFloatOrNull()?.let { it / 100f },
+      bold = Ox.attr(p, "b")?.let { it == "1" },
+      italic = Ox.attr(p, "i")?.let { it == "1" },
+      underline = Ox.attr(p, "u")?.let { it != "none" },
+      strike = Ox.attr(p, "strike")?.let { it != "noStrike" },
+      allCaps = Ox.attr(p, "cap")?.let { it == "all" }
+    )
+    var out = props
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "solidFill" -> out = out.copy(color = resolveColor(parseColorContainer(p)))
+          // `+mn-lt` / `+mj-lt` are theme font TOKENS, not literal faces. They used to be
+          // discarded outright, which threw away the deck's typography; resolve them against
+          // the theme's font scheme instead.
+          "latin", "ea", "cs" -> {
+            resolveFontToken(Ox.attr(p, "typeface")?.takeIf { it.isNotBlank() })?.let {
+              out = out.copy(fontFamily = it)
+            }
+            Ox.skip(p)
+          }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return out
+  }
+
+  private fun parseFieldText(p: XmlPullParser): String? {
+    var text: String? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> if (Ox.local(p) == "t") text = Ox.elementText(p) else Ox.skip(p)
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return text
+  }
+
+  private fun parseTable(p: XmlPullParser, transform: PowerPointTransform): PowerPointElement.Table {
+    val columns = ArrayList<Float>()
+    val rows = ArrayList<PowerPointTableRow>()
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "gridCol" -> {
+            Ox.emuToPt(Ox.attr(p, "w"))?.let { columns.add(it) }
+            Ox.skip(p)
+          }
+          "tr" -> rows.add(parseTableRow(p))
+          // Named descent: <a:gridCol> entries live inside <a:tblGrid>.
+          "tblGrid" -> depth++
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return PowerPointElement.Table(
+      bounds = transform.bounds ?: RectF(0f, 0f, DEFAULT_SLIDE_WIDTH_PT, DEFAULT_SLIDE_HEIGHT_PT),
+      rotation = transform.rotation,
+      columnsPt = columns,
+      rows = rows
+    )
+  }
+
+  private fun parseTableRow(p: XmlPullParser): PowerPointTableRow {
+    val height = Ox.emuToPt(Ox.attr(p, "h"))
+    val cells = ArrayList<PowerPointTableCell>()
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "tc" -> cells.add(parseTableCell(p))
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return PowerPointTableRow(height, cells)
+  }
+
+  private fun parseTableCell(p: XmlPullParser): PowerPointTableCell {
+    val paragraphs = ArrayList<PowerPointParagraph>()
+    var props = TableCellProps()
+    // gridSpan / hMerge / vMerge are attributes of <a:tc> ITSELF, not of <a:tcPr> — reading them
+    // off tcPr (as this did) meant every merged cell silently reverted to a span of one.
+    val gridSpan = Ox.attr(p, "gridSpan")?.toIntOrNull()?.coerceAtLeast(1) ?: 1
+    val merged = Ox.attr(p, "hMerge") == "1" || Ox.attr(p, "vMerge") == "1"
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "tcPr" -> props = parseTableCellProperties(p)
+          "p" -> parseTextParagraph(p)?.let { paragraphs.add(resolveParagraph(it, null)) }
+          // Named descent: cell paragraphs live inside <a:txBody>.
+          "txBody" -> depth++
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return PowerPointTableCell(
+      paragraphs = paragraphs,
+      fillColor = props.fillColor,
+      gridSpan = gridSpan,
+      merged = merged,
+      borderLeft = props.borderLeft,
+      borderRight = props.borderRight,
+      borderTop = props.borderTop,
+      borderBottom = props.borderBottom,
+      marginLeftPt = props.marginLeftPt,
+      marginRightPt = props.marginRightPt,
+      marginTopPt = props.marginTopPt,
+      marginBottomPt = props.marginBottomPt,
+      anchor = props.anchor
+    )
+  }
+
+  /**
+   * `<a:tcPr>`: cell fill, per-edge borders, insets and vertical anchor.
+   *
+   * Only the fill was read before, so every table drew the same hardcoded grey grid regardless of
+   * what the deck specified, with fixed insets and top-anchored text.
+   */
+  private fun parseTableCellProperties(p: XmlPullParser): TableCellProps {
+    var fill: Int? = null
+    var left: PowerPointStroke? = null
+    var right: PowerPointStroke? = null
+    var top: PowerPointStroke? = null
+    var bottom: PowerPointStroke? = null
+    val marL = Ox.emuToPt(Ox.attr(p, "marL")) ?: 7.2f
+    val marR = Ox.emuToPt(Ox.attr(p, "marR")) ?: 7.2f
+    val marT = Ox.emuToPt(Ox.attr(p, "marT")) ?: 3.6f
+    val marB = Ox.emuToPt(Ox.attr(p, "marB")) ?: 3.6f
+    val anchor = when (Ox.attr(p, "anchor")) {
+      "ctr" -> TextVerticalAnchor.MIDDLE
+      "b" -> TextVerticalAnchor.BOTTOM
+      else -> TextVerticalAnchor.TOP
+    }
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          // Edge borders are consumed by parseLine, so the remaining top-level solidFill below
+          // is unambiguously the CELL fill rather than a border colour.
+          "lnL" -> left = parseLine(p)
+          "lnR" -> right = parseLine(p)
+          "lnT" -> top = parseLine(p)
+          "lnB" -> bottom = parseLine(p)
+          "solidFill" -> fill = resolveColor(parseColorContainer(p))
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return TableCellProps(fill, left, right, top, bottom, marL, marR, marT, marB, anchor)
+  }
+
+  private fun parseLine(p: XmlPullParser): PowerPointStroke? {
+    var color: Int? = null
+    val widthPt = Ox.emuToPt(Ox.attr(p, "w")) ?: 1f
+    var noFill = false
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "solidFill" -> color = resolveColor(parseColorContainer(p))
+          "noFill" -> {
+            noFill = true
+            Ox.skip(p)
+          }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    if (noFill) return null
+    // An <a:ln> that only sets a width or a dash pattern takes its COLOUR from the shape's
+    // <a:lnRef>. Defaulting to black here drew a hard black box around such shapes; returning
+    // null lets parseShape supply the theme colour instead.
+    val c = color ?: return null
+    return PowerPointStroke(c, widthPt.coerceAtLeast(0.5f))
+  }
+
+  private fun parseBlipFill(p: XmlPullParser, rels: Map<String, String>): Bitmap? {
+    var bitmap: Bitmap? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "blip" -> {
+            Ox.attr(p, "embed")?.let { relId -> bitmap = loadBitmap(rels[relId] ?: "") }
+            Ox.skip(p)
+          }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return bitmap
+  }
+
+  /**
+   * The first colour choice nested anywhere inside the current element. Shared by every wrapper
+   * that holds exactly one colour: `<a:solidFill>`, `<a:buClr>`, `<a:fgClr>`, a `<p:style>`
+   * reference, and a theme slot such as `<a:dk1>`.
+   */
+  private fun parseColorContainer(p: XmlPullParser): ColorSpec? {
+    var color: ColorSpec? = null
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "srgbClr", "schemeClr", "sysClr", "prstClr" -> color = parseColorChoice(p)
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return color
+  }
+
+  /**
+   * Parses one colour-choice element into an UNRESOLVED [ColorSpec], preserving its child
+   * transforms in document order (they are not commutative). Resolution against the theme /
+   * clrMap / phClr happens later, via [resolveColor].
+   */
+  private fun parseColorChoice(p: XmlPullParser): ColorSpec? {
+    val base: ColorBase? = when (Ox.local(p)) {
+      "srgbClr" -> colorFromHex(Ox.attr(p, "val"))?.let { ColorBase.Literal(it) }
+      "schemeClr" -> Ox.attr(p, "val")?.let {
+        if (it == "phClr") ColorBase.Placeholder else ColorBase.Scheme(it)
+      }
+      "sysClr" -> colorFromHex(Ox.attr(p, "lastClr"))?.let { ColorBase.Literal(it) }
+      "prstClr" -> presetColor(Ox.attr(p, "val"))?.let { ColorBase.Literal(it) }
+      else -> null
+    }
+    val transforms = ArrayList<ColorXf>(4)
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> {
+          // All of these carry a percentage in thousandths of a percent.
+          val pct = Ox.attr(p, "val")?.toFloatOrNull()?.div(100000f)
+          if (pct != null) {
+            when (Ox.local(p)) {
+              "tint" -> transforms.add(ColorXf.Tint(pct))
+              "shade" -> transforms.add(ColorXf.Shade(pct))
+              "lumMod" -> transforms.add(ColorXf.LumMod(pct))
+              "lumOff" -> transforms.add(ColorXf.LumOff(pct))
+              "satMod" -> transforms.add(ColorXf.SatMod(pct))
+              "alpha" -> transforms.add(ColorXf.Alpha(pct))
+            }
+          }
+          Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> break
+      }
+    }
+    return base?.let { ColorSpec(it, transforms) }
+  }
+
+  /** Flattens a parsed spec against this deck's theme palette and colour map. */
+  private fun resolveColor(spec: ColorSpec?): Int? =
+    spec?.let { PptColor.resolve(it, colorContext) }
+
+  /**
+   * Decodes an image part, memoised by path. Without the cache a logo on the slide master was
+   * decoded once per slide — 40x the memory and 40x the image budget on a 40-slide deck, which
+   * matters now that layout/master graphics are drawn at all.
+   */
+  private fun loadBitmap(path: String): Bitmap? {
+    if (path.isBlank()) return null
+    imageCache[path]?.let { return it }
+    val mime = Ox.mimeForName(path)
+    if (mime == "image/x-emf" || mime == "image/svg+xml" || mime == "application/octet-stream") return null
+    if (imageBudget <= 0) return null
+    val bytes = Ox.zipBytes(zip, path, minOf(Ox.MAX_IMAGE_BYTES, imageBudget)) ?: return null
+    val bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size) ?: return null
+    imageBudget -= bytes.size
+    imageCache[path] = bitmap
+    return bitmap
+  }
+
+  /**
+   * Reads the theme part's colour scheme and major/minor latin typefaces into [colorContext],
+   * [majorLatinFont] and [minorLatinFont].
+   *
+   * Bounded to the FIRST `<a:clrScheme>` deliberately: many Office themes append an
+   * `<a:extraClrSchemeLst>` holding further complete schemes, and the previous flat scan ran to
+   * the end of the document and let those silently overwrite the real palette.
+   */
+  private fun parseTheme(z: ZipFile, themePart: String) {
+    val colors = HashMap(DEFAULT_SCHEME_COLORS)
+    var seenScheme = false
+    try {
+      Ox.zipStream(z, themePart)?.use { stream ->
+        val p = Ox.parser(stream)
+        while (p.next() != XmlPullParser.END_DOCUMENT) {
+          if (p.eventType != XmlPullParser.START_TAG) continue
+          when (Ox.local(p)) {
+            "clrScheme" -> if (seenScheme) Ox.skip(p) else {
+              parseClrScheme(p, colors)
+              seenScheme = true
+            }
+            "fontScheme" -> parseFontScheme(p)
+            // Everything after themeElements can restate a full scheme — never let it through.
+            "extraClrSchemeLst", "objectDefaults", "custClrLst" -> Ox.skip(p)
+          }
+        }
+      }
+    } catch (_: Throwable) { /* Keep whatever resolved before the failure. */ }
+    schemeColors = colors
+    refreshColorContext()
+  }
+
+  /** `<a:clrScheme>`: one child element per slot, each wrapping a single colour choice. */
+  private fun parseClrScheme(p: XmlPullParser, out: MutableMap<String, Int>) {
+    // Slots hold literal srgbClr/sysClr values, so a literals-only context is enough here.
+    val literals = ColorContext(emptyMap(), emptyMap())
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> {
+          val slot = Ox.local(p)
+          if (slot in THEME_COLOR_KEYS) {
+            parseColorContainer(p)?.let { out[slot] = PptColor.resolve(it, literals) }
+          } else {
+            Ox.skip(p)
+          }
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> return
+      }
+    }
+  }
+
+  /** `<a:fontScheme>` → the typefaces that `+mj-lt` / `+mn-lt` run tokens resolve to. */
+  private fun parseFontScheme(p: XmlPullParser) {
+    var inMajor = false
+    var depth = 1
+    while (depth > 0) {
+      when (p.next()) {
+        XmlPullParser.START_TAG -> when (Ox.local(p)) {
+          "majorFont" -> inMajor = true
+          "minorFont" -> inMajor = false
+          "latin" -> {
+            val face = Ox.attr(p, "typeface")?.takeIf { it.isNotBlank() }
+            if (face != null) {
+              if (inMajor) majorLatinFont = face else minorLatinFont = face
+            }
+            Ox.skip(p)
+          }
+          else -> Ox.skip(p)
+        }
+        XmlPullParser.END_TAG -> depth--
+        XmlPullParser.END_DOCUMENT -> return
+      }
+    }
+  }
+
+  /** Resolves a run's authored typeface, expanding the theme font tokens. */
+  private fun resolveFontToken(name: String?): String? = when (name) {
+    null -> null
+    "+mj-lt", "+mj-ea", "+mj-cs" -> majorLatinFont
+    "+mn-lt", "+mn-ea", "+mn-cs" -> minorLatinFont
+    else -> name
+  }
+}
+
+private class PptPresentationExtractor : PowerPointPresentationExtractor {
+  override fun extract(file: File): RawPowerPointPresentation {
+    val bytes = file.readBytes()
+    val pptStream = try {
+      CompoundBinaryFile(bytes).stream("PowerPoint Document") ?: bytes
+    } catch (_: Throwable) {
+      bytes
+    }
+    val slides = parseSlideTextRecords(pptStream)
+    val images = extractEmbeddedBitmaps(bytes)
+    val rawSlides = if (slides.isNotEmpty()) {
+      slides.mapIndexed { index, text ->
+        RawPowerPointSlide(
+          textRuns = text,
+          images = images.getOrNull(index)?.let { listOf(it) } ?: emptyList()
+        )
+      }
+    } else {
+      val text = extractBinaryTextRuns(pptStream).take(12)
+      listOf(RawPowerPointSlide(textRuns = text, images = images.take(3)))
+    }
+    return RawPowerPointPresentation(
+      sourceName = file.name,
+      widthPt = DEFAULT_SLIDE_WIDTH_PT,
+      heightPt = DEFAULT_SLIDE_HEIGHT_PT,
+      slides = rawSlides,
+      // ALL decoded bitmaps, not just the few the formatter positions — the rest used to leak.
+      ownedBitmaps = images
+    )
+  }
+
+  private fun parseSlideTextRecords(stream: ByteArray): List<List<String>> {
+    val out = ArrayList<List<String>>()
+    fun scan(start: Int, end: Int, inSlide: Boolean, bucket: MutableList<String>?) {
+      var pos = start
+      while (pos + 8 <= end && pos + 8 <= stream.size) {
+        val verInstance = leUShort(stream, pos)
+        val recVer = verInstance and 0x000F
+        val recType = leUShort(stream, pos + 2)
+        val len = leInt(stream, pos + 4)
+        if (len < 0) return
+        val dataStart = pos + 8
+        val dataEnd = dataStart + len
+        if (dataEnd > end || dataEnd > stream.size) return
+        if (recType == PPT_RECORD_SLIDE_CONTAINER) {
+          val slideTexts = ArrayList<String>()
+          scan(dataStart, dataEnd, true, slideTexts)
+          val cleaned = slideTexts.map { cleanText(it) }.filter { it.length > 1 }.distinct()
+          if (cleaned.isNotEmpty()) out.add(cleaned)
+        } else if (recType == PPT_RECORD_TEXT_CHARS || recType == PPT_RECORD_CSTRING) {
+          if (inSlide) bucket?.add(decodeUtf16Le(stream, dataStart, len))
+        } else if (recType == PPT_RECORD_TEXT_BYTES) {
+          if (inSlide) bucket?.add(decodeCp1252(stream, dataStart, len))
+        } else if (recVer == 0x0F) {
+          scan(dataStart, dataEnd, inSlide, bucket)
+        }
+        pos = dataEnd
+      }
+    }
+    scan(0, stream.size, false, null)
+    return out
+  }
+
+  private fun extractEmbeddedBitmaps(bytes: ByteArray): List<Bitmap> {
+    val out = ArrayList<Bitmap>()
+    val seen = HashSet<Int>()
+    fun addBitmap(start: Int, end: Int) {
+      if (out.size >= 12 || start < 0 || end <= start || end > bytes.size) return
+      val size = end - start
+      if (size < 64 || size > Ox.MAX_IMAGE_BYTES) return
+      val hash = size * 31 + start
+      if (!seen.add(hash)) return
+      val bitmap = BitmapFactory.decodeByteArray(bytes, start, size)
+      if (bitmap != null && bitmap.width > 8 && bitmap.height > 8) out.add(bitmap)
+    }
+    var i = 0
+    while (i < bytes.size - 16) {
+      if (matches(bytes, i, PNG_SIG)) {
+        val end = findPngEnd(bytes, i)
+        if (end > i) addBitmap(i, end)
+        i = max(i + 1, end)
+      } else if ((bytes[i].toInt() and 0xFF) == 0xFF && (bytes[i + 1].toInt() and 0xFF) == 0xD8) {
+        val end = findJpegEnd(bytes, i)
+        if (end > i) addBitmap(i, end)
+        i = max(i + 1, end)
+      } else if (matches(bytes, i, GIF87_SIG) || matches(bytes, i, GIF89_SIG)) {
+        val end = findGifEnd(bytes, i)
+        if (end > i) addBitmap(i, end)
+        i = max(i + 1, end)
+      } else if (bytes[i] == 'B'.code.toByte() && bytes[i + 1] == 'M'.code.toByte()) {
+        val size = leInt(bytes, i + 2)
+        if (size > 0) addBitmap(i, min(bytes.size, i + size))
+        i++
+      } else {
+        i++
+      }
+    }
+    return out
+  }
+}
+
+internal class PowerPointPreviewAdapter(
+  private val context: Context,
+  private val presentation: PowerPointPresentation,
+  private val renderWidthProvider: () -> Int
+) : RecyclerView.Adapter<PowerPointPreviewAdapter.Holder>() {
+  inner class Holder(val slideView: PowerPointSlideView) : RecyclerView.ViewHolder(slideView)
+
+  override fun getItemCount(): Int = presentation.slides.size
+
+  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): Holder {
+    val view = PowerPointSlideView(parent.context)
+    view.setPresentation(presentation)
+    return Holder(view)
+  }
+
+  override fun onBindViewHolder(holder: Holder, position: Int) {
+    val width = renderWidthProvider().coerceAtLeast(240)
+    val height = ceil(width * presentation.heightPt / presentation.widthPt).toInt().coerceAtLeast(1)
+    val lp = RecyclerView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, height)
+    lp.bottomMargin = if (position == presentation.slides.size - 1) 0 else dp(6)
+    holder.slideView.layoutParams = lp
+    holder.slideView.setSlide(presentation.slides[position])
+  }
+
+  private fun dp(value: Int): Int = (value * context.resources.displayMetrics.density).toInt()
+}
+
+internal class PowerPointSlideView(context: Context) : View(context) {
+  private val fillPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+  private val strokePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.STROKE }
+  private val imagePaint = Paint(Paint.ANTI_ALIAS_FLAG or Paint.FILTER_BITMAP_FLAG)
+  // Reused across draws: allocating a Matrix per element per frame would be a per-frame cost in
+  // a scrolling RecyclerView.
+  private val elementMatrix = android.graphics.Matrix()
+  private val gradientMatrix = android.graphics.Matrix()
+  /** Reused for table-cell bullet glyphs; free text boxes build theirs during measurement. */
+  private val bulletPaint = TextPaint(Paint.ANTI_ALIAS_FLAG)
+  private val shapePath = android.graphics.Path()
+  private val customMatrix = android.graphics.Matrix()
+  private val scratchOval = RectF()
+  private val matrixValues = FloatArray(9)
+  private val srcRectPx = android.graphics.Rect()
+  private val slideRect = RectF()
+  private var presentation: PowerPointPresentation? = null
+  private var slide: PowerPointSlide? = null
+
+  init {
+    setBackgroundColor(Color.TRANSPARENT)
+  }
+
+  fun setPresentation(value: PowerPointPresentation) {
+    presentation = value
+  }
+
+  fun setSlide(value: PowerPointSlide) {
+    slide = value
+    invalidate()
+  }
+
+  override fun onDraw(canvas: Canvas) {
+    super.onDraw(canvas)
+    val deck = presentation ?: return
+    val currentSlide = slide ?: return
+    val scale = min(width / deck.widthPt, height / deck.heightPt)
+    val slideW = deck.widthPt * scale
+    val slideH = deck.heightPt * scale
+    val left = (width - slideW) / 2f
+    val top = (height - slideH) / 2f
+    canvas.save()
+    canvas.translate(left, top)
+    canvas.clipRect(0f, 0f, slideW, slideH)
+    drawBackground(canvas, currentSlide.background, slideW, slideH)
+    for (element in currentSlide.elements) drawElement(canvas, element, scale)
+    canvas.restore()
+  }
+
+  private fun drawBackground(canvas: Canvas, background: PptFill, slideW: Float, slideH: Float) {
+    slideRect.set(0f, 0f, slideW, slideH)
+    if (applyFill(background, slideRect)) {
+      canvas.drawRect(slideRect, fillPaint)
+      clearFill()
+    }
+    if (background is PptFill.Image && !background.bitmap.isRecycled) {
+      canvas.drawBitmap(background.bitmap, null, slideRect, imagePaint)
+    }
+  }
+
+  private fun drawElement(canvas: Canvas, element: PowerPointElement, scale: Float) {
+    canvas.save()
+    // Group transform, applied in POINT space between the slide scale and the element's own
+    // geometry. Without this, shapes inside a <p:grpSp> were drawn at their raw child-space
+    // coordinates, which is what put them on top of unrelated content.
+    val parent = element.parent
+    if (!parent.isIdentity()) {
+      canvas.scale(scale, scale)
+      parent.toMatrixValues(matrixValues)
+      elementMatrix.setValues(matrixValues)
+      canvas.concat(elementMatrix)
+      canvas.scale(1f / scale, 1f / scale)
+    }
+    val rect = scaleRect(element.bounds, scale)
+    if (element.rotation != 0f) canvas.rotate(element.rotation, rect.centerX(), rect.centerY())
+    if (element.flipH || element.flipV) {
+      canvas.scale(
+        if (element.flipH) -1f else 1f,
+        if (element.flipV) -1f else 1f,
+        rect.centerX(),
+        rect.centerY()
+      )
+    }
+    when (element) {
+      is PowerPointElement.Shape -> drawShape(canvas, element, rect, scale)
+      is PowerPointElement.Picture -> drawPicture(canvas, element, rect)
+      is PowerPointElement.TextBox -> drawTextBox(canvas, element, rect, scale)
+      is PowerPointElement.Table -> drawTable(canvas, element, rect, scale)
+    }
+    canvas.restore()
+  }
+
+  private fun drawShape(canvas: Canvas, shape: PowerPointElement.Shape, rect: RectF, scale: Float) {
+    if (applyFill(shape.fill, rect)) {
+      drawShapePath(canvas, shape.type, rect, fillPaint, shape.customPath)
+      clearFill()
+    }
+    shape.stroke?.let {
+      strokePaint.color = it.color
+      strokePaint.strokeWidth = max(1f, it.widthPt * scale)
+      strokePaint.style = Paint.Style.STROKE
+      drawShapePath(canvas, shape.type, rect, strokePaint, shape.customPath)
+    }
+  }
+
+  /**
+   * Configures [fillPaint] for [fill] over [rect], returning false when there is nothing to draw.
+   * Gradient shaders are cached on the fill and only rebuilt when the box size changes, so a
+   * scrolling deck doesn't allocate one per frame.
+   */
+  private fun applyFill(fill: PptFill?, rect: RectF): Boolean {
+    fillPaint.style = Paint.Style.FILL
+    fillPaint.shader = null
+    when (fill) {
+      null -> return false
+      is PptFill.Solid -> {
+        if (Color.alpha(fill.color) == 0) return false
+        fillPaint.color = fill.color
+      }
+      is PptFill.Image -> {
+        fillPaint.color = fill.fallbackColor
+      }
+      is PptFill.Gradient -> {
+        val w = rect.width()
+        val h = rect.height()
+        if (w <= 0f || h <= 0f) return false
+        var shader = fill.cachedShader
+        if (shader == null || fill.cachedW != w || fill.cachedH != h) {
+          shader = buildGradientShader(fill, w, h)
+          fill.cachedShader = shader
+          fill.cachedW = w
+          fill.cachedH = h
+        }
+        // The shader is built in the fill's own 0..w/0..h space, so shift it onto the element.
+        gradientMatrix.setTranslate(rect.left, rect.top)
+        shader.setLocalMatrix(gradientMatrix)
+        fillPaint.color = Color.BLACK
+        fillPaint.shader = shader
+      }
+    }
+    return true
+  }
+
+  private fun clearFill() {
+    fillPaint.shader = null
+  }
+
+  private fun buildGradientShader(
+    fill: PptFill.Gradient,
+    w: Float,
+    h: Float
+  ): android.graphics.Shader {
+    if (fill.radial) {
+      return android.graphics.RadialGradient(
+        w / 2f, h / 2f, max(w, h) / 2f,
+        fill.colors, fill.stops, android.graphics.Shader.TileMode.CLAMP
+      )
+    }
+    // <a:lin ang> is clockwise from the +x axis in a y-down space.
+    val rad = Math.toRadians(fill.angleDeg.toDouble())
+    val dx = kotlin.math.cos(rad).toFloat()
+    val dy = kotlin.math.sin(rad).toFloat()
+    // Project the box onto the gradient axis so the ramp spans the whole shape.
+    val half = (kotlin.math.abs(dx) * w + kotlin.math.abs(dy) * h) / 2f
+    val cx = w / 2f
+    val cy = h / 2f
+    return android.graphics.LinearGradient(
+      cx - dx * half, cy - dy * half,
+      cx + dx * half, cy + dy * half,
+      fill.colors, fill.stops, android.graphics.Shader.TileMode.CLAMP
+    )
+  }
+
+  /**
+   * Draws [type] (or [custom], when the shape carried a `<a:custGeom>`) filling [rect].
+   *
+   * Uses one reusable [shapePath] rather than allocating per call: this runs for every shape of
+   * every visible slide, on every frame of a scroll.
+   */
+  private fun drawShapePath(
+    canvas: Canvas,
+    type: PowerPointShapeType,
+    rect: RectF,
+    paint: Paint,
+    custom: android.graphics.Path? = null
+  ) {
+    // A custom geometry is stored normalised to 0..1 so one Path serves every size it is drawn at.
+    if (custom != null) {
+      shapePath.reset()
+      customMatrix.setScale(rect.width(), rect.height())
+      customMatrix.postTranslate(rect.left, rect.top)
+      custom.transform(customMatrix, shapePath)
+      canvas.drawPath(shapePath, paint)
+      return
+    }
+    when (type) {
+      PowerPointShapeType.RECT -> canvas.drawRect(rect, paint)
+      PowerPointShapeType.ELLIPSE -> canvas.drawOval(rect, paint)
+      PowerPointShapeType.LINE ->
+        canvas.drawLine(rect.left, rect.top, rect.right, rect.bottom, paint)
+      PowerPointShapeType.ROUND_RECT ->
+        canvas.drawRoundRect(rect, rect.width() * 0.08f, rect.height() * 0.08f, paint)
+      else -> {
+        buildPresetPath(type, rect, shapePath)
+        canvas.drawPath(shapePath, paint)
+      }
+    }
+  }
+
+  private fun buildPresetPath(type: PowerPointShapeType, r: RectF, out: android.graphics.Path) {
+    out.reset()
+    out.fillType = android.graphics.Path.FillType.WINDING
+    val w = r.width()
+    val h = r.height()
+    val cx = r.centerX()
+    val cy = r.centerY()
+    when (type) {
+      PowerPointShapeType.TRIANGLE -> poly(out, cx, r.top, r.right, r.bottom, r.left, r.bottom)
+      PowerPointShapeType.RIGHT_TRIANGLE ->
+        poly(out, r.left, r.top, r.right, r.bottom, r.left, r.bottom)
+      PowerPointShapeType.DIAMOND ->
+        poly(out, cx, r.top, r.right, cy, cx, r.bottom, r.left, cy)
+      PowerPointShapeType.PARALLELOGRAM -> {
+        val d = w * 0.25f
+        poly(out, r.left + d, r.top, r.right, r.top, r.right - d, r.bottom, r.left, r.bottom)
+      }
+      PowerPointShapeType.TRAPEZOID -> {
+        val d = w * 0.25f
+        poly(out, r.left + d, r.top, r.right - d, r.top, r.right, r.bottom, r.left, r.bottom)
+      }
+      PowerPointShapeType.PENTAGON -> regularPolygon(out, r, 5)
+      PowerPointShapeType.HEXAGON -> regularPolygon(out, r, 6)
+      PowerPointShapeType.OCTAGON -> regularPolygon(out, r, 8)
+      PowerPointShapeType.STAR4 -> star(out, r, 4, 0.36f)
+      PowerPointShapeType.STAR5 -> star(out, r, 5, 0.382f)
+      PowerPointShapeType.STAR6 -> star(out, r, 6, 0.577f)
+      PowerPointShapeType.STAR8 -> star(out, r, 8, 0.707f)
+      PowerPointShapeType.STAR12 -> star(out, r, 12, 0.79f)
+      PowerPointShapeType.STAR16 -> star(out, r, 16, 0.84f)
+      PowerPointShapeType.STAR24 -> star(out, r, 24, 0.89f)
+      PowerPointShapeType.STAR32 -> star(out, r, 32, 0.92f)
+      PowerPointShapeType.ARROW_RIGHT -> {
+        val head = min(w, h).coerceAtMost(w) * 0.5f
+        val bh = h * 0.25f
+        val x = r.right - head
+        poly(
+          out, r.left, cy - bh, x, cy - bh, x, r.top, r.right, cy,
+          x, r.bottom, x, cy + bh, r.left, cy + bh
+        )
+      }
+      PowerPointShapeType.ARROW_LEFT -> {
+        val head = min(w, h).coerceAtMost(w) * 0.5f
+        val bh = h * 0.25f
+        val x = r.left + head
+        poly(
+          out, r.right, cy - bh, x, cy - bh, x, r.top, r.left, cy,
+          x, r.bottom, x, cy + bh, r.right, cy + bh
+        )
+      }
+      PowerPointShapeType.ARROW_UP -> {
+        val head = min(w, h).coerceAtMost(h) * 0.5f
+        val bw = w * 0.25f
+        val y = r.top + head
+        poly(
+          out, cx - bw, r.bottom, cx - bw, y, r.left, y, cx, r.top,
+          r.right, y, cx + bw, y, cx + bw, r.bottom
+        )
+      }
+      PowerPointShapeType.ARROW_DOWN -> {
+        val head = min(w, h).coerceAtMost(h) * 0.5f
+        val bw = w * 0.25f
+        val y = r.bottom - head
+        poly(
+          out, cx - bw, r.top, cx - bw, y, r.left, y, cx, r.bottom,
+          r.right, y, cx + bw, y, cx + bw, r.top
+        )
+      }
+      PowerPointShapeType.ARROW_LEFT_RIGHT -> {
+        val head = (w * 0.25f).coerceAtMost(min(w, h) * 0.5f)
+        val bh = h * 0.25f
+        val x0 = r.left + head
+        val x1 = r.right - head
+        poly(
+          out, r.left, cy, x0, r.top, x0, cy - bh, x1, cy - bh, x1, r.top,
+          r.right, cy, x1, r.bottom, x1, cy + bh, x0, cy + bh, x0, r.bottom
+        )
+      }
+      PowerPointShapeType.ARROW_UP_DOWN -> {
+        val head = (h * 0.25f).coerceAtMost(min(w, h) * 0.5f)
+        val bw = w * 0.25f
+        val y0 = r.top + head
+        val y1 = r.bottom - head
+        poly(
+          out, cx, r.top, r.right, y0, cx + bw, y0, cx + bw, y1, r.right, y1,
+          cx, r.bottom, r.left, y1, cx - bw, y1, cx - bw, y0, r.left, y0
+        )
+      }
+      PowerPointShapeType.HOME_PLATE -> {
+        val d = min(w, h) * 0.5f
+        poly(out, r.left, r.top, r.right - d, r.top, r.right, cy, r.right - d, r.bottom, r.left, r.bottom)
+      }
+      PowerPointShapeType.CHEVRON -> {
+        val d = min(w, h) * 0.5f
+        poly(
+          out, r.left, r.top, r.right - d, r.top, r.right, cy,
+          r.right - d, r.bottom, r.left, r.bottom, r.left + d, cy
+        )
+      }
+      PowerPointShapeType.PLUS -> {
+        val ax = w * 0.25f
+        val ay = h * 0.25f
+        poly(
+          out, r.left + ax, r.top, r.right - ax, r.top, r.right - ax, r.top + ay,
+          r.right, r.top + ay, r.right, r.bottom - ay, r.right - ax, r.bottom - ay,
+          r.right - ax, r.bottom, r.left + ax, r.bottom, r.left + ax, r.bottom - ay,
+          r.left, r.bottom - ay, r.left, r.top + ay, r.left + ax, r.top + ay
+        )
+      }
+      PowerPointShapeType.CAN -> {
+        val ry = h * 0.12f
+        scratchOval.set(r.left, r.top, r.right, r.top + 2f * ry)
+        out.moveTo(r.left, r.top + ry)
+        out.arcTo(scratchOval, 180f, 180f)
+        out.lineTo(r.right, r.bottom - ry)
+        scratchOval.set(r.left, r.bottom - 2f * ry, r.right, r.bottom)
+        out.arcTo(scratchOval, 0f, 180f)
+        out.close()
+      }
+      PowerPointShapeType.DONUT -> {
+        // EVEN_ODD punches the inner oval out of the outer one.
+        out.fillType = android.graphics.Path.FillType.EVEN_ODD
+        out.addOval(r, android.graphics.Path.Direction.CW)
+        scratchOval.set(r.left + w * 0.2f, r.top + h * 0.2f, r.right - w * 0.2f, r.bottom - h * 0.2f)
+        out.addOval(scratchOval, android.graphics.Path.Direction.CW)
+      }
+      PowerPointShapeType.FRAME -> {
+        out.fillType = android.graphics.Path.FillType.EVEN_ODD
+        out.addRect(r, android.graphics.Path.Direction.CW)
+        scratchOval.set(r.left + w * 0.125f, r.top + h * 0.125f, r.right - w * 0.125f, r.bottom - h * 0.125f)
+        out.addRect(scratchOval, android.graphics.Path.Direction.CW)
+      }
+      else -> out.addRect(r, android.graphics.Path.Direction.CW)
+    }
+  }
+
+  /** Closed polygon through the supplied x,y pairs. */
+  private fun poly(out: android.graphics.Path, vararg xy: Float) {
+    if (xy.size < 4) return
+    out.moveTo(xy[0], xy[1])
+    var i = 2
+    while (i + 1 < xy.size) {
+      out.lineTo(xy[i], xy[i + 1])
+      i += 2
+    }
+    out.close()
+  }
+
+  /** Regular n-gon inscribed in [r], first vertex at the top. */
+  private fun regularPolygon(out: android.graphics.Path, r: RectF, sides: Int) {
+    val rx = r.width() / 2f
+    val ry = r.height() / 2f
+    for (i in 0 until sides) {
+      val a = -Math.PI / 2.0 + 2.0 * Math.PI * i / sides
+      val x = r.centerX() + rx * kotlin.math.cos(a).toFloat()
+      val y = r.centerY() + ry * kotlin.math.sin(a).toFloat()
+      if (i == 0) out.moveTo(x, y) else out.lineTo(x, y)
+    }
+    out.close()
+  }
+
+  /** n-pointed star; [innerRatio] is the valley radius as a fraction of the point radius. */
+  private fun star(out: android.graphics.Path, r: RectF, points: Int, innerRatio: Float) {
+    val rx = r.width() / 2f
+    val ry = r.height() / 2f
+    for (i in 0 until points * 2) {
+      val ratio = if (i % 2 == 0) 1f else innerRatio
+      val a = -Math.PI / 2.0 + Math.PI * i / points
+      val x = r.centerX() + rx * ratio * kotlin.math.cos(a).toFloat()
+      val y = r.centerY() + ry * ratio * kotlin.math.sin(a).toFloat()
+      if (i == 0) out.moveTo(x, y) else out.lineTo(x, y)
+    }
+    out.close()
+  }
+
+  private fun drawPicture(canvas: Canvas, picture: PowerPointElement.Picture, rect: RectF) {
+    val bitmap = picture.bitmap
+    if (bitmap.isRecycled) return
+    val crop = picture.srcRect
+    if (crop == null) {
+      canvas.drawBitmap(bitmap, null, rect, imagePaint)
+      return
+    }
+    // <a:srcRect> insets are fractions of the source, so the visible window is what remains
+    // after trimming each edge.
+    val left = (bitmap.width * crop.left).toInt().coerceIn(0, bitmap.width)
+    val top = (bitmap.height * crop.top).toInt().coerceIn(0, bitmap.height)
+    val right = (bitmap.width * (1f - crop.right)).toInt().coerceIn(left + 1, bitmap.width)
+    val bottom = (bitmap.height * (1f - crop.bottom)).toInt().coerceIn(top + 1, bitmap.height)
+    srcRectPx.set(left, top, right, bottom)
+    canvas.drawBitmap(bitmap, srcRectPx, rect, imagePaint)
+  }
+
+  private fun drawTextBox(canvas: Canvas, box: PowerPointElement.TextBox, rect: RectF, scale: Float) {
+    // Use the shape's real geometry, not an unconditional rectangle: a rounded callout or an
+    // ellipse used to get a hard rectangular fill behind its text.
+    if (applyFill(box.fill, rect)) {
+      drawShapePath(canvas, box.shapeType, rect, fillPaint, box.customPath)
+      clearFill()
+    }
+    box.stroke?.let {
+      strokePaint.color = it.color
+      strokePaint.strokeWidth = max(1f, it.widthPt * scale)
+      canvas.drawRect(rect, strokePaint)
+    }
+    val content = RectF(
+      rect.left + box.insetLeftPt * scale,
+      rect.top + box.insetTopPt * scale,
+      rect.right - box.insetRightPt * scale,
+      rect.bottom - box.insetBottomPt * scale
+    )
+    if (content.width() <= 1f || content.height() <= 1f) return
+
+    // Autofit. PowerPoint records the shrink it computed, so honour that rather than recomputing.
+    // When <a:normAutofit> is present but carries no fontScale (hand-written XML, some
+    // third-party producers), fall back to a bounded search so the text still fits.
+    var shrink = if (box.autofit) box.fontScale.coerceIn(0.1f, 1f) else 1f
+    var measured = measureParagraphs(box, content, scale, shrink)
+    if (box.autofit) {
+      var guard = 0
+      while (measured.second > content.height() && shrink > 0.25f && guard < 12) {
+        shrink *= 0.92f
+        measured = measureParagraphs(box, content, scale, shrink)
+        guard++
+      }
+    }
+    val (blocks, totalHeight) = measured
+
+    var y = when (box.verticalAnchor) {
+      TextVerticalAnchor.MIDDLE -> content.top + (content.height() - totalHeight) / 2f
+      TextVerticalAnchor.BOTTOM -> content.bottom - totalHeight
+      else -> content.top
+    }
+
+    // NO clip and no early break: PowerPoint lets text overflow its box, and clipping silently
+    // hid content. Overflow is still bounded by the slide-level clip in onDraw.
+    for (block in blocks) {
+      y += block.spaceBeforePx
+      canvas.save()
+      canvas.translate(content.left + block.textLeftPx, y)
+      block.layout.draw(canvas)
+      canvas.restore()
+      // The bullet is drawn separately at the hanging-indent position so that every WRAPPED
+      // line of the paragraph still aligns at marL - which prepending the glyph to the text
+      // (the old approach) could never achieve.
+      block.bullet?.let { glyph ->
+        canvas.drawText(
+          glyph.text,
+          content.left + glyph.xPx,
+          y + block.layout.getLineBaseline(0),
+          glyph.paint
+        )
+      }
+      y += block.layout.height + block.spaceAfterPx
+    }
+  }
+
+  /** One laid-out paragraph plus everything the draw pass needs to place it. */
+  private class TextBlock(
+    val layout: StaticLayout,
+    val textLeftPx: Float,
+    val spaceBeforePx: Float,
+    val spaceAfterPx: Float,
+    val bullet: BulletGlyph?
+  )
+
+  private class BulletGlyph(val text: String, val xPx: Float, val paint: TextPaint)
+
+  /**
+   * Lays out every paragraph of [box] at [shrink] and returns the blocks plus their total height.
+   */
+  private fun measureParagraphs(
+    box: PowerPointElement.TextBox,
+    content: RectF,
+    scale: Float,
+    shrink: Float
+  ): Pair<List<TextBlock>, Float> {
+    val blocks = ArrayList<TextBlock>(box.paragraphs.size)
+    var total = 0f
+    for (paragraph in box.paragraphs) {
+      val marLPx = paragraph.marLPt * scale
+      val indentPx = paragraph.indentPt * scale
+      val width = (content.width() - marLPx).coerceAtLeast(1f)
+      val layout = buildParagraphLayout(paragraph, width.toInt(), scale, shrink, box.lnSpcReduction)
+      val bullet = paragraph.bullet?.let { glyph ->
+        val paint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply {
+          color = paragraph.baseColor
+          textSize = max(1f, paragraph.baseSizePt * scale * shrink)
+          typeface = typefaceFor(paragraph.baseFontFamily, paragraph.baseBold, paragraph.baseItalic)
+        }
+        BulletGlyph(glyph, marLPx + indentPx, paint)
+      }
+      val before = paragraph.spaceBeforePt * scale
+      val after = paragraph.spaceAfterPt * scale
+      blocks.add(TextBlock(layout, marLPx, before, after, bullet))
+      total += before + layout.height + after
+    }
+    return blocks to total
+  }
+
+  private fun drawTable(canvas: Canvas, table: PowerPointElement.Table, rect: RectF, scale: Float) {
+    val columnCount = max(
+      table.columnsPt.size,
+      table.rows.maxOfOrNull { it.cells.sumOf { cell -> cell.gridSpan } } ?: 1
+    ).coerceAtLeast(1)
+    val columns = if (table.columnsPt.isNotEmpty()) {
+      table.columnsPt
+    } else {
+      List(columnCount) { table.bounds.width() / columnCount }
+    }
+    val totalColPt = columns.sum().takeIf { it > 0f } ?: table.bounds.width()
+    val colScale = rect.width() / totalColPt
+    val defaultRowHeight = rect.height() / table.rows.size.coerceAtLeast(1)
+
+    fun widthOf(colIndex: Int, span: Int): Float =
+      (colIndex until min(columns.size, colIndex + span))
+        .sumOf { columns[it].toDouble() }.toFloat() * colScale
+
+    var y = rect.top
+    for (row in table.rows) {
+      // <a:tr h> is a MINIMUM in PowerPoint, not a fixed height: a row grows to fit its content.
+      // Treating it as fixed (and clamping to the table's declared bottom) is what made table
+      // text collide with the grid lines and get cut off.
+      var rowHeight = (row.heightPt?.times(scale) ?: defaultRowHeight).coerceAtLeast(12f)
+      var probeIndex = 0
+      for (cell in row.cells) {
+        val span = cell.gridSpan.coerceAtLeast(1)
+        if (!cell.merged) {
+          val inner = widthOf(probeIndex, span) -
+            (cell.marginLeftPt + cell.marginRightPt) * scale
+          if (inner > 1f) {
+            val needed = measureCellText(cell.paragraphs, inner, scale) +
+              (cell.marginTopPt + cell.marginBottomPt) * scale
+            if (needed > rowHeight) rowHeight = needed
+          }
+        }
+        probeIndex += span
+      }
+
+      var x = rect.left
+      var colIndex = 0
+      for (cell in row.cells) {
+        val span = cell.gridSpan.coerceAtLeast(1)
+        val cellWidth = widthOf(colIndex, span)
+        // A continuation cell of a horizontal/vertical merge occupies grid space but must not
+        // paint its own fill, border or text over the cell it was merged into.
+        if (cell.merged) {
+          x += cellWidth
+          colIndex += span
+          continue
+        }
+        val cellRect = RectF(x, y, x + cellWidth, y + rowHeight)
+        fillPaint.shader = null
+        fillPaint.color = cell.fillColor ?: Color.TRANSPARENT
+        if (Color.alpha(fillPaint.color) > 0) canvas.drawRect(cellRect, fillPaint)
+        drawCellBorders(canvas, cell, cellRect, scale)
+        val textRect = RectF(
+          cellRect.left + cell.marginLeftPt * scale,
+          cellRect.top + cell.marginTopPt * scale,
+          cellRect.right - cell.marginRightPt * scale,
+          cellRect.bottom - cell.marginBottomPt * scale
+        )
+        drawCellText(canvas, cell.paragraphs, textRect, scale, cell.anchor)
+        x += cellWidth
+        colIndex += span
+      }
+      y += rowHeight
+    }
+  }
+
+  /**
+   * Per-edge cell borders. An edge the deck left unspecified falls back to a neutral hairline so
+   * the grid remains legible rather than vanishing.
+   */
+  private fun drawCellBorders(
+    canvas: Canvas,
+    cell: PowerPointTableCell,
+    r: RectF,
+    scale: Float
+  ) {
+    strokePaint.style = Paint.Style.STROKE
+    fun edge(stroke: PowerPointStroke?, x0: Float, y0: Float, x1: Float, y1: Float) {
+      if (stroke != null) {
+        strokePaint.color = stroke.color
+        strokePaint.strokeWidth = max(1f, stroke.widthPt * scale)
+      } else {
+        strokePaint.color = TABLE_DEFAULT_BORDER
+        strokePaint.strokeWidth = max(1f, 0.75f * scale)
+      }
+      canvas.drawLine(x0, y0, x1, y1, strokePaint)
+    }
+    edge(cell.borderTop, r.left, r.top, r.right, r.top)
+    edge(cell.borderBottom, r.left, r.bottom, r.right, r.bottom)
+    edge(cell.borderLeft, r.left, r.top, r.left, r.bottom)
+    edge(cell.borderRight, r.right, r.top, r.right, r.bottom)
+  }
+
+  /** Total laid-out height of a cell's paragraphs at [width], used for row auto-growth. */
+  private fun measureCellText(
+    paragraphs: List<PowerPointParagraph>,
+    width: Float,
+    scale: Float
+  ): Float {
+    var total = 0f
+    for (paragraph in paragraphs) {
+      val inner = (width - paragraph.marLPt * scale).coerceAtLeast(1f)
+      total += buildParagraphLayout(paragraph, inner.toInt(), scale).height +
+        paragraph.spaceBeforePt * scale + paragraph.spaceAfterPt * scale
+    }
+    return total
+  }
+
+  private fun drawCellText(
+    canvas: Canvas,
+    paragraphs: List<PowerPointParagraph>,
+    rect: RectF,
+    scale: Float,
+    anchor: TextVerticalAnchor = TextVerticalAnchor.TOP
+  ) {
+    if (rect.width() <= 1f || rect.height() <= 1f) return
+    // Rows have already grown to fit, so anchoring is about placing content within any slack.
+    val contentHeight = measureCellText(paragraphs, rect.width(), scale)
+    var y = when (anchor) {
+      TextVerticalAnchor.MIDDLE -> rect.top + (rect.height() - contentHeight) / 2f
+      TextVerticalAnchor.BOTTOM -> rect.bottom - contentHeight
+      else -> rect.top
+    }.coerceAtLeast(rect.top)
+    canvas.save()
+    // Cells DO keep a clip (unlike free text boxes) so text can't bleed across the grid.
+    canvas.clipRect(rect)
+    for (paragraph in paragraphs) {
+      val marLPx = paragraph.marLPt * scale
+      val width = (rect.width() - marLPx).coerceAtLeast(1f)
+      val layout = buildParagraphLayout(paragraph, width.toInt(), scale)
+      y += paragraph.spaceBeforePt * scale
+      canvas.save()
+      canvas.translate(rect.left + marLPx, y)
+      layout.draw(canvas)
+      canvas.restore()
+      // Bullets are drawn separately (see measureParagraphs) so they hang correctly; cells go
+      // through the same path or they would silently lose their markers.
+      paragraph.bullet?.let { glyph ->
+        bulletPaint.color = paragraph.baseColor
+        bulletPaint.textSize = max(1f, paragraph.baseSizePt * scale)
+        bulletPaint.typeface =
+          typefaceFor(paragraph.baseFontFamily, paragraph.baseBold, paragraph.baseItalic)
+        canvas.drawText(
+          glyph,
+          rect.left + marLPx + paragraph.indentPt * scale,
+          y + layout.getLineBaseline(0),
+          bulletPaint
+        )
+      }
+      y += layout.height + paragraph.spaceAfterPt * scale
+    }
+    canvas.restore()
+  }
+
+  private fun buildParagraphLayout(
+    paragraph: PowerPointParagraph,
+    width: Int,
+    scale: Float,
+    shrink: Float = 1f,
+    lnSpcReduction: Float = 0f
+  ): StaticLayout {
+    val text = SpannableStringBuilder()
+    // The bullet is NOT prepended to the text any more - it is drawn separately so wrapped
+    // lines hang correctly. See measureParagraphs.
+    if (paragraph.runs.isEmpty()) text.append(" ")
+    for (run in paragraph.runs) appendRun(text, run, scale * shrink, paragraph)
+    // A paint PER PARAGRAPH, seeded from the paragraph's resolved base appearance. The old code
+    // shared one mutable TextPaint across every StaticLayout (which keeps it by reference) and
+    // reset it to a hardcoded black 14pt — so nothing could carry the deck's real typography.
+    val paint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply {
+      color = paragraph.baseColor
+      textSize = max(1f, paragraph.baseSizePt * scale * shrink)
+      typeface = typefaceFor(paragraph.baseFontFamily, paragraph.baseBold, paragraph.baseItalic)
+    }
+    // A negative authored value carries an exact spcPts height; convert it against this
+    // paragraph's font size so both forms end up as one multiplier.
+    val authored = paragraph.lineSpacePct
+    val multiplier = when {
+      authored == null -> PPT_SINGLE_LINE_FACTOR
+      authored >= 0f -> authored * PPT_SINGLE_LINE_FACTOR
+      else -> {
+        val sizePt = (paragraph.baseSizePt * shrink).coerceAtLeast(1f)
+        (-authored / sizePt).coerceIn(0.5f, 4f)
+      }
+    }
+    val effective = (multiplier - lnSpcReduction).coerceAtLeast(0.2f)
+    return StaticLayout.Builder
+      .obtain(text, 0, text.length, paint, width.coerceAtLeast(1))
+      .setAlignment(paragraph.align.toLayoutAlignment())
+      .setLineSpacing(0f, effective)
+      .setIncludePad(false)
+      .build()
+  }
+
+  private fun appendRun(
+    builder: SpannableStringBuilder,
+    run: PowerPointTextRun,
+    scale: Float,
+    paragraph: PowerPointParagraph
+  ) {
+    val start = builder.length
+    builder.append(if (run.allCaps == true) run.text.uppercase() else run.text)
+    val end = builder.length
+    if (start == end) return
+    fun span(what: Any) = builder.setSpan(what, start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+
+    run.color?.let { span(ForegroundColorSpan(it)) }
+    // AbsoluteSizeSpan takes an INT px and truncates — 10.5pt silently became 10pt. Keeping the
+    // float matters once sizes are scaled by autofit and by the view scale.
+    run.fontSizePt?.let { span(RunSizeSpan(max(1f, it * scale))) }
+    // One span carries family + bold/italic together: Typeface.create picks a real face for the
+    // mapped family and synthesises the style, whereas TypefaceSpan("Calibri") silently
+    // resolved to the default face and lost every serif deck's character.
+    val bold = run.bold ?: paragraph.baseBold
+    val italic = run.italic ?: paragraph.baseItalic
+    val family = run.fontFamily ?: paragraph.baseFontFamily
+    if (family != null || bold || italic) span(RunTypefaceSpan(typefaceFor(family, bold, italic)))
+    if (run.underline == true) span(UnderlineSpan())
+    if (run.strike == true) span(StrikethroughSpan())
+  }
+
+  private fun scaleRect(rect: RectF, scale: Float): RectF =
+    RectF(rect.left * scale, rect.top * scale, rect.right * scale, rect.bottom * scale)
+
+  private fun TextAlign.toLayoutAlignment(): Layout.Alignment = when (this) {
+    TextAlign.CENTER -> Layout.Alignment.ALIGN_CENTER
+    TextAlign.RIGHT -> Layout.Alignment.ALIGN_OPPOSITE
+    else -> Layout.Alignment.ALIGN_NORMAL
+  }
+}
+
+private data class PowerPointTransform(
+  val bounds: RectF? = null,
+  val rotation: Float = 0f,
+  val flipH: Boolean = false,
+  val flipV: Boolean = false
+)
+
+private data class PowerPointShapeProperties(
+  val transform: PowerPointTransform?,
+  val fill: PptFill?,
+  val stroke: PowerPointStroke?,
+  val shapeType: PowerPointShapeType,
+  /** True when the shape said `<a:noFill/>`, which must beat any `<p:style>` fill reference. */
+  val explicitNoFill: Boolean = false,
+  val customPath: android.graphics.Path? = null
+)
+
+/** Theme format-scheme colours referenced by a shape's `<p:style>`. */
+private data class ShapeStyleRefs(
+  val fillColor: Int? = null,
+  val lineColor: Int? = null,
+  val fontColor: Int? = null
+)
+
+private data class PowerPointTextBody(
+  val paragraphs: List<RawParagraph> = emptyList(),
+  val anchor: TextVerticalAnchor = TextVerticalAnchor.TOP,
+  val insetLeftPt: Float = 4f,
+  val insetTopPt: Float = 2f,
+  val insetRightPt: Float = 4f,
+  val insetBottomPt: Float = 2f,
+  val autofit: Boolean = false,
+  val fontScale: Float = 1f,
+  val lnSpcReduction: Float = 0f
+)
+
+private data class PowerPointParagraphProperties(
+  // Null align/unset bullet means the paragraph did not specify one, so the placeholder's
+  // inherited list style (layout → master → txStyles) supplies it.
+  val align: TextAlign?,
+  val bullet: String?,
+  val bulletExplicit: Boolean,
+  val level: Int,
+  val marLPt: Float? = null,
+  val indentPt: Float? = null,
+  val lineSpacePct: Float? = null,
+  val spaceBeforePt: Float? = null,
+  val spaceAfterPt: Float? = null
+)
+
+/**
+ * A paragraph as read from a slide's own XML, BEFORE layout/master defaults are folded in.
+ * `align`/`bullet` are null/absent when the slide didn't set them; [resolveParagraph] later
+ * fills the gaps from the inherited placeholder style.
+ */
+private data class RawParagraph(
+  val runs: List<PowerPointTextRun>,
+  val align: TextAlign?,
+  val bullet: String?,
+  val bulletExplicit: Boolean,
+  val level: Int,
+  val marLPt: Float? = null,
+  val indentPt: Float? = null,
+  val lineSpacePct: Float? = null,
+  val spaceBeforePt: Float? = null,
+  val spaceAfterPt: Float? = null
+)
+
+internal data class PowerPointRunProperties(
+  val fontSizePt: Float? = null,
+  val color: Int? = null,
+  val fontFamily: String? = null,
+  val bold: Boolean? = null,
+  val italic: Boolean? = null,
+  val underline: Boolean? = null,
+  val strike: Boolean? = null,
+  val allCaps: Boolean? = null
+)
+
+// ── Layout / master inheritance model ──────────────────────────────
+
+/** Placeholder identity from `<p:ph type=".." idx="..">` — the key for inheritance matching. */
+private data class PowerPointPlaceholder(val type: String?, val idx: String?)
+
+/** Which master text-style table a placeholder draws its defaults from. */
+private enum class PlaceholderCategory { TITLE, BODY, OTHER }
+
+/** Default run + paragraph formatting for one outline level (from a list/text style). */
+internal data class ParaRunDefaults(
+  val run: PowerPointRunProperties = PowerPointRunProperties(),
+  val align: TextAlign? = null,
+  val bullet: String? = null,
+  /** True when this level SAID something about bullets, including `<a:buNone/>`. */
+  val bulletExplicit: Boolean = false,
+  val marLPt: Float? = null,
+  val indentPt: Float? = null,
+  val lineSpacePct: Float? = null,
+  val spaceBeforePt: Float? = null,
+  val spaceAfterPt: Float? = null
+)
+
+/** Inheritable data for one placeholder on a layout/master: its geometry and per-level styles. */
+private data class PlaceholderInfo(
+  val bounds: RectF? = null,
+  val lstStyle: Map<Int, ParaRunDefaults> = emptyMap()
+)
+
+private data class StoredPlaceholder(val ph: PowerPointPlaceholder, val info: PlaceholderInfo)
+
+/**
+ * Field-wise inheritance: `this` wins, gaps come from [base]. Null strictly means "inherit".
+ * Same idiom as `DocxConverter.RunProps.overlayOn` so both preview paths resolve styles alike.
+ */
+internal fun PowerPointRunProperties.overlayOn(
+  base: PowerPointRunProperties?
+): PowerPointRunProperties {
+  if (base == null) return this
+  return PowerPointRunProperties(
+    fontSizePt = fontSizePt ?: base.fontSizePt,
+    color = color ?: base.color,
+    fontFamily = fontFamily ?: base.fontFamily,
+    bold = bold ?: base.bold,
+    italic = italic ?: base.italic,
+    underline = underline ?: base.underline,
+    strike = strike ?: base.strike,
+    allCaps = allCaps ?: base.allCaps
+  )
+}
+
+internal fun ParaRunDefaults.overlayOn(base: ParaRunDefaults?): ParaRunDefaults {
+  if (base == null) return this
+  return ParaRunDefaults(
+    run = run.overlayOn(base.run),
+    align = align ?: base.align,
+    // An explicit <a:buNone/> must survive: coalescing on null alone would let an inherited
+    // bullet reappear on a level that deliberately turned bullets off.
+    bullet = if (bulletExplicit) bullet else base.bullet,
+    bulletExplicit = bulletExplicit || base.bulletExplicit,
+    marLPt = marLPt ?: base.marLPt,
+    indentPt = indentPt ?: base.indentPt,
+    lineSpacePct = lineSpacePct ?: base.lineSpacePct,
+    spaceBeforePt = spaceBeforePt ?: base.spaceBeforePt,
+    spaceAfterPt = spaceAfterPt ?: base.spaceAfterPt
+  )
+}
+
+/** A master's `<p:txStyles>`: default run/paragraph styling per outline level, per category. */
+private class TextStyles(
+  val title: Map<Int, ParaRunDefaults>,
+  val body: Map<Int, ParaRunDefaults>,
+  val other: Map<Int, ParaRunDefaults>
+) {
+  fun forCategory(cat: PlaceholderCategory): Map<Int, ParaRunDefaults> = when (cat) {
+    PlaceholderCategory.TITLE -> title
+    PlaceholderCategory.BODY -> body
+    PlaceholderCategory.OTHER -> other
+  }
+
+  companion object {
+    val EMPTY = TextStyles(emptyMap(), emptyMap(), emptyMap())
+  }
+}
+
+/** A parsed slide layout or master. `textStyles` is populated for masters only. */
+private data class ParsedSlidePart(
+  val placeholders: List<StoredPlaceholder>,
+  val background: PptFill?,
+  val textStyles: TextStyles,
+  /**
+   * Non-placeholder shapes/pictures on the layout or master - logos, colour bars, framing
+   * graphics. Previously discarded outright, which is why themed decks rendered as bare text on
+   * white.
+   */
+  val decorations: List<PowerPointElement> = emptyList()
+)
+
+/** The resolved inheritance sources for one slide (layout + master). */
+private class SlideInheritanceContext(
+  val layoutPlaceholders: List<StoredPlaceholder>,
+  val masterPlaceholders: List<StoredPlaceholder>,
+  val textStyles: TextStyles,
+  val background: PptFill?,
+  /** Master decoration first, then layout decoration - both behind the slide's own shapes. */
+  val decorations: List<PowerPointElement> = emptyList()
+) {
+  companion object {
+    val EMPTY = SlideInheritanceContext(emptyList(), emptyList(), TextStyles.EMPTY, null)
+  }
+}
+
+/** Match type used for placeholder lookup — center title is equivalent to title; a missing type
+ *  defaults to body (per the OOXML placeholder rules). */
+private fun phMatchType(type: String?): String = when (type) {
+  null -> "body"
+  "ctrTitle" -> "title"
+  else -> type
+}
+
+private fun phCategory(type: String?): PlaceholderCategory = when (type) {
+  "title", "ctrTitle" -> PlaceholderCategory.TITLE
+  "body", "subTitle", "obj", null -> PlaceholderCategory.BODY
+  else -> PlaceholderCategory.OTHER
+}
+
+/** Finds the layout/master placeholder a slide placeholder inherits from: same `idx` first
+ *  (the strongest signal), then same match-type, then same category. */
+private fun matchPlaceholder(list: List<StoredPlaceholder>, ph: PowerPointPlaceholder): PlaceholderInfo? {
+  if (list.isEmpty()) return null
+  if (ph.idx != null) list.firstOrNull { it.ph.idx == ph.idx }?.let { return it.info }
+  val matchType = phMatchType(ph.type)
+  list.firstOrNull { phMatchType(it.ph.type) == matchType }?.let { return it.info }
+  val category = phCategory(ph.type)
+  list.firstOrNull { phCategory(it.ph.type) == category }?.let { return it.info }
+  return null
+}
+
+private class CompoundBinaryFile(private val bytes: ByteArray) {
+  private val sectorShift: Int
+  private val miniSectorShift: Int
+  private val sectorSize: Int
+  private val miniSectorSize: Int
+  private val firstDirSector: Int
+  private val firstMiniFatSector: Int
+  private val numMiniFatSectors: Int
+  private val miniCutoff: Int
+  private val fat: IntArray
+  private val directories: List<DirectoryEntry>
+  private val root: DirectoryEntry?
+  private val miniFat: IntArray
+  private val miniStream: ByteArray
+
+  init {
+    if (!matches(bytes, 0, OLE_SIG)) throw java.io.IOException("Not an OLE compound file")
+    sectorShift = leUShort(bytes, 30)
+    miniSectorShift = leUShort(bytes, 32)
+    sectorSize = 1 shl sectorShift
+    miniSectorSize = 1 shl miniSectorShift
+    miniCutoff = leInt(bytes, 56).takeIf { it > 0 } ?: 4096
+    firstDirSector = leInt(bytes, 48)
+    firstMiniFatSector = leInt(bytes, 60)
+    numMiniFatSectors = leInt(bytes, 64).coerceAtLeast(0)
+    fat = readFat()
+    val dirBytes = readRegularStream(firstDirSector, Int.MAX_VALUE)
+    directories = parseDirectories(dirBytes)
+    root = directories.firstOrNull { it.type == 5 }
+    miniFat = readMiniFat()
+    miniStream = root?.let { readRegularStream(it.startSector, it.size.toIntSafe()) } ?: ByteArray(0)
+  }
+
+  fun stream(name: String): ByteArray? {
+    val entry = directories.firstOrNull { it.name.equals(name, ignoreCase = true) && it.type == 2 } ?: return null
+    return if (entry.size < miniCutoff && entry.startSector >= 0 && miniStream.isNotEmpty()) {
+      readMiniStream(entry.startSector, entry.size.toIntSafe())
+    } else {
+      readRegularStream(entry.startSector, entry.size.toIntSafe())
+    }
+  }
+
+  private fun readFat(): IntArray {
+    val difat = ArrayList<Int>()
+    for (i in 0 until 109) {
+      val sector = leInt(bytes, 76 + i * 4)
+      if (sector >= 0) difat.add(sector)
+    }
+    val out = ArrayList<Int>()
+    for (sector in difat) {
+      val offset = sectorOffset(sector)
+      if (offset < 0 || offset + sectorSize > bytes.size) continue
+      var pos = offset
+      repeat(sectorSize / 4) {
+        out.add(leInt(bytes, pos))
+        pos += 4
+      }
+    }
+    return out.toIntArray()
+  }
+
+  private fun readMiniFat(): IntArray {
+    if (firstMiniFatSector < 0 || numMiniFatSectors <= 0) return IntArray(0)
+    val data = readRegularStream(firstMiniFatSector, numMiniFatSectors * sectorSize)
+    val out = IntArray(data.size / 4)
+    for (i in out.indices) out[i] = leInt(data, i * 4)
+    return out
+  }
+
+  private fun readRegularStream(startSector: Int, expectedSize: Int): ByteArray {
+    if (startSector < 0) return ByteArray(0)
+    val out = java.io.ByteArrayOutputStream(if (expectedSize in 1..(64 * 1024 * 1024)) expectedSize else 4096)
+    var sector = startSector
+    val visited = HashSet<Int>()
+    while (sector >= 0 && sector < fat.size && visited.add(sector)) {
+      val offset = sectorOffset(sector)
+      if (offset < 0 || offset >= bytes.size) break
+      out.write(bytes, offset, min(sectorSize, bytes.size - offset))
+      if (expectedSize != Int.MAX_VALUE && out.size() >= expectedSize) break
+      sector = fat[sector]
+      if (sector == END_OF_CHAIN) break
+    }
+    val data = out.toByteArray()
+    return if (expectedSize != Int.MAX_VALUE && expectedSize in 0 until data.size) data.copyOf(expectedSize) else data
+  }
+
+  private fun readMiniStream(startSector: Int, expectedSize: Int): ByteArray {
+    val out = java.io.ByteArrayOutputStream(if (expectedSize > 0) expectedSize else 256)
+    var sector = startSector
+    val visited = HashSet<Int>()
+    while (sector >= 0 && sector < miniFat.size && visited.add(sector)) {
+      val offset = sector * miniSectorSize
+      if (offset < 0 || offset >= miniStream.size) break
+      out.write(miniStream, offset, min(miniSectorSize, miniStream.size - offset))
+      if (out.size() >= expectedSize) break
+      sector = miniFat[sector]
+      if (sector == END_OF_CHAIN) break
+    }
+    val data = out.toByteArray()
+    return if (expectedSize in 0 until data.size) data.copyOf(expectedSize) else data
+  }
+
+  private fun parseDirectories(data: ByteArray): List<DirectoryEntry> {
+    val out = ArrayList<DirectoryEntry>()
+    var pos = 0
+    while (pos + 128 <= data.size) {
+      val nameLen = leUShort(data, pos + 64)
+      val rawNameBytes = (nameLen - 2).coerceIn(0, 64)
+      val name = if (rawNameBytes > 0) {
+        String(data, pos, rawNameBytes, Charsets.UTF_16LE).trimEnd('\u0000')
+      } else ""
+      val type = data[pos + 66].toInt() and 0xFF
+      val startSector = leInt(data, pos + 116)
+      val sizeLow = leUInt(data, pos + 120)
+      val sizeHigh = leUInt(data, pos + 124)
+      val size = (sizeHigh shl 32) or sizeLow
+      out.add(DirectoryEntry(name, type, startSector, size))
+      pos += 128
+    }
+    return out
+  }
+
+  private fun sectorOffset(sector: Int): Int {
+    val offset = (sector + 1L) * sectorSize
+    return if (offset > Int.MAX_VALUE) -1 else offset.toInt()
+  }
+}
+
+private data class DirectoryEntry(
+  val name: String,
+  val type: Int,
+  val startSector: Int,
+  val size: Long
+)
+
+private fun cleanText(text: String): String =
+  text.replace('\u0000', ' ')
+    .replace(Regex("[\\u0001-\\u0008\\u000B\\u000C\\u000E-\\u001F]"), " ")
+    .replace(Regex("\\s+"), " ")
+    .trim()
+
+private fun extractBinaryTextRuns(bytes: ByteArray): List<String> {
+  val out = ArrayList<String>()
+  var i = 0
+  while (i < bytes.size - 4 && out.size < 80) {
+    if (isUtf16Run(bytes, i)) {
+      val text = extractUtf16Run(bytes, i)
+      val cleaned = cleanText(text)
+      if (cleaned.length >= 3) out.add(cleaned)
+      i += max(2, text.length * 2)
+    } else if (isAsciiRun(bytes, i)) {
+      val text = extractAsciiRun(bytes, i)
+      val cleaned = cleanText(text)
+      if (cleaned.length >= 4 && cleaned.any { it.isLetter() }) out.add(cleaned)
+      i += max(1, text.length)
+    } else {
+      i++
+    }
+  }
+  return out.distinct()
+}
+
+private fun isUtf16Run(bytes: ByteArray, pos: Int): Boolean =
+  pos + 5 < bytes.size &&
+    bytes[pos + 1] == 0.toByte() &&
+    bytes[pos + 3] == 0.toByte() &&
+    printableByte(bytes[pos]) &&
+    printableByte(bytes[pos + 2])
+
+private fun extractUtf16Run(bytes: ByteArray, start: Int): String {
+  val sb = StringBuilder()
+  var i = start
+  while (i + 1 < bytes.size && bytes[i + 1] == 0.toByte() && printableByte(bytes[i])) {
+    sb.append((bytes[i].toInt() and 0xFF).toChar())
+    i += 2
+  }
+  return sb.toString()
+}
+
+private fun isAsciiRun(bytes: ByteArray, pos: Int): Boolean =
+  pos < bytes.size && (bytes[pos].toInt() and 0xFF) in 0x20..0x7E
+
+private fun extractAsciiRun(bytes: ByteArray, start: Int): String {
+  val sb = StringBuilder()
+  var i = start
+  while (i < bytes.size && (bytes[i].toInt() and 0xFF) in 0x20..0x7E) {
+    sb.append((bytes[i].toInt() and 0xFF).toChar())
+    i++
+  }
+  return sb.toString()
+}
+
+private fun printableByte(byte: Byte): Boolean {
+  val value = byte.toInt() and 0xFF
+  return value in 0x20..0x7E || value == 0x09 || value == 0x0A || value == 0x0D
+}
+
+private fun decodeUtf16Le(bytes: ByteArray, start: Int, len: Int): String {
+  if (len <= 0 || start + len > bytes.size) return ""
+  return String(bytes, start, len - (len % 2), Charsets.UTF_16LE)
+}
+
+private fun decodeCp1252(bytes: ByteArray, start: Int, len: Int): String {
+  if (len <= 0 || start + len > bytes.size) return ""
+  return String(bytes, start, len, Charset.forName("windows-1252"))
+}
+
+private fun leUShort(bytes: ByteArray, offset: Int): Int {
+  if (offset + 1 >= bytes.size) return 0
+  return (bytes[offset].toInt() and 0xFF) or ((bytes[offset + 1].toInt() and 0xFF) shl 8)
+}
+
+private fun leInt(bytes: ByteArray, offset: Int): Int {
+  if (offset + 3 >= bytes.size) return 0
+  return (bytes[offset].toInt() and 0xFF) or
+    ((bytes[offset + 1].toInt() and 0xFF) shl 8) or
+    ((bytes[offset + 2].toInt() and 0xFF) shl 16) or
+    ((bytes[offset + 3].toInt() and 0xFF) shl 24)
+}
+
+private fun leUInt(bytes: ByteArray, offset: Int): Long = leInt(bytes, offset).toLong() and 0xFFFF_FFFFL
+
+private fun matches(bytes: ByteArray, offset: Int, signature: ByteArray): Boolean {
+  if (offset < 0 || offset + signature.size > bytes.size) return false
+  for (i in signature.indices) if (bytes[offset + i] != signature[i]) return false
+  return true
+}
+
+private fun findPngEnd(bytes: ByteArray, start: Int): Int {
+  var pos = start + PNG_SIG.size
+  while (pos + 12 <= bytes.size) {
+    val len = leIntBigEndian(bytes, pos)
+    if (len < 0 || pos + 12 + len > bytes.size) return -1
+    val typeStart = pos + 4
+    val isEnd = bytes[typeStart] == 'I'.code.toByte() &&
+      bytes[typeStart + 1] == 'E'.code.toByte() &&
+      bytes[typeStart + 2] == 'N'.code.toByte() &&
+      bytes[typeStart + 3] == 'D'.code.toByte()
+    pos += 12 + len
+    if (isEnd) return pos
+  }
+  return -1
+}
+
+private fun findJpegEnd(bytes: ByteArray, start: Int): Int {
+  var pos = start + 2
+  while (pos + 1 < bytes.size) {
+    if ((bytes[pos].toInt() and 0xFF) == 0xFF && (bytes[pos + 1].toInt() and 0xFF) == 0xD9) return pos + 2
+    pos++
+  }
+  return -1
+}
+
+private fun findGifEnd(bytes: ByteArray, start: Int): Int {
+  var pos = start + 13
+  if (pos >= bytes.size) return -1
+  val packed = bytes[start + 10].toInt() and 0xFF
+  if ((packed and 0x80) != 0) pos += 3 * (1 shl ((packed and 0x07) + 1))
+  while (pos < bytes.size) {
+    when (bytes[pos].toInt() and 0xFF) {
+      0x3B -> return pos + 1
+      0x21 -> {
+        pos += 2
+        while (pos < bytes.size) {
+          val block = bytes[pos].toInt() and 0xFF
+          pos++
+          if (block == 0) break
+          pos += block
+        }
+      }
+      0x2C -> {
+        pos += 9
+        if (pos >= bytes.size) return -1
+        val imagePacked = bytes[pos].toInt() and 0xFF
+        pos++
+        if ((imagePacked and 0x80) != 0) pos += 3 * (1 shl ((imagePacked and 0x07) + 1))
+        if (pos >= bytes.size) return -1
+        pos++
+        while (pos < bytes.size) {
+          val block = bytes[pos].toInt() and 0xFF
+          pos++
+          if (block == 0) break
+          pos += block
+        }
+      }
+      else -> return -1
+    }
+  }
+  return -1
+}
+
+private fun leIntBigEndian(bytes: ByteArray, offset: Int): Int {
+  if (offset + 3 >= bytes.size) return -1
+  return ((bytes[offset].toInt() and 0xFF) shl 24) or
+    ((bytes[offset + 1].toInt() and 0xFF) shl 16) or
+    ((bytes[offset + 2].toInt() and 0xFF) shl 8) or
+    (bytes[offset + 3].toInt() and 0xFF)
+}
+
+private fun colorFromHex(value: String?): Int? {
+  if (value.isNullOrBlank()) return null
+  val clean = value.trim().removePrefix("#")
+  return try {
+    when (clean.length) {
+      6 -> Color.rgb(clean.substring(0, 2).toInt(16), clean.substring(2, 4).toInt(16), clean.substring(4, 6).toInt(16))
+      8 -> Color.argb(clean.substring(0, 2).toInt(16), clean.substring(2, 4).toInt(16), clean.substring(4, 6).toInt(16), clean.substring(6, 8).toInt(16))
+      else -> null
+    }
+  } catch (_: Throwable) {
+    null
+  }
+}
+
+// ── Fonts ───────────────────────────────────────────────────────────
+//
+// No font a PPTX names ships with Android, so the authored family has to be mapped onto an
+// installed one. `TypefaceSpan("Calibri")` looks like it works but silently resolves to the
+// default sans face, which is why serif decks previously rendered sans throughout. Mapping to
+// buckets keeps the right SHAPE class (serif vs sans vs mono) even though the exact face differs.
+
+private val SERIF_FONTS = listOf(
+  "Times", "Cambria", "Georgia", "Garamond", "Book Antiqua", "Palatino", "Constantia",
+  "Bookman", "Baskerville", "Century Schoolbook", "Century Old", "Merriweather", "Playfair",
+  "Minion", "Caslon", "Didot", "Rockwell", "Bodoni", "PT Serif", "Noto Serif", "Source Serif"
+)
+
+private val MONO_FONTS = listOf(
+  "Consolas", "Courier", "Lucida Console", "Lucida Sans Typewriter", "Monaco", "Menlo",
+  "Cascadia", "Andale Mono", "DejaVu Sans Mono", "Roboto Mono", "Source Code", "Fira Code",
+  "IBM Plex Mono", "Inconsolata", "SF Mono"
+)
+
+private val CURSIVE_FONTS = listOf(
+  "Brush Script", "Segoe Script", "Lucida Handwriting", "Comic Sans", "Bradley Hand",
+  "Freestyle Script", "Edwardian Script", "Pacifico", "Dancing Script"
+)
+
+private fun androidFamilyFor(name: String?): String = when {
+  name.isNullOrBlank() -> "sans-serif"
+  MONO_FONTS.any { name.startsWith(it, ignoreCase = true) } -> "monospace"
+  SERIF_FONTS.any { name.startsWith(it, ignoreCase = true) } -> "serif"
+  CURSIVE_FONTS.any { name.startsWith(it, ignoreCase = true) } -> "cursive"
+  name.contains("Narrow", true) || name.contains("Condensed", true) -> "sans-serif-condensed"
+  // Calibri, Aptos, Arial, Helvetica, Segoe UI, Verdana, Tahoma, Wingdings, … all land here.
+  else -> "sans-serif"
+}
+
+/** Typefaces are immutable and cheap to share, but `Typeface.create` is not free — cache them. */
+private val typefaceCache = HashMap<String, Typeface>()
+
+@Synchronized
+private fun typefaceFor(family: String?, bold: Boolean, italic: Boolean): Typeface {
+  val resolved = androidFamilyFor(family)
+  val style = when {
+    bold && italic -> Typeface.BOLD_ITALIC
+    bold -> Typeface.BOLD
+    italic -> Typeface.ITALIC
+    else -> Typeface.NORMAL
+  }
+  return typefaceCache.getOrPut("$resolved#$style") { Typeface.create(resolved, style) }
+}
+
+/**
+ * Float-precise replacement for `AbsoluteSizeSpan`, which takes an int px and truncates — a
+ * 10.5pt run silently rendered at 10pt, and the error compounds once autofit scaling is applied.
+ */
+private class RunSizeSpan(private val px: Float) : MetricAffectingSpan() {
+  override fun updateMeasureState(p: TextPaint) { p.textSize = px }
+  override fun updateDrawState(p: TextPaint) { p.textSize = px }
+}
+
+/**
+ * Applies a concrete [Typeface] to a run. `TypefaceSpan(Typeface)` would do this but is API 28
+ * and this module's minSdk is 24.
+ */
+private class RunTypefaceSpan(private val typeface: Typeface) : MetricAffectingSpan() {
+  override fun updateMeasureState(p: TextPaint) { p.typeface = typeface }
+  override fun updateDrawState(p: TextPaint) { p.typeface = typeface }
+}
+
+private fun presetColor(name: String?): Int? = when (name) {
+  "black" -> Color.BLACK
+  "white" -> Color.WHITE
+  "red" -> Color.RED
+  "green" -> Color.GREEN
+  "blue" -> Color.BLUE
+  "yellow" -> Color.YELLOW
+  "cyan" -> Color.CYAN
+  "magenta" -> Color.MAGENTA
+  else -> null
+}
+
+/**
+ * Office 2007 theme palette, used when a deck's theme part is missing or unreadable.
+ *
+ * Deliberately contains ONLY the twelve real theme slots. The `tx1`/`bg1`/`tx2`/`bg2` aliases
+ * are absent by design: they are clrMap indirections resolved by [ColorContext.scheme], and
+ * seeding them here is exactly what used to make `schemeClr val="tx1"` short-circuit to
+ * hardcoded black (rendering dark-themed decks as black-on-dark).
+ */
+private val DEFAULT_SCHEME_COLORS: Map<String, Int> = mapOf(
+  "dk1" to 0xFF000000.toInt(),
+  "lt1" to 0xFFFFFFFF.toInt(),
+  "dk2" to 0xFF1F497D.toInt(),
+  "lt2" to 0xFFEEECE1.toInt(),
+  "accent1" to 0xFF4F81BD.toInt(),
+  "accent2" to 0xFFC0504D.toInt(),
+  "accent3" to 0xFF9BBB59.toInt(),
+  "accent4" to 0xFF8064A2.toInt(),
+  "accent5" to 0xFF4BACC6.toInt(),
+  "accent6" to 0xFFF79646.toInt(),
+  "hlink" to 0xFF0000FF.toInt(),
+  "folHlink" to 0xFF800080.toInt()
+)
+
+private const val BLACK_ARGB = 0xFF000000.toInt()
+
+/**
+ * Maps a `prstGeom` preset onto a drawable primitive.
+ *
+ * The important case is the LINE family. Only `straightConnector1` was recognised before, so every
+ * other connector, arrow and callout leader was drawn as a fully filled RECTANGLE spanning its
+ * bounding box — which is one of the ways decorative geometry ended up covering slide text.
+ * Anything genuinely unknown still falls back to a rectangle, matching how PowerPoint fills a
+ * closed shape.
+ */
+internal fun mapShapeType(value: String?): PowerPointShapeType = when {
+  value == null -> PowerPointShapeType.RECT
+
+  value == "ellipse" || value == "oval" || value == "circle" || value == "teardrop" ||
+    value == "cloud" || value == "flowChartConnector" || value == "flowChartOnlineStorage" ->
+    PowerPointShapeType.ELLIPSE
+
+  value == "roundRect" || value == "round1Rect" || value == "round2SameRect" ||
+    value == "round2DiagRect" || value == "snip1Rect" || value == "snip2SameRect" ||
+    value == "snip2DiagRect" || value == "snipRoundRect" || value == "bevel" ||
+    value == "flowChartTerminator" || value == "flowChartAlternateProcess" ||
+    value.startsWith("wedgeRoundRectCallout") || value.startsWith("roundRectCallout") ->
+    PowerPointShapeType.ROUND_RECT
+
+  value == "triangle" || value == "flowChartExtract" || value == "flowChartMerge" ->
+    PowerPointShapeType.TRIANGLE
+  value == "rtTriangle" -> PowerPointShapeType.RIGHT_TRIANGLE
+  value == "diamond" || value == "flowChartDecision" -> PowerPointShapeType.DIAMOND
+  value == "parallelogram" || value == "flowChartInputOutput" ->
+    PowerPointShapeType.PARALLELOGRAM
+  value == "trapezoid" || value == "flowChartManualOperation" -> PowerPointShapeType.TRAPEZOID
+
+  value == "pentagon" -> PowerPointShapeType.PENTAGON
+  value == "hexagon" || value == "flowChartPreparation" -> PowerPointShapeType.HEXAGON
+  value == "octagon" -> PowerPointShapeType.OCTAGON
+
+  value == "star4" -> PowerPointShapeType.STAR4
+  value == "star5" -> PowerPointShapeType.STAR5
+  value == "star6" -> PowerPointShapeType.STAR6
+  value == "star7" || value == "star8" -> PowerPointShapeType.STAR8
+  value == "star10" || value == "star12" -> PowerPointShapeType.STAR12
+  value == "star16" -> PowerPointShapeType.STAR16
+  value == "star24" -> PowerPointShapeType.STAR24
+  value == "star32" -> PowerPointShapeType.STAR32
+
+  value == "rightArrow" || value == "stripedRightArrow" || value == "notchedRightArrow" ->
+    PowerPointShapeType.ARROW_RIGHT
+  value == "leftArrow" -> PowerPointShapeType.ARROW_LEFT
+  value == "upArrow" -> PowerPointShapeType.ARROW_UP
+  value == "downArrow" -> PowerPointShapeType.ARROW_DOWN
+  value == "leftRightArrow" -> PowerPointShapeType.ARROW_LEFT_RIGHT
+  value == "upDownArrow" -> PowerPointShapeType.ARROW_UP_DOWN
+
+  value == "chevron" -> PowerPointShapeType.CHEVRON
+  value == "homePlate" -> PowerPointShapeType.HOME_PLATE
+  value == "plus" || value == "mathPlus" -> PowerPointShapeType.PLUS
+  value == "can" || value == "flowChartMagneticDrum" -> PowerPointShapeType.CAN
+  value == "donut" -> PowerPointShapeType.DONUT
+  value == "frame" || value == "halfFrame" -> PowerPointShapeType.FRAME
+
+  // Every connector/line/arrow variant: straight, bent, curved.
+  value == "line" || value.startsWith("straightConnector") ||
+    value.startsWith("bentConnector") || value.startsWith("curvedConnector") ||
+    value.startsWith("lineInv") || value == "bentLine" -> PowerPointShapeType.LINE
+
+  else -> PowerPointShapeType.RECT
+}
+
+/**
+ * `<a:buAutoNum>` -> the literal marker for the paragraph.
+ *
+ * Every numbered list previously rendered as a hardcoded "1.", ignoring the format and the start
+ * value. Reuses [Ox.formatOrdinal], already shared with the DOCX/ODF numbering path.
+ */
+internal fun autoNumberMarker(type: String?, startAt: Int): String {
+  val n = startAt.coerceAtLeast(1)
+  val fmt = when {
+    type == null -> "arabic"
+    type.startsWith("alphaLc") -> "lowerLetter"
+    type.startsWith("alphaUc") -> "upperLetter"
+    type.startsWith("romanLc") -> "lowerRoman"
+    type.startsWith("romanUc") -> "upperRoman"
+    else -> "arabic"
+  }
+  val body = Ox.formatOrdinal(n, fmt)
+  return when {
+    type == null -> "$body."
+    type.endsWith("ParenBoth") -> "($body)"
+    type.endsWith("ParenR") -> "$body)"
+    type.endsWith("Period") -> "$body."
+    type.endsWith("Plain") -> body
+    else -> "$body."
+  }
+}
+
+private fun normalizeBullet(value: String?): String =
+  when {
+    value.isNullOrBlank() -> BULLET
+    value.first().code >= 0xE000 || value.first().code == 0xF0B7 -> BULLET
+    else -> value
+  }
+
+private fun Long.toIntSafe(): Int =
+  when {
+    this < 0L -> 0
+    this > Int.MAX_VALUE -> Int.MAX_VALUE
+    else -> toInt()
+  }
+
+private const val DEFAULT_SLIDE_WIDTH_PT = 720f
+private const val DEFAULT_SLIDE_HEIGHT_PT = 540f
+private const val BULLET = "\u2022"
+
+/** Fallback theme part, used only when the presentation \u2192 master \u2192 theme chain can't be walked. */
+private const val DEFAULT_THEME_PART = "ppt/theme/theme1.xml"
+
+/** Backstop against pathological (or hostile) `<p:grpSp>` nesting; real decks are 2-3 deep. */
+private const val MAX_GROUP_NESTING = 16
+
+/**
+ * `<mc:Choice Requires="...">` namespaces whose content is ordinary DrawingML plus cosmetic
+ * extensions, so taking the Choice loses nothing. Anything else (SmartArt's `dsp`, Word shapes'
+ * `wps`/`wpg`, ink, \u2026) falls through to the `<mc:Fallback>`, which is plain `p:`/`a:` markup.
+ */
+private val RENDERABLE_CHOICE_NS = setOf("a14", "p14", "a15", "p15", "p16", "pm", "com", "v")
+
+// OOXML's own defaults for text that specifies no size anywhere in the inheritance chain. The
+// previous renderer used a flat 14pt for everything, which made every deck look uniformly small.
+private const val DEFAULT_BODY_SIZE_PT = 18f
+private const val DEFAULT_TITLE_SIZE_PT = 44f
+
+/**
+ * PowerPoint's "single" line spacing is 1.2x the font size, whereas Android's default line height
+ * is the font's own ascent+descent+leading (~1.17em for Roboto). One tunable constant rather than
+ * a fudge factor scattered through the layout code.
+ */
+private const val PPT_SINGLE_LINE_FACTOR = 1.2f
+
+/**
+ * Hanging indent used when neither the paragraph nor its inherited list style supplies `marL`.
+ * Matches the DOCX preview's list indent so both previews look like the same product.
+ */
+private const val DEFAULT_BULLET_INDENT_PT = 18f
+
+/** Neutral hairline for table edges the deck didn't specify, so the grid stays legible. */
+private val TABLE_DEFAULT_BORDER = 0xFFB4BECD.toInt()
+private const val PPT_RECORD_SLIDE_CONTAINER = 1006
+private const val PPT_RECORD_TEXT_CHARS = 4000
+private const val PPT_RECORD_TEXT_BYTES = 4008
+private const val PPT_RECORD_CSTRING = 4026
+private const val END_OF_CHAIN = -2
+
+private val OLE_SIG = byteArrayOf(0xD0.toByte(), 0xCF.toByte(), 0x11, 0xE0.toByte(), 0xA1.toByte(), 0xB1.toByte(), 0x1A, 0xE1.toByte())
+private val PNG_SIG = byteArrayOf(0x89.toByte(), 'P'.code.toByte(), 'N'.code.toByte(), 'G'.code.toByte(), 0x0D, 0x0A, 0x1A, 0x0A)
+private val GIF87_SIG = "GIF87a".toByteArray(Charsets.US_ASCII)
+private val GIF89_SIG = "GIF89a".toByteArray(Charsets.US_ASCII)
+private val THEME_COLOR_KEYS = setOf("dk1", "lt1", "dk2", "lt2", "accent1", "accent2", "accent3", "accent4", "accent5", "accent6", "hlink", "folHlink")
+private val LVL_STYLE_REGEX = Regex("lvl(\\d)pPr")