@bota.dev/react-native-app-sdk 2.0.0-beta.13 → 2.0.0-beta.15

package/generated/codegen-contract.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "package": "@bota.dev/react-native-app-sdk",
-  "packageVersion": "2.0.0-beta.13",
+  "packageVersion": "2.0.0-beta.15",
   "reactNativeVersion": "0.86.3",
   "codegenLibrary": "BotaDeviceSDKSpec",
   "nativeModule": "BotaDeviceSDK",
@@ -1216,6 +1216,13 @@
                 "typeAnnotation": {
                   "type": "NumberTypeAnnotation"
                 }
+              },
+              {
+                "name": "markersRequired",
+                "optional": true,
+                "typeAnnotation": {
+                  "type": "BooleanTypeAnnotation"
+                }
               }
             ]
           },
@@ -4143,6 +4150,101 @@
             }
           ],
           "methods": [
+            {
+              "name": "syncByo",
+              "optional": false,
+              "typeAnnotation": {
+                "type": "FunctionTypeAnnotation",
+                "returnTypeAnnotation": {
+                  "type": "PromiseTypeAnnotation",
+                  "elementType": {
+                    "type": "StringTypeAnnotation"
+                  }
+                },
+                "params": [
+                  {
+                    "name": "inputJSON",
+                    "optional": false,
+                    "typeAnnotation": {
+                      "type": "StringTypeAnnotation"
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              "name": "cancelByo",
+              "optional": false,
+              "typeAnnotation": {
+                "type": "FunctionTypeAnnotation",
+                "returnTypeAnnotation": {
+                  "type": "PromiseTypeAnnotation",
+                  "elementType": {
+                    "type": "VoidTypeAnnotation"
+                  }
+                },
+                "params": [
+                  {
+                    "name": "operationId",
+                    "optional": false,
+                    "typeAnnotation": {
+                      "type": "StringTypeAnnotation"
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              "name": "readProtectedStreamingStatus",
+              "optional": false,
+              "typeAnnotation": {
+                "type": "FunctionTypeAnnotation",
+                "returnTypeAnnotation": {
+                  "type": "PromiseTypeAnnotation",
+                  "elementType": {
+                    "type": "StringTypeAnnotation"
+                  }
+                },
+                "params": [
+                  {
+                    "name": "requestId",
+                    "optional": false,
+                    "typeAnnotation": {
+                      "type": "StringTypeAnnotation"
+                    }
+                  },
+                  {
+                    "name": "inputJSON",
+                    "optional": false,
+                    "typeAnnotation": {
+                      "type": "StringTypeAnnotation"
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              "name": "cancelProtectedStreamingStatus",
+              "optional": false,
+              "typeAnnotation": {
+                "type": "FunctionTypeAnnotation",
+                "returnTypeAnnotation": {
+                  "type": "PromiseTypeAnnotation",
+                  "elementType": {
+                    "type": "VoidTypeAnnotation"
+                  }
+                },
+                "params": [
+                  {
+                    "name": "requestId",
+                    "optional": false,
+                    "typeAnnotation": {
+                      "type": "StringTypeAnnotation"
+                    }
+                  }
+                ]
+              }
+            },
             {
               "name": "prepare",
               "optional": false,
@@ -4274,11 +4376,11 @@
       },
       {
         "path": "java/dev/bota/sdk/reactnative/NativeBotaUploadV2BackendSpec.java",
-        "sha256": "50844eb0e1ed98848de2819d2a88f00ccc4a550d4bcfdc5db21039a1eb17127f"
+        "sha256": "a6b48b64cb3531d04b204172456115c041025d18db612d836174ced2617d50fe"
       },
       {
         "path": "jni/BotaDeviceSDKSpec-generated.cpp",
-        "sha256": "f1a82f3cf03616e6f08655204af85317087cd2b0f633c052f2939eb49448c6b8"
+        "sha256": "c98c66a2a320b56be0f7106e35a867d4664e6c8029836c153443cea4e1dd38ce"
       },
       {
         "path": "jni/BotaDeviceSDKSpec.h",
@@ -4290,23 +4392,23 @@
       },
       {
         "path": "jni/react/renderer/components/BotaDeviceSDKSpec/BotaDeviceSDKSpecJSI.h",
-        "sha256": "6c5309bc7b6b6b4b2e62e5bed85a7fab8a9da8c43af9e3904692e50756de9e0f"
+        "sha256": "6c3ab34b33b2e18b2237e389bbca5f813aa679c3ec66e61441ac8fea4a1904a5"
       }
     ],
     "ios": [
       {
         "path": "BotaDeviceSDKSpec/BotaDeviceSDKSpec-generated.mm",
-        "sha256": "8bee25e75f2e73f0b989b65e1c083fb851ba77ca3d4384aecaabb1bcb252fe7a"
+        "sha256": "23bd8488e1e6a59795ec1845d7d6287731e7924e3211655899a58992efa3f6e1"
       },
       {
         "path": "BotaDeviceSDKSpec/BotaDeviceSDKSpec.h",
-        "sha256": "6bef81e2a87bb83ddbc3021e69ddbd280dac23a5049af675b738925454b1c22c"
+        "sha256": "221da1ba25df2b6c8bac02a90fccdb701dc3644c0bfd9df31c75c117a2f9b47c"
       },
       {
         "path": "BotaDeviceSDKSpecJSI.h",
-        "sha256": "6c5309bc7b6b6b4b2e62e5bed85a7fab8a9da8c43af9e3904692e50756de9e0f"
+        "sha256": "6c3ab34b33b2e18b2237e389bbca5f813aa679c3ec66e61441ac8fea4a1904a5"
       }
     ]
   },
-  "contractDigest": "d7f7eef4625f160f168c8e7440128c056f3bc826a33ca61c9fc2e91ecf074c64"
+  "contractDigest": "7b58a71c032bb3c46157b5c52ffc41a655af87186e5a9cd812e8330a93fed844"
 }

package/ios/BotaDeviceSDK.mm

@@ -670,6 +670,7 @@ RCT_EXPORT_MODULE(BotaDeviceSDK)
                            durationMs:recording.durationMs()
                       plaintextLength:recording.plaintextLength()
                         storageFormat:recording.storageFormat().has_value() ? @(recording.storageFormat().value()) : nil
+                      markersRequired:recording.markersRequired().value_or(false)
                           operationID:operationId
                      onProfileRequest:^(NSDictionary *request) {
                        [weakSelf emitOnEncryptedUploadV2ProfileRequested:request];

package/ios/BotaDeviceSDKAppleBridge.swift

@@ -909,7 +909,7 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         }
     }
 
-    @objc(syncEncryptedRecordingV2WithID:serialNumber:deviceType:firmwareVersion:hardwareRevision:isProvisioned:connectionState:mtu:recordingUUID:generation:ciphertextLength:ciphertextSHA256:startedAtMs:durationMs:plaintextLength:storageFormat:operationID:onProfileRequest:onProgress:completion:)
+    @objc(syncEncryptedRecordingV2WithID:serialNumber:deviceType:firmwareVersion:hardwareRevision:isProvisioned:connectionState:mtu:recordingUUID:generation:ciphertextLength:ciphertextSHA256:startedAtMs:durationMs:plaintextLength:storageFormat:markersRequired:operationID:onProfileRequest:onProgress:completion:)
     public func syncEncryptedRecordingV2(
         id: String,
         serialNumber: String,
@@ -927,6 +927,7 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         durationMs: String?,
         plaintextLength: String?,
         storageFormat: NSNumber?,
+        markersRequired: Bool,
         operationID: String,
         onProfileRequest: @escaping @Sendable ([String: Any]) -> Void,
         onProgress: @escaping @Sendable ([String: Any]) -> Void,
@@ -964,7 +965,8 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
                         startedAtMs: try Self.catalogDecimal(startedAtMs),
                         durationMs: try Self.catalogDecimal(durationMs),
                         plaintextLength: try Self.catalogDecimal(plaintextLength),
-                        storageFormat: format
+                        storageFormat: format,
+                        markersRequired: markersRequired
                     ),
                     operationID: operationID,
                     onProfileRequest: onProfileRequest,

package/ios/BotaDeviceSDKAppleRecordingUploads.swift

@@ -179,7 +179,7 @@ actor BotaDeviceSDKAppleRecordingUploads {
         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"]
+        let fields: Set<String> = ["id", "recordingId", "deviceId", "recordingUuid", "localPath", "status", "retryCount", "createdAt", "updatedAt", "recoveryScope", "fileSizeBytes", "nextAttemptAt", "contentType", "contentSha256", "relayUpload", "completionPending"]
         var ids = Set<String>()
         return try tasks.map { task in
             guard let id = task["id"] as? String, !id.isEmpty, ids.insert(id).inserted,
@@ -195,8 +195,8 @@ actor BotaDeviceSDKAppleRecordingUploads {
             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 }
+            for key in ["relayUpload", "completionPending"] where task[key] != nil {
+                guard let number = task[key] as? NSNumber, CFGetTypeID(number) == CFBooleanGetTypeID() else { throw UploadError.invalidJournal }
             }
             let dates = ISO8601DateFormatter()
             let fractionalDates = ISO8601DateFormatter()

package/ios/BotaDeviceSDKAppleRecordings.swift

@@ -646,6 +646,7 @@ actor BotaDeviceSDKAppleRecordings {
             "durationMs": String(recording.durationMs),
             "plaintextLength": String(recording.plaintextLength),
             "storageFormat": Int(recording.storageFormat),
+            "markersRequired": recording.markersRequired,
         ]
     }
 

package/ios/BotaUploadV2Backend.mm

@@ -16,6 +16,15 @@ RCT_EXPORT_MODULE(BotaUploadV2Backend)
   if ((self = [super init])) { _backend = [BotaUploadV2BackendBridge new]; }
   return self;
 }
+- (void)readProtectedStreamingStatus:(NSString *)requestId inputJSON:(NSString *)inputJSON resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  [_backend readProtectedStreamingStatus:requestId inputJSON:inputJSON completion:^(NSString *result, NSError *error) {
+    if (error) { reject(@"BOTA_STREAM_STATUS_FAILED", @"BOTA_STREAM_STATUS_FAILED", nil); }
+    else { resolve(result); }
+  }];
+}
+- (void)cancelProtectedStreamingStatus:(NSString *)requestId resolve:(RCTPromiseResolveBlock)resolve reject:(__unused RCTPromiseRejectBlock)reject {
+  [_backend cancelProtectedStreamingStatus:requestId completion:^{ resolve(nil); }];
+}
 - (void)prepare:(NSString *)inputJSON resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
   __weak BotaUploadV2Backend *weakSelf = self;
   [_backend prepare:inputJSON credentialsRequested:^(NSString *requestId, NSString *operationId) {
@@ -25,6 +34,18 @@ RCT_EXPORT_MODULE(BotaUploadV2Backend)
     else { resolve(result); }
   }];
 }
+- (void)syncByo:(NSString *)inputJSON resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  __weak BotaUploadV2Backend *weakSelf = self;
+  [_backend syncByo:inputJSON credentialsRequested:^(NSString *requestId, NSString *operationId) {
+    [weakSelf emitOnCredentialsRequested:@{@"requestId": requestId, @"operationId": operationId}];
+  } completion:^(NSString *result, NSError *error) {
+    if (error) { reject(error.userInfo[@"byoCode"] ?: @"byo_upload_failed", error.localizedDescription, nil); }
+    else { resolve(result); }
+  }];
+}
+- (void)cancelByo:(NSString *)operationId resolve:(RCTPromiseResolveBlock)resolve reject:(__unused RCTPromiseRejectBlock)reject {
+  [_backend cancelByo:operationId completion:^{ resolve(nil); }];
+}
 - (void)cancel:(NSString *)operationId resolve:(RCTPromiseResolveBlock)resolve reject:(__unused RCTPromiseRejectBlock)reject {
   [_backend cancel:operationId completion:^{ resolve(nil); }];
 }

package/ios/UploadBackend/BotaUploadV2BackendBridge.swift

@@ -4,9 +4,28 @@ import Foundation
 @objc(BotaUploadV2BackendBridge)
 public final class BotaUploadV2BackendBridge: NSObject, @unchecked Sendable {
   @MainActor private var coordinator: UploadCoordinator?
+  @MainActor private var byo: ByoBridgeDriver?
   @MainActor private var destroyed = false
+  @MainActor private var statusJobs: [String: Task<Void, Never>] = [:]
   @MainActor private var credentialsRequested: (@Sendable (String, String) -> Void)?
 
+  @objc(readProtectedStreamingStatus:inputJSON:completion:)
+  public func readProtectedStreamingStatus(_ id: String, inputJSON: String,
+    completion: @escaping @Sendable (String?, NSError?) -> Void) {
+    Task { @MainActor in
+      guard !destroyed, statusJobs[id] == nil else { completion(nil, UploadFailure.cancelled as NSError); return }
+      statusJobs[id] = Task { @MainActor in
+        defer { statusJobs[id] = nil }
+        do { let result = try await UploadStreamingStatus().read(inputJSON); completion(result, nil) }
+        catch { completion(nil, UploadFailure.safe(error) as NSError) }
+      }
+    }
+  }
+  @objc(cancelProtectedStreamingStatus:completion:)
+  public func cancelProtectedStreamingStatus(_ id: String, completion: @escaping @Sendable () -> Void) {
+    Task { @MainActor in statusJobs[id]?.cancel(); completion() }
+  }
+
   @objc(prepare:credentialsRequested:completion:)
   public func prepare(_ json: String,
     credentialsRequested: @escaping @Sendable (String, String) -> Void,
@@ -23,6 +42,26 @@ public final class BotaUploadV2BackendBridge: NSObject, @unchecked Sendable {
     }
   }
 
+  @objc(syncByo:credentialsRequested:completion:)
+  public func syncByo(_ json: String, credentialsRequested: @escaping @Sendable (String, String) -> Void,
+    completion: @escaping @Sendable (String?, NSError?) -> Void) {
+    Task { @MainActor in
+      do {
+        guard !destroyed else { throw UploadFailure.cancelled }
+        self.credentialsRequested = credentialsRequested
+        completion(try await byoService().sync(json), nil)
+      } catch { completion(nil, (error is ByoStorageError ? error : UploadFailure.safe(error)) as NSError) }
+    }
+  }
+  @objc(cancelByo:completion:)
+  public func cancelByo(_ id: String, completion: @escaping @Sendable () -> Void) {
+    Task { @MainActor in await byoService().cancel(id); completion() }
+  }
+  @MainActor private func byoService() -> ByoBridgeDriver {
+    if let byo { return byo }
+    let value = ByoBridgeDriver(credentials: service().credentials); byo = value; return value
+  }
+
   @objc(cancel:completion:)
   public func cancel(_ id: String, completion: @escaping @Sendable () -> Void) {
     Task { @MainActor in coordinator?.cancel(id); completion() }
@@ -45,7 +84,11 @@ public final class BotaUploadV2BackendBridge: NSObject, @unchecked Sendable {
     Task { @MainActor in coordinator?.credentials.reject(requestId: id); completion() }
   }
   @objc public func invalidate() {
-    Task { @MainActor in destroyed = true; coordinator?.cancelAll(); credentialsRequested = nil }
+    Task { @MainActor in
+      destroyed = true; coordinator?.cancelAll(); credentialsRequested = nil
+      statusJobs.values.forEach { $0.cancel() }; statusJobs.removeAll()
+      await byo?.stop()
+    }
   }
 
   @MainActor private func service() -> UploadCoordinator {
@@ -69,6 +112,12 @@ public final class BotaUploadV2BackendBridge: NSObject, @unchecked Sendable {
       default: throw UploadFailure.invalidDocument
       }
       guard let sessionId = UUID(uuidString: prepared.session.session_id) else { throw UploadFailure.invalidDocument }
+      let submitMarkers: EncryptedUploadV2Material.MarkerSubmitter?
+      if operation.input.recording.markersRequired == true {
+        submitMarkers = { documents, evidence in
+          try await operation.submitMarkers(documents, evidence: Self.evidence(evidence))
+        }
+      } else { submitMarkers = nil }
       let material = EncryptedUploadV2Material(
         materialID: UUID().uuidString.lowercased(), recordingID: operation.input.recording.uuid,
         uploadSessionID: sessionId, ownerRevision: prepared.session.owner_revision, policy: policy,
@@ -83,7 +132,8 @@ public final class BotaUploadV2BackendBridge: NSObject, @unchecked Sendable {
           return EncryptedUploadV2ContextExchange(challenge: context.challenge, exchangeProof: context.exchangeProof)
         },
         shouldUploadCiphertext: { try await operation.shouldUpload(Self.evidence($0)) },
-        reconcileStaging: { try await operation.reconcileStaging($0, evidence: Self.evidence($1)) }
+        reconcileStaging: { try await operation.reconcileStaging($0, evidence: Self.evidence($1)) },
+        submitMarkers: submitMarkers
       )
       return BotaDeviceSDKEncryptedUploadV2Materials.register(material)
     }, unregister: { id in _ = BotaDeviceSDKEncryptedUploadV2Materials.remove(id) })

package/ios/UploadBackend/ByoBridgeDriver.swift

@@ -0,0 +1,94 @@
+import BotaAppSDK
+import Foundation
+
+/// Metadata-only RN boundary. SDK native code owns documents and recording bytes.
+@MainActor final class ByoBridgeDriver {
+    private let credentials: UploadCredentials
+    private var tasks: [String: Task<String, Error>] = [:]
+    private var cancelled: Set<String> = []
+    private var stopped = false
+    init(credentials: UploadCredentials) { self.credentials = credentials }
+    private struct Input: Decodable {
+        let operationId: String
+        let device: Device
+        let recording: Recording?
+        let mode: String
+        let scope: Scope
+        struct Recording: Decodable { let uuid: String; let generation: UInt32 }
+        struct Scope: Decodable {
+            let baseUrl, scopeKey, organizationId, projectId, environment, deviceId: String
+            let bindingGeneration: UInt32
+        }
+        struct Device: Decodable {
+            let id, serialNumber, deviceType, firmwareVersion, connectionState: String
+            let hardwareRevision: String?
+            let isProvisioned: Bool
+            let mtu: Int
+            func native() throws -> ConnectedDevice {
+                let type: DeviceType
+                switch deviceType {
+                case "bota_pin": type = .botaPin
+                case "bota_pin_4g": type = .botaPin4G
+                case "bota_note": type = .botaNote
+                default: throw UploadFailure.invalidInput
+                }
+                guard connectionState == "connected", (23...517).contains(mtu),
+                      !id.isEmpty, !serialNumber.isEmpty else { throw UploadFailure.invalidInput }
+                return ConnectedDevice(id: id, serialNumber: serialNumber, deviceType: type, firmwareVersion: firmwareVersion,
+                    hardwareRevision: hardwareRevision, isProvisioned: isProvisioned, connectionState: .connected, mtu: mtu)
+            }
+        }
+    }
+    private func check(_ id: String) throws {
+        try Task.checkCancellation()
+        guard !stopped, !cancelled.contains(id), tasks[id] != nil else { throw UploadFailure.cancelled }
+    }
+    func sync(_ json: String) async throws -> String {
+        guard json.utf8.count <= 8192 else { throw UploadFailure.invalidInput }
+        let input = try JSONDecoder().decode(Input.self, from: Data(json.utf8))
+        let id = input.operationId
+        guard id.hasPrefix("byo-"), id.utf8.count <= 64, !stopped, !cancelled.contains(id), tasks[id] == nil,
+              let url = URL(string: input.scope.baseUrl) else { throw UploadFailure.invalidInput }
+        let device = try input.device.native()
+        let task = Task {
+            try self.check(id)
+            let options = ByoStorageOptions(baseURL: url, scopeKey: input.scope.scopeKey,
+                organizationID: input.scope.organizationId, projectID: input.scope.projectId, deviceID: input.scope.deviceId,
+                environment: input.scope.environment, bindingGeneration: input.scope.bindingGeneration,
+                stateDirectory: FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
+                    .appendingPathComponent("BotaSDKByo", isDirectory: true),
+                accessToken: { try await self.credentials.request(operationId: id) },
+                validateScope: { try await self.check(id) })
+            let bytes: Data
+            if input.mode == "list" {
+                let recordings = try await BotaDeviceClient.shared.recordings.listByoRecordings(device, options: options)
+                try self.check(id)
+                bytes = try JSONSerialization.data(withJSONObject: recordings.map { ["uuid": $0.uuid, "generation": $0.generation] as [String: Any] })
+            } else {
+                guard input.mode == "stream" || (input.mode == "sync" && input.recording != nil) else { throw UploadFailure.invalidInput }
+                let selected = input.recording.map { ByoRecording(uuid: $0.uuid, generation: $0.generation) }
+                let result: ByoUploadResult
+                if input.mode == "stream" { result = try await BotaDeviceClient.shared.recordings.streamByoRecording(device, recording: selected, options: options) }
+                else { result = try await BotaDeviceClient.shared.recordings.syncByoRecording(device, recording: selected!, options: options) }
+                try self.check(id)
+                bytes = try JSONSerialization.data(withJSONObject: ["recordingId": result.recordingID, "uploadSessionId": result.uploadSessionID])
+            }
+            return String(decoding: bytes, as: UTF8.self)
+        }
+        tasks[id] = task
+        defer { tasks[id] = nil; cancelled.remove(id); credentials.cancel(operationId: id) }
+        return try await task.value
+    }
+    func cancel(_ id: String) async {
+        guard id.hasPrefix("byo-"), id.utf8.count <= 64 else { return }
+        if cancelled.count >= 128 { stopped = true }
+        else { cancelled.insert(id) }
+        let task = tasks[id]; task?.cancel(); credentials.cancel(operationId: id); _ = await task?.result
+    }
+    func stop() async {
+        stopped = true
+        let current = tasks
+        for (id, task) in current { task.cancel(); credentials.cancel(operationId: id) }
+        for task in current.values { _ = await task.result }
+    }
+}

package/ios/UploadBackend/UploadModels.swift

@@ -101,6 +101,7 @@ struct UploadInput: Codable, Sendable {
     var durationMs: String
     var plaintextLength: String
     var storageFormat: UInt8
+    var markersRequired: Bool? = nil
   }
   struct Capability: Codable, Sendable { var rawValueHex: String; var flags: UInt32 }
   struct Checkpoint: Codable, Sendable {
@@ -187,7 +188,9 @@ struct UploadInput: Codable, Sendable {
     encoder.outputFormatting = [.sortedKeys, .withoutEscapingSlashes]
     var identityScope = scope
     if !includeTransport { identityScope.nativeDeviceId = "" }
-    return UploadValidation.hash(try encoder.encode(Identity(scope: identityScope, recording: recording)))
+    var identityRecording = recording
+    if identityRecording.markersRequired == false { identityRecording.markersRequired = nil }
+    return UploadValidation.hash(try encoder.encode(Identity(scope: identityScope, recording: identityRecording)))
   }
 
   func validateCheckpoint(_ entry: UploadJournalEntry?) throws {
@@ -242,6 +245,8 @@ struct UploadSession: Decodable, Sendable {
   let plaintext_length: UInt64?
   let completion_receipt_base64: String?
   let completion_receipt_sha256: String?
+  let marker_completion_receipt_base64: String?
+  let marker_completion_receipt_sha256: String?
 
   func validatePointer() throws {
     guard profile == "encrypted_upload_v2", UploadValidation.uuid(session_id), owner_revision > 0,

package/ios/UploadBackend/UploadOperation.swift

@@ -178,7 +178,7 @@ struct UploadContext: Sendable {
     } else {
       let nonce = try await nonce()
       let body: [String: Any] = [
-        "device_id": input.scope.deviceId, "end_user_id": input.scope.endUserId, "binding_generation": input.scope.bindingGeneration,
+        "device_id": input.scope.deviceId, "binding_generation": input.scope.bindingGeneration,
         "recording_uuid": input.recording.uuid, "recording_generation": input.recording.generation,
         "storage_format": "bota_enc_v2", "channel": "ble",
         "capabilities_base64": try UploadValidation.bytes(input.capability.rawValueHex).base64EncodedString(),
@@ -201,7 +201,28 @@ struct UploadContext: Sendable {
     try selected.validatePointer()
     _ = try UploadValidation.date(selected.expires_at)
     guard UploadValidation.hex(selected.authorization_sha256, bytes: 32) else { throw UploadFailure.invalidDocument }
-    let authorization = try UploadValidation.document(selected.authorization_base64, hash: selected.authorization_sha256, size: 408)
+    var authorization = try UploadValidation.document(selected.authorization_base64, hash: selected.authorization_sha256, size: 408)
+    if input.recording.markersRequired == true {
+      struct Admission: Decodable {
+        let profile: String
+        let context_base64: String
+        let authorization_base64: String
+        let authorization_sha256: String
+      }
+      let path = try sessionPath() + "/markers/authorization"
+      let admitted: Data
+      do {
+        admitted = try await retry { try await request(path + "?owner_revision=\(selected.owner_revision)") }
+      } catch UploadFailure.http(404) where ["", "created", "staging", "staged"].contains(selected.state ?? "") {
+        admitted = try await retry { try await request(path, method: "POST", body: [
+          "owner_revision": selected.owner_revision, "request_uuid": selected.session_id,
+        ]) }
+      }
+      let admission: Admission = try decode(admitted)
+      guard admission.profile == "recording-markers/1" else { throw UploadFailure.invalidDocument }
+      authorization.append(try UploadValidation.document(admission.context_base64, size: 176))
+      authorization.append(try UploadValidation.document(admission.authorization_base64, hash: admission.authorization_sha256, size: 280))
+    }
     session = selected
     return UploadPrepared(session: selected, authorization: authorization, recordingId: initial.recordingId)
   }
@@ -313,6 +334,18 @@ struct UploadContext: Sendable {
     needsManifest = false
   }
 
+  func submitMarkers(_ documents: [Data], evidence: UploadEvidence) async throws {
+    try verify(evidence)
+    guard input.recording.markersRequired == true, (2...4097).contains(documents.count),
+          documents.first?.count == 200, documents.dropFirst().allSatisfy({ (216...402).contains($0.count) }),
+          let revision = entry?.ownerRevision else { throw UploadFailure.invalidDocument }
+    let path = try sessionPath() + "/markers/batch"
+    _ = try await retry { try await request(path, method: "POST", body: [
+      "owner_revision": revision, "seal_base64": documents[0].base64EncodedString(),
+      "pages_base64": documents.dropFirst().map { $0.base64EncodedString() },
+    ]) }
+  }
+
   func finalize(_ evidence: UploadEvidence) async throws {
     try verify(evidence)
     guard let entry else { throw UploadFailure.state }
@@ -325,7 +358,12 @@ struct UploadContext: Sendable {
               let hash = status.completion_receipt_sha256, UploadValidation.hex(hash, bytes: 32) else {
           throw UploadFailure.invalidDocument
         }
-        receipt = try UploadValidation.document(status.completion_receipt_base64, hash: hash, size: 336)
+        var completed = try UploadValidation.document(status.completion_receipt_base64, hash: hash, size: 336)
+        if input.recording.markersRequired == true {
+          guard let markerHash = status.marker_completion_receipt_sha256 else { throw UploadFailure.invalidDocument }
+          completed.append(try UploadValidation.document(status.marker_completion_receipt_base64, hash: markerHash, size: 296))
+        }
+        receipt = completed
         return
       }
       try await wait(2000)

package/ios/UploadBackend/UploadStreamingStatus.swift

@@ -0,0 +1,43 @@
+import Foundation
+import CoreFoundation
+
+/** Scalar-only read boundary; all HTTP runs through the no-redirect native client. */
+@MainActor final class UploadStreamingStatus {
+  private let http: any UploadHTTP
+  init(http: any UploadHTTP = UploadURLSessionHTTP()) { self.http = http }
+  func read(_ input: String) async throws -> String {
+    guard let object = try JSONSerialization.jsonObject(with: Data(input.utf8)) as? [String: Any],
+      let address = object["url"] as? String, let token = object["token"] as? String,
+      let org = object["organizationId"] as? String,
+      UploadValidation.matches(address, "https://[A-Za-z0-9.-]+(?::[0-9]+)?(?:/[A-Za-z0-9_-]+)+/recordings/rec_[A-Za-z0-9_-]+/streaming-status\\?session_id=[0-9a-f-]{36}"),
+      let url = URL(string: address), (1...16384).contains(token.utf8.count),
+      token.utf8.allSatisfy({ (33...126).contains($0) }),
+      org.isEmpty || UploadValidation.matches(org, "[A-Za-z0-9_-]{1,128}") else { throw UploadFailure.invalidInput }
+    try Task.checkCancellation()
+    var request = URLRequest(url: url); request.httpMethod = "GET"
+    request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+    request.setValue("application/json", forHTTPHeaderField: "Accept")
+    if !org.isEmpty { request.setValue(org, forHTTPHeaderField: "X-Organization-Id") }
+    let response = try await http.send(request)
+    try Task.checkCancellation()
+    guard response.status == 200 else { throw UploadFailure.http(response.status) }
+    guard response.body.count <= 16384 else { throw UploadFailure.invalidDocument }
+    return try Self.scalarStatus(response.body)
+  }
+  static func scalarStatus(_ body: Data) throws -> String {
+    let strings: Set<String> = ["profile", "recording_id", "session_id", "writer_epoch", "revision", "state"]
+    let numbers: Set<String> = ["recording_generation", "received_count", "contiguous_sequence"]
+    guard let object = try JSONSerialization.jsonObject(with: body) as? [String: Any],
+      Set(object.keys) == strings.union(numbers).union(["expected_count", "authorization_expired"]),
+      strings.allSatisfy({ (object[$0] as? String).map { $0.utf8.count <= 160 } == true }),
+      numbers.allSatisfy({ isNumber(object[$0]) }),
+      object["expected_count"] is NSNull || isNumber(object["expected_count"]),
+      let expired = object["authorization_expired"] as? NSNumber,
+      CFGetTypeID(expired) == CFBooleanGetTypeID() else { throw UploadFailure.invalidDocument }
+    return String(decoding: try JSONSerialization.data(withJSONObject: object), as: UTF8.self)
+  }
+  private static func isNumber(_ value: Any?) -> Bool {
+    guard let number = value as? NSNumber else { return false }
+    return CFGetTypeID(number) != CFBooleanGetTypeID()
+  }
+}