easyproctor-hml 2.6.0 → 2.7.0

package/esm/index.js

@@ -5044,14 +5044,17 @@ var require_browser = __commonJS({
 
 // src/modules/checkPermissions.ts
 async function checkPermissions() {
+  if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+    return false;
+  }
   try {
     const constraints = {
       audio: true,
       video: true
     };
     const stream = await navigator.mediaDevices.getUserMedia(constraints);
-    stream.getTracks().forEach((el) => {
-      el.stop();
+    stream.getTracks().forEach((track) => {
+      track.stop();
     });
     return true;
   } catch (error) {
@@ -9145,7 +9148,6 @@ var BaseDetection = class {
       // objectDetection
       runningMode: this.runningMode
     });
-    console.log("BaseDetection initializeDetector", this.detectorType);
   }
   stopDetection() {
     this.animationFrameId && clearTimeout(this.animationFrameId);
@@ -9155,7 +9157,7 @@ var BaseDetection = class {
     this.createdVideo && this.video && document.body.removeChild(this.video);
     this.createdVideo = false;
   }
-  enableCam(cameraStream) {
+  enableCam(cameraStream, delay = 1e4) {
     var _a2;
     if (!this.detector) {
       console.log("Wait! Detector not loaded yet.");
@@ -9185,7 +9187,7 @@ var BaseDetection = class {
     (_a2 = this.video) == null ? void 0 : _a2.addEventListener("loadeddata", () => {
       this.animationFrameId = setTimeout(() => {
         that.predictWebcam();
-      }, 1e4);
+      }, delay);
     });
     const style = document.createElement("style");
     style.type = "text/css";
@@ -9202,7 +9204,6 @@ var BaseDetection = class {
             }
         `;
     document.getElementsByTagName("head")[0].appendChild(style);
-    console.log("BaseDetection enableCam OK");
   }
   async predictWebcam() {
     if (this.detecting == false) return;
@@ -9332,7 +9333,6 @@ var FaceDetection = class extends BaseDetection {
     );
     this.emmitedPositionAlert = false;
     this.emmitedFaceAlert = false;
-    console.log("FaceDetection constructor");
     this.numFacesSent = -1;
   }
   stopDetection() {
@@ -12093,13 +12093,28 @@ var {
 var DEV_BASE_URL = "https://proctoring-api-dev.easyproctor.tech/api";
 var HOMOL_BASE_URL = "https://proctoring-api-hml.easyproctor.tech/api";
 var PROD_BASE_URL = "https://proctoring-api.easyproctor.tech/api";
+var REALTIME_DEV_BASE_URL = "https://easyproctor-realtime-api-dev.easyproctor.tech/api";
+var REALTIME_HOMOL_BASE_URL = "https://easyproctor-realtime-api-hml.easyproctor.tech/api";
+var REALTIME_PROD_BASE_URL = "https://easyproctor-realtime-api.easyproctor.tech/api";
 var BackendService = class {
   constructor(options) {
     this.options = options;
-    this.baseUrl = this.selectBaseUrl(options.type);
+    this.baseUrl = this.selectBaseUrl(options.type, options.isRealtime);
     this.token = options.token;
   }
-  selectBaseUrl(type) {
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  selectBaseUrl(type, isRealtime) {
+    if (isRealtime) {
+      if (type === "dev") {
+        return REALTIME_DEV_BASE_URL;
+      } else if (type === "homol") {
+        return REALTIME_HOMOL_BASE_URL;
+      } else {
+        return REALTIME_PROD_BASE_URL;
+      }
+    }
     if (type === "dev") {
       return DEV_BASE_URL;
     } else if (type === "homol") {
@@ -12110,6 +12125,9 @@ var BackendService = class {
       return PROD_BASE_URL;
     }
   }
+  setRealtime(isRealtime) {
+    this.baseUrl = this.selectBaseUrl(this.options.type, isRealtime);
+  }
   getSocketUrl() {
     return this.baseUrl.replace("/api", "/hub/sockethub");
   }
@@ -12220,6 +12238,18 @@ var BackendService = class {
     });
     return url.data;
   }
+  async initiateUpload(token, objectName, contentType) {
+    const url = await this.makeRequestAxios({
+      path: `/upload/initiate-upload`,
+      method: "POST",
+      jwt: token,
+      body: {
+        objectName,
+        contentType
+      }
+    });
+    return url.data;
+  }
   async saveAlerts(proctoringOptions, proctoringSession) {
     await this.makeRequest({
       path: "/proctoring/save-alerts",
@@ -12323,6 +12353,22 @@ var BackendService = class {
     });
     return result.data;
   }
+  async checkUpload(token, objectName, contentType) {
+    try {
+      const result = await this.makeRequestAxios({
+        path: `/Upload/check`,
+        method: "POST",
+        jwt: token,
+        body: {
+          objectName,
+          contentType
+        }
+      });
+      return result.data === true;
+    } catch (e3) {
+      return false;
+    }
+  }
   async getServerHour(token) {
     return await this.makeRequest({
       path: `/Proctoring/server-hour`,
@@ -12523,7 +12569,8 @@ var SpyCam = class {
     this.context = context;
     this.backend = new BackendService({
       type: (context == null ? void 0 : context.type) || "prod",
-      token: context.token
+      token: context.token,
+      isRealtime: false
     });
     this.currentIsPlugged = true;
   }
@@ -12675,6 +12722,14 @@ var getDefaultProctoringVideoOptions = {
   minHeight: 480
 };
 
+// src/utils/verifyVersion.ts
+function versionVerify() {
+  const agentStr = window.navigator.userAgent.split("SEB/");
+  if (agentStr.length > 1)
+    return agentStr[1];
+  else return "1.0.0.0";
+}
+
 // src/utils/browserInformations.ts
 function fnBrowserDetect() {
   const userAgent = navigator.userAgent;
@@ -12703,13 +12758,16 @@ 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(stream, buffer, onBufferSizeError = false, onBufferSizeErrorCallback, audio = false) {
+function recorder(stream, buffer, onBufferSizeError = false, onBufferSizeErrorCallback, audio = false, recorderOpts) {
   let resolvePromise;
   let onBufferSizeInterval;
   let lastEvent;
@@ -12717,6 +12775,7 @@ function recorder(stream, buffer, onBufferSizeError = false, onBufferSizeErrorCa
   bufferSize = 0;
   let startTime;
   let duration = 0;
+  let chunkIndex = 0;
   let recorderOptions = {
     // eslint-disable-next-line no-useless-escape
     mimeType: "video/webm",
@@ -12751,6 +12810,10 @@ function recorder(stream, buffer, onBufferSizeError = false, onBufferSizeErrorCa
     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);
       }
     };
@@ -12782,7 +12845,13 @@ function recorder(stream, buffer, onBufferSizeError = false, onBufferSizeErrorCa
       };
       try {
         console.log("State antes do start:", recorder2.state);
-        recorder2.start(1e4);
+        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;
         startTime = new Date(Date.now());
       } catch (e3) {
         console.error("Recorder erro ao chamar start event:", e3);
@@ -12824,6 +12893,9 @@ function recorder(stream, buffer, onBufferSizeError = false, onBufferSizeErrorCa
           console.log("recorder onstop");
           duration = Date.now() - startTime.getTime() || 0;
           console.log("duration no onstop", duration);
+          stream.getTracks().forEach((el) => {
+            el.stop();
+          });
           resolvePromise && resolvePromise();
         };
         mediaRecorder.stop();
@@ -12833,9 +12905,6 @@ function recorder(stream, buffer, onBufferSizeError = false, onBufferSizeErrorCa
         console.log("stopRecording Recorder n\xE3o est\xE1 em estado recording");
         resolve();
       }
-      stream.getTracks().forEach((el) => {
-        el.stop();
-      });
     });
   }
   function pauseRecording() {
@@ -12929,36 +12998,34 @@ var UploadService = class {
     this.proctoringId = proctoringId2;
   }
   async uploadPackage(data, token) {
-    const { file, onProgress } = data;
+    const { file } = data;
     try {
-      const progressCallback = (e3) => {
-        const progress = e3.loadedBytes / file.size * 100;
-        onProgress && onProgress(Math.round(progress));
-      };
-      const uploadUrl = await this.backend.getSignedUrl(token, file, this.proctoringId);
-      const uploaded = await axios_default.request({
+      console.log("Upload service: uploadPackage");
+      var uploadUrl = "";
+      await this.backend.getSignedUrl(token, file, this.proctoringId).then((result) => uploadUrl = result).catch((error) => {
+        throw error;
+      });
+      console.log("Upload service: uploadUrl", uploadUrl);
+      await axios_default.request({
         url: uploadUrl,
         method: "PUT",
         headers: {
           "Content-Type": file.type,
           "x-ms-blob-type": "BlockBlob"
         },
-        data: file,
-        onUploadProgress: (p3) => {
-          progressCallback({ loadedBytes: p3.loaded });
-        }
-      }).then(() => true).catch(() => false);
-      return {
-        storage: "upload" /* none */,
-        url: uploadUrl,
-        uploaded
-      };
+        data: file
+      }).then(() => {
+        return true;
+      }).catch((error) => {
+        throw error;
+      });
+      return true;
     } catch (err) {
-      trackers.registerError(this.proctoringId, `Failed to upload to AWS
+      trackers.registerError(this.proctoringId, `Failed to upload package ${err}
 	File name: ${file.name}
 	File type: ${file.type}
 	File size: ${file.size}`);
-      throw new Error("Failed to upload to AWS");
+      throw err;
     }
   }
   async uploadImages(data, token, packSize) {
@@ -13245,10 +13312,617 @@ 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 import_fix_webm_duration = __toESM(require_fix_webm_duration());
-var CameraRecorder = class {
+var pkg = require_fix_webm_duration();
+var fixWebmDuration = pkg.default || pkg;
+var _CameraRecorder = class _CameraRecorder {
   constructor(options, videoOptions, paramsConfig, backend, backendToken) {
     this.blobs = [];
     this.paramsConfig = {
@@ -13293,6 +13967,7 @@ var CameraRecorder = class {
     this.blobsRTC = [];
     this.imageCount = 0;
     this.filesToUpload = [];
+    this.pendingPackages = [];
     this.animationFrameId = null;
     this.isCanvasLoopActive = false;
     this.hardwareStream = null;
@@ -13300,8 +13975,16 @@ 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;
@@ -13309,10 +13992,122 @@ var CameraRecorder = class {
     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;
@@ -13465,10 +14260,15 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     await new Promise((r3) => setTimeout(r3, 300));
   }
   async startRecording() {
-    var _a2, _b, _c2, _d, _e3, _f, _g;
-    console.log("CameraRecorder startRecording");
+    var _a2, _b, _c2, _d, _e3, _f, _g, _h;
     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,
@@ -13484,7 +14284,8 @@ Setting: ${JSON.stringify(settings, null, 2)}`
       this.blobs,
       this.options.onBufferSizeError,
       (e3) => this.bufferError(e3),
-      false
+      false,
+      recorderOpts
     );
     this.recordingStart = startRecording;
     this.recordingStop = stopRecording;
@@ -13494,13 +14295,18 @@ 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 = ((_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.maxRetries) || 3;
+      const maxRetries = ((_b = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _b.maxRetries) || 3;
       if (this.currentRetries < maxRetries) {
         console.log("Camera Recorder retry", this.currentRetries);
         this.currentRetries++;
@@ -13510,16 +14316,17 @@ Setting: ${JSON.stringify(settings, null, 2)}`
       }
     }
     this.stopped = false;
-    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)) {
+    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)) {
       await this.initializeDetectors();
     }
-    if ((_e3 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _e3.detectFace) {
+    if ((_f = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _f.detectFace) {
       await this.faceDetection.enableCam(this.cameraStream);
     }
-    if (((_f = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _f.detectPerson) || ((_g = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _g.detectCellPhone)) {
+    if (((_g = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _g.detectPerson) || ((_h = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _h.detectCellPhone)) {
       await this.objectDetection.enableCam(this.cameraStream);
     }
     this.filesToUpload = [];
+    this.pendingPackages = [];
     if (this.options.proctoringType == "REALTIME") {
       await this.startRealtimeCapture();
     }
@@ -13539,6 +14346,7 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     this.intervalNoiseDetection && clearInterval(this.intervalNoiseDetection);
     this.recordingStop && await this.recordingStop();
     this.duration = this.getDuration ? this.getDuration() : 0;
+    await new Promise((r3) => setTimeout(r3, 200));
     try {
       if (this.animationFrameId) {
         cancelAnimationFrame(this.animationFrameId);
@@ -13569,9 +14377,54 @@ Setting: ${JSON.stringify(settings, null, 2)}`
       console.error("Erro ao parar os streams de m\xEDdia.");
     }
     if (this.options.proctoringType == "REALTIME" && this.upload && this.backendToken) {
-      await this.sendPackage(this.filesToUpload);
+      this.pendingPackages.push(this.filesToUpload.slice(0, this.filesToUpload.length));
+      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();
@@ -13618,9 +14471,9 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     if (this.proctoringId == void 0) return;
     if (packSize == this.imageCount) {
       this.imageCount = 0;
-      const framesToSend = [...this.filesToUpload];
-      this.sendPackage(framesToSend);
-      await this.filesToUpload.splice(0, this.filesToUpload.length);
+      this.pendingPackages.push(this.filesToUpload.slice(0, packSize));
+      this.sendPackage();
+      await this.filesToUpload.splice(0, packSize);
     }
     let imageName = `${this.proctoringId}_${this.imageCount + 1}.jpg`;
     imageFile = await this.getFile(image_data_url, imageName, "image/jpeg");
@@ -13634,54 +14487,61 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     var _a2;
     this.configImageCapture();
     this.imageCount = 0;
+    this.pendingPackages = [];
     await this.captureFrame();
     this.imageInterval = setInterval(async () => {
       await this.captureFrame();
     }, ((_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.realtimeCaptureInterval) * 1e3);
   }
   // envia pacote de imagens
-  async sendPackage(framesToSend) {
+  async sendPackage() {
     var _a2, _b;
-    let pending = false;
-    let undeliveredPackagesCount = 0;
     const packSize = (_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.realtimePackageSize;
     const packCaptureInterval = (_b = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _b.realtimeCaptureInterval;
-    if (this.upload && this.backendToken && !pending && this.filesToUpload.length > 0) {
-      undeliveredPackagesCount = 0;
-      pending = true;
-      const zip = new import_jszip_min.default();
-      for (const file of framesToSend) {
-        zip.file(file.name, file);
-      }
-      const blob = await zip.generateAsync({ type: "blob" });
-      let packageName = "realtime_package_" + packSize * packCaptureInterval * this.packageCount + ".zip";
-      const myPackage = new File(
-        [blob],
-        packageName,
-        { type: "application/zip" }
-      );
-      const uploadResult = await this.upload.uploadPackage(
-        {
-          file: myPackage
-        },
-        this.backendToken
-      );
-      if (uploadResult.uploaded == true) {
-        this.packageCount++;
-      } else {
-        console.log("erro no upload do pacote");
+    if (this.upload && this.backendToken && this.pendingPackages.length > 0) {
+      let packagesToDelete = [];
+      let packageIndex = 0;
+      for (const packageToSend of this.pendingPackages) {
+        const zip = new import_jszip_min.default();
+        for (const file of packageToSend) {
+          zip.file(file.name, file);
+        }
+        const blob = await zip.generateAsync({ type: "blob" });
+        let packageName = "realtime_package_" + packSize * packCaptureInterval * this.packageCount + ".zip";
+        const myPackage = new File(
+          [blob],
+          packageName,
+          { type: "application/zip" }
+        );
+        try {
+          const uploadResult = await this.upload.uploadPackage(
+            {
+              file: myPackage
+            },
+            this.backendToken
+          );
+          if (uploadResult == true) {
+            this.packageCount++;
+            this.failedUploads = 0;
+            packagesToDelete.push(packageIndex++);
+          }
+        } catch (error) {
+          this.failedUploads++;
+          if (this.failedUploads >= 2) {
+            this.options.onRealtimeAlertsCallback({
+              status: "ALERT",
+              description: "Realtime n\xE3o est\xE1 enviando pacotes",
+              type: "error_upload_package",
+              category: "error_upload_package",
+              begin: 0,
+              end: 0
+            });
+          }
+          break;
+        }
       }
-      pending = false;
-    } else if (pending) {
-      undeliveredPackagesCount++;
-      if (undeliveredPackagesCount == 3) {
-        undeliveredPackagesCount = 0;
-        let newCanvasWidth = this.videoOptions.width / 2;
-        let newCanvasHeight = this.videoOptions.height / 2;
-        if (newCanvasWidth < 320) newCanvasWidth = 320;
-        if (newCanvasHeight < 180) newCanvasHeight = 180;
-        this.canvas.width = newCanvasWidth;
-        this.canvas.height = newCanvasHeight;
+      for (const packageToDelete of packagesToDelete) {
+        await this.pendingPackages.splice(packageToDelete, 1);
       }
     }
   }
@@ -13700,16 +14560,32 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     if (this.blobs != null)
       trackers.registerSaveOnSession(
         this.proctoringId,
-        `Blobs Length: ${this.blobs.length} Buffer Size: ${this.getBufferSize()} `
+        `Blobs Length: ${this.blobs.length} Buffer Size: ${this.getBufferSize()} ChunkEnabled: ${this.isChunkEnabled}`
       );
     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 (0, import_fix_webm_duration.default)(rawBlob, this.duration);
-      const fileWithDuration = new File(
+      const fixedBlob = await fixWebmDuration(rawBlob, this.duration);
+      videoFile = new File(
         [fixedBlob],
         `EP_${session.id}_camera_0.webm`,
         { type: rawBlob.type }
@@ -13721,7 +14597,7 @@ Setting: ${JSON.stringify(settings, null, 2)}`
 
 	Video:
 	${JSON.stringify(this.recorderOptions)}`,
-        file: fileWithDuration,
+        file: videoFile,
         origin: "Camera" /* Camera */
       });
     }
@@ -13736,6 +14612,28 @@ 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;
@@ -13748,7 +14646,6 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     }
     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)) {
-      console.log("entrou" + this.noiseWait);
       if (this.noiseWait >= 20) {
         this.options.onRealtimeAlertsCallback({
           status: "ALERT",
@@ -13761,6 +14658,14 @@ 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 {
@@ -14833,7 +15738,8 @@ var _DeviceCheckerService = class _DeviceCheckerService {
     this.context = context;
     this.backend = new BackendService({
       type: (context == null ? void 0 : context.type) || "prod",
-      token: context.token
+      token: context.token,
+      isRealtime: false
     });
   }
   getDeviceCheckResult() {
@@ -14994,7 +15900,7 @@ var _DeviceCheckerService = class _DeviceCheckerService {
   videoDeviceInterface(stream) {
     this.DeviceCheckerUI && this.DeviceCheckerUI.videoDeviceInterfaceUI(stream);
     this.isUnderResolution();
-    this.faceDetection.enableCam(stream);
+    this.faceDetection.enableCam(stream, 1e3);
   }
   audioDeviceInterface(stream) {
     this.volumeMeter = new VolumeMeter(this.cameraRecorder.cameraStream);
@@ -18260,6 +19166,7 @@ var NoiseRecorder = class {
     this.MAX_PRE_ROLL_CHUNKS = 4;
     this.lastNoiseTime = 0;
     this.SILENCE_THRESHOLD = 3e3;
+    this.filesToUpload = [];
     this.optionsProctoring = optionsProctoring;
     this.proctoringSession = proctoringSession;
     this.paramsConfig = paramsConfig;
@@ -18351,7 +19258,7 @@ var NoiseRecorder = class {
     }
   }
   async stopSoundRecord() {
-    var _a2;
+    var _a2, _b;
     if (!this.recordingInProgress && this.recordingChunks.length === 0) return;
     this.recordingEndTime = Date.now() - (((_a2 = this.cameraRecorder.getStartTime()) == null ? void 0 : _a2.getTime()) || 0);
     if (this.optionsProctoring.proctoringType !== "REALTIME") return;
@@ -18365,7 +19272,33 @@ var NoiseRecorder = class {
         type: "audio/wav"
       }
     );
-    this.uploadRecord(file);
+    let filesToSend = [...this.filesToUpload];
+    for (const myFile of filesToSend) {
+      try {
+        await ((_b = this.upload) == null ? void 0 : _b.upload(
+          {
+            file: myFile
+          },
+          this.backendToken
+        ));
+        this.filesToUpload.splice(this.filesToUpload.indexOf(myFile), 1);
+      } catch (error) {
+        break;
+      }
+    }
+    try {
+      if (file && this.upload && this.backendToken) {
+        this.upload.upload(
+          {
+            file
+          },
+          this.backendToken
+        );
+      }
+    } catch (error) {
+      console.log("error Noise recorder adicionando na fila", error);
+      this.filesToUpload.push(file);
+    }
     this.recordingChunks = [];
     this.recordingInProgress = false;
   }
@@ -18379,16 +19312,6 @@ var NoiseRecorder = class {
     a3.click();
     window.URL.revokeObjectURL(url);
   }
-  uploadRecord(file) {
-    if (file && this.upload && this.backendToken) {
-      this.upload.upload(
-        {
-          file
-        },
-        this.backendToken
-      );
-    }
-  }
   // CLASSIFIER -< Media Pipe
   // Verify if has speech in the classifier array
   hasDesiredResult(array) {
@@ -18495,7 +19418,8 @@ registerProcessor("audio-processor", AudioProcessor);
 `;
 
 // src/new-flow/recorders/ScreenRecorder.ts
-var import_fix_webm_duration2 = __toESM(require_fix_webm_duration());
+var pkg2 = require_fix_webm_duration();
+var fixWebmDuration2 = pkg2.default || pkg2;
 var ScreenRecorder = class {
   constructor(options) {
     this.blobs = [];
@@ -18591,7 +19515,7 @@ var ScreenRecorder = class {
     const rawBlob = new Blob(this.blobs, {
       type: "video/webm"
     });
-    const fixedBlob = await (0, import_fix_webm_duration2.default)(rawBlob, this.duration);
+    const fixedBlob = await fixWebmDuration2(rawBlob, this.duration);
     const file = new File(
       [fixedBlob],
       `EP_${session.id}_screen_0.webm`,
@@ -18696,14 +19620,6 @@ function getGeolocation() {
   });
 }
 
-// src/utils/verifyVersion.ts
-function versionVerify() {
-  const agentStr = window.navigator.userAgent.split("SEB/");
-  if (agentStr.length > 1)
-    return agentStr[1];
-  else return "1.0.0.0";
-}
-
 // src/proctoring/Auth.ts
 var Auth = class {
   constructor(cpf, backend) {
@@ -21697,7 +22613,8 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
     this.onRealtimeAlertsCallback = onRealtimeAlertsCallback;
     this.backend = new BackendService({
       type: (context == null ? void 0 : context.type) || "prod",
-      token: context.token
+      token: context.token,
+      isRealtime: false
     });
     this.currentStep = -1 /* WAITING */;
   }
@@ -22430,6 +23347,12 @@ var Proctoring = class {
     this.serviceType = "Upload" /* Upload */;
     this.onStopSharingScreenCallback = () => {
     };
+    /** Callback notificando que o usuário saiu do browser (minimizou/trocou de aba) */
+    this.onVisibilityLostCallback = () => {
+    };
+    /** Callback notificando que o usuário retornou ao browser */
+    this.onVisibilityRestoredCallback = () => {
+    };
     this.onLostFocusCallback = () => {
     };
     this.onLostFocusAlertRecorderCallback = (response) => {
@@ -22445,13 +23368,16 @@ var Proctoring = class {
       await this.internalOnRealtimeAlerts(response);
       return;
     };
+    this.realtimeAlertsToSend = [];
     this.onBufferSizeErrorCallback = (cameraStream) => {
       return;
     };
     var _a2;
     this.backend = new BackendService({
       type: context.type || "prod",
-      token: context.token
+      token: context.token,
+      isRealtime: false
+      // Default false, atualizado no start() via backend.setRealtime()
     });
     this.repository = new IndexDbSessionRepository("EasyProctorDb", "exams2");
     this.repositoryDevices = new IndexDbSessionRepository(
@@ -22461,6 +23387,12 @@ var Proctoring = class {
     ((_a2 = this.context.credentials) == null ? void 0 : _a2.cpf) && (this.auth = new Auth(this.context.credentials.cpf, this.backend));
     this.appChecker = new ExternalCameraChecker(this.context, (response) => this.onRealtimeAlertsCallback(response));
   }
+  setOnVisibilityLostCallback(cb) {
+    this.onVisibilityLostCallback = cb;
+  }
+  setOnVisibilityRestoredCallback(cb) {
+    this.onVisibilityRestoredCallback = cb;
+  }
   setOnStopSharingScreenCallback(cb) {
     this.onStopSharingScreenCallback = async () => {
       var _a2, _b, _c2, _d;
@@ -22540,6 +23472,8 @@ var Proctoring = class {
         return 25 /* FocusOff */;
       case "focus":
         return 25 /* FocusOff */;
+      case "error_upload_package":
+        return 44 /* RealtimeOffline */;
       default:
         return null;
     }
@@ -22580,19 +23514,53 @@ var Proctoring = class {
     };
     await verifyFace(1);
   }
+  async sendPendingRealtimeAlerts() {
+    let alertsToSend = [...this.realtimeAlertsToSend];
+    for (const alert of alertsToSend) {
+      try {
+        if (alert.status === "ALERT") {
+          await this.backend.startRealtimeAlert({
+            proctoringId: this.proctoringId,
+            begin: alert.begin,
+            end: alert.end,
+            alert: this.convertRealtimeCategoryToAlertCategory(alert.category)
+          });
+        } else if (alert.status === "OK") {
+          await this.stopRealtimeAlert(alert);
+        }
+        this.realtimeAlertsToSend.splice(this.realtimeAlertsToSend.indexOf(alert), 1);
+      } catch (error) {
+        console.log("error sendPendingRealtimeAlerts", error);
+        this.realtimeAlertsToSend.push(alert);
+        break;
+      }
+    }
+  }
   async internalOnRealtimeAlerts(response) {
-    if (this.sessionOptions.proctoringType === "REALTIME" && (response.type === "face_detection_on_stream" || response.type === "person_detection_on_stream" || response.type === "lost_focus" || response.type === "focus")) {
+    if (this.sessionOptions.proctoringType === "REALTIME" && (response.type === "face_detection_on_stream" || response.type === "person_detection_on_stream" || response.type === "lost_focus" || response.type === "focus" || response.type === "error_upload_package")) {
+      await this.sendPendingRealtimeAlerts();
       if (response.status === "ALERT") {
         if (this.allRecorders.cameraRecorder.stopped) return;
-        await this.backend.startRealtimeAlert({
-          proctoringId: this.proctoringId,
-          begin: response.begin,
-          end: response.end,
-          alert: this.convertRealtimeCategoryToAlertCategory(response.category)
-        });
+        try {
+          await this.backend.startRealtimeAlert({
+            proctoringId: this.proctoringId,
+            begin: response.begin,
+            end: response.end,
+            alert: this.convertRealtimeCategoryToAlertCategory(response.category)
+          });
+        } catch (error) {
+          console.log("error startRealtimeAlert " + response.category);
+          console.log("error startRealtimeAlert adicionando na fila", error);
+          this.realtimeAlertsToSend.push(response);
+        }
       } else if (response.status === "OK") {
         if (this.allRecorders.cameraRecorder.stopped && response.description !== "face_stop") return;
-        await this.stopRealtimeAlert(response);
+        try {
+          await this.stopRealtimeAlert(response);
+        } catch (error) {
+          console.log("error stopRealtimeAlert adicionando na fila", error);
+          this.realtimeAlertsToSend.push(response);
+        }
       }
     }
   }
@@ -22600,8 +23568,8 @@ var Proctoring = class {
     this.setOnLostFocusAlertRecorderCallback();
     this.setOnFocusAlertRecorderCallback();
     this.onRealtimeAlertsCallback = async (response) => {
-      await this.internalOnRealtimeAlerts(response);
       options.data && options.data(response);
+      await this.internalOnRealtimeAlerts(response);
     };
   }
   setOnBufferSizeErrorCallback(cb) {
@@ -22697,8 +23665,10 @@ var Proctoring = class {
       await this.repositoryDevices.save({ ...devices, id: "devices" });
       this.sessionOptions = { ...getDefaultProctoringOptions, ...options };
       this.videoOptions = validatePartialVideoOptions(_videoOptions);
+      if (this.sessionOptions.proctoringType === "REALTIME") {
+        this.backend.setRealtime(true);
+      }
       await this.initConfig(options.useGeolocation);
-      await this.verifyBrowser();
       this.sessionOptions.captureScreen && await this.verifyMultipleMonitors(this.sessionOptions);
       try {
         if (options == null ? void 0 : options.useSpyScan) {
@@ -22756,6 +23726,20 @@ 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();
@@ -22835,6 +23819,7 @@ Error: ${error}`
       this.spyCam && this.spyCam.stopCheckSpyCam();
       this.appChecker && await this.appChecker.disconnectWebSocket();
       await this.recorder.saveAllOnSession();
+      await this.sendPendingRealtimeAlerts();
       await this.repository.save(this.proctoringSession);
       let uploader;
       let uploaderServices;
@@ -23119,7 +24104,8 @@ var _SignTerm = class _SignTerm {
   constructor(context) {
     this.backend = new BackendService({
       type: (context == null ? void 0 : context.type) || "prod",
-      token: context.token
+      token: context.token,
+      isRealtime: false
     });
   }
   async signInTerms() {
@@ -23349,6 +24335,8 @@ function useProctoring(proctoringOptions, enviromentConfig = "prod") {
   const onBufferSizeError = proctoring.setOnBufferSizeErrorCallback.bind(proctoring);
   const onStopSharingScreen = proctoring.setOnStopSharingScreenCallback.bind(proctoring);
   const onRealtimeAlerts = proctoring.onRealtimeAlerts.bind(proctoring);
+  const onVisibilityLost = proctoring.setOnVisibilityLostCallback.bind(proctoring);
+  const onVisibilityRestored = proctoring.setOnVisibilityRestoredCallback.bind(proctoring);
   const signInTerms = signTerm.signInTerms.bind(signTerm);
   const checkDevices = checker.checkDevices.bind(checker);
   const checkExternalCamera = proctoring.appChecker.checkExternalCamera.bind(proctoring.appChecker);
@@ -23386,7 +24374,9 @@ function useProctoring(proctoringOptions, enviromentConfig = "prod") {
     startExternalCameraSession,
     takeExternalCameraPicture,
     goToExternalCameraPositionStep,
-    startExternalCameraTransmission
+    startExternalCameraTransmission,
+    onVisibilityLost,
+    onVisibilityRestored
   };
 }