-| UI | Prototype exists; Snapshots/Data Types now default to the local device timeline instead of a multi-device picker. Dashboard status reads archive/cache observation rows and shows cache health, with SwiftData retained only for capture/review actions; Snapshots timeline reads archive/cache rows when available and no longer queries `SnapshotDelta` for list summaries; snapshot detail summaries/type rows and Data Types list prefer Core Data cache rows when archive observation ids exist, with Data Types diff rows no longer falling back to SwiftData `TypeCount` traversal; data type detail reads Core Data type/diff summaries and uses SQLite `diffRecords` for paged drill-down; 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 SwiftData detail cache as transition fallback | Remove remaining SwiftData navigation handles |

-- [x] Observation detail uses cached summary/type rows plus SQLite diff summaries when archive observation ids exist.

-import Charts

-    @Query private var allDeltas: [SnapshotDelta]

-    private var currentDelta: SnapshotDelta? {

-        allDeltas.first { $0.toSnapshotID == currentSnapshot.id }

-    }

-

-    private var currentDeltaSummary: SnapshotDeltaListSummary? {

-        currentDelta?.listSummary

-    }

-

-    private var allTypeDeltas: [TypeDelta] {

-        (currentDelta?.typeDeltas ?? [])

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

-    }

-

-        let delta = archiveRecordChangeCount ?? currentDeltaSummary?.absoluteRecordChangeCount ?? 0

-        let affectedMetricCount = archiveAffectedMetricCount ?? currentDeltaSummary?.affectedMetricCount ?? 0

-                if archiveTypeRows != nil || currentDeltaSummary != nil {

-            } else if currentDelta == nil {

-            } else if allTypeDeltas.isEmpty {

-                Text("No data types are available for this snapshot.")

-                    .foregroundStyle(.secondary)

-            } else {

-                ForEach(allTypeDeltas) { typeDelta in

-                    NavigationLink {

-                        DataTypeSnapshotDetailView(

-                            snapshot: currentSnapshot,

-                            typeIdentifier: typeDelta.typeIdentifier,

-                            displayName: typeDelta.displayName

-                        )

-                    } label: {

-                        SnapshotTypeDeltaRow(typeDelta: typeDelta)

-                    }

-                }

-private struct SnapshotTypeDeltaRow: View {

-    let typeDelta: TypeDelta

-

-    private var deltaLabel: String {

-        switch typeDelta.transition {

-        case .changed:

-            if typeDelta.countDelta == 0 {

-                return "Content changed"

-            }

-            let prefix = typeDelta.countDelta > 0 ? "+" : ""

-            return "\(prefix)\(typeDelta.countDelta) records"

-        case .appeared:

-            return "New"

-        case .disappeared:

-            return "Missing"

-        case .unchanged:

-            return "No changes"

-        }

-    }

-

-    private var deltaColor: Color {

-        switch typeDelta.transition {

-        case .disappeared:

-            return .criticalRed

-        case .changed, .appeared:

-            return .warningAmber

-        case .unchanged:

-            return .secondary

-        }

-    }

-

-    var body: some View {

-        HStack(spacing: 12) {

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

-                Text(typeDelta.displayName)

-                    .font(.subheadline)

-                Text(typeDelta.typeIdentifier)

-                    .font(.caption2)

-                    .foregroundStyle(.secondary)

-                    .lineLimit(1)

-                    .truncationMode(.middle)

-            }

-

-            Spacer()

-

-            Text(deltaLabel)

-                .font(.caption.weight(.semibold))

-                .foregroundStyle(deltaColor)

-        }

-        .accessibilityElement(children: .combine)

-    }

-}

-

-private enum EvolutionXAxisMode: String, CaseIterable, Identifiable {

-    case time

-    case snapshots

-

-    var id: String { rawValue }

-

-    var title: String {

-        switch self {

-        case .time:

-            return "Time"

-        case .snapshots:

-            return "Snapshots"

-        }

-    }

-}

-

-private struct TypeEvolutionSeries: Identifiable {

-    let typeIdentifier: String

-    let displayName: String

-    let points: [TypeEvolutionPoint]

-

-    var id: String { typeIdentifier }

-

-    var latestPoint: TypeEvolutionPoint? {

-        points.max { $0.timestamp < $1.timestamp }

-    }

-

-    var selectedOrLatestPoint: TypeEvolutionPoint? {

-        points.last

-    }

-

-    var yDomain: ClosedRange<Double> {

-        let counts = points.map(\.count)

-        guard let minCount = counts.min(), let maxCount = counts.max() else {

-            return 0...1

-        }

-

-        if minCount == maxCount {

-            let lower = max(0, minCount - 1)

-            return Double(lower)...Double(maxCount + 1)

-        }

-

-        return Double(max(0, minCount))...Double(maxCount)

-    }

-}

-

-private struct TypeEvolutionPoint: Identifiable {

-    let snapshotID: UUID

-    let timestamp: Date

-    let count: Int

-

-    var id: UUID { snapshotID }

-}

-

-private struct TypeEvolutionChart: View {

-    let series: TypeEvolutionSeries

-    let contextSnapshots: [HealthSnapshot]

-    let xAxisMode: EvolutionXAxisMode

-    let selectedSnapshotID: UUID

-    let selectedTimestamp: Date

-    let snapshotNumbers: [UUID: Int]

-    let baselineTypeCount: TypeCount?

-

-    private struct SnapshotAxisPoint: Identifiable {

-        let snapshotID: UUID

-        let contextIndex: Int

-        let timestamp: Date

-        let count: Int

-

-        var id: UUID { snapshotID }

-    }

-

-    private var selectedPoint: TypeEvolutionPoint? {

-        series.points.first { $0.snapshotID == selectedSnapshotID }

-    }

-

-    private var isMissingInSelectedSnapshot: Bool {

-        selectedPoint == nil

-    }

-

-    private var previousPoint: TypeEvolutionPoint? {

-        guard let selectedIndex = series.points.firstIndex(where: { $0.snapshotID == selectedSnapshotID }),

-              selectedIndex > 0 else { return nil }

-        return series.points[selectedIndex - 1]

-    }

-

-    private var delta: Int? {

-        guard let selected = selectedPoint,

-              let previous = previousPoint,

-              selected.count >= 0,

-              previous.count >= 0 else { return nil }

-        return selected.count - previous.count

-    }

-

-    private var isSignificantChange: Bool {

-        guard let d = delta, let prev = previousPoint?.count, prev > 0 else { return false }

-        let percentChange = abs(Double(d)) / Double(prev) * 100

-        return percentChange > 10 || d > 0

-    }

-

-    private var contextPointCountLabel: String {

-        "\(series.points.count)/\(contextSnapshots.count) snapshots with data"

-    }

-

-    private var contextAxisPoints: [SnapshotAxisPoint] {

-        contextSnapshots.enumerated().compactMap { index, snapshot in

-            guard let candidateTypeCount = snapshot.typeCounts?.first(where: {

-                $0.typeIdentifier == series.typeIdentifier

-            }), candidateTypeCount.count >= 0 else {

-                return nil

-            }

-

-            return SnapshotAxisPoint(

-                snapshotID: snapshot.id,

-                contextIndex: index,

-                timestamp: snapshot.timestamp,

-                count: candidateTypeCount.count

-            )

-        }

-    }

-

-    private var contextAxisGroups: [[SnapshotAxisPoint]] {

-        guard !contextAxisPoints.isEmpty else { return [] }

-

-        var groups: [[SnapshotAxisPoint]] = []

-        var currentGroup: [SnapshotAxisPoint] = [contextAxisPoints[0]]

-

-        for point in contextAxisPoints.dropFirst() {

-            if let previous = currentGroup.last, point.contextIndex == previous.contextIndex + 1 {

-                currentGroup.append(point)

-            } else {

-                groups.append(currentGroup)

-                currentGroup = [point]

-            }

-        }

-

-        groups.append(currentGroup)

-        return groups

-    }

-

-    private var selectedContextIndex: Int? {

-        contextSnapshots.firstIndex { $0.id == selectedSnapshotID }

-    }

-

-    private var snapshotAxisValues: [Int] {

-        Array(contextSnapshots.indices)

-    }

-

-    private func snapshotAxisLabel(for index: Int) -> String {

-        guard contextSnapshots.indices.contains(index) else { return "\(index + 1)" }

-        let snapshotID = contextSnapshots[index].id

-        return "\(snapshotNumbers[snapshotID] ?? index + 1)"

-    }

-

-    private var snapshotAxisDomain: ClosedRange<Int> {

-        guard let first = snapshotAxisValues.first, let last = snapshotAxisValues.last else {

-            return 0...0

-        }

-        return first...last

-    }

-

-    @ViewBuilder

-    private var chartContent: some View {

-        switch xAxisMode {

-        case .time:

-            timeChart

-        case .snapshots:

-            snapshotChart

-        }

-    }

-

-    private var timeChart: some View {

-        Chart {

-            ForEach(contextSnapshots, id: \.id) { item in

-                RuleMark(x: .value("Timeline", item.timestamp))

-                    .foregroundStyle(Color.secondary.opacity(0.10))

-            }

-

-            RuleMark(x: .value("Selected Snapshot", selectedTimestamp))

-                .lineStyle(StrokeStyle(lineWidth: 1, dash: [4, 3]))

-                .foregroundStyle(Color.secondary.opacity(0.55))

-

-            ForEach(series.points) { point in

-                LineMark(

-                    x: .value("Date", point.timestamp),

-                    y: .value("Records", point.count)

-                )

-                .interpolationMethod(.linear)

-

-                PointMark(

-                    x: .value("Date", point.timestamp),

-                    y: .value("Records", point.count)

-                )

-                .symbolSize(24)

-

-                if point.snapshotID == selectedSnapshotID {

-                    PointMark(

-                        x: .value("Selected Date", point.timestamp),

-                        y: .value("Selected Records", point.count)

-                    )

-                    .symbolSize(64)

-                }

-            }

-        }

-    }

-

-    private var snapshotChart: some View {

-        Chart {

-            ForEach(contextSnapshots.indices, id: \.self) { index in

-                RuleMark(x: .value("Snapshot", index))

-                    .foregroundStyle(Color.secondary.opacity(0.10))

-            }

-

-            if let selectedContextIndex {

-                RuleMark(x: .value("Selected Snapshot", selectedContextIndex))

-                    .lineStyle(StrokeStyle(lineWidth: 1, dash: [4, 3]))

-                    .foregroundStyle(Color.secondary.opacity(0.55))

-            }

-

-            ForEach(contextAxisGroups.indices, id: \.self) { groupIndex in

-                let group = contextAxisGroups[groupIndex]

-

-                ForEach(group) { point in

-                    LineMark(

-                        x: .value("Snapshot", point.contextIndex),

-                        y: .value("Records", point.count)

-                    )

-                    .interpolationMethod(.linear)

-

-                    PointMark(

-                        x: .value("Snapshot", point.contextIndex),

-                        y: .value("Records", point.count)

-                    )

-                    .symbolSize(24)

-

-                    if point.snapshotID == selectedSnapshotID {

-                        PointMark(

-                            x: .value("Selected Snapshot", point.contextIndex),

-                            y: .value("Selected Records", point.count)

-                        )

-                        .symbolSize(64)

-                    }

-                }

-            }

-        }

-        .chartXAxis {

-            AxisMarks(values: snapshotAxisValues) { value in

-                AxisGridLine()

-                AxisTick()

-                if let rawIndex = value.as(Int.self) {

-                    AxisValueLabel(snapshotAxisLabel(for: rawIndex))

-                }

-            }

-        }

-        .chartXScale(domain: snapshotAxisDomain)

-    }

-

-    var body: some View {

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

-            HStack(alignment: .firstTextBaseline) {

-                Text(series.displayName)

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

-                Spacer()

-                VStack(alignment: .trailing, spacing: 4) {

-                    if let selectedPoint {

-                        Text("\(selectedPoint.count)")

-                            .font(.subheadline.monospacedDigit())

-                            .foregroundStyle(.secondary)

-                    }

-                    if isSignificantChange, let delta {

-                        SeverityBadge(delta: delta)

-                    }

-                }

-            }

-

-            chartContent

-            .chartYScale(domain: series.yDomain)

-            .chartXAxis {

-                switch xAxisMode {

-                case .time:

-                    AxisMarks(values: .automatic(desiredCount: 3))

-                case .snapshots:

-                    AxisMarks(values: snapshotAxisValues) { value in

-                        AxisGridLine()

-                        AxisTick()

-                        if let rawIndex = value.as(Int.self) {

-                            AxisValueLabel(snapshotAxisLabel(for: rawIndex))

-                        }

-                    }

-                }

-            }

-            .chartYAxis {

-                AxisMarks(position: .leading, values: .automatic(desiredCount: 3))

-            }

-            .frame(height: 120)

-            .foregroundStyle(Color.accentColor)

-

-            if isMissingInSelectedSnapshot {

-                Text("Datatype missing in this snapshot")

-                    .font(.caption2)

-                    .foregroundStyle(Color.warningAmber)

-            } else if series.points.count == 1 {

-                Text("Only one measurement")

-                    .font(.caption2)

-                    .foregroundStyle(.secondary)

-            }

-

-            Text(contextPointCountLabel)

-                .font(.caption2)

-                .foregroundStyle(.secondary)

-        }

-        .padding(.vertical, 4)

-        .accessibilityElement(children: .combine)

-    }

-}

-

-private struct SnapshotTypeCountRow: View {

-    let typeCount: TypeCount

-    let baselineTypeCount: TypeCount?

-

-    private var countText: String {

-        if typeCount.isUnsupported { return "Unsupported" }

-        if typeCount.count == -1   { return "Unavailable" }

-        return "\(typeCount.count)"

-    }

-

-    private var countColor: Color {

-        if typeCount.isUnsupported { return .secondary }

-        if typeCount.count == -1   { return Color.criticalRed }

-        if typeCount.quality != SnapshotQuality.complete { return Color.warningAmber }

-        return Color.primary

-    }

-

-    private var delta: Int? {

-        guard let b = baselineTypeCount,

-              typeCount.count >= 0,

-              b.count >= 0 else { return nil }

-        return typeCount.count - b.count

-    }

-

-    private var isSignificantChange: Bool {

-        guard let d = delta, let b = baselineTypeCount?.count, b > 0 else { return false }

-        let percentChange = abs(Double(d)) / Double(b) * 100

-        return percentChange > 10 || d > 0

-    }

-

-    var body: some View {

-        HStack(spacing: 12) {

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

-                Text(typeCount.displayName)

-                    .font(.subheadline)

-                Text(typeCount.typeIdentifier)

-                    .font(.caption2)

-                    .foregroundStyle(.secondary)

-                    .lineLimit(1)

-                    .truncationMode(.middle)

-            }

-            Spacer()

-            VStack(alignment: .trailing, spacing: 4) {

-                Text(countText)

-                    .font(.subheadline.monospacedDigit())

-                    .foregroundStyle(countColor)

-                if isSignificantChange, let delta {

-                    SeverityBadge(delta: delta)

-                }

-            }

-        }

-        .accessibilityElement(children: .combine)

-    }

-}

-

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