easyproctor-hml 2.7.11 → 2.7.13

package/index.js

@@ -30855,16 +30855,13 @@ 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;
 function setRecorderProctoringId(id) {
   proctoringId = id;
 }
-function recorder(stream4, buffer, onBufferSizeError = false, onBufferSizeErrorCallback, audio = false, recorderOpts) {
+function recorder(stream4, buffer, onBufferSizeError = false, onBufferSizeErrorCallback, audio = false) {
   let resolvePromise;
   let onBufferSizeInterval;
   let lastEvent;
@@ -30872,7 +30869,6 @@ function recorder(stream4, buffer, onBufferSizeError = false, onBufferSizeErrorC
   bufferSize = 0;
   let startTime;
   let duration = 0;
-  let chunkIndex = 0;
   let recorderOptions = {
     // eslint-disable-next-line no-useless-escape
     mimeType: "video/webm",
@@ -30907,10 +30903,6 @@ function recorder(stream4, buffer, onBufferSizeError = false, onBufferSizeErrorC
     mediaRecorder2.ondataavailable = (e3) => {
       bufferSize = bufferSize + e3.data.size;
       if (e3.data.size > 0) {
-        if (recorderOpts == null ? void 0 : recorderOpts.onChunkAvailable) {
-          recorderOpts.onChunkAvailable(e3.data, chunkIndex);
-          chunkIndex++;
-        }
         buffer.push(e3.data);
       }
     };
@@ -30942,13 +30934,7 @@ function recorder(stream4, buffer, onBufferSizeError = false, onBufferSizeErrorC
       };
       try {
         console.log("State antes do start:", recorder2.state);
-        chunkIndex = 0;
-        if ((recorderOpts == null ? void 0 : recorderOpts.timeslice) && (recorderOpts == null ? void 0 : recorderOpts.timeslice) > 0) {
-          recorder2.start(recorderOpts.timeslice);
-        } else {
-          recorder2.start(1e4);
-        }
-        bufferSize = 0;
+        recorder2.start(1e4);
         startTime = new Date(Date.now());
       } catch (e3) {
         console.error("Recorder erro ao chamar start event:", e3);
@@ -31002,6 +30988,9 @@ function recorder(stream4, buffer, onBufferSizeError = false, onBufferSizeErrorC
         console.log("stopRecording Recorder n\xE3o est\xE1 em estado recording");
         resolve();
       }
+      stream4.getTracks().forEach((el) => {
+        el.stop();
+      });
     });
   }
   function pauseRecording() {
@@ -31409,617 +31398,11 @@ var VolumeMeter = class {
   }
 };
 
-// src/new-flow/chunk/ChunkStorageService.ts
-var _ChunkStorageService = class _ChunkStorageService {
-  constructor() {
-    this.db = null;
-  }
-  /**
-   * 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) => {
-      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}`));
-        };
-      };
-      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";
-/** Incrementado para v2 para recriar índices com tipos numéricos em vez de boolean */
-_ChunkStorageService.DB_VERSION = 2;
-_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() {
-    this.isRunning = false;
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = null;
-    }
-    console.log(`[BackgroundUpload] Servi\xE7o parado para proctoringId: ${this.proctoringId}`);
-  }
-  /**
-   * 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.`);
-  }
-  /**
-   * 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 end = start + c3.blob.size - 1;
-        virtualStart += c3.blob.size;
-        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 chunkSlice = meta.chunk.blob.slice(sliceStart);
-        combinedBlobParts.push(chunkSlice);
-        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.blob.size, 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 _CameraRecorder {
+var CameraRecorder = class {
   constructor(options, videoOptions, paramsConfig, backend, backendToken) {
     this.blobs = [];
     this.paramsConfig = {
@@ -32072,13 +31455,6 @@ var _CameraRecorder = class _CameraRecorder {
     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;
@@ -32089,122 +31465,10 @@ var _CameraRecorder = class _CameraRecorder {
     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 false;
-  }
   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 {
-      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;
@@ -32357,15 +31621,9 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     await new Promise((r3) => setTimeout(r3, 300));
   }
   async startRecording() {
-    var _a2, _b, _c2, _d, _e3, _f, _g, _h;
+    var _a2, _b, _c2, _d, _e3, _f, _g;
     await this.startStream();
     await this.attachAndWarmup(this.cameraStream);
-    const recorderOpts = this.isChunkEnabled ? {
-      timeslice: _CameraRecorder.CHUNK_TIMESLICE_MS,
-      onChunkAvailable: (blob, idx) => {
-        this.handleNewChunk(blob, idx);
-      }
-    } : {};
     const {
       startRecording,
       stopRecording,
@@ -32381,8 +31639,7 @@ Setting: ${JSON.stringify(settings, null, 2)}`
       this.blobs,
       this.options.onBufferSizeError,
       (e3) => this.bufferError(e3),
-      false,
-      recorderOpts
+      false
     );
     this.recordingStart = startRecording;
     this.recordingStop = stopRecording;
@@ -32392,18 +31649,13 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     this.getBufferSize = getBufferSize;
     this.getStartTime = getStartTime;
     this.getDuration = getDuration;
-    this.chunkIndex = 0;
-    if (this.isChunkEnabled) {
-      (_a2 = this.backgroundUpload) == null ? void 0 : _a2.start();
-      this.setupLifecycleListeners();
-    }
     try {
       await new Promise((r3) => setTimeout(r3, 500));
       await this.recordingStart();
     } catch (error) {
       console.log("Camera Recorder error", error);
       this.stopRecording();
-      const maxRetries = ((_b = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _b.maxRetries) || 3;
+      const maxRetries = ((_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.maxRetries) || 3;
       if (this.currentRetries < maxRetries) {
         console.log("Camera Recorder retry", this.currentRetries);
         this.currentRetries++;
@@ -32413,13 +31665,13 @@ Setting: ${JSON.stringify(settings, null, 2)}`
       }
     }
     this.stopped = false;
-    if (((_c2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _c2.detectPerson) || ((_d = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _d.detectCellPhone) || ((_e3 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _e3.detectFace)) {
+    if (((_b = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _b.detectPerson) || ((_c2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _c2.detectCellPhone) || ((_d = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _d.detectFace)) {
       await this.initializeDetectors();
     }
-    if ((_f = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _f.detectFace) {
+    if ((_e3 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _e3.detectFace) {
       await this.faceDetection.enableCam(this.cameraStream);
     }
-    if (((_g = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _g.detectPerson) || ((_h = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _h.detectCellPhone)) {
+    if (((_f = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _f.detectPerson) || ((_g = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _g.detectCellPhone)) {
       await this.objectDetection.enableCam(this.cameraStream);
     }
     this.filesToUpload = [];
@@ -32478,50 +31730,6 @@ 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 {
-        await this.chunkStorage.saveChunk({
-          proctoringId: this.proctoringId,
-          chunkIndex: this.chunkIndex,
-          blob,
-          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();
@@ -32657,36 +31865,16 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     if (this.blobs != null)
       trackers.registerSaveOnSession(
         this.proctoringId,
-        `Blobs Length: ${this.blobs.length} Buffer Size: ${this.getBufferSize()} ChunkEnabled: ${this.isChunkEnabled}`
+        `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)) {
-      let videoFile;
-      if (this.isChunkEnabled) {
-        const isStable = await this.checkInternetStability();
-        if (isStable) {
-        } else {
-          if (this.backend && this.backendToken && this.proctoringId) {
-            const fileName = `EP_${this.proctoringId}_camera_0.webm`;
-            const objectName = `${this.proctoringId}/${fileName}`;
-            const isUploaded = await this.backend.checkUpload(this.backendToken, objectName, "video/webm");
-            if (isUploaded) {
-              this.chunkStorage && await this.chunkStorage.clearAllChunks(session.id);
-              return;
-            }
-          }
-        }
-      }
       const rawBlob = new Blob(this.blobs, {
         type: ((_b = this.recorderOptions) == null ? void 0 : _b.mimeType) || "video/webm"
       });
       const fixedBlob = await fixWebmDuration(rawBlob, this.duration);
-      videoFile = new File(
-        [fixedBlob],
-        `EP_${session.id}_camera_0.webm`,
-        { type: rawBlob.type }
-      );
+      const arrayBuffer = await fixedBlob.arrayBuffer();
       session.addRecording({
         device: `Audio
 	Sample Rate: ${settingsAudio.sampleRate}
@@ -32694,7 +31882,7 @@ Setting: ${JSON.stringify(settings, null, 2)}`
 
 	Video:
 	${JSON.stringify(this.recorderOptions)}`,
-        file: videoFile,
+        arrayBuffer,
         origin: "Camera" /* Camera */
       });
     }
@@ -32709,28 +31897,6 @@ Setting: ${JSON.stringify(settings, null, 2)}`
       });
     });
   }
-  /**
-   * Verifica se a internet está estável para realizar o upload do vídeo na íntegra.
-   */
-  async checkInternetStability() {
-    var _a2;
-    if (!navigator.onLine) return false;
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 5e3);
-      const baseUrl = (_a2 = this.backend) == null ? void 0 : _a2.getBaseUrl();
-      if (!baseUrl) return true;
-      const response = await fetch(`${baseUrl}/Client/health`, {
-        method: "GET",
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      return response.status < 500;
-    } catch (e3) {
-      console.warn("[CameraRecorder] Internet inst\xE1vel ou lenta detectada para upload integral.");
-      return false;
-    }
-  }
   onNoiseDetected() {
     var _a2, _b, _c2;
     if (this.options.proctoringType === "REALTIME") return;
@@ -32755,14 +31921,6 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     this.noiseWait++;
   }
 };
-// ========================
-// 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/checkers/DeviceCheckerUI.ts
 var DeviceCheckerUI = class {
@@ -34679,46 +33837,60 @@ var ProctoringUploader = class {
       globalOnProgres(100);
     }
   }
+  toFile(rec) {
+    const suffix = rec.origin === "Screen" /* Screen */ ? "screen" : rec.origin === "Camera" /* Camera */ ? "camera" : "audio";
+    const name = `EP_${this.proctoringId}_${suffix}_0.webm`;
+    return new File([rec.arrayBuffer], name, { type: "video/webm" });
+  }
+  getFileType(origin2) {
+    switch (origin2) {
+      case "Camera" /* Camera */:
+        return "Camera";
+      case "Screen" /* Screen */:
+        return "Screen";
+      case "Mic" /* Mic */:
+        return "Audio";
+    }
+  }
   async uploadFile(rec, token, onProgress) {
+    const file = this.toFile(rec);
     for await (const uploadService of this.uploadServices) {
       const result = await uploadService.upload(
         {
-          file: rec.file,
+          file,
           onProgress: (progress) => {
             if (onProgress) onProgress(progress);
           }
         },
         token
-      ).catch(
-        async (e3) => {
-          console.log("Upload File Error", e3), trackers.registerError(this.proctoringId, `Upload File
-	Name: ${rec.file.name}
+      ).catch(async (e3) => {
+        console.log("Upload File Error", e3), trackers.registerError(
+          this.proctoringId,
+          `Upload File
+	Name: ${file.name}
 Error: ${e3.message}
-	Size: ${e3.error}`);
-          await uploadService.upload(
-            {
-              file: rec.file,
-              onProgress: (progress) => {
-                if (onProgress) onProgress(progress);
-              }
-            },
-            token
-          );
-        }
-      );
+	Size: ${e3.error}`
+        );
+        await uploadService.upload(
+          {
+            file,
+            onProgress: (progress) => {
+              if (onProgress) onProgress(progress);
+            }
+          },
+          token
+        );
+      });
       if (result) {
-        let fileType = "";
-        if (rec.file.name.search("camera") !== -1) {
-          fileType = "Camera";
-        } else if (rec.file.name.search("screen") !== -1) {
-          fileType = "Screen";
-        } else if (rec.file.name.search("audio") !== -1) {
-          fileType = "Audio";
-        }
-        trackers.registerUploadFile(this.proctoringId, `Upload File
-	Name: ${rec.file.name}
-	Type: ${rec.file.type}
-	Size: ${rec.file.size}`, fileType);
+        const fileType = this.getFileType(rec.origin);
+        trackers.registerUploadFile(
+          this.proctoringId,
+          `Upload File
+	Name: ${file.name}
+	Type: ${file.type}
+	Size: ${file.size}`,
+          fileType
+        );
         return result;
       }
     }
@@ -37528,14 +36700,10 @@ var ScreenRecorder = class {
       type: "video/webm"
     });
     const fixedBlob = await fixWebmDuration2(rawBlob, this.duration);
-    const file = new File(
-      [fixedBlob],
-      `EP_${session.id}_screen_0.webm`,
-      { type: rawBlob.type }
-    );
+    const arrayBuffer = await fixedBlob.arrayBuffer();
     session.addRecording({
       device: "",
-      file,
+      arrayBuffer,
       origin: "Screen" /* Screen */
     });
   }
@@ -38887,20 +38055,6 @@ var Proctoring = class {
       } catch (error) {
         throw SAFE_BROWSER_API_NOT_FOUND;
       }
-      this.allRecorders.cameraRecorder.onVisibilityRestored = () => {
-        console.log("[Proctoring] Usu\xE1rio retornou ao browser.");
-        this.onVisibilityRestoredCallback();
-      };
-      if (this.sessionOptions.proctoringType === "REALTIME" && !isSafeBrowser()) {
-        try {
-          await BackgroundUploadService.recoverPendingUploads(
-            this.backend,
-            this.context.token
-          );
-        } catch (e3) {
-          console.warn("[Proctoring] Erro ao recuperar chunks de sess\xE3o anterior:", e3);
-        }
-      }
       try {
         console.log("Starting recorders");
         await this.recorder.startAll();
@@ -38981,7 +38135,9 @@ Error: ${error}`
       this.appChecker && await this.appChecker.disconnectWebSocket();
       await this.recorder.saveAllOnSession();
       await this.sendPendingRealtimeAlerts();
+      trackers.registerError(this.proctoringId, `finish this.repository.save starting`);
       await this.repository.save(this.proctoringSession);
+      trackers.registerError(this.proctoringId, `finish this.repository.save finished`);
       let uploader;
       let uploaderServices;
       if (versionVerify() !== "1.0.0.0") {