@vidtreo/recorder 0.0.1

package/dist/index.js

@@ -0,0 +1,3218 @@
+// src/core/utils/error-handler.ts
+function extractErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/core/audio/audio-level-analyzer.ts
+var AUDIO_LEVEL_INTERVAL = 100;
+var FFT_SIZE = 2048;
+var SMOOTHING_TIME_CONSTANT = 0.8;
+var AUDIO_MIDPOINT = 128;
+var AUDIO_NORMALIZATION_DIVISOR = 128;
+var MIN_DB = -60;
+var DB_OFFSET = 50;
+var DB_RANGE = 50;
+var POWER_CURVE_EXPONENT = 0.6;
+var MAX_AUDIO_LEVEL = 100;
+var LEVEL_MULTIPLIER = 110;
+
+class AudioLevelAnalyzer {
+  audioContext = null;
+  analyser = null;
+  audioLevelIntervalId = null;
+  audioLevel = 0;
+  getMutedState = null;
+  currentStream = null;
+  startTracking(stream, callbacks, getMutedState) {
+    if (!stream) {
+      throw new Error("Stream is required");
+    }
+    if (!getMutedState) {
+      throw new Error("getMutedState callback is required");
+    }
+    this.stopTracking();
+    this.currentStream = stream;
+    this.getMutedState = getMutedState;
+    const audioTracks = stream.getAudioTracks();
+    if (audioTracks.length === 0) {
+      throw new Error("Stream has no audio tracks");
+    }
+    const AudioContextClass = this.getAudioContextClass();
+    if (!AudioContextClass) {
+      throw new Error("AudioContext is not supported in this browser");
+    }
+    try {
+      this.audioContext = new AudioContextClass;
+    } catch (error) {
+      throw new Error(`Failed to create AudioContext: ${extractErrorMessage(error)}`);
+    }
+    const source = this.audioContext.createMediaStreamSource(stream);
+    this.analyser = this.audioContext.createAnalyser();
+    this.analyser.fftSize = FFT_SIZE;
+    this.analyser.smoothingTimeConstant = SMOOTHING_TIME_CONSTANT;
+    source.connect(this.analyser);
+    const dataArray = new Uint8Array(this.analyser.fftSize);
+    this.audioLevelIntervalId = window.setInterval(() => {
+      if (!this.analyser) {
+        return;
+      }
+      this.analyser.getByteTimeDomainData(dataArray);
+      const audioLevel = this.calculateAudioLevel(dataArray);
+      this.audioLevel = audioLevel;
+      const isMuted = this.checkMutedState();
+      const displayLevel = isMuted ? 0 : audioLevel;
+      callbacks.onLevelUpdate(displayLevel, isMuted);
+    }, AUDIO_LEVEL_INTERVAL);
+  }
+  stopTracking() {
+    if (this.audioLevelIntervalId !== null) {
+      clearInterval(this.audioLevelIntervalId);
+      this.audioLevelIntervalId = null;
+    }
+    if (this.analyser) {
+      this.analyser.disconnect();
+      this.analyser = null;
+    }
+    if (this.audioContext) {
+      this.audioContext.close();
+      this.audioContext = null;
+    }
+    this.audioLevel = 0;
+    this.getMutedState = null;
+    this.currentStream = null;
+  }
+  getAudioLevel() {
+    return this.audioLevel;
+  }
+  getAudioContextClass() {
+    if (window.AudioContext) {
+      return window.AudioContext;
+    }
+    const webkitAudioContext = window.webkitAudioContext;
+    if (webkitAudioContext) {
+      return webkitAudioContext;
+    }
+    return null;
+  }
+  calculateAudioLevel(dataArray) {
+    let sumSquares = 0;
+    for (const value of dataArray) {
+      const normalized = (value - AUDIO_MIDPOINT) / AUDIO_NORMALIZATION_DIVISOR;
+      sumSquares += normalized * normalized;
+    }
+    const rms = Math.sqrt(sumSquares / dataArray.length);
+    const db = rms > 0 ? 20 * Math.log10(rms) : MIN_DB;
+    const normalizedDb = Math.max(0, Math.min(1, (db + DB_OFFSET) / DB_RANGE));
+    const powerCurve = normalizedDb ** POWER_CURVE_EXPONENT;
+    return Math.min(MAX_AUDIO_LEVEL, powerCurve * LEVEL_MULTIPLIER);
+  }
+  checkMutedState() {
+    if (!this.getMutedState) {
+      throw new Error("getMutedState callback is not set");
+    }
+    const isMutedFromCallback = this.getMutedState();
+    if (!this.currentStream) {
+      throw new Error("Current stream is not set");
+    }
+    const audioTracks = this.currentStream.getAudioTracks();
+    const hasDisabledTracks = audioTracks.length > 0 && audioTracks.some((track) => !track.enabled);
+    return isMutedFromCallback || hasDisabledTracks;
+  }
+}
+// src/core/config/default-config.ts
+var DEFAULT_TRANSCODE_CONFIG = Object.freeze({
+  format: "mp4",
+  fps: 30,
+  width: 1280,
+  height: 720,
+  bitrate: 500000,
+  audioCodec: "aac",
+  audioBitrate: 128000,
+  preset: "medium",
+  packetCount: 1200
+});
+
+// src/core/config/preset-mapper.ts
+var BITRATE_MAP = {
+  sd: 500000,
+  hd: 1e6,
+  fhd: 2000000,
+  "4k": 8000000
+};
+var AUDIO_BITRATE = 128000;
+var PACKET_COUNT_MAP = {
+  sd: 800,
+  hd: 1200,
+  fhd: 2000,
+  "4k": 4000
+};
+var DEFAULT_FPS = 30;
+var DEFAULT_FORMAT = "mp4";
+var DEFAULT_AUDIO_CODEC = "aac";
+var DEFAULT_PRESET = "medium";
+function mapPresetToConfig(preset, maxWidth, maxHeight) {
+  if (!(preset in BITRATE_MAP)) {
+    throw new Error(`Invalid preset: ${preset}`);
+  }
+  if (typeof maxWidth !== "number" || maxWidth <= 0) {
+    throw new Error("maxWidth must be a positive number");
+  }
+  if (typeof maxHeight !== "number" || maxHeight <= 0) {
+    throw new Error("maxHeight must be a positive number");
+  }
+  return {
+    format: DEFAULT_FORMAT,
+    fps: DEFAULT_FPS,
+    width: maxWidth,
+    height: maxHeight,
+    bitrate: BITRATE_MAP[preset],
+    audioCodec: DEFAULT_AUDIO_CODEC,
+    preset: DEFAULT_PRESET,
+    packetCount: PACKET_COUNT_MAP[preset],
+    audioBitrate: AUDIO_BITRATE
+  };
+}
+
+// src/core/config/config-service.ts
+var DEFAULT_CACHE_TIMEOUT = 5 * 60 * 1000;
+var CONFIG_API_PATH = "/api/v1/videos/config";
+
+class ConfigService {
+  cachedConfig = null;
+  cacheTimestamp = 0;
+  cacheTimeout;
+  fetchPromise = null;
+  options;
+  constructor(options) {
+    this.options = options;
+    if (options.cacheTimeout !== undefined) {
+      if (typeof options.cacheTimeout !== "number" || options.cacheTimeout <= 0) {
+        throw new Error("cacheTimeout must be a positive number");
+      }
+      this.cacheTimeout = options.cacheTimeout;
+    } else {
+      this.cacheTimeout = DEFAULT_CACHE_TIMEOUT;
+    }
+  }
+  async fetchConfig() {
+    const now = Date.now();
+    if (this.cachedConfig && now - this.cacheTimestamp < this.cacheTimeout) {
+      return this.cachedConfig;
+    }
+    if (this.fetchPromise) {
+      return this.fetchPromise;
+    }
+    this.fetchPromise = this.fetchConfigFromBackend();
+    try {
+      const config = await this.fetchPromise;
+      this.cachedConfig = config;
+      this.cacheTimestamp = now;
+      return config;
+    } catch {
+      return DEFAULT_TRANSCODE_CONFIG;
+    } finally {
+      this.fetchPromise = null;
+    }
+  }
+  clearCache() {
+    this.cachedConfig = null;
+    this.cacheTimestamp = 0;
+  }
+  getCurrentConfig() {
+    if (!this.cachedConfig) {
+      throw new Error("No cached config available. Call fetchConfig() first.");
+    }
+    return this.cachedConfig;
+  }
+  async fetchConfigFromBackend() {
+    const url = `${this.options.backendUrl}${CONFIG_API_PATH}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${this.options.apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch config: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!data.presetEncoding || typeof data.max_width !== "number" || typeof data.max_height !== "number") {
+      throw new Error("Invalid config response from backend");
+    }
+    return mapPresetToConfig(data.presetEncoding, data.max_width, data.max_height);
+  }
+}
+
+// src/core/config/config-manager.ts
+class ConfigManager {
+  configService = null;
+  currentConfig = DEFAULT_TRANSCODE_CONFIG;
+  configFetchPromise = null;
+  initialize(apiKey, backendUrl) {
+    if (!apiKey) {
+      throw new Error("apiKey is required");
+    }
+    if (!backendUrl) {
+      throw new Error("backendUrl is required");
+    }
+    this.configService = new ConfigService({
+      apiKey,
+      backendUrl
+    });
+    this.fetchConfig();
+  }
+  async fetchConfig() {
+    if (!this.configService) {
+      return;
+    }
+    if (this.configFetchPromise) {
+      this.currentConfig = await this.configFetchPromise;
+      return;
+    }
+    this.configFetchPromise = this.configService.fetchConfig();
+    this.currentConfig = await this.configFetchPromise;
+    this.configFetchPromise = null;
+  }
+  async getConfig() {
+    if (this.configService && !this.configFetchPromise) {
+      await this.fetchConfig();
+    }
+    return this.currentConfig;
+  }
+  clearCache() {
+    if (!this.configService) {
+      throw new Error("ConfigService is not initialized");
+    }
+    this.configService.clearCache();
+  }
+}
+// src/core/device/device-manager.ts
+class DeviceManager {
+  streamManager;
+  callbacks;
+  availableDevices = {
+    audioinput: [],
+    videoinput: []
+  };
+  selectedCameraDeviceId = null;
+  selectedMicDeviceId = null;
+  constructor(streamManager, callbacks) {
+    this.streamManager = streamManager;
+    this.callbacks = callbacks;
+  }
+  async getAvailableDevices() {
+    this.availableDevices = await this.streamManager.getAvailableDevices();
+    if (this.callbacks?.onDevicesChanged) {
+      this.callbacks.onDevicesChanged(this.availableDevices);
+    }
+    return this.availableDevices;
+  }
+  setCameraDevice(deviceId) {
+    this.selectedCameraDeviceId = deviceId;
+    this.streamManager.setVideoDevice(deviceId);
+    if (this.callbacks?.onDeviceSelected) {
+      this.callbacks.onDeviceSelected("camera", deviceId);
+    }
+  }
+  setMicDevice(deviceId) {
+    this.selectedMicDeviceId = deviceId;
+    this.streamManager.setAudioDevice(deviceId);
+    if (this.callbacks?.onDeviceSelected) {
+      this.callbacks.onDeviceSelected("mic", deviceId);
+    }
+  }
+  getSelectedCameraDeviceId() {
+    return this.selectedCameraDeviceId;
+  }
+  getSelectedMicDeviceId() {
+    return this.selectedMicDeviceId;
+  }
+  getAvailableDevicesList() {
+    return this.availableDevices;
+  }
+}
+// src/core/processor/processor.ts
+import {
+  BlobSource,
+  BufferTarget,
+  Conversion,
+  FilePathSource,
+  Input,
+  MP4,
+  Mp4OutputFormat,
+  Output
+} from "mediabunny";
+function createSource(input) {
+  if (typeof input === "string") {
+    return new FilePathSource(input);
+  }
+  if (input instanceof Blob) {
+    return new BlobSource(input);
+  }
+  throw new Error("Invalid input type. Expected Blob, File, or file path string.");
+}
+function createConversionOptions(config) {
+  const video = {
+    width: config.width,
+    height: config.height,
+    fit: "contain",
+    frameRate: config.fps,
+    bitrate: config.bitrate,
+    forceTranscode: true
+  };
+  const audio = {
+    codec: config.audioCodec,
+    forceTranscode: true
+  };
+  return { video, audio };
+}
+function validateConversion(conversion) {
+  if (!conversion.isValid) {
+    const reasons = conversion.discardedTracks.map((track) => track.reason).join(", ");
+    throw new Error(`Conversion is invalid. Discarded tracks: ${reasons}`);
+  }
+}
+async function transcodeVideo(input, config = {}, onProgress) {
+  const finalConfig = {
+    ...DEFAULT_TRANSCODE_CONFIG,
+    ...config
+  };
+  const source = createSource(input);
+  const mediabunnyInput = new Input({
+    formats: [MP4],
+    source
+  });
+  const output = new Output({
+    format: new Mp4OutputFormat,
+    target: new BufferTarget
+  });
+  const conversion = await Conversion.init({
+    input: mediabunnyInput,
+    output,
+    ...createConversionOptions(finalConfig)
+  });
+  validateConversion(conversion);
+  if (onProgress) {
+    conversion.onProgress = onProgress;
+  }
+  await conversion.execute();
+  const buffer = output.target.buffer;
+  if (!buffer) {
+    throw new Error("Transcoding completed but no output buffer was generated");
+  }
+  return {
+    buffer,
+    blob: new Blob([buffer], { type: "video/mp4" })
+  };
+}
+// src/core/processor/stream-processor.ts
+import { CanvasSource } from "mediabunny";
+
+// src/core/processor/audio-track-manager.ts
+import { AudioSample, AudioSampleSource } from "mediabunny";
+
+class AudioTrackManager {
+  originalAudioTrack = null;
+  audioContext = null;
+  audioWorkletNode = null;
+  mediaStreamSource = null;
+  gainNode = null;
+  audioSource = null;
+  lastAudioTimestamp = 0;
+  isMuted = false;
+  isPaused = false;
+  onMuteStateChange;
+  async setupAudioTrack(stream, config) {
+    const audioTrack = stream.getAudioTracks()[0];
+    if (!audioTrack) {
+      return null;
+    }
+    this.originalAudioTrack = audioTrack;
+    this.lastAudioTimestamp = 0;
+    const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+    if (!AudioContextClass) {
+      throw new Error("AudioContext is not supported in this browser");
+    }
+    this.audioContext = new AudioContextClass;
+    if (config.audioBitrate === undefined || config.audioBitrate === null) {
+      throw new Error("audioBitrate is required in config");
+    }
+    const audioBitrate = config.audioBitrate;
+    const audioCodec = config.audioCodec;
+    this.audioSource = new AudioSampleSource({
+      codec: audioCodec,
+      bitrate: audioBitrate
+    });
+    this.mediaStreamSource = this.audioContext.createMediaStreamSource(stream);
+    const processorUrl = new URL("./audio-capture-processor.worklet.js", import.meta.url).href;
+    await this.audioContext.audioWorklet.addModule(processorUrl);
+    this.audioWorkletNode = new AudioWorkletNode(this.audioContext, "audio-capture-processor");
+    this.audioWorkletNode.port.onmessage = (event) => {
+      if (this.isPaused || this.isMuted || !this.audioSource) {
+        return;
+      }
+      const { data, sampleRate, numberOfChannels, duration, bufferLength } = event.data;
+      const float32Data = new Float32Array(data, 0, bufferLength);
+      const audioSample = new AudioSample({
+        data: float32Data,
+        format: "f32-planar",
+        numberOfChannels,
+        sampleRate,
+        timestamp: this.lastAudioTimestamp
+      });
+      this.audioSource.add(audioSample);
+      this.lastAudioTimestamp += duration;
+    };
+    this.gainNode = this.audioContext.createGain();
+    this.gainNode.gain.value = 0;
+    this.mediaStreamSource.connect(this.audioWorkletNode);
+    this.audioWorkletNode.connect(this.gainNode);
+    this.gainNode.connect(this.audioContext.destination);
+    return this.audioSource;
+  }
+  toggleMute() {
+    if (!this.audioSource) {
+      throw new Error("Audio source not initialized");
+    }
+    this.isMuted = !this.isMuted;
+    if (this.onMuteStateChange) {
+      this.onMuteStateChange(this.isMuted);
+    }
+  }
+  isMutedState() {
+    return this.isMuted;
+  }
+  pause() {
+    if (!this.audioSource || this.isPaused) {
+      return;
+    }
+    this.isPaused = true;
+  }
+  resume() {
+    if (!(this.isPaused && this.audioSource)) {
+      return null;
+    }
+    this.isPaused = false;
+    return null;
+  }
+  isPausedState() {
+    return this.isPaused;
+  }
+  getClonedAudioTrack() {
+    return this.originalAudioTrack;
+  }
+  getAudioSource() {
+    return this.audioSource;
+  }
+  getAudioStreamForAnalysis() {
+    if (!this.originalAudioTrack) {
+      return null;
+    }
+    if (this.originalAudioTrack.readyState !== "live") {
+      return null;
+    }
+    return new MediaStream([this.originalAudioTrack]);
+  }
+  getLastAudioTimestamp() {
+    return this.lastAudioTimestamp;
+  }
+  setOnMuteStateChange(callback) {
+    this.onMuteStateChange = callback;
+  }
+  cleanup() {
+    if (this.audioWorkletNode) {
+      this.audioWorkletNode.disconnect();
+      this.audioWorkletNode.port.close();
+      this.audioWorkletNode = null;
+    }
+    if (this.gainNode) {
+      this.gainNode.disconnect();
+      this.gainNode = null;
+    }
+    if (this.mediaStreamSource) {
+      this.mediaStreamSource.disconnect();
+      this.mediaStreamSource = null;
+    }
+    if (this.audioContext) {
+      this.audioContext.close();
+      this.audioContext = null;
+    }
+    if (this.originalAudioTrack) {
+      this.originalAudioTrack.stop();
+      this.originalAudioTrack = null;
+    }
+    this.audioSource = null;
+    this.lastAudioTimestamp = 0;
+  }
+}
+
+// src/core/processor/canvas-renderer.ts
+var BLACK_BACKGROUND = "#000000";
+
+class CanvasRenderer {
+  canvasContext;
+  constructor(canvasContext) {
+    this.canvasContext = canvasContext;
+  }
+  clear() {
+    this.canvasContext.clearRect(0, 0, this.canvasContext.canvas.width, this.canvasContext.canvas.height);
+  }
+  drawFrame(videoElement) {
+    if (videoElement.videoWidth === 0 || videoElement.videoHeight === 0) {
+      return;
+    }
+    const videoAspectRatio = videoElement.videoWidth / videoElement.videoHeight;
+    const canvasAspectRatio = this.canvasContext.canvas.width / this.canvasContext.canvas.height;
+    let drawWidth;
+    let drawHeight;
+    let drawX;
+    let drawY;
+    if (videoAspectRatio > canvasAspectRatio) {
+      drawWidth = this.canvasContext.canvas.width;
+      drawHeight = this.canvasContext.canvas.width / videoAspectRatio;
+      drawX = 0;
+      drawY = (this.canvasContext.canvas.height - drawHeight) / 2;
+    } else {
+      drawHeight = this.canvasContext.canvas.height;
+      drawWidth = this.canvasContext.canvas.height * videoAspectRatio;
+      drawX = (this.canvasContext.canvas.width - drawWidth) / 2;
+      drawY = 0;
+    }
+    this.canvasContext.fillStyle = BLACK_BACKGROUND;
+    this.canvasContext.fillRect(0, 0, this.canvasContext.canvas.width, this.canvasContext.canvas.height);
+    this.canvasContext.drawImage(videoElement, drawX, drawY, drawWidth, drawHeight);
+  }
+  getContext() {
+    return this.canvasContext;
+  }
+}
+
+// src/core/processor/frame-capturer.ts
+var READY_STATE_HAVE_CURRENT_DATA = 2;
+var DEFAULT_FRAME_RATE = 30;
+
+class FrameCapturer {
+  timeoutId = null;
+  isActive = false;
+  isPaused = false;
+  frameCount = 0;
+  lastFrameTimestamp = 0;
+  currentFrameRate = DEFAULT_FRAME_RATE;
+  canvasSource = null;
+  canvasRenderer = null;
+  videoElement = null;
+  pendingFrameAdd = null;
+  start(canvasSource, canvasRenderer, videoElement, frameRate) {
+    this.canvasSource = canvasSource;
+    this.canvasRenderer = canvasRenderer;
+    this.videoElement = videoElement;
+    this.isActive = true;
+    this.isPaused = false;
+    this.frameCount = 0;
+    this.lastFrameTimestamp = 0;
+    this.currentFrameRate = frameRate;
+    this.captureFrame();
+  }
+  pause() {
+    if (!this.isActive || this.isPaused) {
+      return;
+    }
+    this.isPaused = true;
+    if (this.timeoutId !== null) {
+      window.clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+  resume() {
+    if (!(this.isActive && this.isPaused)) {
+      return;
+    }
+    if (!(this.videoElement && this.canvasSource)) {
+      throw new Error("Frame capturer not properly initialized");
+    }
+    this.isPaused = false;
+    this.captureFrame();
+  }
+  isPausedState() {
+    return this.isPaused;
+  }
+  getLastFrameTimestamp() {
+    return this.lastFrameTimestamp;
+  }
+  async waitForPendingFrames() {
+    if (this.pendingFrameAdd) {
+      await this.pendingFrameAdd;
+    }
+  }
+  stop() {
+    this.isActive = false;
+    if (this.timeoutId !== null) {
+      window.clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+  captureFrame() {
+    if (!this.canCaptureFrame()) {
+      return;
+    }
+    if (!this.isVideoReady()) {
+      this.scheduleNextFrame();
+      return;
+    }
+    if (this.isPaused) {
+      return;
+    }
+    this.frameCount += 1;
+    const frameDuration = 1 / this.currentFrameRate;
+    const frameTimestamp = this.lastFrameTimestamp + frameDuration;
+    if (this.isPaused) {
+      this.frameCount -= 1;
+      return;
+    }
+    this.renderFrame();
+    this.addFrameToSource(frameTimestamp, frameDuration);
+    if (this.isPaused) {
+      this.frameCount -= 1;
+      return;
+    }
+    this.lastFrameTimestamp = frameTimestamp;
+    this.scheduleNextFrame();
+  }
+  canCaptureFrame() {
+    if (!this.isActive || this.isPaused || !this.videoElement || !this.canvasSource || !this.canvasRenderer) {
+      return false;
+    }
+    return true;
+  }
+  isVideoReady() {
+    if (!this.videoElement) {
+      return false;
+    }
+    if (this.videoElement.readyState < READY_STATE_HAVE_CURRENT_DATA) {
+      return false;
+    }
+    if (this.videoElement.videoWidth === 0 || this.videoElement.videoHeight === 0) {
+      return false;
+    }
+    return true;
+  }
+  renderFrame() {
+    if (!(this.canvasRenderer && this.videoElement)) {
+      return;
+    }
+    this.canvasRenderer.clear();
+    this.canvasRenderer.drawFrame(this.videoElement);
+  }
+  addFrameToSource(timestamp, duration) {
+    if (!this.canvasSource || this.isPaused) {
+      return;
+    }
+    const isKeyFrame = this.frameCount === 1;
+    this.pendingFrameAdd = this.canvasSource.add(timestamp, duration, isKeyFrame ? { keyFrame: true } : undefined).then(() => {
+      this.pendingFrameAdd = null;
+    }).catch(() => {
+      this.pendingFrameAdd = null;
+    });
+  }
+  scheduleNextFrame() {
+    if (this.isPaused) {
+      return;
+    }
+    const frameInterval = 1000 / this.currentFrameRate;
+    this.timeoutId = window.setTimeout(() => {
+      this.captureFrame();
+    }, frameInterval);
+  }
+}
+
+// src/core/processor/output-manager.ts
+import {
+  Mp4OutputFormat as Mp4OutputFormat2,
+  Output as Output2,
+  StreamTarget
+} from "mediabunny";
+var CHUNK_SIZE = 16 * 1024 * 1024;
+
+class OutputManager {
+  output = null;
+  chunks = [];
+  totalSize = 0;
+  create() {
+    const writable = new WritableStream({
+      write: (chunk) => {
+        this.chunks.push({
+          data: chunk.data,
+          position: chunk.position
+        });
+        this.totalSize = Math.max(this.totalSize, chunk.position + chunk.data.length);
+      }
+    });
+    this.output = new Output2({
+      format: new Mp4OutputFormat2({
+        fastStart: "fragmented"
+      }),
+      target: new StreamTarget(writable, {
+        chunked: true,
+        chunkSize: CHUNK_SIZE
+      })
+    });
+    return this.output;
+  }
+  getOutput() {
+    if (!this.output) {
+      throw new Error("Output not initialized");
+    }
+    return this.output;
+  }
+  getChunks() {
+    return this.chunks;
+  }
+  async finalize() {
+    if (!this.output) {
+      throw new Error("Output not initialized");
+    }
+    await this.output.finalize();
+    const sortedChunks = [...this.chunks].sort((a, b) => a.position - b.position);
+    const buffer = new ArrayBuffer(this.totalSize);
+    const view = new Uint8Array(buffer);
+    for (const chunk of sortedChunks) {
+      view.set(chunk.data, chunk.position);
+    }
+    const blob = new Blob([buffer], { type: "video/mp4" });
+    return {
+      blob,
+      totalSize: this.totalSize
+    };
+  }
+  async cancel() {
+    if (this.output) {
+      await this.output.cancel();
+    }
+  }
+  getTotalSize() {
+    return this.totalSize;
+  }
+}
+
+// src/core/processor/video-element-manager.ts
+var READY_STATE_HAVE_CURRENT_DATA2 = 2;
+var VIDEO_LOAD_TIMEOUT = 5000;
+
+class VideoElementManager {
+  videoElement = null;
+  isActive = false;
+  isIntentionallyPaused = false;
+  create(stream) {
+    const videoElement = document.createElement("video");
+    videoElement.srcObject = stream;
+    videoElement.autoplay = true;
+    videoElement.playsInline = true;
+    videoElement.muted = true;
+    videoElement.addEventListener("pause", () => {
+      if (this.isActive && this.videoElement && !this.isIntentionallyPaused) {
+        this.videoElement.play();
+      }
+    });
+    this.videoElement = videoElement;
+    return videoElement;
+  }
+  async waitForReady() {
+    if (!this.videoElement) {
+      throw new Error("Video element not created");
+    }
+    await this.waitForVideoReady(true);
+  }
+  async switchSource(newStream) {
+    if (!this.videoElement) {
+      throw new Error("Video element not initialized");
+    }
+    this.videoElement.srcObject = newStream;
+    await this.waitForVideoReady(false);
+    await this.videoElement.play();
+  }
+  getElement() {
+    return this.videoElement;
+  }
+  setActive(active) {
+    this.isActive = active;
+  }
+  pause() {
+    if (!(this.videoElement && this.isActive)) {
+      return;
+    }
+    this.isIntentionallyPaused = true;
+    this.videoElement.pause();
+  }
+  resume() {
+    if (!(this.videoElement && this.isActive)) {
+      return;
+    }
+    this.isIntentionallyPaused = false;
+    this.videoElement.play();
+  }
+  cleanup() {
+    if (this.videoElement) {
+      this.videoElement.srcObject = null;
+      this.videoElement = null;
+    }
+  }
+  waitForVideoReady(shouldPlay) {
+    if (!this.videoElement) {
+      throw new Error("Video element not available");
+    }
+    const videoElement = this.videoElement;
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        videoElement.removeEventListener("loadedmetadata", onLoadedMetadata);
+        videoElement.removeEventListener("error", onError);
+      };
+      const onLoadedMetadata = () => {
+        cleanup();
+        if (shouldPlay) {
+          videoElement.play().then(resolve).catch(reject);
+        } else {
+          resolve();
+        }
+      };
+      const onError = () => {
+        cleanup();
+        reject(new Error("Failed to load video metadata"));
+      };
+      if (videoElement.readyState >= READY_STATE_HAVE_CURRENT_DATA2) {
+        if (shouldPlay) {
+          videoElement.play().then(resolve).catch(reject);
+        } else {
+          resolve();
+        }
+        return;
+      }
+      videoElement.addEventListener("loadedmetadata", onLoadedMetadata);
+      videoElement.addEventListener("error", onError);
+      if (!shouldPlay) {
+        videoElement.play().catch(reject);
+      }
+      setTimeout(() => {
+        cleanup();
+        reject(new Error("Timeout waiting for video to load"));
+      }, VIDEO_LOAD_TIMEOUT);
+    });
+  }
+}
+
+// src/core/processor/stream-processor.ts
+var KEY_FRAME_INTERVAL = 5;
+var H264_CODEC = "avc";
+var REALTIME_LATENCY = "realtime";
+
+class StreamProcessor {
+  outputManager;
+  canvasSource = null;
+  offscreenCanvas = null;
+  videoElementManager;
+  canvasRenderer = null;
+  frameCapturer;
+  audioTrackManager;
+  currentVideoStream = null;
+  onSourceChange;
+  constructor() {
+    this.outputManager = new OutputManager;
+    this.videoElementManager = new VideoElementManager;
+    this.frameCapturer = new FrameCapturer;
+    this.audioTrackManager = new AudioTrackManager;
+  }
+  async startProcessing(stream, config) {
+    this.offscreenCanvas = new OffscreenCanvas(config.width, config.height);
+    const ctx = this.offscreenCanvas.getContext("2d", {
+      alpha: false,
+      desynchronized: true,
+      willReadFrequently: false
+    });
+    if (!ctx) {
+      throw new Error("Failed to get OffscreenCanvas context");
+    }
+    this.canvasRenderer = new CanvasRenderer(ctx);
+    this.videoElementManager.create(stream);
+    this.videoElementManager.setActive(true);
+    await this.videoElementManager.waitForReady();
+    this.currentVideoStream = stream;
+    const output = this.outputManager.create();
+    if (typeof config.fps !== "number" || config.fps <= 0) {
+      throw new Error("fps must be a positive number");
+    }
+    const frameRate = config.fps;
+    if (!this.offscreenCanvas) {
+      throw new Error("OffscreenCanvas not initialized");
+    }
+    if (!this.offscreenCanvas) {
+      throw new Error("Cannot create CanvasSource: not initialized");
+    }
+    this.canvasSource = new CanvasSource(this.offscreenCanvas, {
+      codec: H264_CODEC,
+      bitrate: config.bitrate,
+      keyFrameInterval: KEY_FRAME_INTERVAL,
+      latencyMode: REALTIME_LATENCY
+    });
+    output.addVideoTrack(this.canvasSource);
+    const audioSource = await this.audioTrackManager.setupAudioTrack(stream, config);
+    if (audioSource) {
+      output.addAudioTrack(audioSource);
+    }
+    await output.start();
+    if (!this.canvasRenderer) {
+      throw new Error("CanvasRenderer not initialized");
+    }
+    const videoEl = this.videoElementManager.getElement();
+    if (!videoEl) {
+      throw new Error("Video element not available");
+    }
+    if (!this.canvasSource) {
+      throw new Error("CanvasSource not initialized");
+    }
+    this.frameCapturer.start(this.canvasSource, this.canvasRenderer, videoEl, frameRate);
+  }
+  pause() {
+    this.frameCapturer.pause();
+    this.audioTrackManager.pause();
+    this.videoElementManager.pause();
+  }
+  resume() {
+    if (!this.canvasSource) {
+      throw new Error("CanvasSource not initialized - cannot resume");
+    }
+    this.frameCapturer.resume();
+    this.audioTrackManager.resume();
+    this.videoElementManager.resume();
+  }
+  isPausedState() {
+    return this.frameCapturer.isPausedState();
+  }
+  async finalize() {
+    this.frameCapturer.stop();
+    await this.frameCapturer.waitForPendingFrames();
+    this.videoElementManager.cleanup();
+    this.audioTrackManager.cleanup();
+    if (this.canvasSource) {
+      this.canvasSource.close();
+      this.canvasSource = null;
+    }
+    return await this.outputManager.finalize();
+  }
+  toggleMute() {
+    this.audioTrackManager.toggleMute();
+  }
+  isMutedState() {
+    return this.audioTrackManager.isMutedState();
+  }
+  getClonedAudioTrack() {
+    return this.audioTrackManager.getClonedAudioTrack();
+  }
+  getAudioStreamForAnalysis() {
+    return this.audioTrackManager.getAudioStreamForAnalysis();
+  }
+  async switchVideoSource(newStream) {
+    await this.videoElementManager.switchSource(newStream);
+    this.currentVideoStream = newStream;
+    if (this.onSourceChange) {
+      this.onSourceChange(newStream);
+    }
+  }
+  getCurrentVideoSource() {
+    return this.currentVideoStream;
+  }
+  getBufferSize() {
+    return this.outputManager.getTotalSize();
+  }
+  setOnMuteStateChange(callback) {
+    this.audioTrackManager.setOnMuteStateChange(callback);
+  }
+  setOnSourceChange(callback) {
+    this.onSourceChange = callback;
+  }
+  async cancel() {
+    this.frameCapturer.stop();
+    await this.outputManager.cancel();
+    this.videoElementManager.cleanup();
+    this.audioTrackManager.cleanup();
+    if (this.canvasSource) {
+      this.canvasSource.close();
+      this.canvasSource = null;
+    }
+  }
+}
+// src/core/utils/formatters.ts
+var FILE_SIZE_UNITS = ["Bytes", "KB", "MB", "GB"];
+var FILE_SIZE_BASE = 1024;
+function formatFileSize(bytes) {
+  if (bytes === 0) {
+    return "0 Bytes";
+  }
+  const index = Math.floor(Math.log(bytes) / Math.log(FILE_SIZE_BASE));
+  const size = Math.round(bytes / FILE_SIZE_BASE ** index * 100) / 100;
+  return `${size} ${FILE_SIZE_UNITS[index]}`;
+}
+function formatTime(totalSeconds) {
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const secs = totalSeconds % 60;
+  if (hours > 0) {
+    return `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}`;
+  }
+  return `${minutes.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}`;
+}
+
+// src/core/recording/recording-manager.ts
+var DEFAULT_COUNTDOWN_DURATION = 5000;
+var MILLISECONDS_PER_SECOND = 1000;
+var COUNTDOWN_UPDATE_INTERVAL = 100;
+var RECORDING_TIMER_INTERVAL = 1000;
+var RECORDING_STATE_RECORDING = "recording";
+var RECORDING_STATE_IDLE = "idle";
+var RECORDING_STATE_COUNTDOWN = "countdown";
+
+class RecordingManager {
+  recordingState = RECORDING_STATE_IDLE;
+  countdownDuration = DEFAULT_COUNTDOWN_DURATION;
+  countdownRemaining = 0;
+  countdownTimeoutId = null;
+  countdownIntervalId = null;
+  countdownStartTime = null;
+  isPaused = false;
+  maxRecordingTime = null;
+  maxTimeTimer = null;
+  recordingSeconds = 0;
+  recordingIntervalId = null;
+  pauseStartTime = null;
+  totalPausedTime = 0;
+  streamManager;
+  callbacks;
+  streamProcessor = null;
+  originalCameraStream = null;
+  constructor(streamManager, callbacks) {
+    this.streamManager = streamManager;
+    this.callbacks = callbacks;
+  }
+  setCountdownDuration(duration) {
+    this.countdownDuration = duration;
+  }
+  setMaxRecordingTime(maxTime) {
+    this.maxRecordingTime = maxTime;
+  }
+  getRecordingState() {
+    return this.recordingState;
+  }
+  isPausedState() {
+    return this.isPaused;
+  }
+  getRecordingSeconds() {
+    return this.recordingSeconds;
+  }
+  getStreamProcessor() {
+    return this.streamProcessor;
+  }
+  setOriginalCameraStream(stream) {
+    this.originalCameraStream = stream;
+  }
+  getOriginalCameraStream() {
+    return this.originalCameraStream;
+  }
+  async startRecording() {
+    try {
+      this.callbacks.onClearUploadStatus();
+      if (this.countdownDuration > 0) {
+        this.startCountdown();
+      } else {
+        await this.doStartRecording();
+      }
+    } catch (error) {
+      this.handleError(error);
+      this.recordingState = RECORDING_STATE_IDLE;
+      this.cancelCountdown();
+    }
+  }
+  startCountdown() {
+    this.recordingState = RECORDING_STATE_COUNTDOWN;
+    this.countdownRemaining = Math.ceil(this.countdownDuration / MILLISECONDS_PER_SECOND);
+    this.countdownStartTime = Date.now();
+    this.callbacks.onCountdownUpdate(this.recordingState, this.countdownRemaining);
+    this.countdownIntervalId = window.setInterval(() => {
+      if (!this.countdownStartTime) {
+        return;
+      }
+      const elapsed = Date.now() - this.countdownStartTime;
+      const remaining = Math.max(0, Math.ceil((this.countdownDuration - elapsed) / MILLISECONDS_PER_SECOND));
+      this.countdownRemaining = remaining;
+      this.callbacks.onCountdownUpdate(this.recordingState, this.countdownRemaining);
+    }, COUNTDOWN_UPDATE_INTERVAL);
+    this.countdownTimeoutId = window.setTimeout(async () => {
+      await this.doStartRecording();
+    }, this.countdownDuration);
+  }
+  async doStartRecording() {
+    try {
+      this.cancelCountdown();
+      this.recordingState = RECORDING_STATE_RECORDING;
+      this.callbacks.onStateChange(this.recordingState);
+      this.resetRecordingState();
+      const currentStream = this.streamManager.getStream();
+      if (!currentStream) {
+        throw new Error("No stream available for recording");
+      }
+      this.originalCameraStream = currentStream;
+      this.streamProcessor = new StreamProcessor;
+      const config = await this.callbacks.onGetConfig();
+      await this.streamManager.startRecording(this.streamProcessor, config);
+      this.startRecordingTimer();
+      if (this.maxRecordingTime && this.maxRecordingTime > 0) {
+        this.maxTimeTimer = window.setTimeout(async () => {
+          if (this.recordingState === RECORDING_STATE_RECORDING) {
+            await this.stopRecording();
+          }
+        }, this.maxRecordingTime);
+      }
+    } catch (error) {
+      this.handleError(error);
+      this.recordingState = RECORDING_STATE_IDLE;
+      this.callbacks.onStateChange(this.recordingState);
+    }
+  }
+  async stopRecording() {
+    try {
+      this.cancelCountdown();
+      this.clearTimer(this.recordingIntervalId, clearInterval);
+      this.recordingIntervalId = null;
+      this.clearTimer(this.maxTimeTimer, clearTimeout);
+      this.maxTimeTimer = null;
+      this.resetPauseState();
+      this.callbacks.onStopAudioTracking();
+      const blob = await this.streamManager.stopRecording();
+      this.recordingState = RECORDING_STATE_IDLE;
+      this.callbacks.onStateChange(this.recordingState);
+      this.recordingSeconds = 0;
+      this.streamProcessor = null;
+      this.callbacks.onRecordingComplete(blob);
+      return blob;
+    } catch (error) {
+      this.handleError(error);
+      this.recordingState = RECORDING_STATE_IDLE;
+      this.callbacks.onStateChange(this.recordingState);
+      throw error;
+    }
+  }
+  pauseRecording() {
+    if (this.recordingState !== RECORDING_STATE_RECORDING || this.isPaused) {
+      return;
+    }
+    this.streamManager.pauseRecording();
+    this.isPaused = true;
+    this.clearTimer(this.recordingIntervalId, clearInterval);
+    this.recordingIntervalId = null;
+    this.pauseStartTime = Date.now();
+  }
+  resumeRecording() {
+    if (this.recordingState !== RECORDING_STATE_RECORDING || !this.isPaused) {
+      return;
+    }
+    this.streamManager.resumeRecording();
+    this.isPaused = false;
+    this.updatePausedDuration();
+    this.startRecordingTimer();
+  }
+  cancelCountdown() {
+    this.clearTimer(this.countdownTimeoutId, clearTimeout);
+    this.countdownTimeoutId = null;
+    this.clearTimer(this.countdownIntervalId, clearInterval);
+    this.countdownIntervalId = null;
+    this.recordingState = RECORDING_STATE_IDLE;
+    this.countdownRemaining = 0;
+    this.countdownStartTime = null;
+    this.callbacks.onCountdownUpdate(this.recordingState, this.countdownRemaining);
+  }
+  cleanup() {
+    this.cancelCountdown();
+    this.clearTimer(this.recordingIntervalId, clearInterval);
+    this.recordingIntervalId = null;
+    this.clearTimer(this.maxTimeTimer, clearTimeout);
+    this.maxTimeTimer = null;
+  }
+  resetRecordingState() {
+    this.isPaused = false;
+    this.recordingSeconds = 0;
+    this.totalPausedTime = 0;
+    this.pauseStartTime = null;
+  }
+  resetPauseState() {
+    this.isPaused = false;
+    this.pauseStartTime = null;
+    this.totalPausedTime = 0;
+  }
+  updatePausedDuration() {
+    if (this.pauseStartTime === null) {
+      throw new Error("Pause start time not set");
+    }
+    const pausedDuration = Date.now() - this.pauseStartTime;
+    this.totalPausedTime += pausedDuration;
+    this.pauseStartTime = null;
+  }
+  startRecordingTimer() {
+    if (this.recordingIntervalId !== null) {
+      return;
+    }
+    this.recordingIntervalId = window.setInterval(() => {
+      this.recordingSeconds += 1;
+      this.callbacks.onTimerUpdate(formatTime(this.recordingSeconds));
+    }, RECORDING_TIMER_INTERVAL);
+  }
+  clearTimer(timerId, clearFn) {
+    if (timerId !== null) {
+      clearFn(timerId);
+    }
+  }
+  handleError(error) {
+    const errorMessage = error instanceof Error ? error : new Error(extractErrorMessage(error));
+    this.callbacks.onError(errorMessage);
+  }
+}
+
+// src/core/upload/upload-queue-manager.ts
+var MAX_RETRIES = 10;
+var INITIAL_RETRY_DELAY = 2000;
+var MAX_RETRY_DELAY = 300000;
+var RETRY_MULTIPLIER = 1.5;
+var PROCESSING_INTERVAL = 5000;
+
+class UploadQueueManager {
+  storageService;
+  uploadService;
+  processingIntervalId;
+  networkOnlineHandler;
+  isProcessing = false;
+  retryTimeoutId = null;
+  callbacks = {};
+  constructor(storageService, uploadService) {
+    this.storageService = storageService;
+    this.uploadService = uploadService;
+    this.networkOnlineHandler = () => {
+      this.processQueue().catch((error) => {
+        const errorMessage = extractErrorMessage(error);
+        this.callbacks.onUploadError?.("network-recovery", new Error(errorMessage));
+      });
+    };
+    window.addEventListener("online", this.networkOnlineHandler);
+    this.processingIntervalId = window.setInterval(() => {
+      this.processQueue().catch((error) => {
+        const errorMessage = extractErrorMessage(error);
+        this.callbacks.onUploadError?.("processing-loop", new Error(errorMessage));
+      });
+    }, PROCESSING_INTERVAL);
+  }
+  destroy() {
+    this.clearTimer(this.processingIntervalId, clearInterval);
+    this.clearTimer(this.retryTimeoutId, clearTimeout);
+    window.removeEventListener("online", this.networkOnlineHandler);
+  }
+  setCallbacks(callbacks) {
+    this.callbacks = callbacks;
+  }
+  async queueUpload(upload) {
+    const id = await this.storageService.savePendingUpload(upload);
+    this.processQueue();
+    return id;
+  }
+  async processQueue() {
+    if (this.isProcessing) {
+      return;
+    }
+    this.isProcessing = true;
+    try {
+      if (!this.storageService.isInitialized()) {
+        throw new Error("Database not initialized");
+      }
+      const pendingUploads = await this.storageService.getPendingUploads("pending");
+      if (pendingUploads.length > 0) {
+        const upload = this.getOldestUpload(pendingUploads);
+        await this.processUpload(upload);
+        this.isProcessing = false;
+        return;
+      }
+      const failedUploads = await this.storageService.getPendingUploads("failed");
+      const retryableUploads = failedUploads.filter((upload) => upload.retryCount < MAX_RETRIES);
+      if (retryableUploads.length > 0) {
+        const upload = this.getOldestFailedUpload(retryableUploads);
+        const delay = this.calculateRetryDelay(upload.retryCount);
+        const timeSinceLastAttempt = Date.now() - upload.updatedAt;
+        if (timeSinceLastAttempt >= delay) {
+          await this.storageService.updateUploadStatus(upload.id, {
+            status: "pending",
+            retryCount: upload.retryCount
+          });
+          await this.processUpload(upload);
+        } else {
+          const remainingDelay = delay - timeSinceLastAttempt;
+          this.scheduleRetry(remainingDelay);
+        }
+      }
+      this.isProcessing = false;
+    } catch (error) {
+      this.isProcessing = false;
+      throw new Error(`Error processing upload queue: ${extractErrorMessage(error)}`);
+    }
+  }
+  getPendingUploads() {
+    return this.storageService.getPendingUploads();
+  }
+  async getStats() {
+    const all = await this.storageService.getPendingUploads();
+    const stats = {
+      pending: 0,
+      uploading: 0,
+      failed: 0,
+      total: all.length
+    };
+    for (const upload of all) {
+      if (upload.status === "pending") {
+        stats.pending += 1;
+      } else if (upload.status === "uploading") {
+        stats.uploading += 1;
+      } else if (upload.status === "failed") {
+        stats.failed += 1;
+      }
+    }
+    return stats;
+  }
+  getOldestUpload(uploads) {
+    if (uploads.length === 0) {
+      throw new Error("Cannot get oldest upload from empty array");
+    }
+    return uploads.sort((a, b) => a.createdAt - b.createdAt)[0];
+  }
+  getOldestFailedUpload(uploads) {
+    if (uploads.length === 0) {
+      throw new Error("Cannot get oldest failed upload from empty array");
+    }
+    return uploads.sort((a, b) => a.updatedAt - b.updatedAt)[0];
+  }
+  async processUpload(upload) {
+    try {
+      await this.storageService.updateUploadStatus(upload.id, {
+        status: "uploading"
+      });
+      const result = await this.uploadService.uploadVideo(upload.blob, {
+        apiKey: upload.apiKey,
+        backendUrl: upload.backendUrl,
+        filename: upload.filename,
+        duration: upload.duration,
+        metadata: upload.metadata,
+        userMetadata: upload.userMetadata,
+        onProgress: (progress) => {
+          this.callbacks.onUploadProgress?.(upload.id, progress);
+        }
+      });
+      await this.storageService.deleteUpload(upload.id);
+      this.callbacks.onUploadComplete?.(upload.id, result);
+    } catch (error) {
+      const errorMessage = extractErrorMessage(error);
+      const retryCount = upload.retryCount + 1;
+      await this.storageService.updateUploadStatus(upload.id, {
+        status: "failed",
+        retryCount,
+        lastError: errorMessage
+      });
+      if (retryCount >= MAX_RETRIES) {
+        this.callbacks.onUploadError?.(upload.id, new Error(`Upload failed after ${MAX_RETRIES} attempts: ${errorMessage}`));
+      } else {
+        const delay = this.calculateRetryDelay(retryCount);
+        this.scheduleRetry(delay);
+      }
+    }
+  }
+  calculateRetryDelay(retryCount) {
+    const delay = INITIAL_RETRY_DELAY * RETRY_MULTIPLIER ** (retryCount - 1);
+    return Math.min(delay, MAX_RETRY_DELAY);
+  }
+  scheduleRetry(delay) {
+    this.clearTimer(this.retryTimeoutId, clearTimeout);
+    this.retryTimeoutId = window.setTimeout(() => {
+      this.retryTimeoutId = null;
+      this.processQueue();
+    }, delay);
+  }
+  clearTimer(timerId, clearFn) {
+    if (timerId !== null) {
+      clearFn(timerId);
+    }
+  }
+}
+
+// src/core/storage/video-storage.ts
+var DB_NAME = "vidtreo-recorder";
+var DB_VERSION = 1;
+var STORE_NAME = "pending-uploads";
+var STATUS_INDEX = "status";
+var CREATED_AT_INDEX = "createdAt";
+var DEFAULT_RETENTION_HOURS = 24;
+var MAX_RETRIES2 = 10;
+var MILLISECONDS_PER_HOUR = 60 * 60 * 1000;
+var ID_PREFIX = "upload-";
+var ID_RANDOM_LENGTH = 9;
+
+class VideoStorageService {
+  db = null;
+  init() {
+    if (this.db) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(DB_NAME, DB_VERSION);
+      request.onerror = () => {
+        if (request.error) {
+          reject(request.error);
+        } else {
+          reject(new Error("Failed to open database"));
+        }
+      };
+      request.onsuccess = () => {
+        if (!request.result) {
+          reject(new Error("Database result is null"));
+          return;
+        }
+        this.db = request.result;
+        resolve();
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db) {
+          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
+          });
+        }
+      };
+    });
+  }
+  isInitialized() {
+    return this.db !== null;
+  }
+  savePendingUpload(upload) {
+    const id = this.generateUploadId();
+    const pendingUpload = {
+      ...upload,
+      id,
+      status: "pending",
+      retryCount: 0,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    return this.executeTransaction("readwrite", (store) => {
+      const request = store.add(pendingUpload);
+      return new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve(id);
+        request.onerror = () => {
+          if (request.error) {
+            if (request.error.name === "QuotaExceededError") {
+              reject(new Error("Storage quota exceeded. Please free up space or delete old uploads."));
+            } else {
+              reject(request.error);
+            }
+          } else {
+            reject(new Error("Failed to save upload"));
+          }
+        };
+      });
+    });
+  }
+  getPendingUploads(status) {
+    return this.executeTransaction("readonly", (store) => {
+      const request = status ? store.index(STATUS_INDEX).getAll(status) : store.getAll();
+      return new Promise((resolve, reject) => {
+        request.onsuccess = () => {
+          if (request.result === undefined) {
+            reject(new Error("Failed to get uploads: result is undefined"));
+            return;
+          }
+          resolve(request.result);
+        };
+        request.onerror = () => {
+          if (request.error) {
+            reject(request.error);
+          } else {
+            reject(new Error("Failed to get uploads"));
+          }
+        };
+      });
+    });
+  }
+  updateUploadStatus(id, updates) {
+    return this.executeTransaction("readwrite", (store) => {
+      const getRequest = store.get(id);
+      return new Promise((resolve, reject) => {
+        getRequest.onsuccess = () => {
+          const upload = getRequest.result;
+          if (!upload) {
+            reject(new Error("Upload not found"));
+            return;
+          }
+          const updated = { ...upload, ...updates, updatedAt: Date.now() };
+          const putRequest = store.put(updated);
+          putRequest.onsuccess = () => resolve();
+          putRequest.onerror = () => {
+            if (putRequest.error) {
+              reject(putRequest.error);
+            } else {
+              reject(new Error("Failed to update upload"));
+            }
+          };
+        };
+        getRequest.onerror = () => {
+          if (getRequest.error) {
+            reject(getRequest.error);
+          } else {
+            reject(new Error("Failed to get upload"));
+          }
+        };
+      });
+    });
+  }
+  deleteUpload(id) {
+    return this.executeTransaction("readwrite", (store) => {
+      const request = store.delete(id);
+      return new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve();
+        request.onerror = () => {
+          if (request.error) {
+            reject(request.error);
+          } else {
+            reject(new Error("Failed to delete upload"));
+          }
+        };
+      });
+    });
+  }
+  async cleanupPermanentlyFailedUploads(retentionHours) {
+    const actualRetentionHours = retentionHours !== undefined ? retentionHours : DEFAULT_RETENTION_HOURS;
+    if (typeof actualRetentionHours !== "number" || actualRetentionHours < 0) {
+      throw new Error("retentionHours must be a non-negative number");
+    }
+    const cutoffTime = Date.now() - actualRetentionHours * MILLISECONDS_PER_HOUR;
+    const allUploads = await this.getPendingUploads();
+    const toDelete = allUploads.filter((upload) => upload.status === "failed" && upload.retryCount >= MAX_RETRIES2 && upload.updatedAt < cutoffTime);
+    for (const upload of toDelete) {
+      await this.deleteUpload(upload.id);
+    }
+    return toDelete.length;
+  }
+  async getTotalStorageSize() {
+    const uploads = await this.getPendingUploads();
+    return uploads.reduce((total, upload) => total + upload.blob.size, 0);
+  }
+  generateUploadId() {
+    return `${ID_PREFIX}${Date.now()}-${Math.random().toString(36).substring(2, 2 + ID_RANDOM_LENGTH)}`;
+  }
+  executeTransaction(mode, operation) {
+    if (!this.db) {
+      throw new Error("Database not initialized");
+    }
+    const transaction = this.db.transaction([STORE_NAME], mode);
+    const store = transaction.objectStore(STORE_NAME);
+    return operation(store);
+  }
+}
+
+// src/core/storage/storage-manager.ts
+var CLEANUP_INTERVAL = 60 * 60 * 1000;
+var CLEANUP_HOURS = 24;
+
+class StorageManager {
+  storageService = null;
+  uploadQueueManager = null;
+  cleanupIntervalId = null;
+  async initialize(uploadService, callbacks, onCleanupError) {
+    if (!this.storageService) {
+      this.storageService = new VideoStorageService;
+    }
+    if (!this.storageService.isInitialized()) {
+      await this.storageService.init();
+    }
+    if (!uploadService) {
+      return;
+    }
+    if (this.uploadQueueManager) {
+      this.uploadQueueManager.setCallbacks(callbacks);
+      if (this.cleanupIntervalId === null) {
+        this.cleanupIntervalId = window.setInterval(() => {
+          this.performCleanup().catch((error) => {
+            onCleanupError(extractErrorMessage(error));
+          });
+        }, CLEANUP_INTERVAL);
+      }
+      return;
+    }
+    this.uploadQueueManager = new UploadQueueManager(this.storageService, uploadService);
+    this.uploadQueueManager.setCallbacks(callbacks);
+    if (this.cleanupIntervalId === null) {
+      this.cleanupIntervalId = window.setInterval(() => {
+        this.performCleanup().catch((error) => {
+          onCleanupError(extractErrorMessage(error));
+        });
+      }, CLEANUP_INTERVAL);
+    }
+  }
+  async checkPendingUploads() {
+    if (!this.uploadQueueManager) {
+      throw new Error("UploadQueueManager not initialized");
+    }
+    return await this.uploadQueueManager.getStats();
+  }
+  async performCleanup() {
+    if (!this.storageService) {
+      throw new Error("StorageService not initialized");
+    }
+    await this.storageService.cleanupPermanentlyFailedUploads(CLEANUP_HOURS);
+  }
+  getUploadQueueManager() {
+    return this.uploadQueueManager;
+  }
+  getStorageService() {
+    return this.storageService;
+  }
+  destroy() {
+    if (this.uploadQueueManager) {
+      this.uploadQueueManager.destroy();
+      this.uploadQueueManager = null;
+    }
+    if (this.cleanupIntervalId !== null) {
+      clearInterval(this.cleanupIntervalId);
+      this.cleanupIntervalId = null;
+    }
+  }
+}
+
+// src/core/stream/source-switch.ts
+var SCREEN_SHARE_TRANSITION_DELAY = 100;
+var TRACK_READY_STATE_LIVE = "live";
+
+class SourceSwitchManager {
+  currentSourceType = "camera";
+  originalCameraStream = null;
+  originalCameraConstraints = null;
+  screenShareStream = null;
+  screenShareTrackEndHandler = null;
+  streamManager;
+  callbacks;
+  constructor(streamManager, callbacks = {}) {
+    this.streamManager = streamManager;
+    this.callbacks = callbacks;
+  }
+  getCurrentSourceType() {
+    return this.currentSourceType;
+  }
+  getOriginalCameraStream() {
+    return this.originalCameraStream;
+  }
+  stopStreamTracks(stream) {
+    const tracks = stream.getTracks();
+    for (const track of tracks) {
+      if (track.readyState === TRACK_READY_STATE_LIVE) {
+        track.stop();
+      }
+    }
+  }
+  isTrackLive(track) {
+    return track !== undefined && track.readyState === TRACK_READY_STATE_LIVE;
+  }
+  areTracksLive(videoTrack, audioTrack) {
+    return this.isTrackLive(videoTrack) && this.isTrackLive(audioTrack);
+  }
+  storeOriginalCameraConstraints(stream) {
+    const videoTrack = stream.getVideoTracks()[0];
+    if (!videoTrack) {
+      return;
+    }
+    const settings = videoTrack.getSettings();
+    this.originalCameraConstraints = {
+      width: settings.width,
+      height: settings.height,
+      aspectRatio: settings.aspectRatio,
+      frameRate: settings.frameRate,
+      deviceId: settings.deviceId,
+      facingMode: settings.facingMode
+    };
+  }
+  storeOriginalCameraStream(stream) {
+    const videoTrack = stream.getVideoTracks()[0];
+    const audioTrack = stream.getAudioTracks()[0];
+    if (this.areTracksLive(videoTrack, audioTrack)) {
+      this.originalCameraStream = new MediaStream([videoTrack, audioTrack]);
+    } else {
+      this.originalCameraStream = stream;
+    }
+  }
+  createError(error) {
+    if (error instanceof Error) {
+      return error;
+    }
+    return new Error(extractErrorMessage(error));
+  }
+  waitForTracksToEnd(delay) {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        this.screenShareStream = null;
+        resolve();
+      }, delay);
+    });
+  }
+  async switchToScreenCapture() {
+    const currentStream = this.streamManager.getStream();
+    if (currentStream) {
+      this.storeOriginalCameraConstraints(currentStream);
+      this.storeOriginalCameraStream(currentStream);
+    }
+    if (this.callbacks.onTransitionStart) {
+      this.callbacks.onTransitionStart("Select screen to share...");
+    }
+    try {
+      const newStream = await navigator.mediaDevices.getDisplayMedia({
+        video: true,
+        audio: true
+      });
+      this.screenShareStream = newStream;
+      if (currentStream && currentStream !== this.originalCameraStream) {
+        this.stopStreamTracks(currentStream);
+      }
+      this.currentSourceType = "screen";
+      if (this.callbacks.onSourceChange) {
+        this.callbacks.onSourceChange(this.currentSourceType);
+      }
+      this.setupScreenShareTrackHandler(newStream);
+      return newStream;
+    } catch (error) {
+      if (this.callbacks.onTransitionEnd) {
+        this.callbacks.onTransitionEnd();
+      }
+      throw error;
+    }
+  }
+  setupScreenShareTrackHandler(newStream) {
+    const videoTrack = newStream.getVideoTracks()[0];
+    if (!videoTrack) {
+      throw new Error("No video track found in screen share stream");
+    }
+    const handler = this.screenShareTrackEndHandler;
+    if (handler) {
+      const oldStream = this.streamManager.getStream();
+      if (oldStream) {
+        const oldVideoTrack = oldStream.getVideoTracks()[0];
+        if (oldVideoTrack) {
+          oldVideoTrack.removeEventListener("ended", handler);
+        }
+      }
+    }
+    this.screenShareTrackEndHandler = async () => {
+      if (this.currentSourceType === "screen") {
+        try {
+          await this.switchToCamera();
+        } catch (error) {
+          if (this.callbacks.onError) {
+            this.callbacks.onError(this.createError(error));
+          }
+        }
+      }
+    };
+    videoTrack.addEventListener("ended", this.screenShareTrackEndHandler);
+  }
+  removeScreenShareTrackHandler(stream) {
+    if (!(this.screenShareTrackEndHandler && stream)) {
+      return;
+    }
+    const videoTrack = stream.getVideoTracks()[0];
+    if (videoTrack) {
+      videoTrack.removeEventListener("ended", this.screenShareTrackEndHandler);
+    }
+    this.screenShareTrackEndHandler = null;
+  }
+  canReuseOriginalStream() {
+    if (!this.originalCameraStream) {
+      return false;
+    }
+    const videoTrack = this.originalCameraStream.getVideoTracks()[0];
+    const audioTrack = this.originalCameraStream.getAudioTracks()[0];
+    return this.areTracksLive(videoTrack, audioTrack);
+  }
+  canReuseManagerStream() {
+    const managerStream = this.streamManager.getStream();
+    if (!(managerStream && this.originalCameraStream) || managerStream !== this.originalCameraStream) {
+      return false;
+    }
+    const videoTrack = managerStream.getVideoTracks()[0];
+    const audioTrack = managerStream.getAudioTracks()[0];
+    return this.areTracksLive(videoTrack, audioTrack);
+  }
+  buildVideoConstraints(cameraDeviceId) {
+    const constraints = {};
+    if (cameraDeviceId) {
+      constraints.deviceId = { exact: cameraDeviceId };
+    }
+    if (this.originalCameraConstraints) {
+      Object.assign(constraints, this.originalCameraConstraints);
+    }
+    return constraints;
+  }
+  buildAudioConstraints(micDeviceId) {
+    if (micDeviceId) {
+      return { deviceId: { exact: micDeviceId } };
+    }
+    return true;
+  }
+  async createNewCameraStreamForRecording() {
+    const cameraDeviceId = this.callbacks.getSelectedCameraDeviceId ? this.callbacks.getSelectedCameraDeviceId() : null;
+    const micDeviceId = this.callbacks.getSelectedMicDeviceId ? this.callbacks.getSelectedMicDeviceId() : null;
+    const videoConstraints = this.buildVideoConstraints(cameraDeviceId);
+    const audioConstraints = this.buildAudioConstraints(micDeviceId);
+    const constraints = {
+      video: Object.keys(videoConstraints).length > 0 ? videoConstraints : true,
+      audio: audioConstraints
+    };
+    const newStream = await navigator.mediaDevices.getUserMedia(constraints);
+    const videoTrack = newStream.getVideoTracks()[0];
+    const audioTrack = newStream.getAudioTracks()[0];
+    if (!this.isTrackLive(videoTrack)) {
+      this.stopStreamTracks(newStream);
+      const readyState = videoTrack ? videoTrack.readyState : "undefined";
+      throw new Error(`Failed to get live camera video track. ReadyState: ${readyState}`);
+    }
+    if (!this.isTrackLive(audioTrack)) {
+      this.stopStreamTracks(newStream);
+      const readyState = audioTrack ? audioTrack.readyState : "undefined";
+      throw new Error(`Failed to get live camera audio track. ReadyState: ${readyState}`);
+    }
+    this.originalCameraStream = newStream;
+    return newStream;
+  }
+  async getCameraStream() {
+    const isRecording = this.streamManager.isRecording();
+    if (this.canReuseOriginalStream()) {
+      const stream = this.originalCameraStream;
+      if (!stream) {
+        throw new Error("Original camera stream is null");
+      }
+      return stream;
+    }
+    if (this.canReuseManagerStream()) {
+      const stream = this.streamManager.getStream();
+      if (!stream) {
+        throw new Error("Manager stream is null");
+      }
+      return stream;
+    }
+    if (this.originalCameraStream) {
+      this.originalCameraStream = null;
+    }
+    const managerStream = this.streamManager.getStream();
+    if (!isRecording && managerStream && managerStream !== this.originalCameraStream) {
+      this.stopStreamTracks(managerStream);
+      this.streamManager.setMediaStream(null);
+    }
+    if (this.callbacks.getSelectedCameraDeviceId) {
+      const cameraDeviceId = this.callbacks.getSelectedCameraDeviceId();
+      this.streamManager.setVideoDevice(cameraDeviceId);
+    }
+    if (this.callbacks.getSelectedMicDeviceId) {
+      const micDeviceId = this.callbacks.getSelectedMicDeviceId();
+      this.streamManager.setAudioDevice(micDeviceId);
+    }
+    if (isRecording) {
+      return this.createNewCameraStreamForRecording();
+    }
+    const newStream = await this.streamManager.startStream();
+    this.originalCameraStream = newStream;
+    return newStream;
+  }
+  async switchToCamera() {
+    const isRecording = this.streamManager.isRecording();
+    if (!isRecording && this.currentSourceType === "camera") {
+      return;
+    }
+    try {
+      this.notifyTransitionStart("Switching to camera...");
+      await this.handleScreenShareStop();
+      const newStream = await this.getCameraStream();
+      if (!newStream) {
+        throw new Error("Failed to get camera stream");
+      }
+      await this.applyCameraStream(newStream, isRecording);
+      this.notifyTransitionEnd();
+    } catch (error) {
+      this.notifyTransitionEnd();
+      throw error;
+    }
+  }
+  notifyTransitionStart(message) {
+    if (this.callbacks.onTransitionStart) {
+      this.callbacks.onTransitionStart(message);
+    }
+  }
+  notifyTransitionEnd() {
+    if (this.callbacks.onTransitionEnd) {
+      this.callbacks.onTransitionEnd();
+    }
+  }
+  async handleScreenShareStop() {
+    if (this.currentSourceType !== "screen") {
+      return;
+    }
+    const screenShareStreamToStop = this.screenShareStream;
+    const currentStream = this.streamManager.getStream();
+    if (screenShareStreamToStop) {
+      this.removeScreenShareTrackHandler(screenShareStreamToStop);
+      this.stopStreamTracks(screenShareStreamToStop);
+      await this.waitForTracksToEnd(SCREEN_SHARE_TRANSITION_DELAY);
+    }
+    if (currentStream && (!screenShareStreamToStop || currentStream.id !== screenShareStreamToStop.id)) {
+      this.stopStreamTracks(currentStream);
+    }
+  }
+  async applyCameraStream(newStream, isRecording) {
+    this.streamManager.setMediaStream(newStream);
+    this.currentSourceType = "camera";
+    if (this.callbacks.onSourceChange) {
+      this.callbacks.onSourceChange(this.currentSourceType);
+    }
+    if (isRecording) {
+      await this.streamManager.switchVideoSource(newStream);
+    }
+    if (this.callbacks.onPreviewUpdate) {
+      await this.callbacks.onPreviewUpdate(newStream);
+    }
+  }
+  async toggleSource() {
+    const isRecording = this.streamManager.isRecording();
+    if (!isRecording) {
+      return;
+    }
+    try {
+      if (this.currentSourceType === "camera") {
+        await this.switchToScreen();
+      } else {
+        await this.switchToCamera();
+      }
+    } catch (error) {
+      this.handleToggleError(error);
+    }
+  }
+  async switchToScreen() {
+    const newStream = await this.switchToScreenCapture();
+    this.notifyTransitionStart("Switching to screen...");
+    await this.streamManager.switchVideoSource(newStream);
+    if (this.callbacks.onPreviewUpdate) {
+      await this.callbacks.onPreviewUpdate(newStream);
+    }
+    this.notifyTransitionEnd();
+  }
+  handleToggleError(error) {
+    this.notifyTransitionEnd();
+    const errorMessage = extractErrorMessage(error);
+    if (errorMessage.includes("NotAllowedError") || errorMessage.includes("AbortError")) {
+      if (this.currentSourceType === "screen") {
+        this.switchToCamera().catch((switchError) => {
+          if (this.callbacks.onError) {
+            this.callbacks.onError(this.createError(switchError));
+          }
+        });
+      }
+    } else if (this.callbacks.onError) {
+      this.callbacks.onError(this.createError(error));
+    }
+  }
+  async handleRecordingStop() {
+    if (this.currentSourceType !== "screen") {
+      this.cleanup();
+      return;
+    }
+    try {
+      const currentStream = this.streamManager.getStream();
+      if (currentStream) {
+        this.removeScreenShareTrackHandler(currentStream);
+        this.stopStreamTracks(currentStream);
+      }
+      const newStream = await this.getCameraStream();
+      if (!newStream) {
+        throw new Error("Failed to get camera stream");
+      }
+      this.streamManager.setMediaStream(newStream);
+      this.currentSourceType = "camera";
+      if (this.callbacks.onSourceChange) {
+        this.callbacks.onSourceChange(this.currentSourceType);
+      }
+      if (this.callbacks.onPreviewUpdate) {
+        await this.callbacks.onPreviewUpdate(newStream);
+      }
+    } catch (error) {
+      if (this.callbacks.onError) {
+        this.callbacks.onError(this.createError(error));
+      }
+      throw error;
+    }
+    this.cleanup();
+  }
+  cleanup() {
+    if (this.screenShareStream) {
+      this.removeScreenShareTrackHandler(this.screenShareStream);
+      this.stopStreamTracks(this.screenShareStream);
+      this.screenShareStream = null;
+    }
+    const currentStream = this.streamManager.getStream();
+    if (currentStream) {
+      this.removeScreenShareTrackHandler(currentStream);
+    }
+    this.screenShareTrackEndHandler = null;
+    this.originalCameraStream = null;
+    this.originalCameraConstraints = null;
+  }
+  setCallbacks(callbacks) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+  }
+}
+
+// src/core/stream/config.ts
+var DEFAULT_CAMERA_CONSTRAINTS = Object.freeze({
+  width: { ideal: DEFAULT_TRANSCODE_CONFIG.width },
+  height: { ideal: DEFAULT_TRANSCODE_CONFIG.height },
+  frameRate: { ideal: DEFAULT_TRANSCODE_CONFIG.fps }
+});
+var DEFAULT_STREAM_CONFIG = Object.freeze({
+  video: DEFAULT_CAMERA_CONSTRAINTS,
+  audio: true
+});
+var DEFAULT_RECORDING_OPTIONS = Object.freeze({
+  mimeType: "video/webm;codecs=vp9,opus"
+});
+
+// src/core/stream/stream.ts
+var TIMER_INTERVAL = 1000;
+var SECONDS_PER_MINUTE = 60;
+var MILLISECONDS_PER_SECOND2 = 1000;
+var TRACK_READY_STATE_LIVE2 = "live";
+var MEDIA_RECORDER_STATE_RECORDING = "recording";
+var MEDIA_RECORDER_STATE_PAUSED = "paused";
+
+class CameraStreamManager {
+  mediaStream = null;
+  mediaRecorder = null;
+  recordedChunks = [];
+  recordedMimeType = null;
+  state = "idle";
+  recordingStartTime = 0;
+  recordingTimer = null;
+  pauseStartTime = null;
+  totalPausedTime = 0;
+  eventListeners = new Map;
+  streamConfig;
+  recordingOptions;
+  streamProcessor = null;
+  bufferSizeUpdateInterval = null;
+  selectedAudioDeviceId = null;
+  selectedVideoDeviceId = null;
+  constructor(streamConfig = {}, recordingOptions = {}) {
+    this.streamConfig = { ...DEFAULT_STREAM_CONFIG, ...streamConfig };
+    this.recordingOptions = {
+      ...DEFAULT_RECORDING_OPTIONS,
+      ...recordingOptions
+    };
+  }
+  getState() {
+    return this.state;
+  }
+  getStream() {
+    return this.mediaStream;
+  }
+  getAudioStreamForAnalysis() {
+    if (this.streamProcessor) {
+      const audioStream = this.streamProcessor.getAudioStreamForAnalysis();
+      if (audioStream) {
+        return audioStream;
+      }
+    }
+    if (this.mediaStream && this.mediaStream.getAudioTracks().length > 0) {
+      return this.mediaStream;
+    }
+    return null;
+  }
+  getRecorder() {
+    return this.mediaRecorder;
+  }
+  isRecording() {
+    return this.state === "recording";
+  }
+  isActive() {
+    return this.state === "active" || this.state === "recording";
+  }
+  on(event, listener) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, new Set);
+    }
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.add(listener);
+    }
+    return () => {
+      this.off(event, listener);
+    };
+  }
+  off(event, listener) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+    }
+  }
+  once(event, listener) {
+    const wrappedListener = (data) => {
+      listener(data);
+      this.off(event, wrappedListener);
+    };
+    return this.on(event, wrappedListener);
+  }
+  emit(event, data) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(data);
+        } catch {}
+      }
+    }
+  }
+  setState(newState) {
+    if (this.state === newState) {
+      return;
+    }
+    const previousState = this.state;
+    this.state = newState;
+    this.emit("statechange", { state: newState, previousState });
+  }
+  setAudioDevice(deviceId) {
+    this.selectedAudioDeviceId = deviceId;
+  }
+  setVideoDevice(deviceId) {
+    this.selectedVideoDeviceId = deviceId;
+  }
+  getAudioDevice() {
+    return this.selectedAudioDeviceId;
+  }
+  getVideoDevice() {
+    return this.selectedVideoDeviceId;
+  }
+  async getAvailableDevices() {
+    try {
+      const devices = await navigator.mediaDevices.enumerateDevices();
+      return {
+        audioinput: devices.filter((d) => d.kind === "audioinput"),
+        videoinput: devices.filter((d) => d.kind === "videoinput")
+      };
+    } catch (error) {
+      throw new Error(`Failed to enumerate devices: ${extractErrorMessage(error)}`);
+    }
+  }
+  buildVideoConstraints(deviceId) {
+    if (!deviceId) {
+      return this.streamConfig.video;
+    }
+    if (typeof this.streamConfig.video === "object") {
+      return {
+        ...this.streamConfig.video,
+        deviceId: { exact: deviceId }
+      };
+    }
+    return {
+      deviceId: { exact: deviceId }
+    };
+  }
+  buildAudioConstraints(deviceId) {
+    if (!deviceId) {
+      return this.streamConfig.audio;
+    }
+    if (typeof this.streamConfig.audio === "object") {
+      return {
+        ...this.streamConfig.audio,
+        deviceId: { exact: deviceId }
+      };
+    }
+    return {
+      deviceId: { exact: deviceId }
+    };
+  }
+  async startStream() {
+    if (this.mediaStream) {
+      return this.mediaStream;
+    }
+    this.setState("starting");
+    try {
+      const constraints = {
+        video: this.buildVideoConstraints(this.selectedVideoDeviceId),
+        audio: this.buildAudioConstraints(this.selectedAudioDeviceId)
+      };
+      this.mediaStream = await navigator.mediaDevices.getUserMedia(constraints);
+      this.setState("active");
+      this.emit("streamstart", { stream: this.mediaStream });
+      return this.mediaStream;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(extractErrorMessage(error));
+      this.setState("error");
+      this.emit("error", { error: err });
+      throw err;
+    }
+  }
+  stopStream() {
+    if (this.mediaStream) {
+      for (const track of this.mediaStream.getTracks()) {
+        track.stop();
+      }
+      this.mediaStream = null;
+    }
+    if (this.state !== "idle") {
+      this.setState("idle");
+      this.emit("streamstop", undefined);
+    }
+  }
+  stopStreamTracks(stream) {
+    for (const track of stream.getTracks()) {
+      track.stop();
+    }
+  }
+  isTrackLive(track) {
+    return track !== undefined && track.readyState === TRACK_READY_STATE_LIVE2;
+  }
+  async tryReplaceTrack(oldTrack, newTrack, newStream) {
+    const replaceTrackMethod = oldTrack.replaceTrack;
+    if (typeof replaceTrackMethod !== "function") {
+      return false;
+    }
+    try {
+      await replaceTrackMethod.call(oldTrack, newTrack);
+      oldTrack.stop();
+      for (const track of newStream.getTracks()) {
+        if (track !== newTrack) {
+          track.stop();
+        }
+      }
+      newTrack.stop();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  recreateStreamWithNewTrack(newTrack, oldOtherTrack, newStream) {
+    for (const track of newStream.getTracks()) {
+      if (track !== newTrack) {
+        track.stop();
+      }
+    }
+    const tracks = [newTrack];
+    if (this.isTrackLive(oldOtherTrack) && oldOtherTrack) {
+      tracks.push(oldOtherTrack);
+    }
+    const combinedStream = new MediaStream(tracks);
+    if (this.mediaStream) {
+      for (const track of this.mediaStream.getTracks()) {
+        if (track !== oldOtherTrack) {
+          track.stop();
+        }
+      }
+    }
+    return combinedStream;
+  }
+  async switchVideoDevice(deviceId) {
+    if (!this.mediaStream) {
+      throw new Error("No active stream to switch device");
+    }
+    const oldVideoTrack = this.mediaStream.getVideoTracks()[0];
+    const oldAudioTrack = this.mediaStream.getAudioTracks()[0];
+    if (!oldVideoTrack) {
+      throw new Error("No video track in current stream");
+    }
+    const constraints = {
+      video: deviceId ? {
+        ...typeof this.streamConfig.video === "object" ? this.streamConfig.video : {},
+        deviceId: { exact: deviceId }
+      } : this.streamConfig.video
+    };
+    const newStream = await navigator.mediaDevices.getUserMedia(constraints);
+    const newVideoTrack = newStream.getVideoTracks()[0];
+    if (!newVideoTrack) {
+      this.stopStreamTracks(newStream);
+      throw new Error("Failed to get new video track");
+    }
+    const useReplaceTrack = await this.tryReplaceTrack(oldVideoTrack, newVideoTrack, newStream);
+    if (!useReplaceTrack) {
+      oldVideoTrack.stop();
+      this.mediaStream = this.recreateStreamWithNewTrack(newVideoTrack, oldAudioTrack, newStream);
+    }
+    this.selectedVideoDeviceId = deviceId;
+    this.emit("videosourcechange", { stream: this.mediaStream });
+    return this.mediaStream;
+  }
+  async switchAudioDevice(deviceId) {
+    if (!this.mediaStream) {
+      throw new Error("No active stream to switch device");
+    }
+    const oldAudioTrack = this.mediaStream.getAudioTracks()[0];
+    const oldVideoTrack = this.mediaStream.getVideoTracks()[0];
+    if (!oldAudioTrack) {
+      throw new Error("No audio track in current stream");
+    }
+    const constraints = {
+      audio: deviceId ? {
+        ...typeof this.streamConfig.audio === "object" ? this.streamConfig.audio : {},
+        deviceId: { exact: deviceId }
+      } : this.streamConfig.audio
+    };
+    const newStream = await navigator.mediaDevices.getUserMedia(constraints);
+    const newAudioTrack = newStream.getAudioTracks()[0];
+    if (!newAudioTrack) {
+      this.stopStreamTracks(newStream);
+      throw new Error("Failed to get new audio track");
+    }
+    const useReplaceTrack = await this.tryReplaceTrack(oldAudioTrack, newAudioTrack, newStream);
+    if (!useReplaceTrack) {
+      oldAudioTrack.stop();
+      this.mediaStream = this.recreateStreamWithNewTrack(newAudioTrack, oldVideoTrack, newStream);
+    }
+    this.selectedAudioDeviceId = deviceId;
+    return this.mediaStream;
+  }
+  startRecordingWithMediaRecorder() {
+    if (!this.mediaStream) {
+      throw new Error("Stream must be started before recording");
+    }
+    if (this.isRecording()) {
+      return;
+    }
+    this.recordedChunks = [];
+    this.recordedMimeType = null;
+    try {
+      this.mediaRecorder = new MediaRecorder(this.mediaStream, this.recordingOptions);
+    } catch {
+      this.mediaRecorder = new MediaRecorder(this.mediaStream);
+    }
+    this.mediaRecorder.ondataavailable = (event) => {
+      if (event.data && event.data.size > 0) {
+        this.recordedChunks.push(event.data);
+        this.emit("recordingdata", { data: event.data });
+      }
+    };
+    this.mediaRecorder.onstop = () => {
+      if (!this.mediaRecorder) {
+        throw new Error("MediaRecorder is missing in onstop handler");
+      }
+      const mimeType = this.mediaRecorder.mimeType;
+      if (!mimeType) {
+        throw new Error("MediaRecorder mimeType is missing");
+      }
+      this.recordedMimeType = mimeType;
+      const blob = new Blob(this.recordedChunks, {
+        type: mimeType
+      });
+      this.setState("active");
+      this.emit("recordingstop", {
+        blob,
+        mimeType
+      });
+      this.mediaRecorder = null;
+      this.recordedChunks = [];
+    };
+    this.mediaRecorder.start();
+    this.resetRecordingState();
+    this.setState("recording");
+    this.emit("recordingstart", { recorder: this.mediaRecorder });
+    this.startRecordingTimer();
+  }
+  stopRecordingWithMediaRecorder() {
+    if (!(this.mediaRecorder && this.isRecording())) {
+      return;
+    }
+    this.setState("stopping");
+    this.clearRecordingTimer();
+    this.resetPauseState();
+    this.mediaRecorder.stop();
+  }
+  async startRecording(processor, config) {
+    if (!this.mediaStream) {
+      throw new Error("Stream must be started before recording");
+    }
+    if (this.isRecording()) {
+      return;
+    }
+    this.streamProcessor = processor;
+    await processor.startProcessing(this.mediaStream, config);
+    this.bufferSizeUpdateInterval = window.setInterval(() => {
+      if (!this.streamProcessor) {
+        return;
+      }
+      const size = this.streamProcessor.getBufferSize();
+      const formatted = formatFileSize(size);
+      this.emit("recordingbufferupdate", { size, formatted });
+    }, TIMER_INTERVAL);
+    processor.setOnMuteStateChange((muted) => {
+      this.emit("audiomutetoggle", { muted });
+    });
+    processor.setOnSourceChange((stream) => {
+      this.emit("videosourcechange", { stream });
+    });
+    this.resetRecordingState();
+    this.setState("recording");
+    this.emit("recordingstart", { recorder: null });
+    this.startRecordingTimer();
+  }
+  async stopRecording() {
+    if (!(this.streamProcessor && this.isRecording())) {
+      throw new Error("Not currently recording");
+    }
+    this.setState("stopping");
+    this.clearRecordingTimer();
+    this.clearBufferSizeInterval();
+    this.resetPauseState();
+    const result = await this.streamProcessor.finalize();
+    this.setState("active");
+    this.emit("recordingstop", {
+      blob: result.blob,
+      mimeType: "video/mp4"
+    });
+    this.streamProcessor = null;
+    return result.blob;
+  }
+  pauseRecording() {
+    this.clearRecordingTimer();
+    if (this.pauseStartTime === null) {
+      this.pauseStartTime = Date.now();
+    }
+    if (this.streamProcessor && this.isRecording()) {
+      this.streamProcessor.pause();
+    } else if (this.mediaRecorder && this.isRecording() && this.mediaRecorder.state === MEDIA_RECORDER_STATE_RECORDING) {
+      this.mediaRecorder.pause();
+    }
+  }
+  resumeRecording() {
+    if (this.pauseStartTime !== null) {
+      const pausedDuration = Date.now() - this.pauseStartTime;
+      this.totalPausedTime += pausedDuration;
+      this.pauseStartTime = null;
+    }
+    this.startRecordingTimer();
+    if (this.streamProcessor && this.isRecording()) {
+      this.streamProcessor.resume();
+    } else if (this.mediaRecorder && this.isRecording() && this.mediaRecorder.state === MEDIA_RECORDER_STATE_PAUSED) {
+      this.mediaRecorder.resume();
+    }
+  }
+  toggleMute() {
+    if (!this.streamProcessor) {
+      throw new Error("StreamProcessor is required to toggle mute");
+    }
+    this.streamProcessor.toggleMute();
+  }
+  setAudioTracksEnabled(enabled) {
+    if (!this.mediaStream) {
+      return;
+    }
+    const audioTracks = this.mediaStream.getAudioTracks();
+    for (const track of audioTracks) {
+      track.enabled = enabled;
+    }
+  }
+  muteAudio() {
+    if (this.streamProcessor) {
+      if (!this.streamProcessor.isMutedState()) {
+        this.streamProcessor.toggleMute();
+      }
+      this.setAudioTracksEnabled(false);
+    } else if (this.mediaStream) {
+      this.setAudioTracksEnabled(false);
+      this.emit("audiomutetoggle", { muted: true });
+    }
+  }
+  unmuteAudio() {
+    if (this.streamProcessor) {
+      if (this.streamProcessor.isMutedState()) {
+        this.streamProcessor.toggleMute();
+      }
+      this.setAudioTracksEnabled(true);
+    } else if (this.mediaStream) {
+      this.setAudioTracksEnabled(true);
+      this.emit("audiomutetoggle", { muted: false });
+    }
+  }
+  isMuted() {
+    if (this.streamProcessor) {
+      return this.streamProcessor.isMutedState();
+    }
+    if (this.mediaStream) {
+      const audioTracks = this.mediaStream.getAudioTracks();
+      return audioTracks.length > 0 && audioTracks.every((track) => !track.enabled);
+    }
+    return false;
+  }
+  async switchVideoSource(newStream) {
+    if (!this.streamProcessor) {
+      throw new Error("StreamProcessor is required to switch video source");
+    }
+    await this.streamProcessor.switchVideoSource(newStream);
+  }
+  setMediaStream(stream) {
+    this.mediaStream = stream;
+  }
+  getCurrentVideoSource() {
+    if (!this.streamProcessor) {
+      throw new Error("StreamProcessor is required to get current video source");
+    }
+    const source = this.streamProcessor.getCurrentVideoSource();
+    if (!source) {
+      throw new Error("Current video source is not available");
+    }
+    return source;
+  }
+  formatTimeElapsed(elapsedSeconds) {
+    const mins = Math.floor(elapsedSeconds / SECONDS_PER_MINUTE);
+    const secs = Math.floor(elapsedSeconds % SECONDS_PER_MINUTE);
+    return `${mins.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}`;
+  }
+  startRecordingTimer() {
+    this.recordingTimer = window.setInterval(() => {
+      const elapsed = (Date.now() - this.recordingStartTime - this.totalPausedTime) / MILLISECONDS_PER_SECOND2;
+      const formatted = this.formatTimeElapsed(elapsed);
+      this.emit("recordingtimeupdate", { elapsed, formatted });
+    }, TIMER_INTERVAL);
+  }
+  clearRecordingTimer() {
+    if (this.recordingTimer !== null) {
+      clearInterval(this.recordingTimer);
+      this.recordingTimer = null;
+    }
+  }
+  clearBufferSizeInterval() {
+    if (this.bufferSizeUpdateInterval !== null) {
+      clearInterval(this.bufferSizeUpdateInterval);
+      this.bufferSizeUpdateInterval = null;
+    }
+  }
+  resetRecordingState() {
+    this.recordingStartTime = Date.now();
+    this.totalPausedTime = 0;
+    this.pauseStartTime = null;
+  }
+  resetPauseState() {
+    this.totalPausedTime = 0;
+    this.pauseStartTime = null;
+  }
+  getRecordedBlob() {
+    if (this.recordedChunks.length === 0) {
+      throw new Error("No recorded chunks available");
+    }
+    if (!this.recordedMimeType) {
+      throw new Error("Recorded mimeType is missing");
+    }
+    return new Blob(this.recordedChunks, {
+      type: this.recordedMimeType
+    });
+  }
+  destroy() {
+    this.stopRecordingWithMediaRecorder();
+    if (this.streamProcessor) {
+      this.streamProcessor.cancel().catch(() => {});
+      this.streamProcessor = null;
+    }
+    this.stopStream();
+    this.clearRecordingTimer();
+    this.clearBufferSizeInterval();
+    this.eventListeners.clear();
+    this.setState("idle");
+  }
+}
+
+// src/core/upload/duration-extractor.ts
+import { BlobSource as BlobSource2, Input as Input2, MP4 as MP42 } from "mediabunny";
+async function extractVideoDuration(blob) {
+  try {
+    const source = new BlobSource2(blob);
+    const input = new Input2({
+      formats: [MP42],
+      source
+    });
+    if (typeof input.computeDuration !== "function") {
+      throw new Error("computeDuration method is not available");
+    }
+    const duration = await input.computeDuration();
+    if (!duration) {
+      throw new Error("Duration is missing from computeDuration");
+    }
+    if (duration <= 0) {
+      throw new Error("Invalid duration: must be greater than 0");
+    }
+    return duration;
+  } catch {
+    return extractDurationWithVideoElement(blob);
+  }
+}
+function extractDurationWithVideoElement(blob) {
+  return new Promise((resolve, reject) => {
+    const video = document.createElement("video");
+    const url = URL.createObjectURL(blob);
+    const cleanup = () => {
+      URL.revokeObjectURL(url);
+    };
+    video.addEventListener("loadedmetadata", () => {
+      cleanup();
+      const duration = video.duration;
+      if (!Number.isFinite(duration) || duration <= 0) {
+        reject(new Error("Invalid video duration"));
+        return;
+      }
+      resolve(duration);
+    });
+    video.addEventListener("error", () => {
+      cleanup();
+      reject(new Error("Failed to load video metadata"));
+    });
+    video.src = url;
+    video.load();
+  });
+}
+
+// src/core/upload/upload-manager.ts
+class UploadManager {
+  callbacks;
+  uploadQueueManager = null;
+  constructor(callbacks) {
+    this.callbacks = callbacks;
+  }
+  setUploadQueueManager(uploadQueueManager) {
+    this.uploadQueueManager = uploadQueueManager;
+  }
+  async uploadVideo(blob, apiKey, backendUrl, userMetadata) {
+    if (!this.uploadQueueManager) {
+      throw new Error("Upload queue manager not initialized");
+    }
+    try {
+      this.callbacks.onClearStatus();
+      const duration = await extractVideoDuration(blob);
+      const metadata = Object.keys(userMetadata).length > 0 ? userMetadata : undefined;
+      await this.uploadQueueManager.queueUpload({
+        blob,
+        apiKey,
+        backendUrl,
+        filename: `recording-${Date.now()}.mp4`,
+        duration,
+        metadata: undefined,
+        userMetadata: metadata
+      });
+    } catch (error) {
+      this.callbacks.onError(error instanceof Error ? error : new Error(extractErrorMessage(error)));
+      throw error;
+    }
+  }
+  updateProgress(progress) {
+    this.callbacks.onProgress(progress);
+  }
+  showSuccess(result) {
+    this.callbacks.onSuccess(result);
+  }
+  showError(message) {
+    this.callbacks.onError(new Error(message));
+  }
+  clearStatus() {
+    this.callbacks.onClearStatus();
+  }
+}
+
+// src/core/upload/video-upload-service.ts
+var API_INIT_PATH = "/api/v1/videos/init";
+var HTTP_STATUS_OK_MIN = 200;
+var HTTP_STATUS_OK_MAX = 299;
+var BEARER_PREFIX = "Bearer ";
+var CONTENT_TYPE_JSON = "application/json";
+var HEADER_AUTHORIZATION = "Authorization";
+var HEADER_CONTENT_TYPE = "Content-Type";
+var HEADER_X_VIDEO_DURATION = "X-Video-Duration";
+var HTTP_METHOD_POST = "POST";
+var HTTP_METHOD_PUT = "PUT";
+
+class VideoUploadService {
+  async uploadVideo(blob, options) {
+    if (!options.filename) {
+      throw new Error("Filename is required");
+    }
+    if (!blob.type) {
+      throw new Error("Blob type is required");
+    }
+    const initResponse = await this.initVideoUpload({
+      apiKey: options.apiKey,
+      backendUrl: options.backendUrl,
+      filename: options.filename,
+      fileSize: blob.size,
+      mimeType: blob.type,
+      metadata: options.metadata,
+      userMetadata: options.userMetadata
+    });
+    return this.uploadVideoFile(blob, initResponse.uploadUrl, {
+      apiKey: options.apiKey,
+      duration: options.duration,
+      onProgress: options.onProgress
+    });
+  }
+  async initVideoUpload(data) {
+    const url = `${data.backendUrl}${API_INIT_PATH}`;
+    const body = {
+      filename: data.filename,
+      fileSize: data.fileSize,
+      mimeType: data.mimeType,
+      preProcessed: true
+    };
+    if (data.metadata) {
+      body.metadata = data.metadata;
+    }
+    if (data.userMetadata) {
+      body.userMetadata = data.userMetadata;
+    }
+    const response = await fetch(url, {
+      method: HTTP_METHOD_POST,
+      headers: {
+        [HEADER_AUTHORIZATION]: `${BEARER_PREFIX}${data.apiKey}`,
+        [HEADER_CONTENT_TYPE]: CONTENT_TYPE_JSON
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorMessage = await this.extractErrorFromResponse(response, "Failed to initialize video upload");
+      throw new Error(errorMessage);
+    }
+    return await response.json();
+  }
+  async extractErrorFromResponse(response, defaultMessage) {
+    try {
+      const errorData = await response.json();
+      if (errorData.error && typeof errorData.error === "string") {
+        return errorData.error;
+      }
+    } catch {}
+    return `${defaultMessage}: ${response.status} ${response.statusText}`;
+  }
+  uploadVideoFile(blob, uploadUrl, options) {
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest;
+      if (options.onProgress) {
+        const onProgress = options.onProgress;
+        xhr.upload.addEventListener("progress", (event) => {
+          if (event.lengthComputable) {
+            const progress = event.loaded / event.total;
+            onProgress(progress);
+          }
+        });
+      }
+      xhr.addEventListener("load", () => {
+        if (xhr.status >= HTTP_STATUS_OK_MIN && xhr.status <= HTTP_STATUS_OK_MAX) {
+          this.parseSuccessResponse(xhr, resolve, reject);
+        } else {
+          this.parseErrorResponse(xhr, reject);
+        }
+      });
+      xhr.addEventListener("error", () => {
+        reject(new Error("Network error during upload"));
+      });
+      xhr.addEventListener("abort", () => {
+        reject(new Error("Upload was aborted"));
+      });
+      xhr.open(HTTP_METHOD_PUT, uploadUrl);
+      xhr.setRequestHeader(HEADER_AUTHORIZATION, `${BEARER_PREFIX}${options.apiKey}`);
+      xhr.setRequestHeader(HEADER_CONTENT_TYPE, blob.type);
+      if (options.duration !== undefined) {
+        xhr.setRequestHeader(HEADER_X_VIDEO_DURATION, options.duration.toString());
+      }
+      xhr.send(blob);
+    });
+  }
+  parseSuccessResponse(xhr, resolve, reject) {
+    try {
+      const result = JSON.parse(xhr.responseText);
+      resolve(result);
+    } catch (error) {
+      const errorMessage = extractErrorMessage(error);
+      reject(new Error(`Failed to parse upload response: ${errorMessage}`));
+    }
+  }
+  parseErrorResponse(xhr, reject) {
+    let errorMessage = `Upload failed: ${xhr.status} ${xhr.statusText}`;
+    try {
+      const errorData = JSON.parse(xhr.responseText);
+      if (errorData.error && typeof errorData.error === "string") {
+        errorMessage = errorData.error;
+      }
+    } catch {}
+    reject(new Error(errorMessage));
+  }
+}
+
+// src/core/recorder/callback-factory.ts
+var noop = () => {};
+function createRecordingCallbacks(callbacks, audioLevelAnalyzer, configManager) {
+  const recording = callbacks.recording;
+  return {
+    onStateChange: recording?.onStateChange ?? noop,
+    onCountdownUpdate: recording?.onCountdownUpdate ?? noop,
+    onTimerUpdate: recording?.onTimerUpdate ?? noop,
+    onError: recording?.onError ?? noop,
+    onRecordingComplete: recording?.onRecordingComplete ?? noop,
+    onClearUploadStatus: recording?.onClearUploadStatus ?? noop,
+    onStopAudioTracking: () => {
+      audioLevelAnalyzer.stopTracking();
+    },
+    onGetConfig: () => configManager.getConfig()
+  };
+}
+function createSourceSwitchCallbacks(callbacks, deviceManager) {
+  const sourceSwitch = callbacks.sourceSwitch;
+  return {
+    onSourceChange: sourceSwitch?.onSourceChange,
+    onPreviewUpdate: sourceSwitch?.onPreviewUpdate,
+    onError: sourceSwitch?.onError,
+    onTransitionStart: sourceSwitch?.onTransitionStart,
+    onTransitionEnd: sourceSwitch?.onTransitionEnd,
+    getSelectedCameraDeviceId: () => deviceManager.getSelectedCameraDeviceId(),
+    getSelectedMicDeviceId: () => deviceManager.getSelectedMicDeviceId()
+  };
+}
+
+// src/core/recorder/mute-state-manager.ts
+class MuteStateManager {
+  isMuted = false;
+  streamManager;
+  constructor(streamManager) {
+    this.streamManager = streamManager;
+  }
+  mute() {
+    this.streamManager.muteAudio();
+    this.isMuted = true;
+  }
+  unmute() {
+    this.streamManager.unmuteAudio();
+    this.isMuted = false;
+  }
+  toggle() {
+    const currentMuted = this.streamManager.isMuted();
+    if (currentMuted) {
+      this.unmute();
+    } else {
+      this.mute();
+    }
+  }
+  getIsMuted() {
+    const streamMuted = this.streamManager.isMuted();
+    if (this.isMuted !== streamMuted) {
+      this.isMuted = streamMuted;
+    }
+    return this.isMuted;
+  }
+  getMutedStateCallback() {
+    return () => {
+      const muted = this.streamManager.isMuted();
+      if (this.isMuted !== muted) {
+        this.isMuted = muted;
+      }
+      return muted;
+    };
+  }
+}
+
+// src/core/recorder/recorder-controller.ts
+function createDefaultUploadCallbacks() {
+  return {
+    onProgress: () => {},
+    onSuccess: () => {},
+    onError: () => {},
+    onClearStatus: () => {}
+  };
+}
+
+class RecorderController {
+  streamManager;
+  configManager;
+  storageManager;
+  deviceManager;
+  audioLevelAnalyzer;
+  uploadManager;
+  recordingManager;
+  sourceSwitchManager;
+  uploadService = null;
+  muteStateManager;
+  isInitialized = false;
+  constructor(callbacks = {}) {
+    this.streamManager = new CameraStreamManager;
+    this.configManager = new ConfigManager;
+    this.storageManager = new StorageManager;
+    this.deviceManager = new DeviceManager(this.streamManager, callbacks.device);
+    this.audioLevelAnalyzer = new AudioLevelAnalyzer;
+    this.uploadService = new VideoUploadService;
+    const uploadCallbacks = callbacks.upload ? callbacks.upload : createDefaultUploadCallbacks();
+    this.uploadManager = new UploadManager(uploadCallbacks);
+    const recordingCallbacks = createRecordingCallbacks(callbacks, this.audioLevelAnalyzer, this.configManager);
+    this.recordingManager = new RecordingManager(this.streamManager, recordingCallbacks);
+    const sourceSwitchCallbacks = createSourceSwitchCallbacks(callbacks, this.deviceManager);
+    this.sourceSwitchManager = new SourceSwitchManager(this.streamManager, sourceSwitchCallbacks);
+    this.muteStateManager = new MuteStateManager(this.streamManager);
+  }
+  async initialize(config) {
+    if (this.isInitialized) {
+      return;
+    }
+    if (config.apiKey && config.backendUrl) {
+      this.configManager.initialize(config.apiKey, config.backendUrl);
+    }
+    if (config.countdownDuration !== undefined) {
+      this.recordingManager.setCountdownDuration(config.countdownDuration);
+    }
+    if (config.maxRecordingTime !== undefined) {
+      this.recordingManager.setMaxRecordingTime(config.maxRecordingTime);
+    }
+    await this.storageManager.initialize(this.uploadService, {
+      onUploadProgress: (_id, progress) => {
+        this.uploadManager.updateProgress(progress);
+      },
+      onUploadComplete: (_id, result) => {
+        this.uploadManager.showSuccess(result);
+      },
+      onUploadError: (_id, error) => {
+        this.uploadManager.showError(error.message);
+      }
+    }, () => {
+      throw new Error("Storage cleanup error");
+    });
+    const uploadQueueManager = this.storageManager.getUploadQueueManager();
+    this.uploadManager.setUploadQueueManager(uploadQueueManager);
+    this.isInitialized = true;
+  }
+  async startStream() {
+    await this.streamManager.startStream();
+  }
+  async stopStream() {
+    await this.streamManager.stopStream();
+  }
+  async switchVideoDevice(deviceId) {
+    return await this.streamManager.switchVideoDevice(deviceId);
+  }
+  async switchAudioDevice(deviceId) {
+    return await this.streamManager.switchAudioDevice(deviceId);
+  }
+  async startRecording() {
+    await this.recordingManager.startRecording();
+  }
+  async stopRecording() {
+    const blob = await this.recordingManager.stopRecording();
+    await this.sourceSwitchManager.handleRecordingStop().catch(() => {
+      throw new Error("Source switch cleanup failed");
+    });
+    return blob;
+  }
+  pauseRecording() {
+    this.recordingManager.pauseRecording();
+  }
+  resumeRecording() {
+    this.recordingManager.resumeRecording();
+  }
+  async switchSource(_sourceType) {
+    await this.sourceSwitchManager.toggleSource();
+  }
+  setCameraDevice(deviceId) {
+    this.deviceManager.setCameraDevice(deviceId);
+  }
+  setMicDevice(deviceId) {
+    this.deviceManager.setMicDevice(deviceId);
+  }
+  async getAvailableDevices() {
+    return await this.deviceManager.getAvailableDevices();
+  }
+  muteAudio() {
+    this.muteStateManager.mute();
+  }
+  unmuteAudio() {
+    this.muteStateManager.unmute();
+  }
+  toggleMute() {
+    this.muteStateManager.toggle();
+  }
+  getIsMuted() {
+    return this.muteStateManager.getIsMuted();
+  }
+  startAudioLevelTracking(stream, callbacks) {
+    if (!callbacks) {
+      throw new Error("Audio level callbacks are required");
+    }
+    this.audioLevelAnalyzer.startTracking(stream, callbacks, this.muteStateManager.getMutedStateCallback());
+    return Promise.resolve();
+  }
+  stopAudioLevelTracking() {
+    this.audioLevelAnalyzer.stopTracking();
+  }
+  getAudioLevel() {
+    return this.audioLevelAnalyzer.getAudioLevel();
+  }
+  async uploadVideo(blob, apiKey, backendUrl, metadata) {
+    await this.uploadManager.uploadVideo(blob, apiKey, backendUrl, metadata);
+  }
+  getStream() {
+    return this.streamManager.getStream();
+  }
+  getRecordingState() {
+    return this.recordingManager.getRecordingState();
+  }
+  isPaused() {
+    return this.recordingManager.isPausedState();
+  }
+  getCurrentSourceType() {
+    return this.sourceSwitchManager.getCurrentSourceType();
+  }
+  getOriginalCameraStream() {
+    return this.sourceSwitchManager.getOriginalCameraStream();
+  }
+  getStreamManager() {
+    return this.streamManager;
+  }
+  getAudioStreamForAnalysis() {
+    return this.streamManager.getAudioStreamForAnalysis();
+  }
+  getDeviceManager() {
+    return this.deviceManager;
+  }
+  async getConfig() {
+    return await this.configManager.getConfig();
+  }
+  isRecording() {
+    return this.streamManager.isRecording();
+  }
+  isActive() {
+    return this.streamManager.isActive();
+  }
+  cleanup() {
+    this.storageManager.destroy();
+    this.recordingManager.cleanup();
+    this.audioLevelAnalyzer.stopTracking();
+    this.sourceSwitchManager.cleanup();
+  }
+}
+// src/core/storage/quota-manager.ts
+var PERCENTAGE_MULTIPLIER = 100;
+var DEFAULT_WARNING_THRESHOLD = 80;
+var DEFAULT_CRITICAL_THRESHOLD = 95;
+
+class QuotaManager {
+  async getQuota() {
+    if (!(("storage" in navigator) && ("estimate" in navigator.storage))) {
+      throw new Error("Storage API not supported");
+    }
+    const estimate = await navigator.storage.estimate();
+    if (estimate.usage === undefined) {
+      throw new Error("Storage usage estimate not available");
+    }
+    if (estimate.quota === undefined) {
+      throw new Error("Storage quota estimate not available");
+    }
+    const usage = estimate.usage;
+    const quota = estimate.quota;
+    const available = quota - usage;
+    const percentage = quota > 0 ? usage / quota * PERCENTAGE_MULTIPLIER : 0;
+    return {
+      usage,
+      quota,
+      available,
+      percentage
+    };
+  }
+  async hasSpaceFor(sizeInBytes) {
+    if (typeof sizeInBytes !== "number" || sizeInBytes < 0) {
+      throw new Error("sizeInBytes must be a non-negative number");
+    }
+    const quota = await this.getQuota();
+    return quota.available >= sizeInBytes;
+  }
+  async requestPersistentStorage() {
+    if (!(("storage" in navigator) && ("persist" in navigator.storage))) {
+      throw new Error("Persistent storage API not supported");
+    }
+    return await navigator.storage.persist();
+  }
+  async isPersistent() {
+    if (!(("storage" in navigator) && ("persisted" in navigator.storage))) {
+      throw new Error("Persistent storage check API not supported");
+    }
+    return await navigator.storage.persisted();
+  }
+  formatBytes(bytes) {
+    if (typeof bytes !== "number" || bytes < 0) {
+      throw new Error("bytes must be a non-negative number");
+    }
+    return formatFileSize(bytes);
+  }
+  async shouldWarn(threshold) {
+    const actualThreshold = threshold !== undefined ? threshold : DEFAULT_WARNING_THRESHOLD;
+    return await this.checkThreshold(actualThreshold);
+  }
+  async isCritical(threshold) {
+    const actualThreshold = threshold !== undefined ? threshold : DEFAULT_CRITICAL_THRESHOLD;
+    return await this.checkThreshold(actualThreshold);
+  }
+  async checkThreshold(threshold) {
+    if (typeof threshold !== "number" || threshold < 0 || threshold > 100) {
+      throw new Error("threshold must be a number between 0 and 100");
+    }
+    const quota = await this.getQuota();
+    return quota.percentage >= threshold;
+  }
+}
+// src/core/utils/audio-utils.ts
+function calculateBarColor(position) {
+  if (position < 0.25) {
+    const t2 = position / 0.25;
+    return `rgb(255, ${Math.round(165 + (215 - 165) * t2)}, 0)`;
+  }
+  if (position < 0.5) {
+    const t2 = (position - 0.25) / 0.25;
+    return `rgb(${Math.round(255 - (50 - 255) * t2)}, ${Math.round(215 + (205 - 215) * t2)}, ${Math.round(0 + (50 - 0) * t2)})`;
+  }
+  if (position < 0.75) {
+    const t2 = (position - 0.5) / 0.25;
+    return `rgb(${Math.round(50 - (0 - 50) * t2)}, ${Math.round(205 + (128 - 205) * t2)}, ${Math.round(50 + (128 - 50) * t2)})`;
+  }
+  const t = (position - 0.75) / 0.25;
+  return `rgb(0, ${Math.round(128 - (100 - 128) * t)}, ${Math.round(128 + (200 - 128) * t)})`;
+}
+export {
+  transcodeVideo,
+  mapPresetToConfig,
+  formatTime,
+  formatFileSize,
+  extractVideoDuration,
+  extractErrorMessage,
+  calculateBarColor,
+  VideoUploadService,
+  VideoStorageService,
+  UploadQueueManager,
+  UploadManager,
+  StreamProcessor,
+  StorageManager,
+  RecordingManager,
+  RecorderController,
+  QuotaManager,
+  DeviceManager,
+  DEFAULT_TRANSCODE_CONFIG,
+  DEFAULT_STREAM_CONFIG,
+  DEFAULT_RECORDING_OPTIONS,
+  DEFAULT_CAMERA_CONSTRAINTS,
+  ConfigService,
+  ConfigManager,
+  CameraStreamManager,
+  AudioLevelAnalyzer
+};