easyproctor-hml 2.7.13 → 2.8.0

package/esm/index.js

@@ -9340,6 +9340,9 @@ var FaceDetection = class extends BaseDetection {
     if (this.emmitedFaceAlert) {
       this.handleOk("face_stop", "face_detection_on_stream");
     }
+    this.numFacesSent = -1;
+    this.emmitedPositionAlert = false;
+    this.emmitedFaceAlert = false;
   }
   // displayVideoDetections(result: { detections: any; }) {
   //     // console.log(result);
@@ -12699,7 +12702,8 @@ var getDefaultProctoringOptions = {
   useSpyScan: false,
   useExternalCamera: false,
   useChallenge: false,
-  screenRecorderOptions: { width: 1280, height: 720 }
+  screenRecorderOptions: { width: 1280, height: 720 },
+  auto: false
 };
 
 // src/proctoring/options/ProctoringVideoOptions.ts
@@ -12758,6 +12762,9 @@ function isMobileDevice() {
   }
   return /Android|iPhone|iPad|iPod/i.test(navigator.userAgent);
 }
+function isSafeBrowser() {
+  return versionVerify() !== "1.0.0.0";
+}
 
 // src/plugins/recorder.ts
 var proctoringId;
@@ -13251,61 +13258,623 @@ var ObjectDetection = class extends BaseDetection {
   }
 };
 
-// src/new-flow/recorders/VolumeMeter.ts
-var VolumeMeter = class {
-  constructor(stream) {
-    this.volume = null;
-    this.animationFrameId = null;
-    this.stream = stream;
+// src/new-flow/recorders/CameraRecorder.ts
+var import_jszip_min = __toESM(require_jszip_min());
+
+// src/new-flow/chunk/ChunkStorageService.ts
+var _ChunkStorageService = class _ChunkStorageService {
+  constructor() {
+    this.db = null;
   }
-  async start(options = {}) {
+  /**
+   * Abre a conexão com o IndexedDB, criando o banco e o object store se necessário.
+   */
+  async connect() {
+    if (this.db) return this.db;
     return new Promise((resolve, reject) => {
-      try {
-        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;
-        this.microphone.connect(this.analyser);
-        const processAudio = () => {
-          const array = new Uint8Array(this.analyser.frequencyBinCount);
-          this.analyser.getByteFrequencyData(array);
-          const arraySum = array.reduce((a3, value) => a3 + value, 0);
-          const average = arraySum / array.length;
-          this.setVolume(average);
-          options.setVolume && options.setVolume(average);
-          this.animationFrameId = requestAnimationFrame(processAudio);
+      const request = window.indexedDB.open(
+        _ChunkStorageService.DB_NAME,
+        _ChunkStorageService.DB_VERSION
+      );
+      request.onerror = () => {
+        reject(new Error("N\xE3o foi poss\xEDvel conectar ao IndexedDB para chunks."));
+      };
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (db.objectStoreNames.contains(_ChunkStorageService.STORE_NAME)) {
+          db.deleteObjectStore(_ChunkStorageService.STORE_NAME);
+        }
+        const store = db.createObjectStore(_ChunkStorageService.STORE_NAME, {
+          keyPath: "id",
+          autoIncrement: true
+        });
+        store.createIndex("proctoringId", "proctoringId", { unique: false });
+        store.createIndex("uploaded", "uploaded", { unique: false });
+        store.createIndex("proctoringId_uploaded", ["proctoringId", "uploaded"], {
+          unique: false
+        });
+      };
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve(this.db);
+      };
+    });
+  }
+  /**
+   * Salva um chunk de vídeo no IndexedDB.
+   */
+  async saveChunk(chunk) {
+    const db = await this.connect();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(_ChunkStorageService.STORE_NAME, "readwrite");
+      const store = transaction.objectStore(_ChunkStorageService.STORE_NAME);
+      const request = store.add(chunk);
+      request.onsuccess = () => {
+        resolve(request.result);
+      };
+      request.onerror = () => {
+        var _a2;
+        reject(new Error(`Erro ao salvar chunk no IndexedDB: ${(_a2 = request.error) == null ? void 0 : _a2.message}`));
+      };
+    });
+  }
+  /**
+   * Retorna todos os chunks pendentes (não enviados) de um proctoringId específico.
+   */
+  async getPendingChunks(proctoringId2) {
+    const db = await this.connect();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(_ChunkStorageService.STORE_NAME, "readonly");
+      const store = transaction.objectStore(_ChunkStorageService.STORE_NAME);
+      const index = store.index("proctoringId_uploaded");
+      const range = IDBKeyRange.only([proctoringId2, 0]);
+      const request = index.getAll(range);
+      request.onsuccess = () => {
+        const chunks = request.result.sort(
+          (a3, b3) => a3.chunkIndex - b3.chunkIndex
+        );
+        resolve(chunks);
+      };
+      request.onerror = () => {
+        var _a2;
+        reject(new Error(`Erro ao buscar chunks pendentes: ${(_a2 = request.error) == null ? void 0 : _a2.message}`));
+      };
+    });
+  }
+  /**
+   * Retorna todos os chunks (enviados ou não) de um proctoringId específico.
+   */
+  async getAllChunks(proctoringId2) {
+    const db = await this.connect();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(_ChunkStorageService.STORE_NAME, "readonly");
+      const store = transaction.objectStore(_ChunkStorageService.STORE_NAME);
+      const index = store.index("proctoringId");
+      const range = IDBKeyRange.only(proctoringId2);
+      const request = index.getAll(range);
+      request.onsuccess = () => {
+        const chunks = request.result.sort(
+          (a3, b3) => a3.chunkIndex - b3.chunkIndex
+        );
+        resolve(chunks);
+      };
+      request.onerror = () => {
+        var _a2;
+        reject(new Error(`Erro ao buscar todos os chunks: ${(_a2 = request.error) == null ? void 0 : _a2.message}`));
+      };
+    });
+  }
+  /**
+   * Marca um chunk como enviado (uploaded = 1).
+   */
+  async markAsUploaded(chunkId) {
+    const db = await this.connect();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(_ChunkStorageService.STORE_NAME, "readwrite");
+      const store = transaction.objectStore(_ChunkStorageService.STORE_NAME);
+      const getRequest = store.get(chunkId);
+      getRequest.onsuccess = () => {
+        const chunk = getRequest.result;
+        if (!chunk) {
+          resolve();
+          return;
+        }
+        chunk.uploaded = 1;
+        const putRequest = store.put(chunk);
+        putRequest.onsuccess = () => resolve();
+        putRequest.onerror = () => {
+          var _a2;
+          return reject(new Error(`Erro ao marcar chunk como enviado: ${(_a2 = putRequest.error) == null ? void 0 : _a2.message}`));
         };
-        this.animationFrameId = requestAnimationFrame(processAudio);
-        resolve(true);
-      } catch (error) {
-        this.stop();
-        reject(`Error: ${error}`);
-      }
+      };
+      getRequest.onerror = () => {
+        var _a2;
+        return reject(new Error(`Erro ao buscar chunk para marcar: ${(_a2 = getRequest.error) == null ? void 0 : _a2.message}`));
+      };
     });
   }
+  /**
+   * Remove todos os chunks já enviados de um proctoringId para liberar espaço.
+   */
+  async clearUploadedChunks(proctoringId2) {
+    const db = await this.connect();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(_ChunkStorageService.STORE_NAME, "readwrite");
+      const store = transaction.objectStore(_ChunkStorageService.STORE_NAME);
+      const index = store.index("proctoringId_uploaded");
+      const range = IDBKeyRange.only([proctoringId2, 1]);
+      const request = index.openCursor(range);
+      request.onsuccess = () => {
+        const cursor = request.result;
+        if (cursor) {
+          cursor.delete();
+          cursor.continue();
+        } else {
+          resolve();
+        }
+      };
+      request.onerror = () => {
+        var _a2;
+        return reject(new Error(`Erro ao limpar chunks enviados: ${(_a2 = request.error) == null ? void 0 : _a2.message}`));
+      };
+    });
+  }
+  /**
+   * Remove TODOS os chunks de um proctoringId (limpeza completa pós-finalização).
+   */
+  async clearAllChunks(proctoringId2) {
+    const db = await this.connect();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(_ChunkStorageService.STORE_NAME, "readwrite");
+      const store = transaction.objectStore(_ChunkStorageService.STORE_NAME);
+      const index = store.index("proctoringId");
+      const range = IDBKeyRange.only(proctoringId2);
+      const request = index.openCursor(range);
+      request.onsuccess = () => {
+        const cursor = request.result;
+        if (cursor) {
+          cursor.delete();
+          cursor.continue();
+        } else {
+          resolve();
+        }
+      };
+      request.onerror = () => {
+        var _a2;
+        return reject(new Error(`Erro ao limpar todos os chunks: ${(_a2 = request.error) == null ? void 0 : _a2.message}`));
+      };
+    });
+  }
+  /**
+   * Verifica se existem chunks pendentes para qualquer proctoringId.
+   * Útil na recuperação pós-crash.
+   */
+  async hasAnyPendingChunks() {
+    const db = await this.connect();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(_ChunkStorageService.STORE_NAME, "readonly");
+      const store = transaction.objectStore(_ChunkStorageService.STORE_NAME);
+      const index = store.index("uploaded");
+      const range = IDBKeyRange.only(0);
+      const request = index.count(range);
+      request.onsuccess = () => {
+        resolve(request.result > 0);
+      };
+      request.onerror = () => {
+        var _a2;
+        return reject(new Error(`Erro ao verificar chunks pendentes: ${(_a2 = request.error) == null ? void 0 : _a2.message}`));
+      };
+    });
+  }
+  /**
+   * Retorna todos os proctoringIds que possuem chunks pendentes.
+   * Útil na recuperação pós-crash para saber quais sessões precisam ser finalizadas.
+   */
+  async getPendingProctoringIds() {
+    const db = await this.connect();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(_ChunkStorageService.STORE_NAME, "readonly");
+      const store = transaction.objectStore(_ChunkStorageService.STORE_NAME);
+      const index = store.index("uploaded");
+      const range = IDBKeyRange.only(0);
+      const request = index.getAll(range);
+      request.onsuccess = () => {
+        const chunks = request.result;
+        const ids = [...new Set(chunks.map((c3) => c3.proctoringId))];
+        resolve(ids);
+      };
+      request.onerror = () => {
+        var _a2;
+        return reject(new Error(`Erro ao buscar proctoringIds pendentes: ${(_a2 = request.error) == null ? void 0 : _a2.message}`));
+      };
+    });
+  }
+  /**
+   * Fecha a conexão com o banco.
+   */
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+};
+_ChunkStorageService.DB_NAME = "EasyProctorChunksDb";
+/** v2: índices uploaded numéricos; v3: campo arrayBuffer em vez de blob */
+_ChunkStorageService.DB_VERSION = 3;
+_ChunkStorageService.STORE_NAME = "chunks";
+var ChunkStorageService = _ChunkStorageService;
+
+// src/new-flow/chunk/BackgroundUploadService.ts
+var DEFAULT_CONFIG = {
+  pollInterval: 5e3,
+  maxRetries: 5,
+  baseRetryDelay: 2e3,
+  cleanAfterUpload: true
+};
+var BackgroundUploadService = class _BackgroundUploadService {
+  constructor(proctoringId2, token, backend, chunkStorage, config) {
+    this.pollTimer = null;
+    this.isProcessing = false;
+    this.isRunning = false;
+    /** Mapa de chunkId -> número de tentativas já feitas */
+    this.retryCount = /* @__PURE__ */ new Map();
+    /** GCS Resumable Upload State */
+    this.sessionUrl = null;
+    this.currentOffset = 0;
+    this.totalBytesPurged = 0;
+    this.STORAGE_KEY_PREFIX = "ep_upload_session_";
+    this.GCS_CHUNK_SIZE = 256 * 1024;
+    this.proctoringId = proctoringId2.trim();
+    this.token = token;
+    this.backend = backend;
+    this.chunkStorage = chunkStorage;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.loadSessionState();
+  }
+  loadSessionState() {
+    try {
+      const stored = localStorage.getItem(`${this.STORAGE_KEY_PREFIX}${this.proctoringId}`);
+      if (stored) {
+        const { sessionUrl, currentOffset, totalBytesPurged } = JSON.parse(stored);
+        this.sessionUrl = sessionUrl;
+        this.currentOffset = currentOffset;
+        this.totalBytesPurged = totalBytesPurged || 0;
+      }
+    } catch (e3) {
+      console.warn("[BackgroundUpload] Erro ao carregar estado da sess\xE3o:", e3);
+    }
+  }
+  saveSessionState() {
+    try {
+      localStorage.setItem(
+        `${this.STORAGE_KEY_PREFIX}${this.proctoringId}`,
+        JSON.stringify({
+          sessionUrl: this.sessionUrl,
+          currentOffset: this.currentOffset,
+          totalBytesPurged: this.totalBytesPurged
+        })
+      );
+    } catch (e3) {
+      console.warn("[BackgroundUpload] Erro ao salvar estado da sess\xE3o:", e3);
+    }
+  }
+  clearSessionState() {
+    try {
+      localStorage.removeItem(`${this.STORAGE_KEY_PREFIX}${this.proctoringId}`);
+      this.sessionUrl = null;
+      this.currentOffset = 0;
+      this.totalBytesPurged = 0;
+    } catch (e3) {
+      console.warn("[BackgroundUpload] Erro ao limpar estado da sess\xE3o:", e3);
+    }
+  }
+  /**
+   * Inicia o serviço de upload em background. Faz polling periódico no IndexedDB
+   * para enviar chunks pendentes.
+   */
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    console.log(`[BackgroundUpload] Iniciando servi\xE7o para proctoringId: ${this.proctoringId}`);
+    this.processQueue();
+    this.pollTimer = setInterval(() => {
+      this.processQueue(false);
+    }, this.config.pollInterval);
+  }
+  /**
+   * Para o serviço de upload em background.
+   */
   stop() {
-    var _a2, _b, _c2;
-    if (this.animationFrameId !== null) {
-      cancelAnimationFrame(this.animationFrameId);
+    this.isRunning = false;
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
     }
-    (_a2 = this.audioContext) == null ? void 0 : _a2.close();
-    (_b = this.microphone) == null ? void 0 : _b.disconnect();
-    (_c2 = this.analyser) == null ? void 0 : _c2.disconnect();
+    console.log(`[BackgroundUpload] Servi\xE7o parado para proctoringId: ${this.proctoringId}`);
   }
-  getVolume() {
-    return this.volume;
+  /**
+   * Força o processamento de todos os chunks pendentes e encerra a sessão GCS.
+   * Útil quando a gravação é finalizada.
+   */
+  async flush() {
+    console.log(`[BackgroundUpload] Flush: enviando todos os chunks pendentes e finalizando...`);
+    let waitAttempts = 0;
+    while (this.isProcessing && waitAttempts < 10) {
+      await this.sleep(1e3);
+      waitAttempts++;
+    }
+    let flushRetries = 0;
+    const maxFlushRetries = 3;
+    while (flushRetries < maxFlushRetries) {
+      try {
+        await this.processQueue(true);
+        console.log(`[BackgroundUpload] Flush completado com sucesso.`);
+        return;
+      } catch (error) {
+        flushRetries++;
+        console.error(`[BackgroundUpload] Erro no flush (tentativa ${flushRetries}/${maxFlushRetries}):`, error);
+        if (flushRetries < maxFlushRetries) {
+          await this.sleep(2e3);
+        }
+      }
+    }
+    throw new Error(`[BackgroundUpload] Falha ao finalizar upload ap\xF3s ${maxFlushRetries} tentativas.`);
   }
-  setVolume(value) {
-    this.volume = value;
+  /**
+   * Sincroniza o offset local com o estado real no Google Cloud Storage.
+   */
+  async syncOffset() {
+    if (!this.sessionUrl) return 0;
+    try {
+      console.log(`[BackgroundUpload] Sincronizando offset com GCS...`);
+      const response = await fetch(this.sessionUrl, {
+        method: "PUT",
+        headers: {
+          "Content-Range": "bytes */*"
+        }
+      });
+      console.log(`[BackgroundUpload] Status da sincroniza\xE7\xE3o (syncOffset): ${response.status}`);
+      if (response.status === 308) {
+        const range = response.headers.get("Range");
+        if (range) {
+          const lastByte = parseInt(range.split("-")[1], 10);
+          this.currentOffset = lastByte + 1;
+          this.saveSessionState();
+          console.log(`[BackgroundUpload] Offset sincronizado: ${this.currentOffset}`);
+        } else {
+          this.currentOffset = 0;
+        }
+      } else if (response.ok || response.status === 201) {
+        console.log("[BackgroundUpload] Sincroniza\xE7\xE3o indicou upload JA FINALIZADO.");
+        this.currentOffset = -1;
+      } else {
+        console.warn(`[BackgroundUpload] Status inesperado na sincroniza\xE7\xE3o: ${response.status}`);
+      }
+    } catch (error) {
+      console.warn("[BackgroundUpload] Erro ao sincronizar offset:", error);
+    }
+    return this.currentOffset;
+  }
+  /**
+   * Verifica e envia chunks pendentes para o backend.
+   * @param isFinal Se true, não alinha a 256KB e fecha a sessão com /TOTAL no header.
+   */
+  async processQueue(isFinal = false) {
+    var _a2, _b;
+    if (this.isProcessing) return;
+    this.isProcessing = true;
+    try {
+      if (this.sessionUrl) {
+        await this.syncOffset();
+        if (this.currentOffset === -1) {
+          console.log("[BackgroundUpload] Sess\xE3o j\xE1 finalizada no servidor.");
+          this.clearSessionState();
+          this.isProcessing = false;
+          return;
+        }
+      }
+      const allChunks = await this.chunkStorage.getAllChunks(this.proctoringId);
+      const pendingChunks = allChunks.filter((c3) => c3.uploaded === 0);
+      if (pendingChunks.length === 0 && !isFinal) {
+        this.isProcessing = false;
+        return;
+      }
+      console.log(`[BackgroundUpload] ${pendingChunks.length} chunks pendentes encontrados. Modo final: ${isFinal}`);
+      let virtualStart = this.totalBytesPurged;
+      const chunksWithMeta = allChunks.map((c3) => {
+        const start = virtualStart;
+        const byteLength = c3.arrayBuffer.byteLength;
+        const end = start + byteLength - 1;
+        virtualStart += byteLength;
+        return { chunk: c3, start, end };
+      });
+      let combinedBlobParts = [];
+      let lastProcessedChunkId = null;
+      let finalChunkIndex = 0;
+      let mimeType = pendingChunks[0].mimeType;
+      for (const meta of chunksWithMeta) {
+        if (this.currentOffset > meta.end) continue;
+        const sliceStart = Math.max(0, this.currentOffset - meta.start);
+        const sliceBuf = meta.chunk.arrayBuffer.slice(sliceStart);
+        combinedBlobParts.push(new Blob([sliceBuf]));
+        lastProcessedChunkId = meta.chunk.id;
+        finalChunkIndex = meta.chunk.chunkIndex;
+      }
+      if (combinedBlobParts.length === 0 && !isFinal) {
+        this.isProcessing = false;
+        return;
+      }
+      let fullBlob = new Blob(combinedBlobParts, { type: mimeType });
+      let sendableSize = fullBlob.size;
+      let totalSizeForHeader = void 0;
+      if (!isFinal) {
+        sendableSize = Math.floor(fullBlob.size / this.GCS_CHUNK_SIZE) * this.GCS_CHUNK_SIZE;
+        if (sendableSize === 0) {
+          console.log("[BackgroundUpload] Dados insuficientes para atingir 256KB. Aguardando novo chunk...");
+          this.isProcessing = false;
+          return;
+        }
+      } else {
+        totalSizeForHeader = virtualStart;
+      }
+      const blobToSend = fullBlob.slice(0, sendableSize);
+      try {
+        await this.uploadData(blobToSend, mimeType, finalChunkIndex, totalSizeForHeader);
+        for (const meta of chunksWithMeta) {
+          if (meta.chunk.uploaded === 0 && meta.end < this.currentOffset) {
+            await this.chunkStorage.markAsUploaded(meta.chunk.id);
+            this.retryCount.delete(meta.chunk.id);
+            (_a2 = this.onChunkUploaded) == null ? void 0 : _a2.call(this, meta.chunk.id, meta.chunk.chunkIndex);
+            console.log(`[BackgroundUpload] Chunk ${meta.chunk.chunkIndex} marcado como enviado.`);
+          }
+        }
+        if (this.config.cleanAfterUpload) {
+          const chunksToClear = chunksWithMeta.filter((meta) => meta.chunk.uploaded === 1 || meta.chunk.uploaded === 0 && meta.end < this.currentOffset);
+          const sizePurged = chunksToClear.reduce(
+            (acc, meta) => acc + meta.chunk.arrayBuffer.byteLength,
+            0
+          );
+          await this.chunkStorage.clearUploadedChunks(this.proctoringId);
+          if (sizePurged > 0) {
+            this.totalBytesPurged += sizePurged;
+            this.saveSessionState();
+            console.log(`[BackgroundUpload] ${sizePurged} bytes limpos do armazenamento local. Total purgado: ${this.totalBytesPurged}`);
+          }
+        }
+        if (isFinal) {
+          this.clearSessionState();
+        }
+      } catch (error) {
+        console.error("[BackgroundUpload] Falha no upload:", error);
+        (_b = this.onUploadError) == null ? void 0 : _b.call(this, lastProcessedChunkId || 0, error);
+      }
+    } catch (error) {
+      console.error("[BackgroundUpload] Erro ao processar fila:", error);
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+  /**
+   * Faz o upload bruto de dados para a sessão GCS.
+   */
+  async uploadData(blob, mimeType, chunkIndex, totalSize) {
+    const fileName = `EP_${this.proctoringId}_camera_0.webm`;
+    if (!this.sessionUrl) {
+      const initiateUrl = await this.backend.initiateUpload(this.token, `${this.proctoringId}/${fileName}`, mimeType);
+      const startResponse = await fetch(initiateUrl, {
+        method: "POST",
+        headers: { "x-goog-resumable": "start", "Content-Type": mimeType }
+      });
+      if (!startResponse.ok) throw new Error(`Falha ao iniciar: ${startResponse.status}`);
+      this.sessionUrl = startResponse.headers.get("Location");
+      if (!this.sessionUrl) throw new Error("Location header ausente");
+      try {
+        const urlObj = new URL(this.sessionUrl);
+        const pathParts = urlObj.pathname.split("/");
+        let bucket = pathParts[1];
+        let object = decodeURIComponent(pathParts.slice(2).join("/"));
+        if (pathParts.includes("b") && pathParts.includes("o")) {
+          const bIdx = pathParts.indexOf("b") + 1;
+          const oIdx = pathParts.indexOf("o") + 1;
+          bucket = pathParts[bIdx];
+          object = decodeURIComponent(pathParts.slice(oIdx).join("/"));
+        }
+        console.log(`[BackgroundUpload] Sess\xE3o Iniciada -> Bucket: ${bucket}, Objeto: ${object}`);
+      } catch (e3) {
+        console.log(`[BackgroundUpload] Sess\xE3o Iniciada. URL: ${this.sessionUrl}`);
+      }
+      this.currentOffset = 0;
+      this.saveSessionState();
+    } else {
+      console.log(`[BackgroundUpload] Usando sess\xE3o GCS existente: ${this.sessionUrl}`);
+    }
+    const start = this.currentOffset;
+    const end = start + blob.size - 1;
+    const totalHeader = totalSize !== void 0 ? totalSize.toString() : "*";
+    const contentRangeHeader = blob.size === 0 && totalSize !== void 0 ? `bytes */${totalHeader}` : `bytes ${start}-${end}/${totalHeader}`;
+    console.log(`[BackgroundUpload] Enviando ${blob.size > 0 ? "dados" : "finaliza\xE7\xE3o"}: ${contentRangeHeader} (Size: ${blob.size})`);
+    const response = await fetch(this.sessionUrl, {
+      method: "PUT",
+      headers: { "Content-Range": contentRangeHeader },
+      body: blob.size > 0 ? blob : null
+      // Usa null para garantir corpo vazio se necessário
+    });
+    console.log(`[BackgroundUpload] Resposta GCS (uploadData): ${response.status}`);
+    if (response.status !== 200 && response.status !== 201 && response.status !== 308) {
+      const errorText = await response.text();
+      console.error(`[BackgroundUpload] Erro GCS: ${errorText}`);
+      throw new Error(`Status HTTP inesperado: ${response.status}`);
+    }
+    const rangeHeader = response.headers.get("Range");
+    if (rangeHeader) {
+      const lastByte = parseInt(rangeHeader.split("-")[1], 10);
+      this.currentOffset = lastByte + 1;
+    } else {
+      this.currentOffset += blob.size;
+    }
+    this.saveSessionState();
+    trackers.registerUploadFile(
+      this.proctoringId,
+      `GCS Stream Upload
+	Size: ${blob.size}
+	Range: ${start}-${end}
+	Last Index: ${chunkIndex}`,
+      "CameraChunk"
+    );
+  }
+  /**
+   * Método estático para recuperação pós-crash.
+   * Verifica o IndexedDB em busca de chunks pendentes de qualquer sessão
+   * e tenta enviar.
+   */
+  static async recoverPendingUploads(backend, token) {
+    const chunkStorage = new ChunkStorageService();
+    const recoveredIds = [];
+    try {
+      const pendingIds = await chunkStorage.getPendingProctoringIds();
+      if (pendingIds.length === 0) {
+        console.log("[BackgroundUpload] Nenhum chunk pendente encontrado para recupera\xE7\xE3o.");
+        return recoveredIds;
+      }
+      console.log(
+        `[BackgroundUpload] Recupera\xE7\xE3o p\xF3s-crash: ${pendingIds.length} sess\xE3o(\xF5es) com chunks pendentes.`
+      );
+      for (const proctoringId2 of pendingIds) {
+        try {
+          const service = new _BackgroundUploadService(
+            proctoringId2,
+            token,
+            backend,
+            chunkStorage,
+            { cleanAfterUpload: true }
+          );
+          await service.flush();
+          recoveredIds.push(proctoringId2);
+          console.log(
+            `[BackgroundUpload] Chunks da sess\xE3o ${proctoringId2} recuperados com sucesso.`
+          );
+        } catch (error) {
+          console.error(
+            `[BackgroundUpload] Erro ao recuperar chunks da sess\xE3o ${proctoringId2}:`,
+            error
+          );
+        }
+      }
+    } catch (error) {
+      console.error("[BackgroundUpload] Erro geral na recupera\xE7\xE3o:", error);
+    }
+    return recoveredIds;
+  }
+  sleep(ms2) {
+    return new Promise((resolve) => setTimeout(resolve, ms2));
   }
 };
 
 // src/new-flow/recorders/CameraRecorder.ts
-var import_jszip_min = __toESM(require_jszip_min());
 var pkg = require_fix_webm_duration();
 var fixWebmDuration = pkg.default || pkg;
-var CameraRecorder = class {
+var _CameraRecorder = class _CameraRecorder {
   constructor(options, videoOptions, paramsConfig, backend, backendToken) {
     this.blobs = [];
     this.paramsConfig = {
@@ -13358,20 +13927,138 @@ var CameraRecorder = class {
     this.videoElement = null;
     this.duration = 0;
     this.stopped = false;
+    this.backgroundUpload = null;
+    this.chunkIndex = 0;
+    /** Lista de promises de chunks sendo salvos no IndexedDB para evitar race conditions no stop */
+    this.pendingChunkSaves = [];
+    // Handlers bound para poder remover os listeners depois
+    this.boundVisibilityHandler = null;
+    this.boundPageHideHandler = null;
     this.currentRetries = 0;
     this.packageCount = 0;
     this.failedUploads = 0;
-    this.noiseWait = 20;
     this.options = options;
     this.videoOptions = videoOptions;
     this.backend = backend;
     this.backendToken = backendToken;
     paramsConfig && (this.paramsConfig = paramsConfig);
   }
+  /**
+  * Determina se o fluxo de chunks e lifecycle deve estar ativo.
+  * Retorna true se:
+  *  1. O proctoringId já foi definido (ou seja, estamos em uma sessão real, NÃO no checkDevices)
+  *  2. E (`useChunkRecording` foi explicitamente setado como true OU o dispositivo é mobile)
+  */
+  get isChunkEnabled() {
+    return !!this.proctoringId && this.options.proctoringType === "REALTIME" && !isSafeBrowser();
+  }
   setProctoringId(proctoringId2) {
     this.proctoringId = proctoringId2;
     this.proctoringId && this.backend && (this.upload = new UploadService(this.proctoringId, this.backend));
     setRecorderProctoringId(proctoringId2);
+    if (this.isChunkEnabled) {
+      this.chunkStorage = new ChunkStorageService();
+      if (this.backend && this.backendToken) {
+        this.backgroundUpload = new BackgroundUploadService(
+          this.proctoringId,
+          this.backendToken,
+          this.backend,
+          this.chunkStorage,
+          { pollInterval: 5e3, maxRetries: 5, cleanAfterUpload: true }
+        );
+      }
+      this.persistSessionState("IN_PROGRESS");
+      console.log(
+        `[CameraRecorder] Chunk recording ATIVO (type: ${this.options.proctoringType}, mobile: ${isMobileDevice()})`
+      );
+    } else {
+      console.log(
+        `[CameraRecorder] Chunk recording INATIVO (type: ${this.options.proctoringType}) \u2014 modo cl\xE1ssico.`
+      );
+    }
+  }
+  // ========================
+  // Session State Persistence (localStorage)
+  // ========================
+  persistSessionState(status) {
+    try {
+      const data = {
+        proctoringId: this.proctoringId,
+        status,
+        timestamp: Date.now()
+      };
+      localStorage.setItem(_CameraRecorder.LS_SESSION_KEY, JSON.stringify(data));
+    } catch (e3) {
+      console.warn("[CameraRecorder] N\xE3o foi poss\xEDvel salvar estado no localStorage:", e3);
+    }
+  }
+  clearSessionState() {
+    try {
+      localStorage.removeItem(_CameraRecorder.LS_SESSION_KEY);
+    } catch (e3) {
+      console.warn("[CameraRecorder] N\xE3o foi poss\xEDvel limpar estado do localStorage:", e3);
+    }
+  }
+  /**
+   * Verifica se existe uma sessão ativa anterior no localStorage.
+   * Retorna os dados da sessão se ela estiver em IN_PROGRESS, null caso contrário.
+   */
+  static checkForActiveSession() {
+    try {
+      const raw = localStorage.getItem(_CameraRecorder.LS_SESSION_KEY);
+      if (!raw) return null;
+      const data = JSON.parse(raw);
+      if (data.status === "IN_PROGRESS") return data;
+      return null;
+    } catch (e3) {
+      return null;
+    }
+  }
+  // ========================
+  // Page Lifecycle Management
+  // ========================
+  setupLifecycleListeners() {
+    this.boundVisibilityHandler = () => this.handleVisibilityChange();
+    this.boundPageHideHandler = () => this.handlePageHide();
+    document.addEventListener("visibilitychange", this.boundVisibilityHandler);
+    window.addEventListener("pagehide", this.boundPageHideHandler);
+  }
+  removeLifecycleListeners() {
+    if (this.boundVisibilityHandler) {
+      document.removeEventListener("visibilitychange", this.boundVisibilityHandler);
+      this.boundVisibilityHandler = null;
+    }
+    if (this.boundPageHideHandler) {
+      window.removeEventListener("pagehide", this.boundPageHideHandler);
+      this.boundPageHideHandler = null;
+    }
+  }
+  handleVisibilityChange() {
+    var _a2;
+    if (document.visibilityState === "hidden") {
+      console.log("[CameraRecorder] P\xE1gina ficou invis\xEDvel \u2014 sess\xE3o potencialmente interrompida.");
+      this.persistSessionState("INTERRUPTED");
+      this.proctoringId && trackers.registerError(
+        this.proctoringId,
+        "Visibility API: P\xE1gina ficou oculta (hidden). Poss\xEDvel troca de app ou minimiza\xE7\xE3o."
+      );
+    } else if (document.visibilityState === "visible") {
+      console.log("[CameraRecorder] P\xE1gina vis\xEDvel novamente \u2014 verificando estado da grava\xE7\xE3o.");
+      this.persistSessionState("IN_PROGRESS");
+      this.proctoringId && trackers.registerError(
+        this.proctoringId,
+        "Visibility API: P\xE1gina voltou a ficar vis\xEDvel. Usu\xE1rio retornou."
+      );
+      (_a2 = this.onVisibilityRestored) == null ? void 0 : _a2.call(this);
+    }
+  }
+  handlePageHide() {
+    console.log("[CameraRecorder] pagehide detectado \u2014 persistindo estado.");
+    this.persistSessionState("INTERRUPTED");
+    this.proctoringId && trackers.registerError(
+      this.proctoringId,
+      "Page Lifecycle: pagehide event detectado. P\xE1gina est\xE1 sendo descarregada."
+    );
   }
   async initializeDetectors() {
     var _a2, _b, _c2;
@@ -13633,6 +14320,51 @@ Setting: ${JSON.stringify(settings, null, 2)}`
       await this.sendPackage();
       await this.filesToUpload.splice(0, this.filesToUpload.length);
     }
+    if (this.isChunkEnabled) {
+      if (this.backgroundUpload) {
+        try {
+          if (this.pendingChunkSaves.length > 0) {
+            console.log(`[CameraRecorder] Aguardando ${this.pendingChunkSaves.length} salvamentos de chunks pendentes...`);
+            await Promise.all(this.pendingChunkSaves);
+          }
+          await this.backgroundUpload.flush();
+        } catch (e3) {
+          console.warn("[CameraRecorder] Erro ao fazer flush dos chunks:", e3);
+        }
+        this.backgroundUpload.stop();
+      }
+      this.removeLifecycleListeners();
+      this.persistSessionState("FINISHED");
+    }
+  }
+  /**
+   * Callback chamado pelo recorder a cada novo chunk de vídeo disponível.
+   * Salva o chunk no IndexedDB para persistência e recuperação.
+   */
+  async handleNewChunk(blob, idx) {
+    if (!this.proctoringId || !this.chunkStorage) return;
+    const savePromise = (async () => {
+      var _a2;
+      try {
+        const arrayBuffer = await blob.arrayBuffer();
+        await this.chunkStorage.saveChunk({
+          proctoringId: this.proctoringId,
+          chunkIndex: this.chunkIndex,
+          arrayBuffer,
+          timestamp: Date.now(),
+          uploaded: 0,
+          mimeType: ((_a2 = this.recorderOptions) == null ? void 0 : _a2.mimeType) || "video/webm"
+        });
+        this.chunkIndex++;
+        console.log(`[CameraRecorder] Chunk ${this.chunkIndex - 1} salvo no IndexedDB.`);
+      } catch (error) {
+        console.error("[CameraRecorder] Erro ao salvar chunk no IndexedDB:", error);
+      }
+    })();
+    this.pendingChunkSaves.push(savePromise);
+    savePromise.finally(() => {
+      this.pendingChunkSaves = this.pendingChunkSaves.filter((p3) => p3 !== savePromise);
+    });
   }
   async pauseRecording() {
     await this.recordingPause();
@@ -13773,21 +14505,36 @@ 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 fixWebmDuration(rawBlob, this.duration);
-      const arrayBuffer = await fixedBlob.arrayBuffer();
-      session.addRecording({
-        device: `Audio
+      let isUploaded = false;
+      if (this.isChunkEnabled) {
+        if (this.backend && this.backendToken && this.proctoringId) {
+          const fileName = `EP_${this.proctoringId}_camera_0.webm`;
+          const objectName = `${this.proctoringId}/${fileName}`;
+          isUploaded = await this.backend.checkUpload(this.backendToken, objectName, "video/webm");
+          this.chunkStorage && await this.chunkStorage.clearAllChunks(session.id);
+        }
+      }
+      if (!isUploaded) {
+        const rawBlob = new Blob(this.blobs, {
+          type: ((_b = this.recorderOptions) == null ? void 0 : _b.mimeType) || "video/webm"
+        });
+        let finalBlob = rawBlob;
+        if (typeof fixWebmDuration === "function") {
+          finalBlob = await fixWebmDuration(rawBlob, this.duration);
+        } else {
+          console.warn("fixWebmDuration n\xE3o dispon\xEDvel");
+        }
+        session.addRecording({
+          device: `Audio
 	Sample Rate: ${settingsAudio.sampleRate}
 	Sample Size: ${settingsAudio.sampleSize}
 
 	Video:
 	${JSON.stringify(this.recorderOptions)}`,
-        arrayBuffer,
-        origin: "Camera" /* Camera */
-      });
+          arrayBuffer: await finalBlob.arrayBuffer(),
+          origin: "Camera" /* Camera */
+        });
+      }
     }
   }
   async getFile(file, name, type) {
@@ -13800,28 +14547,63 @@ Setting: ${JSON.stringify(settings, null, 2)}`
       });
     });
   }
-  onNoiseDetected() {
-    var _a2, _b, _c2;
-    if (this.options.proctoringType === "REALTIME") return;
-    if (!this.volumeMeter && this.cameraStream) {
-      this.volumeMeter = new VolumeMeter(this.cameraStream);
-      this.volumeMeter.start().catch((e3) => {
-        console.log(e3);
-        this.volumeMeter = void 0;
-      });
-    }
-    const volume = (_b = (_a2 = this.volumeMeter) == null ? void 0 : _a2.getVolume()) != null ? _b : 0;
-    if (volume >= (((_c2 = this.paramsConfig.audioBehaviourParameters) == null ? void 0 : _c2.noiseLimit) || 40)) {
-      if (this.noiseWait >= 20) {
-        this.options.onRealtimeAlertsCallback({
-          status: "ALERT",
-          description: "Barulho detectado",
-          type: "audio_detection_on_stream"
-        });
-        this.noiseWait = 0;
+};
+// ========================
+// Chunk & Lifecycle
+// ========================
+/** Intervalo de cada chunk em ms (padrão: 60 segundos) */
+_CameraRecorder.CHUNK_TIMESLICE_MS = 6e4;
+/** Chave do localStorage para persistir estado da sessão */
+_CameraRecorder.LS_SESSION_KEY = "ep_proctoring_session";
+var CameraRecorder = _CameraRecorder;
+
+// src/new-flow/recorders/VolumeMeter.ts
+var VolumeMeter = class {
+  constructor(stream) {
+    this.volume = null;
+    this.animationFrameId = null;
+    this.stream = stream;
+  }
+  async start(options = {}) {
+    return new Promise((resolve, reject) => {
+      try {
+        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;
+        this.microphone.connect(this.analyser);
+        const processAudio = () => {
+          const array = new Uint8Array(this.analyser.frequencyBinCount);
+          this.analyser.getByteFrequencyData(array);
+          const arraySum = array.reduce((a3, value) => a3 + value, 0);
+          const average = arraySum / array.length;
+          this.setVolume(average);
+          options.setVolume && options.setVolume(average);
+          this.animationFrameId = requestAnimationFrame(processAudio);
+        };
+        this.animationFrameId = requestAnimationFrame(processAudio);
+        resolve(true);
+      } catch (error) {
+        this.stop();
+        reject(`Error: ${error}`);
       }
+    });
+  }
+  stop() {
+    var _a2, _b, _c2;
+    if (this.animationFrameId !== null) {
+      cancelAnimationFrame(this.animationFrameId);
     }
-    this.noiseWait++;
+    (_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;
+  }
+  setVolume(value) {
+    this.volume = value;
   }
 };
 
@@ -13829,6 +14611,8 @@ Setting: ${JSON.stringify(settings, null, 2)}`
 var DeviceCheckerUI = class {
   constructor(options = getDefaultProctoringOptions, _videoOptions) {
     this.videoOptions = { width: 1080, height: 720, minWidth: 0, minHeight: 0 };
+    this.autoConfirmTimer = null;
+    this.autoConfirmSeconds = 5;
     this.options = {
       ...getDefaultProctoringOptions,
       ...options,
@@ -14594,9 +15378,53 @@ var DeviceCheckerUI = class {
     }));
   }
   closeModal() {
+    this.stopAutoConfirm();
     const checkDevices = document.querySelector("#checkDevices");
     checkDevices == null ? void 0 : checkDevices.remove();
   }
+  verifyAutoConfirm(status) {
+    var _a2;
+    if (!((_a2 = this.options) == null ? void 0 : _a2.auto)) return;
+    let isAllGreen = status.allowedResolution && status.allowedPositionFace && status.allowedAmbient && status.allowedMicrophone;
+    if (this.options.useSpyScan) {
+      isAllGreen = isAllGreen && status.allowedSpyScan === true;
+    }
+    if (isAllGreen) {
+      if (!this.autoConfirmTimer) {
+        this.startAutoConfirm();
+      }
+    } else {
+      if (this.autoConfirmTimer) {
+        this.stopAutoConfirm();
+      }
+    }
+  }
+  startAutoConfirm() {
+    this.autoConfirmSeconds = 5;
+    const btn = document.getElementById("confirmBtn");
+    if (btn && !btn.disabled) {
+      btn.innerText = `Continuando em ${this.autoConfirmSeconds}s...`;
+      this.autoConfirmTimer = setInterval(() => {
+        this.autoConfirmSeconds--;
+        if (this.autoConfirmSeconds <= 0) {
+          this.stopAutoConfirm();
+          btn.click();
+        } else {
+          btn.innerText = `Continuando em ${this.autoConfirmSeconds}s...`;
+        }
+      }, 1e3);
+    }
+  }
+  stopAutoConfirm() {
+    if (this.autoConfirmTimer) {
+      clearInterval(this.autoConfirmTimer);
+      this.autoConfirmTimer = null;
+    }
+    const btn = document.getElementById("confirmBtn");
+    if (btn) {
+      btn.innerText = "Continuar";
+    }
+  }
   modalActions(closeCheckDevices) {
     const cancelBtn = document.getElementById("cancelBtn");
     const confirmBtn = document.getElementById("confirmBtn");
@@ -14963,6 +15791,7 @@ var _DeviceCheckerService = class _DeviceCheckerService {
     }
   }
   onUpdateCallback() {
+    var _a2;
     if (typeof this.onUpdateCb === "function") {
       this.onUpdateCb({
         allowedResolution: this.allowedResolution,
@@ -14973,6 +15802,15 @@ var _DeviceCheckerService = class _DeviceCheckerService {
         faceDetectionAlerts: this.faceDetectionAlerts
       });
     }
+    if (((_a2 = this.options) == null ? void 0 : _a2.auto) && this.DeviceCheckerUI) {
+      this.DeviceCheckerUI.verifyAutoConfirm({
+        allowedResolution: this.allowedResolution,
+        allowedPositionFace: this.allowedPositionFace,
+        allowedAmbient: this.allowedAmbient,
+        allowedMicrophone: this.allowedMicrophone,
+        allowedSpyScan: this.allowedSpyScan
+      });
+    }
   }
   async checkDevices(options = getDefaultProctoringOptions, _videoOptions = getDefaultProctoringVideoOptions) {
     var _a2;
@@ -15179,16 +16017,19 @@ var _DeviceCheckerService = class _DeviceCheckerService {
           }).finally(() => {
             this.DeviceCheckerUI && this.DeviceCheckerUI.waitingSpyDevices(false);
             this.DeviceCheckerUI && this.allowedSpyScan != null && this.DeviceCheckerUI.isSpyDevicesUI(this.allowedSpyScan);
+            this.onUpdateCallback();
           });
         } else {
           this.allowedSpyScan = false;
           this.DeviceCheckerUI && this.DeviceCheckerUI.waitingSpyDevices(false);
           this.DeviceCheckerUI && this.DeviceCheckerUI.isSpyDevicesUI(this.allowedSpyScan);
+          this.onUpdateCallback();
         }
       } catch (error) {
         this.allowedSpyScan = false;
         this.DeviceCheckerUI && this.DeviceCheckerUI.waitingSpyDevices(false);
         this.DeviceCheckerUI && this.DeviceCheckerUI.isSpyDevicesUI(this.allowedSpyScan);
+        this.onUpdateCallback();
         console.log(error);
       }
     }
@@ -15508,8 +16349,8 @@ var CapturePhoto = class {
   }
 };
 
-// src/extension/extension.ts
-var Extension = class {
+// src/extension/extensionEasyProctor.ts
+var ExtensionEasyProctor = class {
   constructor() {
     this.hasExtension = false;
     this.tryes = 0;
@@ -15554,6 +16395,89 @@ var Extension = class {
   }
 };
 
+// src/extension/extensionEasyCatcher.ts
+var ExtensionEasyCatcher = class {
+  constructor(options) {
+    this.hasExtension = false;
+    this.tryes = 0;
+    this.responseStart = false;
+    this.options = options || {};
+  }
+  /**
+   * Verifica se a extensão está instalada e ativa.
+   * Retorna o número da versão se encontrada, ou lança erro após timeout.
+   */
+  checkExtensionInstalled(timeoutMs = 2e3) {
+    return new Promise((resolve, reject) => {
+      let handled = false;
+      const handler = (event) => {
+        if (event.source === window && event.data.sender === "easyproctor-extension" && event.data.message_name === "version") {
+          handled = true;
+          window.removeEventListener("message", handler);
+          resolve(event.data.message);
+        }
+      };
+      window.addEventListener("message", handler);
+      window.postMessage({
+        type: "easycatcher",
+        func: "verifyExtensionEasycatcher"
+      }, "*");
+      setTimeout(() => {
+        if (!handled) {
+          window.removeEventListener("message", handler);
+          reject(new Error("Extens\xE3o n\xE3o detectada ou n\xE3o respondeu."));
+        }
+      }, timeoutMs);
+    });
+  }
+  /**
+   * Solicita o JSON da sessão atual capturado pela extensão.
+   */
+  getSessionData(timeoutMs = 5e3) {
+    return new Promise((resolve, reject) => {
+      let handled = false;
+      const handler = (event) => {
+        if (event.source === window && event.data.sender === "easyproctor-extension" && event.data.message_name === "data_response") {
+          handled = true;
+          window.removeEventListener("message", handler);
+          resolve(event.data.payload);
+        }
+      };
+      window.addEventListener("message", handler);
+      window.postMessage({
+        type: "easycatcher",
+        func: "getDataExtensionEasycatcher"
+      }, "*");
+      setTimeout(() => {
+        if (!handled) {
+          window.removeEventListener("message", handler);
+          reject(new Error("Timeout ao aguardar dados da extens\xE3o."));
+        }
+      }, timeoutMs);
+    });
+  }
+  start() {
+    return new Promise((resolve, reject) => {
+      let handled = false;
+      const handler = (event) => {
+        if (event.source === window && event.data.sender === "easyproctor-extension" && event.data.message_name === "started_confirmed") {
+          handled = true;
+          window.removeEventListener("message", handler);
+          resolve(true);
+        }
+      };
+      window.addEventListener("message", handler);
+      window.postMessage({ type: "easycatcher", func: "startExtensionEasycatcher" }, "*");
+      setTimeout(() => {
+        if (!handled) {
+          window.removeEventListener("message", handler);
+          reject(new Error("Timeout: Extens\xE3o n\xE3o confirmou o in\xEDcio."));
+        }
+      }, 3e3);
+    });
+  }
+};
+
 // src/modules/onChangeDevices.ts
 var onChangeDevices = class {
   constructor(repositoryDevices, proctoringId2, sessionOptions, allRecorders) {
@@ -15785,15 +16709,18 @@ Error: ${e3.message}
         );
       });
       if (result) {
-        const fileType = this.getFileType(rec.origin);
-        trackers.registerUploadFile(
-          this.proctoringId,
-          `Upload File
+        let fileType = "";
+        if (rec.origin === "Camera" /* Camera */) {
+          fileType = "Camera";
+        } else if (rec.origin === "Screen" /* Screen */) {
+          fileType = "Screen";
+        } else if (rec.origin === "Mic" /* Mic */) {
+          fileType = "Audio";
+        }
+        trackers.registerUploadFile(this.proctoringId, `Upload File
 	Name: ${file.name}
 	Type: ${file.type}
-	Size: ${file.size}`,
-          fileType
-        );
+	Size: ${file.size}`, fileType);
         return result;
       }
     }
@@ -18602,11 +19529,15 @@ var ScreenRecorder = class {
     const rawBlob = new Blob(this.blobs, {
       type: "video/webm"
     });
-    const fixedBlob = await fixWebmDuration2(rawBlob, this.duration);
-    const arrayBuffer = await fixedBlob.arrayBuffer();
+    let finalBlob = rawBlob;
+    if (typeof fixWebmDuration2 === "function") {
+      finalBlob = await fixWebmDuration2(rawBlob, this.duration);
+    } else {
+      console.warn("fixWebmDuration n\xE3o dispon\xEDvel");
+    }
     session.addRecording({
       device: "",
-      arrayBuffer,
+      arrayBuffer: await finalBlob.arrayBuffer(),
       origin: "Screen" /* Screen */
     });
   }
@@ -22738,7 +23669,10 @@ var Proctoring = class {
       if (this.context.token === void 0) {
         throw TOKEN_MISSING;
       }
-      this.extension = new Extension();
+      if (options.useChallenge) {
+        this.extensionEasycatcher = new ExtensionEasyCatcher();
+      }
+      this.extension = new ExtensionEasyProctor();
       this.extension.addEventListener();
       const baseURL = this.backend.selectBaseUrl(this.context.type);
       const devices = await enumarateDevices();
@@ -23110,6 +24044,61 @@ Error: ` + error
       _screenStream: (_a2 = this.allRecorders.screenRecorder) == null ? void 0 : _a2.screenStream
     };
   }
+  async startChallenge(templateId) {
+    var _a2;
+    if (!this.sessionOptions.useChallenge) {
+      throw new Error("useChallenge is set as false on start method");
+    }
+    await this.extensionEasycatcher.checkExtensionInstalled().catch((err) => {
+      throw new Error("EasyCatcher Extension is not installed");
+    });
+    this.extensionEasycatcher.start();
+    const start = Date.now() - ((_a2 = this.allRecorders.cameraRecorder.getStartTime()) == null ? void 0 : _a2.getTime()) || 0;
+    await this.backend.startChallenge({
+      proctoringId: this.proctoringId,
+      templateId,
+      start
+    }).then((resp) => {
+      console.log(resp);
+      this.challengeId = resp.id;
+    }).catch((reason) => {
+      trackers.registerError(
+        this.proctoringId,
+        "N\xE3o foi poss\xEDvel iniciar desafio!"
+      );
+      throw reason;
+    });
+    this.isChallengeRunning = true;
+  }
+  async stopChallenge() {
+    var _a2;
+    if (!this.isChallengeRunning) {
+      throw new Error("Challenge not started");
+    }
+    try {
+      const sessionData = await this.extensionEasycatcher.getSessionData();
+      const end = Date.now() - ((_a2 = this.allRecorders.cameraRecorder.getStartTime()) == null ? void 0 : _a2.getTime()) || 0;
+      await this.backend.stopChallenge(
+        this.challengeId,
+        {
+          end,
+          data: sessionData
+        }
+      ).catch((reason) => {
+        trackers.registerError(
+          this.proctoringId,
+          "N\xE3o foi poss\xEDvel finalizar o desafio no backend!"
+        );
+        return void 0;
+      });
+      this.isChallengeRunning = false;
+    } catch (error) {
+      trackers.registerError(
+        this.proctoringId,
+        "Erro ao recuperar dados da extens\xE3o: " + error.message
+      );
+    }
+  }
 };
 
 // src/proctoring/SignTerm.ts
@@ -23338,6 +24327,8 @@ function useProctoring(proctoringOptions, enviromentConfig = "prod") {
     return originalStart(parameters2, videoOptions);
   };
   const finish = proctoring.finish.bind(proctoring);
+  const startChallenge = proctoring.startChallenge.bind(proctoring);
+  const stopChallenge = proctoring.stopChallenge.bind(proctoring);
   const pause = proctoring.pause.bind(proctoring);
   const resume = proctoring.resume.bind(proctoring);
   const onFocus = proctoring.setOnFocusCallback.bind(proctoring);
@@ -23362,6 +24353,8 @@ function useProctoring(proctoringOptions, enviromentConfig = "prod") {
     login,
     start,
     finish,
+    startChallenge,
+    stopChallenge,
     onFocus,
     onLostFocus,
     onChangeDevices: onChangeDevices2,