@bota.dev/react-native-app-sdk 2.0.0-beta.1 → 2.0.0-beta.3

package/ios/BotaDeviceSDK.mm

@@ -569,6 +569,46 @@ RCT_EXPORT_MODULE(BotaDeviceSDK)
                 }];
 }
 
+- (void)listPendingRecordings:(JS::NativeBotaDeviceSDK::NativeConnectedDevice &)device
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject
+{
+  [[BotaDeviceSDKAppleBridge shared]
+      listPendingRecordingsWithID:device.id_()
+                     serialNumber:device.serialNumber()
+                       deviceType:device.deviceType()
+                  firmwareVersion:device.firmwareVersion()
+                 hardwareRevision:device.hardwareRevision()
+                    isProvisioned:device.isProvisioned()
+                  connectionState:device.connectionState()
+                              mtu:device.mtu()
+                       completion:^(NSArray<NSDictionary *> *_Nullable values, NSError *_Nullable error) {
+                         if (error != nil) { BotaRejectEncryptedUploadV2Error(reject); return; }
+                         resolve(values);
+                       }];
+}
+
+- (void)cancelEncryptedRecordingV2:(NSString *)operationId
+                          resolve:(RCTPromiseResolveBlock)resolve
+                           reject:(RCTPromiseRejectBlock)reject
+{
+  [[BotaDeviceSDKAppleBridge shared]
+      cancelEncryptedRecordingV2WithOperationID:operationId
+                                     completion:^(NSError *_Nullable error) {
+                                       if (error != nil) { BotaRejectEncryptedUploadV2Error(reject); return; }
+                                       resolve(nil);
+                                     }];
+}
+
+- (void)releaseEncryptedUploadV2Material:(NSString *)materialRegistrationId
+                               resolve:(RCTPromiseResolveBlock)resolve
+                                reject:(RCTPromiseRejectBlock)reject
+{
+  [[BotaDeviceSDKAppleBridge shared]
+      releaseEncryptedUploadV2MaterialWithRegistrationID:materialRegistrationId
+                                              completion:^{ resolve(nil); }];
+}
+
 - (void)syncRecording:(JS::NativeBotaDeviceSDK::NativeConnectedDevice &)device
              recording:(JS::NativeBotaDeviceSDK::NativeDeviceRecording &)recording
                 sinkId:(NSString *)sinkId
@@ -626,6 +666,10 @@ RCT_EXPORT_MODULE(BotaDeviceSDK)
                            generation:recording.generation()
                      ciphertextLength:recording.ciphertextLength()
                      ciphertextSHA256:recording.ciphertextSha256()
+                          startedAtMs:recording.startedAtMs()
+                           durationMs:recording.durationMs()
+                      plaintextLength:recording.plaintextLength()
+                        storageFormat:recording.storageFormat().has_value() ? @(recording.storageFormat().value()) : nil
                           operationID:operationId
                      onProfileRequest:^(NSDictionary *request) {
                        [weakSelf emitOnEncryptedUploadV2ProfileRequested:request];
@@ -807,6 +851,7 @@ RCT_EXPORT_MODULE(BotaDeviceSDK)
       uploadRecordingFileWithTaskID:request.taskId()
                           recordingID:request.recordingId()
                              localPath:request.localPath()
+                         fileSizeBytes:request.fileSizeBytes().has_value() ? @(request.fileSizeBytes().value()) : nil
                              uploadURL:request.uploadUrl()
                            uploadToken:request.uploadToken()
                             completeURL:request.completeUrl()
@@ -826,6 +871,23 @@ RCT_EXPORT_MODULE(BotaDeviceSDK)
                               }];
 }
 
+- (void)releaseRecordingFile:(NSString *)taskId
+                   localPath:(NSString *)localPath
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject
+{
+  [[BotaDeviceSDKAppleBridge shared]
+      releaseRecordingFileWithTaskID:taskId
+                           localPath:localPath
+                          completion:^(NSError *error) {
+                            if (error != nil) {
+                              BotaRejectAppleError(error, reject);
+                              return;
+                            }
+                            resolve(nil);
+                          }];
+}
+
 - (void)cancelRecordingUpload:(NSString *)taskId
                       resolve:(RCTPromiseResolveBlock)resolve
                        reject:(__unused RCTPromiseRejectBlock)reject
@@ -966,6 +1028,46 @@ RCT_EXPORT_MODULE(BotaDeviceSDK)
                 }];
 }
 
+- (void)readDiagnosticEvents:(JS::NativeBotaDeviceSDK::NativeConnectedDevice &)device
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject
+{
+  [[BotaDeviceSDKAppleBridge shared]
+      readDiagnosticEventsWithID:device.id_()
+                    serialNumber:device.serialNumber()
+                      deviceType:device.deviceType()
+                 firmwareVersion:device.firmwareVersion()
+                hardwareRevision:device.hardwareRevision()
+                   isProvisioned:device.isProvisioned()
+                 connectionState:device.connectionState()
+                             mtu:device.mtu()
+                      completion:^(NSDictionary *_Nullable batch, NSError *_Nullable error) {
+                        if (error != nil) { BotaRejectAppleError(error, reject); return; }
+                        resolve(batch);
+                      }];
+}
+
+- (void)acknowledgeDiagnosticEvents:(JS::NativeBotaDeviceSDK::NativeConnectedDevice &)device
+                  acceptedEventIds:(NSArray *)acceptedEventIds
+                           resolve:(RCTPromiseResolveBlock)resolve
+                            reject:(RCTPromiseRejectBlock)reject
+{
+  [[BotaDeviceSDKAppleBridge shared]
+      acknowledgeDiagnosticEventsWithID:device.id_()
+                           serialNumber:device.serialNumber()
+                             deviceType:device.deviceType()
+                        firmwareVersion:device.firmwareVersion()
+                       hardwareRevision:device.hardwareRevision()
+                          isProvisioned:device.isProvisioned()
+                        connectionState:device.connectionState()
+                                    mtu:device.mtu()
+                       acceptedEventIds:acceptedEventIds
+                             completion:^(NSError *_Nullable error) {
+                               if (error != nil) { BotaRejectAppleError(error, reject); return; }
+                               resolve(nil);
+                             }];
+}
+
 - (void)stopDeviceLogs:(RCTPromiseResolveBlock)resolve
                  reject:(__unused RCTPromiseRejectBlock)reject
 {

package/ios/BotaDeviceSDKAppleBridge.swift

@@ -801,6 +801,48 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         }
     }
 
+    @objc(listPendingRecordingsWithID:serialNumber:deviceType:firmwareVersion:hardwareRevision:isProvisioned:connectionState:mtu:completion:)
+    public func listPendingRecordings(
+        id: String, serialNumber: String, deviceType: String, firmwareVersion: String,
+        hardwareRevision: String?, isProvisioned: Bool, connectionState: String, mtu: Double,
+        completion: @escaping @Sendable ([[String: Any]]?, NSError?) -> Void
+    ) {
+        Task {
+            do {
+                let values = try await recordings.listPendingRecordings(Self.connectedDevice(
+                    id: id, serialNumber: serialNumber, deviceType: deviceType,
+                    firmwareVersion: firmwareVersion, hardwareRevision: hardwareRevision,
+                    isProvisioned: isProvisioned, connectionState: connectionState, mtu: mtu
+                ))
+                completion(values.map { value in
+                    switch value {
+                    case let .legacy(recording):
+                        ["profile": "legacy", "legacy": Self.recording(recording)]
+                    case let .encryptedV2(recording):
+                        ["profile": "encrypted_upload_v2", "encrypted": BotaDeviceSDKAppleRecordings.encryptedUploadV2Recording(recording)]
+                    }
+                }, nil)
+            } catch { completion(nil, error as NSError) }
+        }
+    }
+
+    @objc(cancelEncryptedRecordingV2WithOperationID:completion:)
+    public func cancelEncryptedRecordingV2(
+        operationID: String, completion: @escaping @Sendable (NSError?) -> Void
+    ) {
+        Task {
+            do { try await recordings.cancelEncryptedRecordingV2(operationID); completion(nil) }
+            catch { completion(error as NSError) }
+        }
+    }
+
+    @objc(releaseEncryptedUploadV2MaterialWithRegistrationID:completion:)
+    public func releaseEncryptedUploadV2Material(
+        registrationID: String, completion: @escaping @Sendable () -> Void
+    ) {
+        Task { await BotaDeviceSDKEncryptedUploadV2Materials.release(registrationID); completion() }
+    }
+
     @objc(syncRecordingWithID:serialNumber:deviceType:firmwareVersion:hardwareRevision:isProvisioned:connectionState:mtu:recordingUUID:startedAtMilliseconds:durationMilliseconds:fileSize:codec:isEncrypted:sinkID:onProgress:completion:)
     public func syncRecording(
         id: String,
@@ -855,6 +897,7 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
                 var value: [String: Any] = [
                     "localPath": result.localPath,
                     "e2eEncrypted": result.isE2EEncrypted,
+                    "fileSizeBytes": result.fileSizeBytes,
                 ]
                 if let contentSHA256Hex = result.contentSHA256Hex {
                     value["contentSha256"] = contentSHA256Hex
@@ -866,7 +909,7 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         }
     }
 
-    @objc(syncEncryptedRecordingV2WithID:serialNumber:deviceType:firmwareVersion:hardwareRevision:isProvisioned:connectionState:mtu:recordingUUID:generation:ciphertextLength:ciphertextSHA256:operationID:onProfileRequest:onProgress:completion:)
+    @objc(syncEncryptedRecordingV2WithID:serialNumber:deviceType:firmwareVersion:hardwareRevision:isProvisioned:connectionState:mtu:recordingUUID:generation:ciphertextLength:ciphertextSHA256:startedAtMs:durationMs:plaintextLength:storageFormat:operationID:onProfileRequest:onProgress:completion:)
     public func syncEncryptedRecordingV2(
         id: String,
         serialNumber: String,
@@ -880,6 +923,10 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         generation: Double,
         ciphertextLength: String,
         ciphertextSHA256: String,
+        startedAtMs: String?,
+        durationMs: String?,
+        plaintextLength: String?,
+        storageFormat: NSNumber?,
         operationID: String,
         onProfileRequest: @escaping @Sendable ([String: Any]) -> Void,
         onProgress: @escaping @Sendable ([String: Any]) -> Void,
@@ -895,6 +942,9 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
                     throw BotaDeviceSDKAppleBridgeInputError.invalidUnsignedInteger
                 }
                 let digest = try Self.sha256Data(ciphertextSHA256)
+                guard let format = UInt8(exactly: try Self.unsignedInteger(storageFormat?.doubleValue ?? 3)) else {
+                    throw BotaDeviceSDKAppleBridgeInputError.invalidUnsignedInteger
+                }
                 try await recordings.syncEncryptedRecordingV2(
                     Self.connectedDevice(
                         id: id,
@@ -910,7 +960,11 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
                         uuid: recordingUUID,
                         generation: generationValue,
                         ciphertextLength: length,
-                        ciphertextSHA256: digest
+                        ciphertextSHA256: digest,
+                        startedAtMs: try Self.catalogDecimal(startedAtMs),
+                        durationMs: try Self.catalogDecimal(durationMs),
+                        plaintextLength: try Self.catalogDecimal(plaintextLength),
+                        storageFormat: format
                     ),
                     operationID: operationID,
                     onProfileRequest: onProfileRequest,
@@ -923,6 +977,14 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         }
     }
 
+    private static func catalogDecimal(_ text: String?) throws -> UInt64 {
+        guard let text else { return 0 }
+        guard let value = UInt64(text), String(value) == text else {
+            throw BotaDeviceSDKAppleBridgeInputError.invalidUnsignedInteger
+        }
+        return value
+    }
+
     @objc(resolveEncryptedUploadV2ProfileWithRequestID:profile:uploadSessionID:ownerRevision:securityPolicy:materialRegistrationID:completion:)
     public func resolveEncryptedUploadV2Profile(
         requestID: String,
@@ -1126,11 +1188,12 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         }
     }
 
-    @objc(uploadRecordingFileWithTaskID:recordingID:localPath:uploadURL:uploadToken:completeURL:contentType:contentSHA256:relayURL:relayBearerToken:onProgress:completion:)
+    @objc(uploadRecordingFileWithTaskID:recordingID:localPath:fileSizeBytes:uploadURL:uploadToken:completeURL:contentType:contentSHA256:relayURL:relayBearerToken:onProgress:completion:)
     public func uploadRecordingFile(
         taskID: String,
         recordingID: String,
         localPath: String,
+        fileSizeBytes: NSNumber?,
         uploadURL: String,
         uploadToken: String?,
         completeURL: String?,
@@ -1143,6 +1206,11 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
     ) {
         Task {
             do {
+                let expectedSize = try fileSizeBytes.map { value -> Int64 in
+                    let integer = try Self.unsignedInteger(value.doubleValue)
+                    guard integer <= UInt64(Int64.max) else { throw CocoaError(.fileReadCorruptFile) }
+                    return Int64(integer)
+                }
                 try await recordingUploads.upload(.init(
                     taskID: taskID,
                     recordingID: recordingID,
@@ -1153,7 +1221,8 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
                     contentType: contentType,
                     contentSHA256: contentSHA256,
                     relayURL: relayURL,
-                    relayBearerToken: relayBearerToken
+                    relayBearerToken: relayBearerToken,
+                    fileSizeBytes: expectedSize
                 )) { progress in
                     onProgress([
                         "taskId": progress.taskID,
@@ -1168,6 +1237,22 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         }
     }
 
+    @objc(releaseRecordingFileWithTaskID:localPath:completion:)
+    public func releaseRecordingFile(
+        taskID: String,
+        localPath: String,
+        completion: @escaping @Sendable (NSError?) -> Void
+    ) {
+        Task {
+            do {
+                try await recordingUploads.release(taskID: taskID, localPath: localPath)
+                completion(nil)
+            } catch {
+                completion(error as NSError)
+            }
+        }
+    }
+
     @objc(cancelRecordingUploadWithTaskID:completion:)
     public func cancelRecordingUpload(
         taskID: String,
@@ -1359,6 +1444,43 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         }
     }
 
+    @objc(readDiagnosticEventsWithID:serialNumber:deviceType:firmwareVersion:hardwareRevision:isProvisioned:connectionState:mtu:completion:)
+    public func readDiagnosticEvents(
+        id: String, serialNumber: String, deviceType: String, firmwareVersion: String,
+        hardwareRevision: String?, isProvisioned: Bool, connectionState: String, mtu: Double,
+        completion: @escaping @Sendable ([String: Any]?, NSError?) -> Void
+    ) {
+        Task {
+            do {
+                let device = try Self.connectedDevice(
+                    id: id, serialNumber: serialNumber, deviceType: deviceType,
+                    firmwareVersion: firmwareVersion, hardwareRevision: hardwareRevision,
+                    isProvisioned: isProvisioned, connectionState: connectionState, mtu: mtu
+                )
+                completion(diagnosticBatchPayload(try await logs.readDiagnosticEvents(device)), nil)
+            } catch { completion(nil, error as NSError) }
+        }
+    }
+
+    @objc(acknowledgeDiagnosticEventsWithID:serialNumber:deviceType:firmwareVersion:hardwareRevision:isProvisioned:connectionState:mtu:acceptedEventIds:completion:)
+    public func acknowledgeDiagnosticEvents(
+        id: String, serialNumber: String, deviceType: String, firmwareVersion: String,
+        hardwareRevision: String?, isProvisioned: Bool, connectionState: String, mtu: Double,
+        acceptedEventIds: [String], completion: @escaping @Sendable (NSError?) -> Void
+    ) {
+        Task {
+            do {
+                let device = try Self.connectedDevice(
+                    id: id, serialNumber: serialNumber, deviceType: deviceType,
+                    firmwareVersion: firmwareVersion, hardwareRevision: hardwareRevision,
+                    isProvisioned: isProvisioned, connectionState: connectionState, mtu: mtu
+                )
+                try await logs.acknowledgeDiagnosticEvents(device, acceptedEventIds: acceptedEventIds)
+                completion(nil)
+            } catch { completion(error as NSError) }
+        }
+    }
+
     @objc(stopDeviceLogsWithCompletion:)
     public func stopDeviceLogs(completion: @escaping @Sendable () -> Void) {
         Task {

package/ios/BotaDeviceSDKAppleDiagnostics.swift

@@ -0,0 +1,40 @@
+import BotaAppSDK
+import Foundation
+
+func diagnosticBatchPayload(_ batch: DeviceDiagnosticsBatch) -> [String: Any] {
+    ["schema_version": batch.schemaVersion, "events": batch.events.map(diagnosticEventPayload)]
+}
+
+private func diagnosticEventPayload(_ event: DeviceDiagnosticEvent) -> [String: Any] {
+    var payload: [String: Any] = [
+        "event_id": event.eventId, "event_type": event.eventType,
+        "reason_code": event.reasonCode, "uptime_ms": event.uptimeMs,
+        "signature": event.signature, "firmware_build_id": event.firmwareBuildId,
+        "subsystem": event.subsystem, "state_before_event": event.stateBeforeEvent,
+    ]
+    if let report = event.report {
+        var execution: [String: Any] = ["pc_trace": report.execution.pcTrace]
+        execution["task"] = report.execution.task
+        execution["reti"] = report.execution.reti
+        execution["rets"] = report.execution.rets
+        var value: [String: Any] = [
+            "fault": [
+                "cpu_id": report.fault.cpuId, "cpu_emu": report.fault.cpuEmu,
+                "core_emu": report.fault.coreEmu, "hsb_emu": report.fault.hsbEmu,
+                "audio_emu": report.fault.audioEmu, "wireless_emu": report.fault.wirelessEmu,
+            ],
+            "execution": execution,
+        ]
+        if let runtime = report.runtime {
+            var fields: [String: Any] = [:]
+            fields["heap_free_bytes"] = runtime.heapFreeBytes
+            fields["task_stack_remaining_bytes"] = runtime.taskStackRemainingBytes
+            value["runtime"] = fields
+        }
+        if let breadcrumbs = report.breadcrumbs {
+            value["breadcrumbs"] = breadcrumbs.map { ["delta_ms": $0.deltaMs, "code": $0.code, "arg0": $0.arg0] as [String: Any] }
+        }
+        payload["report"] = value
+    }
+    return payload
+}

package/ios/BotaDeviceSDKAppleLogs.swift

@@ -2,6 +2,8 @@ import BotaAppSDK
 import Foundation
 
 protocol BotaDeviceSDKAppleLogClient: Sendable {
+    func readDiagnosticEvents(_ device: ConnectedDevice) async throws -> DeviceDiagnosticsBatch
+    func acknowledgeDiagnosticEvents(_ device: ConnectedDevice, acceptedEventIds: [String]) async throws
     func streamLogs(
         _ device: ConnectedDevice
     ) async throws -> AsyncThrowingStream<DeviceLogLine, Error>
@@ -24,6 +26,14 @@ struct BotaDeviceSDKSharedAppleLogClient: BotaDeviceSDKAppleLogClient {
     func stop() async throws {
         try await logs.stop()
     }
+
+    func readDiagnosticEvents(_ device: ConnectedDevice) async throws -> DeviceDiagnosticsBatch {
+        try await logs.readDiagnosticEvents(device)
+    }
+
+    func acknowledgeDiagnosticEvents(_ device: ConnectedDevice, acceptedEventIds: [String]) async throws {
+        try await logs.acknowledgeDiagnosticEvents(device, acceptedEventIds: acceptedEventIds)
+    }
 }
 
 actor BotaDeviceSDKAppleLogs {
@@ -39,6 +49,14 @@ actor BotaDeviceSDKAppleLogs {
         self.client = client
     }
 
+    func readDiagnosticEvents(_ device: ConnectedDevice) async throws -> DeviceDiagnosticsBatch {
+        try await client.readDiagnosticEvents(device)
+    }
+
+    func acknowledgeDiagnosticEvents(_ device: ConnectedDevice, acceptedEventIds: [String]) async throws {
+        try await client.acknowledgeDiagnosticEvents(device, acceptedEventIds: acceptedEventIds)
+    }
+
     func start(
         _ device: ConnectedDevice,
         onLine: @escaping @Sendable (DeviceLogLine) -> Void,

package/ios/BotaDeviceSDKAppleRecordingUploads.swift

@@ -1,4 +1,5 @@
 import Foundation
+import Darwin
 
 struct BotaDeviceSDKAppleRecordingUploadRequest: Sendable {
     let taskID: String
@@ -11,6 +12,7 @@ struct BotaDeviceSDKAppleRecordingUploadRequest: Sendable {
     let contentSHA256: String?
     let relayURL: String?
     let relayBearerToken: String?
+    var fileSizeBytes: Int64? = nil
 }
 
 struct BotaDeviceSDKAppleRecordingUploadProgress: Equatable, Sendable {
@@ -25,6 +27,9 @@ actor BotaDeviceSDKAppleRecordingUploads {
         case invalidResponse
         case missingFile(String)
         case requestFailed(Int)
+        case invalidJournal
+        case notCompleted
+        case fileSizeChanged
 
         var errorDescription: String? {
             switch self {
@@ -36,24 +41,42 @@ actor BotaDeviceSDKAppleRecordingUploads {
                 "recording file does not exist: \(path)"
             case let .requestFailed(statusCode):
                 "recording upload failed with HTTP \(statusCode)"
+            case .invalidJournal:
+                "invalid upload recovery journal"
+            case .notCompleted:
+                "recording release requires exact durable completion"
+            case .fileSizeChanged:
+                "stored recording length changed"
             }
         }
     }
 
     private var queueFile: URL
+    private var recordingDirectory: URL
     private let session: URLSession
+    private let syncDirectory: @Sendable (URL) throws -> Void
+    private var journalWriteUncertain = false
     private var operations: [String: Task<Void, Error>] = [:]
+    private var cancelledAttempts = Set<String>()
 
     init(
         queueFile: URL = BotaDeviceSDKAppleRecordingUploads.defaultQueueFile(),
-        session: URLSession = .shared
+        session: URLSession = .shared,
+        syncDirectory: @escaping @Sendable (URL) throws -> Void = BotaDeviceSDKAppleRecordingUploads.synchronizeDirectory
     ) {
         self.queueFile = queueFile
+        recordingDirectory = queueFile.deletingLastPathComponent().appendingPathComponent("Recordings", isDirectory: true)
         self.session = session
+        self.syncDirectory = syncDirectory
     }
 
     func configure(applicationSupportDirectory: URL?) {
-        guard let applicationSupportDirectory else { return }
+        guard let applicationSupportDirectory else {
+            queueFile = Self.defaultQueueFile()
+            recordingDirectory = queueFile.deletingLastPathComponent().appendingPathComponent("Recordings", isDirectory: true)
+            return
+        }
+        recordingDirectory = applicationSupportDirectory.appendingPathComponent("Recordings", isDirectory: true)
         queueFile = applicationSupportDirectory
             .appendingPathComponent("BotaDeviceSDK", isDirectory: true)
             .appendingPathComponent("compat-upload-queue.json")
@@ -63,6 +86,8 @@ actor BotaDeviceSDKAppleRecordingUploads {
         _ upload: BotaDeviceSDKAppleRecordingUploadRequest,
         onProgress: @escaping @Sendable (BotaDeviceSDKAppleRecordingUploadProgress) -> Void
     ) async throws {
+        guard !cancelledAttempts.contains(upload.taskID) else { throw CancellationError() }
+        try requireOwnedFile(upload.localPath)
         guard operations[upload.taskID] == nil else {
             throw UploadError.alreadyActive(upload.taskID)
         }
@@ -72,16 +97,21 @@ actor BotaDeviceSDKAppleRecordingUploads {
         }
         operations[upload.taskID] = operation
         defer { operations.removeValue(forKey: upload.taskID) }
-        try await operation.value
+        try await withTaskCancellationHandler {
+            try await operation.value
+        } onCancel: {
+            operation.cancel()
+        }
     }
 
     func cancel(taskID: String) {
-        operations.removeValue(forKey: taskID)?.cancel()
+        cancelledAttempts.insert(taskID)
+        operations[taskID]?.cancel()
     }
 
     func cancelAll() {
+        cancelledAttempts.formUnion(operations.keys)
         operations.values.forEach { $0.cancel() }
-        operations.removeAll()
     }
 
     func loadQueue() throws -> String {
@@ -90,11 +120,103 @@ actor BotaDeviceSDKAppleRecordingUploads {
     }
 
     func saveQueue(_ serializedTasks: String) throws {
+        try writeQueue(Self.serialize(Self.metadata(serializedTasks)))
+    }
+
+    func release(taskID: String, localPath: String) async throws {
+        guard !journalWriteUncertain else { throw UploadError.notCompleted }
+        let tasks = try Self.metadata(String(contentsOf: queueFile, encoding: .utf8))
+        guard tasks.contains(where: {
+            $0["id"] as? String == taskID && $0["localPath"] as? String == localPath &&
+                $0["status"] as? String == "completed"
+        }) else { throw UploadError.notCompleted }
+        try removeCompletedFile(localPath)
+    }
+
+    private func removeCompletedFile(_ path: String) throws {
+        try requireOwnedFile(path)
+        if FileManager.default.fileExists(atPath: path) {
+            let attributes = try FileManager.default.attributesOfItem(atPath: path)
+            guard attributes[.type] as? FileAttributeType == .typeRegular else { throw UploadError.notCompleted }
+            try FileManager.default.removeItem(atPath: path)
+        }
+        // A missing file may be an earlier unlink whose directory sync failed.
+        try syncDirectory(URL(fileURLWithPath: path).deletingLastPathComponent())
+    }
+
+    private func requireOwnedFile(_ path: String) throws {
+        let file = URL(fileURLWithPath: path)
+        guard path.hasPrefix("/"), file.pathExtension == "recording",
+              UUID(uuidString: file.deletingPathExtension().lastPathComponent) != nil,
+              file.resolvingSymlinksInPath().deletingLastPathComponent().standardizedFileURL == recordingDirectory.resolvingSymlinksInPath().standardizedFileURL
+        else { throw UploadError.notCompleted }
+        if FileManager.default.fileExists(atPath: path) {
+            let attributes = try FileManager.default.attributesOfItem(atPath: path)
+            guard attributes[.type] as? FileAttributeType == .typeRegular else { throw UploadError.notCompleted }
+        }
+    }
+
+    private func writeQueue(_ serializedTasks: String) throws {
+        journalWriteUncertain = true
         try FileManager.default.createDirectory(
             at: queueFile.deletingLastPathComponent(),
             withIntermediateDirectories: true
         )
+        try syncDirectory(queueFile.deletingLastPathComponent().deletingLastPathComponent())
         try Data(serializedTasks.utf8).write(to: queueFile, options: .atomic)
+        let handle = try FileHandle(forWritingTo: queueFile)
+        defer { try? handle.close() }
+        try handle.synchronize()
+        try syncDirectory(queueFile.deletingLastPathComponent())
+        journalWriteUncertain = false
+    }
+
+    private static func serialize(_ tasks: [[String: Any]]) throws -> String {
+        String(decoding: try JSONSerialization.data(withJSONObject: tasks, options: [.sortedKeys]), as: UTF8.self)
+    }
+
+    private static func metadata(_ serialized: String) throws -> [[String: Any]] {
+        guard let tasks = try JSONSerialization.jsonObject(with: Data(serialized.utf8)) as? [[String: Any]] else {
+            throw UploadError.invalidJournal
+        }
+        let fields: Set<String> = ["id", "recordingId", "deviceId", "recordingUuid", "localPath", "status", "retryCount", "createdAt", "updatedAt", "recoveryScope", "fileSizeBytes", "nextAttemptAt", "contentType", "contentSha256", "relayUpload"]
+        var ids = Set<String>()
+        return try tasks.map { task in
+            guard let id = task["id"] as? String, !id.isEmpty, ids.insert(id).inserted,
+                  let recordingID = task["recordingId"] as? String, !recordingID.isEmpty,
+                  let deviceID = task["deviceId"] as? String, !deviceID.isEmpty,
+                  task["localPath"] is String, task["createdAt"] is String, task["updatedAt"] is String,
+                  let status = task["status"] as? String, ["pending", "uploading", "completed", "failed"].contains(status),
+                  validInteger(task["retryCount"])
+            else { throw UploadError.invalidJournal }
+            for key in ["recordingUuid", "recoveryScope", "contentType", "contentSha256"] where task[key] != nil {
+                guard task[key] is String else { throw UploadError.invalidJournal }
+            }
+            for key in ["fileSizeBytes", "nextAttemptAt"] where task[key] != nil {
+                guard validInteger(task[key]) else { throw UploadError.invalidJournal }
+            }
+            if let relay = task["relayUpload"] {
+                guard let number = relay as? NSNumber, CFGetTypeID(number) == CFBooleanGetTypeID() else { throw UploadError.invalidJournal }
+            }
+            let dates = ISO8601DateFormatter()
+            let fractionalDates = ISO8601DateFormatter()
+            fractionalDates.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+            for key in ["createdAt", "updatedAt"] {
+                guard let value = task[key] as? String,
+                      dates.date(from: value) != nil || fractionalDates.date(from: value) != nil
+                else { throw UploadError.invalidJournal }
+            }
+            var clean = task.filter { fields.contains($0.key) }
+            guard clean.values.allSatisfy({ $0 is String || $0 is NSNumber }) else { throw UploadError.invalidJournal }
+            clean["relayUpload"] = task["relayUpload"] as? Bool ?? (task["relay"] is [String: Any])
+            return clean
+        }
+    }
+
+    private static func validInteger(_ value: Any?) -> Bool {
+        guard let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID() else { return false }
+        let value = number.doubleValue
+        return value.isFinite && value >= 0 && value <= 9_007_199_254_740_991 && value.rounded() == value
     }
 
     private static func performUpload(
@@ -108,6 +230,8 @@ actor BotaDeviceSDKAppleRecordingUploads {
         }
         let attributes = try FileManager.default.attributesOfItem(atPath: fileURL.path)
         let totalBytes = (attributes[.size] as? NSNumber)?.int64Value ?? 0
+        if let expected = upload.fileSizeBytes, expected != totalBytes { throw UploadError.fileSizeChanged }
+        try Task.checkCancellation()
         onProgress(.init(taskID: upload.taskID, completedBytes: 0, totalBytes: totalBytes))
 
         let relay = upload.relayURL != nil
@@ -123,6 +247,7 @@ actor BotaDeviceSDKAppleRecordingUploads {
         }
         let (_, response) = try await session.upload(for: request, fromFile: fileURL)
         try Self.requireSuccess(response)
+        try Task.checkCancellation()
 
         if !relay,
            let completeURL = upload.completeURL,
@@ -144,12 +269,12 @@ actor BotaDeviceSDKAppleRecordingUploads {
             try requireSuccess(completeResponse)
         }
 
+        try Task.checkCancellation()
         onProgress(.init(
             taskID: upload.taskID,
             completedBytes: totalBytes,
             totalBytes: totalBytes
         ))
-        try FileManager.default.removeItem(at: fileURL)
     }
 
     private static func requiredURL(_ value: String) throws -> URL {
@@ -175,4 +300,11 @@ actor BotaDeviceSDKAppleRecordingUploads {
             .appendingPathComponent("BotaDeviceSDK", isDirectory: true)
             .appendingPathComponent("compat-upload-queue.json")
     }
+
+    private static func synchronizeDirectory(_ directory: URL) throws {
+        let descriptor = Darwin.open(directory.path, O_RDONLY)
+        guard descriptor >= 0 else { throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO) }
+        defer { Darwin.close(descriptor) }
+        guard Darwin.fsync(descriptor) == 0 else { throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO) }
+    }
 }