@neofaceid/web-sdk 1.0.18 → 1.1.0

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

@@ -988,6 +988,7 @@ class CameraStream {
 const useCamera = () => {
   const streamRef = useRef(null);
   const [isActive, setIsActive] = useState(false);
+  const isInitializingRef = useRef(false);
   const getOptimalConstraints = () => {
     const isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
       navigator.userAgent
@@ -1005,45 +1006,103 @@ const useCamera = () => {
   };
   const startCamera = useCallback(
     async (constraints) => {
-      if (isActive) {
-        throw new Error("Camera is already active");
+      var _a;
+      console.log("🎬 [useCamera] startCamera chamado", {
+        hasExistingStream: !!streamRef.current,
+        isInitializing: isInitializingRef.current
+      });
+      const existingStream = streamRef.current;
+      if (existingStream) {
+        console.log("⚠️ [useCamera] Câmera já está ativa, retornando stream existente");
+        return existingStream.getStream();
+      }
+      if (isInitializingRef.current) {
+        console.log("⏳ [useCamera] Inicialização já em andamento, aguardando...");
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        const currentStream = streamRef.current;
+        if (currentStream) {
+          console.log("✅ [useCamera] Stream criado por outra chamada, usando-o");
+          return currentStream.getStream();
+        }
       }
+      isInitializingRef.current = true;
       try {
         const mediaConstraints = constraints || getOptimalConstraints();
+        console.log("📹 [useCamera] Solicitando acesso à câmera...", mediaConstraints);
         const stream = await navigator.mediaDevices.getUserMedia(mediaConstraints);
+        console.log("✅ [useCamera] Stream obtido com sucesso:", {
+          tracks: stream.getTracks().length,
+          videoTracks: stream.getVideoTracks().length,
+          active: stream.active
+        });
         const cameraStream = new CameraStream(stream);
         streamRef.current = cameraStream;
         setIsActive(true);
+        isInitializingRef.current = false;
+        console.log("✅ [useCamera] Câmera iniciada com sucesso");
         return stream;
       } catch (error) {
-        if (error instanceof Error && error.name === "NotAllowedError") {
-          throw new CameraPermissionDenied("Camera access was denied by the user");
+        isInitializingRef.current = false;
+        console.error("❌ [useCamera] Erro ao acessar câmera:", error);
+        if (error instanceof Error) {
+          console.log("📋 [useCamera] Detalhes do erro:", {
+            name: error.name,
+            message: error.message,
+            stack: (_a = error.stack) == null ? void 0 : _a.substring(0, 200)
+          });
+          if (error.name === "NotAllowedError" || error.name === "PermissionDeniedError") {
+            throw new CameraPermissionDenied(
+              "Permissão para acessar a câmera foi negada pelo usuário"
+            );
+          }
+          if (error.name === "NotFoundError" || error.name === "DevicesNotFoundError") {
+            throw new Error("Nenhuma câmera foi encontrada no dispositivo");
+          }
+          if (error.name === "NotReadableError" || error.name === "TrackStartError") {
+            throw new Error("A câmera já está sendo usada por outro aplicativo");
+          }
+          if (error.name === "OverconstrainedError" || error.name === "ConstraintNotSatisfiedError") {
+            throw new Error("As configurações solicitadas não são suportadas pela câmera");
+          }
         }
-        throw error;
+        throw new Error(
+          `Erro ao inicializar câmera: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
     },
-    [isActive]
+    []
+    // 🔥 Array vazio - função é criada apenas uma vez
   );
   const stopCamera = useCallback((stream) => {
+    console.log("🛑 [useCamera] Parando câmera...");
     const cameraStream = streamRef.current;
     if (cameraStream && cameraStream.getStream() === stream) {
       cameraStream.stop();
+      console.log("✅ [useCamera] Todas as tracks paradas");
       streamRef.current = null;
       setIsActive(false);
+      isInitializingRef.current = false;
+      console.log("✅ [useCamera] Câmera desligada com sucesso");
     } else {
-      console.warn("Attempted to stop a camera stream that was not started by this hook");
+      console.warn(
+        "⚠️ [useCamera] Tentativa de parar um stream que não foi iniciado por este hook"
+      );
     }
   }, []);
-  useCallback(() => {
+  const cleanup = useCallback(() => {
+    console.log("🧹 [useCamera] Cleanup chamado");
     if (streamRef.current) {
       streamRef.current.stop();
       streamRef.current = null;
       setIsActive(false);
+      isInitializingRef.current = false;
+      console.log("✅ [useCamera] Cleanup concluído");
     }
   }, []);
   return {
     startCamera,
     stopCamera,
+    cleanup,
     isActive
   };
 };
@@ -1051,6 +1110,14 @@ var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
   ErrorType2["NETWORK"] = "NetworkError";
   ErrorType2["INVALID_TOKEN"] = "InvalidTokenError";
   ErrorType2["RECOGNITION_FAILED"] = "RecognitionFailedError";
+  ErrorType2["LOGIN_FAILED"] = "LoginFailedError";
+  ErrorType2["VALIDATION_ERROR"] = "ValidationError";
+  ErrorType2["API_ERROR"] = "ApiError";
+  ErrorType2["PERSON_NOT_FOUND"] = "PersonNotFoundError";
+  ErrorType2["INITIALIZATION_ERROR"] = "InitializationError";
+  ErrorType2["NETWORK_ERROR"] = "NetworkError";
+  ErrorType2["CAMERA_ERROR"] = "CameraError";
+  ErrorType2["CAPTURE_ERROR"] = "CaptureError";
   return ErrorType2;
 })(ErrorType || {});
 class NeoFaceError extends Error {
@@ -1061,11 +1128,14 @@ class NeoFaceError extends Error {
     this.type = type;
   }
 }
-const API_BASE_URL = "https://core.neofaceid.com/v1";
+const API_BASE_URL = "https://core.neofaceid.com.br";
 const REQUEST_TIMEOUT = 1e4;
 const ensureSecureContext = () => {
   if (!window.isSecureContext) {
-    throw new NeoFaceError("Secure context (HTTPS) is required for this operation", ErrorType.NETWORK);
+    throw new NeoFaceError(
+      "Secure context (HTTPS) is required for this operation",
+      ErrorType.NETWORK
+    );
   }
 };
 const createTimeoutController = () => {
@@ -1107,43 +1177,81 @@ const validateToken = async (applicationToken) => {
   ensureSecureContext();
   const controller = createTimeoutController();
   try {
-    const response = await fetch(
-      `${API_BASE_URL}/auth/consumer`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ token: applicationToken }),
-        signal: controller.signal
+    const response = await fetch(`${API_BASE_URL}/api/v1/external/auth/validate-token/`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-App-Token": applicationToken
+      },
+      body: JSON.stringify({}),
+      signal: controller.signal
+    });
+    return response.ok;
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new NeoFaceError("Request timed out", ErrorType.NETWORK_ERROR);
       }
-    );
+      throw new NeoFaceError(error.message, ErrorType.NETWORK_ERROR);
+    }
+    throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK_ERROR);
+  }
+};
+const recognize = async (image, applicationToken) => {
+  ensureSecureContext();
+  const controller = createTimeoutController();
+  const compressedImage = await compressImage(image);
+  try {
+    const formData = new FormData();
+    formData.append("face_frames", compressedImage);
+    const response = await fetch(`${API_BASE_URL}/api/v1/external/recognition/face/`, {
+      method: "POST",
+      headers: {
+        "X-App-Token": applicationToken
+      },
+      body: formData,
+      signal: controller.signal
+    });
     if (!response.ok) {
       if (response.status === 401 || response.status === 403) {
         throw new NeoFaceError("Invalid or expired application token", ErrorType.INVALID_TOKEN);
       }
       throw new NeoFaceError(`Server returned status ${response.status}`, ErrorType.NETWORK);
     }
+    const data = await response.json();
+    if (!data.success) {
+      throw new NeoFaceError(data.message || "Recognition failed", ErrorType.RECOGNITION_FAILED);
+    }
+    return {
+      accessToken: data.accessToken,
+      payload: data.payload
+    };
   } catch (error) {
     if (error instanceof Error) {
       if (error.name === "AbortError") {
         throw new NeoFaceError("Request timed out", ErrorType.NETWORK);
       }
-      throw error;
+      if (error instanceof NeoFaceError) {
+        throw error;
+      }
+      throw new NeoFaceError(error.message, ErrorType.NETWORK);
     }
-    throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK);
+    throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK_ERROR);
   }
 };
-const recognize = async (image, applicationToken) => {
+const loginWithBiometric = async (image, applicationToken) => {
+  var _a, _b, _c, _d, _e;
   ensureSecureContext();
   const controller = createTimeoutController();
   const compressedImage = await compressImage(image);
   try {
     const formData = new FormData();
-    formData.append("image", compressedImage);
-    formData.append("token", applicationToken);
-    const response = await fetch(`${API_BASE_URL}/auth/person/register/liverecognition`, {
+    formData.append("face_frames", compressedImage);
+    const response = await fetch(`${API_BASE_URL}/api/v1/external/auth/login/`, {
       method: "POST",
+      headers: {
+        "X-App-Token": applicationToken
+      },
       body: formData,
       signal: controller.signal
     });
@@ -1155,12 +1263,212 @@ const recognize = async (image, applicationToken) => {
     }
     const data = await response.json();
     if (!data.success) {
-      throw new NeoFaceError(data.message || "Recognition failed", ErrorType.RECOGNITION_FAILED);
+      throw new NeoFaceError(data.message || "Login failed", ErrorType.LOGIN_FAILED);
     }
     return {
+      success: true,
       accessToken: data.accessToken,
+      alias: data.alias,
+      user: {
+        id: ((_a = data.user) == null ? void 0 : _a.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,
+        active: ((_e = data.user) == null ? void 0 : _e.active) || false
+      },
+      person: data.person ? {
+        name: data.person.name || "",
+        birth_date: data.person.birth_date || ""
+      } : void 0,
+      confidence_score: data.confidence_score,
+      recognition_id: data.recognition_id
+    };
+  } 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 recognizeBiometric = async (image, applicationToken, livenessCheck = true, confidenceThreshold = 0.8) => {
+  ensureSecureContext();
+  const controller = createTimeoutController();
+  const compressedImage = await compressImage(image);
+  try {
+    const formData = new FormData();
+    formData.append("face_frames", compressedImage);
+    formData.append("liveness_check", livenessCheck.toString());
+    formData.append("confidence_threshold", confidenceThreshold.toString());
+    const response = await fetch(`${API_BASE_URL}/api/v1/external/recognition/biometric/`, {
+      method: "POST",
+      headers: {
+        "X-App-Token": applicationToken
+      },
+      body: formData,
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        throw new NeoFaceError("Invalid or expired application token", ErrorType.INVALID_TOKEN);
+      }
+      throw new NeoFaceError(`Server returned status ${response.status}`, ErrorType.NETWORK);
+    }
+    const data = await response.json();
+    return {
+      success: data.success,
+      personId: data.person_id,
+      confidenceScore: data.confidence_score,
+      accessToken: data.access_token,
+      payload: data.payload
+    };
+  } 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 simpleIdentification = async (documentType, documentNumber, applicationToken, purpose = "LOGIN") => {
+  ensureSecureContext();
+  const controller = createTimeoutController();
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/v1/external/recognition/simple/`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-App-Token": applicationToken
+      },
+      body: JSON.stringify({
+        document_type: documentType,
+        document_number: documentNumber,
+        purpose
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        throw new NeoFaceError("Invalid or expired application token", ErrorType.INVALID_TOKEN);
+      }
+      throw new NeoFaceError(`Server returned status ${response.status}`, ErrorType.NETWORK);
+    }
+    const data = await response.json();
+    if (!data.success) {
+      throw new NeoFaceError(data.message || "Identification failed", ErrorType.RECOGNITION_FAILED);
+    }
+    return {
+      success: data.success,
+      personId: data.person_id,
+      accessToken: data.access_token,
+      payload: data.payload
+    };
+  } 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 recognizeByPurpose = async (image, applicationToken, purpose, confidenceThreshold = 0.8) => {
+  ensureSecureContext();
+  const controller = createTimeoutController();
+  const compressedImage = await compressImage(image);
+  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/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
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        throw new NeoFaceError("Invalid or expired application token", ErrorType.INVALID_TOKEN);
+      }
+      throw new NeoFaceError(`Server returned status ${response.status}`, ErrorType.NETWORK);
+    }
+    const data = await response.json();
+    return {
+      success: data.success,
+      personId: data.person_id,
+      confidenceScore: data.confidence_score,
+      accessToken: data.access_token,
       payload: data.payload
     };
+  } 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 registerPersonWithoutFace = async (personData, applicationToken) => {
+  ensureSecureContext();
+  const controller = createTimeoutController();
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/v1/signup/donor/`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-App-Token": applicationToken
+      },
+      body: JSON.stringify({
+        name: personData.name,
+        birth_date: personData.birth_date,
+        cpf: personData.cpf,
+        email: personData.email,
+        password: personData.password,
+        password_confirm: personData.password
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        throw new NeoFaceError("Invalid or expired application token", ErrorType.INVALID_TOKEN);
+      }
+      throw new NeoFaceError(`Server returned status ${response.status}`, ErrorType.NETWORK);
+    }
+    const data = await response.json();
+    return data;
   } catch (error) {
     if (error instanceof Error) {
       if (error.name === "AbortError") {
@@ -1174,7 +1482,91 @@ const recognize = async (image, applicationToken) => {
     throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK);
   }
 };
-const modalReducer = (state, action) => {
+const registerPersonWithBiometric = async (personData, facePhotos, applicationToken) => {
+  ensureSecureContext();
+  if (!facePhotos || facePhotos.length === 0) {
+    throw new NeoFaceError("At least one face photo is required for biometric registration", ErrorType.VALIDATION);
+  }
+  if (facePhotos.length > 5) {
+    throw new NeoFaceError("Maximum of 5 face photos allowed", ErrorType.VALIDATION);
+  }
+  const controller = createTimeoutController();
+  try {
+    const facePhotosBase64 = await Promise.all(
+      facePhotos.map(async (photo) => {
+        const compressedImage = await compressImage(photo);
+        return new Promise((resolve, reject) => {
+          const reader = new FileReader();
+          reader.onload = () => {
+            const result = reader.result;
+            resolve(result);
+          };
+          reader.onerror = reject;
+          reader.readAsDataURL(compressedImage);
+        });
+      })
+    );
+    const response = await fetch(`${API_BASE_URL}/api/v1/signup/donor/`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-App-Token": applicationToken
+      },
+      body: JSON.stringify({
+        name: personData.name,
+        birth_date: personData.birth_date,
+        cpf: personData.cpf,
+        email: personData.email,
+        password: personData.password,
+        password_confirm: personData.password,
+        face_photos: facePhotosBase64
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        throw new NeoFaceError("Invalid or expired application token", ErrorType.INVALID_TOKEN);
+      }
+      try {
+        const errorData = await response.json();
+        if (errorData.error === "fraud_detected") {
+          throw new NeoFaceError("Fraud detected in biometric images. Registration blocked.", ErrorType.VALIDATION);
+        }
+        if (errorData.error === "user_exists") {
+          throw new NeoFaceError("User with this email already exists", ErrorType.VALIDATION);
+        }
+        if (errorData.error === "person_exists") {
+          throw new NeoFaceError("Person with this CPF already exists", ErrorType.VALIDATION);
+        }
+        throw new NeoFaceError(errorData.message || `Server returned status ${response.status}`, ErrorType.NETWORK);
+      } catch (parseError) {
+        throw new NeoFaceError(`Server returned status ${response.status}`, ErrorType.NETWORK);
+      }
+    }
+    const data = await response.json();
+    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
+    };
+  } 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":
       return { status: "ready" };
@@ -1315,7 +1707,7 @@ function FaceCaptureModal({ accessToken, onClose, onSuccess }) {
   const streamRef = useRef(null);
   const faceDetectionTimeoutRef = useRef(null);
   const livenessCheckRef = useRef(null);
-  const [state, dispatch] = useReducer(modalReducer, { status: "requestingPermission" });
+  const [state, dispatch] = useReducer(modalReducer$1, { status: "requestingPermission" });
   const [faceDetected, setFaceDetected] = useState(false);
   const [livenessAttempts, setLivenessAttempts] = useState(0);
   const { startCamera, stopCamera } = useCamera();
@@ -1366,8 +1758,8 @@ function FaceCaptureModal({ accessToken, onClose, onSuccess }) {
     const loadModels = async () => {
       try {
         await Promise.all([
-          faceapi.nets.tinyFaceDetector.loadFromUri("/models"),
-          faceapi.nets.faceLandmark68Net.loadFromUri("/models")
+          faceapi.nets.tinyFaceDetector.loadFromUri("./models"),
+          faceapi.nets.faceLandmark68Net.loadFromUri("./models")
         ]);
       } catch (error) {
         console.error("Failed to load face-api.js models:", error);
@@ -1473,28 +1865,1903 @@ function FaceCaptureModal({ accessToken, onClose, onSuccess }) {
     ] })
   ] });
 }
-const VERSION = "1.0.18";
-const RELEASE_DATE = "2025-06-02";
-function start(applicationToken, callbacks) {
-  const container = document.createElement("div");
-  container.id = "neoface-modal-container";
-  document.body.appendChild(container);
-  const cleanup = () => {
-    if (document.body.contains(container)) {
-      document.body.removeChild(container);
-    }
+const modalReducer = (state, action) => {
+  switch (action.type) {
+    case "START_LIVENESS":
+      return {
+        status: "liveness",
+        step: action.stepSequence[0],
+        capturedPhotos: [],
+        stepSequence: action.stepSequence,
+        currentStepIndex: 0,
+        stepProgress: 0
+      };
+    case "NEXT_STEP":
+      if (state.status === "liveness") {
+        const newPhotos = action.photo ? [...state.capturedPhotos, action.photo] : state.capturedPhotos;
+        return {
+          status: "liveness",
+          step: action.step,
+          capturedPhotos: newPhotos,
+          stepSequence: state.stepSequence,
+          currentStepIndex: state.currentStepIndex + 1,
+          stepProgress: 0
+        };
+      }
+      return state;
+    case "UPDATE_PROGRESS":
+      if (state.status === "liveness") {
+        return {
+          ...state,
+          stepProgress: action.progress
+        };
+      }
+      return state;
+    case "START_PROCESSING":
+      return { status: "processing" };
+    case "SUCCESS":
+      return { status: "success" };
+    case "ERROR":
+      return { status: "error", message: action.message };
+    case "RESET":
+      return initialState;
+    default:
+      return state;
+  }
+};
+const livenessInstructions = {
+  center: "Posicione seu rosto no centro",
+  up: "Incline a cabeça para cima",
+  down: "Incline a cabeça para baixo",
+  left: "Vire o rosto para a esquerda",
+  right: "Vire o rosto para a direita",
+  complete: "Processando..."
+};
+const generateRandomStepSequence = () => {
+  return ["center", "up", "down", "left", "right", "complete"];
+};
+const initialState = (() => {
+  const sequence = generateRandomStepSequence();
+  return {
+    status: "liveness",
+    step: sequence[0],
+    capturedPhotos: [],
+    stepSequence: sequence,
+    currentStepIndex: 0,
+    stepProgress: 0
   };
-  validateToken(applicationToken).then(() => {
-    const modalElement = require$$0$1.createElement(FaceCaptureModal, {
-      accessToken: applicationToken,
-      onClose: cleanup,
-      onSuccess: (result) => {
-        cleanup();
-        callbacks.onSuccess({
-          name: result.data.faceId,
-          email: result.data.faceId,
-          documentId: result.data.faceId
-        });
+})();
+const CALIBRATION = {
+  PITCH_DEAD_ZONE: 8,
+  YAW_DEAD_ZONE: 10,
+  PITCH_OFFSET: 26,
+  PITCH_UP_THRESHOLD: 8,
+  PITCH_DOWN_THRESHOLD: -8,
+  YAW_LEFT_THRESHOLD: 15,
+  YAW_RIGHT_THRESHOLD: -15,
+  CAPTURE_HOLD_TIME: 1500,
+  DETECTION_INTERVAL: 200
+};
+function BiometricRegistrationModal({
+  personData,
+  applicationToken,
+  onClose,
+  onSuccess,
+  onError,
+  useRealApi = false
+  // 🚀 Por padrão, modo simulado
+}) {
+  const videoRef = useRef(null);
+  const canvasRef = useRef(null);
+  const streamRef = useRef(null);
+  const holdStartTimeRef = useRef(null);
+  const progressIntervalRef = useRef(null);
+  const isCapturingRef = useRef(false);
+  const currentStepRef = useRef("center");
+  const captureStateRef = useRef(null);
+  const [state, dispatch] = useReducer(modalReducer, initialState);
+  const [faceDetected, setFaceDetected] = useState(false);
+  const [faceDistance, setFaceDistance] = useState("ok");
+  useEffect(() => {
+    if (state.status === "liveness") {
+      const newStep = state.step;
+      if (currentStepRef.current !== newStep) {
+        currentStepRef.current = newStep;
+        if (!isCapturingRef.current) {
+          if (holdStartTimeRef.current) {
+            holdStartTimeRef.current = null;
+          }
+          if (progressIntervalRef.current) {
+            clearInterval(progressIntervalRef.current);
+            progressIntervalRef.current = null;
+          }
+          dispatch({ type: "UPDATE_PROGRESS", progress: 0 });
+        }
+      }
+      captureStateRef.current = {
+        stepSequence: state.stepSequence,
+        currentStepIndex: state.currentStepIndex,
+        capturedPhotos: state.capturedPhotos
+      };
+    }
+  }, [
+    state.status,
+    state.status === "liveness" && state.step,
+    state.status === "liveness" && state.currentStepIndex
+  ]);
+  const calculateHeadAngles = (landmarks) => {
+    try {
+      const points = landmarks.positions || landmarks._positions;
+      if (!Array.isArray(points) || points.length < 68) {
+        return null;
+      }
+      const getPoint = (index) => {
+        const point = points[index];
+        return {
+          x: point._x !== void 0 ? point._x : point.x,
+          y: point._y !== void 0 ? point._y : point.y
+        };
+      };
+      const noseTip = getPoint(30);
+      const chin = getPoint(8);
+      const leftEye = getPoint(36);
+      const rightEye = getPoint(45);
+      const eyeCenterX = (leftEye.x + rightEye.x) / 2;
+      const noseOffsetX = noseTip.x - eyeCenterX;
+      const eyeDistance = Math.abs(rightEye.x - leftEye.x);
+      const yaw = noseOffsetX / eyeDistance * 90;
+      const eyeCenterY = (leftEye.y + rightEye.y) / 2;
+      const noseOffsetY = noseTip.y - eyeCenterY;
+      const faceHeight = Math.abs(chin.y - eyeCenterY);
+      const pitchRaw = -(noseOffsetY / faceHeight) * 90;
+      const pitch = pitchRaw + CALIBRATION.PITCH_OFFSET;
+      return {
+        pitch: Math.round(pitch),
+        yaw: Math.round(yaw)
+      };
+    } catch (error) {
+      return null;
+    }
+  };
+  const checkPositionMatch = (pitch, yaw, step) => {
+    switch (step) {
+      case "center":
+        return Math.abs(pitch) < CALIBRATION.PITCH_DEAD_ZONE && Math.abs(yaw) < CALIBRATION.YAW_DEAD_ZONE;
+      case "up":
+        return pitch > CALIBRATION.PITCH_UP_THRESHOLD;
+      case "down":
+        return pitch < CALIBRATION.PITCH_DOWN_THRESHOLD;
+      case "left":
+        return yaw > CALIBRATION.YAW_LEFT_THRESHOLD;
+      case "right":
+        return yaw < CALIBRATION.YAW_RIGHT_THRESHOLD;
+      default:
+        return false;
+    }
+  };
+  const manageHoldAndCapture = (positionCorrect) => {
+    if (isCapturingRef.current || currentStepRef.current === "complete") {
+      return;
+    }
+    const now = Date.now();
+    if (positionCorrect) {
+      if (!holdStartTimeRef.current) {
+        holdStartTimeRef.current = now;
+        if (progressIntervalRef.current) {
+          clearInterval(progressIntervalRef.current);
+        }
+        progressIntervalRef.current = window.setInterval(() => {
+          if (!holdStartTimeRef.current)
+            return;
+          const elapsed = Date.now() - holdStartTimeRef.current;
+          const progress = Math.min(elapsed / CALIBRATION.CAPTURE_HOLD_TIME * 100, 100);
+          dispatch({ type: "UPDATE_PROGRESS", progress });
+          if (progress >= 100) {
+            clearInterval(progressIntervalRef.current);
+            progressIntervalRef.current = null;
+            capturePhoto();
+          }
+        }, 50);
+      }
+    } else {
+      if (holdStartTimeRef.current) {
+        holdStartTimeRef.current = null;
+        if (progressIntervalRef.current) {
+          clearInterval(progressIntervalRef.current);
+          progressIntervalRef.current = null;
+        }
+        dispatch({ type: "UPDATE_PROGRESS", progress: 0 });
+      }
+    }
+  };
+  useEffect(() => {
+    const loadModels = async () => {
+      try {
+        const MODEL_URL = "https://cdn.jsdelivr.net/npm/@vladmandic/face-api/model";
+        await Promise.all([
+          faceapi.nets.tinyFaceDetector.loadFromUri(MODEL_URL),
+          faceapi.nets.faceLandmark68Net.loadFromUri(MODEL_URL)
+        ]);
+      } catch (error) {
+        dispatch({ type: "ERROR", message: "Erro ao carregar modelos de IA" });
+      }
+    };
+    loadModels();
+  }, []);
+  useEffect(() => {
+    let mounted = true;
+    const initCamera = async () => {
+      if (state.status !== "liveness" || streamRef.current)
+        return;
+      try {
+        const stream = await navigator.mediaDevices.getUserMedia({
+          video: {
+            width: { ideal: 640 },
+            height: { ideal: 480 },
+            facingMode: "user"
+          }
+        });
+        if (!mounted) {
+          stream.getTracks().forEach((track) => track.stop());
+          return;
+        }
+        const waitForVideo = async () => {
+          let attempts = 0;
+          while (!videoRef.current && attempts < 50) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            attempts++;
+          }
+          return videoRef.current;
+        };
+        const video = await waitForVideo();
+        if (!video) {
+          throw new Error("Elemento de vídeo não encontrado");
+        }
+        video.srcObject = stream;
+        streamRef.current = stream;
+        await video.play();
+      } catch (error) {
+        if (!mounted)
+          return;
+        const errorMessage = error instanceof Error ? error.message : "Erro ao acessar câmera";
+        dispatch({ type: "ERROR", message: errorMessage });
+      }
+    };
+    initCamera();
+    return () => {
+      mounted = false;
+      if (streamRef.current) {
+        streamRef.current.getTracks().forEach((track) => track.stop());
+        streamRef.current = null;
+      }
+      if (progressIntervalRef.current) {
+        clearInterval(progressIntervalRef.current);
+        progressIntervalRef.current = null;
+      }
+      holdStartTimeRef.current = null;
+    };
+  }, [state.status]);
+  useEffect(() => {
+    if (state.status !== "liveness" || !videoRef.current) {
+      return;
+    }
+    let isRunning = true;
+    let lastDetectionTime = 0;
+    const detectFace2 = async () => {
+      if (!isRunning || state.status !== "liveness") {
+        return;
+      }
+      if (isCapturingRef.current || currentStepRef.current === "complete") {
+        requestAnimationFrame(detectFace2);
+        return;
+      }
+      const now = Date.now();
+      if (now - lastDetectionTime < CALIBRATION.DETECTION_INTERVAL) {
+        requestAnimationFrame(detectFace2);
+        return;
+      }
+      lastDetectionTime = now;
+      try {
+        const detection = await faceapi.detectSingleFace(
+          videoRef.current,
+          new faceapi.TinyFaceDetectorOptions({
+            inputSize: 160,
+            scoreThreshold: 0.4
+          })
+        ).withFaceLandmarks();
+        if (!isRunning)
+          return;
+        const hasFace = !!detection;
+        setFaceDetected(hasFace);
+        if (hasFace && detection.detection) {
+          const box = detection.detection.box;
+          const faceWidth = box.width;
+          if (faceWidth > 250) {
+            setFaceDistance("too-close");
+          } else if (faceWidth < 120) {
+            setFaceDistance("too-far");
+          } else {
+            setFaceDistance("ok");
+          }
+        }
+        if (hasFace && detection.landmarks) {
+          const angles = calculateHeadAngles(detection.landmarks);
+          if (angles) {
+            const positionCorrect = checkPositionMatch(
+              angles.pitch,
+              angles.yaw,
+              currentStepRef.current
+            );
+            manageHoldAndCapture(positionCorrect);
+          }
+        } else {
+          if (holdStartTimeRef.current) {
+            holdStartTimeRef.current = null;
+            if (progressIntervalRef.current) {
+              clearInterval(progressIntervalRef.current);
+              progressIntervalRef.current = null;
+            }
+            dispatch({ type: "UPDATE_PROGRESS", progress: 0 });
+          }
+        }
+      } catch (error) {
+      }
+      if (isRunning && state.status === "liveness") {
+        requestAnimationFrame(detectFace2);
+      }
+    };
+    const startTimer = setTimeout(() => {
+      var _a;
+      if (isRunning && ((_a = videoRef.current) == null ? void 0 : _a.readyState) === 4) {
+        detectFace2();
+      }
+    }, 1e3);
+    return () => {
+      isRunning = false;
+      clearTimeout(startTimer);
+      if (progressIntervalRef.current) {
+        clearInterval(progressIntervalRef.current);
+        progressIntervalRef.current = null;
+      }
+      holdStartTimeRef.current = null;
+    };
+  }, [state.status]);
+  const capturePhoto = async () => {
+    if (!videoRef.current || !canvasRef.current || isCapturingRef.current) {
+      return;
+    }
+    isCapturingRef.current = true;
+    holdStartTimeRef.current = null;
+    const capturedState = captureStateRef.current;
+    if (!capturedState) {
+      isCapturingRef.current = false;
+      return;
+    }
+    const canvas = canvasRef.current;
+    const video = videoRef.current;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      isCapturingRef.current = false;
+      return;
+    }
+    canvas.width = video.videoWidth;
+    canvas.height = video.videoHeight;
+    ctx.scale(-1, 1);
+    ctx.drawImage(video, -canvas.width, 0, canvas.width, canvas.height);
+    canvas.toBlob(
+      (blob) => {
+        if (!blob) {
+          isCapturingRef.current = false;
+          return;
+        }
+        const nextStepIndex = capturedState.currentStepIndex + 1;
+        const nextStep = capturedState.stepSequence[nextStepIndex];
+        if (nextStep === "complete") {
+          const allPhotos = [...capturedState.capturedPhotos, blob];
+          dispatch({ type: "START_PROCESSING" });
+          processRegistration(allPhotos);
+        } else {
+          setTimeout(() => {
+            isCapturingRef.current = false;
+            dispatch({ type: "NEXT_STEP", step: nextStep, photo: blob });
+          }, 100);
+        }
+      },
+      "image/jpeg",
+      0.85
+    );
+  };
+  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
+          }))
+        }
+      };
+      dispatch({ type: "SUCCESS" });
+      onSuccess(result);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Erro desconhecido";
+      dispatch({ type: "ERROR", message: errorMessage });
+      onError(errorMessage);
+    }
+  };
+  const renderLivenessDetection = () => {
+    if (state.status !== "liveness")
+      return null;
+    const progress = `${state.currentStepIndex + 1}/${state.stepSequence.length - 1}`;
+    const stepProgress = state.stepProgress;
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "liveness-container", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "progress-indicator", children: /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "progress-text", children: progress }) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "video-wrapper", children: /* @__PURE__ */ jsxRuntimeExports.jsxs(
+        "div",
+        {
+          className: `video-circle ${faceDetected ? "face-detected" : ""} ${stepProgress > 0 ? "capturing" : ""}`,
+          children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx("video", { ref: videoRef, className: "video-feed", autoPlay: true, muted: true, playsInline: true }),
+            faceDetected && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "face-badge", children: [
+              /* @__PURE__ */ jsxRuntimeExports.jsx("svg", { width: "16", height: "16", viewBox: "0 0 20 20", fill: "none", children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+                "path",
+                {
+                  d: "M5 10 L8 13 L15 6",
+                  stroke: "currentColor",
+                  strokeWidth: "2.5",
+                  strokeLinecap: "round",
+                  strokeLinejoin: "round"
+                }
+              ) }),
+              /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Rosto detectado" })
+            ] })
+          ]
+        }
+      ) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "instruction-box", children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: "instruction-text", children: livenessInstructions[state.step] }),
+        stepProgress > 0 && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "progress-bar", children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "progress-fill", style: { width: `${stepProgress}%` } }) })
+      ] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "branding-small", children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("img", { src: "/public/logo-icone.png", alt: "NeoFaceId", className: "brand-logo-small" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "NeoFaceId by" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "brand-name", children: "OCTA" })
+      ] })
+    ] });
+  };
+  const renderProcessing = () => /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "processing-container", children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "spinner-wrapper", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "spinner" }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "spinner-ring" })
+    ] }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("h3", { children: "Processando biometria" }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("p", { children: "Analisando suas capturas faciais..." }),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      "div",
+      {
+        className: "branding",
+        style: {
+          marginTop: "40px",
+          paddingTop: "24px",
+          borderTop: "1px solid rgba(255, 255, 255, 0.1)"
+        },
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "NeoFaceId by" }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "brand-name", children: "OCTA" })
+        ]
+      }
+    )
+  ] });
+  const renderError = () => {
+    if (state.status !== "error")
+      return null;
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "result-container error", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "result-icon error-icon", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("svg", { width: "60", height: "60", viewBox: "0 0 60 60", fill: "none", children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("circle", { cx: "30", cy: "30", r: "28", stroke: "currentColor", strokeWidth: "3" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "path",
+          {
+            d: "M20 20 L40 40 M40 20 L20 40",
+            stroke: "currentColor",
+            strokeWidth: "3",
+            strokeLinecap: "round"
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("h3", { children: "Não foi possível concluir" }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("p", { children: state.message }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "button-group", children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("button", { className: "secondary-button", onClick: () => dispatch({ type: "RESET" }), children: "Tentar Novamente" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("button", { className: "ghost-button", onClick: onClose, children: "Cancelar" })
+      ] })
+    ] });
+  };
+  const renderSuccess = () => /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "result-container success", children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "result-icon success-icon", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("svg", { width: "60", height: "60", viewBox: "0 0 60 60", fill: "none", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("circle", { cx: "30", cy: "30", r: "28", stroke: "currentColor", strokeWidth: "3" }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        "path",
+        {
+          d: "M15 30 L25 40 L45 20",
+          stroke: "currentColor",
+          strokeWidth: "3",
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("h3", { children: "Verificação concluída!" }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("p", { children: "Sua biometria foi registrada com sucesso" }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("button", { className: "primary-button", onClick: onClose, children: "Continuar" })
+  ] });
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx("style", { children: `
+        @keyframes fadeIn {
+          from { opacity: 0; transform: scale(0.95); }
+          to { opacity: 1; transform: scale(1); }
+        }
+
+        @keyframes slideUp {
+          from { opacity: 0; transform: translateY(20px); }
+          to { opacity: 1; transform: translateY(0); }
+        }
+
+        @keyframes slideDown {
+          from { opacity: 0; transform: translateY(-10px); }
+          to { opacity: 1; transform: translateY(0); }
+        }
+
+        @keyframes spin {
+          from { transform: rotate(0deg); }
+          to { transform: rotate(360deg); }
+        }
+
+        @keyframes pulseRing {
+          0%, 100% { 
+            box-shadow: 0 0 0 4px rgba(16, 185, 129, 0.8), 0 0 40px rgba(16, 185, 129, 0.4);
+          }
+          50% { 
+            box-shadow: 0 0 0 6px rgba(16, 185, 129, 0.9), 0 0 50px rgba(16, 185, 129, 0.5);
+          }
+        }
+
+        @keyframes checkmark {
+          0% {
+            stroke-dashoffset: 100;
+          }
+          100% {
+            stroke-dashoffset: 0;
+          }
+        }
+
+        @keyframes scaleIn {
+          0% {
+            transform: scale(0);
+            opacity: 0;
+          }
+          50% {
+            transform: scale(1.1);
+          }
+          100% {
+            transform: scale(1);
+            opacity: 1;
+          }
+        }
+
+        @keyframes scanRing {
+          0%, 100% { transform: scale(1); opacity: 0.3; }
+          50% { transform: scale(1.1); opacity: 0.6; }
+        }
+
+        @keyframes cornerBlink {
+          0%, 100% { opacity: 0.3; }
+          50% { opacity: 1; }
+        }
+
+        .modal-overlay {
+          position: fixed;
+          inset: 0;
+          background: rgba(0, 0, 0, 0.92);
+          backdrop-filter: blur(8px);
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          z-index: 9999;
+          padding: 20px;
+        }
+
+        .modal-content {
+          background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+          border-radius: 24px;
+          width: 100%;
+          max-width: 420px;
+          max-height: 90vh;
+          overflow: hidden;
+          box-shadow: 0 24px 48px rgba(0, 0, 0, 0.4), 0 0 0 1px rgba(255, 255, 255, 0.1);
+          animation: fadeIn 0.3s ease-out;
+          position: relative;
+        }
+
+        .close-button {
+          position: absolute;
+          top: 20px;
+          right: 20px;
+          width: 32px;
+          height: 32px;
+          background: transparent;
+          border: none;
+          color: rgba(255, 255, 255, 0.6);
+          font-size: 28px;
+          font-weight: 300;
+          cursor: pointer;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          transition: all 0.2s;
+          z-index: 10;
+          line-height: 1;
+        }
+
+        .close-button:hover {
+          color: rgba(255, 255, 255, 0.9);
+          transform: rotate(90deg);
+        }
+
+        /* Instructions Screen */
+        .instructions-container {
+          padding: 60px 40px 40px;
+          color: white;
+          text-align: center;
+          animation: slideUp 0.4s ease-out;
+        }
+
+        .instructions-header {
+          margin-bottom: 40px;
+        }
+
+        .icon-wrapper {
+          display: inline-block;
+          color: #7c3aed;
+          margin-bottom: 24px;
+        }
+
+        .icon-wrapper .scan-ring {
+          animation: scanRing 2s ease-in-out infinite;
+        }
+
+        .icon-wrapper .corner {
+          animation: cornerBlink 2s ease-in-out infinite;
+        }
+
+        .icon-wrapper .corner.tl { animation-delay: 0s; }
+        .icon-wrapper .corner.tr { animation-delay: 0.5s; }
+        .icon-wrapper .corner.bl { animation-delay: 1s; }
+        .icon-wrapper .corner.br { animation-delay: 1.5s; }
+
+        .instructions-header h2 {
+          font-size: 28px;
+          font-weight: 700;
+          margin: 0 0 12px 0;
+          background: linear-gradient(135deg, #7c3aed 0%, #a78bfa 100%);
+          -webkit-background-clip: text;
+          -webkit-text-fill-color: transparent;
+          background-clip: text;
+        }
+
+        .subtitle {
+          font-size: 15px;
+          color: rgba(255, 255, 255, 0.7);
+          margin: 0;
+          line-height: 1.5;
+        }
+
+        .requirements-list {
+          text-align: left;
+          margin: 0 auto 40px;
+          max-width: 360px;
+        }
+
+        .requirement-item {
+          display: flex;
+          align-items: center;
+          gap: 16px;
+          padding: 14px 0;
+          font-size: 15px;
+          color: rgba(255, 255, 255, 0.9);
+          border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+        }
+
+        .requirement-item:last-child {
+          border-bottom: none;
+        }
+
+        .req-icon {
+          width: 32px;
+          height: 32px;
+          border-radius: 50%;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          flex-shrink: 0;
+        }
+
+        .req-icon.success {
+          background: rgba(16, 185, 129, 0.15);
+          color: #10b981;
+          border: 1.5px solid rgba(16, 185, 129, 0.3);
+        }
+
+        .primary-button {
+          width: 100%;
+          padding: 16px 32px;
+          border-radius: 12px;
+          border: none;
+          background: linear-gradient(135deg, #7c3aed 0%, #6d28d9 100%);
+          color: white;
+          font-size: 16px;
+          font-weight: 600;
+          cursor: pointer;
+          transition: all 0.3s;
+          box-shadow: 0 4px 16px rgba(124, 58, 237, 0.3);
+        }
+
+        .primary-button:hover {
+          transform: translateY(-2px);
+          box-shadow: 0 8px 24px rgba(124, 58, 237, 0.4);
+        }
+
+        .primary-button:active {
+          transform: translateY(0);
+        }
+
+        .branding {
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          gap: 8px;
+          margin-top: 32px;
+          padding-top: 24px;
+          border-top: 1px solid rgba(255, 255, 255, 0.1);
+          font-size: 13px;
+          color: rgba(255, 255, 255, 0.5);
+        }
+
+        .brand-logo {
+          height: 20px;
+          width: auto;
+        }
+
+        .brand-name {
+          font-weight: 600;
+          font-family: 'SF Pro Display', -apple-system, system-ui, sans-serif;
+          color: #ffffff;
+          letter-spacing: 0.3px;
+        }
+
+        /* Liveness Detection */
+        .liveness-container {
+          height: 100%;
+          min-height: 520px;
+          display: flex;
+          flex-direction: column;
+          align-items: center;
+          justify-content: center;
+          padding: 70px 20px 80px;
+          position: relative;
+          animation: fadeIn 0.3s ease-out;
+        }
+
+        .progress-indicator {
+          position: absolute;
+          top: 20px;
+          left: 50%;
+          transform: translateX(-50%);
+          background: rgba(255, 255, 255, 0.08);
+          backdrop-filter: blur(12px);
+          border-radius: 20px;
+          padding: 8px 20px;
+          border: 1px solid rgba(255, 255, 255, 0.12);
+          z-index: 5;
+        }
+
+        .progress-text {
+          font-size: 14px;
+          font-weight: 600;
+          color: white;
+        }
+
+        .video-wrapper {
+          position: relative;
+          margin: 20px 0;
+        }
+
+        .video-circle {
+          width: 320px;
+          height: 400px;
+          border-radius: 50%;
+          overflow: hidden;
+          position: relative;
+          transition: all 0.3s ease;
+          box-shadow: 0 0 0 4px rgba(124, 58, 237, 0.3);
+        }
+
+        .video-circle.face-detected {
+          box-shadow: 0 0 0 4px rgba(16, 185, 129, 0.5), 0 0 40px rgba(16, 185, 129, 0.3);
+        }
+
+        .video-circle.capturing {
+          box-shadow: 0 0 0 4px rgba(16, 185, 129, 0.9), 0 0 40px rgba(16, 185, 129, 0.5);
+          transition: box-shadow 0.3s ease;
+        }
+
+        .video-feed {
+          width: 100%;
+          height: 100%;
+          object-fit: cover;
+          transform: scaleX(-1);
+        }
+
+        .face-badge {
+          position: absolute;
+          top: 20px;
+          left: 50%;
+          transform: translateX(-50%);
+          background: rgba(16, 185, 129, 0.95);
+          backdrop-filter: blur(10px);
+          border-radius: 20px;
+          padding: 8px 16px;
+          display: flex;
+          align-items: center;
+          gap: 8px;
+          color: white;
+          font-size: 13px;
+          font-weight: 600;
+          border: 1px solid rgba(255, 255, 255, 0.3);
+          box-shadow: 0 4px 12px rgba(16, 185, 129, 0.3);
+          animation: slideDown 0.3s ease-out;
+        }
+
+        .face-badge.warning {
+          background: rgba(251, 191, 36, 0.95);
+          border: 1px solid rgba(255, 255, 255, 0.3);
+          box-shadow: 0 4px 12px rgba(251, 191, 36, 0.3);
+          color: #78350f;
+        }
+
+        .face-badge.error {
+          background: rgba(239, 68, 68, 0.95);
+          border: 1px solid rgba(255, 255, 255, 0.3);
+          box-shadow: 0 4px 12px rgba(239, 68, 68, 0.3);
+          color: white;
+        }
+
+        .instruction-box {
+          background: rgba(255, 255, 255, 0.08);
+          backdrop-filter: blur(12px);
+          border-radius: 16px;
+          padding: 16px 24px;
+          margin-top: 20px;
+          border: 1px solid rgba(255, 255, 255, 0.12);
+          max-width: 320px;
+          animation: slideUp 0.3s ease-out;
+        }
+
+        .instruction-text {
+          font-size: 18px;
+          font-weight: 600;
+          color: white;
+          margin: 0 0 12px 0;
+          text-align: center;
+        }
+
+        .progress-bar {
+          height: 4px;
+          background: rgba(255, 255, 255, 0.2);
+          border-radius: 2px;
+          overflow: hidden;
+        }
+
+        .progress-fill {
+          height: 100%;
+          background: linear-gradient(90deg, #7c3aed 0%, #10b981 100%);
+          border-radius: 2px;
+          transition: width 0.05s linear;
+        }
+
+        .branding-small {
+          position: absolute;
+          bottom: 24px;
+          left: 50%;
+          transform: translateX(-50%);
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          gap: 5px;
+          font-size: 12px;
+          color: rgba(255, 255, 255, 0.5);
+        }
+
+        .brand-logo-small {
+          height: 18px;
+          width: 18px;
+        }
+
+        /* Processing */
+        .processing-container {
+          padding: 80px 40px;
+          text-align: center;
+          color: white;
+          animation: fadeIn 0.3s ease-out;
+        }
+
+        .spinner-wrapper {
+          position: relative;
+          width: 80px;
+          height: 80px;
+          margin: 0 auto 32px;
+        }
+
+        .spinner {
+          position: absolute;
+          inset: 0;
+          border: 4px solid rgba(124, 58, 237, 0.2);
+          border-top-color: #7c3aed;
+          border-radius: 50%;
+          animation: spin 1s linear infinite;
+        }
+
+        .spinner-ring {
+          position: absolute;
+          inset: -10px;
+          border: 2px solid rgba(124, 58, 237, 0.1);
+          border-radius: 50%;
+          animation: pulseSpinner 2s ease-in-out infinite;
+        }
+
+        @keyframes pulseSpinner {
+          0%, 100% { transform: scale(1); opacity: 1; }
+          50% { transform: scale(1.1); opacity: 0.5; }
+        }
+
+        .processing-container h3 {
+          font-size: 24px;
+          font-weight: 700;
+          margin: 0 0 12px 0;
+        }
+
+        .processing-container p {
+          font-size: 15px;
+          color: rgba(255, 255, 255, 0.7);
+          margin: 0;
+        }
+
+        /* Result Screens */
+        .result-container {
+          padding: 80px 40px 40px;
+          text-align: center;
+          color: white;
+          animation: slideUp 0.4s ease-out;
+        }
+
+        .result-icon {
+          display: inline-flex;
+          margin-bottom: 24px;
+        }
+
+        .success-icon {
+          color: #10b981;
+          animation: scaleIn 0.6s ease-out;
+        }
+
+        .success-icon svg circle {
+          animation: scaleIn 0.5s ease-out;
+        }
+
+        .success-icon svg path {
+          stroke-dasharray: 100;
+          stroke-dashoffset: 100;
+          animation: checkmark 0.6s ease-out 0.3s forwards;
+        }
+
+        .error-icon {
+          color: #ef4444;
+          animation: fadeIn 0.5s ease-out;
+        }
+
+        .result-container h3 {
+          font-size: 26px;
+          font-weight: 700;
+          margin: 0 0 12px 0;
+        }
+
+        .result-container p {
+          font-size: 15px;
+          color: rgba(255, 255, 255, 0.7);
+          margin: 0 0 32px 0;
+          line-height: 1.5;
+        }
+
+        .button-group {
+          display: flex;
+          gap: 12px;
+          margin-top: 32px;
+        }
+
+        .secondary-button {
+          flex: 1;
+          padding: 14px 24px;
+          border-radius: 12px;
+          border: 1px solid rgba(255, 255, 255, 0.2);
+          background: rgba(255, 255, 255, 0.1);
+          color: white;
+          font-size: 15px;
+          font-weight: 600;
+          cursor: pointer;
+          transition: all 0.2s;
+        }
+
+        .secondary-button:hover {
+          background: rgba(255, 255, 255, 0.15);
+          border-color: rgba(255, 255, 255, 0.3);
+        }
+
+        .ghost-button {
+          flex: 1;
+          padding: 14px 24px;
+          border-radius: 12px;
+          border: none;
+          background: transparent;
+          color: rgba(255, 255, 255, 0.7);
+          font-size: 15px;
+          font-weight: 600;
+          cursor: pointer;
+          transition: all 0.2s;
+        }
+
+        .ghost-button:hover {
+          color: white;
+          background: rgba(255, 255, 255, 0.05);
+        }
+
+        /* Canvas */
+        canvas {
+          display: none;
+        }
+
+        /* Responsive */
+        @media (max-width: 640px) {
+          .modal-content {
+            max-width: 100%;
+            border-radius: 0;
+            max-height: 100vh;
+          }
+
+          .instructions-container {
+            padding: 50px 24px 24px;
+          }
+
+          .instructions-header h2 {
+            font-size: 24px;
+          }
+
+          .video-circle {
+            width: 280px;
+            height: 350px;
+          }
+
+          .liveness-container {
+            min-height: 100vh;
+          }
+        }
+      ` }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "modal-overlay", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "modal-content", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("button", { className: "close-button", onClick: onClose, children: "×" }),
+      state.status === "liveness" && renderLivenessDetection(),
+      state.status === "processing" && renderProcessing(),
+      state.status === "error" && renderError(),
+      state.status === "success" && renderSuccess()
+    ] }) }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("canvas", { ref: canvasRef })
+  ] });
+}
+class BiometricCaptureModal {
+  constructor(options) {
+    __publicField(this, "modal", null);
+    __publicField(this, "video", null);
+    __publicField(this, "canvas", null);
+    __publicField(this, "stream", null);
+    __publicField(this, "options");
+    __publicField(this, "countdownInterval", null);
+    __publicField(this, "isCapturing", false);
+    this.options = options;
+  }
+  /**
+   * Abre o modal de captura biométrica
+   */
+  async open() {
+    try {
+      await this.createModal();
+      await this.initializeCamera();
+      this.startCountdown();
+    } catch (error) {
+      this.options.onError(
+        new NeoFaceError(
+          "Erro ao inicializar câmera: " + error.message,
+          ErrorType.CAMERA_ERROR
+        )
+      );
+    }
+  }
+  /**
+   * Fecha o modal e limpa recursos
+   */
+  close() {
+    this.cleanup();
+    if (this.modal) {
+      document.body.removeChild(this.modal);
+      this.modal = null;
+    }
+  }
+  /**
+   * Cria a estrutura HTML do modal
+   */
+  async createModal() {
+    this.modal = document.createElement("div");
+    this.modal.className = "neofaceid-biometric-modal";
+    const title = this.options.title || this.getDefaultTitle();
+    const subtitle = this.options.subtitle || this.getDefaultSubtitle();
+    this.modal.innerHTML = `
+      <div class="neofaceid-modal-overlay">
+        <div class="neofaceid-modal-content">
+          <div class="neofaceid-modal-header">
+            <h2>${title}</h2>
+            <button class="neofaceid-close-btn" type="button">&times;</button>
+          </div>
+          <div class="neofaceid-modal-body">
+            <p class="neofaceid-subtitle">${subtitle}</p>
+            <div class="neofaceid-camera-container">
+              <video class="neofaceid-video" autoplay muted playsinline></video>
+              <canvas class="neofaceid-canvas" style="display: none;"></canvas>
+              <div class="neofaceid-overlay">
+                <div class="neofaceid-frame"></div>
+                <div class="neofaceid-countdown">
+                  <span class="neofaceid-countdown-number">${this.options.countdown || 3}</span>
+                </div>
+              </div>
+            </div>
+            <div class="neofaceid-status">
+              <p class="neofaceid-status-text">Posicione-se na frente da câmera</p>
+            </div>
+          </div>
+          <div class="neofaceid-modal-footer">
+            <button class="neofaceid-cancel-btn" type="button">Cancelar</button>
+            <button class="neofaceid-capture-btn" type="button" disabled>Capturar</button>
+          </div>
+        </div>
+      </div>
+    `;
+    this.addStyles();
+    this.addEventListeners();
+    document.body.appendChild(this.modal);
+  }
+  /**
+   * Inicializa a câmera
+   */
+  async initializeCamera() {
+    if (!this.modal)
+      throw new Error("Modal não inicializado");
+    this.video = this.modal.querySelector(".neofaceid-video");
+    this.canvas = this.modal.querySelector(".neofaceid-canvas");
+    if (!this.video || !this.canvas) {
+      throw new Error("Elementos de vídeo ou canvas não encontrados");
+    }
+    try {
+      this.stream = await navigator.mediaDevices.getUserMedia({
+        video: {
+          width: { ideal: 640 },
+          height: { ideal: 480 },
+          facingMode: "user"
+        },
+        audio: false
+      });
+      this.video.srcObject = this.stream;
+      await this.video.play();
+      this.canvas.width = this.video.videoWidth;
+      this.canvas.height = this.video.videoHeight;
+    } catch (error) {
+      throw new Error("Não foi possível acessar a câmera: " + error.message);
+    }
+  }
+  /**
+   * Inicia a contagem regressiva
+   */
+  startCountdown() {
+    if (!this.modal)
+      return;
+    const countdownElement = this.modal.querySelector(".neofaceid-countdown-number");
+    const captureBtn = this.modal.querySelector(".neofaceid-capture-btn");
+    const statusText = this.modal.querySelector(".neofaceid-status-text");
+    let count = this.options.countdown || 3;
+    if (countdownElement) {
+      countdownElement.textContent = count.toString();
+    }
+    this.countdownInterval = window.setInterval(() => {
+      count--;
+      if (countdownElement) {
+        countdownElement.textContent = count.toString();
+      }
+      if (count <= 0) {
+        if (this.countdownInterval) {
+          clearInterval(this.countdownInterval);
+          this.countdownInterval = null;
+        }
+        if (countdownElement) {
+          countdownElement.style.display = "none";
+        }
+        if (captureBtn) {
+          captureBtn.disabled = false;
+          captureBtn.textContent = "Capturar Agora";
+        }
+        if (statusText) {
+          statusText.textContent = "Pronto para capturar!";
+        }
+        if (this.options.mode === "auto") {
+          setTimeout(() => this.captureImage(), 500);
+        }
+      }
+    }, 1e3);
+  }
+  /**
+   * Captura a imagem da câmera
+   */
+  async captureImage() {
+    if (this.isCapturing || !this.video || !this.canvas)
+      return;
+    this.isCapturing = true;
+    try {
+      const context = this.canvas.getContext("2d");
+      if (!context)
+        throw new Error("Não foi possível obter contexto do canvas");
+      context.drawImage(this.video, 0, 0, this.canvas.width, this.canvas.height);
+      const imageData = this.canvas.toDataURL("image/jpeg", 0.8);
+      const base64Data = imageData.split(",")[1];
+      let detectedType = this.options.mode === "auto" ? await this.detectBiometricType(base64Data) : this.options.mode;
+      this.close();
+      this.options.onSuccess(base64Data, detectedType);
+    } catch (error) {
+      this.options.onError(
+        new NeoFaceError(
+          "Erro ao capturar imagem: " + error.message,
+          ErrorType.CAPTURE_ERROR
+        )
+      );
+    } finally {
+      this.isCapturing = false;
+    }
+  }
+  /**
+   * Detecta o tipo biométrico na imagem (face ou mão)
+   */
+  async detectBiometricType(imageData) {
+    try {
+      const { detectBiometricType: detectBiometricType2 } = await Promise.resolve().then(() => biometricDetection);
+      const result = await detectBiometricType2(imageData);
+      if (result.type !== "unknown" && result.confidence > 0.6) {
+        return result.type;
+      }
+      return "face";
+    } catch (error) {
+      console.warn("Erro na detecção automática, usando face como padrão:", error);
+      return "face";
+    }
+  }
+  /**
+   * Adiciona event listeners aos elementos do modal
+   */
+  addEventListeners() {
+    if (!this.modal)
+      return;
+    const closeBtn = this.modal.querySelector(".neofaceid-close-btn");
+    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;
+      this.close();
+      (_b = (_a = this.options).onCancel) == null ? void 0 : _b.call(_a);
+    });
+    cancelBtn == null ? void 0 : cancelBtn.addEventListener("click", () => {
+      var _a, _b;
+      this.close();
+      (_b = (_a = this.options).onCancel) == null ? void 0 : _b.call(_a);
+    });
+    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"))) {
+        this.close();
+        (_c = (_b = this.options).onCancel) == null ? void 0 : _c.call(_b);
+      }
+    });
+  }
+  /**
+   * Limpa recursos (câmera, intervalos, etc.)
+   */
+  cleanup() {
+    if (this.stream) {
+      this.stream.getTracks().forEach((track) => track.stop());
+      this.stream = null;
+    }
+    if (this.countdownInterval) {
+      clearInterval(this.countdownInterval);
+      this.countdownInterval = null;
+    }
+    this.video = null;
+    this.canvas = null;
+    this.isCapturing = false;
+  }
+  /**
+   * Retorna o título padrão baseado no modo
+   */
+  getDefaultTitle() {
+    switch (this.options.mode) {
+      case "face":
+        return "Autenticação Facial";
+      case "hand":
+        return "Autenticação por Mão";
+      case "auto":
+        return "Autenticação Biométrica";
+      default:
+        return "Captura Biométrica";
+    }
+  }
+  /**
+   * Retorna o subtítulo padrão baseado no modo
+   */
+  getDefaultSubtitle() {
+    switch (this.options.mode) {
+      case "face":
+        return "Posicione seu rosto dentro do quadro e aguarde a captura automática.";
+      case "hand":
+        return "Posicione sua mão dentro do quadro e aguarde a captura automática.";
+      case "auto":
+        return "Posicione seu rosto ou mão dentro do quadro para autenticação automática.";
+      default:
+        return "Posicione-se dentro do quadro para captura.";
+    }
+  }
+  /**
+   * Adiciona estilos CSS ao modal
+   */
+  addStyles() {
+    const styleId = "neofaceid-biometric-modal-styles";
+    const existingStyles = document.getElementById(styleId);
+    if (existingStyles) {
+      existingStyles.remove();
+    }
+    const style = document.createElement("style");
+    style.id = styleId;
+    style.textContent = `
+      .neofaceid-biometric-modal {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        z-index: 10000;
+        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      }
+
+      .neofaceid-modal-overlay {
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background: rgba(0, 0, 0, 0.8);
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        padding: 20px;
+        box-sizing: border-box;
+      }
+
+      .neofaceid-modal-content {
+        background: white;
+        border-radius: 12px;
+        max-width: 600px;
+        width: 100%;
+        max-height: 90vh;
+        overflow: hidden;
+        box-shadow: 0 20px 40px rgba(0, 0, 0, 0.3);
+      }
+
+      .neofaceid-modal-header {
+        padding: 20px;
+        border-bottom: 1px solid #e0e0e0;
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+      }
+
+      .neofaceid-modal-header h2 {
+        margin: 0;
+        font-size: 24px;
+        font-weight: 600;
+        color: #333;
+      }
+
+      .neofaceid-close-btn {
+        background: none;
+        border: none;
+        font-size: 28px;
+        cursor: pointer;
+        color: #666;
+        padding: 0;
+        width: 32px;
+        height: 32px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        border-radius: 50%;
+        transition: background-color 0.2s;
+      }
+
+      .neofaceid-close-btn:hover {
+        background-color: #f0f0f0;
+      }
+
+      .neofaceid-modal-body {
+        padding: 20px;
+      }
+
+      .neofaceid-subtitle {
+        margin: 0 0 20px 0;
+        color: #666;
+        font-size: 16px;
+        line-height: 1.4;
+      }
+
+      .neofaceid-camera-container {
+        position: relative;
+        background: #000;
+        border-radius: 8px;
+        overflow: hidden;
+        aspect-ratio: 4/3;
+        margin-bottom: 20px;
+      }
+
+      .neofaceid-video {
+        width: 100%;
+        height: 100%;
+        object-fit: cover;
+      }
+
+      .neofaceid-canvas {
+        position: absolute;
+        top: 0;
+        left: 0;
+      }
+
+      .neofaceid-overlay {
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+      }
+
+      .neofaceid-frame {
+        width: 200px;
+        height: 200px;
+        border: 3px solid #4CAF50;
+        border-radius: 50%;
+        box-shadow: 0 0 0 2px rgba(76, 175, 80, 0.3);
+        animation: pulse 2s infinite;
+      }
+
+      .neofaceid-countdown {
+        position: absolute;
+        top: 20px;
+        right: 20px;
+        background: rgba(0, 0, 0, 0.7);
+        color: white;
+        padding: 10px;
+        border-radius: 50%;
+        width: 50px;
+        height: 50px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+      }
+
+      .neofaceid-countdown-number {
+        font-size: 24px;
+        font-weight: bold;
+      }
+
+      .neofaceid-status {
+        text-align: center;
+        margin-bottom: 20px;
+      }
+
+      .neofaceid-status-text {
+        margin: 0;
+        color: #666;
+        font-size: 16px;
+      }
+
+      .neofaceid-modal-footer {
+        padding: 20px;
+        border-top: 1px solid #e0e0e0;
+        display: flex;
+        gap: 12px;
+        justify-content: flex-end;
+      }
+
+      .neofaceid-cancel-btn,
+      .neofaceid-capture-btn {
+        padding: 12px 24px;
+        border: none;
+        border-radius: 6px;
+        font-size: 16px;
+        font-weight: 500;
+        cursor: pointer;
+        transition: all 0.2s;
+      }
+
+      .neofaceid-cancel-btn {
+        background: #f5f5f5;
+        color: #666;
+      }
+
+      .neofaceid-cancel-btn:hover {
+        background: #e0e0e0;
+      }
+
+      .neofaceid-capture-btn {
+        background: #4CAF50;
+        color: white;
+      }
+
+      .neofaceid-capture-btn:hover:not(:disabled) {
+        background: #45a049;
+      }
+
+      .neofaceid-capture-btn:disabled {
+        background: #ccc;
+        cursor: not-allowed;
+      }
+
+      @keyframes pulse {
+        0% { box-shadow: 0 0 0 2px rgba(76, 175, 80, 0.3); }
+        50% { box-shadow: 0 0 0 10px rgba(76, 175, 80, 0.1); }
+        100% { box-shadow: 0 0 0 2px rgba(76, 175, 80, 0.3); }
+      }
+
+      @media (max-width: 640px) {
+        .neofaceid-modal-overlay {
+          padding: 10px;
+        }
+        
+        .neofaceid-modal-header,
+        .neofaceid-modal-body,
+        .neofaceid-modal-footer {
+          padding: 15px;
+        }
+        
+        .neofaceid-frame {
+          width: 150px;
+          height: 150px;
+        }
+      }
+    `;
+    document.head.appendChild(style);
+  }
+}
+async function startFaceLogin(options) {
+  try {
+    const isValidToken = await validateToken(options.applicationToken);
+    if (!isValidToken) {
+      options.onError(new NeoFaceError("Token de aplicação inválido", ErrorType.INVALID_TOKEN));
+      return;
+    }
+    const captureOptions = {
+      mode: "face",
+      onSuccess: async (imageData, _detectedType) => {
+        try {
+          const imageBlob = await fetch(imageData).then((res) => res.blob());
+          const result = await loginWithBiometric(imageBlob, options.applicationToken);
+          options.onSuccess(result);
+        } catch (error) {
+          options.onError(error);
+        }
+      },
+      onError: options.onError,
+      onCancel: options.onCancel,
+      countdown: options.countdown,
+      title: options.title || "Login Facial",
+      subtitle: options.subtitle || "Posicione seu rosto dentro do quadro para fazer login."
+    };
+    const modal = new BiometricCaptureModal(captureOptions);
+    await modal.open();
+  } catch (error) {
+    options.onError(
+      new NeoFaceError(
+        "Erro ao inicializar login facial: " + error.message,
+        ErrorType.INITIALIZATION_ERROR
+      )
+    );
+  }
+}
+async function detectBiometricType(imageData) {
+  try {
+    const img = await loadImageFromBase64(imageData);
+    const faceResult = await detectFace(img);
+    if (faceResult.confidence > 0.7) {
+      return {
+        type: "face",
+        confidence: faceResult.confidence,
+        details: faceResult.details
+      };
+    }
+    const handResult = await detectHand(img);
+    if (handResult.confidence > 0.6) {
+      return {
+        type: "hand",
+        confidence: handResult.confidence,
+        details: handResult.details
+      };
+    }
+    return {
+      type: "unknown",
+      confidence: Math.max(faceResult.confidence, handResult.confidence)
+    };
+  } catch (error) {
+    console.warn("Erro na detecção biométrica:", error);
+    return {
+      type: "face",
+      confidence: 0.5
+    };
+  }
+}
+async function detectFace(img) {
+  try {
+    if (typeof window !== "undefined" && window.faceapi) {
+      const faceapi2 = window.faceapi;
+      await loadFaceApiModels();
+      const detections = await faceapi2.detectAllFaces(img).withFaceLandmarks().withFaceDescriptors();
+      if (detections && detections.length > 0) {
+        const bestDetection = detections.reduce(
+          (best, current) => current.detection.score > best.detection.score ? current : best
+        );
+        return {
+          confidence: bestDetection.detection.score,
+          details: {
+            faces: detections.length,
+            landmarks: bestDetection.landmarks,
+            box: bestDetection.detection.box
+          }
+        };
+      }
+    }
+    return { confidence: 0 };
+  } catch (error) {
+    console.warn("Erro na detecção facial:", error);
+    return { confidence: 0 };
+  }
+}
+async function detectHand(img) {
+  try {
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return { confidence: 0 };
+    }
+    canvas.width = img.width;
+    canvas.height = img.height;
+    ctx.drawImage(img, 0, 0);
+    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+    const handFeatures = analyzeHandFeatures(imageData);
+    return {
+      confidence: handFeatures.confidence,
+      details: handFeatures
+    };
+  } catch (error) {
+    console.warn("Erro na detecção de mão:", error);
+    return { confidence: 0 };
+  }
+}
+function analyzeHandFeatures(imageData) {
+  const { data, width, height } = imageData;
+  let skinPixels = 0;
+  let totalPixels = 0;
+  for (let i = 0; i < data.length; i += 4) {
+    const r = data[i];
+    const g = data[i + 1];
+    const b = data[i + 2];
+    if (isSkinColor(r, g, b)) {
+      skinPixels++;
+    }
+    totalPixels++;
+  }
+  const skinRatio = skinPixels / totalPixels;
+  const aspectRatio = width / height;
+  const isHandAspectRatio = aspectRatio > 0.6 && aspectRatio < 1.8;
+  let confidence = 0;
+  if (skinRatio > 0.15 && skinRatio < 0.7) {
+    confidence += 0.4 * (skinRatio / 0.7);
+  }
+  if (isHandAspectRatio) {
+    confidence += 0.3;
+  }
+  const imageSize = width * height;
+  if (imageSize > 1e4 && imageSize < 5e5) {
+    confidence += 0.3;
+  }
+  return {
+    confidence: Math.min(confidence, 0.8),
+    // Máximo 80% para detecção básica
+    skinRatio,
+    aspectRatio,
+    imageSize,
+    skinPixels,
+    totalPixels
+  };
+}
+function isSkinColor(r, g, b) {
+  const y = 0.299 * r + 0.587 * g + 0.114 * b;
+  const cb = -0.169 * r - 0.331 * g + 0.5 * b + 128;
+  const cr = 0.5 * r - 0.419 * g - 0.081 * b + 128;
+  return y > 80 && y < 255 && cb > 85 && cb < 135 && cr > 135 && cr < 180;
+}
+function loadImageFromBase64(base64Data) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.onerror = () => reject(new Error("Erro ao carregar imagem"));
+    const dataUrl = base64Data.startsWith("data:") ? base64Data : `data:image/jpeg;base64,${base64Data}`;
+    img.src = dataUrl;
+  });
+}
+async function loadFaceApiModels() {
+  if (typeof window === "undefined" || !window.faceapi) {
+    return;
+  }
+  const faceapi2 = window.faceapi;
+  if (faceapi2.nets.tinyFaceDetector.isLoaded) {
+    return;
+  }
+  try {
+    await Promise.all([
+      faceapi2.nets.tinyFaceDetector.loadFromUri("./models"),
+      faceapi2.nets.faceLandmark68Net.loadFromUri("./models"),
+      faceapi2.nets.faceRecognitionNet.loadFromUri("./models")
+    ]);
+  } catch (error) {
+    console.warn("Não foi possível carregar modelos do face-api.js:", error);
+  }
+}
+async function initializeBiometricDetection() {
+  try {
+    if (typeof window !== "undefined") {
+      await loadFaceApiModels();
+    }
+  } catch (error) {
+    console.warn("Inicialização da detecção biométrica com limitações:", error);
+  }
+}
+function isAdvancedDetectionAvailable() {
+  return typeof window !== "undefined" && window.faceapi && window.faceapi.nets.tinyFaceDetector.isLoaded;
+}
+const biometricDetection = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  detectBiometricType,
+  initializeBiometricDetection,
+  isAdvancedDetectionAvailable
+}, Symbol.toStringTag, { value: "Module" }));
+const VERSION = "1.1.0";
+const RELEASE_DATE = "2025-11-01";
+function start(applicationToken, callbacks) {
+  const container = document.createElement("div");
+  container.id = "neoface-modal-container";
+  document.body.appendChild(container);
+  const cleanup = () => {
+    if (document.body.contains(container)) {
+      document.body.removeChild(container);
+    }
+  };
+  validateToken(applicationToken).then(() => {
+    const modalElement = require$$0$1.createElement(FaceCaptureModal, {
+      accessToken: applicationToken,
+      onClose: cleanup,
+      onSuccess: (result) => {
+        cleanup();
+        callbacks.onSuccess({
+          name: result.data.faceId,
+          email: result.data.faceId,
+          documentId: result.data.faceId
+        });
+      }
+    });
+    const root = createRoot(container);
+    root.render(modalElement);
+  }).catch((error) => {
+    cleanup();
+    callbacks.onError("TOKEN_VALIDATION_ERROR", error.message || "Failed to validate token");
+  });
+}
+function startBiometricRegistration(personData, applicationToken, callbacks, options) {
+  const container = document.createElement("div");
+  container.id = "neoface-biometric-registration-container";
+  document.body.appendChild(container);
+  const cleanup = () => {
+    if (document.body.contains(container)) {
+      document.body.removeChild(container);
+    }
+  };
+  validateToken(applicationToken).then(() => {
+    const modalElement = require$$0$1.createElement(BiometricRegistrationModal, {
+      personData,
+      applicationToken,
+      useRealApi: (options == null ? void 0 : options.useRealApi) || false,
+      // 🚀 Passa a flag para o modal
+      onClose: cleanup,
+      onSuccess: (result) => {
+        cleanup();
+        callbacks.onSuccess(result);
+      },
+      onError: (error) => {
+        cleanup();
+        callbacks.onError("BIOMETRIC_REGISTRATION_ERROR", error);
       }
     });
     const root = createRoot(container);
@@ -1505,13 +3772,26 @@ function start(applicationToken, callbacks) {
   });
 }
 export {
+  BiometricCaptureModal,
+  BiometricRegistrationModal,
   ErrorType,
   FaceCaptureModal,
   NeoFaceError,
   RELEASE_DATE,
   VERSION,
+  detectBiometricType,
+  initializeBiometricDetection,
+  isAdvancedDetectionAvailable,
+  loginWithBiometric,
   recognize,
+  recognizeBiometric,
+  recognizeByPurpose,
+  registerPersonWithBiometric,
+  registerPersonWithoutFace,
+  simpleIdentification,
   start,
+  startBiometricRegistration,
+  startFaceLogin,
   validateToken
 };
 //# sourceMappingURL=neoface-id-sdk.es.js.map