diff --git a/anton/core/artifacts/report_tools.py b/anton/core/artifacts/report_tools.py
index e84651b5a..a882a9a12 100644
--- a/anton/core/artifacts/report_tools.py
+++ b/anton/core/artifacts/report_tools.py
@@ -14,6 +14,11 @@
 
 They are imported from the installed package rather than copied into artifact
 folders, so a report made with one release opens and edits with the next.
+
+Block-level markup (sections, paragraphs, list items, table rows, chart bars)
+ends with a line break, so line-based tools can read and diff a page part by
+part. Line breaks go only between elements where the browser does not show
+whitespace, never inside text.
 """
 
 from __future__ import annotations
@@ -86,36 +91,39 @@ def _slug(text: str) -> str:
 if(empty){empty.hidden=shown>0;}}
 sel.addEventListener('change',apply);apply();});})();
 """
-_FILTER_SCRIPT = f"<script>{_FILTER_JS}</script>"
+_FILTER_SCRIPT = f"<script>{_FILTER_JS}</script>\n"
 
 
 def page(title: str, *parts, lang: str = "en", theme: str = "light", subtitle: str | None = None) -> Html:
     """A complete document: lang, charset, viewport, inline CSS, light or dark theme."""
     if theme not in ("light", "dark"):
         raise ValueError('theme must be "light" or "dark"')
+    # Parts are joined without separators: a line break between two inline
+    # parts (text and a link) would show as a space. Block parts end with one.
     body = "".join(_esc(p) for p in parts)
     script = _FILTER_SCRIPT if "data-rt-filter" in body else ""
-    sub = f'<p class="subtitle">{_esc(subtitle)}</p>' if subtitle else ""
+    sub = f'<p class="subtitle">{_esc(subtitle)}</p>\n' if subtitle else ""
     return Html(
-        f'<!doctype html><html lang="{_esc(lang)}" data-theme="{theme}"><head><meta charset="utf-8">'
-        f'<meta name="viewport" content="width=device-width,initial-scale=1"><title>{_esc(title)}</title>'
-        f"<style>{_CSS}</style></head><body><main><h1>{_esc(title)}</h1>{sub}{body}{script}</main></body></html>\n"
+        f'<!doctype html>\n<html lang="{_esc(lang)}" data-theme="{theme}">\n<head>\n<meta charset="utf-8">\n'
+        f'<meta name="viewport" content="width=device-width,initial-scale=1">\n<title>{_esc(title)}</title>\n'
+        f"<style>{_CSS}</style>\n</head>\n<body>\n<main>\n<h1>{_esc(title)}</h1>\n{sub}{body}{script}"
+        "</main>\n</body>\n</html>\n"
     )
 
 
 def section(heading: str, *parts, id: str | None = None) -> Html:
     """A titled block. ``id`` defaults to the heading's slug plus "-section"."""
-    return Html(f'<section id="{_esc(id or _slug(heading) + "-section")}"><h2>{_esc(heading)}</h2>'
-                + "".join(_esc(p) for p in parts) + "</section>")
+    return Html(f'<section id="{_esc(id or _slug(heading) + "-section")}"><h2>{_esc(heading)}</h2>\n'
+                + "".join(_esc(p) for p in parts) + "</section>\n")
 
 
 def para(*texts) -> Html:
     """One paragraph per text."""
-    return Html("".join(f"<p>{_esc(t)}</p>" for t in texts))
+    return Html("".join(f"<p>{_esc(t)}</p>\n" for t in texts))
 
 
 def bullets(items) -> Html:
-    return Html("<ul>" + "".join(f"<li>{_esc(i)}</li>" for i in items) + "</ul>")
+    return Html("<ul>\n" + "".join(f"<li>{_esc(i)}</li>\n" for i in items) + "</ul>\n")
 
 
 def _is_number(value) -> bool:
@@ -140,9 +148,19 @@ def _numeric_columns(body, count) -> list[bool]:
             for i in range(count)]
 
 
-def _thead(columns, numeric) -> str:
-    return "<thead><tr>" + "".join(
+def _tds(cells, numeric) -> str:
+    return "".join(f'<td{" class=num" if n else ""}>{_esc(v)}</td>' for v, n in zip(cells, numeric))
+
+
+_TABLE_WRAP = '<div class="table-wrap">'
+
+
+def _table_html(columns, numeric, trs, *, table_attrs: str = "", caption: str = "") -> str:
+    """A scrollable table, one row per line. ``trs`` are whole ``<tr>`` elements."""
+    head = "<thead><tr>" + "".join(
         f'<th scope="col"{" class=num" if n else ""}>{_esc(c)}</th>' for c, n in zip(columns, numeric)) + "</tr></thead>"
+    return (f"{_TABLE_WRAP}<table{table_attrs}>{caption}\n{head}\n<tbody>\n"
+            + "".join(tr + "\n" for tr in trs) + "</tbody></table></div>\n")
 
 
 def table(columns, rows, *, caption: str | None = None, id: str | None = None) -> Html:
@@ -151,9 +169,8 @@ def table(columns, rows, *, caption: str | None = None, id: str | None = None) -
     body = [_row_cells(columns, r) for r in rows]
     numeric = _numeric_columns(body, len(columns))
     cap = f"<caption>{_esc(caption)}</caption>" if caption else ""
-    trs = "".join("<tr>" + "".join(f'<td{" class=num" if n else ""}>{_esc(v)}</td>' for v, n in zip(r, numeric))
-                  + "</tr>" for r in body)
-    return Html(f'<div class="table-wrap"><table{_attr_id(id)}>{cap}{_thead(columns, numeric)}<tbody>{trs}</tbody></table></div>')
+    trs = [f"<tr>{_tds(r, numeric)}</tr>" for r in body]
+    return Html(_table_html(columns, numeric, trs, table_attrs=_attr_id(id), caption=cap))
 
 
 def bar_chart(labels, values, *, name: str, value_label: str = "Value", threshold: float | None = None,
@@ -177,13 +194,14 @@ def bar_chart(labels, values, *, name: str, value_label: str = "Value", threshol
         bars.append(f'<text x="{left - 8}" y="{y + 18}" text-anchor="end">{_esc(label)}</text>'
                     f'<rect class="bar" x="{left}" y="{y + 4}" width="{w:.1f}" height="{row_h - 10}">'
                     f"<title>{_esc(label)}: {_esc(value)} {_esc(value_label)}</title></rect>"
-                    f'<text x="{left + w + 6:.1f}" y="{y + 18}">{_esc(value)}</text>')
+                    f'<text x="{left + w + 6:.1f}" y="{y + 18}">{_esc(value)}</text>\n')
     mark = ""
     if threshold is not None:
         x = left + width * threshold / top
-        mark = f'<line class="threshold" x1="{x:.1f}" x2="{x:.1f}" y1="4" y2="{height - 4}"><title>Threshold {_esc(threshold)}</title></line>'
+        mark = (f'<line class="threshold" x1="{x:.1f}" x2="{x:.1f}" y1="4" y2="{height - 4}">'
+                f"<title>Threshold {_esc(threshold)}</title></line>\n")
     return Html(f'<svg class="bars"{_attr_id(id)} role="img" aria-label="{_esc(name)}" '
-                f'viewBox="0 0 {left + width + 60} {height}"><title>{_esc(name)}</title>{"".join(bars)}{mark}</svg>')
+                f'viewBox="0 0 {left + width + 60} {height}"><title>{_esc(name)}</title>\n{"".join(bars)}{mark}</svg>\n')
 
 
 def filter_table(columns, rows, *, key: str, label: str, region_name: str, value: str | None = None,
@@ -213,19 +231,20 @@ def filter_table(columns, rows, *, key: str, label: str, region_name: str, value
         total += r[v] if visible and v is not None and _is_number(r[v]) else 0
         val_attr = f' data-rt-value="{_esc(r[v])}"' if v is not None and _is_number(r[v]) else ""
         trs.append(f'<tr data-rt-key="{_esc(row_key)}"{val_attr}{"" if visible else " hidden"}>'
-                   + "".join(f'<td{" class=num" if n else ""}>{_esc(c)}</td>' for c, n in zip(r, numeric)) + "</tr>")
+                   f"{_tds(r, numeric)}</tr>")
     total_html = ""
     if v is not None:
         tl = total_label or f"Total {value}"
-        total_html = f'<p class="total" data-rt-total="{_esc(tl)}" aria-live="polite">{_esc(tl)}: {_esc(round(total, 6))}</p>'
+        total_html = f'<p class="total" data-rt-total="{_esc(tl)}" aria-live="polite">{_esc(tl)}: {_esc(round(total, 6))}</p>\n'
+    # The label and the select are inline: a line break between them would show as a space.
     return Html(
         f'<div class="filter" id="{_esc(fid)}" data-rt-filter{" data-rt-hide-zero" if hide_zero else ""}>'
         f'<label for="{_esc(fid)}-select">{_esc(label)}</label>'
-        f'<select id="{_esc(fid)}-select"><option value="">All</option>'
-        + "".join(f'<option value="{_esc(o)}">{_esc(o) or "(blank)"}</option>' for o in options) + "</select>"
-        f'<div role="region" aria-label="{_esc(region_name)}"><h3>{_esc(region_name)}</h3>{total_html}'
-        f'<p data-rt-empty{" hidden" if shown else ""}>{_esc(empty_text)}</p>'
-        f'<div class="table-wrap"><table>{_thead(columns, numeric)}<tbody>{"".join(trs)}</tbody></table></div></div></div>'
+        f'<select id="{_esc(fid)}-select">\n<option value="">All</option>\n'
+        + "".join(f'<option value="{_esc(o)}">{_esc(o) or "(blank)"}</option>\n' for o in options) + "</select>\n"
+        f'<div role="region" aria-label="{_esc(region_name)}"><h3>{_esc(region_name)}</h3>\n{total_html}'
+        f'<p data-rt-empty{" hidden" if shown else ""}>{_esc(empty_text)}</p>\n'
+        + _table_html(columns, numeric, trs) + "</div>\n</div>\n"
     )
 
 
@@ -253,7 +272,7 @@ def _json_text(value) -> str:
 
 def data(id: str, value) -> Html:
     """An inert JSON block, for data the author chooses to embed (nothing is embedded otherwise)."""
-    return Html(f'<script type="application/json" id="{_esc(id)}">{_json_text(value)}</script>')
+    return Html(f'<script type="application/json" id="{_esc(id)}">{_json_text(value)}</script>\n')
 
 
 def save(path, html: str) -> Path:
@@ -435,7 +454,30 @@ def handle_endtag(self, tag):
                 return
 
 
-_LEADING_HEADING = re.compile(r"\s*<h([1-6])\b[^>]*>.*?</h\1\s*>", re.I | re.S)
+# The line break after a kept heading stays with it, so new content starts on its own line.
+_LEADING_HEADING = re.compile(r"\s*<h([1-6])\b[^>]*>.*?</h\1\s*>(?:\r?\n)?", re.I | re.S)
+
+
+_EOL = re.compile(r"\r?\n")
+
+
+def _block_end(text: str, end: int) -> int:
+    """``end`` moved past the line break that ends a block there, if any."""
+    found = _EOL.match(text, end)
+    return found.end() if found else end
+
+
+def _page_eol(text: str) -> str:
+    """The page's line break, taken from its first one.
+
+    Not "any \\r\\n in the page": a value shown as text may carry one.
+    """
+    first = _EOL.search(text)
+    return first.group() if first else "\n"
+
+
+def _with_eol(markup: str, eol: str) -> str:
+    return _EOL.sub(eol, markup) if eol != "\n" else markup
 
 
 def _locate(text: str) -> _Locator:
@@ -463,7 +505,7 @@ def _with_filter_script(text: str) -> str:
         return text
     body_ends = list(re.finditer(r"</body\s*>", text, re.I))
     at = body_ends[-1].start() if body_ends else len(text)
-    return text[:at] + _FILTER_SCRIPT + text[at:]
+    return text[:at] + _with_eol(_FILTER_SCRIPT, _page_eol(text)) + text[at:]
 
 
 def _carries_id(markup: str, id_: str) -> bool:
@@ -483,19 +525,26 @@ def update(path, changes: dict) -> dict:
     is kept unless the new content starts with a heading of its own. Markup
     that itself carries an element with the same id, such as a whole
     ``rt.section(..., id=)`` or ``rt.table(..., id=)``, replaces the element
-    rather than its content, so the id is never duplicated. Each id must match
-    exactly one element. A filter added to a page without the filter script
-    also adds the script. Returns a receipt of the ids changed and the old and
-    new file sizes.
+    rather than its content, so the id is never duplicated; a table's scroll
+    wrapper is replaced along with it. Each id must match exactly one element.
+    A filter added to a page without the filter script also adds the script.
+    Line breaks in new markup follow the page's ("\\n" or "\\r\\n"). Returns a
+    receipt of the ids changed and the old and new file sizes.
     """
     path = Path(path)
     text = _read(path)
+    eol = _page_eol(text)
     locator = _locate(text)
     edits = []
     for id_, content in changes.items():
         if isinstance(content, Html) and _carries_id(content, id_):
             start, end = _one(locator.outer, id_)
             new = str(content)
+            # rt.table brings its own wrapper; replacing only the <table> would nest it in the old one.
+            if new.startswith(_TABLE_WRAP) and text.endswith(_TABLE_WRAP, 0, start) and text.startswith("</div>", end):
+                start, end = start - len(_TABLE_WRAP), end + len("</div>")
+            if new.endswith("\n"):
+                end = _block_end(text, end)  # the new block brings its own line break
         elif isinstance(content, str):
             start, end = _one(locator.spans, id_)
             new = _esc(content)
@@ -505,7 +554,7 @@ def update(path, changes: dict) -> dict:
         else:
             start, end = _one(locator.spans, id_)
             new = _json_text(content)
-        edits.append((start, end, new))
+        edits.append((start, end, _with_eol(new, eol)))
     edits.sort()
     for (s1, e1, _), (s2, _e2, _) in zip(edits, edits[1:]):
         if s2 < e1:
@@ -524,17 +573,22 @@ def insert(path, content, *, before: str | None = None, after: str | None = None
 
     For new parts of an existing page, e.g. a decision summary above the
     detail: ``rt.insert(path, rt.section("Decision summary", rt.para(...)),
-    before="detail-section")``. Every other byte is unchanged, except that a
-    filter added to a page without the filter script also adds the script.
-    Plain text is escaped, as elsewhere. Returns a receipt like ``update``.
+    before="detail-section")``. A block from these helpers inserted after an
+    element goes after the line break that ends it, so it gets a line of its
+    own; other content goes right next to the element. Every other byte is
+    unchanged, except that a filter added to a page without the filter script
+    also adds the script. Plain text is escaped, as elsewhere. Line breaks in
+    new markup follow the page's. Returns a receipt like ``update``.
     """
     if (before is None) == (after is None):
         raise ValueError("give exactly one of before= or after=")
     path = Path(path)
     text = _read(path)
     start, end = _one(_locate(text).outer, before or after)
-    at = start if before is not None else end
-    new = _esc(content)
+    new = _with_eol(_esc(content), _page_eol(text))
+    at = start
+    if after is not None:
+        at = _block_end(text, end) if isinstance(content, Html) and new.endswith("\n") else end
     out = text[:at] + new + text[at:]
     if "data-rt-filter" in new:
         out = _with_filter_script(out)
diff --git a/tests/test_report_tools.py b/tests/test_report_tools.py
index af943a78e..422131bab 100644
--- a/tests/test_report_tools.py
+++ b/tests/test_report_tools.py
@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import json
+import re
 import shutil
 import subprocess
 from html.parser import HTMLParser
@@ -28,6 +29,26 @@ def test_page_is_a_complete_offline_document(tmp_path):
     assert rt.check(out)["title"] == "Weekly review"
 
 
+def test_blocks_and_rows_are_on_their_own_lines_and_text_has_no_line_breaks():
+    page = _page(rt.section("Summary", rt.para("One.", "Two."), rt.bullets(["x", "y"])),
+                 rt.section("Detail", rt.table(COLS, ROWS, caption="Gaps"), rt.bar_chart(["a", "b"], [1, 2], name="n")),
+                 rt.filter_table(COLS, ROWS, key="Region", label="Region", region_name="Items", value="Gap"),
+                 rt.data("state", {"v": 1}), subtitle="Week 41")
+    body = page[page.index("</style>"):].replace(rt._FILTER_SCRIPT, "")
+    # A line break inside text would show as a space.
+    assert not re.search(r"[^>]\n|\n[^<]", body)
+    lines = body.splitlines()
+    for line in ("<p>One.</p>", "<li>y</li>", "<tr><td>C-300</td><td>North</td><td class=num>25</td></tr>",
+                 "</section>", "</main>", '<option value="South">South</option>'):
+        assert line in lines
+    assert sum(line.startswith('<tr data-rt-key="') for line in lines) == len(ROWS)
+    assert sum(line.startswith('<text x="') for line in lines) == 2
+    # Inline neighbours stay together: the filter's label and select, text and a link in a section.
+    assert '</label><select id="items-filter-select">' in body
+    assert '<h2>Sources</h2>\nSee <a href="a.csv">a</a>.</section>\n' in rt.section(
+        "Sources", "See ", rt.link("a.csv", "a"), ".")
+
+
 def test_text_from_data_is_escaped_everywhere(tmp_path):
     evil = '<script>alert(1)</script>"&'
     page = _page(rt.section(evil, rt.para(evil), rt.bullets([evil]), rt.table([evil], [[evil]]),
@@ -162,7 +183,7 @@ def test_update_and_insert_find_elements_after_non_newline_line_breaks(tmp_path,
     out.write_text(original, encoding="utf-8")
     rt.update(out, {"detail": rt.para("new")})
     rt.insert(out, rt.para("note"), after="detail")
-    expected = original.replace("\n<p>old</p>\n", "<p>new</p>").replace("</section>", "</section><p>note</p>")
+    expected = original.replace("<p>old</p>", "<p>new</p>").replace("</section>\n", "</section>\n<p>note</p>\n")
     assert out.read_text(encoding="utf-8") == expected
 
 
@@ -173,17 +194,60 @@ def test_update_and_insert_keep_line_endings(tmp_path):
     out.write_bytes(original)
     receipt = rt.update(out, {"total": "12"})
     rt.insert(out, rt.para("added"), after="note")
-    assert out.read_bytes() == original.replace(b">10<", b">12<").replace(b"x</p>", b"x</p><p>added</p>")
+    assert out.read_bytes() == original.replace(b">10<", b">12<").replace(b"x</p>\r\n", b"x</p>\r\n<p>added</p>\r\n")
     assert receipt["bytes_before"] == len(original)
 
 
+def test_update_and_insert_keep_one_block_per_line(tmp_path):
+    out = rt.save(tmp_path / "r.html", _page(rt.section("Summary", rt.para("Old."), id="summary"),
+                                             rt.section("Detail", rt.para("Rows."), id="detail")))
+    rt.update(out, {"summary": rt.para("New.")})
+    rt.update(out, {"detail": rt.section("Detail", rt.para("More rows."), id="detail")})
+    rt.insert(out, rt.section("Notes", rt.para("A."), id="notes"), after="summary")
+    rt.insert(out, rt.section("Audit", rt.para("B."), id="audit"), before="detail")
+    rebuilt = _page(rt.section("Summary", rt.para("New."), id="summary"),
+                    rt.section("Notes", rt.para("A."), id="notes"),
+                    rt.section("Audit", rt.para("B."), id="audit"),
+                    rt.section("Detail", rt.para("More rows."), id="detail"))
+    assert out.read_text() == rebuilt
+
+
+def test_insert_keeps_inline_content_next_to_its_anchor(tmp_path):
+    out = tmp_path / "legacy.html"
+    original = '<html lang="en"><body>\n<p>See <span id="ref">the table</span>\nbelow.</p>\n</body></html>\n'
+    out.write_text(original)
+    rt.insert(out, rt.inline(" (", rt.link("t.csv", "csv"), ")"), after="ref")
+    rt.insert(out, "[1]\n", after="ref")  # plain text is never a block, even with a trailing line break
+    assert out.read_text() == original.replace("</span>", '</span>[1]\n (<a href="t.csv">csv</a>)')
+
+
+def test_edits_on_a_crlf_page_add_no_bare_line_feeds(tmp_path):
+    out = tmp_path / "crlf.html"
+    built = _page(rt.section("Summary", rt.para("Old."), id="summary"), rt.section("Detail", id="detail"))
+    out.write_bytes(built.replace("\n", "\r\n").encode())
+    rt.update(out, {"summary": rt.section("Summary", rt.para("New."), id="summary"), "detail": rt.para("Rows.")})
+    rt.insert(out, rt.filter_table(COLS, ROWS, key="Region", label="Region", region_name="Items"), after="detail")
+    data = out.read_bytes()
+    assert re.search(rb"(?<!\r)\n", data) is None and b"\r\r" not in data
+    assert data.replace(b"\r\n", b"\n").decode().count(rt._FILTER_SCRIPT) == 1
+    assert b'<section id="summary"><h2>Summary</h2>\r\n<p>New.</p>\r\n</section>\r\n<section id="detail">' in data
+    assert b"<h2>Detail</h2>\r\n<p>Rows.</p>\r\n</section>\r\n<div class=\"filter\"" in data
+
+
+def test_a_crlf_inside_text_does_not_make_new_markup_crlf(tmp_path):
+    out = rt.save(tmp_path / "r.html", _page(rt.section("Notes", rt.para("line 1\r\nline 2"), id="notes")))
+    rt.insert(out, rt.section("More", rt.para("x"), id="more"), after="notes")
+    rt.update(out, {"more": rt.section("More", rt.para("y"), id="more")})
+    assert out.read_bytes().count(b"\r\n") == 1
+
+
 def test_update_keeps_a_section_heading_unless_the_new_content_has_one(tmp_path):
     out = rt.save(tmp_path / "r.html", _page(rt.section("Conclusion", rt.para("Old."), id="conclusion"),
                                              rt.section("Detail", rt.para("Rows."), id="detail")))
     rt.update(out, {"conclusion": rt.para("New."), "detail": rt.inline(rt.Html("<h2>Row detail</h2>"), rt.para("R."))})
     text = out.read_text()
-    assert '<section id="conclusion"><h2>Conclusion</h2><p>New.</p></section>' in text
-    assert '<section id="detail"><h2>Row detail</h2><p>R.</p></section>' in text
+    assert rt.section("Conclusion", rt.para("New."), id="conclusion") in text
+    assert '<section id="detail"><h2>Row detail</h2><p>R.</p>\n</section>' in text
     assert rt.check(out)["text"].count("Conclusion") == 1
 
 
@@ -193,10 +257,14 @@ def test_update_with_a_whole_element_of_the_same_id_replaces_the_element(tmp_pat
     rt.update(out, {"summary-section": rt.section("Summary", rt.para("New.")),
                     "detail": rt.table(COLS, ROWS, id="detail")})
     text = out.read_text()
-    assert '<section id="summary-section"><h2>Summary</h2><p>New.</p></section>' in text
+    assert rt.section("Summary", rt.para("New.")) + '<section id="detail-section">' in text
     assert text.count('id="summary-section"') == 1 and "Old." not in text
     seen = rt.check(out)  # no duplicate ids, no table nested in a table
     assert [t["rows"] for t in seen["tables"]] == [[[str(c) for c in r] for r in ROWS]]
+    # The table's scroll wrapper is replaced too, not nested again on every update.
+    rt.update(out, {"detail": rt.table(COLS, ROWS[1:], id="detail")})
+    assert out.read_text() == _page(rt.section("Summary", rt.para("New.")),
+                                    rt.section("Detail", rt.table(COLS, ROWS[1:], id="detail")))
 
 
 def test_update_refuses_new_content_with_the_id_twice(tmp_path):
@@ -230,7 +298,7 @@ def test_insert_adds_new_parts_to_a_page_not_made_with_these_helpers(tmp_path):
     rt.insert(out, rt.para("Checked."), after="audit")
     assert receipt["inserted"] == "before detail"
     assert out.read_text() == original.replace('<section id="detail">', summary + '<section id="detail">').replace(
-        '<h2>Audit</h2></section>', '<h2>Audit</h2></section><p>Checked.</p>')
+        '<h2>Audit</h2></section>\n', '<h2>Audit</h2></section>\n<p>Checked.</p>\n')
     assert "Cover 30 &lt;units&gt;." in out.read_text()
     assert [s for s in rt.check(out)["text"].split() if s in ("Decision", "Detail", "Audit")] == ["Decision", "Detail", "Audit"]
 
@@ -328,7 +396,7 @@ def table(region):
     text = out.read_text()
     assert text.count(rt._FILTER_SCRIPT) == 1
     assert text.index(rt._FILTER_SCRIPT) > text.index("south-items-filter")  # runs after both filters
-    assert text.endswith(rt._FILTER_SCRIPT + "</body></html>\n")
+    assert text.endswith(rt._FILTER_SCRIPT + "</body>\n</html>\n")
     rt.check(out)
 
     legacy = tmp_path / "legacy.html"