@vidtreo/recorder 1.2.0 → 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]
+  }
 };
-function calculateTotalBitrate(sizeMbPerMinute) {
+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 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,141 +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_HEVC = "hevc";
-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 };
+  return value.toLowerCase();
 }
-function createVideoCodecSupportError(error) {
-  return { kind: "error", 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;
+function isNonBrowserRuntime(userAgent) {
+  if (userAgent.includes(RUNTIME_MARKER_BUN)) {
+    return true;
   }
-  const { canEncodeVideo } = mediabunnyModuleResult.module;
-  if (typeof canEncodeVideo !== "function") {
-    return VIDEO_CODEC_AVC;
+  if (userAgent.includes(RUNTIME_MARKER_HAPPY_DOM)) {
+    return true;
+  }
+  if (userAgent.includes(RUNTIME_MARKER_NODE)) {
+    return true;
   }
-  const checkOptions = buildVideoCodecCheckOptions(width, height, bitrate);
-  const videoCodecSupportResult = await canEncodeVideo(VIDEO_CODEC_HEVC, checkOptions).then((supported) => createVideoCodecSupportResult(supported)).catch((error) => createVideoCodecSupportError(error));
-  if (videoCodecSupportResult.kind === "error") {
-    return VIDEO_CODEC_AVC;
+  return false;
+}
+function resolveNavigatorProvider(navigatorProvider) {
+  if (navigatorProvider) {
+    return navigatorProvider;
   }
-  if (videoCodecSupportResult.supported) {
-    return VIDEO_CODEC_HEVC;
+  if (typeof navigator === "undefined") {
+    return null;
   }
-  return VIDEO_CODEC_AVC;
+  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 = {
@@ -436,7 +498,7 @@ async function mapPresetToConfig(options) {
       position: watermark.position
     };
   }
-  return config;
+  return Promise.resolve(config);
 }
 
 // src/core/config/config-service.ts
@@ -559,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) {
@@ -582,6 +637,12 @@ class ConfigManager {
     }
     return this.currentConfig;
   }
+  getConfigForRecording() {
+    if (this.configService && !this.configFetched) {
+      this.fetchConfigInBackground();
+    }
+    return this.currentConfig;
+  }
   isConfigReady() {
     return this.configReady;
   }
@@ -591,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 {
@@ -734,6 +801,159 @@ 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;
 function createSource(input) {
   if (typeof input === "string") {
@@ -773,7 +993,6 @@ function getMimeTypeForFormat(format) {
   }
 }
 function createConversionOptions(config, optimizeForSpeed = false) {
-  const audioCodec = getAudioCodecForFormat(config.format, config.audioCodec);
   const video = {
     fit: "contain",
     forceTranscode: true,
@@ -801,7 +1020,7 @@ function createConversionOptions(config, optimizeForSpeed = false) {
     video.keyFrameInterval = 2;
   }
   const audio = {
-    codec: audioCodec,
+    codec: config.audioCodec,
     forceTranscode: true,
     ...optimizeForSpeed && { bitrateMode: "variable" }
   };
@@ -814,14 +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);
-  }
+  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,
@@ -853,14 +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);
-  }
+  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,
@@ -1028,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";
@@ -1080,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;
@@ -1218,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;
@@ -1341,7 +1681,7 @@ function getEmptyProbeResult() {
 }
 // src/core/storage/video-storage.ts
 var DB_NAME = "vidtreo-recorder";
-var DB_VERSION = 1;
+var DB_VERSION = 2;
 var STORE_NAME = "pending-uploads";
 var STATUS_INDEX = "status";
 var CREATED_AT_INDEX = "createdAt";
@@ -1350,28 +1690,55 @@ var MAX_RETRIES = 10;
 var MILLISECONDS_PER_HOUR = 60 * 60 * 1000;
 var ID_PREFIX = "upload-";
 var ID_RANDOM_LENGTH = 9;
+var VERSION_ERROR_NAME = "VersionError";
+var ERROR_SCHEMA_MISSING_STORE = "Database schema is missing required object store: pending-uploads";
+var ERROR_SCHEMA_MISSING_STATUS_INDEX = "Database schema is missing required index: status";
+var ERROR_SCHEMA_MISSING_CREATED_AT_INDEX = "Database schema is missing required index: createdAt";
 
 class VideoStorageService {
   db = null;
+  databaseFactory;
+  constructor(databaseFactory) {
+    if (databaseFactory) {
+      this.databaseFactory = databaseFactory;
+      return;
+    }
+    this.databaseFactory = indexedDB;
+  }
   init() {
     if (this.db) {
       return Promise.resolve();
     }
+    return this.openDatabase(DB_VERSION, true);
+  }
+  openDatabase(databaseVersion, canRetryWithoutVersion) {
     return new Promise((resolve, reject) => {
-      const request = indexedDB.open(DB_NAME, DB_VERSION);
+      const request = this.createOpenRequest(databaseVersion);
       request.onerror = () => {
-        if (request.error) {
-          reject(request.error);
-        } else {
-          reject(new Error("Failed to open database"));
+        const requestError = request.error;
+        if (canRetryWithoutVersion && requestError && requestError.name === VERSION_ERROR_NAME) {
+          this.openDatabase(undefined, false).then(resolve).catch(reject);
+          return;
+        }
+        if (requestError) {
+          reject(requestError);
+          return;
         }
+        reject(new Error("Failed to open database"));
       };
       request.onsuccess = () => {
         if (!request.result) {
           reject(new Error("Database result is null"));
           return;
         }
-        this.db = request.result;
+        const database = request.result;
+        const schemaValidationError = this.validateRequiredSchema(database);
+        if (schemaValidationError) {
+          database.close();
+          reject(schemaValidationError);
+          return;
+        }
+        this.db = database;
         resolve();
       };
       request.onupgradeneeded = (event) => {
@@ -1380,16 +1747,42 @@ class VideoStorageService {
           reject(new Error("Database upgrade result is null"));
           return;
         }
-        if (!db.objectStoreNames.contains(STORE_NAME)) {
-          const store = db.createObjectStore(STORE_NAME, { keyPath: "id" });
-          store.createIndex(STATUS_INDEX, STATUS_INDEX, { unique: false });
-          store.createIndex(CREATED_AT_INDEX, CREATED_AT_INDEX, {
-            unique: false
-          });
-        }
+        this.initializeStoreSchema(db);
       };
     });
   }
+  createOpenRequest(databaseVersion) {
+    if (databaseVersion === undefined) {
+      return this.databaseFactory.open(DB_NAME);
+    }
+    return this.databaseFactory.open(DB_NAME, databaseVersion);
+  }
+  initializeStoreSchema(database) {
+    if (database.objectStoreNames.contains(STORE_NAME)) {
+      return;
+    }
+    const objectStore = database.createObjectStore(STORE_NAME, {
+      keyPath: "id"
+    });
+    objectStore.createIndex(STATUS_INDEX, STATUS_INDEX, { unique: false });
+    objectStore.createIndex(CREATED_AT_INDEX, CREATED_AT_INDEX, {
+      unique: false
+    });
+  }
+  validateRequiredSchema(database) {
+    if (!database.objectStoreNames.contains(STORE_NAME)) {
+      return new Error(ERROR_SCHEMA_MISSING_STORE);
+    }
+    const transaction = database.transaction([STORE_NAME], "readonly");
+    const store = transaction.objectStore(STORE_NAME);
+    if (!store.indexNames.contains(STATUS_INDEX)) {
+      return new Error(ERROR_SCHEMA_MISSING_STATUS_INDEX);
+    }
+    if (!store.indexNames.contains(CREATED_AT_INDEX)) {
+      return new Error(ERROR_SCHEMA_MISSING_CREATED_AT_INDEX);
+    }
+    return null;
+  }
   isInitialized() {
     return this.db !== null;
   }
@@ -2870,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;
@@ -2880,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) {
@@ -2908,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;
   }
@@ -2975,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({
@@ -2993,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);
   }
 }
@@ -3001,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;
@@ -3015,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";
@@ -3035,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");
@@ -3050,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
     });
@@ -3078,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,
@@ -3105,9 +3542,11 @@ class StreamRecordingState {
     this.startRecordingTimer();
   }
   async stopRecording() {
+    const recordingElapsedSeconds = (this.dependencies.getCurrentTimestamp() - this.recordingStartTime - this.totalPausedTime) / MILLISECONDS_PER_SECOND2;
     logger.debug("[StreamRecordingState] stopRecording called", {
       hasStreamProcessor: !!this.streamProcessor,
-      isRecording: this.isRecording()
+      isRecording: this.isRecording(),
+      recordingElapsedSeconds
     });
     if (!(this.streamProcessor && this.isRecording())) {
       throw new Error("Not currently recording");
@@ -3150,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();
@@ -3161,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;
     }
@@ -3232,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);
@@ -3250,7 +3689,7 @@ class StreamRecordingState {
     }
   }
   resetRecordingState() {
-    this.recordingStartTime = performance.now();
+    this.recordingStartTime = this.dependencies.getCurrentTimestamp();
     this.totalPausedTime = 0;
     this.pauseStartTime = null;
   }
@@ -3258,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");
@@ -3268,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,
@@ -3277,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);
     };
@@ -3291,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
       });
@@ -3429,7 +3878,7 @@ class CameraStreamManager {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.2.0",
+  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",
@@ -4348,6 +4797,118 @@ function serializeBitrate(bitrate) {
   return "high";
 }
 
+// src/core/processor/mp4-container-guard.ts
+var MP4_BOX_HEADER_BYTES = 8;
+var MP4_BOX_TYPE_OFFSET_BYTES = 4;
+var MP4_EXTENDED_SIZE_MARKER = 1;
+var MP4_ZERO_SIZE_MARKER = 0;
+var MP4_EXTENDED_SIZE_BYTES = 8;
+var MP4_EXTENDED_BOX_HEADER_BYTES = MP4_BOX_HEADER_BYTES + MP4_EXTENDED_SIZE_BYTES;
+var TWO_POWER_32 = 4294967296;
+var MP4_FRAGMENT_BOX_TYPE_MOOF = "moof";
+var MP4_FRAGMENT_BOX_TYPE_MFRA = "mfra";
+var ERROR_RECORDING_INVALID_CONTAINER_LAYOUT = "recording.invalid-container-layout";
+function createInvalidMp4ContainerLayoutError(detectedBoxTypes) {
+  const error = new Error(ERROR_RECORDING_INVALID_CONTAINER_LAYOUT);
+  error.code = ERROR_RECORDING_INVALID_CONTAINER_LAYOUT;
+  error.detectedBoxTypes = detectedBoxTypes;
+  return error;
+}
+function toUint8Array(input) {
+  if (input instanceof Uint8Array) {
+    return input;
+  }
+  return new Uint8Array(input);
+}
+function readBoxType(view, offset) {
+  const firstCharCode = view.getUint8(offset);
+  const secondCharCode = view.getUint8(offset + 1);
+  const thirdCharCode = view.getUint8(offset + 2);
+  const fourthCharCode = view.getUint8(offset + 3);
+  return String.fromCharCode(firstCharCode, secondCharCode, thirdCharCode, fourthCharCode);
+}
+function readLargeSize(view, offset) {
+  const highBits = view.getUint32(offset, false);
+  const lowBits = view.getUint32(offset + MP4_BOX_TYPE_OFFSET_BYTES, false);
+  return highBits * TWO_POWER_32 + lowBits;
+}
+function getUniqueValues(values) {
+  const uniqueValues = new Set;
+  for (const value of values) {
+    uniqueValues.add(value);
+  }
+  return [...uniqueValues];
+}
+function parseMp4TopLevelBoxes(input) {
+  const bytes = toUint8Array(input);
+  const totalBytes = bytes.byteLength;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const boxes = [];
+  let currentOffset = 0;
+  while (currentOffset < totalBytes) {
+    const hasMinimumHeader = currentOffset + MP4_BOX_HEADER_BYTES <= totalBytes;
+    if (!hasMinimumHeader) {
+      const detectedBoxTypes = boxes.map((box) => box.type);
+      throw createInvalidMp4ContainerLayoutError(detectedBoxTypes);
+    }
+    const declaredSize = view.getUint32(currentOffset, false);
+    const typeOffset = currentOffset + MP4_BOX_TYPE_OFFSET_BYTES;
+    const boxType = readBoxType(view, typeOffset);
+    let boxSize = declaredSize;
+    let headerSize = MP4_BOX_HEADER_BYTES;
+    if (declaredSize === MP4_EXTENDED_SIZE_MARKER) {
+      const largeSizeOffset = currentOffset + MP4_BOX_HEADER_BYTES;
+      const hasExtendedHeader = largeSizeOffset + MP4_EXTENDED_SIZE_BYTES <= totalBytes;
+      if (!hasExtendedHeader) {
+        const detectedBoxTypes = boxes.map((box) => box.type);
+        throw createInvalidMp4ContainerLayoutError(detectedBoxTypes);
+      }
+      boxSize = readLargeSize(view, largeSizeOffset);
+      headerSize = MP4_EXTENDED_BOX_HEADER_BYTES;
+    }
+    if (declaredSize === MP4_ZERO_SIZE_MARKER) {
+      boxSize = totalBytes - currentOffset;
+    }
+    const hasValidHeaderSize = boxSize >= headerSize;
+    if (!hasValidHeaderSize) {
+      const detectedBoxTypes = boxes.map((box) => box.type);
+      throw createInvalidMp4ContainerLayoutError(detectedBoxTypes);
+    }
+    const nextOffset = currentOffset + boxSize;
+    const hasValidBoxRange = nextOffset <= totalBytes;
+    if (!hasValidBoxRange) {
+      const detectedBoxTypes = boxes.map((box) => box.type);
+      throw createInvalidMp4ContainerLayoutError(detectedBoxTypes);
+    }
+    boxes.push({
+      type: boxType,
+      size: boxSize,
+      startOffset: currentOffset,
+      endOffset: nextOffset
+    });
+    currentOffset = nextOffset;
+  }
+  return boxes;
+}
+function assertMp4ContainerIsNonFragmented(input) {
+  const topLevelBoxes = parseMp4TopLevelBoxes(input);
+  const detectedFragmentBoxes = topLevelBoxes.filter((box) => {
+    if (box.type === MP4_FRAGMENT_BOX_TYPE_MOOF) {
+      return true;
+    }
+    if (box.type === MP4_FRAGMENT_BOX_TYPE_MFRA) {
+      return true;
+    }
+    return false;
+  }).map((box) => box.type);
+  const hasFragmentBoxes = detectedFragmentBoxes.length > 0;
+  if (!hasFragmentBoxes) {
+    return;
+  }
+  const uniqueDetectedBoxTypes = getUniqueValues(detectedFragmentBoxes);
+  throw createInvalidMp4ContainerLayoutError(uniqueDetectedBoxTypes);
+}
+
 // src/core/utils/shared-object-url-store.ts
 function createSharedObjectUrlStore(dependencies) {
   let activeUrl = null;
@@ -13374,6 +13935,54 @@ class FrameCompositor {
   }
 }
 
+// src/core/processor/worker/stop-finalization.ts
+var STOP_PENDING_WRITES_TIMEOUT_MILLISECONDS = 500;
+var STOP_PENDING_WRITES_POLL_INTERVAL_MILLISECONDS = 10;
+var ERROR_STOP_PENDING_WRITES_TIMEOUT = "stop.pending-writes-timeout";
+function createDefaultNowMilliseconds() {
+  return () => performance.now();
+}
+function createDefaultWaitMilliseconds() {
+  return (milliseconds) => new Promise((resolve) => {
+    globalThis.setTimeout(resolve, milliseconds);
+  });
+}
+async function waitForPendingWritesToDrain(dependencies) {
+  let getNowMilliseconds = dependencies.getNowMilliseconds;
+  if (!getNowMilliseconds) {
+    getNowMilliseconds = createDefaultNowMilliseconds();
+  }
+  let waitMilliseconds = dependencies.waitMilliseconds;
+  if (!waitMilliseconds) {
+    waitMilliseconds = createDefaultWaitMilliseconds();
+  }
+  let timeoutMilliseconds = dependencies.timeoutMilliseconds;
+  if (timeoutMilliseconds === undefined) {
+    timeoutMilliseconds = STOP_PENDING_WRITES_TIMEOUT_MILLISECONDS;
+  }
+  const startedAtMilliseconds = getNowMilliseconds();
+  let pendingWriteCount = dependencies.getPendingWriteCount();
+  while (pendingWriteCount > 0) {
+    const elapsedMilliseconds = getNowMilliseconds() - startedAtMilliseconds;
+    if (elapsedMilliseconds >= timeoutMilliseconds) {
+      throw new Error(ERROR_STOP_PENDING_WRITES_TIMEOUT);
+    }
+    await waitMilliseconds(STOP_PENDING_WRITES_POLL_INTERVAL_MILLISECONDS);
+    pendingWriteCount = dependencies.getPendingWriteCount();
+  }
+}
+
+// src/core/processor/worker/stop-transition.ts
+async function runStopTransition(dependencies) {
+  await dependencies.finalizeStopSequence().then(() => dependencies.completeStop()).catch((error) => {
+    return dependencies.recoverStopFailure().then(() => {
+      throw error;
+    });
+  }).finally(() => {
+    dependencies.clearStoppingFlag();
+  });
+}
+
 // src/core/processor/worker/timestamp-manager.ts
 var DEFAULT_FRAME_RATE = 30;
 var DEFAULT_KEY_FRAME_INTERVAL_SECONDS = 5;
@@ -13584,13 +14193,14 @@ function clampValue(value, min, max) {
 var WORKER_MESSAGE_TYPE_PROBE = "probe";
 var WORKER_MESSAGE_TYPE_AUDIO_CHUNK = "audioChunk";
 var WORKER_RESPONSE_TYPE_PROBE_RESULT = "probeResult";
-var WORKER_RESPONSE_TYPE_DEBUG_LOG = "debugLog";
 var WORKER_AUDIO_SAMPLE_FORMAT_F32_PLANAR = "f32-planar";
 
 // src/core/processor/worker/visibility-tracker.ts
 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 = [];
@@ -13598,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;
@@ -13608,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;
@@ -13618,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 = [
@@ -13707,6 +14341,11 @@ var ERROR_AUDIO_CHANNELS_INVALID = "Audio channels must be greater than zero";
 var ERROR_AUDIO_FRAMES_INVALID = "Audio frames must be greater than zero";
 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;
@@ -13729,6 +14368,7 @@ class RecorderWorker {
   totalSize = 0;
   expectedAudioChannels = null;
   expectedAudioSampleRate = null;
+  pendingWriteCount = 0;
   constructor() {
     this.bufferTracker = new BufferTracker({
       getBufferSize: () => this.totalSize,
@@ -13759,14 +14399,6 @@ class RecorderWorker {
       },
       getNowMilliseconds: () => performance.now()
     });
-    const sendDebugLog = (message, payload) => {
-      const response = {
-        type: WORKER_RESPONSE_TYPE_DEBUG_LOG,
-        message,
-        payload
-      };
-      self.postMessage(response);
-    };
     this.frameCompositor = new FrameCompositor({
       logger: {
         debug: (message, data) => logger.debug(message, data),
@@ -13775,7 +14407,9 @@ class RecorderWorker {
       },
       fetchResource: (input, init) => fetch(input, init),
       createImageBitmap: (image) => createImageBitmap(image),
-      sendDebugLog
+      sendDebugLog: (_message, _payload) => {
+        return;
+      }
     });
     self.addEventListener("message", this.handleMessage);
   }
@@ -13909,6 +14543,7 @@ class RecorderWorker {
     this.audioState.reset();
     this.expectedAudioChannels = null;
     this.expectedAudioSampleRate = null;
+    this.pendingWriteCount = 0;
     this.videoProcessingActive = false;
     this.frameCompositor.reset();
     this.recordingStartTime = 0;
@@ -13939,13 +14574,11 @@ class RecorderWorker {
   }
   createOutput() {
     const writable = new WritableStream({
-      write: (chunk) => {
-        this.sendChunk(chunk.data, chunk.position);
-      }
+      write: (chunk) => this.handleOutputChunkWrite(chunk)
     });
     this.output = new Output({
       format: new Mp4OutputFormat({
-        fastStart: "fragmented"
+        fastStart: MP4_FAST_START_DISABLED
       }),
       target: new StreamTarget(writable, {
         chunked: true,
@@ -13953,6 +14586,24 @@ class RecorderWorker {
       })
     });
   }
+  decrementPendingWriteCount() {
+    this.pendingWriteCount -= 1;
+    if (this.pendingWriteCount < 0) {
+      this.pendingWriteCount = 0;
+    }
+  }
+  handleOutputChunkWrite(chunk) {
+    this.pendingWriteCount += 1;
+    const writeOperation = Promise.resolve().then(() => {
+      this.sendChunk(chunk.data, chunk.position);
+    });
+    return writeOperation.then(() => {
+      this.decrementPendingWriteCount();
+    }, (error) => {
+      this.decrementPendingWriteCount();
+      throw error;
+    });
+  }
   createVideoSource(config) {
     const fps = this.timestampManager.getFrameRate();
     const keyFrameIntervalSeconds = config.keyFrameInterval;
@@ -13963,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)
     };
@@ -14146,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
     });
@@ -14442,19 +15089,42 @@ class RecorderWorker {
     }
     this.sendStateChange("recording");
   }
-  async handleStop() {
+  handleStop() {
     if (this.isStopping) {
       logger.debug("[RecorderWorker] handleStop ignored (stopping/finalized)");
-      return;
+      return Promise.resolve();
     }
     if (this.isFinalized) {
       logger.debug("[RecorderWorker] handleStop ignored (stopping/finalized)");
-      return;
+      return Promise.resolve();
     }
     this.isStopping = true;
     this.isFinalized = true;
     this.videoProcessingActive = false;
     this.audioState.setProcessingActive(false);
+    return runStopTransition({
+      finalizeStopSequence: () => this.finalizeStopSequence(),
+      completeStop: () => this.completeStop(),
+      recoverStopFailure: () => {
+        if (this.isFinalized) {
+          this.resetStopStateAfterFailure();
+        }
+        return this.cleanup().catch((cleanupError) => {
+          logger.error("[RecorderWorker] Stop failure cleanup failed", {
+            error: extractErrorMessage(cleanupError)
+          });
+        });
+      },
+      clearStoppingFlag: () => {
+        this.isStopping = false;
+      }
+    });
+  }
+  async completeStop() {
+    await this.cleanup();
+    this.sendStateChange("stopped");
+  }
+  async finalizeStopSequence() {
     if (this.videoProcessor) {
       await this.videoProcessor.cancel();
       this.videoProcessor = null;
@@ -14464,13 +15134,17 @@ class RecorderWorker {
       this.audioProcessor = null;
     }
     if (this.output) {
-      await this.output.finalize().catch((error) => {
-        logger.warn("[RecorderWorker] finalize failed (ignored, already finalized?)", error);
-      });
+      await this.output.finalize();
     }
-    await this.cleanup();
-    this.sendStateChange("stopped");
-    this.isStopping = false;
+    await waitForPendingWritesToDrain({
+      getPendingWriteCount: () => this.pendingWriteCount,
+      timeoutMilliseconds: STOP_PENDING_WRITES_TIMEOUT_MILLISECONDS2
+    });
+  }
+  resetStopStateAfterFailure() {
+    this.isFinalized = false;
+    this.videoProcessingActive = false;
+    this.audioState.setProcessingActive(false);
   }
   handleToggleMute() {
     this.audioState.toggleMuted();
@@ -14586,6 +15260,7 @@ class RecorderWorker {
     this.isScreenCapture = false;
     this.expectedAudioChannels = null;
     this.expectedAudioSampleRate = null;
+    this.pendingWriteCount = 0;
     this.visibilityTracker.reset(this.recordingStartTime, this.isScreenCapture);
   }
   setExpectedAudioFormat(sampleRate, numberOfChannels) {
@@ -14706,8 +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 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;
@@ -14728,6 +15445,7 @@ class WorkerProcessor {
   workerProbeManager;
   canUseMainThreadVideoProcessorFn;
   createVideoStreamFromTrackFn;
+  isLinuxPlatformFn;
   constructor(dependencies = {}) {
     let createWorkerFn = (workerUrl) => new Worker(workerUrl, { type: "classic" });
     if (dependencies.createWorker) {
@@ -14747,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),
@@ -14875,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);
+    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,
@@ -14884,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", {
@@ -14960,28 +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) {
-    let codec = config.codec;
-    if (!codec) {
-      codec = await detectBestCodec(config.width, config.height, config.bitrate);
-    }
-    return codec;
+  async resolveAudioCodec(config, format, policy, audioBitrate) {
+    return await resolveAudioCodecFromPolicy({
+      format,
+      overrideCodec: config.audioCodec,
+      policy,
+      bitrate: audioBitrate
+    });
+  }
+  async resolveVideoCodec(config, format, policy) {
+    return await resolveVideoCodecFromPolicy({
+      format,
+      overrideCodec: config.codec,
+      policy,
+      width: config.width,
+      height: config.height,
+      bitrate: config.bitrate
+    });
   }
-  buildWorkerTranscodeConfig(config, audioCodec, codec, format) {
+  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,
@@ -14990,6 +15777,7 @@ class WorkerProcessor {
   }
   async prepareAudioPipeline(audioTrack, workerProbeResult) {
     if (!audioTrack) {
+      logger.debug("[WorkerProcessor] Audio pipeline disabled (no track)");
       return {
         audioConfig: null,
         audioStream: null,
@@ -15000,6 +15788,10 @@ class WorkerProcessor {
     if (canUseMainThreadAudioPipeline) {
       const audioStream = this.createAudioStreamFromTrack(audioTrack);
       if (audioStream) {
+        logger.debug("[WorkerProcessor] Audio pipeline selected", {
+          path: "main-thread-audio-stream",
+          hasAudioDataInWorker: workerProbeResult.hasAudioData
+        });
         return {
           audioConfig: null,
           audioStream,
@@ -15009,6 +15801,11 @@ class WorkerProcessor {
     }
     const audioConfig = await this.prepareAudioConfig(audioTrack);
     if (audioConfig) {
+      logger.debug("[WorkerProcessor] Audio pipeline selected", {
+        path: "audio-worklet-chunks",
+        sampleRate: audioConfig.sampleRate,
+        numberOfChannels: audioConfig.numberOfChannels
+      });
       return {
         audioConfig,
         audioStream: null,
@@ -15143,42 +15940,88 @@ class WorkerProcessor {
     if (!this.isWorkerActive()) {
       throw new Error("Processing not active");
     }
+    const finalizeStartedAtMilliseconds = performance.now();
     return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error("Finalize timeout"));
-      }, FINALIZE_TIMEOUT_MILLISECONDS);
-      const removeWorkerListener = () => {
-        if (!this.worker) {
+      const worker = this.worker;
+      if (!worker) {
+        reject(new Error("Worker not initialized"));
+        return;
+      }
+      let timeoutId = null;
+      const clearFinalizeTimeout = () => {
+        if (timeoutId === null) {
           return;
         }
-        this.worker.removeEventListener("message", messageHandler);
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      };
+      const removeWorkerListener = () => {
+        worker.removeEventListener("message", messageHandler);
+      };
+      let hasSettled = false;
+      const settleOnce = () => {
+        if (hasSettled) {
+          return false;
+        }
+        hasSettled = true;
+        clearFinalizeTimeout();
+        removeWorkerListener();
+        return true;
       };
       const messageHandler = (event) => {
+        if (hasSettled) {
+          return;
+        }
         const response = event.data;
         const isStopped = response.type === "stateChange" && response.state === "stopped";
         if (isStopped) {
-          removeWorkerListener();
-          clearTimeout(timeout);
-          this.isActive = false;
-          this.stopAudioWorklet();
-          resolve(this.createBlobFromChunks());
+          const canSettle2 = settleOnce();
+          if (!canSettle2) {
+            return;
+          }
+          this.resetFinalizeRuntimeState();
+          Promise.resolve().then(() => this.createBlobFromChunks()).then((streamProcessorResult) => {
+            resolve(streamProcessorResult);
+          }, (error) => {
+            this.rejectFinalizeBlobCreationError(reject, error, finalizeStartedAtMilliseconds);
+          });
           return;
         }
         const isError = response.type === "error";
-        if (isError) {
-          removeWorkerListener();
-          clearTimeout(timeout);
-          this.stopAudioWorklet();
-          reject(new Error(response.error));
+        if (!isError) {
+          return;
         }
+        const canSettle = settleOnce();
+        if (!canSettle) {
+          return;
+        }
+        this.resetFinalizeRuntimeState();
+        logger.error("[WorkerProcessor] Finalize failed", {
+          elapsedSeconds: (performance.now() - finalizeStartedAtMilliseconds) / MILLISECONDS_PER_SECOND3,
+          error: response.error
+        });
+        reject(new Error(response.error));
       };
-      if (this.worker) {
-        this.worker.addEventListener("message", messageHandler);
-        const message = { type: "stop" };
-        this.worker.postMessage(message);
-      }
+      timeoutId = setTimeout(() => {
+        const canSettle = settleOnce();
+        if (!canSettle) {
+          return;
+        }
+        logger.error("[WorkerProcessor] Finalize timeout reached", {
+          elapsedSeconds: (performance.now() - finalizeStartedAtMilliseconds) / MILLISECONDS_PER_SECOND3
+        });
+        this.resetFinalizeRuntimeState();
+        reject(new Error("Finalize timeout"));
+      }, FINALIZE_TIMEOUT_MILLISECONDS);
+      worker.addEventListener("message", messageHandler);
+      const message = { type: "stop" };
+      worker.postMessage(message);
     });
   }
+  resetFinalizeRuntimeState() {
+    this.isActive = false;
+    this.stopAudioWorklet();
+  }
   createBlobFromChunks() {
     const sortedChunks = [...this.chunks].sort((a, b) => a.position - b.position);
     const buffer = new ArrayBuffer(this.totalSize);
@@ -15186,12 +16029,24 @@ class WorkerProcessor {
     for (const chunk of sortedChunks) {
       view.set(chunk.data, chunk.position);
     }
+    assertMp4ContainerIsNonFragmented(buffer);
     const blob = new Blob([buffer], { type: "video/mp4" });
     return {
       blob,
       totalSize: this.totalSize
     };
   }
+  rejectFinalizeBlobCreationError(reject, error, finalizeStartedAtMilliseconds) {
+    logger.error("[WorkerProcessor] Finalize failed while creating blob", {
+      elapsedSeconds: (performance.now() - finalizeStartedAtMilliseconds) / MILLISECONDS_PER_SECOND3,
+      error: extractErrorMessage(error)
+    });
+    if (error instanceof Error) {
+      reject(error);
+      return;
+    }
+    reject(new Error(extractErrorMessage(error)));
+  }
   cancel() {
     if (this.worker && this.isActive) {
       const message = { type: "stop" };
@@ -15221,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",
@@ -15525,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";
@@ -15592,6 +16447,9 @@ class RecordingManager {
   getOriginalCameraStream() {
     return this.originalCameraStream;
   }
+  prewarmStreamProcessor() {
+    this.getOrCreateStreamProcessor();
+  }
   async startRecording() {
     try {
       this.callbacks.onClearUploadStatus();
@@ -15608,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(() => {
@@ -15616,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);
@@ -15627,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:", {
@@ -15644,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) => {
@@ -15674,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) {
@@ -15752,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;
@@ -15766,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");
@@ -15896,6 +16774,7 @@ class UploadMetadataManager {
 
 // src/core/recording/recorder-controller.ts
 var LOGGER_PREFIX = "[RecorderController]";
+var RECORDING_WARMUP_DELAY_MILLISECONDS = 0;
 
 class RecorderController {
   streamManager;
@@ -15913,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;
@@ -15930,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, {
@@ -15995,6 +16876,7 @@ class RecorderController {
         this.applyRecordingConfig(config);
         await this.initializeStorage();
         this.isInitialized = true;
+        this.scheduleRecordingWarmup();
       }
     });
   }
@@ -16006,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: {
@@ -16023,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: {
@@ -16153,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();
@@ -16279,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;
@@ -16704,6 +17624,10 @@ export {
   mapPresetToConfig,
   logger,
   isMobileDevice2 as isMobileDevice,
+  getPresetVideoBitrateForFormat,
+  getPresetTotalBitrate,
+  getPresetAudioBitrateForFormat,
+  getFormatCompatibilityPolicy,
   getDefaultConfigForFormat,
   getDefaultAudioCodecForFormat,
   getBrowserName,
@@ -16716,6 +17640,8 @@ export {
   extractLastFrame,
   extractErrorMessage,
   checkRecorderSupport,
+  calculateVideoBitrate,
+  calculateTotalBitrateFromMbPerMinute,
   calculateBarColor,
   VidtreoRecorder,
   VideoUploadService,
@@ -16726,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,