easyproctor 2.5.5 → 2.5.7

package/esm/index.js

@@ -2400,6 +2400,493 @@ var require_jszip_min = __commonJS({
   }
 });
 
+// node_modules/fix-webm-duration/fix-webm-duration.js
+var require_fix_webm_duration = __commonJS({
+  "node_modules/fix-webm-duration/fix-webm-duration.js"(exports, module) {
+    (function(name, definition) {
+      if (typeof define === "function" && define.amd) {
+        define(definition);
+      } else if (typeof module !== "undefined" && module.exports) {
+        module.exports = definition();
+      } else {
+        window.ysFixWebmDuration = definition();
+      }
+    })("fix-webm-duration", function() {
+      var sections = {
+        172351395: { name: "EBML", type: "Container" },
+        646: { name: "EBMLVersion", type: "Uint" },
+        759: { name: "EBMLReadVersion", type: "Uint" },
+        754: { name: "EBMLMaxIDLength", type: "Uint" },
+        755: { name: "EBMLMaxSizeLength", type: "Uint" },
+        642: { name: "DocType", type: "String" },
+        647: { name: "DocTypeVersion", type: "Uint" },
+        645: { name: "DocTypeReadVersion", type: "Uint" },
+        108: { name: "Void", type: "Binary" },
+        63: { name: "CRC-32", type: "Binary" },
+        190023271: { name: "SignatureSlot", type: "Container" },
+        16010: { name: "SignatureAlgo", type: "Uint" },
+        16026: { name: "SignatureHash", type: "Uint" },
+        16037: { name: "SignaturePublicKey", type: "Binary" },
+        16053: { name: "Signature", type: "Binary" },
+        15963: { name: "SignatureElements", type: "Container" },
+        15995: { name: "SignatureElementList", type: "Container" },
+        9522: { name: "SignedElement", type: "Binary" },
+        139690087: { name: "Segment", type: "Container" },
+        21863284: { name: "SeekHead", type: "Container" },
+        3515: { name: "Seek", type: "Container" },
+        5035: { name: "SeekID", type: "Binary" },
+        5036: { name: "SeekPosition", type: "Uint" },
+        88713574: { name: "Info", type: "Container" },
+        13220: { name: "SegmentUID", type: "Binary" },
+        13188: { name: "SegmentFilename", type: "String" },
+        1882403: { name: "PrevUID", type: "Binary" },
+        1868715: { name: "PrevFilename", type: "String" },
+        2013475: { name: "NextUID", type: "Binary" },
+        1999803: { name: "NextFilename", type: "String" },
+        1092: { name: "SegmentFamily", type: "Binary" },
+        10532: { name: "ChapterTranslate", type: "Container" },
+        10748: { name: "ChapterTranslateEditionUID", type: "Uint" },
+        10687: { name: "ChapterTranslateCodec", type: "Uint" },
+        10661: { name: "ChapterTranslateID", type: "Binary" },
+        710577: { name: "TimecodeScale", type: "Uint" },
+        1161: { name: "Duration", type: "Float" },
+        1121: { name: "DateUTC", type: "Date" },
+        15273: { name: "Title", type: "String" },
+        3456: { name: "MuxingApp", type: "String" },
+        5953: { name: "WritingApp", type: "String" },
+        // 0xf43b675: { name: 'Cluster', type: 'Container' },
+        103: { name: "Timecode", type: "Uint" },
+        6228: { name: "SilentTracks", type: "Container" },
+        6359: { name: "SilentTrackNumber", type: "Uint" },
+        39: { name: "Position", type: "Uint" },
+        43: { name: "PrevSize", type: "Uint" },
+        35: { name: "SimpleBlock", type: "Binary" },
+        32: { name: "BlockGroup", type: "Container" },
+        33: { name: "Block", type: "Binary" },
+        34: { name: "BlockVirtual", type: "Binary" },
+        13729: { name: "BlockAdditions", type: "Container" },
+        38: { name: "BlockMore", type: "Container" },
+        110: { name: "BlockAddID", type: "Uint" },
+        37: { name: "BlockAdditional", type: "Binary" },
+        27: { name: "BlockDuration", type: "Uint" },
+        122: { name: "ReferencePriority", type: "Uint" },
+        123: { name: "ReferenceBlock", type: "Int" },
+        125: { name: "ReferenceVirtual", type: "Int" },
+        36: { name: "CodecState", type: "Binary" },
+        13730: { name: "DiscardPadding", type: "Int" },
+        14: { name: "Slices", type: "Container" },
+        104: { name: "TimeSlice", type: "Container" },
+        76: { name: "LaceNumber", type: "Uint" },
+        77: { name: "FrameNumber", type: "Uint" },
+        75: { name: "BlockAdditionID", type: "Uint" },
+        78: { name: "Delay", type: "Uint" },
+        79: { name: "SliceDuration", type: "Uint" },
+        72: { name: "ReferenceFrame", type: "Container" },
+        73: { name: "ReferenceOffset", type: "Uint" },
+        74: { name: "ReferenceTimeCode", type: "Uint" },
+        47: { name: "EncryptedBlock", type: "Binary" },
+        106212971: { name: "Tracks", type: "Container" },
+        46: { name: "TrackEntry", type: "Container" },
+        87: { name: "TrackNumber", type: "Uint" },
+        13253: { name: "TrackUID", type: "Uint" },
+        3: { name: "TrackType", type: "Uint" },
+        57: { name: "FlagEnabled", type: "Uint" },
+        8: { name: "FlagDefault", type: "Uint" },
+        5546: { name: "FlagForced", type: "Uint" },
+        28: { name: "FlagLacing", type: "Uint" },
+        11751: { name: "MinCache", type: "Uint" },
+        11768: { name: "MaxCache", type: "Uint" },
+        254851: { name: "DefaultDuration", type: "Uint" },
+        216698: { name: "DefaultDecodedFieldDuration", type: "Uint" },
+        209231: { name: "TrackTimecodeScale", type: "Float" },
+        4991: { name: "TrackOffset", type: "Int" },
+        5614: { name: "MaxBlockAdditionID", type: "Uint" },
+        4974: { name: "Name", type: "String" },
+        177564: { name: "Language", type: "String" },
+        6: { name: "CodecID", type: "String" },
+        9122: { name: "CodecPrivate", type: "Binary" },
+        362120: { name: "CodecName", type: "String" },
+        13382: { name: "AttachmentLink", type: "Uint" },
+        1742487: { name: "CodecSettings", type: "String" },
+        1785920: { name: "CodecInfoURL", type: "String" },
+        438848: { name: "CodecDownloadURL", type: "String" },
+        42: { name: "CodecDecodeAll", type: "Uint" },
+        12203: { name: "TrackOverlay", type: "Uint" },
+        5802: { name: "CodecDelay", type: "Uint" },
+        5819: { name: "SeekPreRoll", type: "Uint" },
+        9764: { name: "TrackTranslate", type: "Container" },
+        9980: { name: "TrackTranslateEditionUID", type: "Uint" },
+        9919: { name: "TrackTranslateCodec", type: "Uint" },
+        9893: { name: "TrackTranslateTrackID", type: "Binary" },
+        96: { name: "Video", type: "Container" },
+        26: { name: "FlagInterlaced", type: "Uint" },
+        5048: { name: "StereoMode", type: "Uint" },
+        5056: { name: "AlphaMode", type: "Uint" },
+        5049: { name: "OldStereoMode", type: "Uint" },
+        48: { name: "PixelWidth", type: "Uint" },
+        58: { name: "PixelHeight", type: "Uint" },
+        5290: { name: "PixelCropBottom", type: "Uint" },
+        5307: { name: "PixelCropTop", type: "Uint" },
+        5324: { name: "PixelCropLeft", type: "Uint" },
+        5341: { name: "PixelCropRight", type: "Uint" },
+        5296: { name: "DisplayWidth", type: "Uint" },
+        5306: { name: "DisplayHeight", type: "Uint" },
+        5298: { name: "DisplayUnit", type: "Uint" },
+        5299: { name: "AspectRatioType", type: "Uint" },
+        963876: { name: "ColourSpace", type: "Binary" },
+        1029411: { name: "GammaValue", type: "Float" },
+        230371: { name: "FrameRate", type: "Float" },
+        97: { name: "Audio", type: "Container" },
+        53: { name: "SamplingFrequency", type: "Float" },
+        14517: { name: "OutputSamplingFrequency", type: "Float" },
+        31: { name: "Channels", type: "Uint" },
+        15739: { name: "ChannelPositions", type: "Binary" },
+        8804: { name: "BitDepth", type: "Uint" },
+        98: { name: "TrackOperation", type: "Container" },
+        99: { name: "TrackCombinePlanes", type: "Container" },
+        100: { name: "TrackPlane", type: "Container" },
+        101: { name: "TrackPlaneUID", type: "Uint" },
+        102: { name: "TrackPlaneType", type: "Uint" },
+        105: { name: "TrackJoinBlocks", type: "Container" },
+        109: { name: "TrackJoinUID", type: "Uint" },
+        64: { name: "TrickTrackUID", type: "Uint" },
+        65: { name: "TrickTrackSegmentUID", type: "Binary" },
+        70: { name: "TrickTrackFlag", type: "Uint" },
+        71: { name: "TrickMasterTrackUID", type: "Uint" },
+        68: { name: "TrickMasterTrackSegmentUID", type: "Binary" },
+        11648: { name: "ContentEncodings", type: "Container" },
+        8768: { name: "ContentEncoding", type: "Container" },
+        4145: { name: "ContentEncodingOrder", type: "Uint" },
+        4146: { name: "ContentEncodingScope", type: "Uint" },
+        4147: { name: "ContentEncodingType", type: "Uint" },
+        4148: { name: "ContentCompression", type: "Container" },
+        596: { name: "ContentCompAlgo", type: "Uint" },
+        597: { name: "ContentCompSettings", type: "Binary" },
+        4149: { name: "ContentEncryption", type: "Container" },
+        2017: { name: "ContentEncAlgo", type: "Uint" },
+        2018: { name: "ContentEncKeyID", type: "Binary" },
+        2019: { name: "ContentSignature", type: "Binary" },
+        2020: { name: "ContentSigKeyID", type: "Binary" },
+        2021: { name: "ContentSigAlgo", type: "Uint" },
+        2022: { name: "ContentSigHashAlgo", type: "Uint" },
+        206814059: { name: "Cues", type: "Container" },
+        59: { name: "CuePoint", type: "Container" },
+        51: { name: "CueTime", type: "Uint" },
+        55: { name: "CueTrackPositions", type: "Container" },
+        119: { name: "CueTrack", type: "Uint" },
+        113: { name: "CueClusterPosition", type: "Uint" },
+        112: { name: "CueRelativePosition", type: "Uint" },
+        50: { name: "CueDuration", type: "Uint" },
+        4984: { name: "CueBlockNumber", type: "Uint" },
+        106: { name: "CueCodecState", type: "Uint" },
+        91: { name: "CueReference", type: "Container" },
+        22: { name: "CueRefTime", type: "Uint" },
+        23: { name: "CueRefCluster", type: "Uint" },
+        4959: { name: "CueRefNumber", type: "Uint" },
+        107: { name: "CueRefCodecState", type: "Uint" },
+        155296873: { name: "Attachments", type: "Container" },
+        8615: { name: "AttachedFile", type: "Container" },
+        1662: { name: "FileDescription", type: "String" },
+        1646: { name: "FileName", type: "String" },
+        1632: { name: "FileMimeType", type: "String" },
+        1628: { name: "FileData", type: "Binary" },
+        1710: { name: "FileUID", type: "Uint" },
+        1653: { name: "FileReferral", type: "Binary" },
+        1633: { name: "FileUsedStartTime", type: "Uint" },
+        1634: { name: "FileUsedEndTime", type: "Uint" },
+        4433776: { name: "Chapters", type: "Container" },
+        1465: { name: "EditionEntry", type: "Container" },
+        1468: { name: "EditionUID", type: "Uint" },
+        1469: { name: "EditionFlagHidden", type: "Uint" },
+        1499: { name: "EditionFlagDefault", type: "Uint" },
+        1501: { name: "EditionFlagOrdered", type: "Uint" },
+        54: { name: "ChapterAtom", type: "Container" },
+        13252: { name: "ChapterUID", type: "Uint" },
+        5716: { name: "ChapterStringUID", type: "String" },
+        17: { name: "ChapterTimeStart", type: "Uint" },
+        18: { name: "ChapterTimeEnd", type: "Uint" },
+        24: { name: "ChapterFlagHidden", type: "Uint" },
+        1432: { name: "ChapterFlagEnabled", type: "Uint" },
+        11879: { name: "ChapterSegmentUID", type: "Binary" },
+        11964: { name: "ChapterSegmentEditionUID", type: "Uint" },
+        9155: { name: "ChapterPhysicalEquiv", type: "Uint" },
+        15: { name: "ChapterTrack", type: "Container" },
+        9: { name: "ChapterTrackNumber", type: "Uint" },
+        0: { name: "ChapterDisplay", type: "Container" },
+        5: { name: "ChapString", type: "String" },
+        892: { name: "ChapLanguage", type: "String" },
+        894: { name: "ChapCountry", type: "String" },
+        10564: { name: "ChapProcess", type: "Container" },
+        10581: { name: "ChapProcessCodecID", type: "Uint" },
+        1293: { name: "ChapProcessPrivate", type: "Binary" },
+        10513: { name: "ChapProcessCommand", type: "Container" },
+        10530: { name: "ChapProcessTime", type: "Uint" },
+        10547: { name: "ChapProcessData", type: "Binary" },
+        39109479: { name: "Tags", type: "Container" },
+        13171: { name: "Tag", type: "Container" },
+        9152: { name: "Targets", type: "Container" },
+        10442: { name: "TargetTypeValue", type: "Uint" },
+        9162: { name: "TargetType", type: "String" },
+        9157: { name: "TagTrackUID", type: "Uint" },
+        9161: { name: "TagEditionUID", type: "Uint" },
+        9156: { name: "TagChapterUID", type: "Uint" },
+        9158: { name: "TagAttachmentUID", type: "Uint" },
+        10184: { name: "SimpleTag", type: "Container" },
+        1443: { name: "TagName", type: "String" },
+        1146: { name: "TagLanguage", type: "String" },
+        1156: { name: "TagDefault", type: "Uint" },
+        1159: { name: "TagString", type: "String" },
+        1157: { name: "TagBinary", type: "Binary" }
+      };
+      function doInherit(newClass, baseClass) {
+        newClass.prototype = Object.create(baseClass.prototype);
+        newClass.prototype.constructor = newClass;
+      }
+      function WebmBase(name, type) {
+        this.name = name || "Unknown";
+        this.type = type || "Unknown";
+      }
+      WebmBase.prototype.updateBySource = function() {
+      };
+      WebmBase.prototype.setSource = function(source) {
+        this.source = source;
+        this.updateBySource();
+      };
+      WebmBase.prototype.updateByData = function() {
+      };
+      WebmBase.prototype.setData = function(data) {
+        this.data = data;
+        this.updateByData();
+      };
+      function WebmUint(name, type) {
+        WebmBase.call(this, name, type || "Uint");
+      }
+      doInherit(WebmUint, WebmBase);
+      function padHex(hex) {
+        return hex.length % 2 === 1 ? "0" + hex : hex;
+      }
+      WebmUint.prototype.updateBySource = function() {
+        this.data = "";
+        for (var i3 = 0; i3 < this.source.length; i3++) {
+          var hex = this.source[i3].toString(16);
+          this.data += padHex(hex);
+        }
+      };
+      WebmUint.prototype.updateByData = function() {
+        var length = this.data.length / 2;
+        this.source = new Uint8Array(length);
+        for (var i3 = 0; i3 < length; i3++) {
+          var hex = this.data.substr(i3 * 2, 2);
+          this.source[i3] = parseInt(hex, 16);
+        }
+      };
+      WebmUint.prototype.getValue = function() {
+        return parseInt(this.data, 16);
+      };
+      WebmUint.prototype.setValue = function(value) {
+        this.setData(padHex(value.toString(16)));
+      };
+      function WebmFloat(name, type) {
+        WebmBase.call(this, name, type || "Float");
+      }
+      doInherit(WebmFloat, WebmBase);
+      WebmFloat.prototype.getFloatArrayType = function() {
+        return this.source && this.source.length === 4 ? Float32Array : Float64Array;
+      };
+      WebmFloat.prototype.updateBySource = function() {
+        var byteArray = this.source.reverse();
+        var floatArrayType = this.getFloatArrayType();
+        var floatArray = new floatArrayType(byteArray.buffer);
+        this.data = floatArray[0];
+      };
+      WebmFloat.prototype.updateByData = function() {
+        var floatArrayType = this.getFloatArrayType();
+        var floatArray = new floatArrayType([this.data]);
+        var byteArray = new Uint8Array(floatArray.buffer);
+        this.source = byteArray.reverse();
+      };
+      WebmFloat.prototype.getValue = function() {
+        return this.data;
+      };
+      WebmFloat.prototype.setValue = function(value) {
+        this.setData(value);
+      };
+      function WebmContainer(name, type) {
+        WebmBase.call(this, name, type || "Container");
+      }
+      doInherit(WebmContainer, WebmBase);
+      WebmContainer.prototype.readByte = function() {
+        return this.source[this.offset++];
+      };
+      WebmContainer.prototype.readUint = function() {
+        var firstByte = this.readByte();
+        var bytes = 8 - firstByte.toString(2).length;
+        var value = firstByte - (1 << 7 - bytes);
+        for (var i3 = 0; i3 < bytes; i3++) {
+          value *= 256;
+          value += this.readByte();
+        }
+        return value;
+      };
+      WebmContainer.prototype.updateBySource = function() {
+        this.data = [];
+        for (this.offset = 0; this.offset < this.source.length; this.offset = end) {
+          var id = this.readUint();
+          var len = this.readUint();
+          var end = Math.min(this.offset + len, this.source.length);
+          var data = this.source.slice(this.offset, end);
+          var info = sections[id] || { name: "Unknown", type: "Unknown" };
+          var ctr = WebmBase;
+          switch (info.type) {
+            case "Container":
+              ctr = WebmContainer;
+              break;
+            case "Uint":
+              ctr = WebmUint;
+              break;
+            case "Float":
+              ctr = WebmFloat;
+              break;
+          }
+          var section = new ctr(info.name, info.type);
+          section.setSource(data);
+          this.data.push({
+            id,
+            idHex: id.toString(16),
+            data: section
+          });
+        }
+      };
+      WebmContainer.prototype.writeUint = function(x3, draft) {
+        for (var bytes = 1, flag = 128; x3 >= flag && bytes < 8; bytes++, flag *= 128) {
+        }
+        if (!draft) {
+          var value = flag + x3;
+          for (var i3 = bytes - 1; i3 >= 0; i3--) {
+            var c3 = value % 256;
+            this.source[this.offset + i3] = c3;
+            value = (value - c3) / 256;
+          }
+        }
+        this.offset += bytes;
+      };
+      WebmContainer.prototype.writeSections = function(draft) {
+        this.offset = 0;
+        for (var i3 = 0; i3 < this.data.length; i3++) {
+          var section = this.data[i3], content = section.data.source, contentLength = content.length;
+          this.writeUint(section.id, draft);
+          this.writeUint(contentLength, draft);
+          if (!draft) {
+            this.source.set(content, this.offset);
+          }
+          this.offset += contentLength;
+        }
+        return this.offset;
+      };
+      WebmContainer.prototype.updateByData = function() {
+        var length = this.writeSections("draft");
+        this.source = new Uint8Array(length);
+        this.writeSections();
+      };
+      WebmContainer.prototype.getSectionById = function(id) {
+        for (var i3 = 0; i3 < this.data.length; i3++) {
+          var section = this.data[i3];
+          if (section.id === id) {
+            return section.data;
+          }
+        }
+        return null;
+      };
+      function WebmFile(source) {
+        WebmContainer.call(this, "File", "File");
+        this.setSource(source);
+      }
+      doInherit(WebmFile, WebmContainer);
+      WebmFile.prototype.fixDuration = function(duration, options) {
+        var logger = options && options.logger;
+        if (logger === void 0) {
+          logger = function(message) {
+            console.log(message);
+          };
+        } else if (!logger) {
+          logger = function() {
+          };
+        }
+        var segmentSection = this.getSectionById(139690087);
+        if (!segmentSection) {
+          logger("[fix-webm-duration] Segment section is missing");
+          return false;
+        }
+        var infoSection = segmentSection.getSectionById(88713574);
+        if (!infoSection) {
+          logger("[fix-webm-duration] Info section is missing");
+          return false;
+        }
+        var timeScaleSection = infoSection.getSectionById(710577);
+        if (!timeScaleSection) {
+          logger("[fix-webm-duration] TimecodeScale section is missing");
+          return false;
+        }
+        var durationSection = infoSection.getSectionById(1161);
+        if (durationSection) {
+          if (durationSection.getValue() <= 0) {
+            logger(`[fix-webm-duration] Duration section is present, but the value is ${durationSection.getValue()}`);
+            durationSection.setValue(duration);
+          } else {
+            logger(`[fix-webm-duration] Duration section is present, and the value is ${durationSection.getValue()}`);
+            return false;
+          }
+        } else {
+          logger("[fix-webm-duration] Duration section is missing");
+          durationSection = new WebmFloat("Duration", "Float");
+          durationSection.setValue(duration);
+          infoSection.data.push({
+            id: 1161,
+            data: durationSection
+          });
+        }
+        timeScaleSection.setValue(1e6);
+        infoSection.updateByData();
+        segmentSection.updateByData();
+        this.updateByData();
+        return true;
+      };
+      WebmFile.prototype.toBlob = function(mimeType) {
+        return new Blob([this.source.buffer], { type: mimeType || "video/webm" });
+      };
+      function fixWebmDuration3(blob, duration, callback, options) {
+        if (typeof callback === "object") {
+          options = callback;
+          callback = void 0;
+        }
+        if (!callback) {
+          return new Promise(function(resolve) {
+            fixWebmDuration3(blob, duration, resolve, options);
+          });
+        }
+        try {
+          var reader = new FileReader();
+          reader.onloadend = function() {
+            try {
+              var file = new WebmFile(new Uint8Array(reader.result));
+              if (file.fixDuration(duration, options)) {
+                blob = file.toBlob(blob.type);
+              }
+            } catch (ex) {
+            }
+            callback(blob);
+          };
+          reader.readAsArrayBuffer(blob);
+        } catch (ex) {
+          callback(blob);
+        }
+      }
+      fixWebmDuration3.default = fixWebmDuration3;
+      return fixWebmDuration3;
+    });
+  }
+});
+
 // node_modules/file-saver/dist/FileSaver.min.js
 var require_FileSaver_min = __commonJS({
   "node_modules/file-saver/dist/FileSaver.min.js"(exports, module) {
@@ -8658,6 +9145,7 @@ var BaseDetection = class {
       // objectDetection
       runningMode: this.runningMode
     });
+    console.log("BaseDetection initializeDetector", this.detectorType);
   }
   stopDetection() {
     this.animationFrameId && clearTimeout(this.animationFrameId);
@@ -8669,6 +9157,7 @@ var BaseDetection = class {
   }
   enableCam(cameraStream) {
     var _a2;
+    console.log("BaseDetection enableCam");
     if (!this.detector) {
       console.log("Wait! Detector not loaded yet.");
       return;
@@ -8693,7 +9182,6 @@ var BaseDetection = class {
     }
     cameraStream && !this.video.srcObject && (this.video.srcObject = cameraStream);
     this.video.play();
-    this.startTime = new Date(Date.now());
     const that = this;
     (_a2 = this.video) == null ? void 0 : _a2.addEventListener("loadeddata", () => that.predictWebcam());
     const style = document.createElement("style");
@@ -8711,6 +9199,7 @@ var BaseDetection = class {
             }
         `;
     document.getElementsByTagName("head")[0].appendChild(style);
+    console.log("BaseDetection enableCam OK");
   }
   async predictWebcam() {
     if (this.lastVideoTime === -1) {
@@ -8736,8 +9225,8 @@ var BaseDetection = class {
       description: this.alertTranslate(description),
       type,
       category: description,
-      begin: Date.now() - this.startTime.getTime(),
-      end: Date.now() - this.startTime.getTime()
+      begin: 0,
+      end: 0
     });
     if (this.options.onRealtimeAlertsCallback == null)
       this.error && (this.error.innerText = description);
@@ -8748,8 +9237,8 @@ var BaseDetection = class {
       description: this.alertTranslate(description),
       type,
       category: description,
-      begin: Date.now() - this.startTime.getTime(),
-      end: Date.now() - this.startTime.getTime()
+      begin: 0,
+      end: 0
     });
     this.error && (this.error.innerText = "");
   }
@@ -8839,11 +9328,13 @@ var FaceDetection = class extends BaseDetection {
     );
     this.emmitedPositionAlert = false;
     this.emmitedFaceAlert = false;
+    console.log("FaceDetection constructor");
+    this.numFacesSent = -1;
   }
   stopDetection() {
     super.stopDetection();
     if (this.emmitedFaceAlert) {
-      this.handleOk("face_ok", "face_detection_on_stream");
+      this.handleOk("face_stop", "face_detection_on_stream");
     }
   }
   // displayVideoDetections(result: { detections: any; }) {
@@ -9006,6 +9497,8 @@ var FaceDetection = class extends BaseDetection {
   }
   verify(result) {
     var _a2;
+    console.log("this.numFacesSent", this.numFacesSent);
+    console.log("result.detections.length", result.detections.length);
     if (((_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.detectFace) && result.detections.length !== this.numFacesSent) {
       this.numFacesSent = result.detections.length;
       if (result.detections.length === 0) {
@@ -12209,46 +12702,6 @@ function isMobileDevice() {
   return /Android|iPhone|iPad|iPod/i.test(navigator.userAgent);
 }
 
-// src/plugins/insights.ts
-var backendService;
-var init = (backend) => {
-  backendService = backend;
-  return backendService;
-};
-var eventNames = {
-  DEVICES_CHECKED: "devices_checked",
-  START: "start",
-  FINISH: "finish",
-  ERROR: "error",
-  UPLOAD: "upload",
-  UPLOAD_FILE: "upload_file",
-  DOWNLOAD_VIDEO: "download_video",
-  BUFFER_SIZE: "buffer_size",
-  ANOTHER_STREAM: "another_stream",
-  CHANGE_DEVICE: "change_device",
-  STOP_SHARING_SCREEN: "stop_sharing_screen",
-  ERROR_RECORDER_RTC: "error_recorder_rtc",
-  BROWSER_NOT_SUPPORTED: "browser_not_supported",
-  SAVE_ON_SESSION: "save_on_session"
-};
-var log = (eventName, properties) => backendService && backendService.log(eventName, properties);
-var trackers = {
-  registerDevicesChecked: (proctoringId2, success, description) => log(eventNames.DEVICES_CHECKED, { proctoringId: proctoringId2, success, description }),
-  registerStart: (proctoringId2, success, description) => log(eventNames.START, { proctoringId: proctoringId2, success, description }),
-  registerFinish: (proctoringId2, success, description) => log(eventNames.FINISH, { proctoringId: proctoringId2, success, description }),
-  registerError: (proctoringId2, description) => log(eventNames.ERROR, { proctoringId: proctoringId2, description }),
-  registerBrowserNotSupported: (proctoringId2, description) => log(eventNames.BROWSER_NOT_SUPPORTED, { proctoringId: proctoringId2, description }),
-  registerUpload: (proctoringId2, success, description, serviceType, uploadTime) => log(eventNames.UPLOAD, { proctoringId: proctoringId2, success, description, serviceType, uploadTime }),
-  registerUploadFile: (proctoringId2, description, fileType) => log(eventNames.UPLOAD_FILE, { proctoringId: proctoringId2, description, fileType }),
-  registerChangeDevice: (proctoringId2, inOrOut, description) => log(eventNames.CHANGE_DEVICE, { proctoringId: proctoringId2, inOrOut, description }),
-  registerStopSharingScreen: (proctoringId2, description) => log(eventNames.STOP_SHARING_SCREEN, { proctoringId: proctoringId2, description }),
-  registerErrorRecorderRTC: (proctoringId2, description) => log(eventNames.ERROR_RECORDER_RTC, { proctoringId: proctoringId2, description }),
-  registerDownloadFile: (proctoringId2, description) => log(eventNames.DOWNLOAD_VIDEO, { proctoringId: proctoringId2, description }),
-  registerOnBufferSizeError: (proctoringId2, description) => log(eventNames.BUFFER_SIZE, { proctoringId: proctoringId2, description }),
-  registerAnotherStream: (proctoringId2, description) => log(eventNames.ANOTHER_STREAM, { proctoringId: proctoringId2, description }),
-  registerSaveOnSession: (proctoringId2, description) => log(eventNames.SAVE_ON_SESSION, { proctoringId: proctoringId2, description })
-};
-
 // src/plugins/recorder.ts
 var proctoringId;
 function setRecorderProctoringId(id) {
@@ -12261,6 +12714,7 @@ function recorder(stream, buffer, onBufferSizeError = false, onBufferSizeErrorCa
   let lastEvent;
   let bufferSize;
   bufferSize = 0;
+  let startTime;
   let recorderOptions = {
     // eslint-disable-next-line no-useless-escape
     mimeType: "video/webm",
@@ -12280,59 +12734,106 @@ function recorder(stream, buffer, onBufferSizeError = false, onBufferSizeErrorCa
       audioBitsPerSecond: 64 * 1e3
     };
   }
-  const mediaRecorder = new MediaRecorder(stream, recorderOptions);
-  mediaRecorder.ondataavailable = (e3) => {
-    bufferSize = bufferSize + e3.data.size;
-    if (e3.data.size > 0) {
-      buffer.push(e3.data);
-    }
-    if (!stopped) {
-      if (lastEvent && e3.data.size === lastEvent.data.size || e3.data.size === 0) {
-        proctoringId && lastEvent && e3.data.size === lastEvent.data.size && trackers.registerOnBufferSizeError(
-          proctoringId,
-          `onBufferSizeError: Recorder size freezed: ${e3.data.size} Mb`
-        );
-        proctoringId && e3.data.size === 0 && trackers.registerOnBufferSizeError(
-          proctoringId,
-          `onBufferSizeError: Recorder size equal 0 Mb`
-        );
-        onBufferSizeErrorCallback && onBufferSizeErrorCallback();
+  function buildMediaRecorder(stream2, recorderOptions2) {
+    const tracks = stream2.getTracks();
+    if (tracks.length == 0) {
+      throw new Error("No tracks found");
+    }
+    const invalidTracks = tracks.find((t3) => t3.readyState != "live");
+    if (invalidTracks) {
+      throw new Error("Track not live: " + invalidTracks.label);
+    }
+    console.log("buildMediaRecorder tracks OK");
+    let mediaRecorder2 = new MediaRecorder(stream2, recorderOptions2);
+    console.log("buildMediaRecorder mediaRecorder OK");
+    mediaRecorder2.ondataavailable = (e3) => {
+      bufferSize = bufferSize + e3.data.size;
+      if (e3.data.size > 0) {
+        buffer.push(e3.data);
       }
-      lastEvent = e3;
-    } else {
-      if (audio && mediaRecorder.state == "inactive") {
-        const blob = new Blob(buffer, { type: "audio/webm" });
-        buffer = [blob];
+      if (stopped) {
+        console.log("buildMediaRecorder ondataavailable stopped");
+        resolvePromise && resolvePromise();
       }
-      resolvePromise && resolvePromise();
-    }
-  };
-  function startRecording() {
-    return new Promise((resolve) => {
-      resolvePromise = resolve;
-      mediaRecorder.start();
-      bufferSize = 0;
-      stopped = false;
-      if (onBufferSizeError) {
-        onBufferSizeInterval = setInterval(async () => {
-          await mediaRecorder.requestData();
-        }, 3e4);
+    };
+    return mediaRecorder2;
+  }
+  let mediaRecorder = buildMediaRecorder(stream, recorderOptions);
+  async function startRecorder(recorder2) {
+    return new Promise((resolve, reject) => {
+      var _a2, _b;
+      let started = false;
+      recorder2.onstart = () => {
+        started = true;
+        console.log("recorder onstart");
+        resolve();
+      };
+      recorder2.onerror = (ev) => {
+        console.error("Recorder error event:", ev);
+        stream.getTracks().forEach((t3) => console.log(t3.readyState));
+        if ("error" in ev) {
+          const err = ev.error;
+          console.error("Error name:", err == null ? void 0 : err.name);
+          console.error("Error message:", err == null ? void 0 : err.message);
+          reject(err || ev);
+        } else {
+          console.warn("Evento sem propriedade error");
+          reject(ev);
+        }
+      };
+      try {
+        console.log("State antes do start:", recorder2.state);
+        recorder2.start(1e4);
+        startTime = new Date(Date.now());
+      } catch (e3) {
+        console.error("Recorder erro ao chamar start event:", e3);
+        console.error("Erro real:", e3, e3 == null ? void 0 : e3.error, (_a2 = e3 == null ? void 0 : e3.error) == null ? void 0 : _a2.name, (_b = e3 == null ? void 0 : e3.error) == null ? void 0 : _b.message);
+        console.error("Erro real 2:", e3, e3 == null ? void 0 : e3.message, e3 == null ? void 0 : e3.name);
+        stream.getTracks().forEach((t3) => console.log(t3.readyState));
+        return reject(e3);
       }
+      setTimeout(() => {
+        if (!started) {
+          console.error("Timeout ao iniciar o recorder");
+          reject(new Error("Timeout ao iniciar o recorder"));
+        }
+      }, 2e3);
     });
   }
+  async function startRecording() {
+    try {
+      await startRecorder(mediaRecorder);
+      if (mediaRecorder.state === "recording") {
+        bufferSize = 0;
+        stopped = false;
+        return;
+      } else {
+        console.log("Recorder n\xE3o est\xE1 em estado recording ap\xF3s start");
+      }
+    } catch (e3) {
+      console.error("Erro ao iniciar o recorder:", e3);
+      await new Promise((r3) => setTimeout(r3, 300));
+      throw e3;
+    }
+    return;
+  }
   function stopRecording() {
     return new Promise((resolve) => {
       if (mediaRecorder.state == "recording") {
+        console.log("stopRecording Recorder est\xE1 em estado recording, iniciando stop");
         resolvePromise = resolve;
-        mediaRecorder.stop();
+        mediaRecorder.onstop = () => {
+          console.log("recorder onstop");
+        };
         stopped = true;
-        clearInterval(onBufferSizeInterval);
-        stream.getTracks().forEach((el) => {
-          el.stop();
-        });
+        mediaRecorder.stop();
       } else {
+        console.log("stopRecording Recorder n\xE3o est\xE1 em estado recording");
         resolve();
       }
+      stream.getTracks().forEach((el) => {
+        el.stop();
+      });
     });
   }
   function pauseRecording() {
@@ -12358,16 +12859,60 @@ function recorder(stream, buffer, onBufferSizeError = false, onBufferSizeErrorCa
   function getBufferSize() {
     return bufferSize;
   }
+  function getStartTime() {
+    return startTime;
+  }
   return {
     startRecording,
     stopRecording,
     pauseRecording,
     resumeRecording,
     recorderOptions,
-    getBufferSize
+    getBufferSize,
+    getStartTime
   };
 }
 
+// src/plugins/insights.ts
+var backendService;
+var init = (backend) => {
+  backendService = backend;
+  return backendService;
+};
+var eventNames = {
+  DEVICES_CHECKED: "devices_checked",
+  START: "start",
+  FINISH: "finish",
+  ERROR: "error",
+  UPLOAD: "upload",
+  UPLOAD_FILE: "upload_file",
+  DOWNLOAD_VIDEO: "download_video",
+  BUFFER_SIZE: "buffer_size",
+  ANOTHER_STREAM: "another_stream",
+  CHANGE_DEVICE: "change_device",
+  STOP_SHARING_SCREEN: "stop_sharing_screen",
+  ERROR_RECORDER_RTC: "error_recorder_rtc",
+  BROWSER_NOT_SUPPORTED: "browser_not_supported",
+  SAVE_ON_SESSION: "save_on_session"
+};
+var log = (eventName, properties) => backendService && backendService.log(eventName, properties);
+var trackers = {
+  registerDevicesChecked: (proctoringId2, success, description) => log(eventNames.DEVICES_CHECKED, { proctoringId: proctoringId2, success, description }),
+  registerStart: (proctoringId2, success, description) => log(eventNames.START, { proctoringId: proctoringId2, success, description }),
+  registerFinish: (proctoringId2, success, description) => log(eventNames.FINISH, { proctoringId: proctoringId2, success, description }),
+  registerError: (proctoringId2, description) => log(eventNames.ERROR, { proctoringId: proctoringId2, description }),
+  registerBrowserNotSupported: (proctoringId2, description) => log(eventNames.BROWSER_NOT_SUPPORTED, { proctoringId: proctoringId2, description }),
+  registerUpload: (proctoringId2, success, description, serviceType, uploadTime) => log(eventNames.UPLOAD, { proctoringId: proctoringId2, success, description, serviceType, uploadTime }),
+  registerUploadFile: (proctoringId2, description, fileType) => log(eventNames.UPLOAD_FILE, { proctoringId: proctoringId2, description, fileType }),
+  registerChangeDevice: (proctoringId2, inOrOut, description) => log(eventNames.CHANGE_DEVICE, { proctoringId: proctoringId2, inOrOut, description }),
+  registerStopSharingScreen: (proctoringId2, description) => log(eventNames.STOP_SHARING_SCREEN, { proctoringId: proctoringId2, description }),
+  registerErrorRecorderRTC: (proctoringId2, description) => log(eventNames.ERROR_RECORDER_RTC, { proctoringId: proctoringId2, description }),
+  registerDownloadFile: (proctoringId2, description) => log(eventNames.DOWNLOAD_VIDEO, { proctoringId: proctoringId2, description }),
+  registerOnBufferSizeError: (proctoringId2, description) => log(eventNames.BUFFER_SIZE, { proctoringId: proctoringId2, description }),
+  registerAnotherStream: (proctoringId2, description) => log(eventNames.ANOTHER_STREAM, { proctoringId: proctoringId2, description }),
+  registerSaveOnSession: (proctoringId2, description) => log(eventNames.SAVE_ON_SESSION, { proctoringId: proctoringId2, description })
+};
+
 // src/new-flow/upload/UploadService.ts
 var UploadService = class {
   constructor(proctoringId2, backend) {
@@ -12653,12 +13198,12 @@ var VolumeMeter = class {
   async start(options = {}) {
     return new Promise((resolve, reject) => {
       try {
-        const audioContext = new AudioContext();
-        this.analyser = audioContext.createAnalyser();
-        const microphone = audioContext.createMediaStreamSource(this.stream);
+        this.audioContext = new AudioContext();
+        this.analyser = this.audioContext.createAnalyser();
+        this.microphone = this.audioContext.createMediaStreamSource(this.stream);
         this.analyser.smoothingTimeConstant = 0.8;
         this.analyser.fftSize = 1024;
-        microphone.connect(this.analyser);
+        this.microphone.connect(this.analyser);
         const processAudio = () => {
           const array = new Uint8Array(this.analyser.frequencyBinCount);
           this.analyser.getByteFrequencyData(array);
@@ -12677,9 +13222,13 @@ var VolumeMeter = class {
     });
   }
   stop() {
+    var _a2, _b, _c2;
     if (this.animationFrameId !== null) {
       cancelAnimationFrame(this.animationFrameId);
     }
+    (_a2 = this.audioContext) == null ? void 0 : _a2.close();
+    (_b = this.microphone) == null ? void 0 : _b.disconnect();
+    (_c2 = this.analyser) == null ? void 0 : _c2.disconnect();
   }
   getVolume() {
     return this.volume;
@@ -12691,6 +13240,7 @@ var VolumeMeter = class {
 
 // src/new-flow/recorders/CameraRecorder.ts
 var import_jszip_min = __toESM(require_jszip_min());
+var import_fix_webm_duration = __toESM(require_fix_webm_duration());
 var CameraRecorder = class {
   constructor(options, videoOptions, paramsConfig, backend, backendToken) {
     this.blobs = [];
@@ -12740,6 +13290,8 @@ var CameraRecorder = class {
     this.isCanvasLoopActive = false;
     this.hardwareStream = null;
     this.internalClonedStream = null;
+    this.videoElement = null;
+    this.duration = 0;
     this.currentRetries = 0;
     this.packageCount = 0;
     this.noiseWait = 20;
@@ -12760,7 +13312,12 @@ var CameraRecorder = class {
     if (((_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.detectPerson) || ((_b = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _b.detectCellPhone)) {
       this.objectDetection = new ObjectDetection(
         {
-          onRealtimeAlertsCallback: (response) => this.options.onRealtimeAlertsCallback(response)
+          onRealtimeAlertsCallback: (response) => {
+            var _a3, _b2;
+            response.begin = Date.now() - (((_a3 = this.getStartTime()) == null ? void 0 : _a3.getTime()) || 0);
+            response.end = Date.now() - (((_b2 = this.getStartTime()) == null ? void 0 : _b2.getTime()) || 0);
+            this.options.onRealtimeAlertsCallback(response);
+          }
         },
         this.paramsConfig
       );
@@ -12769,7 +13326,12 @@ var CameraRecorder = class {
     if ((_c2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _c2.detectFace) {
       this.faceDetection = new FaceDetection(
         {
-          onRealtimeAlertsCallback: (response) => this.options.onRealtimeAlertsCallback(response)
+          onRealtimeAlertsCallback: (response) => {
+            var _a3, _b2;
+            response.begin = Date.now() - (((_a3 = this.getStartTime()) == null ? void 0 : _a3.getTime()) || 0);
+            response.end = Date.now() - (((_b2 = this.getStartTime()) == null ? void 0 : _b2.getTime()) || 0);
+            this.options.onRealtimeAlertsCallback(response);
+          }
         },
         this.paramsConfig
       );
@@ -12795,25 +13357,20 @@ var CameraRecorder = class {
   }
   async bufferError(e3) {
     var _a2, _b;
-    console.log("buffer error Camera Recorder params " + this.paramsConfig.videoBehaviourParameters);
+    console.log("buffer error Camera Recorder params ");
     const retryEnabled = ((_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.retryEnabled) || false;
     const maxRetries = ((_b = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _b.maxRetries) || 3;
     if (retryEnabled && this.currentRetries < maxRetries) {
       await this.recordingStop();
-      await this.startRecording({
-        retry: true
-      });
+      await this.startRecording();
       this.currentRetries++;
       this.options.onBufferSizeErrorCallback && this.options.onBufferSizeErrorCallback(this.cameraStream);
     } else {
       this.options.onBufferSizeErrorCallback && this.options.onBufferSizeErrorCallback();
     }
   }
-  async startRecording(options) {
-    var _a2, _b, _c2, _d, _e3, _f, _g, _h;
-    if ((((_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.detectPerson) || ((_b = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _b.detectCellPhone) || ((_c2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _c2.detectFace)) && !(options == null ? void 0 : options.retry)) {
-      await this.initializeDetectors();
-    }
+  async startStream() {
+    var _a2;
     const { cameraId, microphoneId, onBufferSizeErrorCallback } = this.options;
     const constraints = {
       audio: { deviceId: microphoneId },
@@ -12837,13 +13394,81 @@ var CameraRecorder = class {
     const track = this.cameraStream.getVideoTracks()[0];
     const settings = track.getSettings();
     let { width = 0, height = 0 } = settings;
+    const isPortrait = (_a2 = screen.orientation) == null ? void 0 : _a2.type.includes("portrait");
+    if (isPortrait && isMobileDevice()) {
+      if (this.videoOptions.width == height && this.videoOptions.height == width) {
+        [width, height] = [height, width];
+      }
+    }
+    if (this.videoOptions.minWidth > width || this.videoOptions.minHeight > height) {
+      throw STREAM_UNDER_MINIMUM_PERMITTED;
+    } else if (this.videoOptions.width !== width || this.videoOptions.height !== height) {
+      trackers.registerAnotherStream(
+        this.proctoringId,
+        `Maybe have another stream active
+Video Options: ${JSON.stringify(
+          this.videoOptions,
+          null,
+          2
+        )}
+Setting: ${JSON.stringify(settings, null, 2)}`
+      );
+      throw ANOTHER_STREAM_ACTIVE;
+    }
+  }
+  async stopStream() {
+    if (this.cameraStream) {
+      this.cameraStream.getTracks().forEach((track) => track.stop());
+    }
+    if (this.internalClonedStream) {
+      this.internalClonedStream.getTracks().forEach((track) => track.stop());
+      this.internalClonedStream = null;
+    }
+    if (this.hardwareStream) {
+      this.hardwareStream.getTracks().forEach((track) => track.stop());
+      this.hardwareStream = null;
+    }
+  }
+  async waitForVideoFlow() {
+    return new Promise((resolve) => {
+      const check = () => {
+        var _a2;
+        if (this.videoElement && ((_a2 = this.videoElement) == null ? void 0 : _a2.readyState) >= 3) return resolve();
+        else requestAnimationFrame(check);
+      };
+      check();
+    });
+  }
+  async attachAndWarmup(stream) {
+    this.videoElement = document.createElement("video");
+    this.videoElement.srcObject = stream;
+    this.videoElement.muted = true;
+    await this.videoElement.play().catch((e3) => {
+    });
+    await new Promise((resolve) => {
+      var _a2;
+      if (this.videoElement && ((_a2 = this.videoElement) == null ? void 0 : _a2.readyState) >= 1) return resolve();
+      if (this.videoElement)
+        this.videoElement.onloadedmetadata = () => resolve();
+    });
+    console.log("CameraRecorder checking metadata ok");
+    await this.waitForVideoFlow();
+    console.log("CameraRecorder waiting for video flow ok");
+    await new Promise((r3) => setTimeout(r3, 300));
+  }
+  async startRecording() {
+    var _a2, _b, _c2, _d, _e3, _f, _g;
+    console.log("CameraRecorder startRecording");
+    await this.startStream();
+    await this.attachAndWarmup(this.cameraStream);
     const {
       startRecording,
       stopRecording,
       pauseRecording,
       resumeRecording,
       recorderOptions,
-      getBufferSize
+      getBufferSize,
+      getStartTime
     } = recorder(
       this.cameraStream,
       // streamToRecord,
@@ -12858,44 +13483,50 @@ var CameraRecorder = class {
     this.recordingResume = resumeRecording;
     this.recorderOptions = recorderOptions;
     this.getBufferSize = getBufferSize;
-    this.recordingStart();
-    const isPortrait = (_d = screen.orientation) == null ? void 0 : _d.type.includes("portrait");
-    if (isPortrait && isMobileDevice()) {
-      if (this.videoOptions.width == height && this.videoOptions.height == width) {
-        [width, height] = [height, width];
+    this.getStartTime = getStartTime;
+    try {
+      await new Promise((r3) => setTimeout(r3, 500));
+      await this.recordingStart();
+    } catch (error) {
+      console.log("Camera Recorder error", error);
+      this.stopRecording();
+      const maxRetries = ((_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.maxRetries) || 3;
+      if (this.currentRetries < maxRetries) {
+        console.log("Camera Recorder retry", this.currentRetries);
+        this.currentRetries++;
+        await this.startRecording();
+      } else {
+        throw error;
       }
     }
-    if (this.videoOptions.minWidth > width || this.videoOptions.minHeight > height) {
-      throw STREAM_UNDER_MINIMUM_PERMITTED;
-    } else if (this.videoOptions.width !== width || this.videoOptions.height !== height) {
-      trackers.registerAnotherStream(
-        this.proctoringId,
-        `Maybe have another stream active
-Video Options: ${JSON.stringify(
-          this.videoOptions,
-          null,
-          2
-        )}
-Setting: ${JSON.stringify(settings, null, 2)}`
-      );
-      throw ANOTHER_STREAM_ACTIVE;
+    if (((_b = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _b.detectPerson) || ((_c2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _c2.detectCellPhone) || ((_d = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _d.detectFace)) {
+      await this.initializeDetectors();
     }
-    ((_e3 = this.paramsConfig.imageBehaviourParameters) == null ? void 0 : _e3.useUploadImage) && this.options.proctoringType == "IMAGE" && this.photoShotsCycle();
-    if ((_f = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _f.detectFace) {
+    if ((_e3 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _e3.detectFace) {
       await this.faceDetection.enableCam(this.cameraStream);
     }
-    if (((_g = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _g.detectPerson) || ((_h = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _h.detectCellPhone)) {
+    if (((_f = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _f.detectPerson) || ((_g = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _g.detectCellPhone)) {
       await this.objectDetection.enableCam(this.cameraStream);
     }
     this.filesToUpload = [];
     if (this.options.proctoringType == "REALTIME") {
-      this.captureFrame();
+      await this.startRealtimeCapture();
     }
     this.packageCount = 0;
+    console.log("Camera Recorder started OK");
   }
   async stopRecording() {
+    var _a2, _b, _c2, _d;
+    console.log("Camera Recorder stopRecording");
     this.isCanvasLoopActive = false;
+    this.faceDetection && this.faceDetection.detecting && this.faceDetection.stopDetection();
+    this.objectDetection && this.objectDetection.detecting && this.objectDetection.stopDetection();
+    clearInterval(this.imageInterval);
+    clearInterval(this.sendFrameInterval);
+    this.volumeMeter && this.volumeMeter.stop();
+    this.intervalNoiseDetection && clearInterval(this.intervalNoiseDetection);
     this.recordingStop && await this.recordingStop();
+    this.duration = Date.now() - ((_a2 = this.getStartTime()) == null ? void 0 : _a2.getTime()) || 0;
     try {
       if (this.animationFrameId) {
         cancelAnimationFrame(this.animationFrameId);
@@ -12912,19 +13543,23 @@ Setting: ${JSON.stringify(settings, null, 2)}`
         this.hardwareStream.getTracks().forEach((track) => track.stop());
         this.hardwareStream = null;
       }
+      if (this.videoElement) {
+        (_b = this.videoElement) == null ? void 0 : _b.remove();
+        this.videoElement = null;
+      }
+      if (this.video) {
+        (_c2 = this.video) == null ? void 0 : _c2.remove();
+      }
+      if (this.canvas) {
+        (_d = this.canvas) == null ? void 0 : _d.remove();
+      }
     } catch (e3) {
       console.error("Erro ao parar os streams de m\xEDdia.");
     }
-    this.faceDetection && this.faceDetection.detecting && this.faceDetection.stopDetection();
-    this.objectDetection && this.objectDetection.detecting && this.objectDetection.stopDetection();
-    clearInterval(this.imageInterval);
-    clearInterval(this.sendFrameInterval);
     if (this.options.proctoringType == "REALTIME" && this.upload && this.backendToken) {
       await this.sendPackage(this.filesToUpload);
       await this.filesToUpload.splice(0, this.filesToUpload.length);
     }
-    this.volumeMeter && this.volumeMeter.stop();
-    this.intervalNoiseDetection && clearInterval(this.intervalNoiseDetection);
   }
   async pauseRecording() {
     await this.recordingPause();
@@ -12932,35 +13567,6 @@ Setting: ${JSON.stringify(settings, null, 2)}`
   async resumeRecording() {
     await this.recordingResume();
   }
-  photoShotsCycle() {
-    let imageFile;
-    this.configImageCapture();
-    this.imageInterval = setInterval(async () => {
-      this.canvas.getContext("2d").drawImage(
-        this.video,
-        0,
-        0,
-        this.videoOptions.width,
-        this.videoOptions.height
-      );
-      const image_data_url = this.canvas.toDataURL("image/jpeg");
-      imageFile = await this.getFile(
-        image_data_url,
-        `${this.proctoringId}_${this.imageCount + 1}.jpg`,
-        "image/jpeg"
-      );
-      if (imageFile && this.upload && this.backendToken) {
-        this.upload.upload(
-          {
-            file: imageFile
-          },
-          this.backendToken,
-          true
-        );
-        this.imageCount++;
-      }
-    }, this.paramsConfig.imageBehaviourParameters.uploadInterval * 1e3);
-  }
   async getCurrentImageBase64() {
     if (!this.video || !this.canvas) {
       this.configImageCapture();
@@ -12991,30 +13597,35 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     this.canvas.getContext("2d").drawImage(this.video, 0, 0, this.canvas.width, this.canvas.height);
     return this.canvas.toDataURL("image/jpeg");
   }
-  // captura um frame a cada intervalo de tempo definido no paramsConfig.videoBehaviourParameters?.realtimeCaptureInterval!
-  captureFrame() {
-    var _a2, _b;
+  async captureFrame() {
+    var _a2;
     let imageFile;
-    this.configImageCapture();
     const packSize = (_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.realtimePackageSize;
+    this.canvas.getContext("2d").drawImage(this.video, 0, 0, this.canvas.width, this.canvas.height);
+    const image_data_url = this.canvas.toDataURL("image/jpeg");
+    if (this.proctoringId == void 0) return;
+    if (packSize == this.imageCount) {
+      this.imageCount = 0;
+      const framesToSend = [...this.filesToUpload];
+      this.sendPackage(framesToSend);
+      await this.filesToUpload.splice(0, this.filesToUpload.length);
+    }
+    let imageName = `${this.proctoringId}_${this.imageCount + 1}.jpg`;
+    imageFile = await this.getFile(image_data_url, imageName, "image/jpeg");
+    if (imageFile && imageFile.size > 10 && packSize > 0) {
+      this.filesToUpload.push(imageFile);
+      this.imageCount++;
+    }
+  }
+  // inicia a captura de um frame a cada intervalo de tempo definido no paramsConfig.videoBehaviourParameters?.realtimeCaptureInterval!
+  async startRealtimeCapture() {
+    var _a2;
+    this.configImageCapture();
     this.imageCount = 0;
+    await this.captureFrame();
     this.imageInterval = setInterval(async () => {
-      this.canvas.getContext("2d").drawImage(this.video, 0, 0, this.canvas.width, this.canvas.height);
-      const image_data_url = this.canvas.toDataURL("image/jpeg");
-      if (this.proctoringId == void 0) return;
-      if (packSize == this.imageCount) {
-        this.imageCount = 0;
-        const framesToSend = [...this.filesToUpload];
-        this.sendPackage(framesToSend);
-        await this.filesToUpload.splice(0, this.filesToUpload.length);
-      }
-      let imageName = `${this.proctoringId}_${this.imageCount + 1}.jpg`;
-      imageFile = await this.getFile(image_data_url, imageName, "image/jpeg");
-      if (imageFile && imageFile.size > 10 && packSize > 0) {
-        this.filesToUpload.push(imageFile);
-        this.imageCount++;
-      }
-    }, ((_b = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _b.realtimeCaptureInterval) * 1e3);
+      await this.captureFrame();
+    }, ((_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.realtimeCaptureInterval) * 1e3);
   }
   // envia pacote de imagens
   async sendPackage(framesToSend) {
@@ -13022,7 +13633,7 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     let pending = false;
     let undeliveredPackagesCount = 0;
     const packSize = (_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.realtimePackageSize;
-    const packCaptureInterval = ((_b = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _b.realtimeCaptureInterval) + 1;
+    const packCaptureInterval = (_b = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _b.realtimeCaptureInterval;
     if (this.upload && this.backendToken && !pending && this.filesToUpload.length > 0) {
       undeliveredPackagesCount = 0;
       pending = true;
@@ -13082,6 +13693,15 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     const settings = this.cameraStream.getVideoTracks()[0].getSettings();
     const settingsAudio = this.cameraStream.getAudioTracks()[0].getSettings();
     if (this.options.proctoringType == "VIDEO" || this.options.proctoringType == "REALTIME" || this.options.proctoringType == "IMAGE" && ((_a2 = this.paramsConfig.imageBehaviourParameters) == null ? void 0 : _a2.saveVideo)) {
+      const rawBlob = new Blob(this.blobs, {
+        type: ((_b = this.recorderOptions) == null ? void 0 : _b.mimeType) || "video/webm"
+      });
+      const fixedBlob = await (0, import_fix_webm_duration.default)(rawBlob, this.duration);
+      const file = new File(
+        [fixedBlob],
+        `EP_${session.id}_camera_0.webm`,
+        { type: rawBlob.type }
+      );
       session.addRecording({
         device: `Audio
 	Sample Rate: ${settingsAudio.sampleRate}
@@ -13089,9 +13709,7 @@ Setting: ${JSON.stringify(settings, null, 2)}`
 
 	Video:
 	${JSON.stringify(this.recorderOptions)}`,
-        file: new File(this.blobs, `EP_${session.id}_camera_0.webm`, {
-          type: ((_b = this.recorderOptions) == null ? void 0 : _b.mimeType) || "video/webm"
-        }),
+        file,
         origin: "Camera" /* Camera */
       });
     }
@@ -14210,6 +14828,7 @@ var _DeviceCheckerService = class _DeviceCheckerService {
     return this.deviceCheckResult;
   }
   async runCheckDevicesFlow(options, _videoOptions, onModalConfirm, onModalCancel, onUpdate) {
+    var _a2;
     if (_DeviceCheckerService.isModalOpen) {
       return Promise.reject("Modal j\xE1 est\xE1 aberto");
     }
@@ -14227,7 +14846,9 @@ var _DeviceCheckerService = class _DeviceCheckerService {
         options,
         _videoOptions
       );
-      this.checkSpyScan();
+      if ((_a2 = this.options) == null ? void 0 : _a2.useSpyScan) {
+        await this.checkSpyScan();
+      }
       const returnData = { cameraStream: this.cameraRecorder.cameraStream };
       this.onUpdateCb = (e3) => onUpdate(e3);
       const resultPromise = new Promise(
@@ -14282,6 +14903,10 @@ var _DeviceCheckerService = class _DeviceCheckerService {
     if (_DeviceCheckerService.isModalOpen) {
       return Promise.reject();
     }
+    this.allowedAmbient = false;
+    this.allowedMicrophone = false;
+    this.allowedAmbient = false;
+    this.allowedPositionFace = false;
     _DeviceCheckerService.isModalOpen = true;
     this.DeviceCheckerUI = new DeviceCheckerUI(options, _videoOptions);
     try {
@@ -14319,8 +14944,8 @@ var _DeviceCheckerService = class _DeviceCheckerService {
         resolve(response);
       });
     } catch (error) {
+      this.DeviceCheckerUI && this.DeviceCheckerUI.closeModal();
       this.closeCheckDevices();
-      this.DeviceCheckerUI.closeModal();
       return Promise.reject(error);
     }
   }
@@ -14391,7 +15016,7 @@ var _DeviceCheckerService = class _DeviceCheckerService {
   }
   async changeSelectedDevice({ cameraId, microphoneId }) {
     var _a2;
-    this.cameraRecorder.stopRecording && await this.cameraRecorder.stopRecording();
+    this.cameraRecorder.stopStream && await this.cameraRecorder.stopStream();
     (_a2 = this.volumeMeter) == null ? void 0 : _a2.stop();
     this.faceDetection.stopDetection();
     this.cameraRecorder = new CameraRecorder(
@@ -14407,7 +15032,7 @@ var _DeviceCheckerService = class _DeviceCheckerService {
         height: this.videoOptions.height
       }
     );
-    await this.cameraRecorder.startRecording();
+    await this.cameraRecorder.startStream();
     this.videoDeviceInterface(this.cameraRecorder.cameraStream);
     this.audioDeviceInterface(this.cameraRecorder.cameraStream);
     return {
@@ -14415,6 +15040,10 @@ var _DeviceCheckerService = class _DeviceCheckerService {
     };
   }
   async startCheckDevices(options = getDefaultProctoringOptions, _videoOptions) {
+    this.allowedAmbient = false;
+    this.allowedMicrophone = false;
+    this.allowedAmbient = false;
+    this.allowedPositionFace = false;
     this.DeviceCheckerUI && this.DeviceCheckerUI.setSelectOption(
       options,
       (e3) => this.changeSelectedDevice(e3)
@@ -14434,7 +15063,7 @@ var _DeviceCheckerService = class _DeviceCheckerService {
         height: this.videoOptions.height
       }
     );
-    await this.cameraRecorder.startRecording();
+    await this.cameraRecorder.startStream();
     this.videoDeviceInterface(this.cameraRecorder.cameraStream);
     this.audioDeviceInterface(this.cameraRecorder.cameraStream);
     if (this.DeviceCheckerUI) {
@@ -14451,7 +15080,7 @@ var _DeviceCheckerService = class _DeviceCheckerService {
     this.faceDetection.stopDetection();
     (_a2 = this.volumeMeter) == null ? void 0 : _a2.stop();
     this.volumeMedia = Math.ceil(this.volumeSum / this.volumeCounter);
-    this.cameraRecorder.stopRecording && await this.cameraRecorder.stopRecording();
+    this.cameraRecorder.stopStream && await this.cameraRecorder.stopStream();
     this.DeviceCheckerUI = void 0;
     this.onUpdateCb = void 0;
   }
@@ -14524,7 +15153,7 @@ var CapturePhoto = class {
       //     height: 480,
       // }
     );
-    await this.cameraRecorder.startRecording();
+    await this.cameraRecorder.startStream();
     cameraContainer.srcObject = this.cameraRecorder.cameraStream;
     cameraContainer.play();
   }
@@ -14764,7 +15393,7 @@ var CapturePhoto = class {
     });
   }
   async closeInterface() {
-    await this.cameraRecorder.stopRecording();
+    await this.cameraRecorder.stopStream();
     const authPhoto = document.querySelector("#authPhoto");
     authPhoto == null ? void 0 : authPhoto.remove();
   }
@@ -15047,6 +15676,22 @@ var ProctoringUploader = class {
           }
         },
         token
+      ).catch(
+        async (e3) => {
+          console.log("Upload File Error", e3), trackers.registerError(this.proctoringId, `Upload File
+	Name: ${rec.file.name}
+Error: ${e3.message}
+	Size: ${e3.error}`);
+          await uploadService.upload(
+            {
+              file: rec.file,
+              onProgress: (progress) => {
+                if (onProgress) onProgress(progress);
+              }
+            },
+            token
+          );
+        }
       );
       if (result) {
         let fileType = "";
@@ -15268,54 +15913,6 @@ var AlertRecorder = class {
   }
 };
 
-// src/new-flow/recorders/AudioRecorder.ts
-var AudioRecorder = class {
-  constructor(options, audioParams) {
-    this.blobs = [];
-    this.options = {
-      cameraId: void 0,
-      microphoneId: void 0
-    };
-    this.audioParams = {
-      recordingBitrate: 128
-    };
-    audioParams && (this.audioParams = audioParams);
-    options && (this.options = options);
-  }
-  async startRecording() {
-    const constraints = {
-      audio: { deviceId: this.options.microphoneId || "default" }
-    };
-    this.audioStream = await navigator.mediaDevices.getUserMedia(constraints);
-    const { startRecording, stopRecording, pauseRecording, resumeRecording } = recorder(this.audioStream, this.blobs, void 0, void 0, true);
-    this.recordingStart = startRecording;
-    this.recordingStop = stopRecording;
-    this.recordingPause = pauseRecording;
-    this.recordingResume = resumeRecording;
-    this.recordingStart();
-  }
-  async pauseRecording() {
-  }
-  async resumeRecording() {
-  }
-  async stopRecording() {
-    this.recordingStop && await this.recordingStop();
-  }
-  async saveOnSession(session, start, end) {
-    session.addRecording({
-      device: "",
-      file: new File(
-        this.blobs,
-        `EP_${session.id}_audio_${start && end && `${start}_${end}` || "0"}.webm`,
-        {
-          type: "audio/webm"
-        }
-      ),
-      origin: "Mic" /* Mic */
-    });
-  }
-};
-
 // node_modules/@mediapipe/tasks-audio/audio_bundle.mjs
 var t2 = "undefined" != typeof self ? self : {};
 function e2() {
@@ -17555,7 +18152,6 @@ var NoiseRecorder = class {
     this.recordingInProgress = false;
     this.recordIndex = 1;
     this.countLoopTimes = 0;
-    this.examStartTime = 0;
     this.recordingStartTime = 0;
     this.recordingEndTime = 0;
     this.isSpeech = false;
@@ -17582,12 +18178,7 @@ var NoiseRecorder = class {
     this.proctoringId && this.backend && (this.upload = new UploadService(this.proctoringId, this.backend));
   }
   async startRecording() {
-    this.examStartTime = Date.now();
     await this.createAudioClassifier();
-    this.audioRecorder = new AudioRecorder(
-      void 0,
-      this.paramsConfig.audioBehaviourParameters
-    );
     this.intervalNoiseDetection = setInterval(
       () => this.onNoiseDetectedRecord(),
       200
@@ -17599,6 +18190,7 @@ var NoiseRecorder = class {
     await this.stopSoundRecord();
     await this.volumeMeter && this.volumeMeter.stop();
     this.audioWorkletNode && this.audioWorkletNode.disconnect();
+    this.context && this.context.close();
   }
   async pauseRecording() {
   }
@@ -17607,7 +18199,7 @@ var NoiseRecorder = class {
   async saveOnSession(session) {
   }
   async onNoiseDetectedRecord() {
-    var _a2, _b, _c2, _d;
+    var _a2, _b, _c2, _d, _e3, _f, _g, _h, _i3;
     if (!this.volumeMeter && this.cameraRecorder.cameraStream) {
       this.volumeMeter = new VolumeMeter(this.cameraRecorder.cameraStream);
       this.volumeMeter.start().catch((e3) => {
@@ -17629,7 +18221,7 @@ var NoiseRecorder = class {
       this.recordingChunks = [...this.preRollBuffer];
       const totalSamplesInBuffer = this.preRollBuffer.reduce((acc, chunk) => acc + chunk.length, 0);
       const bufferDurationMs = totalSamplesInBuffer / this.SAMPLE_RATE * 1e3;
-      const triggerTime = Date.now() - this.examStartTime;
+      const triggerTime = Date.now() - (((_c2 = this.cameraRecorder.getStartTime()) == null ? void 0 : _c2.getTime()) || 0);
       this.recordingStartTime = triggerTime - bufferDurationMs;
       if (this.recordingStartTime < 0) this.recordingStartTime = 0;
     } else if (this.recordingInProgress) {
@@ -17637,15 +18229,19 @@ var NoiseRecorder = class {
       const currentRecordDuration = Date.now() - this.recordingStartTime;
       if (silenceDuration >= this.SILENCE_THRESHOLD && currentRecordDuration >= 3e3 && this.countLoopTimes > 4) {
         await this.stopSoundRecord();
-        if (((_c2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _c2.detectNoise) && !this.isSpeech) {
+        if (((_d = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _d.detectNoise) && !this.isSpeech) {
           this.onRealtimeAlertsCallback({
+            begin: Date.now() - (((_e3 = this.cameraRecorder.getStartTime()) == null ? void 0 : _e3.getTime()) || 0),
+            end: Date.now() - (((_f = this.cameraRecorder.getStartTime()) == null ? void 0 : _f.getTime()) || 0),
             status: "ALERT",
             description: "Barulho detectado",
             type: "audio_detection_on_stream"
           });
         }
-        if (((_d = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _d.detectSpeech) && this.isSpeech) {
+        if (((_g = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _g.detectSpeech) && this.isSpeech) {
           this.onRealtimeAlertsCallback({
+            begin: Date.now() - (((_h = this.cameraRecorder.getStartTime()) == null ? void 0 : _h.getTime()) || 0),
+            end: Date.now() - (((_i3 = this.cameraRecorder.getStartTime()) == null ? void 0 : _i3.getTime()) || 0),
             status: "ALERT",
             description: "Fala detectada",
             type: "audio_detection_on_stream"
@@ -17660,8 +18256,9 @@ var NoiseRecorder = class {
     }
   }
   async stopSoundRecord() {
+    var _a2;
     if (!this.recordingInProgress && this.recordingChunks.length === 0) return;
-    this.recordingEndTime = Date.now() - this.examStartTime;
+    this.recordingEndTime = Date.now() - (((_a2 = this.cameraRecorder.getStartTime()) == null ? void 0 : _a2.getTime()) || 0);
     if (this.optionsProctoring.proctoringType !== "REALTIME") return;
     const wavBlob = encodeToWav(this.recordingChunks, this.SAMPLE_RATE);
     const file = new File(
@@ -17803,10 +18400,12 @@ registerProcessor("audio-processor", AudioProcessor);
 `;
 
 // src/new-flow/recorders/ScreenRecorder.ts
+var import_fix_webm_duration2 = __toESM(require_fix_webm_duration());
 var ScreenRecorder = class {
   constructor(options) {
     this.blobs = [];
     this.blobsFinal = [];
+    this.duration = 0;
     this.options = options;
   }
   setProctoringId(proctoringId2) {
@@ -17888,14 +18487,24 @@ var ScreenRecorder = class {
   async resumeRecording() {
   }
   async stopRecording() {
+    var _a2;
     this.recordingStop && await this.recordingStop();
+    this.duration = Date.now() - ((_a2 = this.startTime) == null ? void 0 : _a2.getTime()) || 0;
   }
   async saveOnSession(session) {
+    if (isMobileDevice()) return;
+    const rawBlob = new Blob(this.blobs, {
+      type: "video/webm"
+    });
+    const fixedBlob = await (0, import_fix_webm_duration2.default)(rawBlob, this.duration);
+    const file = new File(
+      [fixedBlob],
+      `EP_${session.id}_screen_0.webm`,
+      { type: rawBlob.type }
+    );
     session.addRecording({
       device: "",
-      file: new File(this.blobs, `EP_${session.id}_screen_0.webm`, {
-        type: "video/webm"
-      }),
+      file,
       origin: "Screen" /* Screen */
     });
   }
@@ -20948,7 +21557,6 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
     this.connection = null;
     this.context = context;
     this.onRealtimeAlertsCallback = onRealtimeAlertsCallback;
-    console.log("context -> ", context);
     this.backend = new BackendService({
       type: (context == null ? void 0 : context.type) || "prod",
       token: context.token
@@ -20962,7 +21570,6 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
     try {
       this.transmissionOk = false;
       const response = await this.backend.externalCameraCheckTransmission("" + this.externalSessionId);
-      console.log(response);
       let attempts = 0;
       while (!this.transmissionOk && attempts <= 5) {
         await new Promise((resolve) => setTimeout(resolve, 2e3));
@@ -20979,16 +21586,13 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
     try {
       this.proctoringId = proctoringId2;
       const response = await this.backend.externalCameraStartTransmission("" + this.externalSessionId, proctoringId2);
-      console.log(response);
     } catch (error) {
-      console.error("Erro ao iniciar transmiss\xE3o:", error);
       throw new Error("N\xE3o foi poss\xEDvel iniciar a transmiss\xE3o.");
     }
   }
   async goToPositionGuide() {
     try {
       const response = await this.backend.goToExternalCameraPositionStep("" + this.externalSessionId);
-      console.log(response);
     } catch (error) {
       console.error("Erro ao enviar comando de Position:", error);
       throw new Error("N\xE3o foi poss\xEDvel enviar comando de Position Guide.");
@@ -20998,7 +21602,6 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
     if (this.connection) {
       const actionMessage = new ActionMessage();
       actionMessage.command = "Reset";
-      console.log("Enviando comando 'Reset' para o aplicativo...");
       this.connection.invoke(
         "SendAction",
         this.externalSessionId,
@@ -21012,7 +21615,6 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
       this.onTakePictureCallback = onTakePictureCallback;
       const actionMessage = new ActionMessage();
       actionMessage.command = "Capture";
-      console.log("Enviando comando 'Capture' para o aplicativo...");
       this.connection.invoke(
         "SendAction",
         this.externalSessionId,
@@ -21031,7 +21633,6 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
       await this.reset();
       const response = await this.backend.externalCameraStartSession();
       this.externalSessionId = response.externalSessionId;
-      console.log(this.externalSessionId);
       this.currentStep = 0 /* STARTED */;
       const pairingObject = {
         externalSessionId: this.externalSessionId,
@@ -21040,7 +21641,6 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
       };
       const pairingDataString = JSON.stringify(pairingObject);
       this.qrCodeBase64Image = await import_qrcode.default.toDataURL(pairingDataString);
-      console.log(this.qrCodeBase64Image);
       return this.qrCodeBase64Image;
     } catch (error) {
       this.disconnectWebSocket();
@@ -21139,7 +21739,6 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
         var _a2;
         const actionMessage = new ActionMessage();
         actionMessage.command = "Cancel";
-        console.log("Enviando comando 'Cancel' para o aplicativo...");
         (_a2 = this.connection) == null ? void 0 : _a2.invoke(
           "SendAction",
           this.externalSessionId,
@@ -21479,8 +22078,6 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
     this.connection.on(
       "ReceiveMessage",
       (sessionId, messageStr) => {
-        console.log("sessionId: ", sessionId);
-        console.log("Message: ", messageStr);
         if (sessionId !== this.externalSessionId) {
           console.warn("Sess\xE3o diferente!");
           return;
@@ -21488,7 +22085,6 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
         try {
           const messageKey = messageStr;
           const message = ExternalCameraStatusEnum[messageKey];
-          console.log("Mensagem -> ", message);
           this.handleWebSocketMessage(message);
         } catch (e3) {
           console.error("Erro ao processar mensagem do WebSocket:", e3);
@@ -21498,8 +22094,6 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
     this.connection.on(
       "ReceiveAction",
       (sessionId, actionMessage) => {
-        console.log("sessionId: ", sessionId);
-        console.log("Message: ", actionMessage);
         if (sessionId !== this.externalSessionId) {
           console.warn("Sess\xE3o diferente!");
           return;
@@ -21513,7 +22107,6 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
     );
     try {
       await this.connection.start();
-      console.log("Conectado ao Hub SignalR com sucesso!");
     } catch (err) {
       console.error("Falha ao conectar ou entrar no grupo do SignalR: ", err);
       throw new Error("N\xE3o foi poss\xEDvel conectar ao servi\xE7o em tempo real.");
@@ -21640,7 +22233,6 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
     if (this.connection) {
       try {
         await this.connection.stop();
-        console.log("Desconectado do SignalR.");
       } catch (err) {
         console.error("Erro ao desconectar do SignalR:", err);
       } finally {
@@ -21711,7 +22303,8 @@ var Proctoring = class {
     this.onChangeDevicesCallback = (devices) => {
       return;
     };
-    this.onRealtimeAlertsCallback = (response) => {
+    this.onRealtimeAlertsCallback = async (response) => {
+      await this.internalOnRealtimeAlerts(response);
       return;
     };
     this.onBufferSizeErrorCallback = (cameraStream) => {
@@ -21838,10 +22431,9 @@ var Proctoring = class {
           begin: alert.begin,
           end: alert.end,
           warningCategoryEnum: this.convertRealtimeTypeToWarningType(alert.type),
-          alertImageBase64: await this.allRecorders.cameraRecorder.getCurrentImageBase64(),
+          alertImageBase64: alert.description !== "face_stop" ? await this.allRecorders.cameraRecorder.getCurrentImageBase64() : "",
           retry: verifyCount < verifyMaxRetries - 1 ? true : false
         });
-        console.log("response stopRealtimeAlert", response);
         return response;
       } catch (error) {
         console.log("error stopRealtimeAlert", error);
@@ -21850,23 +22442,26 @@ var Proctoring = class {
     };
     await verifyFace(1);
   }
+  async internalOnRealtimeAlerts(response) {
+    if (this.sessionOptions.proctoringType === "REALTIME" && (response.type === "face_detection_on_stream" || response.type === "person_detection_on_stream" || response.type === "lost_focus" || response.type === "focus")) {
+      if (response.status === "ALERT") {
+        await this.backend.startRealtimeAlert({
+          proctoringId: this.proctoringId,
+          begin: response.begin,
+          end: response.end,
+          alert: this.convertRealtimeCategoryToAlertCategory(response.category)
+        });
+      } else if (response.status === "OK") {
+        await this.stopRealtimeAlert(response);
+      }
+    }
+  }
   async onRealtimeAlerts(options = {}) {
     this.setOnLostFocusAlertRecorderCallback();
     this.setOnFocusAlertRecorderCallback();
     this.onRealtimeAlertsCallback = async (response) => {
+      await this.internalOnRealtimeAlerts(response);
       options.data && options.data(response);
-      if (this.sessionOptions.proctoringType === "REALTIME" && (response.type === "face_detection_on_stream" || response.type === "person_detection_on_stream" || response.type === "lost_focus" || response.type === "focus")) {
-        if (response.status === "ALERT") {
-          await this.backend.startRealtimeAlert({
-            proctoringId: this.proctoringId,
-            begin: response.begin,
-            end: response.end,
-            alert: this.convertRealtimeCategoryToAlertCategory(response.category)
-          });
-        } else if (response.status === "OK") {
-          await this.stopRealtimeAlert(response);
-        }
-      }
     };
   }
   setOnBufferSizeErrorCallback(cb) {
@@ -21880,9 +22475,11 @@ var Proctoring = class {
   setDeviceCheckData(data) {
     this.deviceData = data;
   }
-  createRecorders(options = getDefaultProctoringOptions) {
-    var _a2, _b;
+  async createRecorders(options = getDefaultProctoringOptions) {
+    var _a2, _b, _c2;
     this.onChangeDevices();
+    console.log("Creating recorders");
+    await ((_a2 = this.recorder) == null ? void 0 : _a2.stopAll());
     const cameraRecorder = new CameraRecorder(
       {
         cameraId: this.sessionOptions.cameraId,
@@ -21904,8 +22501,8 @@ var Proctoring = class {
       this.context.token
     );
     const screenRecorder = this.sessionOptions.captureScreen ? new ScreenRecorder({
-      allowOnlyFirstMonitor: (_a2 = this.sessionOptions.allowOnlyFirstMonitor) != null ? _a2 : true,
-      allowMultipleMonitors: (_b = this.sessionOptions.allowMultipleMonitors) != null ? _b : true,
+      allowOnlyFirstMonitor: (_b = this.sessionOptions.allowOnlyFirstMonitor) != null ? _b : true,
+      allowMultipleMonitors: (_c2 = this.sessionOptions.allowMultipleMonitors) != null ? _c2 : true,
       screenRecorderOptions: this.sessionOptions.screenRecorderOptions,
       onStopSharingScreenCallback: () => this.onStopSharingScreenCallback(),
       onBufferSizeError: this.sessionOptions.onBufferSizeError,
@@ -21930,10 +22527,12 @@ var Proctoring = class {
     );
     const recorders = [
       cameraRecorder,
-      screenRecorder,
+      noiseRecorder,
       alertRecorder
     ].filter(Boolean);
-    recorders.push(noiseRecorder);
+    if (this.sessionOptions.proctoringType != "REALTIME" && screenRecorder) {
+      recorders.push(screenRecorder);
+    }
     this.recorder = new ProctoringRecorder(this.proctoringSession, recorders);
     return { cameraRecorder, screenRecorder, alertRecorder, noiseRecorder };
   }
@@ -21973,7 +22572,7 @@ var Proctoring = class {
         await this.repository.clear();
       }
       this.proctoringSession = new ProctoringSession();
-      this.allRecorders = this.createRecorders(this.sessionOptions);
+      this.allRecorders = await this.createRecorders(this.sessionOptions);
       const startResponse = await this.backend.confirmStart(
         {
           clientId: this.context.clientId,
@@ -22000,7 +22599,13 @@ var Proctoring = class {
       this.allRecorders.cameraRecorder.setProctoringId(this.proctoringId);
       this.allRecorders.noiseRecorder.setProctoringId(this.proctoringId);
       this.proctoringSession.setProctoringId(this.proctoringId);
-      await this.recorder.startAll();
+      try {
+        console.log("Starting recorders");
+        await this.recorder.startAll();
+      } catch (error) {
+        console.log("Starting recorders error:", error);
+        throw error;
+      }
       if (options == null ? void 0 : options.useSpyScan) {
         this.spyCam.setProctoringId(this.proctoringId);
         this.spyCam.startCheckSpyCam((_a2 = this.paramsConfig.spyScanInterval) != null ? _a2 : 5, {
@@ -22031,7 +22636,7 @@ Navigator: ${JSON.stringify(_navigator2)}`
           verifyingFace = true;
           verifyFirstFaceIntervalCount++;
           try {
-            var response = await this.backend.verifyFace(this.proctoringId, await this.allRecorders.cameraRecorder.getCurrentImageBase64(), verifyFirstFaceIntervalCount > 5 ? false : true);
+            var response = await this.backend.verifyFace(this.proctoringId, await this.allRecorders.cameraRecorder.getCurrentImageBase64(), verifyFirstFaceIntervalCount > 2 ? false : true);
             verifyingFace = false;
             clearInterval(this.verifyFirstFaceInterval);
           } catch (error) {
@@ -22039,7 +22644,7 @@ Navigator: ${JSON.stringify(_navigator2)}`
             return;
           }
         }
-      }, 1500);
+      }, 5e3);
       return startResponse;
     } catch (error) {
       console.log(error);
@@ -22161,7 +22766,6 @@ Upload Services: ${uploaderServices}`,
       await this.backend.finishAndSendUrls(this.context).then((finishResponse) => {
         var _a2, _b, _c2, _d;
         trackers.registerFinish(this.proctoringSession.id, true, "");
-        console.log("finishResponse: ", finishResponse);
         options.onResultAvailable && options.onResultAvailable((_a2 = finishResponse == null ? void 0 : finishResponse.score) != null ? _a2 : 100, (_b = finishResponse == null ? void 0 : finishResponse.scoreThreshold) != null ? _b : 70, (_c2 = finishResponse == null ? void 0 : finishResponse.approved) != null ? _c2 : true, (_d = finishResponse == null ? void 0 : finishResponse.justification) != null ? _d : "");
       }).catch((error) => {
         trackers.registerFinish(
@@ -22290,7 +22894,6 @@ Error: ` + error
     return {
       cameraStream: this.allRecorders.cameraRecorder.cameraStream,
       // recorder (pause & resume)
-      //   audioStream: this.allRecorders.audioRecorder.audioStream,
       _screenStream: (_a2 = this.allRecorders.screenRecorder) == null ? void 0 : _a2.screenStream
     };
   }