@vidtreo/recorder 1.7.3 → 1.7.5

package/dist/index.js

@@ -1475,7 +1475,7 @@ async function buildDeviceCapabilityProfile(options = {}) {
 
 // src/core/routing/recording-route-decision.ts
 var DEFAULT_MIN_DEVICE_MEMORY_GB = 4;
-var DEFAULT_MIN_HARDWARE_CONCURRENCY = 5;
+var DEFAULT_MIN_HARDWARE_CONCURRENCY = 4;
 var PLATFORM_KEYWORD_ANDROID2 = "android";
 var UNSUPPORTED_GUIDANCE_MESSAGE = "Recording is not supported in this browser context. Use a secure connection, go online, and try a current Chrome or Edge browser.";
 function hasSufficientDeviceMemory(profile, minDeviceMemory) {
@@ -1566,14 +1566,7 @@ function decideRecordingRoute(options) {
   const hasSmoothEncoding = hasSmoothEncodingCapability(selectedCodec);
   const hasPowerEfficientEncoding = hasPowerEfficientEncodingCapability(selectedCodec);
   const localRouteBlockers = buildLocalRouteBlockers(options.profile, hasSupportedTargetCodec, hasEnoughDeviceMemory, hasEnoughHardwareConcurrency, hasSupportedEncoding, hasSmoothEncoding, hasPowerEfficientEncoding);
-  if (isAndroidProfile(options.profile) && canUsePostRecordingTranscodeRoute(options.profile, hasSupportedTargetCodec)) {
-    return {
-      route: "safe-capture-post-recording-transcode",
-      reasonCodes: buildPostRecordingTranscodeReasonCodes(options.profile, localRouteBlockers),
-      selectedCodecId
-    };
-  }
-  if (options.profile.features.isSecureContext && options.profile.features.hasVideoEncoder && hasSupportedTargetCodec && options.profile.network.online !== false && hasEnoughDeviceMemory && hasEnoughHardwareConcurrency && hasSupportedEncoding && hasSmoothEncoding && hasPowerEfficientEncoding) {
+  if (options.profile.features.isSecureContext && options.profile.features.hasVideoEncoder && hasSupportedTargetCodec && options.profile.network.online !== false && hasEnoughDeviceMemory && hasEnoughHardwareConcurrency && hasSupportedEncoding && hasSmoothEncoding) {
     return {
       route: "local-webcodecs",
       reasonCodes: ["webcodecs-supported", "target-codec-supported"],
@@ -6319,7 +6312,7 @@ function resolveDeviceError(input) {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.7.3",
+  version: "1.7.5",
   type: "module",
   description: "Vidtreo SDK for browser-based video recording and transcoding. Features include camera/screen recording, real-time MP4 transcoding, audio level analysis, mute/pause controls, source switching, device selection, and automatic backend uploads. Similar to Ziggeo and Addpipe, Vidtreo provides enterprise-grade video processing capabilities for web applications.",
   main: "./dist/index.js",
@@ -6459,6 +6452,8 @@ var TELEMETRY_EVENT_CATEGORY_MAP = {
   "recording.stop.failed": "error",
   "recording.route.selected": "lifecycle",
   "upload.started": "performance",
+  "upload.attempt.failed": "error",
+  "upload.retry.scheduled": "performance",
   "upload.succeeded": "performance",
   "upload.failed": "error",
   "upload.route.selected": "lifecycle",
@@ -7195,6 +7190,12 @@ class UploadQueueManager {
     return Object.entries(expected).every(([key, value]) => actual[key] === value);
   }
   async processUpload(upload, shouldThrowOnError = false) {
+    const attempt = upload.retryCount + 1;
+    let progressDetails = {
+      progress: 0,
+      loadedBytes: 0,
+      totalBytes: 0
+    };
     try {
       await this.storageService.updateUploadStatus(upload.id, {
         status: "uploading"
@@ -7208,24 +7209,52 @@ class UploadQueueManager {
         userMetadata: upload.userMetadata,
         onProgress: (progress) => {
           this.callbacks.onUploadProgress?.(upload.id, progress);
+        },
+        onProgressDetails: (details) => {
+          progressDetails = details;
+          this.callbacks.onUploadProgressDetails?.(upload.id, details);
         }
       });
+      this.callbacks.onUploadAttemptSucceeded?.(upload.id, {
+        attempt,
+        maxAttempts: MAX_RETRIES2,
+        loadedBytes: progressDetails.loadedBytes,
+        totalBytes: progressDetails.totalBytes
+      });
       await this.storageService.deleteUpload(upload.id);
       this.callbacks.onUploadComplete?.(upload.id, result);
       return result;
     } catch (error) {
       const errorMessage = extractErrorMessage(error);
       const retryCount = upload.retryCount + 1;
+      const willRetry = retryCount < MAX_RETRIES2;
+      const retryDelayMs = willRetry ? this.calculateRetryDelay(retryCount) : null;
       await this.storageService.updateUploadStatus(upload.id, {
         status: "failed",
         retryCount,
         lastError: errorMessage
       });
-      if (retryCount >= MAX_RETRIES2) {
-        this.callbacks.onUploadError?.(upload.id, new Error(`Upload failed after ${MAX_RETRIES2} attempts: ${errorMessage}`));
-      } else {
+      this.callbacks.onUploadAttemptFailed?.(upload.id, {
+        attempt,
+        maxAttempts: MAX_RETRIES2,
+        loadedBytes: progressDetails.loadedBytes,
+        totalBytes: progressDetails.totalBytes,
+        reason: errorMessage,
+        retryDelayMs,
+        willRetry
+      });
+      if (willRetry) {
         const delay2 = this.calculateRetryDelay(retryCount);
+        this.callbacks.onUploadProgress?.(upload.id, 0);
+        this.callbacks.onUploadRetry?.(upload.id, {
+          attempt: attempt + 1,
+          maxAttempts: MAX_RETRIES2,
+          reason: errorMessage,
+          retryDelayMs: delay2
+        });
         this.scheduleRetry(delay2);
+      } else {
+        this.callbacks.onUploadError?.(upload.id, new Error(`Upload failed after ${MAX_RETRIES2} attempts: ${errorMessage}`));
       }
       if (shouldThrowOnError) {
         throw new Error(errorMessage);
@@ -7257,6 +7286,8 @@ class UploadQueueManager {
 // src/core/upload/upload-service.ts
 var API_UPLOAD_PATH = "/api/v1/videos/upload";
 var MIME_TYPE_PARAMETER_SEPARATOR = ";";
+var UPLOAD_INACTIVITY_TIMEOUT_MS = 45000;
+var UPLOAD_INACTIVITY_ERROR = "Upload stalled after 45 seconds without progress";
 
 class VideoUploadService {
   uploadVideo(blob, options) {
@@ -7272,27 +7303,61 @@ class VideoUploadService {
     return new Promise((resolve, reject) => {
       const xhr = new XMLHttpRequest;
       const uploadBlob = this.createUploadBlob(blob, options.mimeType);
-      if (options.onProgress) {
-        const onProgress = options.onProgress;
-        xhr.upload.addEventListener("progress", (event) => {
-          if (event.lengthComputable) {
-            const progress = event.loaded / event.total;
-            onProgress(progress);
-          }
-        });
-      }
+      let inactivityTimeoutId = null;
+      let isSettled = false;
+      let loadedBytes = 0;
+      const clearInactivityTimeout = () => {
+        if (inactivityTimeoutId === null) {
+          return;
+        }
+        window.clearTimeout(inactivityTimeoutId);
+        inactivityTimeoutId = null;
+      };
+      const rejectRequest = (reason, shouldAbort = false) => {
+        if (isSettled) {
+          return;
+        }
+        isSettled = true;
+        clearInactivityTimeout();
+        if (shouldAbort) {
+          xhr.abort();
+        }
+        reject(reason);
+      };
+      const resolveRequest = (result) => {
+        if (isSettled) {
+          return;
+        }
+        isSettled = true;
+        clearInactivityTimeout();
+        resolve(result);
+      };
+      const restartInactivityTimeout = () => {
+        clearInactivityTimeout();
+        inactivityTimeoutId = window.setTimeout(() => {
+          rejectRequest(new Error(UPLOAD_INACTIVITY_ERROR), true);
+        }, UPLOAD_INACTIVITY_TIMEOUT_MS);
+      };
+      xhr.upload.addEventListener("progress", (event) => {
+        this.reportProgress(event, options);
+        if (event.loaded <= loadedBytes) {
+          return;
+        }
+        loadedBytes = event.loaded;
+        restartInactivityTimeout();
+      });
       xhr.addEventListener("load", () => {
         if (xhr.status >= 200 && xhr.status <= 299) {
-          this.parseSuccessResponse(xhr, resolve, reject);
+          this.parseSuccessResponse(xhr, resolveRequest, rejectRequest);
           return;
         }
-        this.parseErrorResponse(xhr, reject);
+        this.parseErrorResponse(xhr, rejectRequest);
       });
       xhr.addEventListener("error", () => {
-        reject(new Error("Network error during upload"));
+        rejectRequest(new Error("Network error during upload"));
       });
       xhr.addEventListener("abort", () => {
-        reject(new Error("Upload was aborted"));
+        rejectRequest(new Error("Upload was aborted"));
       });
       const url = `${options.backendUrl}${API_UPLOAD_PATH}`;
       xhr.open("POST", url);
@@ -7308,6 +7373,19 @@ class VideoUploadService {
       }
       formData.append("metadata", JSON.stringify(metadata));
       xhr.send(formData);
+      restartInactivityTimeout();
+    });
+  }
+  reportProgress(event, options) {
+    if (!event.lengthComputable) {
+      return;
+    }
+    const progress = event.loaded / event.total;
+    options.onProgress?.(progress);
+    options.onProgressDetails?.({
+      progress,
+      loadedBytes: event.loaded,
+      totalBytes: event.total
     });
   }
   createUploadBlob(blob, mimeType) {
@@ -23217,6 +23295,8 @@ class RecorderController {
   callbacks;
   telemetryManager;
   uploadMetadataManager;
+  uploadAttemptFailureById = new Map;
+  uploadAttemptSuccessById = new Map;
   uploadQueueManager = null;
   isInitialized = false;
   isDemo = false;
@@ -23558,6 +23638,11 @@ class RecorderController {
       }, error);
       throw error;
     }
+    let progressDetails = {
+      progress: 0,
+      loadedBytes: 0,
+      totalBytes: 0
+    };
     try {
       const result = await this.uploadService.uploadVideo(options.blob, {
         apiKey: options.apiKey,
@@ -23566,18 +23651,37 @@ class RecorderController {
         mimeType: options.mimeType,
         metadata: undefined,
         userMetadata: options.userMetadata,
-        onProgress: this.uploadCallbacks.onProgress
+        onProgress: this.uploadCallbacks.onProgress,
+        onProgressDetails: (details) => {
+          progressDetails = details;
+        }
       });
       this.uploadCallbacks.onSuccess(result);
       this.telemetryManager.sendEvent("upload.succeeded", {
         filename: options.filename,
         duration: options.duration,
         sourceType: options.sourceType,
-        recordingId: result.id
+        recordingId: result.id,
+        attempt: 1,
+        maxAttempts: 1,
+        loadedBytes: progressDetails.loadedBytes,
+        totalBytes: progressDetails.totalBytes
       });
     } catch (error) {
       const uploadError = error instanceof Error ? error : new Error(extractErrorMessage(error));
       this.uploadCallbacks.onError(uploadError);
+      this.telemetryManager.sendEvent("upload.attempt.failed", {
+        filename: options.filename,
+        duration: options.duration,
+        sourceType: options.sourceType,
+        attempt: 1,
+        maxAttempts: 1,
+        loadedBytes: progressDetails.loadedBytes,
+        totalBytes: progressDetails.totalBytes,
+        reason: uploadError.message,
+        willRetry: false,
+        retryDelayMs: null
+      }, uploadError);
       this.telemetryManager.sendEvent("upload.failed", {
         filename: options.filename,
         duration: options.duration,
@@ -23826,19 +23930,60 @@ class RecorderController {
       onUploadProgress: (_id, progress) => {
         this.uploadCallbacks.onProgress(progress);
       },
+      onUploadAttemptFailed: (id, details) => {
+        this.uploadAttemptFailureById.set(id, details);
+        const metadata = this.uploadMetadataManager.getMetadata(id);
+        if (!metadata) {
+          return;
+        }
+        const error = new Error(details.reason);
+        this.telemetryManager.sendEvent("upload.attempt.failed", {
+          filename: metadata.filename,
+          duration: metadata.duration,
+          sourceType: metadata.sourceType,
+          ...details
+        }, error);
+      },
+      onUploadAttemptSucceeded: (id, details) => {
+        this.uploadAttemptSuccessById.set(id, details);
+      },
+      onUploadRetry: (id, details) => {
+        this.uploadCallbacks.onRetry?.(details);
+        const metadata = this.uploadMetadataManager.getMetadata(id);
+        const failureDetails = this.uploadAttemptFailureById.get(id);
+        if (!(metadata && failureDetails)) {
+          return;
+        }
+        this.telemetryManager.sendEvent("upload.retry.scheduled", {
+          filename: metadata.filename,
+          duration: metadata.duration,
+          sourceType: metadata.sourceType,
+          attempt: details.attempt,
+          maxAttempts: details.maxAttempts,
+          previousAttempt: failureDetails.attempt,
+          loadedBytes: failureDetails.loadedBytes,
+          totalBytes: failureDetails.totalBytes,
+          reason: details.reason,
+          retryDelayMs: details.retryDelayMs
+        });
+      },
       onUploadComplete: (id, result) => {
         this.isUploadInProgress = false;
         this.uploadCallbacks.onSuccess(result);
         const metadata = this.uploadMetadataManager.getMetadata(id);
+        const successDetails = this.uploadAttemptSuccessById.get(id);
         if (metadata) {
           this.telemetryManager.sendEvent("upload.succeeded", {
             filename: metadata.filename,
             duration: metadata.duration,
             sourceType: metadata.sourceType,
-            recordingId: result.id
+            recordingId: result.id,
+            ...successDetails && successDetails
           });
           this.uploadMetadataManager.clearMetadata(id);
         }
+        this.uploadAttemptFailureById.delete(id);
+        this.uploadAttemptSuccessById.delete(id);
       },
       onUploadError: (id, error) => {
         this.isUploadInProgress = false;
@@ -23852,6 +23997,8 @@ class RecorderController {
           }, error);
           this.uploadMetadataManager.clearMetadata(id);
         }
+        this.uploadAttemptFailureById.delete(id);
+        this.uploadAttemptSuccessById.delete(id);
       }
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vidtreo/recorder",
-  "version": "1.7.3",
+  "version": "1.7.5",
   "type": "module",
   "description": "Vidtreo SDK for browser-based video recording and transcoding. Features include camera/screen recording, real-time MP4 transcoding, audio level analysis, mute/pause controls, source switching, device selection, and automatic backend uploads. Similar to Ziggeo and Addpipe, Vidtreo provides enterprise-grade video processing capabilities for web applications.",
   "main": "./dist/index.js",