@vidtreo/recorder 0.9.1 → 0.9.3

package/dist/index.js

@@ -1,3 +1,27 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/core/utils/error-handler.ts
 function extractErrorMessage(error) {
   if (error instanceof Error) {
@@ -127,6 +151,9 @@ class AudioLevelAnalyzer {
     return isMutedFromCallback || hasDisabledTracks;
   }
 }
+// src/core/config/config-constants.ts
+import { QUALITY_HIGH } from "mediabunny";
+
 // src/core/processor/format-codec-mapper.ts
 var FORMAT_DEFAULT_CODECS = {
   mp4: "aac",
@@ -149,13 +176,11 @@ var DEFAULT_BACKEND_URL = "https://api.vidtreo.com";
 var DEFAULT_TRANSCODE_CONFIG = Object.freeze({
   format: "mp4",
   fps: 30,
-  width: 1280,
-  height: 720,
-  bitrate: 500000,
-  audioCodec: undefined,
-  audioBitrate: 128000,
-  preset: "medium",
-  packetCount: 1200
+  width: 1920,
+  height: 1080,
+  bitrate: QUALITY_HIGH,
+  audioCodec: "aac",
+  audioBitrate: 96000
 });
 function getDefaultConfigForFormat(format) {
   return {
@@ -165,23 +190,21 @@ function getDefaultConfigForFormat(format) {
   };
 }
 // src/core/config/preset-mapper.ts
-var BITRATE_MAP = {
-  sd: 500000,
-  hd: 1e6,
-  fhd: 2000000,
-  "4k": 8000000
+import {
+  QUALITY_HIGH as QUALITY_HIGH2,
+  QUALITY_LOW,
+  QUALITY_MEDIUM,
+  QUALITY_VERY_HIGH
+} from "mediabunny";
+var QUALITY_MAP = {
+  sd: QUALITY_LOW,
+  hd: QUALITY_MEDIUM,
+  fhd: QUALITY_HIGH2,
+  "4k": QUALITY_VERY_HIGH
 };
 var AUDIO_BITRATE = 128000;
-var PACKET_COUNT_MAP = {
-  sd: 800,
-  hd: 1200,
-  fhd: 2000,
-  "4k": 4000
-};
-var DEFAULT_FPS = 30;
-var DEFAULT_PRESET = "medium";
-function mapPresetToConfig(preset, maxWidth, maxHeight, format = "mp4") {
-  if (!(preset in BITRATE_MAP)) {
+function mapPresetToConfig(preset, maxWidth, maxHeight, outputFormat) {
+  if (!(preset in QUALITY_MAP)) {
     throw new Error(`Invalid preset: ${preset}`);
   }
   if (typeof maxWidth !== "number" || maxWidth <= 0) {
@@ -190,16 +213,14 @@ function mapPresetToConfig(preset, maxWidth, maxHeight, format = "mp4") {
   if (typeof maxHeight !== "number" || maxHeight <= 0) {
     throw new Error("maxHeight must be a positive number");
   }
+  const format = outputFormat || "mp4";
   const audioCodec = getDefaultAudioCodecForFormat(format);
   return {
     format,
-    fps: DEFAULT_FPS,
     width: maxWidth,
     height: maxHeight,
-    bitrate: BITRATE_MAP[preset],
+    bitrate: QUALITY_MAP[preset],
     audioCodec,
-    preset: DEFAULT_PRESET,
-    packetCount: PACKET_COUNT_MAP[preset],
     audioBitrate: AUDIO_BITRATE
   };
 }
@@ -290,7 +311,7 @@ class ConfigService {
     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);
+    return mapPresetToConfig(data.presetEncoding, data.max_width, data.max_height, data.outputFormat);
   }
 }
 
@@ -311,8 +332,12 @@ class ConfigManager {
       apiKey,
       backendUrl: normalizedBackendUrl
     });
-    this.currentConfig = await this.configService.fetchConfig();
-    this.configFetched = true;
+    this.configService.fetchConfig().then((config) => {
+      this.currentConfig = config;
+      this.configFetched = true;
+    }).catch(() => {
+      this.configFetched = false;
+    });
   }
   async fetchConfig() {
     if (!this.configService) {
@@ -379,6 +404,406 @@ class DeviceManager {
     return this.availableDevices;
   }
 }
+// src/core/utils/video-utils.ts
+import { BlobSource, Input, MP4 } from "mediabunny";
+async function extractVideoDuration(file) {
+  try {
+    const source = new BlobSource(file);
+    const input = new Input({
+      formats: [MP4],
+      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(file);
+  }
+}
+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/native-camera/file-validator.ts
+var DEFAULT_MAX_FILE_SIZE = 500 * 1024 * 1024;
+var ALLOWED_FORMATS = ["video/mp4", "video/quicktime", "video/webm"];
+async function validateFile(file, config = {}) {
+  const maxSize = config.maxFileSize !== undefined ? config.maxFileSize : DEFAULT_MAX_FILE_SIZE;
+  if (file.size > maxSize) {
+    const error = `File too large. Maximum size is ${Math.round(maxSize / 1024 / 1024)}MB`;
+    return { valid: false, error };
+  }
+  const allowedFormats = config.allowedFormats !== undefined ? config.allowedFormats : ALLOWED_FORMATS;
+  if (!allowedFormats.includes(file.type)) {
+    const error = `Unsupported format. Please use: ${allowedFormats.join(", ")}`;
+    return { valid: false, error };
+  }
+  const durationResult = await extractVideoDuration(file).then((videoDuration) => ({
+    success: true,
+    duration: videoDuration
+  })).catch((error) => ({
+    success: false,
+    error: extractErrorMessage(error)
+  }));
+  if (durationResult.success === false) {
+    return {
+      valid: false,
+      error: `Failed to read video file: ${durationResult.error}`
+    };
+  }
+  const duration = durationResult.duration;
+  if (config.maxRecordingTime !== null && config.maxRecordingTime !== undefined && duration > config.maxRecordingTime) {
+    const error = `Video too long. Maximum duration is ${config.maxRecordingTime} seconds`;
+    return { valid: false, error };
+  }
+  return { valid: true };
+}
+// src/core/transcode/video-transcoder.ts
+import {
+  ALL_FORMATS,
+  BlobSource as BlobSource2,
+  BufferTarget,
+  Conversion,
+  FilePathSource,
+  Input as Input2,
+  MkvOutputFormat,
+  MovOutputFormat,
+  Mp4OutputFormat,
+  Output,
+  WebMOutputFormat
+} from "mediabunny";
+function createSource(input) {
+  if (typeof input === "string") {
+    return new FilePathSource(input);
+  }
+  if (input instanceof Blob) {
+    return new BlobSource2(input);
+  }
+  throw new Error("Invalid input type. Expected Blob, File, or file path string.");
+}
+function createOutputFormat(format) {
+  switch (format) {
+    case "mp4":
+      return new Mp4OutputFormat;
+    case "webm":
+      return new WebMOutputFormat;
+    case "mkv":
+      return new MkvOutputFormat;
+    case "mov":
+      return new MovOutputFormat;
+    default:
+      throw new Error(`Unsupported output format: ${format}`);
+  }
+}
+function getMimeTypeForFormat(format) {
+  switch (format) {
+    case "mp4":
+      return "video/mp4";
+    case "webm":
+      return "video/webm";
+    case "mkv":
+      return "video/x-matroska";
+    case "mov":
+      return "video/quicktime";
+    default:
+      throw new Error(`Unsupported output format: ${format}`);
+  }
+}
+function createConversionOptions(config, optimizeForSpeed = false) {
+  const audioCodec = getAudioCodecForFormat(config.format, config.audioCodec);
+  const video = {
+    fit: "contain",
+    forceTranscode: true
+  };
+  if (config.width !== undefined) {
+    video.width = config.width;
+  }
+  if (config.height !== undefined) {
+    video.height = config.height;
+  }
+  if (config.fps !== undefined) {
+    video.frameRate = config.fps;
+  }
+  if (config.bitrate !== undefined) {
+    video.bitrate = config.bitrate;
+  }
+  if (config.codec !== undefined) {
+    video.codec = config.codec;
+  }
+  if (optimizeForSpeed) {
+    video.bitrateMode = "variable";
+    video.latencyMode = "realtime";
+    video.hardwareAcceleration = "prefer-hardware";
+    video.keyFrameInterval = 2;
+  }
+  const audio = {
+    codec: audioCodec,
+    forceTranscode: true,
+    ...optimizeForSpeed && { bitrateMode: "variable" }
+  };
+  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,
+    format: config.format || DEFAULT_TRANSCODE_CONFIG.format
+  };
+  if (!finalConfig.audioCodec) {
+    finalConfig.audioCodec = getDefaultAudioCodecForFormat(finalConfig.format);
+  }
+  const source = createSource(input);
+  const mediabunnyInput = new Input2({
+    formats: ALL_FORMATS,
+    source
+  });
+  const outputFormat = createOutputFormat(finalConfig.format);
+  const output = new Output({
+    format: outputFormat,
+    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");
+  }
+  const mimeType = getMimeTypeForFormat(finalConfig.format);
+  return {
+    buffer,
+    blob: new Blob([buffer], { type: mimeType })
+  };
+}
+async function transcodeVideoForNativeCamera(file, config = {}, onProgress) {
+  const finalConfig = {
+    ...DEFAULT_TRANSCODE_CONFIG,
+    ...config,
+    format: config.format || DEFAULT_TRANSCODE_CONFIG.format
+  };
+  if (!finalConfig.audioCodec) {
+    finalConfig.audioCodec = getDefaultAudioCodecForFormat(finalConfig.format);
+  }
+  const source = new BlobSource2(file);
+  const mediabunnyInput = new Input2({
+    formats: ALL_FORMATS,
+    source
+  });
+  const outputFormat = createOutputFormat(finalConfig.format);
+  const output = new Output({
+    format: outputFormat,
+    target: new BufferTarget
+  });
+  const conversion = await Conversion.init({
+    input: mediabunnyInput,
+    output,
+    video: {
+      codec: finalConfig.codec,
+      width: finalConfig.width,
+      height: finalConfig.height,
+      frameRate: finalConfig.fps,
+      bitrate: finalConfig.bitrate,
+      fit: "contain"
+    },
+    audio: {
+      codec: finalConfig.audioCodec
+    }
+  });
+  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");
+  }
+  const mimeType = getMimeTypeForFormat(finalConfig.format);
+  return {
+    buffer,
+    blob: new Blob([buffer], { type: mimeType })
+  };
+}
+
+// src/core/native-camera/preview-extractor.ts
+function extractLastFrame(file, timeoutMs = 1e4) {
+  return new Promise((resolve, reject) => {
+    const video = document.createElement("video");
+    video.preload = "metadata";
+    video.muted = true;
+    const timeout = setTimeout(() => {
+      cleanup();
+      reject(new Error("Preview extraction timeout"));
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timeout);
+      URL.revokeObjectURL(video.src);
+    };
+    video.addEventListener("loadedmetadata", () => {
+      video.currentTime = Math.max(0, video.duration - 0.1);
+    });
+    video.addEventListener("seeked", () => {
+      const canvas = document.createElement("canvas");
+      canvas.width = video.videoWidth;
+      canvas.height = video.videoHeight;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        cleanup();
+        reject(new Error("Canvas context unavailable"));
+        return;
+      }
+      if (video.videoWidth === 0 || video.videoHeight === 0) {
+        cleanup();
+        reject(new Error("Invalid video dimensions"));
+        return;
+      }
+      if (!(Number.isFinite(video.videoWidth) && Number.isFinite(video.videoHeight))) {
+        cleanup();
+        reject(new Error("Invalid video dimensions"));
+        return;
+      }
+      ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+      canvas.toBlob((blob) => {
+        cleanup();
+        if (blob) {
+          resolve(blob);
+        } else {
+          reject(new Error("Failed to create preview blob"));
+        }
+      }, "image/jpeg", 0.8);
+    });
+    video.addEventListener("error", () => {
+      cleanup();
+      reject(new Error("Failed to load video for preview extraction"));
+    });
+    const videoUrl = URL.createObjectURL(file);
+    video.src = videoUrl;
+  });
+}
+
+// src/core/native-camera/native-camera-handler.ts
+class NativeCameraHandler {
+  pendingFile = null;
+  configService = null;
+  uploadService;
+  config;
+  constructor(config, configService, uploadService) {
+    this.config = config;
+    this.configService = configService;
+    this.uploadService = uploadService;
+  }
+  async handleFileSelection(file) {
+    const maxFileSize = this.config.maxFileSize !== undefined ? this.config.maxFileSize : 2 * 1024 * 1024 * 1024;
+    const validation = await validateFile(file, {
+      maxFileSize,
+      maxRecordingTime: this.config.maxRecordingTime,
+      allowedFormats: ["video/mp4", "video/quicktime", "video/webm"]
+    });
+    if (!validation.valid) {
+      throw new Error(validation.error);
+    }
+    const previewBlob = await extractLastFrame(file);
+    const previewUrl = URL.createObjectURL(previewBlob);
+    const durationResult = await extractVideoDuration(file).then((videoDuration) => ({
+      success: true,
+      duration: videoDuration
+    })).catch((error) => ({
+      success: false,
+      error: extractErrorMessage(error)
+    }));
+    if (durationResult.success === false) {
+      throw new Error(`Failed to extract video duration: ${durationResult.error}`);
+    }
+    const duration = durationResult.duration;
+    this.pendingFile = file;
+    return { file, previewUrl, duration, validated: true };
+  }
+  async processAndUpload(onTranscodeProgress, onUploadProgress) {
+    if (!this.pendingFile) {
+      throw new Error("No file selected");
+    }
+    const transcodeConfig = this.configService ? await this.configService.fetchConfig() : DEFAULT_TRANSCODE_CONFIG;
+    const result = await transcodeVideoForNativeCamera(this.pendingFile, transcodeConfig, onTranscodeProgress);
+    if (!(this.config.apiKey && this.config.backendUrl)) {
+      throw new Error("Upload requires API key and backend URL");
+    }
+    const durationResult = await extractVideoDuration(result.blob).then((videoDuration) => ({
+      success: true,
+      duration: videoDuration
+    })).catch((error) => ({
+      success: false,
+      error: extractErrorMessage(error)
+    }));
+    if (durationResult.success === false) {
+      throw new Error(`Failed to extract video duration: ${durationResult.error}`);
+    }
+    const duration = durationResult.duration;
+    const uploadResult = await this.uploadService.uploadVideo(result.blob, {
+      apiKey: this.config.apiKey,
+      backendUrl: this.config.backendUrl,
+      filename: `${Date.now()}.mp4`,
+      duration,
+      userMetadata: this.config.userMetadata,
+      onProgress: onUploadProgress
+    });
+    this.pendingFile = null;
+    return {
+      blob: result.blob,
+      recordingId: uploadResult.videoId,
+      uploadUrl: uploadResult.uploadUrl
+    };
+  }
+  cancel() {
+    this.pendingFile = null;
+  }
+  async preloadConfig() {
+    if (this.configService) {
+      await this.configService.fetchConfig();
+    }
+  }
+}
 // src/core/storage/video-storage.ts
 var DB_NAME = "vidtreo-recorder";
 var DB_VERSION = 1;
@@ -1379,9 +1804,9 @@ class SourceSwitchManager {
 
 // src/core/stream/stream-constants.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 }
+  width: { ideal: DEFAULT_TRANSCODE_CONFIG.width || 1920 },
+  height: { ideal: DEFAULT_TRANSCODE_CONFIG.height || 1080 },
+  frameRate: { ideal: DEFAULT_TRANSCODE_CONFIG.fps || 30 }
 });
 var DEFAULT_STREAM_CONFIG = Object.freeze({
   video: DEFAULT_CAMERA_CONSTRAINTS,
@@ -2587,55 +3012,6 @@ class VideoUploadService {
   }
 }
 
-// src/core/utils/video-utils.ts
-import { BlobSource, Input, MP4 } from "mediabunny";
-async function extractVideoDuration(blob) {
-  try {
-    const source = new BlobSource(blob);
-    const input = new Input({
-      formats: [MP4],
-      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/utils/stream-utils.ts
 function isScreenCaptureStream(stream) {
   const videoTracks = stream.getVideoTracks();
@@ -2647,6 +3023,30 @@ function isScreenCaptureStream(stream) {
   return "displaySurface" in settings || videoTrack.label.toLowerCase().includes("screen") || videoTrack.label.toLowerCase().includes("display");
 }
 
+// src/core/processor/codec-detector.ts
+async function detectBestCodec(width, height, bitrate) {
+  try {
+    const { canEncodeVideo } = await import("mediabunny");
+    if (typeof canEncodeVideo === "function") {
+      const checkOptions = {};
+      if (width !== undefined) {
+        checkOptions.width = width;
+      }
+      if (height !== undefined) {
+        checkOptions.height = height;
+      }
+      if (bitrate !== undefined) {
+        checkOptions.bitrate = bitrate;
+      }
+      const hevcSupported = await canEncodeVideo("hevc", checkOptions);
+      if (hevcSupported) {
+        return "hevc";
+      }
+    }
+  } catch {}
+  return "avc";
+}
+
 // src/core/processor/worker/recorder-worker.code.ts
 var workerCode = `// ../../node_modules/mediabunny/dist/modules/src/misc.js
 /*!
@@ -8366,6 +8766,7 @@ class Quality {
     return Math.round(finalBitrate / 1000) * 1000;
   }
 }
+var QUALITY_HIGH = /* @__PURE__ */ new Quality(2);
 
 // ../../node_modules/mediabunny/dist/modules/src/media-source.js
 /*!
@@ -9731,6 +10132,8 @@ class RecorderWorker {
   baseVideoTimestamp = null;
   frameCount = 0;
   config = null;
+  lastKeyFrameTimestamp = 0;
+  forceNextKeyFrame = false;
   videoProcessingActive = false;
   audioProcessingActive = false;
   isStopping = false;
@@ -9819,54 +10222,50 @@ class RecorderWorker {
     }
     this.sendError(new Error(\`Unknown message type: \${message.type}\`));
   };
-  async handleStart(videoStream, audioStream, config, overlayConfig) {
+  validateConfig(config) {
     requireDefined(config, "Transcode config is required");
-    if (config.width <= 0 || config.height <= 0) {
-      throw new Error("Video dimensions must be greater than zero");
+    if (config.width !== undefined && config.width <= 0) {
+      throw new Error("Video width must be greater than zero");
     }
-    if (config.fps <= 0) {
+    if (config.height !== undefined && config.height <= 0) {
+      throw new Error("Video height must be greater than zero");
+    }
+    if (config.fps !== undefined && config.fps <= 0) {
       throw new Error("Frame rate must be greater than zero");
     }
-    if (config.bitrate <= 0) {
+    if (config.bitrate !== undefined && typeof config.bitrate === "number" && config.bitrate <= 0) {
       throw new Error("Bitrate must be greater than zero");
     }
     if (config.keyFrameInterval <= 0) {
       throw new Error("Key frame interval must be greater than zero");
     }
-    logger.debug("[RecorderWorker] handleStart called", {
-      hasVideoStream: !!videoStream,
-      hasAudioStream: !!audioStream,
-      config: {
-        width: config.width,
-        height: config.height,
-        fps: config.fps,
-        bitrate: config.bitrate
-      },
-      hasOverlayConfig: !!overlayConfig,
-      overlayConfig
-    });
-    this.isStopping = false;
-    this.isFinalized = false;
-    if (this.output) {
-      logger.debug("[RecorderWorker] Cleaning up existing output");
-      await this.cleanup();
+  }
+  validateFormat(format) {
+    if (format !== "mp4") {
+      throw new Error(\`Format \${format} is not yet supported in worker. Only MP4 is currently supported.\`);
     }
+  }
+  initializeRecordingState(config) {
     this.config = config;
-    this.frameRate = config.fps;
+    this.frameRate = config.fps || 30;
     this.isPaused = false;
     this.isMuted = false;
     this.lastVideoTimestamp = 0;
     this.lastAudioTimestamp = 0;
     this.baseVideoTimestamp = null;
     this.frameCount = 0;
+    this.lastKeyFrameTimestamp = 0;
+    this.forceNextKeyFrame = false;
     this.pausedDuration = 0;
     this.pauseStartedAt = null;
-    this.overlayConfig = overlayConfig ? { enabled: overlayConfig.enabled, text: overlayConfig.text } : null;
     this.overlayCanvas = null;
     this.hiddenIntervals = [];
     this.currentHiddenIntervalStart = null;
-    this.recordingStartTime = overlayConfig?.recordingStartTime !== undefined ? overlayConfig.recordingStartTime / 1000 : performance.now() / 1000;
     this.pendingVisibilityUpdates = [];
+  }
+  setupOverlayConfig(overlayConfig) {
+    this.overlayConfig = overlayConfig ? { enabled: overlayConfig.enabled, text: overlayConfig.text } : null;
+    this.recordingStartTime = overlayConfig?.recordingStartTime !== undefined ? overlayConfig.recordingStartTime / 1000 : performance.now() / 1000;
     const logData = {
       hasOverlayConfig: !!this.overlayConfig,
       overlayEnabled: this.overlayConfig?.enabled,
@@ -9874,15 +10273,13 @@ class RecorderWorker {
       recordingStartTime: this.recordingStartTime
     };
     logger.debug("[RecorderWorker] Overlay config initialized", logData);
+  }
+  createOutput() {
     const writable = new WritableStream({
       write: (chunk) => {
         this.sendChunk(chunk.data, chunk.position);
       }
     });
-    const format = config.format || "mp4";
-    if (format !== "mp4") {
-      throw new Error(\`Format \${format} is not yet supported in worker. Only MP4 is currently supported.\`);
-    }
     this.output = new Output({
       format: new Mp4OutputFormat({
         fastStart: "fragmented"
@@ -9892,27 +10289,75 @@ class RecorderWorker {
         chunkSize: CHUNK_SIZE
       })
     });
-    this.videoSource = new VideoSampleSource({
+  }
+  createVideoSource(config) {
+    const fps = config.fps || 30;
+    const keyFrameIntervalSeconds = config.keyFrameInterval / fps;
+    const videoSourceOptions = {
       codec: config.codec,
-      bitrate: config.bitrate,
-      sizeChangeBehavior: "passThrough"
-    });
-    this.output.addVideoTrack(this.videoSource);
-    if (videoStream) {
-      this.setupVideoProcessing(videoStream);
+      sizeChangeBehavior: "passThrough",
+      bitrateMode: "variable",
+      latencyMode: "quality",
+      contentHint: "detail",
+      hardwareAcceleration: "prefer-hardware",
+      keyFrameInterval: keyFrameIntervalSeconds,
+      bitrate: config.bitrate ?? QUALITY_HIGH
+    };
+    this.videoSource = new VideoSampleSource(videoSourceOptions);
+    const output = requireNonNull(this.output, "Output must be initialized before adding video track");
+    const trackOptions = {};
+    if (fps !== undefined) {
+      trackOptions.frameRate = fps;
     }
+    output.addVideoTrack(this.videoSource, trackOptions);
+  }
+  setupAudioSource(audioStream, config) {
     if (audioStream && config.audioBitrate && config.audioCodec) {
       if (config.audioBitrate <= 0) {
         throw new Error("Audio bitrate must be greater than zero");
       }
       this.audioSource = new AudioSampleSource({
         codec: config.audioCodec,
-        bitrate: config.audioBitrate
+        bitrate: config.audioBitrate,
+        bitrateMode: "variable"
       });
-      this.output.addAudioTrack(this.audioSource);
+      const output = requireNonNull(this.output, "Output must be initialized before adding audio track");
+      output.addAudioTrack(this.audioSource);
       this.setupAudioProcessing(audioStream);
     }
-    await this.output.start();
+  }
+  async handleStart(videoStream, audioStream, config, overlayConfig) {
+    this.validateConfig(config);
+    logger.debug("[RecorderWorker] handleStart called", {
+      hasVideoStream: !!videoStream,
+      hasAudioStream: !!audioStream,
+      config: {
+        width: config.width,
+        height: config.height,
+        fps: config.fps,
+        bitrate: config.bitrate
+      },
+      hasOverlayConfig: !!overlayConfig,
+      overlayConfig
+    });
+    this.isStopping = false;
+    this.isFinalized = false;
+    if (this.output) {
+      logger.debug("[RecorderWorker] Cleaning up existing output");
+      await this.cleanup();
+    }
+    this.initializeRecordingState(config);
+    this.setupOverlayConfig(overlayConfig);
+    const format = config.format || "mp4";
+    this.validateFormat(format);
+    this.createOutput();
+    this.createVideoSource(config);
+    if (videoStream) {
+      this.setupVideoProcessing(videoStream);
+    }
+    this.setupAudioSource(audioStream, config);
+    const output = requireNonNull(this.output, "Output must be initialized before starting");
+    await output.start();
     this.startBufferUpdates();
     this.sendReady();
     this.sendStateChange("recording");
@@ -10157,8 +10602,6 @@ class RecorderWorker {
         }
       }
     }
-    const keyFrameInterval = config.keyFrameInterval > 0 ? config.keyFrameInterval : 5;
-    const isKeyFrame = this.frameCount % keyFrameInterval === 0;
     const maxLead = 0.05;
     const maxLag = 0.1;
     const targetAudio = this.lastAudioTimestamp;
@@ -10170,6 +10613,10 @@ class RecorderWorker {
     }
     const monotonicTimestamp = this.lastVideoTimestamp + frameDuration;
     const finalTimestamp = adjustedTimestamp >= monotonicTimestamp ? adjustedTimestamp : monotonicTimestamp;
+    const keyFrameIntervalFrames = config.keyFrameInterval > 0 ? config.keyFrameInterval : 5;
+    const keyFrameIntervalSeconds = keyFrameIntervalFrames / this.frameRate;
+    const timeSinceLastKeyFrame = finalTimestamp - this.lastKeyFrameTimestamp;
+    const isKeyFrame = this.forceNextKeyFrame || timeSinceLastKeyFrame >= keyFrameIntervalSeconds || this.frameCount % keyFrameIntervalFrames === 0;
     this.driftOffset *= 0.5;
     const sample = new VideoSample(frameToProcess, {
       timestamp: finalTimestamp,
@@ -10184,6 +10631,10 @@ class RecorderWorker {
     if (!addError) {
       this.frameCount += 1;
       this.lastVideoTimestamp = finalTimestamp;
+      if (isKeyFrame) {
+        this.lastKeyFrameTimestamp = finalTimestamp;
+        this.forceNextKeyFrame = false;
+      }
       if (this.frameCount % 90 === 0 && this.audioProcessingActive) {
         const avDrift = this.lastAudioTimestamp - this.lastVideoTimestamp;
         logger.debug("[RecorderWorker] AV drift metrics", {
@@ -10460,6 +10911,7 @@ class RecorderWorker {
     const previousVideoTimestamp = this.lastVideoTimestamp;
     this.lastVideoTimestamp = continuationTimestamp;
     this.frameCount = 0;
+    this.forceNextKeyFrame = true;
     logger.debug("[RecorderWorker] handleSwitchSource - preserving baseVideoTimestamp", {
       continuationTimestamp,
       lastVideoTimestamp: this.lastVideoTimestamp,
@@ -10512,6 +10964,8 @@ class RecorderWorker {
     this.lastAudioTimestamp = 0;
     this.baseVideoTimestamp = null;
     this.frameCount = 0;
+    this.lastKeyFrameTimestamp = 0;
+    this.forceNextKeyFrame = false;
     this.totalSize = 0;
     this.pausedDuration = 0;
     this.pauseStartedAt = null;
@@ -10566,7 +11020,6 @@ new RecorderWorker;
 
 // src/core/processor/worker-processor.ts
 var KEY_FRAME_INTERVAL = 5;
-var H264_CODEC = "avc";
 var workerBlobUrl = null;
 function getWorkerUrl() {
   if (workerBlobUrl) {
@@ -10687,20 +11140,21 @@ class WorkerProcessor {
     const format = config.format || "mp4";
     const audioCodec = config.audioCodec || getDefaultAudioCodecForFormat(format);
     const isScreenCapture = isScreenCaptureStream(stream);
-    const targetFps = config.fps;
+    const codec = config.codec || await detectBestCodec(config.width, config.height, config.bitrate);
     logger.debug("[WorkerProcessor] Starting processing", {
       isScreenCapture,
-      targetFps,
-      originalFps: config.fps
+      fps: config.fps,
+      codec,
+      bitrate: config.bitrate
     });
     const workerConfig = {
       width: config.width,
       height: config.height,
-      fps: targetFps,
+      fps: config.fps,
       bitrate: config.bitrate,
       audioCodec,
       audioBitrate: config.audioBitrate,
-      codec: H264_CODEC,
+      codec,
       keyFrameInterval: KEY_FRAME_INTERVAL,
       format
     };
@@ -11748,113 +12202,6 @@ class QuotaManager {
     return quota.percentage >= threshold;
   }
 }
-// src/core/transcode/video-transcoder.ts
-import {
-  BlobSource as BlobSource2,
-  BufferTarget,
-  Conversion,
-  FilePathSource,
-  Input as Input2,
-  MP4 as MP42,
-  Mp4OutputFormat,
-  Output
-} from "mediabunny";
-function createSource(input) {
-  if (typeof input === "string") {
-    return new FilePathSource(input);
-  }
-  if (input instanceof Blob) {
-    return new BlobSource2(input);
-  }
-  throw new Error("Invalid input type. Expected Blob, File, or file path string.");
-}
-function createOutputFormat(format) {
-  switch (format) {
-    case "mp4":
-      return new Mp4OutputFormat;
-    case "webm":
-    case "mkv":
-    case "mov":
-      throw new Error(`Format ${format} is not yet supported. Only MP4 is currently supported.`);
-    default:
-      throw new Error(`Unsupported output format: ${format}`);
-  }
-}
-function getMimeTypeForFormat(format) {
-  switch (format) {
-    case "mp4":
-      return "video/mp4";
-    case "webm":
-      return "video/webm";
-    case "mkv":
-      return "video/x-matroska";
-    case "mov":
-      return "video/quicktime";
-    default:
-      throw new Error(`Unsupported output format: ${format}`);
-  }
-}
-function createConversionOptions(config) {
-  const audioCodec = getAudioCodecForFormat(config.format, config.audioCodec);
-  const video = {
-    width: config.width,
-    height: config.height,
-    fit: "contain",
-    frameRate: config.fps,
-    bitrate: config.bitrate,
-    forceTranscode: true
-  };
-  const audio = {
-    codec: 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,
-    format: config.format || DEFAULT_TRANSCODE_CONFIG.format
-  };
-  if (!finalConfig.audioCodec) {
-    finalConfig.audioCodec = getDefaultAudioCodecForFormat(finalConfig.format);
-  }
-  const source = createSource(input);
-  const mediabunnyInput = new Input2({
-    formats: [MP42],
-    source
-  });
-  const outputFormat = createOutputFormat(finalConfig.format);
-  const output = new Output({
-    format: outputFormat,
-    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");
-  }
-  const mimeType = getMimeTypeForFormat(finalConfig.format);
-  return {
-    buffer,
-    blob: new Blob([buffer], { type: mimeType })
-  };
-}
 // src/core/utils/audio-utils.ts
 function calculateBarColor(position) {
   if (position < 0.25) {
@@ -11872,6 +12219,23 @@ 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/core/utils/device-detection.ts
+import { UAParser } from "ua-parser-js";
+function isMobileDevice() {
+  const parser = new UAParser;
+  const result = parser.getResult();
+  const deviceType = result.device.type;
+  const isMobile = deviceType === "mobile" || deviceType === "tablet";
+  logger.debug("Mobile detection result", {
+    userAgent: navigator.userAgent,
+    deviceType,
+    isMobile,
+    device: result.device,
+    os: result.os,
+    browser: result.browser
+  });
+  return isMobile;
+}
 // src/vidtreo-recorder.ts
 class VidtreoRecorder {
   controller;
@@ -12075,6 +12439,8 @@ class VidtreoRecorder {
   }
 }
 export {
+  validateFile,
+  transcodeVideoForNativeCamera,
   transcodeVideo,
   requireStream,
   requireProcessor,
@@ -12084,12 +12450,14 @@ export {
   requireActive,
   mapPresetToConfig,
   logger,
+  isMobileDevice,
   getDefaultConfigForFormat,
   getDefaultAudioCodecForFormat,
   getAudioCodecForFormat,
   formatTime,
   formatFileSize,
   extractVideoDuration,
+  extractLastFrame,
   extractErrorMessage,
   calculateBarColor,
   VidtreoRecorder,
@@ -12101,6 +12469,7 @@ export {
   RecordingManager,
   RecorderController,
   QuotaManager,
+  NativeCameraHandler,
   FORMAT_DEFAULT_CODECS,
   DeviceManager,
   DEFAULT_TRANSCODE_CONFIG,