@vidtreo/recorder 1.7.11 → 1.7.12

package/dist/index.js

@@ -6451,7 +6451,7 @@ function resolveDeviceError(input) {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.7.11",
+  version: "1.7.12",
   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",
@@ -8881,12 +8881,14 @@ var workerCode = `(() => {
     }
     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: __accessProp.bind(mod, key),
-          enumerable: true
-        });
+    if (mod && typeof mod === "object" || typeof mod === "function") {
+      for (let key of __getOwnPropNames(mod))
+        if (!__hasOwnProp.call(to, key))
+          __defProp(to, key, {
+            get: __accessProp.bind(mod, key),
+            enumerable: true
+          });
+    }
     if (canCache)
       cache.set(mod, to);
     return to;
@@ -8932,8 +8934,8 @@ var workerCode = `(() => {
   // src/core/processor/worker/recorder-worker.ts
   var exports_recorder_worker = {};
   __export(exports_recorder_worker, {
-    initializeRecorderWorker: () => initializeRecorderWorker,
-    RecorderWorker: () => RecorderWorker
+    RecorderWorker: () => RecorderWorker,
+    initializeRecorderWorker: () => initializeRecorderWorker
   });
 
   // ../../node_modules/.bun/mediabunny@1.45.2/node_modules/mediabunny/dist/modules/src/misc.js
@@ -22899,7 +22901,272 @@ class StreamProcessor {
 }
 
 // src/core/transcode/deferred-video-transcoder.ts
-import { ALL_FORMATS as ALL_FORMATS2, BlobSource as BlobSource3, EncodedPacketSink, Input as Input3 } from "mediabunny";
+import { ALL_FORMATS as ALL_FORMATS3, BlobSource as BlobSource4, EncodedPacketSink as EncodedPacketSink2, Input as Input4 } from "mediabunny";
+
+// src/core/transcode/deferred-video-timing-repair.ts
+import {
+  ALL_FORMATS as ALL_FORMATS2,
+  BlobSource as BlobSource3,
+  BufferTarget as BufferTarget2,
+  EncodedAudioPacketSource,
+  EncodedPacketSink,
+  EncodedVideoPacketSource,
+  Input as Input3,
+  Mp4OutputFormat as Mp4OutputFormat2,
+  Output as Output2
+} from "mediabunny";
+var MINIMUM_IMPLAUSIBLE_DURATION_SECONDS = 60;
+var EXPECTED_DURATION_MULTIPLIER = 2;
+var MAXIMUM_REPAIR_RATIO = 0.05;
+var MINIMUM_REPAIR_LIMIT = 2;
+var MAXIMUM_BOUNDARY_REGRESSION_MULTIPLIER = 2;
+var MINIMUM_BOUNDARY_REGRESSION_TOLERANCE_SECONDS = 0.25;
+function resolveImplausibleDurationThreshold(expectedDurationSeconds) {
+  return Math.max(MINIMUM_IMPLAUSIBLE_DURATION_SECONDS, expectedDurationSeconds * EXPECTED_DURATION_MULTIPLIER);
+}
+function resolveMedian(values) {
+  values.sort((left, right) => left - right);
+  return values[Math.floor(values.length / 2)];
+}
+function validatePacketTimings(packets, expectedDurationSeconds) {
+  if (!Number.isFinite(expectedDurationSeconds) || expectedDurationSeconds < 0) {
+    throw new Error("Timing repair requires a valid recording duration");
+  }
+  if (packets.length === 0) {
+    throw new Error("Timing repair requires video packets");
+  }
+  for (const packet of packets) {
+    if (!Number.isFinite(packet.timestamp)) {
+      throw new Error("Timing repair requires finite packet timestamps");
+    }
+    if (!Number.isFinite(packet.duration) || packet.duration < 0) {
+      throw new Error("Timing repair requires valid packet durations");
+    }
+  }
+}
+function createDeferredVideoTimingRepairPlan(packets, expectedDurationSeconds) {
+  validatePacketTimings(packets, expectedDurationSeconds);
+  const threshold = resolveImplausibleDurationThreshold(expectedDurationSeconds);
+  const packetTimings = packets.map((packet) => ({
+    duration: packet.duration,
+    isDurationRepaired: false,
+    isTimestampRepaired: false,
+    timestamp: packet.timestamp
+  }));
+  const repairIndexes = [];
+  const validDurations = [];
+  for (let index = 0;index < packets.length; index += 1) {
+    const duration = packets[index].duration;
+    if (duration > threshold) {
+      repairIndexes.push(index);
+      continue;
+    }
+    if (duration > 0) {
+      validDurations.push(duration);
+    }
+  }
+  if (repairIndexes.length === 0) {
+    return {
+      nominalDurationSeconds: null,
+      packetTimings,
+      repairedDurationCount: 0,
+      repairedTimestampCount: 0
+    };
+  }
+  const maximumRepairCount = Math.max(MINIMUM_REPAIR_LIMIT, Math.floor(packets.length * MAXIMUM_REPAIR_RATIO));
+  if (repairIndexes.length > maximumRepairCount) {
+    throw new Error("Video timing corruption is not isolated");
+  }
+  if (validDurations.length === 0) {
+    throw new Error("Video timing recovery requires a valid source cadence");
+  }
+  for (let index = 1;index < repairIndexes.length; index += 1) {
+    if (repairIndexes[index] - repairIndexes[index - 1] === 1) {
+      throw new Error("Video timing corruption is not isolated");
+    }
+  }
+  const nominalDurationSeconds = resolveMedian(validDurations);
+  for (const index of repairIndexes) {
+    packetTimings[index].duration = nominalDurationSeconds;
+    packetTimings[index].isDurationRepaired = true;
+  }
+  let repairedTimestampCount = 0;
+  const maximumBoundaryRegression = Math.max(MINIMUM_BOUNDARY_REGRESSION_TOLERANCE_SECONDS, nominalDurationSeconds * MAXIMUM_BOUNDARY_REGRESSION_MULTIPLIER);
+  for (const index of repairIndexes) {
+    const boundaryIndex = index + 1;
+    if (boundaryIndex >= packetTimings.length) {
+      continue;
+    }
+    const repairedPacket = packetTimings[index];
+    const boundaryPacket = packetTimings[boundaryIndex];
+    if (boundaryPacket.timestamp >= repairedPacket.timestamp) {
+      continue;
+    }
+    const regression = repairedPacket.timestamp - boundaryPacket.timestamp;
+    if (regression > maximumBoundaryRegression) {
+      throw new Error("Video timing boundary regression is not recoverable");
+    }
+    boundaryPacket.timestamp = repairedPacket.timestamp + repairedPacket.duration;
+    boundaryPacket.isTimestampRepaired = true;
+    repairedTimestampCount += 1;
+  }
+  return {
+    nominalDurationSeconds,
+    packetTimings,
+    repairedDurationCount: repairIndexes.length,
+    repairedTimestampCount
+  };
+}
+async function readVideoPacketTimings(videoTrack) {
+  const packets = [];
+  const sink = new EncodedPacketSink(videoTrack);
+  for await (const packet of sink.packets(undefined, undefined, {
+    metadataOnly: true
+  })) {
+    packets.push({
+      duration: packet.duration,
+      timestamp: packet.timestamp
+    });
+  }
+  return packets;
+}
+async function addVideoTrack(output, videoTrack, videoSource) {
+  const name = await videoTrack.getName();
+  const metadata = {
+    languageCode: await videoTrack.getLanguageCode(),
+    rotation: await videoTrack.getRotation()
+  };
+  if (name !== null) {
+    metadata.name = name;
+  }
+  output.addVideoTrack(videoSource, metadata);
+}
+async function addAudioTrack(output, audioTrack, audioSource) {
+  const name = await audioTrack.getName();
+  const metadata = {
+    languageCode: await audioTrack.getLanguageCode()
+  };
+  if (name !== null) {
+    metadata.name = name;
+  }
+  output.addAudioTrack(audioSource, metadata);
+}
+async function writeRepairedVideoPackets(videoTrack, videoSource, plan) {
+  const decoderConfig = await videoTrack.getDecoderConfig();
+  const metadata = {};
+  if (decoderConfig !== null) {
+    metadata.decoderConfig = decoderConfig;
+  }
+  let packetIndex = 0;
+  const sink = new EncodedPacketSink(videoTrack);
+  for await (const packet of sink.packets(undefined, undefined, {
+    verifyKeyPackets: true
+  })) {
+    const timing = plan.packetTimings[packetIndex];
+    if (timing === undefined) {
+      throw new Error("Video packet count changed during timing repair");
+    }
+    const outputPacket = timing.isDurationRepaired || timing.isTimestampRepaired ? packet.clone({
+      duration: timing.duration,
+      timestamp: timing.timestamp
+    }) : packet;
+    await videoSource.add(outputPacket, metadata);
+    packetIndex += 1;
+  }
+  if (packetIndex !== plan.packetTimings.length) {
+    throw new Error("Video packet count changed during timing repair");
+  }
+  videoSource.close();
+}
+async function writeAudioPackets(audioTrack, audioSource) {
+  const decoderConfig = await audioTrack.getDecoderConfig();
+  const metadata = {};
+  if (decoderConfig !== null) {
+    metadata.decoderConfig = decoderConfig;
+  }
+  const sink = new EncodedPacketSink(audioTrack);
+  for await (const packet of sink.packets()) {
+    await audioSource.add(packet, metadata);
+  }
+  audioSource.close();
+}
+async function remuxRepairedVideo(input, videoTrack, plan) {
+  const videoCodec = await videoTrack.getCodec();
+  if (videoCodec === null) {
+    throw new Error("Timing repair requires a supported video codec");
+  }
+  const audioTrack = await input.getPrimaryAudioTrack();
+  let audioCodec = null;
+  if (audioTrack !== null) {
+    audioCodec = await audioTrack.getCodec();
+    if (audioCodec === null) {
+      throw new Error("Timing repair requires a supported audio codec");
+    }
+  }
+  const target = new BufferTarget2;
+  const output = new Output2({
+    format: new Mp4OutputFormat2({ fastStart: "in-memory" }),
+    target
+  });
+  const videoSource = new EncodedVideoPacketSource(videoCodec);
+  await addVideoTrack(output, videoTrack, videoSource);
+  let audioSource = null;
+  if (audioTrack !== null && audioCodec !== null) {
+    audioSource = new EncodedAudioPacketSource(audioCodec);
+    await addAudioTrack(output, audioTrack, audioSource);
+  }
+  await output.start();
+  const writers = [
+    writeRepairedVideoPackets(videoTrack, videoSource, plan)
+  ];
+  if (audioTrack !== null && audioSource !== null) {
+    writers.push(writeAudioPackets(audioTrack, audioSource));
+  }
+  await Promise.all(writers);
+  await output.finalize();
+  if (target.buffer === null) {
+    throw new Error("Timing repair did not produce an output buffer");
+  }
+  return new Blob([target.buffer], { type: "video/mp4" });
+}
+async function repairDeferredVideoTiming(blob, expectedDurationSeconds) {
+  const input = new Input3({
+    formats: ALL_FORMATS2,
+    source: new BlobSource3(blob)
+  });
+  try {
+    const videoTrack = await input.getPrimaryVideoTrack();
+    if (videoTrack === null) {
+      return {
+        blob,
+        diagnostics: {
+          deferredTimingRepairedDurationCount: 0,
+          deferredTimingRepairedTimestampCount: 0
+        }
+      };
+    }
+    const packetTimings = await readVideoPacketTimings(videoTrack);
+    const plan = createDeferredVideoTimingRepairPlan(packetTimings, expectedDurationSeconds);
+    const diagnostics = {
+      deferredTimingRepairedDurationCount: plan.repairedDurationCount,
+      deferredTimingRepairedTimestampCount: plan.repairedTimestampCount
+    };
+    if (plan.nominalDurationSeconds !== null) {
+      diagnostics.deferredTimingNominalDurationSeconds = plan.nominalDurationSeconds;
+    }
+    if (plan.repairedDurationCount === 0) {
+      return { blob, diagnostics };
+    }
+    return {
+      blob: await remuxRepairedVideo(input, videoTrack, plan),
+      diagnostics
+    };
+  } finally {
+    input.dispose();
+  }
+}
+
+// src/core/transcode/deferred-video-transcoder.ts
 var MINIMUM_FRAME_DENSITY_RATIO = 0.9;
 var MAXIMUM_DURATION_DIFFERENCE_RATIO = 0.05;
 var MINIMUM_DURATION_TOLERANCE_SECONDS = 0.25;
@@ -22951,12 +23218,13 @@ function validateOutputFrameDensity(summary, targetFrameRate, diagnostics) {
     throw createIntegrityError("Output video frame density is below the capture target", diagnostics);
   }
 }
-function buildIntegrityDiagnostics(validation) {
+function buildIntegrityDiagnostics(validation, additionalDiagnostics = {}) {
   let stage = "output";
   if (validation.stage !== undefined) {
     stage = validation.stage;
   }
   const diagnostics = {
+    ...additionalDiagnostics,
     deferredIntegrityStage: stage
   };
   assignFiniteDiagnostic(diagnostics, "mediaRecorderExpectedDurationSeconds", validation.expectedDurationSeconds);
@@ -22992,8 +23260,8 @@ function validateLifecycleCoverage(summary, label, expectedDurationSeconds, diag
     throw createIntegrityError(`${label} video duration does not cover the active recording`, diagnostics);
   }
 }
-function validateDeferredVideoStats(validation) {
-  const diagnostics = buildIntegrityDiagnostics(validation);
+function validateDeferredVideoStatsWithDiagnostics(validation, additionalDiagnostics) {
+  const diagnostics = buildIntegrityDiagnostics(validation, additionalDiagnostics);
   if (!Number.isFinite(validation.expectedDurationSeconds) || validation.expectedDurationSeconds < 0) {
     throw createIntegrityError("Deferred transcode requires a valid active recording duration", diagnostics);
   }
@@ -23028,9 +23296,9 @@ function validateDeferredVideoStats(validation) {
   }
 }
 async function inspectVideoPackets(blob) {
-  const input = new Input3({
-    formats: ALL_FORMATS2,
-    source: new BlobSource3(blob)
+  const input = new Input4({
+    formats: ALL_FORMATS3,
+    source: new BlobSource4(blob)
   });
   const videoTrack = await input.getPrimaryVideoTrack();
   if (videoTrack === null) {
@@ -23038,7 +23306,7 @@ async function inspectVideoPackets(blob) {
     return null;
   }
   try {
-    const packetSink = new EncodedPacketSink(videoTrack);
+    const packetSink = new EncodedPacketSink2(videoTrack);
     const timestamps = [];
     let firstTimestamp = Number.POSITIVE_INFINITY;
     let lastEndTimestamp = Number.NEGATIVE_INFINITY;
@@ -23073,6 +23341,15 @@ async function inspectDeferredVideo(blob, label, diagnostics) {
     throw createIntegrityError(`Could not inspect ${label} deferred video: ${message}`, diagnostics);
   });
 }
+async function repairDeferredVideoSource(input, expectedDurationSeconds) {
+  return await repairDeferredVideoTiming(input, expectedDurationSeconds).catch((error) => {
+    const message = extractErrorMessage(error);
+    throw createIntegrityError(`Could not repair deferred video timing: ${message}`, {
+      deferredIntegrityStage: "source-repair",
+      mediaRecorderExpectedDurationSeconds: expectedDurationSeconds
+    });
+  });
+}
 async function transcodeDeferredVideo(input, config, onProgress, context) {
   const targetFrameRate = config.fps;
   if (typeof targetFrameRate !== "number" || !Number.isFinite(targetFrameRate) || targetFrameRate <= 0) {
@@ -23081,17 +23358,19 @@ async function transcodeDeferredVideo(input, config, onProgress, context) {
       mediaRecorderExpectedDurationSeconds: context.expectedDurationSeconds
     });
   }
-  const source = await inspectDeferredVideo(input, "source", {
+  const timingRepair = await repairDeferredVideoSource(input, context.expectedDurationSeconds);
+  const source = await inspectDeferredVideo(timingRepair.blob, "source", {
     deferredIntegrityStage: "source",
-    mediaRecorderExpectedDurationSeconds: context.expectedDurationSeconds
+    mediaRecorderExpectedDurationSeconds: context.expectedDurationSeconds,
+    ...timingRepair.diagnostics
   });
-  validateDeferredVideoStats({
+  validateDeferredVideoStatsWithDiagnostics({
     expectedDurationSeconds: context.expectedDurationSeconds,
     output: null,
     source,
     stage: "source",
     targetFrameRate
-  });
+  }, timingRepair.diagnostics);
   const transcodeDiagnostics = buildIntegrityDiagnostics({
     expectedDurationSeconds: context.expectedDurationSeconds,
     output: null,
@@ -23100,7 +23379,8 @@ async function transcodeDeferredVideo(input, config, onProgress, context) {
     targetFrameRate
   });
   transcodeDiagnostics.deferredIntegrityStage = "transcode";
-  const result = await transcodeVideo(input, config, onProgress).catch((error) => {
+  Object.assign(transcodeDiagnostics, timingRepair.diagnostics);
+  const result = await transcodeVideo(timingRepair.blob, config, onProgress).catch((error) => {
     let transcodeError;
     if (error instanceof Error) {
       transcodeError = error;
@@ -23112,7 +23392,8 @@ async function transcodeDeferredVideo(input, config, onProgress, context) {
   });
   const outputDiagnostics = {
     deferredIntegrityStage: "output",
-    mediaRecorderExpectedDurationSeconds: context.expectedDurationSeconds
+    mediaRecorderExpectedDurationSeconds: context.expectedDurationSeconds,
+    ...timingRepair.diagnostics
   };
   if (source !== null) {
     outputDiagnostics.deferredSourceDurationSeconds = source.duration;
@@ -23128,10 +23409,11 @@ async function transcodeDeferredVideo(input, config, onProgress, context) {
     stage: "output",
     targetFrameRate
   };
-  validateDeferredVideoStats(validation);
+  validateDeferredVideoStatsWithDiagnostics(validation, timingRepair.diagnostics);
+  const diagnostics = buildIntegrityDiagnostics(validation, timingRepair.diagnostics);
   return {
     ...result,
-    diagnostics: buildIntegrityDiagnostics(validation)
+    diagnostics
   };
 }
 
@@ -24968,79 +25250,79 @@ class VidtreoRecorder {
   }
 }
 export {
-  validateFile,
-  validateBrowserSupport,
-  transcodeVideoForNativeCamera,
-  transcodeVideo,
-  resolveDeviceError,
-  requireStream,
-  requireProcessor,
-  requireNonNull,
-  requireMediaDevices,
-  requireInitialized,
-  requireDefined,
-  requireActive,
-  recoverPendingUpload,
-  parseBrowserErrorLinkContent,
-  mapPresetToConfig,
-  logger,
-  isMobileDevice2 as isMobileDevice,
-  isAudioRuntimeMissingCode,
-  isAudioMissingError,
-  getPresetVideoBitrateForFormat,
-  getPresetTotalBitrate,
-  getPresetAudioBitrateForFormat,
-  getFormatCompatibilityPolicy,
-  getDefaultConfigForFormat,
-  getDefaultAudioCodecForFormat,
-  getCameraErrorText,
-  getBrowserName,
-  getBrowserInfo,
-  getBrowserErrorText,
-  getAudioErrorText,
-  getAudioCodecForFormat,
-  formatTime,
-  formatFileSize,
-  extractVideoDuration,
-  extractLastFrame,
-  extractErrorMessage,
-  evaluateAudioHealth,
-  createPermissionFlowOrchestratorDependencies,
-  createAudioNoTrackAtStartError,
-  createAudioMissingError,
-  checkRecorderSupport,
-  calculateVideoBitrate,
-  calculateTotalBitrateFromMbPerMinute,
-  calculateBarColor,
-  VidtreoRecorder,
-  VideoUploadService,
-  VideoStorageService,
-  UploadQueueManager,
-  StreamProcessor,
-  StorageManager,
-  RecordingManager,
-  RecorderController,
-  QuotaManager,
-  PermissionFlowOrchestrator,
-  PRESET_SIZE_LIMIT_MB_PER_MINUTE,
-  NativeCameraHandler,
-  FORMAT_DEFAULT_CODECS,
-  FORMAT_COMPATIBILITY_POLICY,
-  ERROR_RECORDING_NO_AUDIO_TRACK,
-  ERROR_RECORDING_NO_AUDIO_FRAMES,
-  ERROR_RECORDING_AUDIO_ZERO_CHANNELS,
-  ERROR_RECORDING_AUDIO_TRACK_ENDED,
-  ERROR_RECORDING_AUDIO_SILENT,
-  ERROR_RECORDING_AUDIO_NO_CHUNKS,
-  ERROR_RECORDING_AUDIO_INVALID_SAMPLE_RATE,
-  ERROR_AUDIO_NO_TRACK_AT_START,
-  DeviceManager,
-  DEFAULT_TRANSCODE_CONFIG,
-  DEFAULT_STREAM_CONFIG,
-  DEFAULT_RECORDING_OPTIONS,
-  DEFAULT_CAMERA_CONSTRAINTS,
-  ConfigService,
-  ConfigManager,
+  AudioLevelAnalyzer,
   CameraStreamManager,
-  AudioLevelAnalyzer
+  ConfigManager,
+  ConfigService,
+  DEFAULT_CAMERA_CONSTRAINTS,
+  DEFAULT_RECORDING_OPTIONS,
+  DEFAULT_STREAM_CONFIG,
+  DEFAULT_TRANSCODE_CONFIG,
+  DeviceManager,
+  ERROR_AUDIO_NO_TRACK_AT_START,
+  ERROR_RECORDING_AUDIO_INVALID_SAMPLE_RATE,
+  ERROR_RECORDING_AUDIO_NO_CHUNKS,
+  ERROR_RECORDING_AUDIO_SILENT,
+  ERROR_RECORDING_AUDIO_TRACK_ENDED,
+  ERROR_RECORDING_AUDIO_ZERO_CHANNELS,
+  ERROR_RECORDING_NO_AUDIO_FRAMES,
+  ERROR_RECORDING_NO_AUDIO_TRACK,
+  FORMAT_COMPATIBILITY_POLICY,
+  FORMAT_DEFAULT_CODECS,
+  NativeCameraHandler,
+  PRESET_SIZE_LIMIT_MB_PER_MINUTE,
+  PermissionFlowOrchestrator,
+  QuotaManager,
+  RecorderController,
+  RecordingManager,
+  StorageManager,
+  StreamProcessor,
+  UploadQueueManager,
+  VideoStorageService,
+  VideoUploadService,
+  VidtreoRecorder,
+  calculateBarColor,
+  calculateTotalBitrateFromMbPerMinute,
+  calculateVideoBitrate,
+  checkRecorderSupport,
+  createAudioMissingError,
+  createAudioNoTrackAtStartError,
+  createPermissionFlowOrchestratorDependencies,
+  evaluateAudioHealth,
+  extractErrorMessage,
+  extractLastFrame,
+  extractVideoDuration,
+  formatFileSize,
+  formatTime,
+  getAudioCodecForFormat,
+  getAudioErrorText,
+  getBrowserErrorText,
+  getBrowserInfo,
+  getBrowserName,
+  getCameraErrorText,
+  getDefaultAudioCodecForFormat,
+  getDefaultConfigForFormat,
+  getFormatCompatibilityPolicy,
+  getPresetAudioBitrateForFormat,
+  getPresetTotalBitrate,
+  getPresetVideoBitrateForFormat,
+  isAudioMissingError,
+  isAudioRuntimeMissingCode,
+  isMobileDevice2 as isMobileDevice,
+  logger,
+  mapPresetToConfig,
+  parseBrowserErrorLinkContent,
+  recoverPendingUpload,
+  requireActive,
+  requireDefined,
+  requireInitialized,
+  requireMediaDevices,
+  requireNonNull,
+  requireProcessor,
+  requireStream,
+  resolveDeviceError,
+  transcodeVideo,
+  transcodeVideoForNativeCamera,
+  validateBrowserSupport,
+  validateFile
 };

package/package.json

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