@neofaceid/web-sdk 1.4.0 → 1.6.0

package/dist/neoface-id-sdk.es.js

@@ -4,6 +4,7 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
+var _a;
 import require$$0$1, { useRef, useState, useCallback, useReducer, useEffect } from "react";
 import require$$0 from "react-dom";
 import * as faceapi from "face-api.js";
@@ -1006,7 +1007,7 @@ const useCamera = () => {
   };
   const startCamera = useCallback(
     async (constraints) => {
-      var _a;
+      var _a2;
       console.log("🎬 [useCamera] startCamera chamado", {
         hasExistingStream: !!streamRef.current,
         isInitializing: isInitializingRef.current
@@ -1048,7 +1049,7 @@ const useCamera = () => {
           console.log("📋 [useCamera] Detalhes do erro:", {
             name: error.name,
             message: error.message,
-            stack: (_a = error.stack) == null ? void 0 : _a.substring(0, 200)
+            stack: (_a2 = error.stack) == null ? void 0 : _a2.substring(0, 200)
           });
           if (error.name === "NotAllowedError" || error.name === "PermissionDeniedError") {
             throw new CameraPermissionDenied(
@@ -1117,6 +1118,7 @@ var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
   ErrorType2["PERSON_NOT_FOUND"] = "PersonNotFoundError";
   ErrorType2["INITIALIZATION_ERROR"] = "InitializationError";
   ErrorType2["CAMERA_ERROR"] = "CameraError";
+  ErrorType2["NO_CAMERA"] = "NoCameraError";
   ErrorType2["CAPTURE_ERROR"] = "CaptureError";
   ErrorType2["NOT_FOUND"] = "NotFoundError";
   ErrorType2["UNKNOWN"] = "UnknownError";
@@ -1135,10 +1137,11 @@ class NeoFaceError extends Error {
     this.type = type;
   }
 }
-const API_BASE_URL = "https://core.neofaceid.com.br";
+const API_BASE_URL = ((_a = { "BASE_URL": "/", "MODE": "production", "DEV": false, "PROD": true, "SSR": false }) == null ? void 0 : _a.VITE_API_BASE_URL) || "http://localhost:8000";
 const REQUEST_TIMEOUT = 1e4;
 const ensureSecureContext = () => {
-  if (!window.isSecureContext) {
+  const isLocalhost = window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1" || window.location.hostname === "";
+  if (!window.isSecureContext && !isLocalhost) {
     throw new NeoFaceError(
       "Secure context (HTTPS) is required for this operation",
       ErrorType.NETWORK
@@ -1184,7 +1187,7 @@ const validateToken = async (applicationToken) => {
   ensureSecureContext();
   const controller = createTimeoutController();
   try {
-    const response = await fetch(`${API_BASE_URL}/api/v1/external/auth/validate-token/`, {
+    const response = await fetch(`${API_BASE_URL}/api/v1/auth/application/validate_token/`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1444,7 +1447,7 @@ const recognize = async (image, applicationToken) => {
   }
 };
 const loginWithBiometric$1 = async (image, applicationToken) => {
-  var _a, _b, _c, _d, _e;
+  var _a2, _b, _c, _d, _e;
   ensureSecureContext();
   const controller = createTimeoutController();
   const compressedImage = await compressImage(image);
@@ -1474,7 +1477,7 @@ const loginWithBiometric$1 = async (image, applicationToken) => {
       accessToken: data.accessToken,
       alias: data.alias,
       user: {
-        id: ((_a = data.user) == null ? void 0 : _a.id) || "",
+        id: ((_a2 = data.user) == null ? void 0 : _a2.id) || "",
         email: ((_b = data.user) == null ? void 0 : _b.email) || "",
         role: ((_c = data.user) == null ? void 0 : _c.role) || "",
         validated: ((_d = data.user) == null ? void 0 : _d.validated) || false,
@@ -1526,7 +1529,7 @@ const recognizeBiometric = async (image, applicationToken, livenessCheck = true,
     const data = await response.json();
     return {
       success: data.success,
-      personId: data.person_id,
+      // personId is intentionally NOT returned for security reasons
       confidenceScore: data.confidence_score,
       accessToken: data.access_token,
       payload: data.payload
@@ -1590,7 +1593,8 @@ const simpleIdentification = async (documentType, documentNumber, applicationTok
     throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK_ERROR);
   }
 };
-const recognizeByPurpose = async (image, applicationToken, purpose, confidenceThreshold = 0.8) => {
+const recognizeByPurpose = async (image, applicationToken, purpose, confidenceThreshold = 0.8, signature, sessionData) => {
+  var _a2;
   ensureSecureContext();
   const controller = createTimeoutController();
   const compressedImage = await compressImage(image);
@@ -1604,18 +1608,22 @@ const recognizeByPurpose = async (image, applicationToken, purpose, confidenceTh
     reader.readAsDataURL(compressedImage);
   });
   try {
+    const requestBody = {
+      biometric_data: base64Image,
+      type_of_identification: "FACE",
+      purpose,
+      confidence_threshold: confidenceThreshold
+    };
+    if (signature) {
+      requestBody.signature = signature;
+    }
     const response = await fetch(`${API_BASE_URL}/api/v1/external/recognition/purpose/`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         "X-App-Token": applicationToken
       },
-      body: JSON.stringify({
-        biometric_data: base64Image,
-        type_of_identification: "FACE",
-        purpose,
-        confidence_threshold: confidenceThreshold
-      }),
+      body: JSON.stringify(requestBody),
       signal: controller.signal
     });
     if (!response.ok) {
@@ -1627,10 +1635,16 @@ const recognizeByPurpose = async (image, applicationToken, purpose, confidenceTh
     const data = await response.json();
     return {
       success: data.success,
-      personId: data.person_id,
+      personName: data.person_name || ((_a2 = data.person) == null ? void 0 : _a2.name),
+      email: data.email || (sessionData == null ? void 0 : sessionData.email),
+      cpf: data.cpf || (sessionData == null ? void 0 : sessionData.cpf),
       confidenceScore: data.confidence_score,
       accessToken: data.access_token,
-      payload: data.payload
+      payload: data.payload,
+      // Return signature and sessionId for external integrations
+      signature,
+      sessionId: sessionData == null ? void 0 : sessionData.sessionId
+      // Note: personId is intentionally NOT returned for security reasons
     };
   } catch (error) {
     if (error instanceof Error) {
@@ -1687,6 +1701,7 @@ const registerPersonWithoutFace = async (personData, applicationToken) => {
   }
 };
 const registerPersonWithBiometric = async (personData, facePhotos, applicationToken) => {
+  var _a2, _b, _c, _d, _e, _f, _g, _h;
   ensureSecureContext();
   if (!facePhotos || facePhotos.length === 0) {
     throw new NeoFaceError("At least one face photo is required for biometric registration", ErrorType.VALIDATION_ERROR);
@@ -1733,29 +1748,56 @@ const registerPersonWithBiometric = async (personData, facePhotos, applicationTo
       }
       try {
         const errorData = await response.json();
+        if (errorData.errors) {
+          const errorMessages = Object.entries(errorData.errors).map(([field, messages]) => {
+            const fieldName = field === "password" ? "senha" : field === "password_confirm" ? "confirmação de senha" : field;
+            const messageList = Array.isArray(messages) ? messages.join(", ") : String(messages);
+            return `${fieldName}: ${messageList}`;
+          }).join("; ");
+          throw new NeoFaceError(`Erro de validação: ${errorMessages}`, ErrorType.VALIDATION_ERROR);
+        }
         if (errorData.error === "fraud_detected") {
           throw new NeoFaceError("Fraud detected in biometric images. Registration blocked.", ErrorType.VALIDATION_ERROR);
         }
-        if (errorData.error === "user_exists") {
+        if (errorData.error === "user_exists" || errorData.error_code === "ALREADY_EXISTS") {
           throw new NeoFaceError("User with this email already exists", ErrorType.VALIDATION_ERROR);
         }
         if (errorData.error === "person_exists") {
           throw new NeoFaceError("Person with this CPF already exists", ErrorType.VALIDATION_ERROR);
         }
-        throw new NeoFaceError(errorData.message || `Server returned status ${response.status}`, ErrorType.NETWORK);
+        const errorMessage = errorData.message || errorData.error || `Server returned status ${response.status}`;
+        throw new NeoFaceError(errorMessage, ErrorType.VALIDATION_ERROR);
       } catch (parseError) {
+        if (parseError instanceof NeoFaceError) {
+          throw parseError;
+        }
         throw new NeoFaceError(`Server returned status ${response.status}`, ErrorType.NETWORK);
       }
     }
     const data = await response.json();
+    if (response.status === 202 && ((_a2 = data.data) == null ? void 0 : _a2.task_id)) {
+      return {
+        success: data.success,
+        message: data.message || "Registration is being processed. You will receive an email when completed.",
+        task_id: data.data.task_id,
+        status: data.data.status || "processing",
+        person_id: void 0,
+        user_id: void 0,
+        person_validated: void 0,
+        face_processing: void 0,
+        onboarding_link: void 0
+      };
+    }
     return {
       success: data.success,
       message: data.message,
-      person_id: data.person_id,
-      user_id: data.user_id,
-      person_validated: data.person_validated,
-      face_processing: data.face_processing,
-      onboarding_link: data.onboarding_link
+      person_id: ((_b = data.data) == null ? void 0 : _b.person_id) || data.person_id,
+      user_id: ((_c = data.data) == null ? void 0 : _c.user_id) || data.user_id,
+      person_validated: ((_d = data.data) == null ? void 0 : _d.person_validated) || data.person_validated,
+      face_processing: ((_e = data.data) == null ? void 0 : _e.face_processing) || data.face_processing,
+      onboarding_link: ((_f = data.data) == null ? void 0 : _f.onboarding_link) || data.onboarding_link,
+      task_id: (_g = data.data) == null ? void 0 : _g.task_id,
+      status: (_h = data.data) == null ? void 0 : _h.status
     };
   } catch (error) {
     if (error instanceof Error) {
@@ -1817,7 +1859,7 @@ const loginWithEmail = async (email, password, applicationToken) => {
   }
 };
 const identifyPerson = async (image, applicationToken) => {
-  var _a, _b;
+  var _a2, _b;
   ensureSecureContext();
   const controller = createTimeoutController();
   const compressedImage = await compressImage(image);
@@ -1853,7 +1895,7 @@ const identifyPerson = async (image, applicationToken) => {
     if (!data.success) {
       throw new NeoFaceError(data.message || "Person identification failed", ErrorType.RECOGNITION_FAILED);
     }
-    const personName = ((_a = data.person) == null ? void 0 : _a.name) || "";
+    const personName = ((_a2 = data.person) == null ? void 0 : _a2.name) || "";
     const birthDateStr = (_b = data.person) == null ? void 0 : _b.birth_date;
     if (!personName) {
       throw new NeoFaceError("Person name not found in response", ErrorType.PERSON_NOT_FOUND);
@@ -1885,6 +1927,79 @@ const identifyPerson = async (image, applicationToken) => {
     throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK_ERROR);
   }
 };
+const registerBiometric = async (personId, faceImage, applicationToken) => {
+  ensureSecureContext();
+  if (!personId) {
+    throw new NeoFaceError("Person ID is required", ErrorType.VALIDATION_ERROR);
+  }
+  if (!faceImage) {
+    throw new NeoFaceError("Face image is required", ErrorType.VALIDATION_ERROR);
+  }
+  const controller = createTimeoutController();
+  const compressedImage = await compressImage(faceImage);
+  const base64Image = await new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const result = reader.result;
+      resolve(result.split(",")[1]);
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(compressedImage);
+  });
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/v1/identity-data/`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-App-Token": applicationToken
+      },
+      body: JSON.stringify({
+        person: personId,
+        type_of_identification: "FACE",
+        biometric_data: base64Image
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        throw new NeoFaceError("Invalid or expired application token, or insufficient permissions", ErrorType.INVALID_TOKEN);
+      }
+      if (response.status === 400) {
+        try {
+          const errorData = await response.json();
+          const errorMessage = errorData.message || errorData.error || "Invalid biometric data";
+          throw new NeoFaceError(errorMessage, ErrorType.VALIDATION_ERROR);
+        } catch (parseError) {
+          if (parseError instanceof NeoFaceError) {
+            throw parseError;
+          }
+          throw new NeoFaceError("Invalid biometric data", ErrorType.VALIDATION_ERROR);
+        }
+      }
+      throw new NeoFaceError(`Server returned status ${response.status}`, ErrorType.NETWORK);
+    }
+    const data = await response.json();
+    return {
+      success: true,
+      message: "Biometric data registered successfully",
+      identity_data_id: data.id,
+      type_of_identification: data.type_of_identification,
+      have_biometric_data: data.have_biometric_data,
+      created_at: data.created_at
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new NeoFaceError("Request timed out", ErrorType.NETWORK);
+      }
+      if (error instanceof NeoFaceError) {
+        throw error;
+      }
+      throw new NeoFaceError(error.message, ErrorType.NETWORK);
+    }
+    throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK_ERROR);
+  }
+};
 const modalReducer$1 = (state, action) => {
   switch (action.type) {
     case "PERMISSION_GRANTED":
@@ -2129,8 +2244,8 @@ function FaceCaptureModal({ accessToken, onClose, onSuccess }) {
       canvasRef.current.height = videoRef.current.videoHeight;
       context.drawImage(videoRef.current, 0, 0, canvasRef.current.width, canvasRef.current.height);
       const blob = await new Promise((resolve, reject) => {
-        var _a;
-        (_a = canvasRef.current) == null ? void 0 : _a.toBlob(
+        var _a2;
+        (_a2 = canvasRef.current) == null ? void 0 : _a2.toBlob(
           (b) => {
             if (b)
               resolve(b);
@@ -2267,8 +2382,8 @@ function BiometricRegistrationModal({
   onClose,
   onSuccess,
   onError,
-  useRealApi = false
-  // 🚀 Por padrão, modo simulado
+  useRealApi = true
+  // Sempre usa API real em produção
 }) {
   const videoRef = useRef(null);
   const canvasRef = useRef(null);
@@ -2530,8 +2645,8 @@ function BiometricRegistrationModal({
       }
     };
     const startTimer = setTimeout(() => {
-      var _a;
-      if (isRunning && ((_a = videoRef.current) == null ? void 0 : _a.readyState) === 4) {
+      var _a2;
+      if (isRunning && ((_a2 = videoRef.current) == null ? void 0 : _a2.readyState) === 4) {
         detectFace2();
       }
     }, 1e3);
@@ -2592,60 +2707,19 @@ function BiometricRegistrationModal({
   };
   const processRegistration = async (photos) => {
     try {
-      if (useRealApi) {
-        console.log("🚀 Fazendo requisição REAL ao backend de produção...");
-        const result2 = await registerPersonWithBiometric(personData, photos, applicationToken);
-        const adaptedResult = {
-          success: result2.success,
-          message: result2.message,
-          person_id: result2.person_id,
-          user_id: result2.user_id,
-          person_validated: result2.person_validated,
-          face_processing: result2.face_processing,
-          onboarding_link: result2.onboarding_link
-        };
-        dispatch({ type: "SUCCESS" });
-        onSuccess(adaptedResult);
-        return;
-      }
-      console.log("🎭 Usando modo SIMULADO para testes...");
-      const facePhotosBase64 = await Promise.all(
-        photos.map(async (photo) => {
-          return new Promise((resolve, reject) => {
-            const reader = new FileReader();
-            reader.onload = () => {
-              const result2 = reader.result;
-              resolve(result2);
-            };
-            reader.onerror = reject;
-            reader.readAsDataURL(photo);
-          });
-        })
-      );
-      await new Promise((resolve) => setTimeout(resolve, 2e3));
-      const result = {
-        success: true,
-        message: "Registro biométrico realizado com sucesso",
-        person_id: "test-person-123",
-        user_id: "test-user-456",
-        person_validated: true,
-        face_processing: {
-          total_photos_captured: photos.length,
-          photo_sizes: photos.map((p, i) => ({
-            photo_index: i + 1,
-            size_kb: Math.round(p.size / 1024)
-          })),
-          // Mostra apenas preview dos primeiros 50 caracteres de cada foto em base64
-          photos_preview: facePhotosBase64.map((b64, i) => ({
-            photo_index: i + 1,
-            format: "data:image/jpeg;base64,...",
-            preview: b64.substring(0, 50) + "...",
-            full_length: b64.length
-          }))
-        }
+      console.log("🚀 Fazendo requisição ao backend...");
+      const result = await registerPersonWithBiometric(personData, photos, applicationToken);
+      const adaptedResult = {
+        success: result.success,
+        message: result.message,
+        person_id: result.person_id,
+        user_id: result.user_id,
+        person_validated: result.person_validated,
+        face_processing: result.face_processing,
+        onboarding_link: result.onboarding_link
       };
       dispatch({ type: "SUCCESS" });
-      onSuccess(result);
+      onSuccess(adaptedResult);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Erro desconhecido";
       dispatch({ type: "ERROR", message: errorMessage });
@@ -3529,21 +3603,21 @@ let BiometricCaptureModal$1 = class BiometricCaptureModal2 {
     const cancelBtn = this.modal.querySelector(".neofaceid-cancel-btn");
     const captureBtn = this.modal.querySelector(".neofaceid-capture-btn");
     closeBtn == null ? void 0 : closeBtn.addEventListener("click", () => {
-      var _a, _b;
+      var _a2, _b;
       this.close();
-      (_b = (_a = this.options).onCancel) == null ? void 0 : _b.call(_a);
+      (_b = (_a2 = this.options).onCancel) == null ? void 0 : _b.call(_a2);
     });
     cancelBtn == null ? void 0 : cancelBtn.addEventListener("click", () => {
-      var _a, _b;
+      var _a2, _b;
       this.close();
-      (_b = (_a = this.options).onCancel) == null ? void 0 : _b.call(_a);
+      (_b = (_a2 = this.options).onCancel) == null ? void 0 : _b.call(_a2);
     });
     captureBtn == null ? void 0 : captureBtn.addEventListener("click", () => {
       this.captureImage();
     });
     this.modal.addEventListener("click", (e) => {
-      var _a, _b, _c;
-      if (e.target === ((_a = this.modal) == null ? void 0 : _a.querySelector(".neofaceid-modal-overlay"))) {
+      var _a2, _b, _c;
+      if (e.target === ((_a2 = this.modal) == null ? void 0 : _a2.querySelector(".neofaceid-modal-overlay"))) {
         this.close();
         (_c = (_b = this.options).onCancel) == null ? void 0 : _c.call(_b);
       }
@@ -4000,7 +4074,7 @@ function BiometricStatusOverlayComponent({ status, onClose }) {
           alt: "NeoFaceId",
           className: `neofaceid-logo ${status === "verifying" ? "pulsing" : ""}`,
           onError: (e) => {
-            var _a;
+            var _a2;
             const img = e.target;
             img.style.display = "none";
             const fallback = document.createElement("div");
@@ -4011,7 +4085,7 @@ function BiometricStatusOverlayComponent({ status, onClose }) {
                       </svg>
                     `;
             fallback.style.cssText = "width: 80px; height: 80px; display: flex; align-items: center; justify-content: center;";
-            (_a = img.parentElement) == null ? void 0 : _a.appendChild(fallback);
+            (_a2 = img.parentElement) == null ? void 0 : _a2.appendChild(fallback);
           }
         }
       ) }),
@@ -4680,6 +4754,116 @@ class EmailPasswordModal {
 }
 const MAX_ATTEMPTS = 3;
 const RETRY_DELAY = 500;
+async function captureFaceSilently() {
+  return new Promise((resolve, reject) => {
+    const video = document.createElement("video");
+    video.style.position = "fixed";
+    video.style.top = "-9999px";
+    video.style.left = "-9999px";
+    video.style.width = "1px";
+    video.style.height = "1px";
+    video.style.opacity = "0";
+    video.setAttribute("autoplay", "");
+    video.setAttribute("muted", "");
+    video.setAttribute("playsinline", "");
+    const canvas = document.createElement("canvas");
+    canvas.style.display = "none";
+    let stream = null;
+    let faceDetectionAttempts = 0;
+    const MAX_FACE_DETECTION_ATTEMPTS = 10;
+    const cleanup = () => {
+      if (stream) {
+        stream.getTracks().forEach((track) => track.stop());
+      }
+      if (video.parentElement) {
+        video.parentElement.removeChild(video);
+      }
+      if (canvas.parentElement) {
+        canvas.parentElement.removeChild(canvas);
+      }
+    };
+    document.body.appendChild(video);
+    document.body.appendChild(canvas);
+    navigator.mediaDevices.getUserMedia({
+      video: {
+        width: { ideal: 640 },
+        height: { ideal: 480 },
+        facingMode: "user"
+      },
+      audio: false
+    }).then((mediaStream) => {
+      stream = mediaStream;
+      video.srcObject = stream;
+      video.play();
+      const tryCapture = () => {
+        if (!video.videoWidth || !video.videoHeight) {
+          if (faceDetectionAttempts < MAX_FACE_DETECTION_ATTEMPTS) {
+            faceDetectionAttempts++;
+            setTimeout(tryCapture, 100);
+            return;
+          }
+          cleanup();
+          reject(new NeoFaceError("Câmera não está pronta", ErrorType.CAMERA_ERROR));
+          return;
+        }
+        canvas.width = video.videoWidth;
+        canvas.height = video.videoHeight;
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+          cleanup();
+          reject(new Error("Failed to get canvas context"));
+          return;
+        }
+        const detectFace2 = async () => {
+          try {
+            const detection = await faceapi.detectSingleFace(
+              video,
+              new faceapi.TinyFaceDetectorOptions({ inputSize: 160, scoreThreshold: 0.4 })
+            );
+            return !!detection;
+          } catch {
+            return false;
+          }
+        };
+        detectFace2().then((hasFace) => {
+          if (!hasFace && faceDetectionAttempts < MAX_FACE_DETECTION_ATTEMPTS) {
+            faceDetectionAttempts++;
+            setTimeout(tryCapture, 200);
+            return;
+          }
+          ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+          canvas.toBlob(
+            (blob) => {
+              cleanup();
+              if (blob) {
+                resolve(blob);
+              } else {
+                reject(new Error("Failed to capture image"));
+              }
+            },
+            "image/jpeg",
+            0.85
+          );
+        });
+      };
+      video.onloadedmetadata = () => {
+        setTimeout(tryCapture, 800);
+      };
+      video.onerror = () => {
+        cleanup();
+        reject(new NeoFaceError("Erro ao acessar câmera", ErrorType.CAMERA_ERROR));
+      };
+    }).catch((error) => {
+      cleanup();
+      reject(
+        new NeoFaceError(
+          "Não foi possível acessar a câmera: " + error.message,
+          ErrorType.CAMERA_ERROR
+        )
+      );
+    });
+  });
+}
 async function detectFaceContinuously(video, minDetectionTime = 3e3, detectionInterval = 200) {
   return new Promise((resolve) => {
     let faceDetectedCount = 0;
@@ -4902,6 +5086,11 @@ async function executeBiometricLoginFlow(options) {
     tryLogin();
   }, 300);
 }
+const biometricLoginFlow = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  captureFaceSilently,
+  executeBiometricLoginFlow
+}, Symbol.toStringTag, { value: "Module" }));
 async function startFaceLogin(options) {
   try {
     const isValidToken = await validateToken(options.applicationToken);
@@ -5229,8 +5418,8 @@ const biometricDetection = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.
   initializeBiometricDetection,
   isAdvancedDetectionAvailable
 }, Symbol.toStringTag, { value: "Module" }));
-const VERSION = "1.4.0";
-const RELEASE_DATE = "2025-11-23";
+const VERSION = "1.6.0";
+const RELEASE_DATE = "2025-12-01";
 class OnboardingCaptureModal {
   constructor(options) {
     __publicField(this, "overlay", null);
@@ -5454,6 +5643,284 @@ const startOnboarding = async (options) => {
     onError(new NeoFaceError(message, ErrorType.UNKNOWN));
   }
 };
+class NeoFaceID {
+  /**
+   * Creates a new NeoFaceID instance
+   * @param config Configuration object
+   * @throws NeoFaceError if signature format is invalid
+   */
+  constructor(config) {
+    __publicField(this, "appToken");
+    __publicField(this, "baseUrl");
+    __publicField(this, "signature");
+    __publicField(this, "sessionData");
+    var _a2;
+    this.appToken = config.appToken;
+    this.baseUrl = config.baseUrl || (((_a2 = { "BASE_URL": "/", "MODE": "production", "DEV": false, "PROD": true, "SSR": false }) == null ? void 0 : _a2.VITE_API_BASE_URL) || "http://localhost:8000");
+    this.signature = config.signature;
+    this.sessionData = config.sessionData;
+    if (this.signature && !this.validateSignatureFormat(this.signature)) {
+      throw new NeoFaceError(
+        "Invalid signature format. Expected HMAC-SHA256 hex string (minimum 64 characters)",
+        ErrorType.VALIDATION_ERROR
+      );
+    }
+    if (this.sessionData) {
+      if (!this.sessionData.email || !this.sessionData.cpf || !this.sessionData.sessionId) {
+        throw new NeoFaceError(
+          "Session data must include email, cpf, and sessionId",
+          ErrorType.VALIDATION_ERROR
+        );
+      }
+    }
+  }
+  /**
+   * Validates the format of a signature
+   * HMAC-SHA256 produces a 64-character hexadecimal string
+   * @param signature The signature to validate
+   * @returns true if valid, false otherwise
+   */
+  validateSignatureFormat(signature) {
+    return /^[a-f0-9]{64,}$/i.test(signature);
+  }
+  /**
+   * Captures multiple face frames for biometric recognition
+   * @param options Capture options
+   * @returns Promise that resolves to an array of image blobs
+   * @throws NeoFaceError if capture fails
+   */
+  async captureFaceFrames(options) {
+    const { numFrames, livenessCheck } = options;
+    if (numFrames < 1 || numFrames > 10) {
+      throw new NeoFaceError(
+        "Number of frames must be between 1 and 10",
+        ErrorType.VALIDATION_ERROR
+      );
+    }
+    const frames = [];
+    try {
+      const { captureFaceSilently: captureFaceSilently2 } = await Promise.resolve().then(() => biometricLoginFlow);
+      for (let i = 0; i < numFrames; i++) {
+        const frame = await captureFaceSilently2();
+        frames.push(frame);
+        if (livenessCheck && i < numFrames - 1) {
+          await new Promise((resolve) => setTimeout(resolve, 300));
+        }
+      }
+      return frames;
+    } catch (error) {
+      if (error instanceof NeoFaceError) {
+        throw error;
+      }
+      throw new NeoFaceError(
+        `Failed to capture face frames: ${error instanceof Error ? error.message : "Unknown error"}`,
+        ErrorType.CAPTURE_ERROR
+      );
+    }
+  }
+  /**
+   * Performs login recognition using biometric data
+   * 
+   * This method is designed for external integrations that require
+   * signature validation and session management.
+   * 
+   * @param options Recognition options
+   * @returns Promise that resolves to recognition result
+   * @throws NeoFaceError if recognition fails
+   * 
+   * @example
+   * ```typescript
+   * const result = await sdk.loginRecognition({
+   *   biometricData: await sdk.captureFaceFrames({
+   *     numFrames: 5,
+   *     livenessCheck: true
+   *   }),
+   *   typeOfIdentification: 'FACE',
+   *   purpose: 'LOGIN',
+   *   confidenceThreshold: 0.8
+   * });
+   * 
+   * // Result includes signature and sessionId for callback validation
+   * console.log(result.signature, result.sessionId);
+   * ```
+   */
+  async loginRecognition(options) {
+    const {
+      biometricData,
+      typeOfIdentification,
+      purpose,
+      confidenceThreshold = 0.8
+    } = options;
+    const imageBlobs = Array.isArray(biometricData) ? biometricData : [biometricData];
+    if (imageBlobs.length === 0) {
+      throw new NeoFaceError(
+        "At least one biometric data frame is required",
+        ErrorType.VALIDATION_ERROR
+      );
+    }
+    const primaryImage = imageBlobs[0];
+    try {
+      const result = await recognizeByPurpose(
+        primaryImage,
+        this.appToken,
+        purpose,
+        confidenceThreshold,
+        this.signature,
+        this.sessionData
+      );
+      if (!result.success) {
+        throw new NeoFaceError(
+          "Recognition failed",
+          ErrorType.RECOGNITION_FAILED
+        );
+      }
+      if (!result.personName || !result.email || !result.cpf) {
+        throw new NeoFaceError(
+          "Incomplete recognition result: missing personName, email, or cpf",
+          ErrorType.RECOGNITION_FAILED
+        );
+      }
+      return {
+        success: true,
+        personName: result.personName,
+        email: result.email,
+        cpf: result.cpf,
+        signature: result.signature,
+        sessionId: result.sessionId,
+        confidenceScore: result.confidenceScore,
+        accessToken: result.accessToken
+      };
+    } catch (error) {
+      if (error instanceof NeoFaceError) {
+        throw error;
+      }
+      throw new NeoFaceError(
+        `Login recognition failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        ErrorType.RECOGNITION_FAILED
+      );
+    }
+  }
+}
+const PHOTO_INSTRUCTIONS = [
+  "Olhe diretamente para a câmera",
+  "Vire levemente a cabeça para a esquerda",
+  "Vire levemente a cabeça para a direita",
+  "Mostre o polegar para cima (👍) e olhe para a câmera"
+];
+const TOTAL_PHOTOS = 4;
+const authorizeOperation = async (applicationToken, cpf, options) => {
+  if (!applicationToken) {
+    throw new NeoFaceError("Application token is required", ErrorType.VALIDATION_ERROR);
+  }
+  if (!cpf) {
+    throw new NeoFaceError("CPF is required", ErrorType.VALIDATION_ERROR);
+  }
+  const cpfClean = cpf.replace(/\D/g, "");
+  if (cpfClean.length !== 11) {
+    throw new NeoFaceError("Invalid CPF format", ErrorType.VALIDATION_ERROR);
+  }
+  const capturedPhotos = [];
+  const captureDelay = (options == null ? void 0 : options.captureDelay) || 2e3;
+  try {
+    if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+      throw new NeoFaceError("Camera not available", ErrorType.NO_CAMERA);
+    }
+    const stream = await navigator.mediaDevices.getUserMedia({
+      video: {
+        facingMode: "user",
+        width: { ideal: 1280 },
+        height: { ideal: 720 }
+      }
+    });
+    const video = document.createElement("video");
+    video.srcObject = stream;
+    video.autoplay = true;
+    video.playsInline = true;
+    await new Promise((resolve) => {
+      video.onloadedmetadata = () => {
+        video.play();
+        resolve();
+      };
+    });
+    const canvas = document.createElement("canvas");
+    canvas.width = video.videoWidth;
+    canvas.height = video.videoHeight;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      throw new NeoFaceError("Failed to get canvas context", ErrorType.CAPTURE_ERROR);
+    }
+    for (let i = 0; i < TOTAL_PHOTOS; i++) {
+      const instruction = PHOTO_INSTRUCTIONS[i];
+      if (options == null ? void 0 : options.onProgress) {
+        options.onProgress(i + 1, TOTAL_PHOTOS, instruction);
+      }
+      if (i > 0) {
+        await new Promise((resolve) => setTimeout(resolve, captureDelay));
+      }
+      ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+      const blob = await new Promise((resolve, reject) => {
+        canvas.toBlob(
+          (blob2) => {
+            if (blob2) {
+              resolve(blob2);
+            } else {
+              reject(new Error("Failed to capture photo"));
+            }
+          },
+          "image/jpeg",
+          0.9
+        );
+      });
+      capturedPhotos.push(blob);
+      if (options == null ? void 0 : options.onPhotoTaken) {
+        options.onPhotoTaken(i + 1, blob);
+      }
+    }
+    stream.getTracks().forEach((track) => track.stop());
+    const lastPhoto = capturedPhotos[TOTAL_PHOTOS - 1];
+    const sessionData = {
+      cpf: cpfClean,
+      email: "",
+      // Not required for authorization
+      sessionId: `auth_${Date.now()}_${Math.random().toString(36).substring(7)}`
+    };
+    const recognitionResult = await recognizeByPurpose(
+      lastPhoto,
+      applicationToken,
+      "AUTHORIZATION",
+      0.8,
+      // Confidence threshold
+      void 0,
+      // No signature for now
+      sessionData
+    );
+    if (!recognitionResult.success) {
+      throw new NeoFaceError(
+        "Authorization failed: Person not recognized",
+        ErrorType.RECOGNITION_FAILED
+      );
+    }
+    return {
+      success: true,
+      authorizationHash: sessionData.sessionId,
+      // TEMPORARY: Using sessionId as hash
+      name: recognitionResult.personName,
+      birthDate: void 0,
+      // Should come from backend
+      cpf: recognitionResult.cpf || cpfClean,
+      confidenceScore: recognitionResult.confidenceScore,
+      message: "Authorization successful"
+    };
+  } catch (error) {
+    if (error instanceof NeoFaceError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new NeoFaceError(error.message, ErrorType.CAPTURE_ERROR);
+    }
+    throw new NeoFaceError("Unknown error during authorization", ErrorType.UNKNOWN);
+  }
+};
 function start(applicationToken, callbacks) {
   const container = document.createElement("div");
   container.id = "neoface-modal-container";
@@ -5496,8 +5963,8 @@ function startBiometricRegistration(personData, applicationToken, callbacks, opt
     const modalElement = require$$0$1.createElement(BiometricRegistrationModal, {
       personData,
       applicationToken,
-      useRealApi: (options == null ? void 0 : options.useRealApi) || false,
-      // 🚀 Passa a flag para o modal
+      useRealApi: (options == null ? void 0 : options.useRealApi) ?? true,
+      // Sempre usa API real em produção
       onClose: cleanup,
       onSuccess: (result) => {
         cleanup();
@@ -5524,8 +5991,10 @@ export {
   FaceCaptureModal,
   FallbackPrompt,
   NeoFaceError,
+  NeoFaceID,
   RELEASE_DATE,
   VERSION,
+  authorizeOperation,
   biometricLogin,
   biometricLoginWithFallback,
   completeOnboarding,
@@ -5538,6 +6007,7 @@ export {
   recognize,
   recognizeBiometric,
   recognizeByPurpose,
+  registerBiometric,
   registerPersonWithBiometric,
   registerPersonWithoutFace,
   simpleIdentification,