easyproctor 2.1.0 → 2.2.0

package/esm/index.js

@@ -4510,34 +4510,6 @@ var FaceDetection = class extends BaseDetection {
   }
 };
 
-// src/proctoring/options/ProctoringOptions.ts
-var getDefaultProctoringOptions = {
-  cameraId: void 0,
-  microphoneId: void 0,
-  allowMultipleMonitors: false,
-  allowOnlyFirstMonitor: true,
-  captureScreen: true,
-  noiseLimit: 40,
-  proctoringType: "IMAGE",
-  insights: "",
-  onBufferSizeError: false,
-  useGeolocation: false
-};
-
-// src/proctoring/options/ProctoringVideoOptions.ts
-function validatePartialVideoOptions(options) {
-  if (!!options.width && !!options.height) {
-    return {
-      width: options.width,
-      height: options.height,
-      minWidth: options.minWidth,
-      minHeight: options.minHeight
-    };
-  } else {
-    return { width: 640, height: 480 };
-  }
-}
-
 // node_modules/axios/lib/helpers/bind.js
 function bind(fn3, thisArg) {
   return function wrap() {
@@ -6635,21 +6607,21 @@ var BackendService = class {
     });
     return url.data;
   }
-  async getSignedUrl(token, file, proctoringId) {
+  async getSignedUrl(token, file, proctoringId2) {
     const url = await this.makeRequestAxios({
       path: `/upload/signed-url`,
       method: "POST",
       jwt: token,
       body: {
-        objectName: `${proctoringId}/${file.name}`,
+        objectName: `${proctoringId2}/${file.name}`,
         contentType: file.type
       }
     });
     return url.data;
   }
-  async saveScreenAlerts(proctoringOptions, proctoringSession) {
+  async saveAlerts(proctoringOptions, proctoringSession) {
     await this.makeRequest({
-      path: "/proctoring/save-screen",
+      path: "/proctoring/save-alerts",
       method: "POST",
       jwt: proctoringOptions.token,
       body: {
@@ -6689,6 +6661,22 @@ var BackendService = class {
       jwt: this.token
     });
   }
+  async signTerm() {
+    return await this.makeRequest({
+      path: `/User/sign-terms`,
+      method: "PATCH",
+      body: {},
+      jwt: this.token
+    });
+  }
+  async signTermUrl() {
+    const result = await this.makeRequestAxios({
+      path: `/User/sign-terms-url`,
+      method: "GET",
+      jwt: this.token
+    });
+    return result.data;
+  }
   async getServerHour(token) {
     return await this.makeRequest({
       path: `/Proctoring/server-hour`,
@@ -6756,6 +6744,77 @@ var BackendService = class {
   }
 };
 
+// src/new-flow/backend/SpyCamBackendService.ts
+var SpyCamBackendService = class {
+  constructor() {
+    this.baseUrl = "https://localhost:5080";
+  }
+  async isAlive() {
+    const paramsConfig = await this.makeRequestAxios({
+      path: `/api/usb-device-manager/is-alive`,
+      method: "GET",
+      jwt: this.token
+    }).catch((error) => {
+      throw "N\xE3o foi poss\xEDvel realizar a requisi\xE7\xE3o, tente novamente mais tarde";
+    });
+    return paramsConfig.data;
+  }
+  async isPluggedIn() {
+    const paramsConfig = await this.makeRequestAxios({
+      path: `/api/usb-device-manager/is-plugged-in`,
+      method: "GET",
+      jwt: this.token
+    }).catch((error) => {
+      throw "N\xE3o foi poss\xEDvel realizar a requisi\xE7\xE3o, tente novamente mais tarde";
+    });
+    return paramsConfig.data;
+  }
+  async ConnectAndScan() {
+    const paramsConfig = await this.makeRequestAxios({
+      path: `/api/usb-device-manager/connect-and-scan`,
+      method: "GET",
+      jwt: this.token
+    }).catch((error) => {
+      throw "N\xE3o foi poss\xEDvel realizar a requisi\xE7\xE3o, tente novamente mais tarde";
+    });
+    return paramsConfig.data;
+  }
+  async Devices({
+    deviceType,
+    rssiThreshold,
+    packageRateThreshold
+  }) {
+    const queryParams = [];
+    deviceType && queryParams.push(`deviceType=${deviceType}`);
+    rssiThreshold && queryParams.push(`rssiThreshold=${rssiThreshold}`);
+    packageRateThreshold && queryParams.push(`packageRateThreshold=${packageRateThreshold}`);
+    const paramsConfig = await this.makeRequestAxios({
+      path: `/api/usb-device-manager/devices?${queryParams.join("&")}`,
+      method: "GET",
+      jwt: this.token
+    }).catch((error) => {
+      throw "N\xE3o foi poss\xEDvel realizar a requisi\xE7\xE3o, tente novamente mais tarde";
+    });
+    return paramsConfig.data;
+  }
+  async makeRequestAxios(data) {
+    const { path, method, body, jwt } = data;
+    const resp = await axios_default.request({
+      url: this.baseUrl + path,
+      method,
+      headers: {
+        Authorization: `Bearer ${jwt}`,
+        "Access-Control-Allow-Origin": "*"
+      },
+      data: body
+    });
+    if (resp.status >= 400) {
+      throw "N\xE3o foi poss\xEDvel realizar a requisi\xE7\xE3o, tente novamente mais tarde";
+    }
+    return resp;
+  }
+};
+
 // src/new-flow/proctoring/ProctoringSession.ts
 var ProctoringSession = class {
   constructor() {
@@ -6787,8 +6846,8 @@ var ProctoringSession = class {
     this.state = "Ended" /* Ended */;
     this.sessionDuration = Date.now() - this.startedAt.getTime();
   }
-  setProctoringId(proctoringId) {
-    this.id = proctoringId;
+  setProctoringId(proctoringId2) {
+    this.id = proctoringId2;
   }
   setEndConfirmed() {
     this.state = "EndConfirmed" /* EndConfirmed */;
@@ -6807,6 +6866,164 @@ var ProctoringSession = class {
   }
 };
 
+// src/modules/SpyCam.ts
+var SpyCam = class {
+  constructor(context, options) {
+    this.backendService = new SpyCamBackendService();
+    this.scanInterval = 5;
+    this.options = {};
+    this.options = options;
+    this.context = context;
+    this.backend = new BackendService({
+      type: (context == null ? void 0 : context.type) || "prod",
+      token: context.token
+    });
+    this.currentIsPlugged = true;
+  }
+  setProctoringId(proctoringId2) {
+    this.proctoringId = proctoringId2;
+  }
+  async isPluggedIn(sendEvent = false) {
+    var _a2, _b, _c2, _d;
+    try {
+      const isPlugged = await this.backendService.isPluggedIn();
+      if (this.proctoringId && sendEvent) {
+        if (isPlugged) {
+          if (!this.currentIsPlugged) {
+            (_b = (_a2 = this.options).onRealtimeAlertsCallback) == null ? void 0 : _b.call(_a2, {
+              type: "spycam",
+              message: "Spycam disconnected",
+              description: "Dispositivo de varredura conectado.",
+              status: "OK"
+            });
+          }
+        } else {
+          const session = new ProctoringSession();
+          session.setProctoringId(this.proctoringId);
+          session.addAlert({
+            begin: Date.now() - this.startTime.getTime(),
+            end: 0,
+            alert: 33 /* SpyDeviceDisconnected */,
+            type: 5 /* Environment */
+          });
+          await this.backend.saveAlerts(this.context, session);
+          (_d = (_c2 = this.options).onRealtimeAlertsCallback) == null ? void 0 : _d.call(_c2, {
+            type: "spycam",
+            message: "Spycam disconnected",
+            description: "Nenhum dispositivo de varredura conectado.",
+            status: "ALERT"
+          });
+        }
+      }
+      this.currentIsPlugged = isPlugged;
+      return this.currentIsPlugged;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async isAlive() {
+    try {
+      return await this.backendService.isAlive();
+    } catch (error) {
+      throw error;
+    }
+  }
+  connectAndScan() {
+    return this.backendService.ConnectAndScan();
+  }
+  async devices({
+    deviceType,
+    rssiThreshold,
+    packageRateThreshold
+  }) {
+    var _a2, _b;
+    const devices = await this.backendService.Devices(
+      {
+        deviceType,
+        rssiThreshold,
+        packageRateThreshold
+      }
+    );
+    if (devices.length > 0) {
+      (_b = (_a2 = this.options).onRealtimeAlertsCallback) == null ? void 0 : _b.call(_a2, {
+        type: "spycam",
+        message: "Spycam detected",
+        description: "Dispositivo espi\xE3o detectado.",
+        data: devices
+      });
+      if (this.proctoringId) {
+        const session = new ProctoringSession();
+        session.setProctoringId(this.proctoringId);
+        session.addAlert({
+          begin: Date.now() - this.startTime.getTime(),
+          end: 0,
+          alert: 32 /* PotentialCamera */,
+          type: 5 /* Environment */
+        });
+        await this.backend.saveAlerts(this.context, session);
+      }
+    }
+    return devices;
+  }
+  async startCheckSpyCam(spyScanInterval, {
+    deviceType,
+    rssiThreshold,
+    packageRateThreshold
+  }) {
+    this.scanInterval = spyScanInterval;
+    this.startTime = new Date(Date.now());
+    await this.isPluggedIn(true);
+    this.checkSpyCam = setInterval(async () => {
+      const isPlugged = await this.isPluggedIn(true);
+      if (isPlugged) {
+        await this.devices({
+          deviceType,
+          rssiThreshold,
+          packageRateThreshold
+        });
+      }
+    }, this.scanInterval * 6e4);
+  }
+  stopCheckSpyCam() {
+    clearInterval(this.checkSpyCam);
+  }
+};
+
+// src/proctoring/options/ProctoringOptions.ts
+var getDefaultProctoringOptions = {
+  cameraId: void 0,
+  microphoneId: void 0,
+  allowMultipleMonitors: false,
+  allowOnlyFirstMonitor: true,
+  captureScreen: true,
+  noiseLimit: 40,
+  proctoringType: "IMAGE",
+  insights: "",
+  onBufferSizeError: false,
+  useGeolocation: false,
+  useSpyScan: false
+};
+
+// src/proctoring/options/ProctoringVideoOptions.ts
+function validatePartialVideoOptions(options) {
+  if (!!options.width && !!options.height) {
+    return {
+      width: options.width,
+      height: options.height,
+      minWidth: options.minWidth,
+      minHeight: options.minHeight
+    };
+  } else {
+    return { width: 640, height: 480 };
+  }
+}
+var getDefaultProctoringVideoOptions = {
+  width: 1280,
+  height: 720,
+  minWidth: 640,
+  minHeight: 480
+};
+
 // src/plugins/insights.ts
 var backendService;
 var init = (backend) => {
@@ -6817,53 +7034,81 @@ var eventNames = {
   START: "start",
   FINISH: "finish",
   ERROR: "error",
-  UPLOAD_VIDEO: "upload_video",
+  UPLOAD: "upload",
+  UPLOAD_FILE: "upload_file",
+  DOWNLOAD_VIDEO: "download_video",
   BUFFER_SIZE: "buffer_size",
   ANOTHER_STREAM: "another_stream",
-  BROWSER_NOT_SUPPORTED: "browser_not_supported"
+  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 = {
-  registerStart: (proctoringId, success, description) => log(eventNames.START, { proctoringId, success, description }),
-  registerFinish: (proctoringId, success, description) => log(eventNames.FINISH, { proctoringId, success, description }),
-  registerError: (proctoringId, description) => log(eventNames.ERROR, { proctoringId, description }),
-  registerBrowserNotSupported: (proctoringId, description) => log(eventNames.BROWSER_NOT_SUPPORTED, { proctoringId, description }),
-  registerUpload: (proctoringId, success, description, serviceType, uploadTime) => log(eventNames.UPLOAD_VIDEO, { proctoringId, success, description, serviceType, uploadTime }),
-  registerUploadFile: (proctoringId, description, fileType) => log(eventNames.UPLOAD_VIDEO, { proctoringId, description, fileType }),
-  registerChangeDevice: (proctoringId, inOrOut, devicesChanged) => log(eventNames.UPLOAD_VIDEO, { proctoringId, inOrOut, devicesChanged }),
-  registerStopSharingScreen: (proctoringId, description) => log(eventNames.UPLOAD_VIDEO, { proctoringId, description }),
-  registerErrorRecorderRTC: (proctoringId, description) => log(eventNames.UPLOAD_VIDEO, { proctoringId, description }),
-  registerOnBufferSizeError: (proctoringId, description) => log(eventNames.BUFFER_SIZE, { proctoringId, description }),
-  registerAnotherStream: (proctoringId, description) => log(eventNames.ANOTHER_STREAM, { proctoringId, 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
-function recorder(stream, buffer, proctoringId, onBufferSizeError = false, onBufferSizeErrorCallback, audio = false) {
+var proctoringId;
+function setRecorderProctoringId(id) {
+  proctoringId = id;
+}
+function recorder(stream, buffer, onBufferSizeError = false, onBufferSizeErrorCallback, audio = false) {
   let resolvePromise;
   let stopped = false;
   let onBufferSizeInterval;
   let lastEvent;
-  let options = {
+  let bufferSize;
+  bufferSize = 0;
+  let recorderOptions = {
     mimeType: "video/webm",
     videoBitsPerSecond: 128e3,
     audioBitsPerSecond: 64 * 1e3
   };
+  if (MediaRecorder.isTypeSupported("video/webm;codecs=vp9")) {
+    recorderOptions.mimeType = "video/webm;codecs=vp9";
+  } else {
+    console.warn(
+      "vp9 codec not supported. Using default mimeType without vp9."
+    );
+  }
   if (audio) {
-    options = {
+    recorderOptions = {
       mimeType: "audio/webm",
       audioBitsPerSecond: 64 * 1e3
     };
   }
-  const mediaRecorder = new MediaRecorder(stream, options);
+  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();
-        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`);
       }
       lastEvent = e3;
     } else {
@@ -6878,6 +7123,7 @@ function recorder(stream, buffer, proctoringId, onBufferSizeError = false, onBuf
     return new Promise((resolve) => {
       resolvePromise = resolve;
       mediaRecorder.start();
+      bufferSize = 0;
       stopped = false;
       if (onBufferSizeError) {
         onBufferSizeInterval = setInterval(async () => {
@@ -6921,17 +7167,27 @@ function recorder(stream, buffer, proctoringId, onBufferSizeError = false, onBuf
       }
     });
   }
-  return { startRecording, stopRecording, pauseRecording, resumeRecording };
+  function getBufferSize() {
+    return bufferSize;
+  }
+  return {
+    startRecording,
+    stopRecording,
+    pauseRecording,
+    resumeRecording,
+    recorderOptions,
+    getBufferSize
+  };
 }
 
 // src/new-flow/upload/UploadService.ts
 var UploadService = class {
-  constructor(proctoringId, backend) {
+  constructor(proctoringId2, backend) {
     this.backend = backend;
     this.imageUrlPackage = [];
     this.imageBatchNum = 0;
     this.contImages = 0;
-    this.proctoringId = proctoringId;
+    this.proctoringId = proctoringId2;
   }
   async uploadImages(data, token, packSize) {
     const { file, onProgress } = data;
@@ -7073,6 +7329,7 @@ var STREAM_UNDER_MINIMUM_PERMITTED = "stream_under_minimum_permitted";
 var BROWSER_NOT_SUPPORTED = "browser_not_supported";
 var TOKEN_MISSING = "token_missing";
 var CREDENTIALS_MISSING = "credentials_missing";
+var SPY_SCAN_API_NOT_FOUND = "spy_scan_api_not_found";
 
 // src/modules/objectDetection.ts
 var ObjectDetection = class extends BaseDetection {
@@ -7230,7 +7487,7 @@ var CameraRecorder = class {
       cameraId: void 0,
       microphoneId: void 0,
       onBufferSizeError: false,
-      onBufferSizeErrorCallback: () => {
+      onBufferSizeErrorCallback: (cameraStream) => {
       },
       proctoringType: "IMAGE",
       onChangeDevicesCallback: (devices) => {
@@ -7247,6 +7504,7 @@ var CameraRecorder = class {
     this.blobsRTC = [];
     this.imageCount = 0;
     this.filesToUpload = [];
+    this.currentRetries = 0;
     this.noiseWait = 20;
     this.options = options;
     this.videoOptions = videoOptions;
@@ -7254,19 +7512,30 @@ var CameraRecorder = class {
     this.backendToken = backendToken;
     paramsConfig && (this.paramsConfig = paramsConfig);
   }
-  setProctoringId(proctoringId) {
-    this.proctoringId = proctoringId;
+  setProctoringId(proctoringId2) {
+    this.proctoringId = proctoringId2;
     this.proctoringId && this.backend && (this.upload = new UploadService(this.proctoringId, this.backend));
+    setRecorderProctoringId(proctoringId2);
   }
   async initializeDetectors() {
     var _a2, _b, _c2;
     buildVideoPreview();
     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) }, this.paramsConfig);
+      this.objectDetection = new ObjectDetection(
+        {
+          onRealtimeAlertsCallback: (response) => this.options.onRealtimeAlertsCallback(response)
+        },
+        this.paramsConfig
+      );
       await this.objectDetection.initializeDetector();
     }
     if ((_c2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _c2.detectFace) {
-      this.faceDetection = new FaceDetection({ onRealtimeAlertsCallback: (response) => this.options.onRealtimeAlertsCallback(response) }, this.paramsConfig);
+      this.faceDetection = new FaceDetection(
+        {
+          onRealtimeAlertsCallback: (response) => this.options.onRealtimeAlertsCallback(response)
+        },
+        this.paramsConfig
+      );
       await this.faceDetection.initializeDetector();
     }
   }
@@ -7279,9 +7548,25 @@ var CameraRecorder = class {
     this.canvas.width = this.videoOptions.width;
     this.canvas.height = this.videoOptions.height;
   }
-  async startRecording() {
+  async bufferError(e3) {
+    var _a2, _b;
+    console.log("buffer error Camera Recorder params " + this.paramsConfig.videoBehaviourParameters);
+    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
+      });
+      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;
-    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)) {
+    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();
     }
     const { cameraId, microphoneId, onBufferSizeErrorCallback } = this.options;
@@ -7295,26 +7580,50 @@ var CameraRecorder = class {
       }
     };
     try {
-      this.cameraStream = await navigator.mediaDevices.getUserMedia(constraints);
+      this.cameraStream = await navigator.mediaDevices.getUserMedia(
+        constraints
+      );
     } catch (error) {
       if (error.toString() == "NotReadableError: Could not start video source")
         throw "N\xE3o foi poss\xEDvel conectar a camera, ela pode estar sendo utilizada por outro programa";
       throw error;
     }
-    const { startRecording, stopRecording, pauseRecording, resumeRecording } = recorder(this.cameraStream, this.blobs, this.proctoringId, this.options.onBufferSizeError, onBufferSizeErrorCallback);
+    const {
+      startRecording,
+      stopRecording,
+      pauseRecording,
+      resumeRecording,
+      recorderOptions,
+      getBufferSize
+    } = recorder(
+      this.cameraStream,
+      this.blobs,
+      this.options.onBufferSizeError,
+      (e3) => this.bufferError(e3),
+      false
+    );
     this.recordingStart = startRecording;
     this.recordingStop = stopRecording;
     this.recordingPause = pauseRecording;
     this.recordingResume = resumeRecording;
+    this.recorderOptions = recorderOptions;
+    this.getBufferSize = getBufferSize;
     this.recordingStart();
     const tracks = this.cameraStream.getVideoTracks();
     const settings = tracks[0].getSettings();
     if (this.videoOptions.minWidth > settings.width || this.videoOptions.minHeight > settings.height) {
       throw STREAM_UNDER_MINIMUM_PERMITTED;
     } else if (this.videoOptions.width !== settings.width || this.videoOptions.height !== settings.height) {
-      trackers.registerAnotherStream(this.proctoringId, `Maybe have another stream active
-Video Options: ${this.videoOptions}
-Setting: ${settings}`);
+      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;
     }
     ((_d = this.paramsConfig.imageBehaviourParameters) == null ? void 0 : _d.useUploadImage) && this.options.proctoringType == "IMAGE" && this.photoShotsCycle();
@@ -7338,8 +7647,13 @@ Setting: ${settings}`);
       const packSize = this.paramsConfig.imageBehaviourParameters.uploadInterval;
       for (let i3 = 0; i3 < size; i3++) {
         if (i3 == size - 1 && this.filesToUpload[0]) {
-          const imageName = this.filesToUpload[0].name.replace(".jpg", "_realtime.jpg");
-          const file = new File([this.filesToUpload[0]], imageName, { type: "image/jpeg" });
+          const imageName = this.filesToUpload[0].name.replace(
+            ".jpg",
+            "_realtime.jpg"
+          );
+          const file = new File([this.filesToUpload[0]], imageName, {
+            type: "image/jpeg"
+          });
           this.filesToUpload[0] = file;
         }
         this.filesToUpload[0] && await this.upload.uploadImages(
@@ -7365,9 +7679,19 @@ Setting: ${settings}`);
     let imageFile;
     this.configImageCapture();
     this.imageInterval = setInterval(async () => {
-      this.canvas.getContext("2d").drawImage(this.video, 0, 0, this.videoOptions.width, this.videoOptions.height);
+      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");
+      imageFile = await this.getFile(
+        image_data_url,
+        `${this.proctoringId}_${this.imageCount + 1}.jpg`,
+        "image/jpeg"
+      );
       if (imageFile && this.upload && this.backendToken) {
         this.upload.upload(
           {
@@ -7459,16 +7783,24 @@ Setting: ${settings}`);
     window.URL.revokeObjectURL(url);
   }
   async saveOnSession(session) {
-    var _a2;
+    var _a2, _b;
+    if (this.blobs != null)
+      trackers.registerSaveOnSession(
+        this.proctoringId,
+        `Blobs Length: ${this.blobs.length} Buffer Size: ${this.getBufferSize()} `
+      );
     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)) {
       session.addRecording({
         device: `Audio
 	Sample Rate: ${settingsAudio.sampleRate}
-	Sample Size: ${settingsAudio.sampleSize}`,
+	Sample Size: ${settingsAudio.sampleSize}
+
+	Video:
+	${JSON.stringify(this.recorderOptions)}`,
         file: new File(this.blobs, `EP_${session.id}_camera_0.webm`, {
-          type: "video/webm"
+          type: ((_b = this.recorderOptions) == null ? void 0 : _b.mimeType) || "video/webm"
         }),
         origin: "Camera" /* Camera */
       });
@@ -7786,10 +8118,29 @@ var DeviceCheckerUI = class {
     checkmark_AmbientVerify.appendChild(checkmark_kick_AmbientVerify);
     alertDivAmbientVerify.appendChild(checkmark_AmbientVerify);
     alertDivAmbientVerify.appendChild(ambientVerifyAlert);
+    const alertDivSpyCam = document.createElement("div");
+    alertDivSpyCam.setAttribute("class", "alert-div");
+    alertDivSpyCam.setAttribute("id", "alertDivSpyCam");
+    alertDivSpyCam.style.display = "none";
+    const SpyCamAlert = document.createElement("error");
+    SpyCamAlert.setAttribute("id", "SpyCamAlert");
+    SpyCamAlert.innerText = "Verifica\xE7\xE3o de Spy Cam";
+    SpyCamAlert.style.marginLeft = "10px";
+    const checkmark_SpyCam = document.createElement("span");
+    const checkmark_stem_SpyCam = document.createElement("div");
+    const checkmark_kick_SpyCam = document.createElement("div");
+    checkmark_SpyCam.setAttribute("id", "checkmark_SpyCam");
+    checkmark_stem_SpyCam.setAttribute("id", "checkmark_stem_SpyCam");
+    checkmark_kick_SpyCam.setAttribute("id", "checkmark_kick_SpyCam");
+    checkmark_SpyCam.appendChild(checkmark_stem_SpyCam);
+    checkmark_SpyCam.appendChild(checkmark_kick_SpyCam);
+    alertDivSpyCam.appendChild(checkmark_SpyCam);
+    alertDivSpyCam.appendChild(SpyCamAlert);
     center.style.transform = "rotateY(180deg)";
     center.appendChild(alertDivResolution);
     center.appendChild(alertDivFacePosition);
     center.appendChild(alertDivAmbientVerify);
+    center.appendChild(alertDivSpyCam);
     divCamera.appendChild(center);
     videoDiv.appendChild(video);
     divCamera.appendChild(videoDiv);
@@ -7968,10 +8319,13 @@ var DeviceCheckerUI = class {
       fontWeight: "bold",
       borderRadius: "10px",
       paddingTop: "5px",
-      paddingBottom: "5px",
-      disabled: true
+      paddingBottom: "5px"
     };
     this.applyStyles(button, buttonStyles);
+    if (this.options.useSpyScan) {
+      button.style.cursor = "not-allowed";
+      button.setAttribute("disabled", "true");
+    }
     divBtn.appendChild(buttonCancel);
     divBtn.appendChild(divider);
     divBtn.appendChild(button);
@@ -8031,6 +8385,8 @@ var DeviceCheckerUI = class {
         });
       });
       confirmBtn == null ? void 0 : confirmBtn.addEventListener("click", () => {
+        if (confirmBtn.disabled)
+          return;
         closeCheckDevices();
         this.closeModal();
         resolve({
@@ -8081,6 +8437,68 @@ var DeviceCheckerUI = class {
       }
     }
   }
+  waitingSpyDevices(waiting) {
+    const SpyCamAlert = document.getElementById("SpyCamAlert");
+    const alertDivSpyCam = document.getElementById(
+      "alertDivSpyCam"
+    );
+    alertDivSpyCam && (alertDivSpyCam.style.display = "flex");
+    if (waiting) {
+      SpyCamAlert && (SpyCamAlert.style.color = "#c7c7c7");
+      SpyCamAlert && (SpyCamAlert.innerText = "Verificando Spy Cam...");
+      const confirmBtn = document.getElementById("confirmBtn");
+      if (confirmBtn)
+        confirmBtn.setAttribute("disabled", "true");
+      confirmBtn && (confirmBtn.style.cursor = "not-allowed");
+    } else {
+      SpyCamAlert && (SpyCamAlert.style.color = "#16A34A");
+      SpyCamAlert && (SpyCamAlert.innerText = "Verifica\xE7\xE3o de Spy Cam");
+      const confirmBtn = document.getElementById("confirmBtn");
+      if (confirmBtn)
+        confirmBtn.setAttribute("disabled", "false");
+      confirmBtn && (confirmBtn.style.cursor = "pointer");
+    }
+  }
+  isSpyDevicesUI(allowedDevices) {
+    const SpyCamAlert = document.getElementById("SpyCamAlert");
+    const confirmBtn = document.getElementById("confirmBtn");
+    const alertDivSpyCam = document.getElementById(
+      "alertDivSpyCam"
+    );
+    alertDivSpyCam && (alertDivSpyCam.style.display = "flex");
+    const checkmark_SpyCam = document.getElementById(
+      "checkmark_SpyCam"
+    );
+    const checkmark_stem_SpyCam = document.getElementById(
+      "checkmark_stem_SpyCam"
+    );
+    const checkmark_kick_SpyCam = document.getElementById(
+      "checkmark_kick_SpyCam"
+    );
+    if (allowedDevices) {
+      SpyCamAlert && (SpyCamAlert.style.color = "#16A34A");
+      if (checkmark_SpyCam) {
+        checkmark_SpyCam.setAttribute("class", "checkmark");
+        checkmark_stem_SpyCam.setAttribute("class", "checkmark_stem");
+        checkmark_kick_SpyCam.setAttribute("class", "checkmark_kick");
+      }
+    } else {
+      if (checkmark_SpyCam) {
+        SpyCamAlert && (SpyCamAlert.style.color = "#FF0000");
+        checkmark_SpyCam.setAttribute("class", "checkmark_error");
+        checkmark_stem_SpyCam.setAttribute(
+          "class",
+          "checkmark_stem_error"
+        );
+        checkmark_kick_SpyCam.setAttribute(
+          "class",
+          "checkmark_kick_error"
+        );
+      }
+    }
+    this.options.useSpyScan && (confirmBtn == null ? void 0 : confirmBtn.removeAttribute("disabled"));
+    confirmBtn && (confirmBtn.style.cursor = "pointer");
+  }
   isUnderResolutionUI(allowedResolution) {
     const error = document.getElementById("resolutionAlert");
     const alertDivResolution = document.getElementById("alertDivResolution");
@@ -8217,7 +8635,12 @@ Para iniciar um exame utilize uma outra c\xE2mera.`);
 // src/new-flow/checkers/DeviceCheckerService.ts
 var _DeviceCheckerService = class {
   constructor(context) {
-    this.videoOptions = { width: 1080, height: 720, minWidth: 0, minHeight: 0 };
+    this.videoOptions = {
+      width: 1080,
+      height: 720,
+      minWidth: 0,
+      minHeight: 0
+    };
     this.volumeMedia = 0;
     this.volumeSum = 0;
     this.volumeCounter = 0;
@@ -8226,8 +8649,16 @@ var _DeviceCheckerService = class {
     this.allowedAmbient = true;
     this.allowedPositionFace = true;
     this.allowedMicrophone = false;
+    this.allowedSpyScan = null;
     this.noiseLimit = 0;
-    this.faceDetection = new FaceDetection({ onRealtimeAlertsCallback: (response) => this.realtimeAlerts(response) }, { videoBehaviourParameters: { detectFace: true } }, "cameraStream", "liveCheckDevices");
+    this.faceDetection = new FaceDetection(
+      {
+        onRealtimeAlertsCallback: (response) => this.realtimeAlerts(response)
+      },
+      { videoBehaviourParameters: { detectFace: true } },
+      "cameraStream",
+      "liveCheckDevices"
+    );
     this.context = context;
     this.backend = new BackendService({
       type: (context == null ? void 0 : context.type) || "prod",
@@ -8238,41 +8669,55 @@ var _DeviceCheckerService = class {
     if (_DeviceCheckerService.isModalOpen) {
       return Promise.reject("Modal j\xE1 est\xE1 aberto");
     }
+    this.options = {
+      ...getDefaultProctoringOptions,
+      ...options,
+      captureScreen: false,
+      allowMultipleMonitors: true,
+      allowOnlyFirstMonitor: false
+    };
     _DeviceCheckerService.isModalOpen = true;
     try {
       await this.faceDetection.initializeDetector();
-      const { cameraStream } = await this.startCheckDevices(options, _videoOptions);
+      const { cameraStream } = await this.startCheckDevices(
+        options,
+        _videoOptions
+      );
+      this.checkSpyScan();
       const returnData = { cameraStream: this.cameraRecorder.cameraStream };
       this.onUpdateCb = (e3) => onUpdate(e3);
-      const resultPromise = new Promise((resolve, reject) => {
-        onModalConfirm(() => {
-          this.closeCheckDevices();
-          resolve({
-            result: true,
-            cameraId: options.cameraId || "default",
-            microphoneId: options.microphoneId || "default",
-            volumeRange: this.volumeMedia,
-            allowedResolution: this.allowedResolution,
-            allowedPositionFace: this.allowedPositionFace,
-            allowedAmbient: this.allowedAmbient,
-            allowedMicrophone: this.allowedMicrophone,
-            faceDetectionAlerts: this.faceDetectionAlerts
+      const resultPromise = new Promise(
+        (resolve, reject) => {
+          onModalConfirm(() => {
+            this.closeCheckDevices();
+            resolve({
+              result: true,
+              cameraId: options.cameraId || "default",
+              microphoneId: options.microphoneId || "default",
+              volumeRange: this.volumeMedia,
+              allowedResolution: this.allowedResolution,
+              allowedPositionFace: this.allowedPositionFace,
+              allowedAmbient: this.allowedAmbient,
+              allowedMicrophone: this.allowedMicrophone,
+              allowedSpyScan: this.allowedSpyScan,
+              faceDetectionAlerts: this.faceDetectionAlerts
+            });
+            _DeviceCheckerService.isModalOpen = false;
           });
-          _DeviceCheckerService.isModalOpen = false;
-        });
-        onModalCancel(() => {
-          this.closeCheckDevices();
-          resolve({
-            result: false
+          onModalCancel(() => {
+            this.closeCheckDevices();
+            resolve({
+              result: false
+            });
+            _DeviceCheckerService.isModalOpen = false;
           });
-          _DeviceCheckerService.isModalOpen = false;
-        });
-      });
+        }
+      );
       return { ...returnData, result: resultPromise };
     } catch (error) {
       this.closeCheckDevices();
       _DeviceCheckerService.isModalOpen = false;
-      return Promise.reject(error);
+      throw error;
     }
   }
   onUpdateCallback() {
@@ -8282,11 +8727,12 @@ var _DeviceCheckerService = class {
         allowedPositionFace: this.allowedPositionFace,
         allowedAmbient: this.allowedAmbient,
         allowedMicrophone: this.allowedMicrophone,
+        allowedSpyScan: this.allowedSpyScan,
         faceDetectionAlerts: this.faceDetectionAlerts
       });
     }
   }
-  async checkDevices(options = getDefaultProctoringOptions, _videoOptions) {
+  async checkDevices(options = getDefaultProctoringOptions, _videoOptions = getDefaultProctoringVideoOptions) {
     var _a2;
     if (_DeviceCheckerService.isModalOpen) {
       return Promise.reject();
@@ -8302,11 +8748,14 @@ var _DeviceCheckerService = class {
         allowOnlyFirstMonitor: false
       };
       this.videoOptions = { ...this.videoOptions, ..._videoOptions };
-      const paramsConfig = await this.backend.getParamsConfig(this.context);
+      const paramsConfig = await this.backend.getParamsConfig(
+        this.context
+      );
       this.noiseLimit = ((_a2 = paramsConfig.audioBehaviourParameters) == null ? void 0 : _a2.noiseLimit) || 40;
       await this.faceDetection.initializeDetector();
       this.DeviceCheckerUI.checkDevicesInterface();
       this.startCheckDevices(options, _videoOptions);
+      await this.checkSpyScan();
       const { cameraId, microphoneId, result } = await this.DeviceCheckerUI.modalActions(() => this.closeCheckDevices());
       return new Promise((resolve) => {
         resolve({
@@ -8318,6 +8767,7 @@ var _DeviceCheckerService = class {
           allowedPositionFace: this.allowedPositionFace,
           allowedAmbient: this.allowedAmbient,
           allowedMicrophone: this.allowedMicrophone,
+          allowedSpyScan: this.allowedSpyScan,
           faceDetectionAlerts: this.faceDetectionAlerts
         });
       });
@@ -8384,10 +8834,7 @@ var _DeviceCheckerService = class {
       this.DeviceCheckerUI && this.DeviceCheckerUI.audioDeviceInterfaceUIErrorExec();
     });
   }
-  async changeSelectedDevice({
-    cameraId,
-    microphoneId
-  }) {
+  async changeSelectedDevice({ cameraId, microphoneId }) {
     var _a2;
     this.cameraRecorder.stopRecording && await this.cameraRecorder.stopRecording();
     (_a2 = this.volumeMeter) == null ? void 0 : _a2.stop();
@@ -8413,7 +8860,10 @@ var _DeviceCheckerService = class {
     };
   }
   async startCheckDevices(options = getDefaultProctoringOptions, _videoOptions) {
-    this.DeviceCheckerUI && this.DeviceCheckerUI.setSelectOption(options, (e3) => this.changeSelectedDevice(e3));
+    this.DeviceCheckerUI && this.DeviceCheckerUI.setSelectOption(
+      options,
+      (e3) => this.changeSelectedDevice(e3)
+    );
     this.videoOptions = validatePartialVideoOptions(_videoOptions);
     await checkPermissions();
     this.cameraRecorder = new CameraRecorder(
@@ -8434,7 +8884,7 @@ var _DeviceCheckerService = class {
     this.audioDeviceInterface(this.cameraRecorder.cameraStream);
     if (this.DeviceCheckerUI) {
       const button = document.querySelector("#confirmBtn");
-      button.disabled = false;
+      !this.options.useSpyScan && (button.disabled = false);
     }
     return {
       cameraStream: this.cameraRecorder.cameraStream
@@ -8450,6 +8900,39 @@ var _DeviceCheckerService = class {
     this.DeviceCheckerUI = void 0;
     this.onUpdateCb = void 0;
   }
+  async checkSpyScan() {
+    this.spycam = new SpyCam(this.context, {});
+    this.allowedSpyScan = null;
+    if (this.options.useSpyScan) {
+      this.DeviceCheckerUI && this.DeviceCheckerUI.waitingSpyDevices(true);
+      try {
+        const isPlugged = await this.spycam.isPluggedIn();
+        if (isPlugged) {
+          await this.spycam.devices({
+            deviceType: 3 /* POTENCIAL_CAMERA */
+          }).then((devices) => {
+            if ((devices == null ? void 0 : devices.length) > 0) {
+              this.allowedSpyScan = false;
+            } else {
+              this.allowedSpyScan = true;
+            }
+          }).finally(() => {
+            this.DeviceCheckerUI && this.DeviceCheckerUI.waitingSpyDevices(false);
+            this.DeviceCheckerUI && this.allowedSpyScan != null && this.DeviceCheckerUI.isSpyDevicesUI(this.allowedSpyScan);
+          });
+        } else {
+          this.allowedSpyScan = false;
+          this.DeviceCheckerUI && this.DeviceCheckerUI.waitingSpyDevices(false);
+          this.DeviceCheckerUI && this.DeviceCheckerUI.isSpyDevicesUI(this.allowedSpyScan);
+        }
+      } catch (error) {
+        this.allowedSpyScan = false;
+        this.DeviceCheckerUI && this.DeviceCheckerUI.waitingSpyDevices(false);
+        this.DeviceCheckerUI && this.DeviceCheckerUI.isSpyDevicesUI(this.allowedSpyScan);
+        console.log(error);
+      }
+    }
+  }
 };
 var DeviceCheckerService = _DeviceCheckerService;
 DeviceCheckerService.isModalOpen = false;
@@ -8811,9 +9294,9 @@ var Extension = class {
 
 // src/modules/onChangeDevices.ts
 var onChangeDevices = class {
-  constructor(repositoryDevices, proctoringId) {
+  constructor(repositoryDevices, proctoringId2) {
     this.repositoryDevices = repositoryDevices;
-    this.proctoringId = proctoringId;
+    this.proctoringId = proctoringId2;
   }
   startRecording(options) {
     navigator.mediaDevices.ondevicechange = () => {
@@ -8844,7 +9327,7 @@ var onChangeDevices = class {
     };
     await this.repositoryDevices.save({ ...devices, id: "devices", status: devices.cameras.length > (copy == null ? void 0 : copy.cameras.length) || devices.microphones.length > (copy == null ? void 0 : copy.microphones.length) ? "in" : "out" });
     if (options.status && (devicesChanged.cameras.length != 0 || devicesChanged.microphones.length != 0)) {
-      trackers.registerChangeDevice(this.proctoringId, devicesChanged.status, devicesChanged);
+      trackers.registerChangeDevice(this.proctoringId, devicesChanged.status, JSON.stringify(devicesChanged, null, 2));
       options.status(devicesChanged);
     }
   }
@@ -8853,18 +9336,26 @@ var onChangeDevices = class {
 // src/new-flow/download/downloadService.ts
 var import_file_saver = __toESM(require_FileSaver_min());
 var DownloadService = class {
-  constructor(proctoringId) {
+  constructor(proctoringId2) {
     this.loadingBoolean = true;
-    this.proctoringId = proctoringId;
+    this.proctoringId = proctoringId2;
   }
   async upload(data, token) {
+    const { file, onProgress } = data;
     try {
-      const { file, onProgress } = data;
+      trackers.registerDownloadFile(this.proctoringId, `File to download
+	File name: ${file.name}
+	File type: ${file.type}
+	File size: ${file.size}}`);
       (0, import_file_saver.saveAs)(file);
       this.loadingBoolean = false;
       clearInterval(this.loadingInterval);
       onProgress && onProgress(Math.round(100));
     } catch (err) {
+      file && this.proctoringId && trackers.registerError(this.proctoringId, `Failed on machine download
+	File name: ${file.name}
+	File type: ${file.type}
+	File size: ${file.size}`);
       throw new Error(`Error on machine download`);
     }
   }
@@ -8879,7 +9370,7 @@ var ProctoringRecorder = class {
   async startAll() {
     this.session.start();
     for (const rec of this.recorders) {
-      await rec.startRecording();
+      await rec.startRecording({ retry: false });
     }
   }
   async pauseAll() {
@@ -8909,9 +9400,9 @@ var ProctoringRecorder = class {
 
 // src/new-flow/proctoring/ProctoringUploader.ts
 var ProctoringUploader = class {
-  constructor(session, proctoringId, uploadServices) {
+  constructor(session, proctoringId2, uploadServices) {
     this.session = session;
-    this.proctoringId = proctoringId;
+    this.proctoringId = proctoringId2;
     this.uploadServices = uploadServices;
   }
   async upload(token, progress) {
@@ -9033,7 +9524,8 @@ var AlertRecorder = class {
       this.alerts.push({
         begin: Date.now() - this.startTime.getTime(),
         end: 0,
-        alert: 25 /* LostFocus */
+        alert: 25 /* LostFocus */,
+        type: 3 /* Screen */
       });
     }
   }
@@ -9065,7 +9557,7 @@ var AudioRecorder = class {
       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, void 0, true);
+    const { startRecording, stopRecording, pauseRecording, resumeRecording } = recorder(this.audioStream, this.blobs, void 0, void 0, true);
     this.recordingStart = startRecording;
     this.recordingStop = stopRecording;
     this.recordingPause = pauseRecording;
@@ -11380,8 +11872,8 @@ var NoiseRecorder = class {
     this.backend = backend;
     this.backendToken = backendToken;
   }
-  setProctoringId(proctoringId) {
-    this.proctoringId = proctoringId;
+  setProctoringId(proctoringId2) {
+    this.proctoringId = proctoringId2;
     this.proctoringId && this.backend && (this.upload = new UploadService(this.proctoringId, this.backend));
   }
   async startRecording() {
@@ -11592,8 +12084,9 @@ var ScreenRecorder = class {
     this.blobsFinal = [];
     this.options = options;
   }
-  setProctoringId(proctoringId) {
-    this.proctoringId = proctoringId;
+  setProctoringId(proctoringId2) {
+    this.proctoringId = proctoringId2;
+    setRecorderProctoringId(proctoringId2);
   }
   async startRecording() {
     this.startTime = new Date(Date.now());
@@ -11641,7 +12134,7 @@ var ScreenRecorder = class {
       });
       throw NOT_SHARED_SCREEN;
     }
-    const { startRecording, stopRecording } = recorder(this.screenStream, this.blobs, this.proctoringId, this.options.onBufferSizeError, onBufferSizeErrorCallback);
+    const { startRecording, stopRecording } = recorder(this.screenStream, this.blobs, this.options.onBufferSizeError, onBufferSizeErrorCallback);
     this.recordingStart = startRecording;
     this.recordingStop = stopRecording;
     this.recordingStart();
@@ -11898,7 +12391,7 @@ var Proctoring = class {
     this.onRealtimeAlertsCallback = (response) => {
       return;
     };
-    this.onBufferSizeErrorCallback = () => {
+    this.onBufferSizeErrorCallback = (cameraStream) => {
       return;
     };
     var _a2;
@@ -11940,7 +12433,7 @@ var Proctoring = class {
     this.onRealtimeAlertsCallback = (response) => options.data && options.data(response);
   }
   setOnBufferSizeErrorCallback(cb) {
-    this.onBufferSizeErrorCallback = () => cb();
+    this.onBufferSizeErrorCallback = (cameraStream) => cb(cameraStream);
   }
   createRecorders(options = getDefaultProctoringOptions) {
     var _a2, _b;
@@ -11950,7 +12443,7 @@ var Proctoring = class {
         cameraId: this.sessionOptions.cameraId,
         microphoneId: this.sessionOptions.microphoneId,
         onBufferSizeError: this.sessionOptions.onBufferSizeError,
-        onBufferSizeErrorCallback: () => this.onBufferSizeErrorCallback(),
+        onBufferSizeErrorCallback: (cameraStream) => this.onBufferSizeErrorCallback(cameraStream),
         proctoringType: this.sessionOptions.proctoringType,
         onChangeDevicesCallback: (devices) => this.onChangeDevicesCallback(devices),
         onRealtimeAlertsCallback: (response) => this.onRealtimeAlertsCallback(response)
@@ -12004,6 +12497,7 @@ var Proctoring = class {
     this.context.token = await this.auth.login();
   }
   async start(options = getDefaultProctoringOptions, _videoOptions = {}) {
+    var _a2;
     try {
       if (this.context.token === void 0) {
         throw TOKEN_MISSING;
@@ -12018,6 +12512,13 @@ var Proctoring = class {
       await this.initConfig(options.useGeolocation);
       await this.verifyBrowser();
       this.sessionOptions.captureScreen && await this.verifyMultipleMonitors(this.sessionOptions);
+      try {
+        if (options == null ? void 0 : options.useSpyScan) {
+          await this.spyCam.isAlive();
+        }
+      } catch (error) {
+        throw SPY_SCAN_API_NOT_FOUND;
+      }
       if (this.state != "Stop" /* Stop */) {
         throw PROCTORING_ALREADY_STARTED;
       }
@@ -12042,6 +12543,12 @@ var Proctoring = class {
       this.allRecorders.cameraRecorder.setProctoringId(this.proctoringId);
       this.allRecorders.noiseRecorder.setProctoringId(this.proctoringId);
       this.proctoringSession.setProctoringId(this.proctoringId);
+      if (options == null ? void 0 : options.useSpyScan) {
+        this.spyCam.setProctoringId(this.proctoringId);
+        this.spyCam.startCheckSpyCam((_a2 = this.paramsConfig.spyScanInterval) != null ? _a2 : 5, {
+          deviceType: 3 /* POTENCIAL_CAMERA */
+        });
+      }
       await this.repository.save(this.proctoringSession);
       const _navigator = {};
       for (const i3 in navigator)
@@ -12075,6 +12582,7 @@ Error: ${error}`
   async cancel() {
     if (this.state === "Recording" /* Recording */ || this.state === "Starting" /* Starting */) {
       await this.recorder.stopAll();
+      this.spyCam && await this.spyCam.stopCheckSpyCam();
     }
     this.state = "Stop" /* Stop */;
   }
@@ -12085,6 +12593,7 @@ Error: ${error}`
         throw PROCTORING_NOT_STARTED;
       }
       await this.recorder.stopAll();
+      this.spyCam && this.spyCam.stopCheckSpyCam();
       await this.recorder.saveAllOnSession();
       await this.repository.save(this.proctoringSession);
       let uploader;
@@ -12162,13 +12671,15 @@ Upload Services: ${uploaderServices}`,
           this.serviceType
         );
       }
-      await this.backend.saveScreenAlerts(this.context, this.proctoringSession).catch((err) => {
-        trackers.registerFinish(
-          this.proctoringSession.id,
-          false,
-          "save-screen error: " + err
-        );
-      });
+      if (this.proctoringSession.alerts.length > 0) {
+        await this.backend.saveAlerts(this.context, this.proctoringSession).catch((err) => {
+          trackers.registerFinish(
+            this.proctoringSession.id,
+            false,
+            "save-screen error: " + err
+          );
+        });
+      }
       await this.backend.finishAndSendUrls(this.context, this.proctoringSession).then(() => {
         trackers.registerFinish(this.proctoringSession.id, true, "");
       }).catch((error) => {
@@ -12215,6 +12726,7 @@ Error: ` + error
     }
   }
   async initConfig(useGeolocation) {
+    var _a2;
     try {
       const paramsConfig = await this.backend.getParamsConfig(
         this.context
@@ -12241,6 +12753,11 @@ Error: ` + error
         });
       }
       init(this.backend);
+      if ((_a2 = this.sessionOptions) == null ? void 0 : _a2.useSpyScan) {
+        this.spyCam = new SpyCam(this.context, {
+          onRealtimeAlertsCallback: (response) => this.onRealtimeAlertsCallback(response)
+        });
+      }
     } catch (err) {
       this.proctoringId && trackers.registerError(this.proctoringId, "Erro no initConfig!");
       await this.cancel();
@@ -12286,6 +12803,200 @@ Error: ` + error
   }
 };
 
+// src/proctoring/SignTerm.ts
+var _SignTerm = class {
+  constructor(context) {
+    this.backend = new BackendService({
+      type: (context == null ? void 0 : context.type) || "prod",
+      token: context.token
+    });
+  }
+  async signInTerms() {
+    if (_SignTerm.isModalOpen) {
+      return Promise.reject();
+    }
+    _SignTerm.isModalOpen = true;
+    try {
+      const response = await this.openModal();
+      return new Promise((resolve) => {
+        resolve(response);
+      });
+    } catch (error) {
+      this.closeModal();
+      return Promise.reject(error);
+    }
+  }
+  openModal() {
+    return new Promise((resolve, reject) => {
+      const fullBg = document.createElement("div");
+      fullBg.setAttribute("id", "signTermModal");
+      const fullBgStyles = {
+        backgroundColor: "rgba(0,0,0,0.4)",
+        zIndex: "1000",
+        position: "fixed",
+        top: "0",
+        left: "0",
+        height: "100vh",
+        width: "100%",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center"
+      };
+      this.applyStyles(fullBg, fullBgStyles);
+      const modal = document.createElement("div");
+      const modalStyles = {
+        backgroundColor: "#fff",
+        zIndex: "1001",
+        width: "850px",
+        maxHeight: "95%",
+        borderRadius: "10px",
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center"
+      };
+      this.applyStyles(modal, modalStyles);
+      const h3 = document.createElement("h3");
+      h3.innerText = "Termo de consentimento para coleta e uso de dados";
+      const h3Styles = {
+        color: "rgba(0, 0, 0, .7)",
+        fontWeight: "bold",
+        fontSize: "20px",
+        marginBottom: "15px",
+        padding: "20px 0px",
+        borderBottom: "2px solid rgba(0, 0, 0, .1)",
+        width: "100%",
+        textAlign: "center"
+      };
+      this.applyStyles(h3, h3Styles);
+      modal.appendChild(h3);
+      const docEmbed = document.createElement("iframe");
+      const defaultUrl = "https://docs.google.com/document/u/3/d/e/2PACX-1vRMgrLhDLyDP8BHmotfPDpwAFaDHqK-mA4eBJ0Cy1mDdvHcWLsx47H4otII_4qi4rhtSf6B0OO97e9c/pub";
+      this.backend.signTermUrl().then((response) => {
+        if (!response)
+          throw new Error("N\xE3o foi poss\xEDvel obter o termo de consentimento");
+        docEmbed.setAttribute("src", response);
+      }).catch(() => {
+        docEmbed.setAttribute("src", defaultUrl);
+      });
+      const docEmbedStyles = {
+        width: "100%",
+        height: "500px",
+        border: "1px solid rgba(0, 0, 0, .1)",
+        margin: "20px",
+        borderRadius: "5px"
+      };
+      this.applyStyles(docEmbed, docEmbedStyles);
+      modal.appendChild(docEmbed);
+      const checkboxContainer = document.createElement("div");
+      const checkbox = document.createElement("input");
+      checkbox.setAttribute("type", "checkbox");
+      checkbox.setAttribute("id", "termsCheckbox");
+      const checkboxLabel = document.createElement("label");
+      checkboxLabel.setAttribute("for", "termsCheckbox");
+      checkboxLabel.innerText = "Li e aceito os termos e condi\xE7\xF5es";
+      const checkboxContainerStyles = {
+        display: "flex",
+        alignItems: "center",
+        gap: "10px",
+        margin: "20px",
+        width: "100%",
+        paddingLeft: "20px"
+      };
+      this.applyStyles(checkboxContainer, checkboxContainerStyles);
+      checkboxContainer.appendChild(checkbox);
+      checkboxContainer.appendChild(checkboxLabel);
+      modal.appendChild(checkboxContainer);
+      const divBtn = document.createElement("div");
+      const divBtnStyles = {
+        width: "100%",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        borderTop: "2px solid rgba(0, 0, 0, .1)"
+      };
+      this.applyStyles(divBtn, divBtnStyles);
+      const buttonCancel = document.createElement("button");
+      buttonCancel.innerText = "Cancelar";
+      const buttonCancelStyles = {
+        width: "100%",
+        height: "70px",
+        backgroundColor: "#FFF",
+        border: "none",
+        color: "rgba(0, 0, 0, .7)",
+        fontWeight: "bold",
+        borderRadius: "10px",
+        paddingTop: "5px",
+        paddingBottom: "5px"
+      };
+      this.applyStyles(buttonCancel, buttonCancelStyles);
+      buttonCancel.addEventListener("click", () => {
+        this.closeModal();
+        resolve(false);
+      });
+      const divider = document.createElement("span");
+      const dividerStyles = {
+        width: "3px",
+        height: "70px",
+        margin: "0px 2px",
+        background: "rgba(0, 0, 0, .1)"
+      };
+      this.applyStyles(divider, dividerStyles);
+      const button = document.createElement("button");
+      button.innerText = "Continuar";
+      button.setAttribute("id", "confirmBtn");
+      const buttonStyles = {
+        width: "100%",
+        height: "70px",
+        backgroundColor: "#FFF",
+        border: "none",
+        color: "rgba(0, 0, 0, .7)",
+        fontWeight: "bold",
+        borderRadius: "10px",
+        paddingTop: "5px",
+        paddingBottom: "5px",
+        disabled: true,
+        cursor: "not-allowed"
+      };
+      this.applyStyles(button, buttonStyles);
+      button.disabled = true;
+      button.addEventListener("click", () => {
+        this.closeModal();
+        this.backend.signTerm().then(() => {
+          resolve(true);
+        });
+      });
+      checkbox.addEventListener("change", (e3) => {
+        button.disabled = !e3.target.checked;
+        if (e3.target.checked) {
+          button.style.color = "#007bff";
+          button.style.cursor = "pointer";
+        } else {
+          button.style.color = "rgba(0, 0, 0, .7)";
+          button.style.cursor = "not-allowed";
+        }
+      });
+      divBtn.appendChild(buttonCancel);
+      divBtn.appendChild(divider);
+      divBtn.appendChild(button);
+      modal.appendChild(divBtn);
+      fullBg.appendChild(modal);
+      document.body.appendChild(fullBg);
+    });
+  }
+  async closeModal() {
+    _SignTerm.isModalOpen = false;
+    const signTermModal = document.querySelector("#signTermModal");
+    signTermModal == null ? void 0 : signTermModal.remove();
+  }
+  applyStyles(element, styles) {
+    for (const [property, value] of Object.entries(styles)) {
+      element.style[property] = value;
+    }
+  }
+};
+var SignTerm = _SignTerm;
+SignTerm.isModalOpen = false;
+
 // src/proctoring/useProctoring.ts
 function useProctoring(proctoringOptions, enviromentConfig = "prod") {
   if (!proctoringOptions.showConsole) {
@@ -12296,22 +13007,17 @@ function useProctoring(proctoringOptions, enviromentConfig = "prod") {
     console.error = () => {
     };
   }
-  const proctoring = new Proctoring({
-    type: enviromentConfig,
-    clientId: proctoringOptions.clientId,
-    examId: proctoringOptions.examId,
-    token: proctoringOptions.token,
-    credentials: proctoringOptions.credentials,
-    showConsole: proctoringOptions.showConsole
-  });
-  const checker = new DeviceCheckerService({
+  const parameters = {
     type: enviromentConfig,
     clientId: proctoringOptions.clientId,
     examId: proctoringOptions.examId,
     token: proctoringOptions.token,
     credentials: proctoringOptions.credentials,
     showConsole: proctoringOptions.showConsole
-  });
+  };
+  const proctoring = new Proctoring(parameters);
+  const checker = new DeviceCheckerService(parameters);
+  const signTerm = new SignTerm(parameters);
   const photo = new CapturePhoto();
   const login = proctoring.login.bind(proctoring);
   const start = proctoring.start.bind(proctoring);
@@ -12324,6 +13030,7 @@ function useProctoring(proctoringOptions, enviromentConfig = "prod") {
   const onBufferSizeError = proctoring.setOnBufferSizeErrorCallback.bind(proctoring);
   const onStopSharingScreen = proctoring.setOnStopSharingScreenCallback.bind(proctoring);
   const onRealtimeAlerts = proctoring.onRealtimeAlerts.bind(proctoring);
+  const signInTerms = signTerm.signInTerms.bind(signTerm);
   const checkDevices = checker.checkDevices.bind(checker);
   const runCheckDevicesFlow = checker.runCheckDevicesFlow.bind(checker);
   const changeSelectedDevice = checker.changeSelectedDevice.bind(checker);
@@ -12344,7 +13051,8 @@ function useProctoring(proctoringOptions, enviromentConfig = "prod") {
     enumarateDevices,
     checkPermissions,
     checkIfhasMultipleMonitors,
-    onStopSharingScreen
+    onStopSharingScreen,
+    signInTerms
   };
 }