@vidtreo/recorder 1.6.2 → 1.6.3

package/dist/index.d.ts

@@ -683,9 +683,17 @@ export type VideoEncoderProbeResult = {
     id: string;
     config: VideoEncoderConfig;
     supported: boolean;
+    encodingCapability?: VideoEncodingCapabilityProbeResult;
     errorCode?: "codec-probe-error";
     errorMessage?: string;
 };
+export type VideoEncodingCapabilityProbeResult = {
+    supported: boolean;
+    smooth: boolean;
+    powerEfficient: boolean;
+    errorCode?: "encoding-capability-probe-error";
+    errorMessage?: string;
+};
 export type DeviceCapabilityProfile = {
     browser: {
         name: string;
@@ -712,12 +720,14 @@ export type DeviceCapabilityProfile = {
     codecProbeResults: VideoEncoderProbeResult[];
 };
 export type VideoEncoderSupportProbe = (config: VideoEncoderConfig) => Promise<VideoEncoderSupport>;
+export type VideoEncodingCapabilityProbe = (config: VideoEncoderConfig) => Promise<MediaCapabilitiesEncodingInfo | null>;
 type DeviceCapabilityProfileDependencies = {
     navigatorProvider: CapabilityNavigatorProvider | null;
     secureContextProvider: () => boolean;
     mediaRecorderAvailabilityProvider: () => boolean;
     videoEncoderAvailabilityProvider: () => boolean;
     codecSupportProbe: VideoEncoderSupportProbe;
+    encodingCapabilityProbe: VideoEncodingCapabilityProbe;
 };
 export type BuildDeviceCapabilityProfileOptions = {
     codecCandidates?: VideoEncoderConfigCandidate[];
@@ -2443,7 +2453,7 @@ export declare function deserializeBitrate(bitrate: number | string | undefined)
 import type { DeviceCapabilityProfile } from "../capabilities/device-capability-profile";
 export type RecordingCapabilityProfile = DeviceCapabilityProfile;
 export type RecordingRoute = "local-webcodecs" | "safe-capture-post-recording-transcode" | "unsupported-with-guidance";
-export type RecordingRouteReasonCode = "webcodecs-supported" | "webcodecs-unavailable" | "android-post-recording-transcode" | "target-codec-supported" | "target-codec-unsupported" | "insufficient-device-memory" | "insufficient-hardware-concurrency" | "insecure-context" | "mediarecorder-supported" | "mediarecorder-unavailable" | "offline";
+export type RecordingRouteReasonCode = "webcodecs-supported" | "webcodecs-unavailable" | "target-codec-supported" | "target-codec-unsupported" | "encoding-capability-unsupported" | "encoding-not-smooth" | "encoding-not-power-efficient" | "insufficient-device-memory" | "insufficient-hardware-concurrency" | "insecure-context" | "mediarecorder-supported" | "mediarecorder-unavailable" | "offline";
 export type RecordingRouteDecision = {
     route: RecordingRoute;
     reasonCodes: RecordingRouteReasonCode[];
@@ -2466,7 +2476,8 @@ export declare function decideRecordingRoute(options: DecideRecordingRouteOption
 export declare const ERROR_RECORDING_STOP_NOT_READY = "recording.stop-not-ready";
 export declare const ERROR_RECORDING_FINALIZE_NOT_READY = "recording.finalize-not-ready";
 export declare const ERROR_RECORDING_FINALIZE_TIMEOUT = "recording.finalize-timeout";
-export type RecordingLifecycleErrorCode = typeof ERROR_RECORDING_STOP_NOT_READY | typeof ERROR_RECORDING_FINALIZE_NOT_READY | typeof ERROR_RECORDING_FINALIZE_TIMEOUT;
+export declare const ERROR_RECORDING_UPLOAD_IN_PROGRESS = "recording.upload-in-progress";
+export type RecordingLifecycleErrorCode = typeof ERROR_RECORDING_STOP_NOT_READY | typeof ERROR_RECORDING_FINALIZE_NOT_READY | typeof ERROR_RECORDING_FINALIZE_TIMEOUT | typeof ERROR_RECORDING_UPLOAD_IN_PROGRESS;
 export type RecordingLifecycleError = Error & {
     code: RecordingLifecycleErrorCode;
     isRecoverable: true;
@@ -2759,6 +2770,7 @@ export declare class RecorderController {
     private isDestroyed;
     private enableTabVisibilityOverlay;
     private tabVisibilityOverlayText;
+    private isUploadInProgress;
     private recordingWarmupTimeoutId;
     private audioTelemetryUnsub;
     constructor(callbacks?: RecorderCallbacks);
@@ -2788,6 +2800,7 @@ export declare class RecorderController {
     stopAudioLevelTracking(): void;
     getAudioLevel(): number;
     uploadVideo(blob: Blob, apiKey: string, backendUrl: string, metadata: Record<string, unknown>): Promise<void>;
+    private uploadVideoAfterStatusClear;
     private uploadDirectlyWithoutQueue;
     getStream(): MediaStream | null;
     isConfigReady(): boolean;
@@ -2802,6 +2815,7 @@ export declare class RecorderController {
     getDeviceManager(): DeviceManager;
     getConfig(): Promise<TranscodeConfig>;
     getUploadService(): VideoUploadService | null;
+    isUploading(): boolean;
     isRecording(): boolean;
     isActive(): boolean;
     isAudioReady(): boolean;

package/dist/index.js

@@ -1321,6 +1321,48 @@ function isMediaRecorderAvailable() {
 function isVideoEncoderAvailable() {
   return typeof globalThis.VideoEncoder !== "undefined";
 }
+function getGlobalMediaCapabilities() {
+  if (typeof navigator === "undefined") {
+    return null;
+  }
+  return navigator.mediaCapabilities;
+}
+function resolveEncodingContentType(codec) {
+  const normalizedCodec = codec.toLowerCase();
+  if (normalizedCodec.startsWith("avc1") || normalizedCodec.startsWith("av01") || normalizedCodec.startsWith("hvc1") || normalizedCodec.startsWith("hev1")) {
+    return `video/mp4;codecs="${codec}"`;
+  }
+  if (normalizedCodec === "vp8" || normalizedCodec.startsWith("vp09") || normalizedCodec.startsWith("vp9")) {
+    return `video/webm;codecs="${codec}"`;
+  }
+  return null;
+}
+function probeVideoEncodingCapability(config) {
+  const mediaCapabilities = getGlobalMediaCapabilities();
+  if (!mediaCapabilities) {
+    return Promise.resolve(null);
+  }
+  const contentType = resolveEncodingContentType(config.codec);
+  if (contentType === null) {
+    return Promise.resolve(null);
+  }
+  if (!(typeof config.bitrate === "number")) {
+    return Promise.resolve(null);
+  }
+  if (!(typeof config.framerate === "number")) {
+    return Promise.resolve(null);
+  }
+  return mediaCapabilities.encodingInfo({
+    type: "record",
+    video: {
+      contentType,
+      width: config.width,
+      height: config.height,
+      bitrate: config.bitrate,
+      framerate: config.framerate
+    }
+  });
+}
 function probeVideoEncoderConfig(config) {
   if (typeof globalThis.VideoEncoder === "undefined") {
     return Promise.resolve({
@@ -1336,7 +1378,8 @@ function resolveDependencies(dependencies) {
     secureContextProvider: dependencies?.secureContextProvider ?? isSecureContextAvailable,
     mediaRecorderAvailabilityProvider: dependencies?.mediaRecorderAvailabilityProvider ?? isMediaRecorderAvailable,
     videoEncoderAvailabilityProvider: dependencies?.videoEncoderAvailabilityProvider ?? isVideoEncoderAvailable,
-    codecSupportProbe: dependencies?.codecSupportProbe ?? probeVideoEncoderConfig
+    codecSupportProbe: dependencies?.codecSupportProbe ?? probeVideoEncoderConfig,
+    encodingCapabilityProbe: dependencies?.encodingCapabilityProbe ?? probeVideoEncodingCapability
   };
 }
 function parseUserAgent(userAgent) {
@@ -1362,14 +1405,22 @@ function normalizeProbeErrorMessage(error) {
   }
   return String(error);
 }
-async function probeCodecCandidate(candidate, codecSupportProbe) {
+async function probeCodecCandidate(candidate, codecSupportProbe, encodingCapabilityProbe) {
   try {
     const result = await codecSupportProbe(candidate.config);
-    return {
+    const encodingCapability = await probeEncodingCapability(candidate.config, encodingCapabilityProbe);
+    const probeResult = {
       id: candidate.id,
       config: candidate.config,
       supported: result.supported === true
     };
+    if (encodingCapability === undefined) {
+      return probeResult;
+    }
+    return {
+      ...probeResult,
+      encodingCapability
+    };
   } catch (error) {
     return {
       id: candidate.id,
@@ -1380,10 +1431,28 @@ async function probeCodecCandidate(candidate, codecSupportProbe) {
     };
   }
 }
+function probeEncodingCapability(config, encodingCapabilityProbe) {
+  return Promise.resolve().then(() => encodingCapabilityProbe(config)).then((result) => {
+    if (result === null) {
+      return;
+    }
+    return {
+      supported: result.supported === true,
+      smooth: result.smooth === true,
+      powerEfficient: result.powerEfficient === true
+    };
+  }).catch((error) => ({
+    supported: false,
+    smooth: false,
+    powerEfficient: false,
+    errorCode: "encoding-capability-probe-error",
+    errorMessage: normalizeProbeErrorMessage(error)
+  }));
+}
 async function buildDeviceCapabilityProfile(options = {}) {
   const dependencies = resolveDependencies(options.dependencies);
   const { browser, os } = parseUserAgent(dependencies.navigatorProvider?.userAgent);
-  const codecProbeResults = await Promise.all((options.codecCandidates ?? []).map((candidate) => probeCodecCandidate(candidate, dependencies.codecSupportProbe)));
+  const codecProbeResults = await Promise.all((options.codecCandidates ?? []).map((candidate) => probeCodecCandidate(candidate, dependencies.codecSupportProbe, dependencies.encodingCapabilityProbe)));
   return {
     browser,
     os,
@@ -1406,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 = 4;
+var DEFAULT_MIN_HARDWARE_CONCURRENCY = 5;
 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) {
   const deviceMemory = profile.resources.deviceMemory;
@@ -1416,18 +1485,14 @@ function hasSufficientHardwareConcurrency(profile, minHardwareConcurrency) {
   const hardwareConcurrency = profile.resources.hardwareConcurrency;
   return hardwareConcurrency === undefined || hardwareConcurrency >= minHardwareConcurrency;
 }
-function findSupportedTargetCodecId(profile, targetCodecIds) {
+function findSupportedTargetCodec(profile, targetCodecIds) {
   const targetCodecIdSet = new Set(targetCodecIds);
-  const supportedCodec = profile.codecProbeResults.find((result) => targetCodecIdSet.has(result.id) && result.supported);
-  return supportedCodec?.id;
+  return profile.codecProbeResults.find((result) => targetCodecIdSet.has(result.id) && result.supported);
 }
 function canUsePostRecordingTranscodeRoute(profile, hasSupportedTargetCodec) {
   return profile.features.isSecureContext && profile.features.hasMediaRecorder && profile.features.hasVideoEncoder && hasSupportedTargetCodec && profile.network.online !== false;
 }
-function isAndroidBrowser(profile) {
-  return profile.os.name.toLowerCase() === "android";
-}
-function buildLocalRouteBlockers(profile, hasSupportedTargetCodec, hasEnoughDeviceMemory, hasEnoughHardwareConcurrency) {
+function buildLocalRouteBlockers(profile, hasSupportedTargetCodec, hasEnoughDeviceMemory, hasEnoughHardwareConcurrency, hasSupportedEncodingCapability, hasSmoothEncoding, hasPowerEfficientEncoding) {
   const reasonCodes = [];
   if (!profile.features.isSecureContext) {
     reasonCodes.push("insecure-context");
@@ -1444,8 +1509,14 @@ function buildLocalRouteBlockers(profile, hasSupportedTargetCodec, hasEnoughDevi
   if (!hasEnoughHardwareConcurrency) {
     reasonCodes.push("insufficient-hardware-concurrency");
   }
-  if (isAndroidBrowser(profile)) {
-    reasonCodes.push("android-post-recording-transcode");
+  if (!hasSupportedEncodingCapability) {
+    reasonCodes.push("encoding-capability-unsupported");
+  }
+  if (!hasSmoothEncoding) {
+    reasonCodes.push("encoding-not-smooth");
+  }
+  if (!hasPowerEfficientEncoding) {
+    reasonCodes.push("encoding-not-power-efficient");
   }
   return reasonCodes;
 }
@@ -1459,15 +1530,31 @@ function buildFallbackRouteBlockers(profile) {
   }
   return reasonCodes;
 }
+function hasSupportedEncodingCapability(selectedCodec) {
+  const encodingCapability = selectedCodec?.encodingCapability;
+  return encodingCapability === undefined || encodingCapability.errorCode !== undefined || encodingCapability.supported === true;
+}
+function hasSmoothEncodingCapability(selectedCodec) {
+  const encodingCapability = selectedCodec?.encodingCapability;
+  return encodingCapability === undefined || encodingCapability.errorCode !== undefined || encodingCapability.supported !== true || encodingCapability.smooth === true;
+}
+function hasPowerEfficientEncodingCapability(selectedCodec) {
+  const encodingCapability = selectedCodec?.encodingCapability;
+  return encodingCapability === undefined || encodingCapability.errorCode !== undefined || encodingCapability.supported !== true || encodingCapability.powerEfficient === true;
+}
 function decideRecordingRoute(options) {
   const minDeviceMemory = options.resourceThresholds?.minDeviceMemory ?? DEFAULT_MIN_DEVICE_MEMORY_GB;
   const minHardwareConcurrency = options.resourceThresholds?.minHardwareConcurrency ?? DEFAULT_MIN_HARDWARE_CONCURRENCY;
-  const selectedCodecId = findSupportedTargetCodecId(options.profile, options.targetCodecIds);
+  const selectedCodec = findSupportedTargetCodec(options.profile, options.targetCodecIds);
+  const selectedCodecId = selectedCodec?.id;
   const hasSupportedTargetCodec = selectedCodecId !== undefined;
   const hasEnoughDeviceMemory = hasSufficientDeviceMemory(options.profile, minDeviceMemory);
   const hasEnoughHardwareConcurrency = hasSufficientHardwareConcurrency(options.profile, minHardwareConcurrency);
-  const localRouteBlockers = buildLocalRouteBlockers(options.profile, hasSupportedTargetCodec, hasEnoughDeviceMemory, hasEnoughHardwareConcurrency);
-  if (options.profile.features.isSecureContext && options.profile.features.hasVideoEncoder && hasSupportedTargetCodec && options.profile.network.online !== false && !isAndroidBrowser(options.profile) && hasEnoughDeviceMemory && hasEnoughHardwareConcurrency) {
+  const hasSupportedEncoding = hasSupportedEncodingCapability(selectedCodec);
+  const hasSmoothEncoding = hasSmoothEncodingCapability(selectedCodec);
+  const hasPowerEfficientEncoding = hasPowerEfficientEncodingCapability(selectedCodec);
+  const localRouteBlockers = buildLocalRouteBlockers(options.profile, hasSupportedTargetCodec, hasEnoughDeviceMemory, hasEnoughHardwareConcurrency, hasSupportedEncoding, hasSmoothEncoding, hasPowerEfficientEncoding);
+  if (options.profile.features.isSecureContext && options.profile.features.hasVideoEncoder && hasSupportedTargetCodec && options.profile.network.online !== false && hasEnoughDeviceMemory && hasEnoughHardwareConcurrency && hasSupportedEncoding && hasSmoothEncoding && hasPowerEfficientEncoding) {
     return {
       route: "local-webcodecs",
       reasonCodes: ["webcodecs-supported", "target-codec-supported"],
@@ -4952,6 +5039,7 @@ class StreamManager {
 var ERROR_RECORDING_STOP_NOT_READY = "recording.stop-not-ready";
 var ERROR_RECORDING_FINALIZE_NOT_READY = "recording.finalize-not-ready";
 var ERROR_RECORDING_FINALIZE_TIMEOUT = "recording.finalize-timeout";
+var ERROR_RECORDING_UPLOAD_IN_PROGRESS = "recording.upload-in-progress";
 function createRecordingLifecycleError(code, message, details) {
   const error = new Error(`${message} [${code}]`);
   error.code = code;
@@ -4978,7 +5066,7 @@ function normalizeRecordingLifecycleError(error) {
 }
 function isRecordingLifecycleError(error) {
   const errorWithCode = error;
-  return errorWithCode.code === ERROR_RECORDING_STOP_NOT_READY || errorWithCode.code === ERROR_RECORDING_FINALIZE_NOT_READY || errorWithCode.code === ERROR_RECORDING_FINALIZE_TIMEOUT;
+  return errorWithCode.code === ERROR_RECORDING_STOP_NOT_READY || errorWithCode.code === ERROR_RECORDING_FINALIZE_NOT_READY || errorWithCode.code === ERROR_RECORDING_FINALIZE_TIMEOUT || errorWithCode.code === ERROR_RECORDING_UPLOAD_IN_PROGRESS;
 }
 
 // src/core/utils/formatters.ts
@@ -5158,11 +5246,6 @@ var LOW_RESOURCE_SAFE_CAPTURE_CONSTRAINTS = {
   height: { ideal: 480, max: 480 },
   frameRate: { ideal: 20, max: 20 }
 };
-var ANDROID_SAFE_CAPTURE_CONSTRAINTS = {
-  width: { ideal: 1280, max: 1280 },
-  height: { ideal: 720, max: 720 },
-  frameRate: { ideal: 24, max: 24 }
-};
 function createUnsupportedRouteError(routeDecision) {
   const guidance = routeDecision.guidance?.message ?? "This browser or device cannot safely record video. Try a supported browser or upload an existing video file.";
   const error = new Error(guidance);
@@ -5549,12 +5632,9 @@ class StreamRecordingState {
   }
   resolveSafeCaptureVideoConstraints() {
     const reasonCodes = this.activeRouteDecision.reasonCodes;
-    if (reasonCodes.includes("insufficient-device-memory") || reasonCodes.includes("insufficient-hardware-concurrency")) {
+    if (reasonCodes.includes("insufficient-device-memory") || reasonCodes.includes("insufficient-hardware-concurrency") || reasonCodes.includes("encoding-capability-unsupported") || reasonCodes.includes("encoding-not-smooth") || reasonCodes.includes("encoding-not-power-efficient")) {
       return LOW_RESOURCE_SAFE_CAPTURE_CONSTRAINTS;
     }
-    if (reasonCodes.includes("android-post-recording-transcode")) {
-      return ANDROID_SAFE_CAPTURE_CONSTRAINTS;
-    }
     return null;
   }
   async stopSafeCaptureRecording() {
@@ -6061,7 +6141,7 @@ function resolveDeviceError(input) {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.6.2",
+  version: "1.6.3",
   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",
@@ -6206,7 +6286,7 @@ var TELEMETRY_EVENT_CATEGORY_MAP = {
   "audio.acquisition.retry": "lifecycle",
   "audio.acquisition.recovered": "lifecycle",
   "audio.acquisition.failed": "error",
-  "audio.warning": "error",
+  "audio.warning": "performance",
   "recording.audio-missing": "error",
   "storage.init.failed": "error",
   "storage.write.probe.failed": "error"
@@ -22867,6 +22947,7 @@ class RecorderController {
   isDestroyed = false;
   enableTabVisibilityOverlay = false;
   tabVisibilityOverlayText;
+  isUploadInProgress = false;
   recordingWarmupTimeoutId = null;
   audioTelemetryUnsub = null;
   constructor(callbacks = {}) {
@@ -23010,6 +23091,9 @@ class RecorderController {
       succeededEvent: "recording.start.succeeded",
       failedEvent: "recording.start.failed",
       action: async () => {
+        if (this.isUploading()) {
+          throw createRecordingLifecycleError(ERROR_RECORDING_UPLOAD_IN_PROGRESS, "Previous recording is still being uploaded");
+        }
         await this.ensureConfigReady();
         await this.streamManager.waitForAudio();
         await this.recordingManager.startRecording();
@@ -23063,7 +23147,7 @@ class RecorderController {
       properties.silenceRatio = error.details.durationMs > 0 ? error.details.mutedDurationMs / error.details.durationMs : 0;
       properties.hadTrackEndedWarning = error.details.hadTrackEndedWarning;
     }
-    this.telemetryManager.sendEvent("recording.audio-missing", properties);
+    this.telemetryManager.sendEvent("recording.audio-missing", properties, error);
   }
   getTabVisibilityOverlayConfig() {
     return {
@@ -23124,8 +23208,15 @@ class RecorderController {
   getAudioLevel() {
     return this.audioLevelAnalyzer.getAudioLevel();
   }
-  async uploadVideo(blob, apiKey, backendUrl, metadata) {
+  uploadVideo(blob, apiKey, backendUrl, metadata) {
     this.uploadCallbacks.onClearStatus();
+    this.isUploadInProgress = true;
+    return this.uploadVideoAfterStatusClear(blob, apiKey, backendUrl, metadata).catch((error) => {
+      this.isUploadInProgress = false;
+      throw error;
+    });
+  }
+  async uploadVideoAfterStatusClear(blob, apiKey, backendUrl, metadata) {
     const duration = await extractVideoDuration(blob);
     const outputFormat = this.configManager.getConfigForRecording().format;
     const filename = `recording-${Date.now()}.${getFileExtensionForOutputFormat(outputFormat)}`;
@@ -23206,6 +23297,8 @@ class RecorderController {
         sourceType: options.sourceType
       }, uploadError);
       throw uploadError;
+    } finally {
+      this.isUploadInProgress = false;
     }
   }
   getStream() {
@@ -23229,6 +23322,7 @@ class RecorderController {
   }
   cleanup() {
     this.isDestroyed = true;
+    this.isUploadInProgress = false;
     if (this.recordingWarmupTimeoutId !== null) {
       clearTimeout(this.recordingWarmupTimeoutId);
       this.recordingWarmupTimeoutId = null;
@@ -23270,6 +23364,9 @@ class RecorderController {
   getUploadService() {
     return this.uploadService;
   }
+  isUploading() {
+    return this.isUploadInProgress;
+  }
   isRecording() {
     return this.streamManager.isRecording();
   }
@@ -23368,7 +23465,10 @@ class RecorderController {
         isSecureContext: profile.features.isSecureContext,
         hasMediaRecorder: profile.features.hasMediaRecorder,
         hasVideoEncoder: profile.features.hasVideoEncoder,
-        supportedCodecIds: profile.codecProbeResults.filter((result) => result.supported).map((result) => result.id)
+        supportedCodecIds: profile.codecProbeResults.filter((result) => result.supported).map((result) => result.id),
+        supportedEncodingCodecIds: profile.codecProbeResults.filter((result) => result.encodingCapability?.supported === true).map((result) => result.id),
+        smoothEncodingCodecIds: profile.codecProbeResults.filter((result) => result.encodingCapability?.smooth === true).map((result) => result.id),
+        powerEfficientEncodingCodecIds: profile.codecProbeResults.filter((result) => result.encodingCapability?.powerEfficient === true).map((result) => result.id)
       }
     };
   }
@@ -23422,9 +23522,10 @@ class RecorderController {
     const probeResult = this.storageManager.getWriteProbeResult();
     if (!probeResult?.ok) {
       const reason = probeResult?.reason ?? "Storage write probe did not complete";
+      const storageWriteProbeError = new Error(reason);
       this.telemetryManager.sendEvent("storage.write.probe.failed", {
         reason
-      });
+      }, storageWriteProbeError);
       const onStorageWriteError = resolveStorageWriteErrorCallback(this.callbacks);
       onStorageWriteError(reason);
       return;
@@ -23439,6 +23540,7 @@ class RecorderController {
         this.uploadCallbacks.onProgress(progress);
       },
       onUploadComplete: (id, result) => {
+        this.isUploadInProgress = false;
         this.uploadCallbacks.onSuccess(result);
         const metadata = this.uploadMetadataManager.getMetadata(id);
         if (metadata) {
@@ -23452,6 +23554,7 @@ class RecorderController {
         }
       },
       onUploadError: (id, error) => {
+        this.isUploadInProgress = false;
         this.uploadCallbacks.onError(error);
         const metadata = this.uploadMetadataManager.getMetadata(id);
         if (metadata) {

package/package.json

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