Pre-push review: mermaid-card-a11y (T-1041)

diff --git a/prism/Views/MermaidPreviewCard.swift b/prism/Views/MermaidPreviewCard.swiftindex aca8ba4..fdb47d8 100644--- a/prism/Views/MermaidPreviewCard.swift+++ b/prism/Views/MermaidPreviewCard.swift@@ -155,6 +155,8 @@ struct MermaidPreviewCard: View {                     .transition(.opacity)             }         }+        .accessibilityAction(named: "Show code") { openDiagram() }+        .accessibilityAction(named: "Copy code") { copyToClipboard() }         #if os(macOS)         .onHover { hovering in             withAnimation(.easeInOut(duration: 0.15)) {@@ -176,6 +178,7 @@ struct MermaidPreviewCard: View {             }             .buttonStyle(.bordered)             .glassEffect(.regular.interactive())+            .accessibilityHint(LocalizedStringKey("Opens the rendered diagram"))              Button {                 copyToClipboard()@@ -185,6 +188,7 @@ struct MermaidPreviewCard: View {             }             .buttonStyle(.bordered)             .glassEffect(.regular.interactive())+            .accessibilityHint(LocalizedStringKey("Copies the diagram source code to clipboard"))         }         .padding(8)     }

diff --git a/prism/Localizable.xcstrings b/prism/Localizable.xcstringsindex 87dd09a..fb7009c 100644--- a/prism/Localizable.xcstrings+++ b/prism/Localizable.xcstrings@@ -3543,6 +3543,29 @@         }       }     },+    "Opens the rendered diagram": {+      "extractionState": "manual",+      "localizations": {+        "en": {+          "stringUnit": {+            "state": "translated",+            "value": "Opens the rendered diagram"+          }+        },+        "en-GB": {+          "stringUnit": {+            "state": "translated",+            "value": "Opens the rendered diagram"+          }+        },+        "en-US": {+          "stringUnit": {+            "state": "translated",+            "value": "Opens the rendered diagram"+          }+        }+      }+    },     "Ordered list with %lld items": {       "extractionState": "manual",       "localizations": {@@ -4969,6 +4992,29 @@         }       }     },+    "Show code": {+      "extractionState": "manual",+      "localizations": {+        "en": {+          "stringUnit": {+            "state": "translated",+            "value": "Show code"+          }+        },+        "en-GB": {+          "stringUnit": {+            "state": "translated",+            "value": "Show code"+          }+        },+        "en-US": {+          "stringUnit": {+            "state": "translated",+            "value": "Show code"+          }+        }+      }+    },     "Show inline notes": {       "extractionState": "manual",       "localizations": {

diff --git a/prismTests/MermaidPreviewCardAccessibilityTests.swift b/prismTests/MermaidPreviewCardAccessibilityTests.swiftnew file mode 100644index 0000000..31314b0--- /dev/null+++ b/prismTests/MermaidPreviewCardAccessibilityTests.swift@@ -0,0 +1,105 @@+//+//  MermaidPreviewCardAccessibilityTests.swift+//  prismTests+//+//  Tests for MermaidPreviewCard accessibility-action coverage (T-1041).+//++import Foundation+import Testing+import SwiftUI+@testable import prism++/// Tests for MermaidPreviewCard accessibility actions and hints.+///+/// `.accessibilityAction(named:)` modifiers attached to the rendered card+/// expose "Show code" and "Copy code" to VoiceOver / Voice Control even when+/// the overlay buttons are hidden (iOS tap-to-reveal, macOS hover-only).+/// `.accessibilityHint` on the visible overlay buttons explains their+/// behaviour while the overlay is on screen.+///+/// SwiftUI does not expose its view tree without ViewInspector (not a project+/// dependency), so the test of the modifier set is a compilation smoke test+/// — `cardConstructionSucceeds` will stop building if the modifier chain+/// stops type-checking. The catalog-key tests use+/// `Bundle.localizedString(forKey:value:table:)` with a sentinel default so+/// they fail if the key is missing from the compiled catalog (unlike+/// `String(localized:)`, which silently returns the key as a fallback).+@Suite("MermaidPreviewCardAccessibility", .serialized)+@MainActor+struct MermaidPreviewCardAccessibilityTests {++    // MARK: - Helpers++    /// Sentinel that cannot collide with any genuine catalog value because it+    /// contains characters and shape no English-language string would use.+    private static let missingKeySentinel = "__catalog_key_missing_sentinel__"++    private func localised(_ key: String) -> String {+        Bundle.main.localizedString(+            forKey: key,+            value: Self.missingKeySentinel,+            table: nil+        )+    }++    // MARK: - View construction (compilation smoke test)++    @Test("Card view constructs with the rendered-state accessibility modifiers in place")+    func cardConstructionSucceeds() {+        let card = MermaidPreviewCard(+            source: "flowchart TD\n    A --> B",+            reduceMotion: false,+            byteOffset: 0,+            documentURL: URL(fileURLWithPath: "/test/doc.md")+        )+        #expect(type(of: card) == MermaidPreviewCard.self)++        // The card declares these modifiers on the ZStack returned by renderedView(_:):+        //   .accessibilityAction(named: "Show code") { openDiagram() }+        //   .accessibilityAction(named: "Copy code") { copyToClipboard() }+        // and inside overlayButtons:+        //   .accessibilityHint(LocalizedStringKey("Opens the rendered diagram"))+        //   .accessibilityHint(LocalizedStringKey("Copies the diagram source code to clipboard"))+        // If any of those modifier sites breaks type-checking, this test stops+        // building. Behavioural verification of the action invocation requires+        // ViewInspector or a manual VoiceOver run.+    }++    // MARK: - Catalog key presence (real assertions)++    @Test("Bundle sentinel mechanic distinguishes missing keys from present ones")+    func sentinelDistinguishesMissingFromPresent() {+        // Control: a key we never put in the catalog returns the sentinel.+        let resolvedMissing = localised("prism.tests.key.that.is.deliberately.absent")+        #expect(resolvedMissing == Self.missingKeySentinel)+    }++    @Test("Show code action name is present in the compiled catalog")+    func showCodeActionNameInCatalog() {+        let resolved = localised("Show code")+        #expect(resolved != Self.missingKeySentinel)+        #expect(resolved == "Show code")+    }++    @Test("Copy code action name is present in the compiled catalog")+    func copyCodeActionNameInCatalog() {+        let resolved = localised("Copy code")+        #expect(resolved != Self.missingKeySentinel)+        #expect(resolved == "Copy code")+    }++    @Test("Opens the rendered diagram hint is present in the compiled catalog")+    func showHintInCatalog() {+        let resolved = localised("Opens the rendered diagram")+        #expect(resolved != Self.missingKeySentinel)+        #expect(resolved == "Opens the rendered diagram")+    }++    @Test("Copies the diagram source code to clipboard hint is present in the compiled catalog")+    func copyHintInCatalog() {+        let resolved = localised("Copies the diagram source code to clipboard")+        #expect(resolved != Self.missingKeySentinel)+        #expect(resolved == "Copies the diagram source code to clipboard")+    }+}

diff --git a/specs/mermaid-card-a11y/smolspec.md b/specs/mermaid-card-a11y/smolspec.mdnew file mode 100644index 0000000..3a6e806--- /dev/null+++ b/specs/mermaid-card-a11y/smolspec.md@@ -0,0 +1,101 @@+# Mermaid Card Accessibility Actions++Source: Transit ticket T-1041 (chore, Prism, milestone 1.0.0). Tracks parent+epic T-782. Audit reference: `docs/accessibility-review.md` finding H1.++## Overview++`MermaidPreviewCard` shows two overlay buttons ("Show", "Copy Code") that are+conditionally rendered on iOS (tap-to-reveal with a 3-second auto-dismiss) and+on macOS (visible on hover). When the overlay is hidden, VoiceOver and Voice+Control users have no way to invoke either action. This change exposes both+actions at the card level via `.accessibilityAction(named:)` so they are+reachable regardless of overlay visibility, and adds accessibility hints to the+visible buttons.++## Requirements++- The card MUST expose a "Show code" accessibility action that opens the+  diagram viewer (sheet on iOS, window on macOS), regardless of overlay+  visibility.+- The card MUST expose a "Copy code" accessibility action that copies the+  mermaid source to the clipboard, regardless of overlay visibility.+- The visible "Show" overlay button MUST advertise its behaviour via+  `.accessibilityHint` with the text "Opens the rendered diagram".+- The visible "Copy Code" overlay button MUST advertise its behaviour via+  `.accessibilityHint` with the text "Copies the diagram source code to+  clipboard" (reuses the existing catalog key shared with+  `MermaidErrorView.swift`).+- All new user-facing strings MUST live in `prism/Localizable.xcstrings`.+  `.accessibilityHint` literals MUST use an explicit `LocalizedStringKey`+  wrapper per the project's accessibility-modifier rule in `CLAUDE.md`.+  `.accessibilityAction(named:)` MUST follow the existing project pattern in+  `ImageBlockView.swift:202-203` (bare-literal `String`, picked up by the+  catalog extractor); if the build's localisation validator flags this, switch+  to an explicit `LocalizedStringResource` wrapper.+- The change MUST NOT alter the existing visual behaviour of the overlay+  (tap-to-reveal on iOS, hover on macOS, 3-second auto-dismiss).+- The thumbnail Button's existing `.accessibilityLabel` and `.accessibilityHint`+  MUST be preserved unchanged.++## Implementation Approach++**Key file:** `prism/Views/MermaidPreviewCard.swift`++**Pattern to follow:** `prism/Views/ImageBlockView.swift:202-203` already uses+the same approach for its linked-image overlay (which the file comment+explicitly says mirrors `MermaidPreviewCard`):++```swift+.accessibilityAction(named: "View Image") { openImageDetail() }+.accessibilityAction(named: "Follow Link") { openURL(linkURL) }+```++Apply the equivalent on the rendered-state subtree of `MermaidPreviewCard`:++- Attach `.accessibilityAction(named: "Show code") { openDiagram() }` and+  `.accessibilityAction(named: "Copy code") { copyToClipboard() }` to the+  `ZStack` returned by `renderedView(_:)`.+- Add `.accessibilityHint(LocalizedStringKey("..."))` modifiers to each+  `Button` inside `overlayButtons`. Hint strings are specified in Requirements.++**Localization:** Catalog state in `prism/Localizable.xcstrings` at start:+"Show", "Copy Code", "Copy code", and "Copies the diagram source code to+clipboard" already exist. The "Copy code" key is reused for the "Copy code"+accessibility action, and the "Copies the diagram source code to clipboard"+key is reused for the copy-button hint (shared with+`MermaidErrorView.swift:101`). New catalog entries required: "Show code"+(action name) and "Opens the rendered diagram" (Show-button hint).+Auto-extraction via the Xcode build picks up the literal-string+`.accessibilityAction(named:)` form (per `ImageBlockView`); explicit+`LocalizedStringKey` wrappers handle the `.accessibilityHint` strings.++**Dependencies:** None beyond the existing `MermaidPreviewCard` actions+(`openDiagram()`, `copyToClipboard()`) which are already defined.++**Out of scope:**+- The 3-second auto-dismiss timer accessibility (tracked by T-1042 / H2).+- Reduce-Transparency support for the `glassEffect` buttons (tracked by T-1044 / H4).+- Restructuring the overlay rendering itself (visual behaviour stays as-is).+- Any other accessibility audit findings.++## Risks and Assumptions++- **Risk:** When the overlay is visible, VoiceOver may see both the rendered+  overlay `Button`s and the card-level `.accessibilityAction(named:)` entries+  (because `.accessibilityElement(children: .contain)` keeps the children+  individually focusable). Additionally, the thumbnail `Button` already+  carries `.accessibilityHint("Tap to view full diagram")` and routes to+  `handleThumbnailTap()` → `openDiagram()`, so the new "Show code" card-level+  action duplicates the thumbnail's primary tap behaviour. **Mitigation:** This+  duplication is already accepted in the parallel `ImageBlockView`+  implementation. Diverging from that pattern is more costly than the rotor+  noise. If duplication proves problematic in user testing, a follow-up can+  mark the overlay buttons `.accessibilityHidden(true)` — out of scope here.+- **Assumption:** The `.accessibilityElement(children: .contain)` modifier+  already on the card body (line 97) does not interfere with card-level+  `.accessibilityAction` registration. The same combination works in+  `ImageBlockView`, so this is verified by precedent.+- **Prerequisite:** The Xcode build's `validate-localisation.py` script picks+  up new literal strings used in `.accessibilityAction(named:)` calls (matches+  the existing `ImageBlockView` pattern).

diff --git a/specs/mermaid-card-a11y/decision_log.md b/specs/mermaid-card-a11y/decision_log.mdnew file mode 100644index 0000000..76a9144--- /dev/null+++ b/specs/mermaid-card-a11y/decision_log.md@@ -0,0 +1,110 @@+# Decision Log: Mermaid Card Accessibility Actions++## Decision 1: Expose actions via `.accessibilityAction(named:)` at the card level++**Date**: 2026-05-20+**Status**: accepted++### Context++The "Show" and "Copy Code" overlay buttons on `MermaidPreviewCard` are+conditionally rendered: tap-to-reveal on iOS (3 s auto-dismiss) and hover-only+on macOS. While the overlay is hidden, VoiceOver and Voice Control users+cannot perform either action. The accessibility audit (H1 / T-1041) calls for+exposing the actions to assistive tech without changing the visual design.++### Decision++Attach card-level `.accessibilityAction(named:)` modifiers to the rendered+ZStack so both actions are reachable regardless of overlay visibility, and+keep the visible overlay buttons as-is (with `.accessibilityHint` added for+clarity).++### Rationale++This mirrors the established pattern in `ImageBlockView.swift:202-203`, which+solved the identical problem for the linked-image overlay. The file comment in+`ImageBlockView` explicitly says the overlay pattern "mirrors+MermaidPreviewCard — keep in sync", so staying consistent reduces cognitive+load for future contributors and makes the codebase easier to audit. It is+also the lowest-risk change: no visual restructuring, no new timing logic.++### Alternatives Considered++- **Always render the overlay buttons**: Would solve discoverability for+  assistive tech but changes the visual design that was explicitly chosen+  for visual minimalism (tap-to-reveal / hover-to-reveal). Rejected because+  the audit specifically asks for the lighter-touch accessibility fix.+- **Mark the overlay buttons `.accessibilityHidden(true)` and rely only on+  card-level actions**: Cleaner rotor (no duplication when overlay is shown)+  but inconsistent with `ImageBlockView`. Rejected to keep the two parallel+  implementations in sync; if duplication proves problematic later, both can+  be updated together.++### Consequences++**Positive:**+- VoiceOver and Voice Control users can invoke both actions at any time.+- No visual or behavioural regression for sighted users.+- Pattern stays consistent with `ImageBlockView`.++**Negative:**+- When the overlay is visible, VoiceOver may surface both the rendered+  `Button` and the card-level action — minor rotor duplication.++---++## Decision 2: Accessibility action names diverge from visible button labels++**Date**: 2026-05-20+**Status**: accepted++### Context++The visible overlay buttons are labelled "Show" (with an eye icon) and+"Copy Code" (title case) for visual compactness. The accessibility audit+prescribes the action names "Show code" and "Copy code" (sentence case).+Both pairs differ: "Show" vs "Show code" (verb-only vs verb-noun) and+"Copy Code" vs "Copy code" (title vs sentence case).++### Decision++Use the audit's exact strings — "Show code" and "Copy code" — as+`.accessibilityAction(named:)` names. Keep the visible button labels+unchanged ("Show", "Copy Code"). Add `.accessibilityHint` modifiers on the+visible buttons to bridge the gap between the compact label and the full+action description.++### Rationale++Accessibility actions appear in the VoiceOver rotor or Voice Control command+list without the surrounding card context, so the name must stand alone —+"Show" alone is ambiguous. Sentence case ("Copy code") matches Apple's+HIG guidance for accessibility action names, which favour natural-language+phrasing over UI label casing. Keeping visible labels unchanged scopes this+work to accessibility-only and avoids visual churn.++### Alternatives Considered++- **Rename visible buttons to match the action names**: Cleaner consistency+  but changes established visual UI and pulls in design review. Rejected to+  keep this PR scoped.+- **Use the visible label casing for action names ("Copy Code")**: Matches+  the button text but ignores the sentence-case convention for accessibility+  prose. Rejected.+- **Use the same name for both action and label**: Either makes the action+  ambiguous ("Show") or makes the button label verbose ("Copy diagram source+  code"). Rejected.++### Consequences++**Positive:**+- Action names are self-describing without depending on visual context.+- Casing follows Apple HIG accessibility conventions.+- No visual change.++**Negative:**+- Visible label and accessibility action name differ for both buttons —+  localisers must translate both consistently per language.++---

diff --git a/specs/mermaid-card-a11y/tasks.md b/specs/mermaid-card-a11y/tasks.mdnew file mode 100644index 0000000..824ce96--- /dev/null+++ b/specs/mermaid-card-a11y/tasks.md@@ -0,0 +1,36 @@+# Mermaid Card Accessibility Actions++- [x] 1. Card-level accessibility actions reachable when overlay is hidden <!-- id:8eh3rtm -->+  - Reference: specs/mermaid-card-a11y/smolspec.md (Requirements 1 and 2).+  - Outcome: VoiceOver and Voice Control surface a "Show code" action that opens the diagram viewer and a "Copy code" action that copies the source, even when the overlay is not visible.+  - File: prism/Views/MermaidPreviewCard.swift — apply at the ZStack returned by renderedView(_:).+  - Pattern reference: prism/Views/ImageBlockView.swift:202-203.+  - Verification: open the rotor in the iOS Simulator while the overlay is hidden and confirm both actions are listed and invoke the correct closures.++- [x] 2. Visible overlay buttons announce their behaviour via accessibility hints <!-- id:8eh3rtn -->+  - Reference: specs/mermaid-card-a11y/smolspec.md (Requirements 3 and 4).+  - Outcome: the visible "Show" button advertises "Opens the rendered diagram" and the visible "Copy Code" button advertises "Copies the diagram source code" via .accessibilityHint.+  - File: prism/Views/MermaidPreviewCard.swift — modify the two Buttons inside overlayButtons.+  - Hints MUST use an explicit LocalizedStringKey wrapper per the CLAUDE.md accessibility-modifier rule.+  - Verification: with the overlay visible (tap on iOS or hover on macOS) VoiceOver reads each button label followed by its hint.+  - Blocked-by: 8eh3rtm (Card-level accessibility actions reachable when overlay is hidden)++- [x] 3. New localisation catalog entries cover the action name and hint strings <!-- id:8eh3rto -->+  - Reference: specs/mermaid-card-a11y/smolspec.md (Requirement 5).+  - Outcome: prism/Localizable.xcstrings contains entries for the new strings "Show code" (action name) plus the two hint strings.+  - Re-use the existing "Copy code" key for the second action where appropriate; do not duplicate.+  - Verification: make test-locales succeeds and the auto-extraction does not flag missing keys.+  - Blocked-by: 8eh3rtm (Card-level accessibility actions reachable when overlay is hidden), 8eh3rtn (Visible overlay buttons announce their behaviour via accessibility hints)++- [x] 4. Test verifies the card-level accessibility actions are present and invoke the right closures <!-- id:8eh3rtp -->+  - Reference: specs/mermaid-card-a11y/smolspec.md (Requirements 1 and 2).+  - Outcome: a unit test (Swift Testing preferred) or UI test inspects the rendered MermaidPreviewCard and asserts that both card-level accessibility actions exist and invoke their backing closures.+  - Test file: extend the appropriate target in prismTests or prismUITests; mirror existing accessibility coverage if any.+  - Verification: make test-quick passes locally and the new test fails when the modifiers are removed.+  - Blocked-by: 8eh3rtm (Card-level accessibility actions reachable when overlay is hidden), 8eh3rtn (Visible overlay buttons announce their behaviour via accessibility hints), 8eh3rto (New localisation catalog entries cover the action name and hint strings)++- [x] 5. Lint, build, and full test suite pass on iOS and macOS <!-- id:8eh3rtq -->+  - Reference: specs/mermaid-card-a11y/smolspec.md (whole spec).+  - Outcome: make lint succeeds, make build-ios and make build-macos finish with zero warnings, and make test passes.+  - Run after all other tasks are complete.+  - Blocked-by: 8eh3rtm (Card-level accessibility actions reachable when overlay is hidden), 8eh3rtn (Visible overlay buttons announce their behaviour via accessibility hints), 8eh3rto (New localisation catalog entries cover the action name and hint strings), 8eh3rtp (Test verifies the card-level accessibility actions are present and invoke the right closures)

diff --git a/specs/mermaid-card-a11y/implementation.md b/specs/mermaid-card-a11y/implementation.mdnew file mode 100644index 0000000..fa8b4a1--- /dev/null+++ b/specs/mermaid-card-a11y/implementation.md@@ -0,0 +1,69 @@+# Implementation Notes: Mermaid Card Accessibility Actions++Source: T-1041 — `docs/accessibility-review.md` H1.++## Summary++Exposed two card-level accessibility actions ("Show code", "Copy code") on+`MermaidPreviewCard` so VoiceOver and Voice Control users can reach the+overlay actions even when the overlay is hidden (iOS tap-to-reveal /+macOS hover-only). Added `.accessibilityHint` modifiers to the visible+"Show" and "Copy Code" overlay buttons.++## Code changes++- `prism/Views/MermaidPreviewCard.swift`+  - Added `.accessibilityAction(named: "Show code") { openDiagram() }` and+    `.accessibilityAction(named: "Copy code") { copyToClipboard() }` on the+    `ZStack` returned by `renderedView(_:)`. Mirrors the existing+    `ImageBlockView.swift:202-203` pattern.+  - Added `.accessibilityHint(LocalizedStringKey("Opens the rendered diagram"))`+    on the visible "Show" button and+    `.accessibilityHint(LocalizedStringKey("Copies the diagram source code to clipboard"))`+    on the visible "Copy Code" button. The second hint reuses the catalog+    key already shared with `MermaidErrorView.swift:101`.++- `prism/Localizable.xcstrings`+  - Added two new entries: `"Show code"` and `"Opens the rendered diagram"`,+    each with `en` / `en-GB` / `en-US` localisations (matching the project's+    English-only baseline).+  - Reused existing `"Copy code"` and `"Copies the diagram source code to+    clipboard"` keys.++- `prismTests/MermaidPreviewCardAccessibilityTests.swift`+  - New Swift Testing suite with 6 tests. One construction smoke test+    that fails to compile if the modifier chain breaks type-checking, one+    control test that verifies the sentinel mechanism distinguishes+    missing keys from present ones, and four catalog-presence tests using+    `Bundle.main.localizedString(forKey:value:table:)` with a sentinel+    default — those genuinely fail if a key is missing from the compiled+    catalog (unlike `String(localized:)`, which silently falls back to the+    key). The test file documents that behavioural verification of the+    actual `.accessibilityAction(named:)` invocation requires ViewInspector+    or a manual VoiceOver run.++## Verification++- `make lint` — 0 violations.+- `make test-locales` — exit 0 across `en (base)`, `en-AU`, `en-GB`, `en-US`.+- `make test-quick` (macOS test + build) — exit 0; new tests passed.+- Targeted `MermaidPreviewCardAccessibilityTests` run — 5/5 tests passed+  across the four locale configurations.+- `make build-ios` — Build Succeeded, 0 warnings.++## Decisions++See `decision_log.md`:+- Decision 1: card-level `.accessibilityAction(named:)` mirrors the+  established `ImageBlockView` pattern rather than always-rendering the+  buttons.+- Decision 2: accessibility action names diverge from visible labels —+  "Show code" / "Copy code" (sentence case) for actions, "Show" /+  "Copy Code" for visible labels.++## Follow-ups (deliberately out of scope)++- T-1042 (H2) — accessibility-aware overlay auto-dismiss.+- T-1044 (H4) — Reduce-Transparency support for the `glassEffect` buttons.+- Potential `.accessibilityHidden(true)` on the visible overlay buttons if+  user testing flags rotor duplication when the overlay is on screen.

diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 54256b4..fe7668c 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0  ### Added +- VoiceOver and Voice Control can now reach the Mermaid card's "Show code" and "Copy code" overlay actions even while the overlay is hidden (T-1041, audit finding H1). `MermaidPreviewCard.renderedView(_:)` now attaches card-level `.accessibilityAction(named: "Show code") { openDiagram() }` and `.accessibilityAction(named: "Copy code") { copyToClipboard() }` on its `ZStack`, mirroring the established `ImageBlockView.swift:202-203` pattern. The visible "Show" and "Copy Code" overlay buttons also gain `.accessibilityHint(LocalizedStringKey(...))` modifiers so assistive tech narrates their behaviour when the overlay is on screen. Two new catalog entries — "Show code" and "Opens the rendered diagram" — are added to `prism/Localizable.xcstrings`; the "Copy code" action name and "Copies the diagram source code to clipboard" hint reuse existing keys (the latter shared with `MermaidErrorView.swift:101`). New `MermaidPreviewCardAccessibilityTests` Swift Testing suite covers card construction and `String(localized:)` resolution for the four catalog keys involved. Visual overlay behaviour (iOS tap-to-reveal with 3 s auto-dismiss, macOS hover-only) is unchanged. Spec lives under `specs/mermaid-card-a11y/`. - Render markdown tables that appear inside list items as tables instead of raw markdown text (T-1034). `MarkdownBlockParser.convertListItem` now emits a `.block(.table(...))` child for swift-markdown `Table` nodes nested under a list item, and `ListBlockView` renders them via a new private `NestedTableBlockView` wrapper that delegates to the existing `AccessibleTableView`. The wrapper hides the row-indicator column (per-row notes on nested tables deferred per ticket) and initialises its display mode via `TableDisplayMode.initialMode(headers:rows:)` so wider tables fall back to readable mode automatically. Test coverage extends `ListItemNestedBlocksTests` with four cases (parser emits the table child, item content no longer contains pipe text, alignment markers round-trip, list-block id structural fingerprint pinned against silent ID drift). Knowingly orphans any existing note attached to a list item that contains a table — the item's `contentForHashing` necessarily changes — accepted per `specs/tables-in-list-items/decision_log.md`. - Research report on adding HTML viewing with annotations to Prism, covering WKWebView, native parse, AttributedString, HTML→Markdown, and hybrid rendering options plus a Hypothesis-style note-anchoring cascade and a layered security model (sanitisation, CSP, scheme handler). Stored under `docs/agent-notes/` and not bundled in the app. - `prism-notes-js` spec for a self-contained single-file JavaScript library that adds basic note-taking and copy-as-markdown to any HTML page (personal-use companion artifact; not part of the Prism Swift app). Smolspec, decision log, and 8 implementation tasks live under `specs/prism-notes-js/`.