@vidtreo/recorder 0.9.2 → 0.9.3

package/dist/index.d.ts

@@ -138,6 +138,52 @@ export declare class VidtreoRecorder {
     private ensureInitialized;
 }
 
+export type NativeCameraFile = {
+    file: File;
+    previewUrl: string;
+    duration: number;
+    validated: boolean;
+};
+export type FileValidationResult = {
+    valid: boolean;
+    error?: string;
+};
+export type NativeCameraConfig = {
+    maxFileSize?: number;
+    maxDuration?: number;
+    allowedFormats?: string[];
+};
+
+export declare function validateFile(file: File, config?: {
+    maxFileSize?: number;
+    maxRecordingTime?: number | null;
+    allowedFormats?: string[];
+}): Promise<FileValidationResult>;
+
+import type { RecordingStopResult } from "../../vidtreo-recorder";
+import type { ConfigService } from "../config/config-service";
+import type { VideoUploadService } from "../upload/upload-service";
+export type NativeCameraHandlerConfig = {
+    apiKey?: string | null;
+    backendUrl?: string | null;
+    maxRecordingTime?: number | null;
+    maxFileSize?: number;
+    userMetadata?: Record<string, unknown>;
+};
+export declare class NativeCameraHandler {
+    private pendingFile;
+    private readonly configService;
+    private readonly uploadService;
+    private readonly config;
+    constructor(config: NativeCameraHandlerConfig, configService: ConfigService | null, uploadService: VideoUploadService);
+    handleFileSelection(file: File): Promise<NativeCameraFile>;
+    processAndUpload(onTranscodeProgress: (progress: number) => void, onUploadProgress: (progress: number) => void): Promise<RecordingStopResult>;
+    cancel(): void;
+    preloadConfig(): Promise<void>;
+}
+
+export declare function extractLastFrame(file: File, timeoutMs?: number): Promise<Blob>;
+
 export type VideoUploadOptions = {
     apiKey: string;
     backendUrl: string;
@@ -278,6 +324,8 @@ export declare function requireInitialized<T>(value: T | null | undefined, compo
 export declare function requireStream(stream: MediaStream | null, message?: string): MediaStream;
 export declare function requireProcessor<T>(processor: T | null, componentName?: string): T;
 
+export declare function isMobileDevice(): boolean;
+
 export declare function extractErrorMessage(error: unknown): string;
 
 export declare const FILE_SIZE_UNITS: readonly ["Bytes", "KB", "MB", "GB"];
@@ -285,7 +333,7 @@ export declare const FILE_SIZE_BASE = 1024;
 export declare function formatFileSize(bytes: number): string;
 export declare function formatTime(totalSeconds: number): string;
 
-export declare function extractVideoDuration(blob: Blob): Promise<number>;
+export declare function extractVideoDuration(file: File | Blob): Promise<number>;
 
 export type StorageQuota = {
     usage: number;
@@ -888,8 +936,9 @@ export type BackendConfigResponse = {
     presetEncoding: BackendPreset;
     max_width: number;
     max_height: number;
+    outputFormat?: "mp4" | "webm" | "mkv" | "mov";
 };
-export declare function mapPresetToConfig(preset: BackendPreset, maxWidth: number, maxHeight: number, format?: TranscodeConfig["format"]): TranscodeConfig;
+export declare function mapPresetToConfig(preset: BackendPreset, maxWidth: number, maxHeight: number, outputFormat?: TranscodeConfig["format"]): TranscodeConfig;
 
 import type { TranscodeConfig } from "../transcode/transcode-types";
 export declare const DEFAULT_BACKEND_URL = "https://api.vidtreo.com";
@@ -920,6 +969,7 @@ export type TranscodeResult = {
 };
 
 export declare function transcodeVideo(input: TranscodeInput, config?: Partial<TranscodeConfig>, onProgress?: (progress: number) => void): Promise<TranscodeResult>;
+export declare function transcodeVideoForNativeCamera(file: File, config?: Partial<TranscodeConfig>, onProgress?: (progress: number) => void): Promise<TranscodeResult>;
 
 import type { AudioLevelCallbacks } from "../audio/types";
 import type { DeviceCallbacks } from "../device/types";
@@ -950,6 +1000,7 @@ export type RecorderConfig = {
     enableDeviceChange?: boolean;
     enableTabVisibilityOverlay?: boolean;
     tabVisibilityOverlayText?: string;
+    nativeCamera?: boolean;
 };
 export type RecorderCallbacks = {
     recording?: Partial<RecordingCallbacks>;

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;
@@ -2611,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();
@@ -11850,124 +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 = {
-    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 +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;
@@ -12188,6 +12439,8 @@ class VidtreoRecorder {
   }
 }
 export {
+  validateFile,
+  transcodeVideoForNativeCamera,
   transcodeVideo,
   requireStream,
   requireProcessor,
@@ -12197,12 +12450,14 @@ export {
   requireActive,
   mapPresetToConfig,
   logger,
+  isMobileDevice,
   getDefaultConfigForFormat,
   getDefaultAudioCodecForFormat,
   getAudioCodecForFormat,
   formatTime,
   formatFileSize,
   extractVideoDuration,
+  extractLastFrame,
   extractErrorMessage,
   calculateBarColor,
   VidtreoRecorder,
@@ -12214,6 +12469,7 @@ export {
   RecordingManager,
   RecorderController,
   QuotaManager,
+  NativeCameraHandler,
   FORMAT_DEFAULT_CODECS,
   DeviceManager,
   DEFAULT_TRANSCODE_CONFIG,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vidtreo/recorder",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "type": "module",
   "description": "Vidtreo SDK for browser-based video recording and transcoding. Features include camera/screen recording, real-time MP4 transcoding, audio level analysis, mute/pause controls, source switching, device selection, and automatic backend uploads. Similar to Ziggeo and Addpipe, Vidtreo provides enterprise-grade video processing capabilities for web applications.",
   "main": "./dist/index.js",
@@ -44,7 +44,8 @@
   "author": "cfonseca@vidtreo.com",
   "license": "MIT",
   "dependencies": {
-    "mediabunny": "^1.25.8"
+    "mediabunny": "^1.25.8",
+    "ua-parser-js": "^2.0.7"
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.0.11",