-| 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, legacy detail/PDF views, 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 before removing `ModelContainer` |

-| Diff/change explanation | SQL diff summaries, paged diff records, aggregate comparisons, and consolidation-evidence labels exist; legacy anomaly/count-drop review has been removed from active flows; the old direct `HealthSnapshot.typeCounts` diff helper has been retired | Continue moving remaining SwiftData fallback detail paths to archive/cache DTOs |

-- Current UI/cache layers still depend on 15 SwiftData-backed files for launch container, capture review actions, model definitions, and legacy repair services.

-  been deleted; Dashboard capture/review actions remain.

-observations and deleting the unused legacy snapshot/type detail views, 15 app

-files still have SwiftData imports because capture, Dashboard review actions,

-model definitions, and legacy repair services still use prototype snapshot

-handles.

-- `HealthProbe/Services/ObserverService.swift`

-- `HealthProbe/Services/SnapshotLifecycleService.swift`

-- `HealthProbe/Utilities/TypeCountArchiveRepair.swift`

-- delete legacy record repair once old SwiftData stores are no longer opened;

-- remove snapshot deletion/repair logic after capture and Dashboard actions no

-  longer require prototype snapshots.

-import Foundation

-

-enum IntegrityService {

-    enum ValidationResult: Equatable {

-        case valid

-        case checksumMismatch(snapshotID: UUID, expected: String, actual: String)

-        case missingDelta(fromID: UUID, toID: UUID)

-        case corrupted(snapshotID: UUID, reason: String)

-    }

-

-    // Strict mode: used by chain traversal and analysis.

-    // Recomputes checksum from TypeCounts; compares with stored delta.checksumAfter.

-    // Returns .valid only if they match exactly.

-    static func validate(snapshot: HealthSnapshot, delta: SnapshotDelta?) -> ValidationResult {

-        guard let delta else {

-            guard snapshot.isChainStart else {

-                return .missingDelta(fromID: snapshot.previousSnapshotID ?? UUID(), toID: snapshot.id)

-            }

-            return .valid

-        }

-

-        let actual = HashService.snapshotChecksum(typeCounts: snapshot.typeCounts ?? [])

-        guard actual == delta.checksumAfter else {

-            return .checksumMismatch(snapshotID: snapshot.id, expected: delta.checksumAfter, actual: actual)

-        }

-        return .valid

-    }

-

-    // Strict chain walk via previousSnapshotID from latest backward.

-    // Stops immediately at first missing delta or checksum mismatch — no skips, no auto-repair.

-    // FORK DETECTION runs before traversal: if any previousSnapshotID value appears more than

-    // once across the snapshot set, returns .corrupted immediately without traversal.

-    static func validateChain(snapshots: [HealthSnapshot], deltas: [SnapshotDelta]) -> [ValidationResult] {

-        // Fork detection: assert no duplicate previousSnapshotID values

-        var seenPrevIDs: [UUID: UUID] = [:] // prevID → first snapshot ID that used it

-        for snapshot in snapshots {

-            guard let prevID = snapshot.previousSnapshotID else { continue }

-            if let existingSnapshotID = seenPrevIDs[prevID] {

-                return [.corrupted(

-                    snapshotID: existingSnapshotID,

-                    reason: "chain fork detected — two snapshots share the same previousSnapshotID"

-                )]

-            }

-            seenPrevIDs[prevID] = snapshot.id

-        }

-

-        let snapshotByID = Dictionary(uniqueKeysWithValues: snapshots.map { ($0.id, $0) })

-        let deltaByToID  = Dictionary(uniqueKeysWithValues: deltas.map { ($0.toSnapshotID, $0) })

-

-        // Walk from the latest snapshot backward

-        guard let latest = snapshots.max(by: { $0.localSequenceNumber < $1.localSequenceNumber }) else {

-            return []

-        }

-

-        var results: [ValidationResult] = []

-        var current: HealthSnapshot? = latest

-

-        while let node = current {

-            let delta = deltaByToID[node.id]

-            let result = validate(snapshot: node, delta: delta)

-

-            switch result {

-            case .valid:

-                break

-            case .checksumMismatch, .missingDelta, .corrupted:

-                // Strict mode — stop immediately on any error

-                results.append(result)

-                return results

-            }

-

-            if node.isChainStart {

-                break

-            }

-            current = node.previousSnapshotID.flatMap { snapshotByID[$0] }

-        }

-

-        return results

-    }

-}

-import Foundation

-import HealthKit

-import SwiftData

-import os.log

-

-private let logger = Logger(subsystem: "ro.xdev.healthprobe", category: "ObserverService")

-

-// Without background observation, a HealthKit deletion followed by reinsertion between two

-// manual snapshots is completely invisible. HKObserverQuery with background delivery closes this gap.

-// Note: HKObserverQuery signals that something changed but does not identify what changed.

-// Actual detection still comes from the next full snapshot + delta comparison.

-final class ObserverService {

-    static let shared = ObserverService()

-

-    // Minimum interval between observer-triggered snapshots — manual snapshots bypass this entirely.

-    private static let debounceIntervalSeconds: TimeInterval = 600  // 10 minutes

-

-    private var observerQueries: [HKObserverQuery] = []

-    private var debounceTask: Task<Void, Never>?

-    private var lastCallbackTimestamp: Date?

-    private var accumulatedTypeIDs: Set<String> = []

-    private let lock = NSLock()

-

-    private weak var modelContainer: ModelContainer?

-    private var selectedTypeIDs: Set<String> = []

-

-    func startObserving(types: [HKObjectType], store: HKHealthStore, container: ModelContainer, selectedTypeIDs: Set<String>) {

-        self.modelContainer = container

-        self.selectedTypeIDs = selectedTypeIDs

-

-        for objectType in types {

-            let query = HKObserverQuery(sampleType: objectType as! HKSampleType, predicate: nil) { [weak self] _, completionHandler, error in

-                // Always call first — HealthKit re-fires indefinitely if not called

-                defer { completionHandler() }

-                // Schedule snapshot task separately; failure is logged, not fatal

-                if let error {

-                    logger.error("ObserverQuery error for \(objectType.identifier): \(error)")

-                    return

-                }

-                self?.handleObserverCallback(typeID: objectType.identifier)

-            }

-            store.execute(query)

-

-            // Frequency: .immediate for critical types, .daily for others

-            let frequency: HKUpdateFrequency = isCriticalType(objectType.identifier) ? .immediate : .daily

-            store.enableBackgroundDelivery(for: objectType, frequency: frequency) { success, error in

-                if !success {

-                    logger.error("Failed to enable background delivery for \(objectType.identifier): \(String(describing: error))")

-                }

-            }

-            observerQueries.append(query)

-        }

-    }

-

-    // MARK: - Callback handling

-

-    private func handleObserverCallback(typeID: String) {

-        let alreadyScheduled = lock.withLock {

-            let now = Date()

-            lastCallbackTimestamp = now

-            accumulatedTypeIDs.insert(typeID)

-            return debounceTask != nil

-        }

-

-        guard !alreadyScheduled else { return }

-

-        debounceTask = Task { [weak self] in

-            guard let self else { return }

-            // Wait out the debounce window

-            try? await Task.sleep(nanoseconds: UInt64(Self.debounceIntervalSeconds * 1_000_000_000))

-            await self.tryCreateObserverSnapshot()

-        }

-    }

-

-    @MainActor

-    private func tryCreateObserverSnapshot() async {

-        lock.withLock {

-            debounceTask = nil

-        }

-

-        guard let container = modelContainer else {

-            logger.error("ObserverService: no modelContainer — cannot create snapshot")

-            return

-        }

-

-        // Manual overlap suppression: if a manual snapshot was created during the debounce window,

-        // cancel the observer snapshot to avoid a redundant .unchanged delta.

-        let context = ModelContext(container)

-        if let lastCallback = lastCallbackTimestamp {

-            let descriptor = FetchDescriptor<HealthSnapshot>(

-                sortBy: [SortDescriptor(\.timestamp, order: .reverse)]

-            )

-            let recent = try? context.fetch(descriptor)

-            if let latestManual = recent?.first(where: { $0.triggerReason == "manual" }),

-               latestManual.timestamp > lastCallback {

-                logger.info("ObserverService: suppressed — manual snapshot captured during debounce window")

-                return

-            }

-        }

-

-        // Create one consolidated snapshot covering all monitored types

-        do {

-            let snapshot = try await HealthKitService.shared.createSnapshot(

-                in: context,

-                selectedTypeIDs: selectedTypeIDs,

-                adaptiveTimeoutsEnabled: true,

-                triggerReason: "observerCallback"

-            )

-            logger.info("ObserverService: observer-triggered snapshot created \(snapshot.id)")

-        } catch {

-            logger.error("ObserverService: failed to create snapshot — \(error)")

-        }

-

-        lock.withLock {

-            accumulatedTypeIDs.removeAll()

-            lastCallbackTimestamp = nil

-        }

-    }

-

-    // MARK: - Type classification

-

-    private func isCriticalType(_ typeID: String) -> Bool {

-        let critical: Set<String> = Set([

-            HKQuantityType.quantityType(forIdentifier: .heartRate)?.identifier,

-            HKQuantityType.quantityType(forIdentifier: .stepCount)?.identifier,

-        ].compactMap { $0 })

-        return critical.contains(typeID)

-    }

-}

-import Foundation

-import SwiftData

-import os.log

-

-private let logger = Logger(subsystem: "ro.xdev.healthprobe", category: "SnapshotLifecycleService")

-

-enum SnapshotLifecycleService {

-    struct DeletionPreview {

-        let target: HealthSnapshot

-        let affectedDeltas: [SnapshotDelta]

-        let mergedDelta: SnapshotDelta?

-        let willBreakChain: Bool

-        let description: String

-    }

-

-    static func previewDeletion(of snapshot: HealthSnapshot, context: ModelContext) throws -> DeletionPreview {

-        let incomingDelta = try fetchIncomingDelta(toSnapshotID: snapshot.id, context: context)

-        let outgoingDelta = try fetchOutgoingDelta(fromSnapshotID: snapshot.id, context: context)

-

-        var willBreakChain = false

-        var description = ""

-

-        let integrityResult = IntegrityService.validate(snapshot: snapshot, delta: incomingDelta)

-        switch integrityResult {

-        case .valid:

-            break

-        case .checksumMismatch(_, let expected, let actual):

-            willBreakChain = true

-            description = "Checksum mismatch: expected \(expected.prefix(8))…, got \(actual.prefix(8))…"

-        case .missingDelta(let fromID, _):

-            willBreakChain = true

-            description = "Missing delta from \(fromID)"

-        case .corrupted(_, let reason):

-            willBreakChain = true

-            description = reason

-        }

-

-        var affectedDeltas: [SnapshotDelta] = []

-        if let d = incomingDelta { affectedDeltas.append(d) }

-        if let d = outgoingDelta { affectedDeltas.append(d) }

-

-        // For intermediate deletion, compute the merged delta preview

-        var mergedDelta: SnapshotDelta? = nil

-        if let d1 = incomingDelta, let d2 = outgoingDelta,

-           let prevSnap = try fetchSnapshot(id: d1.fromSnapshotID, context: context),

-           let nextSnap = try fetchSnapshot(id: d2.toSnapshotID, context: context) {

-            mergedDelta = DeltaService.mergeDeltas(

-                d1: d1, d2: d2,

-                snapshotBefore: prevSnap,

-                snapshotAfter: nextSnap

-            )

-        }

-

-        return DeletionPreview(

-            target: snapshot,

-            affectedDeltas: affectedDeltas,

-            mergedDelta: mergedDelta,

-            willBreakChain: willBreakChain,

-            description: description

-        )

-    }

-

-    static func delete(_ snapshot: HealthSnapshot, context: ModelContext) throws {

-        let incomingDelta = try fetchIncomingDelta(toSnapshotID: snapshot.id, context: context)

-        let outgoingDelta = try fetchOutgoingDelta(fromSnapshotID: snapshot.id, context: context)

-

-        let deviceID = snapshot.deviceID

-        let version = Bundle.main.appBuildVersion

-

-        let log = LocalOperationLog(

-            operationType: "delete",

-            summary: buildSummary(snapshot: snapshot, incoming: incomingDelta, outgoing: outgoingDelta),

-            deviceID: deviceID,

-            appBuildVersion: version

-        )

-        var completedLog = log

-        completedLog.affectedSnapshotIDs = [snapshot.id.uuidString]

-

-        if incomingDelta == nil && outgoingDelta == nil {

-            // Standalone snapshot — just delete

-            context.delete(snapshot)

-        } else if incomingDelta == nil, let outgoing = outgoingDelta {

-            // Oldest snapshot: delete it and outgoing delta, set next as chain start

-            if let nextSnap = try fetchSnapshot(id: outgoing.toSnapshotID, context: context) {

-                nextSnap.previousSnapshotID = nil

-                nextSnap.isChainStart = true

-                nextSnap.contentEquivalentSnapshotID = nil

-                for typeCount in nextSnap.typeCounts ?? [] {

-                    typeCount.contentEquivalentTypeCountID = nil

-                }

-                invalidateDetailCaches(for: nextSnap)

-            }

-            context.delete(outgoing)

-            context.delete(snapshot)

-        } else if outgoingDelta == nil, let incoming = incomingDelta {

-            // Latest snapshot: delete it and incoming delta

-            context.delete(incoming)

-            context.delete(snapshot)

-        } else if let d1 = incomingDelta, let d2 = outgoingDelta {

-            // Intermediate snapshot: merge deltas and delete

-            guard let prevSnap = try fetchSnapshot(id: d1.fromSnapshotID, context: context),

-                  let nextSnap = try fetchSnapshot(id: d2.toSnapshotID, context: context) else {

-                logger.error("SnapshotLifecycleService: failed to find surrounding snapshots for merge")

-                throw LifecycleError.missingNeighbor

-            }

-

-            let merged = DeltaService.mergeDeltas(

-                d1: d1, d2: d2,

-                snapshotBefore: prevSnap,

-                snapshotAfter: nextSnap

-            )

-            merged.deviceID = deviceID

-            context.insert(merged)

-            for td in merged.typeDeltas ?? [] { context.insert(td) }

-

-            nextSnap.previousSnapshotID = prevSnap.id

-            _ = refreshContentEquivalence(for: nextSnap, baseline: prevSnap)

-            invalidateDetailCaches(for: nextSnap)

-            context.delete(d1)

-            context.delete(d2)

-            context.delete(snapshot)

-        }

-

-        try context.save()

-        LocalOperationLogStore.append(completedLog)

-    }

-

-    static func rebuildMissingDetailCaches(

-        context: ModelContext,

-        maxTypeCounts: Int

-    ) throws -> Bool {

-        guard maxTypeCounts > 0 else { return false }

-        MemoryLog.log("snapshotLifecycle.rebuildMissingDetailCaches.begin", metadata: [

-            "maxTypeCounts": "\(maxTypeCounts)"

-        ])

-

-        let snapshotIDs = try context.fetch(FetchDescriptor<HealthSnapshot>()).map { $0.id }

-        MemoryLog.log("snapshotLifecycle.rebuildMissingDetailCaches.snapshotsFetched", metadata: [

-            "snapshotCount": "\(snapshotIDs.count)"

-        ])

-        var rebuiltCount = 0

-        var updatedAliases = 0

-

-        // Alias pass: process in batches to avoid memory bloat

-        let aliasBatchSize = 5

-        for batchStart in stride(from: 0, to: snapshotIDs.count, by: aliasBatchSize) {

-            let batchEnd = min(batchStart + aliasBatchSize, snapshotIDs.count)

-            for id in snapshotIDs[batchStart..<batchEnd] {

-                guard let snapshot = try fetchSnapshot(id: id, context: context),

-                      let baselineID = snapshot.previousSnapshotID,

-                      let baseline = try fetchSnapshot(id: baselineID, context: context) else {

-                    continue

-                }

-

-                if refreshContentEquivalence(for: snapshot, baseline: baseline) {

-                    updatedAliases += 1

-                }

-            }

-            // Save batch to flush object cache and allow garbage collection

-            if updatedAliases > 0 {

-                try context.save()

-            }

-        }

-

-        MemoryLog.log("snapshotLifecycle.rebuildMissingDetailCaches.aliasPassFinished", metadata: [

-            "updatedAliases": "\(updatedAliases)"

-        ])

-        if MemoryLog.isFootprintAtOrAbove(MemoryLog.detailCacheBuildFootprintLimit) {

-            MemoryLog.log("snapshotLifecycle.rebuildMissingDetailCaches.pausedMemoryPressure", metadata: [

-                "limit": MemoryLog.format(MemoryLog.detailCacheBuildFootprintLimit),

-                "phase": "afterAliasPass",

-                "updatedAliases": "\(updatedAliases)"

-            ])

-            return false

-        }

-

-        // Detail cache pass

-        for id in snapshotIDs {

-            guard let snapshot = try fetchSnapshot(id: id, context: context),

-                  let baselineID = snapshot.previousSnapshotID,

-                  let baseline = try fetchSnapshot(id: baselineID, context: context) else {

-                continue

-            }

-

-            let baselineByType = Dictionary(

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

-            )

-

-            if snapshot.isContentAlias,

-               snapshot.contentEquivalentSnapshotID == baseline.contentRepresentativeSnapshotID {

-                continue

-            }

-

-            for typeCount in snapshot.typeCounts ?? [] {

-                guard shouldBackfillDetailCache(

-                    typeCount: typeCount,

-                    baseline: baselineByType[typeCount.typeIdentifier],

-                    baselineID: baseline.id

-                ) else {

-                    continue

-                }

-

-                if MemoryLog.isFootprintAtOrAbove(MemoryLog.detailCacheBuildFootprintLimit) {

-                    MemoryLog.log("snapshotLifecycle.rebuildMissingDetailCaches.pausedMemoryPressure", metadata: [

-                        "limit": MemoryLog.format(MemoryLog.detailCacheBuildFootprintLimit),

-                        "phase": "beforeDetailCacheBuild",

-                        "rebuiltCount": "\(rebuiltCount)",

-                        "updatedAliases": "\(updatedAliases)"

-                    ])

-                    if rebuiltCount > 0 || updatedAliases > 0 {

-                        try context.save()

-                    }

-                    return false

-                }

-

-                MemoryLog.log("snapshotLifecycle.detailCache.buildBegin", metadata: detailCacheMetadata(

-                    current: typeCount,

-                    previous: baselineByType[typeCount.typeIdentifier],

-                    source: "backfill"

-                ))

-                typeCount.setDetailCache(

-                    TypeCountDetailCacheBuilder.build(

-                        current: typeCount,

-                        previous: baselineByType[typeCount.typeIdentifier],

-                        baselineSnapshotID: baseline.id

-                    )

-                )

-                MemoryLog.log("snapshotLifecycle.detailCache.buildEnd", metadata: detailCacheMetadata(

-                    current: typeCount,

-                    previous: baselineByType[typeCount.typeIdentifier],

-                    source: "backfill"

-                ))

-                rebuiltCount += 1

-

-                if rebuiltCount >= maxTypeCounts {

-                    MemoryLog.log("snapshotLifecycle.rebuildMissingDetailCaches.pausedAtLimit", metadata: [

-                        "rebuiltCount": "\(rebuiltCount)",

-                        "updatedAliases": "\(updatedAliases)"

-                    ])

-                    try context.save()

-                    return false

-                }

-            }

-        }

-

-        if rebuiltCount > 0 || updatedAliases > 0 {

-            try context.save()

-        }

-        MemoryLog.log("snapshotLifecycle.rebuildMissingDetailCaches.complete", metadata: [

-            "rebuiltCount": "\(rebuiltCount)",

-            "updatedAliases": "\(updatedAliases)"

-        ])

-        return true

-    }

-

-    // MARK: - Fetch helpers

-

-    private static func fetchIncomingDelta(toSnapshotID snapshotID: UUID, context: ModelContext) throws -> SnapshotDelta? {

-        let descriptor = FetchDescriptor<SnapshotDelta>(

-            predicate: #Predicate<SnapshotDelta> { $0.toSnapshotID == snapshotID }

-        )

-        return try context.fetch(descriptor).first

-    }

-

-    private static func fetchOutgoingDelta(fromSnapshotID snapshotID: UUID, context: ModelContext) throws -> SnapshotDelta? {

-        let descriptor = FetchDescriptor<SnapshotDelta>(

-            predicate: #Predicate<SnapshotDelta> { $0.fromSnapshotID == snapshotID }

-        )

-        return try context.fetch(descriptor).first

-    }

-

-    private static func fetchSnapshot(id: UUID, context: ModelContext) throws -> HealthSnapshot? {

-        let descriptor = FetchDescriptor<HealthSnapshot>(

-            predicate: #Predicate<HealthSnapshot> { $0.id == id }

-        )

-        return try context.fetch(descriptor).first

-    }

-

-    private static func invalidateDetailCaches(for snapshot: HealthSnapshot) {

-        for typeCount in snapshot.typeCounts ?? [] {

-            typeCount.setDetailCache(nil)

-        }

-    }

-

-    @discardableResult

-    private static func refreshContentEquivalence(for snapshot: HealthSnapshot, baseline: HealthSnapshot) -> Bool {

-        let previousSnapshotAliasID = snapshot.contentEquivalentSnapshotID

-        let previousTypeAliasIDs = Dictionary(

-            uniqueKeysWithValues: (snapshot.typeCounts ?? []).map { ($0.id, $0.contentEquivalentTypeCountID) }

-        )

-

-        snapshot.contentEquivalentSnapshotID = nil

-        for typeCount in snapshot.typeCounts ?? [] {

-            typeCount.contentEquivalentTypeCountID = nil

-        }

-

-        guard snapshot.monitoredTypeSetHash == baseline.monitoredTypeSetHash else {

-            return contentEquivalenceDidChange(

-                snapshot: snapshot,

-                previousSnapshotAliasID: previousSnapshotAliasID,

-                previousTypeAliasIDs: previousTypeAliasIDs

-            )

-        }

-

-        let baselineByType = Dictionary(

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

-        )

-

-        for typeCount in snapshot.typeCounts ?? [] {

-            guard let baselineType = baselineByType[typeCount.typeIdentifier],

-                  areTypeCountsContentEquivalent(typeCount, baselineType) else {

-                continue

-            }

-

-            typeCount.contentEquivalentTypeCountID = baselineType.contentRepresentativeTypeCountID

-            typeCount.setDetailCache(nil)

-        }

-

-        if areTypeCountsContentEquivalent(snapshot.typeCounts ?? [], baseline.typeCounts ?? []) {

-            snapshot.contentEquivalentSnapshotID = baseline.contentRepresentativeSnapshotID

-        }

-

-        return contentEquivalenceDidChange(

-            snapshot: snapshot,

-            previousSnapshotAliasID: previousSnapshotAliasID,

-            previousTypeAliasIDs: previousTypeAliasIDs

-        )

-    }

-

-    private static func contentEquivalenceDidChange(

-        snapshot: HealthSnapshot,

-        previousSnapshotAliasID: UUID?,

-        previousTypeAliasIDs: [UUID: UUID?]

-    ) -> Bool {

-        if snapshot.contentEquivalentSnapshotID != previousSnapshotAliasID {

-            return true

-        }

-

-        for typeCount in snapshot.typeCounts ?? [] {

-            if typeCount.contentEquivalentTypeCountID != (previousTypeAliasIDs[typeCount.id] ?? nil) {

-                return true

-            }

-        }

-

-        return false

-    }

-

-    private static func areTypeCountsContentEquivalent(_ lhs: [TypeCount], _ rhs: [TypeCount]) -> Bool {

-        let lhsByType = Dictionary(uniqueKeysWithValues: lhs.map { ($0.typeIdentifier, $0) })

-        let rhsByType = Dictionary(uniqueKeysWithValues: rhs.map { ($0.typeIdentifier, $0) })

-        guard lhsByType.keys == rhsByType.keys else { return false }

-

-        for typeIdentifier in lhsByType.keys {

-            guard let lhsType = lhsByType[typeIdentifier],

-                  let rhsType = rhsByType[typeIdentifier],

-                  lhsType.count == rhsType.count,

-                  lhsType.contentHash == rhsType.contentHash,

-                  lhsType.quality == rhsType.quality,

-                  lhsType.isUnsupported == rhsType.isUnsupported else {

-                return false

-            }

-        }

-

-        return true

-    }

-

-    private static func areTypeCountsContentEquivalent(_ lhs: TypeCount, _ rhs: TypeCount) -> Bool {

-        lhs.count == rhs.count &&

-        lhs.contentHash == rhs.contentHash &&

-        lhs.quality == rhs.quality &&

-        lhs.isUnsupported == rhs.isUnsupported

-    }

-

-    @MainActor private static func shouldBackfillDetailCache(

-        typeCount: TypeCount,

-        baseline: TypeCount?,

-        baselineID: UUID

-    ) -> Bool {

-        if typeCount.isContentAlias {

-            return false

-        }

-

-        if typeCount.detailCache?.matchesBaseline(baselineID) == true {

-            return false

-        }

-

-        guard canBuildDetailCache(typeCount),

-              baseline.map(canBuildDetailCache(_:)) ?? true else {

-            return false

-        }

-

-        return true

-    }

-

-    @MainActor private static func canBuildDetailCache(_ typeCount: TypeCount) -> Bool {

-        typeCount.count <= 0 || typeCount.recordArchiveData != nil

-    }

-

-    private static func detailCacheMetadata(current: TypeCount, previous: TypeCount?, source: String) -> [String: String] {

-        [

-            "source": source,

-            "type": current.typeIdentifier,

-            "currentCount": "\(current.count)",

-            "previousCount": "\(previous?.count ?? 0)",

-            "currentArchive": current.recordArchiveData.map { MemoryLog.format(UInt64($0.count)) } ?? "nil",

-            "previousArchive": previous?.recordArchiveData.map { MemoryLog.format(UInt64($0.count)) } ?? "nil",

-            "isAlias": "\(current.isContentAlias)"

-        ]

-    }

-

-    private static func buildSummary(snapshot: HealthSnapshot, incoming: SnapshotDelta?, outgoing: SnapshotDelta?) -> String {

-        let position: String

-        if incoming == nil && outgoing == nil { position = "standalone" }

-        else if incoming == nil { position = "oldest" }

-        else if outgoing == nil { position = "latest" }

-        else { position = "intermediate" }

-        return "Deleted \(position) snapshot \(snapshot.id) at \(snapshot.timestamp)"

-    }

-

-    enum LifecycleError: Error {

-        case missingNeighbor

-    }

-}

-

-private extension Bundle {

-    var appBuildVersion: String {

-        let version = infoDictionary?["CFBundleShortVersionString"] as? String ?? ""

-        let build = infoDictionary?["CFBundleVersion"] as? String ?? ""

-        return "\(version) (\(build))"

-    }

-}

-import Foundation

-import SwiftData

-

-struct TypeCountDetailCacheResolution: Sendable {

-    let cache: TypeCountDetailCache?

-    let diagnostic: String

-}

-

-extension TypeCount {

-    private static let detailCacheResolverVersion = "resolver-v5"

-

-    @MainActor

-    func ensureRecordArchiveDataIfNeeded() -> Bool {

-        if count <= 0 {

-            return true

-        }

-

-        if let existingArchive = recordArchiveData {

-            if HealthRecordArchive.isCompact(existingArchive) {

-                return true

-            }

-

-            guard let compactArchive = HealthRecordArchive.compactedIfNeeded(existingArchive) else {

-                return false

-            }

-            recordArchiveData = compactArchive

-            return true

-        }

-

-        let legacyRecords = records ?? []

-        guard !legacyRecords.isEmpty else {

-            return false

-        }

-

-        let values = legacyRecords.map { record in

-            HealthRecordValue(

-                typeIdentifier: record.typeIdentifier,

-                sampleUUIDHash: record.sampleUUIDHash,

-                recordFingerprint: record.recordFingerprint,

-                startDate: record.startDate,

-                endDate: record.endDate,

-                displayValue: record.displayValue

-            )

-        }

-        guard let archive = HealthRecordArchive.encode(values) else {

-            return false

-        }

-

-        recordArchiveData = archive

-        records?.removeAll()

-        return true

-    }

-

-    @MainActor

-    func resolveDetailCache(

-        previous: TypeCount?,

-        baselineSnapshotID: UUID?,

-        context: ModelContext,

-        source: String

-    ) -> TypeCountDetailCache? {

-        resolveDetailCacheWithDiagnostics(

-            previous: previous,

-            baselineSnapshotID: baselineSnapshotID,

-            context: context,

-            source: source

-        ).cache

-    }

-

-    @MainActor

-    func resolveDetailCacheWithDiagnostics(

-        previous: TypeCount?,

-        baselineSnapshotID: UUID?,

-        context: ModelContext,

-        source: String

-    ) -> TypeCountDetailCacheResolution {

-        if let cache = detailCache,

-           cache.matchesBaseline(baselineSnapshotID) {

-            return TypeCountDetailCacheResolution(

-                cache: cache,

-                diagnostic: detailCacheDiagnostic(

-                    previous: previous,

-                    baselineSnapshotID: baselineSnapshotID,

-                    phase: "cache-hit"

-                )

-            )

-        }

-

-        let currentArchiveWasMissing = count > 0 && recordArchiveData == nil

-        let previousArchiveWasMissing = (previous?.count ?? 0) > 0 && previous?.recordArchiveData == nil

-        let currentArchiveAvailable = ensureRecordArchiveDataIfNeeded()

-        let previousArchiveAvailable = previous?.ensureRecordArchiveDataIfNeeded() ?? true

-

-        guard currentArchiveAvailable, previousArchiveAvailable else {

-            let diagnostic = detailCacheDiagnostic(

-                previous: previous,

-                baselineSnapshotID: baselineSnapshotID,

-                phase: "missing-archive"

-            )

-            MemoryLog.log("\(source).detailCache.resolveUnavailable", metadata: detailCacheMetadata(previous: previous).merging([

-                "diagnostic": diagnostic

-            ]) { _, new in new })

-            return TypeCountDetailCacheResolution(cache: nil, diagnostic: diagnostic)

-        }

-

-        MemoryLog.log("\(source).detailCache.buildBegin", metadata: detailCacheMetadata(previous: previous))

-        let cache = TypeCountDetailCacheBuilder.build(

-            current: self,

-            previous: previous,

-            baselineSnapshotID: baselineSnapshotID

-        )

-        let diagnostic = detailCacheDiagnostic(

-            previous: previous,

-            baselineSnapshotID: baselineSnapshotID,

-            phase: cache == nil ? "build-nil" : "built"

-        )

-        MemoryLog.log("\(source).detailCache.buildEnd", metadata: [

-            "source": source,

-            "type": typeIdentifier,

-            "cacheBuilt": "\(cache != nil)",

-            "diagnostic": diagnostic

-        ])

-

-        if let cache {

-            setDetailCache(cache)

-        }

-

-        if cache != nil ||

-            (currentArchiveWasMissing && recordArchiveData != nil) ||

-            (previousArchiveWasMissing && previous?.recordArchiveData != nil) {

-            try? context.save()

-        }

-

-        return TypeCountDetailCacheResolution(cache: cache, diagnostic: diagnostic)

-    }

-

-    private func detailCacheMetadata(previous: TypeCount?) -> [String: String] {

-        [

-            "type": typeIdentifier,

-            "currentCount": "\(count)",

-            "previousCount": "\(previous?.count ?? 0)",

-            "currentArchive": recordArchiveData.map { MemoryLog.format(UInt64($0.count)) } ?? "nil",

-            "previousArchive": previous?.recordArchiveData.map { MemoryLog.format(UInt64($0.count)) } ?? "nil"

-        ]

-    }

-

-    private func detailCacheDiagnostic(

-        previous: TypeCount?,

-        baselineSnapshotID: UUID?,

-        phase: String

-    ) -> String {

-        let baseline = baselineSnapshotID?.uuidString.prefix(6) ?? "none"

-        let currentArchive = archiveDebugLabel(for: self)

-        let previousArchive = archiveDebugLabel(for: previous)

-        return "\(Self.detailCacheResolverVersion) phase=\(phase) base=\(baseline) curr=\(currentArchive) prev=\(previousArchive)"

-    }

-

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

-        guard let typeCount else { return "none" }

-        if let archive = typeCount.recordArchiveData {

-            let formatSuffix = HealthRecordArchive.isCompact(archive) ? "-c" : "-p"

-            return "\(MemoryLog.format(UInt64(archive.count)))\(formatSuffix)"

-        }

-        if typeCount.count <= 0 {

-            return "empty"

-        }

-        return "missing"

-    }

-}