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

package/README.md

@@ -1,10 +1,14 @@
 # Bota SDK for React Native
 
-Source candidate `2.0.0-beta.14` synchronizes the five-platform SDK family.
-It adds React Native compatibility completion polling and durable
-`completionPending` recovery. Other facade workflow support is unchanged.
-Beta.13 remains the published baseline until this candidate completes its gates.
+Source candidate `2.0.0-beta.15` synchronizes the five-platform SDK family.
+It includes Apple single-ATT transfer bounds and local connection ownership,
+awaitable React Native reconnect pause, and the reviewed main OTA, recording
+marker, protected-status and BYO storage changes. Beta.14 remains the published
+baseline until this candidate completes its gates.
 Native applications require a new binary.
+The managed Apple backend also matches the strict session-create request without
+an EndUser override; recording creation and native scope fences retain EndUser.
+See [request correction](../../docs/parity/v2-managed-backend.md#october-12-apple-session-request-correction).
 
 Bluetooth device SDK for Bota Pin and Bota Note applications. The 2.x candidate
 preserves the public TypeScript API of `@bota.dev/react-native-sdk@0.0.65`
@@ -29,9 +33,9 @@ adopting this source API; published-package availability is a separate gate.
 
 ## Install
 
-Published beta.13 remains available. Use the beta.14 pin below only after
+Published beta.14 remains available. Use the beta.15 pin below only after
 publication is verified; see the
-[preflight](../../release/evidence/2.0.0-beta.14-preflight.md).
+[preflight](../../release/evidence/2.0.0-beta.15-preflight.md).
 Rebuild native applications and reconnect explicitly after connection loss.
 Physical completed-resume acceptance and wider GATT recovery remain separate.
 Remove `@bota.dev/react-native-sdk` before adding the replacement; do not
@@ -39,7 +43,7 @@ co-install both. Standalone maintenance ended September 29, 2026; follow the
 [retirement and migration notice](../../docs/migrations/react-native-sdk-sunset.md).
 
 ```bash
-npm install --save-exact @bota.dev/react-native-app-sdk@2.0.0-beta.14
+npm install --save-exact @bota.dev/react-native-app-sdk@2.0.0-beta.15
 npx pod-install
 ```
 
@@ -84,6 +88,14 @@ await BotaClient.waitForBluetooth();
 The `BotaClient.devices`, `BotaClient.recordings`, and `BotaClient.ota`
 managers become available after configuration completes.
 
+Source-only workspace coordination adds
+`await BotaClient.devices.pauseAutoReconnect()`. Fence new reconnect work and
+retry rearming first, then inspect fresh device activity and disconnect idle
+connections before changing scope. This method waits for submitted reconnects;
+it does not itself disconnect. Existing `disableAutoReconnect(): void` remains
+unchanged. Published beta.14 does not include the addition; see
+[verification and delivery limits](../../docs/parity/workspace-reconnect-quiescence.md).
+
 Discovery exposes the manufacturer-advertised `macAddress` as uppercase,
 colon-separated bytes (`AA:BB:CC:DD:EE:FF`), preserving the legacy React Native
 registration contract. Compact native addresses are formatted at the RN
@@ -183,6 +195,23 @@ separate physical-device and application rollout gates.
 
 ## Documentation
 
+Unpublished source also exports `createProtectedStreamingStatusBackend` for
+read-only protected STREAMING metadata. Configure a scoped HTTPS `baseUrl`,
+optional `organizationId`, lifetime `signal` and fresh application
+`getAccessToken`; call `getStatus({ recordingId, sessionId,
+recordingGeneration, writerEpoch })`. The exact session identity is checked;
+`revision` remains a decimal string and may be `"0"`. Cancel the lifetime and
+call `dispose()` on workspace or account changes. A matching rebuilt native
+binary is required; published beta.14 lacks these methods. `sealed` means
+marker metadata only, never audio completion or permission to delete. This
+reader does not start protected capture or relay signed documents.
+See `docs/parity/protected-streaming-status.md` in the source repository.
+
+未发布源码新增上述只读状态接口，必须使用匹配的原生二进制；已发布 beta.14 不包含
+这些方法。查询校验精确会话身份，revision 保持字符串且允许 `"0"`；账号或工作空间
+变化时取消并释放。`sealed` 仅指标记元数据，不代表音频完成或允许删除；本接口不启动
+protected 采集，也不转发签名文档。
+
 See [docs.bota.dev](https://docs.bota.dev) for pairing, provisioning,
 recording transfer, WiFi, OTA, and device-management guides.
 

package/android/src/main/java/dev/bota/sdk/reactnative/BotaDeviceSDKAndroidRecordings.kt

@@ -106,6 +106,7 @@ internal data class BotaEncryptedUploadV2Recording(
     val durationMs: String,
     val plaintextLength: String,
     val storageFormat: Int,
+    val markersRequired: Boolean = false,
 )
 
 internal data class BotaEncryptedUploadV2Capability(
@@ -225,6 +226,7 @@ internal fun BotaEncryptedUploadV2Recording.toWritableMap(): WritableMap = Argum
     putString("durationMs", durationMs)
     putString("plaintextLength", plaintextLength)
     putInt("storageFormat", storageFormat)
+    putBoolean("markersRequired", markersRequired)
 }
 
 private fun BotaEncryptedUploadV2Capability.toWritableMap(): WritableMap = Arguments.createMap().apply {
@@ -779,6 +781,7 @@ internal fun EncryptedUploadV2Recording.toBridgeValue(): BotaEncryptedUploadV2Re
         durationMs.toString(),
         plaintextLength.toString(),
         storageFormat.toInt(),
+        markersRequired,
     )
 
 private fun EncryptedUploadV2CapabilitySnapshot.toBridgeValue(): BotaEncryptedUploadV2Capability {

package/android/src/main/java/dev/bota/sdk/reactnative/BotaDeviceSDKModule.kt

@@ -786,6 +786,7 @@ private fun ReadableMap.toEncryptedUploadV2Recording(): EncryptedUploadV2Recordi
         if (hasKey("storageFormat") && !isNull("storageFormat")) {
             getDouble("storageFormat").toUnsignedInt().also { require(it <= 255u) }.toUByte()
         } else 3u,
+        hasKey("markersRequired") && !isNull("markersRequired") && getBoolean("markersRequired"),
     )
 }
 

package/android/src/main/java/dev/bota/sdk/reactnative/upload/BotaUploadV2BackendModule.kt

@@ -13,6 +13,8 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.CoroutineStart
 import org.json.JSONObject
 
 @ReactModule(name = BotaUploadV2BackendModule.NAME)
@@ -24,6 +26,11 @@ internal class BotaUploadV2BackendModule(context: ReactApplicationContext) : Nat
       putString("requestId", requestId); putString("operationId", operationId)
     })
   }
+  private val byo = ByoBridgeDriver(File(context.noBackupFilesDir, "BotaSDKByo")) { requestId, operationId ->
+    emitOnCredentialsRequested(Arguments.createMap().apply {
+      putString("requestId", requestId); putString("operationId", operationId)
+    })
+  }
   private val upload = NativeUpload(
     UploadJournal(File(context.noBackupFilesDir, "BotaSDKUploadV2"), object : JournalDurability {
       override fun syncDirectory(directory: File) {
@@ -35,31 +42,58 @@ internal class BotaUploadV2BackendModule(context: ReactApplicationContext) : Nat
       }
     }), BackendUploadHttp(), credentials::request, BotaDeviceSDKEncryptedUploadV2Materials::readAuthNonce,
   )
+  private val statusReader = UploadStreamingStatus()
+  private val statusJobs = mutableMapOf<String, Job>()
   @Volatile private var destroyed = false
 
   private fun invoke(promise: Promise, block: suspend () -> Any?) {
     work.launch {
       try { demand(!destroyed, "CANCELLED"); promise.resolve(block()) }
       catch (error: Exception) {
-        val code = (error as? UploadFailure)?.code ?: "BOTA_UPLOAD_NATIVE"
+        val code = (error as? dev.bota.sdk.ByoStorageException)?.message ?: (error as? UploadFailure)?.code ?: "BOTA_UPLOAD_NATIVE"
         promise.reject(code, code, null)
       }
     }
   }
+  override fun syncByo(inputJSON: String, promise: Promise) = invoke(promise) { byo.sync(inputJSON) }
+  override fun cancelByo(operationId: String, promise: Promise) = invoke(promise) { byo.cancel(operationId); null }
+  override fun readProtectedStreamingStatus(requestId: String, inputJSON: String, promise: Promise) {
+    val job = work.launch(start = CoroutineStart.LAZY) {
+      try { demand(!destroyed, "CANCELLED"); promise.resolve(statusReader.read(inputJSON)) }
+      catch (_: Exception) { promise.reject("BOTA_STREAM_STATUS_FAILED", "BOTA_STREAM_STATUS_FAILED", null) }
+    }
+    job.invokeOnCompletion { error ->
+      synchronized(statusJobs) { if (statusJobs[requestId] === job) statusJobs.remove(requestId) }
+      if (error != null) promise.reject("BOTA_STREAM_STATUS_FAILED", "BOTA_STREAM_STATUS_FAILED", null)
+    }
+    synchronized(statusJobs) {
+      if (destroyed || statusJobs.containsKey(requestId)) {
+        job.cancel(); return
+      }
+      statusJobs[requestId] = job
+    }
+    job.start()
+  }
+  override fun cancelProtectedStreamingStatus(requestId: String, promise: Promise) {
+    synchronized(statusJobs) { statusJobs[requestId]?.cancel() }
+    promise.resolve(null)
+  }
   override fun prepare(inputJSON: String, promise: Promise) = invoke(promise) {
     JSONObject(upload.prepare(inputJSON)).toString()
   }
   override fun cancel(operationId: String, promise: Promise) = invoke(promise) { upload.cancel(operationId); null }
   override fun complete(operationId: String, promise: Promise) = invoke(promise) { upload.complete(operationId); null }
   override fun resolveCredentials(requestId: String, token: String, promise: Promise) = invoke(promise) {
-    credentials.resolve(requestId, token); null
+    credentials.resolve(requestId, token); byo.resolve(requestId, token); null
   }
   override fun rejectCredentials(requestId: String, promise: Promise) = invoke(promise) {
-    credentials.reject(requestId); null
+    credentials.reject(requestId); byo.reject(requestId); null
   }
   override fun invalidate() {
     destroyed = true
     upload.cancelAll()
+    work.launch { byo.stop() }
+    synchronized(statusJobs) { statusJobs.values.toList().forEach { it.cancel() }; statusJobs.clear() }
     // Dispatched identity-creating requests must drain into their original journal.
     super.invalidate()
   }

package/android/src/main/java/dev/bota/sdk/reactnative/upload/ByoBridgeDriver.kt

@@ -0,0 +1,79 @@
+package dev.bota.sdk.reactnative.upload
+
+import dev.bota.sdk.*
+import dev.bota.sdk.model.*
+import java.io.File
+import java.util.UUID
+import kotlinx.coroutines.*
+import org.json.JSONObject
+
+/** RN passes only identity metadata; all signed material and audio remain native. */
+internal class ByoBridgeDriver(private val root: File,private val emit: (String,String)->Unit) {
+    private val lock=Any()
+    private val tasks=mutableMapOf<String,Job>()
+    private val cancelled=mutableSetOf<String>()
+    private var stopped=false
+    private data class Pending(val owner: String,val value: CompletableDeferred<String>)
+    private val pending=mutableMapOf<String,Pending>()
+    private fun check(id: String)=synchronized(lock) {demand(!stopped && id !in cancelled && tasks.containsKey(id),"CANCELLED")}
+    suspend fun sync(json: String): String=coroutineScope {
+        demand(json.toByteArray().size<=8192,"INVALID_INPUT")
+        val input=JSONObject(json);val id=input.getString("operationId")
+        val job=currentCoroutineContext()[Job]!!
+        synchronized(lock) {
+            demand(id.startsWith("byo-") && id.length<=64 && !stopped && id !in cancelled && !tasks.containsKey(id),"INVALID_INPUT")
+            tasks[id]=job
+        }
+        try {
+            val value=input.getJSONObject("device");val scope=input.getJSONObject("scope");val recording=input.optJSONObject("recording")
+            val type=when(value.getString("deviceType")) {"bota_pin"->DeviceType.BotaPin;"bota_pin_4g"->DeviceType.BotaPin4G;"bota_note"->DeviceType.BotaNote;else->fail("INVALID_INPUT")}
+            demand(value.getString("connectionState")=="connected" && value.getInt("mtu") in 23..517,"INVALID_INPUT")
+            val device=ConnectedDevice(value.getString("id"),value.getString("serialNumber"),type,value.getString("firmwareVersion"),
+                if(value.isNull("hardwareRevision")) null else value.optString("hardwareRevision"),
+                value.getBoolean("isProvisioned"),ConnectionState.Connected,value.getInt("mtu"))
+            val binding=scope.getLong("bindingGeneration");val generation=recording?.getLong("generation") ?: 0
+            demand(binding in 1..0xffffffffL && generation in 0..0xffffffffL,"INVALID_INPUT")
+            val options=ByoStorageOptions(scope.getString("baseUrl"),scope.getString("scopeKey"),scope.getString("organizationId"),
+                scope.getString("projectId"),scope.getString("deviceId"),scope.getString("environment"),binding.toUInt(),root,
+                {token(id)},{currentCoroutineContext().ensureActive();check(id)})
+            if(input.getString("mode")=="list") {
+                val values=BotaDeviceClient.shared.recordings.listByoRecordings(device,options);check(id)
+                org.json.JSONArray(values.map {JSONObject().put("uuid",it.uuid).put("generation",it.generation.toLong())}).toString()
+            } else {
+                demand(input.getString("mode")=="stream" || (input.getString("mode")=="sync" && recording!=null),"INVALID_INPUT")
+                val selected=recording?.let {ByoRecording(it.getString("uuid"),generation.toUInt())}
+                val result=if(input.getString("mode")=="stream") BotaDeviceClient.shared.recordings.streamByoRecording(device,selected,options)
+                    else BotaDeviceClient.shared.recordings.syncByoRecording(device,requireNotNull(selected),options)
+                check(id)
+                JSONObject().put("recordingId",result.recordingId).put("uploadSessionId",result.uploadSessionId).toString()
+            }
+        } finally {
+            synchronized(lock) {tasks.remove(id);cancelled.remove(id)
+                pending.filterValues {it.owner==id}.keys.toList().forEach {pending.remove(it)?.value?.cancel()}}
+        }
+    }
+    private suspend fun token(id: String): String {
+        check(id);val request=UUID.randomUUID().toString();val value=CompletableDeferred<String>()
+        synchronized(lock) {check(id);pending[request]=Pending(id,value)}
+        try {emit(request,id);return withTimeout(30_000) {value.await()}.also {check(id)}}
+        finally {synchronized(lock) {pending.remove(request)}}
+    }
+    fun resolve(request: String,token: String) {
+        val entry=synchronized(lock) {pending.remove(request)} ?: return
+        if(token.isNotEmpty() && token.length<=16384 && token.all {it.code in 33..126}) entry.value.complete(token)
+        else entry.value.completeExceptionally(UploadFailure("BOTA_UPLOAD_CREDENTIALS"))
+    }
+    fun reject(request: String) {synchronized(lock) {pending.remove(request)}?.value?.completeExceptionally(UploadFailure("BOTA_UPLOAD_CREDENTIALS"))}
+    suspend fun cancel(id: String) {
+        val task=synchronized(lock) {
+            if(!id.startsWith("byo-") || id.length>64) return
+            if(cancelled.size>=128) stopped=true else cancelled.add(id)
+            tasks[id]
+        }
+        task?.cancelAndJoin()
+    }
+    suspend fun stop() {
+        val current=synchronized(lock) {stopped=true;tasks.values.toList()}
+        current.forEach {it.cancel()};current.forEach {it.join()}
+    }
+}

package/android/src/main/java/dev/bota/sdk/reactnative/upload/NativeUpload.kt

@@ -257,13 +257,29 @@ internal class NativeUpload(
         else -> fail("INVALID_DOCUMENT")
       }
       timestamp(selected.string("expires_at"))
-      val authorization = opaque(selected.string("authorization_base64"), 408, selected.string("authorization_sha256"))
+      var authorization = opaque(selected.string("authorization_base64"), 408, selected.string("authorization_sha256"))
+      if (input.recording.markersRequired) {
+        val path = sessionPath() + "/markers/authorization"
+        val admission = try {
+          retry { request(path + "?owner_revision=" + pointer!!.ownerRevision) }
+        } catch (error: UploadFailure) {
+          if (error.code != "BOTA_UPLOAD_HTTP_404" || selected.optString("state") !in setOf("", "created", "staging", "staged")) throw error
+          retry { request(path, JSONObject().put("owner_revision", pointer!!.ownerRevision)
+            .put("request_uuid", pointer!!.sessionId)) }
+        }
+        demand(admission.string("profile") == "recording-markers/1", "INVALID_DOCUMENT")
+        authorization += opaque(admission.string("context_base64"), 176)
+        authorization += opaque(admission.string("authorization_base64"), 280, admission.string("authorization_sha256"))
+      }
       val material = EncryptedUploadV2Material(
         materialId = UUID.randomUUID().toString(), recordingId = input.recording.uuid,
         uploadSessionId = UUID.fromString(pointer!!.sessionId), ownerRevision = pointer!!.ownerRevision!!.toUInt(),
         policy = nativePolicy, authorization = authorization,
         stagingRequest = { evidence -> callbacks.withLock { staging(evidence) } },
         submitManifest = { bytes, evidence -> callbacks.withLock { manifest(bytes, evidence) } },
+        submitMarkers = if (input.recording.markersRequired) { documents, evidence ->
+          callbacks.withLock { markers(documents, evidence) }
+        } else null,
         finalize = { evidence -> callbacks.withLock { finalize(evidence) } },
         completionReceipt = { evidence -> callbacks.withLock {
           verifyEvidence(evidence)
@@ -349,6 +365,15 @@ internal class NativeUpload(
       uploadCiphertext = false
       sendManifest = false
     }
+    private suspend fun markers(documents: List<ByteArray>, evidence: EncryptedUploadV2TransferEvidence) {
+      verifyEvidence(evidence)
+      demand(input.recording.markersRequired && documents.size in 2..4097 && documents[0].size == 200 &&
+        documents.drop(1).all { it.size in 216..402 }, "INVALID_DOCUMENT")
+      val pages = org.json.JSONArray()
+      documents.drop(1).forEach { pages.put(encoded(it)) }
+      retry { request(sessionPath() + "/markers/batch", JSONObject().put("owner_revision", pointer!!.ownerRevision)
+        .put("seal_base64", encoded(documents[0])).put("pages_base64", pages)) }
+    }
     private suspend fun finalize(evidence: EncryptedUploadV2TransferEvidence) {
       verifyEvidence(evidence)
       for (poll in 0 until 60) {
@@ -356,7 +381,10 @@ internal class NativeUpload(
         applyStatus(status)
         if (status.string("state") == "published") {
           demand(status.integer("plaintext_length") == input.recording.plaintextLength, "INVALID_DOCUMENT")
-          receipt = opaque(status.string("completion_receipt_base64"), 336, status.string("completion_receipt_sha256"))
+          val audio = opaque(status.string("completion_receipt_base64"), 336, status.string("completion_receipt_sha256"))
+          receipt = if (input.recording.markersRequired) audio + opaque(
+            (status.opt("marker_completion_receipt_base64") as? String ?: fail("INVALID_DOCUMENT")), 296,
+            (status.opt("marker_completion_receipt_sha256") as? String ?: fail("INVALID_DOCUMENT"))) else audio
           return
         }
         wait(2000, operation)

package/android/src/main/java/dev/bota/sdk/reactnative/upload/UploadModels.kt

@@ -78,15 +78,18 @@ internal data class UploadScope(
 internal data class UploadRecording(
   val uuid: String, val generation: Long, val ciphertextLength: Long, val ciphertextSha256: String,
   val startedAtMs: Long, val durationMs: Long, val plaintextLength: Long, val storageFormat: Long,
+  val markersRequired: Boolean = false,
 ) {
   fun identity(): List<Any> = listOf(uuid, generation, ciphertextLength.toString(), ciphertextSha256,
-    startedAtMs.toString(), durationMs.toString(), plaintextLength.toString(), storageFormat)
+    startedAtMs.toString(), durationMs.toString(), plaintextLength.toString(), storageFormat) +
+    if (markersRequired) listOf(true) else emptyList()
 
   companion object {
     fun parse(json: JSONObject): UploadRecording = UploadRecording(uuid(json.string("uuid")),
       json.integer("generation", 1, 4294967295), json.decimal("ciphertextLength", 1),
       hashString(json.string("ciphertextSha256")), json.decimal("startedAtMs"), json.decimal("durationMs"),
-      json.decimal("plaintextLength"), json.integer("storageFormat", 3, 3)).also {
+      json.decimal("plaintextLength"), json.integer("storageFormat", 3, 3),
+      if (json.has("markersRequired")) (json.get("markersRequired") as? Boolean ?: fail("INVALID_DOCUMENT")) else false).also {
       demand(it.startedAtMs + it.durationMs <= 8640000000000000L)
     }
   }

package/android/src/main/java/dev/bota/sdk/reactnative/upload/UploadStreamingStatus.kt

@@ -0,0 +1,67 @@
+package dev.bota.sdk.reactnative.upload
+
+import java.io.IOException
+import java.util.concurrent.TimeUnit
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlinx.coroutines.suspendCancellableCoroutine
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import org.json.JSONObject
+
+/** Read-only native HTTP boundary. Never sends opaque server fields over RN. */
+internal class UploadStreamingStatus(private val client: OkHttpClient = OkHttpClient.Builder()
+  .followRedirects(false).followSslRedirects(false).retryOnConnectionFailure(false)
+  .connectTimeout(20, TimeUnit.SECONDS).readTimeout(30, TimeUnit.SECONDS).callTimeout(45, TimeUnit.SECONDS).build()) {
+  suspend fun read(input: String): String {
+    val json = sanitized("INVALID_INPUT") { JSONObject(input) }
+    val url = json.optString("url")
+    val token = json.optString("token")
+    val org = json.optString("organizationId")
+    demand(url.matches(Regex("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}")), "INVALID_INPUT")
+    demand(token.length in 1..16384 && token.all { it.code in 33..126 } &&
+      (org.isEmpty() || org.matches(Regex("[A-Za-z0-9_-]{1,128}"))), "INVALID_INPUT")
+    val request = Request.Builder().url(url).get().header("Authorization", "Bearer $token")
+      .header("Accept", "application/json").apply { if (org.isNotEmpty()) header("X-Organization-Id", org) }.build()
+    val call = client.newCall(request)
+    return suspendCancellableCoroutine { continuation ->
+      continuation.invokeOnCancellation { call.cancel() }
+      call.enqueue(object : Callback {
+        override fun onFailure(call: Call, e: IOException) {
+          if (continuation.isActive) continuation.resumeWithException(UploadFailure("BOTA_UPLOAD_TRANSPORT"))
+        }
+        override fun onResponse(call: Call, response: Response) {
+          val result = runCatching {
+            response.use {
+              demand(response.code == 200 && response.request.url == request.url, "HTTP_${response.code}")
+              val body = response.body ?: fail("INVALID_DOCUMENT")
+              demand(body.contentLength() <= 16384, "INVALID_DOCUMENT")
+              val source = body.source(); source.request(16385)
+              demand(source.buffer.size <= 16384, "INVALID_DOCUMENT")
+              scalarStatus(source.readUtf8())
+            }
+          }
+          if (continuation.isActive) result.fold({ continuation.resume(it) },
+            { continuation.resumeWithException(if (it is UploadFailure) it else UploadFailure("BOTA_UPLOAD_INVALID_DOCUMENT")) })
+        }
+      })
+    }
+  }
+
+  companion object {
+    private val stringFields = setOf("profile", "recording_id", "session_id", "writer_epoch", "revision", "state")
+    private val numberFields = setOf("recording_generation", "received_count", "contiguous_sequence")
+    fun scalarStatus(body: String): String {
+      val json = sanitized("INVALID_DOCUMENT") { JSONObject(body) }
+      demand(json.keys().asSequence().toSet() == stringFields + numberFields + setOf("expected_count", "authorization_expired"), "INVALID_DOCUMENT")
+      stringFields.forEach { demand(json.get(it) is String && (json.get(it) as String).length <= 160, "INVALID_DOCUMENT") }
+      numberFields.forEach { demand(json.get(it) is Number, "INVALID_DOCUMENT") }
+      demand(json.isNull("expected_count") || json.get("expected_count") is Number, "INVALID_DOCUMENT")
+      demand(json.get("authorization_expired") is Boolean, "INVALID_DOCUMENT")
+      return json.toString()
+    }
+  }
+}

package/generated/codegen-contract.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "package": "@bota.dev/react-native-app-sdk",
-  "packageVersion": "2.0.0-beta.14",
+  "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": "89bbee822844c65336f805fe3311d15b35f4615254f4841561f7a4d2dc3ae23d"
+  "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/BotaDeviceSDKAppleRecordings.swift

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