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

package/src/byoStorageBackend.ts

@@ -0,0 +1,104 @@
+import type { ConnectedDevice } from './models/Device';
+import type { Spec } from './specs/NativeBotaUploadV2Backend';
+
+export interface ByoStorageBackendOptions {
+  /** Customer-authenticated HTTPS proxy for Bota device BYO/context routes. */
+  baseUrl: string;
+  scopeKey: string;
+  organizationId: string;
+  projectId: string;
+  environment: 'development' | 'gamma' | 'production';
+  /** Abort on logout, project change or device reassignment. */
+  signal: AbortSignal;
+  getAccessToken(signal: AbortSignal): Promise<string>;
+}
+export interface ByoRecording { uuid: string; generation: number }
+export interface ByoSyncTarget { deviceId: string; bindingGeneration: number; signal?: AbortSignal }
+export interface ByoUploadResult { recordingId: string; uploadSessionId: string }
+export interface ByoStorageBackend {
+  /** Native owns BLE, HTTP, opaque documents, durable recovery and receipt cleanup. */
+  sync(device: ConnectedDevice, recording: ByoRecording, target: ByoSyncTarget): Promise<ByoUploadResult>;
+  stream(device: ConnectedDevice, recording: ByoRecording | null, target: ByoSyncTarget): Promise<ByoUploadResult>;
+  list(device: ConnectedDevice, target: ByoSyncTarget): Promise<ByoRecording[]>;
+  dispose(): Promise<void>;
+}
+/** @internal Shared implementation for the production factory and host tests. */
+export function createManagedByoStorageBackend(native: Spec | null, options: ByoStorageBackendOptions): ByoStorageBackend {
+  const config = { ...options };
+  const url = new URL(config.baseUrl);
+  if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash ||
+    !config.scopeKey || !config.organizationId || !config.projectId || !config.signal ||
+    !['development', 'gamma', 'production'].includes(config.environment)) throw new Error('Invalid BYO configuration');
+  let disposed = false;
+  const attempts = new Set<{ cancel(): Promise<void>; settled: Promise<void> }>();
+  const perform = async (device: ConnectedDevice, recording: ByoRecording | null, target: ByoSyncTarget, live = false): Promise<ByoUploadResult | ByoRecording[]> => {
+      if (!native?.syncByo || !native.cancelByo) throw new Error('BYO requires the matching native SDK binary');
+      device = { ...device }; recording = recording && { ...recording }; target = { ...target };
+      if ((recording !== null && (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(recording.uuid) ||
+        !Number.isSafeInteger(recording.generation) || recording.generation < 0 || recording.generation > 0xffffffff)) ||
+        !Number.isSafeInteger(target.bindingGeneration) || target.bindingGeneration < 1 || target.bindingGeneration > 0xffffffff) {
+        throw new Error('Invalid BYO recording identity');
+      }
+      const operationId = 'byo-' + 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, key => {
+        const value = Math.floor(Math.random() * 16); return (key === 'x' ? value : (value & 3) | 8).toString(16);
+      });
+      const controller = new AbortController();
+      let cancelTask: Promise<void> | undefined;
+      let settle!: () => void;
+      const settled = new Promise<void>(resolve => { settle = resolve; });
+      const check = () => {
+        if (disposed || controller.signal.aborted || config.signal.aborted || target.signal?.aborted) throw new Error('BYO upload cancelled');
+      };
+      const cancel = () => {
+        controller.abort();
+        return cancelTask ??= Promise.resolve().then(() => native.cancelByo(operationId));
+      };
+      const abort = () => { void cancel().catch(() => {}); };
+      const attempt = { cancel, settled }; attempts.add(attempt);
+      let subscription: { remove(): void } | undefined;
+      let completed = false;
+      try {
+        config.signal.addEventListener('abort', abort, { once: true }); target.signal?.addEventListener('abort', abort, { once: true });
+        check();
+        subscription = native.onCredentialsRequested(event => {
+          if (event.operationId !== operationId) return;
+          void (async () => {
+            try { check(); const token = await config.getAccessToken(controller.signal); check(); await native.resolveCredentials(event.requestId, token); }
+            catch { await native.rejectCredentials(event.requestId).catch(() => {}); }
+          })();
+        });
+        const value: unknown = JSON.parse(await native.syncByo(JSON.stringify({operationId, mode: live ? 'stream' : recording === null ? 'list' : 'sync', device, recording,
+          scope: { baseUrl: url.href, scopeKey: config.scopeKey, organizationId: config.organizationId,
+            projectId: config.projectId, environment: config.environment, deviceId: target.deviceId, bindingGeneration: target.bindingGeneration } })));
+        check();
+        if (recording === null && !live) {
+          if (!Array.isArray(value) || value.length > 4096 || value.some(item => !item ||
+            !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(item.uuid) ||
+            !Number.isSafeInteger(item.generation) || item.generation < 0 || item.generation > 0xffffffff)) throw new Error('Invalid BYO native catalog');
+          completed = true; return value.map(item => ({ uuid: item.uuid as string, generation: item.generation as number }));
+        }
+        const result = value as ByoUploadResult;
+        if (!result || !/^rec_[A-Za-z0-9_-]+$/.test(result.recordingId) ||
+          !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(result.uploadSessionId)) throw new Error('Invalid BYO native result');
+        completed = true; return { recordingId: result.recordingId, uploadSessionId: result.uploadSessionId };
+      } finally {
+        try { if (!completed) await cancel(); }
+        finally {
+          attempts.delete(attempt); config.signal.removeEventListener('abort', abort); target.signal?.removeEventListener('abort', abort);
+          subscription?.remove(); settle();
+        }
+      }
+  };
+  return {
+    async sync(device, recording, target) { return await perform(device, recording, target) as ByoUploadResult; },
+    async stream(device, recording, target) { return await perform(device, recording, target, true) as ByoUploadResult; },
+    async list(device, target) { return await perform(device, null, target) as ByoRecording[]; },
+    async dispose() {
+      disposed = true;
+      const results = await Promise.allSettled([...attempts].map(async attempt => {
+        try { await attempt.cancel(); } finally { await attempt.settled; }
+      }));
+      if (results.some(result => result.status === 'rejected')) throw new Error('BYO cancellation failed');
+    },
+  };
+}

package/src/client.ts

@@ -550,6 +550,7 @@ const mapPendingRecording = (value: NativePendingRecording): DeviceRecording | B
   const plaintextLength = recording.plaintextLength;
   if (typeof recording.uuid !== 'string' || !uuidPattern.test(recording.uuid) ||
       recording.storageFormat !== 3 || typeof plaintextLength !== 'string' ||
+      (recording.markersRequired !== undefined && typeof recording.markersRequired !== 'boolean') ||
       !/^(0|[1-9][0-9]{0,19})$/.test(plaintextLength) || BigInt(plaintextLength) > 0xffffffffffffffffn ||
       typeof recording.ciphertextLength !== 'string' || !/^[1-9][0-9]{0,19}$/.test(recording.ciphertextLength) || BigInt(recording.ciphertextLength) > 0xffffffffffffffffn ||
       typeof recording.ciphertextSha256 !== 'string' || !/^[0-9a-f]{64}$/.test(recording.ciphertextSha256) ||
@@ -560,6 +561,7 @@ const mapPendingRecording = (value: NativePendingRecording): DeviceRecording | B
     uuid: recording.uuid, generation: recording.generation,
     ciphertextLength: recording.ciphertextLength, ciphertextSha256: recording.ciphertextSha256,
     storageFormat: 3, plaintextLength, startedAtMs: recording.startedAtMs,
+    markersRequired: recording.markersRequired ?? false,
     startedAt: new Date(catalogInteger(recording.startedAtMs, 8640000000000000n)),
     durationMs: catalogInteger(recording.durationMs),
   };

package/src/encryptedUploadV2Backend.ts

@@ -112,7 +112,8 @@ export function createManagedEncryptedUploadV2Backend(
             recording: { uuid: context.recording.uuid, generation: context.recording.generation,
               ciphertextLength: context.recording.ciphertextLength, ciphertextSha256: context.recording.ciphertextSha256,
               startedAtMs: context.recording.startedAtMs, durationMs: context.recording.durationMs,
-              plaintextLength: context.recording.plaintextLength, storageFormat: context.recording.storageFormat },
+              plaintextLength: context.recording.plaintextLength, storageFormat: context.recording.storageFormat,
+              ...(context.recording.markersRequired ? { markersRequired: true } : {}) },
             capability: { rawValueHex: context.capability.rawValueHex, flags: context.capability.flags },
             ...(context.checkpoint === undefined ? {} : { checkpoint: {
               version: context.checkpoint.version, uploadSessionId: context.checkpoint.uploadSessionId,

package/src/index.ts

@@ -1,3 +1,5 @@
+import { createManagedProtectedStreamingStatusBackend } from './protectedStreamingStatus';
+import type { ProtectedStreamingStatusBackendOptions } from './protectedStreamingStatus';
 import NativeBotaDeviceSDK from './specs/NativeBotaDeviceSDK';
 import { createBotaDeviceSDK } from './client';
 import NativeBotaUploadV2Backend from './specs/NativeBotaUploadV2Backend';
@@ -58,6 +60,10 @@ export const BotaDeviceSDK = createBotaDeviceSDK(NativeBotaDeviceSDK);
 export const createEncryptedUploadV2Backend = (options: EncryptedUploadV2BackendOptions) =>
   createManagedEncryptedUploadV2Backend(NativeBotaUploadV2Backend, BotaDeviceSDK.recordings, options);
 export type { EncryptedUploadV2BackendOptions, EncryptedUploadV2Backend, EncryptedUploadV2SyncTarget } from './encryptedUploadV2Backend';
+export const createProtectedStreamingStatusBackend = (options: ProtectedStreamingStatusBackendOptions) =>
+  createManagedProtectedStreamingStatusBackend(NativeBotaUploadV2Backend, options);
+export type { ProtectedStreamingIdentity, ProtectedStreamingStatus, ProtectedStreamingStatusBackend,
+  ProtectedStreamingStatusBackendOptions } from './protectedStreamingStatus';
 setDefaultCompatibilityClient(BotaDeviceSDK);
 
 export { BotaClient } from './BotaClient';
@@ -168,3 +174,8 @@ export type {
   SyncStatus,
   SyncStatusInputs,
 } from './sync/syncStatus';
+
+export type { ByoStorageBackendOptions, ByoStorageBackend, ByoRecording, ByoSyncTarget, ByoUploadResult } from './byoStorageBackend';
+import { createManagedByoStorageBackend, type ByoStorageBackendOptions } from './byoStorageBackend';
+export const createByoStorageBackend = (options: ByoStorageBackendOptions) =>
+  createManagedByoStorageBackend(NativeBotaUploadV2Backend, options);

package/src/managers/DeviceManager.ts

@@ -631,6 +631,12 @@ export class DeviceManager extends EventEmitter<DeviceManagerEvents> {
     }
   }
 
+  /** Stop automatic retries and wait for reconnect attempts already submitted. */
+  pauseAutoReconnect(): Promise<void> {
+    this.disableAutoReconnect();
+    return this.reconnectChain.then(() => undefined);
+  }
+
   onCachedDeviceStateChanged(
     listener: (
       serialNumber: string,

package/src/managers/NativeUploadQueue.ts

@@ -3,6 +3,7 @@ import type { BotaDeviceSDKRecordingClient, BotaRecordingTransferProgress } from
 import type { UploadInfo, UploadRecoveryProvider, UploadTask } from '../models/Recording';
 import type { RecordingManagerEvents } from '../models/Status';
 import { persistedUploadQueue, restoreUploadQueue } from './uploadRecoveryMetadata';
+import { UploadVerificationPendingError } from './uploadVerificationPending';
 
 const journalOperations = new WeakMap<object, Promise<unknown>>();
 const journalOwners = new WeakMap<object, NativeUploadQueue>();
@@ -149,10 +150,10 @@ export class NativeUploadQueue extends EventEmitter<RecordingManagerEvents> {
       initialSignal?.addEventListener('abort', initialAbort, { once: true });
       if (initialSignal?.aborted) initialAbort();
       check();
-      if (info && !info.alreadyUploaded && this.provider && !info.signal?.aborted && (
+      if (info && this.provider && !info.signal?.aborted && (task.completionPending || (!info.alreadyUploaded && (
         !(info.relay ? info.relay.url : info.uploadUrl) ||
         (info.expiresAt && info.expiresAt.getTime() <= Date.now())
-      )) {
+      )))) {
         dispose(info);
         info = undefined;
       }
@@ -165,6 +166,7 @@ export class NativeUploadQueue extends EventEmitter<RecordingManagerEvents> {
             recordingUuid: task.recordingUuid!, recoveryScope: task.recoveryScope,
             fileSizeBytes: task.fileSizeBytes, relayUpload: !!task.relayUpload,
             contentType: task.contentType, contentSha256: task.contentSha256, signal,
+            completionPending: task.completionPending,
           });
         }), signal, dispose);
       }
@@ -176,17 +178,21 @@ export class NativeUploadQueue extends EventEmitter<RecordingManagerEvents> {
       if (info.recordingId !== task.recordingId || info.recoveryScope !== task.recoveryScope) {
         throw new Error('Upload recovery identity changed');
       }
-      if (!info.alreadyUploaded && !!info.relay !== !!task.relayUpload) throw new Error('Upload recovery route changed');
+      const uploadRequired = !info.alreadyUploaded && (!task.completionPending || info.reuploadRequired === true);
+      if (uploadRequired && !!info.relay !== !!task.relayUpload) throw new Error('Upload recovery route changed');
+      if (task.completionPending && !info.complete) throw new Error('Pending upload requires durable host completion acknowledgement');
       hostAbort = () => attempt.controller.abort();
       info.signal?.addEventListener('abort', hostAbort, { once: true });
       if (info.signal?.aborted) hostAbort();
       check();
-      if (info.expiresAt && info.expiresAt.getTime() <= Date.now() && !info.alreadyUploaded) throw new Error('Upload credentials expired');
+      if (info.expiresAt && info.expiresAt.getTime() <= Date.now() && uploadRequired) throw new Error('Upload credentials expired');
       await this.update(id, { status: 'uploading', errorMessage: undefined, nextAttemptAt: undefined }, check);
       check();
       this.emit('uploadStarted', id);
       check();
-      if (!info.alreadyUploaded) {
+      if (uploadRequired) {
+        if (task.completionPending) await this.update(id, { completionPending: false }, check);
+        check();
         nativeStarted = true;
         await this.client.uploadRecordingFile({
           ...task, id: attempt.nativeId, uploadUrl: info.uploadUrl,
@@ -203,6 +209,8 @@ export class NativeUploadQueue extends EventEmitter<RecordingManagerEvents> {
       }
       if (info.complete) {
         if (task.fileSizeBytes === undefined) throw new Error('Upload completion requires known file size');
+        await this.update(id, { completionPending: true }, check);
+        check();
         await abortable(Promise.resolve().then(() => {
           check();
           return info!.complete!({ fileSizeBytes: task.fileSizeBytes!, contentSha256: task.contentSha256, signal });
@@ -211,7 +219,7 @@ export class NativeUploadQueue extends EventEmitter<RecordingManagerEvents> {
         throw new Error('Recoverable upload requires durable host completion acknowledgement');
       }
       check();
-      await this.update(id, { status: 'completed', errorMessage: undefined, nextAttemptAt: undefined }, check);
+      await this.update(id, { status: 'completed', completionPending: undefined, errorMessage: undefined, nextAttemptAt: undefined }, check);
       check();
       await this.release(this.get(id)!).catch(() => undefined);
       check();
@@ -219,15 +227,16 @@ export class NativeUploadQueue extends EventEmitter<RecordingManagerEvents> {
     } catch (error) {
       if (!this.destroyed && !this.cancelledTasks.has(id) && this.get(id)?.status !== 'completed') {
         const task = this.get(id)!;
-        const parked = info === null || signal.aborted;
+        const verificationPending = error instanceof UploadVerificationPendingError;
+        const parked = info === null || signal.aborted || verificationPending;
         const retry = !!this.provider && task.retryCount < 6 && Date.now() - task.createdAt.getTime() < 86_400_000;
         await this.update(id, {
           status: parked || retry ? 'pending' : 'failed',
           retryCount: task.retryCount + (parked ? 0 : 1),
           nextAttemptAt: parked ? Date.now() + 30_000 : retry ? Date.now() + retryDelays[Math.min(task.retryCount, 4)] : undefined,
-          errorMessage: parked ? 'Upload waiting for its original account' : 'Upload attempt failed',
+          errorMessage: verificationPending ? 'Upload verification pending' : parked ? 'Upload waiting for its original account' : 'Upload attempt failed',
         }).catch(() => { this.pause(); });
-        if (!this.destroyed) this.emit('uploadFailed', id, new Error(parked ? 'Upload paused' : 'Upload attempt failed'));
+        if (!this.destroyed) this.emit('uploadFailed', id, new Error(verificationPending ? 'Upload verification pending' : parked ? 'Upload paused' : 'Upload attempt failed'));
       }
       throw error;
     } finally {

package/src/managers/uploadRecoveryMetadata.ts

@@ -20,6 +20,7 @@ export function persistedUploadQueue(tasks: UploadTask[]): UploadTask[] {
     ...(task.nextAttemptAt === undefined ? {} : { nextAttemptAt: task.nextAttemptAt }),
     ...(task.contentType === undefined ? {} : { contentType: task.contentType }),
     ...(task.contentSha256 === undefined ? {} : { contentSha256: task.contentSha256 }),
+    ...(task.completionPending === undefined ? {} : { completionPending: task.completionPending }),
     relayUpload: task.relayUpload ?? !!task.relay,
   }));
 }
@@ -44,6 +45,7 @@ export function restoreUploadQueue(value: unknown): UploadTask[] {
       if (task[field] !== undefined && (!Number.isSafeInteger(task[field]) || task[field]! < 0)) return invalid();
     }
     if (task.relayUpload !== undefined && typeof task.relayUpload !== 'boolean') return invalid();
+    if (task.completionPending !== undefined && typeof task.completionPending !== 'boolean') return invalid();
     const createdAt = new Date(task.createdAt);
     const updatedAt = new Date(task.updatedAt);
     if (!Number.isFinite(createdAt.getTime()) || !Number.isFinite(updatedAt.getTime())) return invalid();

package/src/managers/uploadVerificationPending.ts

@@ -0,0 +1,10 @@
+/** Internal completion-budget signal; it is never acknowledgement or repair. */
+export class UploadVerificationPendingError extends Error {
+  constructor() { super('Upload verification pending'); }
+}
+
+export function isUploadVerificationPending(error: unknown): boolean {
+  if (!error || typeof error !== 'object') return false;
+  const value = error as { status?: unknown; data?: { error?: { code?: unknown } } };
+  return value.status === 425 && value.data?.error?.code === 'upload_verification_pending';
+}

package/src/models/Recording.ts

@@ -34,6 +34,8 @@ export interface UploadInfo {
   recoveryScope?: string;
   /** Skip sending the object; complete must still acknowledge host durability. */
   alreadyUploaded?: boolean;
+  /** Explicit authenticated integrity failure permits repair of a completion-pending object. */
+  reuploadRequired?: boolean;
   /** Resolve only after the backend durably acknowledges this exact recording. */
   complete?: (context: {
     fileSizeBytes: number;
@@ -92,6 +94,8 @@ export interface UploadRecoveryContext {
   relayUpload: boolean;
   contentType?: string;
   contentSha256?: string;
+  /** Bytes were sent; recover completion before considering another upload. Not verification proof. */
+  completionPending?: boolean;
   signal: AbortSignal;
 }
 
@@ -152,6 +156,8 @@ export interface UploadTask {
   fileSizeBytes?: number;
   relayUpload?: boolean;
   nextAttemptAt?: number;
+  /** Durable byte-upload completion; backend acknowledgement and cleanup are still required. */
+  completionPending?: boolean;
   /** Volatile compatibility field; never included in queue persistence. */
   complete?: UploadInfo['complete'];
   /** Unique task identifier */

package/src/protectedStreamingStatus.ts

@@ -0,0 +1,137 @@
+import type { Spec } from './specs/NativeBotaUploadV2Backend';
+
+/** Read-only protected STREAMING metadata. None of these values authorize cleanup. */
+export interface ProtectedStreamingIdentity {
+  recordingId: string;
+  sessionId: string;
+  recordingGeneration: number;
+  /** Canonical positive int64 decimal; never convert through a JS number. */
+  writerEpoch: string;
+}
+
+export interface ProtectedStreamingStatus extends ProtectedStreamingIdentity {
+  profile: 'recording_markers_stream_v1';
+  /** Canonical nonnegative int64 decimal; a newly admitted stream starts at zero. */
+  revision: string;
+  receivedCount: number;
+  contiguousSequence: number;
+  /** Marker metadata state, independent from audio completion or publication. */
+  state: 'open' | 'sealing' | 'sealed' | 'aborted';
+  expectedCount: number | null;
+  authorizationExpired: boolean;
+}
+
+export interface ProtectedStreamingStatusBackendOptions {
+  /** Scoped read proxy, e.g. https://api.example/dashboard/projects/proj_123. */
+  baseUrl: string;
+  organizationId?: string;
+  /** Permanently abort on logout, account/project/environment or binding change. */
+  signal: AbortSignal;
+  /** Fresh application read credential. Never embed a secret API key in an App. */
+  getAccessToken(signal: AbortSignal): Promise<string>;
+}
+
+export interface ProtectedStreamingStatusBackend {
+  /** Requires an exact known session/owner; does not select a newer owner implicitly. */
+  getStatus(identity: ProtectedStreamingIdentity, signal?: AbortSignal): Promise<ProtectedStreamingStatus>;
+  dispose(): void;
+}
+
+const decimal = (value: unknown): value is string => typeof value === 'string' &&
+  /^(0|[1-9][0-9]{0,18})$/.test(value) && BigInt(value) <= 9223372036854775807n;
+const count = (value: unknown): value is number => typeof value === 'number' &&
+  Number.isInteger(value) && value >= 0 && value <= 65535;
+const generation = (value: unknown): value is number => typeof value === 'number' &&
+  Number.isInteger(value) && value >= 1 && value <= 4294967295;
+const uuid = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/;
+const keys = ['profile', 'recording_id', 'session_id', 'recording_generation', 'writer_epoch', 'revision',
+  'received_count', 'contiguous_sequence', 'state', 'expected_count', 'authorization_expired'];
+
+function decode(value: unknown, identity: ProtectedStreamingIdentity): ProtectedStreamingStatus {
+  const invalid = () => new Error('Invalid protected streaming status response');
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw invalid();
+  const v = value as Record<string, unknown>;
+  if (Object.keys(v).length !== keys.length || keys.some(key => !Object.prototype.hasOwnProperty.call(v, key)) ||
+    v.profile !== 'recording_markers_stream_v1' || v.recording_id !== identity.recordingId ||
+    v.session_id !== identity.sessionId || v.recording_generation !== identity.recordingGeneration ||
+    v.writer_epoch !== identity.writerEpoch || !decimal(v.revision) || !count(v.received_count) ||
+    !count(v.contiguous_sequence) || v.contiguous_sequence > v.received_count ||
+    !['open', 'sealing', 'sealed', 'aborted'].includes(v.state as string) ||
+    (v.expected_count !== null && (!count(v.expected_count) || v.expected_count < v.received_count)) ||
+    (v.state === 'open' && v.expected_count !== null) ||
+    ((v.state === 'sealing' || v.state === 'sealed') && v.expected_count === null) ||
+    (v.state === 'sealed' && (v.expected_count !== v.received_count || v.contiguous_sequence !== v.received_count)) ||
+    typeof v.authorization_expired !== 'boolean') throw invalid();
+  return { ...identity, profile: v.profile, revision: v.revision, receivedCount: v.received_count,
+    contiguousSequence: v.contiguous_sequence, state: v.state as ProtectedStreamingStatus['state'],
+    expectedCount: v.expected_count as number | null, authorizationExpired: v.authorization_expired };
+}
+
+/** Public read provider. Protected START/relay and signed ACKs remain native-only. */
+export function createManagedProtectedStreamingStatusBackend(native: Pick<Spec, 'readProtectedStreamingStatus' | 'cancelProtectedStreamingStatus'> | null, options: ProtectedStreamingStatusBackendOptions): ProtectedStreamingStatusBackend {
+  const config = { ...options };
+  const url = new URL(config.baseUrl);
+  const path = url.pathname.replace(/\/$/, '');
+  if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash ||
+    !/^(\/[A-Za-z0-9_-]+)+$/.test(path) || !config.signal || typeof config.getAccessToken !== 'function' ||
+    (config.organizationId !== undefined && !/^[A-Za-z0-9_-]{1,128}$/.test(config.organizationId))) {
+    throw new Error('Invalid protected streaming status configuration');
+  }
+  const baseUrl = `${url.origin}${path}`;
+  const active = new Set<AbortController>();
+  let requestSequence = 0;
+  const instance = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  let disposed = false;
+  return {
+    async getStatus(request, callerSignal) {
+      const identity = { recordingId: request.recordingId, sessionId: request.sessionId,
+        recordingGeneration: request.recordingGeneration, writerEpoch: request.writerEpoch };
+      if (!/^rec_[A-Za-z0-9_-]{1,128}$/.test(identity.recordingId) || !uuid.test(identity.sessionId) ||
+        !generation(identity.recordingGeneration) || !decimal(identity.writerEpoch) || identity.writerEpoch === '0') {
+        throw new Error('Invalid protected streaming identity');
+      }
+      if (!native?.readProtectedStreamingStatus) throw new Error('Protected streaming status requires the matching native SDK binary');
+      const controller = new AbortController();
+      const requestId = `${instance}-${++requestSequence}`;
+      let dispatched = false;
+      const cancel = () => controller.abort();
+      controller.signal.addEventListener('abort', () => { if (dispatched) void native.cancelProtectedStreamingStatus(requestId).catch(() => {}); }, { once: true });
+      const check = () => {
+        if (disposed || config.signal.aborted || callerSignal?.aborted || controller.signal.aborted) {
+          throw new Error('Protected streaming status cancelled');
+        }
+      };
+      active.add(controller);
+      config.signal.addEventListener('abort', cancel, { once: true });
+      callerSignal?.addEventListener('abort', cancel, { once: true });
+      try {
+        check();
+        const token = await config.getAccessToken(controller.signal);
+        check();
+        if (typeof token !== 'string' || !/^[!-~]{1,16384}$/.test(token)) {
+          throw new Error('Invalid protected streaming credentials');
+        }
+        const requestUrl = `${baseUrl}/recordings/${identity.recordingId}/streaming-status?session_id=${identity.sessionId}`;
+        let body: string;
+        try {
+          dispatched = true;
+          body = await native.readProtectedStreamingStatus(requestId, JSON.stringify({ url: requestUrl,
+            token, organizationId: config.organizationId ?? '' }));
+        } catch {
+          check();
+          throw new Error('Protected streaming status request failed');
+        }
+        check();
+        if (body.length > 16384) throw new Error('Invalid protected streaming status response');
+        let value: unknown;
+        try { value = JSON.parse(body); } catch { throw new Error('Invalid protected streaming status response'); }
+        return decode(value, identity);
+      } finally {
+        active.delete(controller);
+        config.signal.removeEventListener('abort', cancel);
+        callerSignal?.removeEventListener('abort', cancel);
+      }
+    },
+    dispose() { disposed = true; for (const controller of active) controller.abort(); },
+  };
+}

package/src/sdkIdentity.ts

@@ -1,3 +1,3 @@
 // Generated by cargo xtask client-identity generate. Do not edit.
 export const SDK_PACKAGE = '@bota.dev/react-native-app-sdk'
-export const SDK_VERSION = '2.0.0-beta.13'
+export const SDK_VERSION = '2.0.0-beta.15'

package/src/specs/NativeBotaDeviceSDK.ts

@@ -160,6 +160,7 @@ export type NativeEncryptedUploadV2Recording = {
   durationMs?: string;
   plaintextLength?: string;
   storageFormat?: number;
+  markersRequired?: boolean;
 };
 
 export type NativePendingRecording = {

package/src/specs/NativeBotaUploadV2Backend.ts

@@ -9,6 +9,10 @@ export interface Spec extends TurboModule {
     requestId: string;
     operationId: string;
   }>;
+  syncByo: (inputJSON: string) => Promise<string>;
+  cancelByo: (operationId: string) => Promise<void>;
+  readProtectedStreamingStatus: (requestId: string, inputJSON: string) => Promise<string>;
+  cancelProtectedStreamingStatus: (requestId: string) => Promise<void>;
   prepare: (inputJSON: string) => Promise<string>;
   cancel: (operationId: string) => Promise<void>;
   complete: (operationId: string) => Promise<void>;

package/src/uploadRecovery.ts

@@ -1,4 +1,15 @@
 import type { UploadInfo, UploadRecoveryContext, UploadRecoveryProvider } from './models/Recording';
+import { isUploadVerificationPending, UploadVerificationPendingError } from './managers/uploadVerificationPending';
+
+const waitForCompletion = (milliseconds: number, signals: AbortSignal[]): Promise<void> =>
+  new Promise((resolve, reject) => {
+    const unique = [...new Set(signals)];
+    const clean = () => { clearTimeout(timer); unique.forEach(signal => signal.removeEventListener('abort', abort)); };
+    const abort = () => { clean(); reject(new Error('Upload recovery cancelled')); };
+    const timer = setTimeout(() => { clean(); resolve(); }, milliseconds);
+    unique.forEach(signal => signal.addEventListener('abort', abort, { once: true }));
+    if (unique.some(signal => signal.aborted)) abort();
+  });
 
 /** A host-owned, authenticated lease. It must permanently reject changed identities. */
 export interface UploadRecoveryBackend {
@@ -8,7 +19,7 @@ export interface UploadRecoveryBackend {
   dispose(): void;
   getRecording(id: string, signal: AbortSignal): Promise<{
     id: string; status: string; metadata?: Record<string, unknown>;
-    content_sha256?: string | null; file_size_bytes?: number | null;
+    content_sha256?: string | null; file_size_bytes?: number | string | null;
   }>;
   getUploadInfo(id: string, relay: boolean, contentType: string | undefined, signal: AbortSignal): Promise<Pick<UploadInfo, 'uploadUrl' | 'relay' | 'contentType'>>;
   completeRecording(id: string, data: { duration_seconds?: number; file_size_bytes: number; content_sha256?: string }, signal: AbortSignal): Promise<unknown>;
@@ -36,26 +47,49 @@ export function createUploadRecoveryProvider(
       check();
       const recording = await api.getRecording(task.recordingId, task.signal);
       check();
+      const wireSize = recording.file_size_bytes;
+      if (typeof wireSize === 'string' && !/^(0|[1-9][0-9]*)$/.test(wireSize)) throw new Error('Invalid upload recovery file size');
+      const fileSize = typeof wireSize === 'string' ? Number(wireSize) : wireSize;
+      if (fileSize != null && (typeof fileSize !== 'number' || !Number.isSafeInteger(fileSize) || fileSize < 0)) {
+        throw new Error('Invalid upload recovery file size');
+      }
       if (recording.id !== task.recordingId || (!task.relayUpload && (
         (task.contentSha256 && recording.content_sha256 && task.contentSha256 !== recording.content_sha256) ||
-        (task.fileSizeBytes !== undefined && recording.file_size_bytes != null && task.fileSizeBytes !== recording.file_size_bytes)
+        (task.fileSizeBytes !== undefined && fileSize != null && task.fileSizeBytes !== fileSize)
       ))) throw new Error('Upload recovery identity or evidence changed');
       if (!['pending', 'uploaded', 'integrity_failure'].includes(recording.status)) throw new Error('Recording unavailable for recovery');
       const start = Date.parse(String(recording.metadata?.started_at ?? ''));
       const end = Date.parse(String(recording.metadata?.ended_at ?? ''));
       const duration = Number.isFinite(start) && Number.isFinite(end) && end >= start ? Math.floor((end - start) / 1000) : undefined;
-      const target = recording.status === 'uploaded' ? { uploadUrl: '' }
+      const alreadyUploaded = recording.status === 'uploaded' || (task.completionPending === true && recording.status === 'pending');
+      const target = alreadyUploaded ? { uploadUrl: '' }
         : await api.getUploadInfo(task.recordingId, task.relayUpload, task.contentType, task.signal);
       check();
       return {
         ...target, recordingId: task.recordingId, recoveryScope: task.recoveryScope,
-        alreadyUploaded: recording.status === 'uploaded', signal: api.signal, dispose: () => api.dispose(),
+        alreadyUploaded, reuploadRequired: recording.status === 'integrity_failure',
+        signal: api.signal, dispose: () => api.dispose(),
         complete: async ({ fileSizeBytes, contentSha256, signal }) => {
-          check(signal);
-          await api.completeRecording(task.recordingId, {
+          const data = {
             duration_seconds: duration, file_size_bytes: fileSizeBytes, content_sha256: contentSha256,
-          }, signal);
-          check(signal);
+          };
+          const deadline = Date.now() + 120_000;
+          for (let poll = 0; ; poll++) {
+            check(signal);
+            if (poll > 0 && (Date.now() >= deadline || poll >= 120)) throw new UploadVerificationPendingError();
+            try {
+              await api.completeRecording(task.recordingId, data, signal);
+              check(signal);
+              return;
+            } catch (error) {
+              check(signal);
+              if (!isUploadVerificationPending(error)) throw error;
+              const remaining = deadline - Date.now();
+              if (remaining <= 0) throw new UploadVerificationPendingError();
+              await waitForCompletion(Math.min(1_000 + Math.floor(Math.random() * 1_000), remaining),
+                [signal, task.signal, api.signal]);
+            }
+          }
         },
       };
     } catch {