@vidtreo/recorder 1.4.1 → 1.5.1

package/dist/index.js

@@ -149,7 +149,15 @@ class AudioLevelAnalyzer {
 }
 // src/core/browser-guard/browser-guard.ts
 import { UAParser } from "ua-parser-js";
-var UNSUPPORTED_BROWSERS = ["ie", "internet explorer", "firefox"];
+var UNSUPPORTED_BROWSER_NAMES = new Set([
+  "firefox",
+  "ie",
+  "internet explorer",
+  "samsung browser"
+]);
+var SAMSUNG_INTERNET_UA_PATTERN = /\bsamsungbrowser\//i;
+var ANDROID_WEBVIEW_UA_PATTERN = /; wv\)| version\/4\.[\d.]+ chrome\//i;
+var GOOGLE_APP_UA_PATTERN = /\bgsa\//i;
 var BROWSER_UNSUPPORTED_ERROR_MESSAGE = "This browser is not supported for recording";
 var UNKNOWN_BROWSER_NAME = "unknown";
 var UNKNOWN_BROWSER_VERSION = "";
@@ -203,11 +211,16 @@ function createBrowserUnsupportedError(options = {}) {
   }
   return error;
 }
+function isUnsupportedBrowserPolicy(browserInfo, userAgent) {
+  if (UNSUPPORTED_BROWSER_NAMES.has(browserInfo.normalizedName)) {
+    return true;
+  }
+  return SAMSUNG_INTERNET_UA_PATTERN.test(userAgent) || ANDROID_WEBVIEW_UA_PATTERN.test(userAgent) || GOOGLE_APP_UA_PATTERN.test(userAgent);
+}
 function validateBrowserSupport() {
-  const browserInfo = getBrowserInfo();
-  const browserName = browserInfo.normalizedName;
-  const isUnsupported = UNSUPPORTED_BROWSERS.some((browser) => browserName.includes(browser));
-  if (isUnsupported) {
+  const userAgent = getUserAgent();
+  const browserInfo = parseBrowserInfo(userAgent);
+  if (isUnsupportedBrowserPolicy(browserInfo, userAgent)) {
     const error = createBrowserUnsupportedError({
       browserInfo,
       resolutionStage: "policy"
@@ -2177,7 +2190,7 @@ function getEmptyProbeResult() {
 }
 // src/core/storage/video-storage.ts
 var DB_NAME = "vidtreo-recorder";
-var DB_VERSION = 2;
+var DB_VERSION = 3;
 var STORE_NAME = "pending-uploads";
 var STATUS_INDEX = "status";
 var CREATED_AT_INDEX = "createdAt";
@@ -2190,6 +2203,10 @@ var VERSION_ERROR_NAME = "VersionError";
 var ERROR_SCHEMA_MISSING_STORE = "Database schema is missing required object store: pending-uploads";
 var ERROR_SCHEMA_MISSING_STATUS_INDEX = "Database schema is missing required index: status";
 var ERROR_SCHEMA_MISSING_CREATED_AT_INDEX = "Database schema is missing required index: createdAt";
+var ERROR_BLOB_READ_FAILED = "Failed to prepare upload data for storage. The recorded file could not be read.";
+var PROBE_RECORD_ID = "__probe__";
+var PROBE_DATA = new ArrayBuffer(1);
+var ERROR_PROBE_WRITE_FAILED = "Storage write probe failed. Browser may be in private browsing mode or IndexedDB writes are restricted.";
 
 class VideoStorageService {
   db = null;
@@ -2282,16 +2299,69 @@ class VideoStorageService {
   isInitialized() {
     return this.db !== null;
   }
-  savePendingUpload(upload) {
+  async probeWriteCapability() {
+    if (!this.db) {
+      return { ok: false, reason: "Database not initialized" };
+    }
+    try {
+      await this.executeTransaction("readwrite", (store) => {
+        const record = {
+          id: PROBE_RECORD_ID,
+          blobData: PROBE_DATA,
+          blobType: "application/octet-stream",
+          apiKey: "",
+          backendUrl: "",
+          filename: "probe",
+          status: "pending",
+          retryCount: 0,
+          createdAt: 0,
+          updatedAt: 0
+        };
+        return new Promise((resolve, reject) => {
+          const putRequest = store.put(record);
+          putRequest.onsuccess = () => {
+            const deleteRequest = store.delete(PROBE_RECORD_ID);
+            deleteRequest.onsuccess = () => resolve();
+            deleteRequest.onerror = () => {
+              if (deleteRequest.error) {
+                reject(deleteRequest.error);
+                return;
+              }
+              reject(new Error("Probe delete failed"));
+            };
+          };
+          putRequest.onerror = () => {
+            if (putRequest.error) {
+              reject(putRequest.error);
+              return;
+            }
+            reject(new Error("Probe write failed"));
+          };
+        });
+      });
+      return { ok: true };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        ok: false,
+        reason: `${ERROR_PROBE_WRITE_FAILED} ${message}`
+      };
+    }
+  }
+  async savePendingUpload(upload) {
     const id = this.generateUploadId();
+    const now = Date.now();
     const pendingUpload = {
       ...upload,
       id,
       status: "pending",
       retryCount: 0,
-      createdAt: Date.now(),
-      updatedAt: Date.now()
+      createdAt: now,
+      updatedAt: now,
+      blobData: await this.readBlobData(upload.blob),
+      blobType: upload.blob.type
     };
+    pendingUpload.blob = undefined;
     return this.executeTransaction("readwrite", (store) => {
       const request = store.add(pendingUpload);
       return new Promise((resolve, reject) => {
@@ -2319,7 +2389,7 @@ class VideoStorageService {
             reject(new Error("Failed to get uploads: result is undefined"));
             return;
           }
-          resolve(request.result);
+          resolve(request.result.map((upload) => this.hydrateUpload(upload)));
         };
         request.onerror = () => {
           if (request.error) {
@@ -2331,7 +2401,8 @@ class VideoStorageService {
       });
     });
   }
-  updateUploadStatus(id, updates) {
+  async updateUploadStatus(id, updates) {
+    const storedUpdates = await this.createStoredUpdates(updates);
     return this.executeTransaction("readwrite", (store) => {
       const getRequest = store.get(id);
       return new Promise((resolve, reject) => {
@@ -2342,15 +2413,15 @@ class VideoStorageService {
             return;
           }
           const updatedAt = updates.updatedAt !== undefined ? updates.updatedAt : Date.now();
-          const updated = { ...upload, ...updates, updatedAt };
+          const updated = { ...upload, ...storedUpdates, updatedAt };
           const putRequest = store.put(updated);
           putRequest.onsuccess = () => resolve();
           putRequest.onerror = () => {
             if (putRequest.error) {
               reject(putRequest.error);
-            } else {
-              reject(new Error("Failed to update upload"));
+              return;
             }
+            reject(new Error("Failed to update upload"));
           };
         };
         getRequest.onerror = () => {
@@ -2395,6 +2466,33 @@ class VideoStorageService {
     const uploads = await this.getPendingUploads();
     return uploads.reduce((total, upload) => total + upload.blob.size, 0);
   }
+  hydrateUpload(upload) {
+    if ("blobData" in upload && upload.blobData) {
+      const { blobData, blobType, ...rest } = upload;
+      return {
+        ...rest,
+        blob: new Blob([blobData], { type: blobType })
+      };
+    }
+    return upload;
+  }
+  async createStoredUpdates(updates) {
+    const storedUpdates = { ...updates };
+    if (updates.blob) {
+      storedUpdates.blobData = await this.readBlobData(updates.blob);
+      storedUpdates.blobType = updates.blob.type;
+      storedUpdates.blob = undefined;
+    }
+    return storedUpdates;
+  }
+  readBlobData(blob) {
+    return blob.arrayBuffer().catch((error) => {
+      if (error instanceof Error) {
+        throw new Error(`${ERROR_BLOB_READ_FAILED} ${error.message}`);
+      }
+      throw new Error(ERROR_BLOB_READ_FAILED);
+    });
+  }
   generateUploadId() {
     return `${ID_PREFIX}${Date.now()}-${Math.random().toString(36).substring(2, 2 + ID_RANDOM_LENGTH)}`;
   }
@@ -2404,7 +2502,38 @@ class VideoStorageService {
     }
     const transaction = this.db.transaction([STORE_NAME], mode);
     const store = transaction.objectStore(STORE_NAME);
-    return operation(store);
+    return new Promise((resolve, reject) => {
+      let operationResult;
+      let operationSettled = false;
+      let operationFailed = false;
+      transaction.oncomplete = () => {
+        if (!operationSettled || operationFailed) {
+          return;
+        }
+        resolve(operationResult);
+      };
+      transaction.onerror = () => {
+        if (transaction.error) {
+          reject(transaction.error);
+          return;
+        }
+        reject(new Error("Storage transaction failed"));
+      };
+      transaction.onabort = () => {
+        if (transaction.error) {
+          reject(transaction.error);
+          return;
+        }
+        reject(new Error("Storage transaction aborted"));
+      };
+      operation(store).then((result) => {
+        operationResult = result;
+        operationSettled = true;
+      }, (error) => {
+        operationFailed = true;
+        reject(error);
+      });
+    });
   }
 }
 
@@ -2415,6 +2544,7 @@ var CLEANUP_HOURS = 24;
 class StorageManager {
   storageService = null;
   cleanupIntervalId = null;
+  writeProbeResult = null;
   async initialize(onCleanupError) {
     if (!this.storageService) {
       this.storageService = new VideoStorageService;
@@ -2422,8 +2552,12 @@ class StorageManager {
     if (!this.storageService.isInitialized()) {
       await this.storageService.init();
     }
+    this.writeProbeResult = await this.storageService.probeWriteCapability();
     this.setupCleanupInterval(onCleanupError);
   }
+  getWriteProbeResult() {
+    return this.writeProbeResult;
+  }
   setupCleanupInterval(onCleanupError) {
     if (this.cleanupIntervalId === null) {
       this.cleanupIntervalId = window.setInterval(() => {
@@ -2442,6 +2576,9 @@ class StorageManager {
   getStorageService() {
     return this.storageService;
   }
+  isStorageWritable() {
+    return this.writeProbeResult?.ok === true;
+  }
   destroy() {
     if (this.cleanupIntervalId !== null) {
       clearInterval(this.cleanupIntervalId);
@@ -2617,10 +2754,15 @@ function buildVideoConstraints(cameraDeviceId, dependencies) {
   return constraints;
 }
 function buildAudioConstraints(micDeviceId) {
+  const constraints = {
+    echoCancellation: true,
+    noiseSuppression: true,
+    autoGainControl: true
+  };
   if (micDeviceId) {
-    return { deviceId: { exact: micDeviceId } };
+    return { ...constraints, deviceId: { exact: micDeviceId } };
   }
-  return true;
+  return constraints;
 }
 
 // src/core/stream/stream-utils.ts
@@ -4201,6 +4343,7 @@ class StreamRecordingState {
   visibilityChangeHandler = null;
   blurHandler = null;
   focusHandler = null;
+  preResolvedSupportReport = null;
   streamManager;
   dependencies;
   constructor(streamManager, dependencies) {
@@ -4224,6 +4367,9 @@ class StreamRecordingState {
       getCurrentTimestamp: resolvedGetCurrentTimestampDependency
     };
   }
+  setPreResolvedSupportReport(report) {
+    this.preResolvedSupportReport = report;
+  }
   isRecording() {
     return this.streamManager.getState() === "recording";
   }
@@ -4264,10 +4410,15 @@ class StreamRecordingState {
       throw new Error("Cannot start recording: no audio track available. Please check your microphone.");
     }
     const requiresWatermark = config.watermark !== undefined;
-    const supportReport = await this.dependencies.checkRecorderSupport({
-      requiresAudio: true,
-      requiresWatermark
-    });
+    let supportReport;
+    if (this.preResolvedSupportReport?.isSupported) {
+      supportReport = this.preResolvedSupportReport;
+    } else {
+      supportReport = await this.dependencies.checkRecorderSupport({
+        requiresAudio: true,
+        requiresWatermark
+      });
+    }
     if (!supportReport.isSupported) {
       const unsupportedError = createBrowserUnsupportedError({
         missingCapabilities: supportReport.missing,
@@ -4360,8 +4511,6 @@ class StreamRecordingState {
       blob: result.blob,
       mimeType: "video/mp4"
     });
-    this.streamProcessor = null;
-    logger.debug("[StreamRecordingState] StreamProcessor cleared");
     return {
       blob: result.blob,
       tabVisibilityIntervals,
@@ -4548,7 +4697,7 @@ class StreamRecordingState {
   }
   destroy() {
     if (this.streamProcessor) {
-      this.streamProcessor.cancel().catch(() => {});
+      this.streamProcessor.destroy();
       this.streamProcessor = null;
     }
     this.cleanupVisibilityUpdates();
@@ -4662,6 +4811,9 @@ class CameraStreamManager {
   async waitForAudio() {
     return await this.streamManager.waitForAudio();
   }
+  setPreResolvedSupportReport(report) {
+    this.recordingState.setPreResolvedSupportReport(report);
+  }
   destroy() {
     this.recordingState.destroy();
     this.streamManager.destroy();
@@ -4670,7 +4822,7 @@ class CameraStreamManager {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.4.1",
+  version: "1.5.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",
@@ -4753,6 +4905,8 @@ var BATCH_FLUSH_INTERVAL_MS = 1000;
 var THROTTLE_WINDOW_MS = 5000;
 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;
 function resolveInstallationId(dependencies) {
   const storageProvider = dependencies.storageProvider;
   const stored = storageProvider?.getItem(TELEMETRY_STORAGE_KEY);
@@ -4809,7 +4963,9 @@ var TELEMETRY_EVENT_CATEGORY_MAP = {
   "audio.acquisition.fallback": "lifecycle",
   "audio.acquisition.retry": "lifecycle",
   "audio.acquisition.recovered": "lifecycle",
-  "audio.acquisition.failed": "error"
+  "audio.acquisition.failed": "error",
+  "audio.warning": "error",
+  "storage.write.probe.failed": "error"
 };
 
 class TelemetryClient {
@@ -5054,6 +5210,10 @@ class TelemetryClient {
     const errorDto = {
       message
     };
+    const normalizedCode = this.extractNormalizedErrorCode(message);
+    if (normalizedCode) {
+      errorDto.normalizedCode = normalizedCode;
+    }
     if (error instanceof Error) {
       if (error.name) {
         errorDto.code = error.name;
@@ -5064,6 +5224,17 @@ class TelemetryClient {
     }
     return errorDto;
   }
+  extractNormalizedErrorCode(message) {
+    const bracketCodeMatch = message.match(BRACKET_ERROR_CODE_PATTERN);
+    if (bracketCodeMatch?.[1]) {
+      return bracketCodeMatch[1];
+    }
+    const inlineCodeMatch = message.match(INLINE_ERROR_CODE_PATTERN);
+    if (inlineCodeMatch?.[1]) {
+      return inlineCodeMatch[1];
+    }
+    return null;
+  }
   getBrowserName(userAgent) {
     if (!userAgent) {
       return BROWSER_UNKNOWN;
@@ -5542,6 +5713,9 @@ function resolveUploadCallbacks(callbacks) {
   }
   return uploadCallbacks;
 }
+var DEFAULT_ON_STORAGE_WRITE_ERROR = (_reason) => {
+  return;
+};
 function resolveStorageCleanupErrorCallback(callbacks) {
   let onStorageCleanupError = DEFAULT_ON_STORAGE_CLEANUP_ERROR;
   if (callbacks.onStorageCleanupError) {
@@ -5549,6 +5723,13 @@ function resolveStorageCleanupErrorCallback(callbacks) {
   }
   return onStorageCleanupError;
 }
+function resolveStorageWriteErrorCallback(callbacks) {
+  let onStorageWriteError = DEFAULT_ON_STORAGE_WRITE_ERROR;
+  if (callbacks.onStorageWriteError) {
+    onStorageWriteError = callbacks.onStorageWriteError;
+  }
+  return onStorageWriteError;
+}
 function createRecordingCallbacks(callbacks, dependencies) {
   const recordingCallbacks = callbacks.recording;
   let onStateChange = DEFAULT_ON_STATE_CHANGE;
@@ -5583,7 +5764,10 @@ function createRecordingCallbacks(callbacks, dependencies) {
     onRecordingComplete,
     onClearUploadStatus,
     onStopAudioTracking: dependencies.stopAudioTracking,
-    onGetConfig: dependencies.getConfig
+    onGetConfig: dependencies.getConfig,
+    ...dependencies.onAudioWarning && {
+      onAudioWarning: dependencies.onAudioWarning
+    }
   };
 }
 function createSourceSwitchCallbacks(callbacks, dependencies) {
@@ -5611,6 +5795,179 @@ function createSourceSwitchCallbacks(callbacks, dependencies) {
   };
 }
 
+// src/core/audio/audio-health-monitor.ts
+var DEFAULT_SILENCE_THRESHOLD = 0.001;
+var DEFAULT_LOW_SIGNAL_THRESHOLD = 0.05;
+var DEFAULT_SILENT_WARNING_DURATION_MS = 2000;
+var DEFAULT_NO_CHUNK_WARNING_DURATION_MS = 2000;
+
+class AudioHealthMonitor {
+  silenceThreshold;
+  lowSignalThreshold;
+  silentWarningDurationMs;
+  noChunkWarningDurationMs;
+  totalChunks = 0;
+  nonSilentChunks = 0;
+  lowSignalChunks = 0;
+  peak = 0;
+  rms = 0;
+  startedAtMs = null;
+  lastChunkTimestampMs = null;
+  silentStartedAtMs = null;
+  mutedStartedAtMs = null;
+  mutedDurationMs = 0;
+  currentMuted = false;
+  hasHealthySignal = false;
+  constructor(options = {}) {
+    this.silenceThreshold = this.resolveNumber(options.silenceThreshold, DEFAULT_SILENCE_THRESHOLD);
+    this.lowSignalThreshold = this.resolveNumber(options.lowSignalThreshold, DEFAULT_LOW_SIGNAL_THRESHOLD);
+    this.silentWarningDurationMs = this.resolveNumber(options.silentWarningDurationMs, DEFAULT_SILENT_WARNING_DURATION_MS);
+    this.noChunkWarningDurationMs = this.resolveNumber(options.noChunkWarningDurationMs, DEFAULT_NO_CHUNK_WARNING_DURATION_MS);
+  }
+  recordChunk(input) {
+    this.markStarted(input.timestampMs);
+    this.trackMuteState(input.timestampMs, input.isMuted);
+    const chunkStats = this.calculateChunkStats(input.samples);
+    const isSilent = chunkStats.peak <= this.silenceThreshold;
+    const isLowSignal = chunkStats.peak > this.silenceThreshold && chunkStats.peak < this.lowSignalThreshold;
+    this.totalChunks += 1;
+    this.peak = chunkStats.peak;
+    this.rms = chunkStats.rms;
+    if (!isSilent) {
+      this.nonSilentChunks += 1;
+      this.silentStartedAtMs = null;
+    }
+    if (isLowSignal) {
+      this.lowSignalChunks += 1;
+    }
+    if (chunkStats.peak >= this.lowSignalThreshold) {
+      this.hasHealthySignal = true;
+    }
+    if (isSilent && this.silentStartedAtMs === null) {
+      this.silentStartedAtMs = input.timestampMs;
+    }
+    this.lastChunkTimestampMs = input.timestampMs;
+    return this.snapshot(input.timestampMs, input.isMuted);
+  }
+  inspect(timestampMs, isMuted) {
+    this.markStarted(timestampMs);
+    this.trackMuteState(timestampMs, isMuted);
+    return this.snapshot(timestampMs, isMuted);
+  }
+  reset() {
+    this.totalChunks = 0;
+    this.nonSilentChunks = 0;
+    this.lowSignalChunks = 0;
+    this.peak = 0;
+    this.rms = 0;
+    this.startedAtMs = null;
+    this.lastChunkTimestampMs = null;
+    this.silentStartedAtMs = null;
+    this.mutedStartedAtMs = null;
+    this.mutedDurationMs = 0;
+    this.currentMuted = false;
+    this.hasHealthySignal = false;
+  }
+  snapshot(timestampMs, isMuted) {
+    const consecutiveSilentDurationMs = this.resolveSilentDuration(timestampMs);
+    const noChunkDurationMs = this.resolveNoChunkDuration(timestampMs);
+    const mutedDurationMs = this.resolveMutedDuration(timestampMs, isMuted);
+    return {
+      classification: this.classify(isMuted, consecutiveSilentDurationMs, noChunkDurationMs),
+      totalChunks: this.totalChunks,
+      nonSilentChunks: this.nonSilentChunks,
+      lowSignalChunks: this.lowSignalChunks,
+      peak: this.peak,
+      rms: this.rms,
+      consecutiveSilentDurationMs,
+      noChunkDurationMs,
+      mutedDurationMs
+    };
+  }
+  classify(isMuted, consecutiveSilentDurationMs, noChunkDurationMs) {
+    if (this.totalChunks === 0 && noChunkDurationMs >= this.noChunkWarningDurationMs) {
+      return "no-chunks";
+    }
+    if (isMuted && consecutiveSilentDurationMs >= this.silentWarningDurationMs) {
+      return "muted-silence-expected";
+    }
+    if (!isMuted && consecutiveSilentDurationMs >= this.silentWarningDurationMs) {
+      return "silent-while-unmuted";
+    }
+    if (!this.hasHealthySignal && this.nonSilentChunks > 0 && this.peak < this.lowSignalThreshold) {
+      return "low-signal";
+    }
+    return "healthy";
+  }
+  calculateChunkStats(samples) {
+    if (samples.length === 0) {
+      return { peak: 0, rms: 0 };
+    }
+    let peak = 0;
+    let sumSquares = 0;
+    for (const sample of samples) {
+      const absoluteSample = Math.abs(sample);
+      peak = Math.max(peak, absoluteSample);
+      sumSquares += sample * sample;
+    }
+    return {
+      peak,
+      rms: Math.sqrt(sumSquares / samples.length)
+    };
+  }
+  resolveSilentDuration(timestampMs) {
+    if (this.silentStartedAtMs === null) {
+      return 0;
+    }
+    return timestampMs - this.silentStartedAtMs;
+  }
+  resolveNoChunkDuration(timestampMs) {
+    if (this.lastChunkTimestampMs !== null) {
+      return timestampMs - this.lastChunkTimestampMs;
+    }
+    if (this.startedAtMs !== null) {
+      return timestampMs - this.startedAtMs;
+    }
+    return 0;
+  }
+  markStarted(timestampMs) {
+    if (this.startedAtMs !== null) {
+      return;
+    }
+    this.startedAtMs = timestampMs;
+  }
+  trackMuteState(timestampMs, isMuted) {
+    if (isMuted === this.currentMuted) {
+      return;
+    }
+    if (isMuted) {
+      this.mutedStartedAtMs = timestampMs;
+      this.currentMuted = true;
+      return;
+    }
+    if (this.mutedStartedAtMs !== null) {
+      this.mutedDurationMs += timestampMs - this.mutedStartedAtMs;
+    }
+    this.mutedStartedAtMs = null;
+    this.currentMuted = false;
+  }
+  resolveMutedDuration(timestampMs, isMuted) {
+    if (!(isMuted && this.mutedStartedAtMs !== null)) {
+      return this.mutedDurationMs;
+    }
+    return this.mutedDurationMs + timestampMs - this.mutedStartedAtMs;
+  }
+  resolveNumber(value, fallback) {
+    if (value === undefined) {
+      return fallback;
+    }
+    if (!Number.isFinite(value) || value < 0) {
+      throw new Error("Audio health monitor option must be a non-negative number");
+    }
+    return value;
+  }
+}
+
 // src/core/utils/stream-utils.ts
 function isScreenCaptureStream(stream) {
   const videoTracks = stream.getVideoTracks();
@@ -5664,6 +6021,10 @@ var MP4_FRAGMENT_BOX_TYPE_MFRA = "mfra";
 var ERROR_RECORDING_INVALID_CONTAINER_LAYOUT = "recording.invalid-container-layout";
 var ERROR_RECORDING_NO_VIDEO_TRACK = "recording.no-video-track";
 var ERROR_RECORDING_NO_VIDEO_FRAMES = "recording.no-video-frames";
+var ERROR_RECORDING_NO_AUDIO_TRACK = "recording.no-audio-track";
+var ERROR_RECORDING_NO_AUDIO_FRAMES = "recording.no-audio-frames";
+var ERROR_RECORDING_AUDIO_ZERO_CHANNELS = "recording.audio-zero-channels";
+var ERROR_RECORDING_AUDIO_INVALID_SAMPLE_RATE = "recording.audio-invalid-sample-rate";
 var MP4_BOX_TYPE_MOOV = "moov";
 var MP4_BOX_TYPE_TRAK = "trak";
 var MP4_BOX_TYPE_MDIA = "mdia";
@@ -5672,8 +6033,24 @@ var MP4_BOX_TYPE_MINF = "minf";
 var MP4_BOX_TYPE_STBL = "stbl";
 var MP4_BOX_TYPE_STSZ = "stsz";
 var MP4_HANDLER_VIDEO = "vide";
+var MP4_HANDLER_AUDIO = "soun";
 var MP4_HANDLER_TYPE_OFFSET_BYTES = 8;
 var MP4_STSZ_SAMPLE_COUNT_OFFSET_BYTES = 8;
+var MP4_BOX_TYPE_MDHD = "mdhd";
+var MP4_BOX_TYPE_STSD = "stsd";
+var MP4_MDHD_V0_TIMESCALE_OFFSET = 8;
+var MP4_MDHD_V0_DURATION_OFFSET = 12;
+var MP4_MDHD_V0_PAYLOAD_MIN_BYTES = 16;
+var MP4_STSD_ENTRY_COUNT_BYTES = 4;
+var MP4_FULL_BOX_VERSION_FLAGS_BYTES = 4;
+var MP4_AUDIO_SAMPLE_ENTRY_CHANNEL_OFFSET = 16;
+var MP4_AUDIO_SAMPLE_ENTRY_SAMPLE_RATE_OFFSET = 24;
+var MP4_AUDIO_SAMPLE_ENTRY_MIN_PAYLOAD = 28;
+var MP4_MIN_SAMPLE_RATE = 6000;
+var MP4_MAX_SAMPLE_RATE = 384000;
+function isSampleRateValid(sampleRate) {
+  return sampleRate >= MP4_MIN_SAMPLE_RATE && sampleRate <= MP4_MAX_SAMPLE_RATE;
+}
 function createInvalidMp4ContainerLayoutError(detectedBoxTypes) {
   const error = new Error(ERROR_RECORDING_INVALID_CONTAINER_LAYOUT);
   error.code = ERROR_RECORDING_INVALID_CONTAINER_LAYOUT;
@@ -5776,37 +6153,112 @@ function readAsciiAt(view, offset, endOffset) {
   }
   return readBoxType(view, offset);
 }
-function parseTrackVideoMetadata(bytes, trackBox) {
+function parseMdhdDuration(view, mediaChildren) {
+  const mdhdBox = findFirstBoxByType(mediaChildren, MP4_BOX_TYPE_MDHD);
+  if (mdhdBox === null) {
+    return 0;
+  }
+  const payloadBytesAvailable = mdhdBox.endOffset - mdhdBox.payloadStartOffset;
+  if (payloadBytesAvailable < MP4_MDHD_V0_PAYLOAD_MIN_BYTES) {
+    return 0;
+  }
+  const version = view.getUint8(mdhdBox.payloadStartOffset);
+  if (version !== 0) {
+    return 0;
+  }
+  const timescaleOffset = mdhdBox.payloadStartOffset + MP4_MDHD_V0_TIMESCALE_OFFSET;
+  const durationOffset = mdhdBox.payloadStartOffset + MP4_MDHD_V0_DURATION_OFFSET;
+  const timescale = view.getUint32(timescaleOffset, false);
+  const duration = view.getUint32(durationOffset, false);
+  if (timescale === 0) {
+    return 0;
+  }
+  return duration / timescale;
+}
+function parseAudioSampleEntry(view, sampleTableChildren) {
+  const stsdBox = findFirstBoxByType(sampleTableChildren, MP4_BOX_TYPE_STSD);
+  if (stsdBox === null) {
+    return { channelCount: 0, sampleRate: 0 };
+  }
+  const entryStart = stsdBox.payloadStartOffset + MP4_FULL_BOX_VERSION_FLAGS_BYTES + MP4_STSD_ENTRY_COUNT_BYTES;
+  const entryPayloadStart = entryStart + MP4_BOX_HEADER_BYTES;
+  const entryPayloadEnd = entryPayloadStart + MP4_AUDIO_SAMPLE_ENTRY_MIN_PAYLOAD;
+  if (entryPayloadEnd > stsdBox.endOffset) {
+    return { channelCount: 0, sampleRate: 0 };
+  }
+  const channelCount = view.getUint16(entryPayloadStart + MP4_AUDIO_SAMPLE_ENTRY_CHANNEL_OFFSET, false);
+  const sampleRateFull = view.getUint32(entryPayloadStart + MP4_AUDIO_SAMPLE_ENTRY_SAMPLE_RATE_OFFSET, false);
+  const sampleRate = Math.floor(sampleRateFull / 65536);
+  return { channelCount, sampleRate };
+}
+function parseTrackMetadata(bytes, trackBox, expectedHandler) {
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   const trackChildren = parseMp4BoxesInRange(bytes, trackBox.payloadStartOffset, trackBox.endOffset);
   const mediaBox = findFirstBoxByType(trackChildren, MP4_BOX_TYPE_MDIA);
   if (mediaBox === null) {
-    return { isVideoTrack: false, sampleCount: 0 };
+    return {
+      isMatchingTrack: false,
+      sampleCount: 0,
+      channelCount: 0,
+      sampleRate: 0,
+      durationSeconds: 0
+    };
   }
   const mediaChildren = parseMp4BoxesInRange(bytes, mediaBox.payloadStartOffset, mediaBox.endOffset);
   const handlerBox = findFirstBoxByType(mediaChildren, MP4_BOX_TYPE_HDLR);
   if (handlerBox === null) {
-    return { isVideoTrack: false, sampleCount: 0 };
+    return {
+      isMatchingTrack: false,
+      sampleCount: 0,
+      channelCount: 0,
+      sampleRate: 0,
+      durationSeconds: 0
+    };
   }
   const handlerTypeOffset = handlerBox.payloadStartOffset + MP4_HANDLER_TYPE_OFFSET_BYTES;
   const handlerType = readAsciiAt(view, handlerTypeOffset, handlerBox.endOffset);
-  const isVideoTrack = handlerType === MP4_HANDLER_VIDEO;
-  if (!isVideoTrack) {
-    return { isVideoTrack: false, sampleCount: 0 };
+  const isMatchingTrack = handlerType === expectedHandler;
+  if (!isMatchingTrack) {
+    return {
+      isMatchingTrack: false,
+      sampleCount: 0,
+      channelCount: 0,
+      sampleRate: 0,
+      durationSeconds: 0
+    };
   }
+  const durationSeconds = parseMdhdDuration(view, mediaChildren);
   const mediaInformationBox = findFirstBoxByType(mediaChildren, MP4_BOX_TYPE_MINF);
   if (mediaInformationBox === null) {
-    return { isVideoTrack: true, sampleCount: 0 };
+    return {
+      isMatchingTrack: true,
+      sampleCount: 0,
+      channelCount: 0,
+      sampleRate: 0,
+      durationSeconds
+    };
   }
   const mediaInformationChildren = parseMp4BoxesInRange(bytes, mediaInformationBox.payloadStartOffset, mediaInformationBox.endOffset);
   const sampleTableBox = findFirstBoxByType(mediaInformationChildren, MP4_BOX_TYPE_STBL);
   if (sampleTableBox === null) {
-    return { isVideoTrack: true, sampleCount: 0 };
+    return {
+      isMatchingTrack: true,
+      sampleCount: 0,
+      channelCount: 0,
+      sampleRate: 0,
+      durationSeconds
+    };
   }
   const sampleTableChildren = parseMp4BoxesInRange(bytes, sampleTableBox.payloadStartOffset, sampleTableBox.endOffset);
   const sampleSizeBox = findFirstBoxByType(sampleTableChildren, MP4_BOX_TYPE_STSZ);
   if (sampleSizeBox === null) {
-    return { isVideoTrack: true, sampleCount: 0 };
+    return {
+      isMatchingTrack: true,
+      sampleCount: 0,
+      channelCount: 0,
+      sampleRate: 0,
+      durationSeconds
+    };
   }
   const sampleCountOffset = sampleSizeBox.payloadStartOffset + MP4_STSZ_SAMPLE_COUNT_OFFSET_BYTES;
   const hasSampleCount = sampleCountOffset + MP4_BOX_TYPE_OFFSET_BYTES <= sampleSizeBox.endOffset;
@@ -5814,7 +6266,13 @@ function parseTrackVideoMetadata(bytes, trackBox) {
     throw createInvalidMp4ContainerLayoutError([MP4_BOX_TYPE_STSZ]);
   }
   const sampleCount = view.getUint32(sampleCountOffset, false);
-  return { isVideoTrack: true, sampleCount };
+  const audioFields = expectedHandler === MP4_HANDLER_AUDIO ? parseAudioSampleEntry(view, sampleTableChildren) : { channelCount: 0, sampleRate: 0 };
+  return {
+    isMatchingTrack: true,
+    sampleCount,
+    ...audioFields,
+    durationSeconds
+  };
 }
 function parseMp4TopLevelBoxes(input) {
   const bytes = toUint8Array(input);
@@ -5899,8 +6357,8 @@ function assertMp4HasVideoTrack(buffer) {
   }
   let hasVideoTrack = false;
   for (const trackBox of trackBoxes) {
-    const trackMetadata = parseTrackVideoMetadata(bytes, trackBox);
-    if (!trackMetadata.isVideoTrack) {
+    const trackMetadata = parseTrackMetadata(bytes, trackBox, MP4_HANDLER_VIDEO);
+    if (!trackMetadata.isMatchingTrack) {
       continue;
     }
     hasVideoTrack = true;
@@ -5913,6 +6371,41 @@ function assertMp4HasVideoTrack(buffer) {
   }
   throw createMp4TrackValidationError(ERROR_RECORDING_NO_VIDEO_FRAMES);
 }
+function assertMp4HasAudioTrack(buffer) {
+  const bytes = toUint8Array(buffer);
+  const topLevelBoxes = parseMp4BoxesInRange(bytes, 0, bytes.byteLength);
+  const movieBox = findFirstBoxByType(topLevelBoxes, MP4_BOX_TYPE_MOOV);
+  if (movieBox === null) {
+    throw createMp4TrackValidationError(ERROR_RECORDING_NO_AUDIO_TRACK);
+  }
+  const movieChildren = parseMp4BoxesInRange(bytes, movieBox.payloadStartOffset, movieBox.endOffset);
+  const trackBoxes = movieChildren.filter((box) => box.type === MP4_BOX_TYPE_TRAK);
+  if (trackBoxes.length === 0) {
+    throw createMp4TrackValidationError(ERROR_RECORDING_NO_AUDIO_TRACK);
+  }
+  let hasAudioTrack = false;
+  for (const trackBox of trackBoxes) {
+    const trackMetadata = parseTrackMetadata(bytes, trackBox, MP4_HANDLER_AUDIO);
+    if (!trackMetadata.isMatchingTrack) {
+      continue;
+    }
+    hasAudioTrack = true;
+    if (trackMetadata.sampleCount === 0) {
+      continue;
+    }
+    if (trackMetadata.channelCount === 0) {
+      throw createMp4TrackValidationError(ERROR_RECORDING_AUDIO_ZERO_CHANNELS);
+    }
+    if (!isSampleRateValid(trackMetadata.sampleRate)) {
+      throw createMp4TrackValidationError(ERROR_RECORDING_AUDIO_INVALID_SAMPLE_RATE);
+    }
+    return;
+  }
+  if (!hasAudioTrack) {
+    throw createMp4TrackValidationError(ERROR_RECORDING_NO_AUDIO_TRACK);
+  }
+  throw createMp4TrackValidationError(ERROR_RECORDING_NO_AUDIO_FRAMES);
+}
 
 // src/core/utils/shared-object-url-store.ts
 function createSharedObjectUrlStore(dependencies) {
@@ -6004,18 +6497,9 @@ class VidtreoAudioWorkletProcessor extends AudioWorkletProcessor {
     }
 
     const frames = firstChannel.length;
-    const numberOfChannels = inputGroup.length;
-    const totalSamples = frames * numberOfChannels;
-    const data = new Float32Array(totalSamples);
+    const data = new Float32Array(frames);
 
-    let channelIndex = 0;
-    while (channelIndex < numberOfChannels) {
-      const channelData = inputGroup[channelIndex];
-      if (channelData && channelData.length === frames) {
-        data.set(channelData, channelIndex * frames);
-      }
-      channelIndex += 1;
-    }
+    data.set(firstChannel);
 
     if (this.isMuted) {
       data.fill(0);
@@ -6029,7 +6513,7 @@ class VidtreoAudioWorkletProcessor extends AudioWorkletProcessor {
         type: AUDIO_WORKLET_MESSAGE_TYPE_AUDIO_CHUNK,
         data,
         frames,
-        numberOfChannels,
+        numberOfChannels: 1,
         sampleRate,
         timestamp,
       },
@@ -6045,7 +6529,7 @@ registerProcessor("${AUDIO_WORKLET_PROCESSOR_NAME}", VidtreoAudioWorkletProcesso
 
 // src/core/audio/audio-worklet-controller.ts
 var AUDIO_WORKLET_BLOB_TYPE = "application/javascript";
-var DEFAULT_AUDIO_CHANNELS = 1;
+var RECORDING_AUDIO_CHANNELS = 1;
 var AUDIO_WORKLET_OUTPUT_COUNT = 1;
 var AUDIO_WORKLET_INPUT_COUNT = 1;
 var SILENT_GAIN_VALUE = 0;
@@ -6101,11 +6585,10 @@ class AudioWorkletController {
         const errorMessage = extractErrorMessage(error);
         throw new Error(`Failed to load AudioWorklet module: ${errorMessage}`);
       });
-      const channelCount = this.getChannelCount(audioTracks[0]);
       const audioWorkletNode = new AudioWorkletNode(audioContext, AUDIO_WORKLET_PROCESSOR_NAME, {
         numberOfInputs: AUDIO_WORKLET_INPUT_COUNT,
         numberOfOutputs: AUDIO_WORKLET_OUTPUT_COUNT,
-        outputChannelCount: [channelCount]
+        outputChannelCount: [RECORDING_AUDIO_CHANNELS]
       });
       audioWorkletNode.port.onmessage = this.handleWorkletMessage.bind(this);
       this.audioWorkletNode = audioWorkletNode;
@@ -6114,7 +6597,7 @@ class AudioWorkletController {
       this.audioDestinationNode.gain.value = SILENT_GAIN_VALUE;
       const audioConfig = {
         sampleRate: audioContext.sampleRate,
-        numberOfChannels: channelCount,
+        numberOfChannels: RECORDING_AUDIO_CHANNELS,
         format: WORKER_AUDIO_SAMPLE_FORMAT_F32_PLANAR
       };
       this.audioConfig = audioConfig;
@@ -6211,14 +6694,6 @@ class AudioWorkletController {
     }
     return null;
   }
-  getChannelCount(audioTrack) {
-    const settings = audioTrack.getSettings();
-    const channelCount = settings.channelCount;
-    if (typeof channelCount === "number" && channelCount > 0) {
-      return channelCount;
-    }
-    return DEFAULT_AUDIO_CHANNELS;
-  }
   async cleanupAfterInitializeFailure() {
     this.disconnectAudioNodes(false);
     await this.closeAudioContext();
@@ -6337,6 +6812,116 @@ class AudioWorkletManager {
   }
 }
 
+// src/core/processor/worker/video-frame-preflight.ts
+var DEFAULT_PREFLIGHT_TIMEOUT_MS = 3000;
+var VIDEO_FIRST_FRAME_TIMEOUT_CODE = "video.first-frame-timeout";
+var defaultDependencies = {
+  createVideoStreamFromTrack: (track) => {
+    if (typeof MediaStreamTrackProcessor === "undefined") {
+      return null;
+    }
+    const processor = new MediaStreamTrackProcessor({ track });
+    return processor.readable;
+  },
+  setTimeout: (fn, ms) => window.setTimeout(fn, ms),
+  clearTimeout: (id) => window.clearTimeout(id),
+  performanceNow: () => performance.now()
+};
+async function performVideoFramePreflight(track, timeoutMs = DEFAULT_PREFLIGHT_TIMEOUT_MS, dependencies = {}) {
+  const deps = {
+    createVideoStreamFromTrack: dependencies.createVideoStreamFromTrack ?? defaultDependencies.createVideoStreamFromTrack,
+    setTimeout: dependencies.setTimeout ?? defaultDependencies.setTimeout,
+    clearTimeout: dependencies.clearTimeout ?? defaultDependencies.clearTimeout,
+    performanceNow: dependencies.performanceNow ?? defaultDependencies.performanceNow
+  };
+  const startTime = deps.performanceNow();
+  const preflightTrack = createPreflightTrack(track);
+  const videoStream = deps.createVideoStreamFromTrack(preflightTrack);
+  if (!videoStream) {
+    stopPreflightTrack(preflightTrack, track);
+    logger.debug("[VideoFramePreflight] Cannot create stream from track, skipping preflight");
+    return { elapsedMs: deps.performanceNow() - startTime };
+  }
+  const result = await raceFirstFrame(videoStream, timeoutMs, deps);
+  const elapsedMs = deps.performanceNow() - startTime;
+  logger.debug("[VideoFramePreflight] Completed", {
+    elapsedMs,
+    timedOut: result === null
+  });
+  if (result === null) {
+    await videoStream.cancel().catch(() => {
+      return;
+    });
+    stopPreflightTrack(preflightTrack, track);
+    const error = new Error(`Video stream failed to yield first frame within ${timeoutMs}ms`);
+    error.code = VIDEO_FIRST_FRAME_TIMEOUT_CODE;
+    error.elapsedMs = elapsedMs;
+    throw error;
+  }
+  result.frame.close();
+  result.reader.releaseLock();
+  videoStream.cancel().catch(() => {
+    return;
+  });
+  stopPreflightTrack(preflightTrack, track);
+  return { elapsedMs };
+}
+function createPreflightTrack(track) {
+  if (typeof track.clone !== "function") {
+    return track;
+  }
+  return track.clone();
+}
+function stopPreflightTrack(preflightTrack, originalTrack) {
+  if (preflightTrack === originalTrack) {
+    return;
+  }
+  preflightTrack.stop();
+}
+async function raceFirstFrame(videoStream, timeoutMs, deps) {
+  const reader = videoStream.getReader();
+  let timeoutId;
+  let settled = false;
+  const settle = () => {
+    if (settled) {
+      return false;
+    }
+    settled = true;
+    if (timeoutId !== undefined) {
+      deps.clearTimeout(timeoutId);
+    }
+    return true;
+  };
+  const timeoutPromise = new Promise((resolve) => {
+    timeoutId = deps.setTimeout(() => {
+      if (!settle()) {
+        return;
+      }
+      resolve(null);
+    }, timeoutMs);
+  });
+  const framePromise = reader.read().then(({ value, done }) => {
+    if (!settle()) {
+      return null;
+    }
+    if (done || !value) {
+      return null;
+    }
+    return { frame: value, reader };
+  }).catch(() => {
+    settle();
+    return null;
+  });
+  const result = await Promise.race([framePromise, timeoutPromise]);
+  if (result === null) {
+    await reader.cancel().catch(() => {
+      return;
+    });
+    reader.releaseLock();
+  }
+  return result;
+}
+
 // src/core/processor/worker/video-input-selector.ts
 function prepareVideoTrack(videoTracks, dependencies) {
   if (videoTracks.length === 0) {
@@ -6362,11 +6947,9 @@ function selectVideoInput(videoTrack, workerProbeResult, dependencies) {
   if (workerProbeResult.hasMediaStreamTrackProcessor) {
     return { videoTrack, videoStream: null };
   }
-  if (dependencies.canUseMainThreadVideoProcessor()) {
-    const videoStream = dependencies.createVideoStreamFromTrack(videoTrack);
-    if (videoStream) {
-      return { videoTrack: null, videoStream };
-    }
+  const videoStream = dependencies.createVideoStreamFromTrack(videoTrack);
+  if (videoStream) {
+    return { videoTrack: null, videoStream };
   }
   throw dependencies.createBrowserUnsupportedError();
 }
@@ -14464,6 +15047,7 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
 
   class BufferTracker {
     intervalId = null;
+    lastEmittedSize = null;
     dependencies;
     constructor(dependencies) {
       this.dependencies = dependencies;
@@ -14474,6 +15058,10 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       }
       this.intervalId = this.dependencies.setInterval(() => {
         const size = this.dependencies.getBufferSize();
+        if (size === this.lastEmittedSize) {
+          return;
+        }
+        this.lastEmittedSize = size;
         const formatted = formatFileSize(size);
         this.dependencies.onBufferUpdate(size, formatted);
       }, BUFFER_UPDATE_INTERVAL_MILLISECONDS);
@@ -14484,6 +15072,7 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       }
       this.dependencies.clearInterval(this.intervalId);
       this.intervalId = null;
+      this.lastEmittedSize = null;
     }
   }
   function formatFileSize(bytes2) {
@@ -15716,6 +16305,9 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
         case "updateSourceType":
           this.handleUpdateSourceType(message.isScreenCapture);
           return;
+        case "requestStats":
+          this.sendRecordingStats();
+          return;
         default:
           this.sendError(new Error(\`Unknown message type: \${message.type}\`));
       }
@@ -15973,13 +16565,15 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
         await this.cleanup();
       }
       this.initializeRecordingState(config);
-      if (message.videoSettings) {
-        this.frameCompositor.setVideoSettings(message.videoSettings);
+      const resolvedVideoSettings = message.videoSettings;
+      if (resolvedVideoSettings) {
+        this.frameCompositor.setVideoSettings(resolvedVideoSettings);
       } else {
         this.frameCompositor.setVideoSettings(null);
       }
-      if (message.viewportMetadata) {
-        this.frameCompositor.setViewportMetadata(message.viewportMetadata);
+      const resolvedViewportMetadata = message.viewportMetadata;
+      if (resolvedViewportMetadata) {
+        this.frameCompositor.setViewportMetadata(resolvedViewportMetadata);
       } else {
         this.frameCompositor.setViewportMetadata(null);
       }
@@ -16263,19 +16857,15 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       }
       this.setExpectedAudioFormat(message.sampleRate, message.numberOfChannels);
       if (this.expectedAudioSampleRate !== null && message.sampleRate !== this.expectedAudioSampleRate) {
-        logger.warn("[RecorderWorker] Audio sample rate changed", {
-          expectedSampleRate: this.expectedAudioSampleRate,
-          receivedSampleRate: message.sampleRate
-        });
+        this.sendError(new Error("Audio sample rate changed during recording"));
         return;
       }
-      let audioBuffer = message.data;
-      let numberOfChannels = message.numberOfChannels;
-      if (this.expectedAudioChannels !== null) {
-        const normalized = this.normalizeAudioBuffer(audioBuffer, message.frames, numberOfChannels, this.expectedAudioChannels);
-        audioBuffer = normalized.buffer;
-        numberOfChannels = normalized.numberOfChannels;
+      if (this.expectedAudioChannels !== null && message.numberOfChannels !== this.expectedAudioChannels) {
+        this.sendError(new Error("Audio channel count changed during recording"));
+        return;
       }
+      let audioBuffer = message.data;
+      const numberOfChannels = message.numberOfChannels;
       const expectedSamples = message.frames * numberOfChannels;
       if (audioBuffer.length < expectedSamples) {
         throw new Error("Audio buffer length is shorter than expected");
@@ -16294,10 +16884,14 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
         timestamp: audioTimestamp
       });
       const audioSource = requireInitialized(this.audioSource, "Audio source");
-      await audioSource.add(audioSample).catch((error) => {
-        const errorMessage = extractErrorMessage(error);
-        logger.warn(\`[RecorderWorker] Failed to add audio sample: \${errorMessage}\`);
+      const addError = await audioSource.add(audioSample).then(() => null).catch((error) => {
+        return new Error(\`Failed to add audio sample: \${extractErrorMessage(error)}\`);
       });
+      if (addError) {
+        this.sendError(addError);
+        audioSample.close();
+        return;
+      }
       this.audioState.updateLastAudioTimestamp(audioTimestamp, duration);
       const lastAudioTimestamp = this.audioState.getLastAudioTimestamp();
       logger.debug("[RecorderWorker] Audio sample processed", {
@@ -16752,6 +17346,8 @@ var WORKER_PROBE_TIMEOUT_MILLISECONDS = 2000;
 var FINALIZE_TIMEOUT_MILLISECONDS = 30000;
 var MILLISECONDS_PER_SECOND3 = 1000;
 var DEFAULT_RECORDING_FORMAT = "mp4";
+var VIDEO_PREFLIGHT_TIMEOUT_MS = 3000;
+var NO_FRAME_WATCHDOG_DELAY_MS = 5000;
 var CODEC_CACHE_MAX_ENTRIES = 50;
 var CODEC_CACHE_KEY_SEPARATOR = "|";
 var CODEC_CACHE_ARRAY_SEPARATOR = ",";
@@ -16767,6 +17363,7 @@ var CODEC_CACHE_POLICY_PREFERRED_AUDIO = "policyPreferredAudio";
 var CODEC_CACHE_POLICY_PREFERRED_VIDEO = "policyPreferredVideo";
 var CODEC_CACHE_POLICY_AUDIO_FALLBACK = "policyAudioFallback";
 var CODEC_CACHE_POLICY_VIDEO_FALLBACK = "policyVideoFallback";
+var AUDIO_HEALTH_CHECK_INTERVAL_MS = 1000;
 var resolvedAudioCodecCache = new Map;
 var resolvedVideoCodecCache = new Map;
 function formatCacheValue(value) {
@@ -16804,30 +17401,35 @@ class WorkerProcessor {
   onBufferUpdate;
   onError;
   onMuteStateChange;
+  onAudioWarning;
   audioTrackClone = null;
+  audioTrackWarningTarget = null;
   audioWorkletManager;
   isMuted = false;
   currentVideoTrack = null;
   isPaused = false;
   overlayConfig = null;
   readyPromiseResolve = null;
+  readyPromiseReject = null;
   lastConfigFps = DEFAULT_SWITCH_SOURCE_FPS;
   workerProbeManager;
-  canUseMainThreadVideoProcessorFn;
   createVideoStreamFromTrackFn;
   isLinuxPlatformFn;
   pendingFatalError = null;
   lastRecordingStats = null;
+  audioWasExpected = false;
   lastEncoderAcceleration = null;
+  audioHealthMonitor = new AudioHealthMonitor;
+  audioHealthIntervalId = null;
+  emittedAudioWarnings = new Set;
+  videoFramePreflightDeps;
+  noFrameWatchdogId = null;
+  watchdogDelayMs;
   constructor(dependencies = {}) {
     let createWorkerFn = (workerUrl) => new Worker(workerUrl, { type: "classic" });
     if (dependencies.createWorker) {
       createWorkerFn = dependencies.createWorker;
     }
-    let canUseMainThreadVideoProcessorFn = () => typeof MediaStreamTrackProcessor !== "undefined";
-    if (dependencies.canUseMainThreadVideoProcessor) {
-      canUseMainThreadVideoProcessorFn = dependencies.canUseMainThreadVideoProcessor;
-    }
     let createVideoStreamFromTrackFn = (videoTrack) => {
       if (typeof MediaStreamTrackProcessor === "undefined") {
         return null;
@@ -16842,33 +17444,25 @@ class WorkerProcessor {
     if (dependencies.isLinuxPlatform) {
       isLinuxPlatformFn = dependencies.isLinuxPlatform;
     }
-    this.canUseMainThreadVideoProcessorFn = canUseMainThreadVideoProcessorFn;
     this.createVideoStreamFromTrackFn = createVideoStreamFromTrackFn;
     this.isLinuxPlatformFn = isLinuxPlatformFn;
+    if (dependencies.videoFramePreflightDeps) {
+      this.videoFramePreflightDeps = dependencies.videoFramePreflightDeps;
+    } else {
+      this.videoFramePreflightDeps = {};
+    }
+    if (dependencies.noFrameWatchdogDelayMs !== undefined) {
+      this.watchdogDelayMs = dependencies.noFrameWatchdogDelayMs;
+    } else {
+      this.watchdogDelayMs = NO_FRAME_WATCHDOG_DELAY_MS;
+    }
     const hasWorkerFactory = !!dependencies.createWorker;
     this.workerProbeManager = new WorkerProbeManager({
       setTimeout: window.setTimeout.bind(window),
       clearTimeout: window.clearTimeout.bind(window),
       timeoutMilliseconds: WORKER_PROBE_TIMEOUT_MILLISECONDS
     });
-    const handleAudioWorkletChunk = (chunk) => {
-      if (!(this.isWorkerActive() && this.worker)) {
-        return;
-      }
-      const message = {
-        type: WORKER_MESSAGE_TYPE_AUDIO_CHUNK,
-        data: chunk.data,
-        frames: chunk.frames,
-        numberOfChannels: chunk.numberOfChannels,
-        sampleRate: chunk.sampleRate,
-        timestamp: chunk.timestamp
-      };
-      const transferables = [];
-      if (chunk.data.buffer instanceof ArrayBuffer) {
-        transferables.push(chunk.data.buffer);
-      }
-      this.worker.postMessage(message, transferables);
-    };
+    const handleAudioWorkletChunk = this.handleAudioWorkletChunk.bind(this);
     this.audioWorkletManager = new AudioWorkletManager({
       onChunk: handleAudioWorkletChunk
     });
@@ -16876,10 +17470,10 @@ class WorkerProcessor {
       const response = event.data;
       switch (response.type) {
         case "ready":
-          logger.debug("[WorkerProcessor] Worker ready");
           if (this.readyPromiseResolve) {
             this.readyPromiseResolve();
             this.readyPromiseResolve = null;
+            this.readyPromiseReject = null;
           }
           break;
         case WORKER_RESPONSE_TYPE_PROBE_RESULT:
@@ -16894,6 +17488,13 @@ class WorkerProcessor {
           break;
         case "error":
           logger.error("[WorkerProcessor] Worker error:", response.error);
+          if (this.readyPromiseReject) {
+            const startupReject = this.readyPromiseReject;
+            this.readyPromiseReject = null;
+            this.readyPromiseResolve = null;
+            startupReject(new Error(response.error));
+            break;
+          }
           if (this.onError) {
             this.onError(new Error(response.error));
           }
@@ -16915,10 +17516,18 @@ class WorkerProcessor {
           this.isPaused = response.state === "paused";
           break;
         case "fatalError":
+          if (this.readyPromiseReject) {
+            const startupReject = this.readyPromiseReject;
+            this.readyPromiseReject = null;
+            this.readyPromiseResolve = null;
+            startupReject(new Error(`${response.message} [${response.code}]`));
+            break;
+          }
           this.pendingFatalError = response;
           break;
         case "recordingStats":
           this.lastRecordingStats = response;
+          this.handleNoFrameWatchdogStats(response);
           break;
         case "encoderAcceleration":
           this.lastEncoderAcceleration = response.acceleration;
@@ -16938,6 +17547,13 @@ class WorkerProcessor {
         colno: error.colno,
         error: error.error
       });
+      if (this.readyPromiseReject) {
+        const startupReject = this.readyPromiseReject;
+        this.readyPromiseReject = null;
+        this.readyPromiseResolve = null;
+        startupReject(new Error(error.message || "Unknown worker error"));
+        return;
+      }
       if (this.onError) {
         let errorMessage = error.message;
         if (!errorMessage) {
@@ -16973,6 +17589,14 @@ class WorkerProcessor {
       throw error;
     }
   }
+  prewarm() {
+    if (!this.worker) {
+      return;
+    }
+    this.workerProbeManager.getProbeResult(this.worker).catch(() => {
+      return;
+    });
+  }
   getWorkerProbeResult() {
     const worker = this.getWorkerOrThrow();
     return this.workerProbeManager.getProbeResult(worker);
@@ -16982,6 +17606,9 @@ class WorkerProcessor {
     this.ensureProcessingInactive();
     this.resetProcessingState(overlayConfig);
     this.stopAudioWorklet();
+    this.audioWorkletManager = new AudioWorkletManager({
+      onChunk: this.handleAudioWorkletChunk.bind(this)
+    });
     const format = this.resolveRecordingFormat(config);
     const policy = getFormatCompatibilityPolicy(format, {
       isLinuxPlatform: this.isLinuxPlatformFn()
@@ -17011,6 +17638,11 @@ class WorkerProcessor {
     const videoTrack = prepareVideoTrack(videoTracks, videoInputSelectorDependencies);
     const audioTrack = prepareAudioTrack(audioTracks, videoInputSelectorDependencies);
     const workerProbeResult = await this.getWorkerProbeResult();
+    if (videoTrack) {
+      logger.debug("[WorkerProcessor] Running video first-frame preflight");
+      await performVideoFramePreflight(videoTrack, VIDEO_PREFLIGHT_TIMEOUT_MS, this.videoFramePreflightDeps);
+      logger.debug("[WorkerProcessor] Video first-frame preflight passed");
+    }
     const videoInput = selectVideoInput(videoTrack, workerProbeResult, videoInputSelectorDependencies);
     const isMobileDeviceDetected = getIsMobileDeviceDetected(videoInputSelectorDependencies);
     const videoSettings = buildWorkerVideoSettings(videoTrack);
@@ -17044,6 +17676,10 @@ class WorkerProcessor {
       messageType: message.type
     });
     await this.postStartMessage(message, transferables, shouldStartAudioWorklet);
+    this.startNoFrameWatchdog();
+    if (shouldStartAudioWorklet) {
+      this.startAudioHealthMonitoring();
+    }
   }
   getWorkerOrThrow() {
     if (!this.worker) {
@@ -17056,18 +17692,149 @@ class WorkerProcessor {
       throw new Error("Processing already active");
     }
   }
+  handleAudioWorkletChunk(chunk) {
+    if (!(this.isWorkerActive() && this.worker)) {
+      return;
+    }
+    this.recordAudioHealthChunk(chunk);
+    const message = {
+      type: WORKER_MESSAGE_TYPE_AUDIO_CHUNK,
+      data: chunk.data,
+      frames: chunk.frames,
+      numberOfChannels: chunk.numberOfChannels,
+      sampleRate: chunk.sampleRate,
+      timestamp: chunk.timestamp
+    };
+    const transferables = [];
+    if (chunk.data.buffer instanceof ArrayBuffer) {
+      transferables.push(chunk.data.buffer);
+    }
+    this.worker.postMessage(message, transferables);
+  }
   resetProcessingState(overlayConfig) {
     this.isActive = true;
     this.isMuted = false;
     this.isPaused = false;
     this.chunks = [];
     this.totalSize = 0;
+    this.audioWasExpected = false;
+    this.audioHealthMonitor.reset();
+    this.emittedAudioWarnings = new Set;
+    this.pendingFatalError = null;
+    this.lastRecordingStats = null;
+    this.lastEncoderAcceleration = null;
+    this.stopAudioHealthMonitoring();
+    this.stopNoFrameWatchdog();
     if (overlayConfig) {
       this.overlayConfig = overlayConfig;
     } else {
       this.overlayConfig = null;
     }
   }
+  recordAudioHealthChunk(chunk) {
+    const snapshot = this.audioHealthMonitor.recordChunk({
+      samples: chunk.data,
+      timestampMs: performance.now(),
+      isMuted: this.isMuted
+    });
+    this.emitAudioWarning(snapshot.classification, {
+      durationMs: snapshot.consecutiveSilentDurationMs,
+      peak: snapshot.peak,
+      rms: snapshot.rms
+    });
+  }
+  startAudioHealthMonitoring() {
+    this.stopAudioHealthMonitoring();
+    this.audioHealthIntervalId = window.setInterval(() => {
+      if (!this.isActive) {
+        return;
+      }
+      const snapshot = this.audioHealthMonitor.inspect(performance.now(), this.isMuted);
+      this.emitAudioWarning(snapshot.classification, {
+        durationMs: Math.max(snapshot.noChunkDurationMs, snapshot.consecutiveSilentDurationMs),
+        peak: snapshot.peak,
+        rms: snapshot.rms
+      });
+    }, AUDIO_HEALTH_CHECK_INTERVAL_MS);
+  }
+  stopAudioHealthMonitoring() {
+    if (this.audioHealthIntervalId === null) {
+      return;
+    }
+    window.clearInterval(this.audioHealthIntervalId);
+    this.audioHealthIntervalId = null;
+  }
+  startNoFrameWatchdog() {
+    this.stopNoFrameWatchdog();
+    this.noFrameWatchdogId = window.setTimeout(() => {
+      this.noFrameWatchdogId = null;
+      if (!(this.isWorkerActive() && this.worker)) {
+        return;
+      }
+      const message = { type: "requestStats" };
+      this.worker.postMessage(message);
+    }, this.watchdogDelayMs);
+  }
+  stopNoFrameWatchdog() {
+    if (this.noFrameWatchdogId === null) {
+      return;
+    }
+    window.clearTimeout(this.noFrameWatchdogId);
+    this.noFrameWatchdogId = null;
+  }
+  handleNoFrameWatchdogStats(stats) {
+    if (!this.isActive || stats.videoFrameCount > 0) {
+      return;
+    }
+    logger.error("[WorkerProcessor] No video frames received after watchdog delay", {
+      videoFrameCount: stats.videoFrameCount,
+      totalFrameErrors: stats.totalFrameErrors,
+      totalFramesProcessed: stats.totalFramesProcessed
+    });
+    const watchdogError = new Error(`No video frames received after ${this.watchdogDelayMs / MILLISECONDS_PER_SECOND3}s — video stream may be unresponsive [${VIDEO_FIRST_FRAME_TIMEOUT_CODE}]`);
+    if (this.onError) {
+      this.onError(watchdogError);
+    }
+    this.cancel();
+  }
+  emitAudioWarning(classification, details) {
+    if (classification === "healthy") {
+      this.emittedAudioWarnings.clear();
+      return;
+    }
+    if (classification === "muted-silence-expected") {
+      this.emittedAudioWarnings.delete("audio.no-signal");
+      this.emittedAudioWarnings.delete("audio.no-chunks");
+      return;
+    }
+    const warning = this.createAudioWarning(classification, details);
+    if (!warning) {
+      return;
+    }
+    this.emitAudioWarningOnce(warning);
+  }
+  emitAudioWarningOnce(warning) {
+    if (!this.onAudioWarning) {
+      return;
+    }
+    if (this.emittedAudioWarnings.has(warning.code)) {
+      return;
+    }
+    this.emittedAudioWarnings.add(warning.code);
+    this.onAudioWarning(warning);
+  }
+  createAudioWarning(classification, details) {
+    if (classification === "no-chunks") {
+      return { code: "audio.no-chunks", durationMs: details.durationMs };
+    }
+    if (classification === "silent-while-unmuted") {
+      return { code: "audio.no-signal", durationMs: details.durationMs };
+    }
+    if (classification === "low-signal") {
+      return { code: "audio.low-signal", peak: details.peak, rms: details.rms };
+    }
+    return null;
+  }
   resolveRecordingFormat(config) {
     let format = config.format;
     if (!format) {
@@ -17164,7 +17931,7 @@ class WorkerProcessor {
       watermark: config.watermark
     };
   }
-  async prepareAudioPipeline(audioTrack, workerProbeResult) {
+  async prepareAudioPipeline(audioTrack, _workerProbeResult) {
     if (!audioTrack) {
       logger.debug("[WorkerProcessor] Audio pipeline disabled (no track)");
       return {
@@ -17173,35 +17940,20 @@ class WorkerProcessor {
         shouldStartAudioWorklet: false
       };
     }
-    const canUseMainThreadAudioPipeline = this.canUseMainThreadVideoProcessorFn() && workerProbeResult.hasAudioData;
-    if (canUseMainThreadAudioPipeline) {
-      const audioStream = this.createAudioStreamFromTrack(audioTrack);
-      if (audioStream) {
-        logger.debug("[WorkerProcessor] Audio pipeline selected", {
-          path: "main-thread-audio-stream",
-          hasAudioDataInWorker: workerProbeResult.hasAudioData
-        });
-        return {
-          audioConfig: null,
-          audioStream,
-          shouldStartAudioWorklet: false
-        };
-      }
-    }
     const audioConfig = await this.prepareAudioConfig(audioTrack);
-    if (audioConfig) {
-      logger.debug("[WorkerProcessor] Audio pipeline selected", {
-        path: "audio-worklet-chunks",
-        sampleRate: audioConfig.sampleRate,
-        numberOfChannels: audioConfig.numberOfChannels
-      });
-      return {
-        audioConfig,
-        audioStream: null,
-        shouldStartAudioWorklet: true
-      };
+    if (!audioConfig) {
+      throw this.createBrowserUnsupportedError();
     }
-    throw this.createBrowserUnsupportedError();
+    logger.debug("[WorkerProcessor] Audio pipeline selected", {
+      path: "audio-worklet-chunks",
+      sampleRate: audioConfig.sampleRate,
+      numberOfChannels: audioConfig.numberOfChannels
+    });
+    return {
+      audioConfig,
+      audioStream: null,
+      shouldStartAudioWorklet: true
+    };
   }
   buildOverlayConfigToSend() {
     if (!this.overlayConfig) {
@@ -17211,8 +17963,9 @@ class WorkerProcessor {
   }
   async postStartMessage(message, transferables, shouldStartAudioWorklet) {
     const worker = this.getWorkerOrThrow();
-    const readyPromise = new Promise((resolve) => {
+    const readyPromise = new Promise((resolve, reject) => {
       this.readyPromiseResolve = resolve;
+      this.readyPromiseReject = reject;
     });
     try {
       worker.postMessage(message, transferables);
@@ -17220,11 +17973,14 @@ class WorkerProcessor {
       await readyPromise;
       logger.debug("[WorkerProcessor] Worker confirmed ready");
       if (shouldStartAudioWorklet) {
+        this.audioWasExpected = true;
         await this.startAudioWorkletProcessing();
       }
     } catch (error) {
       logger.error("[WorkerProcessor] Failed to post message:", error);
       this.readyPromiseResolve = null;
+      this.readyPromiseReject = null;
+      this.stopNoFrameWatchdog();
       this.stopAudioWorklet();
       if (this.worker && this.isActive) {
         const stopMessage = { type: "stop" };
@@ -17441,7 +18197,10 @@ class WorkerProcessor {
   }
   resetFinalizeRuntimeState() {
     this.isActive = false;
+    this.stopAudioHealthMonitoring();
+    this.stopNoFrameWatchdog();
     this.stopAudioWorklet();
+    this.detachAudioTrackWarnings();
     this.pendingFatalError = null;
     this.lastRecordingStats = null;
     this.lastEncoderAcceleration = null;
@@ -17455,6 +18214,9 @@ class WorkerProcessor {
     }
     assertMp4ContainerIsNonFragmented(buffer);
     assertMp4HasVideoTrack(buffer);
+    if (this.audioWasExpected) {
+      assertMp4HasAudioTrack(buffer);
+    }
     const blob = new Blob([buffer], { type: "video/mp4" });
     const streamProcessorResult = {
       blob,
@@ -17488,13 +18250,39 @@ class WorkerProcessor {
       const message = { type: "stop" };
       this.worker.postMessage(message);
     }
+    this.stopAudioHealthMonitoring();
+    this.stopNoFrameWatchdog();
     this.stopAudioWorklet();
+    this.detachAudioTrackWarnings();
     this.isActive = false;
     this.isPaused = false;
     this.chunks = [];
     this.totalSize = 0;
+    this.audioWasExpected = false;
+    this.emittedAudioWarnings = new Set;
+    this.pendingFatalError = null;
+    this.lastRecordingStats = null;
+    this.lastEncoderAcceleration = null;
     return Promise.resolve();
   }
+  destroy() {
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this.releaseWorkerUrlLease();
+    this.stopAudioHealthMonitoring();
+    this.stopNoFrameWatchdog();
+    this.stopAudioWorklet();
+    this.detachAudioTrackWarnings();
+    this.isActive = false;
+    this.isPaused = false;
+    this.chunks = [];
+    this.totalSize = 0;
+  }
+  cleanup() {
+    this.destroy();
+  }
   warmupEncoder(config) {
     if (!this.worker) {
       return;
@@ -17503,6 +18291,12 @@ class WorkerProcessor {
     const policy = getFormatCompatibilityPolicy(format);
     const codec = config.codec || policy.preferredVideoCodec;
     const audioBitrate = config.audioBitrate !== undefined ? config.audioBitrate : policy.audioBitrate;
+    const cachePolicy = getFormatCompatibilityPolicy(format, {
+      isLinuxPlatform: this.isLinuxPlatformFn()
+    });
+    const cacheAudioBitrate = this.resolveAudioBitrate(config, format);
+    this.resolveAudioCodecWithCache(config, format, cachePolicy, cacheAudioBitrate).catch(this.handleWarmupCacheError);
+    this.resolveVideoCodecWithCache(config, format, cachePolicy).catch(this.handleWarmupCacheError);
     const workerConfig = this.buildWorkerTranscodeConfig(config, policy.preferredAudioCodec, audioBitrate, codec, format);
     const message = {
       type: WORKER_MESSAGE_TYPE_WARMUP,
@@ -17568,15 +18362,8 @@ class WorkerProcessor {
   prepareAudioConfig(audioTrack) {
     return this.audioWorkletManager.prepareAudioConfig(audioTrack);
   }
-  createAudioStreamFromTrack(audioTrack) {
-    if (!audioTrack) {
-      return null;
-    }
-    if (typeof MediaStreamTrackProcessor === "undefined") {
-      return null;
-    }
-    const processor = new MediaStreamTrackProcessor({ track: audioTrack });
-    return processor.readable;
+  handleWarmupCacheError() {
+    return;
   }
   createBrowserUnsupportedError() {
     return createBrowserUnsupportedError({
@@ -17591,7 +18378,6 @@ class WorkerProcessor {
       setCurrentVideoTrack: (track) => {
         this.currentVideoTrack = track;
       },
-      canUseMainThreadVideoProcessor: () => this.canUseMainThreadVideoProcessorFn(),
       createVideoStreamFromTrack: (track) => this.createVideoStreamFromTrackFn(track),
       createBrowserUnsupportedError: () => this.createBrowserUnsupportedError(),
       getViewportMetadata: () => {
@@ -17651,6 +18437,9 @@ class WorkerProcessor {
   setOnMuteStateChange(callback) {
     this.onMuteStateChange = callback;
   }
+  setOnAudioWarning(callback) {
+    this.onAudioWarning = callback;
+  }
   cloneVideoTrack(originalTrack) {
     logger.debug("[WorkerProcessor] Original video track:", {
       id: originalTrack.id,
@@ -17676,6 +18465,31 @@ class WorkerProcessor {
     logger.warn("[WorkerProcessor] Video track clone() not available, using original");
     return originalTrack;
   }
+  handleAudioTrackEnded = () => {
+    this.emitAudioWarningOnce({ code: "audio.track-ended" });
+  };
+  handleAudioTrackMuted = () => {
+    this.emitAudioWarningOnce({ code: "audio.track-muted-by-browser" });
+  };
+  handleAudioTrackUnmuted = () => {
+    this.emittedAudioWarnings.delete("audio.track-muted-by-browser");
+  };
+  attachAudioTrackWarnings(track) {
+    this.detachAudioTrackWarnings();
+    track.addEventListener("ended", this.handleAudioTrackEnded);
+    track.addEventListener("mute", this.handleAudioTrackMuted);
+    track.addEventListener("unmute", this.handleAudioTrackUnmuted);
+    this.audioTrackWarningTarget = track;
+  }
+  detachAudioTrackWarnings() {
+    if (!this.audioTrackWarningTarget) {
+      return;
+    }
+    this.audioTrackWarningTarget.removeEventListener("ended", this.handleAudioTrackEnded);
+    this.audioTrackWarningTarget.removeEventListener("mute", this.handleAudioTrackMuted);
+    this.audioTrackWarningTarget.removeEventListener("unmute", this.handleAudioTrackUnmuted);
+    this.audioTrackWarningTarget = null;
+  }
   cloneAudioTrack(originalTrack) {
     logger.debug("[WorkerProcessor] Original audio track:", {
       id: originalTrack.id,
@@ -17687,6 +18501,7 @@ class WorkerProcessor {
       try {
         const clonedTrack = originalTrack.clone();
         this.audioTrackClone = clonedTrack;
+        this.attachAudioTrackWarnings(clonedTrack);
         logger.debug("[WorkerProcessor] Audio track cloned successfully:", {
           id: clonedTrack.id,
           kind: clonedTrack.kind,
@@ -17701,6 +18516,7 @@ class WorkerProcessor {
     }
     logger.warn("[WorkerProcessor] Audio track clone() not available, using original");
     this.audioTrackClone = originalTrack;
+    this.attachAudioTrackWarnings(originalTrack);
     return originalTrack;
   }
   stopCurrentVideoTrack() {
@@ -17709,18 +18525,6 @@ class WorkerProcessor {
     }
     this.currentVideoTrack = null;
   }
-  cleanup() {
-    if (this.worker) {
-      this.worker.terminate();
-      this.worker = null;
-    }
-    this.releaseWorkerUrlLease();
-    this.stopAudioWorklet();
-    this.isActive = false;
-    this.isPaused = false;
-    this.chunks = [];
-    this.totalSize = 0;
-  }
   releaseWorkerUrlLease() {
     if (!this.hasWorkerUrlLease) {
       return;
@@ -17822,12 +18626,21 @@ class StreamProcessor {
   setOnError(callback) {
     this.onError = callback;
   }
+  setOnAudioWarning(callback) {
+    this.workerProcessor.setOnAudioWarning(callback);
+  }
   warmupEncoder(config) {
     this.workerProcessor.warmupEncoder(config);
   }
+  prewarm() {
+    this.workerProcessor.prewarm();
+  }
   async cancel() {
     await this.workerProcessor.cancel();
-    this.workerProcessor.cleanup();
+    this.currentVideoStream = null;
+  }
+  destroy() {
+    this.workerProcessor.destroy();
     this.currentVideoStream = null;
   }
 }
@@ -17863,6 +18676,7 @@ class RecordingManager {
   originalCameraStream = null;
   enableTabVisibilityOverlay = false;
   tabVisibilityOverlayText;
+  startupAborted = false;
   constructor(streamManager, callbacks) {
     this.streamManager = streamManager;
     this.callbacks = callbacks;
@@ -17903,6 +18717,7 @@ class RecordingManager {
   }
   prewarmStreamProcessor(config) {
     const processor = this.getOrCreateStreamProcessor();
+    processor.prewarm();
     if (config) {
       processor.warmupEncoder(config);
     }
@@ -17932,17 +18747,23 @@ class RecordingManager {
       }
       const elapsed = Date.now() - this.countdownStartTime;
       const remaining = Math.max(0, Math.ceil((this.countdownDuration - elapsed) / MILLISECONDS_PER_SECOND4));
+      const previousRemaining = this.countdownRemaining;
       this.countdownRemaining = remaining;
-      this.callbacks.onCountdownUpdate(this.recordingState, this.countdownRemaining);
+      if (previousRemaining !== remaining) {
+        this.callbacks.onCountdownUpdate(this.recordingState, this.countdownRemaining);
+      }
     }, COUNTDOWN_UPDATE_INTERVAL);
     this.countdownTimeoutId = window.setTimeout(async () => {
-      await this.doStartRecording().catch(() => {});
+      await this.doStartRecording().catch(() => {
+        return;
+      });
     }, this.countdownDuration);
   }
   async doStartRecording() {
     logger.debug("[RecordingManager] doStartRecording called");
     this.cancelCountdown();
     this.resetRecordingState();
+    this.startupAborted = false;
     const currentStream = this.streamManager.getStream();
     logger.debug("[RecordingManager] Current stream:", {
       hasStream: !!currentStream,
@@ -17979,11 +18800,14 @@ class RecordingManager {
       this.callbacks.onStateChange(this.recordingState);
       return;
     }
+    if (this.callbacks.onAudioWarning) {
+      streamProcessor.setOnAudioWarning(this.callbacks.onAudioWarning);
+    }
+    streamProcessor.setOnError((error) => {
+      this.handleFatalProcessorError(error);
+    });
     logger.debug("[RecordingManager] Starting recording with stream manager");
-    const recordingError = await this.streamManager.startRecording(streamProcessor, recordingConfig, this.enableTabVisibilityOverlay, this.tabVisibilityOverlayText).then(() => {
-      logger.info("[RecordingManager] Recording started successfully");
-      return null;
-    }).catch((error) => {
+    const recordingError = await this.streamManager.startRecording(streamProcessor, recordingConfig, this.enableTabVisibilityOverlay, this.tabVisibilityOverlayText).then(() => null).catch((error) => {
       logger.error("[RecordingManager] Error starting recording:", error);
       return error;
     });
@@ -17993,6 +18817,11 @@ class RecordingManager {
       this.callbacks.onStateChange(this.recordingState);
       return;
     }
+    if (this.startupAborted) {
+      this.startupAborted = false;
+      return;
+    }
+    logger.info("[RecordingManager] Recording started successfully");
     this.recordingState = RECORDING_STATE_RECORDING;
     this.callbacks.onStateChange(this.recordingState);
     this.startRecordingTimer();
@@ -18019,7 +18848,10 @@ class RecordingManager {
       this.recordingState = RECORDING_STATE_IDLE;
       this.callbacks.onStateChange(this.recordingState);
       this.recordingSeconds = 0;
-      this.streamProcessor = null;
+      if (this.streamProcessor) {
+        this.streamProcessor.destroy();
+        this.streamProcessor = null;
+      }
       this.callbacks.onRecordingComplete(finalBlob);
       const telemetryProperties = {};
       if (stopResult.recordingStats !== undefined) {
@@ -18086,9 +18918,7 @@ class RecordingManager {
     this.clearTimer(this.maxTimeTimer, clearTimeout);
     this.maxTimeTimer = null;
     if (this.streamProcessor) {
-      this.streamProcessor.cancel().catch(() => {
-        return;
-      });
+      this.streamProcessor.destroy();
       this.streamProcessor = null;
     }
   }
@@ -18153,6 +18983,28 @@ class RecordingManager {
     const errorMessage = error instanceof Error ? error : new Error(extractErrorMessage(error));
     this.callbacks.onError(errorMessage);
   }
+  handleFatalProcessorError(error) {
+    if (this.recordingState === RECORDING_STATE_RECORDING) {
+      this.clearTimer(this.recordingIntervalId, clearInterval);
+      this.recordingIntervalId = null;
+      this.clearTimer(this.maxTimeTimer, clearTimeout);
+      this.maxTimeTimer = null;
+      this.resetPauseState();
+    }
+    if (!this.streamProcessor && this.recordingState !== RECORDING_STATE_RECORDING) {
+      return;
+    }
+    logger.error("[RecordingManager] Fatal processor error, stopping recording", error);
+    this.startupAborted = true;
+    if (this.streamProcessor) {
+      this.streamProcessor.destroy();
+      this.streamProcessor = null;
+    }
+    this.recordingState = RECORDING_STATE_IDLE;
+    this.callbacks.onStateChange(this.recordingState);
+    this.recordingSeconds = 0;
+    this.callbacks.onError(error);
+  }
 }
 
 // src/core/recording/telemetry-manager.ts
@@ -18304,7 +19156,13 @@ class RecorderController {
     this.uploadMetadataManager = new UploadMetadataManager;
     const recordingCallbacks = createRecordingCallbacks(callbacks, {
       stopAudioTracking: () => this.audioLevelAnalyzer.stopTracking(),
-      getConfig: () => Promise.resolve(this.configManager.getConfigForRecording())
+      getConfig: () => Promise.resolve(this.configManager.getConfigForRecording()),
+      onAudioWarning: callbacks.recording?.onAudioWarning ? (warning) => {
+        this.sendAudioWarningTelemetry(warning);
+        callbacks.recording?.onAudioWarning?.(warning);
+      } : (warning) => {
+        this.sendAudioWarningTelemetry(warning);
+      }
     });
     this.recordingManager = new RecordingManager(this.streamManager, recordingCallbacks);
     const sourceSwitchCallbacks = createSourceSwitchCallbacks(callbacks, {
@@ -18393,6 +19251,7 @@ class RecorderController {
         this.ignorePromiseRejection(this.configManager.getConfig().then((config) => {
           this.recordingManager.prewarmStreamProcessor(config);
         }));
+        this.prewarmSupportCheck();
         logger.debug(`${LOGGER_PREFIX} startStream completed`);
       },
       properties: {
@@ -18613,6 +19472,23 @@ class RecorderController {
   getAudioStatus() {
     return this.streamManager.getAudioStatus();
   }
+  sendAudioWarningTelemetry(warning) {
+    const properties = {
+      code: warning.code,
+      sourceType: this.getCurrentSourceType(),
+      browserName: this.getBrowserNameForTelemetry()
+    };
+    if ("durationMs" in warning) {
+      properties.durationMs = warning.durationMs;
+    }
+    if ("peak" in warning) {
+      properties.peak = warning.peak;
+    }
+    if ("rms" in warning) {
+      properties.rms = warning.rms;
+    }
+    this.telemetryManager.sendEvent("audio.warning", properties);
+  }
   getBrowserNameForTelemetry() {
     try {
       return getBrowserName();
@@ -18656,6 +19532,16 @@ class RecorderController {
     if (this.isDestroyed) {
       return;
     }
+    const probeResult = this.storageManager.getWriteProbeResult();
+    if (!probeResult?.ok) {
+      const reason = probeResult?.reason ?? "Storage write probe did not complete";
+      this.telemetryManager.sendEvent("storage.write.probe.failed", {
+        reason
+      });
+      const onStorageWriteError = resolveStorageWriteErrorCallback(this.callbacks);
+      onStorageWriteError(reason);
+      return;
+    }
     const storageService = this.storageManager.getStorageService();
     if (!(storageService && this.uploadService)) {
       return;
@@ -18731,6 +19617,14 @@ class RecorderController {
       return;
     });
   }
+  prewarmSupportCheck() {
+    this.ignorePromiseRejection(checkRecorderSupport({
+      requiresAudio: true,
+      requiresWatermark: true
+    }).then((report) => {
+      this.streamManager.setPreResolvedSupportReport(report);
+    }));
+  }
 }
 // src/core/storage/quota-manager.ts
 var PERCENTAGE_MULTIPLIER = 100;
@@ -19061,7 +19955,12 @@ class VidtreoRecorder {
             this.config.onRecordingStop();
           }
         },
-        onGetConfig: async () => await this.controller.getConfig()
+        onGetConfig: async () => await this.controller.getConfig(),
+        onAudioWarning: (warning) => {
+          if (this.config.onAudioWarning) {
+            this.config.onAudioWarning(warning);
+          }
+        }
       },
       upload: {
         onProgress: (progress) => {