Pre-push review: T-1929 note navigation

diff --git a/prism/Models/MarkdownSection.swift b/prism/Models/MarkdownSection.swiftindex bf73e69d..4a3d96aa 100644--- a/prism/Models/MarkdownSection.swift+++ b/prism/Models/MarkdownSection.swift@@ -190,6 +190,41 @@ extension DocumentStructure {         return found     } +    /// Returns the source index of the specific occurrence of `blockId` whose+    /// heading path equals `headingPath`, disambiguating duplicate-content+    /// blocks that live under different headings (T-1929).+    ///+    /// Returns nil when `headingPath` is nil (legacy notes carry no heading+    /// path to disambiguate with) or when no occurrence's heading path+    /// matches — the block has since been relocated out from under that+    /// heading, so the caller falls back to first-occurrence behaviour.+    ///+    /// Known limitation, stated plainly: heading-path identity CANNOT+    /// distinguish two occurrences of the same content under the SAME heading+    /// path (the identical paragraph pasted twice directly under one `##`).+    /// Both occurrences match equally, so the earliest in document order — the+    /// lowest source index — is chosen deliberately. The choice is arbitrary+    /// but it must be DEFINED: `headingPathByBlockId` is a `Dictionary`, whose+    /// iteration order is unspecified and varies with Swift's per-process hash+    /// seed, so returning the first match encountered made a note navigate to+    /// a different occurrence from one launch to the next. Telling those+    /// occurrences apart needs an identity this index does not carry; that is+    /// the occurrence-identity cluster (T-2045, T-2084–T-2088), not this+    /// lookup.+    func sourceIndex(forBlockId blockId: String, headingPath: [String]?) -> Int? {+        guard let headingPath else { return nil }+        let prefix = "\(blockId)-"+        var earliest: Int?+        for (key, path) in headingPathByBlockId+        where path == headingPath && key.hasPrefix(prefix) {+            guard let sourceIndex = Int(key.dropFirst(prefix.count)) else { continue }+            if sourceIndex < (earliest ?? Int.max) {+                earliest = sourceIndex+            }+        }+        return earliest+    }+     /// Returns all heading paths for blocks with the given ID.     ///     /// Used by `RelocationEngine` to check if a note's stored heading path

diff --git a/prism/Services/WebRendering/BlockDOMID.swift b/prism/Services/WebRendering/BlockDOMID.swiftindex edc0540c..1ed3cd36 100644--- a/prism/Services/WebRendering/BlockDOMID.swift+++ b/prism/Services/WebRendering/BlockDOMID.swift@@ -121,6 +121,37 @@ nonisolated enum BlockDOMID {         )     } +    /// Resolves a note's stored `(blockId, headingPath)` to an occurrence-aware+    /// navigation target, disambiguating duplicate-content blocks that live+    /// under different headings (T-1929). Feed the result to+    /// `navigationDOMID(forTarget:...)` exactly as a bare block id was fed+    /// before this existed.+    ///+    /// `blockId` may carry a sub-block suffix (`-row-N`, `-row-header`,+    /// `-item-N`); the suffix is stripped before building the composite+    /// target, since navigation always resolves a sub-block id to its+    /// PARENT block's DOM id — table rows and list items are not+    /// independently scrollable sections.+    ///+    /// Falls back to the bare `blockId` unchanged — leaving+    /// `navigationDOMID` to pick the first (or first-visible) occurrence,+    /// the pre-fix behaviour — when `headingPath` is nil (legacy notes+    /// carry no heading path to disambiguate with) or when no occurrence's+    /// heading path matches (the block was relocated since the note was+    /// anchored, `DocumentStructure.sourceIndex(forBlockId:headingPath:)`+    /// has nothing to verify against).+    static func noteNavigationTarget(+        blockId: String,+        headingPath: [String]?,+        structure: DocumentStructure+    ) -> String {+        guard let sourceIndex = structure.sourceIndex(forBlockId: blockId, headingPath: headingPath) else {+            return blockId+        }+        let parentBlockId = strippingSubBlockSuffix(blockId)+        return "\(parentBlockId)-\(sourceIndex)"+    }+     /// Strips a trailing sub-block suffix (`-row-N`, `-row-header`, `-item-N`,     /// nested `-item-N-item-M`) from a note-anchor id, yielding the parent     /// block's content hash. Returns the input unchanged when no suffix matches

diff --git a/prism/Views/NotesPanel.swift b/prism/Views/NotesPanel.swiftindex 3729dce6..6138024c 100644--- a/prism/Views/NotesPanel.swift+++ b/prism/Views/NotesPanel.swift@@ -352,7 +352,11 @@ struct NotesPanel: View {                         .contentShape(Rectangle())                         .onTapGesture {                             onDismiss()-                            onNavigate(note.blockId)+                            onNavigate(BlockDOMID.noteNavigationTarget(+                                blockId: note.blockId,+                                headingPath: note.headingPath,+                                structure: structure+                            ))                         }                         .noteActions(for: note, using: notesManager, onEdit: { editingNote = note })                 }@@ -413,7 +417,11 @@ struct NotesPanel: View {                                         // Navigate unconditionally — if the block no longer                                         // exists, the scroll handler safely no-ops.                                         onDismiss()-                                        onNavigate(note.blockId)+                                        onNavigate(BlockDOMID.noteNavigationTarget(+                                            blockId: note.blockId,+                                            headingPath: note.headingPath,+                                            structure: structure+                                        ))                                     }                                     .noteActions(for: note, using: notesManager, onEdit: { editingNote = note })                             }

diff --git a/prism/Views/SidebarNotesView.swift b/prism/Views/SidebarNotesView.swiftindex 402d2e10..42e05041 100644--- a/prism/Views/SidebarNotesView.swift+++ b/prism/Views/SidebarNotesView.swift@@ -209,7 +209,11 @@ struct SidebarNotesView: View {                             .listRowInsets(EdgeInsets(top: 4, leading: 8, bottom: 4, trailing: 8))                             .contentShape(Rectangle())                             .onTapGesture {-                                onNavigate(note.blockId)+                                onNavigate(BlockDOMID.noteNavigationTarget(+                                    blockId: note.blockId,+                                    headingPath: note.headingPath,+                                    structure: structure+                                ))                             }                             .noteActions(for: note, using: notesManager, onEdit: { editingNote = note })                             .accessibilityHint(LocalizedStringKey("Navigate to this note in the document"))

diff --git a/prismTests/BlockDOMIDNoteNavigationTests.swift b/prismTests/BlockDOMIDNoteNavigationTests.swiftnew file mode 100644index 00000000..ce316c92--- /dev/null+++ b/prismTests/BlockDOMIDNoteNavigationTests.swift@@ -0,0 +1,153 @@+//+//  BlockDOMIDNoteNavigationTests.swift+//  prismTests+//+//  Regression coverage for T-1929: note navigation from NotesPanel and+//  SidebarNotesView must resolve to the SPECIFIC occurrence a note's stored+//  headingPath identifies, not always the first occurrence of duplicate+//  content. Before the fix, `BlockDOMID.navigationDOMID` received a bare+//  content hash and always resolved via `firstOccurrenceDOMID`, so tapping a+//  note on a later duplicate scrolled to the first one instead.+//++import Foundation+import Testing+@testable import prism++@Suite("BlockDOMID.noteNavigationTarget (T-1929)")+struct BlockDOMIDNoteNavigationTests {++    @Test("A note on the second occurrence of duplicate content resolves to that occurrence, not the first")+    func resolvesSecondOccurrence() throws {+        let para = MarkdownBlock.paragraph(markdown: "Duplicate content")+        let blocks: [MarkdownBlock] = [+            .heading(level: 1, text: "Section A"),+            para,+            .heading(level: 1, text: "Section B"),+            para+        ]+        let structure = MarkdownSectionBuilder.build(from: blocks)++        let target = BlockDOMID.noteNavigationTarget(+            blockId: para.id,+            headingPath: ["Section B"],+            structure: structure+        )+        #expect(target == "\(para.id)-3")++        let mapping = BlockDOMID.map(blocks: blocks)+        let resolved = BlockDOMID.navigationDOMID(forTarget: target, blocks: blocks)+        #expect(resolved == mapping[3].domID, "must land on the second occurrence's DOM id")+        #expect(resolved != mapping[1].domID, "must not land on the first occurrence")+    }++    @Test("A note on the first occurrence of duplicate content resolves to that occurrence")+    func resolvesFirstOccurrence() throws {+        let para = MarkdownBlock.paragraph(markdown: "Duplicate content")+        let blocks: [MarkdownBlock] = [+            .heading(level: 1, text: "Section A"),+            para,+            .heading(level: 1, text: "Section B"),+            para+        ]+        let structure = MarkdownSectionBuilder.build(from: blocks)++        let target = BlockDOMID.noteNavigationTarget(+            blockId: para.id,+            headingPath: ["Section A"],+            structure: structure+        )+        #expect(target == "\(para.id)-1")++        let mapping = BlockDOMID.map(blocks: blocks)+        let resolved = BlockDOMID.navigationDOMID(forTarget: target, blocks: blocks)+        #expect(resolved == mapping[1].domID)+    }++    @Test("A legacy note with no headingPath falls back to the bare block id")+    func legacyNoteFallsBackToBareBlockId() {+        let para = MarkdownBlock.paragraph(markdown: "Some content")+        let blocks: [MarkdownBlock] = [para]+        let structure = MarkdownSectionBuilder.build(from: blocks)++        let target = BlockDOMID.noteNavigationTarget(+            blockId: para.id,+            headingPath: nil,+            structure: structure+        )+        #expect(target == para.id)+    }++    @Test("A stale headingPath that matches no current occurrence falls back to the bare block id")+    func staleHeadingPathFallsBack() {+        let para = MarkdownBlock.paragraph(markdown: "Some content")+        let blocks: [MarkdownBlock] = [+            .heading(level: 1, text: "Section A"),+            para+        ]+        let structure = MarkdownSectionBuilder.build(from: blocks)++        let target = BlockDOMID.noteNavigationTarget(+            blockId: para.id,+            headingPath: ["No Longer There"],+            structure: structure+        )+        #expect(target == para.id)+    }++    @Test("A table-row note anchor resolves to its parent block's specific occurrence")+    func tableRowNoteResolvesParentOccurrence() throws {+        let table = MarkdownBlock.table(+            headers: ["A", "B"],+            rows: [["1", "2"]],+            alignments: [.leading, .leading]+        )+        let blocks: [MarkdownBlock] = [+            .heading(level: 1, text: "Section A"),+            table,+            .heading(level: 1, text: "Section B"),+            table+        ]+        let structure = MarkdownSectionBuilder.build(from: blocks)++        let rowId = "\(table.id)-row-0"+        let target = BlockDOMID.noteNavigationTarget(+            blockId: rowId,+            headingPath: ["Section B"],+            structure: structure+        )+        // The suffix is stripped: rows aren't independently scrollable, so+        // the target is the PARENT table's composite id at its own occurrence.+        #expect(target == "\(table.id)-3")++        let mapping = BlockDOMID.map(blocks: blocks)+        let resolved = BlockDOMID.navigationDOMID(forTarget: target, blocks: blocks)+        #expect(resolved == mapping[3].domID)+    }++    @Test("A list-item note anchor resolves to its parent block's specific occurrence")+    func listItemNoteResolvesParentOccurrence() throws {+        let list = MarkdownBlock.list(ordered: false, start: 1, items: [+            ListItem(content: "Duplicate item", checkbox: nil)+        ])+        let blocks: [MarkdownBlock] = [+            .heading(level: 1, text: "Section A"),+            list,+            .heading(level: 1, text: "Section B"),+            list+        ]+        let structure = MarkdownSectionBuilder.build(from: blocks)++        let itemId = list.listItemId(at: 0)!+        let target = BlockDOMID.noteNavigationTarget(+            blockId: itemId,+            headingPath: ["Section B"],+            structure: structure+        )+        #expect(target == "\(list.id)-3")++        let mapping = BlockDOMID.map(blocks: blocks)+        let resolved = BlockDOMID.navigationDOMID(forTarget: target, blocks: blocks)+        #expect(resolved == mapping[3].domID)+    }+}

diff --git a/prismTests/MarkdownSectionBuilderTests.swift b/prismTests/MarkdownSectionBuilderTests.swiftindex 0125b765..ab318e20 100644--- a/prismTests/MarkdownSectionBuilderTests.swift+++ b/prismTests/MarkdownSectionBuilderTests.swift@@ -954,6 +954,89 @@ struct HeadingPathIndexTests {         let structure = MarkdownSectionBuilder.build(from: blocks)         #expect(structure.headingPath(forBlockId: "nonexistent-id-1234") == nil)     }++    // MARK: - sourceIndex(forBlockId:headingPath:) (T-1929)++    @Test("sourceIndex finds the occurrence whose heading path matches, among duplicates")+    func sourceIndexFindsMatchingOccurrence() {+        let para = MarkdownBlock.paragraph(markdown: "Duplicate content")+        let blocks: [MarkdownBlock] = [+            .heading(level: 1, text: "Section A"),+            para,+            .heading(level: 1, text: "Section B"),+            para+        ]+        let structure = MarkdownSectionBuilder.build(from: blocks)++        #expect(structure.sourceIndex(forBlockId: para.id, headingPath: ["Section A"]) == 1)+        #expect(structure.sourceIndex(forBlockId: para.id, headingPath: ["Section B"]) == 3)+    }++    @Test("sourceIndex returns nil when headingPath is nil")+    func sourceIndexReturnsNilForNilHeadingPath() {+        let para = MarkdownBlock.paragraph(markdown: "Body")+        let blocks: [MarkdownBlock] = [.heading(level: 1, text: "Section"), para]+        let structure = MarkdownSectionBuilder.build(from: blocks)++        #expect(structure.sourceIndex(forBlockId: para.id, headingPath: nil) == nil)+    }++    @Test("sourceIndex picks the first occurrence in document order among same-heading duplicates")+    func sourceIndexPicksFirstOccurrenceUnderSameHeading() {+        // Heading-path identity cannot tell these two apart — both live under+        // ["Section"], so both are equally valid matches. The lookup must pick+        // the earliest in document order rather than whichever Dictionary entry+        // happens to enumerate first, or the same note navigates somewhere+        // different from one launch to the next (per-process hash seeding).+        let para = MarkdownBlock.paragraph(markdown: "Duplicate content")+        let blocks: [MarkdownBlock] = [+            .heading(level: 1, text: "Section"),+            para,+            .paragraph(markdown: "Separator"),+            para+        ]+        let structure = MarkdownSectionBuilder.build(from: blocks)++        #expect(structure.sourceIndex(forBlockId: para.id, headingPath: ["Section"]) == 1)++        // Rebuilding must not change the answer: the result is a property of+        // document order, not of dictionary iteration order.+        for _ in 0..<8 {+            let rebuilt = MarkdownSectionBuilder.build(from: blocks)+            #expect(rebuilt.sourceIndex(forBlockId: para.id, headingPath: ["Section"]) == 1)+        }+    }++    @Test("noteNavigationTarget is deterministic for same-heading duplicates")+    func noteNavigationTargetDeterministicUnderSameHeading() {+        let para = MarkdownBlock.paragraph(markdown: "Duplicate content")+        let blocks: [MarkdownBlock] = [+            .heading(level: 1, text: "Section"),+            para,+            .paragraph(markdown: "Separator"),+            para+        ]+        let structure = MarkdownSectionBuilder.build(from: blocks)++        let target = BlockDOMID.noteNavigationTarget(+            blockId: para.id,+            headingPath: ["Section"],+            structure: structure+        )+        #expect(target == "\(para.id)-1")++        let mapping = BlockDOMID.map(blocks: blocks)+        #expect(BlockDOMID.navigationDOMID(forTarget: target, blocks: blocks) == mapping[1].domID)+    }++    @Test("sourceIndex returns nil when no occurrence's heading path matches")+    func sourceIndexReturnsNilForNonMatchingHeadingPath() {+        let para = MarkdownBlock.paragraph(markdown: "Body")+        let blocks: [MarkdownBlock] = [.heading(level: 1, text: "Section"), para]+        let structure = MarkdownSectionBuilder.build(from: blocks)++        #expect(structure.sourceIndex(forBlockId: para.id, headingPath: ["Elsewhere"]) == nil)+    } }  private struct SectionSeededRNG: RandomNumberGenerator {

diff --git a/CHANGELOG.md b/CHANGELOG.mdindex f75bfbce..4d1c62ae 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -25,6 +25,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0  ### Fixed +- Tapping a note in the compact Notes panel or the regular Notes sidebar now scrolls to the block that note is actually anchored to, instead of always the first occurrence of identical content elsewhere in the document (T-1929). Both note UIs navigated by passing the note's bare content-hash block id, which `BlockDOMID` resolves to its first (or first-visible) occurrence by design — the note's own stored heading path, already recorded for note storage/display disambiguation (T-209), was never consulted. Navigation now resolves the note's specific occurrence against that heading path and builds the same verified composite target TOC/search/scroll-restore already use, falling back to the previous first-occurrence behaviour only when a note carries no heading path (legacy notes) or its heading path no longer matches any occurrence (the block was relocated). A table-row or list-item note anchor resolves to its parent block's correct occurrence, since rows and items are not independently scrollable. - `HTMLImageSourceRewriter` no longer re-emits a mediated `src`/`srcset` value with an embedded quote character left unescaped (T-1942). The rewriter always re-emits these attributes double-quoted, but a value could still contain a raw `"`: the `rewrite` closure's `data:` passthrough hands unencoded `data:` URIs back unchanged, and `rewriteSrcset` re-joins a candidate's descriptor half — never passed through `rewrite` — verbatim. Either one could terminate the re-emitted attribute early, splicing the remainder into attribute position (e.g. `srcset='a.png 1x" onerror=… z='`). The value is now escaped for its double-quoted context before being written, so any quote characters it carries round-trip intact instead of breaking out. The escape leaves a character reference the value already carries alone (the `data:` passthrough re-emits the attribute's text as written, references undecoded, and the browser decodes it once), so an SVG `data:` URI whose author correctly wrote `&` for a literal ampersand still renders that ampersand rather than the reference. This is defence in depth rather than a live exploit: the subsequent `HTMLSanitizer` (SwiftSoup) pass is the actual security boundary and already reduced the broken-out remainder to non-allowlisted junk. - A document opened from a URL that redirects now resolves its relative images and links against the address the content was actually served from, not the one you typed (T-1810). A version alias, a shortened link or a page that has moved to another folder or host sends the request on to its final address, and the app kept the original one as the base for everything relative in the document, so every image beside it was looked up in the wrong place and showed the error placeholder. The address shown in the title, in recents and in the notes store is unchanged: it stays the one you opened. Refreshing such a document asks for the address you opened again — not for wherever it redirected to last time — and follows the redirect afresh, so an alias that has been re-pointed since the document was opened picks up its new target, and the image base moves with it; the refresh costs one page reload, not one for the new content and another for the new base. - SVG diagrams that adapt to light/dark mode via CSS `@media (prefers-color-scheme: dark)` now rasterize using the appearance Prism actually asked for, instead of whatever the offscreen render window (macOS) or app (iOS) happened to be reporting at the time (T-1896). `SVGRenderer` accepted a `colorScheme` parameter but never used it past the cache key, so a light-appearance SVG could render with its dark-mode colors — or vice versa — while being cached under the *other* scheme's key, compounding the mismatch on the next lookup. The renderer now forces its WebView's own appearance (`overrideUserInterfaceStyle` on iOS, `NSAppearance` on macOS) to match the requested scheme before every render, not only when the WebView is first created — the pool reuses WebViews across calls that can request a different scheme each time.

diff --git a/specs/bugfixes/note-nav-duplicate-block/report.md b/specs/bugfixes/note-nav-duplicate-block/report.mdnew file mode 100644index 00000000..c159e755--- /dev/null+++ b/specs/bugfixes/note-nav-duplicate-block/report.md@@ -0,0 +1,221 @@+# Bugfix Report: Note navigation targets the wrong duplicate-content block++**Date:** 2026-09-06+**Status:** Fixed++## Description of the Issue++Tapping a note in the compact Notes panel (`NotesPanel`) or the regular+Notes sidebar (`SidebarNotesView`) scrolled the document to the FIRST+occurrence of the note's block content, even when the note was created on a+later occurrence of identical content appearing under a different heading.++**Reproduction steps:**+1. Create two identical paragraphs (or tables/lists) under different headings.+2. Add a note to the second occurrence.+3. Select that note in the compact Notes panel or regular Notes sidebar.++**Actual:** the document scrolls to the first visible occurrence of the+identical content.++**Expected:** it scrolls to the occurrence the note was actually anchored+to (identified by its stored heading path).++**Impact:** Any document with duplicate-content blocks (a common pattern in+templated or repetitive markdown, e.g. repeated table skeletons or+boilerplate paragraphs under multiple headings) sends the user to the wrong+place when navigating from a note anchored to anything but the first such+occurrence.++## Investigation Summary++- **Symptoms examined:** `NotesPanel.swift:355` and `SidebarNotesView.swift:212`+  call `onNavigate(note.blockId)`, passing only the note's bare SHA-256+  content-hash block id.+- **Code inspected:** `DocumentLayoutCoordinator.noteNavigationTarget`+  (stores the bare string unchanged), `WebDocumentStateSynchronizer.scrollToTarget`+  (feeds it straight to `BlockDOMID.navigationDOMID`), and+  `BlockDOMID.navigationDOMID`/`firstOccurrenceDOMID` (resolves a bare+  content hash to the first, or first-visible, occurrence -- by design, for+  ids that carry no occurrence information).+- **Hypotheses tested:** whether the resolution bug lived in `BlockDOMID`+  itself -- ruled out: `BlockDOMID` already supports a verified composite+  target format (`{hash}-{sourceIndex}`, used by TOC/search/scroll-restore)+  that resolves to an exact occurrence. The defect is that notes never+  produced one of these; they always produced the ambiguous bare-hash form.+- Confirmed that `BlockNote.headingPath` (added by T-209 to disambiguate+  note *display*/*storage*) was available on every note but never consulted+  by navigation, and that `DocumentStructure.headingPathByBlockId` (keyed+  `"{blockId}-{sourceIndex}"`) already indexes every occurrence, including+  sub-block (row/item) ids under their parent's source index -- everything+  needed to resolve the correct occurrence was already present, just+  unused by the navigation path.++## Discovered Root Cause++**Defect type:** Missing information propagation -- a value (occurrence+identity) that was already computed and stored was discarded before it+reached the one place that needed it.++**Why it occurred:** T-209 added `headingPath` to `BlockNote` to+disambiguate note *storage and display* for duplicate-content blocks, but+the navigation call sites (`onNavigate(note.blockId)`) were never updated+to use it -- they kept passing the bare block id that pre-dates T-209 (and,+per the ticket, pre-dates the WebKit cutover: the retired+`SharedBlockViews.scrollIdForBlock` had the identical bug).++**Contributing factors:** `BlockDOMID.navigationDOMID` silently and+correctly resolves a bare hash to *a* valid occurrence rather than failing,+so the bug produces a plausible-looking (just wrong) scroll target instead+of a visible error -- nothing short-circuited to surface the gap.++## Resolution for the Issue++**Changes made:**+- `prism/Models/MarkdownSection.swift` -- added+  `DocumentStructure.sourceIndex(forBlockId:headingPath:)`, an O(n) reverse+  lookup over `headingPathByBlockId` that finds the specific occurrence of+  `blockId` (including sub-block/row/item ids, which are indexed under+  their parent's source index) whose heading path equals the one supplied.+  Returns `nil` when `headingPath` is `nil` (legacy notes) or no occurrence+  matches (the block was relocated).+- `prism/Services/WebRendering/BlockDOMID.swift` -- added+  `BlockDOMID.noteNavigationTarget(blockId:headingPath:structure:)`, which+  calls the above, strips any sub-block suffix (rows/items resolve to their+  parent block's DOM id -- they are not independently scrollable), and+  builds the verified composite target `"{parentBlockId}-{sourceIndex}"`+  that `navigationDOMID` already knows how to resolve exactly. Falls back+  to the original bare `blockId` -- i.e. the pre-fix, first-occurrence+  behaviour -- when the occurrence can't be determined.+- `prism/Views/NotesPanel.swift` -- both note-tap call sites+  (`activeNotesSection`, `resolvedNotesSection`) now call+  `BlockDOMID.noteNavigationTarget(blockId:headingPath:structure:)` instead+  of passing `note.blockId` directly.+- `prism/Views/SidebarNotesView.swift` -- the grouped-notes tap call site+  does the same.++**Known limitation (deliberate, PR review round 1):** heading-path identity+cannot distinguish two occurrences of the same content under the SAME+heading path -- the identical paragraph pasted twice directly under one+`##`. Both occurrences match the lookup equally. The first review round+found that the lookup returned whichever `Dictionary` entry enumerated+first, which is unspecified and varies with Swift's per-process hash seed,+so the same note could navigate to a different occurrence from one launch+to the next. The lookup now returns the LOWEST matching source index --+first in document order. That choice is arbitrary, but defined, which is+what a navigation target needs. Telling those occurrences apart needs an+identity `headingPathByBlockId` does not carry, and that is the+occurrence-identity cluster (T-2045, T-2084--T-2088), not this fix.++**Approach rationale:** The fix reuses the existing, already-tested+composite-id verification path in `BlockDOMID` (the same mechanism TOC+navigation, search, and scroll restore use) rather than inventing a new+target format or changing `navigationDOMID`'s resolution rules. No call+site signature changed -- `onNavigate: (String) -> Void` still takes a+plain string; the views just compute a more specific string before calling+it.++**Alternatives considered:**+- **Change `BlockDOMID.navigationDOMID` to accept a heading path+  parameter directly** -- rejected: it would need to take on the+  `DocumentStructure` dependency it currently doesn't have, widening its+  surface for every caller (TOC, search, scroll-restore) that doesn't need+  heading-path disambiguation.+- **Resolve the target inside `WebDocumentStateSynchronizer`** -- rejected:+  the synchronizer only sees the string already stored on+  `coordinator.noteNavigationTarget`; resolving there would mean carrying+  the note's `headingPath` through the coordinator as a second piece of+  state kept in sync with the block id, for no benefit over resolving once+  at the tap site where both the note and the `structure` are already in+  scope.++## Regression Test++**Test file:** `prismTests/BlockDOMIDNoteNavigationTests.swift`+**Test names:** `resolvesSecondOccurrence`, `resolvesFirstOccurrence`,+`legacyNoteFallsBackToBareBlockId`, `staleHeadingPathFallsBack`,+`tableRowNoteResolvesParentOccurrence`, `listItemNoteResolvesParentOccurrence`++**What it verifies:** that `BlockDOMID.noteNavigationTarget` resolves a+note anchored to the second of two identical blocks to that second+occurrence's composite id (and the first note to the first occurrence),+that it falls back to the bare block id for legacy notes (`headingPath ==+nil`) and for a stale heading path that matches no current occurrence, and+that table-row/list-item note anchors resolve to their PARENT block's+correct occurrence with the sub-block suffix stripped.++Also added to `prismTests/MarkdownSectionBuilderTests.swift`:+`sourceIndexFindsMatchingOccurrence`, `sourceIndexReturnsNilForNilHeadingPath`,+`sourceIndexReturnsNilForNonMatchingHeadingPath` -- direct coverage of the+new `DocumentStructure.sourceIndex(forBlockId:headingPath:)` lookup -- plus+`sourceIndexPicksFirstOccurrenceUnderSameHeading` and+`noteNavigationTargetDeterministicUnderSameHeading`, which pin the+same-heading duplicate case to the first occurrence in document order so a+future change to the index cannot silently reintroduce a hash-order-dependent+answer.++**Run command:**+```+xcodebuild test -project prism.xcodeproj -scheme prism \+  -destination 'platform=macOS' -configuration Debug \+  -testPlan prism -only-test-configuration "en (base)" \+  -only-testing:prismTests/BlockDOMIDNoteNavigationTests \+  -only-testing:prismTests/MarkdownSectionBuilderTests+```++## Affected Files++| File | Change |+|------|--------|+| `prism/Models/MarkdownSection.swift` | Added `DocumentStructure.sourceIndex(forBlockId:headingPath:)` |+| `prism/Services/WebRendering/BlockDOMID.swift` | Added `BlockDOMID.noteNavigationTarget(blockId:headingPath:structure:)` |+| `prism/Views/NotesPanel.swift` | Both note-tap navigation call sites use the new resolver |+| `prism/Views/SidebarNotesView.swift` | The grouped-notes tap navigation call site uses the new resolver |+| `prismTests/BlockDOMIDNoteNavigationTests.swift` | New regression test file |+| `prismTests/MarkdownSectionBuilderTests.swift` | Added coverage for the new `sourceIndex` lookup |+| `CHANGELOG.md` | Added `[Unreleased] / Fixed` entry |++## Verification++**Automated:**+- [x] Regression tests pass (`BlockDOMIDNoteNavigationTests`, new+      `MarkdownSectionBuilderTests` cases)+- [x] Targeted suite run (`BlockDOMIDNoteNavigationTests`,+      `MarkdownSectionBuilderTests`, `SidebarNotesViewTests`,+      `NotesPanelDocumentNotesTests`) passes: 78/78, confirmed via+      `Tools/check-test-results.sh`+- [x] `make lint` passes+- [x] `make build-macos` passes+- [x] `make verify-test-isolation` passes+- [ ] Full `make test-quick`/`make test` -- not run in this session per+      instruction (concurrent sibling test runs in other worktrees); the+      change is additive (new methods) plus three narrow call-site edits,+      and the affected areas' full suites were run targeted.++**Manual verification:** Not performed in this session (no simulator/app+launch); the fix is covered structurally by the composite-id path shared+with TOC/search/scroll-restore navigation, which is exercised more broadly+elsewhere (e.g. `TOCNavigationDetailsIndexTests`).++## Prevention++**Recommendations to avoid similar bugs:**+- When a model gains disambiguating identity (like T-209's `headingPath`),+  grep every consumer of the ambiguous field it's meant to supplement+  (here, every `.blockId` navigation use) rather than only updating the+  consumers that prompted the addition.+- `BlockDOMID`'s composite-id format is the general mechanism for+  "resolve to a specific occurrence" -- new navigation sources should reach+  for it before inventing bespoke resolution.++## Related++- T-209: introduced `BlockNote.headingPath` for note storage/display+  disambiguation (this fix is the missing navigation half).+- T-300: fixed details/TOC composite IDs (same composite-id mechanism,+  different call site).+- Out of scope (separate open tickets on the same occurrence-identity+  cluster, deliberately not touched): T-2045 (indicators/bubbles ignore+  headingPath), T-2084 (export at every occurrence), T-2085 (grouping+  ignores occurrence scope), T-2086 (inconsistent section metadata), T-2087+  (fuzzy relocation), T-2088 (replies lose occurrence identity).