@vidtreo/recorder 1.4.0 → 1.5.0

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"
@@ -224,7 +237,9 @@ var HD_SIZE_LIMIT_MB_PER_MINUTE = 8;
 var FHD_SIZE_LIMIT_MB_PER_MINUTE = 18;
 var K4_SIZE_LIMIT_MB_PER_MINUTE = 46;
 var MP4_AUDIO_BITRATE = 128000;
+var MP4_AUDIO_BITRATE_SD = 64000;
 var WEBM_AUDIO_BITRATE = 96000;
+var WEBM_AUDIO_BITRATE_SD = 48000;
 var VIDEO_CODEC_AVC = "avc";
 var VIDEO_CODEC_VP9 = "vp9";
 var VIDEO_CODEC_AV1 = "av1";
@@ -323,13 +338,19 @@ function getPresetTotalBitrate(preset) {
   const sizeLimit = PRESET_SIZE_LIMIT_MB_PER_MINUTE[preset];
   return calculateTotalBitrateFromMbPerMinute(sizeLimit);
 }
-function getPresetAudioBitrateForFormat(format) {
+function getPresetAudioBitrateForFormat(format, preset) {
+  if (preset === "sd") {
+    if (format === "webm") {
+      return WEBM_AUDIO_BITRATE_SD;
+    }
+    return MP4_AUDIO_BITRATE_SD;
+  }
   const policy = getFormatCompatibilityPolicy(format);
   return policy.audioBitrate;
 }
 function getPresetVideoBitrateForFormat(preset, format) {
   const totalBitrate = getPresetTotalBitrate(preset);
-  const audioBitrate = getPresetAudioBitrateForFormat(format);
+  const audioBitrate = getPresetAudioBitrateForFormat(format, preset);
   return calculateVideoBitrate(totalBitrate, audioBitrate);
 }
 var PRESET_VIDEO_BITRATE_MAP = {
@@ -350,6 +371,7 @@ var MOBILE_RESOLUTION_MAP = {
   fhd: { width: 1080, height: 1920 },
   "4k": { width: 2160, height: 3840 }
 };
+var PRESET_DEFAULT_FPS = 30;
 var DEFAULT_BACKEND_URL = "https://core.vidtreo.com";
 var DEFAULT_TRANSCODE_CONFIG = Object.freeze({
   format: "mp4",
@@ -378,7 +400,8 @@ function getDefaultConfigForFormat(format) {
 // src/core/utils/device-detector.ts
 import { UAParser as UAParser2 } from "ua-parser-js";
 function isMobileDevice() {
-  const parser = new UAParser2;
+  const userAgent = globalThis.navigator && typeof globalThis.navigator.userAgent === "string" ? globalThis.navigator.userAgent : "";
+  const parser = new UAParser2(userAgent);
   const device = parser.getDevice();
   if (device.type === "mobile") {
     return true;
@@ -485,11 +508,13 @@ function mapPresetToConfig(options) {
   });
   const config = {
     format,
+    fps: PRESET_DEFAULT_FPS,
     width,
     height,
     bitrate: getPresetVideoBitrateForFormat(preset, format),
     audioCodec: policy.preferredAudioCodec,
-    audioBitrate: policy.audioBitrate
+    audioBitrate: getPresetAudioBitrateForFormat(format, preset),
+    latencyMode: preset === "sd" ? "quality" : undefined
   };
   if (watermark) {
     config.watermark = {
@@ -1819,6 +1844,7 @@ function revokeProbeWorkerUrl(workerUrl) {
 
 // src/core/processor/worker/types.ts
 var WORKER_MESSAGE_TYPE_PROBE = "probe";
+var WORKER_MESSAGE_TYPE_WARMUP = "warmup";
 var WORKER_MESSAGE_TYPE_AUDIO_CHUNK = "audioChunk";
 var WORKER_RESPONSE_TYPE_PROBE_RESULT = "probeResult";
 var WORKER_RESPONSE_TYPE_DEBUG_LOG = "debugLog";
@@ -2013,11 +2039,11 @@ function getIsProbeFeaturesComplete(probeResult, requiresWatermark) {
   }
   return true;
 }
-async function checkRecorderSupport(options = {}) {
+async function checkRecorderSupport(options = {}, dependencies = {}) {
   const requiresAudio = resolveBooleanOption(options.requiresAudio, true);
   const requiresWatermark = resolveBooleanOption(options.requiresWatermark, false);
   if (!shouldUseSupportCache()) {
-    return await buildSupportReport(requiresAudio, requiresWatermark);
+    return await buildSupportReport(requiresAudio, requiresWatermark, dependencies);
   }
   const supportCacheKey = createSupportCacheKey(requiresAudio, requiresWatermark);
   const cachedReport = supportReportCache.get(supportCacheKey);
@@ -2028,7 +2054,7 @@ async function checkRecorderSupport(options = {}) {
   if (inflightReport) {
     return await inflightReport;
   }
-  const reportPromise = buildSupportReport(requiresAudio, requiresWatermark).then((report) => {
+  const reportPromise = buildSupportReport(requiresAudio, requiresWatermark, dependencies).then((report) => {
     supportReportCache.set(supportCacheKey, report);
     supportReportPromiseCache.delete(supportCacheKey);
     return report;
@@ -2039,13 +2065,13 @@ async function checkRecorderSupport(options = {}) {
   supportReportPromiseCache.set(supportCacheKey, reportPromise);
   return await reportPromise;
 }
-async function buildSupportReport(requiresAudio, requiresWatermark) {
+async function buildSupportReport(requiresAudio, requiresWatermark, dependencies) {
   const hasWorker = typeof Worker !== "undefined";
   const audioContextClass = getAudioContextClass();
   const hasAudioContext = audioContextClass !== null;
   const hasAudioWorklet = typeof AudioWorkletNode !== "undefined";
   const hasMainThreadMediaStreamTrackProcessor = typeof MediaStreamTrackProcessor !== "undefined";
-  const probeResult = await probeWorkerCapabilities(hasWorker);
+  const probeResult = await probeWorkerCapabilities(hasWorker, dependencies);
   const videoPath = resolveVideoPath({
     probeResult,
     hasMainThreadMediaStreamTrackProcessor
@@ -2090,7 +2116,7 @@ async function buildSupportReport(requiresAudio, requiresWatermark) {
     audioPath
   };
 }
-async function probeWorkerCapabilities(hasWorker) {
+async function probeWorkerCapabilities(hasWorker, dependencies) {
   if (!hasWorker) {
     return getEmptyProbeResult();
   }
@@ -2100,6 +2126,7 @@ async function probeWorkerCapabilities(hasWorker) {
   }
   return await new Promise((resolve) => {
     let resolved = false;
+    const probeTimeoutMilliseconds = dependencies.probeTimeoutMilliseconds ?? PROBE_TIMEOUT_MILLISECONDS;
     const finalize = (result) => {
       if (resolved) {
         return;
@@ -2110,7 +2137,7 @@ async function probeWorkerCapabilities(hasWorker) {
     };
     const timeoutId = setTimeout(() => {
       finalize(getEmptyProbeResult());
-    }, PROBE_TIMEOUT_MILLISECONDS);
+    }, probeTimeoutMilliseconds);
     worker.onmessage = (event) => {
       const payload = event.data;
       if (payload.type !== WORKER_RESPONSE_TYPE_PROBE_RESULT) {
@@ -2163,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";
@@ -2176,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;
@@ -2268,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) => {
@@ -2305,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) {
@@ -2317,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) => {
@@ -2328,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 = () => {
@@ -2381,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)}`;
   }
@@ -2390,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);
+      });
+    });
   }
 }
 
@@ -2401,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;
@@ -2408,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(() => {
@@ -2428,6 +2576,9 @@ class StorageManager {
   getStorageService() {
     return this.storageService;
   }
+  isStorageWritable() {
+    return this.writeProbeResult?.ok === true;
+  }
   destroy() {
     if (this.cleanupIntervalId !== null) {
       clearInterval(this.cleanupIntervalId);
@@ -2603,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
@@ -3431,26 +3587,48 @@ var DEFAULT_RECORDING_OPTIONS = Object.freeze({
 
 // src/core/stream/stream-manager.ts
 var TRACK_READY_STATE_LIVE2 = "live";
+var AUDIO_RETRY_DELAY_MILLISECONDS = 300;
+var AUDIO_MAX_RETRIES = 2;
 var CAMERA_ERROR_CODE_MAP = {
   NotReadableError: "camera.in-use",
   NotFoundError: "camera.not-found",
   NotAllowedError: "camera.permission-denied",
   OverconstrainedError: "camera.overconstrained"
 };
-function classifyCameraError(error) {
+var AUDIO_ERROR_CODE_MAP = {
+  NotReadableError: "audio.in-use",
+  NotFoundError: "audio.not-found",
+  NotAllowedError: "audio.permission-denied",
+  OverconstrainedError: "audio.overconstrained"
+};
+function getErrorName(error) {
   if (error instanceof DOMException) {
-    const mappedCode = CAMERA_ERROR_CODE_MAP[error.name];
+    return error.name;
+  }
+  if (error !== null && typeof error === "object" && "name" in error && typeof error.name === "string") {
+    return error.name;
+  }
+  return null;
+}
+function classifyCameraError(error) {
+  const errorName = getErrorName(error);
+  if (errorName !== null) {
+    const mappedCode = CAMERA_ERROR_CODE_MAP[errorName];
     if (mappedCode !== undefined) {
       return mappedCode;
     }
   }
-  if (error !== null && typeof error === "object" && "name" in error && typeof error.name === "string") {
-    const mappedCode = CAMERA_ERROR_CODE_MAP[error.name];
+  return "camera.unknown";
+}
+function classifyAudioError(error) {
+  const errorName = getErrorName(error);
+  if (errorName !== null) {
+    const mappedCode = AUDIO_ERROR_CODE_MAP[errorName];
     if (mappedCode !== undefined) {
       return mappedCode;
     }
   }
-  return "camera.unknown";
+  return "audio.unknown";
 }
 function createCameraStreamError(error) {
   const message = extractErrorMessage(error);
@@ -3459,6 +3637,20 @@ function createCameraStreamError(error) {
   cameraError.code = classifyCameraError(error);
   return cameraError;
 }
+function createAudioStreamError(error) {
+  const message = extractErrorMessage(error);
+  const audioError = new Error(message);
+  audioError.name = "AudioError";
+  audioError.code = classifyAudioError(error);
+  return audioError;
+}
+function isRetriableAudioError(error) {
+  const errorName = getErrorName(error);
+  return errorName === "NotReadableError";
+}
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
 
 class StreamManager {
   mediaStream = null;
@@ -3467,8 +3659,46 @@ class StreamManager {
   streamConfig;
   selectedAudioDeviceId = null;
   selectedVideoDeviceId = null;
-  constructor(streamConfig = {}) {
+  audioStatus = "pending";
+  audioAcquisitionPromise = null;
+  pendingAudioError = null;
+  acquisitionGeneration = 0;
+  waitMilliseconds;
+  audioRetryDelayMilliseconds;
+  constructor(streamConfig = {}, dependencies = {}) {
     this.streamConfig = { ...DEFAULT_STREAM_CONFIG, ...streamConfig };
+    this.waitMilliseconds = dependencies.waitMilliseconds ?? delay;
+    this.audioRetryDelayMilliseconds = dependencies.audioRetryDelayMilliseconds ?? AUDIO_RETRY_DELAY_MILLISECONDS;
+  }
+  getAudioStatus() {
+    return this.audioStatus;
+  }
+  isAudioReady() {
+    return this.audioStatus === "acquired";
+  }
+  async waitForAudio() {
+    if (this.audioStatus === "acquired") {
+      return;
+    }
+    if (this.audioStatus === "failed") {
+      throw this.pendingAudioError ?? createAudioStreamError(null);
+    }
+    if (this.audioAcquisitionPromise) {
+      await this.audioAcquisitionPromise;
+    }
+    if (this.getAudioStatus() === "failed") {
+      throw this.pendingAudioError ?? createAudioStreamError(null);
+    }
+  }
+  setAudioStatus(status) {
+    if (this.audioStatus === status) {
+      return;
+    }
+    this.audioStatus = status;
+    this.emit("audiostatuschange", { status });
+  }
+  emitAudioTelemetry(event) {
+    this.emit("audiotelemetry", { event });
   }
   getState() {
     return this.state;
@@ -3602,20 +3832,7 @@ class StreamManager {
     this.setState("starting");
     logger.debug("[StreamManager] State set to 'starting'");
     try {
-      logger.debug("[StreamManager] Building constraints", {
-        selectedVideoDeviceId: this.selectedVideoDeviceId,
-        selectedAudioDeviceId: this.selectedAudioDeviceId
-      });
-      const constraints = {
-        video: this.buildVideoConstraints(this.selectedVideoDeviceId),
-        audio: this.buildAudioConstraints(this.selectedAudioDeviceId)
-      };
-      logger.debug("[StreamManager] Requesting media stream with constraints", {
-        hasVideo: !!constraints.video,
-        hasAudio: !!constraints.audio
-      });
-      const mediaDevices = requireMediaDevices();
-      this.mediaStream = await mediaDevices.getUserMedia(constraints);
+      this.mediaStream = await this.acquireVideoAndAudioStream();
       logger.info("[StreamManager] Media stream obtained", {
         streamId: this.mediaStream.id,
         videoTracks: this.mediaStream.getVideoTracks().length,
@@ -3627,6 +3844,12 @@ class StreamManager {
       this.emit("streamstart", { stream: this.mediaStream });
       return this.mediaStream;
     } catch (error) {
+      if (error instanceof Error && "code" in error && (error.name === "CameraError" || error.name === "AudioError")) {
+        logger.error("[StreamManager] Failed to start stream", error);
+        this.setState("error");
+        this.emit("error", { error });
+        throw error;
+      }
       const err = createCameraStreamError(error);
       logger.error("[StreamManager] Failed to start stream", err);
       this.setState("error");
@@ -3634,6 +3857,187 @@ class StreamManager {
       throw err;
     }
   }
+  async acquireVideoAndAudioStream() {
+    const mediaDevices = requireMediaDevices();
+    const videoConstraints = this.buildVideoConstraints(this.selectedVideoDeviceId);
+    const audioConstraints = this.buildAudioConstraints(this.selectedAudioDeviceId);
+    this.setAudioStatus("pending");
+    this.pendingAudioError = null;
+    logger.debug("[StreamManager] Attempting combined getUserMedia", {
+      selectedVideoDeviceId: this.selectedVideoDeviceId,
+      selectedAudioDeviceId: this.selectedAudioDeviceId
+    });
+    try {
+      const stream = await mediaDevices.getUserMedia({
+        video: videoConstraints,
+        audio: audioConstraints
+      });
+      const hasVideo = stream.getVideoTracks().length > 0;
+      const hasAudio = stream.getAudioTracks().length > 0;
+      if (hasVideo && hasAudio) {
+        logger.debug("[StreamManager] Combined getUserMedia succeeded with video + audio");
+        this.setAudioStatus("acquired");
+        return stream;
+      }
+      logger.warn("[StreamManager] Combined getUserMedia returned incomplete stream", {
+        videoTracks: stream.getVideoTracks().length,
+        audioTracks: stream.getAudioTracks().length
+      });
+      this.stopStreamTracks(stream);
+    } catch (combinedError) {
+      const combinedErrorName = getErrorName(combinedError);
+      const combinedErrorMessage = extractErrorMessage(combinedError);
+      logger.warn("[StreamManager] Combined getUserMedia failed, falling back to separate acquisition", {
+        error: combinedErrorMessage,
+        errorName: combinedErrorName
+      });
+      this.emitAudioTelemetry({
+        name: "audio.acquisition.fallback",
+        properties: {
+          reason: "combined_getUserMedia_failed",
+          originalError: combinedErrorMessage,
+          originalErrorName: combinedErrorName,
+          selectedAudioDeviceId: this.selectedAudioDeviceId,
+          selectedVideoDeviceId: this.selectedVideoDeviceId
+        }
+      });
+    }
+    let videoStream;
+    try {
+      videoStream = await mediaDevices.getUserMedia({
+        video: videoConstraints,
+        audio: false
+      });
+      logger.debug("[StreamManager] Video-only stream acquired for preview");
+    } catch (videoError) {
+      this.setAudioStatus("failed");
+      throw createCameraStreamError(videoError);
+    }
+    this.mediaStream = videoStream;
+    this.acquisitionGeneration++;
+    const generation = this.acquisitionGeneration;
+    this.audioAcquisitionPromise = this.acquireAudioInBackground(mediaDevices, audioConstraints, generation);
+    return videoStream;
+  }
+  async acquireAudioInBackground(mediaDevices, audioConstraints, generation) {
+    try {
+      const audioTrack = await this.acquireAudioTrackWithRetry(mediaDevices, audioConstraints);
+      if (!this.mediaStream || this.acquisitionGeneration !== generation) {
+        logger.debug("[StreamManager] Audio acquired but stream was replaced/stopped, discarding track", { generation, currentGeneration: this.acquisitionGeneration });
+        audioTrack.stop();
+        return;
+      }
+      this.mediaStream.addTrack(audioTrack);
+      logger.info("[StreamManager] Audio track added to stream", {
+        audioTrackId: audioTrack.id,
+        audioTrackLabel: audioTrack.label,
+        totalAudioTracks: this.mediaStream.getAudioTracks().length
+      });
+      this.setAudioStatus("acquired");
+    } catch (error) {
+      if (this.acquisitionGeneration !== generation) {
+        return;
+      }
+      const audioError = error instanceof Error && "code" in error ? error : createAudioStreamError(error);
+      this.pendingAudioError = audioError;
+      this.setAudioStatus("failed");
+      logger.error("[StreamManager] Background audio acquisition failed", audioError);
+      this.emitAudioTelemetry({
+        name: "audio.acquisition.failed",
+        properties: {
+          errorCode: audioError.code,
+          errorName: audioError.name,
+          maxRetries: AUDIO_MAX_RETRIES,
+          retryDelayMs: this.audioRetryDelayMilliseconds,
+          selectedAudioDeviceId: this.selectedAudioDeviceId
+        },
+        error: audioError
+      });
+      this.emit("error", { error: audioError });
+    } finally {
+      this.audioAcquisitionPromise = null;
+    }
+  }
+  resolveAudioConstraintsForAttempt(audioConstraints, attempt) {
+    if (attempt !== AUDIO_MAX_RETRIES) {
+      return audioConstraints;
+    }
+    if (typeof audioConstraints !== "object") {
+      return audioConstraints;
+    }
+    const { deviceId: _deviceId, ...relaxed } = audioConstraints;
+    const hasOtherConstraints = Object.keys(relaxed).length > 0;
+    const result = hasOtherConstraints ? relaxed : true;
+    logger.debug("[StreamManager] Audio retry with relaxed constraints (no deviceId)", { attempt });
+    return result;
+  }
+  async acquireAudioTrackWithRetry(mediaDevices, audioConstraints) {
+    let lastError = null;
+    for (let attempt = 0;attempt <= AUDIO_MAX_RETRIES; attempt++) {
+      try {
+        const constraintsForAttempt = this.resolveAudioConstraintsForAttempt(audioConstraints, attempt);
+        const audioStream = await mediaDevices.getUserMedia({
+          video: false,
+          audio: constraintsForAttempt
+        });
+        const audioTrack = audioStream.getAudioTracks()[0];
+        if (!audioTrack) {
+          this.stopStreamTracks(audioStream);
+          throw new Error("getUserMedia returned no audio tracks");
+        }
+        for (const track of audioStream.getVideoTracks()) {
+          track.stop();
+        }
+        logger.debug("[StreamManager] Audio track acquired", {
+          attempt,
+          trackId: audioTrack.id,
+          trackLabel: audioTrack.label
+        });
+        if (attempt > 0) {
+          this.emitAudioTelemetry({
+            name: "audio.acquisition.recovered",
+            properties: {
+              successAttempt: attempt,
+              totalAttempts: attempt + 1,
+              audioTrackLabel: audioTrack.label,
+              usedRelaxedConstraints: attempt === AUDIO_MAX_RETRIES
+            }
+          });
+        }
+        return audioTrack;
+      } catch (error) {
+        lastError = error;
+        const errorMessage = extractErrorMessage(error);
+        const errorName = getErrorName(error);
+        const retriable = isRetriableAudioError(error);
+        logger.warn("[StreamManager] Audio acquisition failed", {
+          attempt,
+          maxRetries: AUDIO_MAX_RETRIES,
+          error: errorMessage,
+          errorName,
+          isRetriable: retriable
+        });
+        this.emitAudioTelemetry({
+          name: "audio.acquisition.retry",
+          properties: {
+            attempt,
+            maxRetries: AUDIO_MAX_RETRIES,
+            errorMessage,
+            errorName: errorName ?? "unknown",
+            isRetriable: retriable,
+            usedRelaxedConstraints: attempt === AUDIO_MAX_RETRIES,
+            willRetry: attempt < AUDIO_MAX_RETRIES && retriable
+          }
+        });
+        const canRetry = attempt < AUDIO_MAX_RETRIES && retriable;
+        if (!canRetry) {
+          break;
+        }
+        await this.waitMilliseconds(this.audioRetryDelayMilliseconds);
+      }
+    }
+    throw createAudioStreamError(lastError);
+  }
   stopStream() {
     if (this.mediaStream) {
       for (const track of this.mediaStream.getTracks()) {
@@ -3641,6 +4045,10 @@ class StreamManager {
       }
       this.mediaStream = null;
     }
+    this.audioStatus = "pending";
+    this.pendingAudioError = null;
+    this.audioAcquisitionPromise = null;
+    this.acquisitionGeneration++;
     if (this.state !== "idle") {
       this.setState("idle");
       this.emit("streamstop", undefined);
@@ -3935,6 +4343,7 @@ class StreamRecordingState {
   visibilityChangeHandler = null;
   blurHandler = null;
   focusHandler = null;
+  preResolvedSupportReport = null;
   streamManager;
   dependencies;
   constructor(streamManager, dependencies) {
@@ -3958,6 +4367,9 @@ class StreamRecordingState {
       getCurrentTimestamp: resolvedGetCurrentTimestampDependency
     };
   }
+  setPreResolvedSupportReport(report) {
+    this.preResolvedSupportReport = report;
+  }
   isRecording() {
     return this.streamManager.getState() === "recording";
   }
@@ -3993,11 +4405,20 @@ class StreamRecordingState {
       return Promise.resolve();
     }
     const hasAudioTracks = mediaStream.getAudioTracks().length > 0;
+    if (!hasAudioTracks) {
+      logger.error("[StreamRecordingState] Cannot start recording without audio tracks");
+      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: hasAudioTracks,
-      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,
@@ -4090,8 +4511,6 @@ class StreamRecordingState {
       blob: result.blob,
       mimeType: "video/mp4"
     });
-    this.streamProcessor = null;
-    logger.debug("[StreamRecordingState] StreamProcessor cleared");
     return {
       blob: result.blob,
       tabVisibilityIntervals,
@@ -4278,7 +4697,7 @@ class StreamRecordingState {
   }
   destroy() {
     if (this.streamProcessor) {
-      this.streamProcessor.cancel().catch(() => {});
+      this.streamProcessor.destroy();
       this.streamProcessor = null;
     }
     this.cleanupVisibilityUpdates();
@@ -4383,6 +4802,18 @@ class CameraStreamManager {
   getCurrentVideoSource() {
     return this.recordingState.getCurrentVideoSource();
   }
+  getAudioStatus() {
+    return this.streamManager.getAudioStatus();
+  }
+  isAudioReady() {
+    return this.streamManager.isAudioReady();
+  }
+  async waitForAudio() {
+    return await this.streamManager.waitForAudio();
+  }
+  setPreResolvedSupportReport(report) {
+    this.recordingState.setPreResolvedSupportReport(report);
+  }
   destroy() {
     this.recordingState.destroy();
     this.streamManager.destroy();
@@ -4391,7 +4822,7 @@ class CameraStreamManager {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.4.0",
+  version: "1.5.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",
@@ -4418,6 +4849,7 @@ var package_default = {
     test: "bun test --concurrent",
     "test:watch": "bun test --watch --concurrent",
     "test:coverage": "bun test --coverage --concurrent",
+    "test:bench:recording-start": 'RUN_RECORDING_BENCHMARKS=1 bun test --concurrent "tests/core/recording/recording-start.micro-benchmark.test.ts" "tests/core/recording/recording-start.realistic-benchmark.test.ts"',
     "test:isolation": "bun test --bail",
     "test:random": "bun test --bail --rerun-each 2"
   },
@@ -4473,7 +4905,8 @@ var BATCH_FLUSH_INTERVAL_MS = 1000;
 var THROTTLE_WINDOW_MS = 5000;
 var MAX_RETRY_ATTEMPTS = 3;
 var MAX_PENDING_EVENTS = 100;
-var ONE_TIME_EVENT_CACHE = new Map;
+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);
@@ -4526,7 +4959,13 @@ var TELEMETRY_EVENT_CATEGORY_MAP = {
   "source.switch.requested": "interaction",
   "source.switch.succeeded": "interaction",
   "source.switch.failed": "error",
-  "stream.error": "error"
+  "stream.error": "error",
+  "audio.acquisition.fallback": "lifecycle",
+  "audio.acquisition.retry": "lifecycle",
+  "audio.acquisition.recovered": "lifecycle",
+  "audio.acquisition.failed": "error",
+  "audio.warning": "error",
+  "storage.write.probe.failed": "error"
 };
 
 class TelemetryClient {
@@ -4537,6 +4976,7 @@ class TelemetryClient {
   flushTimeoutId = null;
   throttledEventTimestamps = new Map;
   retryCountMap = new Map;
+  oneTimeEventCache = new Map;
   constructor(config, dependencies) {
     this.config = config;
     this.dependencies = dependencies;
@@ -4639,7 +5079,7 @@ class TelemetryClient {
   shouldSkipEvent(name, timestamp) {
     if (this.isOneTimeEvent(name)) {
       const cacheKey = this.getOneTimeCacheKey(name);
-      const wasSent = ONE_TIME_EVENT_CACHE.get(cacheKey);
+      const wasSent = this.oneTimeEventCache.get(cacheKey);
       if (wasSent) {
         logger.debug("Telemetry event skipped (dedupe)", {
           event: name
@@ -4662,7 +5102,7 @@ class TelemetryClient {
   markEventTracking(name, timestamp) {
     if (this.isOneTimeEvent(name)) {
       const cacheKey = this.getOneTimeCacheKey(name);
-      ONE_TIME_EVENT_CACHE.set(cacheKey, true);
+      this.oneTimeEventCache.set(cacheKey, true);
     }
     if (this.isThrottledEvent(name)) {
       this.throttledEventTimestamps = this.updateNumberMap(this.throttledEventTimestamps, name, timestamp);
@@ -4770,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;
@@ -4780,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;
@@ -5003,16 +5458,16 @@ class UploadQueueManager {
       const retryableUploads = failedUploads.filter((upload) => upload.retryCount < MAX_RETRIES2);
       if (retryableUploads.length > 0) {
         const upload = this.getOldestFailedUpload(retryableUploads);
-        const delay = this.calculateRetryDelay(upload.retryCount);
+        const delay2 = this.calculateRetryDelay(upload.retryCount);
         const timeSinceLastAttempt = Date.now() - upload.updatedAt;
-        if (timeSinceLastAttempt >= delay) {
+        if (timeSinceLastAttempt >= delay2) {
           await this.storageService.updateUploadStatus(upload.id, {
             status: "pending",
             retryCount: upload.retryCount
           });
           await this.processUpload(upload);
         } else {
-          const remainingDelay = delay - timeSinceLastAttempt;
+          const remainingDelay = delay2 - timeSinceLastAttempt;
           this.scheduleRetry(remainingDelay);
         }
       }
@@ -5084,16 +5539,16 @@ class UploadQueueManager {
       if (retryCount >= MAX_RETRIES2) {
         this.callbacks.onUploadError?.(upload.id, new Error(`Upload failed after ${MAX_RETRIES2} attempts: ${errorMessage}`));
       } else {
-        const delay = this.calculateRetryDelay(retryCount);
-        this.scheduleRetry(delay);
+        const delay2 = this.calculateRetryDelay(retryCount);
+        this.scheduleRetry(delay2);
       }
     }
   }
   calculateRetryDelay(retryCount) {
-    const delay = INITIAL_RETRY_DELAY * RETRY_MULTIPLIER ** (retryCount - 1);
-    return Math.min(delay, MAX_RETRY_DELAY);
+    const delay2 = INITIAL_RETRY_DELAY * RETRY_MULTIPLIER ** (retryCount - 1);
+    return Math.min(delay2, MAX_RETRY_DELAY);
   }
-  scheduleRetry(delay) {
+  scheduleRetry(delay2) {
     this.clearTimer(this.retryTimeoutId, clearTimeout);
     this.retryTimeoutId = window.setTimeout(() => {
       this.retryTimeoutId = null;
@@ -5101,7 +5556,7 @@ class UploadQueueManager {
         const errorMessage = extractErrorMessage(error);
         this.callbacks.onUploadError?.("scheduled-retry", new Error(errorMessage));
       });
-    }, delay);
+    }, delay2);
   }
   clearTimer(timerId, clearFn) {
     if (timerId !== null) {
@@ -5258,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) {
@@ -5265,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;
@@ -5299,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) {
@@ -5327,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();
@@ -5380,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";
@@ -5388,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;
@@ -5492,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;
@@ -5530,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);
@@ -5615,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;
@@ -5629,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) {
@@ -5720,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);
@@ -5745,7 +6513,7 @@ class VidtreoAudioWorkletProcessor extends AudioWorkletProcessor {
         type: AUDIO_WORKLET_MESSAGE_TYPE_AUDIO_CHUNK,
         data,
         frames,
-        numberOfChannels,
+        numberOfChannels: 1,
         sampleRate,
         timestamp,
       },
@@ -5761,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;
@@ -5817,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;
@@ -5830,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;
@@ -5927,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();
@@ -6053,20 +6812,130 @@ class AudioWorkletManager {
   }
 }
 
-// src/core/processor/worker/video-input-selector.ts
-function prepareVideoTrack(videoTracks, dependencies) {
-  if (videoTracks.length === 0) {
-    return null;
-  }
-  dependencies.stopCurrentVideoTrack();
-  const originalTrack = videoTracks[0];
-  const videoTrack = dependencies.cloneVideoTrack(originalTrack);
-  dependencies.setCurrentVideoTrack(videoTrack);
-  return videoTrack;
-}
-function prepareAudioTrack(audioTracks, dependencies) {
-  if (audioTracks.length === 0) {
-    return null;
+// 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) {
+    return null;
+  }
+  dependencies.stopCurrentVideoTrack();
+  const originalTrack = videoTracks[0];
+  const videoTrack = dependencies.cloneVideoTrack(originalTrack);
+  dependencies.setCurrentVideoTrack(videoTrack);
+  return videoTrack;
+}
+function prepareAudioTrack(audioTracks, dependencies) {
+  if (audioTracks.length === 0) {
+    return null;
   }
   const originalTrack = audioTracks[0];
   return dependencies.cloneAudioTrack(originalTrack);
@@ -6078,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();
 }
@@ -14180,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;
@@ -14190,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);
@@ -14200,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) {
@@ -14475,20 +15348,31 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       if (!compositionPlan.needsComposition) {
         return { frameToProcess: parameters.videoFrame, imageBitmap: null };
       }
-      const dimensions = this.getValidFrameDimensions(parameters.videoFrame, compositionPlan.rotationDegrees);
-      if (!dimensions) {
+      const outputDimensions = this.getOutputDimensions(parameters.videoFrame, compositionPlan.rotationDegrees, parameters.config);
+      if (!outputDimensions) {
         return { frameToProcess: parameters.videoFrame, imageBitmap: null };
       }
-      const width = dimensions.width;
-      const height = dimensions.height;
+      const width = outputDimensions.width;
+      const height = outputDimensions.height;
+      let fit = null;
+      const sourceDimensions = this.getFrameDimensions(parameters.videoFrame, compositionPlan.rotationDegrees);
+      const dimensionsMismatch = sourceDimensions.width !== width || sourceDimensions.height !== height;
+      if (compositionPlan.needsResizing || dimensionsMismatch) {
+        fit = this.calculateContainFit(sourceDimensions.width, sourceDimensions.height, width, height);
+      }
       const context = this.ensureCompositionCanvas(width, height);
       context.clearRect(0, 0, width, height);
+      if (fit && (fit.drawX > 0 || fit.drawY > 0)) {
+        context.fillStyle = "#000000";
+        context.fillRect(0, 0, width, height);
+      }
       this.drawVideoFrame({
         context,
         videoFrame: parameters.videoFrame,
         rotationDegrees: compositionPlan.rotationDegrees,
         width,
-        height
+        height,
+        fit
       });
       this.applyOverlayIfNeeded(context, width, compositionPlan.shouldApplyOverlay, parameters.overlayConfig);
       this.applyWatermarkIfNeeded({
@@ -14507,6 +15391,7 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       if (parameters.config.watermark && this.watermarkCanvas) {
         needsWatermark = true;
       }
+      const needsResizing = this.detectResizingNeed(parameters.videoFrame, rotationDegrees, parameters.config);
       let needsComposition = false;
       if (parameters.shouldApplyOverlay) {
         needsComposition = true;
@@ -14517,30 +15402,17 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       if (shouldRotateFrame) {
         needsComposition = true;
       }
+      if (needsResizing) {
+        needsComposition = true;
+      }
       return {
         rotationDegrees,
         shouldApplyOverlay: parameters.shouldApplyOverlay,
         needsWatermark,
+        needsResizing,
         needsComposition
       };
     }
-    getValidFrameDimensions(videoFrame, rotationDegrees) {
-      const dimensions = this.getFrameDimensions(videoFrame, rotationDegrees);
-      const width = dimensions.width;
-      const height = dimensions.height;
-      let hasInvalidDimensions = false;
-      if (width <= 0) {
-        hasInvalidDimensions = true;
-      }
-      if (height <= 0) {
-        hasInvalidDimensions = true;
-      }
-      if (hasInvalidDimensions) {
-        this.logger.warn(\`\${RECORDER_WORKER_LOG_PREFIX} Invalid video frame dimensions, skipping composition\`, { width, height });
-        return null;
-      }
-      return { width, height };
-    }
     applyOverlayIfNeeded(context, videoWidth, shouldApplyOverlay, overlayConfig) {
       if (!(shouldApplyOverlay && overlayConfig)) {
         return;
@@ -14724,25 +15596,60 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       return { width, height };
     }
     drawVideoFrame(parameters) {
-      const { context, videoFrame, rotationDegrees, width, height } = parameters;
+      const { context, videoFrame, rotationDegrees, width, height, fit } = parameters;
       const sourceWidth = videoFrame.displayWidth;
       const sourceHeight = videoFrame.displayHeight;
+      if (sourceWidth <= 0 || sourceHeight <= 0) {
+        return;
+      }
       context.setTransform(1, 0, 0, 1, 0, 0);
-      if (rotationDegrees === ROTATION_DEGREES_90) {
-        context.translate(width, 0);
-        context.rotate(ROTATION_RADIANS_90);
+      if (!fit) {
+        if (rotationDegrees === ROTATION_DEGREES_90) {
+          context.translate(width, 0);
+          context.rotate(ROTATION_RADIANS_90);
+          context.drawImage(videoFrame, 0, 0, sourceWidth, sourceHeight);
+          context.setTransform(1, 0, 0, 1, 0, 0);
+          return;
+        }
+        if (rotationDegrees === ROTATION_DEGREES_270) {
+          context.translate(0, height);
+          context.rotate(ROTATION_RADIANS_270);
+          context.drawImage(videoFrame, 0, 0, sourceWidth, sourceHeight);
+          context.setTransform(1, 0, 0, 1, 0, 0);
+          return;
+        }
         context.drawImage(videoFrame, 0, 0, sourceWidth, sourceHeight);
-        context.setTransform(1, 0, 0, 1, 0, 0);
         return;
       }
-      if (rotationDegrees === ROTATION_DEGREES_270) {
-        context.translate(0, height);
-        context.rotate(ROTATION_RADIANS_270);
-        context.drawImage(videoFrame, 0, 0, sourceWidth, sourceHeight);
-        context.setTransform(1, 0, 0, 1, 0, 0);
+      if (rotationDegrees === ROTATION_DEGREES_0) {
+        context.drawImage(videoFrame, fit.drawX, fit.drawY, fit.drawWidth, fit.drawHeight);
         return;
       }
-      context.drawImage(videoFrame, 0, 0, sourceWidth, sourceHeight);
+      const centerX = fit.drawX + fit.drawWidth / DOUBLE_VALUE;
+      const centerY = fit.drawY + fit.drawHeight / DOUBLE_VALUE;
+      context.translate(centerX, centerY);
+      if (rotationDegrees === ROTATION_DEGREES_90) {
+        context.rotate(ROTATION_RADIANS_90);
+      } else if (rotationDegrees === ROTATION_DEGREES_270) {
+        context.rotate(ROTATION_RADIANS_270);
+      } else {
+        context.rotate(Math.PI * rotationDegrees / ROTATION_DEGREES_180);
+      }
+      const isSwappedRotation = rotationDegrees === ROTATION_DEGREES_90 || rotationDegrees === ROTATION_DEGREES_270;
+      const scaleX = isSwappedRotation ? fit.drawWidth / sourceHeight : fit.drawWidth / sourceWidth;
+      const scaleY = isSwappedRotation ? fit.drawHeight / sourceWidth : fit.drawHeight / sourceHeight;
+      context.scale(scaleX, scaleY);
+      context.drawImage(videoFrame, -sourceWidth / DOUBLE_VALUE, -sourceHeight / DOUBLE_VALUE, sourceWidth, sourceHeight);
+      context.setTransform(1, 0, 0, 1, 0, 0);
+    }
+    detectResizingNeed(videoFrame, rotationDegrees, config) {
+      return detectResizingNeed(videoFrame, rotationDegrees, config);
+    }
+    getOutputDimensions(videoFrame, rotationDegrees, config) {
+      return getOutputDimensions(videoFrame, rotationDegrees, config);
+    }
+    calculateContainFit(sourceWidth, sourceHeight, targetWidth, targetHeight) {
+      return calculateContainFit(sourceWidth, sourceHeight, targetWidth, targetHeight);
     }
     logWatermarkError(url2, error) {
       const errorMessage = extractErrorMessage(error);
@@ -14752,6 +15659,78 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       });
     }
   }
+  function calculateContainFit(sourceWidth, sourceHeight, targetWidth, targetHeight) {
+    if (sourceWidth <= 0 || sourceHeight <= 0 || targetWidth <= 0 || targetHeight <= 0) {
+      return {
+        drawX: 0,
+        drawY: 0,
+        drawWidth: targetWidth,
+        drawHeight: targetHeight
+      };
+    }
+    const sourceAspect = sourceWidth / sourceHeight;
+    const targetAspect = targetWidth / targetHeight;
+    let drawWidth;
+    let drawHeight;
+    if (sourceAspect > targetAspect) {
+      drawWidth = targetWidth;
+      drawHeight = targetWidth / sourceAspect;
+    } else {
+      drawHeight = targetHeight;
+      drawWidth = targetHeight * sourceAspect;
+    }
+    const roundedDrawWidth = Math.round(drawWidth);
+    const roundedDrawHeight = Math.round(drawHeight);
+    const drawX = (targetWidth - roundedDrawWidth) / 2;
+    const drawY = (targetHeight - roundedDrawHeight) / 2;
+    return {
+      drawX: Math.round(drawX),
+      drawY: Math.round(drawY),
+      drawWidth: roundedDrawWidth,
+      drawHeight: roundedDrawHeight
+    };
+  }
+  function detectResizingNeed(videoFrame, rotationDegrees, config) {
+    if (typeof config.width !== "number" || typeof config.height !== "number") {
+      return false;
+    }
+    if (config.width <= 0 || config.height <= 0) {
+      return false;
+    }
+    let frameWidth = videoFrame.displayWidth;
+    let frameHeight = videoFrame.displayHeight;
+    if (rotationDegrees === 90 || rotationDegrees === 270) {
+      frameWidth = videoFrame.displayHeight;
+      frameHeight = videoFrame.displayWidth;
+    }
+    if (frameWidth === config.width && frameHeight === config.height) {
+      return false;
+    }
+    const sourceAspect = frameWidth / frameHeight;
+    const targetAspect = config.width / config.height;
+    const aspectRatioTolerance = 0.02;
+    if (Math.abs(sourceAspect - targetAspect) > aspectRatioTolerance) {
+      return true;
+    }
+    const sourcePixels = frameWidth * frameHeight;
+    const targetPixels = config.width * config.height;
+    return sourcePixels > targetPixels;
+  }
+  function getOutputDimensions(videoFrame, rotationDegrees, config) {
+    if (typeof config.width === "number" && config.width > 0 && typeof config.height === "number" && config.height > 0) {
+      return { width: config.width, height: config.height };
+    }
+    let width = videoFrame.displayWidth;
+    let height = videoFrame.displayHeight;
+    if (rotationDegrees === 90 || rotationDegrees === 270) {
+      width = videoFrame.displayHeight;
+      height = videoFrame.displayWidth;
+    }
+    if (width <= 0 || height <= 0) {
+      return null;
+    }
+    return { width, height };
+  }
 
   // src/core/processor/worker/recording-integrity.ts
   var EXCESSIVE_FRAME_ERROR_RATIO_THRESHOLD = 0.5;
@@ -14830,7 +15809,6 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
 
   // src/core/processor/worker/timestamp-manager.ts
   var DEFAULT_FRAME_RATE = 30;
-  var DEFAULT_KEY_FRAME_INTERVAL_SECONDS = 5;
   var MILLISECONDS_PER_SECOND2 = 1000;
   var MICROSECONDS_PER_SECOND = 1e6;
   var MAX_LEAD_SECONDS = 0.05;
@@ -14845,7 +15823,6 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
     lastVideoTimestamp = 0;
     baseVideoTimestamp = null;
     frameCount = 0;
-    lastKeyFrameTimestamp = 0;
     forceNextKeyFrame = false;
     driftOffset = 0;
     logger;
@@ -14863,7 +15840,6 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       this.lastVideoTimestamp = 0;
       this.baseVideoTimestamp = null;
       this.frameCount = 0;
-      this.lastKeyFrameTimestamp = 0;
       this.forceNextKeyFrame = false;
       this.driftOffset = 0;
     }
@@ -14952,36 +15928,25 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
     prepareFrameTiming(parameters) {
       const frameDuration = 1 / this.frameRate;
       let adjustedTimestamp = parameters.frameTimestamp + this.driftOffset;
-      if (adjustedTimestamp - parameters.lastAudioTimestamp > MAX_LEAD_SECONDS) {
-        adjustedTimestamp = parameters.lastAudioTimestamp + MAX_LEAD_SECONDS;
-      }
-      if (parameters.lastAudioTimestamp - adjustedTimestamp > MAX_LAG_SECONDS) {
-        adjustedTimestamp = parameters.lastAudioTimestamp - MAX_LAG_SECONDS;
-      }
       const monotonicTimestamp = this.lastVideoTimestamp + frameDuration;
+      if (adjustedTimestamp < monotonicTimestamp) {
+        adjustedTimestamp = monotonicTimestamp;
+      }
       let finalTimestamp = adjustedTimestamp;
-      if (finalTimestamp < monotonicTimestamp) {
-        finalTimestamp = monotonicTimestamp;
+      if (finalTimestamp - parameters.lastAudioTimestamp > MAX_LEAD_SECONDS) {
+        finalTimestamp = parameters.lastAudioTimestamp + MAX_LEAD_SECONDS;
       }
-      let keyFrameIntervalSeconds = parameters.keyFrameIntervalSeconds;
-      if (!(keyFrameIntervalSeconds > 0)) {
-        keyFrameIntervalSeconds = DEFAULT_KEY_FRAME_INTERVAL_SECONDS;
+      if (parameters.lastAudioTimestamp - finalTimestamp > MAX_LAG_SECONDS) {
+        finalTimestamp = parameters.lastAudioTimestamp - MAX_LAG_SECONDS;
       }
-      let keyFrameIntervalFrames = Math.round(keyFrameIntervalSeconds * this.frameRate);
-      if (keyFrameIntervalFrames < 1) {
-        keyFrameIntervalFrames = 1;
+      const minimumTimestamp = this.lastVideoTimestamp + frameDuration;
+      if (finalTimestamp < minimumTimestamp) {
+        finalTimestamp = minimumTimestamp;
       }
-      const timeSinceLastKeyFrame = finalTimestamp - this.lastKeyFrameTimestamp;
       let isKeyFrame = false;
       if (this.forceNextKeyFrame) {
         isKeyFrame = true;
       }
-      if (timeSinceLastKeyFrame >= keyFrameIntervalSeconds) {
-        isKeyFrame = true;
-      }
-      if (this.frameCount % keyFrameIntervalFrames === 0) {
-        isKeyFrame = true;
-      }
       this.driftOffset *= DRIFT_OFFSET_DECAY_FACTOR;
       return {
         finalTimestamp,
@@ -14993,7 +15958,6 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       this.frameCount += 1;
       this.lastVideoTimestamp = parameters.finalTimestamp;
       if (parameters.isKeyFrame) {
-        this.lastKeyFrameTimestamp = parameters.finalTimestamp;
         this.forceNextKeyFrame = false;
       }
       let shouldLogDrift = false;
@@ -15036,6 +16000,7 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
 
   // src/core/processor/worker/types.ts
   var WORKER_MESSAGE_TYPE_PROBE = "probe";
+  var WORKER_MESSAGE_TYPE_WARMUP = "warmup";
   var WORKER_MESSAGE_TYPE_AUDIO_CHUNK = "audioChunk";
   var WORKER_RESPONSE_TYPE_PROBE_RESULT = "probeResult";
   var WORKER_AUDIO_SAMPLE_FORMAT_F32_PLANAR = "f32-planar";
@@ -15220,6 +16185,7 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
     expectedAudioSampleRate = null;
     pendingWriteCount = 0;
     resolvedHardwareAcceleration = VIDEO_HARDWARE_ACCELERATION_PREFERENCE;
+    hwAccelCacheKey = null;
     consecutiveFrameErrors = 0;
     videoProcessingRunId = 0;
     totalFrameErrors = 0;
@@ -15302,6 +16268,13 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
         case WORKER_MESSAGE_TYPE_PROBE:
           this.handleProbe();
           return;
+        case WORKER_MESSAGE_TYPE_WARMUP:
+          this.resolveHardwareAcceleration(message.config).then((result) => {
+            this.resolvedHardwareAcceleration = result;
+          }).catch((error) => {
+            logger.warn("[RecorderWorker] Warmup hardware acceleration probe failed", { error: extractErrorMessage(error) });
+          });
+          return;
         case "start":
           this.handleStartMessage(message);
           return;
@@ -15332,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}\`));
       }
@@ -15461,7 +16437,6 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
     }
     createVideoSource(config, hardwareAcceleration) {
       const fps = this.timestampManager.getFrameRate();
-      const keyFrameIntervalSeconds = config.keyFrameInterval;
       const videoSourceOptions = {
         codec: config.codec,
         width: config.width,
@@ -15469,10 +16444,10 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
         sizeChangeBehavior: "contain",
         alpha: "discard",
         bitrateMode: "variable",
-        latencyMode: VIDEO_LATENCY_MODE_REALTIME,
+        latencyMode: config.latencyMode || VIDEO_LATENCY_MODE_REALTIME,
         contentHint: VIDEO_CONTENT_HINT_MOTION,
         hardwareAcceleration,
-        keyFrameInterval: keyFrameIntervalSeconds,
+        keyFrameInterval: config.keyFrameInterval,
         bitrate: this.deserializeBitrate(config.bitrate)
       };
       this.videoSource = new VideoSampleSource(videoSourceOptions);
@@ -15499,7 +16474,13 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       if (typeof config.bitrate === "number" && config.bitrate > 0) {
         bitrate = config.bitrate;
       }
-      return await resolveVideoHardwareAcceleration(config.codec, width, height, bitrate);
+      const cacheKey = \`\${config.codec}:\${width}:\${height}:\${config.bitrate}\`;
+      if (this.hwAccelCacheKey === cacheKey) {
+        return this.resolvedHardwareAcceleration;
+      }
+      const result = await resolveVideoHardwareAcceleration(config.codec, width, height, bitrate);
+      this.hwAccelCacheKey = cacheKey;
+      return result;
     }
     setupAudioSource(audioConfig, config) {
       if (!audioConfig) {
@@ -15584,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);
       }
@@ -15601,9 +16584,13 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
         format = DEFAULT_OUTPUT_FORMAT;
       }
       this.validateFormat(format);
-      this.resolvedHardwareAcceleration = await this.resolveHardwareAcceleration(config);
-      this.sendEncoderAcceleration(this.resolvedHardwareAcceleration);
+      const hwAccelPromise = this.resolveHardwareAcceleration(config);
       this.createOutput();
+      if (this.config?.watermark) {
+        this.frameCompositor.prepareWatermark(this.config);
+      }
+      this.resolvedHardwareAcceleration = await hwAccelPromise;
+      this.sendEncoderAcceleration(this.resolvedHardwareAcceleration);
       this.createVideoSource(config, this.resolvedHardwareAcceleration);
       if (videoStream) {
         this.setupVideoProcessingFromStream(videoStream);
@@ -15617,9 +16604,6 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
         this.setupAudioSource(audioConfig, config);
       }
       const output = requireNonNull(this.output, "Output must be initialized before starting");
-      if (this.config?.watermark) {
-        this.frameCompositor.prepareWatermark(this.config);
-      }
       await output.start();
       this.bufferTracker.start();
       this.sendReady();
@@ -15695,7 +16679,6 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       const lastAudioTimestamp = this.audioState.getLastAudioTimestamp();
       const frameTiming = this.timestampManager.prepareFrameTiming({
         frameTimestamp,
-        keyFrameIntervalSeconds: config.keyFrameInterval,
         lastAudioTimestamp
       });
       const sample = new VideoSample(compositionResult.frameToProcess, {
@@ -15874,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");
@@ -15905,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", {
@@ -16199,7 +17182,6 @@ Mediabunny was loaded twice.\` + " This will likely cause Mediabunny not to work
       this.expectedAudioChannels = null;
       this.expectedAudioSampleRate = null;
       this.pendingWriteCount = 0;
-      this.resolvedHardwareAcceleration = VIDEO_HARDWARE_ACCELERATION_PREFERENCE;
       this.consecutiveFrameErrors = 0;
       this.totalFrameErrors = 0;
       this.totalFramesProcessed = 0;
@@ -16364,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 = ",";
@@ -16379,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) {
@@ -16416,29 +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;
@@ -16453,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
     });
@@ -16487,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:
@@ -16505,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));
           }
@@ -16526,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;
@@ -16549,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) {
@@ -16584,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);
@@ -16593,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()
@@ -16608,6 +17624,9 @@ class WorkerProcessor {
       bitrate: config.bitrate
     });
     const workerConfig = this.buildWorkerTranscodeConfig(config, audioCodec, audioBitrate, codec, format);
+    if (typeof config.fps === "number" && config.fps > 0) {
+      this.lastConfigFps = config.fps;
+    }
     const videoTracks = stream.getVideoTracks();
     const audioTracks = stream.getAudioTracks();
     logger.debug("[WorkerProcessor] Preparing to start processing", {
@@ -16619,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);
@@ -16652,6 +17676,10 @@ class WorkerProcessor {
       messageType: message.type
     });
     await this.postStartMessage(message, transferables, shouldStartAudioWorklet);
+    this.startNoFrameWatchdog();
+    if (shouldStartAudioWorklet) {
+      this.startAudioHealthMonitoring();
+    }
   }
   getWorkerOrThrow() {
     if (!this.worker) {
@@ -16664,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) {
@@ -16767,11 +17926,12 @@ class WorkerProcessor {
       audioBitrate,
       codec,
       keyFrameInterval: KEY_FRAME_INTERVAL_SECONDS,
+      latencyMode: config.latencyMode,
       format,
       watermark: config.watermark
     };
   }
-  async prepareAudioPipeline(audioTrack, workerProbeResult) {
+  async prepareAudioPipeline(audioTrack, _workerProbeResult) {
     if (!audioTrack) {
       logger.debug("[WorkerProcessor] Audio pipeline disabled (no track)");
       return {
@@ -16780,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) {
@@ -16818,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);
@@ -16827,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" };
@@ -16888,7 +18037,7 @@ class WorkerProcessor {
       return Promise.resolve();
     }
     const isScreenCapture = isScreenCaptureStream(newStream);
-    const targetFps = DEFAULT_SWITCH_SOURCE_FPS;
+    const targetFps = this.lastConfigFps;
     logger.debug("[WorkerProcessor] Source type detected", {
       isScreenCapture,
       targetFps
@@ -17048,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;
@@ -17062,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,
@@ -17095,13 +18250,60 @@ 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;
+    }
+    const format = config.format || "mp4";
+    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,
+      config: workerConfig
+    };
+    this.worker.postMessage(message);
+  }
   getBufferSize() {
     return this.totalSize;
   }
@@ -17160,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({
@@ -17183,7 +18378,6 @@ class WorkerProcessor {
       setCurrentVideoTrack: (track) => {
         this.currentVideoTrack = track;
       },
-      canUseMainThreadVideoProcessor: () => this.canUseMainThreadVideoProcessorFn(),
       createVideoStreamFromTrack: (track) => this.createVideoStreamFromTrackFn(track),
       createBrowserUnsupportedError: () => this.createBrowserUnsupportedError(),
       getViewportMetadata: () => {
@@ -17243,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,
@@ -17268,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,
@@ -17279,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,
@@ -17293,6 +18516,7 @@ class WorkerProcessor {
     }
     logger.warn("[WorkerProcessor] Audio track clone() not available, using original");
     this.audioTrackClone = originalTrack;
+    this.attachAudioTrackWarnings(originalTrack);
     return originalTrack;
   }
   stopCurrentVideoTrack() {
@@ -17301,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;
@@ -17414,9 +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;
   }
 }
@@ -17452,6 +18676,7 @@ class RecordingManager {
   originalCameraStream = null;
   enableTabVisibilityOverlay = false;
   tabVisibilityOverlayText;
+  startupAborted = false;
   constructor(streamManager, callbacks) {
     this.streamManager = streamManager;
     this.callbacks = callbacks;
@@ -17490,8 +18715,12 @@ class RecordingManager {
   getOriginalCameraStream() {
     return this.originalCameraStream;
   }
-  prewarmStreamProcessor() {
-    this.getOrCreateStreamProcessor();
+  prewarmStreamProcessor(config) {
+    const processor = this.getOrCreateStreamProcessor();
+    processor.prewarm();
+    if (config) {
+      processor.warmupEncoder(config);
+    }
   }
   async startRecording() {
     try {
@@ -17518,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,
@@ -17565,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;
     });
@@ -17579,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();
@@ -17605,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) {
@@ -17672,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;
     }
   }
@@ -17739,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
@@ -17874,6 +19140,7 @@ class RecorderController {
   enableTabVisibilityOverlay = false;
   tabVisibilityOverlayText;
   recordingWarmupTimeoutId = null;
+  audioTelemetryUnsub = null;
   constructor(callbacks = {}) {
     this.callbacks = callbacks;
     this.streamManager = new CameraStreamManager;
@@ -17889,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, {
@@ -17925,6 +19198,14 @@ class RecorderController {
         }
       });
     }
+    this.audioTelemetryUnsub = this.streamManager.on("audiotelemetry", ({ event }) => {
+      const browserName = this.getBrowserNameForTelemetry();
+      this.telemetryManager.sendEvent(event.name, {
+        ...event.properties,
+        browserName,
+        sourceType: this.getCurrentSourceType()
+      }, event.error);
+    });
   }
   async initialize(config) {
     if (this.isInitialized) {
@@ -17967,7 +19248,10 @@ class RecorderController {
         logger.debug(`${LOGGER_PREFIX} startStream called`);
         await this.streamManager.startStream();
         this.ignorePromiseRejection(this.ensureConfigReady());
-        this.recordingManager.prewarmStreamProcessor();
+        this.ignorePromiseRejection(this.configManager.getConfig().then((config) => {
+          this.recordingManager.prewarmStreamProcessor(config);
+        }));
+        this.prewarmSupportCheck();
         logger.debug(`${LOGGER_PREFIX} startStream completed`);
       },
       properties: {
@@ -17992,6 +19276,7 @@ class RecorderController {
       failedEvent: "recording.start.failed",
       action: async () => {
         await this.ensureConfigReady();
+        await this.streamManager.waitForAudio();
         await this.recordingManager.startRecording();
       },
       properties: {
@@ -18138,6 +19423,10 @@ class RecorderController {
       clearTimeout(this.recordingWarmupTimeoutId);
       this.recordingWarmupTimeoutId = null;
     }
+    if (this.audioTelemetryUnsub) {
+      this.audioTelemetryUnsub();
+      this.audioTelemetryUnsub = null;
+    }
     this.uploadQueueManager?.destroy();
     this.storageManager.destroy();
     this.recordingManager.cleanup();
@@ -18177,6 +19466,36 @@ class RecorderController {
   isActive() {
     return this.streamManager.isActive();
   }
+  isAudioReady() {
+    return this.streamManager.isAudioReady();
+  }
+  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();
+    } catch {
+      return "unknown";
+    }
+  }
   async initializeConfig(apiKey, backendUrl) {
     let shouldInitializeConfig = true;
     if (apiKey === null) {
@@ -18213,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;
@@ -18278,8 +19607,8 @@ class RecorderController {
         return;
       }
       this.ignorePromiseRejection(this.ensureConfigReady());
-      this.ignorePromiseRejection(Promise.resolve().then(() => {
-        this.recordingManager.prewarmStreamProcessor();
+      this.ignorePromiseRejection(this.configManager.getConfig().then((config) => {
+        this.recordingManager.prewarmStreamProcessor(config);
       }));
     }, RECORDING_WARMUP_DELAY_MILLISECONDS);
   }
@@ -18288,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;
@@ -18441,6 +19778,18 @@ function getCameraErrorText(errorCode, translations) {
   }
   return translations.failedToStartCamera;
 }
+function getAudioErrorText(errorCode, translations) {
+  if (errorCode === "audio.in-use") {
+    return translations.audioInUse;
+  }
+  if (errorCode === "audio.not-found") {
+    return translations.audioNotFound;
+  }
+  if (errorCode === "audio.permission-denied") {
+    return translations.audioPermissionDenied;
+  }
+  return translations.failedToStartAudio;
+}
 function formatDynamicBrowserUnsupportedText(template, browserName, browserVersion) {
   let resolvedBrowserName = FALLBACK_BROWSER_NAME;
   if (browserName && browserName.trim().length > 0) {
@@ -18494,12 +19843,13 @@ function parseBrowserErrorLinkContent(text) {
 // src/core/utils/device-detection.ts
 import { UAParser as UAParser3 } from "ua-parser-js";
 function isMobileDevice2() {
-  const parser = new UAParser3;
+  const userAgent = globalThis.navigator && typeof globalThis.navigator.userAgent === "string" ? globalThis.navigator.userAgent : "";
+  const parser = new UAParser3(userAgent);
   const result = parser.getResult();
   const deviceType = result.device.type;
   const isMobile = deviceType === "mobile" || deviceType === "tablet";
   logger.debug("Mobile detection result", {
-    userAgent: navigator.userAgent,
+    userAgent,
     deviceType,
     isMobile,
     device: result.device,
@@ -18508,6 +19858,80 @@ function isMobileDevice2() {
   });
   return isMobile;
 }
+// src/core/utils/device-error-resolver.ts
+var ERROR_CODE_BROWSER_UNSUPPORTED2 = "browser.unsupported";
+var ERROR_CODE_CAMERA_PERMISSION_DENIED = "camera.permission-denied";
+var ERROR_CODE_AUDIO_PERMISSION_DENIED = "audio.permission-denied";
+var HIDDEN_RESULT = Object.freeze({
+  visible: false,
+  variant: "generic",
+  canRetry: false,
+  isCameraError: false,
+  isAudioError: false,
+  isBrowserUnsupported: false,
+  isPermissionDenied: false
+});
+function resolveDeviceError(input) {
+  const { errorCode, hasAudioFailed, error } = input;
+  if (errorCode === ERROR_CODE_BROWSER_UNSUPPORTED2) {
+    return {
+      visible: true,
+      variant: "browser",
+      canRetry: false,
+      isCameraError: false,
+      isAudioError: false,
+      isBrowserUnsupported: true,
+      isPermissionDenied: false
+    };
+  }
+  if (errorCode?.startsWith("camera.")) {
+    const isPermissionDenied = errorCode === ERROR_CODE_CAMERA_PERMISSION_DENIED;
+    return {
+      visible: true,
+      variant: "camera",
+      canRetry: !isPermissionDenied,
+      isCameraError: true,
+      isAudioError: false,
+      isBrowserUnsupported: false,
+      isPermissionDenied
+    };
+  }
+  if (hasAudioFailed) {
+    return {
+      visible: true,
+      variant: "audio",
+      canRetry: true,
+      isCameraError: false,
+      isAudioError: true,
+      isBrowserUnsupported: false,
+      isPermissionDenied: false
+    };
+  }
+  if (errorCode?.startsWith("audio.")) {
+    const isPermissionDenied = errorCode === ERROR_CODE_AUDIO_PERMISSION_DENIED;
+    return {
+      visible: true,
+      variant: "audio",
+      canRetry: !isPermissionDenied,
+      isCameraError: false,
+      isAudioError: true,
+      isBrowserUnsupported: false,
+      isPermissionDenied
+    };
+  }
+  if (error) {
+    return {
+      visible: true,
+      variant: "generic",
+      canRetry: true,
+      isCameraError: false,
+      isAudioError: false,
+      isBrowserUnsupported: false,
+      isPermissionDenied: false
+    };
+  }
+  return HIDDEN_RESULT;
+}
 // src/vidtreo-recorder.ts
 class VidtreoRecorder {
   controller;
@@ -18531,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) => {
@@ -18713,6 +20142,7 @@ export {
   validateBrowserSupport,
   transcodeVideoForNativeCamera,
   transcodeVideo,
+  resolveDeviceError,
   requireStream,
   requireProcessor,
   requireNonNull,
@@ -18734,6 +20164,7 @@ export {
   getBrowserName,
   getBrowserInfo,
   getBrowserErrorText,
+  getAudioErrorText,
   getAudioCodecForFormat,
   formatTime,
   formatFileSize,