From f2e974cfaa1c1a82ca6b8abdad78030604b96e4e Mon Sep 17 00:00:00 2001
From: Max Stepanov <stpmax@yandex.ru>
Date: Fri, 9 Oct 2026 13:01:50 +0100
Subject: [PATCH 1/3] feat(report_tools): put blocks and table rows on their
 own lines (ENG-3358)

Pages built with report_tools were one long line after </style>, so
line-based tools (read_text_file ranges, html_lint line numbers, diffs)
could not address a single section. Block helpers now end their markup
with a line break, one table row, list item, chart bar and option per
line. Line breaks go only where the browser shows no whitespace;
rendering is pixel-identical.

update and insert keep that layout: a kept section heading keeps its
line break, a whole-element replacement does not double the break, and
insert(after=) puts a block after the element's line break. New markup
uses the page's line endings.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 anton/core/artifacts/report_tools.py | 99 +++++++++++++++++++---------
 tests/test_report_tools.py           | 56 ++++++++++++++--
 2 files changed, 117 insertions(+), 38 deletions(-)

diff --git a/anton/core/artifacts/report_tools.py b/anton/core/artifacts/report_tools.py
index e84651b5a..ba923da9f 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,16 @@ 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))
+
+
+def _table_wrap(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'<div class="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 +166,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_wrap(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 +191,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 +228,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_wrap(columns, numeric, trs) + "</div>\n</div>\n"
     )
 
 
@@ -253,7 +269,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 +451,20 @@ 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)
+
+
+def _newline_at(text: str, at: int) -> str:
+    """The line break that starts at ``at``, or ""."""
+    if text.startswith("\r\n", at):
+        return "\r\n"
+    return "\n" if text.startswith("\n", at) else ""
+
+
+def _in_page_line_endings(markup: str, page: str) -> str:
+    """``markup`` with "\\r\\n" line breaks when the page uses them."""
+    return re.sub(r"\r?\n", "\r\n", markup) if "\r\n" in page else markup
 
 
 def _locate(text: str) -> _Locator:
@@ -463,7 +492,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] + _in_page_line_endings(_FILTER_SCRIPT, text) + text[at:]
 
 
 def _carries_id(markup: str, id_: str) -> bool:
@@ -495,10 +524,14 @@ def update(path, changes: dict) -> dict:
     for id_, content in changes.items():
         if isinstance(content, Html) and _carries_id(content, id_):
             start, end = _one(locator.outer, id_)
-            new = str(content)
+            new = _in_page_line_endings(str(content), text)
+            # The page already breaks the line after the element.
+            eol = _newline_at(text, end)
+            if eol and new.endswith(eol):
+                new = new[:-len(eol)]
         elif isinstance(content, str):
             start, end = _one(locator.spans, id_)
-            new = _esc(content)
+            new = _in_page_line_endings(_esc(content), text)
             heading = _LEADING_HEADING.match(text, start, end)
             if heading and not re.match(r"\s*<h[1-6]\b", new, re.I):
                 new = heading.group(0) + new
@@ -533,8 +566,12 @@ def insert(path, content, *, before: str | None = None, after: str | None = None
     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 = _in_page_line_endings(_esc(content), text)
+    at = start
+    if after is not None:
+        # A block goes after the line break that ends the element, so it gets a
+        # line of its own; inline content stays right next to the element.
+        at = end + (len(_newline_at(text, end)) if new.endswith("\n") else 0)
     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..35be9858f 100644
--- a/tests/test_report_tools.py
+++ b/tests/test_report_tools.py
@@ -28,6 +28,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 all(body[i - 1] == ">" and body[i + 1:i + 2] in ("<", "") for i, c in enumerate(body) if c == "\n")
+    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 +182,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 +193,39 @@ 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")
+    assert out.read_text() == original.replace("</span>", '</span> (<a href="t.csv">csv</a>)')
+
+
 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,7 +235,7 @@ 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]]
@@ -230,7 +272,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 +370,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"

From 0f7763f1df4dd01aebcf528832e18ddbd270f5db Mon Sep 17 00:00:00 2001
From: Max Stepanov <stpmax@yandex.ru>
Date: Fri, 9 Oct 2026 13:24:10 +0100
Subject: [PATCH 2/3] fix(report_tools): page line endings, plain-text inserts
 and table re-updates (ENG-3358)

- Take the page's line break from its first one: a "\r\n" inside a shown
  value no longer turns all new markup into CRLF on an LF page. Computed
  once per update.
- insert(after=) moves past the element's line break only for Html blocks;
  plain text always stays next to the element.
- update with rt.table(..., id=) replaces the table's scroll wrapper too,
  instead of nesting a new wrapper on every update.
- Docstrings describe the placement and line-ending rules; tests cover
  CRLF pages, mixed pages, plain-text inserts and repeated table updates.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 anton/core/artifacts/report_tools.py | 63 ++++++++++++++++++----------
 tests/test_report_tools.py           | 28 ++++++++++++-
 2 files changed, 67 insertions(+), 24 deletions(-)

diff --git a/anton/core/artifacts/report_tools.py b/anton/core/artifacts/report_tools.py
index ba923da9f..d319cad27 100644
--- a/anton/core/artifacts/report_tools.py
+++ b/anton/core/artifacts/report_tools.py
@@ -152,11 +152,14 @@ 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_wrap(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'<div class="table-wrap"><table{table_attrs}>{caption}\n{head}\n<tbody>\n'
+    return (f"{_TABLE_WRAP}<table{table_attrs}>{caption}\n{head}\n<tbody>\n"
             + "".join(tr + "\n" for tr in trs) + "</tbody></table></div>\n")
 
 
@@ -462,9 +465,17 @@ def _newline_at(text: str, at: int) -> str:
     return "\n" if text.startswith("\n", at) else ""
 
 
-def _in_page_line_endings(markup: str, page: str) -> str:
-    """``markup`` with "\\r\\n" line breaks when the page uses them."""
-    return re.sub(r"\r?\n", "\r\n", markup) if "\r\n" in page else markup
+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 = re.search(r"\r?\n", text)
+    return first.group() if first else "\n"
+
+
+def _with_eol(markup: str, eol: str) -> str:
+    return re.sub(r"\r?\n", eol, markup) if eol != "\n" else markup
 
 
 def _locate(text: str) -> _Locator:
@@ -492,7 +503,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] + _in_page_line_endings(_FILTER_SCRIPT, text) + text[at:]
+    return text[:at] + _with_eol(_FILTER_SCRIPT, _page_eol(text)) + text[at:]
 
 
 def _carries_id(markup: str, id_: str) -> bool:
@@ -512,26 +523,31 @@ 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 = _in_page_line_endings(str(content), text)
+            new = _with_eol(str(content), eol)
+            # 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>")
             # The page already breaks the line after the element.
-            eol = _newline_at(text, end)
-            if eol and new.endswith(eol):
-                new = new[:-len(eol)]
+            after = _newline_at(text, end)
+            if after and new.endswith(after):
+                new = new[:-len(after)]
         elif isinstance(content, str):
             start, end = _one(locator.spans, id_)
-            new = _in_page_line_endings(_esc(content), text)
+            new = _with_eol(_esc(content), eol)
             heading = _LEADING_HEADING.match(text, start, end)
             if heading and not re.match(r"\s*<h[1-6]\b", new, re.I):
                 new = heading.group(0) + new
@@ -557,21 +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)
-    new = _in_page_line_endings(_esc(content), text)
-    at = start
-    if after is not None:
-        # A block goes after the line break that ends the element, so it gets a
-        # line of its own; inline content stays right next to the element.
-        at = end + (len(_newline_at(text, end)) if new.endswith("\n") else 0)
+    new = _with_eol(_esc(content), _page_eol(text))
+    at = start if before is not None else end
+    if after is not None and isinstance(content, Html) and new.endswith("\n"):
+        at += len(_newline_at(text, 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 35be9858f..010447ad9 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
@@ -216,7 +217,28 @@ def test_insert_keeps_inline_content_next_to_its_anchor(tmp_path):
     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")
-    assert out.read_text() == original.replace("</span>", '</span> (<a href="t.csv">csv</a>)')
+    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):
@@ -239,6 +261,10 @@ def test_update_with_a_whole_element_of_the_same_id_replaces_the_element(tmp_pat
     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):

From d0b88fc5f4a5f70901bf9dd8816102cdb2316b10 Mon Sep 17 00:00:00 2001
From: Max Stepanov <stpmax@yandex.ru>
Date: Fri, 9 Oct 2026 13:28:36 +0100
Subject: [PATCH 3/3] refactor(report_tools): one line-break rule for update
 and insert (ENG-3358)

- One _EOL pattern for page line-ending detection and conversion.
- update (whole element) and insert(after=) both extend the span over the
  line break that ends a block (_block_end) instead of trimming new markup
  in one place and moving the insert point in another.
- update converts new markup to the page's line ending once per edit.
- Rename _table_wrap to _table_html so it does not read like _TABLE_WRAP.
- Simpler layout assertion in the tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 anton/core/artifacts/report_tools.py | 40 ++++++++++++++--------------
 tests/test_report_tools.py           |  2 +-
 2 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/anton/core/artifacts/report_tools.py b/anton/core/artifacts/report_tools.py
index d319cad27..a882a9a12 100644
--- a/anton/core/artifacts/report_tools.py
+++ b/anton/core/artifacts/report_tools.py
@@ -155,7 +155,7 @@ def _tds(cells, numeric) -> str:
 _TABLE_WRAP = '<div class="table-wrap">'
 
 
-def _table_wrap(columns, numeric, trs, *, table_attrs: str = "", caption: str = "") -> str:
+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>"
@@ -170,7 +170,7 @@ def table(columns, rows, *, caption: str | None = None, id: str | None = None) -
     numeric = _numeric_columns(body, len(columns))
     cap = f"<caption>{_esc(caption)}</caption>" if caption else ""
     trs = [f"<tr>{_tds(r, numeric)}</tr>" for r in body]
-    return Html(_table_wrap(columns, numeric, trs, table_attrs=_attr_id(id), caption=cap))
+    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,
@@ -244,7 +244,7 @@ def filter_table(columns, rows, *, key: str, label: str, region_name: str, value
         + "".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_wrap(columns, numeric, trs) + "</div>\n</div>\n"
+        + _table_html(columns, numeric, trs) + "</div>\n</div>\n"
     )
 
 
@@ -458,11 +458,13 @@ def handle_endtag(self, tag):
 _LEADING_HEADING = re.compile(r"\s*<h([1-6])\b[^>]*>.*?</h\1\s*>(?:\r?\n)?", re.I | re.S)
 
 
-def _newline_at(text: str, at: int) -> str:
-    """The line break that starts at ``at``, or ""."""
-    if text.startswith("\r\n", at):
-        return "\r\n"
-    return "\n" if text.startswith("\n", at) else ""
+_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:
@@ -470,12 +472,12 @@ def _page_eol(text: str) -> str:
 
     Not "any \\r\\n in the page": a value shown as text may carry one.
     """
-    first = re.search(r"\r?\n", text)
+    first = _EOL.search(text)
     return first.group() if first else "\n"
 
 
 def _with_eol(markup: str, eol: str) -> str:
-    return re.sub(r"\r?\n", eol, markup) if eol != "\n" else markup
+    return _EOL.sub(eol, markup) if eol != "\n" else markup
 
 
 def _locate(text: str) -> _Locator:
@@ -537,24 +539,22 @@ def update(path, changes: dict) -> dict:
     for id_, content in changes.items():
         if isinstance(content, Html) and _carries_id(content, id_):
             start, end = _one(locator.outer, id_)
-            new = _with_eol(str(content), eol)
+            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>")
-            # The page already breaks the line after the element.
-            after = _newline_at(text, end)
-            if after and new.endswith(after):
-                new = new[:-len(after)]
+            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 = _with_eol(_esc(content), eol)
+            new = _esc(content)
             heading = _LEADING_HEADING.match(text, start, end)
             if heading and not re.match(r"\s*<h[1-6]\b", new, re.I):
                 new = heading.group(0) + new
         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:
@@ -586,9 +586,9 @@ def insert(path, content, *, before: str | None = None, after: str | None = None
     text = _read(path)
     start, end = _one(_locate(text).outer, before or after)
     new = _with_eol(_esc(content), _page_eol(text))
-    at = start if before is not None else end
-    if after is not None and isinstance(content, Html) and new.endswith("\n"):
-        at += len(_newline_at(text, end))
+    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 010447ad9..422131bab 100644
--- a/tests/test_report_tools.py
+++ b/tests/test_report_tools.py
@@ -36,7 +36,7 @@ def test_blocks_and_rows_are_on_their_own_lines_and_text_has_no_line_breaks():
                  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 all(body[i - 1] == ">" and body[i + 1:i + 2] in ("<", "") for i, c in enumerate(body) if c == "\n")
+    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>'):