@vidtreo/recorder 0.9.2 → 0.9.4

package/dist/index.js

@@ -203,7 +203,7 @@ var QUALITY_MAP = {
   "4k": QUALITY_VERY_HIGH
 };
 var AUDIO_BITRATE = 128000;
-function mapPresetToConfig(preset, maxWidth, maxHeight, format = "mp4") {
+function mapPresetToConfig(preset, maxWidth, maxHeight, outputFormat) {
   if (!(preset in QUALITY_MAP)) {
     throw new Error(`Invalid preset: ${preset}`);
   }
@@ -213,6 +213,7 @@ 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,
@@ -310,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);
   }
 }
 
@@ -403,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;
@@ -1560,6 +1961,10 @@ class StreamManager {
     this.setState("starting");
     logger.debug("[StreamManager] State set to 'starting'");
     try {
+      logger.debug("[StreamManager] Building constraints", {
+        selectedVideoDeviceId: this.selectedVideoDeviceId,
+        selectedAudioDeviceId: this.selectedAudioDeviceId
+      });
       const constraints = {
         video: this.buildVideoConstraints(this.selectedVideoDeviceId),
         audio: this.buildAudioConstraints(this.selectedAudioDeviceId)
@@ -2611,55 +3016,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();
@@ -2671,6 +3027,35 @@ function isScreenCaptureStream(stream) {
   return "displaySurface" in settings || videoTrack.label.toLowerCase().includes("screen") || videoTrack.label.toLowerCase().includes("display");
 }
 
+// src/core/processor/bitrate-utils.ts
+import {
+  QUALITY_HIGH as QUALITY_HIGH3,
+  QUALITY_LOW as QUALITY_LOW2,
+  QUALITY_MEDIUM as QUALITY_MEDIUM2,
+  QUALITY_VERY_HIGH as QUALITY_VERY_HIGH2
+} from "mediabunny";
+function serializeBitrate(bitrate) {
+  if (bitrate === undefined) {
+    return;
+  }
+  if (typeof bitrate === "number") {
+    return bitrate;
+  }
+  if (bitrate === QUALITY_LOW2) {
+    return "low";
+  }
+  if (bitrate === QUALITY_MEDIUM2) {
+    return "medium";
+  }
+  if (bitrate === QUALITY_HIGH3) {
+    return "high";
+  }
+  if (bitrate === QUALITY_VERY_HIGH2) {
+    return "very-high";
+  }
+  return "high";
+}
+
 // src/core/processor/codec-detector.ts
 async function detectBestCodec(width, height, bitrate) {
   try {
@@ -8414,7 +8799,10 @@ class Quality {
     return Math.round(finalBitrate / 1000) * 1000;
   }
 }
+var QUALITY_LOW = /* @__PURE__ */ new Quality(0.6);
+var QUALITY_MEDIUM = /* @__PURE__ */ new Quality(1);
 var QUALITY_HIGH = /* @__PURE__ */ new Quality(2);
+var QUALITY_VERY_HIGH = /* @__PURE__ */ new Quality(4);
 
 // ../../node_modules/mediabunny/dist/modules/src/media-source.js
 /*!
@@ -9949,7 +10337,7 @@ class RecorderWorker {
       contentHint: "detail",
       hardwareAcceleration: "prefer-hardware",
       keyFrameInterval: keyFrameIntervalSeconds,
-      bitrate: config.bitrate ?? QUALITY_HIGH
+      bitrate: this.deserializeBitrate(config.bitrate)
     };
     this.videoSource = new VideoSampleSource(videoSourceOptions);
     const output = requireNonNull(this.output, "Output must be initialized before adding video track");
@@ -10662,6 +11050,24 @@ class RecorderWorker {
     };
     self.postMessage(response);
   }
+  deserializeBitrate(bitrate) {
+    if (typeof bitrate === "number") {
+      return bitrate;
+    }
+    if (bitrate === "low") {
+      return QUALITY_LOW;
+    }
+    if (bitrate === "medium") {
+      return QUALITY_MEDIUM;
+    }
+    if (bitrate === "high") {
+      return QUALITY_HIGH;
+    }
+    if (bitrate === "very-high") {
+      return QUALITY_VERY_HIGH;
+    }
+    return QUALITY_HIGH;
+  }
 }
 new RecorderWorker;
 `;
@@ -10799,7 +11205,7 @@ class WorkerProcessor {
       width: config.width,
       height: config.height,
       fps: config.fps,
-      bitrate: config.bitrate,
+      bitrate: serializeBitrate(config.bitrate),
       audioCodec,
       audioBitrate: config.audioBitrate,
       codec,
@@ -11850,124 +12256,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 = {
-    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;
-  }
-  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) {
@@ -11985,6 +12273,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;
@@ -12188,6 +12493,8 @@ class VidtreoRecorder {
   }
 }
 export {
+  validateFile,
+  transcodeVideoForNativeCamera,
   transcodeVideo,
   requireStream,
   requireProcessor,
@@ -12197,12 +12504,14 @@ export {
   requireActive,
   mapPresetToConfig,
   logger,
+  isMobileDevice,
   getDefaultConfigForFormat,
   getDefaultAudioCodecForFormat,
   getAudioCodecForFormat,
   formatTime,
   formatFileSize,
   extractVideoDuration,
+  extractLastFrame,
   extractErrorMessage,
   calculateBarColor,
   VidtreoRecorder,
@@ -12214,6 +12523,7 @@ export {
   RecordingManager,
   RecorderController,
   QuotaManager,
+  NativeCameraHandler,
   FORMAT_DEFAULT_CODECS,
   DeviceManager,
   DEFAULT_TRANSCODE_CONFIG,