-| SQLite archive | Archive v2 schema, snapshot-level observation grouping, differential write path, v2 verification/delete bookkeeping, daily aggregate rebuilds, integrity report, v2 record reads, SQL diff/count/aggregate/provenance/consolidation-evidence APIs, large synthetic diff pagination coverage, formal timing/memory metrics, and XCTest coverage are in place; the legacy `archive_samples` mirror has been removed | Continue replacing remaining transition detail/PDF paths with archive/cache DTOs |

-| SwiftData cache | Exists; test builds now reset legacy prototype UI/archive/cache stores once for archive v2 so old SwiftData-only snapshots are not treated as backed-up observations. Metric timeout calibration, local device profile settings, operation logging, ContentView preview, Settings data maintenance, and legacy anomaly/count-drop review have moved outside SwiftData or been removed. Remaining SwiftData imports are inventoried in [`SwiftData-Retirement-Inventory.md`](SwiftData-Retirement-Inventory.md) | Treat as disposable prototype data; replace capture/review actions and transition detail/PDF paths before removing `ModelContainer` |

-| UI | Prototype exists; Dashboard status reads archive/cache observation rows and shows cache health, with SwiftData retained only for capture/review actions; Snapshots and Data Types tab roots no longer import SwiftData, load Core Data cached observation rows, and open archive/cache-backed detail rows; `SnapshotArchiveDetailView` and `DataTypeArchiveDetailView` read Core Data type/diff summaries and page record drill-down through SQLite; legacy `SnapshotDetailView`/`DataTypeSnapshotDetailView` remain as transition views outside the active tab roots; record-change evolution and temporal distribution screens now receive DTO rows/cache input instead of querying SwiftData directly; export preview reads the archive export API before showing/exporting JSON; simplified detail mode replaces heavy charts with summary rows on small/accessibility layouts or when enabled in Settings; visible change labels now use neutral new/missing/change-review language, with already-existing SwiftData detail cache as transition fallback | Remove or isolate remaining SwiftData transition detail/PDF paths |

-1. Remove or isolate remaining SwiftData transition detail/PDF paths.

-- Current UI/cache layers still depend on 17 SwiftData-backed files for launch container, capture review actions, legacy transition detail paths, model definitions, and PDF paths.

-- Legacy SwiftData-only snapshots can show diffs without archive-backed values; they are now reset for archive v2 test installs rather than migrated.

-  longer import SwiftData; Dashboard capture/review actions and legacy

-  transition detail/PDF paths remain.

-observations, 17 app files still have SwiftData imports because capture,

-Dashboard review actions, legacy detail transition paths, model definitions, and

-PDF/export transition paths still use prototype snapshot handles.

-- replace prototype snapshot model dependencies in tab roots;

-- remove `.modelContainer(...)` once no active view needs `@Query` or

-  `ModelContext`.

-- make capture persist archive observations first and expose only bridge ids

-  while transition UI still exists;

-- move operation logging out of SwiftData;

-- remove snapshot deletion/repair logic after archive/cache navigation replaces

-  prototype snapshots.

-- `HealthProbe/Views/Snapshots/DataTypeSnapshotDetailView.swift`

-- `HealthProbe/Views/Snapshots/SnapshotDetailView.swift`

-- replace detail navigation parameters from SwiftData models to observation/type

-  DTOs;

-- remove remaining snapshot/cache SwiftData rows from active flows;

-- keep paged record drill-down and export paths on archive APIs.

-  by Settings, Dashboard, Snapshots, and legacy PDF export.

-- `HealthProbe/Views/Snapshots/SnapshotDetailView.swift` no longer queries

-  `SnapshotDelta`/`TypeDelta` or carries the old SwiftData type-delta/chart

-  fallback. Snapshot detail type rows now require archive/cache summaries; the

-  temporary SwiftData dependency is limited to snapshot navigation, metadata,

-  and PDF export handles.

-- `HealthProbe/Views/Snapshots/DataTypeSnapshotDetailView.swift` no longer

-  queries `SnapshotDelta`/`TypeDelta` and no longer rebuilds legacy

-  `TypeCount.detailCache` rows from the UI. It reads Core Data/SQLite diff

-  summaries first and only displays an already-existing legacy detail cache as a

-  transition fallback.

-2. Delete or isolate unused SwiftData snapshot/type detail transition views once

-   PDF/export and any remaining preview paths have archive/cache replacements.

-import CoreGraphics

-import CoreText

-import Foundation

-

-// MARK: - Report data (value type, Sendable — passed to background task)

-

-struct SnapshotReportData: Sendable {

-    let timestamp: Date

-    let osVersion: String

-    let deviceName: String

-    let deviceID: String

-    let typeCounts: [TypeCountData]

-    let baseline: BaselineData?

-

-    struct TypeCountData: Sendable {

-        let identifier: String

-        let displayName: String

-        let count: Int

-    }

-

-    struct BaselineData: Sendable {

-        let timestamp: Date

-        let totalChange: Int

-        let changedCount: Int

-        let countByIdentifier: [String: Int]

-    }

-}

-

-// MARK: - Exporter

-

-enum SnapshotPDFExporter {

-

-    /// Reads SwiftData models. Must be called on the main actor.

-    @MainActor

-    static func extractReportData(

-        snapshot: HealthSnapshot,

-        baseline: HealthSnapshot?,

-        profile: LocalDeviceProfile?

-    ) -> SnapshotReportData {

-        let profileName: String? = {

-            guard let n = profile?.name, !n.isEmpty else { return nil }

-            return n

-        }()

-

-        let typeCounts = (snapshot.typeCounts ?? [])

-            .sorted { $0.displayName.localizedCompare($1.displayName) == .orderedAscending }

-            .map {

-                SnapshotReportData.TypeCountData(

-                    identifier: $0.typeIdentifier,

-                    displayName: $0.displayName,

-                    count: $0.count

-                )

-            }

-

-        let baselineData: SnapshotReportData.BaselineData?

-        if let baseline {

-            let baselineCountByIdentifier = Dictionary(

-                uniqueKeysWithValues: (baseline.typeCounts ?? []).map { ($0.typeIdentifier, $0.count) }

-            )

-            let comparableCurrentCounts = (snapshot.typeCounts ?? []).filter { currentType in

-                currentType.quality == .complete &&

-                (baseline.typeCounts ?? []).contains {

-                    $0.typeIdentifier == currentType.typeIdentifier && $0.quality == .complete

-                }

-            }

-            let totalChange = comparableCurrentCounts.reduce(0) { partial, currentType in

-                partial + abs(currentType.count - (baselineCountByIdentifier[currentType.typeIdentifier] ?? 0))

-            }

-            let changedCount = comparableCurrentCounts.filter {

-                $0.count != (baselineCountByIdentifier[$0.typeIdentifier] ?? 0)

-            }.count

-

-            baselineData = SnapshotReportData.BaselineData(

-                timestamp: baseline.timestamp,

-                totalChange: totalChange,

-                changedCount: changedCount,

-                countByIdentifier: baselineCountByIdentifier

-            )

-        } else {

-            baselineData = nil

-        }

-

-        // Device ID is truncated to first 8 chars — enough for local correlation,

-        // not enough to uniquely identify the device in a shared report.

-        let rawID = snapshot.deviceID

-        let displayID = rawID.isEmpty ? "—" : String(rawID.prefix(8)) + "…"

-

-        return SnapshotReportData(

-            timestamp: snapshot.timestamp,

-            osVersion: snapshot.osVersion.isEmpty ? "—" : snapshot.osVersion,

-            deviceName: profileName ?? "This Device",

-            deviceID: displayID,

-            typeCounts: typeCounts,

-            baseline: baselineData

-        )

-    }

-

-    /// Generates PDF using only CoreGraphics + CoreText. Safe to call off the main thread.

-    static func generatePDF(from data: SnapshotReportData) -> Data {

-        let pageSize = CGSize(width: 595.2, height: 841.8)

-        let pdfData = NSMutableData()

-        guard let consumer = CGDataConsumer(data: pdfData as CFMutableData) else { return Data() }

-        var mediaBox = CGRect(origin: .zero, size: pageSize)

-        guard let ctx = CGContext(consumer: consumer, mediaBox: &mediaBox, nil) else { return Data() }

-

-        let pen = Pen(ctx: ctx, pageSize: pageSize, margin: 48)

-        pen.beginPage()

-

-        drawPageHeader(pen, timestamp: data.timestamp)

-        drawSummarySection(pen, data: data)

-        drawDeviceSection(pen, data: data)

-        if let baseline = data.baseline {

-            drawComparisonSection(pen, baseline: baseline)

-        }

-        drawDataTypesSection(pen, data: data)

-        pen.endPage()

-

-        ctx.closePDF()

-        return pdfData as Data

-    }

-

-    // MARK: - Sections

-

-    private static func drawPageHeader(_ pen: Pen, timestamp: Date) {

-        text("HealthProbe", x: pen.margin, y: pen.y, font: pf(10), color: .secondary, pen: pen)

-        pen.advance(16)

-        text("Snapshot Report", x: pen.margin, y: pen.y, font: pf(22, .bold), color: .primary, pen: pen)

-        pen.advance(30)

-        text("Generated \(formatted(Date()))", x: pen.margin, y: pen.y, font: pf(9), color: .secondary, pen: pen)

-        pen.advance(14)

-        rule(pen)

-        pen.advance(16)

-    }

-

-    private static func drawSummarySection(_ pen: Pen, data: SnapshotReportData) {

-        let total = data.typeCounts.filter { $0.count > 0 }.reduce(0) { $0 + $1.count }

-        sectionTitle(pen, "Summary")

-        keyValue(pen, "Captured",      value: formatted(data.timestamp))

-        keyValue(pen, "Tracked Types", value: "\(data.typeCounts.count)")

-        keyValue(pen, "Total Records", value: "\(total)")

-        pen.advance(12)

-    }

-

-    private static func drawDeviceSection(_ pen: Pen, data: SnapshotReportData) {

-        sectionTitle(pen, "Device")

-        keyValue(pen, "Name",      value: data.deviceName)

-        keyValue(pen, "OS",        value: data.osVersion)

-        keyValue(pen, "Device ID", value: data.deviceID)

-        pen.advance(12)

-    }

-

-    private static func drawComparisonSection(_ pen: Pen, baseline: SnapshotReportData.BaselineData) {

-        sectionTitle(pen, "Comparison vs. Baseline")

-        keyValue(pen, "Baseline Date",  value: formatted(baseline.timestamp))

-        keyValue(pen, "Total Changes",  value: baseline.totalChange == 0 ? "None" : "\(baseline.totalChange) records")

-        keyValue(pen, "Changed Types",  value: "\(baseline.changedCount)")

-        pen.advance(12)

-    }

-

-    private static func drawDataTypesSection(_ pen: Pen, data: SnapshotReportData) {

-        guard !data.typeCounts.isEmpty else { return }

-        let hasBaseline = data.baseline != nil

-        sectionTitle(pen, "Data Types (\(data.typeCounts.count))")

-        tableHeader(pen, hasBaseline: hasBaseline)

-        for tc in data.typeCounts {

-            pen.checkBreak(height: 16)

-            let delta = data.baseline?.countByIdentifier[tc.identifier].map { tc.count - $0 }

-            tableRow(pen, tc: tc, delta: delta, hasBaseline: hasBaseline)

-        }

-    }

-

-    // MARK: - Drawing primitives

-

-    private static func sectionTitle(_ pen: Pen, _ title: String) {

-        pen.checkBreak(height: 40)

-        text(title, x: pen.margin, y: pen.y, font: pf(12, .semibold), color: .primary, pen: pen)

-        pen.advance(18)

-    }

-

-    private static func keyValue(_ pen: Pen, _ label: String, value: String) {

-        pen.checkBreak(height: 18)

-        let f = pf(10)

-        text(label, x: pen.margin, y: pen.y, font: f, color: .secondary, pen: pen)

-        text(value, x: pen.margin + pen.contentWidth - tw(value, font: f), y: pen.y, font: f, color: .primary, pen: pen)

-        pen.advance(16)

-    }

-

-    private static func tableHeader(_ pen: Pen, hasBaseline: Bool) {

-        let f = pf(8, .semibold)

-        let countRight = pen.margin + pen.contentWidth - (hasBaseline ? 100 : 0)

-        let deltaRight = pen.margin + pen.contentWidth

-

-        text("TYPE",  x: pen.margin,                  y: pen.y, font: f, color: .tertiary, pen: pen)

-        text("COUNT", x: countRight - tw("COUNT", font: f), y: pen.y, font: f, color: .tertiary, pen: pen)

-        if hasBaseline {

-            text("DELTA", x: deltaRight - tw("DELTA", font: f), y: pen.y, font: f, color: .tertiary, pen: pen)

-        }

-        pen.advance(12)

-        rule(pen, alpha: 0.35, width: 0.25)

-        pen.advance(4)

-    }

-

-    private static func tableRow(

-        _ pen: Pen,

-        tc: SnapshotReportData.TypeCountData,

-        delta: Int?,

-        hasBaseline: Bool

-    ) {

-        let nf = pf(9)

-        let mf = mf(9)

-        let countRight = pen.margin + pen.contentWidth - (hasBaseline ? 100 : 0)

-        let deltaRight = pen.margin + pen.contentWidth

-        let maxNameW   = countRight - pen.margin - 12

-

-        var name = tc.displayName

-        if tw(name, font: nf) > maxNameW { name = String(name.prefix(45)) + "…" }

-        text(name, x: pen.margin, y: pen.y, font: nf, color: .primary, pen: pen)

-

-        let cs = tc.count < 0 ? "err" : "\(tc.count)"

-        text(cs, x: countRight - tw(cs, font: mf), y: pen.y, font: mf, color: .primary, pen: pen)

-

-        if hasBaseline, let delta {

-            let ds  = delta == 0 ? "—" : (delta > 0 ? "+\(delta)" : "\(delta)")

-            let col: CGColor = delta > 0 ? .orange : delta < 0 ? .red : .tertiary

-            text(ds, x: deltaRight - tw(ds, font: mf), y: pen.y, font: mf, color: col, pen: pen)

-        }

-        pen.advance(15)

-    }

-

-    private static func rule(_ pen: Pen, alpha: CGFloat = 1, width: CGFloat = 0.5) {

-        let cgY = pen.pageSize.height - pen.y

-        pen.ctx.saveGState()

-        pen.ctx.setStrokeColor(CGColor(gray: 0.75, alpha: alpha))

-        pen.ctx.setLineWidth(width)

-        pen.ctx.move(to: CGPoint(x: pen.margin, y: cgY))

-        pen.ctx.addLine(to: CGPoint(x: pen.margin + pen.contentWidth, y: cgY))

-        pen.ctx.strokePath()

-        pen.ctx.restoreGState()

-        pen.advance(6)

-    }

-

-    // MARK: - CoreText

-

-    private static func text(

-        _ string: String,

-        x: CGFloat,

-        y: CGFloat,

-        font: CTFont,

-        color: CGColor,

-        pen: Pen

-    ) {

-        let attrStr = NSAttributedString(string: string, attributes: [

-            kCTFontAttributeName as NSAttributedString.Key: font,

-            kCTForegroundColorAttributeName as NSAttributedString.Key: color

-        ])

-        let line = CTLineCreateWithAttributedString(attrStr)

-        let cgY = pen.pageSize.height - y - CTFontGetAscent(font)

-        pen.ctx.textMatrix = .identity

-        pen.ctx.textPosition = CGPoint(x: x, y: cgY)

-        CTLineDraw(line, pen.ctx)

-    }

-

-    private static func tw(_ string: String, font: CTFont) -> CGFloat {

-        let attrStr = NSAttributedString(string: string, attributes: [

-            kCTFontAttributeName as NSAttributedString.Key: font

-        ])

-        return CGFloat(CTLineGetTypographicBounds(CTLineCreateWithAttributedString(attrStr), nil, nil, nil))

-    }

-

-    // MARK: - Font helpers (CTFont, no UIKit)

-

-    private enum Weight { case regular, semibold, bold }

-

-    private static func pf(_ size: CGFloat, _ weight: Weight = .regular) -> CTFont {

-        let name: CFString

-        switch weight {

-        case .regular:  name = "HelveticaNeue" as CFString

-        case .semibold: name = "HelveticaNeue-Medium" as CFString

-        case .bold:     name = "HelveticaNeue-Bold" as CFString

-        }

-        return CTFontCreateWithName(name, size, nil)

-    }

-

-    private static func mf(_ size: CGFloat) -> CTFont {

-        CTFontCreateWithName("Menlo-Regular" as CFString, size, nil)

-    }

-

-    private static func formatted(_ date: Date) -> String {

-        let f = DateFormatter()

-        f.dateStyle = .medium

-        f.timeStyle = .short

-        return f.string(from: date)

-    }

-}

-

-// MARK: - CGColor shortcuts

-

-private extension CGColor {

-    static let primary   = CGColor(gray: 0.05, alpha: 1)

-    static let secondary = CGColor(gray: 0.40, alpha: 1)

-    static let tertiary  = CGColor(gray: 0.60, alpha: 1)

-    static let orange    = CGColor(srgbRed: 1.00, green: 0.58, blue: 0.00, alpha: 1)

-    static let red       = CGColor(srgbRed: 1.00, green: 0.23, blue: 0.19, alpha: 1)

-}

-

-// MARK: - Pen (page state, CoreGraphics only)

-

-private final class Pen {

-    let ctx: CGContext

-    let pageSize: CGSize

-    let margin: CGFloat

-    private(set) var y: CGFloat

-    private(set) var pageNumber: Int = 0

-

-    var contentWidth: CGFloat  { pageSize.width  - margin * 2 }

-    var bottomBoundary: CGFloat { pageSize.height - margin - 28 }

-

-    init(ctx: CGContext, pageSize: CGSize, margin: CGFloat) {

-        self.ctx      = ctx

-        self.pageSize = pageSize

-        self.margin   = margin

-        self.y        = margin

-    }

-

-    func beginPage() {

-        ctx.beginPDFPage(nil)

-        y = margin

-        pageNumber += 1

-    }

-

-    func endPage() {

-        drawFooter()

-        ctx.endPDFPage()

-    }

-

-    func advance(_ delta: CGFloat) { y += delta }

-

-    func checkBreak(height: CGFloat) {

-        guard y + height > bottomBoundary else { return }

-        endPage()

-        beginPage()

-    }

-

-    private func drawFooter() {

-        let footerFont  = CTFontCreateWithName("HelveticaNeue" as CFString, 8, nil)

-        let footerColor = CGColor(gray: 0.6, alpha: 1)

-        let ascent      = CTFontGetAscent(footerFont)

-        let sepCGY      = margin                    // separator y in CGContext (from bottom)

-        let textCGY     = margin - 10 - ascent      // text y in CGContext

-

-        // Separator

-        ctx.saveGState()

-        ctx.setStrokeColor(CGColor(gray: 0.75, alpha: 0.4))

-        ctx.setLineWidth(0.5)

-        ctx.move(to: CGPoint(x: margin, y: sepCGY))

-        ctx.addLine(to: CGPoint(x: pageSize.width - margin, y: sepCGY))

-        ctx.strokePath()

-        ctx.restoreGState()

-

-        func footerLine(_ str: String, x: CGFloat) {

-            let a = NSAttributedString(string: str, attributes: [

-                kCTFontAttributeName as NSAttributedString.Key: footerFont,

-                kCTForegroundColorAttributeName as NSAttributedString.Key: footerColor

-            ])

-            let line = CTLineCreateWithAttributedString(a)

-            ctx.textMatrix = .identity

-            ctx.textPosition = CGPoint(x: x, y: textCGY)

-            CTLineDraw(line, ctx)

-        }

-

-        footerLine("HealthProbe — Snapshot Report", x: margin)

-

-        let pageStr   = "Page \(pageNumber)"

-        let pageAttr  = NSAttributedString(string: pageStr, attributes: [

-            kCTFontAttributeName as NSAttributedString.Key: footerFont

-        ])

-        let pageWidth = CGFloat(CTLineGetTypographicBounds(CTLineCreateWithAttributedString(pageAttr), nil, nil, nil))

-        footerLine(pageStr, x: pageSize.width - margin - pageWidth)

-    }

-}

-import SwiftUI

-import SwiftData

-

-struct DataTypeSnapshotDetailView: View {

-    let snapshot: HealthSnapshot

-    let typeIdentifier: String

-    let displayName: String

-

-    @Environment(AppSettings.self) private var appSettings

-    @Environment(\.dynamicTypeSize) private var dynamicTypeSize

-    @Environment(\.horizontalSizeClass) private var horizontalSizeClass

-    @Query(sort: \HealthSnapshot.timestamp) private var allSnapshots: [HealthSnapshot]

-

-    @State private var displayedSnapshot: HealthSnapshot?

-    @State private var diffState: RecordDiffState = .idle

-    @State private var showAddedRecords = false

-    @State private var showDisappearedRecords = false

-    @State private var showTemporalDistribution = false

-    @State private var detailCacheDiagnostic: String?

-    @State private var currentCachedTypeSummary: CachedArchiveTypeSummary?

-    @State private var previousCachedTypeSummary: CachedArchiveTypeSummary?

-    @State private var contentWidth: CGFloat = 744

-

-    private var currentSnapshot: HealthSnapshot {

-        displayedSnapshot ?? snapshot

-    }

-

-    private var timelineSnapshots: [HealthSnapshot] {

-        allSnapshots.filter { candidate in

-            if currentSnapshot.deviceID.isEmpty {

-                return candidate.deviceID.isEmpty

-            }

-            return candidate.deviceID == currentSnapshot.deviceID

-        }

-        .sorted(by: HealthSnapshot.timelineSort)

-    }

-

-    private var previousSnapshot: HealthSnapshot? {

-        currentSnapshot.previousInTimeline(timelineSnapshots)

-    }

-

-    private var currentTypeCount: TypeCount? {

-        typeCount(in: currentSnapshot)

-    }

-

-    private var previousTypeCount: TypeCount? {

-        previousSnapshot.flatMap(typeCount(in:))

-    }

-

-    private var isCurrentTypeContentAliasToPrevious: Bool {

-        guard let currentTypeCount,

-              let previousTypeCount else { return false }

-        return currentTypeCount.contentEquivalentTypeCountID == previousTypeCount.contentRepresentativeTypeCountID

-    }

-

-    private var hasTemporalDistributionCache: Bool {

-        temporalDistributionInput != nil

-    }

-

-    private var temporalDistributionInput: TemporalDistributionInput? {

-        guard let currentTypeCount,

-              let previousSnapshot,

-              let cache = currentTypeCount.detailCache,

-              cache.matchesBaseline(previousSnapshot.id) else { return nil }

-

-        return TemporalDistributionInput(

-            displayName: currentTypeCount.displayName,

-            currentCount: currentTypeCount.count,

-            previousCount: previousTypeCount?.count ?? 0,

-            detailCache: cache

-        )

-    }

-

-    private var diffTaskID: String {

-        [

-            currentSnapshot.id.uuidString,

-            previousSnapshot?.id.uuidString ?? "none",

-            typeIdentifier

-        ].joined(separator: "|")

-    }

-

-    private var totalDelta: Int? {

-        guard previousSnapshot != nil,

-              let currentCount = countValue(for: currentTypeCount),

-              let previousCount = countValue(for: previousTypeCount) else { return nil }

-        return currentCount - previousCount

-    }

-

-    private var currentCountText: String {

-        countText(for: currentTypeCount)

-    }

-

-    private var previousCountText: String {

-        countText(for: previousTypeCount)

-    }

-

-    private var quickCurrentCountValue: Int {

-        max(currentCachedTypeSummary?.visibleRecordCount ?? currentTypeCount?.count ?? 0, 0)

-    }

-

-    private var quickPreviousCountValue: Int {

-        max(previousCachedTypeSummary?.visibleRecordCount ?? previousTypeCount?.count ?? 0, 0)

-    }

-

-    private var quickAddedDisappeared: (added: Int, disappeared: Int, exact: Bool) {

-        if let previousSnapshot,

-           let cache = currentTypeCount?.detailCache,

-           cache.matchesBaseline(previousSnapshot.id) {

-            return (cache.addedCount, cache.disappearedCount, true)

-        }

-

-        let net = quickCurrentCountValue - quickPreviousCountValue

-        return (max(net, 0), max(-net, 0), false)

-    }

-

-    private var recordEvolutionSnapshots: [RecordChangeEvolutionSnapshot] {

-        timelineSnapshots.map { snapshot in

-            let count = max(typeCount(in: snapshot)?.count ?? 0, 0)

-            let fallback = recordEvolutionCachedFallback(for: snapshot)

-            return RecordChangeEvolutionSnapshot(

-                id: snapshot.id,

-                timestamp: snapshot.timestamp,

-                localSequenceNumber: snapshot.localSequenceNumber,

-                previousSnapshotID: snapshot.previousSnapshotID,

-                archiveObservationID: snapshot.archiveObservationID,

-                count: count,

-                fallbackAdded: fallback.added,

-                fallbackDisappeared: fallback.disappeared,

-                fallbackIsExact: fallback.exact

-            )

-        }

-    }

-

-    private var simplifiedRecordCounts: (added: Int, disappeared: Int, exact: Bool) {

-        if case .loaded(let diff) = diffState {

-            return (diff.addedCount, diff.disappearedCount, true)

-        }

-        return quickAddedDisappeared

-    }

-

-    private var currentArchiveObservationID: Int64? {

-        currentSnapshot.archiveObservationID

-    }

-

-    private var previousArchiveObservationID: Int64? {

-        previousSnapshot?.archiveObservationID

-    }

-

-    private var isTypeTrackedInCurrentContext: Bool {

-        currentTypeCount != nil ||

-        previousTypeCount != nil ||

-        currentCachedTypeSummary != nil ||

-        previousCachedTypeSummary != nil ||

-        currentArchiveObservationID != nil

-    }

-

-    private var usesSimplifiedDetailUI: Bool {

-        LegacyUIMode.isEnabled(

-            forceEnabled: appSettings.simplifiedUIModeEnabled,

-            horizontalSizeClass: horizontalSizeClass,

-            dynamicTypeSize: dynamicTypeSize,

-            screenWidth: contentWidth

-        )

-    }

-

-    var body: some View {

-        ScrollView {

-            VStack(spacing: 16) {

-                if previousSnapshot == nil {

-                    emptyStateContent("No baseline available for this device.", icon: "clock.badge.questionmark")

-                } else if !isTypeTrackedInCurrentContext {

-                    emptyStateContent("Data type not tracked in selected snapshots.", icon: "eye.slash")

-                } else {

-                    dataRangeSection

-                    recordChangeComparisonSection

-                    if usesSimplifiedDetailUI {

-                        simplifiedDetailSection

-                    } else {

-                        recordChangeEvolutionSection

-                        temporalDistributionSection

-                    }

-                }

-            }

-            .padding(16)

-        }

-        .navigationTitle(displayName)

-        .navigationBarTitleDisplayMode(.inline)

-        .safeAreaInset(edge: .top, spacing: 0) {

-            SnapshotNavigationHeader(

-                snapshots: timelineSnapshots,

-                currentSnapshot: currentSnapshot,

-                onSnapshotSelected: { displayedSnapshot = $0 }

-            )

-                .frame(height: 64)

-        }

-        .toolbar {

-            ToolbarItem(placement: .principal) {

-                snapshotToolbarTitle

-            }

-        }

-        .background(contentWidthReader)

-        .task(id: diffTaskID) {

-            await loadArchiveTypeSummaries()

-            await loadRecordDiff()

-        }

-        .navigationDestination(isPresented: $showTemporalDistribution) {

-            DataTypeTemporalDistributionView(

-                input: temporalDistributionInput,

-                displayName: displayName

-            )

-        }

-    }

-

-    private var contentWidthReader: some View {

-        GeometryReader { proxy in

-            Color.clear

-                .onAppear {

-                    contentWidth = proxy.size.width

-                }

-                .onChange(of: proxy.size.width) { _, newWidth in

-                    contentWidth = newWidth

-                }

-        }

-    }

-

-    private func typeCount(in snapshot: HealthSnapshot) -> TypeCount? {

-        snapshot.typeCounts?.first { $0.typeIdentifier == typeIdentifier }

-    }

-

-    private func countText(for typeCount: TypeCount?) -> String {

-        guard let typeCount else { return "Not tracked" }

-        if typeCount.isUnsupported { return "Unsupported" }

-        if typeCount.count < 0 { return "Unavailable" }

-        return "\(typeCount.count)"

-    }

-

-    private func countValue(for typeCount: TypeCount?) -> Int? {

-        guard let typeCount else { return 0 }

-        guard !typeCount.isUnsupported, typeCount.count >= 0 else { return nil }

-        return typeCount.count

-    }

-

-    @ViewBuilder

-    private var snapshotToolbarTitle: some View {

-        if #available(iOS 26.0, *) {

-            Text(displayName)

-                .font(.headline.weight(.semibold))

-                .lineLimit(1)

-                .padding(.horizontal, 18)

-                .frame(height: 36)

-                .background(Color(.systemBackground).opacity(0.08), in: Capsule())

-                .glassEffect(

-                    .regular.tint(Color(.systemBackground).opacity(0.12)),

-                    in: Capsule()

-                )

-        } else {

-            Text(displayName)

-                .font(.headline.weight(.semibold))

-                .lineLimit(1)

-                .padding(.horizontal, 18)

-                .frame(height: 36)

-                .background(.ultraThinMaterial, in: Capsule())

-        }

-    }

-

-    @ViewBuilder

-    private var dataRangeSection: some View {

-        if currentTypeCount != nil || currentCachedTypeSummary != nil {

-            DataTypeRangeIndicator(

-                earliestDate: currentCachedTypeSummary?.earliestStartDate ?? currentTypeCount?.earliestDate,

-                latestDate: currentCachedTypeSummary?.latestEndDate ?? currentTypeCount?.latestDate,

-                quality: currentTypeCount?.quality ?? .complete

-            )

-        }

-    }

-

-    private var recordChangeComparisonSection: some View {

-        Group {

-            if previousSnapshot != nil {

-                switch diffState {

-            case .loaded(let diff):

-                RecordChangeComparisonCard(

-                    displayName: displayName,

-                    currentCount: quickCurrentCountValue,

-                    previousCount: previousCachedTypeSummary?.visibleRecordCount ?? previousTypeCount?.count,

-                    addedCount: diff.addedCount,

-                    disappearedCount: diff.disappearedCount,

-                    isCurrentValid: quickCurrentCountValue >= 0,

-                    isPreviousTracked: previousTypeCount != nil || previousCachedTypeSummary != nil,

-                    onAddedTap: {

-                        if diff.addedCount > 0 {

-                            showAddedRecords = true

-                        }

-                    },

-                    onDisappearedTap: {

-                        if diff.disappearedCount > 0 {

-                            showDisappearedRecords = true

-                        }

-                    }

-                )

-                .navigationDestination(isPresented: $showAddedRecords) {

-                    if let previous = previousSnapshot {

-                        DataTypeRecordListView(

-                            title: "New Records",

-                            displayName: displayName,

-                            totalCount: diff.addedCount,

-                            mode: addedRecordListMode(previous: previous),

-                            previewRecords: diff.addedRecords,

-                            tint: Color.healthyGreen

-                        )

-                    }

-                }

-                .navigationDestination(isPresented: $showDisappearedRecords) {

-                    DataTypeRecordListView(

-                        title: "Missing Records",

-                        displayName: displayName,

-                        totalCount: diff.disappearedCount,

-                        mode: disappearedRecordListMode(),

-                        previewRecords: diff.disappearedRecords,

-                        tint: Color.criticalRed

-                    )

-                }

-

-            case .idle:

-                VStack(alignment: .leading, spacing: 10) {

-                    let quick = quickAddedDisappeared

-

-                    VStack(alignment: .leading, spacing: 8) {

-                        Text("Quick Counts")

-                            .font(.subheadline.weight(.semibold))

-

-                        HStack {

-                            quickStat(label: "Current", value: "\(quickCurrentCountValue)")

-                            quickStat(label: "Previous", value: "\(quickPreviousCountValue)")

-                        }

-

-                        HStack {

-                            quickStat(label: "New", value: "\(quick.added)", color: .healthyGreen)

-                            quickStat(label: "Missing", value: "\(quick.disappeared)", color: .criticalRed)

-                        }

-

-                        if !quick.exact {

-                            Text("New/Missing are net values from observation delta. Exact split needs deep record analysis.")

-                                .font(.caption2)

-                                .foregroundStyle(.secondary)

-                        }

-                    }

-                    .padding(12)

-                    .background(Color(.systemBackground).opacity(0.35), in: RoundedRectangle(cornerRadius: 8))

-                }

-                .padding(12)

-                .frame(maxWidth: .infinity, alignment: .leading)

-                .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 8))

-

-            case .unavailable:

-                VStack(alignment: .leading, spacing: 8) {

-                    Label(

-                        "Record detail cache is unavailable for this snapshot pair.",

-                        systemImage: "exclamationmark.triangle.fill"

-                    )

-                    .font(.subheadline)

-                    .foregroundStyle(Color.warningAmber)

-

-                    #if DEBUG

-                    if let detailCacheDiagnostic {

-                        Text(detailCacheDiagnostic)

-                            .font(.caption2.monospaced())

-                            .foregroundStyle(.secondary)

-                            .textSelection(.enabled)

-                    }

-                    #endif

-                }

-                .padding(12)

-                .frame(maxWidth: .infinity, alignment: .leading)

-                .background(Color.warningAmber.opacity(0.12), in: RoundedRectangle(cornerRadius: 8))

-

-            case .failed(let message):

-                Label(message, systemImage: "exclamationmark.triangle.fill")

-                    .font(.subheadline)

-                    .foregroundStyle(Color.warningAmber)

-                    .padding(12)

-                    .frame(maxWidth: .infinity, alignment: .leading)

-                    .background(Color.warningAmber.opacity(0.12), in: RoundedRectangle(cornerRadius: 8))

-

-            case .loading:

-                HStack(spacing: 8) {

-                    ProgressView()

-                    Text("Analyzing record changes...")

-                        .font(.subheadline)

-                        .foregroundStyle(.secondary)

-                }

-                .frame(maxWidth: .infinity, alignment: .leading)

-                .padding(12)

-                .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 8))

-                }

-            }

-        }

-    }

-

-    @ViewBuilder

-    private var recordChangeEvolutionSection: some View {

-        if previousSnapshot != nil, currentTypeCount != nil || currentCachedTypeSummary != nil {

-            RecordChangeEvolutionChart(

-                snapshots: recordEvolutionSnapshots,

-                currentSnapshotID: currentSnapshot.id,

-                typeIdentifier: typeIdentifier,

-                displayName: displayName

-            )

-        }

-    }

-

-    private var simplifiedDetailSection: some View {

-        VStack(alignment: .leading, spacing: 12) {

-            Text("Summary")

-                .font(.headline.weight(.semibold))

-

-            HStack(spacing: 12) {

-                quickStat(label: "Current", value: "\(quickCurrentCountValue)")

-                quickStat(label: "Previous", value: "\(quickPreviousCountValue)")

-            }

-

-            let quick = simplifiedRecordCounts

-            HStack(spacing: 12) {

-                quickStat(label: "New", value: "\(quick.added)", color: .healthyGreen)

-                quickStat(label: "Missing", value: "\(quick.disappeared)", color: .criticalRed)

-            }

-

-            if !quick.exact {

-                Text("Exact split needs record analysis.")

-                    .font(.caption2)

-                    .foregroundStyle(.secondary)

-            }

-        }

-        .padding(12)

-        .frame(maxWidth: .infinity, alignment: .leading)

-        .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 8))

-        .accessibilityElement(children: .combine)

-        .accessibilityLabel("Summary. Current \(quickCurrentCountValue). Previous \(quickPreviousCountValue). New \(simplifiedRecordCounts.added). Missing \(simplifiedRecordCounts.disappeared).")

-    }

-

-    @ViewBuilder

-    private var temporalDistributionSection: some View {

-        if previousSnapshot != nil, currentTypeCount != nil, !isCurrentTypeContentAliasToPrevious {

-            if !hasTemporalDistributionCache {

-                VStack(alignment: .leading, spacing: 8) {

-                    Label(

-                        "Temporal distribution is available only when precomputed cache exists for this snapshot pair.",

-                        systemImage: "info.circle"

-                    )

-                    .font(.caption)

-                    .foregroundStyle(.secondary)

-                }

-                .padding(12)

-                .frame(maxWidth: .infinity, alignment: .leading)

-                .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 8))

-            } else {

-            Button {

-                showTemporalDistribution = true

-            } label: {

-                HStack(spacing: 10) {

-                    Image(systemName: "chart.bar.xaxis")

-                        .font(.system(size: 16, weight: .semibold))

-                        .foregroundStyle(.secondary)

-

-                    VStack(alignment: .leading, spacing: 2) {

-                        Text("Temporal Distribution")

-                            .font(.headline.weight(.semibold))

-                            .foregroundStyle(.primary)

-                        Text("New / missing by time bucket")

-                            .font(.caption)

-                            .foregroundStyle(.secondary)

-                    }

-

-                    Spacer()

-

-                    Image(systemName: "chevron.right")

-                        .font(.system(size: 12, weight: .semibold))

-                        .foregroundStyle(.secondary)

-                }

-                .padding(12)

-                .frame(maxWidth: .infinity, alignment: .leading)

-                .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 8))

-            }

-            .buttonStyle(.plain)

-            }

-        }

-    }

-

-    private func emptyStateContent(_ message: String, icon: String) -> some View {

-        VStack(spacing: 12) {

-            Image(systemName: icon)

-                .font(.system(size: 32, weight: .semibold))

-                .foregroundStyle(.secondary)

-

-            Text(message)

-                .font(.subheadline)

-                .foregroundStyle(.secondary)

-                .multilineTextAlignment(.center)

-        }

-        .padding(24)

-        .frame(maxWidth: .infinity)

-        .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 12))

-    }

-

-    private func quickStat(label: String, value: String, color: Color = .primary) -> some View {

-        VStack(alignment: .leading, spacing: 2) {

-            Text(label)

-                .font(.caption2)

-                .foregroundStyle(.secondary)

-            Text(value)

-                .font(.subheadline.weight(.semibold).monospacedDigit())

-                .foregroundStyle(color)

-        }

-        .frame(maxWidth: .infinity, alignment: .leading)

-    }

-

-    private func recordEvolutionCachedFallback(for snapshot: HealthSnapshot) -> (added: Int, disappeared: Int, exact: Bool) {

-        guard let previous = snapshot.previousInTimeline(timelineSnapshots) else {

-            return (0, 0, false)

-        }

-

-        if let cache = typeCount(in: snapshot)?.detailCache,

-           cache.matchesBaseline(previous.id) {

-            return (cache.addedCount, cache.disappearedCount, true)

-        }

-

-        return (0, 0, false)

-    }

-

-    private func addedRecordListMode(previous: HealthSnapshot) -> RecordListMode {

-        if let fromObservationID = previous.archiveObservationID,

-           let toObservationID = currentArchiveObservationID {

-            return .addedDiff(

-                typeIdentifier: typeIdentifier,

-                afterDate: previous.timestamp,

-                beforeDate: currentSnapshot.timestamp,

-                fromObservationID: fromObservationID,

-                toObservationID: toObservationID

-            )

-        }

-

-        return .added(

-            typeIdentifier: typeIdentifier,

-            afterDate: previous.timestamp,

-            beforeDate: currentSnapshot.timestamp

-        )

-    }

-

-    private func disappearedRecordListMode() -> RecordListMode {

-        if let fromObservationID = previousArchiveObservationID,

-           let toObservationID = currentArchiveObservationID {

-            return .disappearedDiff(

-                typeIdentifier: typeIdentifier,

-                fromObservationID: fromObservationID,

-                toObservationID: toObservationID

-            )

-        }

-

-        return .disappeared(typeIdentifier: typeIdentifier)

-    }

-

-    @MainActor

-    private func loadRecordDiff() async {

-        guard previousSnapshot != nil else {

-            detailCacheDiagnostic = nil

-            diffState = .loaded(.empty)

-            return

-        }

-

-        if isCurrentTypeContentAliasToPrevious {

-            detailCacheDiagnostic = nil

-            diffState = .loaded(.empty)

-            return

-        }

-

-        let currentCount = currentCachedTypeSummary?.visibleRecordCount ?? currentTypeCount?.count ?? 0

-        let previousCount = previousCachedTypeSummary?.visibleRecordCount ?? previousTypeCount?.count ?? 0

-

-        guard currentCount >= 0, previousCount >= 0 else {

-            detailCacheDiagnostic = "counts-invalid current=\(currentCount) previous=\(previousCount)"

-            diffState = .unavailable

-            return

-        }

-

-        if let previousArchiveObservationID,

-           let currentArchiveObservationID {

-            do {

-                let cache = try CoreDataArchiveCacheStore()

-                if let cached = try cache.diffSummary(

-                    fromObservationID: previousArchiveObservationID,

-                    toObservationID: currentArchiveObservationID,

-                    sampleTypeIdentifier: typeIdentifier

-                ) {

-                    detailCacheDiagnostic = "resolver-v6 phase=core-data-diff-cache"

-                    diffState = .loaded(DataTypeRecordDiff(cached: cached))

-                    return

-                }

-            } catch {

-                detailCacheDiagnostic = "core-data-diff-cache-failed \(error.localizedDescription)"

-            }

-

-            do {

-                let summary = try await SQLiteHealthArchiveStore.shared.diffSummary(HealthArchiveDiffRequest(

-                    fromObservationID: previousArchiveObservationID,

-                    toObservationID: currentArchiveObservationID,

-                    sampleTypeIdentifier: typeIdentifier

-                ))

-                detailCacheDiagnostic = "resolver-v5 phase=archive-diff"

-                diffState = .loaded(DataTypeRecordDiff(summary: summary))

-                return

-            } catch {

-                detailCacheDiagnostic = "archive-diff-failed \(error.localizedDescription)"

-            }

-        }

-

-        if let cache = currentTypeCount?.detailCache,

-           cache.matchesBaseline(previousSnapshot?.id) {

-            detailCacheDiagnostic = "resolver-v7 phase=legacy-detail-cache-read-only"

-            diffState = .loaded(DataTypeRecordDiff(cache: cache))

-            return

-        }

-

-        diffState = .unavailable

-    }

-

-    @MainActor

-    private func loadArchiveTypeSummaries() async {

-        guard currentArchiveObservationID != nil || previousArchiveObservationID != nil else {

-            currentCachedTypeSummary = nil

-            previousCachedTypeSummary = nil

-            return

-        }

-

-        do {

-            let cache = try CoreDataArchiveCacheStore()

-            if let currentArchiveObservationID {

-                currentCachedTypeSummary = try cache.typeSummaries(observationID: currentArchiveObservationID)

-                    .first { $0.sampleTypeIdentifier == typeIdentifier }

-            } else {

-                currentCachedTypeSummary = nil

-            }

-

-            if let previousArchiveObservationID {

-                previousCachedTypeSummary = try cache.typeSummaries(observationID: previousArchiveObservationID)

-                    .first { $0.sampleTypeIdentifier == typeIdentifier }

-            } else {

-                previousCachedTypeSummary = nil

-            }

-        } catch {

-            currentCachedTypeSummary = nil

-            previousCachedTypeSummary = nil

-            detailCacheDiagnostic = "core-data-type-cache-failed \(error.localizedDescription)"

-        }

-    }

-

-}

-

-private enum RecordDiffState: Equatable {

-    case idle

-    case loading

-    case unavailable

-    case failed(String)

-    case loaded(DataTypeRecordDiff)

-}

-

-private struct DataTypeRecordDiff: Equatable, Sendable {

-    static let previewLimit = 1_000

-    static let empty = DataTypeRecordDiff(

-        addedCount: 0,

-        disappearedCount: 0,

-        addedRecords: [],

-        disappearedRecords: []

-    )

-

-    let addedCount: Int

-    let disappearedCount: Int

-    let addedRecords: [HealthRecordValue]

-    let disappearedRecords: [HealthRecordValue]

-

-    init(

-        addedCount: Int,

-        disappearedCount: Int,

-        addedRecords: [HealthRecordValue],

-        disappearedRecords: [HealthRecordValue]

-    ) {

-        self.addedCount = addedCount

-        self.disappearedCount = disappearedCount

-        self.addedRecords = addedRecords

-        self.disappearedRecords = disappearedRecords

-    }

-

-    init(cache: TypeCountDetailCache) {

-        self.addedCount = cache.addedCount

-        self.disappearedCount = cache.disappearedCount

-        self.addedRecords = cache.addedPreviewRecords

-        self.disappearedRecords = cache.disappearedPreviewRecords

-    }

-

-    init(summary: HealthArchiveDiffSummary) {

-        self.addedCount = summary.appearedCount

-        self.disappearedCount = summary.disappearedCount

-        self.addedRecords = []

-        self.disappearedRecords = []

-    }

-

-    init(cached: CachedArchiveDiffSummary) {

-        self.addedCount = cached.appearedCount

-        self.disappearedCount = cached.disappearedCount

-        self.addedRecords = []

-        self.disappearedRecords = []

-    }

-

-    var isPreviewLimited: Bool {

-        addedCount > Self.previewLimit || disappearedCount > Self.previewLimit

-    }

-}

-

-#Preview {

-    NavigationStack {

-        DataTypeSnapshotDetailView(

-            snapshot: HealthSnapshot(

-                timestamp: .now,

-                osVersion: "iOS 26.4",

-                deviceName: "Preview iPhone",

-                deviceID: "preview-device"

-            ),

-            typeIdentifier: "HKQuantityTypeIdentifierStepCount",

-            displayName: "Step Count"

-        )

-    }

-    .modelContainer(for: [HealthSnapshot.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self], inMemory: true)

-    .environment(AppSettings())

-}

-import SwiftUI

-import SwiftData

-import UIKit

-

-struct SnapshotDetailView: View {

-    let snapshot: HealthSnapshot

-    let baseline: HealthSnapshot?

-    let profile: LocalDeviceProfile?

-

-    @Query(sort: \HealthSnapshot.timestamp) private var allSnapshots: [HealthSnapshot]

-    @State private var displayedSnapshot: HealthSnapshot?

-    @State private var archiveTypeRows: [SnapshotArchiveTypeRow]?

-    @State private var archiveTypeError: String?

-

-    private var currentSnapshot: HealthSnapshot {

-        displayedSnapshot ?? snapshot

-    }

-

-    private var archiveReloadID: String {

-        [

-            currentSnapshot.id.uuidString,

-            String(currentSnapshot.archiveObservationID ?? -1),

-            String(baseline?.archiveObservationID ?? -1)

-        ].joined(separator: "|")

-    }

-

-    private var summaryTypeCount: Int? {

-        if let archiveTypeRows {

-            return archiveTypeRows.count

-        }

-        guard currentSnapshot.hasCurrentCachedSummary else { return nil }

-        return currentSnapshot.cachedTypeCount

-    }

-

-    private var summaryRecordCount: Int? {

-        if let archiveTypeRows {

-            return archiveTypeRows.reduce(0) { $0 + $1.currentCount }

-        }

-        guard currentSnapshot.hasCurrentCachedSummary else { return nil }

-        return currentSnapshot.cachedRecordCount

-    }

-

-    private var summaryEarliestRecordDate: Date? {

-        archiveTypeRows?.compactMap(\.earliestStartDate).min() ?? currentSnapshot.cachedEarliestRecordDate

-    }

-

-    private var summaryLatestRecordDate: Date? {

-        archiveTypeRows?.compactMap(\.latestEndDate).max() ?? currentSnapshot.cachedLatestRecordDate

-    }

-

-    private var archiveRecordChangeCount: Int? {

-        archiveTypeRows?.reduce(0) { $0 + $1.recordChangeCount }

-    }

-

-    private var archiveAffectedMetricCount: Int? {

-        archiveTypeRows?.filter(\.hasChanges).count

-    }

-

-    private var deviceDisplayName: String {

-        if let name = profile?.name, !name.isEmpty { return name }

-        return currentSnapshot.deviceName.isEmpty ? "Unknown device" : currentSnapshot.deviceName

-    }

-

-    private var timelineSnapshots: [HealthSnapshot] {

-        allSnapshots.filter { candidate in

-            if currentSnapshot.deviceID.isEmpty {

-                return candidate.deviceID.isEmpty

-            }

-            return candidate.deviceID == currentSnapshot.deviceID

-        }

-    }

-

-    @State private var showShareSheet = false

-    @State private var pdfExportURL: URL?

-    @State private var isExporting = false

-    @State private var showMetadataSheet = false

-

-    var body: some View {

-        List {

-            evolutionSection

-        }

-        .navigationTitle("Snapshot")

-        .navigationBarTitleDisplayMode(.inline)

-        .safeAreaInset(edge: .top, spacing: 0) {

-            SnapshotNavigationHeader(

-                snapshots: timelineSnapshots,

-                currentSnapshot: currentSnapshot,

-                onSnapshotSelected: { displayedSnapshot = $0 }

-            )

-                .frame(height: 64)

-        }

-        .toolbar {

-            ToolbarItem(placement: .principal) {

-                snapshotToolbarTitle

-            }

-            ToolbarItem(placement: .navigationBarTrailing) {

-                HStack(spacing: 12) {

-                    Button {

-                        showMetadataSheet = true

-                    } label: {

-                        Image(systemName: "info.circle")

-                    }

-                    .accessibilityLabel("View snapshot details")

-

-                    if isExporting {

-                        ProgressView()

-                            .accessibilityLabel("Generating PDF")

-                    } else {

-                        Button {

-                            exportAsPDF()

-                        } label: {

-                            Image(systemName: "square.and.arrow.up")

-                        }

-                        .accessibilityLabel("Export snapshot as PDF")

-                    }

-                }

-            }

-        }

-        .sheet(isPresented: $showMetadataSheet) {

-            metadataSheetContent

-        }

-        .sheet(isPresented: $showShareSheet) {

-            if let url = pdfExportURL {

-                ShareSheet(items: [url])

-                    .ignoresSafeArea()

-            }

-        }

-        .task(id: archiveReloadID) {

-            await loadArchiveTypeRows()

-        }

-    }

-

-    private func exportAsPDF() {

-        isExporting = true

-        let reportData = SnapshotPDFExporter.extractReportData(

-            snapshot: currentSnapshot,

-            baseline: baseline,

-            profile: profile

-        )

-        let timestamp = currentSnapshot.timestamp

-        Task(priority: .userInitiated) {

-            let pdfData = SnapshotPDFExporter.generatePDF(from: reportData)

-            let formatter = DateFormatter()

-            formatter.dateFormat = "yyyy-MM-dd-HH-mm"

-            let name = "HealthProbe-Snapshot-\(formatter.string(from: timestamp)).pdf"

-            let url = FileManager.default.temporaryDirectory.appendingPathComponent(name)

-            try? pdfData.write(to: url)

-            isExporting = false

-            pdfExportURL = url

-            showShareSheet = true

-        }

-    }

-

-    @MainActor

-    private func loadArchiveTypeRows() async {

-        guard let currentObservationID = currentSnapshot.archiveObservationID else {

-            archiveTypeRows = nil

-            archiveTypeError = nil

-            return

-        }

-

-        do {

-            let cache = try CoreDataArchiveCacheStore()

-            let currentSummaries = try cache.typeSummaries(observationID: currentObservationID)

-            let baselineObservationID = baseline?.archiveObservationID

-            let baselineSummaries = try baselineObservationID.map {

-                try cache.typeSummaries(observationID: $0)

-            } ?? []

-

-            let currentByType = Dictionary(uniqueKeysWithValues: currentSummaries.map { ($0.sampleTypeIdentifier, $0) })

-            let baselineByType = Dictionary(uniqueKeysWithValues: baselineSummaries.map { ($0.sampleTypeIdentifier, $0) })

-            let allTypeIdentifiers = Set(currentByType.keys).union(baselineByType.keys)

-

-            var rows: [SnapshotArchiveTypeRow] = []

-            rows.reserveCapacity(allTypeIdentifiers.count)

-

-            for typeIdentifier in allTypeIdentifiers {

-                let current = currentByType[typeIdentifier]

-                let baselineSummary = baselineByType[typeIdentifier]

-                let diff: HealthArchiveDiffSummary

-                if let baselineObservationID {

-                    diff = try await SQLiteHealthArchiveStore.shared.diffSummary(HealthArchiveDiffRequest(

-                        fromObservationID: baselineObservationID,

-                        toObservationID: currentObservationID,

-                        sampleTypeIdentifier: typeIdentifier

-                    ))

-                } else {

-                    diff = HealthArchiveDiffSummary(

-                        fromObservationID: currentObservationID,

-                        toObservationID: currentObservationID,

-                        sampleTypeIdentifier: typeIdentifier,

-                        appearedCount: 0,

-                        disappearedCount: 0,

-                        representationChangedCount: 0

-                    )

-                }

-

-                rows.append(SnapshotArchiveTypeRow(

-                    typeIdentifier: typeIdentifier,

-                    displayName: current?.displayName ?? baselineSummary?.displayName ?? typeIdentifier,

-                    currentCount: current?.visibleRecordCount ?? 0,

-                    previousCount: baselineSummary?.visibleRecordCount,

-                    appearedCount: diff.appearedCount,

-                    disappearedCount: diff.disappearedCount,

-                    representationChangedCount: diff.representationChangedCount,

-                    earliestStartDate: current?.earliestStartDate,

-                    latestEndDate: current?.latestEndDate

-                ))

-            }

-

-            archiveTypeRows = rows.sorted {

-                $0.displayName.localizedCompare($1.displayName) == .orderedAscending

-            }

-            archiveTypeError = nil

-        } catch {

-            archiveTypeRows = nil

-            archiveTypeError = error.localizedDescription

-        }

-    }

-

-    @ViewBuilder

-    private var snapshotToolbarTitle: some View {

-        if #available(iOS 26.0, *) {

-            Text("Snapshot")

-                .font(.headline.weight(.semibold))

-                .padding(.horizontal, 18)

-                .frame(height: 36)

-                .background(Color(.systemBackground).opacity(0.08), in: Capsule())

-                .glassEffect(

-                    .regular.tint(Color(.systemBackground).opacity(0.12)),

-                    in: Capsule()

-                )

-        } else {

-            Text(currentSnapshot.timestamp, format: .dateTime.month().day().hour().minute())

-                .font(.headline.weight(.semibold))

-                .padding(.horizontal, 18)

-                .frame(height: 36)

-                .background(.ultraThinMaterial, in: Capsule())

-        }

-    }

-

-    @ViewBuilder

-    private var metadataSheetContent: some View {

-        NavigationStack {

-            ScrollView {

-                VStack(alignment: .leading, spacing: 12) {

-                    // Title with Date

-                    VStack(spacing: 4) {

-                        Text("Snapshot")

-                            .font(.headline.weight(.semibold))

-                        Text(currentSnapshot.timestamp, format: .dateTime.month().day().hour().minute())

-                            .font(.subheadline)

-                            .foregroundStyle(.secondary)

-                    }

-                    .frame(maxWidth: .infinity, alignment: .center)

-                    .padding(12)

-                    .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 12))

-

-                    // Data Range

-                    SnapshotDataRangeIndicator(