Pre-push review: T-1877/bugfix-single-line-html-footnotes

diff --git a/prism/Services/FootnotePreprocessor.swift b/prism/Services/FootnotePreprocessor.swiftindex 8117de7..2c50e60 100644--- a/prism/Services/FootnotePreprocessor.swift+++ b/prism/Services/FootnotePreprocessor.swift@@ -409,24 +409,164 @@ enum FootnotePreprocessor: Sendable {     nonisolated private static let blockTags = ["div", "details", "section", "article", "aside", "nav",                                                 "header", "footer", "table", "pre", "blockquote"] +    /// Returns the block-level tag that this line leaves open, or `nil` when the line+    /// opens no HTML block at all.+    ///+    /// The line is scanned once, left to right, tracking opening and closing block tags so+    /// a block opened and closed on the same line (`<div>Text</div>`) does not put the+    /// parser into `.inHTMLBlock` state and swallow the footnote definitions that follow+    /// (T-1877). Self-closing tags (`<div/>`) never open a block, and closing tags with+    /// no matching opening on the line are ignored. When several tags remain unclosed the+    /// first one (in line order) wins, since that is the block the following lines sit in.+    ///+    /// Recognised tags are consumed whole by `scanTagRemainder`, so a block tag name that+    /// only appears inside a quoted attribute value (`<table title="<div>">Content</table>`)+    /// is not mistaken for real markup and left spuriously open.+    ///+    /// Known gap, deliberately out of scope here: HTML comments get no special treatment, so+    /// a block tag name that only appears inside one (`<!-- comment with <div> -->`) is still+    /// read as real markup and leaves a block spuriously open — swallowing every following+    /// footnote definition, the same user-visible failure as T-1877 itself. `swift-markdown`+    /// disagrees: it parses that line as a CommonMark **type-2** comment block, which ends at+    /// the `-->` rather than at a blank line, so the next line is an ordinary paragraph.+    /// Closing this needs real comment-span recognition (`<!--` … `-->`, possibly across+    /// lines) rather than a patch to the tag scan, so it is tracked in T-1963 alongside the+    /// blank-line termination divergence — both are the same root cause: this preprocessor+    /// keeps its own notion of HTML-block extent, which can disagree with the real parser.+    ///+    /// Balancing costs O(tags) rather than O(tags²): each open reserves a slot in+    /// `openSlots` and records that slot under its name, and each close pops its own name's+    /// most recent slot, so a close with no matching open costs nothing instead of scanning+    /// the whole open stack (the shape T-1655 fixed in the raw-HTML image scan).     nonisolated private static func detectHTMLBlockOpening(_ line: String) -> String? {         let trimmed = line.trimmingCharacters(in: .whitespaces)         guard trimmed.hasPrefix("<") else { return nil } -        for tag in blockTags {-            guard let range = trimmed.range(of: "<\(tag)", options: .caseInsensitive) else {+        // Open tags in line order; a slot is cleared when its closing tag is seen.+        var openSlots: [String?] = []+        var slotsByTag: [String: [Int]] = [:]+        var index = trimmed.startIndex++        while index < trimmed.endIndex {+            guard trimmed[index] == "<" else {+                index = trimmed.index(after: index)                 continue             }-            // Ensure tag name ends at a boundary (>, space, tab, /, or end of string)-            let afterTag = trimmed[range.upperBound...]-            if afterTag.isEmpty || ">/ \t".contains(afterTag.first!) {-                return tag++            var nameStart = trimmed.index(after: index)+            let isClosing = nameStart < trimmed.endIndex && trimmed[nameStart] == "/"+            if isClosing {+                nameStart = trimmed.index(after: nameStart)+            }++            // A `<` not followed by a tag name is literal text (`3 < 4`), not markup.+            guard nameStart < trimmed.endIndex, trimmed[nameStart].isLetter else {+                index = trimmed.index(after: index)+                continue+            }++            let tag = matchBlockTag(in: trimmed, at: nameStart)+            let scan = scanTagRemainder(in: trimmed, from: nameStart)+            index = scan.end++            guard let tag else { continue }++            if isClosing {+                if let slot = slotsByTag[tag]?.popLast() {+                    openSlots[slot] = nil+                }+            } else if !scan.isSelfClosing {+                slotsByTag[tag, default: []].append(openSlots.count)+                openSlots.append(tag)             }         } +        for slot in openSlots {+            if let slot { return slot }+        }         return nil     } +    /// Consumes the HTML tag whose name starts at `index` (just past its `<` or `</`), and+    /// reports where the tag ends plus whether it was self-closing (`<div/>`).+    ///+    /// A quoted attribute value is skipped as a unit, so a `<` or `>` inside `title="<div>"`+    /// is never read as markup. An unterminated quote consumes the rest of the line, leaving+    /// the tag open — the same treatment an unterminated tag already gets. A `<` found+    /// outside a value ends the scan at that point rather than swallowing it, so a stray `<`+    /// in the text (`<div>a <b</div>`) cannot hide the closing tag that follows it.+    ///+    /// Quote handling follows the HTML5 tokenizer rather than inventing escapes, because HTML+    /// attribute values have none: a quote only opens a value in the *before attribute value*+    /// state — immediately after an `=`, whitespace allowed — and a double-quoted value then+    /// ends at the very next `"` with no escape processing (likewise `'`). So `title="\""` is+    /// the value `\` followed by a bogus attribute named `"`, and the tag still ends at its+    /// `>`. Treating every quote as a delimiter instead made any odd number of literal quotes+    /// of the matching type inside a value — a deliberate `\"`, or just a careless straight+    /// quote in `title="a"b"` — re-open a value that then ran past the real `>` and closing+    /// tag, reviving T-1877's swallow-every-following-footnote symptom (T-1877 review).+    ///+    /// Each character is visited at most once and the returned index is always past `index`,+    /// so the caller's loop makes progress and stays linear in line length.+    nonisolated private static func scanTagRemainder(+        in line: String,+        from index: String.Index+    ) -> (end: String.Index, isSelfClosing: Bool) {+        var cursor = index+        var lastNonSpace: Character?+        // True in the HTML5 "before attribute value" state: an `=` has been seen and only+        // whitespace since, so the next quote opens a quoted value.+        var expectingValue = false++        while cursor < line.endIndex {+            let character = line[cursor]++            if expectingValue, character == "\"" || character == "'" {+                cursor = line.index(after: cursor)+                while cursor < line.endIndex, line[cursor] != character {+                    cursor = line.index(after: cursor)+                }+                guard cursor < line.endIndex else { return (line.endIndex, false) }+                lastNonSpace = character+                expectingValue = false+                cursor = line.index(after: cursor)+                continue+            }++            if character == ">" {+                return (line.index(after: cursor), lastNonSpace == "/")+            }++            if character == "<" {+                return (cursor, false)+            }++            if !character.isWhitespace {+                lastNonSpace = character+                expectingValue = character == "="+            }+            cursor = line.index(after: cursor)+        }++        return (line.endIndex, false)+    }++    /// Matches a known block tag name starting at `index`, requiring a tag-name boundary+    /// (`>`, `/`, whitespace, or end of line) immediately after it.+    nonisolated private static func matchBlockTag(+        in line: String,+        at index: String.Index+    ) -> String? {+        guard index < line.endIndex else { return nil }+        let remainder = line[index...]++        let name = remainder.prefix(while: { $0.isLetter || $0.isNumber }).lowercased()+        guard blockTags.contains(name) else { return nil }++        guard let boundary = remainder.dropFirst(name.count).first else { return name }+        return ">/ \t".contains(boundary) ? name : nil+    }+     nonisolated private static func detectHTMLBlockClosing(_ line: String, tag: String) -> Bool {         line.range(of: "</\(tag)>", options: .caseInsensitive) != nil     }

diff --git a/prismTests/FootnotePreprocessorTests.swift b/prismTests/FootnotePreprocessorTests.swiftindex 6e2ebd9..3333eb2 100644--- a/prismTests/FootnotePreprocessorTests.swift+++ b/prismTests/FootnotePreprocessorTests.swift@@ -164,6 +164,321 @@ struct FootnotePreprocessorTests {         #expect(result.footnoteData.definition(for: "inside") == nil)     } +    // MARK: - Single-Line HTML Blocks (T-1877)++    @Test("One-line div block does not suppress following footnotes")+    func testOneLineDivDoesNotSuppressFootnotes() {+        let source = """+        <div>Text</div>++        Ordinary content Text[^1].++        [^1]: Note.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "1")?.content == "Note.")+        #expect(!result.cleanedSource.contains("[^1]: Note."))+        #expect(result.cleanedSource.contains("<div>Text</div>"))+    }++    @Test("One-line details block does not suppress following footnotes")+    func testOneLineDetailsDoesNotSuppressFootnotes() {+        let source = """+        <details><summary>More</summary>Text</details>++        Ordinary content Text[^1].++        [^1]: Note.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "1")?.content == "Note.")+        #expect(result.cleanedSource.contains("<details><summary>More</summary>Text</details>"))+    }++    @Test("Nested tags closed on the same line do not suppress following footnotes")+    func testNestedSameLineTagsDoNotSuppressFootnotes() {+        let source = """+        <div><span>x</span></div>++        Text[^n].++        [^n]: Nested note.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "n")?.content == "Nested note.")+    }++    @Test("Nested same-name tags closed on the same line do not suppress following footnotes")+    func testNestedSameNameTagsDoNotSuppressFootnotes() {+        let source = """+        <div><div>x</div></div>++        Text[^n].++        [^n]: Nested note.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "n")?.content == "Nested note.")+    }++    // The two fixtures below keep the definition line directly after the opening line,+    // with no blank line in between, so the raw-HTML block genuinely still covers it: a+    // CommonMark type-6 block runs from its opening line to the first blank line, and+    // `swift-markdown` parses these inputs with the `[^inside]` line inside the `HTMLBlock`.+    // Separating them with a blank line would instead pin a divergence — the preprocessor's+    // `.inHTMLBlock` continuation runs past blank lines while the real parser stops at them,+    // so it would keep suppressing a definition `swift-markdown` reads as a plain paragraph.+    // That divergence is pre-existing, out of scope for T-1877, and tracked in T-1963.+    // Each fixture also references `[^inside]` from outside the block, so a definition that+    // was wrongly extracted would survive orphan filtering and fail the assertions.++    @Test("Unclosed tag after a same-line closed tag still opens an HTML block")+    func testUnclosedTagAfterClosedTagOpensBlock() {+        let source = """+        Intro[^out] and a dangling ref[^inside].++        <div>x</div><section>+        [^inside]: Inside the still-open section.+        </section>++        [^out]: Outside.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "out")?.content == "Outside.")+        #expect(result.footnoteData.definition(for: "inside") == nil)+        #expect(result.cleanedSource.contains("[^inside]: Inside the still-open section."))+    }++    @Test("Unbalanced closing tag on the same line leaves the block open")+    func testMismatchedTagsLeaveBlockOpen() {+        let source = """+        Intro[^out] and a dangling ref[^inside].++        <div>Text</section>+        [^inside]: Still inside the unclosed div.+        </div>++        [^out]: Outside.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "out")?.content == "Outside.")+        #expect(result.footnoteData.definition(for: "inside") == nil)+        #expect(result.cleanedSource.contains("[^inside]: Still inside the unclosed div."))+    }++    @Test("Self-closing block tag does not open an HTML block")+    func testSelfClosingBlockTagDoesNotOpenBlock() {+        let source = """+        <div/>++        Text[^s].++        [^s]: Self-closed.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "s")?.content == "Self-closed.")+    }++    @Test("Void HTML elements do not suppress following footnotes")+    func testVoidElementsDoNotSuppressFootnotes() {+        let source = """+        <hr/>++        <br>++        Text[^v].++        [^v]: Void note.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "v")?.content == "Void note.")+    }++    @Test("One-line HTML block after a definition does not suppress later definitions")+    func testOneLineBlockWhileReprocessingDefinitionLine() {+        let source = """+        Text[^a] and more[^b].++        [^a]: Definition A.+        <div>Inline block</div>+        [^b]: Definition B.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "a")?.content == "Definition A.")+        #expect(result.footnoteData.definition(for: "b")?.content == "Definition B.")+        #expect(result.cleanedSource.contains("<div>Inline block</div>"))+    }++    // MARK: - Block Tag Names Inside Attribute Values (T-1877 review)++    @Test("Block tag name inside a double-quoted attribute value does not open a block")+    func testBlockTagInDoubleQuotedAttributeDoesNotOpenBlock() {+        // `swift-markdown` parses this line as one self-contained HTMLBlock followed by+        // ordinary paragraphs, so nothing after it may be suppressed.+        let source = """+        <table title="<div>">Content</table>++        Ordinary content Text[^q].++        [^q]: Quoted attribute note.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "q")?.content == "Quoted attribute note.")+        #expect(!result.cleanedSource.contains("[^q]: Quoted attribute note."))+        #expect(result.cleanedSource.contains("<table title=\"<div>\">Content</table>"))+    }++    @Test("Block tag name inside a single-quoted attribute value does not open a block")+    func testBlockTagInSingleQuotedAttributeDoesNotOpenBlock() {+        let source = """+        <div title='<section>'>Text</div>++        Ordinary content Text[^q].++        [^q]: Single-quoted attribute note.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "q")?.content == "Single-quoted attribute note.")+        #expect(result.cleanedSource.contains("<div title='<section>'>Text</div>"))+    }++    @Test("Unterminated attribute quote leaves the block open")+    func testUnterminatedAttributeQuoteLeavesBlockOpen() {+        // With the quote never closed the tag never terminates, so the div stays open --+        // and a type-6 block opens on `<div` regardless, which is what `swift-markdown`+        // does here too (the `[^inside]` line lands inside its HTMLBlock).+        let source = """+        Intro[^out] and a dangling ref[^inside].++        <div title="oops>+        [^inside]: Inside the block.+        </div>++        [^out]: Outside.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "out")?.content == "Outside.")+        #expect(result.footnoteData.definition(for: "inside") == nil)+        #expect(result.cleanedSource.contains("[^inside]: Inside the block."))+    }++    // Each of the four tests below puts the reference *before* the HTML line and the+    // definition on the line directly after it, so a wrongly-opened block swallows the+    // definition while the reference survives orphan filtering and the assertion fails.++    @Test("A literal quote after a closed attribute value does not extend the value")+    func testLiteralQuoteAfterAttributeValueDoesNotSwallowTag() {+        // HTML has no escaping inside attribute values: per the HTML5 tokenizer a+        // double-quoted value ends at the very next `"`, with no escape processing. So+        // `title="\""` is the value `\` followed by a bogus attribute named `"`, and the tag+        // still ends at the `>` -- leaving the line balanced (verified against both the+        // HTML5 tokenizer and `swift-markdown`). Reading that trailing `"` as a *fresh*+        // value delimiter consumed the rest of the line, including the real `</div>`, and+        // reopened T-1877's swallow-every-following-footnote symptom through the+        // attribute-value path.+        let source = """+        Intro[^q] first.++        <div title="\\"">Content</div>+        [^q]: Odd double quote note.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "q")?.content == "Odd double quote note.")+        #expect(!result.cleanedSource.contains("[^q]: Odd double quote note."))+        #expect(result.cleanedSource.contains("<div title=\"\\\"\">Content</div>"))+    }++    @Test("A literal quote after a closed single-quoted attribute value does not extend it")+    func testLiteralSingleQuoteAfterAttributeValueDoesNotSwallowTag() {+        let source = """+        Intro[^q] first.++        <div title='\\''>Content</div>+        [^q]: Odd single quote note.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "q")?.content == "Odd single quote note.")+        #expect(!result.cleanedSource.contains("[^q]: Odd single quote note."))+        #expect(result.cleanedSource.contains("<div title='\\''>Content</div>"))+    }++    @Test("A stray quote in an attribute value does not swallow the closing tag")+    func testStrayQuoteInAttributeValueDoesNotSwallowClosingTag() {+        // The same shape with no pretence of escaping -- a careless straight quote is enough.+        // HTML5 reads `title="a"b"` as value `a` plus a bogus attribute named `b"`.+        let source = """+        Intro[^q] first.++        <div title="a"b">Content</div>+        [^q]: Stray quote note.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "q")?.content == "Stray quote note.")+        #expect(!result.cleanedSource.contains("[^q]: Stray quote note."))+    }++    @Test("Whitespace around the attribute equals still delimits the quoted value")+    func testSpacedEqualsStillSkipsQuotedAttributeValue() {+        // The HTML5 before-attribute-value state skips whitespace after `=`, so the quote+        // still opens a value here and the embedded `<div>` stays inert.+        let source = """+        Intro[^q] first.++        <table title = "<div>">Content</table>+        [^q]: Spaced equals note.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "q")?.content == "Spaced equals note.")+        #expect(!result.cleanedSource.contains("[^q]: Spaced equals note."))+    }++    @Test("A stray less-than in text does not hide the closing tag after it")+    func testStrayLessThanDoesNotHideClosingTag() {+        let source = """+        <div>a <b</div>++        Ordinary content Text[^s].++        [^s]: Stray marker note.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definition(for: "s")?.content == "Stray marker note.")+    }++    @Test("Definition text inside a one-line HTML block is not extracted")+    func testDefinitionInsideOneLineBlockIsNotExtracted() {+        let source = """+        Text[^real].++        <div>[^fake]: Not a definition.</div>++        [^real]: Real definition.+        """+        let result = FootnotePreprocessor.process(source)++        #expect(result.footnoteData.definitions.count == 1)+        #expect(result.footnoteData.definition(for: "real") != nil)+        #expect(result.footnoteData.definition(for: "fake") == nil)+        #expect(result.cleanedSource.contains("<div>[^fake]: Not a definition.</div>"))+    }+     // MARK: - Reference Ordering      @Test("First appearance determines display number")

diff --git a/prismTests/FootnotePreprocessorPerformanceTests.swift b/prismTests/FootnotePreprocessorPerformanceTests.swiftindex 14c8652..beaf161 100644--- a/prismTests/FootnotePreprocessorPerformanceTests.swift+++ b/prismTests/FootnotePreprocessorPerformanceTests.swift@@ -146,6 +146,82 @@ struct FootnotePreprocessorPerformanceTests {         }     } +    // MARK: - Same-Line HTML Tag Balancing Growth (T-1877 review)++    /// Builds a document whose single raw-HTML line holds `pairs` opening `<div>` tags+    /// followed by `pairs` closing `</section>` tags.+    ///+    /// This is the worst case for same-line tag balancing: every close names a tag that+    /// was never opened, so a search of the open-tag stack cannot short-circuit. The+    /// balancing used to remove the last matching entry by scanning that stack, which made+    /// the line quadratic in tag count and was reachable from any opened document,+    /// including a remote one via Open URL.+    /// The reference and its definition sit *ahead* of the stress line on purpose: the+    /// line's unmatched closes leave a block open by design, so a definition placed after+    /// it would correctly be left alone and the correctness check below would not hold.+    private func htmlTagStressDocument(pairs: Int) -> String {+        let line = String(repeating: "<div>", count: pairs)+            + String(repeating: "</section>", count: pairs)+        return "Text[^p].\n\n[^p]: Note.\n\n" + line + "\n"+    }++    private func fastestElapsed(runs: Int, of body: () -> Void) -> Duration {+        (0..<runs).map { _ in+            let start = ContinuousClock.now+            body()+            return ContinuousClock.now - start+        }.min()!+    }++    private func milliseconds(_ duration: Duration) -> Double {+        Double(duration.components.seconds) * 1000.0+            + Double(duration.components.attoseconds) / 1_000_000_000_000_000.0+    }++    @Test("Same-line HTML tag balancing does not grow quadratically with tag count")+    func testHTMLTagBalancingDoesNotGrowQuadratically() {+        // Deliberately a growth-ratio assertion, not an absolute budget: one budget at one+        // input size cannot distinguish a linear scan from a quadratic one (the naming+        // lesson from T-1655). Quadrupling the tag count costs ~4x when the scan is linear+        // and ~16x when it is quadratic, so the 8x ceiling sits with 2x headroom above+        // linear and 2x below quadratic — wide enough for the timing flakiness this repo+        // has seen (T-1541). Measured pre-fix on a release build, quadrupling cost ~15x.+        let smallDocument = htmlTagStressDocument(pairs: 2_000)+        let largeDocument = htmlTagStressDocument(pairs: 8_000)++        // Warm up so first-call costs do not land on the smaller measurement and inflate+        // the ratio; the growth signal is what matters, not the absolute numbers.+        for _ in 0..<3 {+            _ = FootnotePreprocessor.process(smallDocument)+        }++        let small = fastestElapsed(runs: 5) { _ = FootnotePreprocessor.process(smallDocument) }+        let large = fastestElapsed(runs: 5) { _ = FootnotePreprocessor.process(largeDocument) }++        let smallMs = milliseconds(small)+        let largeMs = milliseconds(large)+        let ratio = largeMs / smallMs+        let ratioText = String(format: "%.2f", ratio)++        print("HTML tag balancing — 2,000 pairs: \(small), 8,000 pairs: \(large), ratio: \(ratioText)")++        // Correctness alongside the timing: the stress line must not derail extraction of+        // the definition ahead of it.+        #expect(+            FootnotePreprocessor.process(largeDocument).footnoteData.definition(for: "p")?.content+                == "Note."+        )++        #expect(+            smallMs > 0,+            "Baseline measurement must be resolvable to make the ratio meaningful"+        )+        #expect(+            ratio < 8.0,+            "Quadrupling the tag count should cost roughly 4x, not ~16x — got \(ratioText)x (\(small) -> \(large))"+        )+    }+     @Test("Pre-processing is consistent across iterations")     func preprocessingConsistency() {         let content = generateContent(targetBytes: 250 * 1024, footnoteCount: 25)

diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 0d8d7a7..63ef5c5 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -18,6 +18,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0  ### Fixed +- Footnotes keep working after a one-line block of raw HTML (T-1877). Writing something like `<div>Text</div>` or `<details><summary>More</summary>Text</details>` on a single line silently switched off every footnote from that point on: references stayed as plain `[^1]` text instead of becoming badges, no popover was available, and the definitions themselves showed up as ordinary paragraphs. Footnote preprocessing was waiting for a closing tag that had already gone past on the same line, so it treated the rest of the document as raw HTML. Opening and closing tags are now balanced within the line, including nesting (`<div><div>x</div></div>`) and self-closing forms (`<div/>`). A tag genuinely left open — `<div>x</div><section>`, or a mismatched `<div>Text</section>` — still starts an HTML block, so definitions written inside raw HTML are still left alone. A tag name that only appears inside a quoted attribute value (`<table title="<div>">Content</table>`) no longer counts as real markup; it used to leave a phantom block open and switch off the following footnotes in exactly the same way, and so did a stray or deliberately-escaped quote inside such a value (`<div title="a"b">`). Balancing the tags on a line also no longer costs time in proportion to the square of the tag count, so a line packed with unmatched closing tags — reachable from any document, including a remote one opened by URL — no longer stalls. Two ways footnote pre-processing can still disagree with the real parser about where a raw-HTML block ends are tracked separately: a blank line after an unclosed tag, and a block tag name written inside an HTML comment (`<!-- comment with <div> -->`), which still switches off the footnotes that follow it. - Changing the theme while viewing raw source no longer brings back the previous version of the document (T-1759). If the file changed on disk — or a URL document was refreshed — at the same moment the colours changed, the recolour worked from a snapshot taken before the reload and, finishing last, put the old text back on screen, where it stayed until the next reload or raw/rendered toggle. Recolouring now only applies while the lines it started from are still the ones being shown. - The system **Increase Contrast** accessibility setting applies to the document again (T-1829). Since the WebKit rendering cutover, turning it on changed the app's own interface but left the document body untouched: search highlights and footnote badges stayed translucent and tertiary text stayed low-contrast. The rendered document now uses the same higher-contrast search, footnote, and tertiary colours as the rest of the app, on every theme, and the deliberately-faded "add note" button beside each block is shown at full strength. It follows the setting live — toggling it while a document is open updates immediately, without a reload and without losing your reading position, and the styling survives a WebKit process recovery. Footnote popovers keep the standard palette. - Jumping to a specific place in a document you have read before now lands where you asked instead of at your saved reading position (T-1775). This covers every way you can ask: following a link to a heading, picking a table-of-contents entry, opening a note, and stepping to a search match. The requested target was queued while the document's HTML was being prepared in the background, and the saved position — restored a moment later — replaced it, so the page settled where you last stopped reading. An explicit target now takes precedence for that load. Reading position is otherwise untouched: an ordinary reopen, returning from raw source, and a reload after the file changes on disk or a URL refresh all still restore where you left off, even with a search active.