@vidtreo/recorder 1.6.3 → 1.7.1

package/dist/index.js

@@ -1476,6 +1476,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 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) {
   const deviceMemory = profile.resources.deviceMemory;
@@ -1530,6 +1531,17 @@ function buildFallbackRouteBlockers(profile) {
   }
   return reasonCodes;
 }
+function isAndroidProfile(profile) {
+  return profile.os.name.toLowerCase().includes(PLATFORM_KEYWORD_ANDROID2);
+}
+function buildPostRecordingTranscodeReasonCodes(profile, localRouteBlockers) {
+  const reasonCodes = [...localRouteBlockers];
+  if (isAndroidProfile(profile)) {
+    reasonCodes.push("android-post-recording-transcode");
+  }
+  reasonCodes.push("mediarecorder-supported");
+  return reasonCodes;
+}
 function hasSupportedEncodingCapability(selectedCodec) {
   const encodingCapability = selectedCodec?.encodingCapability;
   return encodingCapability === undefined || encodingCapability.errorCode !== undefined || encodingCapability.supported === true;
@@ -1554,6 +1566,13 @@ 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) {
     return {
       route: "local-webcodecs",
@@ -1564,7 +1583,7 @@ function decideRecordingRoute(options) {
   if (canUsePostRecordingTranscodeRoute(options.profile, hasSupportedTargetCodec)) {
     return {
       route: "safe-capture-post-recording-transcode",
-      reasonCodes: [...localRouteBlockers, "mediarecorder-supported"],
+      reasonCodes: buildPostRecordingTranscodeReasonCodes(options.profile, localRouteBlockers),
       selectedCodecId
     };
   }
@@ -1758,6 +1777,12 @@ async function resolveAudioCodecFromPolicy(options) {
   if (options.bitrate !== undefined) {
     audioCodecOptions.bitrate = options.bitrate;
   }
+  if (options.numberOfChannels !== undefined) {
+    audioCodecOptions.numberOfChannels = options.numberOfChannels;
+  }
+  if (options.sampleRate !== undefined) {
+    audioCodecOptions.sampleRate = options.sampleRate;
+  }
   const probeResults = await Promise.allSettled([
     getFirstEncodableAudioCodec(candidates, audioCodecOptions)
   ]);
@@ -5246,6 +5271,16 @@ 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 }
+};
+var SAFE_CAPTURE_TIMESLICE_MS = 1000;
+var MEDIA_RECORDER_ERROR_FINALIZE_TIMEOUT_MS = 5000;
+var ANDROID_POST_RECORDING_TRANSCODE_REASON = "android-post-recording-transcode";
+var MEDIA_RECORDER_ERROR_CODE = "recording.mediarecorder-error";
+var MEDIA_RECORDER_EMPTY_ERROR_CODE = "recording.mediarecorder-empty";
 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);
@@ -5277,6 +5312,8 @@ class StreamRecordingState {
   mediaRecorderStopPromise = null;
   mediaRecorderStopResolve = null;
   mediaRecorderStopReject = null;
+  mediaRecorderError = null;
+  mediaRecorderErrorTimeoutId = null;
   streamManager;
   dependencies;
   constructor(streamManager, dependencies) {
@@ -5449,9 +5486,11 @@ class StreamRecordingState {
     }
     let result;
     if (this.activeRouteDecision.route === "safe-capture-post-recording-transcode") {
+      const safeCaptureResult = await this.stopSafeCaptureRecording();
       logger.debug("[StreamRecordingState] Finalizing MediaRecorder capture");
       result = {
-        blob: await this.stopSafeCaptureRecording()
+        blob: safeCaptureResult.blob,
+        mediaRecorderDiagnostics: safeCaptureResult.diagnostics
       };
     } else {
       logger.debug("[StreamRecordingState] Finalizing stream processor");
@@ -5470,7 +5509,8 @@ class StreamRecordingState {
       blob: result.blob,
       tabVisibilityIntervals,
       recordingStats: result.recordingStats,
-      encoderAcceleration: result.encoderAcceleration
+      encoderAcceleration: result.encoderAcceleration,
+      mediaRecorderDiagnostics: result.mediaRecorderDiagnostics
     };
   }
   pauseRecording() {
@@ -5481,6 +5521,9 @@ class StreamRecordingState {
     if (this.tabVisibilityTracker) {
       this.tabVisibilityTracker.pause();
     }
+    if (this.mediaRecorder?.state === "recording") {
+      this.mediaRecorder.pause?.();
+    }
     if (this.streamProcessor && this.isRecording()) {
       this.streamProcessor.pause();
     }
@@ -5494,6 +5537,9 @@ class StreamRecordingState {
     if (this.tabVisibilityTracker) {
       this.tabVisibilityTracker.resume();
     }
+    if (this.mediaRecorder?.state === "paused") {
+      this.mediaRecorder.resume?.();
+    }
     this.startRecordingTimer();
     if (this.streamProcessor && this.isRecording()) {
       this.streamProcessor.resume();
@@ -5593,6 +5639,7 @@ class StreamRecordingState {
     }
     await this.applySafeCaptureTrackConstraints(mediaStream);
     this.mediaRecorderChunks = [];
+    this.mediaRecorderError = null;
     const preferredMimeType = this.resolvePreferredSafeCaptureMimeType(config);
     const recorderOptions = preferredMimeType === undefined ? undefined : { mimeType: preferredMimeType };
     const recorder = new MediaRecorder(mediaStream, recorderOptions);
@@ -5601,20 +5648,34 @@ class StreamRecordingState {
       this.mediaRecorderStopResolve = resolve;
       this.mediaRecorderStopReject = reject;
     });
+    this.mediaRecorderStopPromise.catch(() => {
+      return;
+    });
     recorder.ondataavailable = (event) => {
       if (event.data.size > 0) {
         this.mediaRecorderChunks.push(event.data);
       }
     };
     recorder.onstop = () => {
+      this.clearMediaRecorderErrorTimeout();
+      if (this.mediaRecorderError !== null) {
+        this.updateMediaRecorderErrorDiagnostics(recorder);
+        this.mediaRecorderStopReject?.(this.mediaRecorderError);
+        return;
+      }
       const mimeType = recorder.mimeType || this.resolveSafeCaptureMimeType();
       const blob = new Blob(this.mediaRecorderChunks, { type: mimeType });
-      this.mediaRecorderStopResolve?.(blob);
+      const diagnostics = this.buildMediaRecorderDiagnostics(recorder);
+      if (blob.size > 0) {
+        this.mediaRecorderStopResolve?.({ blob, diagnostics });
+        return;
+      }
+      this.mediaRecorderStopReject?.(this.createEmptyMediaRecorderError(recorder));
     };
-    recorder.onerror = () => {
-      this.mediaRecorderStopReject?.(new Error("Browser recording failed before upload could start"));
+    recorder.onerror = (event) => {
+      this.mediaRecorderError = this.createMediaRecorderError(event, recorder);
     };
-    recorder.start();
+    recorder.start(SAFE_CAPTURE_TIMESLICE_MS);
   }
   async applySafeCaptureTrackConstraints(mediaStream) {
     const constraints = this.resolveSafeCaptureVideoConstraints();
@@ -5635,6 +5696,9 @@ class StreamRecordingState {
     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_REASON)) {
+      return ANDROID_SAFE_CAPTURE_CONSTRAINTS;
+    }
     return null;
   }
   async stopSafeCaptureRecording() {
@@ -5646,6 +5710,7 @@ class StreamRecordingState {
     if (recorder.state !== "inactive") {
       recorder.stop();
     }
+    this.scheduleMediaRecorderErrorFinalizeTimeout(recorder);
     try {
       return await stopPromise;
     } finally {
@@ -5654,6 +5719,8 @@ class StreamRecordingState {
       this.mediaRecorderStopPromise = null;
       this.mediaRecorderStopResolve = null;
       this.mediaRecorderStopReject = null;
+      this.mediaRecorderError = null;
+      this.clearMediaRecorderErrorTimeout();
       this.activeRouteDecision = DEFAULT_ROUTE_DECISION;
     }
   }
@@ -5669,17 +5736,110 @@ class StreamRecordingState {
       }
       return MediaRecorder.isTypeSupported(mimeType);
     };
-    const candidateMimeTypes = config.format === "mp4" ? [
-      "video/mp4;codecs=avc1.42E01E,mp4a.40.2",
-      "video/mp4;codecs=avc1.42001f,mp4a.40.2",
-      "video/mp4"
-    ] : [
+    const webmCandidateMimeTypes = [
       "video/webm;codecs=vp8,opus",
       "video/webm;codecs=vp9,opus",
       "video/webm"
     ];
+    const mp4CandidateMimeTypes = [
+      "video/mp4;codecs=avc1.42E01E,mp4a.40.2",
+      "video/mp4;codecs=avc1.42001f,mp4a.40.2",
+      "video/mp4"
+    ];
+    let candidateMimeTypes = mp4CandidateMimeTypes;
+    if (this.shouldPreferWebmSafeCapture(config)) {
+      candidateMimeTypes = [
+        ...webmCandidateMimeTypes,
+        ...mp4CandidateMimeTypes
+      ];
+    } else if (config.format !== "mp4") {
+      candidateMimeTypes = webmCandidateMimeTypes;
+    }
     return candidateMimeTypes.find(canUseMimeType);
   }
+  shouldPreferWebmSafeCapture(config) {
+    if (config.format !== "mp4") {
+      return false;
+    }
+    return this.activeRouteDecision.reasonCodes.includes(ANDROID_POST_RECORDING_TRANSCODE_REASON);
+  }
+  scheduleMediaRecorderErrorFinalizeTimeout(recorder) {
+    if (this.mediaRecorderErrorTimeoutId !== null) {
+      return;
+    }
+    this.mediaRecorderErrorTimeoutId = window.setTimeout(() => {
+      if (this.mediaRecorderError !== null) {
+        this.mediaRecorderStopReject?.(this.mediaRecorderError);
+        return;
+      }
+      this.mediaRecorderStopReject?.(this.createEmptyMediaRecorderError(recorder));
+    }, MEDIA_RECORDER_ERROR_FINALIZE_TIMEOUT_MS);
+  }
+  clearMediaRecorderErrorTimeout() {
+    if (this.mediaRecorderErrorTimeoutId === null) {
+      return;
+    }
+    window.clearTimeout(this.mediaRecorderErrorTimeoutId);
+    this.mediaRecorderErrorTimeoutId = null;
+  }
+  createMediaRecorderError(event, recorder) {
+    const mediaRecorderEvent = event;
+    const browserError = mediaRecorderEvent.error;
+    const error = new Error("Browser recording failed before upload could start");
+    error.name = "MediaRecorderRecordingError";
+    error.code = MEDIA_RECORDER_ERROR_CODE;
+    error.mediaRecorderMimeType = recorder.mimeType;
+    error.mediaRecorderChunkCount = this.mediaRecorderChunks.length;
+    error.mediaRecorderChunkSize = this.getMediaRecorderChunkSize();
+    if (browserError?.name) {
+      error.mediaRecorderErrorName = browserError.name;
+    }
+    if (browserError?.message) {
+      error.mediaRecorderErrorMessage = browserError.message;
+    }
+    return error;
+  }
+  createEmptyMediaRecorderError(recorder) {
+    const error = new Error("Browser recording produced no data before upload could start");
+    error.name = "MediaRecorderEmptyDataError";
+    error.code = MEDIA_RECORDER_EMPTY_ERROR_CODE;
+    error.mediaRecorderMimeType = recorder.mimeType;
+    error.mediaRecorderChunkCount = this.mediaRecorderChunks.length;
+    error.mediaRecorderChunkSize = this.getMediaRecorderChunkSize();
+    if (this.mediaRecorderError?.mediaRecorderErrorName) {
+      error.mediaRecorderErrorName = this.mediaRecorderError.mediaRecorderErrorName;
+    }
+    if (this.mediaRecorderError?.mediaRecorderErrorMessage) {
+      error.mediaRecorderErrorMessage = this.mediaRecorderError.mediaRecorderErrorMessage;
+    }
+    return error;
+  }
+  updateMediaRecorderErrorDiagnostics(recorder) {
+    if (this.mediaRecorderError === null) {
+      return;
+    }
+    this.mediaRecorderError.mediaRecorderMimeType = recorder.mimeType;
+    this.mediaRecorderError.mediaRecorderChunkCount = this.mediaRecorderChunks.length;
+    this.mediaRecorderError.mediaRecorderChunkSize = this.getMediaRecorderChunkSize();
+  }
+  buildMediaRecorderDiagnostics(recorder) {
+    const diagnostics = {
+      mediaRecorderMimeType: recorder.mimeType,
+      mediaRecorderChunkCount: this.mediaRecorderChunks.length,
+      mediaRecorderChunkSize: this.getMediaRecorderChunkSize(),
+      mediaRecorderHadError: this.mediaRecorderError !== null
+    };
+    if (this.mediaRecorderError?.mediaRecorderErrorName) {
+      diagnostics.mediaRecorderErrorName = this.mediaRecorderError.mediaRecorderErrorName;
+    }
+    if (this.mediaRecorderError?.mediaRecorderErrorMessage) {
+      diagnostics.mediaRecorderErrorMessage = this.mediaRecorderError.mediaRecorderErrorMessage;
+    }
+    return diagnostics;
+  }
+  getMediaRecorderChunkSize() {
+    return this.mediaRecorderChunks.reduce((total, chunk) => total + chunk.size, 0);
+  }
   resetPauseState() {
     this.totalPausedTime = 0;
     this.pauseStartTime = null;
@@ -5759,6 +5919,8 @@ class StreamRecordingState {
     this.mediaRecorderStopPromise = null;
     this.mediaRecorderStopResolve = null;
     this.mediaRecorderStopReject = null;
+    this.mediaRecorderError = null;
+    this.clearMediaRecorderErrorTimeout();
     this.activeRouteDecision = DEFAULT_ROUTE_DECISION;
     if (this.streamProcessor) {
       this.streamProcessor.destroy();
@@ -5906,6 +6068,8 @@ var RECORDING_CODEC_UNSUPPORTED_CODES = new Set([
 ]);
 var RECORDING_SERVER_TRANSCODE_FALLBACK_CODES = new Set([
   "recording.post-recording-transcode-fallback",
+  "recording.mediarecorder-empty",
+  "recording.mediarecorder-error",
   "transcode.post-recording-fallback",
   "route.post-recording-transcode-fallback"
 ]);
@@ -6141,7 +6305,7 @@ function resolveDeviceError(input) {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.6.3",
+  version: "1.7.1",
   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",
@@ -6226,6 +6390,13 @@ var MAX_RETRY_ATTEMPTS = 3;
 var MAX_PENDING_EVENTS = 100;
 var BRACKET_ERROR_CODE_PATTERN = /\[([a-z]+(?:[.-][a-z0-9]+)+)\]/i;
 var INLINE_ERROR_CODE_PATTERN = /\b([a-z]+(?:[.-][a-z0-9]+)+)\b/i;
+var MEDIA_RECORDER_ERROR_PROPERTY_KEYS = [
+  "mediaRecorderErrorName",
+  "mediaRecorderErrorMessage",
+  "mediaRecorderMimeType",
+  "mediaRecorderChunkCount",
+  "mediaRecorderChunkSize"
+];
 function resolveInstallationId(dependencies) {
   const storageProvider = dependencies.storageProvider;
   const stored = storageProvider?.getItem(TELEMETRY_STORAGE_KEY);
@@ -6567,6 +6738,23 @@ class TelemetryClient {
         recordingPipelineErrorCode: recordingPipelineCode
       };
     }
+    return {
+      ...properties,
+      ...this.buildMediaRecorderErrorProperties(error)
+    };
+  }
+  buildMediaRecorderErrorProperties(error) {
+    if (!(error && typeof error === "object")) {
+      return {};
+    }
+    const candidate = error;
+    let properties = {};
+    for (const key of MEDIA_RECORDER_ERROR_PROPERTY_KEYS) {
+      const value = candidate[key];
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        properties = { ...properties, [key]: value };
+      }
+    }
     return properties;
   }
   buildFingerprint() {
@@ -20980,6 +21168,8 @@ var CODEC_CACHE_AUDIO_OVERRIDE = "audioOverride";
 var CODEC_CACHE_VIDEO_OVERRIDE = "videoOverride";
 var CODEC_CACHE_AUDIO_BITRATE = "audioBitrate";
 var CODEC_CACHE_VIDEO_BITRATE = "videoBitrate";
+var CODEC_CACHE_AUDIO_CHANNELS = "audioChannels";
+var CODEC_CACHE_AUDIO_SAMPLE_RATE = "audioSampleRate";
 var CODEC_CACHE_WIDTH = "width";
 var CODEC_CACHE_HEIGHT = "height";
 var CODEC_CACHE_POLICY_PREFERRED_AUDIO = "policyPreferredAudio";
@@ -21241,7 +21431,6 @@ class WorkerProcessor {
       isLinuxPlatform: this.isLinuxPlatformFn()
     });
     const audioBitrate = this.resolveAudioBitrate(config, format);
-    const audioCodec = await this.resolveAudioCodecWithCache(config, format, policy, audioBitrate);
     const codec = await this.resolveVideoCodecWithCache(config, format, policy);
     const isScreenCapture = isScreenCaptureStream(stream);
     logger.debug("[WorkerProcessor] Starting processing", {
@@ -21250,7 +21439,6 @@ class WorkerProcessor {
       codec,
       bitrate: config.bitrate
     });
-    const workerConfig = this.buildWorkerTranscodeConfig(config, audioCodec, audioBitrate, codec, format);
     if (typeof config.fps === "number" && config.fps > 0) {
       this.lastConfigFps = config.fps;
     }
@@ -21286,6 +21474,8 @@ class WorkerProcessor {
         };
       }
       const { audioConfig, audioStream, shouldStartAudioWorklet } = await this.prepareAudioPipeline(audioTrack, workerProbeResult);
+      const audioCodec = await this.resolveAudioCodecWithCache(config, format, policy, audioBitrate, audioConfig);
+      const workerConfig = this.buildWorkerTranscodeConfig(config, audioCodec, audioBitrate, codec, format);
       const overlayConfigToSend = this.buildOverlayConfigToSend();
       const message = createStartMessage({
         videoTrack: videoInput.videoTrack,
@@ -21545,12 +21735,14 @@ class WorkerProcessor {
     }
     return getPresetAudioBitrateForFormat(format);
   }
-  async resolveAudioCodec(config, format, policy, audioBitrate) {
+  async resolveAudioCodec(config, format, policy, audioBitrate, audioConfig) {
     return await resolveAudioCodecFromPolicy({
       format,
       overrideCodec: config.audioCodec,
       policy,
-      bitrate: audioBitrate
+      bitrate: audioBitrate,
+      numberOfChannels: audioConfig?.numberOfChannels,
+      sampleRate: audioConfig?.sampleRate
     });
   }
   async resolveVideoCodec(config, format, policy) {
@@ -21563,13 +21755,13 @@ class WorkerProcessor {
       bitrate: config.bitrate
     });
   }
-  async resolveAudioCodecWithCache(config, format, policy, audioBitrate) {
-    const audioCodecCacheKey = this.buildAudioCodecCacheKey(config, format, policy, audioBitrate);
+  async resolveAudioCodecWithCache(config, format, policy, audioBitrate, audioConfig) {
+    const audioCodecCacheKey = this.buildAudioCodecCacheKey(config, format, policy, audioBitrate, audioConfig);
     const cachedAudioCodec = resolvedAudioCodecCache.get(audioCodecCacheKey);
     if (cachedAudioCodec) {
       return cachedAudioCodec;
     }
-    const resolvedAudioCodec = await this.resolveAudioCodec(config, format, policy, audioBitrate);
+    const resolvedAudioCodec = await this.resolveAudioCodec(config, format, policy, audioBitrate, audioConfig);
     setCodecCacheValue(resolvedAudioCodecCache, audioCodecCacheKey, resolvedAudioCodec);
     return resolvedAudioCodec;
   }
@@ -21583,15 +21775,19 @@ class WorkerProcessor {
     setCodecCacheValue(resolvedVideoCodecCache, videoCodecCacheKey, resolvedVideoCodec);
     return resolvedVideoCodec;
   }
-  buildAudioCodecCacheKey(config, format, policy, audioBitrate) {
+  buildAudioCodecCacheKey(config, format, policy, audioBitrate, audioConfig) {
     const audioOverride = formatCacheValue(config.audioCodec);
     const preferredAudioCodec = formatCacheValue(policy.preferredAudioCodec);
     const audioFallbackOrder = formatCacheArray(policy.audioCodecFallbackOrder);
     const audioBitrateValue = formatCacheValue(audioBitrate);
+    const audioChannelsValue = formatCacheValue(audioConfig?.numberOfChannels);
+    const audioSampleRateValue = formatCacheValue(audioConfig?.sampleRate);
     return [
       buildCacheEntry(CODEC_CACHE_FORMAT, formatCacheValue(format)),
       buildCacheEntry(CODEC_CACHE_AUDIO_OVERRIDE, audioOverride),
       buildCacheEntry(CODEC_CACHE_AUDIO_BITRATE, audioBitrateValue),
+      buildCacheEntry(CODEC_CACHE_AUDIO_CHANNELS, audioChannelsValue),
+      buildCacheEntry(CODEC_CACHE_AUDIO_SAMPLE_RATE, audioSampleRateValue),
       buildCacheEntry(CODEC_CACHE_POLICY_PREFERRED_AUDIO, preferredAudioCodec),
       buildCacheEntry(CODEC_CACHE_POLICY_AUDIO_FALLBACK, audioFallbackOrder)
     ].join(CODEC_CACHE_KEY_SEPARATOR);
@@ -22020,7 +22216,7 @@ class WorkerProcessor {
       isLinuxPlatform: this.isLinuxPlatformFn()
     });
     const cacheAudioBitrate = this.resolveAudioBitrate(config, format);
-    this.resolveAudioCodecWithCache(config, format, cachePolicy, cacheAudioBitrate).catch(this.handleWarmupCacheError);
+    this.resolveAudioCodecWithCache(config, format, cachePolicy, cacheAudioBitrate, null).catch(this.handleWarmupCacheError);
     this.resolveVideoCodecWithCache(config, format, cachePolicy).catch(this.handleWarmupCacheError);
     const workerConfig = this.buildWorkerTranscodeConfig(config, policy.preferredAudioCodec, audioBitrate, codec, format);
     const message = {
@@ -22637,6 +22833,9 @@ class RecordingManager {
       if (stopResult.encoderAcceleration !== undefined) {
         telemetryProperties.encoderAcceleration = stopResult.encoderAcceleration;
       }
+      if (stopResult.mediaRecorderDiagnostics !== undefined) {
+        Object.assign(telemetryProperties, stopResult.mediaRecorderDiagnostics);
+      }
       return {
         blob: finalBlob,
         telemetryProperties
@@ -22646,6 +22845,10 @@ class RecordingManager {
       this.handleError(normalizedError);
       this.recordingState = RECORDING_STATE_IDLE;
       this.callbacks.onStateChange(this.recordingState);
+      if (this.streamProcessor) {
+        this.streamProcessor.destroy();
+        this.streamProcessor = null;
+      }
       throw normalizedError;
     } finally {
       this.activeRecordingConfig = null;
@@ -23105,6 +23308,7 @@ class RecorderController {
   }
   async stopRecording() {
     const sourceType = this.getCurrentSourceType();
+    let shouldStopStream = true;
     try {
       const stopResult = await this.telemetryManager.executeActionWithResult({
         requestedEvent: "recording.stop.requested",
@@ -23115,7 +23319,6 @@ class RecorderController {
           await this.sourceSwitchManager.handleRecordingStop().catch(() => {
             throw new Error("Source switch cleanup failed");
           });
-          this.streamManager.stopStream();
           return recordingStopResult;
         },
         properties: {
@@ -23127,11 +23330,22 @@ class RecorderController {
       });
       return stopResult.blob;
     } catch (error) {
+      shouldStopStream = this.shouldStopStreamAfterStopFailure(error);
       if (isAudioMissingError(error)) {
         this.sendAudioMissingTelemetry(error);
       }
       throw error;
+    } finally {
+      if (shouldStopStream) {
+        this.streamManager.stopStream();
+      }
+    }
+  }
+  shouldStopStreamAfterStopFailure(error) {
+    if (!(error && typeof error === "object" && ("code" in error))) {
+      return true;
     }
+    return error.code !== ERROR_RECORDING_STOP_NOT_READY;
   }
   sendAudioMissingTelemetry(error) {
     const properties = {

package/package.json

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