@vidtreo/recorder 1.3.4 → 1.4.1

package/dist/index.js

@@ -224,7 +224,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 +325,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 +358,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 +387,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 +495,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 = {
@@ -704,6 +716,488 @@ class DeviceManager {
     return this.availableDevices;
   }
 }
+// src/core/device/permission-checker.ts
+var noOperation = () => {
+  return;
+};
+function isPermissionsApiAvailable() {
+  if (typeof navigator === "undefined") {
+    return false;
+  }
+  if (!navigator.permissions) {
+    return false;
+  }
+  return typeof navigator.permissions.query === "function";
+}
+function queryPermissionState(permissionName) {
+  if (!isPermissionsApiAvailable()) {
+    return Promise.resolve("unknown");
+  }
+  return navigator.permissions.query({ name: permissionName }).then((status) => status.state).catch(() => "unknown");
+}
+async function queryAllPermissions() {
+  const [camera, microphone] = await Promise.all([
+    queryPermissionState("camera"),
+    queryPermissionState("microphone")
+  ]);
+  return { camera, microphone };
+}
+function createPermissionChangeListener(permissionName, onStateChange) {
+  if (!isPermissionsApiAvailable()) {
+    return noOperation;
+  }
+  let permissionStatus = null;
+  let isDestroyed = false;
+  const handleChange = () => {
+    if (!permissionStatus) {
+      return;
+    }
+    onStateChange(permissionStatus.state);
+  };
+  navigator.permissions.query({ name: permissionName }).then((status) => {
+    if (isDestroyed) {
+      return;
+    }
+    permissionStatus = status;
+    permissionStatus.addEventListener("change", handleChange);
+  }).catch(noOperation);
+  return () => {
+    isDestroyed = true;
+    if (permissionStatus) {
+      permissionStatus.removeEventListener("change", handleChange);
+      permissionStatus = null;
+    }
+  };
+}
+
+// src/core/device/permission-recovery.ts
+var CHROME_INSTRUCTIONS = {
+  en: "Click the lock/tune icon in the address bar → Site settings → Camera/Microphone → Allow",
+  es: "Haz clic en el icono de candado/ajustes en la barra de direcciones → Configuración del sitio → Cámara/Micrófono → Permitir",
+  resetUrl: "chrome://settings/content/camera"
+};
+var SAFARI_INSTRUCTIONS = {
+  en: "Go to Safari → Settings → Websites → Camera/Microphone → Allow for this site",
+  es: "Ve a Safari → Ajustes → Sitios web → Cámara/Micrófono → Permitir para este sitio"
+};
+var EDGE_INSTRUCTIONS = {
+  en: "Click the lock icon in the address bar → Permissions → Camera/Microphone → Allow",
+  es: "Haz clic en el icono de candado en la barra de direcciones → Permisos → Cámara/Micrófono → Permitir",
+  resetUrl: "edge://settings/content/camera"
+};
+var OPERA_INSTRUCTIONS = {
+  en: "Click the lock icon → Site settings → Camera/Microphone → Allow",
+  es: "Haz clic en el icono de candado → Configuración del sitio → Cámara/Micrófono → Permitir",
+  resetUrl: "opera://settings/content/camera"
+};
+var UNKNOWN_BROWSER_INSTRUCTIONS = {
+  en: "Please check your browser settings to allow camera and microphone access for this site",
+  es: "Por favor, revisa la configuración de tu navegador para permitir el acceso a la cámara y el micrófono en este sitio"
+};
+var INSECURE_CONTEXT_INSTRUCTIONS = {
+  en: "This site must be accessed over HTTPS (secure connection) to use camera and microphone",
+  es: "Este sitio debe ser accedido a través de HTTPS (conexión segura) para usar cámara y micrófono"
+};
+var BROWSER_INSTRUCTIONS_MAP = {
+  chrome: CHROME_INSTRUCTIONS,
+  safari: SAFARI_INSTRUCTIONS,
+  edge: EDGE_INSTRUCTIONS,
+  opera: OPERA_INSTRUCTIONS,
+  unknown: UNKNOWN_BROWSER_INSTRUCTIONS
+};
+var RETRYABLE_ERROR_CODES = new Set([
+  "permission-denied-camera",
+  "permission-denied-microphone",
+  "permission-denied-both",
+  "device-not-found",
+  "device-in-use"
+]);
+function resolveBrowserKey(browserName) {
+  const normalizedName = browserName.toLowerCase();
+  if (normalizedName.includes("edge")) {
+    return "edge";
+  }
+  if (normalizedName.includes("opera") || normalizedName.includes("opr")) {
+    return "opera";
+  }
+  if (normalizedName.includes("chrome")) {
+    return "chrome";
+  }
+  if (normalizedName.includes("safari")) {
+    return "safari";
+  }
+  return "unknown";
+}
+function createPermissionRecoveryData(errorCode, browserInfo, language = "en") {
+  if (errorCode === "insecure-context") {
+    return {
+      errorCode,
+      browserName: browserInfo.name,
+      browserVersion: browserInfo.version,
+      resetInstructions: INSECURE_CONTEXT_INSTRUCTIONS[language],
+      resetUrl: undefined,
+      canRetry: false
+    };
+  }
+  const browserKey = resolveBrowserKey(browserInfo.name);
+  const instructions = BROWSER_INSTRUCTIONS_MAP[browserKey];
+  const canRetry = RETRYABLE_ERROR_CODES.has(errorCode);
+  return {
+    errorCode,
+    browserName: browserInfo.name,
+    browserVersion: browserInfo.version,
+    resetInstructions: instructions[language],
+    resetUrl: instructions.resetUrl,
+    canRetry
+  };
+}
+
+// src/core/device/permission-flow-orchestrator.ts
+var GRANTED_PERMISSION_COUNT = 2;
+var DEFAULT_PERMISSION_STATUS = {
+  camera: "unknown",
+  microphone: "unknown"
+};
+function noOperation2() {
+  return;
+}
+function getIsSecureContext() {
+  const globalWindow = globalThis.window;
+  if (!globalWindow) {
+    return false;
+  }
+  return globalWindow.isSecureContext;
+}
+function stopStreamTracks(stream) {
+  const tracks = stream.getTracks();
+  for (const track of tracks) {
+    track.stop();
+  }
+}
+async function requestPermissionProbe() {
+  const mediaDevices = globalThis.navigator?.mediaDevices;
+  if (!mediaDevices) {
+    return;
+  }
+  const canGetUserMedia = typeof mediaDevices.getUserMedia === "function";
+  if (!canGetUserMedia) {
+    return;
+  }
+  const stream = await mediaDevices.getUserMedia({ audio: true, video: true });
+  stopStreamTracks(stream);
+  await mediaDevices.getUserMedia({
+    audio: true,
+    video: { width: { ideal: 1920 }, height: { ideal: 1080 } }
+  }).then((stream2) => {
+    stopStreamTracks(stream2);
+    return;
+  }).catch(noOperation2);
+}
+function countGrantedPermissions(permissions) {
+  let grantedCount = 0;
+  if (permissions.camera === "granted") {
+    grantedCount += 1;
+  }
+  if (permissions.microphone === "granted") {
+    grantedCount += 1;
+  }
+  return grantedCount;
+}
+function hasUnknownPermissionState(permissions) {
+  if (permissions.camera === "unknown") {
+    return true;
+  }
+  if (permissions.microphone === "unknown") {
+    return true;
+  }
+  return false;
+}
+function hasPromptPermissionState(permissions) {
+  if (permissions.camera === "prompt") {
+    return true;
+  }
+  if (permissions.microphone === "prompt") {
+    return true;
+  }
+  return false;
+}
+function hasHardPermissionDenial(permissions) {
+  if (permissions.camera === "denied") {
+    return true;
+  }
+  if (permissions.microphone === "denied") {
+    return true;
+  }
+  return false;
+}
+function getPermissionDeniedIssueCode(permissions) {
+  const hasCameraDenied = permissions.camera === "denied";
+  const hasMicrophoneDenied = permissions.microphone === "denied";
+  if (hasCameraDenied && hasMicrophoneDenied) {
+    return "permission-denied-both";
+  }
+  if (hasCameraDenied) {
+    return "permission-denied-camera";
+  }
+  return "permission-denied-microphone";
+}
+function createPermissionFlowOrchestratorDependencies() {
+  return {
+    queryAllPermissions,
+    createPermissionChangeListener,
+    createPermissionRecoveryData,
+    getBrowserInfo: () => {
+      const browserInfo = getBrowserInfo();
+      return {
+        name: browserInfo.name,
+        version: browserInfo.version
+      };
+    },
+    getIsSecureContext,
+    requestPermissionProbe
+  };
+}
+
+class PermissionFlowOrchestrator {
+  dependencies;
+  callbacks;
+  language;
+  currentState;
+  cleanupCameraListener = noOperation2;
+  cleanupMicrophoneListener = noOperation2;
+  isInitialized = false;
+  hasCompleted = false;
+  constructor(dependencies, options = {}) {
+    this.dependencies = dependencies;
+    let callbacks = {};
+    if (options.callbacks) {
+      callbacks = options.callbacks;
+    }
+    this.callbacks = callbacks;
+    let language = "en";
+    if (options.language === "es") {
+      language = "es";
+    }
+    this.language = language;
+    this.currentState = {
+      step: "idle",
+      permissions: DEFAULT_PERMISSION_STATUS,
+      denialType: "none",
+      isSecureContext: true,
+      isComplete: false,
+      canRetry: true,
+      shouldProbeUnknown: true
+    };
+  }
+  initialize() {
+    if (this.isInitialized) {
+      return Promise.resolve(this.currentState);
+    }
+    this.isInitialized = true;
+    this.hasCompleted = false;
+    this.setupPermissionListeners();
+    this.updateStateForChecking();
+    this.emitChange("initialized");
+    const isSecureContext = this.dependencies.getIsSecureContext();
+    if (!isSecureContext) {
+      this.currentState = this.createInsecureContextState();
+      this.emitChange("insecure-context");
+      this.tryComplete();
+      return Promise.resolve(this.currentState);
+    }
+    return this.refreshPermissions("permission-refresh");
+  }
+  requestCurrentStep() {
+    if (!this.isInitialized) {
+      return this.initialize();
+    }
+    if (!this.currentState.canRetry) {
+      return Promise.resolve(this.currentState);
+    }
+    this.updateStateForChecking();
+    this.emitChange("current-step-requested");
+    return this.requestPermissionAndRefresh();
+  }
+  retryCurrentStep() {
+    if (!this.isInitialized) {
+      return this.initialize();
+    }
+    if (!this.currentState.canRetry) {
+      return Promise.resolve(this.currentState);
+    }
+    this.updateStateForChecking();
+    this.emitChange("retry-requested");
+    return this.requestPermissionAndRefresh();
+  }
+  getState() {
+    return this.currentState;
+  }
+  requestPermissionAndRefresh() {
+    return this.dependencies.requestPermissionProbe().then(() => {
+      const grantedPermissions = {
+        camera: "granted",
+        microphone: "granted"
+      };
+      this.currentState = this.createStateFromPermissions(grantedPermissions);
+      this.emitChange("probe-complete");
+      this.tryComplete();
+      return this.currentState;
+    }).catch(() => this.refreshPermissions("permission-refresh").then((state) => {
+      if (state.step !== "awaiting-user") {
+        return state;
+      }
+      return this.transitionToBlockedFromFailedProbe();
+    }));
+  }
+  destroy() {
+    this.cleanupCameraListener();
+    this.cleanupCameraListener = noOperation2;
+    this.cleanupMicrophoneListener();
+    this.cleanupMicrophoneListener = noOperation2;
+    this.isInitialized = false;
+    this.hasCompleted = false;
+    this.emitChange("destroyed");
+  }
+  setupPermissionListeners() {
+    this.cleanupCameraListener = this.dependencies.createPermissionChangeListener("camera", (state) => {
+      this.handlePermissionStateChange("camera", state);
+    });
+    this.cleanupMicrophoneListener = this.dependencies.createPermissionChangeListener("microphone", (state) => {
+      this.handlePermissionStateChange("microphone", state);
+    });
+  }
+  handlePermissionStateChange(permissionName, state) {
+    if (!this.isInitialized) {
+      return;
+    }
+    const nextPermissions = {
+      ...this.currentState.permissions,
+      [permissionName]: state
+    };
+    const previousStep = this.currentState.step;
+    this.currentState = this.createStateFromPermissions(nextPermissions);
+    const isFlowReactivating = previousStep === "ready" && this.currentState.step !== "ready";
+    if (isFlowReactivating) {
+      this.hasCompleted = false;
+    }
+    this.emitChange("permission-change");
+    this.tryComplete();
+  }
+  async refreshPermissions(reason) {
+    const permissions = await this.dependencies.queryAllPermissions();
+    this.currentState = this.createStateFromPermissions(permissions);
+    this.emitChange(reason);
+    this.tryComplete();
+    return this.currentState;
+  }
+  createStateFromPermissions(permissions) {
+    const isSecureContext = this.dependencies.getIsSecureContext();
+    if (!isSecureContext) {
+      return this.createInsecureContextState();
+    }
+    const grantedCount = countGrantedPermissions(permissions);
+    if (grantedCount === GRANTED_PERMISSION_COUNT) {
+      return {
+        step: "ready",
+        permissions,
+        denialType: "none",
+        isSecureContext: true,
+        isComplete: true,
+        canRetry: false,
+        shouldProbeUnknown: false
+      };
+    }
+    if (hasHardPermissionDenial(permissions)) {
+      const issueCode = getPermissionDeniedIssueCode(permissions);
+      const recoveryData = this.dependencies.createPermissionRecoveryData(issueCode, this.dependencies.getBrowserInfo(), this.language);
+      return {
+        step: "blocked",
+        permissions,
+        denialType: "hard",
+        issueCode,
+        recoveryData,
+        isSecureContext: true,
+        isComplete: true,
+        canRetry: recoveryData.canRetry,
+        shouldProbeUnknown: false
+      };
+    }
+    const shouldProbeUnknown = hasUnknownPermissionState(permissions);
+    const hasPromptState = hasPromptPermissionState(permissions);
+    let canRetry = false;
+    if (shouldProbeUnknown) {
+      canRetry = true;
+    }
+    if (hasPromptState) {
+      canRetry = true;
+    }
+    return {
+      step: "awaiting-user",
+      permissions,
+      denialType: "soft",
+      isSecureContext: true,
+      isComplete: false,
+      canRetry,
+      shouldProbeUnknown
+    };
+  }
+  transitionToBlockedFromFailedProbe() {
+    const issueCode = "permission-denied-both";
+    const recoveryData = this.dependencies.createPermissionRecoveryData(issueCode, this.dependencies.getBrowserInfo(), this.language);
+    this.currentState = {
+      step: "blocked",
+      permissions: this.currentState.permissions,
+      denialType: "hard",
+      issueCode,
+      recoveryData,
+      isSecureContext: true,
+      isComplete: true,
+      canRetry: recoveryData.canRetry,
+      shouldProbeUnknown: false
+    };
+    this.emitChange("probe-complete");
+    this.tryComplete();
+    return this.currentState;
+  }
+  createInsecureContextState() {
+    const issueCode = "insecure-context";
+    const recoveryData = this.dependencies.createPermissionRecoveryData(issueCode, this.dependencies.getBrowserInfo(), this.language);
+    return {
+      step: "blocked",
+      permissions: this.currentState.permissions,
+      denialType: "hard",
+      issueCode,
+      recoveryData,
+      isSecureContext: false,
+      isComplete: true,
+      canRetry: false,
+      shouldProbeUnknown: false
+    };
+  }
+  updateStateForChecking() {
+    this.currentState = {
+      ...this.currentState,
+      step: "checking"
+    };
+  }
+  emitChange(reason) {
+    if (this.callbacks.onChange) {
+      this.callbacks.onChange(this.currentState, reason);
+    }
+  }
+  tryComplete() {
+    if (this.hasCompleted) {
+      return;
+    }
+    if (!this.currentState.isComplete) {
+      return;
+    }
+    this.hasCompleted = true;
+    if (this.callbacks.onComplete) {
+      this.callbacks.onComplete(this.currentState);
+    }
+  }
+}
 // src/core/utils/video-utils.ts
 import { BlobSource, Input, MP4 } from "mediabunny";
 async function extractVideoDuration(file) {
@@ -1337,6 +1831,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";
@@ -1531,11 +2026,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);
@@ -1546,7 +2041,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;
@@ -1557,13 +2052,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
@@ -1608,7 +2103,7 @@ async function buildSupportReport(requiresAudio, requiresWatermark) {
     audioPath
   };
 }
-async function probeWorkerCapabilities(hasWorker) {
+async function probeWorkerCapabilities(hasWorker, dependencies) {
   if (!hasWorker) {
     return getEmptyProbeResult();
   }
@@ -1618,6 +2113,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;
@@ -1628,7 +2124,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) {
@@ -2136,7 +2632,7 @@ function stopLiveTracks(tracks) {
     }
   }
 }
-function stopStreamTracks(stream) {
+function stopStreamTracks2(stream) {
   stopLiveTracks(stream.getTracks());
 }
 function stopStreamVideoTracks(stream) {
@@ -2153,7 +2649,7 @@ function areTracksLive(videoTrack, audioTrack) {
 }
 function validateTrack(track, trackType, stream) {
   if (!isTrackLive(track)) {
-    stopStreamTracks(stream);
+    stopStreamTracks2(stream);
     let readyState = "undefined";
     if (track) {
       readyState = track.readyState;
@@ -2311,7 +2807,7 @@ class CameraStreamBuilder {
     }
     const managerStream = this.dependencies.streamManager.getStream();
     if (!isRecording && managerStream && managerStream !== this.dependencies.getOriginalCameraStream()) {
-      stopStreamTracks(managerStream);
+      stopStreamTracks2(managerStream);
       this.dependencies.streamManager.setMediaStream(null);
     }
     if (isRecording) {
@@ -2639,7 +3135,7 @@ class SourceSwitchManager {
       callbacks: this.callbacks,
       streamManager: this.streamManager,
       combineScreenShareWithOriginalAudio: (screenVideoTrack) => this.combineScreenShareWithOriginalAudio(screenVideoTrack),
-      stopStreamTracks: (stream) => stopStreamTracks(stream),
+      stopStreamTracks: (stream) => stopStreamTracks2(stream),
       stopStreamVideoTracks: (stream) => stopStreamVideoTracks(stream),
       getCurrentSourceType: () => this.currentSourceType,
       setCurrentSourceType: (sourceType) => {
@@ -2949,26 +3445,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);
@@ -2977,6 +3495,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;
@@ -2985,8 +3517,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;
@@ -3120,20 +3690,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,
@@ -3145,6 +3702,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");
@@ -3152,6 +3715,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()) {
@@ -3159,6 +3903,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);
@@ -3511,9 +4259,13 @@ 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,
+      requiresAudio: true,
       requiresWatermark
     });
     if (!supportReport.isSupported) {
@@ -3901,6 +4653,15 @@ class CameraStreamManager {
   getCurrentVideoSource() {
     return this.recordingState.getCurrentVideoSource();
   }
+  getAudioStatus() {
+    return this.streamManager.getAudioStatus();
+  }
+  isAudioReady() {
+    return this.streamManager.isAudioReady();
+  }
+  async waitForAudio() {
+    return await this.streamManager.waitForAudio();
+  }
   destroy() {
     this.recordingState.destroy();
     this.streamManager.destroy();
@@ -3909,7 +4670,7 @@ class CameraStreamManager {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.3.4",
+  version: "1.4.1",
   type: "module",
   description: "Vidtreo SDK for browser-based video recording and transcoding. Features include camera/screen recording, real-time MP4 transcoding, audio level analysis, mute/pause controls, source switching, device selection, and automatic backend uploads. Similar to Ziggeo and Addpipe, Vidtreo provides enterprise-grade video processing capabilities for web applications.",
   main: "./dist/index.js",
@@ -3936,6 +4697,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"
   },
@@ -3991,7 +4753,6 @@ 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;
 function resolveInstallationId(dependencies) {
   const storageProvider = dependencies.storageProvider;
   const stored = storageProvider?.getItem(TELEMETRY_STORAGE_KEY);
@@ -4044,7 +4805,11 @@ 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"
 };
 
 class TelemetryClient {
@@ -4055,6 +4820,7 @@ class TelemetryClient {
   flushTimeoutId = null;
   throttledEventTimestamps = new Map;
   retryCountMap = new Map;
+  oneTimeEventCache = new Map;
   constructor(config, dependencies) {
     this.config = config;
     this.dependencies = dependencies;
@@ -4157,7 +4923,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
@@ -4180,7 +4946,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);
@@ -4521,16 +5287,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);
         }
       }
@@ -4602,16 +5368,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;
@@ -4619,7 +5385,7 @@ class UploadQueueManager {
         const errorMessage = extractErrorMessage(error);
         this.callbacks.onUploadError?.("scheduled-retry", new Error(errorMessage));
       });
-    }, delay);
+    }, delay2);
   }
   clearTimer(timerId, clearFn) {
     if (timerId !== null) {
@@ -13993,20 +14759,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({
@@ -14025,6 +14802,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;
@@ -14035,30 +14813,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;
@@ -14242,25 +15007,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);
@@ -14270,6 +15070,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;
@@ -14348,7 +15220,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;
@@ -14363,7 +15234,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;
@@ -14381,7 +15251,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;
     }
@@ -14470,36 +15339,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,
@@ -14511,7 +15369,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;
@@ -14554,6 +15411,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";
@@ -14738,6 +15596,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;
@@ -14820,6 +15679,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;
@@ -14979,7 +15845,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,
@@ -14987,10 +15852,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);
@@ -15017,7 +15882,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) {
@@ -15119,9 +15990,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);
@@ -15135,9 +16010,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();
@@ -15213,7 +16085,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, {
@@ -15717,7 +16588,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;
@@ -15941,6 +16811,7 @@ class WorkerProcessor {
   isPaused = false;
   overlayConfig = null;
   readyPromiseResolve = null;
+  lastConfigFps = DEFAULT_SWITCH_SOURCE_FPS;
   workerProbeManager;
   canUseMainThreadVideoProcessorFn;
   createVideoStreamFromTrackFn;
@@ -16126,6 +16997,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", {
@@ -16285,6 +17159,7 @@ class WorkerProcessor {
       audioBitrate,
       codec,
       keyFrameInterval: KEY_FRAME_INTERVAL_SECONDS,
+      latencyMode: config.latencyMode,
       format,
       watermark: config.watermark
     };
@@ -16406,7 +17281,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
@@ -16620,6 +17495,21 @@ class WorkerProcessor {
     this.totalSize = 0;
     return Promise.resolve();
   }
+  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 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;
   }
@@ -16932,6 +17822,9 @@ class StreamProcessor {
   setOnError(callback) {
     this.onError = callback;
   }
+  warmupEncoder(config) {
+    this.workerProcessor.warmupEncoder(config);
+  }
   async cancel() {
     await this.workerProcessor.cancel();
     this.workerProcessor.cleanup();
@@ -17008,8 +17901,11 @@ class RecordingManager {
   getOriginalCameraStream() {
     return this.originalCameraStream;
   }
-  prewarmStreamProcessor() {
-    this.getOrCreateStreamProcessor();
+  prewarmStreamProcessor(config) {
+    const processor = this.getOrCreateStreamProcessor();
+    if (config) {
+      processor.warmupEncoder(config);
+    }
   }
   async startRecording() {
     try {
@@ -17392,6 +18288,7 @@ class RecorderController {
   enableTabVisibilityOverlay = false;
   tabVisibilityOverlayText;
   recordingWarmupTimeoutId = null;
+  audioTelemetryUnsub = null;
   constructor(callbacks = {}) {
     this.callbacks = callbacks;
     this.streamManager = new CameraStreamManager;
@@ -17443,6 +18340,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) {
@@ -17485,7 +18390,9 @@ 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);
+        }));
         logger.debug(`${LOGGER_PREFIX} startStream completed`);
       },
       properties: {
@@ -17510,6 +18417,7 @@ class RecorderController {
       failedEvent: "recording.start.failed",
       action: async () => {
         await this.ensureConfigReady();
+        await this.streamManager.waitForAudio();
         await this.recordingManager.startRecording();
       },
       properties: {
@@ -17656,6 +18564,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();
@@ -17695,6 +18607,19 @@ class RecorderController {
   isActive() {
     return this.streamManager.isActive();
   }
+  isAudioReady() {
+    return this.streamManager.isAudioReady();
+  }
+  getAudioStatus() {
+    return this.streamManager.getAudioStatus();
+  }
+  getBrowserNameForTelemetry() {
+    try {
+      return getBrowserName();
+    } catch {
+      return "unknown";
+    }
+  }
   async initializeConfig(apiKey, backendUrl) {
     let shouldInitializeConfig = true;
     if (apiKey === null) {
@@ -17796,8 +18721,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);
   }
@@ -17959,6 +18884,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) {
@@ -18012,12 +18949,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,
@@ -18026,6 +18964,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;
@@ -18231,6 +19243,7 @@ export {
   validateBrowserSupport,
   transcodeVideoForNativeCamera,
   transcodeVideo,
+  resolveDeviceError,
   requireStream,
   requireProcessor,
   requireNonNull,
@@ -18252,12 +19265,14 @@ export {
   getBrowserName,
   getBrowserInfo,
   getBrowserErrorText,
+  getAudioErrorText,
   getAudioCodecForFormat,
   formatTime,
   formatFileSize,
   extractVideoDuration,
   extractLastFrame,
   extractErrorMessage,
+  createPermissionFlowOrchestratorDependencies,
   checkRecorderSupport,
   calculateVideoBitrate,
   calculateTotalBitrateFromMbPerMinute,
@@ -18271,6 +19286,7 @@ export {
   RecordingManager,
   RecorderController,
   QuotaManager,
+  PermissionFlowOrchestrator,
   PRESET_SIZE_LIMIT_MB_PER_MINUTE,
   NativeCameraHandler,
   FORMAT_DEFAULT_CODECS,