+| UI | Prototype exists; Snapshots/Data Types now default to the local device timeline instead of a multi-device picker. Dashboard status prefers archive/cache observation rows and shows cache health; Snapshots timeline, snapshot detail summaries/type rows, and Data Types list prefer Core Data cache rows when archive observation ids exist; data type detail reads Core Data type/diff summaries and uses SQLite `diffRecords` for paged drill-down; export preview reads the archive export API before showing/exporting JSON; visible change labels now use neutral new/missing/change-review language, with SwiftData detail cache as transition fallback | Add legacy/small-device simplifications and remove remaining SwiftData navigation handles |

+| Export | SQLite export preview, paged JSON writing, SHA256 manifest hashing, and `export_manifests` rows are in place for selected records and observation diffs | Fill remaining recovery-compatible envelope metadata, CSV export, relationship preservation, and reproducibility checks |

+4. Complete recovery-compatible export metadata, CSV output, and reproducibility checks.

+- Current UI/cache layers still depend on SwiftData prototype models for capture review actions, navigation handles, some charts, and PDF paths.

+- Initial SQLite archive tests cover open/init/reset/idempotency, snapshot-level observation grouping, legacy mirror removal, small observation diffs, large synthetic diff pagination, formal timing/memory metrics, materialized aggregate comparison, source/provenance breakdowns, consolidation-evidence labels, export preview, paged JSON output, and manifest row persistence.

+- [x] Export can stream/page selected record sets without materializing the full record list.

+- [x] Export manifests include hashes and diff observation metadata when applicable.

+- [x] Define JSON export envelope.

+- [x] Define manifest hash algorithm.

+- [x] Include values/dates/units/type fields.

+- [x] Include source/provenance metadata where available and allowed.

+- [x] Stream/page export from SQLite.

+- [x] Store export manifest rows.

+- [x] Large export does not materialize full record set in RAM.

+- [x] Export preview uses export query/manifest APIs.

+    func exportPreview(_ request: HealthArchiveReportRequest) async throws -> HealthArchiveExportPreview

+    let diffFromObservationID: Int64?

+    let diffToObservationID: Int64?

+    let diffKind: HealthArchiveDiffKind?

+        firstSeenBefore: Date? = nil,

+        diffFromObservationID: Int64? = nil,

+        diffToObservationID: Int64? = nil,

+        diffKind: HealthArchiveDiffKind? = nil

+        self.diffFromObservationID = diffFromObservationID

+        self.diffToObservationID = diffToObservationID

+        self.diffKind = diffKind

+struct HealthArchiveExportPreview: Equatable, Sendable {

+    let reportID: UUID

+    let title: String

+    let exportKind: String

+    let estimatedRecordCount: Int

+    let typeIdentifierFilter: String?

+    let disappearedOnly: Bool

+    let firstSeenAfter: Date?

+    let firstSeenBefore: Date?

+    let diffFromObservationID: Int64?

+    let diffToObservationID: Int64?

+    let diffKind: HealthArchiveDiffKind?

+}

+

+struct HealthArchiveExportManifest: Equatable, Sendable {

+    let exportID: UUID

+    let exportKind: String

+    let createdAt: Date

+    let recordCount: Int

+    let manifestHash: String

+}

+

+import CryptoKit

+    func exportPreview(_ request: HealthArchiveReportRequest) async throws -> HealthArchiveExportPreview {

+        let db = try openDatabase()

+        defer { sqlite3_close(db) }

+        try prepareSchemaIfNeeded(db)

+

+        let recordCount = try await exportRecordCount(for: request, db: db)

+        return HealthArchiveExportPreview(

+            reportID: request.reportID,

+            title: request.title,

+            exportKind: "observation_records_json",

+            estimatedRecordCount: recordCount,

+            typeIdentifierFilter: request.typeIdentifierFilter,

+            disappearedOnly: request.disappearedOnly,

+            firstSeenAfter: request.firstSeenAfter,

+            firstSeenBefore: request.firstSeenBefore,

+            diffFromObservationID: request.diffFromObservationID,

+            diffToObservationID: request.diffToObservationID,

+            diffKind: request.diffKind

+        )

+    }

+

+        let exportedAt = Date()

+        let manifest = try await buildExportManifest(request: request, exportedAt: exportedAt)

+        let exportURL = URL.temporaryDirectory

+            .appending(path: "HealthProbe-\(request.reportID.uuidString)")

+            .appendingPathExtension("json")

+        try await writeExportReport(

+            request: request,

+            manifest: manifest,

+            exportedAt: exportedAt,

+            to: exportURL

+        )

+        try recordExportManifest(request: request, manifest: manifest)

+        return exportURL

+    }

+

+    private func recordRequest(from request: HealthArchiveReportRequest) -> HealthArchiveRecordRequest {

+        HealthArchiveRecordRequest(

+    }

+

+    private func exportRecordCount(for request: HealthArchiveReportRequest, db: OpaquePointer?) async throws -> Int {

+        if let fromObservationID = request.diffFromObservationID,

+           let toObservationID = request.diffToObservationID,

+           let diffKind = request.diffKind {

+            let summary = try await diffSummary(HealthArchiveDiffRequest(

+                fromObservationID: fromObservationID,

+                toObservationID: toObservationID,

+                sampleTypeIdentifier: request.typeIdentifierFilter

+            ))

+            switch diffKind {

+            case .appeared:

+                return summary.appearedCount

+            case .disappeared:

+                return summary.disappearedCount

+            case .representationChanged:

+                return summary.representationChangedCount

+            }

+        }

+

+        return try exportRecordCount(for: recordRequest(from: request), db: db)

+    }

+

+    private func exportRecordCount(for request: HealthArchiveRecordRequest, db: OpaquePointer?) throws -> Int {

+        var clauses: [String] = []

+        if request.sampleTypeIdentifier != nil {

+            clauses.append("t.type_identifier = ?")

+        }

+        if !request.fingerprints.isEmpty {

+            clauses.append("s.strict_fingerprint IN (\(Array(repeating: "?", count: request.fingerprints.count).joined(separator: ",")))")

+        }

+        if request.disappearedOnly {

+            clauses.append("rr.last_observation_id IS NOT NULL AND es.disappeared_at IS NOT NULL")

+        }

+        if request.firstSeenAfter != nil {

+            clauses.append("s.first_seen_at >= ?")

+        }

+        if request.firstSeenBefore != nil {

+            clauses.append("s.first_seen_at <= ?")

+        }

+        let whereClause = clauses.isEmpty ? "" : "WHERE \(clauses.joined(separator: " AND "))"

+        let sql = """

+        WITH selected_ranges AS (

+            SELECT

+                r.sample_id, r.version_id, r.first_observation_id, r.last_observation_id,

+                r.first_seen_at, r.last_seen_at,

+                ROW_NUMBER() OVER (

+                    PARTITION BY r.sample_id

+                    ORDER BY

+                        CASE

+                            WHEN ? IS NOT NULL THEN 0

+                            WHEN r.last_observation_id IS NULL THEN 0

+                            ELSE 1

+                        END,

+                        COALESCE(r.last_observation_id, 9223372036854775807) DESC,

+                        r.first_observation_id DESC

+                ) AS record_rank

+            FROM sample_visibility_ranges r

+            WHERE (? IS NULL OR (

+                r.first_observation_id <= ?

+                AND (r.last_observation_id IS NULL OR r.last_observation_id > ?)

+            ))

+        ),

+        record_ranges AS (

+            SELECT *

+            FROM selected_ranges

+            WHERE record_rank = 1

+        ),

+        event_summary AS (

+            SELECT

+                sample_id,

+                MAX(CASE WHEN event_kind != 'disappeared' THEN observed_at END) AS last_seen_at,

+                MAX(observed_at) AS last_verified_at,

+                MAX(CASE WHEN event_kind = 'disappeared' THEN observed_at END) AS disappeared_at

+            FROM sample_observation_events

+            GROUP BY sample_id

+        SELECT COUNT(*)

+        FROM record_ranges rr

+        JOIN samples s ON s.id = rr.sample_id

+        JOIN sample_types t ON t.id = s.sample_type_id

+        JOIN sample_versions v ON v.id = rr.version_id

+        LEFT JOIN event_summary es ON es.sample_id = s.id

+        \(whereClause)

+        """

+

+        return try withStatement(sql, db: db) { statement in

+            var index: Int32 = 1

+            try bindRecordFilterValues(request, to: statement, startingAt: &index, includeCursor: false)

+            guard sqlite3_step(statement) == SQLITE_ROW else { return 0 }

+            return columnInt(statement, 0) ?? 0

+        }

+    }

+

+    private func bindRecordFilterValues(

+        _ request: HealthArchiveRecordRequest,

+        to statement: OpaquePointer?,

+        startingAt index: inout Int32,

+        includeCursor: Bool

+    ) throws {

+        bindInt64(request.visibleAtObservationID, to: index, in: statement)

+        index += 1

+        bindInt64(request.visibleAtObservationID, to: index, in: statement)

+        index += 1

+        bindInt64(request.visibleAtObservationID, to: index, in: statement)

+        index += 1

+        bindInt64(request.visibleAtObservationID, to: index, in: statement)

+        index += 1

+        if let typeIdentifier = request.sampleTypeIdentifier {

+            bindText(typeIdentifier, to: index, in: statement)

+            index += 1

+        }

+        for fingerprint in request.fingerprints.sorted() {

+            bindText(fingerprint, to: index, in: statement)

+            index += 1

+        }

+        if let firstSeenAfter = request.firstSeenAfter {

+            sqlite3_bind_double(statement, index, firstSeenAfter.timeIntervalSince1970)

+            index += 1

+        }

+        if let firstSeenBefore = request.firstSeenBefore {

+            sqlite3_bind_double(statement, index, firstSeenBefore.timeIntervalSince1970)

+            index += 1

+        }

+        if includeCursor, let cursor = request.afterCursor {

+            sqlite3_bind_double(statement, index, cursor.startDate.timeIntervalSince1970)

+            index += 1

+            sqlite3_bind_double(statement, index, cursor.startDate.timeIntervalSince1970)

+            index += 1

+            bindText(cursor.strictFingerprint, to: index, in: statement)

+            index += 1

+        }

+    }

+

+    private func buildExportManifest(

+        request: HealthArchiveReportRequest,

+        exportedAt: Date

+    ) async throws -> HealthArchiveExportManifest {

+        var hasher = SHA256()

+        hasher.update(data: Data("hp:export:manifest:v1".utf8))

+        hasher.update(data: Data(request.reportID.uuidString.utf8))

+        hasher.update(data: Data(request.title.utf8))

+        hasher.update(data: Data(exportedAt.timeIntervalSince1970.description.utf8))

+        hasher.update(data: Data((request.typeIdentifierFilter ?? "*").utf8))

+        hasher.update(data: Data(request.disappearedOnly.description.utf8))

+        if let firstSeenAfter = request.firstSeenAfter {

+            hasher.update(data: Data(firstSeenAfter.timeIntervalSince1970.description.utf8))

+        }

+        if let firstSeenBefore = request.firstSeenBefore {

+            hasher.update(data: Data(firstSeenBefore.timeIntervalSince1970.description.utf8))

+        }

+        if let diffFromObservationID = request.diffFromObservationID {

+            hasher.update(data: Data(diffFromObservationID.description.utf8))

+        }

+        if let diffToObservationID = request.diffToObservationID {

+            hasher.update(data: Data(diffToObservationID.description.utf8))

+        }

+        if let diffKind = request.diffKind {

+            hasher.update(data: Data(diffKind.rawValue.utf8))

+        }

+

+        var recordCount = 0

+        try await forEachReportRecord(request) { record in

+            recordCount += 1

+            let data = try JSONEncoder.healthArchive.encode(ExportRecordPayload(record))

+            let itemHash = Self.hexDigest(SHA256.hash(data: data))

+            hasher.update(data: Data(itemHash.utf8))

+        }

+

+        let manifestHash = Self.hexDigest(hasher.finalize())

+        return HealthArchiveExportManifest(

+            exportID: request.reportID,

+            exportKind: "observation_records_json",

+            createdAt: exportedAt,

+            recordCount: recordCount,

+            manifestHash: manifestHash

+        )

+    }

+

+    private func writeExportReport(

+        request: HealthArchiveReportRequest,

+        manifest: HealthArchiveExportManifest,

+        exportedAt: Date,

+        to exportURL: URL

+    ) async throws {

+        FileManager.default.createFile(atPath: exportURL.path, contents: nil)

+        let handle = try FileHandle(forWritingTo: exportURL)

+        defer { try? handle.close() }

+

+        try handle.write(contentsOf: Data("{\n".utf8))

+        try writeJSONField("exportFormatVersion", value: "1", quoted: false, trailingComma: true, to: handle)

+        try writeJSONField("reportID", value: request.reportID.uuidString, trailingComma: true, to: handle)

+        try writeJSONField("title", value: request.title, trailingComma: true, to: handle)

+        try writeJSONField("exportedAt", value: JSONEncoder.healthArchiveDateString(exportedAt), trailingComma: true, to: handle)

+        try handle.write(contentsOf: Data("  \"manifest\" : {\n".utf8))

+        try writeJSONField("exportKind", value: manifest.exportKind, trailingComma: true, indent: "    ", to: handle)

+        try writeJSONField("recordCount", value: "\(manifest.recordCount)", quoted: false, trailingComma: true, indent: "    ", to: handle)

+        try writeJSONField("manifestHash", value: manifest.manifestHash, trailingComma: false, indent: "    ", to: handle)

+        try handle.write(contentsOf: Data("  },\n".utf8))

+        try handle.write(contentsOf: Data("  \"records\" : [\n".utf8))

+

+        var isFirstRecord = true

+        try await forEachReportRecord(request) { record in

+            if isFirstRecord {

+                isFirstRecord = false

+            } else {

+                try handle.write(contentsOf: Data(",\n".utf8))

+            }

+            let data = try JSONEncoder.healthArchive.encode(ExportRecordPayload(record))

+            try handle.write(contentsOf: data)

+        }

+

+        try handle.write(contentsOf: Data("\n  ]\n}\n".utf8))

+    }

+

+    private func forEachReportRecord(

+        _ request: HealthArchiveReportRequest,

+        _ body: (ArchivedHealthRecord) throws -> Void

+    ) async throws {

+        if let fromObservationID = request.diffFromObservationID,

+           let toObservationID = request.diffToObservationID,

+           let diffKind = request.diffKind {

+            try await forEachDiffExportRecord(

+                HealthArchiveDiffRecordRequest(

+                    fromObservationID: fromObservationID,

+                    toObservationID: toObservationID,

+                    sampleTypeIdentifier: request.typeIdentifierFilter,

+                    kind: diffKind

+                ),

+                body

+            )

+            return

+        }

+

+        try await forEachExportRecord(recordRequest(from: request), body)

+    }

+

+    private func writeJSONField(

+        _ key: String,

+        value: String,

+        quoted: Bool = true,

+        trailingComma: Bool,

+        indent: String = "  ",

+        to handle: FileHandle

+    ) throws {

+        let encodedValue: String

+        if quoted {

+            let data = try JSONEncoder.healthArchive.encode(value)

+            encodedValue = String(decoding: data, as: UTF8.self)

+        } else {

+            encodedValue = value

+        }

+        let comma = trailingComma ? "," : ""

+        try handle.write(contentsOf: Data("\(indent)\"\(key)\" : \(encodedValue)\(comma)\n".utf8))

+    }

+

+    private func forEachExportRecord(

+        _ request: HealthArchiveRecordRequest,

+        _ body: (ArchivedHealthRecord) throws -> Void

+    ) async throws {

+        var cursor: RecordCursor?

+        let pageSize = 500

+        while true {

+            let page = try await records(for: HealthArchiveRecordRequest(

+                visibleAtObservationID: request.visibleAtObservationID,

+                sampleTypeIdentifier: request.sampleTypeIdentifier,

+                fingerprints: request.fingerprints,

+                disappearedOnly: request.disappearedOnly,

+                firstSeenAfter: request.firstSeenAfter,

+                firstSeenBefore: request.firstSeenBefore,

+                afterCursor: cursor,

+                limit: pageSize

+            ))

+            guard !page.isEmpty else { break }

+            for record in page {

+                try body(record)

+            }

+            guard page.count == pageSize, let last = page.last else { break }

+            cursor = RecordCursor(startDate: last.startDate, strictFingerprint: last.strictFingerprint)

+        }

+    }

+

+    private func forEachDiffExportRecord(

+        _ request: HealthArchiveDiffRecordRequest,

+        _ body: (ArchivedHealthRecord) throws -> Void

+    ) async throws {

+        var cursor: RecordCursor?

+        let pageSize = 500

+        while true {

+            let page = try await diffRecords(HealthArchiveDiffRecordRequest(

+                fromObservationID: request.fromObservationID,

+                toObservationID: request.toObservationID,

+                sampleTypeIdentifier: request.sampleTypeIdentifier,

+                kind: request.kind,

+                afterCursor: cursor,

+                limit: pageSize

+            ))

+            guard !page.isEmpty else { break }

+            for record in page {

+                try body(record)

+            }

+            guard page.count == pageSize, let last = page.last else { break }

+            cursor = RecordCursor(startDate: last.startDate, strictFingerprint: last.strictFingerprint)

+        }

+    }

+

+    private func recordExportManifest(

+        request: HealthArchiveReportRequest,

+        manifest: HealthArchiveExportManifest

+    ) throws {

+        let db = try openDatabase()

+        defer { sqlite3_close(db) }

+        try prepareSchemaIfNeeded(db)

+

+        let filterJSON = exportFilterJSON(request)

+        let sql = """

+        INSERT OR REPLACE INTO export_manifests (

+            export_id, created_at, export_kind, from_observation_id, to_observation_id,

+            filter_json, record_count, manifest_hash

+        )

+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)

+        """

+        try withStatement(sql, db: db) { statement in

+            bindText(manifest.exportID.uuidString, to: 1, in: statement)

+            sqlite3_bind_double(statement, 2, manifest.createdAt.timeIntervalSince1970)

+            bindText(manifest.exportKind, to: 3, in: statement)

+            bindInt64(request.diffFromObservationID, to: 4, in: statement)

+            bindInt64(request.diffToObservationID, to: 5, in: statement)

+            bindText(filterJSON, to: 6, in: statement)

+            sqlite3_bind_int64(statement, 7, Int64(manifest.recordCount))

+            bindText(manifest.manifestHash, to: 8, in: statement)

+            guard sqlite3_step(statement) == SQLITE_DONE else {

+                throw SQLiteHealthArchiveStoreError.stepFailed(lastErrorMessage(db))

+            }

+        }

+    }

+

+    nonisolated private func exportFilterJSON(_ request: HealthArchiveReportRequest) -> String {

+        let payload: [String: Any] = [

+            "typeIdentifier": request.typeIdentifierFilter ?? "*",

+            "disappearedOnly": request.disappearedOnly,

+            "firstSeenAfter": request.firstSeenAfter?.timeIntervalSince1970 ?? NSNull(),

+            "firstSeenBefore": request.firstSeenBefore?.timeIntervalSince1970 ?? NSNull(),

+            "diffFromObservationID": request.diffFromObservationID ?? NSNull(),

+            "diffToObservationID": request.diffToObservationID ?? NSNull(),

+            "diffKind": request.diffKind?.rawValue ?? NSNull()

+        ]

+        guard

+            let data = try? JSONSerialization.data(withJSONObject: payload, options: [.sortedKeys]),

+            let json = String(data: data, encoding: .utf8)

+        else {

+            return "{}"

+        }

+        return json

+    }

+

+    nonisolated private static func hexDigest<D: Sequence>(_ bytes: D) -> String where D.Element == UInt8 {

+        bytes.map { String(format: "%02x", $0) }.joined()

+nonisolated private struct ExportRecordPayload: Encodable {

+    let id: String

+    let sampleTypeIdentifier: String

+    let strictFingerprint: String

+    let semanticFingerprint: String?

+    let healthKitUUIDHash: String?

+    let startDate: Date

+    let endDate: Date

+    let firstSeenAt: Date

+    let lastSeenAt: Date?

+    let lastVerifiedAt: Date?

+    let disappearedAt: Date?

+    let valueKind: String?

+    let value: Double?

+    let unit: String?

+    let categoryValue: Int?

+    let workoutActivityType: Int?

+    let durationSeconds: Double?

+    let sourceName: String?

+    let sourceBundleIdentifier: String?

+    let deviceName: String?

+    let displayValue: String?

+

+    init(_ record: ArchivedHealthRecord) {

+        id = record.id

+        sampleTypeIdentifier = record.sampleTypeIdentifier

+        strictFingerprint = record.strictFingerprint

+        semanticFingerprint = record.semanticFingerprint

+        healthKitUUIDHash = record.healthKitUUIDHash

+        startDate = record.startDate

+        endDate = record.endDate

+        firstSeenAt = record.firstSeenAt

+        lastSeenAt = record.lastSeenAt

+        lastVerifiedAt = record.lastVerifiedAt

+        disappearedAt = record.disappearedAt

+        valueKind = record.valueKind

+        value = record.value

+        unit = record.unit

+        categoryValue = record.categoryValue

+        workoutActivityType = record.workoutActivityType

+        durationSeconds = record.durationSeconds

+        sourceName = record.sourceName

+        sourceBundleIdentifier = record.sourceBundleIdentifier

+        deviceName = record.deviceName

+        displayValue = record.displayValue

+    }

+

+    static func healthArchiveDateString(_ date: Date) -> String {

+        let data = try? healthArchive.encode(date)

+        let encoded = data.map { String(decoding: $0, as: UTF8.self) } ?? "\"\(date.timeIntervalSince1970)\""

+        return encoded.trimmingCharacters(in: CharacterSet(charactersIn: "\""))

+    }

+    var exportPreview: HealthArchiveExportPreview?

+    var exportPreviewError: String?

+    private let reportID = UUID()

+        await loadExportPreview()

+    func loadExportPreview() async {

+        do {

+            exportPreview = try await archiveStore.exportPreview(buildExportRequest())

+            exportPreviewError = nil

+        } catch {

+            exportPreview = nil

+            exportPreviewError = error.localizedDescription

+        }

+    }

+

+        case .disappeared(let typeID):

+                reportID: reportID,

+        case .disappearedDiff(let typeID, let fromObservationID, let toObservationID):

+                reportID: reportID,

+                title: "Missing Records - \(displayName)",

+                typeIdentifierFilter: typeID,

+                disappearedOnly: true,

+                diffFromObservationID: fromObservationID,

+                diffToObservationID: toObservationID,

+                diffKind: .disappeared

+            )

+        case .added(let typeID, let afterDate, let beforeDate):

+            return HealthArchiveReportRequest(

+                reportID: reportID,

+        case .addedDiff(let typeID, let afterDate, let beforeDate, let fromObservationID, let toObservationID):

+            return HealthArchiveReportRequest(

+                reportID: reportID,

+                title: "New Records - \(displayName)",

+                typeIdentifierFilter: typeID,

+                firstSeenAfter: afterDate,

+                firstSeenBefore: beforeDate,

+                diffFromObservationID: fromObservationID,

+                diffToObservationID: toObservationID,

+                diffKind: .appeared

+            )

+

+                        if let preview = viewModel.exportPreview {

+                            Divider()

+                            DataTypeDetailRow(label: "Export Preview") {

+                                Text("\(preview.estimatedRecordCount) JSON records")

+                                    .font(.caption)

+                                    .foregroundStyle(.secondary)

+                                    .monospacedDigit()

+                            }

+                            DataTypeDetailRow(label: "Export Kind") {

+                                Text(preview.exportKind)

+                                    .font(.caption)

+                                    .foregroundStyle(.secondary)

+                                    .lineLimit(1)

+                            }

+                        } else if let error = viewModel.exportPreviewError {

+                            Divider()

+                            Label(error, systemImage: "exclamationmark.triangle.fill")

+                                .font(.caption)

+                                .foregroundStyle(Color.warningAmber)

+                        }

+                                if viewModel.exportState == .loading {

+                                    Label("Exporting...", systemImage: "hourglass")

+                                } else {

+                                    Label("Export as JSON", systemImage: "square.and.arrow.up")

+                                }

+                            .disabled(viewModel.exportState == .loading)

+

+        let exportRequest = HealthArchiveReportRequest(

+            reportID: UUID(),

+            title: "Disappeared Step Count Export",

+            typeIdentifierFilter: typeIdentifier,

+            diffFromObservationID: observationIDs[1],

+            diffToObservationID: observationIDs[2],

+            diffKind: .disappeared

+        )

+        let exportPreview = try await store.exportPreview(exportRequest)

+        let exportURL = try await store.exportReport(exportRequest)

+

+        XCTAssertEqual(exportPreview.estimatedRecordCount, 1)

+        XCTAssertTrue(FileManager.default.fileExists(atPath: exportURL.path))

+        XCTAssertEqual(try countRows(in: "export_manifests WHERE record_count = 1 AND from_observation_id = \(observationIDs[1]) AND to_observation_id = \(observationIDs[2])", at: url), 1)

+    }

+

+    func testExportPreviewAndReportUseSQLiteManifest() async throws {

+        let url = databaseURL()

+        let store = SQLiteHealthArchiveStore(databaseURL: url)

+        let typeIdentifier = HKQuantityTypeIdentifier.stepCount.rawValue

+        let samples = [

+            makeStepCountSample(value: 42, start: 1_000),

+            makeStepCountSample(value: 7, start: 2_000)

+        ]

+

+        _ = try await store.upsertSamples(samples, observedAt: Date(timeIntervalSince1970: 3_000))

+

+        let request = HealthArchiveReportRequest(

+            reportID: UUID(),

+            title: "Step Count Export",

+            typeIdentifierFilter: typeIdentifier

+        )

+        let preview = try await store.exportPreview(request)

+        let exportURL = try await store.exportReport(request)

+

+        XCTAssertEqual(preview.estimatedRecordCount, 2)

+        XCTAssertTrue(FileManager.default.fileExists(atPath: exportURL.path))

+        XCTAssertEqual(try countRows(in: "export_manifests", at: url), 1)

+        XCTAssertEqual(try countRows(in: "export_manifests WHERE record_count = 2", at: url), 1)

+

+        let cache = try CoreDataArchiveCacheStore(inMemory: true)

+        let rebuild = try cache.rebuild(fromArchiveAt: url)

+        XCTAssertEqual(rebuild.exportManifestRows, 1)