@vidtreo/recorder 1.2.1 → 1.3.0

package/dist/index.js

@@ -215,42 +215,102 @@ function validateBrowserSupport() {
     throw error;
   }
 }
-// src/core/processor/format-codec-mapper.ts
-var FORMAT_DEFAULT_CODECS = {
-  mp4: "aac",
-  mov: "aac",
-  mkv: "opus",
-  webm: "opus"
-};
-function getDefaultAudioCodecForFormat(format) {
-  return FORMAT_DEFAULT_CODECS[format];
-}
-function getAudioCodecForFormat(format, overrideCodec) {
-  if (overrideCodec) {
-    return overrideCodec;
-  }
-  return getDefaultAudioCodecForFormat(format);
-}
-
 // src/core/config/config-constants.ts
 var BYTES_PER_MEGABYTE = 1e6;
 var BITS_PER_BYTE = 8;
 var SECONDS_PER_MINUTE = 60;
-var SD_TARGET_SIZE_MB_PER_MINUTE = 4;
-var HD_TARGET_SIZE_MB_PER_MINUTE = 8;
-var FHD_TARGET_SIZE_MB_PER_MINUTE = 20;
-var K4_TARGET_SIZE_MB_PER_MINUTE = 60;
-var DEFAULT_AUDIO_BITRATE = 128000;
-var TARGET_SIZE_MB_PER_MINUTE = {
-  sd: SD_TARGET_SIZE_MB_PER_MINUTE,
-  hd: HD_TARGET_SIZE_MB_PER_MINUTE,
-  fhd: FHD_TARGET_SIZE_MB_PER_MINUTE,
-  "4k": K4_TARGET_SIZE_MB_PER_MINUTE
+var SD_SIZE_LIMIT_MB_PER_MINUTE = 4;
+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 WEBM_AUDIO_BITRATE = 96000;
+var VIDEO_CODEC_AVC = "avc";
+var VIDEO_CODEC_VP9 = "vp9";
+var VIDEO_CODEC_AV1 = "av1";
+var VIDEO_CODEC_HEVC = "hevc";
+var VIDEO_CODEC_VP8 = "vp8";
+var AUDIO_CODEC_AAC = "aac";
+var AUDIO_CODEC_OPUS = "opus";
+var FORMAT_COMPATIBILITY_POLICY = {
+  mp4: {
+    preferredVideoCodec: VIDEO_CODEC_AVC,
+    preferredAudioCodec: AUDIO_CODEC_AAC,
+    audioBitrate: MP4_AUDIO_BITRATE,
+    videoCodecFallbackOrder: [
+      VIDEO_CODEC_AVC,
+      VIDEO_CODEC_VP9,
+      VIDEO_CODEC_AV1,
+      VIDEO_CODEC_HEVC,
+      VIDEO_CODEC_VP8
+    ],
+    audioCodecFallbackOrder: [AUDIO_CODEC_AAC, AUDIO_CODEC_OPUS]
+  },
+  mov: {
+    preferredVideoCodec: VIDEO_CODEC_AVC,
+    preferredAudioCodec: AUDIO_CODEC_AAC,
+    audioBitrate: MP4_AUDIO_BITRATE,
+    videoCodecFallbackOrder: [
+      VIDEO_CODEC_AVC,
+      VIDEO_CODEC_VP9,
+      VIDEO_CODEC_AV1,
+      VIDEO_CODEC_HEVC,
+      VIDEO_CODEC_VP8
+    ],
+    audioCodecFallbackOrder: [AUDIO_CODEC_AAC, AUDIO_CODEC_OPUS]
+  },
+  mkv: {
+    preferredVideoCodec: VIDEO_CODEC_AVC,
+    preferredAudioCodec: AUDIO_CODEC_AAC,
+    audioBitrate: MP4_AUDIO_BITRATE,
+    videoCodecFallbackOrder: [
+      VIDEO_CODEC_AVC,
+      VIDEO_CODEC_VP9,
+      VIDEO_CODEC_AV1,
+      VIDEO_CODEC_HEVC,
+      VIDEO_CODEC_VP8
+    ],
+    audioCodecFallbackOrder: [AUDIO_CODEC_AAC, AUDIO_CODEC_OPUS]
+  },
+  webm: {
+    preferredVideoCodec: VIDEO_CODEC_VP9,
+    preferredAudioCodec: AUDIO_CODEC_OPUS,
+    audioBitrate: WEBM_AUDIO_BITRATE,
+    videoCodecFallbackOrder: [
+      VIDEO_CODEC_VP9,
+      VIDEO_CODEC_AV1,
+      VIDEO_CODEC_VP8
+    ],
+    audioCodecFallbackOrder: [AUDIO_CODEC_OPUS]
+  }
+};
+var PRESET_SIZE_LIMIT_MB_PER_MINUTE = {
+  sd: SD_SIZE_LIMIT_MB_PER_MINUTE,
+  hd: HD_SIZE_LIMIT_MB_PER_MINUTE,
+  fhd: FHD_SIZE_LIMIT_MB_PER_MINUTE,
+  "4k": K4_SIZE_LIMIT_MB_PER_MINUTE
 };
-function calculateTotalBitrate(sizeMbPerMinute) {
+function resolveLinuxAudioPolicy(formatCompatibilityPolicy) {
+  return {
+    ...formatCompatibilityPolicy,
+    preferredAudioCodec: AUDIO_CODEC_OPUS,
+    audioCodecFallbackOrder: [AUDIO_CODEC_OPUS]
+  };
+}
+function getFormatCompatibilityPolicy(format, formatCompatibilityContext) {
+  const formatCompatibilityPolicy = FORMAT_COMPATIBILITY_POLICY[format];
+  if (!formatCompatibilityContext) {
+    return formatCompatibilityPolicy;
+  }
+  if (!formatCompatibilityContext.isLinuxPlatform) {
+    return formatCompatibilityPolicy;
+  }
+  return resolveLinuxAudioPolicy(formatCompatibilityPolicy);
+}
+function calculateTotalBitrateFromMbPerMinute(sizeMbPerMinute) {
   const bytesPerMinute = sizeMbPerMinute * BYTES_PER_MEGABYTE;
   const bitsPerMinute = bytesPerMinute * BITS_PER_BYTE;
-  return Math.round(bitsPerMinute / SECONDS_PER_MINUTE);
+  return Math.floor(bitsPerMinute / SECONDS_PER_MINUTE);
 }
 function calculateVideoBitrate(totalBitrate, audioBitrate) {
   let videoBitrate = totalBitrate - audioBitrate;
@@ -259,11 +319,24 @@ function calculateVideoBitrate(totalBitrate, audioBitrate) {
   }
   return videoBitrate;
 }
+function getPresetTotalBitrate(preset) {
+  const sizeLimit = PRESET_SIZE_LIMIT_MB_PER_MINUTE[preset];
+  return calculateTotalBitrateFromMbPerMinute(sizeLimit);
+}
+function getPresetAudioBitrateForFormat(format) {
+  const policy = getFormatCompatibilityPolicy(format);
+  return policy.audioBitrate;
+}
+function getPresetVideoBitrateForFormat(preset, format) {
+  const totalBitrate = getPresetTotalBitrate(preset);
+  const audioBitrate = getPresetAudioBitrateForFormat(format);
+  return calculateVideoBitrate(totalBitrate, audioBitrate);
+}
 var PRESET_VIDEO_BITRATE_MAP = {
-  sd: calculateVideoBitrate(calculateTotalBitrate(TARGET_SIZE_MB_PER_MINUTE.sd), DEFAULT_AUDIO_BITRATE),
-  hd: calculateVideoBitrate(calculateTotalBitrate(TARGET_SIZE_MB_PER_MINUTE.hd), DEFAULT_AUDIO_BITRATE),
-  fhd: calculateVideoBitrate(calculateTotalBitrate(TARGET_SIZE_MB_PER_MINUTE.fhd), DEFAULT_AUDIO_BITRATE),
-  "4k": calculateVideoBitrate(calculateTotalBitrate(TARGET_SIZE_MB_PER_MINUTE["4k"]), DEFAULT_AUDIO_BITRATE)
+  sd: getPresetVideoBitrateForFormat("sd", "mp4"),
+  hd: getPresetVideoBitrateForFormat("hd", "mp4"),
+  fhd: getPresetVideoBitrateForFormat("fhd", "mp4"),
+  "4k": getPresetVideoBitrateForFormat("4k", "mp4")
 };
 var RESOLUTION_MAP = {
   sd: { width: 854, height: 480 },
@@ -283,9 +356,9 @@ var DEFAULT_TRANSCODE_CONFIG = Object.freeze({
   fps: 30,
   width: RESOLUTION_MAP.fhd.width,
   height: RESOLUTION_MAP.fhd.height,
-  bitrate: PRESET_VIDEO_BITRATE_MAP.fhd,
-  audioCodec: "aac",
-  audioBitrate: DEFAULT_AUDIO_BITRATE,
+  bitrate: getPresetVideoBitrateForFormat("fhd", "mp4"),
+  audioCodec: getFormatCompatibilityPolicy("mp4").preferredAudioCodec,
+  audioBitrate: getPresetAudioBitrateForFormat("mp4"),
   watermark: {
     url: "https://avatars.githubusercontent.com/u/244247750?s=200&v=4",
     opacity: 1,
@@ -293,171 +366,130 @@ var DEFAULT_TRANSCODE_CONFIG = Object.freeze({
   }
 });
 function getDefaultConfigForFormat(format) {
+  const policy = getFormatCompatibilityPolicy(format);
   return {
     ...DEFAULT_TRANSCODE_CONFIG,
     format,
-    audioCodec: getDefaultAudioCodecForFormat(format)
+    bitrate: getPresetVideoBitrateForFormat("fhd", format),
+    audioCodec: policy.preferredAudioCodec,
+    audioBitrate: policy.audioBitrate
   };
 }
-// src/core/processor/codec-detector.ts
-var VIDEO_CODEC_AV1 = "av1";
-var VIDEO_CODEC_VP9 = "vp9";
-var VIDEO_CODEC_AVC = "avc";
-var AUDIO_CODEC_AAC = "aac";
-var AUDIO_CODEC_OPUS = "opus";
-var ERROR_NO_SUPPORTED_AUDIO_CODEC = "No supported audio codec found for recording";
-var AUDIO_CODEC_CANDIDATES = [
-  AUDIO_CODEC_AAC,
-  AUDIO_CODEC_OPUS
-];
-async function resolveMediabunnyModule(dependencies) {
-  if (dependencies?.loadMediabunny) {
-    return await dependencies.loadMediabunny();
-  }
-  return await import("mediabunny");
-}
-function buildVideoCodecCheckOptions(width, height, bitrate) {
-  let checkOptions = {};
-  if (width !== undefined) {
-    checkOptions = { ...checkOptions, width };
-  }
-  if (height !== undefined) {
-    checkOptions = { ...checkOptions, height };
+// src/core/utils/device-detector.ts
+import { UAParser as UAParser2 } from "ua-parser-js";
+function isMobileDevice() {
+  const parser = new UAParser2;
+  const device = parser.getDevice();
+  if (device.type === "mobile") {
+    return true;
   }
-  if (bitrate !== undefined) {
-    checkOptions = { ...checkOptions, bitrate };
+  if (device.type === "tablet") {
+    return true;
   }
-  return checkOptions;
+  return false;
 }
-function buildAudioCodecCheckOptions(bitrate) {
-  let checkOptions = {};
-  if (bitrate !== undefined) {
-    checkOptions = { ...checkOptions, bitrate };
+
+// src/core/utils/platform-detection.ts
+var PLATFORM_KEYWORD_LINUX = "linux";
+var PLATFORM_KEYWORD_ANDROID = "android";
+var RUNTIME_MARKER_BUN = "bun/";
+var RUNTIME_MARKER_HAPPY_DOM = "happydom";
+var RUNTIME_MARKER_NODE = "node.js";
+function normalizeValue(value) {
+  if (value === undefined) {
+    return "";
   }
-  return checkOptions;
-}
-function createMediabunnyModuleResult(module) {
-  return { kind: "result", module };
-}
-function createMediabunnyModuleError(error) {
-  return { kind: "error", error };
-}
-function createVideoCodecSupportResult(supported) {
-  return { kind: "result", supported };
-}
-function createVideoCodecSupportError(error) {
-  return { kind: "error", error };
+  return value.toLowerCase();
 }
-async function getVideoCodecSupport(canEncodeVideo, codec, checkOptions) {
-  return await canEncodeVideo(codec, checkOptions).then((supported) => createVideoCodecSupportResult(supported)).catch((error) => createVideoCodecSupportError(error));
+function hasPlatformKeyword(value, keyword) {
+  return value.includes(keyword);
 }
-function createAudioCodecLookupResult(codec) {
-  return { kind: "result", codec };
-}
-function createAudioCodecLookupError(error) {
-  return { kind: "error", error };
-}
-async function detectBestCodec(width, height, bitrate, dependencies) {
-  const mediabunnyModuleResult = await resolveMediabunnyModule(dependencies).then((module) => createMediabunnyModuleResult(module)).catch((error) => createMediabunnyModuleError(error));
-  if (mediabunnyModuleResult.kind === "error") {
-    return VIDEO_CODEC_AVC;
-  }
-  const { canEncodeVideo } = mediabunnyModuleResult.module;
-  if (typeof canEncodeVideo !== "function") {
-    return VIDEO_CODEC_AVC;
+function isNonBrowserRuntime(userAgent) {
+  if (userAgent.includes(RUNTIME_MARKER_BUN)) {
+    return true;
   }
-  const checkOptions = buildVideoCodecCheckOptions(width, height, bitrate);
-  const videoCodecSupportResult = await getVideoCodecSupport(canEncodeVideo, VIDEO_CODEC_AV1, checkOptions);
-  if (videoCodecSupportResult.kind === "error") {
-    return VIDEO_CODEC_AVC;
+  if (userAgent.includes(RUNTIME_MARKER_HAPPY_DOM)) {
+    return true;
   }
-  if (videoCodecSupportResult.supported) {
-    return VIDEO_CODEC_AV1;
+  if (userAgent.includes(RUNTIME_MARKER_NODE)) {
+    return true;
   }
-  return VIDEO_CODEC_AVC;
+  return false;
 }
-async function detectBestWebmCodec(width, height, bitrate, dependencies) {
-  const mediabunnyModuleResult = await resolveMediabunnyModule(dependencies).then((module) => createMediabunnyModuleResult(module)).catch((error) => createMediabunnyModuleError(error));
-  if (mediabunnyModuleResult.kind === "error") {
-    return VIDEO_CODEC_VP9;
-  }
-  const { canEncodeVideo } = mediabunnyModuleResult.module;
-  if (typeof canEncodeVideo !== "function") {
-    return VIDEO_CODEC_VP9;
+function resolveNavigatorProvider(navigatorProvider) {
+  if (navigatorProvider) {
+    return navigatorProvider;
   }
-  const checkOptions = buildVideoCodecCheckOptions(width, height, bitrate);
-  const av1SupportResult = await getVideoCodecSupport(canEncodeVideo, VIDEO_CODEC_AV1, checkOptions);
-  if (av1SupportResult.kind === "error") {
-    return VIDEO_CODEC_VP9;
-  }
-  if (av1SupportResult.supported) {
-    return VIDEO_CODEC_AV1;
-  }
-  const vp9SupportResult = await getVideoCodecSupport(canEncodeVideo, VIDEO_CODEC_VP9, checkOptions);
-  if (vp9SupportResult.kind === "error") {
-    return VIDEO_CODEC_VP9;
-  }
-  if (vp9SupportResult.supported) {
-    return VIDEO_CODEC_VP9;
+  if (typeof navigator === "undefined") {
+    return null;
   }
-  return VIDEO_CODEC_VP9;
+  const globalNavigator = navigator;
+  return {
+    platform: globalNavigator.platform,
+    userAgent: globalNavigator.userAgent,
+    userAgentData: globalNavigator.userAgentData
+  };
 }
-async function detectBestAudioCodec(bitrate, dependencies) {
-  const mediabunnyModuleResult = await resolveMediabunnyModule(dependencies).then((module) => createMediabunnyModuleResult(module)).catch((error) => createMediabunnyModuleError(error));
-  if (mediabunnyModuleResult.kind === "error") {
-    return AUDIO_CODEC_AAC;
+function isLinuxPlatform(navigatorProvider) {
+  const resolvedNavigatorProvider = resolveNavigatorProvider(navigatorProvider);
+  if (resolvedNavigatorProvider === null) {
+    return false;
   }
-  const { getFirstEncodableAudioCodec } = mediabunnyModuleResult.module;
-  if (typeof getFirstEncodableAudioCodec !== "function") {
-    return AUDIO_CODEC_AAC;
+  const userAgent = normalizeValue(resolvedNavigatorProvider.userAgent);
+  if (isNonBrowserRuntime(userAgent)) {
+    return false;
   }
-  const checkOptions = buildAudioCodecCheckOptions(bitrate);
-  const audioCodecLookupResult = await getFirstEncodableAudioCodec(AUDIO_CODEC_CANDIDATES, checkOptions).then((codec) => createAudioCodecLookupResult(codec)).catch((error) => createAudioCodecLookupError(error));
-  if (audioCodecLookupResult.kind === "error") {
-    const errorMessage = extractErrorMessage(audioCodecLookupResult.error);
-    if (errorMessage === ERROR_NO_SUPPORTED_AUDIO_CODEC) {
-      throw new Error(ERROR_NO_SUPPORTED_AUDIO_CODEC);
-    }
-    return AUDIO_CODEC_AAC;
+  const platform = normalizeValue(resolvedNavigatorProvider.platform);
+  const userAgentDataPlatform = normalizeValue(resolvedNavigatorProvider.userAgentData?.platform);
+  const isAndroidPlatform = hasPlatformKeyword(platform, PLATFORM_KEYWORD_ANDROID) || hasPlatformKeyword(userAgentDataPlatform, PLATFORM_KEYWORD_ANDROID) || hasPlatformKeyword(userAgent, PLATFORM_KEYWORD_ANDROID);
+  if (isAndroidPlatform) {
+    return false;
   }
-  if (audioCodecLookupResult.codec === null) {
-    throw new Error(ERROR_NO_SUPPORTED_AUDIO_CODEC);
+  if (platform.includes(PLATFORM_KEYWORD_LINUX)) {
+    return true;
   }
-  return audioCodecLookupResult.codec;
-}
-
-// src/core/utils/device-detector.ts
-import { UAParser as UAParser2 } from "ua-parser-js";
-function isMobileDevice() {
-  const parser = new UAParser2;
-  const device = parser.getDevice();
-  if (device.type === "mobile") {
+  if (userAgentDataPlatform.includes(PLATFORM_KEYWORD_LINUX)) {
     return true;
   }
-  if (device.type === "tablet") {
+  if (userAgent.includes(PLATFORM_KEYWORD_LINUX)) {
     return true;
   }
   return false;
 }
 
 // src/core/config/preset-mapper.ts
-async function mapPresetToConfig(options) {
+function mapPresetToConfig(options) {
   const { preset, outputFormat, watermark, isMobile } = options;
-  if (!(preset in PRESET_VIDEO_BITRATE_MAP)) {
-    throw new Error(`Invalid preset: ${preset}`);
+  if (!(preset in RESOLUTION_MAP)) {
+    return Promise.reject(new Error(`Invalid preset: ${preset}`));
+  }
+  let isMobileDeviceDetected = isMobile;
+  if (isMobileDeviceDetected === undefined) {
+    isMobileDeviceDetected = isMobileDevice();
+  }
+  let resolutionMap = RESOLUTION_MAP;
+  if (isMobileDeviceDetected) {
+    resolutionMap = MOBILE_RESOLUTION_MAP;
   }
-  const isMobileDeviceDetected = isMobile === undefined ? isMobileDevice() : isMobile;
-  const resolutionMap = isMobileDeviceDetected ? MOBILE_RESOLUTION_MAP : RESOLUTION_MAP;
   const { width, height } = resolutionMap[preset];
-  const format = outputFormat || "mp4";
-  const audioCodec = await detectBestAudioCodec(DEFAULT_AUDIO_BITRATE);
+  let format = outputFormat;
+  if (format === undefined) {
+    format = "mp4";
+  }
+  let isLinuxPlatformDetected = options.isLinuxPlatform;
+  if (isLinuxPlatformDetected === undefined) {
+    isLinuxPlatformDetected = isLinuxPlatform();
+  }
+  const policy = getFormatCompatibilityPolicy(format, {
+    isLinuxPlatform: isLinuxPlatformDetected
+  });
   const config = {
     format,
     width,
     height,
-    bitrate: PRESET_VIDEO_BITRATE_MAP[preset],
-    audioCodec,
-    audioBitrate: DEFAULT_AUDIO_BITRATE
+    bitrate: getPresetVideoBitrateForFormat(preset, format),
+    audioCodec: policy.preferredAudioCodec,
+    audioBitrate: policy.audioBitrate
   };
   if (watermark) {
     config.watermark = {
@@ -466,7 +498,7 @@ async function mapPresetToConfig(options) {
       position: watermark.position
     };
   }
-  return config;
+  return Promise.resolve(config);
 }
 
 // src/core/config/config-service.ts
@@ -589,14 +621,7 @@ class ConfigManager {
       apiKey,
       backendUrl: normalizedBackendUrl
     });
-    this.configService.fetchConfig().then((config) => {
-      this.currentConfig = config;
-      this.configReady = this.configService?.isConfigReady() ?? false;
-      this.configFetched = true;
-    }).catch(() => {
-      this.configReady = false;
-      this.configFetched = true;
-    });
+    this.fetchConfigInBackground();
   }
   async fetchConfig() {
     if (!this.configService) {
@@ -612,6 +637,12 @@ class ConfigManager {
     }
     return this.currentConfig;
   }
+  getConfigForRecording() {
+    if (this.configService && !this.configFetched) {
+      this.fetchConfigInBackground();
+    }
+    return this.currentConfig;
+  }
   isConfigReady() {
     return this.configReady;
   }
@@ -621,6 +652,12 @@ class ConfigManager {
     }
     this.configService.clearCache();
   }
+  fetchConfigInBackground() {
+    this.fetchConfig().catch(() => {
+      this.configReady = false;
+      this.configFetched = true;
+    });
+  }
 }
 // src/core/device/device-manager.ts
 class DeviceManager {
@@ -764,8 +801,160 @@ import {
   Output,
   WebMOutputFormat
 } from "mediabunny";
+
+// src/core/processor/codec-policy-resolver.ts
+var VIDEO_HARDWARE_ACCELERATION_PREFERENCE = "prefer-hardware";
+var FIRST_RESULT_INDEX = 0;
+async function loadMediabunnyModuleDependency() {
+  const importResults = await Promise.allSettled([import("mediabunny")]);
+  const importResult = importResults[FIRST_RESULT_INDEX];
+  if (importResult.status === "fulfilled") {
+    return importResult.value;
+  }
+  return null;
+}
+var DEFAULT_CODEC_POLICY_RESOLVER_DEPENDENCIES = {
+  loadMediabunnyModule: loadMediabunnyModuleDependency
+};
+function resolveCodecPolicyResolverDependencies(dependencies) {
+  const loadMediabunnyModuleDependency2 = dependencies?.loadMediabunnyModule;
+  let resolvedLoadMediabunnyModuleDependency;
+  if (loadMediabunnyModuleDependency2 === undefined) {
+    resolvedLoadMediabunnyModuleDependency = DEFAULT_CODEC_POLICY_RESOLVER_DEPENDENCIES.loadMediabunnyModule;
+  } else {
+    resolvedLoadMediabunnyModuleDependency = loadMediabunnyModuleDependency2;
+  }
+  return {
+    loadMediabunnyModule: resolvedLoadMediabunnyModuleDependency
+  };
+}
+function addUniqueCandidate(candidates, candidate) {
+  if (candidate === undefined) {
+    return candidates;
+  }
+  const hasCandidate = candidates.includes(candidate);
+  if (hasCandidate) {
+    return candidates;
+  }
+  return [...candidates, candidate];
+}
+function buildVideoCandidates(overrideCodec, policy) {
+  let candidates = [];
+  if (overrideCodec !== undefined) {
+    const canUseOverride = policy.videoCodecFallbackOrder.includes(overrideCodec);
+    if (canUseOverride) {
+      candidates = addUniqueCandidate(candidates, overrideCodec);
+    }
+  }
+  candidates = addUniqueCandidate(candidates, policy.preferredVideoCodec);
+  for (const fallbackCodec of policy.videoCodecFallbackOrder) {
+    candidates = addUniqueCandidate(candidates, fallbackCodec);
+  }
+  return candidates;
+}
+function buildAudioCandidates(overrideCodec, policy) {
+  let candidates = [];
+  if (overrideCodec !== undefined) {
+    const canUseOverride = policy.audioCodecFallbackOrder.includes(overrideCodec);
+    if (canUseOverride) {
+      candidates = addUniqueCandidate(candidates, overrideCodec);
+    }
+  }
+  candidates = addUniqueCandidate(candidates, policy.preferredAudioCodec);
+  for (const fallbackCodec of policy.audioCodecFallbackOrder) {
+    candidates = addUniqueCandidate(candidates, fallbackCodec);
+  }
+  return candidates;
+}
+async function resolveVideoCodecFromPolicy(options) {
+  const dependencies = resolveCodecPolicyResolverDependencies(options.dependencies);
+  const mediabunnyModule = await dependencies.loadMediabunnyModule();
+  if (mediabunnyModule === null) {
+    return options.policy.preferredVideoCodec;
+  }
+  const canEncodeVideo = mediabunnyModule.canEncodeVideo;
+  if (typeof canEncodeVideo !== "function") {
+    return options.policy.preferredVideoCodec;
+  }
+  const candidates = buildVideoCandidates(options.overrideCodec, options.policy);
+  const videoCodecOptions = {
+    hardwareAcceleration: VIDEO_HARDWARE_ACCELERATION_PREFERENCE
+  };
+  if (options.width !== undefined) {
+    videoCodecOptions.width = options.width;
+  }
+  if (options.height !== undefined) {
+    videoCodecOptions.height = options.height;
+  }
+  if (options.bitrate !== undefined) {
+    videoCodecOptions.bitrate = options.bitrate;
+  }
+  const probeResults = await Promise.allSettled(candidates.map(async (codec) => {
+    const canEncode = await canEncodeVideo(codec, videoCodecOptions);
+    return {
+      codec,
+      canEncode
+    };
+  }));
+  let hasProbeError = false;
+  for (const probeResult of probeResults) {
+    if (probeResult.status === "rejected") {
+      hasProbeError = true;
+      continue;
+    }
+    if (probeResult.value.canEncode) {
+      return probeResult.value.codec;
+    }
+  }
+  if (hasProbeError) {
+    return options.policy.preferredVideoCodec;
+  }
+  if (options.shouldThrowIfNoCodecAvailable) {
+    throw new Error(`No encodable video codec available for format: ${options.format}`);
+  }
+  return options.policy.preferredVideoCodec;
+}
+async function resolveAudioCodecFromPolicy(options) {
+  const dependencies = resolveCodecPolicyResolverDependencies(options.dependencies);
+  const mediabunnyModule = await dependencies.loadMediabunnyModule();
+  if (mediabunnyModule === null) {
+    return options.policy.preferredAudioCodec;
+  }
+  const getFirstEncodableAudioCodec = mediabunnyModule.getFirstEncodableAudioCodec;
+  if (typeof getFirstEncodableAudioCodec !== "function") {
+    return options.policy.preferredAudioCodec;
+  }
+  const candidates = buildAudioCandidates(options.overrideCodec, options.policy);
+  const audioCodecOptions = {};
+  if (options.bitrate !== undefined) {
+    audioCodecOptions.bitrate = options.bitrate;
+  }
+  const probeResults = await Promise.allSettled([
+    getFirstEncodableAudioCodec(candidates, audioCodecOptions)
+  ]);
+  const firstProbeResult = probeResults[FIRST_RESULT_INDEX];
+  if (firstProbeResult.status === "rejected") {
+    return options.policy.preferredAudioCodec;
+  }
+  const resolvedCodec = firstProbeResult.value;
+  if (resolvedCodec === null) {
+    if (options.shouldThrowIfNoCodecAvailable) {
+      throw new Error(`No encodable audio codec available for format: ${options.format}`);
+    }
+    return options.policy.preferredAudioCodec;
+  }
+  const canUseResolvedCodec = candidates.includes(resolvedCodec);
+  if (canUseResolvedCodec) {
+    return resolvedCodec;
+  }
+  if (options.shouldThrowIfNoCodecAvailable) {
+    throw new Error(`No encodable audio codec available for format: ${options.format}`);
+  }
+  return options.policy.preferredAudioCodec;
+}
+
+// src/core/transcode/video-transcoder.ts
 var ALLOW_ROTATION_METADATA = false;
-var OUTPUT_FORMAT_WEBM = "webm";
 function createSource(input) {
   if (typeof input === "string") {
     return new FilePathSource(input);
@@ -803,14 +992,7 @@ function getMimeTypeForFormat(format) {
       throw new Error(`Unsupported output format: ${format}`);
   }
 }
-async function resolvePreferredVideoCodec(config) {
-  if (config.format === OUTPUT_FORMAT_WEBM) {
-    return await detectBestWebmCodec(config.width, config.height, config.bitrate);
-  }
-  return await detectBestCodec(config.width, config.height, config.bitrate);
-}
 function createConversionOptions(config, optimizeForSpeed = false) {
-  const audioCodec = getAudioCodecForFormat(config.format, config.audioCodec);
   const video = {
     fit: "contain",
     forceTranscode: true,
@@ -838,7 +1020,7 @@ function createConversionOptions(config, optimizeForSpeed = false) {
     video.keyFrameInterval = 2;
   }
   const audio = {
-    codec: audioCodec,
+    codec: config.audioCodec,
     forceTranscode: true,
     ...optimizeForSpeed && { bitrateMode: "variable" }
   };
@@ -851,15 +1033,35 @@ function validateConversion(conversion) {
   }
 }
 async function transcodeVideo(input, config = {}, onProgress) {
+  let resolvedFormat = config.format;
+  if (resolvedFormat === undefined) {
+    resolvedFormat = DEFAULT_TRANSCODE_CONFIG.format;
+  }
   const finalConfig = {
     ...DEFAULT_TRANSCODE_CONFIG,
     ...config,
-    format: config.format || DEFAULT_TRANSCODE_CONFIG.format
+    format: resolvedFormat
   };
-  if (!finalConfig.audioCodec) {
-    finalConfig.audioCodec = await detectBestAudioCodec(finalConfig.audioBitrate);
-  }
-  finalConfig.codec = await resolvePreferredVideoCodec(finalConfig);
+  const policy = getFormatCompatibilityPolicy(finalConfig.format, {
+    isLinuxPlatform: isLinuxPlatform()
+  });
+  if (finalConfig.audioBitrate === undefined) {
+    finalConfig.audioBitrate = getPresetAudioBitrateForFormat(finalConfig.format);
+  }
+  finalConfig.audioCodec = await resolveAudioCodecFromPolicy({
+    format: finalConfig.format,
+    overrideCodec: finalConfig.audioCodec,
+    policy,
+    bitrate: finalConfig.audioBitrate
+  });
+  finalConfig.codec = await resolveVideoCodecFromPolicy({
+    format: finalConfig.format,
+    overrideCodec: finalConfig.codec,
+    policy,
+    width: finalConfig.width,
+    height: finalConfig.height,
+    bitrate: finalConfig.bitrate
+  });
   const source = createSource(input);
   const mediabunnyInput = new Input2({
     formats: ALL_FORMATS,
@@ -891,15 +1093,35 @@ async function transcodeVideo(input, config = {}, onProgress) {
   };
 }
 async function transcodeVideoForNativeCamera(file, config = {}, onProgress) {
+  let resolvedFormat = config.format;
+  if (resolvedFormat === undefined) {
+    resolvedFormat = DEFAULT_TRANSCODE_CONFIG.format;
+  }
   const finalConfig = {
     ...DEFAULT_TRANSCODE_CONFIG,
     ...config,
-    format: config.format || DEFAULT_TRANSCODE_CONFIG.format
+    format: resolvedFormat
   };
-  if (!finalConfig.audioCodec) {
-    finalConfig.audioCodec = await detectBestAudioCodec(finalConfig.audioBitrate);
-  }
-  finalConfig.codec = await resolvePreferredVideoCodec(finalConfig);
+  const policy = getFormatCompatibilityPolicy(finalConfig.format, {
+    isLinuxPlatform: isLinuxPlatform()
+  });
+  if (finalConfig.audioBitrate === undefined) {
+    finalConfig.audioBitrate = getPresetAudioBitrateForFormat(finalConfig.format);
+  }
+  finalConfig.audioCodec = await resolveAudioCodecFromPolicy({
+    format: finalConfig.format,
+    overrideCodec: finalConfig.audioCodec,
+    policy,
+    bitrate: finalConfig.audioBitrate
+  });
+  finalConfig.codec = await resolveVideoCodecFromPolicy({
+    format: finalConfig.format,
+    overrideCodec: finalConfig.codec,
+    policy,
+    width: finalConfig.width,
+    height: finalConfig.height,
+    bitrate: finalConfig.bitrate
+  });
   const source = new BlobSource2(file);
   const mediabunnyInput = new Input2({
     formats: ALL_FORMATS,
@@ -1067,6 +1289,25 @@ class NativeCameraHandler {
     }
   }
 }
+// src/core/processor/format-codec-mapper.ts
+var FORMAT_COMPATIBILITY_CONTEXT = {
+  isLinuxPlatform: isLinuxPlatform()
+};
+var FORMAT_DEFAULT_CODECS = {
+  mp4: getFormatCompatibilityPolicy("mp4", FORMAT_COMPATIBILITY_CONTEXT).preferredAudioCodec,
+  mov: getFormatCompatibilityPolicy("mov", FORMAT_COMPATIBILITY_CONTEXT).preferredAudioCodec,
+  mkv: getFormatCompatibilityPolicy("mkv", FORMAT_COMPATIBILITY_CONTEXT).preferredAudioCodec,
+  webm: getFormatCompatibilityPolicy("webm", FORMAT_COMPATIBILITY_CONTEXT).preferredAudioCodec
+};
+function getDefaultAudioCodecForFormat(format) {
+  return FORMAT_DEFAULT_CODECS[format];
+}
+function getAudioCodecForFormat(format, overrideCodec) {
+  if (overrideCodec) {
+    return overrideCodec;
+  }
+  return getDefaultAudioCodecForFormat(format);
+}
 // src/core/processor/worker/probe-worker-url.ts
 var PROBE_WORKER_CODE = `"use strict";
 var PROBE_MESSAGE_TYPE="probe";
@@ -1119,12 +1360,48 @@ var AUDIO_PATH_MAIN_THREAD_AUDIO_STREAM = "main-thread-audio-stream";
 var AUDIO_PATH_AUDIO_WORKLET_CHUNKS = "audio-worklet-chunks";
 var AUDIO_PATH_NONE_REQUIRED = "none-required";
 var AUDIO_PATH_UNAVAILABLE = "unavailable";
+var SUPPORT_CACHE_KEY_SEPARATOR = "|";
+var SUPPORT_CACHE_AUDIO_PREFIX = "audio";
+var SUPPORT_CACHE_WATERMARK_PREFIX = "watermark";
+var SUPPORT_CACHE_TRUE_VALUE = "1";
+var SUPPORT_CACHE_FALSE_VALUE = "0";
+var NODE_ENV_TEST = "test";
+var supportReportCache = new Map;
+var supportReportPromiseCache = new Map;
 function resolveBooleanOption(value, defaultValue) {
   if (typeof value === "boolean") {
     return value;
   }
   return defaultValue;
 }
+function resolveSupportCacheBooleanValue(value) {
+  if (value) {
+    return SUPPORT_CACHE_TRUE_VALUE;
+  }
+  return SUPPORT_CACHE_FALSE_VALUE;
+}
+function createSupportCacheKey(requiresAudio, requiresWatermark) {
+  const audioValue = resolveSupportCacheBooleanValue(requiresAudio);
+  const watermarkValue = resolveSupportCacheBooleanValue(requiresWatermark);
+  return [
+    SUPPORT_CACHE_AUDIO_PREFIX,
+    audioValue,
+    SUPPORT_CACHE_WATERMARK_PREFIX,
+    watermarkValue
+  ].join(SUPPORT_CACHE_KEY_SEPARATOR);
+}
+function shouldUseSupportCache() {
+  if (typeof process === "undefined") {
+    return true;
+  }
+  if (!process.env) {
+    return true;
+  }
+  if (NODE_ENV_TEST === "development") {
+    return false;
+  }
+  return true;
+}
 function resolveVideoPath(inputs) {
   if (inputs.probeResult.hasMediaStreamTrackProcessor) {
     return VIDEO_PATH_WORKER_TRACK;
@@ -1257,6 +1534,30 @@ function getIsProbeFeaturesComplete(probeResult, requiresWatermark) {
 async function checkRecorderSupport(options = {}) {
   const requiresAudio = resolveBooleanOption(options.requiresAudio, true);
   const requiresWatermark = resolveBooleanOption(options.requiresWatermark, false);
+  if (!shouldUseSupportCache()) {
+    return await buildSupportReport(requiresAudio, requiresWatermark);
+  }
+  const supportCacheKey = createSupportCacheKey(requiresAudio, requiresWatermark);
+  const cachedReport = supportReportCache.get(supportCacheKey);
+  if (cachedReport) {
+    return cachedReport;
+  }
+  const inflightReport = supportReportPromiseCache.get(supportCacheKey);
+  if (inflightReport) {
+    return await inflightReport;
+  }
+  const reportPromise = buildSupportReport(requiresAudio, requiresWatermark).then((report) => {
+    supportReportCache.set(supportCacheKey, report);
+    supportReportPromiseCache.delete(supportCacheKey);
+    return report;
+  }).catch((error) => {
+    supportReportPromiseCache.delete(supportCacheKey);
+    throw error;
+  });
+  supportReportPromiseCache.set(supportCacheKey, reportPromise);
+  return await reportPromise;
+}
+async function buildSupportReport(requiresAudio, requiresWatermark) {
   const hasWorker = typeof Worker !== "undefined";
   const audioContextClass = getAudioContextClass();
   const hasAudioContext = audioContextClass !== null;
@@ -2962,6 +3263,11 @@ function formatTime(totalSeconds) {
 }
 
 // src/core/utils/tab-visibility-tracker.ts
+var MILLISECONDS_PER_SECOND = 1000;
+var DEFAULT_TAB_VISIBILITY_TRACKER_DEPENDENCIES = {
+  getCurrentTimestamp: () => performance.now()
+};
+
 class TabVisibilityTracker {
   recordingStartTime = 0;
   totalPausedTime = 0;
@@ -2972,10 +3278,17 @@ class TabVisibilityTracker {
   visibilityChangeHandler;
   blurHandler;
   focusHandler;
-  constructor() {
+  getCurrentTimestamp;
+  constructor(dependencies) {
     this.visibilityChangeHandler = this.handleVisibilityChange.bind(this);
     this.blurHandler = this.handleBlur.bind(this);
     this.focusHandler = this.handleFocus.bind(this);
+    const getCurrentTimestampDependency = dependencies?.getCurrentTimestamp;
+    if (getCurrentTimestampDependency === undefined) {
+      this.getCurrentTimestamp = DEFAULT_TAB_VISIBILITY_TRACKER_DEPENDENCIES.getCurrentTimestamp;
+    } else {
+      this.getCurrentTimestamp = getCurrentTimestampDependency;
+    }
   }
   start(recordingStartTime) {
     if (this.isTracking) {
@@ -3000,14 +3313,14 @@ class TabVisibilityTracker {
     if (!this.isTracking || this.pauseStartTime !== null) {
       return;
     }
-    this.pauseStartTime = Date.now();
+    this.pauseStartTime = this.getCurrentTimestamp();
     this.endCurrentIntervalIfActive();
   }
   resume() {
     if (!this.isTracking || this.pauseStartTime === null) {
       return;
     }
-    const pausedDuration = Date.now() - this.pauseStartTime;
+    const pausedDuration = this.getCurrentTimestamp() - this.pauseStartTime;
     this.totalPausedTime += pausedDuration;
     this.pauseStartTime = null;
   }
@@ -3067,13 +3380,13 @@ class TabVisibilityTracker {
     if (this.pauseStartTime !== null) {
       return;
     }
-    this.currentIntervalStart = Date.now();
+    this.currentIntervalStart = this.getCurrentTimestamp();
   }
   endCurrentIntervalIfActive() {
     if (this.currentIntervalStart === null) {
       return;
     }
-    const endTime = Date.now();
+    const endTime = this.getCurrentTimestamp();
     const startTime = this.currentIntervalStart;
     if (endTime > startTime) {
       this.intervals.push({
@@ -3085,7 +3398,7 @@ class TabVisibilityTracker {
   }
   normalizeTimestamp(absoluteTime) {
     const elapsed = absoluteTime - this.recordingStartTime;
-    const normalized = (elapsed - this.totalPausedTime) / 1000;
+    const normalized = (elapsed - this.totalPausedTime) / MILLISECONDS_PER_SECOND;
     return Math.max(0, normalized);
   }
 }
@@ -3093,7 +3406,12 @@ class TabVisibilityTracker {
 // src/core/stream/stream-recording-state.ts
 var TIMER_INTERVAL = 1000;
 var SECONDS_PER_MINUTE2 = 60;
-var MILLISECONDS_PER_SECOND = 1000;
+var MILLISECONDS_PER_SECOND2 = 1000;
+var DEFAULT_TAB_VISIBILITY_OVERLAY_TEXT = "User in another tab";
+var DEFAULT_STREAM_RECORDING_STATE_DEPENDENCIES = {
+  checkRecorderSupport,
+  getCurrentTimestamp: () => performance.now()
+};
 
 class StreamRecordingState {
   recordingStartTime = 0;
@@ -3107,8 +3425,27 @@ class StreamRecordingState {
   blurHandler = null;
   focusHandler = null;
   streamManager;
-  constructor(streamManager) {
+  dependencies;
+  constructor(streamManager, dependencies) {
     this.streamManager = streamManager;
+    const checkRecorderSupportDependency = dependencies?.checkRecorderSupport;
+    let resolvedCheckRecorderSupportDependency;
+    if (checkRecorderSupportDependency === undefined) {
+      resolvedCheckRecorderSupportDependency = DEFAULT_STREAM_RECORDING_STATE_DEPENDENCIES.checkRecorderSupport;
+    } else {
+      resolvedCheckRecorderSupportDependency = checkRecorderSupportDependency;
+    }
+    const getCurrentTimestampDependency = dependencies?.getCurrentTimestamp;
+    let resolvedGetCurrentTimestampDependency;
+    if (getCurrentTimestampDependency === undefined) {
+      resolvedGetCurrentTimestampDependency = DEFAULT_STREAM_RECORDING_STATE_DEPENDENCIES.getCurrentTimestamp;
+    } else {
+      resolvedGetCurrentTimestampDependency = getCurrentTimestampDependency;
+    }
+    this.dependencies = {
+      checkRecorderSupport: resolvedCheckRecorderSupportDependency,
+      getCurrentTimestamp: resolvedGetCurrentTimestampDependency
+    };
   }
   isRecording() {
     return this.streamManager.getState() === "recording";
@@ -3127,11 +3464,15 @@ class StreamRecordingState {
   }
   async startRecording(processor, config, enableTabVisibilityOverlay, tabVisibilityOverlayText) {
     const mediaStream = this.streamManager.getStream();
+    let audioTrackCount = 0;
+    if (mediaStream !== null) {
+      audioTrackCount = mediaStream.getAudioTracks().length;
+    }
     logger.debug("[StreamRecordingState] startRecording called", {
       hasMediaStream: !!mediaStream,
       isRecording: this.isRecording(),
       hasProcessor: !!processor,
-      audioTracks: mediaStream?.getAudioTracks().length || 0
+      audioTracks: audioTrackCount
     });
     if (!mediaStream) {
       throw new Error("Stream must be started before recording");
@@ -3142,7 +3483,7 @@ class StreamRecordingState {
     }
     const hasAudioTracks = mediaStream.getAudioTracks().length > 0;
     const requiresWatermark = config.watermark !== undefined;
-    const supportReport = await checkRecorderSupport({
+    const supportReport = await this.dependencies.checkRecorderSupport({
       requiresAudio: hasAudioTracks,
       requiresWatermark
     });
@@ -3170,11 +3511,15 @@ class StreamRecordingState {
       this.streamManager.emit("recordingbufferupdate", { size, formatted });
     }, TIMER_INTERVAL);
     this.resetRecordingState();
-    const overlayConfig = enableTabVisibilityOverlay && tabVisibilityOverlayText ? {
-      enabled: true,
-      text: tabVisibilityOverlayText,
-      recordingStartTime: this.recordingStartTime
-    } : undefined;
+    let overlayConfig;
+    if (enableTabVisibilityOverlay === true) {
+      const resolvedOverlayText = this.resolveTabVisibilityOverlayText(tabVisibilityOverlayText);
+      overlayConfig = {
+        enabled: true,
+        text: resolvedOverlayText,
+        recordingStartTime: this.recordingStartTime
+      };
+    }
     logger.debug("[StreamRecordingState] Overlay config", {
       enableTabVisibilityOverlay,
       hasOverlayText: !!tabVisibilityOverlayText,
@@ -3197,7 +3542,7 @@ class StreamRecordingState {
     this.startRecordingTimer();
   }
   async stopRecording() {
-    const recordingElapsedSeconds = (performance.now() - this.recordingStartTime - this.totalPausedTime) / MILLISECONDS_PER_SECOND;
+    const recordingElapsedSeconds = (this.dependencies.getCurrentTimestamp() - this.recordingStartTime - this.totalPausedTime) / MILLISECONDS_PER_SECOND2;
     logger.debug("[StreamRecordingState] stopRecording called", {
       hasStreamProcessor: !!this.streamProcessor,
       isRecording: this.isRecording(),
@@ -3244,7 +3589,7 @@ class StreamRecordingState {
   pauseRecording() {
     this.clearRecordingTimer();
     if (this.pauseStartTime === null) {
-      this.pauseStartTime = Date.now();
+      this.pauseStartTime = this.dependencies.getCurrentTimestamp();
     }
     if (this.tabVisibilityTracker) {
       this.tabVisibilityTracker.pause();
@@ -3255,7 +3600,7 @@ class StreamRecordingState {
   }
   resumeRecording() {
     if (this.pauseStartTime !== null) {
-      const pausedDuration = Date.now() - this.pauseStartTime;
+      const pausedDuration = this.dependencies.getCurrentTimestamp() - this.pauseStartTime;
       this.totalPausedTime += pausedDuration;
       this.pauseStartTime = null;
     }
@@ -3326,7 +3671,7 @@ class StreamRecordingState {
   }
   startRecordingTimer() {
     this.recordingTimer = window.setInterval(() => {
-      const elapsed = (Date.now() - this.recordingStartTime - this.totalPausedTime) / MILLISECONDS_PER_SECOND;
+      const elapsed = (this.dependencies.getCurrentTimestamp() - this.recordingStartTime - this.totalPausedTime) / MILLISECONDS_PER_SECOND2;
       const formatted = this.formatTimeElapsed(elapsed);
       this.streamManager.emit("recordingtimeupdate", { elapsed, formatted });
     }, TIMER_INTERVAL);
@@ -3344,7 +3689,7 @@ class StreamRecordingState {
     }
   }
   resetRecordingState() {
-    this.recordingStartTime = performance.now();
+    this.recordingStartTime = this.dependencies.getCurrentTimestamp();
     this.totalPausedTime = 0;
     this.pauseStartTime = null;
   }
@@ -3352,6 +3697,16 @@ class StreamRecordingState {
     this.totalPausedTime = 0;
     this.pauseStartTime = null;
   }
+  resolveTabVisibilityOverlayText(tabVisibilityOverlayText) {
+    if (tabVisibilityOverlayText === undefined) {
+      return DEFAULT_TAB_VISIBILITY_OVERLAY_TEXT;
+    }
+    const trimmedText = tabVisibilityOverlayText.trim();
+    if (trimmedText.length === 0) {
+      return DEFAULT_TAB_VISIBILITY_OVERLAY_TEXT;
+    }
+    return tabVisibilityOverlayText;
+  }
   setupVisibilityUpdates(processor) {
     if (typeof document === "undefined" || typeof window === "undefined") {
       logger.warn("[StreamRecordingState] Cannot setup visibility updates - document/window not available");
@@ -3362,7 +3717,7 @@ class StreamRecordingState {
         return;
       }
       const isHidden = document.visibilityState === "hidden";
-      const timestamp = performance.now();
+      const timestamp = this.dependencies.getCurrentTimestamp();
       logger.debug("[StreamRecordingState] Visibility change", {
         isHidden,
         timestamp,
@@ -3371,12 +3726,12 @@ class StreamRecordingState {
       processor.updateTabVisibility(isHidden, timestamp);
     };
     this.blurHandler = () => {
-      const timestamp = performance.now();
+      const timestamp = this.dependencies.getCurrentTimestamp();
       logger.debug("[StreamRecordingState] Window blur", { timestamp });
       processor.updateTabVisibility(true, timestamp);
     };
     this.focusHandler = () => {
-      const timestamp = performance.now();
+      const timestamp = this.dependencies.getCurrentTimestamp();
       logger.debug("[StreamRecordingState] Window focus", { timestamp });
       processor.updateTabVisibility(false, timestamp);
     };
@@ -3385,7 +3740,7 @@ class StreamRecordingState {
     window.addEventListener("focus", this.focusHandler);
     const initialHidden = document.visibilityState === "hidden";
     if (initialHidden) {
-      const timestamp = performance.now();
+      const timestamp = this.dependencies.getCurrentTimestamp();
       logger.debug("[StreamRecordingState] Initial state is hidden", {
         timestamp
       });
@@ -3523,7 +3878,7 @@ class CameraStreamManager {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.2.1",
+  version: "1.3.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",
@@ -13844,6 +14199,8 @@ var WORKER_AUDIO_SAMPLE_FORMAT_F32_PLANAR = "f32-planar";
 var MILLISECONDS_PER_SECOND3 = 1000;
 var OVERLAY_LOG_FRAME_INTERVAL = 90;
 var RECORDER_WORKER_LOG_PREFIX3 = "[RecorderWorker]";
+var INITIAL_INTERVAL_INDEX = 0;
+var INITIAL_LAST_OVERLAY_TIMESTAMP = -1;
 
 class VisibilityTracker {
   hiddenIntervals = [];
@@ -13851,6 +14208,8 @@ class VisibilityTracker {
   pendingVisibilityUpdates = [];
   recordingStartTime = 0;
   isScreenCapture = false;
+  intervalCursor = INITIAL_INTERVAL_INDEX;
+  lastOverlayTimestamp = INITIAL_LAST_OVERLAY_TIMESTAMP;
   logger;
   constructor(dependencies) {
     this.logger = dependencies.logger;
@@ -13861,6 +14220,8 @@ class VisibilityTracker {
     this.pendingVisibilityUpdates = [];
     this.recordingStartTime = recordingStartTime;
     this.isScreenCapture = isScreenCapture;
+    this.intervalCursor = INITIAL_INTERVAL_INDEX;
+    this.lastOverlayTimestamp = INITIAL_LAST_OVERLAY_TIMESTAMP;
   }
   setRecordingStartTime(recordingStartTime) {
     this.recordingStartTime = recordingStartTime;
@@ -13871,32 +14232,52 @@ class VisibilityTracker {
   getPendingUpdatesCount() {
     return this.pendingVisibilityUpdates.length;
   }
-  shouldApplyOverlay(parameters) {
-    if (!parameters.overlayEnabled) {
-      return false;
-    }
+  shouldApplyOverlay(timestamp, frameCount) {
     if (this.isScreenCapture) {
       return false;
     }
-    const completedIntervalMatch = this.hiddenIntervals.some((interval) => parameters.timestamp >= interval.start && parameters.timestamp <= interval.end);
-    const currentIntervalMatch = this.currentHiddenIntervalStart !== null && parameters.timestamp >= this.currentHiddenIntervalStart;
+    const shouldApplyCurrentInterval = this.currentHiddenIntervalStart !== null && timestamp >= this.currentHiddenIntervalStart;
     let shouldApply = false;
-    if (completedIntervalMatch) {
+    if (shouldApplyCurrentInterval) {
       shouldApply = true;
     }
-    if (currentIntervalMatch) {
-      shouldApply = true;
+    if (!shouldApplyCurrentInterval) {
+      shouldApply = this.shouldApplyCompletedIntervalOverlay(timestamp);
     }
-    if (parameters.frameCount % OVERLAY_LOG_FRAME_INTERVAL === 0) {
+    if (frameCount % OVERLAY_LOG_FRAME_INTERVAL === 0) {
       this.logger.debug(\`\${RECORDER_WORKER_LOG_PREFIX3} Overlay check\`, {
-        timestamp: parameters.timestamp,
+        timestamp,
         shouldApply,
-        frameCount: parameters.frameCount,
-        intervalsCount: this.hiddenIntervals.length
+        frameCount,
+        intervalsCount: this.hiddenIntervals.length,
+        intervalCursor: this.intervalCursor
       });
     }
     return shouldApply;
   }
+  shouldApplyCompletedIntervalOverlay(timestamp) {
+    if (this.hiddenIntervals.length === 0) {
+      return false;
+    }
+    if (this.lastOverlayTimestamp !== INITIAL_LAST_OVERLAY_TIMESTAMP && timestamp < this.lastOverlayTimestamp) {
+      this.intervalCursor = INITIAL_INTERVAL_INDEX;
+    }
+    this.lastOverlayTimestamp = timestamp;
+    let activeCursor = this.intervalCursor;
+    while (activeCursor < this.hiddenIntervals.length) {
+      const interval = this.hiddenIntervals[activeCursor];
+      if (timestamp < interval.start) {
+        break;
+      }
+      if (timestamp <= interval.end) {
+        this.intervalCursor = activeCursor;
+        return true;
+      }
+      activeCursor += 1;
+    }
+    this.intervalCursor = activeCursor;
+    return false;
+  }
   handleUpdateVisibility(isHidden, timestamp, hasBaseVideoTimestamp, pausedDuration) {
     if (!hasBaseVideoTimestamp) {
       this.pendingVisibilityUpdates = [
@@ -13962,6 +14343,9 @@ var STEREO_CHANNEL_COUNT = 2;
 var AUDIO_SAMPLE_AVERAGE_SCALE = 0.5;
 var STOP_PENDING_WRITES_TIMEOUT_MILLISECONDS2 = 500;
 var MP4_FAST_START_DISABLED = false;
+var VIDEO_LATENCY_MODE_REALTIME = "realtime";
+var VIDEO_CONTENT_HINT_MOTION = "motion";
+var VIDEO_HARDWARE_ACCELERATION_PREFERENCE = "prefer-hardware";
 
 class RecorderWorker {
   output = null;
@@ -14230,9 +14614,9 @@ class RecorderWorker {
       sizeChangeBehavior: "contain",
       alpha: "discard",
       bitrateMode: "variable",
-      latencyMode: "quality",
-      contentHint: "detail",
-      hardwareAcceleration: "no-preference",
+      latencyMode: VIDEO_LATENCY_MODE_REALTIME,
+      contentHint: VIDEO_CONTENT_HINT_MOTION,
+      hardwareAcceleration: VIDEO_HARDWARE_ACCELERATION_PREFERENCE,
       keyFrameInterval: keyFrameIntervalSeconds,
       bitrate: this.deserializeBitrate(config.bitrate)
     };
@@ -14413,18 +14797,14 @@ class RecorderWorker {
       },
       isScreenCapture: this.isScreenCapture
     });
-    let overlayEnabled = false;
-    if (this.overlayConfig?.enabled) {
-      overlayEnabled = true;
-    }
-    const shouldApplyOverlay = this.visibilityTracker.shouldApplyOverlay({
-      timestamp: frameTimestamp,
-      overlayEnabled,
-      frameCount: this.timestampManager.getFrameCount()
-    });
+    const overlayConfig = this.overlayConfig;
+    let shouldApplyOverlay = false;
+    if (overlayConfig?.enabled && !this.isScreenCapture) {
+      shouldApplyOverlay = this.visibilityTracker.shouldApplyOverlay(frameTimestamp, this.timestampManager.getFrameCount());
+    }
     const compositionResult = this.frameCompositor.composeFrame({
       videoFrame,
-      overlayConfig: this.overlayConfig,
+      overlayConfig,
       shouldApplyOverlay,
       config
     });
@@ -15001,9 +15381,50 @@ var KEY_FRAME_INTERVAL_SECONDS = 5;
 var DEFAULT_SWITCH_SOURCE_FPS = 30;
 var WORKER_PROBE_TIMEOUT_MILLISECONDS = 2000;
 var FINALIZE_TIMEOUT_MILLISECONDS = 30000;
-var MILLISECONDS_PER_SECOND2 = 1000;
+var MILLISECONDS_PER_SECOND3 = 1000;
 var DEFAULT_RECORDING_FORMAT = "mp4";
-var OUTPUT_FORMAT_WEBM2 = "webm";
+var CODEC_CACHE_MAX_ENTRIES = 50;
+var CODEC_CACHE_KEY_SEPARATOR = "|";
+var CODEC_CACHE_ARRAY_SEPARATOR = ",";
+var CODEC_CACHE_UNDEFINED = "undefined";
+var CODEC_CACHE_FORMAT = "format";
+var CODEC_CACHE_AUDIO_OVERRIDE = "audioOverride";
+var CODEC_CACHE_VIDEO_OVERRIDE = "videoOverride";
+var CODEC_CACHE_AUDIO_BITRATE = "audioBitrate";
+var CODEC_CACHE_VIDEO_BITRATE = "videoBitrate";
+var CODEC_CACHE_WIDTH = "width";
+var CODEC_CACHE_HEIGHT = "height";
+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 resolvedAudioCodecCache = new Map;
+var resolvedVideoCodecCache = new Map;
+function formatCacheValue(value) {
+  if (value === undefined) {
+    return CODEC_CACHE_UNDEFINED;
+  }
+  return String(value);
+}
+function formatCacheArray(values) {
+  return values.join(CODEC_CACHE_ARRAY_SEPARATOR);
+}
+function buildCacheEntry(segment, value) {
+  return `${segment}=${value}`;
+}
+function setCodecCacheValue(cache, cacheKey, value) {
+  if (cache.has(cacheKey)) {
+    cache.delete(cacheKey);
+  }
+  cache.set(cacheKey, value);
+  if (cache.size <= CODEC_CACHE_MAX_ENTRIES) {
+    return;
+  }
+  const oldestEntry = cache.keys().next();
+  if (!oldestEntry.done) {
+    cache.delete(oldestEntry.value);
+  }
+}
 
 class WorkerProcessor {
   worker = null;
@@ -15024,6 +15445,7 @@ class WorkerProcessor {
   workerProbeManager;
   canUseMainThreadVideoProcessorFn;
   createVideoStreamFromTrackFn;
+  isLinuxPlatformFn;
   constructor(dependencies = {}) {
     let createWorkerFn = (workerUrl) => new Worker(workerUrl, { type: "classic" });
     if (dependencies.createWorker) {
@@ -15043,8 +15465,13 @@ class WorkerProcessor {
     if (dependencies.createVideoStreamFromTrack) {
       createVideoStreamFromTrackFn = dependencies.createVideoStreamFromTrack;
     }
+    let isLinuxPlatformFn = () => isLinuxPlatform();
+    if (dependencies.isLinuxPlatform) {
+      isLinuxPlatformFn = dependencies.isLinuxPlatform;
+    }
     this.canUseMainThreadVideoProcessorFn = canUseMainThreadVideoProcessorFn;
     this.createVideoStreamFromTrackFn = createVideoStreamFromTrackFn;
+    this.isLinuxPlatformFn = isLinuxPlatformFn;
     const hasWorkerFactory = !!dependencies.createWorker;
     this.workerProbeManager = new WorkerProbeManager({
       setTimeout: window.setTimeout.bind(window),
@@ -15171,8 +15598,12 @@ class WorkerProcessor {
     this.resetProcessingState(overlayConfig);
     this.stopAudioWorklet();
     const format = this.resolveRecordingFormat(config);
-    const audioCodec = await this.resolveAudioCodec(config);
-    const codec = await this.resolveVideoCodec(config, format);
+    const policy = getFormatCompatibilityPolicy(format, {
+      isLinuxPlatform: this.isLinuxPlatformFn()
+    });
+    const audioBitrate = this.resolveAudioBitrate(config, format);
+    const audioCodec = await this.resolveAudioCodecWithCache(config, format, policy, audioBitrate);
+    const codec = await this.resolveVideoCodecWithCache(config, format, policy);
     const isScreenCapture = isScreenCaptureStream(stream);
     logger.debug("[WorkerProcessor] Starting processing", {
       isScreenCapture,
@@ -15180,7 +15611,7 @@ class WorkerProcessor {
       codec,
       bitrate: config.bitrate
     });
-    const workerConfig = this.buildWorkerTranscodeConfig(config, audioCodec, codec, format);
+    const workerConfig = this.buildWorkerTranscodeConfig(config, audioCodec, audioBitrate, codec, format);
     const videoTracks = stream.getVideoTracks();
     const audioTracks = stream.getAudioTracks();
     logger.debug("[WorkerProcessor] Preparing to start processing", {
@@ -15256,27 +15687,88 @@ class WorkerProcessor {
     }
     return format;
   }
-  async resolveAudioCodec(config) {
-    let audioCodec = config.audioCodec;
-    if (!audioCodec) {
-      audioCodec = await detectBestAudioCodec(config.audioBitrate);
+  resolveAudioBitrate(config, format) {
+    if (config.audioBitrate !== undefined) {
+      return config.audioBitrate;
     }
-    return audioCodec;
+    return getPresetAudioBitrateForFormat(format);
   }
-  async resolveVideoCodec(config, format) {
-    if (format === OUTPUT_FORMAT_WEBM2) {
-      return await detectBestWebmCodec(config.width, config.height, config.bitrate);
-    }
-    return await detectBestCodec(config.width, config.height, config.bitrate);
+  async resolveAudioCodec(config, format, policy, audioBitrate) {
+    return await resolveAudioCodecFromPolicy({
+      format,
+      overrideCodec: config.audioCodec,
+      policy,
+      bitrate: audioBitrate
+    });
   }
-  buildWorkerTranscodeConfig(config, audioCodec, codec, format) {
+  async resolveVideoCodec(config, format, policy) {
+    return await resolveVideoCodecFromPolicy({
+      format,
+      overrideCodec: config.codec,
+      policy,
+      width: config.width,
+      height: config.height,
+      bitrate: config.bitrate
+    });
+  }
+  async resolveAudioCodecWithCache(config, format, policy, audioBitrate) {
+    const audioCodecCacheKey = this.buildAudioCodecCacheKey(config, format, policy, audioBitrate);
+    const cachedAudioCodec = resolvedAudioCodecCache.get(audioCodecCacheKey);
+    if (cachedAudioCodec) {
+      return cachedAudioCodec;
+    }
+    const resolvedAudioCodec = await this.resolveAudioCodec(config, format, policy, audioBitrate);
+    setCodecCacheValue(resolvedAudioCodecCache, audioCodecCacheKey, resolvedAudioCodec);
+    return resolvedAudioCodec;
+  }
+  async resolveVideoCodecWithCache(config, format, policy) {
+    const videoCodecCacheKey = this.buildVideoCodecCacheKey(config, format, policy);
+    const cachedVideoCodec = resolvedVideoCodecCache.get(videoCodecCacheKey);
+    if (cachedVideoCodec) {
+      return cachedVideoCodec;
+    }
+    const resolvedVideoCodec = await this.resolveVideoCodec(config, format, policy);
+    setCodecCacheValue(resolvedVideoCodecCache, videoCodecCacheKey, resolvedVideoCodec);
+    return resolvedVideoCodec;
+  }
+  buildAudioCodecCacheKey(config, format, policy, audioBitrate) {
+    const audioOverride = formatCacheValue(config.audioCodec);
+    const preferredAudioCodec = formatCacheValue(policy.preferredAudioCodec);
+    const audioFallbackOrder = formatCacheArray(policy.audioCodecFallbackOrder);
+    const audioBitrateValue = formatCacheValue(audioBitrate);
+    return [
+      buildCacheEntry(CODEC_CACHE_FORMAT, formatCacheValue(format)),
+      buildCacheEntry(CODEC_CACHE_AUDIO_OVERRIDE, audioOverride),
+      buildCacheEntry(CODEC_CACHE_AUDIO_BITRATE, audioBitrateValue),
+      buildCacheEntry(CODEC_CACHE_POLICY_PREFERRED_AUDIO, preferredAudioCodec),
+      buildCacheEntry(CODEC_CACHE_POLICY_AUDIO_FALLBACK, audioFallbackOrder)
+    ].join(CODEC_CACHE_KEY_SEPARATOR);
+  }
+  buildVideoCodecCacheKey(config, format, policy) {
+    const videoOverride = formatCacheValue(config.codec);
+    const widthValue = formatCacheValue(config.width);
+    const heightValue = formatCacheValue(config.height);
+    const bitrateValue = formatCacheValue(config.bitrate);
+    const preferredVideoCodec = formatCacheValue(policy.preferredVideoCodec);
+    const videoFallbackOrder = formatCacheArray(policy.videoCodecFallbackOrder);
+    return [
+      buildCacheEntry(CODEC_CACHE_FORMAT, formatCacheValue(format)),
+      buildCacheEntry(CODEC_CACHE_VIDEO_OVERRIDE, videoOverride),
+      buildCacheEntry(CODEC_CACHE_WIDTH, widthValue),
+      buildCacheEntry(CODEC_CACHE_HEIGHT, heightValue),
+      buildCacheEntry(CODEC_CACHE_VIDEO_BITRATE, bitrateValue),
+      buildCacheEntry(CODEC_CACHE_POLICY_PREFERRED_VIDEO, preferredVideoCodec),
+      buildCacheEntry(CODEC_CACHE_POLICY_VIDEO_FALLBACK, videoFallbackOrder)
+    ].join(CODEC_CACHE_KEY_SEPARATOR);
+  }
+  buildWorkerTranscodeConfig(config, audioCodec, audioBitrate, codec, format) {
     return {
       width: config.width,
       height: config.height,
       fps: config.fps,
       bitrate: serializeBitrate(config.bitrate),
       audioCodec,
-      audioBitrate: config.audioBitrate,
+      audioBitrate,
       codec,
       keyFrameInterval: KEY_FRAME_INTERVAL_SECONDS,
       format,
@@ -15505,7 +15997,7 @@ class WorkerProcessor {
         }
         this.resetFinalizeRuntimeState();
         logger.error("[WorkerProcessor] Finalize failed", {
-          elapsedSeconds: (performance.now() - finalizeStartedAtMilliseconds) / MILLISECONDS_PER_SECOND2,
+          elapsedSeconds: (performance.now() - finalizeStartedAtMilliseconds) / MILLISECONDS_PER_SECOND3,
           error: response.error
         });
         reject(new Error(response.error));
@@ -15516,7 +16008,7 @@ class WorkerProcessor {
           return;
         }
         logger.error("[WorkerProcessor] Finalize timeout reached", {
-          elapsedSeconds: (performance.now() - finalizeStartedAtMilliseconds) / MILLISECONDS_PER_SECOND2
+          elapsedSeconds: (performance.now() - finalizeStartedAtMilliseconds) / MILLISECONDS_PER_SECOND3
         });
         this.resetFinalizeRuntimeState();
         reject(new Error("Finalize timeout"));
@@ -15546,7 +16038,7 @@ class WorkerProcessor {
   }
   rejectFinalizeBlobCreationError(reject, error, finalizeStartedAtMilliseconds) {
     logger.error("[WorkerProcessor] Finalize failed while creating blob", {
-      elapsedSeconds: (performance.now() - finalizeStartedAtMilliseconds) / MILLISECONDS_PER_SECOND2,
+      elapsedSeconds: (performance.now() - finalizeStartedAtMilliseconds) / MILLISECONDS_PER_SECOND3,
       error: extractErrorMessage(error)
     });
     if (error instanceof Error) {
@@ -15584,7 +16076,7 @@ class WorkerProcessor {
     logger.debug("[WorkerProcessor] Sending visibility update to worker", {
       isHidden,
       timestamp,
-      timestampSeconds: timestamp / MILLISECONDS_PER_SECOND2
+      timestampSeconds: timestamp / MILLISECONDS_PER_SECOND3
     });
     const message = {
       type: "updateVisibility",
@@ -15888,7 +16380,7 @@ class StreamProcessor {
 
 // src/core/recording/recording-manager.ts
 var DEFAULT_COUNTDOWN_DURATION = 5000;
-var MILLISECONDS_PER_SECOND3 = 1000;
+var MILLISECONDS_PER_SECOND4 = 1000;
 var COUNTDOWN_UPDATE_INTERVAL = 100;
 var RECORDING_TIMER_INTERVAL = 1000;
 var RECORDING_STATE_RECORDING = "recording";
@@ -15955,6 +16447,9 @@ class RecordingManager {
   getOriginalCameraStream() {
     return this.originalCameraStream;
   }
+  prewarmStreamProcessor() {
+    this.getOrCreateStreamProcessor();
+  }
   async startRecording() {
     try {
       this.callbacks.onClearUploadStatus();
@@ -15971,7 +16466,7 @@ class RecordingManager {
   }
   startCountdown() {
     this.recordingState = RECORDING_STATE_COUNTDOWN;
-    this.countdownRemaining = Math.ceil(this.countdownDuration / MILLISECONDS_PER_SECOND3);
+    this.countdownRemaining = Math.ceil(this.countdownDuration / MILLISECONDS_PER_SECOND4);
     this.countdownStartTime = Date.now();
     this.callbacks.onCountdownUpdate(this.recordingState, this.countdownRemaining);
     this.countdownIntervalId = window.setInterval(() => {
@@ -15979,7 +16474,7 @@ class RecordingManager {
         return;
       }
       const elapsed = Date.now() - this.countdownStartTime;
-      const remaining = Math.max(0, Math.ceil((this.countdownDuration - elapsed) / MILLISECONDS_PER_SECOND3));
+      const remaining = Math.max(0, Math.ceil((this.countdownDuration - elapsed) / MILLISECONDS_PER_SECOND4));
       this.countdownRemaining = remaining;
       this.callbacks.onCountdownUpdate(this.recordingState, this.countdownRemaining);
     }, COUNTDOWN_UPDATE_INTERVAL);
@@ -15990,8 +16485,6 @@ class RecordingManager {
   async doStartRecording() {
     logger.debug("[RecordingManager] doStartRecording called");
     this.cancelCountdown();
-    this.recordingState = RECORDING_STATE_RECORDING;
-    this.callbacks.onStateChange(this.recordingState);
     this.resetRecordingState();
     const currentStream = this.streamManager.getStream();
     logger.debug("[RecordingManager] Current stream:", {
@@ -16007,24 +16500,30 @@ class RecordingManager {
       return;
     }
     this.originalCameraStream = currentStream;
-    logger.debug("[RecordingManager] Creating stream processor");
-    this.streamProcessor = new StreamProcessor;
-    logger.debug("[RecordingManager] StreamProcessor created:", !!this.streamProcessor);
-    const configResult = await this.callbacks.onGetConfig().then((config) => ({ config, error: null })).catch((error) => ({ config: null, error }));
-    if (configResult.error) {
-      this.handleError(configResult.error);
+    logger.debug("[RecordingManager] Ensuring stream processor");
+    const streamProcessor = this.getOrCreateStreamProcessor();
+    logger.debug("[RecordingManager] StreamProcessor ready:", !!streamProcessor);
+    let recordingConfig = null;
+    const configError = await this.callbacks.onGetConfig().then((resolvedConfig) => {
+      recordingConfig = resolvedConfig;
+      return null;
+    }).catch((error) => {
+      return error;
+    });
+    if (configError) {
+      this.handleError(configError);
       this.recordingState = RECORDING_STATE_IDLE;
       this.callbacks.onStateChange(this.recordingState);
       return;
     }
-    if (!configResult.config) {
+    if (!recordingConfig) {
       this.handleError(new Error("Failed to get recording config"));
       this.recordingState = RECORDING_STATE_IDLE;
       this.callbacks.onStateChange(this.recordingState);
       return;
     }
     logger.debug("[RecordingManager] Starting recording with stream manager");
-    const recordingError = await this.streamManager.startRecording(this.streamProcessor, configResult.config, this.enableTabVisibilityOverlay, this.tabVisibilityOverlayText).then(() => {
+    const recordingError = await this.streamManager.startRecording(streamProcessor, recordingConfig, this.enableTabVisibilityOverlay, this.tabVisibilityOverlayText).then(() => {
       logger.info("[RecordingManager] Recording started successfully");
       return null;
     }).catch((error) => {
@@ -16037,6 +16536,8 @@ class RecordingManager {
       this.callbacks.onStateChange(this.recordingState);
       return;
     }
+    this.recordingState = RECORDING_STATE_RECORDING;
+    this.callbacks.onStateChange(this.recordingState);
     this.startRecordingTimer();
     this.recordingStartTime = Date.now();
     if (this.maxRecordingTime && this.maxRecordingTime > 0) {
@@ -16115,6 +16616,12 @@ class RecordingManager {
     this.recordingIntervalId = null;
     this.clearTimer(this.maxTimeTimer, clearTimeout);
     this.maxTimeTimer = null;
+    if (this.streamProcessor) {
+      this.streamProcessor.cancel().catch(() => {
+        return;
+      });
+      this.streamProcessor = null;
+    }
   }
   resetRecordingState() {
     this.isPaused = false;
@@ -16129,6 +16636,14 @@ class RecordingManager {
     this.pauseStartTime = null;
     this.totalPausedTime = 0;
   }
+  getOrCreateStreamProcessor() {
+    if (this.streamProcessor) {
+      return this.streamProcessor;
+    }
+    const streamProcessor = new StreamProcessor;
+    this.streamProcessor = streamProcessor;
+    return streamProcessor;
+  }
   updatePausedDuration() {
     if (this.pauseStartTime === null) {
       throw new Error("Pause start time not set");
@@ -16259,6 +16774,7 @@ class UploadMetadataManager {
 
 // src/core/recording/recorder-controller.ts
 var LOGGER_PREFIX = "[RecorderController]";
+var RECORDING_WARMUP_DELAY_MILLISECONDS = 0;
 
 class RecorderController {
   streamManager;
@@ -16276,8 +16792,10 @@ class RecorderController {
   uploadQueueManager = null;
   isInitialized = false;
   isDemo = false;
+  isDestroyed = false;
   enableTabVisibilityOverlay = false;
   tabVisibilityOverlayText;
+  recordingWarmupTimeoutId = null;
   constructor(callbacks = {}) {
     this.callbacks = callbacks;
     this.streamManager = new CameraStreamManager;
@@ -16293,7 +16811,7 @@ class RecorderController {
     this.uploadMetadataManager = new UploadMetadataManager;
     const recordingCallbacks = createRecordingCallbacks(callbacks, {
       stopAudioTracking: () => this.audioLevelAnalyzer.stopTracking(),
-      getConfig: () => this.configManager.getConfig()
+      getConfig: () => Promise.resolve(this.configManager.getConfigForRecording())
     });
     this.recordingManager = new RecordingManager(this.streamManager, recordingCallbacks);
     const sourceSwitchCallbacks = createSourceSwitchCallbacks(callbacks, {
@@ -16358,6 +16876,7 @@ class RecorderController {
         this.applyRecordingConfig(config);
         await this.initializeStorage();
         this.isInitialized = true;
+        this.scheduleRecordingWarmup();
       }
     });
   }
@@ -16369,6 +16888,8 @@ class RecorderController {
       action: async () => {
         logger.debug(`${LOGGER_PREFIX} startStream called`);
         await this.streamManager.startStream();
+        this.ignorePromiseRejection(this.ensureConfigReady());
+        this.recordingManager.prewarmStreamProcessor();
         logger.debug(`${LOGGER_PREFIX} startStream completed`);
       },
       properties: {
@@ -16386,13 +16907,13 @@ class RecorderController {
     return this.streamManager.switchAudioDevice(deviceId);
   }
   async startRecording() {
-    await this.ensureConfigReady();
     const sourceType = this.getCurrentSourceType();
     await this.telemetryManager.executeAction({
       requestedEvent: "recording.start.requested",
       succeededEvent: "recording.start.succeeded",
       failedEvent: "recording.start.failed",
       action: async () => {
+        await this.ensureConfigReady();
         await this.recordingManager.startRecording();
       },
       properties: {
@@ -16516,13 +17037,25 @@ class RecorderController {
   isConfigReady() {
     return this.configManager.isConfigReady();
   }
-  async ensureConfigReady() {
+  ensureConfigReady() {
     if (this.isDemo) {
-      return;
+      return Promise.resolve();
     }
-    await this.configManager.fetchConfig();
+    if (this.configManager.isConfigReady()) {
+      return Promise.resolve();
+    }
+    return this.configManager.fetchConfig().then(() => {
+      return;
+    }).catch(() => {
+      return;
+    });
   }
   cleanup() {
+    this.isDestroyed = true;
+    if (this.recordingWarmupTimeoutId !== null) {
+      clearTimeout(this.recordingWarmupTimeoutId);
+      this.recordingWarmupTimeoutId = null;
+    }
     this.storageManager.destroy();
     this.recordingManager.cleanup();
     this.audioLevelAnalyzer.stopTracking();
@@ -16642,6 +17175,30 @@ class RecorderController {
     });
     throw error;
   }
+  scheduleRecordingWarmup() {
+    if (this.recordingWarmupTimeoutId !== null) {
+      clearTimeout(this.recordingWarmupTimeoutId);
+      this.recordingWarmupTimeoutId = null;
+    }
+    if (this.isDestroyed) {
+      return;
+    }
+    this.recordingWarmupTimeoutId = setTimeout(() => {
+      this.recordingWarmupTimeoutId = null;
+      if (this.isDestroyed) {
+        return;
+      }
+      this.ignorePromiseRejection(this.ensureConfigReady());
+      this.ignorePromiseRejection(Promise.resolve().then(() => {
+        this.recordingManager.prewarmStreamProcessor();
+      }));
+    }, RECORDING_WARMUP_DELAY_MILLISECONDS);
+  }
+  ignorePromiseRejection(promise) {
+    promise.catch(() => {
+      return;
+    });
+  }
 }
 // src/core/storage/quota-manager.ts
 var PERCENTAGE_MULTIPLIER = 100;
@@ -17067,6 +17624,10 @@ export {
   mapPresetToConfig,
   logger,
   isMobileDevice2 as isMobileDevice,
+  getPresetVideoBitrateForFormat,
+  getPresetTotalBitrate,
+  getPresetAudioBitrateForFormat,
+  getFormatCompatibilityPolicy,
   getDefaultConfigForFormat,
   getDefaultAudioCodecForFormat,
   getBrowserName,
@@ -17079,6 +17640,8 @@ export {
   extractLastFrame,
   extractErrorMessage,
   checkRecorderSupport,
+  calculateVideoBitrate,
+  calculateTotalBitrateFromMbPerMinute,
   calculateBarColor,
   VidtreoRecorder,
   VideoUploadService,
@@ -17089,8 +17652,10 @@ export {
   RecordingManager,
   RecorderController,
   QuotaManager,
+  PRESET_SIZE_LIMIT_MB_PER_MINUTE,
   NativeCameraHandler,
   FORMAT_DEFAULT_CODECS,
+  FORMAT_COMPATIBILITY_POLICY,
   DeviceManager,
   DEFAULT_TRANSCODE_CONFIG,
   DEFAULT_STREAM_CONFIG,