@vidtreo/recorder 1.6.2 → 1.7.0

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export type StopRecordingResult = {
     tabVisibilityIntervals: VisibilityInterval[];
     recordingStats?: StreamRecordingStats;
     encoderAcceleration?: VideoHardwareAcceleration;
+    mediaRecorderDiagnostics?: Record<string, unknown>;
 };
 type CheckRecorderSupportDependency = (options: SupportCheckOptions) => Promise<SupportReport>;
 type GetCurrentTimestampDependency = () => number;
@@ -32,6 +33,8 @@ export declare class StreamRecordingState {
     private mediaRecorderStopPromise;
     private mediaRecorderStopResolve;
     private mediaRecorderStopReject;
+    private mediaRecorderError;
+    private mediaRecorderErrorTimeoutId;
     private readonly streamManager;
     private readonly dependencies;
     constructor(streamManager: StreamManager, dependencies?: Partial<StreamRecordingStateDependencies>);
@@ -60,6 +63,14 @@ export declare class StreamRecordingState {
     private stopSafeCaptureRecording;
     private resolveSafeCaptureMimeType;
     private resolvePreferredSafeCaptureMimeType;
+    private shouldPreferWebmSafeCapture;
+    private scheduleMediaRecorderErrorFinalizeTimeout;
+    private clearMediaRecorderErrorTimeout;
+    private createMediaRecorderError;
+    private createEmptyMediaRecorderError;
+    private updateMediaRecorderErrorDiagnostics;
+    private buildMediaRecorderDiagnostics;
+    private getMediaRecorderChunkSize;
     private resetPauseState;
     private resolveTabVisibilityOverlayText;
     private setupVisibilityUpdates;
@@ -683,9 +694,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 +731,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[];
@@ -1326,6 +1347,7 @@ export declare class TelemetryClient {
     private isSafeCapabilityValue;
     private isRouteSourceType;
     private buildErrorProperties;
+    private buildMediaRecorderErrorProperties;
     private buildFingerprint;
     private buildContext;
     private buildError;
@@ -2443,7 +2465,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" | "android-post-recording-transcode" | "offline";
 export type RecordingRouteDecision = {
     route: RecordingRoute;
     reasonCodes: RecordingRouteReasonCode[];
@@ -2466,7 +2488,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 +2782,7 @@ export declare class RecorderController {
     private isDestroyed;
     private enableTabVisibilityOverlay;
     private tabVisibilityOverlayText;
+    private isUploadInProgress;
     private recordingWarmupTimeoutId;
     private audioTelemetryUnsub;
     constructor(callbacks?: RecorderCallbacks);
@@ -2769,6 +2793,7 @@ export declare class RecorderController {
     switchAudioDevice(deviceId: string | null): Promise<MediaStream>;
     startRecording(): Promise<void>;
     stopRecording(): Promise<Blob>;
+    private shouldStopStreamAfterStopFailure;
     private sendAudioMissingTelemetry;
     getTabVisibilityOverlayConfig(): {
         enabled: boolean;
@@ -2788,6 +2813,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 +2828,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,8 @@ 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 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;
@@ -1416,18 +1486,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 +1510,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 +1531,49 @@ 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;
+}
+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 (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",
       reasonCodes: ["webcodecs-supported", "target-codec-supported"],
@@ -1477,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
     };
   }
@@ -4952,6 +5058,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 +5085,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
@@ -5163,6 +5270,11 @@ var ANDROID_SAFE_CAPTURE_CONSTRAINTS = {
   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);
@@ -5194,6 +5306,8 @@ class StreamRecordingState {
   mediaRecorderStopPromise = null;
   mediaRecorderStopResolve = null;
   mediaRecorderStopReject = null;
+  mediaRecorderError = null;
+  mediaRecorderErrorTimeoutId = null;
   streamManager;
   dependencies;
   constructor(streamManager, dependencies) {
@@ -5366,9 +5480,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");
@@ -5387,7 +5503,8 @@ class StreamRecordingState {
       blob: result.blob,
       tabVisibilityIntervals,
       recordingStats: result.recordingStats,
-      encoderAcceleration: result.encoderAcceleration
+      encoderAcceleration: result.encoderAcceleration,
+      mediaRecorderDiagnostics: result.mediaRecorderDiagnostics
     };
   }
   pauseRecording() {
@@ -5398,6 +5515,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();
     }
@@ -5411,6 +5531,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();
@@ -5510,6 +5633,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);
@@ -5518,20 +5642,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();
@@ -5549,10 +5687,10 @@ 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")) {
+    if (reasonCodes.includes(ANDROID_POST_RECORDING_TRANSCODE_REASON)) {
       return ANDROID_SAFE_CAPTURE_CONSTRAINTS;
     }
     return null;
@@ -5566,6 +5704,7 @@ class StreamRecordingState {
     if (recorder.state !== "inactive") {
       recorder.stop();
     }
+    this.scheduleMediaRecorderErrorFinalizeTimeout(recorder);
     try {
       return await stopPromise;
     } finally {
@@ -5574,6 +5713,8 @@ class StreamRecordingState {
       this.mediaRecorderStopPromise = null;
       this.mediaRecorderStopResolve = null;
       this.mediaRecorderStopReject = null;
+      this.mediaRecorderError = null;
+      this.clearMediaRecorderErrorTimeout();
       this.activeRouteDecision = DEFAULT_ROUTE_DECISION;
     }
   }
@@ -5589,17 +5730,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;
@@ -5679,6 +5913,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();
@@ -5826,6 +6062,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"
 ]);
@@ -6061,7 +6299,7 @@ function resolveDeviceError(input) {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.6.2",
+  version: "1.7.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",
@@ -6146,6 +6384,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);
@@ -6206,7 +6451,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"
@@ -6487,6 +6732,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() {
@@ -22557,6 +22819,9 @@ class RecordingManager {
       if (stopResult.encoderAcceleration !== undefined) {
         telemetryProperties.encoderAcceleration = stopResult.encoderAcceleration;
       }
+      if (stopResult.mediaRecorderDiagnostics !== undefined) {
+        Object.assign(telemetryProperties, stopResult.mediaRecorderDiagnostics);
+      }
       return {
         blob: finalBlob,
         telemetryProperties
@@ -22566,6 +22831,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;
@@ -22867,6 +23136,7 @@ class RecorderController {
   isDestroyed = false;
   enableTabVisibilityOverlay = false;
   tabVisibilityOverlayText;
+  isUploadInProgress = false;
   recordingWarmupTimeoutId = null;
   audioTelemetryUnsub = null;
   constructor(callbacks = {}) {
@@ -23010,6 +23280,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();
@@ -23021,6 +23294,7 @@ class RecorderController {
   }
   async stopRecording() {
     const sourceType = this.getCurrentSourceType();
+    let shouldStopStream = true;
     try {
       const stopResult = await this.telemetryManager.executeActionWithResult({
         requestedEvent: "recording.stop.requested",
@@ -23031,7 +23305,6 @@ class RecorderController {
           await this.sourceSwitchManager.handleRecordingStop().catch(() => {
             throw new Error("Source switch cleanup failed");
           });
-          this.streamManager.stopStream();
           return recordingStopResult;
         },
         properties: {
@@ -23043,11 +23316,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 = {
@@ -23063,7 +23347,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 +23408,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 +23497,8 @@ class RecorderController {
         sourceType: options.sourceType
       }, uploadError);
       throw uploadError;
+    } finally {
+      this.isUploadInProgress = false;
     }
   }
   getStream() {
@@ -23229,6 +23522,7 @@ class RecorderController {
   }
   cleanup() {
     this.isDestroyed = true;
+    this.isUploadInProgress = false;
     if (this.recordingWarmupTimeoutId !== null) {
       clearTimeout(this.recordingWarmupTimeoutId);
       this.recordingWarmupTimeoutId = null;
@@ -23270,6 +23564,9 @@ class RecorderController {
   getUploadService() {
     return this.uploadService;
   }
+  isUploading() {
+    return this.isUploadInProgress;
+  }
   isRecording() {
     return this.streamManager.isRecording();
   }
@@ -23368,7 +23665,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 +23722,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 +23740,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 +23754,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.7.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",