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

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/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.14'

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 {