@vidtreo/recorder 1.6.1 → 1.6.3

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"],
@@ -1695,6 +1782,36 @@ async function resolveAudioCodecFromPolicy(options) {
   return options.policy.preferredAudioCodec;
 }
 
+// src/core/transcode/output-format.ts
+function getMimeTypeForOutputFormat(format) {
+  switch (format) {
+    case "mp4":
+      return "video/mp4";
+    case "webm":
+      return "video/webm";
+    case "mkv":
+      return "video/x-matroska";
+    case "mov":
+      return "video/quicktime";
+    default:
+      throw new Error(`Unsupported output format: ${format}`);
+  }
+}
+function getFileExtensionForOutputFormat(format) {
+  switch (format) {
+    case "mp4":
+      return "mp4";
+    case "webm":
+      return "webm";
+    case "mkv":
+      return "mkv";
+    case "mov":
+      return "mov";
+    default:
+      throw new Error(`Unsupported output format: ${format}`);
+  }
+}
+
 // src/core/transcode/video-transcoder.ts
 var ALLOW_ROTATION_METADATA = false;
 function createSource(input) {
@@ -1720,20 +1837,6 @@ function createOutputFormat(format) {
       throw new Error(`Unsupported output format: ${format}`);
   }
 }
-function getMimeTypeForFormat(format) {
-  switch (format) {
-    case "mp4":
-      return "video/mp4";
-    case "webm":
-      return "video/webm";
-    case "mkv":
-      return "video/x-matroska";
-    case "mov":
-      return "video/quicktime";
-    default:
-      throw new Error(`Unsupported output format: ${format}`);
-  }
-}
 function createConversionOptions(config, optimizeForSpeed = false) {
   const video = {
     fit: "contain",
@@ -1828,7 +1931,7 @@ async function transcodeVideo(input, config = {}, onProgress) {
   if (!buffer) {
     throw new Error("Transcoding completed but no output buffer was generated");
   }
-  const mimeType = getMimeTypeForFormat(finalConfig.format);
+  const mimeType = getMimeTypeForOutputFormat(finalConfig.format);
   return {
     buffer,
     blob: new Blob([buffer], { type: mimeType })
@@ -1899,7 +2002,7 @@ async function transcodeVideoForNativeCamera(file, config = {}, onProgress) {
   if (!buffer) {
     throw new Error("Transcoding completed but no output buffer was generated");
   }
-  const mimeType = getMimeTypeForFormat(finalConfig.format);
+  const mimeType = getMimeTypeForOutputFormat(finalConfig.format);
   return {
     buffer,
     blob: new Blob([buffer], { type: mimeType })
@@ -4936,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;
@@ -4962,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
@@ -5142,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);
@@ -5533,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() {
@@ -6045,7 +6141,7 @@ function resolveDeviceError(input) {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.6.1",
+  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",
@@ -6190,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"
@@ -6852,6 +6948,7 @@ class UploadQueueManager {
         apiKey: upload.apiKey,
         backendUrl: upload.backendUrl,
         filename: upload.filename,
+        mimeType: upload.mimeType,
         metadata: upload.metadata,
         userMetadata: upload.userMetadata,
         onProgress: (progress) => {
@@ -6899,6 +6996,7 @@ class UploadQueueManager {
 
 // src/core/upload/upload-service.ts
 var API_UPLOAD_PATH = "/api/v1/videos/upload";
+var MIME_TYPE_PARAMETER_SEPARATOR = ";";
 
 class VideoUploadService {
   uploadVideo(blob, options) {
@@ -6913,6 +7011,7 @@ class VideoUploadService {
   uploadVideoFile(blob, options) {
     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) => {
@@ -6939,10 +7038,10 @@ class VideoUploadService {
       xhr.open("POST", url);
       xhr.setRequestHeader("Authorization", `Bearer ${options.apiKey}`);
       const formData = new FormData;
-      formData.append("file", blob, options.filename);
+      formData.append("file", uploadBlob, options.filename);
       const metadata = {
         filename: options.filename,
-        mimeType: blob.type
+        mimeType: uploadBlob.type
       };
       if (options.userMetadata) {
         metadata.userMetadata = options.userMetadata;
@@ -6951,6 +7050,26 @@ class VideoUploadService {
       xhr.send(formData);
     });
   }
+  createUploadBlob(blob, mimeType) {
+    const normalizedMimeType = this.resolveUploadMimeType(blob, mimeType);
+    if (normalizedMimeType === blob.type) {
+      return blob;
+    }
+    return new Blob([blob], { type: normalizedMimeType });
+  }
+  resolveUploadMimeType(blob, mimeType) {
+    if (mimeType && mimeType.trim().length > 0) {
+      return this.normalizeMimeType(mimeType);
+    }
+    return this.normalizeMimeType(blob.type);
+  }
+  normalizeMimeType(mimeType) {
+    const [baseMimeType] = mimeType.split(MIME_TYPE_PARAMETER_SEPARATOR);
+    if (baseMimeType === undefined) {
+      return mimeType.trim().toLowerCase();
+    }
+    return baseMimeType.trim().toLowerCase();
+  }
   parseSuccessResponse(xhr, resolve, reject) {
     const parsed = this.safeParseJsonFromXhr(xhr);
     if (!parsed) {
@@ -22276,23 +22395,9 @@ var DEFAULT_ROUTE_DECISION2 = {
 var DEFAULT_RECORDING_MANAGER_DEPENDENCIES = {
   transcodeVideo
 };
-function getExpectedMimeTypePrefix(config) {
-  switch (config.format) {
-    case "mp4":
-      return "video/mp4";
-    case "webm":
-      return "video/webm";
-    case "mkv":
-      return "video/x-matroska";
-    case "mov":
-      return "video/quicktime";
-    default:
-      return null;
-  }
-}
 function isBlobAlreadyInTargetFormat(blob, config) {
-  const expectedMimeTypePrefix = getExpectedMimeTypePrefix(config);
-  return expectedMimeTypePrefix !== null && blob.type.toLowerCase().startsWith(expectedMimeTypePrefix);
+  const expectedMimeTypePrefix = getMimeTypeForOutputFormat(config.format);
+  return blob.type.toLowerCase().startsWith(expectedMimeTypePrefix);
 }
 
 class RecordingManager {
@@ -22842,6 +22947,7 @@ class RecorderController {
   isDestroyed = false;
   enableTabVisibilityOverlay = false;
   tabVisibilityOverlayText;
+  isUploadInProgress = false;
   recordingWarmupTimeoutId = null;
   audioTelemetryUnsub = null;
   constructor(callbacks = {}) {
@@ -22985,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();
@@ -23038,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 {
@@ -23099,10 +23208,19 @@ 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 filename = `recording-${Date.now()}.mp4`;
+    const outputFormat = this.configManager.getConfigForRecording().format;
+    const filename = `recording-${Date.now()}.${getFileExtensionForOutputFormat(outputFormat)}`;
+    const mimeType = getMimeTypeForOutputFormat(outputFormat);
     const sourceType = this.getCurrentSourceType();
     let userMetadata;
     if (Object.keys(metadata).length > 0) {
@@ -23119,6 +23237,7 @@ class RecorderController {
         apiKey,
         backendUrl,
         filename,
+        mimeType,
         duration,
         sourceType,
         userMetadata
@@ -23130,6 +23249,7 @@ class RecorderController {
       apiKey,
       backendUrl,
       filename,
+      mimeType,
       duration,
       metadata: undefined,
       userMetadata
@@ -23156,6 +23276,7 @@ class RecorderController {
         apiKey: options.apiKey,
         backendUrl: options.backendUrl,
         filename: options.filename,
+        mimeType: options.mimeType,
         metadata: undefined,
         userMetadata: options.userMetadata,
         onProgress: this.uploadCallbacks.onProgress
@@ -23176,6 +23297,8 @@ class RecorderController {
         sourceType: options.sourceType
       }, uploadError);
       throw uploadError;
+    } finally {
+      this.isUploadInProgress = false;
     }
   }
   getStream() {
@@ -23199,6 +23322,7 @@ class RecorderController {
   }
   cleanup() {
     this.isDestroyed = true;
+    this.isUploadInProgress = false;
     if (this.recordingWarmupTimeoutId !== null) {
       clearTimeout(this.recordingWarmupTimeoutId);
       this.recordingWarmupTimeoutId = null;
@@ -23240,6 +23364,9 @@ class RecorderController {
   getUploadService() {
     return this.uploadService;
   }
+  isUploading() {
+    return this.isUploadInProgress;
+  }
   isRecording() {
     return this.streamManager.isRecording();
   }
@@ -23338,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)
       }
     };
   }
@@ -23392,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;
@@ -23409,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) {
@@ -23422,6 +23554,7 @@ class RecorderController {
         }
       },
       onUploadError: (id, error) => {
+        this.isUploadInProgress = false;
         this.uploadCallbacks.onError(error);
         const metadata = this.uploadMetadataManager.getMetadata(id);
         if (metadata) {
@@ -23854,8 +23987,10 @@ class VidtreoRecorder {
   async stopRecording() {
     await this.ensureInitialized();
     const blob = await this.controller.stopRecording();
+    const outputFormat = (await this.controller.getConfig()).format;
     const timestamp = Date.now();
-    const filename = `recording-${timestamp}.mp4`;
+    const filename = `recording-${timestamp}.${getFileExtensionForOutputFormat(outputFormat)}`;
+    const mimeType = getMimeTypeForOutputFormat(outputFormat);
     const uploadService = this.controller.getUploadService();
     if (!uploadService) {
       throw new Error("Upload service not available");
@@ -23864,6 +23999,7 @@ class VidtreoRecorder {
       apiKey: this.config.apiKey,
       backendUrl: this.config.apiUrl,
       filename,
+      mimeType,
       userMetadata: this.config.userMetadata,
       onProgress: this.config.onUploadProgress
     });

package/package.json

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