authorized backup volume can be much larger than the original 15-type test

   subset and that first-import write-path performance must remain a separate

   acceptance track from repeated incremental capture performance.

 ## Open Issues / Observations

 9. Keep watching first-import insert timing on the next clean large-database

    import because the new `sample_versions(start_date, sample_id)` index from

    `bf5a861` is a write-path tradeoff.

 11. Investigate full-profile empty anchored-query cost for zero-count types.

    Compare slow empty types across reports before changing behavior; any skip or

    lower-frequency strategy must preserve the promise that full authorized

         }

         progress?.updateBlockProgress(

             monitoredType.id,

             recordCount: distribution.totalCount

         )

         var timingBreakdown = distribution.timingBreakdown

         timingBreakdown.fetchElapsedSeconds += dateFetchElapsedSeconds

         var result = TypeCountFetchResult(

             typeIdentifier: monitoredType.id,

                 )

             },

             records: [],

         )

         result.captureMode = distribution.captureMode.diagnosticValue

         result.deltaEventCount = distribution.deltaEventCount

         var firstRecordDate: Date?

         var latestRecordDate: Date?

         var yearMap: [Int: Int] = [:]

         var hashBuilder = HashService.TypeHashBuilder(typeIdentifier: typeIdentifier)

         var shouldFetchNextPage = true

         var pendingArchiveSamples: [HKSample] = []

             for sample in page.samples {

                 autoreleasepool {

                     let value = Self.recordValue(for: sample, sampleType: sampleType, typeIdentifier: typeIdentifier)

                     hashBuilder.append(recordFingerprint: value.recordFingerprint)

                     yearMap[Calendar.current.component(.year, from: value.startDate), default: 0] += 1

                     firstRecordDate = min(firstRecordDate ?? value.startDate, value.startDate)

         let contentHash = hashBuilder.finalize()

         let hashFinalizeElapsed = Date().timeIntervalSince(finalizeHashStartedAt)

         captureTimings.processingElapsedSeconds += hashFinalizeElapsed

         progress?.updateBlockProgress(

             typeIdentifier,

             detail: pageNumber == 1 ? "Imported 1 page" : "Imported \(pageNumber) pages",

         let rawBinEnd = latestDate ?? latestRecordDate ?? binStart

         let binEnd = rawBinEnd > binStart ? rawBinEnd : binStart.addingTimeInterval(1)

         return SampleDistribution(

             totalCount: recordCount,

             bins: [

             records: [],

             contentHash: contentHash,

             yearlyCounts: yearMap,

             captureMode: .initialImport,

             deltaEventCount: processedEventCount,

             timingBreakdown: captureTimings.importBreakdown