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

package/src/managers/RecordingManager.ts

@@ -16,7 +16,9 @@ import type {
   UploadTask,
 } from '../models/Recording';
 import type { RecordingManagerEvents } from '../models/Status';
-import type { UploadInfoProvider } from './types';
+import type { RecordingManagerOptions, UploadInfoProvider } from './types';
+import { NativeUploadQueue } from './NativeUploadQueue';
+import { rejectRecordingDataStore } from './uploadRecoveryMetadata';
 import {
   StreamingSession,
   setStreamingSessionTerminalHandler,
@@ -85,26 +87,30 @@ const observeProgress = <T>(
 
 export class RecordingManager extends EventEmitter<RecordingManagerEvents> {
   private readonly client: BotaDeviceSDKClient;
-  private tasks: UploadTask[] = [];
+  private readonly queue: NativeUploadQueue;
   private initialized = false;
-  private paused = false;
   private destroyed = false;
   private activeStreamingSession: StreamingSession | null = null;
 
-  constructor() {
+  constructor();
+  constructor(options: RecordingManagerOptions);
+  constructor(options: RecordingManagerOptions = {}) {
     super();
+    rejectRecordingDataStore(options.recordingDataStore);
     this.client = getCompatibilityClient();
+    this.queue = new NativeUploadQueue(this.client.recordings, options.uploadRecoveryProvider);
+    this.queue.on('queueUpdated', tasks => this.emit('queueUpdated', tasks));
+    this.queue.on('uploadStarted', id => this.emit('uploadStarted', id));
+    this.queue.on('uploadProgress', (id, progress) => this.emit('uploadProgress', id, progress));
+    this.queue.on('uploadCompleted', (id, recordingId) => this.emit('uploadCompleted', id, recordingId));
+    this.queue.on('uploadFailed', (id, error) => this.emit('uploadFailed', id, error));
   }
 
   async initialize(): Promise<void> {
     if (this.initialized) return;
     this.assertAlive();
-    this.tasks = (await this.client.recordings.loadUploadQueue()).map((task) => ({
-      ...task,
-      createdAt: new Date(task.createdAt),
-      updatedAt: new Date(task.updatedAt),
-      status: task.status === 'uploading' ? 'pending' : task.status,
-    }));
+    await this.queue.initialize();
+    this.assertAlive();
     this.initialized = true;
   }
 
@@ -133,6 +139,10 @@ export class RecordingManager extends EventEmitter<RecordingManagerEvents> {
     uploadInfo: UploadInfo
   ): AsyncGenerator<SyncProgress> {
     this.assertReady();
+    if (uploadInfo.signal?.aborted) {
+      uploadInfo.dispose?.();
+      throw new Error('Upload authorization context cancelled');
+    }
     this.emit('syncStarted', recording.uuid);
     const sinkId = createOpaqueId();
     const now = new Date();
@@ -140,6 +150,9 @@ export class RecordingManager extends EventEmitter<RecordingManagerEvents> {
       id: createTaskId(),
       recordingId: uploadInfo.recordingId,
       deviceId: device.id,
+      recordingUuid: recording.uuid,
+      recoveryScope: uploadInfo.recoveryScope,
+      fileSizeBytes: recording.fileSizeBytes,
       localPath: '',
       uploadUrl: uploadInfo.uploadUrl,
       ...(uploadInfo.uploadToken ? { uploadToken: uploadInfo.uploadToken } : {}),
@@ -150,10 +163,33 @@ export class RecordingManager extends EventEmitter<RecordingManagerEvents> {
       createdAt: now,
       updatedAt: now,
     };
-    this.tasks.push(task);
-    await this.persistTasks();
-    this.emitQueueUpdated();
+    const recovered = uploadInfo.recoveryScope && this.queue.all().find(value =>
+      value.recoveryScope === uploadInfo.recoveryScope && value.recordingId === uploadInfo.recordingId &&
+      value.deviceId === device.id && value.recordingUuid === recording.uuid && !!value.localPath
+    );
+    if (recovered) {
+      const adopted = this.queue.offerCredentials(recovered.id, uploadInfo);
+      try {
+        await this.queue.run(recovered.id);
+        this.assertReady();
+        if (uploadInfo.signal?.aborted) throw new Error('Upload authorization context cancelled');
+        await this.client.recordings.confirmRecording(device, recording.uuid);
+        this.assertReady();
+        yield this.emitSyncProgress(recording.uuid, { stage: 'completed', progress: 1, recordingId: recovered.recordingId, contentSha256: recovered.contentSha256 });
+        this.emit('syncCompleted', recording.uuid, recovered.recordingId);
+      } finally {
+        if (!adopted) uploadInfo.dispose?.();
+      }
+      return;
+    }
+    try {
+      await this.queue.add(task, uploadInfo);
+    } catch (error) {
+      uploadInfo.dispose?.();
+      throw error;
+    }
 
+    let uploadAttempted = false;
     try {
       yield this.emitSyncProgress(recording.uuid, {
         stage: 'preparing',
@@ -193,10 +229,19 @@ export class RecordingManager extends EventEmitter<RecordingManagerEvents> {
           'Device delivered encrypted recording data without an upload relay'
         );
       }
-      await this.updateTask(task.id, {
+      this.assertReady();
+      if (uploadInfo.signal?.aborted || !this.queue.get(task.id)) throw new Error('Upload cancelled');
+      const nativeSize = 'fileSizeBytes' in transferResult && typeof transferResult.fileSizeBytes === 'number'
+        ? transferResult.fileSizeBytes : undefined;
+      if (nativeSize !== undefined && (!Number.isSafeInteger(nativeSize) || nativeSize < 0)) throw new Error('Invalid native recording file size');
+      if (nativeSize === undefined && uploadInfo.complete) throw new Error('Host completion requires actual native recording file size');
+      // Route selection comes from native transfer metadata, never list flags.
+      uploadInfo = { ...uploadInfo, relay: transferResult.e2eEncrypted ? uploadInfo.relay : undefined };
+      await this.queue.update(task.id, {
         localPath: transferResult.localPath,
+        fileSizeBytes: nativeSize ?? (transferResult.e2eEncrypted ? undefined : recording.fileSizeBytes),
         contentSha256: transferResult.contentSha256,
-        relay: transferResult.e2eEncrypted ? uploadInfo.relay : undefined,
+        relayUpload: transferResult.e2eEncrypted,
       });
 
       yield this.emitSyncProgress(recording.uuid, {
@@ -206,8 +251,9 @@ export class RecordingManager extends EventEmitter<RecordingManagerEvents> {
         totalBytes: recording.fileSizeBytes,
         contentSha256: transferResult.contentSha256,
       });
+      uploadAttempted = true;
       const upload = observeProgress((onProgress) =>
-        this.runUpload(task.id, onProgress)
+        this.queue.run(task.id, onProgress)
       );
       while (true) {
         const value = await upload.next();
@@ -228,7 +274,10 @@ export class RecordingManager extends EventEmitter<RecordingManagerEvents> {
         stage: 'completing',
         progress: 0.5,
       });
+      this.assertReady();
+      if (uploadInfo.signal?.aborted || !this.queue.get(task.id)) throw new Error('Upload cancelled');
       await this.client.recordings.confirmRecording(device, recording.uuid);
+      this.assertReady();
       const completed = this.emitSyncProgress(recording.uuid, {
         stage: 'completed',
         progress: 1,
@@ -239,12 +288,13 @@ export class RecordingManager extends EventEmitter<RecordingManagerEvents> {
       this.emit('syncCompleted', recording.uuid, uploadInfo.recordingId);
     } catch (error) {
       const failure = error instanceof Error ? error : new Error(String(error));
-      if (this.requireTask(task.id).status !== 'completed') {
-        await this.updateTask(task.id, {
+      if (!this.destroyed && this.queue.get(task.id)?.status === 'pending' && !this.queue.get(task.id)?.localPath) {
+        await this.queue.update(task.id, {
           status: 'failed',
-          errorMessage: failure.message,
+          errorMessage: 'Recording transfer failed',
         });
       }
+      if (this.destroyed) throw failure;
       yield this.emitSyncProgress(recording.uuid, {
         stage: 'failed',
         progress: 0,
@@ -252,6 +302,8 @@ export class RecordingManager extends EventEmitter<RecordingManagerEvents> {
       });
       this.emit('syncFailed', recording.uuid, failure);
       throw failure;
+    } finally {
+      if (!uploadAttempted) this.queue.discardCredentials(task.id);
     }
   }
 
@@ -392,13 +444,13 @@ export class RecordingManager extends EventEmitter<RecordingManagerEvents> {
   }
 
   getPendingUploads(): UploadTask[] {
-    return this.tasks.filter(
+    return this.queue.all().filter(
       (task) => task.status === 'pending' || task.status === 'uploading'
     );
   }
 
   getAllUploads(): UploadTask[] {
-    return this.tasks.map((task) => ({ ...task }));
+    return this.queue.all();
   }
 
   startStreamingSync(
@@ -435,99 +487,43 @@ export class RecordingManager extends EventEmitter<RecordingManagerEvents> {
   }
 
   async cancelUpload(taskId: string): Promise<void> {
-    await this.client.recordings.cancelRecordingUpload(taskId);
-    this.tasks = this.tasks.filter((task) => task.id !== taskId);
-    await this.persistTasks();
-    this.emitQueueUpdated();
+    this.assertReady();
+    await this.queue.cancel(taskId);
   }
 
   async retryFailedUploads(): Promise<void> {
     this.assertReady();
-    if (this.paused) return;
-    for (const task of this.tasks.filter((value) => value.status === 'failed')) {
-      await this.updateTask(task.id, {
-        status: 'pending',
-        retryCount: task.retryCount + 1,
-        errorMessage: undefined,
-      });
-      try {
-        await this.runUpload(task.id);
-      } catch {
-        // Keep failed tasks available for the next explicit retry.
-      }
-    }
+    await this.queue.retryFailed();
   }
 
   async clearCompletedUploads(): Promise<void> {
-    this.tasks = this.tasks.filter((task) => task.status !== 'completed');
-    await this.persistTasks();
-    this.emitQueueUpdated();
+    this.assertReady();
+    await this.queue.clearCompleted();
   }
 
   async clearAllUploads(): Promise<void> {
-    const ids = this.tasks.map((task) => task.id);
-    await Promise.all(
-      ids.map((taskId) =>
-        this.client.recordings.cancelRecordingUpload(taskId).catch(() => undefined)
-      )
-    );
-    this.tasks = [];
-    await this.persistTasks();
-    this.emitQueueUpdated();
+    this.assertReady();
+    await this.queue.clearAll();
   }
 
   pauseUploads(): void {
-    this.paused = true;
+    this.queue.pause();
   }
 
   resumeUploads(): void {
-    this.paused = false;
-    void this.retryFailedUploads();
+    this.queue.resume();
   }
 
   destroy(): void {
     if (this.destroyed) return;
     this.destroyed = true;
+    this.queue.destroy();
     this.activeStreamingSession?.abort();
     this.activeStreamingSession = null;
-    void this.client.recordings.destroyCompatibilityOperations().catch(() => undefined);
     this.removeAllListeners();
     this.initialized = false;
   }
 
-  private async runUpload(
-    taskId: string,
-    onProgress?: (progress: BotaRecordingTransferProgress) => void
-  ): Promise<void> {
-    if (this.paused) throw new Error('Upload queue is paused');
-    const task = this.requireTask(taskId);
-    await this.updateTask(taskId, { status: 'uploading', errorMessage: undefined });
-    this.emit('uploadStarted', taskId);
-    try {
-      await this.client.recordings.uploadRecordingFile(
-        this.requireTask(taskId),
-        (progress) => {
-          onProgress?.(progress);
-          const ratio =
-            progress.totalBytes > 0
-              ? Math.min(progress.completedBytes / progress.totalBytes, 1)
-              : 0;
-          this.emit('uploadProgress', taskId, ratio);
-        }
-      );
-      await this.updateTask(taskId, { status: 'completed', errorMessage: undefined });
-      this.emit('uploadCompleted', taskId, task.recordingId);
-    } catch (error) {
-      const failure = error instanceof Error ? error : new Error(String(error));
-      await this.updateTask(taskId, {
-        status: 'failed',
-        errorMessage: failure.message,
-      });
-      this.emit('uploadFailed', taskId, failure);
-      throw failure;
-    }
-  }
-
   private emitSyncProgress(
     recordingUuid: string,
     progress: SyncProgress
@@ -536,35 +532,6 @@ export class RecordingManager extends EventEmitter<RecordingManagerEvents> {
     return progress;
   }
 
-  private requireTask(taskId: string): UploadTask {
-    const task = this.tasks.find((value) => value.id === taskId);
-    if (!task) throw new Error(`Upload task not found: ${taskId}`);
-    return task;
-  }
-
-  private async updateTask(
-    taskId: string,
-    patch: Partial<UploadTask>
-  ): Promise<void> {
-    const index = this.tasks.findIndex((task) => task.id === taskId);
-    if (index < 0) throw new Error(`Upload task not found: ${taskId}`);
-    this.tasks[index] = {
-      ...this.tasks[index],
-      ...patch,
-      updatedAt: new Date(),
-    };
-    await this.persistTasks();
-    this.emitQueueUpdated();
-  }
-
-  private async persistTasks(): Promise<void> {
-    await this.client.recordings.saveUploadQueue(this.tasks);
-  }
-
-  private emitQueueUpdated(): void {
-    this.emit('queueUpdated', this.getAllUploads());
-  }
-
   private assertReady(): void {
     this.assertAlive();
     if (!this.initialized) {

package/src/managers/types.ts

@@ -1,4 +1,10 @@
-import type { DeviceRecording, UploadInfo } from '../models/Recording';
+import type { DeviceRecording, RecordingDataStore, UploadInfo, UploadRecoveryProvider } from '../models/Recording';
+
+export interface RecordingManagerOptions {
+  uploadRecoveryProvider?: UploadRecoveryProvider;
+  /** Unsupported: recording bytes remain native-owned. Configuration throws. */
+  recordingDataStore?: RecordingDataStore;
+}
 
 export type UploadInfoProvider = (
   recording: DeviceRecording

package/src/managers/uploadRecoveryMetadata.ts

@@ -0,0 +1,59 @@
+import type { UploadTask } from '../models/Recording';
+
+const invalid = (): never => { throw new Error('Invalid upload recovery journal'); };
+
+/** Whitelist, never spread a runtime object into persistent storage. */
+export function persistedUploadQueue(tasks: UploadTask[]): UploadTask[] {
+  return tasks.map((task) => ({
+    id: task.id,
+    recordingId: task.recordingId,
+    deviceId: task.deviceId,
+    localPath: task.localPath,
+    uploadUrl: '',
+    status: task.status,
+    retryCount: task.retryCount,
+    createdAt: new Date(task.createdAt),
+    updatedAt: new Date(task.updatedAt),
+    ...(task.recordingUuid === undefined ? {} : { recordingUuid: task.recordingUuid }),
+    ...(task.recoveryScope === undefined ? {} : { recoveryScope: task.recoveryScope }),
+    ...(task.fileSizeBytes === undefined ? {} : { fileSizeBytes: task.fileSizeBytes }),
+    ...(task.nextAttemptAt === undefined ? {} : { nextAttemptAt: task.nextAttemptAt }),
+    ...(task.contentType === undefined ? {} : { contentType: task.contentType }),
+    ...(task.contentSha256 === undefined ? {} : { contentSha256: task.contentSha256 }),
+    relayUpload: task.relayUpload ?? !!task.relay,
+  }));
+}
+
+export function restoreUploadQueue(value: unknown): UploadTask[] {
+  if (!Array.isArray(value)) return invalid();
+  const ids = new Set<string>();
+  const validated = value.map((entry): UploadTask => {
+    if (!entry || typeof entry !== 'object') return invalid();
+    const task = entry as UploadTask;
+    for (const field of ['id', 'recordingId', 'deviceId'] as const) {
+      if (typeof task[field] !== 'string' || !task[field]) return invalid();
+    }
+    if (typeof task.localPath !== 'string' || ids.has(task.id)) return invalid();
+    ids.add(task.id);
+    if (!['pending', 'uploading', 'failed', 'completed'].includes(task.status)) return invalid();
+    if (!Number.isSafeInteger(task.retryCount) || task.retryCount < 0) return invalid();
+    for (const field of ['recordingUuid', 'recoveryScope', 'contentType', 'contentSha256'] as const) {
+      if (task[field] !== undefined && typeof task[field] !== 'string') return invalid();
+    }
+    for (const field of ['fileSizeBytes', 'nextAttemptAt'] as const) {
+      if (task[field] !== undefined && (!Number.isSafeInteger(task[field]) || task[field]! < 0)) return invalid();
+    }
+    if (task.relayUpload !== undefined && typeof task.relayUpload !== '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();
+    return { ...task, createdAt, updatedAt, status: task.status === 'uploading' ? 'pending' : task.status };
+  });
+  return persistedUploadQueue(validated);
+}
+
+export function rejectRecordingDataStore(value: unknown): void {
+  if (value !== undefined) {
+    throw new Error('RecordingDataStore byte callbacks are unsupported; recording files are native-owned');
+  }
+}

package/src/models/Device.ts

@@ -199,6 +199,49 @@ export interface DeviceLogEvent {
   isBacklog: boolean;
 }
 
+export type DeviceDiagnosticEventType =
+  | 'reset' | 'watchdog' | 'hard_fault' | 'storage'
+  | 'power' | 'radio' | 'security';
+
+export type DeviceDiagnosticReasonCode =
+  | 'watchdog_timeout' | 'cpu_illegal_instruction'
+  | 'cpu_misaligned_access' | 'cpu_stack_overflow'
+  | 'cpu_usage_fault' | 'memory_protection_fault'
+  | 'invalid_register_read' | 'invalid_register_write'
+  | 'audio_subsystem_fault' | 'wireless_subsystem_fault'
+  | 'flash_mmu_fault' | 'low_voltage_reset'
+  | 'unknown_cpu_exception';
+
+/** A retained device fault. Reading does not acknowledge or delete it. */
+export interface DeviceDiagnosticEvent {
+  event_id: string;
+  event_type: DeviceDiagnosticEventType;
+  reason_code: DeviceDiagnosticReasonCode;
+  uptime_ms: number;
+  signature: string;
+  firmware_build_id: string;
+  subsystem: string;
+  state_before_event: string;
+  report?: {
+    fault: {
+      cpu_id: number;
+      cpu_emu: string;
+      core_emu: string;
+      hsb_emu: string;
+      audio_emu: string;
+      wireless_emu: string;
+    };
+    execution: { task?: string; reti?: string; rets?: string; pc_trace: string[] };
+    runtime?: { heap_free_bytes?: number; task_stack_remaining_bytes?: number };
+    breadcrumbs?: Array<{ delta_ms: number; code: string; arg0: number }>;
+  };
+}
+
+export interface DeviceDiagnosticsBatch {
+  schema_version: 1;
+  events: DeviceDiagnosticEvent[];
+}
+
 /**
  * Storage information from device
  */

package/src/models/Recording.ts

@@ -30,6 +30,20 @@ export interface DeviceRecording {
  * (obtained by calling customer's API, not Bota API directly)
  */
 export interface UploadInfo {
+  /** Non-secret account/project/environment identity. Must match during recovery. */
+  recoveryScope?: string;
+  /** Skip sending the object; complete must still acknowledge host durability. */
+  alreadyUploaded?: boolean;
+  /** Resolve only after the backend durably acknowledges this exact recording. */
+  complete?: (context: {
+    fileSizeBytes: number;
+    contentSha256?: string;
+    signal: AbortSignal;
+  }) => Promise<void>;
+  /** Aborted by the host when this authorization context becomes invalid. */
+  signal?: AbortSignal;
+  /** Releases host listeners/leases after the attempt, including cancellation. */
+  dispose?: () => void;
   /** Pre-signed S3 URL for upload */
   uploadUrl: string;
   /** Recording ID assigned by Bota API (rec_*) */
@@ -55,6 +69,37 @@ export interface UploadInfo {
   };
 }
 
+/** Maintenance compatibility shape only. JS byte stores are unsupported by the
+ * native-owned facade; supplying one throws before native configuration. */
+export interface RecordingDataStore {
+  saveRecordingData(input: {
+    deviceId: string;
+    recordingUuid: string;
+    data: Uint8Array;
+  }): Promise<string>;
+  loadRecordingData(localPath: string): Promise<Uint8Array>;
+  deleteRecordingData(localPath: string): Promise<void>;
+}
+
+/** Metadata only. The host must refresh credentials for this exact identity. */
+export interface UploadRecoveryContext {
+  taskId: string;
+  recordingId: string;
+  deviceId: string;
+  recordingUuid: string;
+  recoveryScope?: string;
+  fileSizeBytes?: number;
+  relayUpload: boolean;
+  contentType?: string;
+  contentSha256?: string;
+  signal: AbortSignal;
+}
+
+/** Null parks an unavailable account without consuming the retry budget. */
+export type UploadRecoveryProvider = (
+  context: UploadRecoveryContext
+) => Promise<UploadInfo | null>;
+
 /**
  * Sync progress stages
  */
@@ -102,6 +147,13 @@ export type UploadTaskStatus = 'pending' | 'uploading' | 'completed' | 'failed';
  * Upload task in the queue
  */
 export interface UploadTask {
+  recordingUuid?: string;
+  recoveryScope?: string;
+  fileSizeBytes?: number;
+  relayUpload?: boolean;
+  nextAttemptAt?: number;
+  /** Volatile compatibility field; never included in queue persistence. */
+  complete?: UploadInfo['complete'];
   /** Unique task identifier */
   id: string;
   /** Recording ID from Bota API */

package/src/models/Status.ts

@@ -3,7 +3,7 @@
  */
 
 import type { DeviceStatus, StorageInfo } from './Device';
-import type { SyncProgress, UploadTask } from './Recording';
+import type { RecordingDataStore, SyncProgress, UploadRecoveryProvider, UploadTask } from './Recording';
 
 /**
  * SDK log level
@@ -14,6 +14,10 @@ export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
  * SDK configuration options
  */
 export interface BotaConfig {
+  /** Refreshes credentials for retained native recordings after restart. */
+  uploadRecoveryProvider?: UploadRecoveryProvider;
+  /** Unsupported compatibility option: byte callbacks cannot cross the bridge. */
+  recordingDataStore?: RecordingDataStore;
   /** Environment for API endpoint (development, gamma, or production) */
   environment?: 'development' | 'gamma' | 'production';
   /** Enable background sync (default: true) */

package/src/sdkIdentity.ts

@@ -0,0 +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.11'

package/src/specs/NativeBotaDeviceSDK.ts

@@ -156,6 +156,16 @@ export type NativeEncryptedUploadV2Recording = {
   generation: number;
   ciphertextLength: string;
   ciphertextSha256: string;
+  startedAtMs?: string;
+  durationMs?: string;
+  plaintextLength?: string;
+  storageFormat?: number;
+};
+
+export type NativePendingRecording = {
+  profile: string;
+  legacy?: NativeDeviceRecording;
+  encrypted?: NativeEncryptedUploadV2Recording;
 };
 
 export type NativeEncryptedUploadV2Capability = {
@@ -223,6 +233,7 @@ export type NativeRecordingTransferResult = {
   localPath: string;
   e2eEncrypted: boolean;
   contentSha256?: string;
+  fileSizeBytes: number;
 };
 
 export type NativeRecordingUploadProgress = {
@@ -236,6 +247,7 @@ export type NativeRecordingUploadRequest = {
   recordingId: string;
   deviceId: string;
   localPath: string;
+  fileSizeBytes?: number;
   uploadUrl: string;
   uploadToken?: string;
   completeUrl?: string;
@@ -329,6 +341,44 @@ export type NativeDeviceLogLine = {
   isBacklog: boolean;
 };
 
+export type NativeDiagnosticFault = {
+  cpu_id: number;
+  cpu_emu: string;
+  core_emu: string;
+  hsb_emu: string;
+  audio_emu: string;
+  wireless_emu: string;
+};
+export type NativeDiagnosticExecution = {
+  task?: string;
+  reti?: string;
+  rets?: string;
+  pc_trace: ReadonlyArray<string>;
+};
+export type NativeDiagnosticRuntime = {
+  heap_free_bytes?: number;
+  task_stack_remaining_bytes?: number;
+};
+export type NativeDiagnosticBreadcrumb = { delta_ms: number; code: string; arg0: number };
+export type NativeDiagnosticReport = {
+  fault: NativeDiagnosticFault;
+  execution: NativeDiagnosticExecution;
+  runtime?: NativeDiagnosticRuntime;
+  breadcrumbs?: ReadonlyArray<NativeDiagnosticBreadcrumb>;
+};
+export type NativeDiagnosticEvent = {
+  event_id: string;
+  event_type: string;
+  reason_code: string;
+  uptime_ms: number;
+  signature: string;
+  firmware_build_id: string;
+  subsystem: string;
+  state_before_event: string;
+  report?: NativeDiagnosticReport;
+};
+export type NativeDiagnosticsBatch = { schema_version: number; events: ReadonlyArray<NativeDiagnosticEvent> };
+
 export type NativeWiFiConfigResult = {
   success: boolean;
   error?: string;
@@ -353,7 +403,17 @@ export type NativeDeviceWiFiScanResult = {
   currentSsid?: string;
 };
 
+export type NativeClientContext = {
+  schemaVersion: number;
+  sessionId: string;
+  sequence: number;
+  platform: string;
+  sdkPackage: string;
+  sdkVersion: string;
+};
+
 export interface Spec extends TurboModule {
+  nextClientPresence: (deviceId: string) => Promise<NativeClientContext | null>;
   readonly onDeviceDiscovered: EventEmitter<NativeDiscoveredDevice>;
   readonly onDeviceDisconnected: EventEmitter<NativeDeviceDisconnection>;
   readonly onDeviceStatusUpdated: EventEmitter<NativeDeviceStatus>;
@@ -480,6 +540,8 @@ export interface Spec extends TurboModule {
   startWiFiStatusUpdates: (device: NativeConnectedDevice) => Promise<void>;
   startDeviceLogs: (device: NativeConnectedDevice) => Promise<void>;
   stopDeviceLogs: () => Promise<void>;
+  readDiagnosticEvents: (device: NativeConnectedDevice) => Promise<NativeDiagnosticsBatch>;
+  acknowledgeDiagnosticEvents: (device: NativeConnectedDevice, acceptedEventIds: ReadonlyArray<string>) => Promise<void>;
   stopStatusUpdates: () => Promise<void>;
   stopWiFiStatusUpdates: () => Promise<void>;
   stopScan: () => Promise<void>;
@@ -493,6 +555,9 @@ export interface Spec extends TurboModule {
     recording: NativeEncryptedUploadV2Recording,
     operationId: string
   ) => Promise<void>;
+  listPendingRecordings: (device: NativeConnectedDevice) => Promise<ReadonlyArray<NativePendingRecording>>;
+  cancelEncryptedRecordingV2: (operationId: string) => Promise<void>;
+  releaseEncryptedUploadV2Material: (materialRegistrationId: string) => Promise<void>;
   resolveEncryptedUploadV2Profile: (
     requestId: string,
     decision: NativeEncryptedUploadV2ProfileDecision
@@ -507,6 +572,7 @@ export interface Spec extends TurboModule {
   ) => Promise<void>;
   uploadRecordingFile: (request: NativeRecordingUploadRequest) => Promise<void>;
   cancelRecordingUpload: (taskId: string) => Promise<void>;
+  releaseRecordingFile: (taskId: string, localPath: string) => Promise<void>;
   loadCompatibilityUploadQueue: () => Promise<string>;
   saveCompatibilityUploadQueue: (serializedTasks: string) => Promise<void>;
   stopAllRecordingOperations: () => Promise<void>;