From 896136c58e191b6eb50b903e0925b924e7d7da16 Mon Sep 17 00:00:00 2001
From: KnifeLemon <role___play@naver.com>
Date: Wed, 28 Oct 2026 12:03:59 +0900
Subject: [PATCH] Render quality harness: feature matrix, read-back checks and
 compare against rhwp
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Measures a document renderer without sample files in the repository (Project 4, M0):

- Feature matrix written in code (RenderFeatures): line spacing kinds x alignment, tabs, lists, tables, headers
  and footers, notes, columns, floating objects, equations and paragraphs in eight scripts, through the HWPX
  writer or DocxBuilder and the DOCX reader; binary HWP twins made with rhwp convert.
- Read-back checks with PdfPig, one tested function each (PdfChecks): text round trip, overlapping glyphs
  (> 0.05 em), glyphs outside the page and the margins, page count, baselines (±0.5 pt), fonts embedded and subset.
- Differential compare (RenderDiff): page count, line-break agreement (Myers LCS over lines), baselines and
  per-page SSIM of PDFium pictures at 100 dpi; proven by rhwp against itself and by perturbed renderings.
- Thresholds and an allow-list for known rhwp defects in render-thresholds.json; a worse value fails the test.
- One seam for the layout engine (DocumentRenderers.Candidate); its compare is skipped until it is registered.
- build/render-compare.ps1: a private corpus (FILEE_RENDER_CORPUS, doc.hwpx + the PDF 한글 printed) to an HTML
  report in the temp folder.

PdfPageWriterTests now share the checks, SSIM and the HarfBuzz test shaper (TestShaper) with the harness.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 build/render-compare.ps1                      |  55 +++
 docs/ENGINES.md                               |  10 +-
 docs/RENDER-QUALITY.md                        | 137 +++++++
 .../Filee.Engines.Tests.csproj                |   2 +
 .../Filee.Engines.Tests/PdfPageWriterTests.cs | 228 ++----------
 .../RenderQuality/DocumentRenderers.cs        |  86 +++++
 .../RenderQuality/PageImage.cs                | 129 +++++++
 .../RenderQuality/PdfChecks.cs                | 250 +++++++++++++
 .../RenderQuality/PdfLines.cs                 | 122 +++++++
 .../RenderQuality/RenderChecksTests.cs        | 327 +++++++++++++++++
 .../RenderQuality/RenderCorpusTests.cs        | 157 ++++++++
 .../RenderQuality/RenderDiff.cs               |  61 ++++
 .../RenderQuality/RenderFeatures.cs           | 336 ++++++++++++++++++
 .../RenderQuality/RenderHarness.cs            | 182 ++++++++++
 .../RenderQuality/RenderQualityTests.cs       | 181 ++++++++++
 .../RenderQuality/RenderThresholds.cs         |  91 +++++
 .../RenderQuality/SequenceMatch.cs            |  92 +++++
 .../RenderQuality/render-thresholds.json      |  52 +++
 tests/Filee.Engines.Tests/TestShaper.cs       |  69 ++++
 19 files changed, 2360 insertions(+), 207 deletions(-)
 create mode 100644 build/render-compare.ps1
 create mode 100644 docs/RENDER-QUALITY.md
 create mode 100644 tests/Filee.Engines.Tests/RenderQuality/DocumentRenderers.cs
 create mode 100644 tests/Filee.Engines.Tests/RenderQuality/PageImage.cs
 create mode 100644 tests/Filee.Engines.Tests/RenderQuality/PdfChecks.cs
 create mode 100644 tests/Filee.Engines.Tests/RenderQuality/PdfLines.cs
 create mode 100644 tests/Filee.Engines.Tests/RenderQuality/RenderChecksTests.cs
 create mode 100644 tests/Filee.Engines.Tests/RenderQuality/RenderCorpusTests.cs
 create mode 100644 tests/Filee.Engines.Tests/RenderQuality/RenderDiff.cs
 create mode 100644 tests/Filee.Engines.Tests/RenderQuality/RenderFeatures.cs
 create mode 100644 tests/Filee.Engines.Tests/RenderQuality/RenderHarness.cs
 create mode 100644 tests/Filee.Engines.Tests/RenderQuality/RenderQualityTests.cs
 create mode 100644 tests/Filee.Engines.Tests/RenderQuality/RenderThresholds.cs
 create mode 100644 tests/Filee.Engines.Tests/RenderQuality/SequenceMatch.cs
 create mode 100644 tests/Filee.Engines.Tests/RenderQuality/render-thresholds.json
 create mode 100644 tests/Filee.Engines.Tests/TestShaper.cs

diff --git a/build/render-compare.ps1 b/build/render-compare.ps1
new file mode 100644
index 000000000..86df7f8cf
--- /dev/null
+++ b/build/render-compare.ps1
@@ -0,0 +1,55 @@
+<#
+.SYNOPSIS
+  Compares Filee's document renderers with the PDFs 한글 printed, over a private corpus outside the repository.
+
+.DESCRIPTION
+  The corpus is a folder (searched recursively) of documents next to the PDF 한글 printed of each: doc.hwpx + doc.pdf,
+  or doc.hwp + doc.pdf. Nothing of it is copied into the repository. Every document is rendered by rhwp (fetch it with
+  build/fetch-engines.ps1 -Only rhwp) and, once one is registered, by Filee's layout engine; each rendering is compared
+  with 한글's PDF (page count, line breaks, baselines, per-page SSIM at 100 dpi) and read back (text, overlapping
+  glyphs, glyphs outside the page, embedded fonts). The results go to an HTML report with the page that differs most of
+  each document side by side.
+
+  It runs RenderCorpusTests in tests/Filee.Engines.Tests (docs/RENDER-QUALITY.md).
+
+.PARAMETER Corpus
+  The corpus folder. Defaults to the FILEE_RENDER_CORPUS environment variable.
+
+.PARAMETER Report
+  The HTML report to write. Defaults to filee-render-compare-<time>.html in the temp folder.
+
+.PARAMETER Open
+  Opens the report when done.
+
+.EXAMPLE
+  pwsh build/render-compare.ps1 -Corpus D:\hwp-corpus -Open
+#>
+[CmdletBinding()]
+param(
+    [string]$Corpus = $env:FILEE_RENDER_CORPUS,
+    [string]$Report = (Join-Path ([IO.Path]::GetTempPath()) "filee-render-compare-$(Get-Date -Format 'yyyyMMdd-HHmmss').html"),
+    [ValidateSet('Debug', 'Release')]
+    [string]$Configuration = 'Release',
+    [switch]$Open
+)
+
+$ErrorActionPreference = 'Stop'
+if (-not $Corpus) { throw 'Name the corpus folder with -Corpus or FILEE_RENDER_CORPUS.' }
+if (-not (Test-Path $Corpus -PathType Container)) { throw "Corpus folder not found: $Corpus" }
+
+$repository = Split-Path $PSScriptRoot -Parent
+$project = Join-Path $repository 'tests/Filee.Engines.Tests/Filee.Engines.Tests.csproj'
+
+$env:FILEE_RENDER_CORPUS = (Resolve-Path $Corpus).Path
+$env:FILEE_RENDER_REPORT = [IO.Path]::GetFullPath($Report)
+try {
+    dotnet test $project -c $Configuration --filter 'FullyQualifiedName~RenderQuality.RenderCorpusTests' --logger 'console;verbosity=normal'
+    if ($LASTEXITCODE -ne 0) { throw "The compare failed (exit $LASTEXITCODE)." }
+}
+finally {
+    Remove-Item Env:FILEE_RENDER_REPORT -ErrorAction SilentlyContinue
+}
+
+if (-not (Test-Path $Report)) { throw "No report was written to $Report." }
+Write-Host "Report: $Report"
+if ($Open) { Invoke-Item $Report }
diff --git a/docs/ENGINES.md b/docs/ENGINES.md
index 2cc1db4fc..85e08a3fa 100644
--- a/docs/ENGINES.md
+++ b/docs/ENGINES.md
@@ -617,7 +617,15 @@ glyphs a thousand times too small. They are now combined the way rasterizers do
 and advances at the same glyph IDs in Skia, composite components kept, CFF converted, tables dropped, cmap round
 trips); `tests/Filee.Engines.Tests/PdfPageWriterTests.cs` builds the page above and checks size, fonts, text and the
 PDFium picture, with each installed Korean font (Malgun Gothic, Noto Sans CJK, Noto Sans KR VF; skipped when none is
-installed), plus page sizes, links and the outline.
+installed), plus page sizes, links and the outline. The page also passes the render quality harness's read-back checks.
+
+### Render quality harness
+
+How the renderer is measured, against rhwp now and against the PDFs 한글 printed: [RENDER-QUALITY.md](RENDER-QUALITY.md).
+A feature matrix of documents written in code, read-back checks of the PDF (text, overlapping glyphs, page and
+margins, page count, baselines, embedded fonts), a compare of two renderings (page count, line breaks, per-page SSIM
+at 100 dpi) with thresholds kept in `tests/Filee.Engines.Tests/RenderQuality/render-thresholds.json`, and
+`build/render-compare.ps1` for a private corpus. The layout engine plugs in at `DocumentRenderers.Candidate`.
 
 ## DOCX writer
 
diff --git a/docs/RENDER-QUALITY.md b/docs/RENDER-QUALITY.md
new file mode 100644
index 000000000..6be05dfc6
--- /dev/null
+++ b/docs/RENDER-QUALITY.md
@@ -0,0 +1,137 @@
+# Render quality harness
+
+How Filee measures a document renderer: GitHub Project 4, "Filee: built-in engines", item *Layout engine: render
+quality harness*. Filee's own layout engine doesn't exist yet; the harness measures rhwp today, the renderer Filee
+bundles, and the layout engine plugs in at one place when its first milestone lands. No input or reference file is in
+the repository: every document is written in code at test time, and real documents stay in a private corpus outside
+it.
+
+The code is in `tests/Filee.Engines.Tests/RenderQuality/`.
+
+## Plugging in a renderer
+
+A renderer takes a document and returns a PDF (`DocumentRenderers.cs`):
+
+```csharp
+internal delegate Task<byte[]> RenderDocument(RenderInput input, CancellationToken cancellationToken);
+internal sealed record DocumentRenderer(string Name, IReadOnlySet<string> Formats, RenderDocument Render);
+```
+
+`RenderInput` has the file (HWPX, or a binary HWP), a work folder, and the layout model (`HDocument`, read with
+`HwpxReader.ReadForLayout` when first asked for). `DocumentRenderers.Reference` is rhwp as Filee runs it
+(`RhwpInput`'s fixes, then `rhwp export-pdf` with Filee's fallback fonts). rhwp is only the yardstick here; nothing in
+the harness adds a conversion path through it.
+
+`DocumentRenderers.Candidate` is Filee's layout engine. It is null until the first layout milestone sets it, and until
+then the compare test is skipped with that reason. Once it is set, its PDFs get the same read-back checks and are
+compared with rhwp's, with no other change.
+
+## The feature matrix
+
+`RenderFeatures.cs` writes one small document per feature. Most are built as a document model and written by Filee's
+HWPX writer. Floating objects and equations are built with `DocxBuilder` and go through the DOCX reader, the way a
+Word document reaches the renderer. Every document is A4 with 한글's default margins.
+
+| Feature | Built from | What it holds |
+|---|---|---|
+| `line-spacing-percent`, `-fixed`, `-at-least` | model | 160 %, fixed 20 pt and at least 24 pt line spacing, one paragraph per alignment (left, right, centre, justify, distribute); the lines must be one pitch apart |
+| `tabs` | model | left, centre, decimal and right tab stops with dot and dash leaders |
+| `lists` | model | numbered list with a 가나다 sub-level and hanging indents, bullets |
+| `tables` | model | 3 columns of fixed widths, a filled header row, wrapped cell text, a merged cell |
+| `headers-footers` | model | a header, a footer with the page number, two pages |
+| `notes` | model | a footnote and an endnote |
+| `columns` | model | two columns with a separator line and a column break |
+| `floating` | DOCX | a picture with square wrap, a text box above and below the text, a picture behind and a box in front of it |
+| `equations` | DOCX | an inline equation, a fraction and a sum |
+| `script-ko`, `-zh`, `-ja`, `-ar`, `-he`, `-hi`, `-gu`, `-th` | model | Korean, Chinese, Japanese, Arabic, Hebrew, Devanagari, Gujarati and Thai paragraphs |
+
+`line-spacing-percent`, `tables` and `script-ko` are also rendered from a binary HWP made with `rhwp convert` while
+rhwp is bundled (`*.hwp` rows below), and compared with the rendering of their HWPX.
+
+## Read-back checks
+
+Each check is one function in `PdfChecks.cs`. It takes the PDF, plus what the document asks for, and returns a value,
+whether the value meets the ideal, and the first offenders. `RenderChecksTests.cs` tests every check on PDFs built in
+code.
+
+| Check | Value | Ideal |
+|---|---|---|
+| `text` | share of the document's text (white space left out, NFC) found in the PDF's text in the same order; `/ActualText` spans count as their text, and text the renderer adds (list numbers, page numbers) doesn't count against it | 1 |
+| `overlaps` | share of neighbouring glyphs on a line whose advances overlap by more than 0.05 em; glyphs without an advance (marks) are left out | 0 |
+| `outside-page` | glyphs whose outline leaves the page by more than 0.5 pt | 0 |
+| `outside-margins` | glyphs whose advance or baseline lies outside the page less its margins by more than 1 pt (the header and footer areas count as inside, as 한글 puts them in the top and bottom margins) | 0 |
+| `pages` | the page count | the document's |
+| `baselines` | share of lines on their expected baseline within ±0.5 pt (the line-spacing features: one pitch apart from the first line of each page) | 1 |
+| `fonts` | fonts that aren't embedded or aren't subset (Type 3 fonts count as both) | 0 |
+
+Lines are letters on one baseline (within 0.35 of their size, so a superscript stays on its line), measured from the
+top of the page. Kerning deeper than 0.05 em counts as an overlap. Segoe UI, for example, kerns reh and zain 0.08 em
+under a letter that doesn't join them, so a shaping renderer may need a threshold for that (`PdfPageWriterTests`
+allows 0.1 em for its Arabic paragraph).
+
+## Differential compare
+
+`RenderDiff.Compare` compares two renderings of one document (rhwp and the layout engine, rhwp's HWP and HWPX, or
+한글's PDF and a renderer):
+
+- **pages**: the same page count.
+- **lines**: line-break agreement. Each line is its text without white space. The two documents' lines are matched in
+  order (longest common subsequence, Myers' O(ND) diff), and a line agrees when the other PDF has a line with the same
+  text at that point. It then agrees on both its first and its last character. A page break moved by one line costs
+  only the lines that moved. The value is the share of the longer document's lines.
+- **placed**: the share of lines that also sit on the same page and baseline (±0.5 pt).
+- **ssim**: the lowest per-page SSIM of the pages drawn by PDFium (PDFtoImage) at 100 dpi. SSIM is computed over
+  8×8 windows with a step of 4, leaving out windows that are blank paper in both pages (`PageImage.cs`).
+
+Two tests prove the compare itself. **rhwp against rhwp** must be identical (same pages, every line on its baseline,
+SSIM 1). **Perturbed renderings** must be caught: the same PDF drawn 2 pt lower keeps every line but no baseline, and
+its SSIM falls to 0.27; a copy of the document with a 20 mm wider left margin breaks every line elsewhere.
+
+## Thresholds and the allow-list
+
+`render-thresholds.json` holds what each renderer reaches where it falls short of the ideal, per feature and check.
+Every other measurement must meet the ideal. A value worse than its threshold is a regression and fails the test. A
+better one passes, and the report says which threshold to raise or remove in the same change. Overlaps are a share,
+not a count, so the longer documents of the full run compare with the same thresholds.
+
+The `allow` list holds measurements that are reported but never fail, each with its reason. They are the compares of
+the layout engine with rhwp where rhwp is wrong: floating objects, equations, and the scripts it draws without
+shaping.
+
+## Running it
+
+- **CI**: the Windows build job runs the harness in its normal `dotnet test` step (rhwp is fetched there). The
+  metrics table of each run is added to the job summary (`GITHUB_STEP_SUMMARY`) and to the test output.
+  rhwp's results depend on the installed fonts, so the thresholds are those of Windows and the rhwp tests are skipped
+  on Linux and macOS. The building blocks run everywhere.
+- **`FILEE_RENDER_FULL=1`**: the longer run. The script paragraphs are twelve times as long, a document of some pages
+  is added, and every feature is also rendered from a binary HWP. It takes about a minute.
+- **`FILEE_RENDER_OUT=<folder>`**: keeps every document, PDF and page picture (PNG at 100 dpi) for a look.
+- **Private corpus**: `pwsh build/render-compare.ps1 -Corpus <folder> -Open` (or `FILEE_RENDER_CORPUS`). The folder
+  holds documents next to the PDFs 한글 printed of them (`doc.hwpx` + `doc.pdf`, `doc.hwp` + `doc.pdf`). Each renderer
+  is compared with 한글's PDF and read back. An HTML report goes to the temp folder, with the page that differs most of
+  each document side by side. The corpus run only reports; it never fails on the numbers.
+
+## rhwp today
+
+rhwp 0.8.7 on Windows, the CI matrix. Every feature not listed meets the ideal in every check. That covers the
+three line-spacing rules (lines exactly one pitch apart), tabs, lists, tables, headers and footers, notes, columns,
+Korean, Chinese and Japanese, every font embedded and subset, and the HWP renderings of `line-spacing-percent`,
+`tables` and `script-ko` identical to their HWPX.
+
+| Feature | Measured |
+|---|---|
+| `floating` | overlaps 0.1265: square wrap isn't kept, and the two paragraphs after the floating objects are drawn on one line |
+| `equations` | overlaps 0.0303: *m* and *c* of the inline E = mc² overlap |
+| `script-ar` | overlaps 0.4867 (unshaped, #202) |
+| `script-he` | overlaps 0.6 (fixed half-em widths, rhwp#8143) |
+| `script-hi` | overlaps 0.6724 (unshaped, #185) |
+| `script-gu` | overlaps 0.6404 (unshaped, #185) |
+| `script-th` | text 0.9735 (ำ is drawn as its two parts), overlaps 0.214 |
+
+The full run adds the HWP renderings of every feature. From the HWP, rhwp draws 。 and 、 half an em over the next
+character, so no Chinese or Japanese line breaks where it does from the HWPX (lines 0, SSIM 0.23 and 0.19), and it
+places the equations differently (SSIM 0.50).
+
+Not checked yet: line-breaking rules (kinsoku: in both renderings above, a line of the Chinese paragraph starts with
+"，"), colours and pictures beyond SSIM, and tagged PDF.
diff --git a/tests/Filee.Engines.Tests/Filee.Engines.Tests.csproj b/tests/Filee.Engines.Tests/Filee.Engines.Tests.csproj
index 90946d300..ee77df756 100644
--- a/tests/Filee.Engines.Tests/Filee.Engines.Tests.csproj
+++ b/tests/Filee.Engines.Tests/Filee.Engines.Tests.csproj
@@ -25,5 +25,7 @@
     <None Update="Fonts\*.ttf;Fonts\*.otf;Fonts\*.woff2" CopyToOutputDirectory="PreserveNewest" />
     <!-- Small Shapefiles written by GDAL for the geospatial tests (synthetic data; Geo/make-test-geo.py recreates them). -->
     <None Update="Geo\*" CopyToOutputDirectory="PreserveNewest" />
+    <!-- What each renderer measured where it falls short of the ideal (RenderQuality/RenderThresholds.cs). -->
+    <None Update="RenderQuality\render-thresholds.json" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
 </Project>
diff --git a/tests/Filee.Engines.Tests/PdfPageWriterTests.cs b/tests/Filee.Engines.Tests/PdfPageWriterTests.cs
index 7bc23ffde..15427e56e 100644
--- a/tests/Filee.Engines.Tests/PdfPageWriterTests.cs
+++ b/tests/Filee.Engines.Tests/PdfPageWriterTests.cs
@@ -2,17 +2,15 @@
 // acceptance page of the "PDF backend and font subsetting" spike is built here in code: one A4 page with Korean, Latin,
 // Arabic and Devanagari paragraphs shaped by HarfBuzz, a link, outline entries and some non-text drawing. It needs
 // installed fonts (Malgun Gothic, Segoe UI, Nirmala UI on Windows) and is skipped where they are missing, like the other
-// font-dependent tests. Set FILEE_RENDER_OUT to a folder to keep the PDFs for a look in other viewers.
+// font-dependent tests. The page also goes through the render quality harness's read-back checks (RenderQuality/).
+// Set FILEE_RENDER_OUT to a folder to keep the PDFs for a look in other viewers.
 
-using System.Runtime.InteropServices;
 using System.Text;
 using Filee.Engines.Rendering;
-using HarfBuzzSharp;
+using Filee.Engines.Tests.RenderQuality;
 using PdfSharp.Pdf.IO;
 using PDFtoImage;
 using SkiaSharp;
-using UglyToad.PdfPig.Content;
-using Buffer = HarfBuzzSharp.Buffer;
 using PdfPigDocument = UglyToad.PdfPig.PdfDocument;
 
 #pragma warning disable CA1416
@@ -44,7 +42,7 @@ public sealed class PdfPageWriterTests : IDisposable
         "फ़ाइली खोजने योग्य पीडीएफ़ फ़ाइलें लिखता है: हर फ़ॉन्ट का केवल वह हिस्सा जोड़ा जाता है जिसके अक्षर पृष्ठ पर " +
         "इस्तेमाल हुए हैं। हिन्दी में संयुक्ताक्षर जैसे क्ष, त्र, ज्ञ और श्र भी सही दिखने चाहिए।";
 
-    private readonly Shaper _shaper = new();
+    private readonly TestShaper _shaper = new();
 
     public void Dispose() => _shaper.Dispose();
 
@@ -77,7 +75,7 @@ public void Mixed_script_a4_page_is_small_searchable_and_looks_right(string kore
 
         // Under 200 KB with every font embedded and subset.
         Assert.True(pdf.Length < 200_000, $"{pdf.Length:N0} bytes");
-        var fonts = Fonts(pdf);
+        var fonts = PdfChecks.ListFonts(pdf);
         Assert.Equal(3, fonts.Count);
         foreach (var font in fonts)
         {
@@ -88,13 +86,26 @@ public void Mixed_script_a4_page_is_small_searchable_and_looks_right(string kore
         Assert.True(fonts.Sum(f => f.Length) < new FileInfo(korean!).Length / 10);
 
         // The exact source text, Arabic in logical order, clusters whole.
-        Assert.Equal(text, ReadBack(pdf));
+        Assert.Equal(text, PdfLines.Text(pdf));
+
+        // The render quality harness's read-back checks: the text, no glyphs drawn over each other, everything inside
+        // the page and its 50 pt margins, every font embedded and subset. Segoe UI kerns reh and zain 0.08 em under a
+        // letter that doesn't join them, so overlaps up to 0.1 em are the font's own.
+        Assert.All(new[]
+        {
+            PdfChecks.TextRoundTrip(pdf, text),
+            PdfChecks.OverlappingGlyphs(pdf, tolerance: 0.1),
+            PdfChecks.GlyphsOutsidePage(pdf),
+            PdfChecks.GlyphsOutsideMargins(pdf, new PageMargins(Margin, Margin, Margin, Margin)),
+            PdfChecks.PageCount(pdf, 1),
+            PdfChecks.FontsEmbeddedAndSubset(pdf),
+        }, check => Assert.True(check.Ok, check.ToString()));
 
         // PDFium draws what Skia draws (rendered at 3× and averaged down, so rasterizer anti-aliasing differences fade).
         const int Dpi = 100;
         using var pdfium = Conversion.ToImage(pdf, 0, null, new RenderOptions(Dpi: 3 * Dpi, WithAnnotations: false, BackgroundColor: SKColors.White));
         using var skia = Raster(page, 3 * Dpi);
-        var (ssim, off) = Compare(Downsample(pdfium, 3), Downsample(skia, 3));
+        var (ssim, off) = Ssim.Compare(GreyImage.From(pdfium, 3), GreyImage.From(skia, 3));
         Assert.True(ssim > 0.9 && off < 0.01, $"SSIM {ssim:F4}, {off:P2} of the pixels differ");
     }
 
@@ -148,10 +159,10 @@ public void Cff_font_is_embedded_as_a_truetype_subset()
 
         var pdf = Write([page]);
 
-        var font = Assert.Single(Fonts(pdf));
+        var font = Assert.Single(PdfChecks.ListFonts(pdf));
         Assert.Equal("/Type0", font.Subtype);
         Assert.Equal("/FontFile2", font.File);
-        Assert.Equal("Filee 한글 변환", ReadBack(pdf));
+        Assert.Equal("Filee 한글 변환", PdfLines.Text(pdf));
     }
 
     [Fact]
@@ -257,66 +268,6 @@ private List<string> Lines(PageFont font, float size, string body, float maxWidt
         return lines;
     }
 
-    /// <summary>HarfBuzz shaping of one run in one font (the layout engine's shaper is a later step).</summary>
-    private sealed class Shaper : IDisposable
-    {
-        private readonly Dictionary<PageFont, (Blob Blob, Face Face, HarfBuzzSharp.Font Font)> _fonts = new(ReferenceEqualityComparer.Instance);
-
-        public float Width(PageFont font, float size, string text) => Shape(font, size, text, 0, 0).Width;
-
-        /// <summary>Shapes <paramref name="text"/> with the pen starting at x on baseline y (page coordinates).</summary>
-        public (GlyphRun Run, float Width) Shape(PageFont font, float size, string text, float x, float y, SKColor? color = null)
-        {
-            var (hb, upem) = For(font);
-            using var buffer = new Buffer();
-            buffer.AddUtf16(text);
-            buffer.GuessSegmentProperties();
-            hb.Shape(buffer);
-            var infos = buffer.GlyphInfos;
-            var positions = buffer.GlyphPositions;
-            var scale = size / upem;
-            var glyphs = new ushort[infos.Length];
-            var points = new SKPoint[infos.Length];
-            var clusters = new int[infos.Length];
-            var pen = 0f;
-            for (var i = 0; i < infos.Length; i++)
-            {
-                glyphs[i] = (ushort)infos[i].Codepoint;
-                clusters[i] = (int)infos[i].Cluster;
-                points[i] = new SKPoint(x + pen + positions[i].XOffset * scale, y - positions[i].YOffset * scale);
-                pen += positions[i].XAdvance * scale;
-            }
-            return (new GlyphRun(font, size, glyphs, points, text, clusters) { Color = color ?? SKColors.Black }, pen);
-        }
-
-        private (HarfBuzzSharp.Font Font, int Upem) For(PageFont font)
-        {
-            if (!_fonts.TryGetValue(font, out var entry))
-            {
-                // A native copy the blob owns: HarfBuzz reads the font data for as long as the face lives.
-                var memory = Marshal.AllocHGlobal(font.Data.Length);
-                Marshal.Copy(font.Data, 0, memory, font.Data.Length);
-                var blob = new Blob(memory, font.Data.Length, MemoryMode.ReadOnly, () => Marshal.FreeHGlobal(memory));
-                var face = new Face(blob, font.FaceIndex);
-                var hb = new HarfBuzzSharp.Font(face);
-                hb.SetScale(face.UnitsPerEm, face.UnitsPerEm);
-                hb.SetFunctionsOpenType();
-                _fonts[font] = entry = (blob, face, hb);
-            }
-            return (entry.Font, entry.Face.UnitsPerEm);
-        }
-
-        public void Dispose()
-        {
-            foreach (var (blob, face, font) in _fonts.Values)
-            {
-                font.Dispose();
-                face.Dispose();
-                blob.Dispose();
-            }
-        }
-    }
-
     // ───────────────────────── Checks ─────────────────────────
 
     private static byte[] Write(IReadOnlyList<PageContent> pages, PdfDocumentInfo? info = null)
@@ -358,66 +309,6 @@ private static void Keep(byte[] pdf, string name)
         return null;
     }
 
-    private sealed record FontInfo(string BaseFont, string Subtype, string? File, int Length);
-
-    /// <summary>The fonts of every page: Type 0 fonts are described by their descendant.</summary>
-    private static List<FontInfo> Fonts(byte[] pdf)
-    {
-        using var document = PdfReader.Open(new MemoryStream(pdf), PdfDocumentOpenMode.Import);
-        var result = new List<FontInfo>();
-        foreach (var page in document.Pages)
-        {
-            if (page.Resources.Elements.GetDictionary("/Font") is not { } fonts)
-                continue;
-            foreach (var key in fonts.Elements.Keys)
-            {
-                var font = fonts.Elements.GetDictionary(key)!;
-                var subtype = font.Elements.GetName("/Subtype");
-                var described = subtype == "/Type0" ? font.Elements.GetArray("/DescendantFonts")!.Elements.GetDictionary(0)! : font;
-                var descriptor = described.Elements.GetDictionary("/FontDescriptor");
-                var file = new[] { "/FontFile", "/FontFile2", "/FontFile3" }.FirstOrDefault(k => descriptor?.Elements.GetDictionary(k) is not null);
-                result.Add(new FontInfo(font.Elements.GetName("/BaseFont"), subtype, file, file is null ? 0 : descriptor!.Elements.GetDictionary(file)!.Stream.Length));
-            }
-        }
-        return result;
-    }
-
-    /// <summary>The text in content-stream order, the glyphs of each /ActualText span replaced by its text.</summary>
-    private static string ReadBack(byte[] pdf)
-    {
-        using var document = PdfPigDocument.Open(pdf);
-        var result = new StringBuilder();
-        foreach (var page in document.GetPages())
-        {
-            var spans = new Dictionary<Letter, MarkedContentElement>(ReferenceEqualityComparer.Instance);
-            void Walk(IEnumerable<MarkedContentElement> elements)
-            {
-                foreach (var element in elements)
-                {
-                    if (element.ActualText is null)
-                    {
-                        Walk(element.Children);
-                        continue;
-                    }
-                    foreach (var letter in All(element))
-                        spans.TryAdd(letter, element);
-                }
-            }
-            Walk(page.GetMarkedContents());
-            var done = new HashSet<MarkedContentElement>(ReferenceEqualityComparer.Instance);
-            foreach (var letter in page.Letters)
-            {
-                if (!spans.TryGetValue(letter, out var span))
-                    result.Append(letter.Value);
-                else if (done.Add(span))
-                    result.Append(span.ActualText);
-            }
-        }
-        return result.ToString();
-
-        static IEnumerable<Letter> All(MarkedContentElement element) => element.Letters.Concat(element.Children.SelectMany(All));
-    }
-
     private static SKBitmap Raster(PageContent page, int dpi)
     {
         var scale = dpi / 72f;
@@ -428,79 +319,4 @@ private static SKBitmap Raster(PageContent page, int dpi)
         page.Draw(canvas);
         return bitmap;
     }
-
-    /// <summary>Grey levels averaged over <paramref name="factor"/>² blocks.</summary>
-    private static (int Width, int Height, double[] Grey) Downsample(SKBitmap bitmap, int factor)
-    {
-        using var grey = new SKBitmap(bitmap.Width, bitmap.Height, SKColorType.Gray8, SKAlphaType.Opaque);
-        using (var canvas = new SKCanvas(grey))
-            canvas.DrawBitmap(bitmap, 0, 0);
-        var pixels = grey.GetPixelSpan();
-        var stride = grey.RowBytes;
-        int width = bitmap.Width / factor, height = bitmap.Height / factor;
-        var result = new double[width * height];
-        for (var y = 0; y < height; y++)
-        {
-            for (var x = 0; x < width; x++)
-            {
-                var sum = 0;
-                for (var j = 0; j < factor; j++)
-                    for (var i = 0; i < factor; i++)
-                        sum += pixels[(y * factor + j) * stride + x * factor + i];
-                result[y * width + x] = (double)sum / (factor * factor);
-            }
-        }
-        return (width, height, result);
-    }
-
-    /// <summary>
-    /// Mean SSIM over 8×8 windows (step 4) that have ink in either picture, and the share of pixels whose grey levels
-    /// differ by more than 64.
-    /// </summary>
-    private static (double Ssim, double Off) Compare((int Width, int Height, double[] Grey) a, (int Width, int Height, double[] Grey) b)
-    {
-        int w = Math.Min(a.Width, b.Width), h = Math.Min(a.Height, b.Height);
-        double At((int Width, int Height, double[] Grey) p, int x, int y) => p.Grey[y * p.Width + x];
-        const double C1 = 6.5025, C2 = 58.5225;
-        double sum = 0;
-        var windows = 0;
-        for (var y = 0; y + 8 <= h; y += 4)
-        {
-            for (var x = 0; x + 8 <= w; x += 4)
-            {
-                double ma = 0, mb = 0;
-                for (var j = 0; j < 8; j++)
-                    for (var i = 0; i < 8; i++)
-                    {
-                        ma += At(a, x + i, y + j);
-                        mb += At(b, x + i, y + j);
-                    }
-                ma /= 64;
-                mb /= 64;
-                double va = 0, vb = 0, cov = 0;
-                for (var j = 0; j < 8; j++)
-                    for (var i = 0; i < 8; i++)
-                    {
-                        var da = At(a, x + i, y + j) - ma;
-                        var db = At(b, x + i, y + j) - mb;
-                        va += da * da;
-                        vb += db * db;
-                        cov += da * db;
-                    }
-                if (va + vb < 1e-9 && ma > 250 && mb > 250)
-                    continue;
-                va /= 63;
-                vb /= 63;
-                cov /= 63;
-                sum += (2 * ma * mb + C1) * (2 * cov + C2) / ((ma * ma + mb * mb + C1) * (va + vb + C2));
-                windows++;
-            }
-        }
-        var off = 0;
-        for (var y = 0; y < h; y++)
-            for (var x = 0; x < w; x++)
-                if (Math.Abs(At(a, x, y) - At(b, x, y)) > 64)
-                    off++;
-        return (windows == 0 ? 1 : sum / windows, (double)off / (w * h));
-    }
 }
diff --git a/tests/Filee.Engines.Tests/RenderQuality/DocumentRenderers.cs b/tests/Filee.Engines.Tests/RenderQuality/DocumentRenderers.cs
new file mode 100644
index 000000000..f037cfcf8
--- /dev/null
+++ b/tests/Filee.Engines.Tests/RenderQuality/DocumentRenderers.cs
@@ -0,0 +1,86 @@
+// The renderers the render quality harness measures. rhwp is the reference while it is still bundled: it renders a
+// document the way Filee's users get it today (RhwpInput's fixes, then rhwp export-pdf with Filee's fallback fonts).
+// It is used here only as a yardstick; no conversion path is added through it.
+//
+// Filee's own layout engine plugs in at one place, Candidate below: a renderer takes a document (HWPX or HWP, with
+// its layout model read on demand) and returns a PDF. Each layout milestone registers what it can render there, and
+// the differential compare and the read-back checks pick it up without other changes.
+
+using Filee.Engines.Hwp;
+using Filee.Engines.Hwp.Hwpx;
+using Filee.Engines.Infrastructure;
+
+namespace Filee.Engines.Tests.RenderQuality;
+
+/// <summary>A document to render: the file, its format and (read when first asked for) its layout model.</summary>
+internal sealed class RenderInput(string path, string workDirectory)
+{
+    private HDocument? _document;
+
+    public string Path { get; } = path;
+
+    /// <summary>"hwpx" or "hwp".</summary>
+    public string Format { get; } = System.IO.Path.GetExtension(path).TrimStart('.').ToLowerInvariant();
+
+    /// <summary>A folder of this input's own for temporary files.</summary>
+    public string WorkDirectory { get; } = workDirectory;
+
+    /// <summary>The document read for layout (HWPX only, until there is an HWP reader).</summary>
+    public HDocument Document => _document ??= Format == "hwpx"
+        ? HwpxReader.ReadForLayout(Path, System.IO.Path.Combine(WorkDirectory, "media"))
+        : throw new NotSupportedException("Only HWPX documents are read for layout.");
+}
+
+/// <summary>Renders a document to PDF bytes.</summary>
+internal delegate Task<byte[]> RenderDocument(RenderInput input, CancellationToken cancellationToken);
+
+/// <param name="Formats">Input formats the renderer takes ("hwpx", "hwp").</param>
+internal sealed record DocumentRenderer(string Name, IReadOnlySet<string> Formats, RenderDocument Render);
+
+internal static class DocumentRenderers
+{
+    /// <summary>
+    /// Filee's layout engine, measured against <see cref="Reference"/>; null until its first milestone registers a
+    /// renderer here (for example <c>new("filee", Hwpx, (input, ct) =&gt; Task.FromResult(FileeRenderer.ToPdf(input.Document, ct)))</c>).
+    /// </summary>
+    public static DocumentRenderer? Candidate => null;
+
+    /// <summary>Why the differential compare doesn't run while <see cref="Candidate"/> is null.</summary>
+    public const string NoCandidate =
+        "Filee's layout engine has no renderer yet: the first layout milestone registers one in DocumentRenderers.Candidate";
+
+    public static readonly IReadOnlySet<string> Hwpx = new HashSet<string>(["hwpx"]);
+    public static readonly IReadOnlySet<string> HwpxAndHwp = new HashSet<string>(["hwpx", "hwp"]);
+
+    /// <summary>rhwp as Filee runs it, or null when rhwp isn't there (fetch it with build/fetch-engines.ps1 -Only rhwp).</summary>
+    public static DocumentRenderer? Reference => RhwpExecutable() is { } exe ? new DocumentRenderer("rhwp", HwpxAndHwp, (input, ct) => RhwpPdfAsync(exe, input, ct)) : null;
+
+    /// <summary>The bundled rhwp executable, or null.</summary>
+    public static string? RhwpExecutable() =>
+        EngineEnvironment.FindBundled("rhwp") is { } folder && Path.Combine(folder, OperatingSystem.IsWindows() ? "rhwp.exe" : "rhwp") is var exe && File.Exists(exe)
+            ? exe
+            : null;
+
+    private static async Task<byte[]> RhwpPdfAsync(string exe, RenderInput input, CancellationToken cancellationToken)
+    {
+        // The same input Filee gives rhwp: an HWPX with RhwpInput's fixes when it needs any (an HWP as it is).
+        var source = input.Format == "hwpx" ? RhwpInput.Prepare(input.Path, input.WorkDirectory) ?? input.Path : input.Path;
+        var pdf = Path.Combine(input.WorkDirectory, $"rhwp-{Guid.NewGuid():N}.pdf");
+        var result = await ProcessRunner.RunAsync(exe, ["export-pdf", source, "-o", pdf, .. RhwpInput.PdfOptions()],
+            RhwpConverter.TimeLimit(RhwpConverter.TextSize(source)), cancellationToken);
+        if (!File.Exists(pdf) || new FileInfo(pdf).Length == 0)
+            throw new InvalidOperationException($"rhwp failed (exit {result.ExitCode}): {result.StandardError.Trim()}");
+        return await File.ReadAllBytesAsync(pdf, cancellationToken);
+    }
+
+    /// <summary>A binary HWP made from <paramref name="hwpx"/> with <c>rhwp convert</c> (inputs for the HWP reader).</summary>
+    public static async Task<string> ConvertToHwpAsync(string hwpx, CancellationToken cancellationToken)
+    {
+        var exe = RhwpExecutable() ?? throw new InvalidOperationException("rhwp not found");
+        var hwp = Path.ChangeExtension(hwpx, ".hwp");
+        var result = await ProcessRunner.RunAsync(exe, ["convert", hwpx, hwp], TimeSpan.FromMinutes(2), cancellationToken);
+        if (!File.Exists(hwp) || new FileInfo(hwp).Length == 0)
+            throw new InvalidOperationException($"rhwp convert failed (exit {result.ExitCode}): {result.StandardError.Trim()}");
+        return hwp;
+    }
+}
diff --git a/tests/Filee.Engines.Tests/RenderQuality/PageImage.cs b/tests/Filee.Engines.Tests/RenderQuality/PageImage.cs
new file mode 100644
index 000000000..bba23baf2
--- /dev/null
+++ b/tests/Filee.Engines.Tests/RenderQuality/PageImage.cs
@@ -0,0 +1,129 @@
+// Pages as grey pictures and how alike two of them look: PDFium (PDFtoImage) rasterises the PDF, and the structural
+// similarity index (SSIM) compares the pictures window by window. Windows blank in both pictures are left out, so a
+// page with little text isn't rated alike just for its white paper.
+
+using PDFtoImage;
+using SkiaSharp;
+
+#pragma warning disable CA1416 // PDFtoImage runs on Windows, Linux and macOS, the platforms the tests run on
+
+namespace Filee.Engines.Tests.RenderQuality;
+
+/// <summary>A grey picture: one level per pixel, 0 black to 255 white.</summary>
+internal sealed record GreyImage(int Width, int Height, double[] Pixels)
+{
+    public double this[int x, int y] => Pixels[y * Width + x];
+
+    /// <summary>Grey levels of <paramref name="bitmap"/> averaged over <paramref name="factor"/>² blocks.</summary>
+    public static GreyImage From(SKBitmap bitmap, int factor = 1)
+    {
+        using var grey = new SKBitmap(bitmap.Width, bitmap.Height, SKColorType.Gray8, SKAlphaType.Opaque);
+        using (var canvas = new SKCanvas(grey))
+        {
+            canvas.Clear(SKColors.White);
+            canvas.DrawBitmap(bitmap, 0, 0);
+        }
+        var pixels = grey.GetPixelSpan();
+        var stride = grey.RowBytes;
+        int width = bitmap.Width / factor, height = bitmap.Height / factor;
+        var result = new double[width * height];
+        for (var y = 0; y < height; y++)
+        {
+            for (var x = 0; x < width; x++)
+            {
+                var sum = 0;
+                for (var j = 0; j < factor; j++)
+                    for (var i = 0; i < factor; i++)
+                        sum += pixels[(y * factor + j) * stride + x * factor + i];
+                result[y * width + x] = (double)sum / (factor * factor);
+            }
+        }
+        return new GreyImage(width, height, result);
+    }
+
+    /// <summary>Every page of <paramref name="pdf"/> drawn by PDFium on white at <paramref name="dpi"/>.</summary>
+    public static List<GreyImage> Pages(byte[] pdf, int dpi = 100)
+    {
+        var pages = new List<GreyImage>();
+        foreach (var bitmap in Conversion.ToImages(pdf, null, new RenderOptions(Dpi: dpi, WithAnnotations: false, BackgroundColor: SKColors.White)))
+        {
+            using (bitmap)
+                pages.Add(From(bitmap));
+        }
+        return pages;
+    }
+
+    /// <summary>The picture as a PNG (for reports).</summary>
+    public byte[] ToPng()
+    {
+        using var bitmap = new SKBitmap(Width, Height, SKColorType.Gray8, SKAlphaType.Opaque);
+        var span = bitmap.GetPixelSpan();
+        var stride = bitmap.RowBytes;
+        for (var y = 0; y < Height; y++)
+            for (var x = 0; x < Width; x++)
+                span[y * stride + x] = (byte)Math.Clamp(Math.Round(this[x, y]), 0, 255);
+        using var data = bitmap.Encode(SKEncodedImageFormat.Png, 100);
+        return data.ToArray();
+    }
+}
+
+internal static class Ssim
+{
+    private const int Window = 8, Step = 4;
+
+    // The usual constants for 8-bit pictures: (0.01 × 255)² and (0.03 × 255)².
+    private const double C1 = 6.5025, C2 = 58.5225;
+
+    /// <summary>
+    /// Mean SSIM over 8×8 windows (step 4) that have ink in either picture, and the share of pixels whose grey levels
+    /// differ by more than 64. Pictures of different sizes are compared over the area they share.
+    /// </summary>
+    public static (double Ssim, double Off) Compare(GreyImage a, GreyImage b)
+    {
+        int w = Math.Min(a.Width, b.Width), h = Math.Min(a.Height, b.Height);
+        double sum = 0;
+        var windows = 0;
+        for (var y = 0; y + Window <= h; y += Step)
+        {
+            for (var x = 0; x + Window <= w; x += Step)
+            {
+                double ma = 0, mb = 0;
+                for (var j = 0; j < Window; j++)
+                {
+                    for (var i = 0; i < Window; i++)
+                    {
+                        ma += a[x + i, y + j];
+                        mb += b[x + i, y + j];
+                    }
+                }
+                ma /= Window * Window;
+                mb /= Window * Window;
+                double va = 0, vb = 0, cov = 0;
+                for (var j = 0; j < Window; j++)
+                {
+                    for (var i = 0; i < Window; i++)
+                    {
+                        var da = a[x + i, y + j] - ma;
+                        var db = b[x + i, y + j] - mb;
+                        va += da * da;
+                        vb += db * db;
+                        cov += da * db;
+                    }
+                }
+                if (va + vb < 1e-9 && ma > 250 && mb > 250)
+                    continue; // paper in both
+                va /= Window * Window - 1;
+                vb /= Window * Window - 1;
+                cov /= Window * Window - 1;
+                sum += (2 * ma * mb + C1) * (2 * cov + C2) / ((ma * ma + mb * mb + C1) * (va + vb + C2));
+                windows++;
+            }
+        }
+        var off = 0;
+        for (var y = 0; y < h; y++)
+            for (var x = 0; x < w; x++)
+                if (Math.Abs(a[x, y] - b[x, y]) > 64)
+                    off++;
+        return (windows == 0 ? 1 : sum / windows, w * h == 0 ? 0 : (double)off / (w * h));
+    }
+}
diff --git a/tests/Filee.Engines.Tests/RenderQuality/PdfChecks.cs b/tests/Filee.Engines.Tests/RenderQuality/PdfChecks.cs
new file mode 100644
index 000000000..e72042870
--- /dev/null
+++ b/tests/Filee.Engines.Tests/RenderQuality/PdfChecks.cs
@@ -0,0 +1,250 @@
+// Read-back checks of a rendered PDF (PdfPig and PDFsharp): each takes the PDF (and what the document asks for) and
+// returns a measured value, whether it meets the ideal, and the first offenders. The render quality tests compare the
+// values with the thresholds in render-thresholds.json; the checks themselves are tested on PDFs built in code
+// (RenderChecksTests).
+
+using System.Globalization;
+using System.Text;
+using PdfSharp.Pdf.IO;
+using UglyToad.PdfPig;
+using UglyToad.PdfPig.Content;
+
+namespace Filee.Engines.Tests.RenderQuality;
+
+/// <summary>A measured value; <paramref name="Ok"/> when it meets the ideal (no overlaps, the exact text, ...).</summary>
+internal sealed record CheckResult(string Name, double Value, bool Ok, string Detail)
+{
+    public override string ToString() => $"{Name} = {Value.ToString("0.####", CultureInfo.InvariantCulture)}{(Detail.Length > 0 ? $" ({Detail})" : "")}";
+}
+
+/// <summary>The body of a page in points from its edges: the paper less 한글's margins (header and footer areas inside).</summary>
+internal readonly record struct PageMargins(double Left, double Top, double Right, double Bottom);
+
+/// <summary>An embedded font as the PDF describes it (a Type 0 font by its descendant).</summary>
+internal sealed record PdfFontInfo(string BaseFont, string Subtype, string? File, int Length)
+{
+    /// <summary>The font program is in the file. Type 3 fonts carry their glyphs as drawing procedures.</summary>
+    public bool Embedded => File is not null || Subtype == "/Type3";
+
+    /// <summary>Only the used glyphs are embedded: a subset tag (ABCDEF+), or a Type 3 font (one procedure per glyph drawn).</summary>
+    public bool Subset => Subtype == "/Type3" || (BaseFont.Length > 8 && BaseFont[7] == '+' && BaseFont[1..7].All(char.IsAsciiLetterUpper));
+}
+
+internal static class PdfChecks
+{
+    public const string Text = "text";
+    public const string Overlaps = "overlaps";
+    public const string OutsidePage = "outside-page";
+    public const string OutsideMargins = "outside-margins";
+    public const string Pages = "pages";
+    public const string Baselines = "baselines";
+    public const string Fonts = "fonts";
+
+    private const int Examples = 3;
+
+    /// <summary>
+    /// Share of the expected text (white space left out) found in the PDF's text in the same order. Text the document
+    /// adds (list numbers, headers, page numbers) doesn't count against it.
+    /// </summary>
+    public static CheckResult TextRoundTrip(byte[] pdf, string expected)
+    {
+        var want = PdfLines.Normalise(expected);
+        var got = PdfLines.Normalise(PdfLines.Text(pdf));
+        if (want.Length == 0)
+            return new CheckResult(Text, 1, true, "");
+        var (pairs, exact) = SequenceMatch.Match(want.ToCharArray(), got.ToCharArray());
+        var missing = new StringBuilder();
+        var matched = new bool[want.Length];
+        foreach (var (a, _) in pairs)
+            matched[a] = true;
+        for (var i = 0; i < want.Length && missing.Length < 40; i++)
+            if (!matched[i])
+                missing.Append(want[i]);
+        var share = (double)pairs.Count / want.Length;
+        var detail = share >= 1 ? "" : $"missing \"{missing}\"{(exact ? "" : ", approximate")}";
+        return new CheckResult(Text, share, share >= 1, detail);
+    }
+
+    /// <summary>
+    /// Share of neighbouring glyphs on a line whose advances overlap by more than <paramref name="tolerance"/> em (a
+    /// share, so documents of any length compare). Marks and other glyphs without an advance are left out: they sit on
+    /// their base by design. Kerning deeper than the tolerance counts too.
+    /// </summary>
+    public static CheckResult OverlappingGlyphs(byte[] pdf, double tolerance = 0.05)
+    {
+        int count = 0, pairs = 0;
+        var examples = new List<string>();
+        foreach (var line in PdfLines.Read(pdf))
+        {
+            var glyphs = line.Letters
+                .Where(l => Math.Abs(l.EndBaseLine.X - l.StartBaseLine.X) > 0.01 * PdfLines.Size(l))
+                .OrderBy(l => Math.Min(l.StartBaseLine.X, l.EndBaseLine.X))
+                .ToList();
+            for (var i = 1; i < glyphs.Count; i++)
+            {
+                pairs++;
+                var previous = glyphs[i - 1];
+                var next = glyphs[i];
+                var overlap = Math.Max(previous.StartBaseLine.X, previous.EndBaseLine.X) - Math.Min(next.StartBaseLine.X, next.EndBaseLine.X);
+                var em = Math.Max(PdfLines.Size(previous), PdfLines.Size(next));
+                if (overlap <= tolerance * em)
+                    continue;
+                count++;
+                if (examples.Count < Examples)
+                    examples.Add(string.Create(CultureInfo.InvariantCulture, $"p{line.Page + 1} \"{previous.Value}{next.Value}\" {overlap / em:0.##} em"));
+            }
+        }
+        var detail = count == 0 ? "" : $"{count} of {pairs} pairs: {string.Join(", ", examples)}";
+        return new CheckResult(Overlaps, pairs == 0 ? 0 : (double)count / pairs, count == 0, detail);
+    }
+
+    /// <summary>Glyphs whose outline leaves the page by more than <paramref name="tolerance"/> points.</summary>
+    public static CheckResult GlyphsOutsidePage(byte[] pdf, double tolerance = 0.5)
+    {
+        var count = 0;
+        var examples = new List<string>();
+        using var document = PdfDocument.Open(pdf);
+        foreach (var page in document.GetPages())
+        {
+            foreach (var letter in page.Letters.Where(l => !string.IsNullOrWhiteSpace(l.Value)))
+            {
+                var box = letter.BoundingBox;
+                if (box.Width <= 0 && box.Height <= 0)
+                    continue;
+                if (box.Left >= -tolerance && box.Bottom >= -tolerance && box.Right <= page.Width + tolerance && box.Top <= page.Height + tolerance)
+                    continue;
+                count++;
+                if (examples.Count < Examples)
+                    examples.Add(string.Create(CultureInfo.InvariantCulture, $"p{page.Number} \"{letter.Value}\" at {box.Left:0.#}, {page.Height - box.Top:0.#}"));
+            }
+        }
+        return new CheckResult(OutsidePage, count, count == 0, string.Join(", ", examples));
+    }
+
+    /// <summary>
+    /// Glyphs whose advance or baseline lies outside the body by more than <paramref name="tolerance"/> points: the page
+    /// less its margins, with the header and footer areas (which 한글 puts inside the top and bottom margins).
+    /// </summary>
+    public static CheckResult GlyphsOutsideMargins(byte[] pdf, PageMargins margins, double tolerance = 1)
+    {
+        var count = 0;
+        var examples = new List<string>();
+        using var document = PdfDocument.Open(pdf);
+        foreach (var page in document.GetPages())
+        {
+            double left = margins.Left - tolerance, right = page.Width - margins.Right + tolerance;
+            double top = margins.Top - tolerance, bottom = page.Height - margins.Bottom + tolerance;
+            foreach (var letter in page.Letters.Where(l => !string.IsNullOrWhiteSpace(l.Value)))
+            {
+                var start = Math.Min(letter.StartBaseLine.X, letter.EndBaseLine.X);
+                var end = Math.Max(letter.StartBaseLine.X, letter.EndBaseLine.X);
+                var baseline = page.Height - letter.StartBaseLine.Y;
+                if (start >= left && end <= right && baseline >= top && baseline <= bottom)
+                    continue;
+                count++;
+                if (examples.Count < Examples)
+                    examples.Add(string.Create(CultureInfo.InvariantCulture, $"p{page.Number} \"{letter.Value}\" at {start:0.#}, {baseline:0.#}"));
+            }
+        }
+        return new CheckResult(OutsideMargins, count, count == 0, string.Join(", ", examples));
+    }
+
+    /// <summary>The number of pages, ideal when it is <paramref name="expected"/>.</summary>
+    public static CheckResult PageCount(byte[] pdf, int expected)
+    {
+        using var document = PdfDocument.Open(pdf);
+        var pages = document.NumberOfPages;
+        return new CheckResult(Pages, pages, pages == expected, pages == expected ? "" : $"expected {expected}");
+    }
+
+    /// <summary>
+    /// Share of the expected baselines (points from the top of a page, in reading order) met within
+    /// <paramref name="tolerance"/> points by the line at the same position. Missing or extra lines count as misses.
+    /// </summary>
+    public static CheckResult BaselinesMatch(IReadOnlyList<double> actual, IReadOnlyList<double> expected, double tolerance = 0.5)
+    {
+        var total = Math.Max(actual.Count, expected.Count);
+        if (total == 0)
+            return new CheckResult(Baselines, 1, true, "");
+        var met = 0;
+        var examples = new List<string>();
+        for (var i = 0; i < Math.Min(actual.Count, expected.Count); i++)
+        {
+            if (Math.Abs(actual[i] - expected[i]) <= tolerance)
+                met++;
+            else if (examples.Count < Examples)
+                examples.Add(string.Create(CultureInfo.InvariantCulture, $"line {i + 1} at {actual[i]:0.##}, expected {expected[i]:0.##}"));
+        }
+        if (actual.Count != expected.Count)
+            examples.Add($"{actual.Count} lines, expected {expected.Count}");
+        var share = (double)met / total;
+        return new CheckResult(Baselines, share, met == total, string.Join(", ", examples));
+    }
+
+    /// <summary>
+    /// Lines of each page <paramref name="pitch"/> points apart from the page's first line (a document whose lines all
+    /// have one fixed height): the baselines check against the grid the document asks for.
+    /// </summary>
+    public static CheckResult BaselinePitch(byte[] pdf, double pitch, double tolerance = 0.5)
+    {
+        var lines = PdfLines.Read(pdf);
+        var actual = new List<double>();
+        var expected = new List<double>();
+        foreach (var page in lines.GroupBy(l => l.Page))
+        {
+            var first = page.First().Baseline;
+            var i = 0;
+            foreach (var line in page)
+            {
+                actual.Add(line.Baseline);
+                expected.Add(first + i++ * pitch);
+            }
+        }
+        return BaselinesMatch(actual, expected, tolerance);
+    }
+
+    /// <summary>Fonts that aren't embedded or aren't subset (Type 3 fonts count as both).</summary>
+    public static CheckResult FontsEmbeddedAndSubset(byte[] pdf)
+    {
+        var fonts = ListFonts(pdf);
+        var bad = fonts.Where(f => !f.Embedded || !f.Subset).ToList();
+        var detail = string.Join(", ", bad.Take(Examples).Select(f => $"{f.BaseFont.TrimStart('/')} {(f.Embedded ? "not subset" : "not embedded")}"));
+        return new CheckResult(Fonts, bad.Count, bad.Count == 0, fonts.Count == 0 ? "no fonts" : detail);
+    }
+
+    /// <summary>The fonts of every page, each once.</summary>
+    public static List<PdfFontInfo> ListFonts(byte[] pdf)
+    {
+        using var document = PdfReader.Open(new MemoryStream(pdf), PdfDocumentOpenMode.Import);
+        var result = new List<PdfFontInfo>();
+        var seen = new HashSet<PdfSharp.Pdf.PdfDictionary>(ReferenceEqualityComparer.Instance);
+        void Collect(PdfSharp.Pdf.PdfDictionary? resources, int depth)
+        {
+            if (resources is null || depth > 8)
+                return;
+            if (resources.Elements.GetDictionary("/Font") is { } fonts)
+            {
+                foreach (var key in fonts.Elements.Keys)
+                {
+                    var font = fonts.Elements.GetDictionary(key)!;
+                    if (!seen.Add(font))
+                        continue;
+                    var subtype = font.Elements.GetName("/Subtype");
+                    var described = subtype == "/Type0" ? font.Elements.GetArray("/DescendantFonts")!.Elements.GetDictionary(0)! : font;
+                    var descriptor = described.Elements.GetDictionary("/FontDescriptor");
+                    var file = new[] { "/FontFile", "/FontFile2", "/FontFile3" }.FirstOrDefault(k => descriptor?.Elements.GetDictionary(k) is not null);
+                    result.Add(new PdfFontInfo(font.Elements.GetName("/BaseFont"), subtype, file,
+                        file is null ? 0 : descriptor!.Elements.GetDictionary(file)!.Stream.Length));
+                }
+            }
+            // Fonts used inside form XObjects (some writers draw each page or each glyph run as one).
+            if (resources.Elements.GetDictionary("/XObject") is { } objects)
+                foreach (var key in objects.Elements.Keys)
+                    if (objects.Elements.GetDictionary(key) is { } form && form.Elements.GetName("/Subtype") == "/Form")
+                        Collect(form.Elements.GetDictionary("/Resources"), depth + 1);
+        }
+        foreach (var page in document.Pages)
+            Collect(page.Resources, 0);
+        return result;
+    }
+}
diff --git a/tests/Filee.Engines.Tests/RenderQuality/PdfLines.cs b/tests/Filee.Engines.Tests/RenderQuality/PdfLines.cs
new file mode 100644
index 000000000..25c0d7b4d
--- /dev/null
+++ b/tests/Filee.Engines.Tests/RenderQuality/PdfLines.cs
@@ -0,0 +1,122 @@
+// What the render checks read back from a PDF with PdfPig: the text in content order (with /ActualText spans in place
+// of their glyphs, as Filee's page writer marks ligatures, Indic clusters and Arabic forms), and the text lines of
+// each page: letters on one baseline, measured from the top of the page like the layout engine measures.
+
+using System.Globalization;
+using System.Text;
+using UglyToad.PdfPig;
+using UglyToad.PdfPig.Content;
+
+namespace Filee.Engines.Tests.RenderQuality;
+
+/// <summary>One line of text on a page: letters sharing a baseline, in content order.</summary>
+/// <param name="Page">0-based page index.</param>
+/// <param name="Baseline">Baseline in points from the top of the page.</param>
+/// <param name="Size">Largest letter size on the line, in points.</param>
+/// <param name="Letters">The letters, in content-stream order.</param>
+internal sealed record TextLine(int Page, double Baseline, double Size, IReadOnlyList<Letter> Letters)
+{
+    /// <summary>The line's text without white space, normalised (NFC): what two renderers of one document share.</summary>
+    public string Key { get; } = PdfLines.Normalise(string.Concat(Letters.Select(l => l.Value)));
+}
+
+internal static class PdfLines
+{
+    /// <summary>A letter belongs to a line when its baseline is within this share of the line's size.</summary>
+    private const double SameLine = 0.35;
+
+    /// <summary>The text lines of every page, top to bottom; lines without visible text are left out.</summary>
+    public static List<TextLine> Read(byte[] pdf)
+    {
+        using var document = PdfDocument.Open(pdf);
+        var lines = new List<TextLine>();
+        foreach (var page in document.GetPages())
+            lines.AddRange(Read(page, page.Number - 1));
+        return lines;
+    }
+
+    /// <summary>The text lines of one page, top to bottom.</summary>
+    public static List<TextLine> Read(Page page, int index)
+    {
+        var height = page.Height;
+        var letters = page.Letters
+            .Select((letter, order) => (Letter: letter, Order: order, Baseline: height - letter.StartBaseLine.Y))
+            .Where(l => l.Letter.TextOrientation == TextOrientation.Horizontal && !string.IsNullOrWhiteSpace(l.Letter.Value))
+            .OrderBy(l => l.Baseline)
+            .ToList();
+        var lines = new List<TextLine>();
+        var group = new List<(Letter Letter, int Order, double Baseline)>();
+        void Flush()
+        {
+            if (group.Count == 0)
+                return;
+            var baselines = group.Select(l => l.Baseline).Order().ToList();
+            var line = new TextLine(index, baselines[baselines.Count / 2], group.Max(l => Size(l.Letter)),
+                group.OrderBy(l => l.Order).Select(l => l.Letter).ToList());
+            if (line.Key.Length > 0)
+                lines.Add(line);
+            group.Clear();
+        }
+        foreach (var letter in letters)
+        {
+            if (group.Count > 0)
+            {
+                var size = Math.Max(Size(letter.Letter), group.Max(l => Size(l.Letter)));
+                if (letter.Baseline - group[0].Baseline > SameLine * size)
+                    Flush();
+            }
+            group.Add(letter);
+        }
+        Flush();
+        return lines;
+    }
+
+    /// <summary>The text of every page in content order, each /ActualText span replacing its glyphs.</summary>
+    public static string Text(byte[] pdf)
+    {
+        using var document = PdfDocument.Open(pdf);
+        var result = new StringBuilder();
+        foreach (var page in document.GetPages())
+        {
+            var spans = new Dictionary<Letter, MarkedContentElement>(ReferenceEqualityComparer.Instance);
+            void Walk(IEnumerable<MarkedContentElement> elements)
+            {
+                foreach (var element in elements)
+                {
+                    if (element.ActualText is null)
+                    {
+                        Walk(element.Children);
+                        continue;
+                    }
+                    foreach (var letter in All(element))
+                        spans.TryAdd(letter, element);
+                }
+            }
+            Walk(page.GetMarkedContents());
+            var done = new HashSet<MarkedContentElement>(ReferenceEqualityComparer.Instance);
+            foreach (var letter in page.Letters)
+            {
+                if (!spans.TryGetValue(letter, out var span))
+                    result.Append(letter.Value);
+                else if (done.Add(span))
+                    result.Append(span.ActualText);
+            }
+        }
+        return result.ToString();
+
+        static IEnumerable<Letter> All(MarkedContentElement element) => element.Letters.Concat(element.Children.SelectMany(All));
+    }
+
+    /// <summary>The letter's size on the page in points (font size times the text matrix scale).</summary>
+    public static double Size(Letter letter) => letter.PointSize > 0 ? letter.PointSize : letter.FontSize;
+
+    /// <summary>Text without white space, in Unicode normalisation form C.</summary>
+    public static string Normalise(string text)
+    {
+        var builder = new StringBuilder(text.Length);
+        foreach (var c in text.Normalize(NormalizationForm.FormC))
+            if (!char.IsWhiteSpace(c) && CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.Format)
+                builder.Append(c);
+        return builder.ToString();
+    }
+}
diff --git a/tests/Filee.Engines.Tests/RenderQuality/RenderChecksTests.cs b/tests/Filee.Engines.Tests/RenderQuality/RenderChecksTests.cs
new file mode 100644
index 000000000..195b89aa4
--- /dev/null
+++ b/tests/Filee.Engines.Tests/RenderQuality/RenderChecksTests.cs
@@ -0,0 +1,327 @@
+// The render quality harness's building blocks on PDFs written in code (no renderer, no installed fonts): each
+// read-back check, the line reader, the sequence matching, SSIM, the line compare and the thresholds.
+
+using Filee.Engines.Rendering;
+using SkiaSharp;
+
+namespace Filee.Engines.Tests.RenderQuality;
+
+public sealed class RenderChecksTests : IDisposable
+{
+    private readonly string _folder = Path.Combine(Path.GetTempPath(), "filee-render-checks", Guid.NewGuid().ToString("N")[..8]);
+    private readonly TestShaper _shaper = new();
+
+    public RenderChecksTests() => Directory.CreateDirectory(_folder);
+
+    public void Dispose()
+    {
+        _shaper.Dispose();
+        try { Directory.Delete(_folder, true); } catch (IOException) { }
+    }
+
+    private byte[] Pdf(GlyphPdfBuilder builder) => File.ReadAllBytes(builder.Save(Path.Combine(_folder, Guid.NewGuid().ToString("N") + ".pdf")));
+
+    private byte[] Pdf(PdfBuilder builder) => File.ReadAllBytes(builder.Save(Path.Combine(_folder, Guid.NewGuid().ToString("N") + ".pdf")));
+
+    // ───────────────────────── Sequences ─────────────────────────
+
+    [Theory]
+    [InlineData("ABCABBA", "CBABAC", 4)]
+    [InlineData("abcdef", "abcdef", 6)]
+    [InlineData("", "abc", 0)]
+    [InlineData("abc", "", 0)]
+    [InlineData("xaxbxc", "abc", 3)]
+    [InlineData("한글 문서", "한글문서", 4)]
+    public void Longest_common_subsequence(string a, string b, int length)
+    {
+        var (pairs, exact) = SequenceMatch.Match(a.ToCharArray(), b.ToCharArray());
+
+        Assert.True(exact);
+        Assert.Equal(length, pairs.Count);
+        Assert.All(pairs, p => Assert.Equal(a[p.A], b[p.B]));
+        Assert.Equal(pairs.OrderBy(p => p.A).ToList(), pairs);
+        Assert.Equal(pairs.OrderBy(p => p.B).ToList(), pairs);
+    }
+
+    [Fact]
+    public void Matching_past_the_limit_pairs_equal_items_in_order_of_occurrence()
+    {
+        var (pairs, exact) = SequenceMatch.Match("abcdefgh".ToCharArray(), "hgfedcba".ToCharArray(), maxDifferences: 3);
+
+        Assert.False(exact);
+        Assert.Equal(8, pairs.Count); // every letter has its twin, though not in order
+    }
+
+    // ───────────────────────── Text and lines ─────────────────────────
+
+    [Fact]
+    public void Text_round_trip_counts_the_expected_text_in_order()
+    {
+        var pdf = Pdf(new GlyphPdfBuilder()
+            .Run("1.", 50, 100, 6) // a list number the document adds
+            .Run("Hello", 70, 100, 6)
+            .ActualText("ffi", b => b.Glyph("ffi", 106, 100, 9))
+            .Run("world", 50, 120, 6));
+
+        Assert.Equal(1, PdfChecks.TextRoundTrip(pdf, "Hello ffi world").Value);
+        var missing = PdfChecks.TextRoundTrip(pdf, "Hello there world");
+        Assert.False(missing.Ok);
+        Assert.Equal(10.0 / 15, missing.Value, 4); // "Hello" and "world" of "Hellothereworld"
+        Assert.Contains("missing", missing.Detail);
+    }
+
+    [Fact]
+    public void Lines_group_letters_on_one_baseline_in_content_order()
+    {
+        var pdf = Pdf(new GlyphPdfBuilder()
+            .Run("one", 50, 100, 6)
+            .Glyph("2", 70, 96, 4, size: 7) // a superscript stays on its line
+            .Run("two", 50, 116, 6)
+            .Run("ab", 300, 116, 6)); // a second column on the same baseline
+
+        var lines = PdfLines.Read(pdf);
+
+        Assert.Equal(["one2", "twoab"], lines.Select(l => l.Key));
+        Assert.Equal(100, lines[0].Baseline, 2);
+        Assert.Equal(116, lines[1].Baseline, 2);
+        Assert.Equal(12, lines[1].Size, 2);
+    }
+
+    // ───────────────────────── Overlaps ─────────────────────────
+
+    [Fact]
+    public void Glyphs_drawn_over_each_other_are_found()
+    {
+        var pdf = Pdf(new GlyphPdfBuilder()
+            .Run("abc", 50, 100, 6)                                      // side by side
+            .Glyph("x", 50, 130, 6).Glyph("y", 55, 130, 6)               // 1 pt = 0.083 em over: found
+            .Glyph("p", 50, 160, 6).Glyph("q", 55.5, 160, 6)             // 0.5 pt = 0.042 em: within the tolerance
+            .Glyph("क", 50, 190, 6).Glyph("ि", 52, 190, 0)     // a mark without an advance on its letter
+            .Glyph("m", 50, 220, 6).Glyph("n", 53, 240, 6));             // different lines
+
+        var result = PdfChecks.OverlappingGlyphs(pdf);
+
+        Assert.Equal(0.25, result.Value); // one of the four neighbouring pairs (ab, bc, xy, pq)
+        Assert.False(result.Ok);
+        Assert.Contains("1 of 4 pairs", result.Detail);
+        Assert.Contains("\"xy\"", result.Detail);
+        Assert.Equal(0, PdfChecks.OverlappingGlyphs(pdf, tolerance: 0.1).Value);
+    }
+
+    [Fact]
+    public void Right_to_left_glyphs_drawn_in_logical_order_do_not_overlap()
+    {
+        // Glyphs written from right to left, as Filee's page writer and rhwp leave Arabic and Hebrew.
+        var pdf = Pdf(new GlyphPdfBuilder().Glyph("א", 80, 100, 6).Glyph("ב", 74, 100, 6).Glyph("ג", 68, 100, 6));
+
+        Assert.True(PdfChecks.OverlappingGlyphs(pdf).Ok);
+    }
+
+    // ───────────────────────── Page and margins ─────────────────────────
+
+    [Fact]
+    public void Glyphs_outside_the_page_are_found()
+    {
+        var inside = new PdfBuilder().NewPage();
+        inside.Line("inside", 12, inside.Font(), 100, 100);
+        var outside = new PdfBuilder().NewPage();
+        outside.Line("W", 12, outside.Font(), -20, 100).Line("bottom", 12, outside.Font(), 100, 845);
+
+        Assert.True(PdfChecks.GlyphsOutsidePage(Pdf(inside)).Ok);
+        var result = PdfChecks.GlyphsOutsidePage(Pdf(outside));
+        Assert.Equal(1 + "bottom".Length, result.Value); // "W" left of the page, "bottom" below it
+        Assert.Contains("\"W\"", result.Detail);
+    }
+
+    [Fact]
+    public void Glyphs_outside_the_margins_are_found_but_not_those_in_the_header_area()
+    {
+        var margins = new PageMargins(Left: 85, Top: 57, Right: 85, Bottom: 42.5);
+        var pdf = Pdf(new GlyphPdfBuilder()
+            .Run("header", 85, 70, 6)    // in the header area: inside the top margin as 한글 measures it
+            .Run("body", 100, 200, 6)
+            .Run("edge", 488, 300, 6)    // ends at 512 = the right margin (595 - 85 = 510) + 2 pt
+            .Run("low", 100, 805, 6));   // below 842 - 42.5
+
+        var result = PdfChecks.GlyphsOutsideMargins(pdf, margins);
+
+        Assert.Equal(1 + 3, result.Value); // the last letter of "edge" and all of "low"
+        Assert.Equal(0, PdfChecks.GlyphsOutsideMargins(pdf, new PageMargins(10, 10, 10, 10)).Value);
+    }
+
+    [Fact]
+    public void Page_count_is_measured_against_the_document()
+    {
+        var builder = new PdfBuilder().NewPage();
+        var font = builder.Font();
+        var pdf = Pdf(builder.Line("one", 12, font, 100, 100).NewPage().Line("two", 12, font, 100, 100));
+
+        Assert.True(PdfChecks.PageCount(pdf, 2).Ok);
+        var wrong = PdfChecks.PageCount(pdf, 1);
+        Assert.Equal(2, wrong.Value);
+        Assert.False(wrong.Ok);
+    }
+
+    // ───────────────────────── Baselines ─────────────────────────
+
+    [Fact]
+    public void Baselines_are_met_within_half_a_point()
+    {
+        Assert.True(PdfChecks.BaselinesMatch([100, 116.5, 132], [100, 116, 132]).Ok);
+        var off = PdfChecks.BaselinesMatch([100, 116.6, 132], [100, 116, 132]);
+        Assert.Equal(2.0 / 3, off.Value, 4);
+        Assert.Contains("line 2", off.Detail);
+        Assert.Equal(0.5, PdfChecks.BaselinesMatch([100, 116], [100, 117, 132, 148], 1.5).Value); // missing lines count
+    }
+
+    [Fact]
+    public void Baseline_pitch_follows_the_documents_line_height()
+    {
+        var even = Pdf(new GlyphPdfBuilder().Run("one", 50, 100, 6).Run("two", 50, 116, 6).Run("three", 50, 132, 6));
+        var uneven = Pdf(new GlyphPdfBuilder().Run("one", 50, 100, 6).Run("two", 50, 116, 6).Run("three", 50, 133, 6));
+
+        Assert.True(PdfChecks.BaselinePitch(even, 16).Ok);
+        Assert.Equal(2.0 / 3, PdfChecks.BaselinePitch(uneven, 16).Value, 4);
+    }
+
+    // ───────────────────────── Fonts ─────────────────────────
+
+    [Fact]
+    public void Fonts_must_be_embedded_and_subset()
+    {
+        using var face = PageFont.FromFile(Path.Combine(AppContext.BaseDirectory, "Fonts", "FileeTest-TrueType.ttf"));
+        var page = new PageContent(300, 100);
+        page.DrawGlyphs(_shaper.Shape(face, 20, "Filee", 10, 50).Run);
+        using var output = new MemoryStream();
+        PdfPageWriter.Write(output, [page], cancellationToken: TestContext.Current.CancellationToken);
+        var builder = new PdfBuilder().NewPage();
+        var standard = Pdf(builder.Line("Helvetica", 12, builder.Font(), 100, 100));
+
+        Assert.True(PdfChecks.FontsEmbeddedAndSubset(output.ToArray()).Ok);               // Filee's subset TrueType
+        Assert.True(PdfChecks.FontsEmbeddedAndSubset(Pdf(new GlyphPdfBuilder().Run("a", 50, 100, 6))).Ok); // Type 3
+        var result = PdfChecks.FontsEmbeddedAndSubset(standard);
+        Assert.Equal(1, result.Value);
+        Assert.Contains("Helvetica not embedded", result.Detail);
+    }
+
+    // ───────────────────────── Compare ─────────────────────────
+
+    [Fact]
+    public void Ssim_is_one_for_the_same_picture_and_drops_with_changes()
+    {
+        var page = Picture(0);
+        Assert.Equal((1.0, 0.0), Ssim.Compare(page, page));
+        Assert.Equal(1, Ssim.Compare(Blank(), Blank()).Ssim); // paper only: nothing to compare
+
+        var moved = Ssim.Compare(page, Picture(3));
+        Assert.InRange(moved.Ssim, 0, 0.9);
+        Assert.InRange(Ssim.Compare(page, Blank()).Ssim, 0, 0.5);
+
+        static GreyImage Picture(int shift)
+        {
+            using var bitmap = new SKBitmap(200, 100);
+            using (var canvas = new SKCanvas(bitmap))
+            {
+                canvas.Clear(SKColors.White);
+                using var paint = new SKPaint { Color = SKColors.Black };
+                for (var x = 10; x < 190; x += 12)
+                    canvas.DrawRect(x + shift, 20, 6, 50, paint);
+            }
+            return GreyImage.From(bitmap);
+        }
+
+        static GreyImage Blank() => new(200, 100, Enumerable.Repeat(255.0, 200 * 100).ToArray());
+    }
+
+    [Fact]
+    public void Line_breaks_and_baselines_are_compared_line_by_line()
+    {
+        string[] lines = ["The first line", "the second line", "the third line", "and the last one"];
+        var reference = new PdfBuilder().NewPage();
+        for (var i = 0; i < lines.Length; i++)
+            reference.Line(lines[i], 12, reference.Font(), 72, 100 + 16 * i);
+        // The last line on the next page, the third broken one word earlier.
+        var candidate = new PdfBuilder().NewPage();
+        var font = candidate.Font();
+        candidate.Line(lines[0], 12, font, 72, 100).Line(lines[1], 12, font, 72, 116).Line("the third", 12, font, 72, 132.3)
+            .Line("line", 12, font, 72, 148).NewPage().Line(lines[3], 12, font, 72, 100);
+
+        var (agree, placed, referenceLines, candidateLines, exact) =
+            RenderDiff.CompareLines(PdfLines.Read(Pdf(reference)), PdfLines.Read(Pdf(candidate)));
+
+        Assert.True(exact);
+        Assert.Equal((4, 5), (referenceLines, candidateLines));
+        Assert.Equal(3.0 / 5, agree, 4);  // first, second and last line
+        Assert.Equal(2.0 / 5, placed, 4); // the last one moved to another page
+    }
+
+    [Fact]
+    public void A_pdf_compared_with_itself_is_identical_and_a_shifted_copy_is_not()
+    {
+        var builder = new PdfBuilder().NewPage();
+        var font = builder.Font();
+        for (var i = 0; i < 10; i++)
+            builder.Line($"Line {i + 1} of a page drawn twice", 12, font, 72, 100 + 16 * i);
+        var pdf = Pdf(builder);
+
+        var same = RenderDiff.Compare(pdf, pdf);
+        Assert.True(same.SamePageCount && same.LineAgreement == 1 && same.BaselineAgreement == 1 && same.MinSsim == 1, same.ToString());
+
+        var shifted = RenderDiff.Compare(pdf, RenderQualityTests.Shift(pdf, 2));
+        Assert.Equal(1, shifted.LineAgreement);
+        Assert.Equal(0, shifted.BaselineAgreement);
+        Assert.True(shifted.MinSsim < 0.9, shifted.ToString());
+    }
+
+    // ───────────────────────── Thresholds ─────────────────────────
+
+    [Fact]
+    public void Measurements_are_judged_against_the_ideal_their_threshold_or_the_allow_list()
+    {
+        var thresholds = new RenderThresholds
+        {
+            Thresholds = new() { ["rhwp"] = new() { ["script-ar"] = new() { ["overlaps"] = 0.5, ["text"] = 0.9 } } },
+            Allow = [new("filee", "script-ar", "vs-rhwp-*", "rhwp draws Arabic unshaped")],
+        };
+        Verdict Judge(string renderer, string feature, string check, double value, bool ok) =>
+            thresholds.Judge(new Measurement(renderer, feature, new CheckResult(check, value, ok, "")));
+
+        Assert.Equal(Verdict.Ideal, Judge("rhwp", "tables", "overlaps", 0, true));
+        Assert.Equal(Verdict.Regression, Judge("rhwp", "tables", "overlaps", 0.01, false));
+        Assert.Equal(Verdict.WithinThreshold, Judge("rhwp", "script-ar", "overlaps", 0.5, false));
+        Assert.Equal(Verdict.Improved, Judge("rhwp", "script-ar", "overlaps", 0.4, false));
+        Assert.Equal(Verdict.Ideal, Judge("rhwp", "script-ar", "overlaps", 0, true));
+        Assert.Equal(Verdict.Regression, Judge("rhwp", "script-ar", "overlaps", 0.51, false));
+        Assert.Equal(Verdict.Regression, Judge("rhwp", "script-ar", "text", 0.89, false));
+        Assert.Equal(Verdict.Improved, Judge("rhwp", "script-ar", "text", 0.95, false));
+        Assert.Equal(Verdict.Allowed, Judge("filee", "script-ar", "vs-rhwp-ssim", 0.2, false));
+        Assert.Equal(Verdict.Regression, Judge("filee", "script-ar", "overlaps", 0.1, false)); // only the compares are allowed
+
+        Assert.Equal("0.9734", RenderThresholds.Suggest(new CheckResult("text", 0.97349, false, "")));
+        Assert.Equal("0.5311", RenderThresholds.Suggest(new CheckResult("overlaps", 0.53101, false, "")));
+    }
+
+    [Fact]
+    public void The_thresholds_file_names_known_checks_and_gives_reasons()
+    {
+        var thresholds = RenderThresholds.Load();
+        string[] checks = [PdfChecks.Text, PdfChecks.Overlaps, PdfChecks.OutsidePage, PdfChecks.OutsideMargins, PdfChecks.Pages,
+            PdfChecks.Baselines, PdfChecks.Fonts, RenderThresholds.Lines, RenderThresholds.Placed, RenderThresholds.MinSsim];
+        var features = RenderFeatures.Full.SelectMany(f => new[] { f.Name, f.Name + ".hwp" }).ToHashSet();
+
+        Assert.Contains("rhwp", thresholds.Thresholds.Keys);
+        foreach (var (renderer, byFeature) in thresholds.Thresholds)
+        {
+            foreach (var (feature, values) in byFeature)
+            {
+                Assert.Contains(feature, features);
+                Assert.All(values.Keys, check => Assert.Contains(check.Replace(RenderThresholds.Versus, "", StringComparison.Ordinal), checks));
+            }
+        }
+        Assert.All(thresholds.Allow, entry =>
+        {
+            Assert.False(string.IsNullOrWhiteSpace(entry.Reason));
+            Assert.True(entry.Feature == "*" || features.Contains(entry.Feature), entry.Feature);
+        });
+    }
+}
diff --git a/tests/Filee.Engines.Tests/RenderQuality/RenderCorpusTests.cs b/tests/Filee.Engines.Tests/RenderQuality/RenderCorpusTests.cs
new file mode 100644
index 000000000..547fc7ba6
--- /dev/null
+++ b/tests/Filee.Engines.Tests/RenderQuality/RenderCorpusTests.cs
@@ -0,0 +1,157 @@
+// The render quality harness on a private corpus outside the repository: documents next to the PDFs 한글 printed of
+// them (doc.hwpx + doc.pdf, or doc.hwp + doc.pdf), in FILEE_RENDER_CORPUS. Each renderer (rhwp, and Filee's layout
+// engine once registered) renders every document, which is compared with 한글's PDF and read back; the results go to
+// an HTML report (FILEE_RENDER_REPORT, else a file in the temp folder) with the page that differs most of each
+// document side by side. It reports and never fails on the numbers: the corpus is private and differs from PC to PC.
+// build/render-compare.ps1 runs it.
+
+using System.Globalization;
+using System.Net;
+using System.Text;
+
+namespace Filee.Engines.Tests.RenderQuality;
+
+[Trait("Category", "RenderCorpus")]
+public class RenderCorpusTests
+{
+    private sealed record Row(string Document, string Renderer, DiffResult? Diff, IReadOnlyList<CheckResult> Checks, TimeSpan Time,
+        string? Error, (int Page, byte[] Reference, byte[] Rendered)? Worst);
+
+    [Fact]
+    public async Task Corpus_is_compared_with_the_pdfs_hangul_printed()
+    {
+        var corpus = Environment.GetEnvironmentVariable("FILEE_RENDER_CORPUS");
+        Assert.SkipWhen(string.IsNullOrEmpty(corpus), "FILEE_RENDER_CORPUS is not set (see build/render-compare.ps1)");
+        Assert.True(Directory.Exists(corpus), $"{corpus} does not exist");
+        var pairs = Pairs(corpus).ToList();
+        Assert.True(pairs.Count > 0, $"No document with a PDF of the same name in {corpus}");
+        var renderers = new[] { DocumentRenderers.Reference, DocumentRenderers.Candidate }.OfType<DocumentRenderer>().ToList();
+        Assert.True(renderers.Count > 0, "No renderer: rhwp not found and no layout engine registered");
+
+        var ct = TestContext.Current.CancellationToken;
+        var work = Path.Combine(Path.GetTempPath(), "filee-render-compare", Guid.NewGuid().ToString("N")[..8]);
+        var rows = new List<Row>();
+        try
+        {
+            using var gate = new SemaphoreSlim(4);
+            var jobs = pairs.SelectMany(pair => renderers.Where(r => r.Formats.Contains(Format(pair.Document))).Select(async renderer =>
+            {
+                await gate.WaitAsync(ct);
+                try
+                {
+                    return await CompareAsync(Path.GetRelativePath(corpus, pair.Document), pair.Document, pair.Pdf, renderer, Path.Combine(work, Guid.NewGuid().ToString("N")[..8]), ct);
+                }
+                finally
+                {
+                    gate.Release();
+                }
+            }));
+            rows.AddRange(await Task.WhenAll(jobs));
+        }
+        finally
+        {
+            try { Directory.Delete(work, true); } catch (IOException) { } catch (UnauthorizedAccessException) { }
+        }
+
+        var report = Environment.GetEnvironmentVariable("FILEE_RENDER_REPORT") is { Length: > 0 } path
+            ? path
+            : Path.Combine(Path.GetTempPath(), $"filee-render-compare-{DateTime.Now:yyyyMMdd-HHmmss}.html");
+        await File.WriteAllTextAsync(report, Html(corpus, rows), ct);
+        TestContext.Current.TestOutputHelper?.WriteLine($"Report: {report}");
+        foreach (var row in rows)
+            TestContext.Current.TestOutputHelper?.WriteLine($"{row.Document} [{row.Renderer}] {(row.Error ?? row.Diff?.ToString())}");
+    }
+
+    /// <summary>Documents with a PDF of the same name next to them.</summary>
+    private static IEnumerable<(string Document, string Pdf)> Pairs(string corpus)
+    {
+        foreach (var file in Directory.EnumerateFiles(corpus, "*", SearchOption.AllDirectories).Order(StringComparer.OrdinalIgnoreCase))
+        {
+            if (Format(file) is not ("hwpx" or "hwp"))
+                continue;
+            var pdf = Path.ChangeExtension(file, ".pdf");
+            if (File.Exists(pdf))
+                yield return (file, pdf);
+        }
+    }
+
+    private static string Format(string path) => Path.GetExtension(path).TrimStart('.').ToLowerInvariant();
+
+    private static async Task<Row> CompareAsync(string name, string document, string printed, DocumentRenderer renderer, string work, CancellationToken ct)
+    {
+        Directory.CreateDirectory(work);
+        try
+        {
+            var reference = await File.ReadAllBytesAsync(printed, ct);
+            var started = DateTime.UtcNow;
+            var pdf = await renderer.Render(new RenderInput(document, work), ct);
+            var time = DateTime.UtcNow - started;
+            var referencePages = GreyImage.Pages(reference, RenderDiff.Dpi);
+            var renderedPages = GreyImage.Pages(pdf, RenderDiff.Dpi);
+            var diff = RenderDiff.Compare(reference, pdf, referencePages, renderedPages);
+            var checks = new List<CheckResult>
+            {
+                PdfChecks.TextRoundTrip(pdf, PdfLines.Text(reference)),
+                PdfChecks.OverlappingGlyphs(pdf),
+                PdfChecks.GlyphsOutsidePage(pdf),
+                PdfChecks.FontsEmbeddedAndSubset(pdf),
+            };
+            // The page that differs most, both pictures for the report.
+            (int, byte[], byte[])? worst = null;
+            if (diff.PageSsim.Count > 0)
+            {
+                var page = diff.PageSsim.Select((s, i) => (s, i)).MinBy(p => p.s).i;
+                worst = (page, referencePages[page].ToPng(), renderedPages[page].ToPng());
+            }
+            return new Row(name, renderer.Name, diff, checks, time, null, worst);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            return new Row(name, renderer.Name, null, [], TimeSpan.Zero, ex.Message, null);
+        }
+    }
+
+    private static string Html(string corpus, IReadOnlyList<Row> rows)
+    {
+        static string E(string text) => WebUtility.HtmlEncode(text);
+        static string N(double value, string format = "0.###") => value.ToString(format, CultureInfo.InvariantCulture);
+        var html = new StringBuilder();
+        html.Append("<!doctype html><html><head><meta charset=\"utf-8\"><title>Filee render compare</title><style>")
+            .Append("body{font:14px system-ui,sans-serif;margin:24px;color:#222}table{border-collapse:collapse}")
+            .Append("th,td{border:1px solid #ccc;padding:4px 8px;text-align:right}td:first-child,td:nth-child(2){text-align:left}")
+            .Append(".bad{background:#fde2e1}.pages{display:flex;gap:12px;margin:8px 0 24px}.pages img{width:420px;border:1px solid #999}")
+            .Append("</style></head><body>")
+            .Append(CultureInfo.InvariantCulture, $"<h1>Render compare</h1><p>{E(corpus)}: {rows.Select(r => r.Document).Distinct().Count()} documents, ")
+            .Append(CultureInfo.InvariantCulture, $"{DateTime.Now:yyyy-MM-dd HH:mm}. Reference: the PDF 한글 printed. Pages drawn by PDFium at {RenderDiff.Dpi} dpi.</p>")
+            .Append("<table><tr><th>Document</th><th>Renderer</th><th>Pages (한글 / renderer)</th><th>Lines</th><th>On baseline</th>")
+            .Append("<th>SSIM min</th><th>SSIM mean</th><th>Text</th><th>Overlaps</th><th>Outside page</th><th>Fonts not subset</th><th>Time (s)</th></tr>");
+        foreach (var row in rows)
+        {
+            if (row.Diff is not { } diff)
+            {
+                html.Append(CultureInfo.InvariantCulture, $"<tr class=\"bad\"><td>{E(row.Document)}</td><td>{E(row.Renderer)}</td><td colspan=\"10\">{E(row.Error ?? "")}</td></tr>");
+                continue;
+            }
+            string Check(string name) => row.Checks.FirstOrDefault(c => c.Name == name) is { } c
+                ? $"<td{(c.Ok ? "" : " class=\"bad\"")} title=\"{E(c.Detail)}\">{N(c.Value)}</td>"
+                : "<td></td>";
+            html.Append(CultureInfo.InvariantCulture, $"<tr><td>{E(row.Document)}</td><td>{E(row.Renderer)}</td>")
+                .Append(CultureInfo.InvariantCulture, $"<td{(diff.SamePageCount ? "" : " class=\"bad\"")}>{diff.ReferencePages} / {diff.CandidatePages}</td>")
+                .Append(CultureInfo.InvariantCulture, $"<td>{N(diff.LineAgreement, "0.0%")}</td><td>{N(diff.BaselineAgreement, "0.0%")}</td>")
+                .Append(CultureInfo.InvariantCulture, $"<td>{N(diff.MinSsim, "0.000")}</td><td>{N(diff.MeanSsim, "0.000")}</td>")
+                .Append(Check(PdfChecks.Text)).Append(Check(PdfChecks.Overlaps)).Append(Check(PdfChecks.OutsidePage)).Append(Check(PdfChecks.Fonts))
+                .Append(CultureInfo.InvariantCulture, $"<td>{N(row.Time.TotalSeconds, "0.0")}</td></tr>");
+        }
+        html.Append("</table><h2>Pages that differ most</h2>");
+        foreach (var row in rows.Where(r => r.Worst is not null))
+        {
+            var (page, reference, rendered) = row.Worst!.Value;
+            html.Append(CultureInfo.InvariantCulture, $"<h3>{E(row.Document)}, page {page + 1}: 한글 and {E(row.Renderer)} (SSIM {N(row.Diff!.PageSsim[page], "0.000")})</h3>")
+                .Append("<div class=\"pages\">")
+                .Append(CultureInfo.InvariantCulture, $"<img alt=\"한글\" src=\"data:image/png;base64,{Convert.ToBase64String(reference)}\">")
+                .Append(CultureInfo.InvariantCulture, $"<img alt=\"{E(row.Renderer)}\" src=\"data:image/png;base64,{Convert.ToBase64String(rendered)}\">")
+                .Append("</div>");
+        }
+        return html.Append("</body></html>").ToString();
+    }
+}
diff --git a/tests/Filee.Engines.Tests/RenderQuality/RenderDiff.cs b/tests/Filee.Engines.Tests/RenderQuality/RenderDiff.cs
new file mode 100644
index 000000000..3ad3dabde
--- /dev/null
+++ b/tests/Filee.Engines.Tests/RenderQuality/RenderDiff.cs
@@ -0,0 +1,61 @@
+// Differential compare of two renderings of one document (rhwp and Filee's layout engine, or 한글's own PDF and a
+// renderer): page count, line breaks, baselines and per-page SSIM of the pages drawn by PDFium at 100 dpi.
+//
+// Line breaks are compared as lines: the text of each line without white space, matched in order between the two
+// PDFs (longest common subsequence). A line agrees when the other PDF has a line with the same text at that point of
+// the document, so it agrees in both its first and its last character; a page break moved by one line costs nothing
+// more than the lines that moved. Matched lines also compare their baselines (same page, within ±0.5 pt).
+
+using System.Globalization;
+
+namespace Filee.Engines.Tests.RenderQuality;
+
+/// <summary>How alike two renderings are.</summary>
+/// <param name="LineAgreement">Share of lines with the same text in both, of the longer document's lines.</param>
+/// <param name="BaselineAgreement">Share of lines that also sit on the same page and baseline (±0.5 pt).</param>
+/// <param name="PageSsim">SSIM of each page both have.</param>
+/// <param name="Exact">False when the documents differed too much for an exact line matching (then approximate).</param>
+internal sealed record DiffResult(int ReferencePages, int CandidatePages, int ReferenceLines, int CandidateLines,
+    double LineAgreement, double BaselineAgreement, IReadOnlyList<double> PageSsim, bool Exact)
+{
+    public bool SamePageCount => ReferencePages == CandidatePages;
+    public double MinSsim => PageSsim.Count == 0 ? (ReferencePages == 0 && CandidatePages == 0 ? 1 : 0) : PageSsim.Min();
+    public double MeanSsim => PageSsim.Count == 0 ? MinSsim : PageSsim.Average();
+
+    public override string ToString() => string.Create(CultureInfo.InvariantCulture,
+        $"pages {ReferencePages}/{CandidatePages}, lines {LineAgreement:P1}, baselines {BaselineAgreement:P1}, SSIM min {MinSsim:0.####} mean {MeanSsim:0.####}{(Exact ? "" : " (approximate)")}");
+}
+
+internal static class RenderDiff
+{
+    public const int Dpi = 100;
+
+    /// <summary>
+    /// Compares <paramref name="candidate"/> with <paramref name="reference"/>; pages already drawn at <see cref="Dpi"/>
+    /// can be passed in.
+    /// </summary>
+    public static DiffResult Compare(byte[] reference, byte[] candidate, IReadOnlyList<GreyImage>? referencePages = null,
+        IReadOnlyList<GreyImage>? candidatePages = null, double baselineTolerance = 0.5)
+    {
+        var (lines, baselines, referenceLines, candidateLines, exact) = CompareLines(PdfLines.Read(reference), PdfLines.Read(candidate), baselineTolerance);
+        referencePages ??= GreyImage.Pages(reference, Dpi);
+        candidatePages ??= GreyImage.Pages(candidate, Dpi);
+        var ssim = new List<double>();
+        for (var i = 0; i < Math.Min(referencePages.Count, candidatePages.Count); i++)
+            ssim.Add(Ssim.Compare(referencePages[i], candidatePages[i]).Ssim);
+        return new DiffResult(referencePages.Count, candidatePages.Count, referenceLines, candidateLines, lines, baselines, ssim, exact);
+    }
+
+    /// <summary>Line-break and baseline agreement of two documents' lines (see the file comment).</summary>
+    public static (double Lines, double Baselines, int ReferenceLines, int CandidateLines, bool Exact) CompareLines(
+        IReadOnlyList<TextLine> reference, IReadOnlyList<TextLine> candidate, double baselineTolerance = 0.5)
+    {
+        var total = Math.Max(reference.Count, candidate.Count);
+        if (total == 0)
+            return (1, 1, 0, 0, true);
+        var (pairs, exact) = SequenceMatch.Match(reference.Select(l => l.Key).ToList(), candidate.Select(l => l.Key).ToList(), StringComparer.Ordinal);
+        var placed = pairs.Count(p => reference[p.A].Page == candidate[p.B].Page
+                                      && Math.Abs(reference[p.A].Baseline - candidate[p.B].Baseline) <= baselineTolerance);
+        return ((double)pairs.Count / total, (double)placed / total, reference.Count, candidate.Count, exact);
+    }
+}
diff --git a/tests/Filee.Engines.Tests/RenderQuality/RenderFeatures.cs b/tests/Filee.Engines.Tests/RenderQuality/RenderFeatures.cs
new file mode 100644
index 000000000..d3e01acfb
--- /dev/null
+++ b/tests/Filee.Engines.Tests/RenderQuality/RenderFeatures.cs
@@ -0,0 +1,336 @@
+// The feature matrix of the render quality harness: small documents written in code at test time, one per feature,
+// so no input or reference file is kept in the repository. Most are built as a document model (HDocument) and written
+// by Filee's HWPX writer; floating objects and equations go through DocxBuilder and the DOCX reader, the way a Word
+// document reaches the renderer. Some are also made binary HWP files with `rhwp convert` (DocumentRenderers) while
+// rhwp is bundled.
+//
+// Each document stays under a page or two and a few hundred characters: rhwp needs some 3.5 ms per character, and the
+// whole matrix has to fit in a minute of the Windows CI job. FILEE_RENDER_FULL=1 adds the longer variants.
+
+using Filee.Engines.Hwp.Hwpx;
+using Filee.Engines.Hwp.Hwpx.Docx;
+using SkiaSharp;
+using static Filee.Engines.Tests.DocxBuilder;
+
+namespace Filee.Engines.Tests.RenderQuality;
+
+/// <summary>One document of the feature matrix.</summary>
+/// <param name="Name">Feature name, the key of its thresholds.</param>
+/// <param name="Write">Writes the document as HWPX into the given folder and returns its path.</param>
+/// <param name="Text">Text the PDF must hold, in reading order (white space doesn't count).</param>
+/// <param name="Pages">Pages the document takes; null where only a compare can tell.</param>
+/// <param name="Pitch">Baseline-to-baseline distance of every line in points, for documents with one line height.</param>
+/// <param name="Hwp">Also rendered from a binary HWP made by <c>rhwp convert</c>.</param>
+internal sealed record RenderFeature(string Name, Func<string, string> Write, string Text, int? Pages = 1, double? Pitch = null, bool Hwp = false)
+{
+    public override string ToString() => Name;
+}
+
+internal static class RenderFeatures
+{
+    /// <summary>A4 with 한글's default margins (30 mm left and right, 20 mm top, 15 mm bottom, 15 mm header and footer).</summary>
+    public static readonly HPage Page = new(59528, 84186, 8504, 8504, 5669, 4252, 4252, 4252, 0);
+
+    private const string Korean = "한글 문서는 줄 간격과 정렬에 따라 줄이 나뉘는 자리가 달라집니다. 같은 문단을 몇 번 그려도 줄은 같은 자리에서 끝나야 합니다.";
+    private const string Latin = "Filee lays out every paragraph the way the document asks: line spacing, alignment and the place where each line ends.";
+
+    /// <summary>Paragraphs in the scripts Filee's renderer must shape: name, text, font and right-to-left.</summary>
+    public static readonly (string Name, string Text, string? Font, bool RightToLeft)[] Scripts =
+    [
+        ("ko", "한국어 문단입니다. 어절 단위로 줄을 나누고 문장 부호는 줄 머리에 오지 않습니다. 다람쥐 헌 쳇바퀴에 타고파.", null, false),
+        ("zh", "文件转换工具应当保持段落的排版和换行位置。汉字之间可以在任意位置断行，但标点符号不能出现在行首。", "Microsoft YaHei", false),
+        ("ja", "文書の変換では、段落の行送りと改行の位置を保つことが大切です。句読点は行頭に来ないように調整されます。", "Yu Gothic", false),
+        ("ar", "يحافظ برنامج التحويل على تنسيق الفقرات ومواضع فواصل الأسطر. يجب أن تتصل الحروف العربية وأن يقرأ النص من اليمين إلى اليسار.", "Segoe UI", true),
+        ("he", "תוכנת ההמרה שומרת על עיצוב הפסקאות ועל מקומות שבירת השורות. הטקסט העברי נקרא מימין לשמאל.", "Segoe UI", true),
+        ("hi", "रूपांतरण उपकरण अनुच्छेदों के स्वरूप और पंक्ति विराम की जगह को बनाए रखता है। संयुक्ताक्षर जैसे क्ष, त्र और ज्ञ सही दिखने चाहिए।", "Nirmala UI", false),
+        ("gu", "રૂપાંતર સાધન ફકરાઓનું સ્વરૂપ અને લીટી તૂટવાની જગ્યા જાળવે છે. જોડાક્ષરો જેમ કે ક્ષ, જ્ઞ અને શ્ર યોગ્ય રીતે દેખાવા જોઈએ.", "Nirmala UI", false),
+        ("th", "โปรแกรมแปลงไฟล์ต้องรักษารูปแบบของย่อหน้าและตำแหน่งการตัดบรรทัด ภาษาไทยไม่เว้นวรรคระหว่างคำ จึงต้องตัดคำตามพจนานุกรม", "Leelawadee UI", false),
+    ];
+
+    private static readonly HAlign[] Alignments = [HAlign.Left, HAlign.Right, HAlign.Center, HAlign.Justify, HAlign.Distribute];
+
+    /// <summary>The matrix the CI runs.</summary>
+    public static IReadOnlyList<RenderFeature> All { get; } = Build(full: false);
+
+    /// <summary>The longer run: the script paragraphs twelve times, a document of some pages, and every feature also as HWP.</summary>
+    public static IReadOnlyList<RenderFeature> Full { get; } = Build(full: true);
+
+    /// <summary><see cref="Full"/> with FILEE_RENDER_FULL=1, else <see cref="All"/>.</summary>
+    public static IReadOnlyList<RenderFeature> Selected =>
+        Environment.GetEnvironmentVariable("FILEE_RENDER_FULL") is "1" or "true" ? Full : All;
+
+    private static List<RenderFeature> Build(bool full)
+    {
+        var features = new List<RenderFeature>
+        {
+            LineSpacing("line-spacing-percent", new HLineSpacing(HLineSpacingKind.Percent, 160), 16, hwp: true),
+            LineSpacing("line-spacing-fixed", new HLineSpacing(HLineSpacingKind.Fixed, 2000), 20),
+            LineSpacing("line-spacing-at-least", new HLineSpacing(HLineSpacingKind.AtLeast, 2400), 24),
+            Tabs(),
+            Lists(),
+            Tables(),
+            HeadersAndFooters(),
+            Notes(),
+            Columns(),
+            FloatingObjects(),
+            Equations(),
+        };
+        features.AddRange(Scripts.Select(s => Script(s.Name, s.Text, s.Font, s.RightToLeft, repeat: full ? 12 : 2, hwp: s.Name == "ko")));
+        if (!full)
+            return features;
+        features.Add(LongDocument());
+        return [.. features.Select(f => f with { Hwp = true })];
+    }
+
+    // ───────────────────────── Features ─────────────────────────
+
+    /// <summary>One paragraph per alignment, all with one line spacing and size, so every line is one pitch apart.</summary>
+    private static RenderFeature LineSpacing(string name, HLineSpacing spacing, double pitch, bool hwp = false)
+    {
+        var text = Alignments.Select(align => $"{align}: {Korean} {Latin}").ToList();
+        return new RenderFeature(name, folder => Model(folder, name, section =>
+        {
+            for (var i = 0; i < Alignments.Length; i++)
+                section.Blocks.Add(Paragraph(text[i], new HParaFormat(Align: Alignments[i], Before: 0, After: 0, LineSpacing: spacing)));
+        }), string.Concat(text), Pitch: pitch, Hwp: hwp);
+    }
+
+    private static RenderFeature Tabs()
+    {
+        HTabStop[] stops = [new(12000, HTabKind.Left, "NONE"), new(24000, HTabKind.Center, "DOT"), new(36000, HTabKind.Decimal, "DASH"), new(42520, HTabKind.Right, "DOT")];
+        string[][] rows = [["품목", "분류", "123.45", "끝"], ["Item", "Group", "7.5", "End"], ["항목 이름이 긴 줄", "가운데", "1,234.5", "오른쪽"]];
+        return new RenderFeature("tabs", folder => Model(folder, "tabs", section =>
+        {
+            foreach (var row in rows)
+            {
+                var paragraph = new HParagraph { Format = new HParaFormat(Tabs: stops) };
+                for (var i = 0; i < row.Length; i++)
+                {
+                    paragraph.Inlines.Add(new HTab(default));
+                    paragraph.Inlines.Add(new HText(row[i], default));
+                }
+                section.Blocks.Add(paragraph);
+            }
+        }), string.Concat(rows.SelectMany(r => r)));
+    }
+
+    private static RenderFeature Lists()
+    {
+        var numbers = new HNumbering();
+        numbers.Levels.Add(new HNumberingLevel("DIGIT", "^1.", 1, false));
+        numbers.Levels.Add(new HNumberingLevel("HANGUL_SYLLABLE", "^2)", 1, false));
+        var bullets = new HNumbering();
+        bullets.Levels.Add(new HNumberingLevel("DIGIT", "•", 1, true));
+        (string Text, HNumbering List, int Level)[] items =
+        [
+            ("첫째 항목: 번호가 붙은 목록의 줄은 번호 뒤에서 시작합니다.", numbers, 0),
+            ("하위 항목은 한 단계 들여 씁니다.", numbers, 1),
+            ("Second item with a hanging indent that wraps onto a second line so the indent of the wrapped line shows.", numbers, 0),
+            ("글머리표 항목", bullets, 0),
+            ("Bulleted item", bullets, 0),
+        ];
+        return new RenderFeature("lists", folder => Model(folder, "lists", section =>
+        {
+            foreach (var (text, list, level) in items)
+            {
+                var paragraph = Paragraph(text, new HParaFormat(Left: 2000 * (level + 1), FirstLine: -2000));
+                paragraph.List = new HListRef(list, level, true);
+                section.Blocks.Add(paragraph);
+            }
+        }), string.Concat(items.Select(i => i.Text)));
+    }
+
+    private static RenderFeature Tables()
+    {
+        string[][] cells = [["구분", "내용", "비고"], ["가", "표 안의 글이 칸 너비를 넘으면 칸 안에서 줄을 바꿉니다.", "1"], ["나", "Cell text wraps inside its column.", "2"]];
+        return new RenderFeature("tables", folder => Model(folder, "tables", section =>
+        {
+            section.Blocks.Add(Paragraph("표 앞 문단"));
+            var table = new HTable { ColumnCount = 3, ColumnWidths = [6000, 26520, 10000], Borders = HBorders.Grid };
+            for (var r = 0; r < cells.Length; r++)
+            {
+                var row = new HRow { Header = r == 0 };
+                foreach (var text in cells[r])
+                {
+                    var cell = new HCell { Fill = r == 0 ? "#D9E2F3" : null, VerticalAlign = HVerticalAlign.Center };
+                    cell.Blocks.Add(Paragraph(text, new HParaFormat(Align: r == 0 ? HAlign.Center : HAlign.Left)));
+                    row.Cells.Add(cell);
+                }
+                table.Rows.Add(row);
+            }
+            var merged = new HRow();
+            var wide = new HCell { ColSpan = 2 };
+            wide.Blocks.Add(Paragraph("병합된 칸"));
+            var last = new HCell();
+            last.Blocks.Add(Paragraph("끝"));
+            merged.Cells.Add(wide);
+            merged.Cells.Add(last);
+            table.Rows.Add(merged);
+            section.Blocks.Add(table);
+            section.Blocks.Add(Paragraph("표 뒤 문단"));
+        }), "표 앞 문단" + string.Concat(cells.SelectMany(r => r)) + "병합된 칸끝표 뒤 문단", Hwp: true);
+    }
+
+    private static RenderFeature HeadersAndFooters()
+    {
+        string[] body = ["첫 쪽 본문입니다. 머리말과 꼬리말은 본문 위와 아래의 여백 안에 그려집니다.", "둘째 쪽 본문입니다."];
+        return new RenderFeature("headers-footers", folder => Model(folder, "headers-footers", section =>
+        {
+            var header = new HHeaderFooter(HPageType.Both);
+            header.Blocks.Add(Paragraph("머리말 Header", new HParaFormat(Align: HAlign.Right)));
+            section.Headers.Add(header);
+            var footer = new HHeaderFooter(HPageType.Both);
+            var number = new HParagraph { Format = new HParaFormat(Align: HAlign.Center) };
+            number.Inlines.Add(new HText("- ", default));
+            number.Inlines.Add(new HField(HFieldKind.PageNumber, default));
+            number.Inlines.Add(new HText(" -", default));
+            footer.Blocks.Add(number);
+            section.Footers.Add(footer);
+            section.Blocks.Add(Paragraph(body[0]));
+            var second = Paragraph(body[1]);
+            second.PageBreakBefore = true;
+            section.Blocks.Add(second);
+        }), string.Concat(body), Pages: 2);
+    }
+
+    private static RenderFeature Notes()
+    {
+        return new RenderFeature("notes", folder => Model(folder, "notes", section =>
+        {
+            var paragraph = Paragraph("각주가 달린 문장입니다");
+            var note = new HNote(endnote: false);
+            note.Blocks.Add(Paragraph("각주 내용은 쪽 아래에 작은 글자로 놓입니다."));
+            paragraph.Inlines.Add(note);
+            paragraph.Inlines.Add(new HText(". A sentence with an endnote", default));
+            var endnote = new HNote(endnote: true);
+            endnote.Blocks.Add(Paragraph("미주 내용"));
+            paragraph.Inlines.Add(endnote);
+            paragraph.Inlines.Add(new HText(".", default));
+            section.Blocks.Add(paragraph);
+        }), "각주가 달린 문장입니다. A sentence with an endnote.");
+    }
+
+    private static RenderFeature Columns()
+    {
+        string[] text = [$"{Korean} {Korean}", $"{Latin} {Latin}"];
+        return new RenderFeature("columns", folder => Model(folder, "columns", section =>
+        {
+            section.Columns = new HColumns(2, 2268, true);
+            section.Blocks.Add(Paragraph(text[0], new HParaFormat(Align: HAlign.Justify)));
+            var second = Paragraph(text[1], new HParaFormat(Align: HAlign.Justify));
+            second.ColumnBreakBefore = true;
+            section.Blocks.Add(second);
+        }), string.Concat(text));
+    }
+
+    /// <summary>Pictures and text boxes floating beside, above, behind and in front of the text (DOCX → HWPX).</summary>
+    private static RenderFeature FloatingObjects()
+    {
+        const string Body = "그림 옆으로 글이 흐릅니다. Text flows around the picture on its right side and continues below it once the picture ends. ";
+        return new RenderFeature("floating", folder => Docx(folder, "floating", docx =>
+        {
+            var picture = docx.Image(Png(160, 120));
+            const string Margin = "<wp:positionH relativeFrom=\"margin\"><wp:posOffset>0</wp:posOffset></wp:positionH>";
+            const string Paragraph = "<wp:positionV relativeFrom=\"paragraph\"><wp:posOffset>0</wp:posOffset></wp:positionV>";
+            const string Right = "<wp:positionH relativeFrom=\"margin\"><wp:align>right</wp:align></wp:positionH>";
+            string TextBox(string text) =>
+                "<wps:wsp><wps:spPr><a:xfrm><a:off x=\"0\" y=\"0\"/><a:ext cx=\"2286000\" cy=\"457200\"/></a:xfrm><a:prstGeom prst=\"rect\"/>" +
+                "<a:solidFill><a:srgbClr val=\"FFF2CC\"/></a:solidFill><a:ln w=\"12700\"><a:solidFill><a:srgbClr val=\"C00000\"/></a:solidFill></a:ln></wps:spPr>" +
+                $"<wps:txbx><w:txbxContent>{P(R(text))}</w:txbxContent></wps:txbx><wps:bodyPr anchor=\"ctr\"/></wps:wsp>";
+            var behind = Anchor(PictureUri, Picture(picture, 1828800, 914400), 1828800, 914400, Right, Paragraph, "<wp:wrapNone/>")
+                .Replace("behindDoc=\"0\"", "behindDoc=\"1\"", StringComparison.Ordinal);
+            docx.Paragraph(P(Anchor(PictureUri, Picture(picture, 1371600, 1028700), 1371600, 1028700, Margin, Paragraph) + R(Body + Body)))
+                .Paragraph(P(Anchor(ShapeUri, TextBox("위아래 배치 글상자"), 2286000, 457200,
+                    "<wp:positionH relativeFrom=\"margin\"><wp:align>center</wp:align></wp:positionH>", Paragraph, "<wp:wrapTopAndBottom/>") + R("글상자 아래 문단.")))
+                .Paragraph(P(behind + R("Text over a picture behind it. 글 뒤에 놓인 그림 위의 글.")))
+                .Paragraph(P(Anchor(ShapeUri, TextBox("글 앞 글상자"), 2286000, 457200, Right, Paragraph, "<wp:wrapNone/>") + R("Text under a box in front of it.")));
+        }), Body + Body + "글상자 아래 문단.Text over a picture behind it. 글 뒤에 놓인 그림 위의 글.Text under a box in front of it.");
+    }
+
+    /// <summary>Inline and display equations (Word math → 한글 equation objects).</summary>
+    private static RenderFeature Equations()
+    {
+        static string Run(string text) => $"<m:r><m:t>{text}</m:t></m:r>";
+        var inline = "<m:oMath>" + Run("E=m") + $"<m:sSup><m:e>{Run("c")}</m:e><m:sup>{Run("2")}</m:sup></m:sSup></m:oMath>";
+        var fraction = $"<m:oMathPara><m:oMath><m:f><m:num>{Run("a+b")}</m:num><m:den>{Run("2c")}</m:den></m:f></m:oMath></m:oMathPara>";
+        var sum = "<m:oMathPara><m:oMath><m:nary><m:naryPr><m:chr m:val=\"∑\"/></m:naryPr>" +
+                  $"<m:sub>{Run("i=1")}</m:sub><m:sup>{Run("n")}</m:sup><m:e><m:sSup><m:e>{Run("i")}</m:e><m:sup>{Run("2")}</m:sup></m:sSup></m:e></m:nary></m:oMath></m:oMathPara>";
+        return new RenderFeature("equations", folder => Docx(folder, "equations", docx =>
+        {
+            docx.Paragraph(P(R("Inline ") + inline + R(" in a sentence.")))
+                .Paragraph(P(fraction))
+                .Paragraph(P(sum))
+                .Paragraph(P(R("수식 뒤 문단.")));
+        }), "Inline in a sentence.수식 뒤 문단.");
+    }
+
+    private static RenderFeature Script(string name, string text, string? font, bool rightToLeft, int repeat, bool hwp)
+    {
+        var body = string.Join(' ', Enumerable.Repeat(text, repeat));
+        var format = new HCharFormat(Size: 1100, Font: font, EastAsianFont: name is "zh" or "ja" ? font : null);
+        return new RenderFeature($"script-{name}", folder => Model(folder, $"script-{name}", section =>
+        {
+            section.Blocks.Add(Paragraph(body, new HParaFormat(Align: rightToLeft ? HAlign.Left : HAlign.Justify, RightToLeft: rightToLeft), format));
+            section.Blocks.Add(Paragraph(text, new HParaFormat(RightToLeft: rightToLeft), format));
+        }), body + text, Hwp: hwp);
+    }
+
+    /// <summary>Some pages of mixed paragraphs (FILEE_RENDER_FULL only).</summary>
+    private static RenderFeature LongDocument()
+    {
+        var text = Enumerable.Range(1, 60).Select(i => $"{i}. {Korean} {Latin}").ToList();
+        return new RenderFeature("long", folder => Model(folder, "long", section =>
+        {
+            for (var i = 0; i < text.Count; i++)
+                section.Blocks.Add(Paragraph(text[i], new HParaFormat(Align: Alignments[i % Alignments.Length])));
+        }), string.Concat(text), Pages: null);
+    }
+
+    // ───────────────────────── Building ─────────────────────────
+
+    private static string Model(string folder, string name, Action<HSection> fill)
+    {
+        var section = new HSection { Page = Page };
+        fill(section);
+        var document = new HDocument { Title = name };
+        document.Sections.Add(section);
+        Directory.CreateDirectory(folder);
+        var path = Path.Combine(folder, name + ".hwpx");
+        HwpxWriter.Write(document, path);
+        return path;
+    }
+
+    private static string Docx(string folder, string name, Action<DocxBuilder> fill)
+    {
+        // 한글's margins in Word's terms: Word measures the body from the paper edge, 한글 stacks the header area on top.
+        var docx = new DocxBuilder
+        {
+            SectionProperties = "<w:pgSz w:w=\"11906\" w:h=\"16838\"/><w:pgMar w:top=\"1984\" w:right=\"1701\" w:bottom=\"1701\" w:left=\"1701\" w:header=\"1134\" w:footer=\"850\" w:gutter=\"0\"/>",
+        };
+        fill(docx);
+        Directory.CreateDirectory(folder);
+        var source = docx.Save(Path.Combine(folder, name + ".docx"));
+        var path = Path.Combine(folder, name + ".hwpx");
+        HwpxWriter.Write(DocxReader.Read(source, Path.Combine(folder, name + "-media")), path);
+        return path;
+    }
+
+    private static HParagraph Paragraph(string text, HParaFormat format = default, HCharFormat chars = default)
+    {
+        var paragraph = new HParagraph { Format = format, MarkFormat = chars };
+        paragraph.Inlines.Add(new HText(text, chars));
+        return paragraph;
+    }
+
+    private static byte[] Png(int width, int height)
+    {
+        using var bitmap = new SKBitmap(width, height);
+        using (var canvas = new SKCanvas(bitmap))
+        {
+            using var paint = new SKPaint { Shader = SKShader.CreateLinearGradient(new SKPoint(0, 0), new SKPoint(width, height), [new SKColor(0x7F, 0x77, 0xDD), new SKColor(0x1D, 0x9E, 0x75)], SKShaderTileMode.Clamp) };
+            canvas.DrawRect(0, 0, width, height, paint);
+        }
+        using var data = bitmap.Encode(SKEncodedImageFormat.Png, 100);
+        return data.ToArray();
+    }
+}
diff --git a/tests/Filee.Engines.Tests/RenderQuality/RenderHarness.cs b/tests/Filee.Engines.Tests/RenderQuality/RenderHarness.cs
new file mode 100644
index 000000000..a0df0e58e
--- /dev/null
+++ b/tests/Filee.Engines.Tests/RenderQuality/RenderHarness.cs
@@ -0,0 +1,182 @@
+// Runs the feature matrix through a renderer and measures the PDFs: the read-back checks for every rendering, the
+// differential compare where there is something to compare with. Renderings run four at a time (rhwp is a process per
+// document). FILEE_RENDER_OUT keeps the documents, the PDFs and their pages as PNG in a folder for a look.
+
+using System.Diagnostics;
+using System.Globalization;
+using System.Text;
+using Filee.Engines.Hwp.Hwpx;
+
+namespace Filee.Engines.Tests.RenderQuality;
+
+/// <summary>A feature's document rendered by one renderer.</summary>
+/// <param name="Key">The feature name, with ".hwp" for the binary HWP made from its HWPX.</param>
+/// <param name="Input">The rendered document.</param>
+internal sealed record Rendering(RenderFeature Feature, string Key, string Input, byte[] Pdf, TimeSpan Time);
+
+internal static class RenderHarness
+{
+    private const int Parallel = 4;
+
+    /// <summary>
+    /// Writes each feature's document into <paramref name="root"/> and renders it (and, with
+    /// <paramref name="withHwp"/>, the binary HWP of the features that ask for one).
+    /// </summary>
+    public static async Task<List<Rendering>> RenderAsync(DocumentRenderer renderer, IEnumerable<RenderFeature> features, string root,
+        bool withHwp, CancellationToken cancellationToken, Func<string, string>? prepare = null)
+    {
+        using var gate = new SemaphoreSlim(Parallel);
+        var jobs = new List<Task<Rendering>>();
+        foreach (var feature in features)
+        {
+            var folder = Path.Combine(root, renderer.Name, feature.Name);
+            var hwpx = feature.Write(folder);
+            if (prepare is not null)
+                hwpx = prepare(hwpx);
+            jobs.Add(RunAsync(feature, feature.Name, hwpx));
+            if (withHwp && feature.Hwp && renderer.Formats.Contains("hwp"))
+                jobs.Add(RunAsync(feature, feature.Name + ".hwp", null, hwpx));
+        }
+        return [.. await Task.WhenAll(jobs)];
+
+        async Task<Rendering> RunAsync(RenderFeature feature, string key, string? path, string? convertFrom = null)
+        {
+            await gate.WaitAsync(cancellationToken);
+            try
+            {
+                path ??= await DocumentRenderers.ConvertToHwpAsync(convertFrom!, cancellationToken);
+                var work = Path.Combine(Path.GetDirectoryName(path)!, "work-" + Path.GetExtension(path).TrimStart('.'));
+                Directory.CreateDirectory(work);
+                var watch = Stopwatch.StartNew();
+                var pdf = await renderer.Render(new RenderInput(path, work), cancellationToken);
+                var rendering = new Rendering(feature, key, path, pdf, watch.Elapsed);
+                Keep(renderer.Name, rendering);
+                return rendering;
+            }
+            finally
+            {
+                gate.Release();
+            }
+        }
+    }
+
+    /// <summary>The read-back checks of one rendering.</summary>
+    public static List<CheckResult> ReadBack(Rendering rendering)
+    {
+        var pdf = rendering.Pdf;
+        var results = new List<CheckResult>
+        {
+            PdfChecks.TextRoundTrip(pdf, rendering.Feature.Text),
+            PdfChecks.OverlappingGlyphs(pdf),
+            PdfChecks.GlyphsOutsidePage(pdf),
+        };
+        if (Margins(rendering.Input) is { } margins)
+            results.Add(PdfChecks.GlyphsOutsideMargins(pdf, margins));
+        if (rendering.Feature.Pages is { } pages)
+            results.Add(PdfChecks.PageCount(pdf, pages));
+        if (rendering.Feature.Pitch is { } pitch)
+            results.Add(PdfChecks.BaselinePitch(pdf, pitch));
+        results.Add(PdfChecks.FontsEmbeddedAndSubset(pdf));
+        return results;
+    }
+
+    /// <summary>The differential compare as measurements: same page count, lines, lines on their baselines, lowest SSIM.</summary>
+    public static List<CheckResult> Differences(DiffResult diff) =>
+    [
+        new(PdfChecks.Pages, diff.CandidatePages, diff.SamePageCount, diff.SamePageCount ? "" : $"reference has {diff.ReferencePages}"),
+        new(RenderThresholds.Lines, diff.LineAgreement, diff.LineAgreement >= 1, $"{diff.ReferenceLines}/{diff.CandidateLines} lines{(diff.Exact ? "" : ", approximate")}"),
+        new(RenderThresholds.Placed, diff.BaselineAgreement, diff.BaselineAgreement >= 1, ""),
+        new(RenderThresholds.MinSsim, diff.MinSsim, diff.MinSsim >= 0.999, string.Create(CultureInfo.InvariantCulture, $"mean {diff.MeanSsim:0.####}")),
+    ];
+
+    /// <summary>The body margins of the document's first section, when its file is an HWPX that sets them.</summary>
+    public static PageMargins? Margins(string path)
+    {
+        if (!path.EndsWith(".hwpx", StringComparison.OrdinalIgnoreCase))
+            path = Path.ChangeExtension(path, ".hwpx"); // a binary HWP: the HWPX it was made from
+        if (!File.Exists(path))
+            return null;
+        var media = Path.Combine(Path.GetTempPath(), "filee-render-media", Guid.NewGuid().ToString("N")[..8]);
+        try
+        {
+            var document = HwpxReader.ReadForLayout(path, media);
+            // Several sections with different paper: the checks would need page-by-page margins.
+            if (document.Sections.Select(s => s.Page).Distinct().Count() != 1 || document.Sections[0].Page is not { } page)
+                return null;
+            return new PageMargins(page.Left / 100.0, page.Top / 100.0, page.Right / 100.0, page.Bottom / 100.0);
+        }
+        finally
+        {
+            try { Directory.Delete(media, true); } catch (IOException) { } catch (UnauthorizedAccessException) { }
+        }
+    }
+
+    private static void Keep(string renderer, Rendering rendering)
+    {
+        if (Environment.GetEnvironmentVariable("FILEE_RENDER_OUT") is not { Length: > 0 } folder)
+            return;
+        var target = Path.Combine(folder, renderer);
+        Directory.CreateDirectory(target);
+        File.WriteAllBytes(Path.Combine(target, rendering.Key + ".pdf"), rendering.Pdf);
+        File.Copy(rendering.Input, Path.Combine(target, Path.GetFileName(rendering.Input)), overwrite: true);
+        // The pages as PDFium draws them for the compare.
+        var pages = GreyImage.Pages(rendering.Pdf, RenderDiff.Dpi);
+        for (var i = 0; i < pages.Count; i++)
+            File.WriteAllBytes(Path.Combine(target, $"{rendering.Key}-{i + 1}.png"), pages[i].ToPng());
+    }
+
+    // ───────────────────────── Report ─────────────────────────
+
+    /// <summary>
+    /// A table of the measurements, one row per feature: each value with its verdict (ok = ideal, ≤ = within the
+    /// threshold, ↑ = better than the threshold, allowed, FAIL), then the regressions and improvements spelled out.
+    /// </summary>
+    public static string Report(IReadOnlyList<Measurement> measurements, RenderThresholds thresholds, bool markdown)
+    {
+        var checks = measurements.Select(m => m.Result.Name).Distinct().ToList();
+        var builder = new StringBuilder();
+        var rows = measurements.GroupBy(m => (m.Renderer, m.Feature)).ToList();
+        string Cell(Measurement m)
+        {
+            var value = m.Result.Value.ToString("0.####", CultureInfo.InvariantCulture);
+            return thresholds.Judge(m) switch
+            {
+                Verdict.Ideal => value,
+                Verdict.WithinThreshold => "≤ " + value,
+                Verdict.Improved => "↑ " + value,
+                Verdict.Allowed => value + " (allowed)",
+                _ => "FAIL " + value,
+            };
+        }
+        string[] header = ["renderer", "feature", .. checks];
+        var table = rows.Select(r => (string[])[r.Key.Renderer, r.Key.Feature, .. checks.Select(c => r.FirstOrDefault(m => m.Result.Name == c) is { } m ? Cell(m) : "")]).ToList();
+        if (markdown)
+        {
+            builder.AppendLine("| " + string.Join(" | ", header) + " |");
+            builder.AppendLine("|" + string.Concat(header.Select(_ => "---|")));
+            foreach (var row in table)
+                builder.AppendLine("| " + string.Join(" | ", row) + " |");
+        }
+        else
+        {
+            var widths = header.Select((h, i) => Math.Max(h.Length, table.Count == 0 ? 0 : table.Max(r => r[i].Length))).ToArray();
+            builder.AppendLine(string.Join("  ", header.Select((h, i) => h.PadRight(widths[i]))));
+            foreach (var row in table)
+                builder.AppendLine(string.Join("  ", row.Select((c, i) => c.PadRight(widths[i]))));
+        }
+        builder.AppendLine();
+        foreach (var m in measurements)
+        {
+            var verdict = thresholds.Judge(m);
+            if (verdict == Verdict.Regression)
+                builder.AppendLine($"- REGRESSION {m.Renderer} {m.Feature}: {m.Result} (threshold {thresholds.Threshold(m.Renderer, m.Feature, m.Result.Name)?.ToString(CultureInfo.InvariantCulture) ?? "ideal"}; measured {RenderThresholds.Suggest(m.Result)})");
+            else if (verdict == Verdict.Improved)
+                builder.AppendLine($"- improved {m.Renderer} {m.Feature}: {m.Result} (raise the threshold to {RenderThresholds.Suggest(m.Result)})");
+            else if (verdict == Verdict.Allowed && m.Result.Ok)
+                builder.AppendLine($"- allowed {m.Renderer} {m.Feature} {m.Result.Name} now meets the ideal: the allow-list entry can go");
+            else if (verdict == Verdict.Ideal && thresholds.Threshold(m.Renderer, m.Feature, m.Result.Name) is not null)
+                builder.AppendLine($"- improved {m.Renderer} {m.Feature}: {m.Result} meets the ideal, the threshold can go");
+        }
+        return builder.ToString();
+    }
+}
diff --git a/tests/Filee.Engines.Tests/RenderQuality/RenderQualityTests.cs b/tests/Filee.Engines.Tests/RenderQuality/RenderQualityTests.cs
new file mode 100644
index 000000000..f70399ae9
--- /dev/null
+++ b/tests/Filee.Engines.Tests/RenderQuality/RenderQualityTests.cs
@@ -0,0 +1,181 @@
+// The render quality harness on the feature matrix (RenderFeatures): every document rendered by rhwp, the reference,
+// goes through the read-back checks, its binary HWP twin is compared with it, and every measurement is held to
+// render-thresholds.json. Once Filee's layout engine registers a renderer (DocumentRenderers.Candidate), its PDFs
+// get the same checks and are compared with rhwp's. The metrics are printed per feature (and added to the job
+// summary on GitHub Actions).
+//
+// rhwp's results depend on the fonts installed, so the thresholds are those of the Windows CI runner and the
+// matrix runs on Windows only. The self-comparison and the perturbed renderings prove the compare itself: rhwp
+// against rhwp must be identical, and a shifted or re-wrapped rendering must be caught.
+
+using System.IO.Compression;
+using System.Text;
+using System.Text.RegularExpressions;
+using PdfSharp.Drawing;
+using PdfSharp.Pdf;
+using PdfSharp.Pdf.IO;
+
+namespace Filee.Engines.Tests.RenderQuality;
+
+[Trait("Category", "Render")]
+public class RenderQualityTests(EngineFixture fx) : IClassFixture<EngineFixture>
+{
+    private static DocumentRenderer Rhwp()
+    {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "rhwp's thresholds are measured with the fonts of Windows");
+        var rhwp = DocumentRenderers.Reference;
+        Assert.SkipUnless(rhwp is not null, "rhwp not found (pwsh build/fetch-engines.ps1 -Only rhwp)");
+        return rhwp;
+    }
+
+    [Fact]
+    public async Task Feature_matrix_rendered_by_rhwp_holds_its_thresholds()
+    {
+        var rhwp = Rhwp();
+        var thresholds = RenderThresholds.Load();
+        var ct = TestContext.Current.CancellationToken;
+
+        var renderings = await RenderHarness.RenderAsync(rhwp, RenderFeatures.Selected, fx.NewFolder(), withHwp: true, ct);
+
+        var measurements = new List<Measurement>();
+        foreach (var rendering in renderings)
+        {
+            measurements.AddRange(RenderHarness.ReadBack(rendering).Select(r => new Measurement(rhwp.Name, rendering.Key, r)));
+            // rhwp's HWP against its HWPX: one document, so the two renderings should agree.
+            if (rendering.Key.EndsWith(".hwp", StringComparison.Ordinal))
+            {
+                var fromHwpx = renderings.Single(r => r.Key == rendering.Feature.Name);
+                measurements.AddRange(RenderHarness.Differences(RenderDiff.Compare(fromHwpx.Pdf, rendering.Pdf))
+                    .Where(r => r.Name != PdfChecks.Pages || rendering.Feature.Pages is null) // else measured against the feature's count
+                    .Select(r => new Measurement(rhwp.Name, rendering.Key, r)));
+            }
+        }
+
+        Publish("rhwp", measurements, thresholds, renderings);
+        var regressions = measurements.Where(m => thresholds.Judge(m) == Verdict.Regression).ToList();
+        Assert.True(regressions.Count == 0, "Render quality regressions:\n" + string.Join("\n", regressions.Select(m => $"{m.Feature}: {m.Result}")));
+    }
+
+    [Fact]
+    public async Task Feature_matrix_rendered_by_filee_holds_its_thresholds_against_rhwp()
+    {
+        var rhwp = Rhwp();
+        var filee = DocumentRenderers.Candidate;
+        Assert.SkipWhen(filee is null, DocumentRenderers.NoCandidate);
+        var thresholds = RenderThresholds.Load();
+        var ct = TestContext.Current.CancellationToken;
+        var root = fx.NewFolder();
+
+        var features = RenderFeatures.Selected;
+        var reference = await RenderHarness.RenderAsync(rhwp, features, root, withHwp: false, ct);
+        var candidate = await RenderHarness.RenderAsync(filee!, features, root, withHwp: true, ct);
+
+        var measurements = new List<Measurement>();
+        foreach (var rendering in candidate)
+        {
+            measurements.AddRange(RenderHarness.ReadBack(rendering).Select(r => new Measurement(filee!.Name, rendering.Key, r)));
+            var against = reference.Single(r => r.Key == rendering.Feature.Name);
+            measurements.AddRange(RenderHarness.Differences(RenderDiff.Compare(against.Pdf, rendering.Pdf))
+                .Select(r => new Measurement(filee!.Name, rendering.Key, r with { Name = RenderThresholds.Versus + r.Name })));
+        }
+
+        Publish(filee!.Name, measurements, thresholds, candidate);
+        var regressions = measurements.Where(m => thresholds.Judge(m) == Verdict.Regression).ToList();
+        Assert.True(regressions.Count == 0, "Render quality regressions:\n" + string.Join("\n", regressions.Select(m => $"{m.Feature}: {m.Result}")));
+    }
+
+    [Fact]
+    public async Task Rhwp_compared_with_itself_is_identical()
+    {
+        var rhwp = Rhwp();
+        var ct = TestContext.Current.CancellationToken;
+        var features = RenderFeatures.All.Where(f => f.Name is "tables" or "script-ko").ToList();
+
+        var first = await RenderHarness.RenderAsync(rhwp, features, fx.NewFolder(), withHwp: false, ct);
+        var second = await RenderHarness.RenderAsync(rhwp, features, fx.NewFolder(), withHwp: false, ct);
+
+        foreach (var (a, b) in first.Zip(second))
+        {
+            var diff = RenderDiff.Compare(a.Pdf, b.Pdf);
+            TestContext.Current.TestOutputHelper?.WriteLine($"{a.Key}: {diff}");
+            Assert.True(diff.SamePageCount && diff.LineAgreement == 1 && diff.BaselineAgreement == 1 && diff.MinSsim > 0.9999, $"{a.Key}: {diff}");
+        }
+    }
+
+    [Fact]
+    public async Task Perturbed_renderings_are_caught()
+    {
+        var rhwp = Rhwp();
+        var ct = TestContext.Current.CancellationToken;
+        var feature = RenderFeatures.All.Single(f => f.Name == "line-spacing-percent");
+        var original = Assert.Single(await RenderHarness.RenderAsync(rhwp, [feature], fx.NewFolder(), withHwp: false, ct));
+
+        // The same pages moved down by 2 pt: every line keeps its text, none its baseline, and the pictures differ.
+        var shifted = RenderDiff.Compare(original.Pdf, Shift(original.Pdf, 2));
+        TestContext.Current.TestOutputHelper?.WriteLine($"shifted: {shifted}");
+        Assert.True(shifted.SamePageCount);
+        Assert.Equal(1, shifted.LineAgreement);
+        Assert.Equal(0, shifted.BaselineAgreement);
+        Assert.True(shifted.MinSsim < 0.95, shifted.ToString());
+        Assert.Equal(0, PdfChecks.BaselinesMatch([.. PdfLines.Read(Shift(original.Pdf, 2)).Select(l => l.Baseline)], [.. PdfLines.Read(original.Pdf).Select(l => l.Baseline)]).Value);
+
+        // A wider left margin: the lines break elsewhere.
+        var narrower = Assert.Single(await RenderHarness.RenderAsync(rhwp, [feature], fx.NewFolder(), withHwp: false, ct, WidenLeftMargin));
+        var rewrapped = RenderDiff.Compare(original.Pdf, narrower.Pdf);
+        TestContext.Current.TestOutputHelper?.WriteLine($"re-wrapped: {rewrapped}");
+        Assert.True(rewrapped.LineAgreement < 0.5, rewrapped.ToString());
+        Assert.True(rewrapped.MinSsim < 0.9, rewrapped.ToString());
+    }
+
+    // ───────────────────────── Perturbations ─────────────────────────
+
+    /// <summary>Every page of <paramref name="pdf"/> drawn <paramref name="points"/> lower on a page of the same size.</summary>
+    internal static byte[] Shift(byte[] pdf, double points)
+    {
+        using var source = new MemoryStream(pdf);
+        using var form = XPdfForm.FromStream(source);
+        using var output = new PdfDocument();
+        for (var i = 0; i < form.PageCount; i++)
+        {
+            form.PageNumber = i + 1;
+            var page = output.AddPage();
+            page.Width = XUnit.FromPoint(form.PointWidth);
+            page.Height = XUnit.FromPoint(form.PointHeight);
+            using var graphics = XGraphics.FromPdfPage(page);
+            graphics.DrawImage(form, 0, points, form.PointWidth, form.PointHeight);
+        }
+        using var result = new MemoryStream();
+        output.Save(result);
+        return result.ToArray();
+    }
+
+    /// <summary>A copy of an HWPX whose left margin is 20 mm wider, so its lines are shorter.</summary>
+    private static string WidenLeftMargin(string hwpx)
+    {
+        var copy = Path.Combine(Path.GetDirectoryName(hwpx)!, "narrower.hwpx");
+        File.Copy(hwpx, copy, overwrite: true);
+        using var zip = ZipFile.Open(copy, ZipArchiveMode.Update);
+        var entry = zip.GetEntry("Contents/section0.xml")!;
+        string xml;
+        using (var reader = new StreamReader(entry.Open()))
+            xml = reader.ReadToEnd();
+        xml = Regex.Replace(xml, "(<hp:margin[^>]*\\bleft=\")(\\d+)\"", m => $"{m.Groups[1].Value}{int.Parse(m.Groups[2].Value, System.Globalization.CultureInfo.InvariantCulture) + 5669}\"");
+        entry.Delete();
+        using (var writer = new StreamWriter(zip.CreateEntry("Contents/section0.xml").Open(), new UTF8Encoding(false)))
+            writer.Write(xml);
+        return copy;
+    }
+
+    // ───────────────────────── Output ─────────────────────────
+
+    private static void Publish(string renderer, IReadOnlyList<Measurement> measurements, RenderThresholds thresholds, IReadOnlyList<Rendering> renderings)
+    {
+        var time = TimeSpan.FromTicks(renderings.Sum(r => r.Time.Ticks));
+        var title = $"Render quality: {renderer}, {renderings.Count} documents ({time.TotalSeconds:0.0} s rendering)";
+        TestContext.Current.TestOutputHelper?.WriteLine(title);
+        TestContext.Current.TestOutputHelper?.WriteLine(RenderHarness.Report(measurements, thresholds, markdown: false));
+        // The CI's job summary shows the table without opening the test results.
+        if (Environment.GetEnvironmentVariable("GITHUB_STEP_SUMMARY") is { Length: > 0 } summary)
+            File.AppendAllText(summary, $"### {title}\n\n{RenderHarness.Report(measurements, thresholds, markdown: true)}\n");
+    }
+}
diff --git a/tests/Filee.Engines.Tests/RenderQuality/RenderThresholds.cs b/tests/Filee.Engines.Tests/RenderQuality/RenderThresholds.cs
new file mode 100644
index 000000000..6b3d083a7
--- /dev/null
+++ b/tests/Filee.Engines.Tests/RenderQuality/RenderThresholds.cs
@@ -0,0 +1,91 @@
+// The render quality thresholds (render-thresholds.json next to this file): what each renderer measured on each
+// feature where it falls short of the ideal. A measurement must meet the ideal (the exact text, no overlaps, every
+// font subset, identical renderings ...) unless the file gives a threshold for it, and must never be worse than that
+// threshold: a worse value is a regression and fails the test. A better value passes and is reported, so the
+// threshold can be raised in the same change. Allow-listed measurements (known rhwp defects) are reported only.
+
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Filee.Engines.Tests.RenderQuality;
+
+/// <summary>A measured value of one feature, rendered by one renderer.</summary>
+internal sealed record Measurement(string Renderer, string Feature, CheckResult Result);
+
+internal enum Verdict
+{
+    Ideal,
+    WithinThreshold,
+    Improved,
+    Allowed,
+    Regression,
+}
+
+internal sealed class RenderThresholds
+{
+    /// <summary>Measurements where a higher value is better; the others count faults (lower is better).</summary>
+    private static readonly HashSet<string> HigherIsBetter = [PdfChecks.Text, PdfChecks.Baselines, Lines, Placed, MinSsim];
+
+    /// <summary>Diff measurements: share of lines with the same text, share also on the same baseline, lowest page SSIM.</summary>
+    public const string Lines = "lines", Placed = "placed", MinSsim = "ssim";
+
+    /// <summary>Prefix of the diff measurements of a candidate renderer against the reference.</summary>
+    public const string Versus = "vs-rhwp-";
+
+    /// <summary>renderer → feature → measurement → threshold.</summary>
+    [JsonPropertyName("thresholds")]
+    public Dictionary<string, Dictionary<string, Dictionary<string, double>>> Thresholds { get; init; } = [];
+
+    [JsonPropertyName("allow")]
+    public List<AllowEntry> Allow { get; init; } = [];
+
+    public sealed record AllowEntry(
+        [property: JsonPropertyName("renderer")] string Renderer,
+        [property: JsonPropertyName("feature")] string Feature,
+        [property: JsonPropertyName("check")] string Check,
+        [property: JsonPropertyName("reason")] string Reason);
+
+    public static RenderThresholds Load(string? path = null)
+    {
+        path ??= Path.Combine(AppContext.BaseDirectory, "RenderQuality", "render-thresholds.json");
+        var options = new JsonSerializerOptions { ReadCommentHandling = JsonCommentHandling.Skip, AllowTrailingCommas = true };
+        return JsonSerializer.Deserialize<RenderThresholds>(File.ReadAllText(path), options) ?? new RenderThresholds();
+    }
+
+    public double? Threshold(string renderer, string feature, string check) =>
+        Thresholds.TryGetValue(renderer, out var features) && features.TryGetValue(feature, out var checks) && checks.TryGetValue(check, out var value)
+            ? value
+            : null;
+
+    /// <summary>The allow-list entry for a measurement; "*" stands for any feature, a trailing "*" for checks starting so.</summary>
+    public AllowEntry? Allowed(string renderer, string feature, string check) =>
+        Allow.FirstOrDefault(a => a.Renderer == renderer && (a.Feature == feature || a.Feature == "*")
+                                  && (a.Check == check || (a.Check.EndsWith('*') && check.StartsWith(a.Check[..^1], StringComparison.Ordinal))));
+
+    public Verdict Judge(Measurement measurement)
+    {
+        var (renderer, feature, result) = measurement;
+        if (Allowed(renderer, feature, result.Name) is not null)
+            return Verdict.Allowed;
+        if (Threshold(renderer, feature, result.Name) is not { } threshold)
+            return result.Ok ? Verdict.Ideal : Verdict.Regression;
+        const double Epsilon = 1e-4; // values are printed and kept to four decimals
+        var higher = HigherIsBetter.Contains(Base(result.Name));
+        var better = higher ? result.Value > threshold + Epsilon : result.Value < threshold - Epsilon;
+        var worse = higher ? result.Value < threshold - Epsilon : result.Value > threshold + Epsilon;
+        if (Base(result.Name) == PdfChecks.Pages)
+            return Math.Abs(result.Value - threshold) < Epsilon ? Verdict.WithinThreshold : Verdict.Regression;
+        return worse ? Verdict.Regression : better ? (result.Ok ? Verdict.Ideal : Verdict.Improved) : Verdict.WithinThreshold;
+    }
+
+    /// <summary>The value to keep in the file for a measurement (four decimals, rounded towards passing).</summary>
+    public static string Suggest(CheckResult result)
+    {
+        var scaled = result.Value * 10000;
+        var value = (HigherIsBetter.Contains(Base(result.Name)) ? Math.Floor(scaled + 1e-6) : Math.Ceiling(scaled - 1e-6)) / 10000;
+        return value.ToString("0.####", CultureInfo.InvariantCulture);
+    }
+
+    private static string Base(string name) => name.StartsWith(Versus, StringComparison.Ordinal) ? name[Versus.Length..] : name;
+}
diff --git a/tests/Filee.Engines.Tests/RenderQuality/SequenceMatch.cs b/tests/Filee.Engines.Tests/RenderQuality/SequenceMatch.cs
new file mode 100644
index 000000000..81469cc36
--- /dev/null
+++ b/tests/Filee.Engines.Tests/RenderQuality/SequenceMatch.cs
@@ -0,0 +1,92 @@
+// Longest common subsequence of two sequences (characters of a text, lines of a document) with Myers' O(ND) diff, so
+// documents that mostly agree are matched quickly whatever their length. Past a number of differences the matching
+// stops and falls back to pairing equal items without regard to their order: the result is then marked approximate.
+
+namespace Filee.Engines.Tests.RenderQuality;
+
+internal static class SequenceMatch
+{
+    /// <summary>
+    /// Index pairs (in <paramref name="a"/>, in <paramref name="b"/>) of a longest common subsequence, in order. With
+    /// more than <paramref name="maxDifferences"/> insertions and deletions, equal items are paired in order of
+    /// occurrence instead and <c>Exact</c> is false.
+    /// </summary>
+    public static (List<(int A, int B)> Pairs, bool Exact) Match<T>(IReadOnlyList<T> a, IReadOnlyList<T> b,
+        IEqualityComparer<T>? comparer = null, int maxDifferences = 2000) where T : notnull
+    {
+        comparer ??= EqualityComparer<T>.Default;
+        int n = a.Count, m = b.Count;
+        var limit = Math.Min(n + m, maxDifferences);
+        var offset = limit + 1;
+        var v = new int[2 * limit + 3];
+        // The furthest x on each diagonal -d..d before step d: the trace grows with d², not with the length.
+        var trace = new List<int[]>();
+        for (var d = 0; d <= limit; d++)
+        {
+            trace.Add(v[(offset - d)..(offset + d + 1)]);
+            for (var k = -d; k <= d; k += 2)
+            {
+                var x = k == -d || (k != d && v[offset + k - 1] < v[offset + k + 1]) ? v[offset + k + 1] : v[offset + k - 1] + 1;
+                var y = x - k;
+                while (x < n && y < m && comparer.Equals(a[x], b[y]))
+                {
+                    x++;
+                    y++;
+                }
+                v[offset + k] = x;
+                if (x >= n && y >= m)
+                    return (Backtrack(trace, n, m), true);
+            }
+        }
+        return (InOrderOfOccurrence(a, b, comparer), false);
+    }
+
+    private static List<(int A, int B)> Backtrack(List<int[]> trace, int n, int m)
+    {
+        var pairs = new List<(int A, int B)>();
+        int x = n, y = m;
+        for (var d = trace.Count - 1; d >= 0; d--)
+        {
+            int startX = 0, startY = 0, previousX = 0, previousY = 0;
+            if (d > 0)
+            {
+                var before = trace[d];
+                int At(int diagonal) => before[diagonal + d];
+                var k = x - y;
+                var down = k == -d || (k != d && At(k - 1) < At(k + 1));
+                var previousK = down ? k + 1 : k - 1;
+                previousX = At(previousK);
+                previousY = previousX - previousK;
+                (startX, startY) = down ? (previousX, previousY + 1) : (previousX + 1, previousY);
+            }
+            // The snake of equal items that ends at (x, y).
+            while (x > startX && y > startY)
+            {
+                pairs.Add((x - 1, y - 1));
+                x--;
+                y--;
+            }
+            x = previousX;
+            y = previousY;
+        }
+        pairs.Reverse();
+        return pairs;
+    }
+
+    private static List<(int A, int B)> InOrderOfOccurrence<T>(IReadOnlyList<T> a, IReadOnlyList<T> b, IEqualityComparer<T> comparer)
+        where T : notnull
+    {
+        var waiting = new Dictionary<T, Queue<int>>(comparer);
+        for (var j = 0; j < b.Count; j++)
+        {
+            if (!waiting.TryGetValue(b[j], out var queue))
+                waiting[b[j]] = queue = new Queue<int>();
+            queue.Enqueue(j);
+        }
+        var pairs = new List<(int A, int B)>();
+        for (var i = 0; i < a.Count; i++)
+            if (waiting.TryGetValue(a[i], out var queue) && queue.Count > 0)
+                pairs.Add((i, queue.Dequeue()));
+        return pairs;
+    }
+}
diff --git a/tests/Filee.Engines.Tests/RenderQuality/render-thresholds.json b/tests/Filee.Engines.Tests/RenderQuality/render-thresholds.json
new file mode 100644
index 000000000..e24a16bc1
--- /dev/null
+++ b/tests/Filee.Engines.Tests/RenderQuality/render-thresholds.json
@@ -0,0 +1,52 @@
+// Render quality thresholds (tests/Filee.Engines.Tests/RenderQuality, docs/RENDER-QUALITY.md).
+//
+// A measurement must meet the ideal (the exact text, no overlapping glyphs, nothing outside the page or the margins,
+// the page count, the line pitch, every font embedded and subset; for compares: the same pages, lines and baselines
+// and SSIM >= 0.999) unless a threshold below says what the renderer reaches today. It must never fall below that:
+// a worse value fails the test. A better one is reported, and the threshold is raised (or removed) in the same change.
+// "allow" lists measurements that are reported but never fail, each with its reason.
+//
+// rhwp's values were measured on Windows (Malgun Gothic, Segoe UI, Nirmala UI, Leelawadee UI, Microsoft YaHei, Yu
+// Gothic) with rhwp 0.8.7.
+{
+  "thresholds": {
+    "rhwp": {
+      // Square wrap isn't kept and the paragraphs after the floating objects are drawn over each other.
+      "floating": { "overlaps": 0.1265 },
+      // E = mc²: m and c of the inline equation overlap.
+      "equations": { "overlaps": 0.0304 },
+      // Unshaped text at rhwp's fixed widths (#185, #202, rhwp#8143). Overlaps are a share of neighbouring glyphs.
+      "script-ar": { "overlaps": 0.487 },
+      "script-he": { "overlaps": 0.6 },
+      "script-hi": { "overlaps": 0.6725 },
+      "script-gu": { "overlaps": 0.6404 },
+      // ำ (SARA AM) is drawn as its two parts, so the text doesn't round-trip.
+      "script-th": { "text": 0.9734, "overlaps": 0.2141 },
+
+      // Only in the full run (FILEE_RENDER_FULL=1), where every feature is also rendered from a binary HWP made by
+      // rhwp convert. From the HWP, rhwp draws 。 and 、 half an em over the next character (so the lines break
+      // elsewhere) and places the equations differently.
+      "floating.hwp": { "overlaps": 0.1265 },
+      "equations.hwp": { "overlaps": 0.0304, "placed": 0.375, "ssim": 0.5044 },
+      "script-zh.hwp": { "overlaps": 0.0215, "lines": 0, "placed": 0, "ssim": 0.234 },
+      "script-ja.hwp": { "overlaps": 0.0404, "lines": 0, "placed": 0, "ssim": 0.1858 },
+      "script-ar.hwp": { "overlaps": 0.487 },
+      "script-he.hwp": { "overlaps": 0.5965 },
+      "script-hi.hwp": { "overlaps": 0.6707 },
+      "script-gu.hwp": { "overlaps": 0.6387 },
+      "script-th.hwp": { "text": 0.9734, "overlaps": 0.1709 }
+    },
+    // Filee's layout engine (DocumentRenderers.Candidate): its own read-back checks and vs-rhwp-* compares.
+    "filee": {}
+  },
+  "allow": [
+    // Where rhwp is wrong, Filee's renderer can't agree with it: the compare is reported, never failed.
+    { "renderer": "filee", "feature": "floating", "check": "vs-rhwp-*", "reason": "rhwp ignores square wrap and overlaps the paragraphs after floating objects" },
+    { "renderer": "filee", "feature": "equations", "check": "vs-rhwp-*", "reason": "rhwp lays out equations itself, Filee's engine draws them its own way" },
+    { "renderer": "filee", "feature": "script-ar", "check": "vs-rhwp-*", "reason": "rhwp draws Arabic unshaped, left to right (#202)" },
+    { "renderer": "filee", "feature": "script-he", "check": "vs-rhwp-*", "reason": "rhwp draws Hebrew left to right at fixed widths (rhwp#8143)" },
+    { "renderer": "filee", "feature": "script-hi", "check": "vs-rhwp-*", "reason": "rhwp draws Devanagari unshaped (#185)" },
+    { "renderer": "filee", "feature": "script-gu", "check": "vs-rhwp-*", "reason": "rhwp draws Gujarati unshaped (#185)" },
+    { "renderer": "filee", "feature": "script-th", "check": "vs-rhwp-*", "reason": "rhwp draws Thai marks at fixed widths and breaks lines without a dictionary" }
+  ]
+}
diff --git a/tests/Filee.Engines.Tests/TestShaper.cs b/tests/Filee.Engines.Tests/TestShaper.cs
new file mode 100644
index 000000000..40ecbecef
--- /dev/null
+++ b/tests/Filee.Engines.Tests/TestShaper.cs
@@ -0,0 +1,69 @@
+// HarfBuzz shaping of one run in one font, for tests that draw pages with Filee's page writer (PdfPageWriterTests,
+// the render quality checks). The layout engine's own shaper is a later step.
+
+using System.Runtime.InteropServices;
+using Filee.Engines.Rendering;
+using HarfBuzzSharp;
+using SkiaSharp;
+using Buffer = HarfBuzzSharp.Buffer;
+
+namespace Filee.Engines.Tests;
+
+internal sealed class TestShaper : IDisposable
+{
+    private readonly Dictionary<PageFont, (Blob Blob, Face Face, HarfBuzzSharp.Font Font)> _fonts = new(ReferenceEqualityComparer.Instance);
+
+    public float Width(PageFont font, float size, string text) => Shape(font, size, text, 0, 0).Width;
+
+    /// <summary>Shapes <paramref name="text"/> with the pen starting at x on baseline y (page coordinates).</summary>
+    public (GlyphRun Run, float Width) Shape(PageFont font, float size, string text, float x, float y, SKColor? color = null)
+    {
+        var (hb, upem) = For(font);
+        using var buffer = new Buffer();
+        buffer.AddUtf16(text);
+        buffer.GuessSegmentProperties();
+        hb.Shape(buffer);
+        var infos = buffer.GlyphInfos;
+        var positions = buffer.GlyphPositions;
+        var scale = size / upem;
+        var glyphs = new ushort[infos.Length];
+        var points = new SKPoint[infos.Length];
+        var clusters = new int[infos.Length];
+        var pen = 0f;
+        for (var i = 0; i < infos.Length; i++)
+        {
+            glyphs[i] = (ushort)infos[i].Codepoint;
+            clusters[i] = (int)infos[i].Cluster;
+            points[i] = new SKPoint(x + pen + positions[i].XOffset * scale, y - positions[i].YOffset * scale);
+            pen += positions[i].XAdvance * scale;
+        }
+        return (new GlyphRun(font, size, glyphs, points, text, clusters) { Color = color ?? SKColors.Black }, pen);
+    }
+
+    private (HarfBuzzSharp.Font Font, int Upem) For(PageFont font)
+    {
+        if (!_fonts.TryGetValue(font, out var entry))
+        {
+            // A native copy the blob owns: HarfBuzz reads the font data for as long as the face lives.
+            var memory = Marshal.AllocHGlobal(font.Data.Length);
+            Marshal.Copy(font.Data, 0, memory, font.Data.Length);
+            var blob = new Blob(memory, font.Data.Length, MemoryMode.ReadOnly, () => Marshal.FreeHGlobal(memory));
+            var face = new Face(blob, font.FaceIndex);
+            var hb = new HarfBuzzSharp.Font(face);
+            hb.SetScale(face.UnitsPerEm, face.UnitsPerEm);
+            hb.SetFunctionsOpenType();
+            _fonts[font] = entry = (blob, face, hb);
+        }
+        return (entry.Font, entry.Face.UnitsPerEm);
+    }
+
+    public void Dispose()
+    {
+        foreach (var (blob, face, font) in _fonts.Values)
+        {
+            font.Dispose();
+            face.Dispose();
+            blob.Dispose();
+        }
+    }
+}