@vidtreo/recorder 1.6.3 → 1.7.0

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export type StopRecordingResult = {
     tabVisibilityIntervals: VisibilityInterval[];
     recordingStats?: StreamRecordingStats;
     encoderAcceleration?: VideoHardwareAcceleration;
+    mediaRecorderDiagnostics?: Record<string, unknown>;
 };
 type CheckRecorderSupportDependency = (options: SupportCheckOptions) => Promise<SupportReport>;
 type GetCurrentTimestampDependency = () => number;
@@ -32,6 +33,8 @@ export declare class StreamRecordingState {
     private mediaRecorderStopPromise;
     private mediaRecorderStopResolve;
     private mediaRecorderStopReject;
+    private mediaRecorderError;
+    private mediaRecorderErrorTimeoutId;
     private readonly streamManager;
     private readonly dependencies;
     constructor(streamManager: StreamManager, dependencies?: Partial<StreamRecordingStateDependencies>);
@@ -60,6 +63,14 @@ export declare class StreamRecordingState {
     private stopSafeCaptureRecording;
     private resolveSafeCaptureMimeType;
     private resolvePreferredSafeCaptureMimeType;
+    private shouldPreferWebmSafeCapture;
+    private scheduleMediaRecorderErrorFinalizeTimeout;
+    private clearMediaRecorderErrorTimeout;
+    private createMediaRecorderError;
+    private createEmptyMediaRecorderError;
+    private updateMediaRecorderErrorDiagnostics;
+    private buildMediaRecorderDiagnostics;
+    private getMediaRecorderChunkSize;
     private resetPauseState;
     private resolveTabVisibilityOverlayText;
     private setupVisibilityUpdates;
@@ -1336,6 +1347,7 @@ export declare class TelemetryClient {
     private isSafeCapabilityValue;
     private isRouteSourceType;
     private buildErrorProperties;
+    private buildMediaRecorderErrorProperties;
     private buildFingerprint;
     private buildContext;
     private buildError;
@@ -2453,7 +2465,7 @@ export declare function deserializeBitrate(bitrate: number | string | undefined)
 import type { DeviceCapabilityProfile } from "../capabilities/device-capability-profile";
 export type RecordingCapabilityProfile = DeviceCapabilityProfile;
 export type RecordingRoute = "local-webcodecs" | "safe-capture-post-recording-transcode" | "unsupported-with-guidance";
-export type RecordingRouteReasonCode = "webcodecs-supported" | "webcodecs-unavailable" | "target-codec-supported" | "target-codec-unsupported" | "encoding-capability-unsupported" | "encoding-not-smooth" | "encoding-not-power-efficient" | "insufficient-device-memory" | "insufficient-hardware-concurrency" | "insecure-context" | "mediarecorder-supported" | "mediarecorder-unavailable" | "offline";
+export type RecordingRouteReasonCode = "webcodecs-supported" | "webcodecs-unavailable" | "target-codec-supported" | "target-codec-unsupported" | "encoding-capability-unsupported" | "encoding-not-smooth" | "encoding-not-power-efficient" | "insufficient-device-memory" | "insufficient-hardware-concurrency" | "insecure-context" | "mediarecorder-supported" | "mediarecorder-unavailable" | "android-post-recording-transcode" | "offline";
 export type RecordingRouteDecision = {
     route: RecordingRoute;
     reasonCodes: RecordingRouteReasonCode[];
@@ -2781,6 +2793,7 @@ export declare class RecorderController {
     switchAudioDevice(deviceId: string | null): Promise<MediaStream>;
     startRecording(): Promise<void>;
     stopRecording(): Promise<Blob>;
+    private shouldStopStreamAfterStopFailure;
     private sendAudioMissingTelemetry;
     getTabVisibilityOverlayConfig(): {
         enabled: boolean;

package/dist/index.js

@@ -1476,6 +1476,7 @@ async function buildDeviceCapabilityProfile(options = {}) {
 // src/core/routing/recording-route-decision.ts
 var DEFAULT_MIN_DEVICE_MEMORY_GB = 4;
 var DEFAULT_MIN_HARDWARE_CONCURRENCY = 5;
+var PLATFORM_KEYWORD_ANDROID2 = "android";
 var UNSUPPORTED_GUIDANCE_MESSAGE = "Recording is not supported in this browser context. Use a secure connection, go online, and try a current Chrome or Edge browser.";
 function hasSufficientDeviceMemory(profile, minDeviceMemory) {
   const deviceMemory = profile.resources.deviceMemory;
@@ -1530,6 +1531,17 @@ function buildFallbackRouteBlockers(profile) {
   }
   return reasonCodes;
 }
+function isAndroidProfile(profile) {
+  return profile.os.name.toLowerCase().includes(PLATFORM_KEYWORD_ANDROID2);
+}
+function buildPostRecordingTranscodeReasonCodes(profile, localRouteBlockers) {
+  const reasonCodes = [...localRouteBlockers];
+  if (isAndroidProfile(profile)) {
+    reasonCodes.push("android-post-recording-transcode");
+  }
+  reasonCodes.push("mediarecorder-supported");
+  return reasonCodes;
+}
 function hasSupportedEncodingCapability(selectedCodec) {
   const encodingCapability = selectedCodec?.encodingCapability;
   return encodingCapability === undefined || encodingCapability.errorCode !== undefined || encodingCapability.supported === true;
@@ -1554,6 +1566,13 @@ function decideRecordingRoute(options) {
   const hasSmoothEncoding = hasSmoothEncodingCapability(selectedCodec);
   const hasPowerEfficientEncoding = hasPowerEfficientEncodingCapability(selectedCodec);
   const localRouteBlockers = buildLocalRouteBlockers(options.profile, hasSupportedTargetCodec, hasEnoughDeviceMemory, hasEnoughHardwareConcurrency, hasSupportedEncoding, hasSmoothEncoding, hasPowerEfficientEncoding);
+  if (isAndroidProfile(options.profile) && canUsePostRecordingTranscodeRoute(options.profile, hasSupportedTargetCodec)) {
+    return {
+      route: "safe-capture-post-recording-transcode",
+      reasonCodes: buildPostRecordingTranscodeReasonCodes(options.profile, localRouteBlockers),
+      selectedCodecId
+    };
+  }
   if (options.profile.features.isSecureContext && options.profile.features.hasVideoEncoder && hasSupportedTargetCodec && options.profile.network.online !== false && hasEnoughDeviceMemory && hasEnoughHardwareConcurrency && hasSupportedEncoding && hasSmoothEncoding && hasPowerEfficientEncoding) {
     return {
       route: "local-webcodecs",
@@ -1564,7 +1583,7 @@ function decideRecordingRoute(options) {
   if (canUsePostRecordingTranscodeRoute(options.profile, hasSupportedTargetCodec)) {
     return {
       route: "safe-capture-post-recording-transcode",
-      reasonCodes: [...localRouteBlockers, "mediarecorder-supported"],
+      reasonCodes: buildPostRecordingTranscodeReasonCodes(options.profile, localRouteBlockers),
       selectedCodecId
     };
   }
@@ -5246,6 +5265,16 @@ var LOW_RESOURCE_SAFE_CAPTURE_CONSTRAINTS = {
   height: { ideal: 480, max: 480 },
   frameRate: { ideal: 20, max: 20 }
 };
+var ANDROID_SAFE_CAPTURE_CONSTRAINTS = {
+  width: { ideal: 1280, max: 1280 },
+  height: { ideal: 720, max: 720 },
+  frameRate: { ideal: 24, max: 24 }
+};
+var SAFE_CAPTURE_TIMESLICE_MS = 1000;
+var MEDIA_RECORDER_ERROR_FINALIZE_TIMEOUT_MS = 5000;
+var ANDROID_POST_RECORDING_TRANSCODE_REASON = "android-post-recording-transcode";
+var MEDIA_RECORDER_ERROR_CODE = "recording.mediarecorder-error";
+var MEDIA_RECORDER_EMPTY_ERROR_CODE = "recording.mediarecorder-empty";
 function createUnsupportedRouteError(routeDecision) {
   const guidance = routeDecision.guidance?.message ?? "This browser or device cannot safely record video. Try a supported browser or upload an existing video file.";
   const error = new Error(guidance);
@@ -5277,6 +5306,8 @@ class StreamRecordingState {
   mediaRecorderStopPromise = null;
   mediaRecorderStopResolve = null;
   mediaRecorderStopReject = null;
+  mediaRecorderError = null;
+  mediaRecorderErrorTimeoutId = null;
   streamManager;
   dependencies;
   constructor(streamManager, dependencies) {
@@ -5449,9 +5480,11 @@ class StreamRecordingState {
     }
     let result;
     if (this.activeRouteDecision.route === "safe-capture-post-recording-transcode") {
+      const safeCaptureResult = await this.stopSafeCaptureRecording();
       logger.debug("[StreamRecordingState] Finalizing MediaRecorder capture");
       result = {
-        blob: await this.stopSafeCaptureRecording()
+        blob: safeCaptureResult.blob,
+        mediaRecorderDiagnostics: safeCaptureResult.diagnostics
       };
     } else {
       logger.debug("[StreamRecordingState] Finalizing stream processor");
@@ -5470,7 +5503,8 @@ class StreamRecordingState {
       blob: result.blob,
       tabVisibilityIntervals,
       recordingStats: result.recordingStats,
-      encoderAcceleration: result.encoderAcceleration
+      encoderAcceleration: result.encoderAcceleration,
+      mediaRecorderDiagnostics: result.mediaRecorderDiagnostics
     };
   }
   pauseRecording() {
@@ -5481,6 +5515,9 @@ class StreamRecordingState {
     if (this.tabVisibilityTracker) {
       this.tabVisibilityTracker.pause();
     }
+    if (this.mediaRecorder?.state === "recording") {
+      this.mediaRecorder.pause?.();
+    }
     if (this.streamProcessor && this.isRecording()) {
       this.streamProcessor.pause();
     }
@@ -5494,6 +5531,9 @@ class StreamRecordingState {
     if (this.tabVisibilityTracker) {
       this.tabVisibilityTracker.resume();
     }
+    if (this.mediaRecorder?.state === "paused") {
+      this.mediaRecorder.resume?.();
+    }
     this.startRecordingTimer();
     if (this.streamProcessor && this.isRecording()) {
       this.streamProcessor.resume();
@@ -5593,6 +5633,7 @@ class StreamRecordingState {
     }
     await this.applySafeCaptureTrackConstraints(mediaStream);
     this.mediaRecorderChunks = [];
+    this.mediaRecorderError = null;
     const preferredMimeType = this.resolvePreferredSafeCaptureMimeType(config);
     const recorderOptions = preferredMimeType === undefined ? undefined : { mimeType: preferredMimeType };
     const recorder = new MediaRecorder(mediaStream, recorderOptions);
@@ -5601,20 +5642,34 @@ class StreamRecordingState {
       this.mediaRecorderStopResolve = resolve;
       this.mediaRecorderStopReject = reject;
     });
+    this.mediaRecorderStopPromise.catch(() => {
+      return;
+    });
     recorder.ondataavailable = (event) => {
       if (event.data.size > 0) {
         this.mediaRecorderChunks.push(event.data);
       }
     };
     recorder.onstop = () => {
+      this.clearMediaRecorderErrorTimeout();
+      if (this.mediaRecorderError !== null) {
+        this.updateMediaRecorderErrorDiagnostics(recorder);
+        this.mediaRecorderStopReject?.(this.mediaRecorderError);
+        return;
+      }
       const mimeType = recorder.mimeType || this.resolveSafeCaptureMimeType();
       const blob = new Blob(this.mediaRecorderChunks, { type: mimeType });
-      this.mediaRecorderStopResolve?.(blob);
+      const diagnostics = this.buildMediaRecorderDiagnostics(recorder);
+      if (blob.size > 0) {
+        this.mediaRecorderStopResolve?.({ blob, diagnostics });
+        return;
+      }
+      this.mediaRecorderStopReject?.(this.createEmptyMediaRecorderError(recorder));
     };
-    recorder.onerror = () => {
-      this.mediaRecorderStopReject?.(new Error("Browser recording failed before upload could start"));
+    recorder.onerror = (event) => {
+      this.mediaRecorderError = this.createMediaRecorderError(event, recorder);
     };
-    recorder.start();
+    recorder.start(SAFE_CAPTURE_TIMESLICE_MS);
   }
   async applySafeCaptureTrackConstraints(mediaStream) {
     const constraints = this.resolveSafeCaptureVideoConstraints();
@@ -5635,6 +5690,9 @@ class StreamRecordingState {
     if (reasonCodes.includes("insufficient-device-memory") || reasonCodes.includes("insufficient-hardware-concurrency") || reasonCodes.includes("encoding-capability-unsupported") || reasonCodes.includes("encoding-not-smooth") || reasonCodes.includes("encoding-not-power-efficient")) {
       return LOW_RESOURCE_SAFE_CAPTURE_CONSTRAINTS;
     }
+    if (reasonCodes.includes(ANDROID_POST_RECORDING_TRANSCODE_REASON)) {
+      return ANDROID_SAFE_CAPTURE_CONSTRAINTS;
+    }
     return null;
   }
   async stopSafeCaptureRecording() {
@@ -5646,6 +5704,7 @@ class StreamRecordingState {
     if (recorder.state !== "inactive") {
       recorder.stop();
     }
+    this.scheduleMediaRecorderErrorFinalizeTimeout(recorder);
     try {
       return await stopPromise;
     } finally {
@@ -5654,6 +5713,8 @@ class StreamRecordingState {
       this.mediaRecorderStopPromise = null;
       this.mediaRecorderStopResolve = null;
       this.mediaRecorderStopReject = null;
+      this.mediaRecorderError = null;
+      this.clearMediaRecorderErrorTimeout();
       this.activeRouteDecision = DEFAULT_ROUTE_DECISION;
     }
   }
@@ -5669,17 +5730,110 @@ class StreamRecordingState {
       }
       return MediaRecorder.isTypeSupported(mimeType);
     };
-    const candidateMimeTypes = config.format === "mp4" ? [
-      "video/mp4;codecs=avc1.42E01E,mp4a.40.2",
-      "video/mp4;codecs=avc1.42001f,mp4a.40.2",
-      "video/mp4"
-    ] : [
+    const webmCandidateMimeTypes = [
       "video/webm;codecs=vp8,opus",
       "video/webm;codecs=vp9,opus",
       "video/webm"
     ];
+    const mp4CandidateMimeTypes = [
+      "video/mp4;codecs=avc1.42E01E,mp4a.40.2",
+      "video/mp4;codecs=avc1.42001f,mp4a.40.2",
+      "video/mp4"
+    ];
+    let candidateMimeTypes = mp4CandidateMimeTypes;
+    if (this.shouldPreferWebmSafeCapture(config)) {
+      candidateMimeTypes = [
+        ...webmCandidateMimeTypes,
+        ...mp4CandidateMimeTypes
+      ];
+    } else if (config.format !== "mp4") {
+      candidateMimeTypes = webmCandidateMimeTypes;
+    }
     return candidateMimeTypes.find(canUseMimeType);
   }
+  shouldPreferWebmSafeCapture(config) {
+    if (config.format !== "mp4") {
+      return false;
+    }
+    return this.activeRouteDecision.reasonCodes.includes(ANDROID_POST_RECORDING_TRANSCODE_REASON);
+  }
+  scheduleMediaRecorderErrorFinalizeTimeout(recorder) {
+    if (this.mediaRecorderErrorTimeoutId !== null) {
+      return;
+    }
+    this.mediaRecorderErrorTimeoutId = window.setTimeout(() => {
+      if (this.mediaRecorderError !== null) {
+        this.mediaRecorderStopReject?.(this.mediaRecorderError);
+        return;
+      }
+      this.mediaRecorderStopReject?.(this.createEmptyMediaRecorderError(recorder));
+    }, MEDIA_RECORDER_ERROR_FINALIZE_TIMEOUT_MS);
+  }
+  clearMediaRecorderErrorTimeout() {
+    if (this.mediaRecorderErrorTimeoutId === null) {
+      return;
+    }
+    window.clearTimeout(this.mediaRecorderErrorTimeoutId);
+    this.mediaRecorderErrorTimeoutId = null;
+  }
+  createMediaRecorderError(event, recorder) {
+    const mediaRecorderEvent = event;
+    const browserError = mediaRecorderEvent.error;
+    const error = new Error("Browser recording failed before upload could start");
+    error.name = "MediaRecorderRecordingError";
+    error.code = MEDIA_RECORDER_ERROR_CODE;
+    error.mediaRecorderMimeType = recorder.mimeType;
+    error.mediaRecorderChunkCount = this.mediaRecorderChunks.length;
+    error.mediaRecorderChunkSize = this.getMediaRecorderChunkSize();
+    if (browserError?.name) {
+      error.mediaRecorderErrorName = browserError.name;
+    }
+    if (browserError?.message) {
+      error.mediaRecorderErrorMessage = browserError.message;
+    }
+    return error;
+  }
+  createEmptyMediaRecorderError(recorder) {
+    const error = new Error("Browser recording produced no data before upload could start");
+    error.name = "MediaRecorderEmptyDataError";
+    error.code = MEDIA_RECORDER_EMPTY_ERROR_CODE;
+    error.mediaRecorderMimeType = recorder.mimeType;
+    error.mediaRecorderChunkCount = this.mediaRecorderChunks.length;
+    error.mediaRecorderChunkSize = this.getMediaRecorderChunkSize();
+    if (this.mediaRecorderError?.mediaRecorderErrorName) {
+      error.mediaRecorderErrorName = this.mediaRecorderError.mediaRecorderErrorName;
+    }
+    if (this.mediaRecorderError?.mediaRecorderErrorMessage) {
+      error.mediaRecorderErrorMessage = this.mediaRecorderError.mediaRecorderErrorMessage;
+    }
+    return error;
+  }
+  updateMediaRecorderErrorDiagnostics(recorder) {
+    if (this.mediaRecorderError === null) {
+      return;
+    }
+    this.mediaRecorderError.mediaRecorderMimeType = recorder.mimeType;
+    this.mediaRecorderError.mediaRecorderChunkCount = this.mediaRecorderChunks.length;
+    this.mediaRecorderError.mediaRecorderChunkSize = this.getMediaRecorderChunkSize();
+  }
+  buildMediaRecorderDiagnostics(recorder) {
+    const diagnostics = {
+      mediaRecorderMimeType: recorder.mimeType,
+      mediaRecorderChunkCount: this.mediaRecorderChunks.length,
+      mediaRecorderChunkSize: this.getMediaRecorderChunkSize(),
+      mediaRecorderHadError: this.mediaRecorderError !== null
+    };
+    if (this.mediaRecorderError?.mediaRecorderErrorName) {
+      diagnostics.mediaRecorderErrorName = this.mediaRecorderError.mediaRecorderErrorName;
+    }
+    if (this.mediaRecorderError?.mediaRecorderErrorMessage) {
+      diagnostics.mediaRecorderErrorMessage = this.mediaRecorderError.mediaRecorderErrorMessage;
+    }
+    return diagnostics;
+  }
+  getMediaRecorderChunkSize() {
+    return this.mediaRecorderChunks.reduce((total, chunk) => total + chunk.size, 0);
+  }
   resetPauseState() {
     this.totalPausedTime = 0;
     this.pauseStartTime = null;
@@ -5759,6 +5913,8 @@ class StreamRecordingState {
     this.mediaRecorderStopPromise = null;
     this.mediaRecorderStopResolve = null;
     this.mediaRecorderStopReject = null;
+    this.mediaRecorderError = null;
+    this.clearMediaRecorderErrorTimeout();
     this.activeRouteDecision = DEFAULT_ROUTE_DECISION;
     if (this.streamProcessor) {
       this.streamProcessor.destroy();
@@ -5906,6 +6062,8 @@ var RECORDING_CODEC_UNSUPPORTED_CODES = new Set([
 ]);
 var RECORDING_SERVER_TRANSCODE_FALLBACK_CODES = new Set([
   "recording.post-recording-transcode-fallback",
+  "recording.mediarecorder-empty",
+  "recording.mediarecorder-error",
   "transcode.post-recording-fallback",
   "route.post-recording-transcode-fallback"
 ]);
@@ -6141,7 +6299,7 @@ function resolveDeviceError(input) {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.6.3",
+  version: "1.7.0",
   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",
@@ -6226,6 +6384,13 @@ var MAX_RETRY_ATTEMPTS = 3;
 var MAX_PENDING_EVENTS = 100;
 var BRACKET_ERROR_CODE_PATTERN = /\[([a-z]+(?:[.-][a-z0-9]+)+)\]/i;
 var INLINE_ERROR_CODE_PATTERN = /\b([a-z]+(?:[.-][a-z0-9]+)+)\b/i;
+var MEDIA_RECORDER_ERROR_PROPERTY_KEYS = [
+  "mediaRecorderErrorName",
+  "mediaRecorderErrorMessage",
+  "mediaRecorderMimeType",
+  "mediaRecorderChunkCount",
+  "mediaRecorderChunkSize"
+];
 function resolveInstallationId(dependencies) {
   const storageProvider = dependencies.storageProvider;
   const stored = storageProvider?.getItem(TELEMETRY_STORAGE_KEY);
@@ -6567,6 +6732,23 @@ class TelemetryClient {
         recordingPipelineErrorCode: recordingPipelineCode
       };
     }
+    return {
+      ...properties,
+      ...this.buildMediaRecorderErrorProperties(error)
+    };
+  }
+  buildMediaRecorderErrorProperties(error) {
+    if (!(error && typeof error === "object")) {
+      return {};
+    }
+    const candidate = error;
+    let properties = {};
+    for (const key of MEDIA_RECORDER_ERROR_PROPERTY_KEYS) {
+      const value = candidate[key];
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        properties = { ...properties, [key]: value };
+      }
+    }
     return properties;
   }
   buildFingerprint() {
@@ -22637,6 +22819,9 @@ class RecordingManager {
       if (stopResult.encoderAcceleration !== undefined) {
         telemetryProperties.encoderAcceleration = stopResult.encoderAcceleration;
       }
+      if (stopResult.mediaRecorderDiagnostics !== undefined) {
+        Object.assign(telemetryProperties, stopResult.mediaRecorderDiagnostics);
+      }
       return {
         blob: finalBlob,
         telemetryProperties
@@ -22646,6 +22831,10 @@ class RecordingManager {
       this.handleError(normalizedError);
       this.recordingState = RECORDING_STATE_IDLE;
       this.callbacks.onStateChange(this.recordingState);
+      if (this.streamProcessor) {
+        this.streamProcessor.destroy();
+        this.streamProcessor = null;
+      }
       throw normalizedError;
     } finally {
       this.activeRecordingConfig = null;
@@ -23105,6 +23294,7 @@ class RecorderController {
   }
   async stopRecording() {
     const sourceType = this.getCurrentSourceType();
+    let shouldStopStream = true;
     try {
       const stopResult = await this.telemetryManager.executeActionWithResult({
         requestedEvent: "recording.stop.requested",
@@ -23115,7 +23305,6 @@ class RecorderController {
           await this.sourceSwitchManager.handleRecordingStop().catch(() => {
             throw new Error("Source switch cleanup failed");
           });
-          this.streamManager.stopStream();
           return recordingStopResult;
         },
         properties: {
@@ -23127,11 +23316,22 @@ class RecorderController {
       });
       return stopResult.blob;
     } catch (error) {
+      shouldStopStream = this.shouldStopStreamAfterStopFailure(error);
       if (isAudioMissingError(error)) {
         this.sendAudioMissingTelemetry(error);
       }
       throw error;
+    } finally {
+      if (shouldStopStream) {
+        this.streamManager.stopStream();
+      }
+    }
+  }
+  shouldStopStreamAfterStopFailure(error) {
+    if (!(error && typeof error === "object" && ("code" in error))) {
+      return true;
     }
+    return error.code !== ERROR_RECORDING_STOP_NOT_READY;
   }
   sendAudioMissingTelemetry(error) {
     const properties = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vidtreo/recorder",
-  "version": "1.6.3",
+  "version": "1.7.0",
   "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",