Precompute datatype detail caches · 6e82b28

Precompute datatype detail caches
Browse files

bogdan committed 3 weeks ago

main

1 parent fcfaf56

commit 6e82b28

Showing 11 changed files with 515 additions and 126 deletions

+9 -0

AGENTS.md

@@ -131,6 +131,15 @@ final class TypeDistributionBin {
 // instead of building a full in-memory dictionary/array; plist archives remain readable
 // for backwards compatibility.
 
+// Interface updated 2026-05-17 — see AGENTS.md
+// Models/TypeCount.detailCacheData stores precomputed detail data for the current
+// TypeCount compared with the immediately previous snapshot on the same device.
+// The cache contains aggregate added/disappeared counts, capped preview records for
+// UI drill-down, and daily change bins for temporal charts. It must be computed when
+// snapshots are saved and refreshed for neighboring snapshots when snapshot deletion
+// changes chain links. Existing stores are backfilled incrementally with a strict
+// per-launch TypeCount cap to avoid decoding many large archives in one run.
+
 // Models/DetectedAnomaly.swift
 enum AnomalyType: String, Codable {
     case historicalInsertion = "historical_insertion"


+31 -0

HealthProbe/ContentView.swift

View

+                     import SwiftData
+                     struct ContentView: View {
+                    +    @Environment(\.modelContext) private var modelContext
+                    +    @AppStorage(AppSettings.typeDetailCacheBackfillVersionKey)
+                    +    private var typeDetailCacheBackfillVersion: Int = 0
+                    +    @State private var didAttemptTypeDetailCacheBackfill = false
+                         var body: some View {
+                             TabView {
+                                 Tab("Dashboard", systemImage: "waveform.path.ecg") {
+                                     SettingsView()
+                    +        .task {
+                    +            await rebuildTypeDetailCachesIfNeeded()
+                    +        }
+                    +    }
+                    +    @MainActor
+                    +    private func rebuildTypeDetailCachesIfNeeded() async {
+                    +        guard !didAttemptTypeDetailCacheBackfill,
+                    +              typeDetailCacheBackfillVersion < AppSettings.currentTypeDetailCacheBackfillVersion else {
+                    +            return
+                    +        }
+                    +        didAttemptTypeDetailCacheBackfill = true
+                    +        try? await Task.sleep(for: .seconds(2))
+                    +        do {
+                    +            let isComplete = try SnapshotLifecycleService.rebuildMissingDetailCaches(
+                    +                context: modelContext,
+                    +                maxTypeCounts: 1
+                    +            )
+                    +            if isComplete {
+                    +                typeDetailCacheBackfillVersion = AppSettings.currentTypeDetailCacheBackfillVersion
+                    +            }
+                    +        } catch {
+                    +            assertionFailure("Failed to rebuild type detail caches: \(error)")
+                    +        }

+56 -7

HealthProbe/Models/HealthRecord.swift

View

@@ -28,6 +28,30 @@ enum HealthRecordArchive {
         return try? PropertyListDecoder().decode([HealthRecordValue].self, from: data)
     }
 
+    static func forEachRecord(in data: Data, _ body: (HealthRecordValue) -> Void) -> Bool {
+        if data.starts(with: compactMagic) {
+            return forEachCompactRecord(in: data, body)
+        }
+
+        guard let decoded = try? PropertyListDecoder().decode([HealthRecordValue].self, from: data) else {
+            return false
+        }
+        for value in decoded {
+            body(value)
+        }
+        return true
+    }
+
+    static func fingerprintSet(from data: Data?) -> Set<String>? {
+        guard let data else { return [] }
+
+        var fingerprints = Set<String>()
+        let didRead = forEachRecord(in: data) { value in
+            fingerprints.insert(value.recordFingerprint)
+        }
+        return didRead ? fingerprints : nil
+    }
+
     static func makeCompactWriter(typeIdentifier: String, estimatedRecordCount: Int = 0) -> CompactWriter {
         CompactWriter(typeIdentifier: typeIdentifier, estimatedRecordCount: estimatedRecordCount)
     }
@@ -108,24 +132,49 @@ enum HealthRecordArchive {
     }
 
     private static func decodeCompact(_ data: Data) -> [HealthRecordValue]? {
-        guard data.starts(with: compactMagic) else { return nil }
+        var values: [HealthRecordValue] = []
+        var expectedCount = 0
+        guard forEachCompactRecord(in: data, onHeader: { count in
+            expectedCount = count
+            values.reserveCapacity(count)
+        }, body: { value in
+            values.append(value)
+        }) else {
+            return nil
+        }
+        guard values.count == expectedCount else { return nil }
+        return values
+    }
+
+    private static func forEachCompactRecord(
+        in data: Data,
+        _ body: (HealthRecordValue) -> Void
+    ) -> Bool {
+        forEachCompactRecord(in: data, onHeader: { _ in }, body: body)
+    }
+
+    private static func forEachCompactRecord(
+        in data: Data,
+        onHeader: (Int) -> Void,
+        body: (HealthRecordValue) -> Void
+    ) -> Bool {
+        guard data.starts(with: compactMagic) else { return false }
         var reader = CompactReader(data: data, offset: compactMagic.count)
         guard let typeIdentifier = reader.readString(),
               let count = reader.readUInt64() else {
-            return nil
+            return false
         }
 
-        var values: [HealthRecordValue] = []
-        values.reserveCapacity(Int(min(count, UInt64(Int.max))))
+        onHeader(Int(min(count, UInt64(Int.max))))
         for _ in 0..<count {
             guard let sampleUUIDHash = reader.readString(),
                   let recordFingerprint = reader.readString(),
                   let startInterval = reader.readDouble(),
                   let endInterval = reader.readDouble(),
                   let displayValue = reader.readOptionalString() else {
-                return nil
+                return false
             }
-            values.append(
+            body(
                 HealthRecordValue(
                     typeIdentifier: typeIdentifier,
                     sampleUUIDHash: sampleUUIDHash,
@@ -136,7 +185,7 @@ enum HealthRecordArchive {
                 )
             )
         }
-        return values
+        return true
     }
 
     private struct CompactReader {


+11 -1

HealthProbe/Models/TypeCount.swift

View

@@ -1,7 +1,7 @@
 import Foundation
 import SwiftData
 
-// Interface updated 2026-05-14 — see AGENTS.md
+// Interface updated 2026-05-17 — see AGENTS.md
 @Model final class TypeCount {
     var id: UUID = UUID()
     var typeIdentifier: String = ""
@@ -13,6 +13,7 @@ import SwiftData
     var qualityRaw: String = SnapshotQuality.complete.rawValue
     var isUnsupported: Bool = false
     @Attribute(.externalStorage) var recordArchiveData: Data?
+    @Attribute(.externalStorage) var detailCacheData: Data?
     var snapshot: HealthSnapshot?
     @Relationship(deleteRule: .cascade, inverse: \YearlyCount.typeCount)
     var yearlyCounts: [YearlyCount]? = []
@@ -49,4 +50,13 @@ extension TypeCount {
         recordArchiveData = HealthRecordArchive.encode(values)
         records?.removeAll()
     }
+
+    @MainActor var detailCache: TypeCountDetailCache? {
+        guard let detailCacheData else { return nil }
+        return TypeCountDetailCacheArchive.decode(detailCacheData)
+    }
+
+    @MainActor func setDetailCache(_ cache: TypeCountDetailCache?) {
+        detailCacheData = cache.flatMap(TypeCountDetailCacheArchive.encode)
+    }
 }


+192 -0

HealthProbe/Models/TypeCountDetailCache.swift

View

+                    +import Foundation
+                    +// Interface updated 2026-05-17 — see AGENTS.md
+                    +struct TypeCountDailyChangeBin: Codable, Equatable, Sendable {
+                    +    let dayStart: Date
+                    +    let added: Int
+                    +    let disappeared: Int
+                    +    let unchanged: Int
+                    +}
+                    +// Interface updated 2026-05-17 — see AGENTS.md
+                    +struct TypeCountDetailCache: Codable, Equatable, Sendable {
+                    +    static let previewLimit = 1_000
+                    +    let baselineSnapshotID: UUID?
+                    +    let addedCount: Int
+                    +    let disappearedCount: Int
+                    +    let addedPreviewRecords: [HealthRecordValue]
+                    +    let disappearedPreviewRecords: [HealthRecordValue]
+                    +    let dailyChangeBins: [TypeCountDailyChangeBin]
+                    +    let earliestRecordDate: Date?
+                    +    let latestRecordDate: Date?
+                    +    var isPreviewLimited: Bool {
+                    +        addedCount > Self.previewLimit || disappearedCount > Self.previewLimit
+                    +    }
+                    +    func matchesBaseline(_ snapshotID: UUID?) -> Bool {
+                    +        baselineSnapshotID == snapshotID
+                    +    }
+                    +}
+                    +enum TypeCountDetailCacheArchive {
+                    +    static func encode(_ cache: TypeCountDetailCache) -> Data? {
+                    +        try? PropertyListEncoder().encode(cache)
+                    +    }
+                    +    static func decode(_ data: Data) -> TypeCountDetailCache? {
+                    +        try? PropertyListDecoder().decode(TypeCountDetailCache.self, from: data)
+                    +    }
+                    +}
+                    +enum TypeCountDetailCacheBuilder {
+                    +    static func build(
+                    +        current: TypeCount,
+                    +        previous: TypeCount?,
+                    +        baselineSnapshotID: UUID?
+                    +    ) -> TypeCountDetailCache? {
+                    +        guard let currentFingerprints = HealthRecordArchive.fingerprintSet(from: current.recordArchiveData),
+                    +              let previousFingerprints = HealthRecordArchive.fingerprintSet(from: previous?.recordArchiveData) else {
+                    +            return nil
+                    +        }
+                    +        if current.count > 0, current.recordArchiveData == nil { return nil }
+                    +        if let previous, previous.count > 0, previous.recordArchiveData == nil { return nil }
+                    +        var accumulator = DetailCacheAccumulator()
+                    +        if let previousArchive = previous?.recordArchiveData {
+                    +            guard HealthRecordArchive.forEachRecord(in: previousArchive, { record in
+                    +                if !currentFingerprints.contains(record.recordFingerprint) {
+                    +                    accumulator.add(record, as: .disappeared)
+                    +                }
+                    +            }) else {
+                    +                return nil
+                    +            }
+                    +        }
+                    +        if let currentArchive = current.recordArchiveData {
+                    +            guard HealthRecordArchive.forEachRecord(in: currentArchive, { record in
+                    +                if previousFingerprints.contains(record.recordFingerprint) {
+                    +                    accumulator.add(record, as: .unchanged)
+                    +                } else {
+                    +                    accumulator.add(record, as: .added)
+                    +                }
+                    +            }) else {
+                    +                return nil
+                    +            }
+                    +        }
+                    +        return TypeCountDetailCache(
+                    +            baselineSnapshotID: baselineSnapshotID,
+                    +            addedCount: accumulator.addedCount,
+                    +            disappearedCount: accumulator.disappearedCount,
+                    +            addedPreviewRecords: accumulator.addedPreview.records,
+                    +            disappearedPreviewRecords: accumulator.disappearedPreview.records,
+                    +            dailyChangeBins: accumulator.dailyBins,
+                    +            earliestRecordDate: accumulator.earliestRecordDate,
+                    +            latestRecordDate: accumulator.latestRecordDate
+                    +        )
+                    +    }
+                    +}
+                    +private enum TypeCountDetailCacheRecordKind {
+                    +    case added
+                    +    case disappeared
+                    +    case unchanged
+                    +}
+                    +private struct DetailCacheAccumulator {
+                    +    private let calendar = Calendar.current
+                    +    private var bins: [Date: (added: Int, disappeared: Int, unchanged: Int)] = [:]
+                    +    var addedCount = 0
+                    +    var disappearedCount = 0
+                    +    var addedPreview = NewestRecordBuffer(limit: TypeCountDetailCache.previewLimit)
+                    +    var disappearedPreview = NewestRecordBuffer(limit: TypeCountDetailCache.previewLimit)
+                    +    var earliestRecordDate: Date?
+                    +    var latestRecordDate: Date?
+                    +    var dailyBins: [TypeCountDailyChangeBin] {
+                    +        bins
+                    +            .map { dayStart, counts in
+                    +                TypeCountDailyChangeBin(
+                    +                    dayStart: dayStart,
+                    +                    added: counts.added,
+                    +                    disappeared: counts.disappeared,
+                    +                    unchanged: counts.unchanged
+                    +                )
+                    +            }
+                    +            .sorted { $0.dayStart < $1.dayStart }
+                    +    }
+                    +    mutating func add(_ record: HealthRecordValue, as kind: TypeCountDetailCacheRecordKind) {
+                    +        updateDateRange(with: record.startDate)
+                    +        let dayStart = calendar.startOfDay(for: record.startDate)
+                    +        var bin = bins[dayStart] ?? (added: 0, disappeared: 0, unchanged: 0)
+                    +        switch kind {
+                    +        case .added:
+                    +            addedCount += 1
+                    +            addedPreview.append(record)
+                    +            bin.added += 1
+                    +        case .disappeared:
+                    +            disappearedCount += 1
+                    +            disappearedPreview.append(record)
+                    +            bin.disappeared += 1
+                    +        case .unchanged:
+                    +            bin.unchanged += 1
+                    +        }
+                    +        bins[dayStart] = bin
+                    +    }
+                    +    private mutating func updateDateRange(with date: Date) {
+                    +        if earliestRecordDate.map({ date < $0 }) ?? true {
+                    +            earliestRecordDate = date
+                    +        }
+                    +        if latestRecordDate.map({ date > $0 }) ?? true {
+                    +            latestRecordDate = date
+                    +        }
+                    +    }
+                    +}
+                    +private struct NewestRecordBuffer {
+                    +    let limit: Int
+                    +    private var storage: [HealthRecordValue] = []
+                    +    private var oldestPreviewIndex: Int?
+                    +    init(limit: Int) {
+                    +        self.limit = limit
+                    +    }
+                    +    var records: [HealthRecordValue] {
+                    +        storage.sorted { $0.startDate > $1.startDate }
+                    +    }
+                    +    mutating func append(_ record: HealthRecordValue) {
+                    +        guard limit > 0 else { return }
+                    +        if storage.count < limit {
+                    +            storage.append(record)
+                    +            refreshOldestPreviewIndex()
+                    +            return
+                    +        }
+                    +        guard let oldestPreviewIndex,
+                    +              record.startDate > storage[oldestPreviewIndex].startDate else {
+                    +            return
+                    +        }
+                    +        storage[oldestPreviewIndex] = record
+                    +        refreshOldestPreviewIndex()
+                    +    }
+                    +    private mutating func refreshOldestPreviewIndex() {
+                    +        oldestPreviewIndex = storage.indices.min { lhs, rhs in
+                    +            storage[lhs].startDate < storage[rhs].startDate
+                    +        }
+                    +    }
+                    +}

+43 -0

HealthProbe/Services/HealthKitService.swift

View

@@ -140,6 +140,11 @@ final class HealthKitService {
             intendedTypeIDs: active.map { $0.id },
             context: context
         )
+        precomputeTypeCountDetailCaches(
+            snapshot: snapshot,
+            typeCounts: typeCounts,
+            context: context
+        )
 
         if snapshot.snapshotQuality == .complete,
            reviewAmbiguousCompleteDisappearedTypes,
@@ -167,6 +172,11 @@ final class HealthKitService {
             intendedTypeIDs: typeCounts.map(\.typeIdentifier),
             context: context
         )
+        precomputeTypeCountDetailCaches(
+            snapshot: snapshot,
+            typeCounts: typeCounts,
+            context: context
+        )
         try await persistSnapshot(snapshot, typeCounts: typeCounts, context: context)
         return snapshot
     }
@@ -185,6 +195,11 @@ final class HealthKitService {
             intendedTypeIDs: typeCounts.map(\.typeIdentifier),
             context: context
         )
+        precomputeTypeCountDetailCaches(
+            snapshot: snapshot,
+            typeCounts: typeCounts,
+            context: context
+        )
         try await persistSnapshot(snapshot, typeCounts: typeCounts, context: context)
         return snapshot
     }
@@ -294,6 +309,34 @@ final class HealthKitService {
         }
     }
 
+    private func precomputeTypeCountDetailCaches(
+        snapshot: HealthSnapshot,
+        typeCounts: [TypeCount],
+        context: ModelContext
+    ) {
+        guard let previousID = snapshot.previousSnapshotID,
+              let previous = fetchSnapshot(id: previousID, context: context) else {
+            for typeCount in typeCounts {
+                typeCount.setDetailCache(nil)
+            }
+            return
+        }
+
+        let previousByType = Dictionary(
+            uniqueKeysWithValues: (previous.typeCounts ?? []).map { ($0.typeIdentifier, $0) }
+        )
+
+        for typeCount in typeCounts {
+            typeCount.setDetailCache(
+                TypeCountDetailCacheBuilder.build(
+                    current: typeCount,
+                    previous: previousByType[typeCount.typeIdentifier],
+                    baselineSnapshotID: previous.id
+                )
+            )
+        }
+    }
+
     private func hasAmbiguousCompleteDisappearance(
         snapshot: HealthSnapshot,
         typeCounts: [TypeCount],


+99 -0

HealthProbe/Services/SnapshotLifecycleService.swift

View

+                                 if let nextSnap = try fetchSnapshot(id: outgoing.toSnapshotID, context: context) {
+                                     nextSnap.previousSnapshotID = nil
+                                     nextSnap.isChainStart = true
+                    +                refreshDetailCaches(for: nextSnap, baseline: nil)
+                                 context.delete(outgoing)
+                                 context.delete(snapshot)
+                                 for td in merged.typeDeltas ?? [] { context.insert(td) }
+                                 nextSnap.previousSnapshotID = prevSnap.id
+                    +            refreshDetailCaches(for: nextSnap, baseline: prevSnap)
+                                 context.delete(d1)
+                                 context.delete(d2)
+                                 context.delete(snapshot)
+                    +    static func rebuildMissingDetailCaches(
+                    +        context: ModelContext,
+                    +        maxTypeCounts: Int
+                    +    ) throws -> Bool {
+                    +        guard maxTypeCounts > 0 else { return false }
+                    +        let descriptor = FetchDescriptor<HealthSnapshot>(
+                    +            sortBy: [SortDescriptor(\.timestamp, order: .forward)]
+                    +        )
+                    +        let snapshots = try context.fetch(descriptor)
+                    +        var rebuiltCount = 0
+                    +        for snapshot in snapshots {
+                    +            guard let baselineID = snapshot.previousSnapshotID,
+                    +                  let baseline = try fetchSnapshot(id: baselineID, context: context) else {
+                    +                continue
+                    +            }
+                    +            let baselineByType = Dictionary(
+                    +                uniqueKeysWithValues: (baseline.typeCounts ?? []).map { ($0.typeIdentifier, $0) }
+                    +            )
+                    +            for typeCount in snapshot.typeCounts ?? [] {
+                    +                guard shouldBackfillDetailCache(
+                    +                    typeCount: typeCount,
+                    +                    baseline: baselineByType[typeCount.typeIdentifier],
+                    +                    baselineID: baseline.id
+                    +                ) else {
+                    +                    continue
+                    +                }
+                    +                typeCount.setDetailCache(
+                    +                    TypeCountDetailCacheBuilder.build(
+                    +                        current: typeCount,
+                    +                        previous: baselineByType[typeCount.typeIdentifier],
+                    +                        baselineSnapshotID: baseline.id
+                    +                    )
+                    +                )
+                    +                rebuiltCount += 1
+                    +                if rebuiltCount >= maxTypeCounts {
+                    +                    try context.save()
+                    +                    return false
+                    +                }
+                    +            }
+                    +        }
+                    +        if rebuiltCount > 0 {
+                    +            try context.save()
+                    +        }
+                    +        return true
+                    +    }
+                         // MARK: - Fetch helpers
+                         private static func fetchDeltas(context: ModelContext) throws -> [SnapshotDelta] {
+                             return try context.fetch(descriptor).first
+                    +    private static func refreshDetailCaches(for snapshot: HealthSnapshot, baseline: HealthSnapshot?) {
+                    +        guard let baseline else {
+                    +            for typeCount in snapshot.typeCounts ?? [] {
+                    +                typeCount.setDetailCache(nil)
+                    +            }
+                    +            return
+                    +        }
+                    +        let baselineByType = Dictionary(
+                    +            uniqueKeysWithValues: (baseline.typeCounts ?? []).map { ($0.typeIdentifier, $0) }
+                    +        )
+                    +        for typeCount in snapshot.typeCounts ?? [] {
+                    +            typeCount.setDetailCache(
+                    +                TypeCountDetailCacheBuilder.build(
+                    +                    current: typeCount,
+                    +                    previous: baselineByType[typeCount.typeIdentifier],
+                    +                    baselineSnapshotID: baseline.id
+                    +                )
+                    +            )
+                    +        }
+                    +    }
+                    +    @MainActor private static func shouldBackfillDetailCache(
+                    +        typeCount: TypeCount,
+                    +        baseline: TypeCount?,
+                    +        baselineID: UUID
+                    +    ) -> Bool {
+                    +        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 buildSummary(snapshot: HealthSnapshot, incoming: SnapshotDelta?, outgoing: SnapshotDelta?) -> String {
+                             let position: String
+                             if incoming == nil && outgoing == nil { position = "standalone" }

+2 -0

HealthProbe/Utilities/AppSettings.swift

View

@@ -6,6 +6,8 @@ final class AppSettings {
     private static let selectedTypeIDsKey   = "hp_selectedTypeIDs"
     private static let selectedDeviceIDsKey = "hp_selectedDeviceIDs"
     static let adaptiveTimeoutsEnabledKey = "hp_adaptiveTimeoutsEnabled"
+    static let typeDetailCacheBackfillVersionKey = "hp_typeDetailCacheBackfillVersion"
+    static let currentTypeDetailCacheBackfillVersion = 1
 
     var selectedTypeIDs: Set<String> {
         didSet { persistTypes() }


+16 -38

HealthProbe/ViewModels/DataTypeTemporalDistributionViewModel.swift

View

@@ -6,13 +6,13 @@ enum BinningStrategy: String, CaseIterable, Equatable {
     case month = "Lună"
     case year = "An"
 
-    var calendar: Calendar {
+    nonisolated var calendar: Calendar {
         var cal = Calendar.current
         cal.timeZone = TimeZone(abbreviation: "UTC") ?? TimeZone.current
         return cal
     }
 
-    func bins(from startDate: Date, to endDate: Date) -> [Date] {
+    nonisolated func bins(from startDate: Date, to endDate: Date) -> [Date] {
         var result: [Date] = []
         var current = startDate
 
@@ -42,7 +42,7 @@ enum BinningStrategy: String, CaseIterable, Equatable {
         return result
     }
 
-    func label(for date: Date) -> String {
+    nonisolated func label(for date: Date) -> String {
         switch self {
         case .day:
             return date.formatted(.dateTime.hour().minute())
@@ -55,11 +55,11 @@ enum BinningStrategy: String, CaseIterable, Equatable {
         }
     }
 
-    func contains(_ date: Date, in binStart: Date, binEnd: Date) -> Bool {
+    nonisolated func contains(_ date: Date, in binStart: Date, binEnd: Date) -> Bool {
         date >= binStart && date < binEnd
     }
 
-    func dateRange(containing date: Date) -> (start: Date, end: Date) {
+    nonisolated func dateRange(containing date: Date) -> (start: Date, end: Date) {
         let cal = calendar
 
         switch self {
@@ -110,10 +110,6 @@ final class DataTypeTemporalDistributionViewModel: Sendable {
         }
     }
 
-    private var addedRecords: [HealthRecordValue] = []
-    private var disappearedRecords: [HealthRecordValue] = []
-    private var unchangedRecords: [HealthRecordValue] = []
-
     private var addedByDate: [Date: Int] = [:]
     private var disappearedByDate: [Date: Int] = [:]
     private var unchangedByDate: [Date: Int] = [:]
@@ -126,23 +122,14 @@ final class DataTypeTemporalDistributionViewModel: Sendable {
             return
         }
 
-        let currentRecords = current.recordValues
-        let previousRecords = previous?.recordValues ?? []
-
-        let currentFingerprints = Set(currentRecords.map(\.recordFingerprint))
-        let previousFingerprints = Set(previousRecords.map(\.recordFingerprint))
-
-        addedRecords = currentRecords.filter { !previousFingerprints.contains($0.recordFingerprint) }
-        disappearedRecords = previousRecords.filter { !currentFingerprints.contains($0.recordFingerprint) }
-        unchangedRecords = currentRecords.filter { currentFingerprints.contains($0.recordFingerprint) }
-
-        guard !currentRecords.isEmpty else {
-            error = "No records to display"
+        guard let cache = current.detailCache,
+              cache.matchesBaseline(previous?.snapshot?.id) else {
+            error = "Precomputed detail data is unavailable for this snapshot. Create a new snapshot to generate temporal detail caches."
             return
         }
 
-        let dates = currentRecords.map(\.startDate)
-        guard let minDate = dates.min(), let maxDate = dates.max() else {
+        guard let minDate = cache.earliestRecordDate,
+              let maxDate = cache.latestRecordDate else {
             error = "Cannot determine date range"
             return
         }
@@ -150,23 +137,14 @@ final class DataTypeTemporalDistributionViewModel: Sendable {
         dateRange = (minDate, maxDate)
         displayedDateRange = (minDate, maxDate)
 
-        await indexRecordsByDate()
+        indexDailyBins(cache.dailyChangeBins)
         await rebuildBinsBackground()
     }
 
-    private func indexRecordsByDate() async {
-        let calendar = Calendar.current
-
-        func dayKey(_ date: Date) -> Date {
-            calendar.startOfDay(for: date)
-        }
-
-        addedByDate = Dictionary(grouping: addedRecords, by: { dayKey($0.startDate) })
-            .mapValues { $0.count }
-        disappearedByDate = Dictionary(grouping: disappearedRecords, by: { dayKey($0.startDate) })
-            .mapValues { $0.count }
-        unchangedByDate = Dictionary(grouping: unchangedRecords, by: { dayKey($0.startDate) })
-            .mapValues { $0.count }
+    private func indexDailyBins(_ bins: [TypeCountDailyChangeBin]) {
+        addedByDate = Dictionary(uniqueKeysWithValues: bins.map { ($0.dayStart, $0.added) })
+        disappearedByDate = Dictionary(uniqueKeysWithValues: bins.map { ($0.dayStart, $0.disappeared) })
+        unchangedByDate = Dictionary(uniqueKeysWithValues: bins.map { ($0.dayStart, $0.unchanged) })
     }
 
     private func adjustDisplayRangeForStrategy() {
@@ -254,7 +232,7 @@ struct TemporalBin: Identifiable, Sendable {
 }
 
 extension Array {
-    fileprivate subscript(safe index: Index) -> Element? {
+    nonisolated fileprivate subscript(safe index: Index) -> Element? {
         indices.contains(index) ? self[index] : nil
     }
 }


+6 -26

HealthProbe/Views/DataTypes/RecordChangeEvolutionChart.swift

View

+                         private func recordDiff(current: HealthSnapshot, previous: HealthSnapshot?) -> (added: Int, disappeared: Int) {
+                             guard let previous = previous else { return (0, 0) }
+                    -        let currentArchive = current.typeCounts?.first { $0.typeIdentifier == typeIdentifier }?.recordArchiveData
+                    -        let previousArchive = previous.typeCounts?.first { $0.typeIdentifier == typeIdentifier }?.recordArchiveData
+                    -        let currentRecords: [HealthRecordValue]
+                    -        if let currentArchive {
+                    -            guard let decoded = HealthRecordArchive.decode(currentArchive) else { return (0, 0) }
+                    -            currentRecords = decoded
+                    -        } else {
+                    -            currentRecords = []
+                    +        guard let cache = current.typeCounts?
+                    +            .first(where: { $0.typeIdentifier == typeIdentifier })?
+                    +            .detailCache,
+                    +              cache.matchesBaseline(previous.id) else {
+                    +            return (0, 0)
+                    -        let previousRecords: [HealthRecordValue]
+                    -        if let previousArchive {
+                    -            guard let decoded = HealthRecordArchive.decode(previousArchive) else { return (0, 0) }
+                    -            previousRecords = decoded
+                    -        } else {
+                    -            previousRecords = []
+                    -        }
+                    -        let previousFingerprints = Set(previousRecords.map(\.recordFingerprint))
+                    -        let currentFingerprints = Set(currentRecords.map(\.recordFingerprint))
+                    -        let added = currentRecords.filter { !previousFingerprints.contains($0.recordFingerprint) }.count
+                    -        let disappeared = previousRecords.filter { !currentFingerprints.contains($0.recordFingerprint) }.count
+                    -        return (added, disappeared)
+                    +        return (cache.addedCount, cache.disappearedCount)
+                         var body: some View {

+50 -54

HealthProbe/Views/Snapshots/DataTypeSnapshotDetailView.swift

View

+                         let typeIdentifier: String
+                         let displayName: String
+                    +    @Environment(\.modelContext) private var modelContext
+                         @Query(sort: \HealthSnapshot.timestamp) private var allSnapshots: [HealthSnapshot]
+                         @State private var displayedSnapshot: HealthSnapshot?
+                                 case .unavailable:
+                                     Label(
+                    -                    "Legacy record format. Recreate database to inspect details.",
+                    +                    "Record detail cache is unavailable for this snapshot pair.",
+                                         systemImage: "exclamationmark.triangle.fill"
+                                     .font(.subheadline)
+                             let currentCount = currentTypeCount?.count ?? 0
+                             let previousCount = previousTypeCount?.count ?? 0
+                    -        let currentArchive = currentTypeCount?.recordArchiveData
+                    -        let previousArchive = previousTypeCount?.recordArchiveData
+                    -        let currentNeedsArchive = currentCount > 0
+                    -        let previousNeedsArchive = previousCount > 0
+                    -        guard (!currentNeedsArchive || currentArchive != nil),
+                    -              (!previousNeedsArchive || previousArchive != nil) else {
+                    +        guard currentCount >= 0, previousCount >= 0 else {
+                                 diffState = .unavailable
+                                 return
+                    -        diffState = .loading
+                    -        let result = await Task.detached(priority: .userInitiated) {
+                    -            DataTypeRecordDiff.compute(
+                    -                currentArchive: currentArchive,
+                    -                previousArchive: previousArchive
+                    -            )
+                    -        }.value
+                    -        diffState = result
+                    +        guard let cache = currentDetailCache() else {
+                    +            diffState = .unavailable
+                    +            return
+                    +        }
+                    +        diffState = .loaded(DataTypeRecordDiff(cache: cache))
+                    +    }
+                    +    @MainActor
+                    +    private func currentDetailCache() -> TypeCountDetailCache? {
+                    +        if let cache = currentTypeCount?.detailCache,
+                    +           cache.matchesBaseline(previousSnapshot?.id) {
+                    +            return cache
+                    +        }
+                    +        guard let currentTypeCount,
+                    +              let previousSnapshot else {
+                    +            return nil
+                    +        }
+                    +        let cache = TypeCountDetailCacheBuilder.build(
+                    +            current: currentTypeCount,
+                    +            previous: previousTypeCount,
+                    +            baselineSnapshotID: previousSnapshot.id
+                    +        )
+                    +        currentTypeCount.setDetailCache(cache)
+                    +        if cache != nil {
+                    +            try? modelContext.save()
+                    +        }
+                    +        return cache
+                         let addedRecords: [HealthRecordValue]
+                         let disappearedRecords: [HealthRecordValue]
+                    -    var isPreviewLimited: Bool {
+                    -        addedCount > Self.previewLimit || disappearedCount > Self.previewLimit
+                    +    init(
+                    +        addedCount: Int,
+                    +        disappearedCount: Int,
+                    +        addedRecords: [HealthRecordValue],
+                    +        disappearedRecords: [HealthRecordValue]
+                    +    ) {
+                    +        self.addedCount = addedCount
+                    +        self.disappearedCount = disappearedCount
+                    +        self.addedRecords = addedRecords
+                    +        self.disappearedRecords = disappearedRecords
+                    -    static func compute(currentArchive: Data?, previousArchive: Data?) -> RecordDiffState {
+                    -        let currentRecords: [HealthRecordValue]
+                    -        if let currentArchive {
+                    -            guard let decoded = HealthRecordArchive.decode(currentArchive) else {
+                    -                return .failed("Could not decode current record archive.")
+                    -            }
+                    -            currentRecords = decoded
+                    -        } else {
+                    -            currentRecords = []
+                    -        }
+                    -        let previousRecords: [HealthRecordValue]
+                    -        if let previousArchive {
+                    -            guard let decoded = HealthRecordArchive.decode(previousArchive) else {
+                    -                return .failed("Could not decode previous record archive.")
+                    -            }
+                    -            previousRecords = decoded
+                    -        } else {
+                    -            previousRecords = []
+                    -        }
+                    -        let previousFingerprints = Set(previousRecords.map(\.recordFingerprint))
+                    -        let currentFingerprints = Set(currentRecords.map(\.recordFingerprint))
+                    -        let added = currentRecords.filter { !previousFingerprints.contains($0.recordFingerprint) }
+                    -        let disappeared = previousRecords.filter { !currentFingerprints.contains($0.recordFingerprint) }
+                    -        return .loaded(
+                    -            DataTypeRecordDiff(
+                    -                addedCount: added.count,
+                    -                disappearedCount: disappeared.count,
+                    -                addedRecords: newestRecords(from: added),
+                    -                disappearedRecords: newestRecords(from: disappeared)
+                    -            )
+                    -        )
+                    +    init(cache: TypeCountDetailCache) {
+                    +        self.addedCount = cache.addedCount
+                    +        self.disappearedCount = cache.disappearedCount
+                    +        self.addedRecords = cache.addedPreviewRecords
+                    +        self.disappearedRecords = cache.disappearedPreviewRecords
+                    -    private static func newestRecords(from records: [HealthRecordValue]) -> [HealthRecordValue] {
+                    -        Array(records.sorted { $0.startDate > $1.startDate }.prefix(previewLimit))
+                    +    var isPreviewLimited: Bool {
+                    +        addedCount > Self.previewLimit || disappearedCount > Self.previewLimit

	@@ -140,6 +140,11 @@ final class HealthKitService {
140	140	intendedTypeIDs: active.map { $0.id },
141	141	context: context
142	142	)
	143	+ precomputeTypeCountDetailCaches(
	144	+ snapshot: snapshot,
	145	+ typeCounts: typeCounts,
	146	+ context: context
	147	+ )
143	148
144	149	if snapshot.snapshotQuality == .complete,
145	150	reviewAmbiguousCompleteDisappearedTypes,
	@@ -167,6 +172,11 @@ final class HealthKitService {
167	172	intendedTypeIDs: typeCounts.map(\.typeIdentifier),
168	173	context: context
169	174	)
	175	+ precomputeTypeCountDetailCaches(
	176	+ snapshot: snapshot,
	177	+ typeCounts: typeCounts,
	178	+ context: context
	179	+ )
170	180	try await persistSnapshot(snapshot, typeCounts: typeCounts, context: context)
171	181	return snapshot
172	182	}
	@@ -185,6 +195,11 @@ final class HealthKitService {
185	195	intendedTypeIDs: typeCounts.map(\.typeIdentifier),
186	196	context: context
187	197	)
	198	+ precomputeTypeCountDetailCaches(
	199	+ snapshot: snapshot,
	200	+ typeCounts: typeCounts,
	201	+ context: context
	202	+ )
188	203	try await persistSnapshot(snapshot, typeCounts: typeCounts, context: context)
189	204	return snapshot
190	205	}
	@@ -294,6 +309,34 @@ final class HealthKitService {
294	309	}
295	310	}
296	311
	312	+ private func precomputeTypeCountDetailCaches(
	313	+ snapshot: HealthSnapshot,
	314	+ typeCounts: [TypeCount],
	315	+ context: ModelContext
	316	+ ) {
	317	+ guard let previousID = snapshot.previousSnapshotID,
	318	+ let previous = fetchSnapshot(id: previousID, context: context) else {
	319	+ for typeCount in typeCounts {
	320	+ typeCount.setDetailCache(nil)
	321	+ }
	322	+ return
	323	+ }
	324	+
	325	+ let previousByType = Dictionary(
	326	+ uniqueKeysWithValues: (previous.typeCounts ?? []).map { ($0.typeIdentifier, $0) }
	327	+ )
	328	+
	329	+ for typeCount in typeCounts {
	330	+ typeCount.setDetailCache(
	331	+ TypeCountDetailCacheBuilder.build(
	332	+ current: typeCount,
	333	+ previous: previousByType[typeCount.typeIdentifier],
	334	+ baselineSnapshotID: previous.id
	335	+ )
	336	+ )
	337	+ }
	338	+ }
	339	+
297	340	private func hasAmbiguousCompleteDisappearance(
298	341	snapshot: HealthSnapshot,
299	342	typeCounts: [TypeCount],

	@@ -131,6 +131,15 @@ final class TypeDistributionBin {
131	131	// instead of building a full in-memory dictionary/array; plist archives remain readable
132	132	// for backwards compatibility.
133	133
	134	+// Interface updated 2026-05-17 — see AGENTS.md
	135	+// Models/TypeCount.detailCacheData stores precomputed detail data for the current
	136	+// TypeCount compared with the immediately previous snapshot on the same device.
	137	+// The cache contains aggregate added/disappeared counts, capped preview records for
	138	+// UI drill-down, and daily change bins for temporal charts. It must be computed when
	139	+// snapshots are saved and refreshed for neighboring snapshots when snapshot deletion
	140	+// changes chain links. Existing stores are backfilled incrementally with a strict
	141	+// per-launch TypeCount cap to avoid decoding many large archives in one run.
	142	+
134	143	// Models/DetectedAnomaly.swift
135	144	enum AnomalyType: String, Codable {
136	145	case historicalInsertion = "historical_insertion"

	@@ -28,6 +28,30 @@ enum HealthRecordArchive {
28	28	return try? PropertyListDecoder().decode([HealthRecordValue].self, from: data)
29	29	}
30	30
	31	+ static func forEachRecord(in data: Data, _ body: (HealthRecordValue) -> Void) -> Bool {
	32	+ if data.starts(with: compactMagic) {
	33	+ return forEachCompactRecord(in: data, body)
	34	+ }
	35	+
	36	+ guard let decoded = try? PropertyListDecoder().decode([HealthRecordValue].self, from: data) else {
	37	+ return false
	38	+ }
	39	+ for value in decoded {
	40	+ body(value)
	41	+ }
	42	+ return true
	43	+ }
	44	+
	45	+ static func fingerprintSet(from data: Data?) -> Set<String>? {
	46	+ guard let data else { return [] }
	47	+
	48	+ var fingerprints = Set<String>()
	49	+ let didRead = forEachRecord(in: data) { value in
	50	+ fingerprints.insert(value.recordFingerprint)
	51	+ }
	52	+ return didRead ? fingerprints : nil
	53	+ }
	54	+
31	55	static func makeCompactWriter(typeIdentifier: String, estimatedRecordCount: Int = 0) -> CompactWriter {
32	56	CompactWriter(typeIdentifier: typeIdentifier, estimatedRecordCount: estimatedRecordCount)
33	57	}
	@@ -108,24 +132,49 @@ enum HealthRecordArchive {
108	132	}
109	133
110	134	private static func decodeCompact(_ data: Data) -> [HealthRecordValue]? {
111		- guard data.starts(with: compactMagic) else { return nil }
	135	+ var values: [HealthRecordValue] = []
	136	+ var expectedCount = 0
	137	+ guard forEachCompactRecord(in: data, onHeader: { count in
	138	+ expectedCount = count
	139	+ values.reserveCapacity(count)
	140	+ }, body: { value in
	141	+ values.append(value)
	142	+ }) else {
	143	+ return nil
	144	+ }
	145	+ guard values.count == expectedCount else { return nil }
	146	+ return values
	147	+ }
	148	+
	149	+ private static func forEachCompactRecord(
	150	+ in data: Data,
	151	+ _ body: (HealthRecordValue) -> Void
	152	+ ) -> Bool {
	153	+ forEachCompactRecord(in: data, onHeader: { _ in }, body: body)
	154	+ }
	155	+
	156	+ private static func forEachCompactRecord(
	157	+ in data: Data,
	158	+ onHeader: (Int) -> Void,
	159	+ body: (HealthRecordValue) -> Void
	160	+ ) -> Bool {
	161	+ guard data.starts(with: compactMagic) else { return false }
112	162	var reader = CompactReader(data: data, offset: compactMagic.count)
113	163	guard let typeIdentifier = reader.readString(),
114	164	let count = reader.readUInt64() else {
115		- return nil
	165	+ return false
116	166	}
117	167
118		- var values: [HealthRecordValue] = []
119		- values.reserveCapacity(Int(min(count, UInt64(Int.max))))
	168	+ onHeader(Int(min(count, UInt64(Int.max))))
120	169	for _ in 0..<count {
121	170	guard let sampleUUIDHash = reader.readString(),
122	171	let recordFingerprint = reader.readString(),
123	172	let startInterval = reader.readDouble(),
124	173	let endInterval = reader.readDouble(),
125	174	let displayValue = reader.readOptionalString() else {
126		- return nil
	175	+ return false
127	176	}
128		- values.append(
	177	+ body(
129	178	HealthRecordValue(
130	179	typeIdentifier: typeIdentifier,
131	180	sampleUUIDHash: sampleUUIDHash,
	@@ -136,7 +185,7 @@ enum HealthRecordArchive {
136	185	)
137	186	)
138	187	}
139		- return values
	188	+ return true
140	189	}
141	190
142	191	private struct CompactReader {

	@@ -1,7 +1,7 @@
1	1	import Foundation
2	2	import SwiftData
3	3
4		-// Interface updated 2026-05-14 — see AGENTS.md
	4	+// Interface updated 2026-05-17 — see AGENTS.md
5	5	@Model final class TypeCount {
6	6	var id: UUID = UUID()
7	7	var typeIdentifier: String = ""
	@@ -13,6 +13,7 @@ import SwiftData
13	13	var qualityRaw: String = SnapshotQuality.complete.rawValue
14	14	var isUnsupported: Bool = false
15	15	@Attribute(.externalStorage) var recordArchiveData: Data?
	16	+ @Attribute(.externalStorage) var detailCacheData: Data?
16	17	var snapshot: HealthSnapshot?
17	18	@Relationship(deleteRule: .cascade, inverse: \YearlyCount.typeCount)
18	19	var yearlyCounts: [YearlyCount]? = []
	@@ -49,4 +50,13 @@ extension TypeCount {
49	50	recordArchiveData = HealthRecordArchive.encode(values)
50	51	records?.removeAll()
51	52	}
	53	+
	54	+ @MainActor var detailCache: TypeCountDetailCache? {
	55	+ guard let detailCacheData else { return nil }
	56	+ return TypeCountDetailCacheArchive.decode(detailCacheData)
	57	+ }
	58	+
	59	+ @MainActor func setDetailCache(_ cache: TypeCountDetailCache?) {
	60	+ detailCacheData = cache.flatMap(TypeCountDetailCacheArchive.encode)
	61	+ }
52	62	}

	@@ -6,6 +6,8 @@ final class AppSettings {
6	6	private static let selectedTypeIDsKey = "hp_selectedTypeIDs"
7	7	private static let selectedDeviceIDsKey = "hp_selectedDeviceIDs"
8	8	static let adaptiveTimeoutsEnabledKey = "hp_adaptiveTimeoutsEnabled"
	9	+ static let typeDetailCacheBackfillVersionKey = "hp_typeDetailCacheBackfillVersion"
	10	+ static let currentTypeDetailCacheBackfillVersion = 1
9	11
10	12	var selectedTypeIDs: Set<String> {
11	13	didSet { persistTypes() }

	@@ -6,13 +6,13 @@ enum BinningStrategy: String, CaseIterable, Equatable {
6	6	case month = "Lună"
7	7	case year = "An"
8	8
9		- var calendar: Calendar {
	9	+ nonisolated var calendar: Calendar {
10	10	var cal = Calendar.current
11	11	cal.timeZone = TimeZone(abbreviation: "UTC") ?? TimeZone.current
12	12	return cal
13	13	}
14	14
15		- func bins(from startDate: Date, to endDate: Date) -> [Date] {
	15	+ nonisolated func bins(from startDate: Date, to endDate: Date) -> [Date] {
16	16	var result: [Date] = []
17	17	var current = startDate
18	18
	@@ -42,7 +42,7 @@ enum BinningStrategy: String, CaseIterable, Equatable {
42	42	return result
43	43	}
44	44
45		- func label(for date: Date) -> String {
	45	+ nonisolated func label(for date: Date) -> String {
46	46	switch self {
47	47	case .day:
48	48	return date.formatted(.dateTime.hour().minute())
	@@ -55,11 +55,11 @@ enum BinningStrategy: String, CaseIterable, Equatable {
55	55	}
56	56	}
57	57
58		- func contains(_ date: Date, in binStart: Date, binEnd: Date) -> Bool {
	58	+ nonisolated func contains(_ date: Date, in binStart: Date, binEnd: Date) -> Bool {
59	59	date >= binStart && date < binEnd
60	60	}
61	61
62		- func dateRange(containing date: Date) -> (start: Date, end: Date) {
	62	+ nonisolated func dateRange(containing date: Date) -> (start: Date, end: Date) {
63	63	let cal = calendar
64	64
65	65	switch self {
	@@ -110,10 +110,6 @@ final class DataTypeTemporalDistributionViewModel: Sendable {
110	110	}
111	111	}
112	112
113		- private var addedRecords: [HealthRecordValue] = []
114		- private var disappearedRecords: [HealthRecordValue] = []
115		- private var unchangedRecords: [HealthRecordValue] = []
116		-
117	113	private var addedByDate: [Date: Int] = [:]
118	114	private var disappearedByDate: [Date: Int] = [:]
119	115	private var unchangedByDate: [Date: Int] = [:]
	@@ -126,23 +122,14 @@ final class DataTypeTemporalDistributionViewModel: Sendable {
126	122	return
127	123	}
128	124
129		- let currentRecords = current.recordValues
130		- let previousRecords = previous?.recordValues ?? []
131		-
132		- let currentFingerprints = Set(currentRecords.map(\.recordFingerprint))
133		- let previousFingerprints = Set(previousRecords.map(\.recordFingerprint))
134		-
135		- addedRecords = currentRecords.filter { !previousFingerprints.contains($0.recordFingerprint) }
136		- disappearedRecords = previousRecords.filter { !currentFingerprints.contains($0.recordFingerprint) }
137		- unchangedRecords = currentRecords.filter { currentFingerprints.contains($0.recordFingerprint) }
138		-
139		- guard !currentRecords.isEmpty else {
140		- error = "No records to display"
	125	+ guard let cache = current.detailCache,
	126	+ cache.matchesBaseline(previous?.snapshot?.id) else {
	127	+ error = "Precomputed detail data is unavailable for this snapshot. Create a new snapshot to generate temporal detail caches."
141	128	return
142	129	}
143	130
144		- let dates = currentRecords.map(\.startDate)
145		- guard let minDate = dates.min(), let maxDate = dates.max() else {
	131	+ guard let minDate = cache.earliestRecordDate,
	132	+ let maxDate = cache.latestRecordDate else {
146	133	error = "Cannot determine date range"
147	134	return
148	135	}
	@@ -150,23 +137,14 @@ final class DataTypeTemporalDistributionViewModel: Sendable {
150	137	dateRange = (minDate, maxDate)
151	138	displayedDateRange = (minDate, maxDate)
152	139
153		- await indexRecordsByDate()
	140	+ indexDailyBins(cache.dailyChangeBins)
154	141	await rebuildBinsBackground()
155	142	}
156	143
157		- private func indexRecordsByDate() async {
158		- let calendar = Calendar.current
159		-
160		- func dayKey(_ date: Date) -> Date {
161		- calendar.startOfDay(for: date)
162		- }
163		-
164		- addedByDate = Dictionary(grouping: addedRecords, by: { dayKey($0.startDate) })
165		- .mapValues { $0.count }
166		- disappearedByDate = Dictionary(grouping: disappearedRecords, by: { dayKey($0.startDate) })
167		- .mapValues { $0.count }
168		- unchangedByDate = Dictionary(grouping: unchangedRecords, by: { dayKey($0.startDate) })
169		- .mapValues { $0.count }
	144	+ private func indexDailyBins(_ bins: [TypeCountDailyChangeBin]) {
	145	+ addedByDate = Dictionary(uniqueKeysWithValues: bins.map { ($0.dayStart, $0.added) })
	146	+ disappearedByDate = Dictionary(uniqueKeysWithValues: bins.map { ($0.dayStart, $0.disappeared) })
	147	+ unchangedByDate = Dictionary(uniqueKeysWithValues: bins.map { ($0.dayStart, $0.unchanged) })
170	148	}
171	149
172	150	private func adjustDisplayRangeForStrategy() {
	@@ -254,7 +232,7 @@ struct TemporalBin: Identifiable, Sendable {
254	232	}
255	233
256	234	extension Array {
257		- fileprivate subscript(safe index: Index) -> Element? {
	235	+ nonisolated fileprivate subscript(safe index: Index) -> Element? {
258	236	indices.contains(index) ? self[index] : nil
259	237	}
260	238	}