Pre-push review: T-1713 hidden-comment footnote search badges

diff --git a/prism/Models/MarkdownBlock.swift b/prism/Models/MarkdownBlock.swiftindex 16c7c11..d03f6b6 100644--- a/prism/Models/MarkdownBlock.swift+++ b/prism/Models/MarkdownBlock.swift@@ -915,29 +915,14 @@ nonisolated enum MarkdownBlock: Identifiable, Equatable, Sendable {         forInlineText text: String,         context: SearchContext     ) -> String {-        let nsText = text as NSString-        let fullRange = NSRange(location: 0, length: nsText.length)--        // Strip comment markers from the base so search never matches-        // on raw `<!--…-->`. Same input is used to extract inner text-        // below when the toggle is ON.-        let baseWithoutMarkers = inlineHTMLCommentRegex.stringByReplacingMatches(-            in: text, range: fullRange, withTemplate: ""-        )-        var result = stripMarkdownFormatting(baseWithoutMarkers)--        // Bodies of comment spans the renderer actually surfaces. Collected-        // once so the search append and the footnote-reference scan below-        // agree on which comment content is "visible".-        var surfacedBodies: [String] = []-        if context.showHTMLComments {-            let matches = inlineHTMLCommentRegex.matches(in: text, range: fullRange)-            for match in matches where match.numberOfRanges >= 2 {-                let span = nsText.substring(with: match.range)-                guard let body = HTMLCommentParser.parseBlock(span) else { continue }-                surfacedBodies.append(body)-                result += " " + body-            }+        let components = footnoteScanComponents(forInlineText: text, context: context)+        var result = stripMarkdownFormatting(components.baseWithoutMarkers)++        // Append the bodies of comment spans the renderer actually surfaces+        // (toggle ON only) so comment content is searchable exactly when it+        // is visible.+        for body in components.surfacedCommentBodies {+            result += " " + body         }          // Append footnote definition content for any resolvable `[^id]`@@ -948,9 +933,8 @@ nonisolated enum MarkdownBlock: Identifiable, Equatable, Sendable {         // references inside rendered comment ranges contribute consistently         // with the render — but references inside rejected (never-rendered)         // comment shapes still contribute nothing.-        let footnoteScanSource = ([baseWithoutMarkers] + surfacedBodies).joined(separator: " ")         if !context.footnoteData.isEmpty {-            for match in footnoteScanSource.matches(of: footnoteReferenceRegex) {+            for match in components.scanSource.matches(of: footnoteReferenceRegex) {                 let identifier = String(match.1)                 if let definition = context.footnoteData.definition(for: identifier) {                     result += " " + stripMarkdownFormatting(definition.content)@@ -961,6 +945,66 @@ nonisolated enum MarkdownBlock: Identifiable, Equatable, Sendable {         return result     } +    // MARK: - Footnote scan source (shared with SearchStateFeeder)++    /// The comment-visibility-gated pieces of an inline source that are+    /// eligible for footnote-reference scanning.+    ///+    /// Single source of truth for WHERE a `[^id]` reference may count:+    /// ``combinedSearchableText(forInlineText:context:)`` expands footnote+    /// definitions from it, and `SearchStateFeeder` derives+    /// `matchedFootnoteIds` from it — so the badges the web search payload+    /// marks can never drift from the references the native search model+    /// counts (T-1713).+    struct FootnoteScanComponents {+        /// The inline source with every `<!--…-->` span removed. References+        /// hidden inside a comment never appear here (T-1365).+        let baseWithoutMarkers: String+        /// Bodies of comment spans the renderer actually surfaces: populated+        /// only when `showHTMLComments` is ON, and only for shapes+        /// `HTMLCommentParser.parseBlock` accepts — rejected shapes+        /// (conditional comments, note-infrastructure tags, empty bodies)+        /// are never rendered, so they contribute nothing.+        let surfacedCommentBodies: [String]++        /// The joined text to scan for `[^id]` references.+        var scanSource: String {+            ([baseWithoutMarkers] + surfacedCommentBodies).joined(separator: " ")+        }+    }++    /// Splits an inline source into the comment-gated pieces eligible for+    /// footnote-reference scanning, honouring `context.showHTMLComments`.+    static func footnoteScanComponents(+        forInlineText text: String,+        context: SearchContext+    ) -> FootnoteScanComponents {+        let nsText = text as NSString+        let fullRange = NSRange(location: 0, length: nsText.length)++        // Strip comment markers from the base so scans never see content+        // inside a `<!--…-->` range. Same input is used to extract inner+        // text below when the toggle is ON.+        let baseWithoutMarkers = inlineHTMLCommentRegex.stringByReplacingMatches(+            in: text, range: fullRange, withTemplate: ""+        )++        var surfacedBodies: [String] = []+        if context.showHTMLComments {+            let matches = inlineHTMLCommentRegex.matches(in: text, range: fullRange)+            for match in matches where match.numberOfRanges >= 2 {+                let span = nsText.substring(with: match.range)+                guard let body = HTMLCommentParser.parseBlock(span) else { continue }+                surfacedBodies.append(body)+            }+        }++        return FootnoteScanComponents(+            baseWithoutMarkers: baseWithoutMarkers,+            surfacedCommentBodies: surfacedBodies+        )+    }+     // MARK: - Compatibility shims      /// Legacy plain-text search builder.

diff --git a/prism/Services/SearchStateFeeder.swift b/prism/Services/SearchStateFeeder.swiftindex 077fe3c..c497492 100644--- a/prism/Services/SearchStateFeeder.swift+++ b/prism/Services/SearchStateFeeder.swift@@ -198,15 +198,22 @@ enum SearchStateFeeder {     }      /// The footnote identifiers referenced within a block, in source order, honouring-    /// the comment-visibility gate the same way `combinedSearchableText` does (a-    /// reference inside a hidden comment contributes nothing when comments are off).+    /// the comment-visibility gate the same way `combinedSearchableText` does: each+    /// inline source is routed through the shared+    /// `MarkdownBlock.footnoteScanComponents(forInlineText:context:)`, so a reference+    /// inside a hidden `<!--…-->` range contributes nothing when comments are off,+    /// and — when comments are on — only references in surfaced comment bodies+    /// count, never ones in rejected (never-rendered) comment shapes (T-1713).     private static func referencedFootnoteIdentifiers(         in block: MarkdownBlock,         context: SearchContext     ) -> [String] {         var identifiers: [String] = []         for source in inlineSources(of: block) {-            for match in source.matches(of: FootnoteData.referencePattern) {+            let scanSource = MarkdownBlock+                .footnoteScanComponents(forInlineText: source, context: context)+                .scanSource+            for match in scanSource.matches(of: FootnoteData.referencePattern) {                 identifiers.append(String(match.1))             }         }

diff --git a/prismTests/WebRendering/WebSearchBridgeTests.swift b/prismTests/WebRendering/WebSearchBridgeTests.swiftindex 360e519..f387548 100644--- a/prismTests/WebRendering/WebSearchBridgeTests.swift+++ b/prismTests/WebRendering/WebSearchBridgeTests.swift@@ -122,6 +122,80 @@ struct WebSearchBridgeTests {         #expect(state?.matchedFootnoteIds == ["1"])     } +    // MARK: - T-1713: comment-gated footnote refs and badge-state parity++    @Test("A footnote ref hidden inside an HTML comment produces no badge state when comments are off")+    func hiddenCommentFootnoteRefProducesNoState() {+        // "alpha" matches only footnote 1's content, and the only [^1] reference+        // sits inside a `<!-- … -->` comment. With showHTMLComments == false the+        // native search model strips the comment before expanding footnotes, so it+        // counts zero matches — the web payload must agree and emit NO state.+        // Before the T-1713 fix, the feeder scanned the RAW source, saw the hidden+        // [^1], and emitted a stale matchedFootnoteIds: ["1"] state.+        let blocks: [MarkdownBlock] = [+            .paragraph(markdown: "Visible text. <!-- hidden [^1] -->"),+        ]+        let context = footnoteContext() // showHTMLComments: false+        let counts = blocks.map { SearchService.countMatches(query: "alpha", in: $0, context: context) }+        #expect(counts[0] == 0)++        let states = SearchStateFeeder.buildStates(+            query: "alpha",+            blocks: blocks,+            matchCountsPerBlock: counts,+            currentGlobalMatchIndex: nil,+            context: context+        )+        #expect(states.isEmpty)+    }++    @Test("A footnote ref inside a surfaced HTML comment contributes badge state when comments are on")+    func visibleCommentFootnoteRefSurfacesBadge() throws {+        // Same paragraph, but with showHTMLComments == true the comment body is+        // surfaced, its [^1] expands footnote 1's content natively (1 match for+        // "alpha"), and the feeder must mark the badge — as a footnote match, not+        // a text match.+        let blocks: [MarkdownBlock] = [+            .paragraph(markdown: "Visible text. <!-- hidden [^1] -->"),+        ]+        let context = SearchContext(showHTMLComments: true, footnoteData: footnoteData())+        let counts = blocks.map { SearchService.countMatches(query: "alpha", in: $0, context: context) }+        #expect(counts[0] == 1)++        let states = SearchStateFeeder.buildStates(+            query: "alpha",+            blocks: blocks,+            matchCountsPerBlock: counts,+            currentGlobalMatchIndex: nil,+            context: context+        )+        let state = try #require(states.first)+        #expect(state.textMatchCount == 0)+        #expect(state.matchedFootnoteIds == ["1"])+    }++    @Test("A footnote ref inside a rejected comment shape produces no badge state even when comments are on")+    func rejectedCommentShapeFootnoteRefProducesNoState() {+        // Conditional comments are never surfaced by HTMLCommentParser, so a [^1]+        // inside one must not expand its definition — the native model counts zero+        // matches even with the toggle ON, and the payload must carry no state.+        let blocks: [MarkdownBlock] = [+            .paragraph(markdown: "Visible text. <!--[if IE]> [^1] <![endif]-->"),+        ]+        let context = SearchContext(showHTMLComments: true, footnoteData: footnoteData())+        let counts = blocks.map { SearchService.countMatches(query: "alpha", in: $0, context: context) }+        #expect(counts[0] == 0)++        let states = SearchStateFeeder.buildStates(+            query: "alpha",+            blocks: blocks,+            matchCountsPerBlock: counts,+            currentGlobalMatchIndex: nil,+            context: context+        )+        #expect(states.isEmpty)+    }+     // MARK: - current-match addressing (text ordinal vs footnote badge id)      @Test("Current match in the text portion is addressed by text ordinal")