Pre-push review: prism

diff --git a/prism/Services/WebRendering/BlockHTMLEmitter.swift b/prism/Services/WebRendering/BlockHTMLEmitter.swiftindex d0677129..74e86d2f 100644--- a/prism/Services/WebRendering/BlockHTMLEmitter.swift+++ b/prism/Services/WebRendering/BlockHTMLEmitter.swift@@ -586,10 +586,14 @@ nonisolated enum BlockHTMLEmitter {             // its items are not anchorable and propagate nil down their own nested lists.             let sub = subIDPrefix.map { "\($0)-\(index)" }             let subAttr = sub.map { " data-prism-sub=\"\($0)\"" } ?? ""-            html += "<li\(subAttr)>"             if let checkbox = item.checkbox {+                // A task item carries `prism-task`: document.css drops its marker and seats+                // the checkbox in the marker gutter in its place.                 let checked = checkbox == .checked ? " checked" : ""+                html += "<li class=\"prism-task\"\(subAttr)>"                 html += "<input type=\"checkbox\" disabled\(checked) data-prism-chrome>"+            } else {+                html += "<li\(subAttr)>"             }             let itemSpan = itemOffsets.map { InlineSpan.subspan(offset: $0[index]) } ?? .unmapped             html += renderInline(item.content, in: itemSpan, context: context)

diff --git a/prism/Resources/WebRenderer/document.css b/prism/Resources/WebRenderer/document.cssindex c6b1715c..eec89444 100644--- a/prism/Resources/WebRenderer/document.css+++ b/prism/Resources/WebRenderer/document.css@@ -423,9 +423,28 @@ ul, ol { margin: 0 0 var(--prism-spacing); padding-left: 1.6em; }  * line). Each li is a positioning context so its gutter "+" anchors to it. */ li { margin: 0.1em 0; position: relative; } -/* Task list items (Req 1.1). */-li.prism-task { list-style: none; margin-left: -1.4em; }-li.prism-task input[type="checkbox"] { margin-right: 0.4em; }+/* Task list items (Req 1.1): the checkbox replaces the marker. It is pulled back into the+ * marker gutter with its box sized so the item's text starts where a sibling bullet item's+ * text does, and the item itself is not shifted — so the "+" / note-dot gutter column+ * (`--prism-item-gutter` below) needs no task-specific correction at any nesting level. */+li.prism-task { list-style: none; }++li.prism-task > input[type="checkbox"] {+    /* The pull-back is spelled as box + gap rather than as a constant so the derivation is+     * checkable (pinned by DocumentCSSNoteGutterRulesTests): the text then lands at the+     * item's content edge. 1.5em rather than 1em because iOS scales the checkbox to its box+     * and 1em read as small next to the text (macOS draws it at the native control size+     * regardless); the box then overhangs the 1.6em marker gutter by 0.3em, which is still+     * clear of the "+" / note-dot column at every enumerated `--prism-item-gutter` level.+     * (Past those levels the base -1.5em gutter already overlapped the bullet marker, and+     * overlaps the checkbox the same way.) */+    width: 1.5em;+    height: 1.5em;+    margin: 0;+    margin-right: 0.4em;+    margin-left: calc(-1 * (1.5em + 0.4em));+    vertical-align: middle;+}  /* Inline + block code. */ code, kbd, samp {@@ -1085,11 +1104,6 @@ section[data-prism-block-id] > :is(ul, ol) > li > :is(ul, ol) > li > :is(ul, ol)     --prism-item-gutter: -9.775em; } -/* Task-list items carry no bullet and are shifted left 1.4em; centre their chrome on the dot. */-section[data-prism-block-id] > ul > li.prism-task {-    --prism-item-gutter: -1.975em;-}- /* List-item affordance: positioned out of flow so it reads as beside the item and does  * not inflate the line height (which spaced items too far apart). It sits in the SAME  * leading gutter column as the block-level note dot, so a list's "+" and its note

diff --git a/prismTests/WebRendering/BlockHTMLEmitterTests.swift b/prismTests/WebRendering/BlockHTMLEmitterTests.swiftindex ff2e9794..a9f54111 100644--- a/prismTests/WebRendering/BlockHTMLEmitterTests.swift+++ b/prismTests/WebRendering/BlockHTMLEmitterTests.swift@@ -162,6 +162,18 @@ struct BlockHTMLEmitterStructureTests {         #expect(doc.html.contains("checked"))     } +    @Test("Task list item carries the class document.css styles, so its marker is dropped")+    func taskListItemClass() {+        // document.css targets `li.prism-task` to hide the bullet and seat the checkbox in+        // the marker gutter; without the class the item rendered a bullet AND a checkbox,+        // with no space after it.+        let items = [ListItem(content: "todo", checkbox: .unchecked),+                     ListItem(content: "plain", checkbox: nil)]+        let doc = BlockHTMLEmitterTestSupport.emit([.list(ordered: false, start: 1, items: items)])+        #expect(doc.html.contains("<li class=\"prism-task\" data-prism-sub=\"item-0\">"))+        #expect(doc.html.contains("<li data-prism-sub=\"item-1\">"))+    }+     @Test("Nested list emits nested <ul>/<ol> with nested sub-IDs")     func nestedList() {         let nested = ListItem.NestedList(ordered: false, start: 1, items: [ListItem(content: "child", checkbox: nil)])

diff --git a/prismTests/WebRendering/DocumentCSSNoteGutterRulesTests.swift b/prismTests/WebRendering/DocumentCSSNoteGutterRulesTests.swiftindex 0a071a46..6389796b 100644--- a/prismTests/WebRendering/DocumentCSSNoteGutterRulesTests.swift+++ b/prismTests/WebRendering/DocumentCSSNoteGutterRulesTests.swift@@ -400,4 +400,53 @@ struct DocumentCSSNoteGutterRulesTests {             """         )     }++    // MARK: - 4. A task item's checkbox sits in the marker gutter, not on the + column++    /// The checkbox replaces the marker WITHOUT shifting the item: it is pulled back into+    /// the marker gutter by exactly its own box plus its gap, so the text lands at the+    /// item's content edge and lines up with sibling bullet items. That is also why no+    /// task-specific `--prism-item-gutter` override may exist — one used to (`-1.975em`)+    /// for the old shift-the-item approach, and with the item unshifted it would put a+    /// task item's "+" 1.4em off its siblings' column.+    @Test("A task item's checkbox box plus gap is the gutter it is pulled back by")+    func taskCheckboxIsPulledBackByItsOwnBox() throws {+        let css = Self.flattened(try Self.loadDocumentCSS())+        let rules = Self.rules(in: css)+        let columns = try Self.columns(in: css)++        let checkbox = try #require(+            rules.first { $0.selector == "li.prism-task > input[type=\"checkbox\"]" },+            "document.css must keep the task checkbox rule"+        )+        let width = try #require(Self.em(Self.value(of: "width", in: checkbox.body)))+        let gap = try #require(Self.em(Self.value(of: "margin-right", in: checkbox.body)))+        let pullBack = Self.ems(Self.value(of: "margin-left", in: checkbox.body))++        // The pull-back is spelled `calc(-1 * (box + gap))`, restating the box and the gap+        // it must equal, so the sheet carries the derivation rather than a constant.+        #expect(+            pullBack == [width, gap],+            """+            margin-left must restate the box (\(width)em) and the gap (\(gap)em) it pulls the \+            checkbox back by, or a task item's text no longer starts where its siblings' does. \+            Declared terms: \(pullBack)+            """+        )+        let leadingEdge = -(width + gap)+        #expect(+            leadingEdge >= columns.topLevelItemGutter + columns.chipWidth,+            """+            the checkbox's leading edge (\(leadingEdge)em) overlaps the "+" chip, which ends at \+            \(columns.topLevelItemGutter + columns.chipWidth)em+            """+        )+        let taskOverrides = rules.filter {+            $0.selector.contains("prism-task") && Self.value(of: Self.token, in: $0.body) != nil+        }+        #expect(+            taskOverrides.isEmpty,+            "a task item shares its siblings' gutter column; found override: \(taskOverrides.map(\.selector))"+        )+    } }

diff --git a/CHANGELOG.md b/CHANGELOG.mdindex b8c80bbb..0caefefb 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -25,6 +25,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0  ### Fixed +- Task list items render the way they did before the WebKit rendering cutover: the checkbox replaces the list marker, with a space before the text (T-1542 regression). `document.css` has carried rules for a `prism-task` item class since the cutover, but `BlockHTMLEmitter` never put that class on the `<li>`, so every task item drew its bullet or number AND the checkbox, with the text jammed against the box. The class is now emitted, and the stylesheet seats the checkbox in the marker gutter rather than shifting the whole item left, so a task item's text lines up with its sibling bullet items at every nesting level and in ordered lists, and the item's add-note "+" and note-indicator column needs no task-specific offset.+ - A document's YAML frontmatter is shown again as a collapsed "Metadata" card at the top of the document, expandable in place to reveal the raw YAML. The WebKit rendering cutover (T-1542) dropped this: the parser still produced the frontmatter block, but the emitter wrote it out as an inert hidden section, so a document that opened with `---` metadata simply started at its first heading with no way to see what the frontmatter said. The card is a native `<details>` disclosure — no script of its own — whose title comes from the localisation catalog, whose body is the YAML as escaped monospaced text, and whose open state is recorded natively like every other disclosure, so it survives a WebContent recovery. Because the block now lays out, the native raw-to-rendered position picker no longer has to skip it to agree with the page about which sections exist, and the pre-cutover SwiftUI `MetadataView` that nothing had rendered since the cutover is removed.  - A note anchored to a table's header row now draws its own indicator dot on the header row, instead of none at all (T-2044). T-1725 had removed the header row's indicator deliberately rather than leave it wrong: with no ordinal to address it by, a header-row note used to fold into the table's block-level dot, which opens a popover scoped to the block and so could never contain the header row's own note — and once that dot started announcing its count out loud, it was announcing a note the tap could not show. The header row now gets an indicator of its own, addressed by `subID: "row-header"` — the same channel T-1745 opened for list items — rather than a second one; `WebDocumentMessageRouter` resolves that exact string back to the header row's anchor, and `prism-notes.js` places the dot inside the header row's own cell, since a `<tr>` may only contain `<td>`/`<th>` and the list-item placement path it reuses cannot be used verbatim. Header-row notes were always visible through the inline note bubble and the notes panel; only the row's own indicator dot was missing. This is the READING half only: a header row still cannot be given a note by long-press or right-click (that gesture falls back to a note on the whole table), so a header-row note continues to arrive by import or through the text-selection path. That is T-2318.