@vidtreo/recorder 1.9.0 → 1.11.0

package/README.md

@@ -29,7 +29,7 @@ Recordings and native-camera uploads are written to an IndexedDB upload queue be
 - The queued upload keeps its idempotency key, so the backend returns the same video and the SDK uploads only the parts R2 has not verified yet.
 - Failed attempts are retried by the queue with exponential backoff (up to 10 attempts) on top of the per-part retries. Retries wait while the browser is offline.
 - Uploads authenticated with `apiKey` store the key with the queued item. Uploads authenticated with `getAccessToken` never persist a token: the provider is called again when the upload resumes, so the page must create the recorder (or native-camera handler) with the same `getAccessToken` after a reload.
-- Errors that cannot succeed on retry (such as `upload.insufficient-credits`) are reported immediately and are not retried.
+- An `upload.insufficient-credits` rejection does not use up the 10 attempts and never gives up: the upload stays in the queue and is retried every 5 minutes and whenever the queue starts. Each rejection is reported through `onUploadError` with the backend message, and the upload is removed once it succeeds.
 - When IndexedDB is unavailable (private browsing, blocked storage) the SDK uploads directly without persistence.
 
 Version 1.8.0 does not fall back to the legacy Worker-proxied upload endpoint. Applications that need the previous transport must remain on an earlier SDK version while the backend continues to support those clients. Custom Vidtreo backend deployments must expose initiation, part authorization, and confirmation endpoints. Managed R2 CORS must allow browser `PUT` plus the signed `Content-MD5` header and expose `ETag`.
@@ -747,7 +747,7 @@ const recorder = new VidtreoRecorder({
 
 | Code | Meaning |
 |------|---------|
-| `upload.insufficient-credits` | The backend rejected the upload with HTTP 402 because the account has no credits left. The upload is not retried. |
+| `upload.insufficient-credits` | The backend rejected the upload with HTTP 402 because the account has no credits left. The upload stays queued and is retried every 5 minutes (and when the queue starts), and `onUploadError` receives this error on every rejected attempt. Repeated rejections of the same upload carry `isRepeatedRejection: true` (check it with `isRepeatedUploadRejection(error)`); the built-in UIs use it to show their dialog only once. |
 
 `getUploadErrorCode` returns `null` for every other error (network failures, timeouts, and so on). Those errors are retried automatically before they are reported.
 
@@ -1113,7 +1113,7 @@ handler.destroy();
 ```
 
 - `startUploadQueue(callbacks?)` opens the IndexedDB queue and immediately resumes uploads left over from a previous page load (same idempotency key, only missing parts are sent). Its callbacks receive events for those resumed uploads and for queue-level errors. It resolves to `false` when persistent storage is unavailable; uploads then go directly to the backend.
-- `processAndUpload(onTranscodeProgress, onUploadProgress, onUploadProgressDetails?, onUploadRetry?)` queues the transcoded file and resolves with a `NativeCameraUploadResult` (`RecordingUploadResult & { blob: Blob }`) once the upload is confirmed. It rejects only with a terminal error, after the queue has exhausted its retries or immediately for `upload.insufficient-credits`. Events for this upload go to the per-call callbacks, not to the `startUploadQueue` callbacks.
+- `processAndUpload(onTranscodeProgress, onUploadProgress, onUploadProgressDetails?, onUploadRetry?)` queues the transcoded file and resolves with a `NativeCameraUploadResult` (`RecordingUploadResult & { blob: Blob }`) once the upload is confirmed. It rejects only with a terminal error, after the queue has exhausted its retries, or with `upload.insufficient-credits` on the first credit rejection; that upload stays queued and keeps retrying, and later rejections and the final success reach the `startUploadQueue` callbacks, so call `startUploadQueue` (with those callbacks) if you want to receive them. Events for this upload go to the per-call callbacks, not to the `startUploadQueue` callbacks.
 - Calling `processAndUpload` without `startUploadQueue` opens the queue on demand.
 - `destroy()` stops the queue timers. An upload that is still pending stays in IndexedDB and resumes the next time a handler or recorder starts the queue.
 

package/dist/index.d.ts

@@ -275,6 +275,8 @@ export {};
 
 export {};
 
+export {};
+
 export type VidtreoRecorderConfig = {
     apiKey?: string;
     getAccessToken?: AccessTokenProvider;
@@ -453,6 +455,7 @@ export type TranscodedAudio = {
 };
 
 export declare const DISABLED_AUDIO_RECORDING_CONFIG: Readonly<AudioRecordingConfig>;
+export declare const DEMO_AUDIO_RECORDING_CONFIG: Readonly<AudioRecordingConfig>;
 export declare function parseAudioRecordingConfig(value: unknown): AudioRecordingConfig;
 export declare function requireEnabledAudioRecordingConfig(config: AudioRecordingConfig | undefined): AudioRecordingConfig;
 
@@ -1121,6 +1124,7 @@ export declare class ConfigManager {
     private configFetched;
     private configReady;
     initialize(apiKey: string | null, backendUrl: string | null, getAccessToken?: AccessTokenProvider | null): Promise<void>;
+    applyDemoConfig(): void;
     fetchConfig(): Promise<void>;
     getConfig(): Promise<TranscodeConfig>;
     getConfigForRecording(): TranscodeConfig;
@@ -3666,6 +3670,8 @@ export declare class RecorderController {
     prepareLocalRecording(blob: Blob): Promise<LocalRecording>;
     uploadVideo(blob: Blob, apiKey: string | null, backendUrl: string, metadata: Record<string, unknown>, getAccessToken?: AccessTokenProvider): Promise<void>;
     private uploadVideoAfterStatusClear;
+    private handleQueuedUploadError;
+    private sendUploadFailedTelemetry;
     private uploadDirectlyWithoutQueue;
     getStream(): MediaStream | null;
     isConfigReady(): boolean;
@@ -3777,6 +3783,7 @@ export declare class UploadQueueManager {
     private readonly networkOnlineHandler;
     private readonly progressFloors;
     private readonly interruptedUploadIds;
+    private readonly creditRejectedUploadIds;
     private isProcessing;
     private hasRecoveredStaleUploads;
     private hasNetworkRecovered;
@@ -3802,11 +3809,14 @@ export declare class UploadQueueManager {
     private canProcessMatchingUpload;
     private matchesMetadata;
     private processUpload;
+    private handleUploadFailure;
     private isResumedUpload;
     private resolveRetryCount;
     private reportUploadProgress;
     private forgetUploadProgress;
     private isOffline;
+    private getRemainingRetryDelay;
+    private resolveRetryDelay;
     private calculateRetryDelay;
     private scheduleRetry;
     private clearTimer;
@@ -3817,10 +3827,13 @@ export declare const UPLOAD_ERROR_INSUFFICIENT_CREDITS = "upload.insufficient-cr
 export type UploadErrorCode = typeof UPLOAD_ERROR_INSUFFICIENT_CREDITS;
 export type UploadError = Error & {
     code: UploadErrorCode;
+    isRepeatedRejection?: true;
 };
 export declare function createUploadError(code: UploadErrorCode, message: string): UploadError;
 export declare function getUploadErrorCode(error: unknown): UploadErrorCode | null;
-export declare function isRetryableUploadError(error: unknown): boolean;
+export declare function isInsufficientCreditsError(error: unknown): boolean;
+export declare function markRepeatedUploadRejection(error: Error): void;
+export declare function isRepeatedUploadRejection(error: unknown): boolean;
 
 export type PartHasher = {
     hash: (part: Blob) => Promise<PartChecksums>;

package/dist/index.js

@@ -544,6 +544,10 @@ var DISABLED_AUDIO_RECORDING_CONFIG = Object.freeze({
   autoGain: true,
   normalize: false
 });
+var DEMO_AUDIO_RECORDING_CONFIG = Object.freeze({
+  ...DISABLED_AUDIO_RECORDING_CONFIG,
+  enabled: true
+});
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1098,6 +1102,12 @@ class ConfigManager {
     }
     this.fetchConfigInBackground();
   }
+  applyDemoConfig() {
+    this.currentConfig = {
+      ...DEFAULT_TRANSCODE_CONFIG,
+      audioRecording: { ...DEMO_AUDIO_RECORDING_CONFIG }
+    };
+  }
   async fetchConfig() {
     if (!this.configService) {
       return;
@@ -2937,8 +2947,14 @@ function getUploadErrorCode(error) {
   }
   return null;
 }
-function isRetryableUploadError(error) {
-  return getUploadErrorCode(error) === null;
+function isInsufficientCreditsError(error) {
+  return getUploadErrorCode(error) === UPLOAD_ERROR_INSUFFICIENT_CREDITS;
+}
+function markRepeatedUploadRejection(error) {
+  Object.assign(error, { isRepeatedRejection: true });
+}
+function isRepeatedUploadRejection(error) {
+  return error instanceof Error && "isRepeatedRejection" in error && error.isRepeatedRejection === true;
 }
 
 // src/core/upload/upload-queue.ts
@@ -2947,6 +2963,7 @@ var INITIAL_RETRY_DELAY = 2000;
 var MAX_RETRY_DELAY = 300000;
 var RETRY_MULTIPLIER = 1.5;
 var PROCESSING_INTERVAL = 5000;
+var creditRejectedUploadIdsInPageSession = new Set;
 
 class UploadQueueManager {
   getAccessToken;
@@ -2956,6 +2973,7 @@ class UploadQueueManager {
   networkOnlineHandler;
   progressFloors = new Map;
   interruptedUploadIds = new Set;
+  creditRejectedUploadIds = new Set;
   isProcessing = false;
   hasRecoveredStaleUploads = false;
   hasNetworkRecovered = false;
@@ -3016,20 +3034,19 @@ class UploadQueueManager {
       const failedUploads = await this.storageService.getPendingUploads("failed");
       const retryableUploads = failedUploads.filter((upload) => upload.retryCount < MAX_RETRIES2);
       if (retryableUploads.length > 0) {
-        const upload = this.getOldestFailedUpload(retryableUploads);
-        const delay = this.calculateRetryDelay(upload.retryCount);
-        const timeSinceLastAttempt = Date.now() - upload.updatedAt;
-        const isRetryDue = this.hasNetworkRecovered || timeSinceLastAttempt >= delay;
+        const hasNetworkRecovered = this.hasNetworkRecovered;
         this.hasNetworkRecovered = false;
-        if (isRetryDue) {
+        const dueUploads = retryableUploads.filter((upload) => hasNetworkRecovered || this.getRemainingRetryDelay(upload) <= 0);
+        if (dueUploads.length > 0) {
+          const upload = this.getOldestFailedUpload(dueUploads);
           await this.storageService.updateUploadStatus(upload.id, {
             status: "pending",
             retryCount: upload.retryCount
           });
           await this.processUpload(upload);
         } else {
-          const remainingDelay = delay - timeSinceLastAttempt;
-          this.scheduleRetry(remainingDelay);
+          const remainingDelays = retryableUploads.map((upload) => this.getRemainingRetryDelay(upload));
+          this.scheduleRetry(Math.min(...remainingDelays));
         }
       }
       this.isProcessing = false;
@@ -3059,7 +3076,7 @@ class UploadQueueManager {
       return result;
     } catch (error) {
       this.isProcessing = false;
-      if (!isRetryableUploadError(error)) {
+      if (isInsufficientCreditsError(error)) {
         throw error;
       }
       throw new Error(`Error processing matching upload: ${extractErrorMessage(error)}`);
@@ -3187,57 +3204,80 @@ class UploadQueueManager {
       this.callbacks.onUploadComplete?.(upload.id, result);
       return result;
     } catch (error) {
-      const errorMessage = extractErrorMessage(error);
-      const isRetryable = isRetryableUploadError(error);
-      const uploadError = error instanceof Error ? error : new Error(errorMessage);
-      const retryCount = this.resolveRetryCount(upload, isRetryable);
-      const willRetry = retryCount < MAX_RETRIES2;
-      const retryDelayMs = willRetry ? this.calculateRetryDelay(retryCount) : null;
-      await this.storageService.updateUploadStatus(upload.id, {
-        status: "failed",
-        retryCount,
-        lastError: errorMessage
-      });
-      this.callbacks.onUploadAttemptFailed?.(upload.id, {
+      return this.handleUploadFailure({
+        upload,
+        error,
         attempt,
+        progressDetails,
+        shouldThrowOnError
+      });
+    }
+  }
+  async handleUploadFailure({
+    upload,
+    error,
+    attempt,
+    progressDetails,
+    shouldThrowOnError
+  }) {
+    const errorMessage = extractErrorMessage(error);
+    const isCreditRejected = isInsufficientCreditsError(error);
+    const uploadError = error instanceof Error ? error : new Error(errorMessage);
+    const retryCount = this.resolveRetryCount(upload, isCreditRejected);
+    const willRetry = retryCount < MAX_RETRIES2;
+    if (isCreditRejected) {
+      if (creditRejectedUploadIdsInPageSession.has(upload.id)) {
+        markRepeatedUploadRejection(uploadError);
+      }
+      creditRejectedUploadIdsInPageSession.add(upload.id);
+      this.creditRejectedUploadIds.add(upload.id);
+    } else {
+      this.creditRejectedUploadIds.delete(upload.id);
+    }
+    const retryDelayMs = this.resolveRetryDelay(upload.id, retryCount);
+    await this.storageService.updateUploadStatus(upload.id, {
+      status: "failed",
+      retryCount,
+      lastError: errorMessage
+    });
+    this.callbacks.onUploadAttemptFailed?.(upload.id, {
+      attempt,
+      maxAttempts: MAX_RETRIES2,
+      loadedBytes: progressDetails.loadedBytes,
+      totalBytes: progressDetails.totalBytes,
+      reason: errorMessage,
+      retryDelayMs: willRetry ? retryDelayMs : null,
+      willRetry
+    });
+    if (!willRetry) {
+      this.forgetUploadProgress(upload.id);
+    }
+    if (willRetry && !isCreditRejected) {
+      this.callbacks.onUploadRetry?.(upload.id, {
+        attempt: attempt + 1,
         maxAttempts: MAX_RETRIES2,
-        loadedBytes: progressDetails.loadedBytes,
-        totalBytes: progressDetails.totalBytes,
         reason: errorMessage,
-        retryDelayMs,
-        willRetry
+        retryDelayMs
       });
-      if (!willRetry) {
-        this.forgetUploadProgress(upload.id);
-      }
-      if (willRetry) {
-        const delay = this.calculateRetryDelay(retryCount);
-        this.callbacks.onUploadRetry?.(upload.id, {
-          attempt: attempt + 1,
-          maxAttempts: MAX_RETRIES2,
-          reason: errorMessage,
-          retryDelayMs: delay
-        });
-        this.scheduleRetry(delay);
-      } else if (isRetryable) {
-        this.callbacks.onUploadError?.(upload.id, new Error(`Upload failed after ${MAX_RETRIES2} attempts: ${errorMessage}`));
-      } else {
-        this.callbacks.onUploadError?.(upload.id, uploadError);
-      }
-      if (shouldThrowOnError) {
-        throw isRetryable ? new Error(errorMessage) : uploadError;
-      }
-      return null;
     }
+    if (willRetry) {
+      this.scheduleRetry(retryDelayMs);
+    }
+    if (isCreditRejected) {
+      this.callbacks.onUploadError?.(upload.id, uploadError);
+    } else if (!willRetry) {
+      this.callbacks.onUploadError?.(upload.id, new Error(`Upload failed after ${MAX_RETRIES2} attempts: ${errorMessage}`));
+    }
+    if (shouldThrowOnError) {
+      throw isCreditRejected ? uploadError : new Error(errorMessage);
+    }
+    return null;
   }
   isResumedUpload(upload) {
-    return upload.retryCount > 0 || this.interruptedUploadIds.has(upload.id) || this.progressFloors.has(upload.id);
+    return upload.retryCount > 0 || upload.status === "failed" || this.interruptedUploadIds.has(upload.id) || this.progressFloors.has(upload.id);
   }
-  resolveRetryCount(upload, isRetryable) {
-    if (!isRetryable) {
-      return MAX_RETRIES2;
-    }
-    if (this.isOffline()) {
+  resolveRetryCount(upload, isCreditRejected) {
+    if (isCreditRejected || this.isOffline()) {
       return upload.retryCount;
     }
     return upload.retryCount + 1;
@@ -3253,10 +3293,22 @@ class UploadQueueManager {
   forgetUploadProgress(id) {
     this.progressFloors.delete(id);
     this.interruptedUploadIds.delete(id);
+    this.creditRejectedUploadIds.delete(id);
+    creditRejectedUploadIdsInPageSession.delete(id);
   }
   isOffline() {
     return typeof navigator !== "undefined" && navigator.onLine === false;
   }
+  getRemainingRetryDelay(upload) {
+    const delay = this.resolveRetryDelay(upload.id, upload.retryCount);
+    return delay - (Date.now() - upload.updatedAt);
+  }
+  resolveRetryDelay(uploadId, retryCount) {
+    if (this.creditRejectedUploadIds.has(uploadId)) {
+      return MAX_RETRY_DELAY;
+    }
+    return this.calculateRetryDelay(retryCount);
+  }
   calculateRetryDelay(retryCount) {
     const delay = INITIAL_RETRY_DELAY * RETRY_MULTIPLIER ** (retryCount - 1);
     return Math.min(delay, MAX_RETRY_DELAY);
@@ -9049,7 +9101,7 @@ function resolveDeviceError(input) {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.9.0",
+  version: "1.11.0",
   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",
@@ -32143,6 +32195,9 @@ class RecorderController {
       isDemo = config.demo;
     }
     this.isDemo = isDemo;
+    if (isDemo) {
+      this.configManager.applyDemoConfig();
+    }
     let apiKey = null;
     if (typeof config.apiKey === "string" && config.apiKey.length > 0) {
       apiKey = config.apiKey;
@@ -32528,6 +32583,30 @@ class RecorderController {
       sourceType
     });
   }
+  handleQueuedUploadError(id, error) {
+    this.isUploadInProgress = false;
+    this.uploadCallbacks.onError(error);
+    const metadata = this.uploadMetadataManager.getMetadata(id);
+    if (isInsufficientCreditsError(error)) {
+      if (metadata && !isRepeatedUploadRejection(error)) {
+        this.sendUploadFailedTelemetry(metadata, error);
+      }
+      return;
+    }
+    if (metadata) {
+      this.sendUploadFailedTelemetry(metadata, error);
+      this.uploadMetadataManager.clearMetadata(id);
+    }
+    this.uploadAttemptFailureById.delete(id);
+    this.uploadAttemptSuccessById.delete(id);
+  }
+  sendUploadFailedTelemetry(metadata, error) {
+    this.telemetryManager.sendEvent("upload.failed", {
+      filename: metadata.filename,
+      duration: metadata.duration,
+      sourceType: metadata.sourceType
+    }, error);
+  }
   async uploadDirectlyWithoutQueue(options) {
     if (!this.uploadService) {
       const error = new Error("Upload service not available");
@@ -32952,19 +33031,7 @@ class RecorderController {
         this.uploadAttemptSuccessById.delete(id);
       },
       onUploadError: (id, error) => {
-        this.isUploadInProgress = false;
-        this.uploadCallbacks.onError(error);
-        const metadata = this.uploadMetadataManager.getMetadata(id);
-        if (metadata) {
-          this.telemetryManager.sendEvent("upload.failed", {
-            filename: metadata.filename,
-            duration: metadata.duration,
-            sourceType: metadata.sourceType
-          }, error);
-          this.uploadMetadataManager.clearMetadata(id);
-        }
-        this.uploadAttemptFailureById.delete(id);
-        this.uploadAttemptSuccessById.delete(id);
+        this.handleQueuedUploadError(id, error);
       }
     });
     this.uploadQueueManager.processQueue().catch((error) => {
@@ -33727,6 +33794,7 @@ export {
   isCredentialConflictError,
   isMobileDevice2 as isMobileDevice,
   isPictureInPictureSupported,
+  isRepeatedUploadRejection,
   logger,
   mapPresetToConfig,
   parseAudioRecordingConfig,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vidtreo/recorder",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "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",