Pre-push review: T-1829 — Increase Contrast for web-rendered documents

diff --git a/prism/ViewModels/WebBridgeContract.swift b/prism/ViewModels/WebBridgeContract.swiftindex 90be817..d9b5b1d 100644--- a/prism/ViewModels/WebBridgeContract.swift+++ b/prism/ViewModels/WebBridgeContract.swift@@ -158,18 +158,40 @@ enum InboundMessageType: String, CaseIterable, Sendable {  // MARK: - Outbound (native → JS) commands +/// The system Increase Contrast state, as the rendered document sees it (T-1829).+///+/// Native reads `Environment(\.colorSchemeContrast)` and pushes this with the theme;+/// prism-theme.js maps it onto the `data-prism-contrast` attribute and `document.css`+/// holds the per-theme override values — the same native/CSS split the base palette+/// uses, so only the STATE crosses the bridge.+enum WebContrastMode: String, Equatable, Sendable {+    case standard+    case increased+}+ /// A native→JS command. Each maps to one bridge function the controller invokes /// via `callJavaScript(in: bridgeWorld)`. Commands queue until the page posts /// `ready` for the current generation (design `load` ordering contract). enum OutboundBridgeCommand: Equatable, Sendable {-    /// `theme` selects the CSS `data-prism-theme` block; `variables` overlays explicit-    /// CSS custom properties; `mermaidConfig` is the per-theme mermaid config as a JSON+    /// `theme` selects the CSS `data-prism-theme` block; `contrast` selects the matching+    /// `data-prism-contrast` overrides (T-1829); `variables` overlays explicit CSS custom+    /// properties; `mermaidConfig` is the per-theme mermaid config as a JSON     /// string (theme name + themeVariables, from MermaidThemeConfig.toJavaScriptConfig()).     /// prism-theme.js forwards it on the `prism:retheme` DOM event; the page-world mermaid     /// script JSON-parses it and re-renders diagrams in the new theme without a reload     /// (Req 1.3). Empty string when no per-theme mermaid config applies (classic themes     /// keep mermaid's built-in theme via the baseline config).-    case applyTheme(theme: String, variables: [String: String], mermaidConfig: String)+    ///+    /// Contrast rides on this command rather than getting its own so the theme key and+    /// its high-contrast variant are applied atomically — the override values are+    /// per-theme, so a split push could momentarily pair one theme's palette with+    /// another's overrides.+    case applyTheme(+        theme: String,+        contrast: WebContrastMode,+        variables: [String: String],+        mermaidConfig: String+    )     case applyTypography(variables: [String: String])     case setCommentVisibility(Bool)     case setSearchState(json: String)

diff --git a/prism/ViewModels/WebDocumentController.swift b/prism/ViewModels/WebDocumentController.swiftindex 2dcab1b..7d45300 100644--- a/prism/ViewModels/WebDocumentController.swift+++ b/prism/ViewModels/WebDocumentController.swift@@ -283,8 +283,13 @@ final class WebDocumentController {     /// The JS-passable payload for a command (numbers/strings/arrays/dicts only).     static func payload(for command: OutboundBridgeCommand) -> [String: Any] {         switch command {-        case .applyTheme(let theme, let variables, let mermaidConfig):-            return ["theme": theme, "variables": variables, "mermaidConfig": mermaidConfig]+        case .applyTheme(let theme, let contrast, let variables, let mermaidConfig):+            return [+                "theme": theme,+                "contrast": contrast.rawValue,+                "variables": variables,+                "mermaidConfig": mermaidConfig,+            ]         case .applyTypography(let variables):             return ["variables": variables]         case .setCommentVisibility(let visible):@@ -312,8 +317,20 @@ final class WebDocumentController {      // MARK: - Named native→JS commands (design WebDocumentController interface) -    func applyTheme(theme: String, variables: [String: String], mermaidConfig: String = "") {-        send(.applyTheme(theme: theme, variables: variables, mermaidConfig: mermaidConfig))+    /// Pushes the palette: the theme key plus the system Increase Contrast state+    /// (T-1829), which selects the stylesheet's per-theme high-contrast overrides.+    ///+    /// `contrast` is un-defaulted so no push path can drop it silently; every caller+    /// states whether the document is rendering under Increase Contrast.+    func applyTheme(+        theme: String,+        contrast: WebContrastMode,+        variables: [String: String],+        mermaidConfig: String = ""+    ) {+        send(.applyTheme(+            theme: theme, contrast: contrast, variables: variables, mermaidConfig: mermaidConfig+        ))     }      func applyTypography(variables: [String: String]) {@@ -481,7 +498,17 @@ struct WebUserScript: Sendable { /// than a queued event history. Each setter overwrites the previous value, so a /// burst of theme changes before `ready` collapses to one applyTheme on flush. struct WebDocumentStateSnapshot: Equatable, Sendable {-    var theme: (name: String, variables: [String: String], mermaidConfig: String)?+    /// The last-pushed palette: theme key, Increase Contrast state (T-1829), explicit+    /// variable overlay, and the per-theme mermaid config. A value type rather than a+    /// tuple so the snapshot's `Equatable` synthesises.+    struct ThemePush: Equatable, Sendable {+        var name: String+        var contrast: WebContrastMode+        var variables: [String: String]+        var mermaidConfig: String+    }++    var theme: ThemePush?     var typography: [String: String]?     var commentVisibility: Bool?     var searchStateJSON: String?@@ -493,29 +520,15 @@ struct WebDocumentStateSnapshot: Equatable, Sendable {     /// The last scroll target to restore after layout settles (Req 2.2).     var scrollTargetBlockID: String? -    /// Equatable can't synthesise for a tuple; compare the fields explicitly.-    static func == (lhs: WebDocumentStateSnapshot, rhs: WebDocumentStateSnapshot) -> Bool {-        lhs.theme?.name == rhs.theme?.name-            && lhs.theme?.variables == rhs.theme?.variables-            && lhs.theme?.mermaidConfig == rhs.theme?.mermaidConfig-            && lhs.typography == rhs.typography-            && lhs.commentVisibility == rhs.commentVisibility-            && lhs.searchStateJSON == rhs.searchStateJSON-            && lhs.detailsExpandedIDs == rhs.detailsExpandedIDs-            && lhs.tableModes == rhs.tableModes-            && lhs.noteIndicatorsJSON == rhs.noteIndicatorsJSON-            && lhs.inlineNotesJSON == rhs.inlineNotesJSON-            && lhs.sectionCollapsedIDs == rhs.sectionCollapsedIDs-            && lhs.scrollTargetBlockID == rhs.scrollTargetBlockID-    }-     /// Folds a command into the snapshot, overwriting any previous value of the     /// same kind. Transient page-scroll commands (scrollByPage, scrollToEdge) are     /// not part of restorable state and are not retained.     mutating func apply(_ command: OutboundBridgeCommand) {         switch command {-        case .applyTheme(let theme, let variables, let mermaidConfig):-            self.theme = (theme, variables, mermaidConfig)+        case .applyTheme(let theme, let contrast, let variables, let mermaidConfig):+            self.theme = ThemePush(+                name: theme, contrast: contrast, variables: variables, mermaidConfig: mermaidConfig+            )         case .applyTypography(let variables):             typography = variables         case .setCommentVisibility(let visible):@@ -546,7 +559,10 @@ struct WebDocumentStateSnapshot: Equatable, Sendable {         var commands: [OutboundBridgeCommand] = []         if let theme {             commands.append(.applyTheme(-                theme: theme.name, variables: theme.variables, mermaidConfig: theme.mermaidConfig+                theme: theme.name,+                contrast: theme.contrast,+                variables: theme.variables,+                mermaidConfig: theme.mermaidConfig             ))         }         if let typography { commands.append(.applyTypography(variables: typography)) }

diff --git a/prism/ViewModels/WebDocumentStateSynchronizer.swift b/prism/ViewModels/WebDocumentStateSynchronizer.swiftindex adacc5e..9944aaf 100644--- a/prism/ViewModels/WebDocumentStateSynchronizer.swift+++ b/prism/ViewModels/WebDocumentStateSynchronizer.swift@@ -20,8 +20,9 @@ //      modes, note indicators/inline notes, typography, comment visibility — //      pushed on change so the controller's coalesced snapshot can replay //      native truth exactly after reload/WebContent recovery.-//    - Theme: pushed through `applyTheme(themeKey:)`, fed by the hosting view-//      (the effective theme depends on the view-world colorScheme).+//    - Theme: pushed through `applyTheme(themeKey:contrast:)`, fed by the hosting+//      view (the effective theme depends on the view-world colorScheme, and the+//      Increase Contrast state is a view-world environment value). // //  Change reaction runs through the Observation framework, NOT SwiftUI //  `.onChange`, so the wiring exists independent of any view being mounted —@@ -106,12 +107,21 @@ final class WebDocumentStateSynchronizer {         synchronize()     } -    /// Pushes the effective theme. Called by the hosting view, which owns the-    /// colorScheme-resolved theme key (initial push and on change) — theme is-    /// the one view-fed domain because the view world owns colorScheme.-    func applyTheme(themeKey: String) {+    /// Pushes the effective palette: the theme key plus the system Increase Contrast+    /// state (T-1829). Called by the hosting view, which owns both — the theme key is+    /// colorScheme-resolved and `colorSchemeContrast` is a view-world environment value+    /// — so this stays the one view-fed domain (initial push and on change).+    ///+    /// Only the contrast STATE crosses the bridge; `document.css` holds the per-theme+    /// override values, matching how the theme key selects a palette block.+    ///+    /// `contrast` carries no default: this is the live initial-push seam, and a+    /// silently-`.standard` default would let a new call site drop Increase Contrast+    /// while still compiling — the T-1829 regression, reintroduced.+    func applyTheme(themeKey: String, contrast: WebContrastMode) {         controller.applyTheme(             theme: themeKey,+            contrast: contrast,             variables: [:],             mermaidConfig: WebDocumentControllerFactory.mermaidThemeConfigJSON(for: themeKey)         )

diff --git a/prism/ViewModels/WebDocumentControllerFactory.swift b/prism/ViewModels/WebDocumentControllerFactory.swiftindex 8549c33..e84f4b2 100644--- a/prism/ViewModels/WebDocumentControllerFactory.swift+++ b/prism/ViewModels/WebDocumentControllerFactory.swift@@ -235,15 +235,22 @@ enum WebDocumentControllerFactory {     /// Pushes the current theme, typography, and comment visibility onto the     /// controller so they queue until `ready` and replay after recovery (Req 1.3/     /// 1.4/1.7/9.6). The CSS holds the per-theme colour blocks keyed by-    /// `data-prism-theme`, so only the theme key + typography scale variables are-    /// pushed — not every colour.+    /// `data-prism-theme` — and their Increase Contrast variants keyed by+    /// `data-prism-contrast` (T-1829) — so only the theme key, the contrast state, and+    /// the typography scale variables are pushed, not every colour.+    ///+    /// `contrast` carries no default on purpose. A silently-`.standard` default is the+    /// exact shape of the T-1829 regression — a push path that keeps compiling while+    /// dropping the contrast state — so every caller has to state its intent.     static func pushInitialState(         to controller: WebDocumentController,         settings: AppSettings,-        themeKey: String+        themeKey: String,+        contrast: WebContrastMode     ) {         controller.applyTheme(             theme: themeKey,+            contrast: contrast,             variables: [:],             mermaidConfig: mermaidThemeConfigJSON(for: themeKey)         )

diff --git a/prism/Views/DocumentScrollContent.swift b/prism/Views/DocumentScrollContent.swiftindex 60af6bc..92c01c6 100644--- a/prism/Views/DocumentScrollContent.swift+++ b/prism/Views/DocumentScrollContent.swift@@ -50,6 +50,11 @@ struct DocumentScrollContent: View {     /// Resolves the effective theme (light/dark) for the theme pushes.     @Environment(\.colorScheme) private var colorScheme +    /// The system Increase Contrast setting (T-1829). Read here rather than in the+    /// state synchronizer because it is a view-world environment value, like+    /// `colorScheme` — the two together form the palette the document renders in.+    @Environment(\.colorSchemeContrast) private var colorSchemeContrast+     /// Image services, for the iOS sibling-image folder-access grant flow (Req 3.x).     @Environment(\.imageServices) private var imageServices @@ -110,9 +115,11 @@ struct DocumentScrollContent: View {             )             webRouter = made.router             made.synchronizer.start()-            // The theme stays view-fed: the effective key depends on colorScheme.+            // The theme stays view-fed: the effective key depends on colorScheme, and+            // the Increase Contrast state alongside it is a view-world environment value.             made.synchronizer.applyTheme(-                themeKey: context.settings.theme(for: colorScheme).rawValue+                themeKey: paletteFeed.themeKey,+                contrast: paletteFeed.contrast             )             synchronizer = made.synchronizer             // Keyboard/menu scrolling (T-1719): route the shared controller's@@ -137,11 +144,14 @@ struct DocumentScrollContent: View {             )             webController = controller         }-        // Live theme updates without a reload (Req 1.3). Typography, comment-        // visibility, notes, sections, details, and table modes re-push from the-        // synchronizer's observation pass — no view .onChange needed.-        .onChange(of: context.settings.theme(for: colorScheme)) { _, theme in-            synchronizer?.applyTheme(themeKey: theme.rawValue)+        // Live theme + Increase Contrast updates without a reload (Req 1.3, T-1829).+        // Typography, comment visibility, notes, sections, details, and table modes+        // re-push from the synchronizer's observation pass — no view .onChange needed.+        // One .onChange over the whole palette feed so theme and contrast can never be+        // pushed out of step, and so a future view-world palette input joins by growing+        // `WebPaletteFeed` rather than adding another observer.+        .onChange(of: paletteFeed) { _, feed in+            synchronizer?.applyTheme(themeKey: feed.themeKey, contrast: feed.contrast)         }         // Search highlights (Req 6.1/6.2/6.3/7.2, T-1680): re-push whenever the         // coordinator's debounced query, per-block counts (recomputed on block or@@ -298,9 +308,36 @@ struct DocumentScrollContent: View {         let currentIndex: Int?     } +    /// The view-world palette inputs the rendered document needs: the+    /// colorScheme-resolved theme key and the system Increase Contrast state+    /// (T-1829). Both are pushed together by `applyTheme`.+    private var paletteFeed: WebPaletteFeed {+        WebPaletteFeed(+            themeKey: context.settings.theme(for: colorScheme).rawValue,+            contrast: WebContrastMode(colorSchemeContrast)+        )+    }+     /// Identity key for the web load trigger: a new value re-runs the load `.task`.     private struct WebLoadKey: Equatable {         let hasController: Bool         let revision: UInt64     } }++/// The palette state the document surface feeds to the web renderer from the view+/// world. Grouped into one `Equatable` value so a single `.onChange` covers every+/// input and they are always pushed as a consistent pair (T-1829).+struct WebPaletteFeed: Equatable {+    let themeKey: String+    let contrast: WebContrastMode+}++extension WebContrastMode {+    /// Maps SwiftUI's `colorSchemeContrast` environment value onto the bridged mode.+    /// The environment value is two-state, but it is not a frozen enum, so anything+    /// other than `.increased` is treated as standard.+    init(_ contrast: ColorSchemeContrast) {+        self = contrast == .increased ? .increased : .standard+    }+}

diff --git a/prism/Resources/WebRenderer/document.css b/prism/Resources/WebRenderer/document.cssindex ce157f1..2a75fdd 100644--- a/prism/Resources/WebRenderer/document.css+++ b/prism/Resources/WebRenderer/document.css@@ -211,6 +211,77 @@     --prism-error: #FF453A; } +/* ---- Increase Contrast overrides (T-1829) ----+ *+ * Mirrors Theme/HighContrastThemeColors.swift, which applies the same five token+ * overrides to native chrome (T-1045, audit finding H5). Native pushes only the+ * contrast STATE (the data-prism-contrast attribute, carried on the applyTheme bridge+ * command); the per-theme values live here — the same native/CSS split the base+ * palette uses. Keeping them here also makes toggling the setting off exact: the+ * attribute is removed and the base block applies again, with no inline overrides left+ * on the root element.+ *+ * Each per-theme block carries BOTH attributes, so at (0,3,0) it outranks the matching+ * base theme block at (0,2,0) regardless of source order. The attribute-less arm grouped+ * with prism-light is (0,2,0) and only ever competes with the bare `:root` fallback at+ * (0,1,0), which it beats: it can match only if data-prism-contrast is set while+ * data-prism-theme is not. prism-theme.js sets both from the one applyTheme payload and+ * production always sends a theme key, so that is defensive only — it mirrors the base+ * palette's `:root, :root[data-prism-theme="prism-light"]` grouping rather than covering+ * a state the app can currently reach.+ */+:root[data-prism-contrast="increased"],+:root[data-prism-contrast="increased"][data-prism-theme="prism-light"] {+    --prism-text-tertiary: #3F4880;+    --prism-search-match: #F5C36A;+    --prism-search-current: #D97706;+    --prism-footnote-badge-bg: #1E3A8A;+    --prism-footnote-badge-fg: #FFF;+}++:root[data-prism-contrast="increased"][data-prism-theme="refraction"] {+    --prism-text-tertiary: #3F4880;+    --prism-search-match: #F0A858;+    --prism-search-current: #C76A0C;+    --prism-footnote-badge-bg: #3A54A0;+    --prism-footnote-badge-fg: #FFF;+}++:root[data-prism-contrast="increased"][data-prism-theme="prism-dark"] {+    --prism-text-tertiary: #A6B4DC;+    --prism-search-match: rgb(245 195 106 / 85%);+    --prism-search-current: rgb(245 166 56 / 95%);+    --prism-footnote-badge-bg: #1E3A8A;+    --prism-footnote-badge-fg: #93C5FD;+}++:root[data-prism-contrast="increased"][data-prism-theme="classic-light"] {+    --prism-text-tertiary: #3F3F50;+    --prism-search-match: #F5C36A;+    --prism-search-current: #D97706;+    --prism-footnote-badge-bg: #1E3A8A;+    --prism-footnote-badge-fg: #FFF;+}++:root[data-prism-contrast="increased"][data-prism-theme="classic-dark"] {+    --prism-text-tertiary: #A6B4DC;+    --prism-search-match: rgb(245 195 106 / 85%);+    --prism-search-current: rgb(245 166 56 / 95%);+    --prism-footnote-badge-bg: #1E3A8A;+    --prism-footnote-badge-fg: #93C5FD;+}++/* The add-note affordance is deliberately dimmed (0.35, or 0.5 on touch — see the+ * `.prism-add-note` rules below), which is the sixth requirement of the smolspec: under+ * Increase Contrast it must not be faded. The requirement was written against the retired+ * native AccessibleTableView glyph (`.opacity(0.4)`); the cutover moved the affordance+ * into this stylesheet, so the override belongs here too. At (0,3,0) this outranks both+ * the base rule and the `@media (hover: none)` variant, which are each (0,1,0). Not a+ * custom property — the dimming is an opacity on the element, not a palette token. */+:root[data-prism-contrast="increased"] .prism-add-note {+    opacity: 1;+}+ /* ---- Base layout ---- */ html {     -webkit-text-size-adjust: 100%;

diff --git a/prism/Resources/WebRenderer/prism-theme.js b/prism/Resources/WebRenderer/prism-theme.jsindex 6dc1781..6e8c5ce 100644--- a/prism/Resources/WebRenderer/prism-theme.js+++ b/prism/Resources/WebRenderer/prism-theme.js@@ -21,9 +21,21 @@     // ---- Theme (Req 1.3) -------------------------------------------------     // applyTheme sets data-prism-theme (selecting a :root variable block) and     // overlays any explicit variable overrides, then re-themes in-page mermaid.+    //+    // Contrast (T-1829) rides on the SAME command as the theme key so the palette+    // and its high-contrast variant are always applied in one step — a separate+    // command could leave a frame where a newly-selected theme still wore the+    // previous theme's contrast overrides. "increased" mirrors SwiftUI's+    // colorSchemeContrast; anything else clears the attribute back to the base+    // palette. The stylesheet owns the per-theme override values.     bridge.registerCommand("applyTheme", function (payload) {         if (!payload) { return null; }         if (payload.theme) { root.setAttribute("data-prism-theme", payload.theme); }+        if (payload.contrast === "increased") {+            root.setAttribute("data-prism-contrast", "increased");+        } else {+            root.removeAttribute("data-prism-contrast");+        }         applyVariables(payload.variables);         // Mermaid re-theme: dispatch a DOM event the media script listens for so a         // theme change re-renders diagrams in the new theme without a reload.

diff --git a/prismTests/WebRendering/DocumentCSSContrastRulesTests.swift b/prismTests/WebRendering/DocumentCSSContrastRulesTests.swiftnew file mode 100644index 0000000..69a92f8--- /dev/null+++ b/prismTests/WebRendering/DocumentCSSContrastRulesTests.swift@@ -0,0 +1,279 @@+//+//  DocumentCSSContrastRulesTests.swift+//  prismTests+//+//  Stylesheet guard for the Increase Contrast regression (T-1829).+//+//  The T-1542 WebKit cutover moved document rendering into WebKit, but the+//  high-contrast token overrides T-1045 added natively (`HighContrastThemeColors`)+//  never reached the page: `document.css` carried only the base per-theme variable+//  blocks and nothing bridged the OS contrast state. Search highlights, footnote+//  badges, and tertiary text stayed translucent with Increase Contrast enabled.+//+//  The fix keeps the palette in CSS (the established split — native pushes the+//  theme KEY, the stylesheet owns the colours) and adds one+//  `[data-prism-contrast="increased"]` block per theme. These tests pin those+//  blocks and guard them against drifting away from `HighContrastThemeColors`,+//  which is the native source of truth for the same five tokens.+//+//  Rule-pin, not a rendered-contrast proof: the live WebPage harness never applies+//  the emitted stylesheet (see specs/readable-tables-restoration/decision_log.md+//  Decision 2), so computed colours cannot be asserted here. Visual verification is+//  manual, per specs/a11y-increase-contrast/smolspec.md.+//++import SwiftUI+import Testing+@testable import prism++@Suite("document.css Increase Contrast overrides (T-1829)")+@MainActor+struct DocumentCSSContrastRulesTests {++    /// The five tokens `HighContrastThemeColors` overrides, paired with the CSS+    /// custom property each maps onto.+    private static let overriddenTokens: [(css: String, native: (any ThemeColors) -> Color)] = [+        ("--prism-search-match", { $0.searchMatchBackground }),+        ("--prism-search-current", { $0.searchMatchCurrentBackground }),+        ("--prism-footnote-badge-bg", { $0.footnoteBadgeBackground }),+        ("--prism-footnote-badge-fg", { $0.footnoteBadgeForeground }),+        ("--prism-text-tertiary", { $0.textTertiary }),+    ]++    /// Loads the bundled `document.css` from the same `Bundle.main` location the+    /// scheme handler serves it from.+    private static func loadDocumentCSS() throws -> String {+        let url = try #require(+            Bundle.main.url(forResource: "document", withExtension: "css"),+            "bundled document.css must be present in the test host"+        )+        return try String(contentsOf: url, encoding: .utf8)+    }++    private static func normalized(_ css: String) -> String {+        css.replacingOccurrences(of: "\\s+", with: " ", options: .regularExpression)+    }++    /// The declaration body of the first *rule* whose selector text contains+    /// `selectorFragment`, or nil when no such rule exists.+    ///+    /// Matches the implementation in the sibling `document.css` guards+    /// (`DocumentCSSTableRulesTests`, `DocumentCSSCodeBlockRulesTests`): a hit is only a+    /// selector if no `}` sits between it and the next `{`, so a fragment appearing inside+    /// a previous rule body — or inside the section comment above these blocks — is+    /// skipped rather than silently yielding the wrong body.+    private static func ruleBody(containing selectorFragment: String, in css: String) -> String? {+        let flat = normalized(css)+        var searchStart = flat.startIndex+        while let selectorRange = flat.range(of: selectorFragment, range: searchStart..<flat.endIndex) {+            guard let openBrace = flat.range(of: "{", range: selectorRange.upperBound..<flat.endIndex) else {+                return nil+            }+            let priorClose = flat.range(of: "}", range: selectorRange.upperBound..<openBrace.lowerBound)+            if priorClose == nil,+               let closeBrace = flat.range(of: "}", range: openBrace.upperBound..<flat.endIndex) {+                return String(flat[openBrace.upperBound..<closeBrace.lowerBound])+            }+            searchStart = selectorRange.upperBound+        }+        return nil+    }++    /// The value of `property` inside a declaration body, trimmed.+    private static func value(of property: String, in body: String) -> String? {+        for declaration in body.split(separator: ";") {+            let parts = declaration.split(separator: ":", maxSplits: 1)+            guard parts.count == 2 else { continue }+            if parts[0].trimmingCharacters(in: .whitespaces) == property {+                return parts[1].trimmingCharacters(in: .whitespaces)+            }+        }+        return nil+    }++    /// The contrast-block selector for a theme key. Both halves are derived — the theme+    /// key from `PrismTheme.rawValue`, the contrast value from `WebContrastMode.rawValue`+    /// (the string prism-theme.js writes) — so a rename on either side fails here rather+    /// than leaving Swift and JS agreeing on a value the stylesheet never got.+    private static func contrastSelector(for themeKey: String) -> String {+        ":root[data-prism-contrast=\"\(WebContrastMode.increased.rawValue)\"][data-prism-theme=\"\(themeKey)\"]"+    }++    /// The RGB channels of a CSS colour (`#RGB`, `#RRGGBB`, or `rgb(r g b / a%)`).+    /// Alpha is a separate axis, handled by `alpha(fromCSS:)` against+    /// `ContrastChecker.alphaComponent`: `Color.hexString` drops it, so the two cannot be+    /// compared from one source.+    private static func channels(fromCSS value: String) -> [Int]? {+        let trimmed = value.trimmingCharacters(in: .whitespaces)+        if trimmed.hasPrefix("#") {+            var digits = String(trimmed.dropFirst())+            if digits.count == 3 { digits = digits.map { "\($0)\($0)" }.joined() }+            guard digits.count == 6 else { return nil }+            // compactMap would DROP an unparseable pair, leaving a short array that the+            // caller's `zip` then compares as a prefix — a silently weakened assertion.+            // Require all three channels, like the rgb() branch below.+            let parsed = stride(from: 0, to: 6, by: 2).compactMap { offset in+                let start = digits.index(digits.startIndex, offsetBy: offset)+                let end = digits.index(start, offsetBy: 2)+                return Int(digits[start..<end], radix: 16)+            }+            return parsed.count == 3 ? parsed : nil+        }+        guard trimmed.hasPrefix("rgb("), trimmed.hasSuffix(")") else { return nil }+        let inner = trimmed.dropFirst(4).dropLast()+        let parsed = inner.split(separator: "/")[0]+            .split(separator: " ")+            .compactMap { Int($0) }+        return parsed.count == 3 ? parsed : nil+    }++    /// The alpha of a CSS colour as a 0…1 fraction. A bare hex literal is opaque; an+    /// `rgb(r g b / a)` slash component is read either as a percentage (`85%`) or as a+    /// fraction (`0.85`). Returns nil for anything else, so a malformed value fails the+    /// guard instead of silently reading as fully opaque.+    private static func alpha(fromCSS value: String) -> Double? {+        let trimmed = value.trimmingCharacters(in: .whitespaces)+        if trimmed.hasPrefix("#") { return 1 }+        guard trimmed.hasPrefix("rgb("), trimmed.hasSuffix(")") else { return nil }+        let components = trimmed.dropFirst(4).dropLast().split(separator: "/")+        guard components.count == 2 else { return components.count == 1 ? 1 : nil }+        let raw = components[1].trimmingCharacters(in: .whitespaces)+        if raw.hasSuffix("%") {+            guard let percent = Double(raw.dropLast()) else { return nil }+            return percent / 100+        }+        return Double(raw)+    }++    // MARK: - Per-theme blocks exist and override every token++    @Test("Every theme has an Increase Contrast block overriding all five tokens", arguments: PrismTheme.allCases)+    func perThemeContrastBlockOverridesEveryToken(theme: PrismTheme) throws {+        let css = try Self.loadDocumentCSS()+        let selector = Self.contrastSelector(for: theme.rawValue)+        let body = try #require(+            Self.ruleBody(containing: selector, in: css),+            "document.css must define \(selector) so Increase Contrast reaches the rendered document"+        )+        for token in Self.overriddenTokens {+            let overridden = Self.value(of: token.css, in: body)+            #expect(+                overridden != nil,+                "\(selector) must override \(token.css) (T-1829)"+            )+        }+    }++    @Test("The default (attribute-less) :root arm is grouped with prism-light")+    func bareRootContrastBlockExists() throws {+        let css = try Self.loadDocumentCSS()+        // Defensive only, and deliberately so: `data-prism-contrast` is written *by*+        // applyTheme (prism-theme.js), which sets `data-prism-theme` from the same+        // payload, and production always sends a non-empty theme key — so a document+        // carrying the contrast attribute but no theme attribute is not currently+        // reachable. The grouping mirrors the base palette's+        // `:root, :root[data-prism-theme="prism-light"]` shape so the two sections stay+        // structurally parallel; this pins that shape, not a live code path.+        let body = try #require(+            Self.ruleBody(+                containing: ":root[data-prism-contrast=\"\(WebContrastMode.increased.rawValue)\"],",+                in: css+            ),+            "document.css must group the bare :root contrast selector with prism-light"+        )+        #expect(Self.value(of: "--prism-search-match", in: body) != nil)+    }++    // MARK: - The dimmed add-note affordance (smolspec requirement 6)++    @Test("Increase Contrast un-dims the add-note affordance")+    func addNoteAffordanceIsOpaqueUnderIncreasedContrast() throws {+        let css = try Self.loadDocumentCSS()+        // The smolspec requires the dimmed add-note glyph to stop being faded under+        // Increase Contrast. It was written against the retired native+        // AccessibleTableView `.opacity(0.4)`; the cutover moved the affordance into+        // document.css (`.prism-add-note { opacity: 0.35 }` plus a 0.5 touch variant),+        // so the override has to live here.+        let selector = ":root[data-prism-contrast=\"\(WebContrastMode.increased.rawValue)\"] .prism-add-note"+        let body = try #require(+            Self.ruleBody(containing: selector, in: css),+            "document.css must un-dim .prism-add-note under Increase Contrast (T-1829)"+        )+        #expect(Self.value(of: "opacity", in: body) == "1")+    }++    // MARK: - Anti-drift against the native source of truth++    @Test(+        "Contrast block values track HighContrastThemeColors",+        arguments: PrismTheme.allCases+    )+    func contrastValuesMatchNativeOverrides(theme: PrismTheme) throws {+        let css = try Self.loadDocumentCSS()+        let selector = Self.contrastSelector(for: theme.rawValue)+        let body = try #require(Self.ruleBody(containing: selector, in: css))+        let native = HighContrastThemeColors(theme: theme)+        for token in Self.overriddenTokens {+            let cssValue = try #require(+                Self.value(of: token.css, in: body),+                "\(selector) must define \(token.css)"+            )+            let cssChannels = try #require(+                Self.channels(fromCSS: cssValue),+                "\(token.css) in \(selector) must be a hex or rgb() colour, got \(cssValue)"+            )+            let nativeChannels = try #require(+                Self.channels(fromCSS: token.native(native).hexString)+            )+            // Per-channel tolerance of 1: `Color.hexString` truncates rather than+            // rounds (245/255 * 255 = 244.999… → 244), so an exact match would fail+            // on values that are in fact identical. Any real drift is a different+            // colour by far more than one level.+            let drifted = zip(cssChannels, nativeChannels).contains { abs($0 - $1) > 1 }+            #expect(+                !drifted,+                "\(token.css) in \(selector) (\(cssValue)) has drifted from HighContrastThemeColors"+            )+            // Alpha is its own axis and needs its own comparison: the RGB check above+            // reads channels only, so the dark themes' `.opacity(0.85)` / `.opacity(0.95)`+            // search highlights would otherwise be entirely unguarded — an `85%` → `8.5%`+            // slip keeps the same channels and would sail through, silently restoring the+            // translucency T-1829 exists to fix.+            let cssAlpha = try #require(+                Self.alpha(fromCSS: cssValue),+                "\(token.css) in \(selector) must carry a readable alpha, got \(cssValue)"+            )+            #expect(+                abs(cssAlpha - ContrastChecker.alphaComponent(token.native(native))) <= 0.005,+                """+                \(token.css) in \(selector) (\(cssValue)) has drifted in opacity from \+                HighContrastThemeColors+                """+            )+        }+    }++    // MARK: - The overrides actually change something++    @Test(+        "Contrast blocks differ from the theme's base values",+        arguments: PrismTheme.allCases+    )+    func contrastValuesDifferFromBase(theme: PrismTheme) throws {+        let css = try Self.loadDocumentCSS()+        let contrastBody = try #require(Self.ruleBody(containing: Self.contrastSelector(for: theme.rawValue), in: css))+        let baseSelector = ":root[data-prism-theme=\"\(theme.rawValue)\"]"+        let baseBody = try #require(Self.ruleBody(containing: baseSelector, in: css))+        // Search highlights and the footnote badge background are the tokens the audit+        // called out as translucent; they must not be reused verbatim under increased+        // contrast on any theme.+        for property in ["--prism-search-match", "--prism-search-current", "--prism-footnote-badge-bg"] {+            let base = Self.value(of: property, in: baseBody)+            let increased = Self.value(of: property, in: contrastBody)+            #expect(+                base != increased,+                "\(property) must change under Increase Contrast on \(theme.rawValue)"+            )+        }+    }+}

diff --git a/prismTests/WebRendering/WebContrastBridgeTests.swift b/prismTests/WebRendering/WebContrastBridgeTests.swiftnew file mode 100644index 0000000..20df6ea--- /dev/null+++ b/prismTests/WebRendering/WebContrastBridgeTests.swift@@ -0,0 +1,147 @@+//+//  WebContrastBridgeTests.swift+//  prismTests+//+//  Regression tests for T-1829: the system Increase Contrast setting was ignored by+//  web-rendered documents.+//+//  T-1045 wired Increase Contrast into the native theme environment+//  (`HighContrastThemeColors`), but the T-1542 WebKit cutover moved the document body+//  into a WKWebView that only ever received the theme KEY — `applyTheme` sent+//  `variables: [:]` and nothing observed `colorSchemeContrast`. Search highlights,+//  footnote badges, and tertiary document text stayed translucent.+//+//  The fix carries the contrast STATE on the existing `applyTheme` command (so the+//  theme key and its high-contrast variant can never be applied out of step), maps it+//  onto `data-prism-contrast` in prism-theme.js, and keeps the per-theme override+//  values in `document.css` (pinned by DocumentCSSContrastRulesTests).+//++import SwiftUI+import Testing+import WebKit+@testable import prism++@Suite("Increase Contrast reaches the rendered document (T-1829)")+@MainActor+struct WebContrastBridgeTests {++    private func sampleBlocks() -> [MarkdownBlock] {+        [+            .heading(level: 1, text: "Doc"),+            .paragraph(markdown: "Body text with a footnote.[^1]"),+        ]+    }++    // MARK: - Environment mapping++    @Test("colorSchemeContrast maps onto the bridged contrast mode")+    func environmentMapping() {+        #expect(WebContrastMode(ColorSchemeContrast.increased) == .increased)+        #expect(WebContrastMode(ColorSchemeContrast.standard) == .standard)+    }++    @Test("The palette feed pairs the theme key with the contrast state")+    func paletteFeedEquatable() {+        let standard = WebPaletteFeed(themeKey: "prism-dark", contrast: .standard)+        let increased = WebPaletteFeed(themeKey: "prism-dark", contrast: .increased)+        // A contrast-only change must be a distinct value, or the view's single+        // .onChange would never re-push when the user toggles the OS setting.+        #expect(standard != increased)+    }++    // MARK: - Command payload++    @Test("applyTheme's JS payload carries the contrast state")+    func payloadCarriesContrast() {+        let increased = WebDocumentController.payload(+            for: .applyTheme(theme: "prism-dark", contrast: .increased, variables: [:], mermaidConfig: "")+        )+        #expect(increased["contrast"] as? String == "increased")++        let standard = WebDocumentController.payload(+            for: .applyTheme(theme: "prism-dark", contrast: .standard, variables: [:], mermaidConfig: "")+        )+        #expect(standard["contrast"] as? String == "standard")+    }++    // MARK: - Recovery replay (Req 9.6)++    @Test("The coalesced snapshot replays the contrast state after a WebContent recovery")+    func snapshotReplaysContrast() {+        var snapshot = WebDocumentStateSnapshot()+        snapshot.apply(.applyTheme(theme: "prism-dark", contrast: .increased, variables: [:], mermaidConfig: ""))+        #expect(snapshot.theme?.contrast == .increased)+        #expect(snapshot.coalescedCommands().contains(+            .applyTheme(theme: "prism-dark", contrast: .increased, variables: [:], mermaidConfig: "")+        ))++        // Turning the setting off must overwrite, not linger.+        snapshot.apply(.applyTheme(theme: "prism-dark", contrast: .standard, variables: [:], mermaidConfig: ""))+        #expect(snapshot.theme?.contrast == .standard)+    }++    @Test("A contrast-only change is a distinct snapshot")+    func contrastChangesSnapshotIdentity() {+        var standard = WebDocumentStateSnapshot()+        standard.apply(.applyTheme(theme: "prism-light", contrast: .standard, variables: [:], mermaidConfig: ""))+        var increased = WebDocumentStateSnapshot()+        increased.apply(.applyTheme(theme: "prism-light", contrast: .increased, variables: [:], mermaidConfig: ""))+        #expect(standard != increased)+    }++    // MARK: - Synchronizer push++    @Test("The state synchronizer pushes the contrast state with the theme")+    func synchronizerPushesContrast() async {+        // The production assembly — the same entry point DocumentScrollContent uses.+        let session = DocumentSession(+            url: URL(fileURLWithPath: "/tmp/t1829-contrast-fixture.md"),+            content: "# Doc\n\nBody text."+        )+        await session.parseContent()+        let made = WebDocumentStateSynchronizer.makeAssembly(+            session: session,+            settings: AppSettings(),+            coordinator: DocumentLayoutCoordinator(),+            notesManager: NotesManager()+        )+        made.synchronizer.applyTheme(themeKey: "prism-dark", contrast: .increased)+        #expect(made.controller.latestSnapshot.theme?.name == "prism-dark")+        #expect(made.controller.latestSnapshot.theme?.contrast == .increased)++        made.synchronizer.applyTheme(themeKey: "prism-dark", contrast: .standard)+        #expect(made.controller.latestSnapshot.theme?.contrast == .standard)+    }++    // MARK: - Live page (accessibility smoke test)++    @Test("applyTheme toggles the document's contrast attribute live, without a reload")+    func liveContrastAttributeToggles() async throws {+        let harness = try await WebDocumentLiveHarness.make(blocks: sampleBlocks())+        let urlBefore = harness.page.url++        try await harness.send(+            .applyTheme(theme: "prism-dark", contrast: .increased, variables: [:], mermaidConfig: "")+        )+        try await Task.sleep(for: .milliseconds(100))+        var attr = try await harness.evalString(+            "return document.documentElement.getAttribute('data-prism-contrast');"+        )+        #expect(attr == "increased", "the stylesheet's high-contrast blocks key on this attribute")++        // Turning the OS setting back off must restore the base palette exactly —+        // the attribute is removed, so no override survives (nothing is written as an+        // inline style that would have to be unwound).+        try await harness.send(+            .applyTheme(theme: "prism-dark", contrast: .standard, variables: [:], mermaidConfig: "")+        )+        try await Task.sleep(for: .milliseconds(100))+        attr = try await harness.evalString(+            "return document.documentElement.getAttribute('data-prism-contrast');"+        )+        #expect(attr == nil || attr == "")++        #expect(harness.page.url == urlBefore, "contrast changes must not reload the document")+    }+}

diff --git a/prismTests/WebRendering/WebDocumentControllerTests.swift b/prismTests/WebRendering/WebDocumentControllerTests.swiftindex b4d26f8..0437877 100644--- a/prismTests/WebRendering/WebDocumentControllerTests.swift+++ b/prismTests/WebRendering/WebDocumentControllerTests.swift@@ -57,7 +57,7 @@ struct WebDocumentControllerTests {         #expect(generation.processGeneration == 0)          let args = WebDocumentController.arguments(-            for: .applyTheme(theme: "prism-dark", variables: ["--x": "1"], mermaidConfig: ""),+            for: .applyTheme(theme: "prism-dark", contrast: .standard, variables: ["--x": "1"], mermaidConfig: ""),             generation: generation         )         let tag = args["generation"] as? [String: Any]@@ -282,7 +282,7 @@ struct WebDocumentControllerTests {     func commandsQueueUntilReady() {         let controller = makeController()         controller.setCommentVisibility(true)-        controller.applyTheme(theme: "prism-dark", variables: [:])+        controller.applyTheme(theme: "prism-dark", contrast: .standard, variables: [:])         #expect(controller.pendingCommands.count == 2)         #expect(!controller.canDispatch(.setCommentVisibility(true)))     }@@ -291,7 +291,7 @@ struct WebDocumentControllerTests {     func readyFlushesQueue() {         let controller = makeController()         controller.setCommentVisibility(true)-        controller.applyTheme(theme: "prism-dark", variables: [:])+        controller.applyTheme(theme: "prism-dark", contrast: .standard, variables: [:])         controller.test_markReady()         // Non-scroll commands are dispatched and drained from the queue.         #expect(controller.pendingCommands.isEmpty)@@ -328,23 +328,23 @@ struct WebDocumentControllerTests {     @Test("A burst of theme pushes coalesces to the latest in the snapshot")     func snapshotCoalescesThemeBurst() {         var snapshot = WebDocumentStateSnapshot()-        snapshot.apply(.applyTheme(theme: "prism-light", variables: ["--a": "1"], mermaidConfig: ""))-        snapshot.apply(.applyTheme(theme: "prism-dark", variables: ["--a": "2"], mermaidConfig: ""))+        snapshot.apply(.applyTheme(theme: "prism-light", contrast: .standard, variables: ["--a": "1"], mermaidConfig: ""))+        snapshot.apply(.applyTheme(theme: "prism-dark", contrast: .standard, variables: ["--a": "2"], mermaidConfig: ""))         let themes = snapshot.coalescedCommands().filter {             if case .applyTheme = $0 { return true } else { return false }         }-        #expect(themes == [.applyTheme(theme: "prism-dark", variables: ["--a": "2"], mermaidConfig: "")])+        #expect(themes == [.applyTheme(theme: "prism-dark", contrast: .standard, variables: ["--a": "2"], mermaidConfig: "")])     }      @Test("Snapshot replay puts scroll restore last so it runs after theme/layout")     func snapshotReplayOrdersScrollLast() {         var snapshot = WebDocumentStateSnapshot()         snapshot.apply(.scrollToBlock(domID: "b-9-0"))-        snapshot.apply(.applyTheme(theme: "prism-dark", variables: [:], mermaidConfig: ""))+        snapshot.apply(.applyTheme(theme: "prism-dark", contrast: .standard, variables: [:], mermaidConfig: ""))         snapshot.apply(.setSearchState(json: "{}"))         let commands = snapshot.coalescedCommands()         #expect(commands.last == .scrollToBlock(domID: "b-9-0"))-        #expect(commands.first == .applyTheme(theme: "prism-dark", variables: [:], mermaidConfig: ""))+        #expect(commands.first == .applyTheme(theme: "prism-dark", contrast: .standard, variables: [:], mermaidConfig: ""))     }      @Test("Transient page scroll commands are not retained in the snapshot")@@ -361,7 +361,7 @@ struct WebDocumentControllerTests {     func terminationReplaysSnapshot() {         let controller = makeController()         // Establish some native truth, then become ready and drain it.-        controller.applyTheme(theme: "prism-dark", variables: ["--a": "1"])+        controller.applyTheme(theme: "prism-dark", contrast: .standard, variables: ["--a": "1"])         controller.setSearchState(json: "{\"q\":1}")         controller.scrollTo(blockID: "b-3-0")         controller.test_markReady()@@ -376,7 +376,7 @@ struct WebDocumentControllerTests {         #expect(!controller.isLayoutSettled)         // The coalesced snapshot is re-queued: theme, search, then scroll last.         let queued = controller.pendingCommands-        #expect(queued.contains(.applyTheme(theme: "prism-dark", variables: ["--a": "1"], mermaidConfig: "")))+        #expect(queued.contains(.applyTheme(theme: "prism-dark", contrast: .standard, variables: ["--a": "1"], mermaidConfig: "")))         #expect(queued.contains(.setSearchState(json: "{\"q\":1}")))         #expect(queued.last == .scrollToBlock(domID: "b-3-0"))     }

diff --git a/prismTests/WebRendering/WebThemeStateSyncTests.swift b/prismTests/WebRendering/WebThemeStateSyncTests.swiftindex 0099a08..e3f565c 100644--- a/prismTests/WebRendering/WebThemeStateSyncTests.swift+++ b/prismTests/WebRendering/WebThemeStateSyncTests.swift@@ -42,7 +42,12 @@ struct WebThemeStateSyncTests {     func applyThemeNoReload() async throws {         let harness = try await WebDocumentLiveHarness.make(blocks: sampleBlocks())         let urlBefore = harness.page.url-        try await harness.send(.applyTheme(theme: "prism-dark", variables: ["--prism-accent": "#123456"], mermaidConfig: ""))+        try await harness.send(.applyTheme(+            theme: "prism-dark",+            contrast: .standard,+            variables: ["--prism-accent": "#123456"],+            mermaidConfig: ""+        ))         try await Task.sleep(for: .milliseconds(100))          let themeAttr = try await harness.evalString(@@ -66,7 +71,7 @@ struct WebThemeStateSyncTests {                 + "document.addEventListener('prism:retheme', function(){ window.__rethemeSeen = true; }); return null;",             contentWorld: harness.bridgeWorld         )-        try await harness.send(.applyTheme(theme: "refraction", variables: [:], mermaidConfig: ""))+        try await harness.send(.applyTheme(theme: "refraction", contrast: .standard, variables: [:], mermaidConfig: ""))         try await Task.sleep(for: .milliseconds(100))         let seen = try await harness.evalBool("return window.__rethemeSeen === true;")         #expect(seen == true)

diff --git a/prismTests/WebRendering/WebSearchWiringTests.swift b/prismTests/WebRendering/WebSearchWiringTests.swiftindex 43a505f..87be62b 100644--- a/prismTests/WebRendering/WebSearchWiringTests.swift+++ b/prismTests/WebRendering/WebSearchWiringTests.swift@@ -68,7 +68,10 @@ struct WebSearchWiringTests {         )         let controller = made.controller         made.synchronizer.start()-        made.synchronizer.applyTheme(themeKey: settings.theme(for: .light).rawValue)+        made.synchronizer.applyTheme(+            themeKey: settings.theme(for: .light).rawValue,+            contrast: .standard+        )         WebDocumentControllerFactory.pushSearchState(             to: controller,             session: session,

diff --git a/prismTests/WebRendering/HTMLCommentVisibilityLiveTests.swift b/prismTests/WebRendering/HTMLCommentVisibilityLiveTests.swiftindex d1a8874..37b8124 100644--- a/prismTests/WebRendering/HTMLCommentVisibilityLiveTests.swift+++ b/prismTests/WebRendering/HTMLCommentVisibilityLiveTests.swift@@ -139,7 +139,8 @@ struct HTMLCommentVisibilityLiveTests {         WebDocumentControllerFactory.pushInitialState(             to: controller,             settings: settings,-            themeKey: PrismTheme.prismLight.rawValue+            themeKey: PrismTheme.prismLight.rawValue,+            contrast: .standard         )         let url = WebDocumentControllerFactory.documentURL(             session: session, parseRevision: session.parseRevision

diff --git a/prismTests/WebRendering/WebStateSynchronizerAssemblyTests.swift b/prismTests/WebRendering/WebStateSynchronizerAssemblyTests.swiftindex 40599da..f1cbc2d 100644--- a/prismTests/WebRendering/WebStateSynchronizerAssemblyTests.swift+++ b/prismTests/WebRendering/WebStateSynchronizerAssemblyTests.swift@@ -156,7 +156,7 @@ struct WebStateSynchronizerAssemblyTests {     @Test("applyTheme pushes the theme through the synchronizer")     func applyThemePushes() async throws {         let assembly = await makeAssembly()-        assembly.synchronizer.applyTheme(themeKey: "dark")+        assembly.synchronizer.applyTheme(themeKey: "dark", contrast: .standard)         let pushed = await waitUntil {             assembly.controller.latestSnapshot.theme?.name == "dark"         }

diff --git a/specs/a11y-increase-contrast/smolspec.md b/specs/a11y-increase-contrast/smolspec.mdindex ce4c220..bd275d9 100644--- a/specs/a11y-increase-contrast/smolspec.md+++ b/specs/a11y-increase-contrast/smolspec.md@@ -70,3 +70,38 @@ Notes: - **Risk:** The proposed contrast-ratio target of ≥4.5:1 is WCAG AA for normal text. Apple's HIG-style Increase Contrast can go higher (7:1, WCAG AAA) for some users. | **Mitigation:** Aim for ≥4.5:1 minimum; if specific tokens land naturally at 7:1+ keep them there. Don't over-engineer to AAA for tokens that already meet AA. Verify with the [WebAIM Contrast Checker](https://webaim.org/resources/contrastchecker/) using the hex values resolved against each theme's `background`. - **Assumption:** The user's OS reports `.increased` for `Environment(\.colorSchemeContrast)` when Increase Contrast is enabled in Accessibility settings. (Confirmed in Apple's documentation; the env value is two-state: `.standard` / `.increased`.) - **Prerequisite:** The existing 5 themes' default tokens render correctly. (Confirmed — no recent changes to theme color values affecting the five overridden tokens.)++## Addendum: the web renderer (T-1829)++The T-1542 WebKit cutover moved the document body out of the SwiftUI view tree, so the+environment-injected `HighContrastThemeColors` above no longer reached it — the five tokens+reverted to their base values inside the rendered document. `TextualThemeAdapter` (referenced+in "Key files" above) was removed by the cutover and no longer exists.++T-1829 restores the behaviour for the web path, following the same native/CSS split the base+palette uses — native pushes STATE, the stylesheet owns the VALUES:++- `DocumentScrollContent` reads `@Environment(\.colorSchemeContrast)` and pairs it with the+  colorScheme-resolved theme key in one `WebPaletteFeed`, pushed by a single `.onChange`.+- The state travels on the existing `applyTheme` bridge command as a `WebContrastMode`, so the+  theme key and its contrast variant are always applied together (the override values are+  per-theme). It is part of the coalesced snapshot, so a WebContent recovery replays it.+- `prism-theme.js` maps it onto `data-prism-contrast`; `document.css` carries one+  `[data-prism-contrast="increased"]` block per theme with the values from the table above.++`DocumentCSSContrastRulesTests` pins those CSS values against `HighContrastThemeColors`, so+the two representations of the same five tokens cannot drift apart.++**The dimmed add-note affordance.** The requirement above about `AccessibleTableView`'s+`.opacity(0.4)` empty-state glyph also moved: the cutover retired that view and the+affordance now lives in `document.css` as `.prism-add-note` (`opacity: 0.35`, and `0.5`+under `@media (hover: none)`). T-1829 adds+`:root[data-prism-contrast="increased"] .prism-add-note { opacity: 1; }` so the requirement+holds on the surface where the affordance actually exists. It is an element opacity, not a+palette token, so it sits outside the five-token table and outside the anti-drift test; it+has its own rule-pin instead.++**Not covered.** The footnote popover page (`FootnotePopoverWebPage`) has no bridge — it+bakes `RenderSettings.theme` into the emitted HTML — and receives no contrast state. Its+content is limited to paragraphs, lists and blockquotes, which consume none of the five+overridden tokens, so the gap is unobservable today. See decision-log Q4.

diff --git a/specs/a11y-increase-contrast/decision_log.md b/specs/a11y-increase-contrast/decision_log.mdindex 44f63b2..17002fa 100644--- a/specs/a11y-increase-contrast/decision_log.md+++ b/specs/a11y-increase-contrast/decision_log.md@@ -1,5 +1,15 @@ # Decision Log: A11y Increase Contrast Wiring +## Quick Decisions++| ID | Date | Decision | Rationale |+|----|------|----------|-----------|+| Q1 | 2026-07-26 | Record T-1829 as an addendum to this smolspec rather than a `specs/bugfixes/<name>/report.md` | The web-path work restores the *same* requirements this spec already states against a surface that moved; splitting the token table across two documents would create the drift the addendum exists to prevent |+| Q2 | 2026-07-26 | `contrast` carries no default on `WebDocumentController.applyTheme`, `WebDocumentStateSynchronizer.applyTheme`, and `WebDocumentControllerFactory.pushInitialState` | A silently-`.standard` default is the exact shape of the regression this ticket fixes: a push path that keeps compiling while dropping the contrast state. Cost is churn at call sites and 6 test files, paid once |+| Q3 | 2026-07-26 | `WebDocumentStateSnapshot.theme` becomes a `ThemePush` struct instead of growing the 4-member tuple | Tuples have no synthesised `Equatable`; the hand-written `==` it replaces would have silently ignored a newly-added field |+| Q4 | 2026-07-26 | The footnote popover page is **not** given a contrast path | It has no bridge, so contrast would have to be baked into `RenderSettings`/`BlockHTMLEmitter`. Its content is restricted to paragraphs, lists and blockquotes, none of which consume the five overridden tokens, so the gap is currently unobservable. Revisit if the popover ever renders badges, comments or search highlights |+| Q5 | 2026-07-26 | A contrast-only `applyTheme` push still dispatches `prism:retheme`, re-rendering in-page mermaid diagrams | Guarding the dispatch would add state to `prism-theme.js` to save work on a setting toggled rarely, and diagrams do not consume the overridden tokens, so the re-render is wasteful but correct. Tracked as a possible follow-up, not fixed here |+ ## Decision 1: Wrapper-with-per-theme-overrides instead of full high-contrast theme variants  **Date**: 2026-05-20@@ -107,3 +117,42 @@ Under increased contrast, `textTertiary` MUST be darkened (light themes) or ligh - Per-theme hex values must be picked and visually verified; cannot fall back to a system semantic colour.  ---++## Decision 4: Push the contrast STATE, keep the per-theme VALUES in `document.css`++**Date**: 2026-07-26+**Status**: accepted++### Context++The T-1542 WebKit cutover moved the document body out of the SwiftUI view tree, so the `HighContrastThemeColors` value `ThemeModifier` injects into the environment (Decision 1) no longer reached it — the five overridden tokens reverted to their base values inside the rendered document (T-1829).++The `applyTheme` bridge command already carries a `variables: [String: String]` overlay that could have shipped the five *resolved* `HighContrastThemeColors` colours to the page, making the Swift wrapper the single source of truth for both surfaces.++### Decision++Native pushes only the contrast STATE — a `WebContrastMode` that `prism-theme.js` maps onto a `data-prism-contrast` attribute. `document.css` carries one `[data-prism-contrast="increased"]` block per theme holding the values, mirroring `HighContrastThemeColors`. `DocumentCSSContrastRulesTests` pins the two representations together on both the RGB and the alpha axis.++### Rationale++- It is the split the base palette already uses: native pushes the theme KEY, the stylesheet owns the colours. A second, different mechanism for the contrast variant would be the odd one out.+- Toggling the setting off is then exact. Removing an attribute restores the base block with nothing to unwind; pushing values through `variables` writes inline styles on the root element that a later "off" push would have to explicitly clear, and any missed token would stick.+- The override values are per-theme, so the palette block and its contrast variant must change atomically — which the attribute gives for free, since both come off one command.++### Alternatives Considered++- **Push the resolved colours through the existing `variables` overlay**: Removes the duplication outright and keeps `HighContrastThemeColors` as the one source of truth. Rejected because clearing inline root styles on toggle-off is error-prone in exactly the direction that fails silently (a stale override survives), and because it diverges from the established native-state/CSS-values split.+- **A separate `applyContrast` bridge command**: Cleaner command surface. Rejected because a split push has a frame in which a newly-selected theme still wears the previous theme's overrides — the values are per-theme, so the two are not independent.+- **Bake `data-prism-contrast` into the emitted HTML like `RenderSettings.theme`**: Would require a re-emit and reload on every toggle, losing reading position — the opposite of the live-update requirement.++### Consequences++**Positive:**+- Toggling Increase Contrast is a single attribute write; no reload, no lost reading position, and it replays through the coalesced snapshot after a WebContent recovery.+- The base palette and its contrast variant are always applied together.++**Negative:**+- The five override values exist twice, in Swift and in CSS. Mitigated, not removed, by the anti-drift test.+- Four of the five tokens (`searchMatchBackground`, `searchMatchCurrentBackground`, `footnoteBadgeBackground`, `footnoteBadgeForeground`) now have no native consumer outside `prism/Theme/`, so the Swift "source of truth" for them renders nothing itself.++---

diff --git a/specs/a11y-increase-contrast/tasks.md b/specs/a11y-increase-contrast/tasks.mdindex ae79296..35522c4 100644--- a/specs/a11y-increase-contrast/tasks.md+++ b/specs/a11y-increase-contrast/tasks.md@@ -5,6 +5,13 @@ references: --- # A11y Increase Contrast Wiring (T-1045) +> **Status note (T-1829, 2026-07-26).** Tasks 3 and 4 are **superseded by the T-1542 WebKit+> cutover**: `prism/Views/AccessibleTableView.swift` and `TextualThemeAdapter` no longer+> exist. The dimmed affordance task 3 targeted now lives in `document.css` as+> `.prism-add-note` and is handled by T-1829's contrast override; task 4's adapter has no+> successor. See the "Addendum: the web renderer (T-1829)" section of `smolspec.md` for the+> work that replaced them.+ - [ ] 1. HighContrastThemeColors wrapper with pass-through and per-theme overrides <!-- id:t1045a -->   - Add `prism/Theme/HighContrastThemeColors.swift` containing a struct that conforms to `ThemeColors`, takes a single `PrismTheme` in its initializer (deriving the stored `base: any ThemeColors` and `themeIdentity: PrismTheme` from it), and forwards every protocol property (~30) to `base` via computed properties.   - Override `searchMatchBackground`, `searchMatchCurrentBackground`, `footnoteBadgeBackground`, `footnoteBadgeForeground`, and `textTertiary` via a private `switch` on `themeIdentity` using the per-theme hex table in `smolspec.md`.

diff --git a/CLAUDE.md b/CLAUDE.mdindex f9e5f00..ed32b0a 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -50,7 +50,7 @@ The document is rendered by WebKit-for-SwiftUI (`WebView`/`WebPage`). The SwiftU 1. **Parse**: `swift-markdown` → AST → `MarkdownBlock` enum variants (`MarkdownBlockParser`), unchanged from before. T-1558 made the model lossless for nested blockquotes, ordered-list `start`, and rich blocks inside list items (see `specs/web-markdown-fidelity/`). 2. **Emit**: `BlockHTMLEmitter` (`prism/Services/WebRendering/`) is a pure, deterministic function of `[MarkdownBlock]` + `FootnoteData` + `RenderSettings`. It emits one `<section>` per block carrying the content-hash block identity and an occurrence-qualified DOM id (`b-{hash}-{sourceIndex}`, allocated via the shared `BlockDOMID`), escapes by default, and is total (a block that fails to emit falls back to escaped-source `<pre>`, never dropped). `InlineHTMLRenderer` wraps mappable text runs in `<span data-prism-run>` and records a `DocumentSourceMap` (UTF-16 offsets, shipped as an inert `<div hidden>` data island) for selection-anchored notes. `emit` (and the model/service value types it reads) is `nonisolated`, so it runs off the MainActor: `WebDocumentControllerFactory.precomputeDocumentHTML` emits once per `parseRevision` on a `Task.detached` and caches the HTML on `DocumentSession`; the scheme handler serves that cache (synchronous on-main emit only on a miss). Its per-block/inline `HTMLSanitizer` (SwiftSoup) passes are serialized behind a shared `Mutex` because SwiftSoup keeps unsynchronized static pools (T-1681, `specs/offmain-html-emit/`). 3. **Serve**: `PrismDocSchemeHandler` (`prism-doc://` `URLSchemeHandler`) is the single audited I/O path — it serves the document HTML, `document.css` (the only asset fetched through the scheme), and mediates every image subresource through `/img/?src=` (rewritten absolute/relative URLs routed via `ImagePathResolver`/`ImageLoader`/`SVGSourceLoader`). It serves the verbatim CSP (`script-src 'none'`, `connect-src 'none'`, …) as a response header. The document is loaded via the scheme, never `loadHTMLString`.-4. **Host + bridge**: `WebDocumentController`/`WebDocumentView` (`prism/ViewModels/`, `prism/Views/`) own one `WebPage` per session (non-persistent store, `allowsContentJavaScript = false`, all JS injected as user scripts via `WebDocumentControllerFactory.userScripts()`). The native↔JS bridge runs in a dedicated isolated `WKContentWorld`; every message in both directions carries a generation tag (sessionID, parseRevision, processGeneration). `BridgeMessageRouter` validates inbound messages against an enumerated allowlist + exact-generation match and drops forged/stale/malformed ones; `WebDocumentMessageRouter` routes accepted messages onto the existing native session/coordinator state. Outbound commands queue until `ready`; scroll restore waits for `layoutSettled`; on WebContent termination the controller bumps the process generation, reloads, and replays one coalesced state snapshot. `WebDocumentStateSynchronizer` (T-1719) is the single production owner that pushes native truth (sections, details open-state, table modes, notes, typography, comment visibility) to the controller and routes navigation targets (TOC/fragment via `session.pendingAnchorScroll`, notes via `coordinator.noteNavigationTarget`, search current match) through `controller.scrollTo` with `BlockDOMID.navigationDOMID` id translation — Observation-framework driven, so it works with no view mounted; `DocumentScrollContent` mounts the whole assembly via `WebDocumentStateSynchronizer.makeAssembly` (theme alone is view-fed, via `applyTheme(themeKey:)`, because it depends on colorScheme).+4. **Host + bridge**: `WebDocumentController`/`WebDocumentView` (`prism/ViewModels/`, `prism/Views/`) own one `WebPage` per session (non-persistent store, `allowsContentJavaScript = false`, all JS injected as user scripts via `WebDocumentControllerFactory.userScripts()`). The native↔JS bridge runs in a dedicated isolated `WKContentWorld`; every message in both directions carries a generation tag (sessionID, parseRevision, processGeneration). `BridgeMessageRouter` validates inbound messages against an enumerated allowlist + exact-generation match and drops forged/stale/malformed ones; `WebDocumentMessageRouter` routes accepted messages onto the existing native session/coordinator state. Outbound commands queue until `ready`; scroll restore waits for `layoutSettled`; on WebContent termination the controller bumps the process generation, reloads, and replays one coalesced state snapshot. `WebDocumentStateSynchronizer` (T-1719) is the single production owner that pushes native truth (sections, details open-state, table modes, notes, typography, comment visibility) to the controller and routes navigation targets (TOC/fragment via `session.pendingAnchorScroll`, notes via `coordinator.noteNavigationTarget`, search current match) through `controller.scrollTo` with `BlockDOMID.navigationDOMID` id translation — Observation-framework driven, so it works with no view mounted; `DocumentScrollContent` mounts the whole assembly via `WebDocumentStateSynchronizer.makeAssembly` (the palette alone is view-fed, via `applyTheme(themeKey:contrast:)`, because it depends on view-world environment values — the colorScheme-resolved theme key plus `colorSchemeContrast`, grouped as a `WebPaletteFeed` so a single `.onChange` pushes them together and they can never be applied out of step; T-1829). 5. **Notes**: `NoteStateFeeder` (`prism/Services/WebRendering/`) maps `NotesManager` state onto `setNoteIndicators`/`setInlineNotes` payloads; `NoteHTMLBuilder` renders the (escaped) bubble/banner HTML natively; `prism-notes.js` (isolated world) injects it as `data-prism-chrome` and posts interaction messages back. 6. **Search**: counts and navigation order stay in `SearchService`/`SearchCoordinator`. `SearchStateFeeder` translates that into a per-block `setSearchState` payload; `prism-search.js` re-finds the query in each block's rendered text and registers ranges on two named **CSS Custom Highlights** (`prism-search`, `prism-search-current`), windowed to the viewport. The web view's built-in find navigator stays disabled so Cmd+F routes to Prism's search. 7. **Security**: `HTMLSanitizer` (over SwiftSoup) reduces raw HTML embedded in markdown to an allowlist subset on load (Req 1.8/8.1); its `plainText` feeds searchable text. Combined with `allowsContentJavaScript = false` and the served CSP, active-content vectors are blocked by construction.

diff --git a/CHANGELOG.md b/CHANGELOG.mdindex c78d7e9..06bfe1f 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 +- The system **Increase Contrast** accessibility setting applies to the document again (T-1829). Since the WebKit rendering cutover, turning it on changed the app's own interface but left the document body untouched: search highlights and footnote badges stayed translucent and tertiary text stayed low-contrast. The rendered document now uses the same higher-contrast search, footnote, and tertiary colours as the rest of the app, on every theme, and the deliberately-faded "add note" button beside each block is shown at full strength. It follows the setting live — toggling it while a document is open updates immediately, without a reload and without losing your reading position, and the styling survives a WebKit process recovery. Footnote popovers keep the standard palette. - The saved reading position is no longer corrupted by content the document does not show (T-1851). Hidden content measures as sitting exactly at the top of the window, which beat every genuinely visible block, so the document reported a block the reader could not see as the block being read. That happened with any heading collapsed, and — because the carrier holding a document's YAML frontmatter is hidden the same way — on every document that starts with frontmatter, collapsed or not. Reopening the document, returning from raw source, or recovering from a rendering-process restart then landed on the wrong block or did nothing at all. Content the document does not lay out is now skipped when working out the reading position. - Opening or reloading a large or HTML-heavy document no longer freezes the UI (T-1681). Since the WebKit rendering cutover, the full document HTML — including a SwiftSoup sanitisation pass per raw-HTML block and per inline HTML run — was built synchronously on the main thread on every serve, so a big or markup-dense document blocked the app while it rendered, and re-built the HTML on every reload. The build now runs off the main thread and its result is cached per parse: the UI stays responsive, and reloads (external file change, URL refresh, WebContent-process recovery, the iOS folder-access retry) reuse the cached HTML instead of re-emitting. Very HTML-dense documents can still take a noticeable moment to appear; making that incremental is tracked separately. - Search matches are highlighted in the rendered document again (T-1680). Since the WebKit rendering cutover, searching counted matches and navigated natively but the page never showed a highlight — the native→web search-state feed was never connected. Matches now light up as you type, the current match gets its distinct emphasis and scrolls into view when navigating (including when a result is picked from the iPhone search overlay), footnote badges whose content matches are marked, and dismissing search clears the highlights.