Pre-push review: T-1992 non-text footnote occurrence mapping

diff --git a/prism/Services/WebRendering/InlineHTMLRenderer.swift b/prism/Services/WebRendering/InlineHTMLRenderer.swiftindex 183ed7b..53a795c 100644--- a/prism/Services/WebRendering/InlineHTMLRenderer.swift+++ b/prism/Services/WebRendering/InlineHTMLRenderer.swift@@ -56,7 +56,8 @@ nonisolated struct InlineHTMLRenderer {     ///     /// The walk then decides *where* a candidate may render as a badge: text position, and     /// not nested inside an element that cannot contain an anchor (a `Link` — the badge is-    /// itself an `<a>`). Everywhere else the marker is restored to the literal `[^id]`.+    /// itself an `<a>`). Everywhere else the marker is restored to the literal `[^id]`, and+    /// its occurrence is claimed by source range so it cannot shadow a later badge (T-1992).     static func render(         source: String,         footnotes: FootnoteData,@@ -197,6 +198,9 @@ nonisolated struct InlineHTMLRenderer {          /// The text as the author wrote it: markers restored to their literal `[^id]` form.         /// A no-op (and allocation-free) when the block has no marked references.+        ///+        /// For text whose markers the cursor does NOT step over — attributes, destinations,+        /// raw HTML — use `consumingVisibleText` instead, which also claims the occurrences.         private func visibleText(_ text: String) -> String {             occurrences.isEmpty ? text : FootnoteReferenceMarker.restoringLiterals(text)         }@@ -259,9 +263,12 @@ nonisolated struct InlineHTMLRenderer {         ///         /// A marker that arrives in any other position is restored to the literal `[^id]` by         /// `visibleText` instead. Two ways that happens: the marker never reaches here at all-        /// (a code span, a link destination, an image's `src`/`alt`, raw inline HTML — each-        /// read as an attribute or as its own node), or it reaches here inside a link, where-        /// `linkDepth` sends the whole text node down the unsplit path below.+        /// (a code span, a link's destination or title, an image's `src`/`alt`/title, raw+        /// inline HTML — each read as an attribute or as its own node), or it reaches here+        /// inside a link, where `linkDepth` sends the whole text node down the unsplit path+        /// below. An image's or link's title is the one landing place with no rendered form+        /// at all: the emitter writes no `title` attribute, so it is claimed but not+        /// restored.         mutating func visitText(_ text: Text) {             guard !occurrences.isEmpty, linkDepth == 0 else {                 // Inside a link, the whole node — markers included — is located against the@@ -290,19 +297,116 @@ nonisolated struct InlineHTMLRenderer {             appendVisible(String(decoding: units[segmentStart...], as: UTF16.self))         } -        /// The first live occurrence starting at or after `from`, when its identifier+        /// The first unclaimed occurrence starting at or after `from`, when its identifier         /// matches. Used only to anchor the cursor and bound a forward search; a `nil`         /// answer costs precision in the source map, never correctness of the badge.         private mutating func liveOccurrence(             atOrAfter from: Int, identifier: String         ) -> FootnoteReferenceScanner.Occurrence? {+            advanceOccurrenceFloor(to: from)+            guard occurrenceIndex < occurrences.count,+                  occurrences[occurrenceIndex].identifier == identifier else { return nil }+            return occurrences[occurrenceIndex]+        }++        /// Drops every occurrence that starts before `from` — the walk has moved past+        /// their source, so nothing it renders from here on can have come from them.+        private mutating func advanceOccurrenceFloor(to from: Int) {             while occurrenceIndex < occurrences.count,                   occurrences[occurrenceIndex].sourceStart < from {                 occurrenceIndex += 1             }+        }++        // MARK: Occurrences consumed outside text position (T-1992)++        /// Restores the markers in text that landed in a NON-text position — an image's+        /// alt or `src`, a link destination, raw inline HTML — and claims the occurrences+        /// those markers came from. (Titles land there too, but render nothing, so they+        /// call `claimOccurrences` directly rather than going through here.)+        ///+        /// Restoring alone is not enough. The pre-pass marks an occurrence before anything+        /// knows where its characters will land, so an occurrence consumed by an attribute+        /// is still in the list, and these nodes render no run, so the cursor does not move+        /// past it either. A later text-position marker with the same identifier then binds+        /// to it — `liveOccurrence(atOrAfter:)` answers with the attribute's occurrence —+        /// and the prose before the real badge is searched with an upper bound that lies+        /// BEFORE it, so the run comes out zero-length and a selection over that prose is+        /// declined. Claiming the occurrence here is what keeps the two in step (T-1992).+        private mutating func consumingVisibleText(_ text: String) -> String {+            guard !occurrences.isEmpty else { return text }+            claimOccurrences(in: text)+            return FootnoteReferenceMarker.restoringLiterals(text)+        }++        /// Claims the occurrences that `text` — a stretch of source the walk consumed+        /// outside text position — physically covers, and steps the cursor past it.+        ///+        /// The claim is POSITIONAL, and that is the whole of what makes it sound: `text`+        /// is located in the source at or after the cursor, and exactly the occurrences+        /// lying inside that located span are claimed. Nothing is keyed on the identifier,+        /// because an identifier match cannot tell one spelling of `[^1]` from another —+        /// claiming "the next `[^1]` at or after the cursor" is only ever right while the+        /// attribute's own span is known to sit AHEAD of the cursor.+        ///+        /// That precondition is the caller's to honour, and it has exactly one exception:+        /// an autolink (`<http://x/[^1]>`) parses to a `Link` whose destination IS its+        /// `Text` child, so the descent steps the cursor over those characters before the+        /// destination is claimed. `visitLink` filters that case out up front with+        /// `consumedAsAutolinkBody` rather than letting it reach here, because nothing+        /// below can catch it: the autolink's own occurrence is behind the cursor and gets+        /// floored away, so the covering constraint ends up anchored on a LATER occurrence+        /// and accepts the later span that carries it. Otherwise callers pass a node's+        /// parts in SOURCE order (an image's alt before its `src` before its title; a+        /// link's destination only after its text has been walked), because the search+        /// runs forward from the cursor. Out of order, the later part simply fails to+        /// locate and claims nothing — a precision loss, not a mis-claim.+        ///+        /// Locating also fails, claiming nothing, for an attribute cmark hands back+        /// normalised rather than verbatim: an entity- or backslash-decoded destination,+        /// or an alt whose `InlineContainer` markup has been flattened (`Image.plainText`+        /// joins its children's plain text, so emphasis, strong, strikethrough and link+        /// markup all vanish — but NOT a code span, whose `InlineCode.plainText` keeps its+        /// backticks and so still matches the source verbatim). There the walk has no+        /// evidence of where the occurrence sits. Not claiming leaves one occurrence+        /// shadowing until the next text located past it: bounded precision loss. Claiming+        /// one that is still owed would cost a real badge its source offset, so declining+        /// is the safe direction.+        ///+        /// The forward search is what makes that normalised case dangerous, and the+        /// COVERING constraint below is what defuses it. A normalised attribute does not+        /// match at its own offset, but the search does not stop there — it can match a+        /// later span (`![*a*[^1]](x.png) prose ![b](y/a[^1].png)`: the first alt's+        /// `a[^1]` matches inside the SECOND image's `src`), and stepping the cursor to+        /// the end of that span would skip prose the walk has not rendered yet. So a+        /// located span is only claimed when it CONTAINS the next unclaimed occurrence: an+        /// occurrence still owed that lies before the located span proves the span is not+        /// the attribute's own, and the claim is refused. Every real attribute span+        /// satisfies it, because the marker it carries IS that occurrence — which is+        /// precisely the premise the autolink breaks, and why it is excluded above rather+        /// than here.+        private mutating func claimOccurrences(in text: String) {+            guard !occurrences.isEmpty,+                  text.utf16.contains(where: FootnoteReferenceMarker.isReserved) else { return }+            let units = Array(text.utf16)+            guard let start = locate(units, from: cursor) else { return }+            let end = start + units.count+            // Refuse a span that overshoots the next occurrence the walk still owes.+            // (This subsumes the reserved-unit check above — a span covering an occurrence+            // necessarily carries its marker — which stays only as a fast path.)+            advanceOccurrenceFloor(to: cursor)             guard occurrenceIndex < occurrences.count,-                  occurrences[occurrenceIndex].identifier == identifier else { return nil }-            return occurrences[occurrenceIndex]+                  occurrences[occurrenceIndex].sourceStart >= start,+                  occurrences[occurrenceIndex].sourceStart+                    + occurrences[occurrenceIndex].length <= end else { return }+            while occurrenceIndex < occurrences.count,+                  occurrences[occurrenceIndex].sourceStart+                    + occurrences[occurrenceIndex].length <= end {+                occurrenceIndex += 1+            }+            // `locate` searches from the cursor and `units` is non-empty, so `end > cursor`+            // unconditionally — the step is always forward.+            cursor = end         }          /// Emits the badge as chrome: no run covers it, and the cursor steps over the@@ -320,9 +424,11 @@ nonisolated struct InlineHTMLRenderer {             closeRun()             // Record the badge's source position (emission order == DOM order). The             // occurrence's own start is authoritative; when it is nil (defensive), the-            // cursor sits at the marker's start because the preceding text was just-            // located — an approximation that costs eligibility-matching precision for-            // one occurrence, never badge correctness.+            // cursor stands in — the marker's own start whenever the preceding text+            // located verbatim, and otherwise the end of the last span the walk+            // accounted for, which need not be an offset any `[^id]` token occupies. An+            // approximation either way: it costs eligibility-matching precision for one+            // occurrence, never badge correctness.             badgeSourceStarts.append(occurrence?.sourceStart ?? cursor)             // Anchoring on the occurrence's own source range keeps the cursor exact even             // when the preceding text did not locate verbatim (escaped or entity-encoded@@ -364,8 +470,9 @@ nonisolated struct InlineHTMLRenderer {             // text resolve to no run and are declined (design: hidden comments and             // chrome have no run; notes on comments are a non-goal).             // Raw HTML is not text position: a marker that landed here is author text-            // (e.g. `<span title="[^1]">`), so it is restored before anything else runs.-            let rawHTML = visibleText(inlineHTML.rawHTML)+            // (e.g. `<span title="[^1]">`), so it is restored — and its occurrence claimed+            // (T-1992) — before anything else runs.+            let rawHTML = consumingVisibleText(inlineHTML.rawHTML)             if let commentText = HTMLCommentParser.parseBlock(rawHTML) {                 html += "<span class=\"prism-comment-inline\" data-prism-comment-inline>"                     + HTMLEscaping.escapeText(commentText) + "</span>"@@ -515,10 +622,11 @@ nonisolated struct InlineHTMLRenderer {             // Links route through native link handling on click; the href is escaped             // into the attribute. Internal anchors/relative md/http(s) are dispatched by             // the controller's NavigationDeciding, not here (Req 2.4).-            // A link destination is not text position: `[t](http://x/[^1])` keeps the-            // literal token in the href rather than turning it into a badge.-            let href = link.destination.map { HTMLEscaping.escapeAttribute(visibleText($0)) } ?? ""-            appendInlineMarkup("<a href=\"\(href)\">")+            // Neither a link's destination nor its title is text position:+            // `[t](http://x/[^1] "t [^2]")` keeps the literal token in the href, and the+            // title is not rendered at all, rather than either turning into a badge.+            let destination = link.destination ?? ""+            appendInlineMarkup("<a href=\"\(HTMLEscaping.escapeAttribute(visibleText(destination)))\">")             // A link's TEXT is text position, but not a position a badge may occupy: the             // badge is an anchor, and `<a>` inside `<a>` is invalid HTML. `[see [^1]](url)`             // therefore renders the literal `[^1]` inside the link caption rather than a@@ -528,17 +636,88 @@ nonisolated struct InlineHTMLRenderer {             descendInto(link)             linkDepth -= 1             appendInlineMarkup("</a>")+            // Source order in `[text](dest "title")` is text, destination, title, and the+            // text's own markers are stepped over by the cursor as each text node is+            // located — so both claims belong here, after the descent, in this order.+            // `Link.title` IS exposed by the AST and is never emitted, which makes a+            // reference inside one a live occurrence nothing else would ever account for+            // (T-1992 review). Defensive rather than production-reachable today:+            // `MarkdownBlockParser.convertParagraph` rebuilds the block source with+            // `paragraph.format()`, and swift-markdown's `MarkupFormatter` prints an+            // image title but NOT a link one, so this only fires for a directly built+            // `.paragraph(markdown:)` — or a future source that skips `format()`.+            if !consumedAsAutolinkBody(link, destination) {+                claimOccurrences(in: destination)+            }+            claimOccurrences(in: link.title ?? "")+        }++        /// True when `destination` is THIS link's own body, already consumed by the descent+        /// above — the autolink, the one shape whose destination and link text are the very+        /// same source characters (`<http://x/[^1]>` parses to a `Link` whose destination+        /// IS its single `Text` child).+        ///+        /// Skipping the claim is not just an optimisation. Those characters lie BEHIND the+        /// cursor, so a forward search can only ever find some LATER span — and the+        /// covering constraint in `claimOccurrences` cannot reject it, because the+        /// autolink's own occurrence was consumed by the descent and floored away, leaving+        /// the guard to compare against an occurrence that lives inside the spurious span+        /// and fits it exactly. `see <http://x/[^1]> prose ![b](http://x/[^1]) tail` claimed+        /// the image's span and stepped the cursor over " prose ", collapsing a run that+        /// maps correctly without any claim at all (T-1992 review round 3).+        ///+        /// BOTH the node shape and the source spelling have to agree, because each alone+        /// admits a link whose destination is a second, unconsumed span:+        ///+        /// - Shape alone is `Link.isAutolink` (`destination == the single Text child's+        ///   string`), which is equally true of `[http://x/[^1]](http://x/[^1])`, whose+        ///   destination is a SECOND source span that must be claimed. Only the angle+        ///   brackets tell those two apart.+        /// - Spelling alone reads the characters behind the cursor, which belong to this+        ///   link only if its descent actually moved the cursor. A zero-child link+        ///   (`[](http://x/[^1])`) descends into nothing, so it inherits wherever the+        ///   PREVIOUS node left the cursor — after `<http://x/[^1]>` that is the preceding+        ///   autolink's body, angle brackets and all, and the test matches the wrong link+        ///   (T-1992 review round 4).+        ///+        /// The shape half is spelled out here rather than calling `Link.isAutolink`, which+        /// swift-markdown declares internal (`Link.swift:89`, no `public`) and so is not+        /// visible outside its module.+        ///+        /// `<…>` is the whole set of autolink spellings the walker can see: swift-markdown+        /// attaches only the `table`, `strikethrough` and `tasklist` GFM extensions+        /// (`CommonMarkConverter.swift:624-626`), never `autolink`, so a bare `http://…`+        /// stays plain text. An email autolink (`<a@b.c>`) has destination `mailto:a@b.c`,+        /// which is not its text, so it fails the shape test and falls through to the+        /// ordinary claim, which simply fails to locate.+        private func consumedAsAutolinkBody(_ link: Link, _ destination: String) -> Bool {+            guard link.childCount == 1, let text = link.child(at: 0) as? Text,+                  text.string == destination else { return false }+            let units = Array(destination.utf16)+            let start = cursor - units.count+            guard !units.isEmpty, start > 0, cursor < sourceUTF16.count,+                  sourceUTF16[start - 1] == 0x3C, // '<'+                  sourceUTF16[cursor] == 0x3E     // '>'+            else { return false }+            for offset in 0..<units.count where sourceUTF16[start + offset] != units[offset] {+                return false+            }+            return true         }          mutating func visitImage(_ image: Image) {             // Inline images inside text flow render as the alt text run (block-level             // images are handled by the emitter via the dedicated .image case). The             // image markup itself is rendered as a void <img> with a rewritten src.-            // Neither an image's src nor its alt is text position: a reference-shaped token-            // in either is author text and stays literal (it could not be chrome — an-            // attribute cannot hold a badge element).-            let src = image.source.map { BlockHTMLEmitter.rewriteImageSrc(visibleText($0)) } ?? ""-            let alt = visibleText(image.plainText)+            // None of an image's alt, `src` or title is text position: a reference-shaped+            // token in any of them is author text and stays literal (it could not be+            // chrome — an attribute cannot hold a badge element). All three claim their+            // occurrences, in the source order of `![alt](src "title")` (T-1992). The+            // title is claim-only: the AST exposes it (`Image.title`) but the emitter+            // renders no `title` attribute, so it has no text to restore.+            let alt = consumingVisibleText(image.plainText)+            let src = image.source.map { BlockHTMLEmitter.rewriteImageSrc(consumingVisibleText($0)) } ?? ""+            claimOccurrences(in: image.title ?? "")             closeRun()             html += "<img src=\"\(HTMLEscaping.escapeAttribute(src))\""                 + " alt=\"\(HTMLEscaping.escapeAttribute(alt))\""

diff --git a/prism/Services/WebRendering/FootnoteReferenceScanner.swift b/prism/Services/WebRendering/FootnoteReferenceScanner.swiftindex 1366949..1d4c15f 100644--- a/prism/Services/WebRendering/FootnoteReferenceScanner.swift+++ b/prism/Services/WebRendering/FootnoteReferenceScanner.swift@@ -41,10 +41,11 @@ import Foundation /// A marker is a badge when it reaches text position AND that position is not nested /// inside an element forbidden from containing an anchor — the badge is itself an `<a>`, /// so a `Link` ancestor disqualifies it (`<a>` inside `<a>` is invalid HTML). Every other-/// landing place — a code span, a link destination, an image's alt text, raw inline HTML,-/// or text inside a link — is restored to the literal `[^id]` the author wrote. All of-/// these are decisions about *where the character data ended up*, which the walker knows-/// for free; none is reconstructed from the parsed text.+/// landing place — a code span, a link's destination or title, an image's alt text, `src`+/// or title, raw inline HTML, or text inside a link — is restored to the literal `[^id]`+/// the author wrote (titles excepted: nothing renders them). All of these are decisions+/// about *where the character data ended up*, which the walker knows for free; none is+/// reconstructed from the parsed text. nonisolated enum FootnoteReferenceMarker {      /// Identifier characters are shifted by this amount into the Private Use Area.@@ -165,10 +166,10 @@ nonisolated enum FootnoteReferenceScanner {     /// other spelling is left exactly as the author wrote it, so the parser handles it the     /// way it always has: an escaped token keeps its backslashes for cmark to strip, an     /// entity-encoded one is never even a candidate (the source holds `&#91;`, not `[`),-    /// and a token inside a code span, a link destination, an image's alt text or a link's-    /// text is restored to its literal form at emit time because that is where the marker-    /// landed. Marking makes an occurrence a *candidate*; the walk decides whether its-    /// landing place may hold a badge.+    /// and a token inside a code span, a link's destination or title, an image's alt text,+    /// `src` or title, or a link's text is restored to its literal form at emit time+    /// because that is where the marker landed. Marking makes an occurrence a *candidate*;+    /// the walk decides whether its landing place may hold a badge.     ///     /// Cost is O(source): the outer index advances on every iteration, and the identifier     /// scans launched from distinct `[^` positions cannot overlap (neither `[` nor `^` is

diff --git a/prismTests/WebRendering/FootnoteBadgeSubstitutionTests.swift b/prismTests/WebRendering/FootnoteBadgeSubstitutionTests.swiftindex 12e1bc5..e281695 100644--- a/prismTests/WebRendering/FootnoteBadgeSubstitutionTests.swift+++ b/prismTests/WebRendering/FootnoteBadgeSubstitutionTests.swift@@ -480,3 +480,337 @@ struct FootnoteBadgeNestedContextTests {         #expect(FootnoteRenderProbe.text(html).contains("outer [^1]"))     } }++// MARK: - I: a non-text occurrence followed by a live one of the same id (T-1992)+//+// D3/D4 already pin that a reference in an image alt or a link destination renders+// literally — but they follow it with an ESCAPED token, which is never a candidate, so+// nothing there could bind to the wrong occurrence. When the token that follows is a+// LIVE one with the same identifier, the walker asks for "the first occurrence at or+// after the cursor with this identifier" and gets the attribute's occurrence, because+// nothing claimed it. The badge still renders (the count looks right), but it is+// recorded at the attribute's source offset — which is what search occurrence identity+// and the source map are built on.++struct FootnoteNonTextOccurrenceTests {++    private func footnotes(_ identifiers: [String]) -> FootnoteData {+        FootnoteRenderProbe.footnotes(identifiers)+    }++    /// The badge source offsets the walk records for a one-paragraph source.+    private func badgeStarts(_ source: String, _ identifiers: [String] = ["1"]) -> [Int] {+        InlineHTMLRenderer.badgeSourceStarts(source: source, footnotes: footnotes(identifiers))+    }++    /// The source substrings the emitted runs cover, in the paragraph's own coordinates.+    ///+    /// Badge count and rendered text are both already correct when an occurrence is+    /// mis-claimed — the damage is entirely in the coordinates — so every case here+    /// pins the run spans as well, or it pins nothing (T-1992 review).+    private func runSpans(_ source: String, _ identifiers: [String] = ["1"]) -> [String] {+        let doc = BlockHTMLEmitter.emit(+            blocks: [.paragraph(markdown: source)],+            footnotes: footnotes(identifiers), settings: RenderSettings()+        )+        let units = Array(source.utf16)+        return (doc.sourceMap.runs.values.first ?? []).compactMap { run in+            let end = run.sourceStart + run.length+            guard run.length > 0, run.sourceStart >= 0, end <= units.count else { return nil }+            return String(decoding: units[run.sourceStart..<end], as: UTF16.self)+        }+    }++    /// The offset of the live `[^id]` token — the one spelled with a space on both sides.+    private func liveTokenStart(_ source: String) -> Int {+        (source as NSString).range(of: " [^1] ").location + 1+    }++    @Test("I1: image alt then a live reference of the same id badges only the live one")+    func imageAltThenLiveReference() {+        let source = "![[^1]](x.png) choose [^1] after"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 1)+        #expect(html.contains("alt=\"[^1]\""))+        #expect(FootnoteRenderProbe.text(html) == "choose {1} after")+        #expect(runSpans(source) == [" choose ", " after"])+        #expect(badgeStarts(source) == [liveTokenStart(source)])+    }++    @Test("I2: link destination then a live reference of the same id badges only the live one")+    func linkDestinationThenLiveReference() {+        let source = "[link](http://x/[^1]) choose [^1] after"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 1)+        #expect(html.contains("href=\"http://x/[^1]\""))+        #expect(FootnoteRenderProbe.text(html) == "link choose {1} after")+        #expect(runSpans(source) == ["link", " choose ", " after"])+        #expect(badgeStarts(source) == [liveTokenStart(source)])+    }++    @Test("I3: the badge source start is the LIVE token's offset, not the image alt's")+    func badgeSourceStartSkipsImageAltOccurrence() {+        // `badgeSourceStarts` is how `SearchStateFeeder` decides which `[^id]`-shaped+        // occurrence owns a DOM badge (T-1853). Reporting the alt's offset makes the+        // feeder mark the wrong occurrence eligible and address the wrong badge.+        let source = "![[^1]](x.png) choose [^1] after"+        let starts = InlineHTMLRenderer.badgeSourceStarts(source: source, footnotes: footnotes(["1"]))+        #expect(starts == [(source as NSString).range(of: " [^1] ").location + 1])+    }++    @Test("I4: the badge source start is the LIVE token's offset, not the destination's")+    func badgeSourceStartSkipsLinkDestinationOccurrence() {+        let source = "[link](http://x/[^1]) choose [^1] after"+        let starts = InlineHTMLRenderer.badgeSourceStarts(source: source, footnotes: footnotes(["1"]))+        #expect(starts == [(source as NSString).range(of: " [^1] ").location + 1])+    }++    @Test("I5: the badge source start is the LIVE token's offset, not the inline HTML's")+    func badgeSourceStartSkipsInlineHTMLOccurrence() {+        let source = "pre <em title=\"[^1]\"></em> choose [^1] after"+        let starts = InlineHTMLRenderer.badgeSourceStarts(source: source, footnotes: footnotes(["1"]))+        #expect(starts == [(source as NSString).range(of: " [^1] ").location + 1])+    }++    // MARK: Titles — exposed by the AST, so they hold live occurrences too++    @Test("I6: the badge source start is the LIVE token's offset, not the link TITLE's")+    func badgeSourceStartSkipsLinkTitleOccurrence() {+        // `Link.title` is exposed by swift-markdown 0.7.3, so the token in the title is a+        // live occurrence the walker is handed. Nothing emits it, so unless it is claimed+        // the badge that follows binds to it and reports the title's offset instead.+        //+        // The walker in isolation, not a production shape: a parsed document reaches the+        // walker through `paragraph.format()`, which prints an image title but drops a+        // link one, so only this directly-built source carries it. Kept as a guard on the+        // walker's own contract (and against a future non-`format()` source).+        let source = "[link](http://x \"t [^1]\") choose [^1] after"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 1)+        #expect(FootnoteRenderProbe.text(html) == "link choose {1} after")+        #expect(runSpans(source) == ["link", " choose ", " after"])+        #expect(badgeStarts(source) == [liveTokenStart(source)])+    }++    @Test("I7: the badge source start is the LIVE token's offset, not the image TITLE's")+    func badgeSourceStartSkipsImageTitleOccurrence() {+        let source = "![a](x.png \"t [^1]\") choose [^1] after"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 1)+        #expect(FootnoteRenderProbe.text(html) == "choose {1} after")+        #expect(runSpans(source) == [" choose ", " after"])+        #expect(badgeStarts(source) == [liveTokenStart(source)])+    }++    // MARK: Autolinks — the destination IS the link text, so it must not be claimed twice++    @Test("I8: an autolink's single occurrence is claimed once, not twice")+    func autolinkDestinationIsNotDoubleClaimed() {+        // `<http://x/[^1]>` parses to a Link whose destination is its own Text child. The+        // text descent already accounts for that occurrence, so an identifier-keyed+        // destination claim floors past it onto the LIVE occurrence and consumes a real+        // badge's slot — both prose runs collapse and the recorded offset matches no+        // token at all.+        //+        // With only ONE occurrence of the token in the block, the positional claim is also+        // safe by accident: the forward search finds nothing and refuses. I14-I16 add the+        // second occurrence that gives the search something to land on, which is what+        // `consumedAsAutolinkBody` exists for.+        //+        // NOT red against `main` (which claims nothing at all, so nothing can double-claim):+        // this is a guard against the identifier-keyed claim this branch first shipped and+        // then replaced. It pins that regression out, it does not reproduce T-1992.+        let source = "<http://x/[^1]> choose [^1] after"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 1)+        #expect(FootnoteRenderProbe.text(html) == "http://x/[^1] choose {1} after")+        #expect(runSpans(source) == ["http://x/[^1]", " choose ", " after"])+        #expect(badgeStarts(source) == [liveTokenStart(source)])+    }++    @Test("I9: a link whose text equals its destination still claims the destination")+    func linkTextEqualToDestinationStillClaimsDestination() {+        // Same AST shape as I8 (`destination == the single Text child's string`, i.e.+        // `Link.isAutolink` is true for BOTH) but an ordinary inline link: the destination+        // is a SECOND source span holding a second occurrence, which must be claimed.+        // Distinguishing THESE two by node shape cannot work; only the SOURCE spelling+        // can, which is why `consumedAsAutolinkBody` reads the angle brackets around the+        // characters sitting immediately behind the cursor. (It requires the shape too,+        // for the separate reason I17 pins — the two tests bound the predicate from+        // opposite sides.)+        //+        // Also walker-in-isolation: `paragraph.format()` condenses `[url](url)` back into+        // the `<url>` autolink of I8, so the two cover one production spelling between+        // them. The discrimination they pin is still the walker's to get right.+        let source = "[http://x/[^1]](http://x/[^1]) choose [^1] after"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 1)+        #expect(runSpans(source) == ["http://x/[^1]", " choose ", " after"])+        #expect(badgeStarts(source) == [liveTokenStart(source)])+    }++    // MARK: Normalised attributes — the locate must fail closed, never overshoot+    //+    // The claim locates an attribute's text in the block source. cmark does not always+    // hand the attribute back verbatim: `Image.plainText` joins its children's plain+    // text, so any inline markup inside the alt is normalised away, and an entity or+    // backslash escape in a destination is decoded. The attribute's own span then does+    // not match, and because the search runs forward it can match a LATER span instead —+    // stepping the cursor over prose that has not been rendered yet.+    //+    // None of these are red against `main` (which claims nothing, so the cursor never+    // moves on an attribute); they pin out the overshoot this branch's claim introduced.+    // The bound is positional: a located span is only claimed when it COVERS the next+    // unclaimed occurrence, so a span that skips one is rejected by construction.++    @Test("I10: an alt normalised by inline markup does not claim a later attribute's span")+    func normalisedImageAltDoesNotOvershoot() {+        // `Image.plainText` for `![*a*[^1]](x.png)` is `a[^1]` — the source spells+        // `*a*[^1]`, so the alt cannot locate at its own offset. The only forward match is+        // inside the SECOND image's src, and claiming it would put the cursor past+        // " prose ", collapsing a run that maps correctly today.+        //+        // The one normalisation case that IS production-reachable: `paragraph.format()`+        // round-trips `![*a*[^1]](x.png)` verbatim, so this spelling reaches the walker+        // from a parsed document, not only from a directly-built `.paragraph(markdown:)`.+        let source = "![*a*[^1]](x.png) prose ![b](y/a[^1].png) tail"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 0)+        #expect(runSpans(source) == [" prose ", " tail"])+        #expect(badgeStarts(source).isEmpty)+    }++    @Test("I11: an alt normalised by a link child does not claim a later attribute's span")+    func linkNormalisedImageAltDoesNotOvershoot() {+        // Same normalisation class as I10 through a different child node: `Link` is an+        // `InlineContainer`, so `Image.plainText` for `![[a](u)[^1]](x.png)` is `a[^1]`+        // and the alt cannot locate at its own offset. The only forward match is inside+        // the SECOND image's src, which the covering constraint refuses.+        let source = "![[a](u)[^1]](x.png) prose ![b](y/a[^1].png) tail"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 0)+        #expect(runSpans(source) == [" prose ", " tail"])+        #expect(badgeStarts(source).isEmpty)+    }++    @Test("I11b: an alt holding a code span locates verbatim and claims its OWN span")+    func codeSpanImageAltClaimsItsOwnSpan() {+        // NOT a normalisation case, despite the neighbouring shapes: `InlineCode.plainText`+        // returns the code WITH its backticks (swift-markdown `InlineCode.swift:51`), so+        // `Image.plainText` for ``![`a`[^1]](x.png)`` is ``` `a`[^1] ``` — byte-identical to+        // the source. Only `InlineContainer` children (emphasis, strong, strikethrough,+        // link) normalise. The alt therefore locates at its own offset and the claim is+        // ACCEPTED; the second image's src then claims its own span in turn. Pinned as the+        // accept path it is, so the boundary between "verbatim" and "normalised" stays+        // where swift-markdown actually draws it.+        let source = "![`a`[^1]](x.png) prose ![b](y/a[^1].png) tail"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 0)+        #expect(runSpans(source) == [" prose ", " tail"])+        #expect(badgeStarts(source).isEmpty)+    }++    @Test("I12: an entity-decoded destination does not claim a later attribute's span")+    func entityDecodedDestinationDoesNotOvershoot() {+        // Destinations are entity-decoded, so the source `x&amp;/[^1]` reaches the walker+        // as `x&/[^1]` and cannot locate at its own offset either.+        //+        // Walker-in-isolation, like I6/I9: `paragraph.format()` prints the DECODED+        // destination (`[l](x&amp;/[^1])` comes back as `[l](x&/[^1])`), and every inline+        // source that reaches the walker in production is rebuilt by `format()`/`plainText`+        // (`MarkdownBlockParser.convertParagraph` and friends), so an entity-encoded+        // destination never survives to here. I10 carries the production-reachable half of+        // this class; this case guards the walker's own contract.+        let source = "[l](x&amp;/[^1]) prose ![b](y/x&/[^1].png) tail"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 0)+        #expect(runSpans(source) == ["l", " prose ", " tail"])+        #expect(badgeStarts(source).isEmpty)+    }++    @Test("I13: an attribute holding no reference leaves the live occurrence alone")+    func markerFreeAttributeClaimsNothing() {+        // The claim must be inert for an attribute with no footnote token in it, or every+        // ordinary image in a document with footnotes would move the cursor. Green before+        // the bound too (the reserved-unit fast path already rejected it); pinned because+        // nothing else covered it and it is the shape a refactor is most likely to break.+        let source = "![pic](x.png) choose [^1] after"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 1)+        #expect(runSpans(source) == [" choose ", " after"])+        #expect(badgeStarts(source) == [liveTokenStart(source)])+    }++    // MARK: An autolink whose occurrence repeats later — the covering constraint's blind spot+    //+    // I8 pins that an autolink's single occurrence is not double-claimed, but it has only+    // ONE occurrence, so the destination's forward search finds nothing and the claim is+    // refused for free. Add a second occurrence of the same token later in the block and+    // the search DOES find something — and the covering constraint cannot object, because+    // the autolink's own occurrence was consumed by the text descent and floored away, so+    // the guard is left comparing against the later occurrence, which the spurious span+    // covers exactly. The claim is accepted and the cursor jumps over the prose in+    // between (T-1992 review round 3).+    //+    // Unlike I6/I9/I12 these are reachable block sources: `paragraph.format()` round-trips+    // all three spellings verbatim.++    @Test("I14: an autolink before an image src holding the same token keeps the prose run")+    func autolinkBeforeMatchingImageSourceDoesNotOvershoot() {+        let source = "see <http://x/[^1]> prose ![b](http://x/[^1]) tail"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 0)+        #expect(runSpans(source) == ["see ", "http://x/[^1]", " prose ", " tail"])+        #expect(badgeStarts(source).isEmpty)+    }++    @Test("I15: two autolinks carrying the same token keep every run between them")+    func repeatedAutolinkDoesNotOvershoot() {+        let source = "<http://x/[^1]> and <http://x/[^1]>"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 0)+        #expect(runSpans(source) == ["http://x/[^1]", " and ", "http://x/[^1]"])+        #expect(badgeStarts(source).isEmpty)+    }++    @Test("I16: an autolink before an ordinary link with the same token still claims the link's")+    func autolinkBeforeOrdinaryLinkStillClaimsThatLinksDestination() {+        // The refusal must be scoped to the autolink's OWN destination, not to every+        // destination carrying that identifier: the second link's destination is a+        // genuine, unconsumed source span and has to be claimed like any other.+        //+        // A LIVE token follows, because that is the only thing that can tell the two+        // apart. Run spans and a zero badge count come out identical whether or not the+        // second destination is claimed — an unclaimed occurrence only shows itself when+        // a badge later binds to it. With the live token there, the badge's recorded+        // offset IS the assertion: `liveTokenStart` when the destination was claimed, the+        // destination's own offset when it was not (T-1992 review round 4).+        let source = "<http://x/[^1]> and [see](http://x/[^1]) choose [^1] after"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 1)+        #expect(runSpans(source) == ["http://x/[^1]", " and ", "see", " choose ", " after"])+        #expect(badgeStarts(source) == [liveTokenStart(source)])+    }++    @Test("I17: a zero-child link after an autolink still claims its own destination")+    func zeroChildLinkAfterAutolinkStillClaimsItsDestination() {+        // `consumedAsAutolinkBody` reads the source characters immediately BEHIND the+        // cursor, and a zero-child link (`[](url)`) descends into nothing — so the cursor+        // is still parked where the PRECEDING autolink's descent left it: on the `>`, with+        // that autolink's body behind it. The bracket test therefore matches the wrong+        // link's body and refuses a claim that is genuinely owed; the second destination's+        // occurrence survives and the live badge after it binds there instead.+        //+        // Conjoining the AST shape — a link with exactly one `Text` child equal to its+        // destination, which is `Link.isAutolink`'s definition (internal to+        // swift-markdown, so spelled out locally) — settles it: a zero-child link is not+        // autolink-shaped whatever sits behind the cursor, and the two shapes the source+        // test exists to separate (I8 vs I9) are identical under it, so it can only ever+        // narrow the refusal, never widen it.+        let source = "<http://x/[^1]>[](http://x/[^1]) choose [^1] after"+        let html = FootnoteRenderProbe.emit(source)+        #expect(FootnoteRenderProbe.badgeCount(html) == 1)+        #expect(runSpans(source) == ["http://x/[^1]", " choose ", " after"])+        #expect(badgeStarts(source) == [liveTokenStart(source)])+    }+}

diff --git a/prismTests/WebRendering/DocumentSourceMapTests.swift b/prismTests/WebRendering/DocumentSourceMapTests.swiftindex d252113..9c9428d 100644--- a/prismTests/WebRendering/DocumentSourceMapTests.swift+++ b/prismTests/WebRendering/DocumentSourceMapTests.swift@@ -300,6 +300,163 @@ struct DocumentSourceMapInvariantTests {         #expect(wordRange?.selectedText == "after")     } +    // MARK: - Non-text occurrences must not claim a later badge's slot (T-1992)+    //+    // The scanner marks every resolvable `[^id]` token before the parse, so a token that+    // lands in an image's alt/src, a link destination, or raw inline HTML is a live+    // occurrence too — the walker only finds out where it landed once it is holding it.+    // Those landing places restore the marker to literal text and emit no badge, so their+    // occurrence has to be CLAIMED; otherwise the next text-position marker with the same+    // identifier binds to it, the prose before the real badge is searched with an upper+    // bound that lies before it, and the run comes out zero-length or anchored over the+    // image/link syntax. Each case below pins the prose run's exact source span.++    @Test("A reference in an image alt does not steal a later badge's occurrence")+    func imageAltReferenceDoesNotStealLaterOccurrence() {+        let source = "![[^1]](x.png) choose [^1] after"+        let runs = runs(for: .paragraph(markdown: source), footnotes: footnoteData(["1"]))+        let spans = runs.compactMap { sourceSpan($0, in: source) }+        #expect(spans == [" choose ", " after"])+        #expect(runs.first?.sourceStart == (source as NSString).range(of: " choose ").location)+    }++    @Test("A reference in an image src does not steal a later badge's occurrence")+    func imageSourceReferenceDoesNotStealLaterOccurrence() {+        let source = "![pic](x/[^1].png) choose [^1] after"+        let runs = runs(for: .paragraph(markdown: source), footnotes: footnoteData(["1"]))+        let spans = runs.compactMap { sourceSpan($0, in: source) }+        #expect(spans == [" choose ", " after"])+    }++    @Test("A reference in a link destination does not steal a later badge's occurrence")+    func linkDestinationReferenceDoesNotStealLaterOccurrence() {+        let source = "[link](http://x/[^1]) choose [^1] after"+        let runs = runs(for: .paragraph(markdown: source), footnotes: footnoteData(["1"]))+        let spans = runs.compactMap { sourceSpan($0, in: source) }+        #expect(spans == ["link", " choose ", " after"])+        #expect(runs.last?.sourceStart == (source as NSString).range(of: " after").location)+    }++    @Test("A reference in raw inline HTML does not steal a later badge's occurrence")+    func inlineHTMLReferenceDoesNotStealLaterOccurrence() {+        // The element is empty on purpose: any text node between the raw HTML and the+        // live reference would advance the cursor past the stale occurrence on its own,+        // which is why the defect hides behind the more obvious spellings.+        let source = "pre <em title=\"[^1]\"></em> choose [^1] after"+        let runs = runs(for: .paragraph(markdown: source), footnotes: footnoteData(["1"]))+        let spans = runs.compactMap { sourceSpan($0, in: source) }+        #expect(spans == ["pre ", " choose ", " after"])+        #expect(runs.last?.sourceStart == (source as NSString).range(of: " after").location)+    }++    @Test("An image alt whose identifier differs still leaves the live occurrence intact")+    func imageAltWithOtherIdentifierKeepsLiveOccurrence() {+        // Claiming in source order matters: the alt's `[^2]` precedes the src's `[^1]`,+        // so claiming the src first would test `[^1]` against the alt's occurrence,+        // claim nothing, and leave the src occurrence to shadow the real badge.+        let source = "![[^2]](x/[^1].png) choose [^1] after"+        let runs = runs(for: .paragraph(markdown: source), footnotes: footnoteData(["1", "2"]))+        let spans = runs.compactMap { sourceSpan($0, in: source) }+        #expect(spans == [" choose ", " after"])+    }++    @Test("A link whose TEXT and destination both hold references keeps the live one")+    func linkTextAndDestinationReferencesKeepLiveOccurrence() {+        // Link text is text position (so its marker is walked, located, and stepped over+        // by the cursor) while the destination is not — and the destination follows the+        // text in source order, so it must be claimed after the descent.+        let source = "[see [^1]](http://x/[^1]) choose [^1] after"+        let runs = runs(for: .paragraph(markdown: source), footnotes: footnoteData(["1"]))+        let spans = runs.compactMap { sourceSpan($0, in: source) }+        #expect(spans == ["see [^1]", " choose ", " after"])+    }++    @Test("A reference in a link TITLE does not steal a later badge's occurrence")+    func linkTitleReferenceDoesNotStealLaterOccurrence() {+        // `Link.title` IS exposed by swift-markdown (0.7.3, `Link.swift`), so a token in+        // a title is a live occurrence the walker holds — it is simply never emitted, and+        // an unclaimed one shadows the real badge exactly as a destination's used to.+        // Defensive: a parsed document reaches the walker via `paragraph.format()`, which+        // prints an image title but drops a link one, so only a directly built source+        // like this one carries it.+        let source = "[link](http://x \"t [^1]\") choose [^1] after"+        let runs = runs(for: .paragraph(markdown: source), footnotes: footnoteData(["1"]))+        let spans = runs.compactMap { sourceSpan($0, in: source) }+        #expect(spans == ["link", " choose ", " after"])+        #expect(runs.last?.sourceStart == (source as NSString).range(of: " after").location)+    }++    @Test("A reference in an image TITLE does not steal a later badge's occurrence")+    func imageTitleReferenceDoesNotStealLaterOccurrence() {+        // `Image.title` is exposed too; the image renders no run at all, so the whole+        // burden of accounting for its occurrence falls on the claim.+        let source = "![a](x.png \"t [^1]\") choose [^1] after"+        let runs = runs(for: .paragraph(markdown: source), footnotes: footnoteData(["1"]))+        let spans = runs.compactMap { sourceSpan($0, in: source) }+        #expect(spans == [" choose ", " after"])+        #expect(runs.first?.sourceStart == (source as NSString).range(of: " choose ").location)+    }++    @Test("An autolink's destination is its own link text and is claimed only once")+    func autolinkDestinationIsNotDoubleClaimed() {+        // `<http://x/[^1]>` parses to a Link whose destination IS its Text child, so the+        // one source occurrence is reachable by two paths. The text descent already steps+        // the cursor over it; a destination claim keyed on identifier alone would then+        // floor PAST it onto the live occurrence at " [^1] " and consume a real badge's+        // slot, leaving both prose runs zero-length. Positional correspondence is what+        // rules that out: the destination's characters sit behind the cursor.+        let source = "<http://x/[^1]> choose [^1] after"+        let runs = runs(for: .paragraph(markdown: source), footnotes: footnoteData(["1"]))+        let spans = runs.compactMap { sourceSpan($0, in: source) }+        #expect(spans == ["http://x/[^1]", " choose ", " after"])+        #expect(runs.last?.sourceStart == (source as NSString).range(of: " after").location)+    }++    @Test("A link whose text equals its destination still claims the destination")+    func linkTextEqualToDestinationStillClaimsDestination() {+        // The autolink shape test "destination == the text child's string" is TRUE here+        // too, but this is an ordinary inline link: the destination is a SECOND source+        // span, holding a second occurrence that must be claimed. Only a positional+        // claim tells the two apart — the destination here is ahead of the cursor.+        // `paragraph.format()` condenses this spelling back into the autolink above, so+        // the pair pins the walker's discrimination rather than two production shapes.+        let source = "[http://x/[^1]](http://x/[^1]) choose [^1] after"+        let runs = runs(for: .paragraph(markdown: source), footnotes: footnoteData(["1"]))+        let spans = runs.compactMap { sourceSpan($0, in: source) }+        #expect(spans == ["http://x/[^1]", " choose ", " after"])+        #expect(runs.last?.sourceStart == (source as NSString).range(of: " after").location)+    }++    @Test("A normalised alt does not claim a later attribute's span")+    func normalisedImageAltDoesNotOvershootOntoLaterAttribute() {+        // `Image.plainText` joins its children's plain text, so the alt of+        // `![*a*[^1]](x.png)` is `a[^1]` while the source spells `*a*[^1]`. The attribute+        // cannot locate at its own offset, and the forward search's only match is inside+        // the SECOND image's src — claiming it would step the cursor past " prose " and+        // record that run zero-length. The claim is therefore bounded: a located span is+        // only claimed when it covers the next unclaimed occurrence, so a span that skips+        // one is rejected and nothing is claimed (the safe direction).+        //+        // Green on `main` (nothing claims there, so the cursor cannot overshoot); this+        // pins out a failure mode introduced by this branch's claim, not T-1992 itself.+        let source = "![*a*[^1]](x.png) prose ![b](y/a[^1].png) tail"+        let runs = runs(for: .paragraph(markdown: source), footnotes: footnoteData(["1"]))+        let spans = runs.compactMap { sourceSpan($0, in: source) }+        #expect(spans == [" prose ", " tail"])+        #expect(runs.first?.sourceStart == (source as NSString).range(of: " prose ").location)+    }++    @Test("An attribute holding no reference claims nothing")+    func markerFreeAttributeLeavesLiveOccurrenceIntact() {+        // The inert case: an ordinary image in a document that has footnotes must not move+        // the cursor or consume the live occurrence that follows it.+        let source = "![pic](x.png) choose [^1] after"+        let runs = runs(for: .paragraph(markdown: source), footnotes: footnoteData(["1"]))+        let spans = runs.compactMap { sourceSpan($0, in: source) }+        #expect(spans == [" choose ", " after"])+        #expect(runs.first?.sourceStart == (source as NSString).range(of: " choose ").location)+    }+     @Test("UTF-16 coordinate space: astral chars count as surrogate pairs")     func utf16Coordinates() {         // One astral scalar = 2 UTF-16 units; the run length must reflect that.

diff --git a/prismTests/WebRendering/WebSelectionNoteTests.swift b/prismTests/WebRendering/WebSelectionNoteTests.swiftindex 9ae65b7..e55c310 100644--- a/prismTests/WebRendering/WebSelectionNoteTests.swift+++ b/prismTests/WebRendering/WebSelectionNoteTests.swift@@ -320,6 +320,70 @@ struct WebSelectionNoteTests {         #expect(coordinator.addNoteTextRange?.selectedText == "gamma")     } +    // MARK: - Selections after a NON-TEXT footnote token (T-1992)+    //+    // A `[^id]`-shaped token in an image's alt/src, a link destination, or raw inline+    // HTML is marked live by the pre-pass (nothing knows where it will land until the+    // walker holds it) and then restored to literal text. Unless its occurrence is+    // claimed, the next same-id text-position badge binds to it, and the prose in+    // between is searched with an upper bound that lies BEFORE it — so the prose run+    // comes out zero-length and Add Note over "choose" is declined.++    /// Resolves the whole run at `runIndex` and asserts it quotes `expected`.+    private func expectRunQuotes(+        _ harness: WebDocumentLiveHarness,+        block: MarkdownBlock,+        runIndex: Int,+        source: String,+        expected: String+    ) async throws {+        let resolved = try await resolveWholeRun(+            harness, domID: domID(block), runIndex: runIndex, startOffset: 1+        )+        let start = (resolved?["start"] as? NSNumber)?.intValue ?? -1+        let length = (resolved?["length"] as? NSNumber)?.intValue ?? -1+        #expect(start == (source as NSString).range(of: expected).location)+        #expect(length == (expected as NSString).length)++        let session = DocumentSession(clipboardContent: "x")+        session.parsedBlocks = [block]+        let coordinator = DocumentLayoutCoordinator()+        let router = WebDocumentMessageRouter(+            session: session, coordinator: coordinator,+            notesManager: NotesManager.makeForTesting(store: MockNotesStore())+        )+        router.createSelectionNote(+            blockID: domID(block), range: .init(start: start, length: length)+        )+        #expect(coordinator.addNoteTextRange?.selectedText == expected)+    }++    @Test("A live selection before a badge whose id also appears in an image alt resolves")+    func liveSelectionAfterImageAltLookAlikeResolvesSelectedText() async throws {+        let source = "![[^1]](x.png) choose [^1] after"+        let para = MarkdownBlock.paragraph(markdown: source)+        let harness = try await WebDocumentLiveHarness.make(+            blocks: [para], footnotes: footnoteData(["1"]), featureScripts: Self.notesScripts+        )+        // Run 0 is " choose " (the image contributes no run); offset 1 selects "choose ".+        try await expectRunQuotes(+            harness, block: para, runIndex: 0, source: source, expected: "choose "+        )+    }++    @Test("A live selection before a badge whose id also appears in a link destination resolves")+    func liveSelectionAfterLinkDestinationLookAlikeResolvesSelectedText() async throws {+        let source = "[link](http://x/[^1]) choose [^1] after"+        let para = MarkdownBlock.paragraph(markdown: source)+        let harness = try await WebDocumentLiveHarness.make(+            blocks: [para], footnotes: footnoteData(["1"]), featureScripts: Self.notesScripts+        )+        // Run 0 is the link caption, run 1 is " choose ".+        try await expectRunQuotes(+            harness, block: para, runIndex: 1, source: source, expected: "choose "+        )+    }+     @Test("A cross-block selection is reported as declined (crossBlock), not a range")     func liveCrossBlockDeclined() async throws {         let first = MarkdownBlock.paragraph(markdown: "first block")

diff --git a/CLAUDE.md b/CLAUDE.mdindex a054e97..e4830ec 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -63,7 +63,7 @@ Implementation history and gotchas (the `<script>` data-island CSP trap, the nat 2. `MarkdownBlockParser.parseWithFootnotes()` integrates the preprocessor into the parsing pipeline; `parseFragment()` renders footnote content in popovers without the full pipeline 3. `DocumentSession` stores `FootnoteData` alongside parsed blocks; both are bundled in `ParseResult` 4. Badge substitution happens inside `InlineHTMLRenderer.render`, NOT by splitting the source in the emitter (T-1716/T-1945). `FootnoteReferenceScanner.scan` walks the block's inline SOURCE once and marks every occurrence that is spelled verbatim (no backslash escape anywhere in the token) and resolvable, rewriting only its identifier characters into a reserved Private Use Area window. The marker is length-preserving (runs come out in block coordinates — no rebasing, `rebased` is gone) and parse-shape-preserving (`[`, `^`, `]` untouched, so cmark builds the same tree). The whole marked source is then parsed ONCE-5. `InlineHTMLRenderer.Walker` turns a marker into a badge only where a badge is legal: TEXT position **and** not nested inside an element that cannot contain an anchor. Text position alone is not sufficient — the badge is itself an `<a>`, so a `Link` ancestor disqualifies it (`<a>` inside `<a>` is invalid HTML), tracked by the walker's `linkDepth` counter. Every other landing place — a code span, a link destination, an image `src`/`alt`, raw inline HTML, or text inside a link — is restored to the literal `[^id]` the author wrote. Classification is never inferred from parsed text, which is the failure class the redesign removes. `BlockHTMLEmitter.footnoteBadge` builds the styled pill-badge anchor (`prism://footnote/{id}`, display number from `FootnoteData`) carrying `data-prism-chrome`: inert, unselectable, covered by no source-map run+5. `InlineHTMLRenderer.Walker` turns a marker into a badge only where a badge is legal: TEXT position **and** not nested inside an element that cannot contain an anchor. Text position alone is not sufficient — the badge is itself an `<a>`, so a `Link` ancestor disqualifies it (`<a>` inside `<a>` is invalid HTML), tracked by the walker's `linkDepth` counter. Every other landing place — a code span, a link's destination or title, an image `src`/`alt`/title, raw inline HTML, or text inside a link — is restored to the literal `[^id]` the author wrote (titles excepted: the emitter renders no `title` attribute, so there is nothing to restore). Classification is never inferred from parsed text, which is the failure class the redesign removes. Restoring is only half of it: a landing place that declines the badge must also CLAIM the occurrence and step the cursor past it (`consumingVisibleText`/`claimOccurrences`, used by `visitImage` alt-then-src-then-title, `visitInlineHTML`, and `visitLink` for destination-then-title *after* the descent). Text position claims implicitly, because `appendVisible` locates the text and moves the cursor; the non-text paths render no run, so they must claim explicitly or a later live reference with the same identifier binds to the attribute's occurrence — zero-length source-map run for the prose before the real badge, wrong offset in `badgeSourceStarts` (T-1992). The claim is POSITIONAL, never keyed on the identifier: `claimOccurrences` locates the attribute text in the source at or after the cursor and claims exactly the occurrences inside that span. It is sound only while the attribute's own span sits AHEAD of the cursor, and exactly one shape breaks that — an autolink (`<http://x/[^1]>`), whose destination IS its own `Text` child, so the descent has already stepped the cursor over those characters. `visitLink` filters it out before the claim (`consumedAsAutolinkBody`, keyed on the source's angle brackets: `Link.isAutolink` is derived from `destination == the single Text child's string` and so is equally true of `[url](url)`, whose destination is a second span that MUST be claimed; and `<…>` is the whole set, because swift-markdown attaches only the `table`/`strikethrough`/`tasklist` GFM extensions, never `autolink`). Failing to locate claims nothing, a bounded precision loss for an attribute cmark hands back normalised rather than verbatim (`Image.plainText` joins its children's plain text, so `InlineContainer` markup — emphasis, strong, strikethrough, link — is flattened out of an alt; a code span is NOT, because `InlineCode.plainText` returns the code *with* its backticks and so still matches the source; destinations are entity-decoded). Because the search runs FORWARD, a normalised attribute can also match a *later* span, so a located span is only claimed when it CONTAINS the next unclaimed occurrence — an occurrence still owed that lies before the span proves the span is not the attribute's own, and the claim is refused rather than stepping the cursor over prose that has not been rendered yet. That covering constraint is also why the autolink needs its own filter and cannot be caught here: its occurrence is behind the cursor and gets floored away, leaving the constraint anchored on a later occurrence that the spurious span covers exactly. Only the IMAGE title claim is production-reachable: `MarkdownBlockParser.convertParagraph` rebuilds the block source with `paragraph.format()`, and swift-markdown's `MarkupFormatter` prints an image title but drops a link title (and collapses `[url](url)` back to an autolink), so the link-title claim is defensive against a future non-`format()` source. `BlockHTMLEmitter.footnoteBadge` builds the styled pill-badge anchor (`prism://footnote/{id}`, display number from `FootnoteData`) carrying `data-prism-chrome`: inert, unselectable, covered by no source-map run 6. Badge taps produce `prism://footnote/{id}` links → `linkActivated` over the bridge → `WebDocumentMessageRouter` → `DocumentLayoutCoordinator` popover state (`PrismLinkRoute.footnotePrefix`) 7. `FootnotePopoverView` displays rendered footnote content (paragraphs, lists, blockquotes only) over a shared, non-persistent `FootnotePopoverWebPage` (emitter-rendered fragment). Since the WebKit cutover it is presented as a sheet on every platform via the shared `FootnotePresenter` modifier (`View.footnotePresentation(coordinator:session:)`), which **both** `CompactDocumentLayout` and `RegularDocumentLayout` must apply — the regular layout lacking it is T-1893. The web-rendered badge has no SwiftUI anchor view, so the anchored popover the original footnotes spec called for (Req 3.1/3.6/3.7) no longer applies; `FootnotePopoverView` self-sizes per platform. The popover page is bridge-less, so everything the document surface receives over the bridge must instead be BAKED into the emitted HTML via `RenderSettings`. Baked today: the palette — theme key **and** Increase Contrast state, carried as one `WebPaletteFeed` so they can never be applied out of step (T-1542/T-1829), emitted as `data-prism-theme`/`data-prism-contrast` by `BlockHTMLEmitter.paletteAttributes`; and the typography custom properties (T-1978, emitted as a validated `<html style>` by `BlockHTMLEmitter.rootStyleAttribute`). Not baked: the mermaid theme config and the note/search/section state, none of which a footnote fragment can contain. `FootnotePopoverView.renderSettings(settings:colorScheme:contrast:dynamicTypeSize:)` is the single pure builder of that render input — it reuses `WebDocumentControllerFactory.typographyVariables` rather than resolving fonts again (font-settings Decision 18), and its equatable result is one half of the re-present key. Because a bake can only be applied by re-emitting, an OPEN popover stays current only by re-presenting: `FootnotePopoverWebPage.RenderKey` (footnote id + the resolved `FootnoteDefinition` + that `RenderSettings`) is the equatable trigger, and `FootnotePopoverView` drives it with one `.onChange(of: renderKey, initial: true)` — evaluated in `body`, which is what registers the `AppSettings` reads with Observation (reading them only inside `onAppear` registered nothing). `present` no-ops on an unchanged key (an identical re-emit would blank the live page mid-read) and `renderGeneration` guards overlapping loads so a superseded one cannot win; it also varies the document URL's `rev`. Keying on `footnoteId` alone was T-1979: the identifier is the one input that does not move when the theme, contrast, typography, comment visibility, or a same-id definition does 8. `FootnoteStripping` removes `[^id]` references from heading text used in ToC entries, anchor IDs, and window titles

diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 45fa2fc..6b2770e 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 +- Adding a note to text in a paragraph that also mentions a footnote reference inside an image, a link address, an image tooltip, or raw HTML now works (T-1992). In a paragraph like `![[^1]](cat.png) choose [^1] after` — or the same with the reference written inside a link address such as `[link](http://example.com/[^1])`, inside an image's tooltip text such as `![cat](cat.png "see [^1]")`, or inside raw HTML — the badge still appeared in the right place, but the app matched it to the reference-shaped text inside the image, address or tooltip rather than the real one. Selecting the words in between and choosing **Add Note** was then declined, or saved a note quoting the wrong text and pointing at the image or link syntax, which the note carried into relocation and inline-note export. Stepping search onto such a footnote could also mark the wrong badge. Text that merely looks like a reference in those positions is now accounted for, so the words either side of a badge map to what you actually selected. This is separate from the earlier fix for selecting after a badge (T-1876); footnotes inside list items and table cells are still tracked separately. - Footnote popovers now use the same text settings as the document (T-1978). A footnote's content ignored the **Body Font** you chose, the in-app **Text Size** slider, and the system text size (iOS Larger Text / macOS Text Size), always rendering in the system font at the default reading size — so footnote text could be noticeably smaller than the document it belongs to, and at accessibility text sizes it stayed small while everything around it grew. Footnote content now follows the same font, scale, and system text size as document text. A font that is no longer installed still falls back to the system font, and a font name is applied as text only, so it cannot alter the popover's styling. The system **Increase Contrast** setting had been missed in the same way and now reaches popovers too, though the only footnote content that looks different for it today is an HTML comment shown inline, which kept the standard low-contrast grey. A popover already open when you change these settings updates in place, as of the fix below (T-1979). - An open footnote popover now keeps up with the document instead of freezing at the moment it opened (T-1979). Switching to dark mode, turning **Increase Contrast** on, changing the **Body Font**, moving the **Text Size** slider, changing the system text size, or toggling **Show HTML comments** all left a popover that was already on screen showing the settings it opened with — and if the file changed on disk (or a URL document was refreshed) while the popover was open, the "Footnote N" heading could update to the new document while the footnote text below it still showed the old definition. The popover now re-renders whenever anything it displays changes, including replaced footnote content under the same reference, and leaves itself alone when nothing did, so reading is not interrupted by needless redraws. Changes arriving in quick succession settle on the newest one rather than whichever finished last. - Search and reading-position restore no longer lose their place to content the document hides (T-1944). Three faults shared one cause: hidden content — the body of a collapsed section, or the carrier holding a document's YAML frontmatter — measures as a zero-size box sitting exactly at the top of the window, and several parts of the app read that as "visible". Stepping to a search match inside a collapsed section silently did nothing: the section expanded, but the app had already treated the invisible match as on screen and skipped the scroll; the match is now brought to its usual resting place a third of the way down the window as soon as the section opens. Reopening a document after collapsing the section you were reading left the page at the top instead of anywhere near your place; the restore now lands on the collapsed heading that hides the saved block — and a stale saved position pointing at the hidden frontmatter carrier now falls back to the top of the document instead of doing nothing. Hidden matches also no longer count as on-screen when deciding which highlights to draw, and expanding a section lights its highlights up immediately instead of waiting for the next scroll. The zero-size test now lives in one shared check used by every reader of section layout, so a future feature cannot quietly reintroduce the assumption. Matches inside nested collapsed disclosure blocks (`<details>`) are tracked separately (T-1930).