feat(epub): inline images and floats (T-66)

Inline <img> is no longer dropped: an image with computed inline
display (the CSS default) flows on the line as a single unbreakable
token, sized from CSS width/height, the HTML attributes, or its
intrinsic pixel size at 0.75pt/px, capped to the content width. It
advances the pen, sits bottom-on-baseline, grows the line's ascent to
its height, rides PositionedLine.images as PlacedImage (draw width kept
separate from the justification-stretched advance), and paints next to
the run loop for both raster and SVG payloads. display:block or floated
images keep the block ImageBox path.

float:left/right leaves the flow, lays out against the content edge,
and registers an exclusion band; wrap gained an optional per-line width
callback (the no-float path is the exact old code) and placeLines
shortens and offsets overlapping lines; clear drops the flow cursor
below matching floats. Simplifications are commented at the source:
same-side floats stack downward, blocks grow to contain their floats
so pagination never splits across one, band widths use the authored
line-height estimate, and a widthless floated block takes half the
content width as shrink-to-fit.

Sweep moves 4148 -> 4149 pages (+1): a real book reflowing under
inline-image layout, recorded in the progress log. Existing tests that
relied on every img being a block now say display:block explicitly.

Author: yuroyami

FABLE5_AUDIT_PROGRESS.md

@@ -461,6 +461,58 @@ kinsoku, T-73 reader settings, T-66 inline images + floats, T-47 WOFF2).
 
 ---
 
+## T-66. Inline images and floats
+
+- **Status:** DONE
+- **Commit:** (this commit)
+- **What landed:**
+  - **Inline images:** `processInline` no longer drops `<img>` (the stale
+    "Phase 5" skip is gone), and `buildBlock` routes an img by its
+    computed display: inline (the CSS default; the resolver's initial
+    display is already INLINE) flows on the line, `display:block` or a
+    float keeps the old block `ImageBox` path. An inline image is one
+    unbreakable single-cell token sized from CSS width/height, the HTML
+    attributes (x0.75 px->pt), or the intrinsic pixel size at 0.75pt/px,
+    capped to the content width; it advances the pen, sits bottom on the
+    baseline, and grows the line's ascent to its height. Carried through
+    `PositionedLine.images` as `PlacedImage` (parallel to `PlacedRun`,
+    with the natural draw width kept separate from the possibly
+    justified pen advance) and painted next to the run loop in
+    `EpubPage.renderTo` (raster + SVG). Extraction/search skip images
+    automatically (they live outside the glyph runs).
+  - **Floats:** `float`/`clear` parsed into `ComputedStyle`. A floated
+    child lays out against the left/right content edge at the current
+    flow y and registers a `FloatBand` exclusion; the flow cursor does
+    not advance. `wrap` gained an optional per-line-width callback
+    (`availAt`, null = the exact old single-width path) and
+    `placeLines` shortens and offsets each overlapping line via
+    `floatInsets`; `clear` drops the cursor below matching floats.
+    Commented simplifications per the audit: same-side floats stack
+    downward; floats do not escape their containing block (it grows to
+    contain them, protecting pagination); a float paginates as one
+    unbreakable unit; float-band widths use the authored line-height
+    estimate (ruby/image-grown lines may drift by their growth); a
+    floated block without explicit width takes half the content width
+    as its shrink-to-fit approximation.
+- **Verification:** `InlineImageFloatTest` (6 tests): fixture A (no
+  content loss, image draws between its neighbouring words, bottom
+  exactly on the baseline by draw-ctm equality, ascent grows to the
+  40pt image), fixture B (lines beside a float:left start right of it;
+  lines below return to full width; float:right mirrors), and clear
+  (content starts below the float's 100pt band). Four existing tests
+  that relied on every img being a block were pointed at
+  `display:block` explicitly; the raster blit test sizes its tiny PNG
+  up (a bare img now draws at intrinsic size, the CSS behaviour, not
+  full-width).
+- **Sweep:** 4148 -> 4149 pages (+1), 0 failures, worstMAE 0.2666
+  (unchanged at 4 s.f.). The +1 is a real book reflowing under
+  inline-image layout; the harness prints only aggregates, so the
+  gaining book was not isolated (the per-book p0 MAE list is stable,
+  consistent with mid-chapter images moving line flow, not covers).
+  PDF differential untouched (29 pages, 0.0115).
+
+---
+
 ## Discovered during execution
 
 (nothing yet)

kitepdf-epub/src/commonMain/kotlin/io/github/yuroyami/kitepdf/epub/BoxBuilder.kt

@@ -1,6 +1,7 @@
 package io.github.yuroyami.kitepdf.epub
 
 import io.github.yuroyami.kitepdf.epub.css.ComputedStyle
+import io.github.yuroyami.kitepdf.epub.css.CssFloat
 import io.github.yuroyami.kitepdf.epub.css.Display
 import io.github.yuroyami.kitepdf.epub.css.Edge
 import io.github.yuroyami.kitepdf.epub.css.ListType
@@ -71,10 +72,19 @@ internal class BoxBuilder(
                 if (child.tag == "img" || child.tag == "image") {
                     val src = child.attrs["src"] ?: child.attrs["href"] ?: child.attrs["xlink:href"]
                     if (src != null && src.isNotBlank()) {
-                        flush()
+                        val cs = resolver.compute(child, childAncestors, style)
                         val aw = child.attrs["width"]?.trim()?.removeSuffix("px")?.toDoubleOrNull()
                         val ah = child.attrs["height"]?.trim()?.removeSuffix("px")?.toDoubleOrNull()
-                        children.add(ImageBox(resolver.compute(child, childAncestors, style), resolveHref(src), attrWidth = aw, attrHeight = ah))
+                        // img is inline by default (CSS): it flows on the line
+                        // unless the author blocks or floats it.
+                        if ((cs.display == Display.INLINE || cs.display == Display.INLINE_BLOCK) &&
+                            cs.cssFloat == CssFloat.NONE
+                        ) {
+                            inl.addImage(resolveHref(src), style, cs.widthPt ?: aw?.times(0.75), cs.heightPt ?: ah?.times(0.75))
+                        } else {
+                            flush()
+                            children.add(ImageBox(cs, resolveHref(src), attrWidth = aw, attrHeight = ah))
+                        }
                     }
                     continue
                 }
@@ -282,7 +292,17 @@ internal class BoxBuilder(
                 is HtmlNode.Text -> inl.appendText(child.text, style)
                 is HtmlNode.Element -> {
                     if (child.tag == "br") { inl.addBreak(); continue }
-                    if (child.tag == "img" || child.tag == "image") continue // inline images: Phase 5
+                    if (child.tag == "img" || child.tag == "image") {
+                        // Inline image: flows on the line, bottom on the baseline.
+                        val src = child.attrs["src"] ?: child.attrs["href"] ?: child.attrs["xlink:href"]
+                        if (src != null && src.isNotBlank()) {
+                            val cs = resolver.compute(child, childAncestors, style)
+                            val aw = child.attrs["width"]?.trim()?.removeSuffix("px")?.toDoubleOrNull()?.times(0.75)
+                            val ah = child.attrs["height"]?.trim()?.removeSuffix("px")?.toDoubleOrNull()?.times(0.75)
+                            inl.addImage(resolveHref(src), style, cs.widthPt ?: aw, cs.heightPt ?: ah)
+                        }
+                        continue
+                    }
                     val cs = resolver.compute(child, childAncestors, style)
                     if (cs.display != Display.NONE) processInline(child, cs, childAncestors, inl, anchorSink)
                 }
@@ -389,6 +409,17 @@ internal class BoxBuilder(
             pendingSpace = false; lastWasBreak = true
         }
 
+        /** An inline `<img>`: one U+FFFC run carrying the source + size hints. */
+        fun addImage(src: String, style: ComputedStyle, cssW: Double?, cssH: Double?) {
+            if (pendingSpace && blockHasContent && !lastWasBreak) {
+                runs.add(makeRun(" ", style))
+            }
+            pendingSpace = false; lastWasBreak = false; blockHasContent = true
+            runs.add(
+                makeRun("", style).copy(imageSrc = src, imageCssW = cssW, imageCssH = cssH),
+            )
+        }
+
         fun appendText(raw: String, style: ComputedStyle) {
             if (raw.isEmpty()) return
             if (style.whiteSpace == WhiteSpaceMode.PRE || style.whiteSpace == WhiteSpaceMode.PRE_WRAP || style.whiteSpace == WhiteSpaceMode.PRE_LINE) {