@vidtreo/recorder 0.0.1 → 0.8.0

package/dist/index.js

@@ -179,13 +179,17 @@ function mapPresetToConfig(preset, maxWidth, maxHeight) {
 // src/core/config/config-service.ts
 var DEFAULT_CACHE_TIMEOUT = 5 * 60 * 1000;
 var CONFIG_API_PATH = "/api/v1/videos/config";
+var serviceInstances = new Map;
+function getInstanceKey(backendUrl, apiKey) {
+  return `${backendUrl}:${apiKey}`;
+}
 
 class ConfigService {
+  cacheTimeout;
+  options;
   cachedConfig = null;
   cacheTimestamp = 0;
-  cacheTimeout;
   fetchPromise = null;
-  options;
   constructor(options) {
     this.options = options;
     if (options.cacheTimeout !== undefined) {
@@ -197,6 +201,15 @@ class ConfigService {
       this.cacheTimeout = DEFAULT_CACHE_TIMEOUT;
     }
   }
+  static getInstance(options) {
+    const key = getInstanceKey(options.backendUrl, options.apiKey);
+    let instance = serviceInstances.get(key);
+    if (!instance) {
+      instance = new ConfigService(options);
+      serviceInstances.set(key, instance);
+    }
+    return instance;
+  }
   async fetchConfig() {
     const now = Date.now();
     if (this.cachedConfig && now - this.cacheTimestamp < this.cacheTimeout) {
@@ -210,16 +223,22 @@ class ConfigService {
       const config = await this.fetchPromise;
       this.cachedConfig = config;
       this.cacheTimestamp = now;
+      this.fetchPromise = null;
       return config;
     } catch {
-      return DEFAULT_TRANSCODE_CONFIG;
-    } finally {
       this.fetchPromise = null;
+      return DEFAULT_TRANSCODE_CONFIG;
     }
   }
   clearCache() {
+    const key = getInstanceKey(this.options.backendUrl, this.options.apiKey);
     this.cachedConfig = null;
     this.cacheTimestamp = 0;
+    this.fetchPromise = null;
+    serviceInstances.delete(key);
+  }
+  static clearAllInstances() {
+    serviceInstances.clear();
   }
   getCurrentConfig() {
     if (!this.cachedConfig) {
@@ -251,35 +270,30 @@ class ConfigService {
 class ConfigManager {
   configService = null;
   currentConfig = DEFAULT_TRANSCODE_CONFIG;
-  configFetchPromise = null;
   initialize(apiKey, backendUrl) {
+    if (this.configService) {
+      return;
+    }
     if (!apiKey) {
       throw new Error("apiKey is required");
     }
     if (!backendUrl) {
       throw new Error("backendUrl is required");
     }
-    this.configService = new ConfigService({
-      apiKey,
-      backendUrl
+    this.configService = ConfigService.getInstance({ apiKey, backendUrl });
+    this.configService.fetchConfig().then((config) => {
+      this.currentConfig = config;
     });
-    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;
+    this.currentConfig = await this.configService.fetchConfig();
   }
   async getConfig() {
-    if (this.configService && !this.configFetchPromise) {
-      await this.fetchConfig();
+    if (this.configService) {
+      this.currentConfig = await this.configService.fetchConfig();
     }
     return this.currentConfig;
   }
@@ -415,6 +429,69 @@ import { CanvasSource } from "mediabunny";
 // src/core/processor/audio-track-manager.ts
 import { AudioSample, AudioSampleSource } from "mediabunny";
 
+// src/core/processor/audio-capture-processor.worklet.ts
+var workletCode = `class AudioCaptureProcessor extends AudioWorkletProcessor {
+  process(inputs, outputs) {
+    const input = inputs[0];
+
+    if (!input?.length) {
+      return true;
+    }
+
+    const bufferLength = input[0].length;
+    const numberOfChannels = input.length;
+    const combinedBuffer = new Float32Array(bufferLength * numberOfChannels);
+
+    for (let channel = 0; channel < numberOfChannels; channel++) {
+      combinedBuffer.set(input[channel], channel * bufferLength);
+    }
+
+    const arrayBuffer = combinedBuffer.buffer.slice(
+      0,
+      combinedBuffer.length * Float32Array.BYTES_PER_ELEMENT
+    );
+
+    this.port.postMessage(
+      {
+        type: "audioData",
+        data: arrayBuffer,
+        sampleRate: sampleRate,
+        numberOfChannels,
+        duration: bufferLength / sampleRate,
+        bufferLength: combinedBuffer.length,
+      },
+      [arrayBuffer]
+    );
+
+    if (outputs && outputs[0] && outputs[0].length > 0) {
+      for (let channel = 0; channel < numberOfChannels; channel++) {
+        if (outputs[0][channel] && input[channel]) {
+          outputs[0][channel].set(input[channel]);
+        }
+      }
+    }
+
+    return true;
+  }
+}
+
+registerProcessor("audio-capture-processor", AudioCaptureProcessor);
+`;
+
+// src/core/processor/audio-track-manager.ts
+var workletBlobUrl = null;
+function getWorkletUrl() {
+  if (workletBlobUrl) {
+    return workletBlobUrl;
+  }
+  if (typeof Blob === "undefined" || typeof URL === "undefined") {
+    throw new Error("Blob and URL APIs are required for worklet loading");
+  }
+  const blob = new Blob([workletCode], { type: "application/javascript" });
+  workletBlobUrl = URL.createObjectURL(blob);
+  return workletBlobUrl;
+}
+
 class AudioTrackManager {
   originalAudioTrack = null;
   audioContext = null;
@@ -427,7 +504,14 @@ class AudioTrackManager {
   isPaused = false;
   onMuteStateChange;
   async setupAudioTrack(stream, config) {
-    const audioTrack = stream.getAudioTracks()[0];
+    if (!stream) {
+      return null;
+    }
+    const audioTracks = stream.getAudioTracks();
+    if (audioTracks.length === 0) {
+      return null;
+    }
+    const audioTrack = audioTracks[0];
     if (!audioTrack) {
       return null;
     }
@@ -435,11 +519,22 @@ class AudioTrackManager {
     this.lastAudioTimestamp = 0;
     const AudioContextClass = window.AudioContext || window.webkitAudioContext;
     if (!AudioContextClass) {
-      throw new Error("AudioContext is not supported in this browser");
+      return null;
     }
-    this.audioContext = new AudioContextClass;
     if (config.audioBitrate === undefined || config.audioBitrate === null) {
-      throw new Error("audioBitrate is required in config");
+      return null;
+    }
+    if (!config.audioCodec) {
+      return null;
+    }
+    this.audioContext = new AudioContextClass;
+    if (this.audioContext.state === "suspended") {
+      await this.audioContext.resume();
+    }
+    if (!this.audioContext.audioWorklet) {
+      await this.audioContext.close();
+      this.audioContext = null;
+      return null;
     }
     const audioBitrate = config.audioBitrate;
     const audioCodec = config.audioCodec;
@@ -447,8 +542,9 @@ class AudioTrackManager {
       codec: audioCodec,
       bitrate: audioBitrate
     });
-    this.mediaStreamSource = this.audioContext.createMediaStreamSource(stream);
-    const processorUrl = new URL("./audio-capture-processor.worklet.js", import.meta.url).href;
+    const audioOnlyStream = new MediaStream([this.originalAudioTrack]);
+    this.mediaStreamSource = this.audioContext.createMediaStreamSource(audioOnlyStream);
+    const processorUrl = getWorkletUrl();
     await this.audioContext.audioWorklet.addModule(processorUrl);
     this.audioWorkletNode = new AudioWorkletNode(this.audioContext, "audio-capture-processor");
     this.audioWorkletNode.port.onmessage = (event) => {
@@ -472,6 +568,9 @@ class AudioTrackManager {
     this.mediaStreamSource.connect(this.audioWorkletNode);
     this.audioWorkletNode.connect(this.gainNode);
     this.gainNode.connect(this.audioContext.destination);
+    if (this.audioContext.state === "suspended") {
+      await this.audioContext.resume();
+    }
     return this.audioSource;
   }
   toggleMute() {
@@ -524,6 +623,7 @@ class AudioTrackManager {
     this.onMuteStateChange = callback;
   }
   cleanup() {
+    this.audioSource = null;
     if (this.audioWorkletNode) {
       this.audioWorkletNode.disconnect();
       this.audioWorkletNode.port.close();
@@ -545,7 +645,10 @@ class AudioTrackManager {
       this.originalAudioTrack.stop();
       this.originalAudioTrack = null;
     }
-    this.audioSource = null;
+    if (workletBlobUrl) {
+      URL.revokeObjectURL(workletBlobUrl);
+      workletBlobUrl = null;
+    }
     this.lastAudioTimestamp = 0;
   }
 }
@@ -644,6 +747,10 @@ class FrameCapturer {
     return this.lastFrameTimestamp;
   }
   async waitForPendingFrames() {
+    if (!this.isActive && this.pendingFrameAdd) {
+      this.pendingFrameAdd = null;
+      return;
+    }
     if (this.pendingFrameAdd) {
       await this.pendingFrameAdd;
     }
@@ -654,6 +761,7 @@ class FrameCapturer {
       window.clearTimeout(this.timeoutId);
       this.timeoutId = null;
     }
+    this.pendingFrameAdd = null;
   }
   captureFrame() {
     if (!this.canCaptureFrame()) {
@@ -1717,14 +1825,19 @@ class SourceSwitchManager {
   getOriginalCameraStream() {
     return this.originalCameraStream;
   }
-  stopStreamTracks(stream) {
-    const tracks = stream.getTracks();
+  stopLiveTracks(tracks) {
     for (const track of tracks) {
       if (track.readyState === TRACK_READY_STATE_LIVE) {
         track.stop();
       }
     }
   }
+  stopStreamTracks(stream) {
+    this.stopLiveTracks(stream.getTracks());
+  }
+  stopStreamVideoTracks(stream) {
+    this.stopLiveTracks(stream.getVideoTracks());
+  }
   isTrackLive(track) {
     return track !== undefined && track.readyState === TRACK_READY_STATE_LIVE;
   }
@@ -1769,6 +1882,14 @@ class SourceSwitchManager {
       }, delay);
     });
   }
+  combineScreenShareWithOriginalAudio(screenVideoTrack) {
+    const originalAudioTrack = this.originalCameraStream ? this.originalCameraStream.getAudioTracks()[0] : undefined;
+    const combinedTracks = [screenVideoTrack];
+    if (this.isTrackLive(originalAudioTrack)) {
+      combinedTracks.push(originalAudioTrack);
+    }
+    return new MediaStream(combinedTracks);
+  }
   async switchToScreenCapture() {
     const currentStream = this.streamManager.getStream();
     if (currentStream) {
@@ -1779,24 +1900,39 @@ class SourceSwitchManager {
       this.callbacks.onTransitionStart("Select screen to share...");
     }
     try {
-      const newStream = await navigator.mediaDevices.getDisplayMedia({
+      const screenShareStream = await navigator.mediaDevices.getDisplayMedia({
         video: true,
         audio: true
       });
-      this.screenShareStream = newStream;
+      this.screenShareStream = screenShareStream;
+      const screenVideoTrack = screenShareStream.getVideoTracks()[0];
+      if (!screenVideoTrack) {
+        this.stopStreamTracks(screenShareStream);
+        throw new Error("No video track found in screen share stream");
+      }
+      const combinedStream = this.combineScreenShareWithOriginalAudio(screenVideoTrack);
       if (currentStream && currentStream !== this.originalCameraStream) {
-        this.stopStreamTracks(currentStream);
+        this.stopStreamVideoTracks(currentStream);
+      }
+      const screenAudioTracks = screenShareStream.getAudioTracks();
+      for (const track of screenAudioTracks) {
+        track.stop();
       }
       this.currentSourceType = "screen";
       if (this.callbacks.onSourceChange) {
         this.callbacks.onSourceChange(this.currentSourceType);
       }
-      this.setupScreenShareTrackHandler(newStream);
-      return newStream;
+      this.setupScreenShareTrackHandler(combinedStream);
+      return combinedStream;
     } catch (error) {
       if (this.callbacks.onTransitionEnd) {
         this.callbacks.onTransitionEnd();
       }
+      const errorMessage = extractErrorMessage(error);
+      const isPermissionDenied = errorMessage.includes("NotAllowedError") || errorMessage.includes("AbortError") || errorMessage.toLowerCase().includes("permission denied") || errorMessage.toLowerCase().includes("user denied");
+      if (isPermissionDenied) {
+        return null;
+      }
       throw error;
     }
   }
@@ -1838,30 +1974,62 @@ class SourceSwitchManager {
     }
     this.screenShareTrackEndHandler = null;
   }
-  canReuseOriginalStream() {
-    if (!this.originalCameraStream) {
+  canReuseStream(stream, mustMatchOriginal) {
+    if (!stream) {
       return false;
     }
-    const videoTrack = this.originalCameraStream.getVideoTracks()[0];
-    const audioTrack = this.originalCameraStream.getAudioTracks()[0];
-    return this.areTracksLive(videoTrack, audioTrack);
+    if (mustMatchOriginal && stream !== this.originalCameraStream) {
+      return false;
+    }
+    const videoTrack = stream.getVideoTracks()[0];
+    const audioTrack = stream.getAudioTracks()[0];
+    if (!this.areTracksLive(videoTrack, audioTrack)) {
+      return false;
+    }
+    if (this.callbacks.getSelectedCameraDeviceId) {
+      const selectedCameraDeviceId = this.callbacks.getSelectedCameraDeviceId();
+      const streamDeviceId = videoTrack.getSettings().deviceId;
+      if (selectedCameraDeviceId !== streamDeviceId) {
+        return false;
+      }
+    }
+    return true;
+  }
+  canReuseOriginalStream() {
+    return this.canReuseStream(this.originalCameraStream, false);
   }
   canReuseManagerStream() {
     const managerStream = this.streamManager.getStream();
-    if (!(managerStream && this.originalCameraStream) || managerStream !== this.originalCameraStream) {
+    if (!(managerStream && this.originalCameraStream)) {
       return false;
     }
-    const videoTrack = managerStream.getVideoTracks()[0];
-    const audioTrack = managerStream.getAudioTracks()[0];
-    return this.areTracksLive(videoTrack, audioTrack);
+    return this.canReuseStream(managerStream, true);
+  }
+  getSelectedCameraDeviceId() {
+    if (this.callbacks.getSelectedCameraDeviceId) {
+      return this.callbacks.getSelectedCameraDeviceId();
+    }
+    return this.streamManager.getVideoDevice();
+  }
+  getSelectedMicDeviceId() {
+    if (this.callbacks.getSelectedMicDeviceId) {
+      return this.callbacks.getSelectedMicDeviceId();
+    }
+    return this.streamManager.getAudioDevice();
   }
   buildVideoConstraints(cameraDeviceId) {
     const constraints = {};
+    if (this.originalCameraConstraints) {
+      const { deviceId: _, ...originalConstraintsWithoutDeviceId } = this.originalCameraConstraints;
+      Object.assign(constraints, originalConstraintsWithoutDeviceId);
+    }
     if (cameraDeviceId) {
       constraints.deviceId = { exact: cameraDeviceId };
-    }
-    if (this.originalCameraConstraints) {
-      Object.assign(constraints, this.originalCameraConstraints);
+    } else if (!constraints.deviceId) {
+      const selectedDeviceId = this.getSelectedCameraDeviceId();
+      if (selectedDeviceId) {
+        constraints.deviceId = { exact: selectedDeviceId };
+      }
     }
     return constraints;
   }
@@ -1871,9 +2039,35 @@ class SourceSwitchManager {
     }
     return true;
   }
-  async createNewCameraStreamForRecording() {
-    const cameraDeviceId = this.callbacks.getSelectedCameraDeviceId ? this.callbacks.getSelectedCameraDeviceId() : null;
-    const micDeviceId = this.callbacks.getSelectedMicDeviceId ? this.callbacks.getSelectedMicDeviceId() : null;
+  validateTrack(track, trackType, stream) {
+    if (!this.isTrackLive(track)) {
+      this.stopStreamTracks(stream);
+      const readyState = track ? track.readyState : "undefined";
+      throw new Error(`Failed to get live camera ${trackType} track. ReadyState: ${readyState}`);
+    }
+  }
+  async createCameraStreamWithOriginalAudio(cameraDeviceId) {
+    const originalAudioTrack = this.originalCameraStream ? this.originalCameraStream.getAudioTracks()[0] : undefined;
+    if (!this.isTrackLive(originalAudioTrack)) {
+      return null;
+    }
+    const videoConstraints = this.buildVideoConstraints(cameraDeviceId);
+    const constraints = {
+      video: Object.keys(videoConstraints).length > 0 ? videoConstraints : true,
+      audio: false
+    };
+    const newStream = await navigator.mediaDevices.getUserMedia(constraints);
+    const videoTrack = newStream.getVideoTracks()[0];
+    this.validateTrack(videoTrack, "video", newStream);
+    const combinedTracks = [videoTrack];
+    combinedTracks.push(originalAudioTrack);
+    const combinedStream = new MediaStream(combinedTracks);
+    this.stopLiveTracks(newStream.getAudioTracks());
+    this.originalCameraStream = combinedStream;
+    return combinedStream;
+  }
+  async createCameraStreamWithNewAudio(cameraDeviceId) {
+    const micDeviceId = this.getSelectedMicDeviceId();
     const videoConstraints = this.buildVideoConstraints(cameraDeviceId);
     const audioConstraints = this.buildAudioConstraints(micDeviceId);
     const constraints = {
@@ -1883,27 +2077,30 @@ class SourceSwitchManager {
     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.validateTrack(videoTrack, "video", newStream);
+    this.validateTrack(audioTrack, "audio", newStream);
     this.originalCameraStream = newStream;
     return newStream;
   }
+  async createNewCameraStreamForRecording() {
+    const cameraDeviceId = this.getSelectedCameraDeviceId();
+    const streamWithOriginalAudio = await this.createCameraStreamWithOriginalAudio(cameraDeviceId);
+    if (streamWithOriginalAudio) {
+      return streamWithOriginalAudio;
+    }
+    return this.createCameraStreamWithNewAudio(cameraDeviceId);
+  }
   async getCameraStream() {
     const isRecording = this.streamManager.isRecording();
+    const cameraDeviceId = this.getSelectedCameraDeviceId();
+    const micDeviceId = this.getSelectedMicDeviceId();
+    this.streamManager.setVideoDevice(cameraDeviceId);
+    this.streamManager.setAudioDevice(micDeviceId);
     if (this.canReuseOriginalStream()) {
-      const stream = this.originalCameraStream;
-      if (!stream) {
+      if (!this.originalCameraStream) {
         throw new Error("Original camera stream is null");
       }
-      return stream;
+      return this.originalCameraStream;
     }
     if (this.canReuseManagerStream()) {
       const stream = this.streamManager.getStream();
@@ -1920,15 +2117,9 @@ class SourceSwitchManager {
       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) {
+      this.streamManager.setVideoDevice(this.getSelectedCameraDeviceId());
+      this.streamManager.setAudioDevice(this.getSelectedMicDeviceId());
       return this.createNewCameraStreamForRecording();
     }
     const newStream = await this.streamManager.startStream();
@@ -1964,6 +2155,10 @@ class SourceSwitchManager {
       this.callbacks.onTransitionEnd();
     }
   }
+  stopScreenShareStreamTracks(stream) {
+    this.stopLiveTracks(stream.getVideoTracks());
+    this.stopLiveTracks(stream.getAudioTracks());
+  }
   async handleScreenShareStop() {
     if (this.currentSourceType !== "screen") {
       return;
@@ -1972,11 +2167,11 @@ class SourceSwitchManager {
     const currentStream = this.streamManager.getStream();
     if (screenShareStreamToStop) {
       this.removeScreenShareTrackHandler(screenShareStreamToStop);
-      this.stopStreamTracks(screenShareStreamToStop);
+      this.stopScreenShareStreamTracks(screenShareStreamToStop);
       await this.waitForTracksToEnd(SCREEN_SHARE_TRANSITION_DELAY);
     }
     if (currentStream && (!screenShareStreamToStop || currentStream.id !== screenShareStreamToStop.id)) {
-      this.stopStreamTracks(currentStream);
+      this.stopStreamVideoTracks(currentStream);
     }
   }
   async applyCameraStream(newStream, isRecording) {
@@ -2009,6 +2204,10 @@ class SourceSwitchManager {
   }
   async switchToScreen() {
     const newStream = await this.switchToScreenCapture();
+    if (!newStream) {
+      this.notifyTransitionEnd();
+      return;
+    }
     this.notifyTransitionStart("Switching to screen...");
     await this.streamManager.switchVideoSource(newStream);
     if (this.callbacks.onPreviewUpdate) {
@@ -2040,7 +2239,7 @@ class SourceSwitchManager {
       const currentStream = this.streamManager.getStream();
       if (currentStream) {
         this.removeScreenShareTrackHandler(currentStream);
-        this.stopStreamTracks(currentStream);
+        this.stopStreamVideoTracks(currentStream);
       }
       const newStream = await this.getCameraStream();
       if (!newStream) {
@@ -2065,7 +2264,7 @@ class SourceSwitchManager {
   cleanup() {
     if (this.screenShareStream) {
       this.removeScreenShareTrackHandler(this.screenShareStream);
-      this.stopStreamTracks(this.screenShareStream);
+      this.stopScreenShareStreamTracks(this.screenShareStream);
       this.screenShareStream = null;
     }
     const currentStream = this.streamManager.getStream();
@@ -2220,13 +2419,13 @@ class CameraStreamManager {
       throw new Error(`Failed to enumerate devices: ${extractErrorMessage(error)}`);
     }
   }
-  buildVideoConstraints(deviceId) {
+  buildDeviceConstraints(deviceId, config) {
     if (!deviceId) {
-      return this.streamConfig.video;
+      return config;
     }
-    if (typeof this.streamConfig.video === "object") {
+    if (typeof config === "object") {
       return {
-        ...this.streamConfig.video,
+        ...config,
         deviceId: { exact: deviceId }
       };
     }
@@ -2234,23 +2433,30 @@ class CameraStreamManager {
       deviceId: { exact: deviceId }
     };
   }
+  buildVideoConstraints(deviceId) {
+    return this.buildDeviceConstraints(deviceId, this.streamConfig.video);
+  }
   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 }
-    };
+    return this.buildDeviceConstraints(deviceId, this.streamConfig.audio);
   }
   async startStream() {
     if (this.mediaStream) {
-      return this.mediaStream;
+      const videoTrack = this.mediaStream.getVideoTracks()[0];
+      if (this.selectedVideoDeviceId === null) {
+        const existingDeviceId = videoTrack?.getSettings?.()?.deviceId;
+        if (existingDeviceId) {
+          this.stopStream();
+        } else {
+          return this.mediaStream;
+        }
+      }
+      if (videoTrack?.getSettings) {
+        const trackDeviceId = videoTrack.getSettings().deviceId;
+        if (trackDeviceId === this.selectedVideoDeviceId) {
+          return this.mediaStream;
+        }
+      }
+      this.stopStream();
     }
     this.setState("starting");
     try {
@@ -2328,65 +2534,45 @@ class CameraStreamManager {
     }
     return combinedStream;
   }
-  async switchVideoDevice(deviceId) {
+  async switchDeviceTrack(deviceId, trackType, config) {
     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 oldTrack = trackType === "video" ? this.mediaStream.getVideoTracks()[0] : this.mediaStream.getAudioTracks()[0];
+    const oldOtherTrack = trackType === "video" ? this.mediaStream.getAudioTracks()[0] : this.mediaStream.getVideoTracks()[0];
+    if (!oldTrack) {
+      const trackName = trackType === "video" ? "video" : "audio";
+      throw new Error(`No ${trackName} track in current stream`);
     }
     const constraints = {
-      video: deviceId ? {
-        ...typeof this.streamConfig.video === "object" ? this.streamConfig.video : {},
-        deviceId: { exact: deviceId }
-      } : this.streamConfig.video
+      [trackType]: this.buildDeviceConstraints(deviceId, config)
     };
     const newStream = await navigator.mediaDevices.getUserMedia(constraints);
-    const newVideoTrack = newStream.getVideoTracks()[0];
-    if (!newVideoTrack) {
+    const newTrack = trackType === "video" ? newStream.getVideoTracks()[0] : newStream.getAudioTracks()[0];
+    if (!newTrack) {
       this.stopStreamTracks(newStream);
-      throw new Error("Failed to get new video track");
+      const trackName = trackType === "video" ? "video" : "audio";
+      throw new Error(`Failed to get new ${trackName} track`);
     }
-    const useReplaceTrack = await this.tryReplaceTrack(oldVideoTrack, newVideoTrack, newStream);
+    const useReplaceTrack = await this.tryReplaceTrack(oldTrack, newTrack, 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");
+      oldTrack.stop();
+      this.mediaStream = this.recreateStreamWithNewTrack(newTrack, oldOtherTrack, newStream);
     }
-    const useReplaceTrack = await this.tryReplaceTrack(oldAudioTrack, newAudioTrack, newStream);
-    if (!useReplaceTrack) {
-      oldAudioTrack.stop();
-      this.mediaStream = this.recreateStreamWithNewTrack(newAudioTrack, oldVideoTrack, newStream);
+    if (trackType === "video") {
+      this.selectedVideoDeviceId = deviceId;
+      this.emit("videosourcechange", { stream: this.mediaStream });
+    } else {
+      this.selectedAudioDeviceId = deviceId;
     }
-    this.selectedAudioDeviceId = deviceId;
     return this.mediaStream;
   }
+  switchVideoDevice(deviceId) {
+    return this.switchDeviceTrack(deviceId, "video", this.streamConfig.video);
+  }
+  switchAudioDevice(deviceId) {
+    return this.switchDeviceTrack(deviceId, "audio", this.streamConfig.audio);
+  }
   startRecordingWithMediaRecorder() {
     if (!this.mediaStream) {
       throw new Error("Stream must be started before recording");
@@ -2732,22 +2918,13 @@ class UploadManager {
 
 // 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) {
+    if (!blob.type || blob.type.trim() === "") {
       throw new Error("Blob type is required");
     }
     const initResponse = await this.initVideoUpload({
@@ -2780,10 +2957,10 @@ class VideoUploadService {
       body.userMetadata = data.userMetadata;
     }
     const response = await fetch(url, {
-      method: HTTP_METHOD_POST,
+      method: "POST",
       headers: {
-        [HEADER_AUTHORIZATION]: `${BEARER_PREFIX}${data.apiKey}`,
-        [HEADER_CONTENT_TYPE]: CONTENT_TYPE_JSON
+        Authorization: `Bearer ${data.apiKey}`,
+        "Content-Type": "application/json"
       },
       body: JSON.stringify(body)
     });
@@ -2794,14 +2971,19 @@ class VideoUploadService {
     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 {}
+    const errorData = await this.parseJsonResponse(response);
+    if (errorData && typeof errorData === "object" && "error" in errorData && typeof errorData.error === "string") {
+      return errorData.error;
+    }
     return `${defaultMessage}: ${response.status} ${response.statusText}`;
   }
+  async parseJsonResponse(response) {
+    const jsonData = await response.json();
+    if (typeof jsonData === "object" && jsonData !== null) {
+      return jsonData;
+    }
+    return null;
+  }
   uploadVideoFile(blob, uploadUrl, options) {
     return new Promise((resolve, reject) => {
       const xhr = new XMLHttpRequest;
@@ -2815,11 +2997,11 @@ class VideoUploadService {
         });
       }
       xhr.addEventListener("load", () => {
-        if (xhr.status >= HTTP_STATUS_OK_MIN && xhr.status <= HTTP_STATUS_OK_MAX) {
+        if (xhr.status >= 200 && xhr.status <= 299) {
           this.parseSuccessResponse(xhr, resolve, reject);
-        } else {
-          this.parseErrorResponse(xhr, reject);
+          return;
         }
+        this.parseErrorResponse(xhr, reject);
       });
       xhr.addEventListener("error", () => {
         reject(new Error("Network error during upload"));
@@ -2827,47 +3009,72 @@ class VideoUploadService {
       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);
+      xhr.open("PUT", uploadUrl);
+      xhr.setRequestHeader("Authorization", `Bearer ${options.apiKey}`);
+      xhr.setRequestHeader("Content-Type", blob.type);
       if (options.duration !== undefined) {
-        xhr.setRequestHeader(HEADER_X_VIDEO_DURATION, options.duration.toString());
+        xhr.setRequestHeader("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}`));
+    const result = this.safeParseJsonFromXhr(xhr);
+    if (!result) {
+      reject(new Error("Failed to parse upload response: invalid JSON"));
+      return;
     }
+    resolve(result);
   }
   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));
+    const errorData = this.safeParseJsonFromXhr(xhr);
+    if (errorData && typeof errorData === "object" && "error" in errorData && typeof errorData.error === "string") {
+      reject(new Error(errorData.error));
+      return;
+    }
+    reject(new Error(`Upload failed: ${xhr.status} ${xhr.statusText}`));
+  }
+  safeParseJsonFromXhr(xhr) {
+    if (!xhr.responseText || xhr.responseText.trim() === "") {
+      return null;
+    }
+    const trimmed = xhr.responseText.trim();
+    if (!(trimmed.startsWith("{") && trimmed.endsWith("}")) || trimmed.length < 2) {
+      return null;
+    }
+    const parsed = JSON.parse(xhr.responseText);
+    if (typeof parsed === "object" && parsed !== null) {
+      return parsed;
+    }
+    return null;
   }
 }
 
 // src/core/recorder/callback-factory.ts
-var noop = () => {};
+var noopStateChange = (_state) => {};
+var noopCountdownUpdate = (_state, _remaining) => {};
+var noopTimerUpdate = (_formatted) => {};
+var noopError = (_error) => {};
+var noopRecordingComplete = (_blob) => {};
+var noopClearUploadStatus = () => {};
+function ensureCallback(callback, fallback) {
+  return callback ?? fallback;
+}
 function createRecordingCallbacks(callbacks, audioLevelAnalyzer, configManager) {
   const recording = callbacks.recording;
+  const onStateChange = ensureCallback(recording?.onStateChange, noopStateChange);
+  const onCountdownUpdate = ensureCallback(recording?.onCountdownUpdate, noopCountdownUpdate);
+  const onTimerUpdate = ensureCallback(recording?.onTimerUpdate, noopTimerUpdate);
+  const onError = ensureCallback(recording?.onError, noopError);
+  const onRecordingComplete = ensureCallback(recording?.onRecordingComplete, noopRecordingComplete);
+  const onClearUploadStatus = ensureCallback(recording?.onClearUploadStatus, noopClearUploadStatus);
   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,
+    onStateChange,
+    onCountdownUpdate,
+    onTimerUpdate,
+    onError,
+    onRecordingComplete,
+    onClearUploadStatus,
     onStopAudioTracking: () => {
       audioLevelAnalyzer.stopTracking();
     },
@@ -3001,11 +3208,11 @@ class RecorderController {
   async stopStream() {
     await this.streamManager.stopStream();
   }
-  async switchVideoDevice(deviceId) {
-    return await this.streamManager.switchVideoDevice(deviceId);
+  switchVideoDevice(deviceId) {
+    return this.streamManager.switchVideoDevice(deviceId);
   }
-  async switchAudioDevice(deviceId) {
-    return await this.streamManager.switchAudioDevice(deviceId);
+  switchAudioDevice(deviceId) {
+    return this.streamManager.switchAudioDevice(deviceId);
   }
   async startRecording() {
     await this.recordingManager.startRecording();
@@ -3032,8 +3239,8 @@ class RecorderController {
   setMicDevice(deviceId) {
     this.deviceManager.setMicDevice(deviceId);
   }
-  async getAvailableDevices() {
-    return await this.deviceManager.getAvailableDevices();
+  getAvailableDevices() {
+    return this.deviceManager.getAvailableDevices();
   }
   muteAudio() {
     this.muteStateManager.mute();
@@ -3087,8 +3294,8 @@ class RecorderController {
   getDeviceManager() {
     return this.deviceManager;
   }
-  async getConfig() {
-    return await this.configManager.getConfig();
+  getConfig() {
+    return this.configManager.getConfig();
   }
   isRecording() {
     return this.streamManager.isRecording();
@@ -3189,6 +3396,204 @@ function calculateBarColor(position) {
   const t = (position - 0.75) / 0.25;
   return `rgb(0, ${Math.round(128 - (100 - 128) * t)}, ${Math.round(128 + (200 - 128) * t)})`;
 }
+// src/vidtreo-recorder.ts
+class VidtreoRecorder {
+  controller;
+  config;
+  uploadService;
+  isInitialized = false;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("apiKey is required");
+    }
+    if (!config.apiUrl) {
+      throw new Error("apiUrl is required");
+    }
+    this.config = config;
+    this.uploadService = new VideoUploadService;
+    const callbacks = {
+      recording: {
+        onStateChange: (state) => {
+          if (state === "recording" && this.config.onRecordingStart) {
+            this.config.onRecordingStart();
+          }
+          if (state === "idle" && this.config.onRecordingStop) {
+            this.config.onRecordingStop();
+          }
+        },
+        onGetConfig: async () => await this.controller.getConfig()
+      },
+      upload: {
+        onProgress: (progress) => {
+          if (this.config.onUploadProgress) {
+            this.config.onUploadProgress(progress);
+          }
+        },
+        onSuccess: (result) => {
+          if (this.config.onUploadComplete) {
+            this.config.onUploadComplete({
+              recordingId: result.videoId,
+              uploadUrl: result.uploadUrl
+            });
+          }
+        },
+        onError: (error) => {
+          if (this.config.onUploadError) {
+            this.config.onUploadError(error);
+          }
+        },
+        onClearStatus: () => {}
+      },
+      stream: {
+        onError: (error) => {
+          if (this.config.onError) {
+            this.config.onError(error);
+          }
+        }
+      }
+    };
+    this.controller = new RecorderController(callbacks);
+  }
+  async initialize() {
+    if (this.isInitialized) {
+      return;
+    }
+    const recorderConfig = {
+      apiKey: this.config.apiKey,
+      backendUrl: this.config.apiUrl,
+      maxRecordingTime: this.config.maxRecordingTime ?? null,
+      countdownDuration: this.config.countdownDuration,
+      userMetadata: this.config.userMetadata,
+      enableSourceSwitching: this.config.enableSourceSwitching,
+      enableMute: this.config.enableMute,
+      enablePause: this.config.enablePause,
+      enableDeviceChange: this.config.enableDeviceChange
+    };
+    await this.controller.initialize(recorderConfig);
+    this.isInitialized = true;
+  }
+  async startPreview(sourceType = "camera") {
+    await this.ensureInitialized();
+    await this.controller.startStream();
+    if (sourceType === "screen") {
+      await this.controller.switchSource("screen");
+    }
+    const stream = this.controller.getStream();
+    if (!stream) {
+      throw new Error("Failed to start preview stream");
+    }
+    return stream;
+  }
+  async startRecording(_options = {}, sourceType = "camera") {
+    await this.ensureInitialized();
+    if (!this.controller.isActive()) {
+      await this.startPreview(sourceType);
+    }
+    if (sourceType === "screen" && this.controller.getCurrentSourceType() !== "screen") {
+      await this.controller.switchSource("screen");
+    }
+    if (sourceType === "camera" && this.controller.getCurrentSourceType() !== "camera") {
+      await this.controller.switchSource("camera");
+    }
+    await this.controller.startRecording();
+  }
+  async switchSource(sourceType) {
+    await this.ensureInitialized();
+    if (!this.config.enableSourceSwitching) {
+      throw new Error("Source switching is not enabled");
+    }
+    const currentSourceType = this.controller.getCurrentSourceType();
+    if (currentSourceType === sourceType) {
+      return;
+    }
+    if (!this.controller.isRecording()) {
+      if (sourceType === "screen") {
+        await this.startPreview("screen");
+      } else {
+        await this.startPreview("camera");
+      }
+      return;
+    }
+    await this.controller.switchSource(sourceType);
+  }
+  async stopRecording() {
+    await this.ensureInitialized();
+    const blob = await this.controller.stopRecording();
+    const duration = await extractVideoDuration(blob);
+    const timestamp = Date.now();
+    const filename = `recording-${timestamp}.mp4`;
+    const uploadResult = await this.uploadService.uploadVideo(blob, {
+      apiKey: this.config.apiKey,
+      backendUrl: this.config.apiUrl,
+      filename,
+      duration,
+      userMetadata: this.config.userMetadata,
+      onProgress: this.config.onUploadProgress
+    });
+    return {
+      recordingId: uploadResult.videoId,
+      uploadUrl: uploadResult.uploadUrl,
+      blob
+    };
+  }
+  async getAvailableDevices() {
+    if (this.config.enableDeviceChange === false) {
+      throw new Error("Device change functionality is disabled");
+    }
+    await this.ensureInitialized();
+    return await this.controller.getAvailableDevices();
+  }
+  muteAudio() {
+    if (this.config.enableMute === false) {
+      throw new Error("Mute functionality is disabled");
+    }
+    this.controller.muteAudio();
+  }
+  unmuteAudio() {
+    if (this.config.enableMute === false) {
+      throw new Error("Mute functionality is disabled");
+    }
+    this.controller.unmuteAudio();
+  }
+  toggleMute() {
+    if (this.config.enableMute === false) {
+      throw new Error("Mute functionality is disabled");
+    }
+    this.controller.toggleMute();
+  }
+  isMuted() {
+    return this.controller.getIsMuted();
+  }
+  pauseRecording() {
+    if (this.config.enablePause === false) {
+      throw new Error("Pause functionality is disabled");
+    }
+    this.controller.pauseRecording();
+  }
+  resumeRecording() {
+    if (this.config.enablePause === false) {
+      throw new Error("Pause functionality is disabled");
+    }
+    this.controller.resumeRecording();
+  }
+  isPaused() {
+    return this.controller.isPaused();
+  }
+  getRecordingState() {
+    return this.controller.getRecordingState();
+  }
+  getStream() {
+    return this.controller.getStream();
+  }
+  cleanup() {
+    this.controller.cleanup();
+  }
+  async ensureInitialized() {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+  }
+}
 export {
   transcodeVideo,
   mapPresetToConfig,
@@ -3197,6 +3602,7 @@ export {
   extractVideoDuration,
   extractErrorMessage,
   calculateBarColor,
+  VidtreoRecorder,
   VideoUploadService,
   VideoStorageService,
   UploadQueueManager,