@jaak.ai/stamps 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/collection/components/my-component/my-component.js

@@ -1,132 +1,231 @@
 import { h } from "@stencil/core";
+import { ServiceContainer } from "../../services/ServiceContainer";
 export class JaakStamps {
     el;
     debug = false;
-    alignmentTolerance = 10; // Tolerancia en píxeles para considerar un lado alineado (escalado para 320x320)
-    maskSize = 90; // Porcentaje del video que ocupará la máscara (default 90%)
-    cropMargin = 0; // Margen en píxeles para el recorte del documento (default 0)
-    useDocumentClassification = false; // Habilita la clasificación automática de documentos para determinar si solicitar reverso
+    alignmentTolerance = 15;
+    maskSize = 80;
+    cropMargin = 20;
+    useDocumentClassification = false;
+    preferredCamera = 'auto';
+    captureDelay = 1500;
     captureCompleted;
     isReady;
-    isVideoActive = false;
-    statusMessage = 'Presione el botón para activar la cámara';
-    statusColor = '#aaa';
-    bestScore = 0;
-    capturedFullFrame = null;
-    capturedCroppedId = null;
-    capturedBackFullFrame = null;
-    capturedBackCroppedId = null;
-    captureStep = 'front';
-    isCapturing = false;
-    showFlipAnimation = false;
-    showSuccessAnimation = false;
-    shouldMirrorVideo = true;
+    // State derived from services
+    detectionBoxes = [];
     sideAlignment = {
-        top: false,
-        right: false,
-        bottom: false,
-        left: false
+        top: false, right: false, bottom: false, left: false
     };
-    isDetectionPaused = false;
-    isLoading = false;
-    isModelPreloaded = false;
     isMaskReady = false;
+    shouldMirrorVideo = true;
+    showCameraSelector = false;
+    isSwitchingCamera = false;
+    hasDocumentDetected = false;
+    currentStatus = {
+        message: 'Inicializando componente...',
+        description: 'Configurando servicios y cargando recursos',
+        type: 'initializing',
+        isInitialized: false
+    };
+    performanceData = {
+        fps: 0,
+        inferenceTime: 0,
+        memoryUsage: 0,
+        onnxLoadTime: 0,
+        frameProcessingTime: 0,
+        totalDetections: 0,
+        successfulDetections: 0,
+        detectionRate: 0
+    };
+    // Services
+    serviceContainer;
+    logger;
+    eventBus;
+    stateManager;
+    cameraService;
+    detectionService;
+    // UI References
     videoRef;
-    canvasRef;
-    session;
-    startTime;
+    detectionContainer;
     videoStream;
     animationId;
-    hasScreenshotTaken = false;
+    // Detection state
     lastDetectedBox;
-    mobileNetSession;
-    mobileNetClassMap;
-    // Performance optimization properties
+    startTime;
+    hasScreenshotTaken = false;
+    alignmentStartTime;
+    alignmentTimer;
+    // Performance monitoring
+    performanceMetrics = {
+        fps: 0,
+        inferenceTime: 0,
+        memoryUsage: 0,
+        cpuUsage: 0,
+        onnxLoadTime: 0,
+        frameProcessingTime: 0,
+        totalDetections: 0,
+        successfulDetections: 0,
+        detectionRate: 0,
+        lastUpdateTime: 0
+    };
+    performanceUpdateInterval;
+    // Performance optimization
     frameSkipCounter = 0;
-    FRAME_SKIP = 2; // Process every 3rd frame (reduces CPU by ~66%)
+    FRAME_SKIP = 2;
     consecutiveFailures = 0;
-    MAX_FAILURES = 30; // 0.5 seconds without detection
+    MAX_FAILURES = 30;
     lastInferenceTime = 0;
-    MIN_INFERENCE_INTERVAL = 50; // Minimum 50ms between inferences
-    // Canvas pooling for memory optimization
-    preprocessCanvas;
-    preprocessCtx;
-    captureCanvas;
-    captureCtx;
-    MODEL_PATH = "https://storage.googleapis.com/jaak-static/web/component/stamps/ddmyp-v1.onnx";
-    MOBILENET_MODEL_PATH = "https://storage.googleapis.com/jaak-static/web/component/stamps/cdmmp-v1.onnx";
-    MOBILENET_CLASSES_PATH = "https://storage.googleapis.com/jaak-static/web/component/stamps/cdmmp-v1.json";
-    INPUT_SIZE = 320;
-    CONFIDENCE_THRESHOLD = 0.6;
-    // ISO/IEC 7810 ID-1 standard dimensions (85.60mm x 53.98mm)
-    ID1_ASPECT_RATIO = 85.60 / 53.98; // 1.5863320574...
-    debugLog(...args) {
+    MIN_INFERENCE_INTERVAL = 50;
+    async componentDidLoad() {
+        this.updateStatus('Iniciando servicios...', 'Configurando módulos internos', 'initializing');
+        await this.initializeServices();
+        this.updateStatus('Configurando eventos...', 'Preparando comunicación entre servicios', 'initializing');
+        await this.setupEventListeners();
+        this.updateStatus('Inicializando cámara...', 'Detectando dispositivos disponibles', 'initializing');
+        await this.initializeComponent();
+        if (this.debug) {
+            this.initializePerformanceMonitor();
+        }
+    }
+    async initializeServices() {
+        const config = {
+            debug: this.debug,
+            alignmentTolerance: this.alignmentTolerance,
+            maskSize: this.maskSize,
+            cropMargin: this.cropMargin,
+            useDocumentClassification: this.useDocumentClassification,
+            preferredCamera: this.preferredCamera,
+            captureDelay: this.captureDelay
+        };
+        this.serviceContainer = new ServiceContainer(config);
+        this.logger = this.serviceContainer.getLogger();
+        this.eventBus = this.serviceContainer.getEventBus();
+        this.stateManager = this.serviceContainer.getStateManager();
+        this.cameraService = this.serviceContainer.getCameraService();
+        this.detectionService = this.serviceContainer.getDetectionService();
+        this.logger.state('SERVICIOS_INICIALIZADOS', { timestamp: Date.now() });
+    }
+    async setupEventListeners() {
+        this.eventBus.on('state-changed', (data) => {
+            this.handleStateChange(data);
+        });
+        this.eventBus.on('camera-changed', (cameraId) => {
+            this.logger.state('CAMARA_CAMBIADA_EVENT', { cameraId });
+        });
+        this.eventBus.on('error', (error) => {
+            this.logger.error('Error en servicio:', error);
+        });
+    }
+    async initializeComponent() {
+        this.logger.state('COMPONENTE_INICIALIZANDO', {
+            debug: this.debug,
+            maskSize: this.maskSize,
+            cropMargin: this.cropMargin,
+            useDocumentClassification: this.useDocumentClassification,
+            preferredCamera: this.preferredCamera,
+            captureDelay: this.captureDelay
+        });
+        this.validateProps();
         if (this.debug) {
-            console.log(...args);
+            this.stateManager.updateCaptureState({ isLoading: true });
+            await new Promise(resolve => setTimeout(resolve, 500));
         }
+        this.updateStatus('Detectando cámaras...', 'Buscando dispositivos de captura', 'initializing');
+        await this.cameraService.detectDeviceType();
+        await this.cameraService.enumerateDevices();
+        this.updateStatus('Cargando modelo IA...', 'Preparando reconocimiento de documentos', 'initializing');
+        await this.loadOnnxRuntime();
+        this.initializeResizeObserver();
     }
-    validateMaskSize() {
+    validateProps() {
         if (this.maskSize < 50 || this.maskSize > 100) {
-            console.warn(`maskSize debe estar entre 50 y 100. Valor actual: ${this.maskSize}. Usando valor por defecto: 90`);
+            this.logger.warn(`Propiedad maskSize inválida. Valor: ${this.maskSize}, esperado: 50-100. Usando valor por defecto: 90`);
             this.maskSize = 90;
         }
-    }
-    validateCropMargin() {
         if (this.cropMargin < 0 || this.cropMargin > 100) {
-            console.warn(`cropMargin debe estar entre 0 y 100. Valor actual: ${this.cropMargin}. Usando valor por defecto: 0`);
+            this.logger.warn(`Propiedad cropMargin inválida. Valor: ${this.cropMargin}, esperado: 0-100. Usando valor por defecto: 0`);
             this.cropMargin = 0;
         }
+        const validOptions = ['auto', 'front', 'back'];
+        if (!validOptions.includes(this.preferredCamera)) {
+            this.logger.warn(`Propiedad preferredCamera inválida. Valor: ${this.preferredCamera}, esperado: ${validOptions.join(', ')}. Usando valor por defecto: 'auto'`);
+            this.preferredCamera = 'auto';
+        }
+        if (this.captureDelay < 0 || this.captureDelay > 10000) {
+            this.logger.warn(`Propiedad captureDelay inválida. Valor: ${this.captureDelay}, esperado: 0-10000. Usando valor por defecto: 1500`);
+            this.captureDelay = 1500;
+        }
     }
-    emitReadyEvent() {
-        const isDocumentReady = !!window.ort && this.isModelPreloaded;
-        this.isReady.emit(isDocumentReady);
-        this.debugLog('🟢 isReady event emitted:', isDocumentReady);
-    }
-    isRearCamera(stream) {
-        const videoTrack = stream.getVideoTracks()[0];
-        if (!videoTrack)
-            return false;
-        const settings = videoTrack.getSettings();
-        return settings.facingMode === 'environment';
-    }
-    async componentDidLoad() {
-        this.validateMaskSize();
-        this.validateCropMargin();
+    async loadOnnxRuntime() {
         if (!window.ort) {
+            this.updateStatus('Descargando librerías...', 'Obteniendo recursos de reconocimiento', 'initializing');
             const script = document.createElement('script');
             script.src = 'https://cdn.jsdelivr.net/npm/onnxruntime-web/dist/ort.min.js';
             document.head.appendChild(script);
-            // Wait for ONNX runtime to load before emitting ready event
-            script.onload = () => {
-                this.emitReadyEvent();
-            };
+            await new Promise((resolve) => {
+                script.onload = () => {
+                    setTimeout(() => {
+                        this.finalizeInitialization();
+                        resolve(undefined);
+                    }, 300);
+                };
+            });
         }
         else {
-            // ONNX runtime already loaded
-            this.emitReadyEvent();
+            setTimeout(() => {
+                this.finalizeInitialization();
+            }, 300);
+        }
+    }
+    finalizeInitialization() {
+        this.stateManager.updateCaptureState({ isLoading: false });
+        this.currentStatus = {
+            message: 'Listo para capturar',
+            description: '',
+            type: 'ready',
+            isInitialized: true
+        };
+        this.emitReadyEvent();
+    }
+    updateStatus(message, description, type = 'loading') {
+        this.currentStatus = {
+            message,
+            description,
+            type,
+            isInitialized: this.currentStatus.isInitialized
+        };
+    }
+    emitReadyEvent() {
+        const isDocumentReady = !!window.ort && this.detectionService.isModelLoaded();
+        this.isReady.emit(isDocumentReady);
+        this.logger.state('COMPONENTE_LISTO', {
+            ortLibraryLoaded: !!window.ort,
+            modelPreloaded: this.detectionService.isModelLoaded(),
+            isReady: isDocumentReady
+        });
+    }
+    handleStateChange(data) {
+        // React to state changes from StateManager
+        // This is where the component updates its internal state based on service state changes
+        if (data.changes.isLoading !== undefined) {
+            // Force re-render when loading state changes
+            // Note: Stencil automatically re-renders when @State changes
         }
-        // Initialize canvas pool for better performance
-        this.initializeCanvasPool();
-        this.setupResizeObserver();
     }
-    setupResizeObserver() {
-        if ('ResizeObserver' in window && this.canvasRef) {
+    initializeResizeObserver() {
+        if ('ResizeObserver' in window && this.detectionContainer) {
             const resizeObserver = new ResizeObserver(() => {
                 this.handleResize();
             });
-            resizeObserver.observe(this.canvasRef.parentElement);
+            resizeObserver.observe(this.detectionContainer.parentElement);
         }
     }
     handleResize() {
-        if (this.canvasRef) {
-            const container = this.canvasRef.parentElement;
+        if (this.detectionContainer) {
+            const container = this.detectionContainer.parentElement;
             const rect = container.getBoundingClientRect();
-            // Set canvas size to match container
-            this.canvasRef.width = rect.width;
-            this.canvasRef.height = rect.height;
-            // Update mask positioning based on container and video dimensions
             this.updateMaskDimensions(rect);
-            this.debugLog('📐 Canvas resized:', { width: rect.width, height: rect.height });
+            this.logger.debug('Container redimensionado:', { width: rect.width, height: rect.height });
         }
     }
     updateMaskDimensions(containerRect) {
@@ -143,32 +242,27 @@ export class JaakStamps {
         let displayedVideoWidth, displayedVideoHeight;
         let videoOffsetX = 0, videoOffsetY = 0;
         if (videoAspectRatio > containerAspectRatio) {
-            // Video is wider - letterboxed (black bars top/bottom)
             displayedVideoWidth = containerRect.width;
             displayedVideoHeight = containerRect.width / videoAspectRatio;
             videoOffsetY = (containerRect.height - displayedVideoHeight) / 2;
         }
         else {
-            // Video is taller - pillarboxed (black bars left/right)
             displayedVideoHeight = containerRect.height;
             displayedVideoWidth = containerRect.height * videoAspectRatio;
             videoOffsetX = (containerRect.width - displayedVideoWidth) / 2;
         }
-        // Calculate maximum possible mask size while preserving exact ID-1 aspect ratio
-        // Determine the limiting dimension based on video orientation and ID-1 proportions
-        // Calculate what would be the max width if limited by video height
-        const maxWidthByHeight = displayedVideoHeight * this.ID1_ASPECT_RATIO;
+        // Calculate mask dimensions with ID-1 aspect ratio
+        const ID1_ASPECT_RATIO = 85.60 / 53.98;
+        const maxWidthByHeight = displayedVideoHeight * ID1_ASPECT_RATIO;
         let maskWidthInVideo, maskHeightInVideo;
         const sizeRatio = this.maskSize / 100;
         if (maxWidthByHeight <= displayedVideoWidth) {
-            // Video height is the limiting factor
             maskHeightInVideo = displayedVideoHeight * sizeRatio;
-            maskWidthInVideo = maskHeightInVideo * this.ID1_ASPECT_RATIO;
+            maskWidthInVideo = maskHeightInVideo * ID1_ASPECT_RATIO;
         }
         else {
-            // Video width is the limiting factor
             maskWidthInVideo = displayedVideoWidth * sizeRatio;
-            maskHeightInVideo = maskWidthInVideo / this.ID1_ASPECT_RATIO;
+            maskHeightInVideo = maskWidthInVideo / ID1_ASPECT_RATIO;
         }
         // Convert to percentages of the container
         const maskWidthPercent = (maskWidthInVideo / containerRect.width) * 100;
@@ -184,9 +278,8 @@ export class JaakStamps {
         this.el.style.setProperty('--mask-height', `${maskHeightPercent}%`);
         this.el.style.setProperty('--mask-center-x', `${videoCenterXPercent}%`);
         this.el.style.setProperty('--mask-center-y', `${videoCenterYPercent}%`);
-        // Mark mask as ready now that dimensions are calculated
         this.isMaskReady = true;
-        this.debugLog('🎯 Mask dimensions updated:', {
+        this.logger.state('DIMENSIONES_MASCARA_ACTUALIZADAS', {
             video: { width: videoWidth, height: videoHeight },
             displayed: { width: displayedVideoWidth, height: displayedVideoHeight },
             mask: { widthPercent: maskWidthPercent, heightPercent: maskHeightPercent },
@@ -194,46 +287,16 @@ export class JaakStamps {
             offset: { x: videoOffsetX, y: videoOffsetY }
         });
     }
-    initializeCanvasPool() {
-        // Preprocess canvas - reused for every inference
-        this.preprocessCanvas = document.createElement('canvas');
-        this.preprocessCanvas.width = this.INPUT_SIZE;
-        this.preprocessCanvas.height = this.INPUT_SIZE;
-        this.preprocessCtx = this.preprocessCanvas.getContext('2d', {
-            alpha: false, // No transparency needed
-            willReadFrequently: true // Optimize for frequent getImageData calls
-        });
-        // Capture canvas - reused for screenshots
-        this.captureCanvas = document.createElement('canvas');
-        this.captureCtx = this.captureCanvas.getContext('2d', {
-            alpha: false
-        });
-        this.debugLog('🎨 Canvas pool initialized for performance');
-    }
-    disconnectedCallback() {
-        this.cleanup();
-    }
+    // PUBLIC METHODS
     async getCapturedImages() {
-        if (this.captureStep !== 'completed') {
+        const state = this.stateManager.getCaptureState();
+        if (state.step !== 'completed') {
             throw new Error('El proceso de captura no ha sido completado');
         }
-        return {
-            front: {
-                fullFrame: this.capturedFullFrame,
-                cropped: this.capturedCroppedId
-            },
-            back: {
-                fullFrame: this.capturedBackFullFrame,
-                cropped: this.capturedBackCroppedId
-            },
-            metadata: {
-                hasBackCapture: !!(this.capturedBackFullFrame && this.capturedBackCroppedId),
-                totalImages: (this.capturedBackFullFrame && this.capturedBackCroppedId) ? 4 : 2
-            }
-        };
+        return this.stateManager.getCapturedImages();
     }
     async isProcessCompleted() {
-        return this.captureStep === 'completed';
+        return this.stateManager.isProcessCompleted();
     }
     async startCapture() {
         await this.startDetection();
@@ -244,395 +307,250 @@ export class JaakStamps {
     async resetCapture() {
         this.resetDetection();
     }
+    async skipBackCapture() {
+        const captureState = this.stateManager.getCaptureState();
+        const capturedImages = this.stateManager.getCapturedImages();
+        if (captureState.step === 'back' && capturedImages.front.fullFrame) {
+            this.completeProcess(true);
+        }
+    }
     async getStatus() {
+        const captureState = this.stateManager.getCaptureState();
+        const capturedImages = this.stateManager.getCapturedImages();
         return {
-            isVideoActive: this.isVideoActive,
-            captureStep: this.captureStep,
-            statusMessage: this.statusMessage,
-            hasImages: !!(this.capturedFullFrame || this.capturedBackFullFrame),
-            isProcessCompleted: this.captureStep === 'completed',
-            isModelPreloaded: this.isModelPreloaded
+            isVideoActive: captureState.isVideoActive,
+            captureStep: captureState.step,
+            hasImages: !!(capturedImages.front.fullFrame || capturedImages.back.fullFrame),
+            isProcessCompleted: this.stateManager.isProcessCompleted(),
+            isModelPreloaded: this.detectionService.isModelLoaded()
         };
     }
     async preloadModel() {
-        if (this.isModelPreloaded || this.session) {
-            this.debugLog('🚀 Model already preloaded or session exists');
+        if (this.detectionService.isModelLoaded()) {
+            this.logger.state('MODELO_YA_PRECARGADO');
+            this.updateStatus('Modelos ya cargados', '', 'ready');
             return { success: true, message: 'Model already loaded' };
         }
         try {
-            this.isLoading = true;
-            this.statusMessage = "Precargando modelos...";
-            this.statusColor = "#007bff";
-            const modelPath = this.MODEL_PATH;
-            this.debugLog('🤖 Preloading detection model:', modelPath);
-            // Configure ONNX Runtime with device-specific optimizations
-            const sessionOptions = this.getSessionOptions();
-            this.session = await window.ort.InferenceSession.create(modelPath, sessionOptions);
-            // Preload MobileNet model and classes only if classification is enabled
-            if (this.useDocumentClassification) {
-                await this.loadMobileNetModel();
+            const loadStartTime = performance.now();
+            this.updateStatus('Descargando modelo de detección...', 'Obteniendo red neuronal para reconocimiento de documentos', 'loading');
+            this.stateManager.updateCaptureState({ isLoading: true });
+            await this.detectionService.loadModel();
+            this.updateStatus('Cargando clasificador...', 'Preparando modelo de clasificación de tipos de documento', 'loading');
+            await this.detectionService.loadClassificationModel();
+            const loadEndTime = performance.now();
+            const loadTime = loadEndTime - loadStartTime;
+            // Record ONNX load time
+            if (this.debug) {
+                this.recordOnnxPerformance(loadTime, 0);
             }
-            this.isModelPreloaded = true;
-            this.isLoading = false;
-            this.statusMessage = "Modelos precargados. Listo para comenzar detección";
-            this.statusColor = "#28a745";
+            this.updateStatus('Optimizando modelos...', 'Configurando parámetros de rendimiento', 'loading');
+            await new Promise(resolve => setTimeout(resolve, 300));
+            this.updateStatus('Modelos precargados', '', 'ready');
+            this.stateManager.updateCaptureState({ isLoading: false });
             this.emitReadyEvent();
-            this.debugLog('✅ Models preloaded successfully');
+            this.logger.state('MODELOS_PRECARGADOS_EXITOSAMENTE', { loadTime: Math.round(loadTime) });
             return { success: true, message: 'Models preloaded successfully' };
         }
         catch (error) {
-            this.debugLog('❌ Error preloading models:', error);
-            this.isLoading = false;
-            this.statusMessage = "Error al precargar los modelos";
-            this.statusColor = "#ff6b6b";
+            this.logger.error('Error al precargar modelos:', error);
+            this.updateStatus('Error al cargar modelos', 'No se pudieron descargar los recursos necesarios', 'error');
+            this.stateManager.updateCaptureState({ isLoading: false });
             return { success: false, error: error.message };
         }
     }
-    async skipBackCapture() {
-        if (this.captureStep === 'back' && this.capturedFullFrame) {
-            this.completeProcess(true);
-        }
-    }
-    async loadMobileNetModel() {
-        try {
-            this.debugLog('🤖 Loading MobileNet model...');
-            // Load class map
-            const classResponse = await fetch(this.MOBILENET_CLASSES_PATH);
-            if (!classResponse.ok) {
-                throw new Error(`Failed to load class map: ${this.MOBILENET_CLASSES_PATH}`);
-            }
-            this.mobileNetClassMap = await classResponse.json();
-            this.debugLog('📋 MobileNet classes loaded:', this.mobileNetClassMap);
-            // Load model
-            const sessionOptions = this.getSessionOptions();
-            this.mobileNetSession = await window.ort.InferenceSession.create(this.MOBILENET_MODEL_PATH, sessionOptions);
-            this.debugLog('✅ MobileNet model loaded successfully');
-        }
-        catch (error) {
-            this.debugLog('❌ Error loading MobileNet model:', error);
-            throw error;
-        }
-    }
-    preprocessMobileNet(canvas) {
-        // Create a temporary canvas for MobileNet preprocessing (224x224)
-        const tempCanvas = document.createElement('canvas');
-        tempCanvas.width = 224;
-        tempCanvas.height = 224;
-        const tempCtx = tempCanvas.getContext('2d');
-        // Draw the cropped image onto the 224x224 canvas
-        tempCtx.drawImage(canvas, 0, 0, 224, 224);
-        // Get image data and preprocess for MobileNet
-        const imageData = tempCtx.getImageData(0, 0, 224, 224);
-        const data = imageData.data;
-        const hw = 224 * 224;
-        const arr = new Float32Array(3 * hw);
-        // Normalize pixels: (pixel/255 - 0.5) / 0.5 = (pixel - 127.5) / 127.5
-        for (let i = 0; i < hw; i++) {
-            arr[i] = (data[i * 4 + 0] / 255 - 0.5) / 0.5; // R
-            arr[hw + i] = (data[i * 4 + 1] / 255 - 0.5) / 0.5; // G  
-            arr[2 * hw + i] = (data[i * 4 + 2] / 255 - 0.5) / 0.5; // B
-        }
-        return new window.ort.Tensor('float32', arr, [1, 3, 224, 224]);
-    }
-    async classifyDocument(canvas) {
-        if (!this.mobileNetSession || !this.mobileNetClassMap) {
-            this.debugLog('⚠️ MobileNet model not loaded');
-            return null;
-        }
-        try {
-            this.debugLog('🔍 Classifying document...');
-            // Preprocess image for MobileNet
-            const inputTensor = this.preprocessMobileNet(canvas);
-            // Run inference
-            const feeds = { input: inputTensor };
-            const results = await this.mobileNetSession.run(feeds);
-            const output = results[Object.keys(results)[0]].data;
-            // Find the class with highest confidence
-            const maxIdx = output.reduce((bestIdx, val, idx, arr) => val > arr[bestIdx] ? idx : bestIdx, 0);
-            const confidence = output[maxIdx];
-            const className = this.mobileNetClassMap[maxIdx.toString()] || "unknown";
-            this.debugLog('📄 Document classification result:', {
-                class: className,
-                confidence: confidence.toFixed(3),
-                classIndex: maxIdx
-            });
-            return {
-                class: className,
-                confidence: confidence,
-                classIndex: maxIdx
-            };
-        }
-        catch (error) {
-            this.debugLog('❌ Error classifying document:', error);
-            return null;
-        }
+    async getCameraInfo() {
+        return this.cameraService.getCameraInfo();
     }
-    cleanup() {
-        if (this.animationId) {
-            cancelAnimationFrame(this.animationId);
-        }
-        if (this.videoStream) {
-            this.videoStream.getTracks().forEach(track => track.stop());
-        }
-        // Limpiar canvas en cleanup general
-        if (this.canvasRef) {
-            const ctx = this.canvasRef.getContext("2d");
-            if (ctx) {
-                ctx.clearRect(0, 0, this.canvasRef.width, this.canvasRef.height);
+    async setPreferredCamera(camera) {
+        this.preferredCamera = camera;
+        this.serviceContainer.updateConfig({ preferredCamera: camera });
+        await this.cameraService.enumerateDevices();
+        const captureState = this.stateManager.getCaptureState();
+        if (captureState.isVideoActive) {
+            const selectedCameraId = this.cameraService.getSelectedCameraId();
+            if (selectedCameraId) {
+                await this.cameraService.switchCamera(selectedCameraId);
             }
         }
-        // OPTIMIZATION: Clean up canvas pool
-        this.cleanupCanvasPool();
+        return {
+            success: true,
+            selectedCamera: this.cameraService.getSelectedCameraId(),
+            availableCameras: this.cameraService.getAvailableCameras().length
+        };
     }
-    cleanupCanvasPool() {
-        // Release canvas references for garbage collection
-        if (this.preprocessCanvas) {
-            this.preprocessCtx = undefined;
-            this.preprocessCanvas = undefined;
-        }
-        if (this.captureCanvas) {
-            this.captureCtx = undefined;
-            this.captureCanvas = undefined;
-        }
-        // Disposed ONNX sessions
-        if (this.session) {
-            this.session.release?.();
-            this.session = undefined;
-        }
-        if (this.mobileNetSession) {
-            this.mobileNetSession.release?.();
-            this.mobileNetSession = undefined;
-        }
-        this.mobileNetClassMap = undefined;
-        this.isModelPreloaded = false;
-        this.debugLog('🧹 Canvas pool cleaned up');
-    }
-    async getMaxResolution() {
-        try {
-            // Primero obtén un stream básico para acceder a las capacidades
-            const tempStream = await navigator.mediaDevices.getUserMedia({
-                video: { facingMode: "environment" }
-            });
-            const videoTrack = tempStream.getVideoTracks()[0];
-            const capabilities = videoTrack.getCapabilities();
-            // Detener el stream temporal
-            tempStream.getTracks().forEach(track => track.stop());
-            // Construir restricciones con resolución optimizada para tablets
-            const constraints = {
-                facingMode: "environment"
-            };
-            if (capabilities.width && capabilities.height) {
-                // Limitar resolución máxima para tablets para evitar problemas de rendimiento
-                const maxWidth = Math.min(capabilities.width.max, 1920);
-                const maxHeight = Math.min(capabilities.height.max, 1080);
-                // Para tablets, usar resolución moderada en lugar de máxima
-                const isTablet = /iPad|Android/i.test(navigator.userAgent) && window.innerWidth >= 768;
-                if (isTablet) {
-                    constraints.width = { ideal: Math.min(maxWidth, 1280) };
-                    constraints.height = { ideal: Math.min(maxHeight, 720) };
-                }
-                else {
-                    constraints.width = { ideal: maxWidth };
-                    constraints.height = { ideal: maxHeight };
-                }
-                this.debugLog('📐 Resolution capabilities:', {
-                    maxWidth: capabilities.width.max,
-                    maxHeight: capabilities.height.max,
-                    selectedWidth: constraints.width.ideal,
-                    selectedHeight: constraints.height.ideal,
-                    isTablet
-                });
-            }
-            return constraints;
-        }
-        catch (err) {
-            this.debugLog('⚠️ Could not get capabilities, using fallback');
-            // Fallback optimizado para tablets
-            const isTablet = /iPad|Android/i.test(navigator.userAgent) && window.innerWidth >= 768;
-            return {
-                facingMode: "environment",
-                width: { ideal: isTablet ? 1280 : 1920 },
-                height: { ideal: isTablet ? 720 : 1080 }
-            };
+    async setCaptureDelay(delay) {
+        if (delay < 0 || delay > 10000) {
+            throw new Error('Capture delay must be between 0 and 10000 milliseconds');
         }
+        this.captureDelay = delay;
+        this.serviceContainer.updateConfig({ captureDelay: delay });
+        return {
+            success: true,
+            captureDelay: this.captureDelay
+        };
     }
-    async setupCamera() {
-        try {
-            const constraints = await this.getMaxResolution();
-            const stream = await navigator.mediaDevices.getUserMedia({
-                video: constraints,
-                audio: false
-            });
-            if (this.videoRef) {
-                this.videoRef.srcObject = stream;
-                this.videoStream = stream;
-                // Determine if video should be mirrored
-                const isRear = this.isRearCamera(stream);
-                this.shouldMirrorVideo = !isRear;
-                this.debugLog('📹 Rear camera:', isRear);
-                this.debugLog('🪞 Should mirror video:', this.shouldMirrorVideo);
-                return new Promise((resolve) => {
-                    this.videoRef.onloadedmetadata = async () => {
-                        await this.videoRef.play();
-                        this.isVideoActive = true;
-                        // Update mask dimensions once video is loaded
-                        if (this.canvasRef) {
-                            const container = this.canvasRef.parentElement;
-                            const rect = container.getBoundingClientRect();
-                            this.updateMaskDimensions(rect);
-                        }
-                        resolve();
-                    };
-                });
-            }
-        }
-        catch (err) {
-            this.debugLog("❌ No se pudo acceder a la cámara:", err);
-            this.statusMessage = "Error: No se pudo acceder a la cámara.";
-            this.statusColor = "#ff6b6b";
-        }
+    async getCaptureDelay() {
+        return this.captureDelay;
     }
-    preprocess(video) {
-        // OPTIMIZATION: Reuse canvas instead of creating new ones
-        if (!this.preprocessCanvas || !this.preprocessCtx) {
-            this.initializeCanvasPool();
-        }
-        // Clear and redraw on reused canvas
-        this.preprocessCtx.clearRect(0, 0, this.INPUT_SIZE, this.INPUT_SIZE);
-        this.preprocessCtx.drawImage(video, 0, 0, this.INPUT_SIZE, this.INPUT_SIZE);
-        const imageData = this.preprocessCtx.getImageData(0, 0, this.INPUT_SIZE, this.INPUT_SIZE);
-        const [R, G, B] = [[], [], []];
-        const { data } = imageData;
-        // Optimized pixel processing
-        for (let i = 0; i < data.length; i += 4) {
-            R.push(data[i] / 255);
-            G.push(data[i + 1] / 255);
-            B.push(data[i + 2] / 255);
-        }
-        const transposedData = new Float32Array(R.concat(G, B));
-        return new window.ort.Tensor("float32", transposedData, [1, 3, this.INPUT_SIZE, this.INPUT_SIZE]);
+    async setTorchEnabled(enabled) {
+        const torchEnabled = await this.cameraService.setTorchEnabled(enabled, this.videoStream);
+        return {
+            success: torchEnabled,
+            enabled: torchEnabled ? enabled : false
+        };
     }
-    getSessionOptions() {
+    async focusAtPoint(x, y) {
+        const focused = await this.cameraService.focusAtPoint(x, y, this.videoStream);
         return {
-            executionProviders: [
-                // Try WebGL first for GPU acceleration, fallback to WASM
-                'webgl',
-                'wasm'
-            ],
-            graphOptimizationLevel: 'all', // Maximum optimization
-            logSeverityLevel: this.debug ? 2 : 4, // Reduce logging overhead in production
-            logVerbosityLevel: 0,
-            enableCpuMemArena: true,
-            enableMemPattern: true,
-            executionMode: 'parallel',
-            interOpNumThreads: 2,
-            intraOpNumThreads: 2,
+            success: focused,
+            coordinates: { x, y }
         };
     }
+    // DETECTION METHODS
     async startDetection() {
+        this.logger.state('INICIANDO_DETECCION');
         try {
-            // Check if model is already preloaded
-            if (!this.session) {
-                this.isLoading = true;
-                this.statusMessage = "Cargando modelos...";
-                this.statusColor = "#007bff";
-                const modelPath = this.MODEL_PATH;
-                this.debugLog('🤖 Loading detection model:', modelPath);
-                const sessionOptions = this.getSessionOptions();
-                this.session = await window.ort.InferenceSession.create(modelPath, sessionOptions);
-                // Load MobileNet model if classification is enabled and not already loaded
-                if (this.useDocumentClassification && !this.mobileNetSession) {
-                    await this.loadMobileNetModel();
+            // Paso 1: Verificar y cargar modelos si es necesario
+            if (!this.detectionService.isModelLoaded()) {
+                const loadStartTime = performance.now();
+                this.updateStatus('Cargando modelo de detección...', 'Descargando red neuronal para reconocimiento', 'loading');
+                this.stateManager.updateCaptureState({ isLoading: true });
+                await this.detectionService.loadModel();
+                this.updateStatus('Cargando clasificador...', 'Preparando modelo de clasificación de documentos', 'loading');
+                await this.detectionService.loadClassificationModel();
+                const loadEndTime = performance.now();
+                const loadTime = loadEndTime - loadStartTime;
+                // Record ONNX load time
+                if (this.debug) {
+                    this.recordOnnxPerformance(loadTime, 0);
                 }
-                this.isModelPreloaded = true;
-                this.emitReadyEvent();
+                this.logger.state('MODELOS_CARGADOS_EN_DETECCION', { loadTime: Math.round(loadTime) });
             }
-            else {
-                this.debugLog('🚀 Using preloaded models');
-                this.statusMessage = "Usando modelos precargados...";
-                this.statusColor = "#007bff";
+            // Paso 2: Detectar y configurar dispositivos
+            this.updateStatus('Detectando cámaras...', 'Buscando dispositivos de captura disponibles', 'loading');
+            await this.cameraService.enumerateDevices();
+            // Paso 3: Configurar cámara seleccionada
+            this.updateStatus('Configurando cámara...', 'Estableciendo resolución y parámetros óptimos', 'loading');
+            const stream = await this.cameraService.setupCamera();
+            // Paso 4: Inicializar video y ocultar estado inmediatamente
+            this.updateStatus('Captura activa', 'Buscando documento en el marco de captura', 'active');
+            await this.initializeVideoStream(stream);
+            // Paso 5: Calibrar máscara
+            if (this.detectionContainer) {
+                const container = this.detectionContainer.parentElement;
+                const rect = container.getBoundingClientRect();
+                this.updateMaskDimensions(rect);
             }
-            this.statusMessage = "Configurando cámara...";
-            await this.setupCamera();
+            // Finalizar e iniciar captura
             this.startTime = Date.now();
-            this.isLoading = false;
+            this.stateManager.updateCaptureState({ isLoading: false });
             this.detectFrame();
         }
         catch (err) {
-            this.debugLog("Error al inicializar:", err);
-            this.statusMessage = "Error al inicializar el detector";
-            this.statusColor = "#ff6b6b";
-            this.isLoading = false;
+            this.logger.error('Error al inicializar detección:', err);
+            this.updateStatus('Error al iniciar captura', 'No se pudo completar la inicialización', 'error');
+            this.stateManager.updateCaptureState({ isLoading: false });
+        }
+    }
+    async initializeVideoStream(stream) {
+        if (this.videoRef) {
+            this.videoRef.srcObject = stream;
+            this.videoStream = stream;
+            const isRear = this.cameraService.isRearCamera(stream);
+            this.shouldMirrorVideo = !isRear;
+            this.logger.state('CAMARA_CONFIGURADA', {
+                isRearCamera: isRear,
+                shouldMirrorVideo: this.shouldMirrorVideo
+            });
+            return new Promise((resolve) => {
+                this.videoRef.onloadedmetadata = async () => {
+                    await this.videoRef.play();
+                    this.stateManager.updateCaptureState({ isVideoActive: true });
+                    resolve();
+                };
+            });
+        }
+        else {
+            throw new Error('Video element not available');
         }
     }
     async detectFrame() {
         try {
-            if (!this.videoRef || !this.canvasRef || !this.session)
+            const frameStartTime = performance.now();
+            const captureState = this.stateManager.getCaptureState();
+            if (!this.videoRef || !this.detectionContainer || !this.detectionService.isModelLoaded())
                 return;
-            // Pausar detección si está marcado como pausado
-            if (this.isDetectionPaused) {
-                // Solo continuar el bucle sin procesar detección
-                if (this.captureStep !== 'completed') {
+            if (captureState.isDetectionPaused) {
+                if (captureState.step !== 'completed') {
                     this.animationId = requestAnimationFrame(() => this.detectFrame());
                 }
                 return;
             }
-            // OPTIMIZATION 1: Frame skipping for performance
+            // Frame skipping for performance
             this.frameSkipCounter++;
             if (this.frameSkipCounter <= this.FRAME_SKIP) {
-                if (this.captureStep !== 'completed') {
+                if (captureState.step !== 'completed') {
                     this.animationId = requestAnimationFrame(() => this.detectFrame());
                 }
                 return;
             }
             this.frameSkipCounter = 0;
-            // OPTIMIZATION 2: Throttle inference based on time
+            // Throttle inference
             const currentTime = Date.now();
             if (currentTime - this.lastInferenceTime < this.MIN_INFERENCE_INTERVAL) {
-                if (this.captureStep !== 'completed') {
+                if (captureState.step !== 'completed') {
                     this.animationId = requestAnimationFrame(() => this.detectFrame());
                 }
                 return;
             }
             this.lastInferenceTime = currentTime;
-            const ctx = this.canvasRef.getContext("2d");
-            const inputTensor = this.preprocess(this.videoRef);
-            const feeds = { [this.session.inputNames[0]]: inputTensor };
-            const results = await this.session.run(feeds);
-            const output = results[this.session.outputNames[0]].data;
-            const finalBoxes = [];
-            for (let i = 0; i < output.length; i += 6) {
-                const [x1, y1, x2, y2, score, classId] = output.slice(i, i + 6);
-                if (score > this.CONFIDENCE_THRESHOLD) {
-                    finalBoxes.push({ x: x1, y: y1, w: x2 - x1, h: y2 - y1, score, classId });
-                    if (this.startTime && Date.now() - this.startTime < 5000) {
-                        const currentBox = { x: x1, y: y1, w: x2 - x1, h: y2 - y1, score };
-                        const isWellPositioned = this.isCardInFrame(currentBox);
-                        const effectiveScore = isWellPositioned ? score * 1.2 : score;
-                        if (effectiveScore > this.bestScore) {
-                            this.bestScore = effectiveScore;
-                        }
+            // Measure preprocessing and inference time
+            const inferenceStartTime = performance.now();
+            const inputTensor = this.detectionService.preprocess(this.videoRef);
+            // Standard detection without quality validation
+            const detections = await this.detectionService.runInference(inputTensor);
+            const inferenceTime = performance.now() - inferenceStartTime;
+            // Record ONNX performance metrics
+            if (this.debug) {
+                this.recordOnnxPerformance(0, inferenceTime);
+            }
+            // Update best score logic
+            if (this.startTime && Date.now() - this.startTime < 5000) {
+                detections.forEach((detection) => {
+                    const isWellPositioned = this.detectionService.isCardInFrame(detection);
+                    const effectiveScore = isWellPositioned ? detection.score * 1.2 : detection.score;
+                    if (effectiveScore > captureState.bestScore) {
+                        this.stateManager.updateCaptureState({ bestScore: effectiveScore });
                     }
-                }
+                });
             }
-            // OPTIMIZATION 3: Adaptive frame rate based on detection success
-            if (finalBoxes.length === 0) {
+            // Update document detection state
+            this.hasDocumentDetected = detections.length > 0;
+            // Adaptive frame rate
+            if (detections.length === 0) {
                 this.consecutiveFailures++;
             }
             else {
                 this.consecutiveFailures = 0;
             }
-            ctx.clearRect(0, 0, this.canvasRef.width, this.canvasRef.height);
+            // Update detection boxes for debug
+            if (this.debug) {
+                this.updateDetectionBoxes(detections);
+            }
+            else {
+                this.detectionBoxes = [];
+            }
+            this.updateMaskColor(detections);
+            // Record frame processing metrics
             if (this.debug) {
-                this.drawDetections(ctx, finalBoxes);
+                const frameEndTime = performance.now();
+                const totalFrameTime = frameEndTime - frameStartTime;
+                this.recordFrameProcessing(totalFrameTime, detections.length);
             }
-            this.updateGuidanceStatus(finalBoxes);
-            this.updateMaskColor(finalBoxes);
-            // Solo continuar si no hemos completado el proceso
-            if (this.captureStep !== 'completed') {
-                // OPTIMIZATION 4: Reduce frame rate when no detection for better battery life
+            // Continue detection loop
+            if (captureState.step !== 'completed') {
                 if (this.consecutiveFailures > this.MAX_FAILURES) {
-                    // Reduce to ~5fps when no detection for 0.5 seconds
                     setTimeout(() => this.detectFrame(), 200);
                 }
                 else {
@@ -641,102 +559,101 @@ export class JaakStamps {
             }
         }
         catch (e) {
-            this.debugLog("Error en inferencia:", e);
-            // Solo continuar si no hemos completado el proceso
-            if (this.captureStep !== 'completed') {
-                // On error, wait longer before retrying
+            this.logger.error('Error en inferencia de modelo:', e);
+            const captureState = this.stateManager.getCaptureState();
+            if (captureState.step !== 'completed') {
                 setTimeout(() => this.detectFrame(), 100);
             }
         }
     }
-    isCardInFrame(box) {
-        const cardCenterX = box.x + box.w / 2;
-        const cardCenterY = box.y + box.h / 2;
-        const frameCenterX = this.INPUT_SIZE / 2;
-        const frameCenterY = this.INPUT_SIZE / 2;
-        const toleranceX = 40;
-        const toleranceY = 30;
-        const isCentered = Math.abs(cardCenterX - frameCenterX) < toleranceX &&
-            Math.abs(cardCenterY - frameCenterY) < toleranceY;
-        const isGoodSize = box.w > 150 && box.w < 300 && box.h > 90 && box.h < 200;
-        return isCentered && isGoodSize;
+    // ... (continuing with remaining methods)
+    // Due to length constraints, I'll provide the key architectural changes
+    disconnectedCallback() {
+        this.cleanup();
     }
-    checkSideAlignment(box) {
-        if (!this.videoRef)
-            return { top: false, right: false, bottom: false, left: false };
-        // Get video dimensions to calculate actual mask boundaries in model space
+    cleanup() {
+        if (this.animationId) {
+            cancelAnimationFrame(this.animationId);
+        }
+        if (this.videoStream) {
+            this.videoStream.getTracks().forEach(track => track.stop());
+        }
+        if (this.alignmentTimer) {
+            clearTimeout(this.alignmentTimer);
+            this.alignmentTimer = undefined;
+        }
+        if (this.performanceUpdateInterval) {
+            clearInterval(this.performanceUpdateInterval);
+            this.performanceUpdateInterval = undefined;
+        }
+        this.detectionBoxes = [];
+        this.alignmentStartTime = undefined;
+        this.hasDocumentDetected = false;
+        this.serviceContainer?.cleanup();
+    }
+    render() {
+        const captureState = this.stateManager?.getCaptureState() || {
+            isVideoActive: false,
+            isLoading: false,
+            showFlipAnimation: false,
+            showSuccessAnimation: false,
+            step: 'front',
+            isCapturing: false
+        };
+        const cameraInfo = this.cameraService?.getCameraInfo() || {
+            availableCameras: [],
+            isMultipleCamerasAvailable: false,
+            selectedCameraId: null,
+            deviceType: 'desktop',
+            preferredFacing: null
+        };
+        return (h("div", { key: '7af79a0ff25b51790a9477cd7b338a0584172fc2', class: "detector-container" }, h("div", { key: 'ebf6a3811e0e599f29e98325b975a645e3bfb5e0', class: "video-container" }, h("video", { key: '5208fc9574fa78b1149be5839bc26d04bf9bcdfc', ref: el => this.videoRef = el, autoplay: true, muted: true, playsinline: true, class: this.shouldMirrorVideo ? 'mirror' : '', style: { display: captureState.isVideoActive ? 'block' : 'none' } }), h("div", { key: 'b507c786eccbd21acdd884ef50bc6ec280b9d437', ref: el => this.detectionContainer = el, class: `detection-overlay ${this.shouldMirrorVideo ? 'mirror' : ''}` }, this.debug && this.detectionBoxes.map((box, index) => (h("div", { key: index, class: "detection-box", style: {
+                position: 'absolute',
+                left: `${box.x}px`,
+                top: `${box.y}px`,
+                width: `${box.w}px`,
+                height: `${box.h}px`,
+                border: '2px solid #32406C',
+                pointerEvents: 'none',
+                boxSizing: 'border-box'
+            } })))), this.isMaskReady && (h("div", { key: '53066c626b23daae351ea9a80409e8882434b0dd', class: "overlay-mask" }, h("div", { key: '77bb4048d43e328e57a5c7e1909e0a59c8957217', class: "card-outline" }, h("div", { key: 'ea0f2610d903f985286856ab69f8be24fd42148e', class: "side side-top" }), h("div", { key: 'dc671111ef4adf33aa41f4457fdf344ede23eb80', class: "side side-right" }), h("div", { key: '2475ec41577dca92b425542c8861c570ed7ecd3b', class: "side side-bottom" }), h("div", { key: 'a06171c8eb1bd6353a6464485604560d73ac04b7', class: "side side-left" }), !captureState.showFlipAnimation && !captureState.showSuccessAnimation && (h("div", { key: 'ecfd98f36d457fe7282b26f6a0efef5361380c76', class: "guide-text" }, "Alinee su identificaci\u00F3n con el marco"))), captureState.step === 'back' && !captureState.showFlipAnimation && !captureState.showSuccessAnimation && (h("button", { key: 'f3c7b66500110437e9e4a7442cb327f2fdc6d71f', class: "skip-button", onClick: () => this.skipBackCapture(), type: "button" }, "Saltar reverso")), captureState.isVideoActive && (h("div", { key: 'b5b2a8dfc6dbcf381c32c4caa562c27ced2e3e56', class: "camera-controls" }, h("button", { key: '6b40d4649dfa22c5ea8ca90cacce35cd0ca53ff3', class: `camera-selector-button ${this.isSwitchingCamera ? 'loading' : ''}`, onClick: () => this.toggleCameraSelector(), type: "button", title: "Seleccionar c\u00E1mara", disabled: this.isSwitchingCamera }, this.isSwitchingCamera ? (h("div", { class: "button-spinner" })) : ('Cámaras')))), this.showCameraSelector && cameraInfo.availableCameras.length > 0 && (h("div", { key: '41feec90287510b08bd1090ad15586b323007c30', class: "camera-selector-dropdown" }, h("div", { key: '8310ebe3db842c463ad428b973f841053315a76f', class: "camera-selector-header" }, h("span", { key: '6693bdfa33643dfe73798d4f25b0c2d9de7aac7c' }, "Seleccionar C\u00E1mara"), h("button", { key: '8552d45e1482c570d7ff85588d4404eec7c369d7', class: "close-selector", onClick: () => this.toggleCameraSelector(), type: "button" }, "\u00D7")), h("div", { key: '5333ec0e5fb2c50a07a7c0b7d4dfb1bb4ee0df1c', class: "camera-list" }, cameraInfo.availableCameras.map((camera) => (h("button", { key: camera.id, class: `camera-option ${cameraInfo.selectedCameraId === camera.id ? 'selected' : ''}`, onClick: () => this.handleCameraSwitch(camera.id), type: "button" }, h("span", { class: "camera-label" }, camera.label || `Cámara ${cameraInfo.availableCameras.indexOf(camera) + 1}`), cameraInfo.selectedCameraId === camera.id && (h("span", { class: "selected-indicator" }, "\u2713")))))), h("div", { key: '8adf70b0e632c56a4784dec44621688809a3ff56', class: "device-info" }, h("small", { key: '2ea23922386ecda4a9011b50faba5efe4b4e60bb' }, "Dispositivo: ", cameraInfo.deviceType)))))), captureState.isCapturing && (h("div", { key: '8e693db67fe1e6ae8f11082b8993682b6d19b11d', class: "capture-animation" })), captureState.showFlipAnimation && (h("div", { key: '474489ed7848cdc163c492a5e19f5f13231e17b3', class: "flip-animation" }, h("div", { key: 'a9bd24ca21330882f001b7811077630eb1c30f50', class: "id-card-icon" }), h("div", { key: 'ffadb660a61e0f5e3e29bdc473d987e87dc4ad8a', class: "flip-text" }, "\u00A1Voltea tu identificaci\u00F3n!"))), captureState.showSuccessAnimation && (h("div", { key: 'd2522ee33aa159d49f040a293775892fb1cb81b5', class: "success-animation" }, h("div", { key: 'e7f899fac58bc9a3d51cf2cb89ee33bb320b241f', class: "check-icon" }), h("div", { key: 'd5d0ee1f37dbc659ca625ad03cbce325be0cf0a6', class: "success-text" }, "\u00A1Proceso completado!"))), h("div", { key: '425d347666032c3982a660ebee13b47670b996cb', class: `component-status status-${this.currentStatus.type}` }, (this.currentStatus.type === 'loading' || this.currentStatus.type === 'initializing') && (h("div", { key: '4d396fa107872f9a1e526fd59dc4edf279a05792', class: "status-spinner" })), h("div", { key: '232e9ae24c8cf5ef8ac0e3442e45a920799c724d', class: "status-content" }, h("div", { key: 'fe9dc0ca6d8e8276052bac7d2d44f1c7c9730364', class: "status-message" }, this.currentStatus.message), this.currentStatus.description && (h("div", { key: '6910c7ac78fd89e6fa1165446ec6d46fb356035c', class: "status-description" }, this.currentStatus.description)))), this.debug && (h("div", { key: '7282b8afaf03da53b01a23d04babd772528c3c14', class: "performance-monitor" }, h("div", { key: 'b582b3124fed13387cd70a02a34ab2bb541f3bfc', class: "performance-expanded" }, h("div", { key: '764bac2d61224b9a5f306f50934d410e1bd27787', class: "metrics-row" }, h("div", { key: '261563f8314a9f6069b1ac6362eb9c38936a9dc7', class: "metric-compact" }, h("span", { key: '4feea98eff86620c1bc90eb65d9799102423109d', class: "metric-label" }, "FPS"), h("span", { key: 'eb15f13b27b8aa50701ad3d11c4cf87200010b67', class: `metric-value ${this.performanceData.fps < 15 ? 'warning' : this.performanceData.fps < 10 ? 'danger' : 'good'}` }, this.performanceData.fps)), h("div", { key: '0813c35c2c33286f2276bfb5adce59b32c7bb597', class: "metric-compact" }, h("span", { key: '201e7bcb556e63b141e42a3ffc3419eb4284bfa8', class: "metric-label" }, "MEM"), h("span", { key: '4f6703cbe0128440d0f2f22f631035ab85422c64', class: `metric-value ${this.performanceData.memoryUsage > 100 ? 'warning' : this.performanceData.memoryUsage > 200 ? 'danger' : 'good'}` }, this.performanceData.memoryUsage, "MB"))), h("div", { key: '6343c361c93138b9ea66e8ae8acd361b93333f8c', class: "metrics-row" }, h("div", { key: 'd3c81fe597004bf380fae2d32f3a8314317e7769', class: "metric-compact" }, h("span", { key: 'fce572af3e200a611974dceef4da02f6aecedffc', class: "metric-label" }, "INF"), h("span", { key: '18dd78d54dcecfb70ddf59b782f87f8c6f208b0f', class: `metric-value ${this.performanceData.inferenceTime > 100 ? 'warning' : this.performanceData.inferenceTime > 200 ? 'danger' : 'good'}` }, this.performanceData.inferenceTime, "ms")), h("div", { key: '4c31ebfd835b017fd3e41b23d6bd9b19add511aa', class: "metric-compact" }, h("span", { key: '66b1a380b9479a8fc1e8c2385cb72aa4158dc74e', class: "metric-label" }, "FRAME"), h("span", { key: '3c6e41f7f11123c524d3a9df409345929d63f352', class: `metric-value ${this.performanceData.frameProcessingTime > 50 ? 'warning' : this.performanceData.frameProcessingTime > 100 ? 'danger' : 'good'}` }, this.performanceData.frameProcessingTime, "ms"))), h("div", { key: '3b522e2cdfe4bd9f1dd6eb0f91ee3577dc43e490', class: "metrics-row" }, h("div", { key: 'fa1e6f687b43aa2582b8b3426feb03a16c6493fc', class: "metric-compact" }, h("span", { key: 'a9355091e71a33a6a0d7cc6c11171dcda2e51b22', class: "metric-label" }, "DET"), h("span", { key: 'beca5a7ccf4853675cf8366bcf577ebfbd46c4f0', class: "metric-value good" }, this.performanceData.successfulDetections, "/", this.performanceData.totalDetections)), h("div", { key: '4b07fc9b3d35f99bc6e77c8726192cde0476a787', class: "metric-compact" }, h("span", { key: 'a1674b538f45328ee0afb00e582c07e0b4ccf553', class: "metric-label" }, "RATE"), h("span", { key: 'fd384a5137bc3df6c939d3d698a3ef80e9087030', class: `metric-value ${this.performanceData.detectionRate < 30 ? 'danger' : this.performanceData.detectionRate < 60 ? 'warning' : 'good'}` }, this.performanceData.detectionRate, "%")))))), h("div", { key: 'ebbaf15a0ad96e4da5bbf746c32d7a4abb51b973', class: "watermark" }, h("img", { key: '8e7d274b529d1f7020ec4a7225579792763f871a', src: "https://storage.googleapis.com/jaak-static/commons/powered-by-jaak.png", alt: "Powered by Jaak" })))));
+    }
+    // Utility methods
+    updateDetectionBoxes(boxes) {
+        if (!this.videoRef || !this.detectionContainer)
+            return;
         const videoWidth = this.videoRef.videoWidth;
         const videoHeight = this.videoRef.videoHeight;
-        if (videoWidth === 0 || videoHeight === 0) {
-            return { top: false, right: false, bottom: false, left: false };
-        }
-        // Calculate video aspect ratio
+        const container = this.detectionContainer.parentElement;
+        const containerRect = container.getBoundingClientRect();
+        const containerWidth = containerRect.width;
+        const containerHeight = containerRect.height;
+        if (videoWidth === 0 || videoHeight === 0)
+            return;
         const videoAspectRatio = videoWidth / videoHeight;
-        // The model sees video stretched to 320x320, but we need to calculate where
-        // the mask should be in this distorted space to match the visual mask
-        // In the visual display, we calculate mask size based on the limiting dimension
-        // We need to replicate this logic but account for the distortion in model space
-        // Calculate the "display" dimensions (what the visual mask calculations use)
-        const containerAspectRatio = 1; // Assume square container for simplicity
+        const containerAspectRatio = containerWidth / containerHeight;
         let displayedVideoWidth, displayedVideoHeight;
+        let videoOffsetX = 0, videoOffsetY = 0;
         if (videoAspectRatio > containerAspectRatio) {
-            // Video is wider - letterboxed in display
-            displayedVideoWidth = this.INPUT_SIZE;
-            displayedVideoHeight = this.INPUT_SIZE / videoAspectRatio;
-        }
-        else {
-            // Video is taller - pillarboxed in display  
-            displayedVideoHeight = this.INPUT_SIZE;
-            displayedVideoWidth = this.INPUT_SIZE * videoAspectRatio;
-        }
-        // Calculate mask dimensions using the same logic as updateMaskDimensions
-        const maxWidthByHeight = displayedVideoHeight * this.ID1_ASPECT_RATIO;
-        let visualMaskWidth, visualMaskHeight;
-        const sizeRatio = this.maskSize / 100;
-        if (maxWidthByHeight <= displayedVideoWidth) {
-            // Video height is the limiting factor
-            visualMaskHeight = displayedVideoHeight * sizeRatio;
-            visualMaskWidth = visualMaskHeight * this.ID1_ASPECT_RATIO;
+            displayedVideoWidth = containerWidth;
+            displayedVideoHeight = containerWidth / videoAspectRatio;
+            videoOffsetY = (containerHeight - displayedVideoHeight) / 2;
         }
         else {
-            // Video width is the limiting factor
-            visualMaskWidth = displayedVideoWidth * sizeRatio;
-            visualMaskHeight = visualMaskWidth / this.ID1_ASPECT_RATIO;
-        }
-        // Now map these visual mask dimensions to the distorted model space
-        // The model stretches video to 320x320, so we need to apply the inverse transformation
-        const modelMaskWidth = visualMaskWidth * (this.INPUT_SIZE / displayedVideoWidth);
-        const modelMaskHeight = visualMaskHeight * (this.INPUT_SIZE / displayedVideoHeight);
-        // Calculate mask boundaries in model coordinate system (always centered in 320x320)
-        const maskCenterX = this.INPUT_SIZE / 2;
-        const maskCenterY = this.INPUT_SIZE / 2;
-        const maskLeft = maskCenterX - (modelMaskWidth / 2);
-        const maskRight = maskCenterX + (modelMaskWidth / 2);
-        const maskTop = maskCenterY - (modelMaskHeight / 2);
-        const maskBottom = maskCenterY + (modelMaskHeight / 2);
-        // Obtener las coordenadas del documento detectado
-        let docLeft = box.x;
-        let docRight = box.x + box.w;
-        const docTop = box.y;
-        const docBottom = box.y + box.h;
-        // Si el video está en modo mirror, invertir las coordenadas horizontales
-        if (this.shouldMirrorVideo) {
-            const originalDocLeft = docLeft;
-            const originalDocRight = docRight;
-            docLeft = this.INPUT_SIZE - originalDocRight;
-            docRight = this.INPUT_SIZE - originalDocLeft;
+            displayedVideoHeight = containerHeight;
+            displayedVideoWidth = containerHeight * videoAspectRatio;
+            videoOffsetX = (containerWidth - displayedVideoWidth) / 2;
         }
-        // Tolerancia para considerar que un lado está alineado (en píxeles)
-        const tolerance = this.alignmentTolerance;
-        return {
-            top: Math.abs(docTop - maskTop) <= tolerance,
-            right: Math.abs(docRight - maskRight) <= tolerance,
-            bottom: Math.abs(docBottom - maskBottom) <= tolerance,
-            left: Math.abs(docLeft - maskLeft) <= tolerance
-        };
-    }
-    areAllSidesAligned(alignment) {
-        return alignment.top && alignment.right && alignment.bottom && alignment.left;
+        const INPUT_SIZE = 320;
+        const scaleX = displayedVideoWidth / INPUT_SIZE;
+        const scaleY = displayedVideoHeight / INPUT_SIZE;
+        this.detectionBoxes = boxes.map(det => ({
+            x: det.x * scaleX + videoOffsetX,
+            y: det.y * scaleY + videoOffsetY,
+            w: det.w * scaleX,
+            h: det.h * scaleY,
+            score: det.score
+        }));
     }
     updateMaskColor(boxes) {
         const cardOutline = this.el.shadowRoot?.querySelector('.card-outline');
@@ -749,297 +666,327 @@ export class JaakStamps {
         let currentAlignment = { top: false, right: false, bottom: false, left: false };
         if (boxes.length > 0) {
             bestBox = boxes.reduce((best, current) => current.score > best.score ? current : best);
-            currentAlignment = this.checkSideAlignment(bestBox);
+            const maskConfig = {
+                INPUT_SIZE: 320,
+                ID1_ASPECT_RATIO: 85.60 / 53.98,
+                shouldMirrorVideo: this.shouldMirrorVideo,
+                alignmentTolerance: this.alignmentTolerance,
+                maskSize: this.maskSize,
+                videoRef: this.videoRef
+            };
+            currentAlignment = this.detectionService.checkSideAlignment(bestBox, maskConfig);
             this.sideAlignment = currentAlignment;
         }
         else {
-            // Reset alignment when no detection
             this.sideAlignment = { top: false, right: false, bottom: false, left: false };
         }
-        // Actualizar colores de cada lado individualmente
         topSide?.classList.toggle('aligned', currentAlignment.top);
         rightSide?.classList.toggle('aligned', currentAlignment.right);
         bottomSide?.classList.toggle('aligned', currentAlignment.bottom);
         leftSide?.classList.toggle('aligned', currentAlignment.left);
-        // Verificar si todos los lados están alineados
-        const allSidesAligned = this.areAllSidesAligned(currentAlignment);
+        const allSidesAligned = this.detectionService.areAllSidesAligned(currentAlignment);
         if (allSidesAligned && bestBox) {
             cardOutline?.classList.add('perfect-match');
             corners?.forEach(corner => corner.classList.add('perfect-match'));
+            // Debug logging
+            this.logger.state('CAPTURE_EVALUATION', {
+                allSidesAligned: true,
+                hasScreenshotTaken: this.hasScreenshotTaken,
+                captureDelay: this.captureDelay,
+                alignmentStartTime: this.alignmentStartTime
+            });
             if (!this.hasScreenshotTaken) {
-                this.lastDetectedBox = bestBox;
-                this.takeScreenshot().catch(error => {
-                    this.debugLog('❌ Error taking screenshot:', error);
+                const currentTime = Date.now();
+                // Initialize alignment start time if not set
+                if (!this.alignmentStartTime) {
+                    this.alignmentStartTime = currentTime;
+                    this.logger.state('ALIGNMENT_TIMER_STARTED', { startTime: currentTime });
+                }
+                // Check if document has been aligned for the configured delay
+                const alignmentDuration = currentTime - this.alignmentStartTime;
+                this.logger.state('ALIGNMENT_DURATION_CHECK', {
+                    alignmentDuration,
+                    captureDelay: this.captureDelay,
+                    readyToCapture: alignmentDuration >= this.captureDelay
                 });
-                this.hasScreenshotTaken = true;
-                // Reset para permitir segunda captura
-                setTimeout(() => {
-                    this.hasScreenshotTaken = false;
-                }, 2000);
+                if (alignmentDuration >= this.captureDelay) {
+                    this.logger.state('TRIGGERING_CAPTURE', {
+                        alignmentDuration,
+                        captureDelay: this.captureDelay
+                    });
+                    this.lastDetectedBox = bestBox;
+                    this.takeScreenshot().catch(error => {
+                        this.logger.error('Error al tomar captura de pantalla:', error);
+                    });
+                    this.hasScreenshotTaken = true;
+                    this.alignmentStartTime = undefined;
+                    setTimeout(() => {
+                        this.hasScreenshotTaken = false;
+                    }, 2000);
+                }
             }
         }
         else {
             cardOutline?.classList.remove('perfect-match');
             corners?.forEach(corner => corner.classList.remove('perfect-match'));
-        }
-    }
-    updateGuidanceStatus(boxes) {
-        if (boxes.length === 0) {
-            this.statusMessage = "Posicione la identificación dentro del marco";
-            this.statusColor = "#ff6b6b";
-        }
-        else {
-            const bestBox = boxes.reduce((best, current) => current.score > best.score ? current : best);
-            const alignment = this.checkSideAlignment(bestBox);
-            const alignedSides = [alignment.top, alignment.right, alignment.bottom, alignment.left].filter(Boolean).length;
-            const allSidesAligned = this.areAllSidesAligned(alignment);
-            if (allSidesAligned) {
-                this.statusMessage = "Identificación perfectamente alineada. Mantenga inmóvil";
-                this.statusColor = "#00ff00";
-            }
-            else if (alignedSides > 0) {
-                this.statusMessage = `Alinee los lados restantes (${alignedSides}/4 lados correctos)`;
-                this.statusColor = "#ffb366";
+            // Reset alignment timer when document moves out of position
+            if (this.alignmentStartTime) {
+                this.alignmentStartTime = undefined;
             }
-            else if (bestBox.w < 150) {
-                this.statusMessage = "Identificación detectada. Acerque al marco";
-                this.statusColor = "#ffb366";
-            }
-            else {
-                this.statusMessage = "Identificación detectada. Alinee con el marco";
-                this.statusColor = "#ffb366";
+            if (this.alignmentTimer) {
+                clearTimeout(this.alignmentTimer);
+                this.alignmentTimer = undefined;
             }
         }
     }
-    drawDetections(ctx, boxes) {
-        if (!this.videoRef)
-            return;
-        // Get video and container dimensions
-        const videoWidth = this.videoRef.videoWidth;
-        const videoHeight = this.videoRef.videoHeight;
-        const containerWidth = this.canvasRef.width;
-        const containerHeight = this.canvasRef.height;
-        if (videoWidth === 0 || videoHeight === 0)
-            return;
-        // Calculate video aspect ratio and container aspect ratio
-        const videoAspectRatio = videoWidth / videoHeight;
-        const containerAspectRatio = containerWidth / containerHeight;
-        // Determine how video fits in container (same logic as updateMaskDimensions)
-        let displayedVideoWidth, displayedVideoHeight;
-        let videoOffsetX = 0, videoOffsetY = 0;
-        if (videoAspectRatio > containerAspectRatio) {
-            // Video is wider - letterboxed (black bars top/bottom)
-            displayedVideoWidth = containerWidth;
-            displayedVideoHeight = containerWidth / videoAspectRatio;
-            videoOffsetY = (containerHeight - displayedVideoHeight) / 2;
-        }
-        else {
-            // Video is taller - pillarboxed (black bars left/right)
-            displayedVideoHeight = containerHeight;
-            displayedVideoWidth = containerHeight * videoAspectRatio;
-            videoOffsetX = (containerWidth - displayedVideoWidth) / 2;
-        }
-        // Scale factor from model coordinates (320x320) to displayed video area
-        const scaleX = displayedVideoWidth / this.INPUT_SIZE;
-        const scaleY = displayedVideoHeight / this.INPUT_SIZE;
-        boxes.forEach(det => {
-            // Convert model coordinates to displayed video coordinates
-            const x = det.x * scaleX + videoOffsetX;
-            const y = det.y * scaleY + videoOffsetY;
-            const w = det.w * scaleX;
-            const h = det.h * scaleY;
-            ctx.strokeStyle = "#32406C";
-            ctx.lineWidth = 2;
-            ctx.strokeRect(x, y, w, h);
-        });
-    }
     async takeScreenshot() {
         if (!this.videoRef || !this.lastDetectedBox)
             return;
-        // Activar animación
+        this.logger.state('INICIANDO_CAPTURA', {
+            captureStep: this.stateManager.getCaptureState().step,
+            detectedBox: this.lastDetectedBox,
+            videoResolution: {
+                width: this.videoRef.videoWidth,
+                height: this.videoRef.videoHeight
+            }
+        });
+        this.stateManager.updateCaptureState({ isCapturing: true });
         this.triggerCaptureAnimation();
-        // OPTIMIZATION: Reuse capture canvas for full frame
-        if (!this.captureCanvas || !this.captureCtx) {
-            this.initializeCanvasPool();
-        }
-        // Resize reused canvas for full frame
-        this.captureCanvas.width = this.videoRef.videoWidth;
-        this.captureCanvas.height = this.videoRef.videoHeight;
-        this.captureCtx.drawImage(this.videoRef, 0, 0, this.captureCanvas.width, this.captureCanvas.height);
-        // Calcular las coordenadas de recorte basadas en la detección
-        const scaleX = this.videoRef.videoWidth / this.INPUT_SIZE;
-        const scaleY = this.videoRef.videoHeight / this.INPUT_SIZE;
+        // Create capture canvas
+        const captureCanvas = document.createElement('canvas');
+        captureCanvas.width = this.videoRef.videoWidth;
+        captureCanvas.height = this.videoRef.videoHeight;
+        const captureCtx = captureCanvas.getContext('2d', { alpha: false });
+        captureCtx.drawImage(this.videoRef, 0, 0, captureCanvas.width, captureCanvas.height);
+        // Calculate crop coordinates
+        const INPUT_SIZE = 320;
+        const scaleX = this.videoRef.videoWidth / INPUT_SIZE;
+        const scaleY = this.videoRef.videoHeight / INPUT_SIZE;
         const cropX = Math.max(0, (this.lastDetectedBox.x * scaleX) - this.cropMargin);
         const cropY = Math.max(0, (this.lastDetectedBox.y * scaleY) - this.cropMargin);
         const cropWidth = Math.min((this.lastDetectedBox.w * scaleX) + (2 * this.cropMargin), this.videoRef.videoWidth - cropX);
         const cropHeight = Math.min((this.lastDetectedBox.h * scaleY) + (2 * this.cropMargin), this.videoRef.videoHeight - cropY);
-        // OPTIMIZATION: Create temporary canvas only for cropped version
-        // (We reuse main capture canvas for full frame)
+        // Create cropped version
         const croppedCanvas = document.createElement('canvas');
         croppedCanvas.width = cropWidth;
         croppedCanvas.height = cropHeight;
         const croppedCtx = croppedCanvas.getContext('2d', { alpha: false });
-        // Recortar la identificación del frame completo
-        croppedCtx.drawImage(this.videoRef, cropX, cropY, cropWidth, cropHeight, // Área de origen
-        0, 0, cropWidth, cropHeight // Área de destino
-        );
-        if (this.captureStep === 'front') {
-            // Captura del frente usando canvas reutilizado
-            this.capturedFullFrame = this.captureCanvas.toDataURL('image/png');
-            this.capturedCroppedId = croppedCanvas.toDataURL('image/png');
+        croppedCtx.drawImage(this.videoRef, cropX, cropY, cropWidth, cropHeight, 0, 0, cropWidth, cropHeight);
+        const captureState = this.stateManager.getCaptureState();
+        if (captureState.step === 'front') {
+            this.stateManager.setCapturedImages({
+                front: {
+                    fullFrame: captureCanvas.toDataURL('image/png'),
+                    cropped: croppedCanvas.toDataURL('image/png')
+                }
+            });
             // Check if document classification is enabled
             if (this.useDocumentClassification) {
-                // Load MobileNet model if not loaded yet (lazy loading)
-                if (!this.mobileNetSession) {
-                    try {
-                        await this.loadMobileNetModel();
-                    }
-                    catch (error) {
-                        this.debugLog('⚠️ Failed to load classification model, continuing without classification:', error);
-                    }
-                }
-                // Classify the cropped document if model is available
-                if (this.mobileNetSession) {
-                    const classification = await this.classifyDocument(croppedCanvas);
-                    if (classification && classification.class === 'passport') {
-                        // If it's a passport, skip back capture since passports don't have a back side
-                        this.debugLog('📄 Passport detected - skipping back capture');
-                        this.completeProcess(true);
-                        return;
-                    }
+                const classification = await this.detectionService.classifyDocument(croppedCanvas);
+                if (classification && classification.class === 'passport') {
+                    this.logger.state('PASAPORTE_DETECTADO_SALTANDO_REVERSO', { classification: classification?.class });
+                    this.completeProcess(true);
+                    return;
                 }
             }
-            // For other IDs, continue with normal flow (back capture)
-            this.captureStep = 'back';
-            this.statusMessage = "Voltee la identificación y muestre la parte trasera";
-            this.statusColor = "#007bff";
-            // Pausar detección durante la animación de giro
-            this.isDetectionPaused = true;
-            // Mostrar animación de giro después de la captura
+            this.stateManager.updateCaptureState({
+                step: 'back',
+                isDetectionPaused: true,
+                showFlipAnimation: true
+            });
             setTimeout(() => {
-                this.showFlipAnimation = true;
-                setTimeout(() => {
-                    this.showFlipAnimation = false;
-                    // Reanudar detección después de que termine la animación
-                    this.isDetectionPaused = false;
-                }, 3000);
-            }, 800);
-            this.debugLog('📸 FRENTE capturado. Esperando trasera...');
+                this.stateManager.updateCaptureState({
+                    showFlipAnimation: false,
+                    isDetectionPaused: false
+                });
+            }, 3000);
         }
-        else if (this.captureStep === 'back') {
-            // Captura de la trasera usando canvas reutilizado
-            this.capturedBackFullFrame = this.captureCanvas.toDataURL('image/png');
-            this.capturedBackCroppedId = croppedCanvas.toDataURL('image/png');
+        else if (captureState.step === 'back') {
+            this.stateManager.setCapturedImages({
+                back: {
+                    fullFrame: captureCanvas.toDataURL('image/png'),
+                    cropped: croppedCanvas.toDataURL('image/png')
+                }
+            });
             this.completeProcess(false);
-            this.debugLog('📸 TRASERA capturada. Proceso completado. Detector detenido. Imágenes emitidas.');
         }
     }
     triggerCaptureAnimation() {
-        this.isCapturing = true;
-        // Agregar clase de animación al marco
         const cardOutline = this.el.shadowRoot?.querySelector('.card-outline');
         cardOutline?.classList.add('capturing');
-        // Limpiar animación después de que termine
         setTimeout(() => {
-            this.isCapturing = false;
+            this.stateManager.updateCaptureState({ isCapturing: false });
             cardOutline?.classList.remove('capturing');
         }, 600);
     }
+    completeProcess(skippedBack = false) {
+        this.stateManager.updateCaptureState({
+            step: 'completed',
+            showSuccessAnimation: true
+        });
+        const capturedImages = this.stateManager.getCapturedImages();
+        capturedImages.metadata.processCompleted = true;
+        capturedImages.metadata.backCaptureSkipped = skippedBack;
+        this.stateManager.setCapturedImages(capturedImages);
+        this.stopDetection();
+        this.updateStatus('Proceso completado', `${capturedImages.metadata.totalImages} imágenes capturadas exitosamente`, 'ready');
+        const finalImages = {
+            ...capturedImages,
+            timestamp: new Date().toISOString()
+        };
+        this.captureCompleted.emit(finalImages);
+        setTimeout(() => {
+            this.stateManager.updateCaptureState({ showSuccessAnimation: false });
+        }, 3000);
+        this.logger.state('PROCESO_COMPLETADO', {
+            skippedBack,
+            totalImages: capturedImages.metadata.totalImages,
+            timestamp: new Date().toISOString()
+        });
+    }
     stopDetection() {
         if (this.animationId) {
             cancelAnimationFrame(this.animationId);
             this.animationId = undefined;
         }
-        // Limpiar canvas para eliminar cualquier detección visual residual
-        if (this.canvasRef) {
-            const ctx = this.canvasRef.getContext("2d");
-            ctx.clearRect(0, 0, this.canvasRef.width, this.canvasRef.height);
+        this.detectionBoxes = [];
+        this.logger.state('DETECTOR_DETENIDO', { timestamp: Date.now() });
+    }
+    toggleCameraSelector() {
+        if (this.isSwitchingCamera)
+            return; // Don't toggle if switching camera
+        this.showCameraSelector = !this.showCameraSelector;
+    }
+    async handleCameraSwitch(cameraId) {
+        if (this.isSwitchingCamera)
+            return; // Prevent multiple simultaneous switches
+        try {
+            // Close the selector immediately when user selects a camera
+            this.showCameraSelector = false;
+            this.isSwitchingCamera = true;
+            this.logger.state('INICIANDO_CAMBIO_CAMARA', {
+                from: this.cameraService.getSelectedCameraId(),
+                to: cameraId
+            });
+            // Stop current video stream
+            if (this.videoStream) {
+                this.videoStream.getTracks().forEach(track => track.stop());
+            }
+            // Switch camera in service
+            await this.cameraService.switchCamera(cameraId);
+            // Setup new camera stream
+            const newStream = await this.cameraService.setupCamera();
+            // Update video element
+            await this.initializeVideoStream(newStream);
+            this.logger.state('CAMBIO_CAMARA_EXITOSO', {
+                newCameraId: cameraId,
+                isRearCamera: this.cameraService.isRearCamera(newStream)
+            });
+        }
+        catch (error) {
+            this.logger.error('Error al cambiar cámara:', error);
+            // Try to restore previous camera if switch failed
+            try {
+                const fallbackStream = await this.cameraService.setupCamera();
+                await this.initializeVideoStream(fallbackStream);
+            }
+            catch (fallbackError) {
+                this.logger.error('Error al restaurar cámara anterior:', fallbackError);
+                this.updateStatus('Error al cambiar cámara', 'No se pudo completar el cambio de dispositivo', 'error');
+            }
+        }
+        finally {
+            this.isSwitchingCamera = false;
         }
-        this.debugLog('🛑 Detector de identificación detenido');
     }
     resetDetection() {
-        this.bestScore = 0;
-        this.startTime = Date.now();
-        this.statusMessage = "Sistema reiniciado. Posicione la identificación";
-        this.statusColor = "#aaa";
+        const currentCaptureState = this.stateManager.getCaptureState();
+        const wasVideoActive = currentCaptureState.isVideoActive;
+        this.stateManager.reset();
+        if (wasVideoActive) {
+            this.stateManager.updateCaptureState({ isVideoActive: true });
+        }
         this.hasScreenshotTaken = false;
-        this.capturedFullFrame = null;
-        this.capturedCroppedId = null;
-        this.capturedBackFullFrame = null;
-        this.capturedBackCroppedId = null;
-        this.captureStep = 'front';
-        this.isCapturing = false;
-        this.showFlipAnimation = false;
-        this.showSuccessAnimation = false;
-        this.isDetectionPaused = false;
-        this.isLoading = false;
-        this.lastDetectedBox = undefined;
-        this.isModelPreloaded = false;
-        // Reset performance counters
+        this.startTime = Date.now();
         this.frameSkipCounter = 0;
         this.consecutiveFailures = 0;
         this.lastInferenceTime = 0;
-        if (this.canvasRef) {
-            const ctx = this.canvasRef.getContext("2d");
-            ctx.clearRect(0, 0, this.canvasRef.width, this.canvasRef.height);
+        this.detectionBoxes = [];
+        this.alignmentStartTime = undefined;
+        this.hasDocumentDetected = false;
+        if (this.alignmentTimer) {
+            clearTimeout(this.alignmentTimer);
+            this.alignmentTimer = undefined;
         }
-        // Reiniciar el detector si estaba funcionando
-        if (this.isVideoActive && this.session) {
+        if (wasVideoActive && this.detectionService.isModelLoaded()) {
+            this.updateStatus('Captura reiniciada', 'Buscando documento en el marco de captura', 'active');
             this.detectFrame();
         }
-    }
-    completeProcess(skippedBack = false) {
-        this.captureStep = 'completed';
-        this.statusMessage = skippedBack ?
-            "Proceso completado (solo frente capturado)" :
-            "Proceso de captura completado exitosamente";
-        this.statusColor = "#28a745";
-        // Detener el detector
-        this.stopDetection();
-        // Emitir evento con las imágenes capturadas
-        const capturedImages = {
-            front: {
-                fullFrame: this.capturedFullFrame,
-                cropped: this.capturedCroppedId
-            },
-            back: {
-                fullFrame: this.capturedBackFullFrame,
-                cropped: this.capturedBackCroppedId
-            },
-            timestamp: new Date().toISOString(),
-            metadata: {
-                totalImages: skippedBack ? 2 : 4,
-                processCompleted: true,
-                backCaptureSkipped: skippedBack
-            }
-        };
-        this.captureCompleted.emit(capturedImages);
-        // Mostrar animación de éxito después de la captura
-        setTimeout(() => {
-            this.showSuccessAnimation = true;
-            setTimeout(() => {
-                this.showSuccessAnimation = false;
-            }, 3000);
-        }, 800);
+        else {
+            this.updateStatus('Listo para capturar', '', 'ready');
+        }
     }
     exitSession() {
         if (this.videoStream) {
             this.videoStream.getTracks().forEach(track => track.stop());
             this.videoStream = undefined;
-            this.isVideoActive = false;
-            this.statusMessage = "Sesión finalizada.";
-            this.statusColor = "#aaa";
-        }
-        this.isLoading = false;
-        // Limpiar canvas al finalizar sesión
-        if (this.canvasRef) {
-            const ctx = this.canvasRef.getContext("2d");
-            ctx.clearRect(0, 0, this.canvasRef.width, this.canvasRef.height);
+            this.stateManager.updateCaptureState({ isVideoActive: false, isLoading: false });
         }
+        this.isMaskReady = false;
+        this.updateStatus('Sesión finalizada', '', 'ready');
+        this.detectionBoxes = [];
         this.cleanup();
     }
-    render() {
-        return (h("div", { key: '42591479495df221b101555198a23288d7d765b0', class: "detector-container" }, h("div", { key: '2b9ab48572aa2fb5542b8a8dc1b70a0f2a6eca89', class: "video-container" }, h("video", { key: 'b9e84f2eb67fa6f7f158e19b90871a1eebee624b', ref: el => this.videoRef = el, autoplay: true, muted: true, playsinline: true, class: this.shouldMirrorVideo ? 'mirror' : '', style: { display: this.isVideoActive ? 'block' : 'none' } }), h("canvas", { key: 'a82fc4826e220e696799b07b3510456f174a6628', ref: el => this.canvasRef = el, class: this.shouldMirrorVideo ? 'mirror' : '' }), this.isMaskReady && (h("div", { key: '9b3b838f99030e3dfa760fa0dd7c89ff24f26ed9', class: "overlay-mask" }, h("div", { key: 'f6a3b1ac2f12c1fb081f6b5eb853e627040396f4', class: "card-outline" }, h("div", { key: '6626259249ac5e0fd6ba665ab802af1ac2f9fc17', class: "side side-top" }), h("div", { key: '7a3195c96b2406b40b122f4267c2a251614cdede', class: "side side-right" }), h("div", { key: 'ece78305cfb083ada1d44de1d7d5226730879cc3', class: "side side-bottom" }), h("div", { key: '107468c583bbb01dd46c36c096e49be8e0b574ba', class: "side side-left" }), h("div", { key: 'c590f13b80c5e37c0ac0c68cfc2e2904b4345ebc', class: "corner corner-tl" }), h("div", { key: 'ab1e5aab179068ad1bc7b58ef3628d9618a877a8', class: "corner corner-tr" }), h("div", { key: '3a1db6cf1105bd3a2dfe7d4b998e79f6e40625ec', class: "corner corner-bl" }), h("div", { key: '5f9bc4e4557e5539335894160dccbaa2a6d6ac2d', class: "corner corner-br" }), !this.showFlipAnimation && !this.showSuccessAnimation && (h("div", { key: '8226d6721b0ae800f935e978a93113bd3b99656a', class: "guide-text" }, this.statusMessage))), this.captureStep === 'back' && !this.showFlipAnimation && !this.showSuccessAnimation && (h("button", { key: '16cec7ca4a80ba0db1ace768826da17063eddb3e', class: "skip-button", onClick: () => this.skipBackCapture(), type: "button" }, "Saltar reverso")))), this.isCapturing && (h("div", { key: 'bfdca0059eb50d37a77e8e43ef963ba7ed953edf', class: "capture-animation" })), this.showFlipAnimation && (h("div", { key: 'a1ad4b4f884d7d9f6090f148ddd6df19250073dd', class: "flip-animation" }, h("div", { key: 'e159ce385824dc049a6e9409d3747105c6f0a08e', class: "id-card-icon" }), h("div", { key: '6fcff650a3c7fdb16f8d327750e06055b9a93d0d', class: "flip-text" }, "\u00A1Voltea tu identificaci\u00F3n!"))), this.showSuccessAnimation && (h("div", { key: 'c4b76ecb19c65969676e5156689c2c0b1c9a584e', class: "success-animation" }, h("div", { key: '12203a8fe7ee878089b3dda1d1142cde5489eed0', class: "check-icon" }), h("div", { key: 'a2d41c8944873d33106994b8d56c3ee1ee1ae9fc', class: "success-text" }, "\u00A1Proceso completado!"))), this.isLoading && (h("div", { key: 'a155cd999fa40c35fa7b391cde7c1026edb250a7', class: "loading-overlay" }, h("div", { key: 'ccba76c5d4a472158c28bc564ba95bd65829b58d', class: "loading-spinner" }), h("div", { key: '23168f9bdcf4e993539288ff5703acaed13bb16a', class: "loading-text" }, this.statusMessage))), h("div", { key: '0107b82ad19726c1bab131e17892a46b04e08cfd', class: "watermark" }, h("img", { key: 'ad8831a6f77fa61805f22e3a27f5c5619ac1cc0e', src: "https://storage.googleapis.com/jaak-static/commons/powered-by-jaak.png", alt: "Powered by Jaak" })))));
+    // PERFORMANCE MONITORING METHODS
+    initializePerformanceMonitor() {
+        this.performanceMetrics.lastUpdateTime = performance.now();
+        // Update performance metrics every 500ms
+        this.performanceUpdateInterval = window.setInterval(() => {
+            this.updatePerformanceMetrics();
+        }, 500);
+        this.logger.debug('Monitor de performance inicializado');
+    }
+    updatePerformanceMetrics() {
+        const currentTime = performance.now();
+        const deltaTime = currentTime - this.performanceMetrics.lastUpdateTime;
+        // Calculate FPS
+        if (deltaTime > 0) {
+            this.performanceMetrics.fps = Math.round(1000 / (deltaTime / this.frameSkipCounter || 1));
+        }
+        // Get memory usage if available
+        if ('memory' in performance) {
+            const memInfo = performance.memory;
+            this.performanceMetrics.memoryUsage = Math.round(memInfo.usedJSHeapSize / 1048576); // MB
+        }
+        // Calculate detection success rate
+        if (this.performanceMetrics.totalDetections > 0) {
+            this.performanceMetrics.successfulDetections = this.performanceMetrics.successfulDetections;
+            const detectionRate = (this.performanceMetrics.successfulDetections / this.performanceMetrics.totalDetections) * 100;
+            this.performanceMetrics.detectionRate = Math.round(detectionRate);
+        }
+        // Update state for rendering
+        this.performanceData = {
+            fps: this.performanceMetrics.fps,
+            inferenceTime: this.performanceMetrics.inferenceTime,
+            memoryUsage: this.performanceMetrics.memoryUsage,
+            onnxLoadTime: this.performanceMetrics.onnxLoadTime,
+            frameProcessingTime: this.performanceMetrics.frameProcessingTime,
+            totalDetections: this.performanceMetrics.totalDetections,
+            successfulDetections: this.performanceMetrics.successfulDetections,
+            detectionRate: this.performanceMetrics.detectionRate
+        };
+        this.performanceMetrics.lastUpdateTime = currentTime;
+    }
+    recordOnnxPerformance(loadTime, inferenceTime) {
+        this.performanceMetrics.onnxLoadTime = Math.round(loadTime);
+        this.performanceMetrics.inferenceTime = Math.round(inferenceTime);
+    }
+    recordFrameProcessing(processingTime, detectionsFound) {
+        this.performanceMetrics.frameProcessingTime = Math.round(processingTime);
+        this.performanceMetrics.totalDetections++;
+        if (detectionsFound > 0) {
+            this.performanceMetrics.successfulDetections++;
+        }
     }
     static get is() { return "jaak-stamps"; }
     static get encapsulation() { return "shadow"; }
@@ -1093,7 +1040,7 @@ export class JaakStamps {
                 "getter": false,
                 "setter": false,
                 "reflect": false,
-                "defaultValue": "10"
+                "defaultValue": "15"
             },
             "maskSize": {
                 "type": "number",
@@ -1113,7 +1060,7 @@ export class JaakStamps {
                 "getter": false,
                 "setter": false,
                 "reflect": false,
-                "defaultValue": "90"
+                "defaultValue": "80"
             },
             "cropMargin": {
                 "type": "number",
@@ -1133,7 +1080,7 @@ export class JaakStamps {
                 "getter": false,
                 "setter": false,
                 "reflect": false,
-                "defaultValue": "0"
+                "defaultValue": "20"
             },
             "useDocumentClassification": {
                 "type": "boolean",
@@ -1154,29 +1101,60 @@ export class JaakStamps {
                 "setter": false,
                 "reflect": false,
                 "defaultValue": "false"
+            },
+            "preferredCamera": {
+                "type": "string",
+                "attribute": "preferred-camera",
+                "mutable": false,
+                "complexType": {
+                    "original": "'auto' | 'front' | 'back'",
+                    "resolved": "\"auto\" | \"back\" | \"front\"",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "'auto'"
+            },
+            "captureDelay": {
+                "type": "number",
+                "attribute": "capture-delay",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "1500"
             }
         };
     }
     static get states() {
         return {
-            "isVideoActive": {},
-            "statusMessage": {},
-            "statusColor": {},
-            "bestScore": {},
-            "capturedFullFrame": {},
-            "capturedCroppedId": {},
-            "capturedBackFullFrame": {},
-            "capturedBackCroppedId": {},
-            "captureStep": {},
-            "isCapturing": {},
-            "showFlipAnimation": {},
-            "showSuccessAnimation": {},
-            "shouldMirrorVideo": {},
+            "detectionBoxes": {},
             "sideAlignment": {},
-            "isDetectionPaused": {},
-            "isLoading": {},
-            "isModelPreloaded": {},
-            "isMaskReady": {}
+            "isMaskReady": {},
+            "shouldMirrorVideo": {},
+            "showCameraSelector": {},
+            "isSwitchingCamera": {},
+            "hasDocumentDetected": {},
+            "currentStatus": {},
+            "performanceData": {}
         };
     }
     static get events() {
@@ -1216,15 +1194,20 @@ export class JaakStamps {
         return {
             "getCapturedImages": {
                 "complexType": {
-                    "signature": "() => Promise<{ front: { fullFrame: string; cropped: string; }; back: { fullFrame: string; cropped: string; }; metadata: { hasBackCapture: boolean; totalImages: number; }; }>",
+                    "signature": "() => Promise<CapturedImagesResponse>",
                     "parameters": [],
                     "references": {
                         "Promise": {
                             "location": "global",
                             "id": "global::Promise"
+                        },
+                        "CapturedImagesResponse": {
+                            "location": "import",
+                            "path": "../../types/component-types",
+                            "id": "src/types/component-types.ts::CapturedImagesResponse"
                         }
                     },
-                    "return": "Promise<{ front: { fullFrame: string; cropped: string; }; back: { fullFrame: string; cropped: string; }; metadata: { hasBackCapture: boolean; totalImages: number; }; }>"
+                    "return": "Promise<CapturedImagesResponse>"
                 },
                 "docs": {
                     "text": "",
@@ -1299,17 +1282,39 @@ export class JaakStamps {
                     "tags": []
                 }
             },
+            "skipBackCapture": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
             "getStatus": {
                 "complexType": {
-                    "signature": "() => Promise<{ isVideoActive: boolean; captureStep: \"front\" | \"back\" | \"completed\"; statusMessage: string; hasImages: boolean; isProcessCompleted: boolean; isModelPreloaded: boolean; }>",
+                    "signature": "() => Promise<StatusResponse>",
                     "parameters": [],
                     "references": {
                         "Promise": {
                             "location": "global",
                             "id": "global::Promise"
+                        },
+                        "StatusResponse": {
+                            "location": "import",
+                            "path": "../../types/component-types",
+                            "id": "src/types/component-types.ts::StatusResponse"
                         }
                     },
-                    "return": "Promise<{ isVideoActive: boolean; captureStep: \"front\" | \"back\" | \"completed\"; statusMessage: string; hasImages: boolean; isProcessCompleted: boolean; isModelPreloaded: boolean; }>"
+                    "return": "Promise<StatusResponse>"
                 },
                 "docs": {
                     "text": "",
@@ -1333,17 +1338,127 @@ export class JaakStamps {
                     "tags": []
                 }
             },
-            "skipBackCapture": {
+            "getCameraInfo": {
                 "complexType": {
-                    "signature": "() => Promise<void>",
+                    "signature": "() => Promise<CameraInfoResponse>",
                     "parameters": [],
                     "references": {
                         "Promise": {
                             "location": "global",
                             "id": "global::Promise"
+                        },
+                        "CameraInfoResponse": {
+                            "location": "import",
+                            "path": "../../types/component-types",
+                            "id": "src/types/component-types.ts::CameraInfoResponse"
                         }
                     },
-                    "return": "Promise<void>"
+                    "return": "Promise<CameraInfoResponse>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "setPreferredCamera": {
+                "complexType": {
+                    "signature": "(camera: \"auto\" | \"front\" | \"back\") => Promise<{ success: boolean; selectedCamera: string; availableCameras: number; }>",
+                    "parameters": [{
+                            "name": "camera",
+                            "type": "\"auto\" | \"front\" | \"back\"",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<{ success: boolean; selectedCamera: string; availableCameras: number; }>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "setCaptureDelay": {
+                "complexType": {
+                    "signature": "(delay: number) => Promise<{ success: boolean; captureDelay: number; }>",
+                    "parameters": [{
+                            "name": "delay",
+                            "type": "number",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<{ success: boolean; captureDelay: number; }>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "getCaptureDelay": {
+                "complexType": {
+                    "signature": "() => Promise<number>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<number>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "setTorchEnabled": {
+                "complexType": {
+                    "signature": "(enabled: boolean) => Promise<{ success: boolean; enabled: boolean; }>",
+                    "parameters": [{
+                            "name": "enabled",
+                            "type": "boolean",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<{ success: boolean; enabled: boolean; }>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "focusAtPoint": {
+                "complexType": {
+                    "signature": "(x: number, y: number) => Promise<{ success: boolean; coordinates: { x: number; y: number; }; }>",
+                    "parameters": [{
+                            "name": "x",
+                            "type": "number",
+                            "docs": ""
+                        }, {
+                            "name": "y",
+                            "type": "number",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<{ success: boolean; coordinates: { x: number; y: number; }; }>"
                 },
                 "docs": {
                     "text": "",