@jaak.ai/stamps 2.0.1 → 2.1.0-beta.2

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

@@ -7,6 +7,7 @@ export class JaakStamps {
     maskSize = 90;
     cropMargin = 20;
     useDocumentClassification = false;
+    useDocumentDetector = true;
     preferredCamera = 'auto';
     captureDelay = 1500;
     enableBackDocumentTimer = false;
@@ -23,9 +24,16 @@ export class JaakStamps {
     showCameraSelector = false;
     isSwitchingCamera = false;
     hasDocumentDetected = false;
+    cameraInfoWithAutofocus = {
+        availableCameras: [],
+        selectedCameraId: null,
+        deviceType: 'desktop',
+        isMultipleCamerasAvailable: false,
+        preferredFacing: null
+    };
     currentStatus = {
-        message: 'Inicializando componente...',
-        description: 'Configurando servicios y cargando recursos',
+        message: 'Preparando capturador...',
+        description: 'Configurando herramientas de captura',
         type: 'initializing',
         isInitialized: false
     };
@@ -40,9 +48,13 @@ export class JaakStamps {
         detectionRate: 0
     };
     backDocumentTimerRemaining = 0;
+    showManualCaptureButton = false;
+    performanceDegradedMode = false; // Auto-switched to manual mode due to performance
+    showPerformanceMessage = false; // Show performance message temporarily
+    captureStateVersion = 0; // Triggers re-render when StateManager changes
+    processingButton = null; // Track which button is processing
     // Services
     serviceContainer;
-    logger;
     eventBus;
     stateManager;
     cameraService;
@@ -59,12 +71,12 @@ export class JaakStamps {
     alignmentStartTime;
     alignmentTimer;
     backDocumentTimer;
+    orientationTimer;
     // Performance monitoring
     performanceMetrics = {
         fps: 0,
         inferenceTime: 0,
         memoryUsage: 0,
-        cpuUsage: 0,
         onnxLoadTime: 0,
         frameProcessingTime: 0,
         totalDetections: 0,
@@ -73,22 +85,39 @@ export class JaakStamps {
         lastUpdateTime: 0
     };
     performanceUpdateInterval;
-    // Performance optimization
+    // Performance optimization with adaptive frame skipping
     frameSkipCounter = 0;
-    FRAME_SKIP = 2;
+    BASE_FRAME_SKIP = 2;
+    MAX_FRAME_SKIP = 8;
     consecutiveFailures = 0;
     MAX_FAILURES = 30;
     lastInferenceTime = 0;
     MIN_INFERENCE_INTERVAL = 50;
+    performanceHistory = [];
+    PERFORMANCE_HISTORY_SIZE = 10;
+    // Sistema simplificado de monitoreo de rendimiento
+    PERFORMANCE_THRESHOLD_MS = 2000; // Umbral único para todos los frames
+    SLOW_FRAMES_TO_TRIGGER = 2; // Cuántos frames lentos consecutivos antes de cambiar
+    slowFrameCount = 0; // Contador de frames consecutivos lentos
+    processedFramesCount = 0; // Contador total de frames procesados
+    hasAutoSwitchedToManual = false;
+    // Canvas pool for optimized screenshot capture
+    canvasPool = [];
+    MAX_CANVAS_POOL_SIZE = 3;
     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();
+        try {
+            this.updateStatus('Preparando capturador...', 'Configurando herramientas de captura', 'initializing');
+            await this.initializeServices();
+            this.updateStatus('Preparando funciones...', 'Configurando herramientas de trabajo', 'initializing');
+            await this.setupEventListeners();
+            this.updateStatus('Configurando cámara...', 'Detectando dispositivos disponibles', 'initializing');
+            await this.initializeComponent();
+            if (this.debug) {
+                this.initializePerformanceMonitor();
+            }
+        }
+        catch (error) {
+            this.updateStatus('Error de inicialización', error.message, 'error');
         }
     }
     async initializeServices() {
@@ -98,37 +127,22 @@ export class JaakStamps {
             maskSize: this.maskSize,
             cropMargin: this.cropMargin,
             useDocumentClassification: this.useDocumentClassification,
+            useDocumentDetector: this.useDocumentDetector,
             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);
+        this.eventBus.on('state-changed', () => {
+            this.handleStateChange();
         });
     }
     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) {
             this.stateManager.updateCaptureState({ isLoading: true });
@@ -137,58 +151,67 @@ export class JaakStamps {
         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.updateCameraInfoWithAutofocus();
+        this.updateStatus('Preparando reconocimiento...', 'Configurando detección de documentos', 'initializing');
         await this.loadOnnxRuntime();
         this.initializeResizeObserver();
     }
     validateProps() {
         if (this.maskSize < 50 || this.maskSize > 100) {
-            this.logger.warn(`Propiedad maskSize inválida. Valor: ${this.maskSize}, esperado: 50-100. Usando valor por defecto: 90`);
             this.maskSize = 90;
         }
         if (this.cropMargin < 0 || this.cropMargin > 100) {
-            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;
         }
     }
     async loadOnnxRuntime() {
         if (!window.ort) {
-            this.updateStatus('Descargando librerías...', 'Obteniendo recursos de reconocimiento', 'initializing');
+            this.updateStatus('Preparando herramientas...', 'Configurando funciones de captura', 'initializing');
             const script = document.createElement('script');
-            script.src = 'https://cdn.jsdelivr.net/npm/onnxruntime-web/dist/ort.min.js';
+            script.src = 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.0/dist/ort.min.js';
             document.head.appendChild(script);
             await new Promise((resolve) => {
                 script.onload = () => {
-                    setTimeout(() => {
-                        this.finalizeInitialization();
+                    setTimeout(async () => {
+                        await this.finalizeInitialization();
                         resolve(undefined);
                     }, 300);
                 };
             });
         }
         else {
-            setTimeout(() => {
-                this.finalizeInitialization();
+            setTimeout(async () => {
+                await this.finalizeInitialization();
             }, 300);
         }
     }
-    finalizeInitialization() {
+    async finalizeInitialization() {
         this.stateManager.updateCaptureState({ isLoading: false });
-        this.currentStatus = {
-            message: 'Listo para capturar',
-            description: '',
-            type: 'ready',
-            isInitialized: true
-        };
+        // Check camera permissions before showing "ready" status
+        const hasPermissions = await this.checkCameraPermissions();
+        if (hasPermissions) {
+            this.currentStatus = {
+                message: 'Listo para capturar',
+                description: '',
+                type: 'ready',
+                isInitialized: true
+            };
+        }
+        else {
+            this.currentStatus = {
+                message: 'Permisos de cámara requeridos',
+                description: 'Por favor, otorgue permisos de cámara para continuar',
+                type: 'error',
+                isInitialized: true
+            };
+        }
         this.emitReadyEvent();
     }
     updateStatus(message, description, type = 'loading') {
@@ -202,20 +225,30 @@ export class JaakStamps {
     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
+    async checkCameraPermissions() {
+        try {
+            if (!navigator.permissions) {
+                // Fallback: try to access camera directly
+                try {
+                    const stream = await navigator.mediaDevices.getUserMedia({ video: true });
+                    stream.getTracks().forEach(track => track.stop());
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            }
+            const permission = await navigator.permissions.query({ name: 'camera' });
+            return permission.state === 'granted';
+        }
+        catch (error) {
+            return false;
         }
     }
+    handleStateChange() {
+        // Handle state changes from StateManager if needed
+    }
     initializeResizeObserver() {
         if ('ResizeObserver' in window && this.detectionContainer) {
             const resizeObserver = new ResizeObserver(() => {
@@ -223,15 +256,56 @@ export class JaakStamps {
             });
             resizeObserver.observe(this.detectionContainer.parentElement);
         }
+        // Handle mobile device orientation changes
+        window.addEventListener('orientationchange', () => {
+            // Clear any existing orientation timer
+            if (this.orientationTimer) {
+                clearTimeout(this.orientationTimer);
+            }
+            // Add delay to ensure video dimensions are updated after rotation
+            this.orientationTimer = window.setTimeout(() => {
+                this.handleResize();
+                this.orientationTimer = undefined;
+            }, 300);
+        });
     }
     handleResize() {
         if (this.detectionContainer) {
             const container = this.detectionContainer.parentElement;
             const rect = container.getBoundingClientRect();
             this.updateMaskDimensions(rect);
-            this.logger.debug('Container redimensionado:', { width: rect.width, height: rect.height });
         }
     }
+    triggerRerender() {
+        this.captureStateVersion = this.captureStateVersion + 1;
+    }
+    getGuideText(step) {
+        if (step === 'completed') {
+            return 'Proceso completado';
+        }
+        // Check if we should show performance message
+        if (this.showPerformanceMessage && step === 'front') {
+            return 'Modo manual activado por rendimiento. Use el botón para capturar.';
+        }
+        if (step === 'front') {
+            // Para el frente, si el detector manual está activo, mostrar instrucciones de captura manual
+            if (this.showManualCaptureButton) {
+                return 'Posicione el frente de su documento en el marco y presione el botón para capturar';
+            }
+            // Instrucción básica de alineación
+            return 'Alinee su identificación con el marco';
+        }
+        else if (step === 'back') {
+            // Para el reverso, mostrar instrucciones específicas según el modo
+            if (this.useDocumentDetector) {
+                return 'Si tu documento no tiene lado trasero, da clic en el botón para continuar con el proceso';
+            }
+            else {
+                return 'Posicione el reverso de su documento en el marco y capture, o salte este paso';
+            }
+        }
+        return 'Alinee su identificación con el marco';
+    }
     updateMaskDimensions(containerRect) {
         if (!this.videoRef)
             return;
@@ -283,16 +357,38 @@ export class JaakStamps {
         this.el.style.setProperty('--mask-center-x', `${videoCenterXPercent}%`);
         this.el.style.setProperty('--mask-center-y', `${videoCenterYPercent}%`);
         this.isMaskReady = true;
-        this.logger.state('DIMENSIONES_MASCARA_ACTUALIZADAS', {
-            video: { width: videoWidth, height: videoHeight },
-            displayed: { width: displayedVideoWidth, height: displayedVideoHeight },
-            mask: { widthPercent: maskWidthPercent, heightPercent: maskHeightPercent },
-            center: { x: videoCenterXPercent, y: videoCenterYPercent },
-            offset: { x: videoOffsetX, y: videoOffsetY }
-        });
     }
     // PUBLIC METHODS
+    // Helper method to check if component is ready for operations
+    isComponentReady() {
+        if (!this.currentStatus.isInitialized) {
+            return {
+                ready: false,
+                message: 'El componente aún se está inicializando',
+                status: 'initializing'
+            };
+        }
+        if (this.currentStatus.type === 'loading' || this.currentStatus.type === 'initializing') {
+            return {
+                ready: false,
+                message: 'El componente está cargando recursos',
+                status: 'loading'
+            };
+        }
+        if (!this.serviceContainer || !this.stateManager || !this.cameraService || !this.detectionService) {
+            return {
+                ready: false,
+                message: 'Los servicios del componente no están disponibles',
+                status: 'error'
+            };
+        }
+        return { ready: true };
+    }
     async getCapturedImages() {
+        const readyCheck = this.isComponentReady();
+        if (!readyCheck.ready) {
+            throw new Error(readyCheck.message);
+        }
         const state = this.stateManager.getCaptureState();
         if (state.step !== 'completed') {
             throw new Error('El proceso de captura no ha sido completado');
@@ -300,146 +396,359 @@ export class JaakStamps {
         return this.stateManager.getCapturedImages();
     }
     async isProcessCompleted() {
+        const readyCheck = this.isComponentReady();
+        if (!readyCheck.ready) {
+            return false; // Return false instead of error for this method
+        }
         return this.stateManager.isProcessCompleted();
     }
     async startCapture() {
-        await this.startDetection();
+        const readyCheck = this.isComponentReady();
+        if (!readyCheck.ready) {
+            this.updateStatus(readyCheck.message, 'Espere a que termine la inicialización', readyCheck.status);
+            return { success: false, error: readyCheck.message };
+        }
+        try {
+            await this.startDetection();
+            return { success: true };
+        }
+        catch (error) {
+            this.updateStatus('Error al iniciar captura', error.message, 'error');
+            return { success: false, error: error.message };
+        }
     }
     async stopCapture() {
-        this.exitSession();
+        const readyCheck = this.isComponentReady();
+        if (!readyCheck.ready) {
+            return { success: false, error: readyCheck.message };
+        }
+        try {
+            this.exitSession();
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
     }
     async resetCapture() {
-        this.resetDetection();
+        const readyCheck = this.isComponentReady();
+        if (!readyCheck.ready) {
+            return { success: false, error: readyCheck.message };
+        }
+        try {
+            this.resetDetection();
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
     }
     async skipBackCapture() {
-        const captureState = this.stateManager.getCaptureState();
-        const capturedImages = this.stateManager.getCapturedImages();
-        if (captureState.step === 'back' && capturedImages.front.fullFrame) {
-            this.completeProcess(true);
+        console.log('🟡 Botón clicked: Saltar reverso');
+        // Set processing state immediately
+        this.processingButton = 'skip-back';
+        // Add small delay to show spinner
+        await new Promise(resolve => setTimeout(resolve, 100));
+        const readyCheck = this.isComponentReady();
+        if (!readyCheck.ready) {
+            this.processingButton = null;
+            return { success: false, error: readyCheck.message };
+        }
+        try {
+            const captureState = this.stateManager.getCaptureState();
+            const capturedImages = this.stateManager.getCapturedImages();
+            if (captureState.step === 'back' && capturedImages.front.fullFrame) {
+                this.completeProcess(true);
+                return { success: true };
+            }
+            else {
+                return { success: false, error: 'No se puede saltar el reverso en el estado actual' };
+            }
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+        finally {
+            // Always clear processing state when done
+            this.processingButton = null;
         }
     }
     async getStatus() {
-        const captureState = this.stateManager.getCaptureState();
-        const capturedImages = this.stateManager.getCapturedImages();
-        return {
-            isVideoActive: captureState.isVideoActive,
-            captureStep: captureState.step,
-            hasImages: !!(capturedImages.front.fullFrame || capturedImages.back.fullFrame),
-            isProcessCompleted: this.stateManager.isProcessCompleted(),
-            isModelPreloaded: this.detectionService.isModelLoaded()
-        };
+        const readyCheck = this.isComponentReady();
+        if (!readyCheck.ready) {
+            return {
+                isVideoActive: false,
+                captureStep: 'front',
+                hasImages: false,
+                isProcessCompleted: false,
+                isModelPreloaded: false,
+                componentStatus: readyCheck.status,
+                componentMessage: readyCheck.message
+            };
+        }
+        try {
+            const captureState = this.stateManager.getCaptureState();
+            const capturedImages = this.stateManager.getCapturedImages();
+            return {
+                isVideoActive: captureState.isVideoActive,
+                captureStep: captureState.step,
+                hasImages: !!(capturedImages.front.fullFrame || capturedImages.back.fullFrame),
+                isProcessCompleted: this.stateManager.isProcessCompleted(),
+                isModelPreloaded: this.detectionService.isModelLoaded(),
+                componentStatus: 'ready'
+            };
+        }
+        catch (error) {
+            return {
+                isVideoActive: false,
+                captureStep: 'front',
+                hasImages: false,
+                isProcessCompleted: false,
+                isModelPreloaded: false,
+                componentStatus: 'error',
+                componentMessage: error.message
+            };
+        }
     }
     async preloadModel() {
+        const readyCheck = this.isComponentReady();
+        if (!readyCheck.ready) {
+            this.updateStatus(readyCheck.message, 'Espere a que termine la inicialización', readyCheck.status);
+            return { success: false, error: readyCheck.message };
+        }
         if (this.detectionService.isModelLoaded()) {
-            this.logger.state('MODELO_YA_PRECARGADO');
-            this.updateStatus('Modelos ya cargados', '', 'ready');
+            this.updateStatus('Reconocimiento listo', '', 'ready');
             return { success: true, message: 'Model already loaded' };
         }
         try {
             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();
+            this.updateStatus('Preparando reconocimiento...', 'Configurando detección de documentos', 'loading');
+            if (this.stateManager) {
+                this.stateManager.updateCaptureState({ isLoading: true });
+            }
+            try {
+                await this.detectionService.loadModel();
+            }
+            catch (modelError) {
+                this.switchToManualModeWithError('Error al cargar modelo de detección');
+                throw modelError;
+            }
+            this.updateStatus('Optimizando detección...', 'Configurando reconocimiento de documentos', 'loading');
+            try {
+                await this.detectionService.loadClassificationModel();
+            }
+            catch (classificationError) {
+                this.switchToManualModeWithError('Error al cargar modelo de clasificación');
+                throw classificationError;
+            }
             const loadEndTime = performance.now();
             const loadTime = loadEndTime - loadStartTime;
             // Record ONNX load time
             if (this.debug) {
                 this.recordOnnxPerformance(loadTime, 0);
             }
-            this.updateStatus('Optimizando modelos...', 'Configurando parámetros de rendimiento', 'loading');
+            this.updateStatus('Finalizando configuración...', 'Preparando herramientas para captura', 'loading');
             await new Promise(resolve => setTimeout(resolve, 300));
-            this.updateStatus('Modelos precargados', '', 'ready');
-            this.stateManager.updateCaptureState({ isLoading: false });
+            this.updateStatus('Reconocimiento preparado', '', 'ready');
+            if (this.stateManager) {
+                this.stateManager.updateCaptureState({ isLoading: false });
+            }
             this.emitReadyEvent();
-            this.logger.state('MODELOS_PRECARGADOS_EXITOSAMENTE', { loadTime: Math.round(loadTime) });
             return { success: true, message: 'Models preloaded successfully' };
         }
         catch (error) {
-            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 });
+            this.updateStatus('Error de configuración', 'No se pudieron preparar las herramientas necesarias', 'error');
+            if (this.stateManager) {
+                this.stateManager.updateCaptureState({ isLoading: false });
+            }
             return { success: false, error: error.message };
         }
     }
     async getCameraInfo() {
-        return this.cameraService.getCameraInfo();
+        const readyCheck = this.isComponentReady();
+        if (!readyCheck.ready) {
+            return {
+                availableCameras: [],
+                selectedCameraId: null,
+                deviceType: 'desktop',
+                isMultipleCamerasAvailable: false,
+                preferredFacing: null,
+                error: readyCheck.message
+            };
+        }
+        try {
+            return await this.cameraService.getCameraInfo();
+        }
+        catch (error) {
+            return {
+                availableCameras: [],
+                selectedCameraId: null,
+                deviceType: 'desktop',
+                isMultipleCamerasAvailable: false,
+                preferredFacing: null,
+                error: error.message
+            };
+        }
     }
     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);
+        const readyCheck = this.isComponentReady();
+        if (!readyCheck.ready) {
+            return {
+                success: false,
+                error: readyCheck.message,
+                selectedCamera: null,
+                availableCameras: 0
+            };
+        }
+        try {
+            this.preferredCamera = camera;
+            this.serviceContainer.updateConfig({ preferredCamera: camera });
+            await this.cameraService.enumerateDevices();
+            await this.updateCameraInfoWithAutofocus();
+            const captureState = this.stateManager.getCaptureState();
+            if (captureState.isVideoActive) {
+                const selectedCameraId = this.cameraService.getSelectedCameraId();
+                if (selectedCameraId) {
+                    await this.cameraService.switchCamera(selectedCameraId);
+                }
             }
+            return {
+                success: true,
+                selectedCamera: this.cameraService.getSelectedCameraId(),
+                availableCameras: this.cameraService.getAvailableCameras().length
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                selectedCamera: null,
+                availableCameras: 0
+            };
         }
-        return {
-            success: true,
-            selectedCamera: this.cameraService.getSelectedCameraId(),
-            availableCameras: this.cameraService.getAvailableCameras().length
-        };
     }
     async setCaptureDelay(delay) {
         if (delay < 0 || delay > 10000) {
-            throw new Error('Capture delay must be between 0 and 10000 milliseconds');
+            return {
+                success: false,
+                error: 'Capture delay must be between 0 and 10000 milliseconds',
+                captureDelay: this.captureDelay
+            };
         }
+        // Allow setting capture delay even during initialization
         this.captureDelay = delay;
-        this.serviceContainer.updateConfig({ captureDelay: delay });
+        if (this.serviceContainer) {
+            this.serviceContainer.updateConfig({ captureDelay: delay });
+        }
         return {
             success: true,
             captureDelay: this.captureDelay
         };
     }
     async getCaptureDelay() {
+        // Always allow getting capture delay, even during initialization
         return this.captureDelay;
     }
-    async setTorchEnabled(enabled) {
-        const torchEnabled = await this.cameraService.setTorchEnabled(enabled, this.videoStream);
-        return {
-            success: torchEnabled,
-            enabled: torchEnabled ? enabled : false
-        };
-    }
-    async focusAtPoint(x, y) {
-        const focused = await this.cameraService.focusAtPoint(x, y, this.videoStream);
+    // Memory and device capability detection
+    checkDeviceCapabilities() {
+        const deviceMemory = navigator.deviceMemory;
+        // Siempre intentar usar ML, independientemente del dispositivo
+        // Las restricciones anteriores no eran confiables
         return {
-            success: focused,
-            coordinates: { x, y }
+            canUseML: true,
+            reason: 'Dispositivo compatible con detección automática.',
+            memoryMB: deviceMemory ? deviceMemory * 1024 : null
         };
     }
     // DETECTION METHODS
     async startDetection() {
-        this.logger.state('INICIANDO_DETECCION');
         try {
+            // Verificar capacidades del dispositivo antes de cargar modelos
+            const capabilities = this.checkDeviceCapabilities();
+            // Si el dispositivo no puede usar ML o tenemos problemas de memoria, usar modo manual
+            if (!capabilities.canUseML && this.useDocumentDetector) {
+                this.switchToManualModeWithWarning(capabilities.reason);
+                return;
+            }
             // 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.updateStatus('Preparando reconocimiento...', 'Configurando detección de documentos', '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();
+                try {
+                    await this.detectionService.loadModel();
+                }
+                catch (modelError) {
+                    // Si es un error de memoria, cambiar a modo manual con mensaje específico
+                    if (modelError.message.includes('Out of memory') || modelError.message.includes('no available backend')) {
+                        const memoryInfo = navigator.deviceMemory ? `(${navigator.deviceMemory}GB disponible)` : '';
+                        this.switchToManualModeWithWarning(`Memoria insuficiente para detección automática ${memoryInfo}. Modo manual activado - funciona igual de bien!`);
+                        return;
+                    }
+                    else {
+                        this.switchToManualModeWithError('Error al cargar modelo de detección');
+                        throw modelError;
+                    }
+                }
+                this.updateStatus('Optimizando detección...', 'Configurando reconocimiento de documentos', 'loading');
+                try {
+                    await this.detectionService.loadClassificationModel();
+                }
+                catch (classificationError) {
+                    // Si es un error de memoria, cambiar a modo manual con mensaje específico
+                    if (classificationError.message.includes('Out of memory') || classificationError.message.includes('no available backend')) {
+                        const memoryInfo = navigator.deviceMemory ? `(${navigator.deviceMemory}GB disponible)` : '';
+                        this.switchToManualModeWithWarning(`Memoria insuficiente para clasificación automática ${memoryInfo}. Modo manual activado para optimizar rendimiento.`);
+                        return;
+                    }
+                    else {
+                        this.switchToManualModeWithError('Error al cargar modelo de clasificación');
+                        throw classificationError;
+                    }
+                }
                 const loadEndTime = performance.now();
                 const loadTime = loadEndTime - loadStartTime;
                 // Record ONNX load time
                 if (this.debug) {
                     this.recordOnnxPerformance(loadTime, 0);
                 }
-                this.logger.state('MODELOS_CARGADOS_EN_DETECCION', { loadTime: Math.round(loadTime) });
             }
             // Paso 2: Detectar y configurar dispositivos
-            this.updateStatus('Detectando cámaras...', 'Buscando dispositivos de captura disponibles', 'loading');
-            await this.cameraService.enumerateDevices();
+            this.updateStatus('Configurando cámara...', 'Buscando dispositivos disponibles', 'loading');
+            try {
+                await this.cameraService.enumerateDevices();
+            }
+            catch (enumerateError) {
+                throw new Error(`Error al enumerar dispositivos: ${enumerateError.message}`);
+            }
+            try {
+                await this.updateCameraInfoWithAutofocus();
+            }
+            catch (cameraInfoError) {
+                throw new Error(`Error al actualizar información de cámara: ${cameraInfoError.message}`);
+            }
             // 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);
+            this.updateStatus('Ajustando cámara...', 'Configurando calidad de imagen', 'loading');
+            let stream;
+            try {
+                stream = await this.cameraService.setupCamera();
+            }
+            catch (setupError) {
+                throw new Error(`Error al configurar cámara: ${setupError.message}`);
+            }
+            // Paso 4: Inicializar video y mostrar estado de análisis inicial
+            if (this.useDocumentDetector) {
+                this.updateStatus('Analizando estabilidad...', 'Evaluando rendimiento del sistema', 'loading');
+            }
+            else {
+                this.updateStatus('Captura activa', 'Posicione su documento y use el botón para capturar', 'active');
+            }
+            try {
+                await this.initializeVideoStream(stream);
+            }
+            catch (videoError) {
+                throw new Error(`Error al inicializar video: ${videoError.message}`);
+            }
             // Paso 5: Calibrar máscara
             if (this.detectionContainer) {
                 const container = this.detectionContainer.parentElement;
@@ -449,11 +758,14 @@ export class JaakStamps {
             // Finalizar e iniciar captura
             this.startTime = Date.now();
             this.stateManager.updateCaptureState({ isLoading: false });
+            // Mostrar botón manual si el detector está deshabilitado
+            if (!this.useDocumentDetector) {
+                this.showManualCaptureButton = true;
+            }
             this.detectFrame();
         }
         catch (err) {
-            this.logger.error('Error al inicializar detección:', err);
-            this.updateStatus('Error al iniciar captura', 'No se pudo completar la inicialización', 'error');
+            this.updateStatus('Error al iniciar', 'No se pudo preparar la captura', 'error');
             this.stateManager.updateCaptureState({ isLoading: false });
         }
     }
@@ -463,14 +775,16 @@ export class JaakStamps {
             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 });
+                    // Recalculate mask dimensions when new camera stream loads
+                    if (this.detectionContainer) {
+                        const container = this.detectionContainer.parentElement;
+                        const rect = container.getBoundingClientRect();
+                        this.updateMaskDimensions(rect);
+                    }
                     resolve();
                 };
             });
@@ -485,15 +799,28 @@ export class JaakStamps {
             const captureState = this.stateManager.getCaptureState();
             if (!this.videoRef || !this.detectionContainer || !this.detectionService.isModelLoaded())
                 return;
+            // Show manual capture button when document detector is disabled or performance is degraded
+            if (!this.useDocumentDetector || this.performanceDegradedMode) {
+                this.showManualCaptureButton = true;
+                // Continue the loop for UI updates but skip detection logic
+                if (captureState.step !== 'completed') {
+                    this.animationId = requestAnimationFrame(() => this.detectFrame());
+                }
+                return;
+            }
+            else if (!this.performanceDegradedMode) {
+                this.showManualCaptureButton = false;
+            }
             if (captureState.isDetectionPaused) {
                 if (captureState.step !== 'completed') {
                     this.animationId = requestAnimationFrame(() => this.detectFrame());
                 }
                 return;
             }
-            // Frame skipping for performance
+            // Adaptive frame skipping for performance
             this.frameSkipCounter++;
-            if (this.frameSkipCounter <= this.FRAME_SKIP) {
+            const currentFrameSkip = this.getAdaptiveFrameSkip();
+            if (this.frameSkipCounter <= currentFrameSkip) {
                 if (captureState.step !== 'completed') {
                     this.animationId = requestAnimationFrame(() => this.detectFrame());
                 }
@@ -511,10 +838,27 @@ export class JaakStamps {
             this.lastInferenceTime = currentTime;
             // 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;
+            let inputTensor;
+            let detections;
+            let inferenceTime;
+            try {
+                inputTensor = this.detectionService.preprocess(this.videoRef);
+            }
+            catch (preprocessError) {
+                this.switchToManualModeWithError('Error al procesar imagen');
+                return;
+            }
+            try {
+                // Standard detection without timeout (timeout is handled by frame counting)
+                detections = await this.detectionService.runInference(inputTensor);
+                inferenceTime = performance.now() - inferenceStartTime;
+            }
+            catch (inferenceError) {
+                this.switchToManualModeWithError('Error en detección automática');
+                return;
+            }
+            // Increment frame count
+            this.processedFramesCount++;
             // Record ONNX performance metrics
             if (this.debug) {
                 this.recordOnnxPerformance(0, inferenceTime);
@@ -553,9 +897,30 @@ export class JaakStamps {
             }
             this.updateMaskColor(detections);
             // Record frame processing metrics
+            const frameEndTime = performance.now();
+            const totalFrameTime = frameEndTime - frameStartTime;
+            // Sistema simplificado: Verificar rendimiento de cada frame (solo si no se ha cambiado a manual)
+            if (this.useDocumentDetector && !this.hasAutoSwitchedToManual) {
+                // Verificar si el frame es lento
+                if (totalFrameTime >= this.PERFORMANCE_THRESHOLD_MS) {
+                    this.slowFrameCount++;
+                    // Si tenemos suficientes frames lentos consecutivos, cambiar a manual
+                    if (this.slowFrameCount >= this.SLOW_FRAMES_TO_TRIGGER) {
+                        this.switchToManualMode();
+                    }
+                }
+                else {
+                    // Frame rápido, reiniciar contador
+                    if (this.slowFrameCount > 0) {
+                        this.slowFrameCount = 0;
+                    }
+                }
+                // Cambiar mensaje de estado después de analizar los primeros 2 frames
+                if (this.processedFramesCount === 2) {
+                    this.updateStatus('Captura activa', 'Buscando documento en el marco de captura', 'active');
+                }
+            }
             if (this.debug) {
-                const frameEndTime = performance.now();
-                const totalFrameTime = frameEndTime - frameStartTime;
                 this.recordFrameProcessing(totalFrameTime, detections.length);
             }
             // Continue detection loop
@@ -569,7 +934,6 @@ export class JaakStamps {
             }
         }
         catch (e) {
-            this.logger.error('Error en inferencia de modelo:', e);
             const captureState = this.stateManager.getCaptureState();
             if (captureState.step !== 'completed') {
                 setTimeout(() => this.detectFrame(), 100);
@@ -592,10 +956,18 @@ export class JaakStamps {
             clearTimeout(this.alignmentTimer);
             this.alignmentTimer = undefined;
         }
+        if (this.orientationTimer) {
+            clearTimeout(this.orientationTimer);
+            this.orientationTimer = undefined;
+        }
+        // Liberar recursos de ONNX al limpiar el componente
+        this.releaseOnnxResources();
         if (this.performanceUpdateInterval) {
             clearInterval(this.performanceUpdateInterval);
             this.performanceUpdateInterval = undefined;
         }
+        // Clear canvas pool
+        this.canvasPool = [];
         this.detectionBoxes = [];
         this.alignmentStartTime = undefined;
         this.hasDocumentDetected = false;
@@ -610,14 +982,8 @@ export class JaakStamps {
             step: 'front',
             isCapturing: false
         };
-        const cameraInfo = this.cameraService?.getCameraInfo() || {
-            availableCameras: [],
-            isMultipleCamerasAvailable: false,
-            selectedCameraId: null,
-            deviceType: 'desktop',
-            preferredFacing: null
-        };
-        return (h("div", { key: '9d4d77042218ab3d0bc4fb1ce879db09dc3e78b4', class: "detector-container" }, h("div", { key: '51ac8ccb1275637282b038ad8364d19f14ef61b1', class: "video-container" }, h("video", { key: 'a34f0481da20ec5b7b62b21aa275ec5f6dfec5d1', ref: el => this.videoRef = el, autoplay: true, muted: true, playsinline: true, class: this.shouldMirrorVideo ? 'mirror' : '', style: { display: captureState.isVideoActive ? 'block' : 'none' } }), h("div", { key: '43b71dfe3eaf20ffa66a4139e24b1af6a2074631', 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: {
+        const cameraInfo = this.cameraInfoWithAutofocus;
+        return (h("div", { key: 'f9cbca2fd6b8548a29ace7fcb972b53f402f61af', class: "detector-container" }, h("div", { key: '4f3cac734eb6bfd44a8de644eadca17e7893e11a', class: "video-container" }, h("video", { key: '5e15a38c989a72d5274281272d41ba064447ca6f', ref: el => this.videoRef = el, autoplay: true, muted: true, playsinline: true, class: this.shouldMirrorVideo ? 'mirror' : '', style: { display: captureState.isVideoActive ? 'block' : 'none' } }), h("div", { key: '38c8ad8b691db60e9b5a2a8b641fe6febbeacfca', 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`,
@@ -626,9 +992,9 @@ export class JaakStamps {
                 border: '2px solid #32406C',
                 pointerEvents: 'none',
                 boxSizing: 'border-box'
-            } })))), this.isMaskReady && (h("div", { key: 'c2596f8cabb227e3ea3b082495f52b141cb1690f', class: "overlay-mask" }, h("div", { key: 'ba1ea39b5df1cd312a9bd9410b7225a29cfb8a29', class: "card-outline" }, h("div", { key: '6ce4d4d969d5f3fbcf75a4eb285f61d434c5633b', class: "side side-top" }), h("div", { key: '36653ecc4fcda25dfc84bc4d1f4c4c5dfb71ced7', class: "side side-right" }), h("div", { key: '8b108fa8fb370b229a0d1a77cb1ff044319a8f75', class: "side side-bottom" }), h("div", { key: 'a7aa3b45c065a50445aafd5c3ccefb57b0c9c769', class: "side side-left" }), !captureState.showFlipAnimation && !captureState.showSuccessAnimation && (h("div", { key: 'b94b92273e12a019238e11ae57f21e140f13c3f1', class: "guide-text" }, "Alinee su identificaci\u00F3n con el marco"))), captureState.step === 'back' && !captureState.showFlipAnimation && !captureState.showSuccessAnimation && (h("div", { key: '144c3741003ec0cc148bb6ce92012d7b3cd110c8', class: "skip-section" }, h("div", { key: 'f0a984a6b75afa374c5d47da9d53e39f98071da0', class: "skip-explanation" }, "Si tu documento no tiene lado trasero, da clic en el bot\u00F3n para continuar con el proceso"), h("button", { key: '57ac30d776e30709aab6e0a621cef889da3cc677', class: "skip-button", onClick: () => this.skipBackCapture(), type: "button" }, this.enableBackDocumentTimer && this.backDocumentTimerRemaining > 0
+            } })))), this.isMaskReady && (h("div", { key: 'c56fde56b7a86a4e8a4cf558745291ea5cde12fd', class: "overlay-mask" }, h("div", { key: '04ed3f01f271dc84eed594cb4b60c2453645bd41', class: "card-outline" }, h("div", { key: '648bd423a5e886d4768115237de5896c7223b30b', class: "side side-top" }), h("div", { key: 'b8878059493ca61961b9b3c82ecc18b50b79ac85', class: "side side-right" }), h("div", { key: '09e5ad64ff33dbd5c112bf52b71e14409ab6aa65', class: "side side-bottom" }), h("div", { key: 'b8ba3d83c9bc1b4a0da859d7ed4b9a15eaddcc2a', class: "side side-left" })), !captureState.showFlipAnimation && !captureState.showSuccessAnimation && (h("div", { key: '3279701a240f77ac96e68a34ad95c099340c9a6a', class: `guide-text ${this.showPerformanceMessage ? 'performance-warning-text' : ''}` }, this.getGuideText(captureState.step))), captureState.step === 'back' && !captureState.showFlipAnimation && !captureState.showSuccessAnimation && (h("div", { key: '2adf96d0a57e482372fd9586229dac2301b64fd4', class: "back-capture-section" }, h("div", { key: '305a147c9cfee854c60ac946a48a1d21b2792725', class: "back-capture-buttons" }, (!this.useDocumentDetector || this.performanceDegradedMode || this.showManualCaptureButton) && (h("button", { key: '43270a0647f39307229c540dd5130fb58b1ff4fb', class: "capture-button primary-button", onClick: () => this.takeManualScreenshot(), type: "button", disabled: this.processingButton !== null }, this.processingButton === 'capture-back' && (h("span", { key: 'eb4666603774564eef95a120ac13faeb9e10c8b4', class: "button-spinner" })), "Capturar Reverso")), h("button", { key: 'cac667d9548ae2314ad5a677c5ed90f25184f728', class: "skip-button", onClick: () => this.skipBackCapture(), type: "button", disabled: this.processingButton !== null }, this.processingButton === 'skip-back' && (h("span", { key: '0af7aa4106ce189ae2d79bec78ede01abe25b1e7', class: "button-spinner" })), this.enableBackDocumentTimer && this.backDocumentTimerRemaining > 0
             ? `Saltar reverso (${this.backDocumentTimerRemaining}s)`
-            : 'Saltar reverso'))), captureState.isVideoActive && (h("div", { key: 'bd45628707e0169317ed3dd4247e1056d7046104', class: "camera-controls" }, h("button", { key: 'e750fbf4d5d76d9e9596823bb2b86801ef19e485', 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: '40ada780a8ea13aeeaee9cb39bc6496f69f2679d', class: "camera-selector-dropdown" }, h("div", { key: '3a920bb02ba024f0359513f10544bf0528ecee6d', class: "camera-selector-header" }, h("span", { key: 'e5efd478a602b13821ba53cb9a7a59d1b4a71178' }, "Seleccionar C\u00E1mara"), h("button", { key: '2df6cc11e162be74862029e33815927e3fa8f2f8', class: "close-selector", onClick: () => this.toggleCameraSelector(), type: "button" }, "\u00D7")), h("div", { key: '06934642dff134c9e1a6872f935a5892a9c7b835', 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: '8d5ede287c2efb0ebe418bee8dc7fb310443c991', class: "device-info" }, h("small", { key: 'b7dd10565113694b09f01ab28ffa29262ae1d2bc' }, "Dispositivo: ", cameraInfo.deviceType)))))), captureState.isCapturing && (h("div", { key: '2f9e549e6c0c56d4db5835e58361fb17bba6cf90', class: "capture-animation" })), captureState.showFlipAnimation && (h("div", { key: 'a6ef0ed127f23e9d764896ed743ca8d8454851a6', class: "flip-animation" }, h("div", { key: '0b04411f88a634bb3243b00ca2d5a45fd6962dea', class: "id-card-icon" }), h("div", { key: '9327be58879b407cea87f455989406e58302e9d1', class: "flip-text" }, "\u00A1Voltea tu identificaci\u00F3n!"))), captureState.showSuccessAnimation && (h("div", { key: 'bd268578b5003e99256e3340b4a9a6fb7656be64', class: "success-animation" }, h("div", { key: '064e0a5b9851de14bc6829f028e7ea7161fd1633', class: "check-icon" }), h("div", { key: 'bdcd94a8806399e396e218a359c10b11d05f38d6', class: "success-text" }, "\u00A1Proceso completado!"))), h("div", { key: '3d9af617376c16e44e065873919c3d90ff46110a', class: `component-status status-${this.currentStatus.type}` }, (this.currentStatus.type === 'loading' || this.currentStatus.type === 'initializing') && (h("div", { key: 'be7b56decfd6f12dcca46b2a9456480e3d5ac00e', class: "status-spinner" })), h("div", { key: '5fe9850883cb749cebaa18c3e9c13ca21325e373', class: "status-content" }, h("div", { key: '43fdb50691e4b98e56126af1a129f625061128bf', class: "status-message" }, this.currentStatus.message), this.currentStatus.description && (h("div", { key: 'b76cbfa4a0349421fcd535d3fd8bf40c89ca3aef', class: "status-description" }, this.currentStatus.description)))), this.debug && (h("div", { key: 'eddefb464af0487ab9ab2a0f76dccbb6a2092e51', class: "performance-monitor" }, h("div", { key: '7b7d93b56cb4cd4fbb1bdde89c6150b282fa805e', class: "performance-expanded" }, h("div", { key: 'f302e8b9d985fb8cad53c4c4e0d37a3bf5a63261', class: "metrics-row" }, h("div", { key: 'e8d8f2420ee8643a7f454d38065c75b5be598f77', class: "metric-compact" }, h("span", { key: '6e52eb5bb06e0df57e61774de38c31349f45e22b', class: "metric-label" }, "FPS"), h("span", { key: '6636f9cea20c49b49c17db86188e2f6b214c45c3', class: `metric-value ${this.performanceData.fps < 15 ? 'warning' : this.performanceData.fps < 10 ? 'danger' : 'good'}` }, this.performanceData.fps)), h("div", { key: 'afa1d9dec05b14256a1b1fcec8638b8c21a56e37', class: "metric-compact" }, h("span", { key: '9c55e30f5d01582648bacc1fb38ca1990485a591', class: "metric-label" }, "MEM"), h("span", { key: 'ca263601e8715027f95ffb2d5413a643dc570cf2', class: `metric-value ${this.performanceData.memoryUsage > 100 ? 'warning' : this.performanceData.memoryUsage > 200 ? 'danger' : 'good'}` }, this.performanceData.memoryUsage, "MB"))), h("div", { key: '03caf19961fd01b7781484d49d8121b1e78c161f', class: "metrics-row" }, h("div", { key: 'bffb08f01f703411f7c8605e4f8d95b1c37b5c0f', class: "metric-compact" }, h("span", { key: '9b92279b3253cc669412733facb3751f4344d69f', class: "metric-label" }, "INF"), h("span", { key: '3234d4150e2e1479e3b552767af8123e69911d6c', class: `metric-value ${this.performanceData.inferenceTime > 100 ? 'warning' : this.performanceData.inferenceTime > 200 ? 'danger' : 'good'}` }, this.performanceData.inferenceTime, "ms")), h("div", { key: '77082d2669db53f19fb50b3bbfa1ebefb0b86ff4', class: "metric-compact" }, h("span", { key: 'cc6ef96c72c800ba36dab2a388f1de863b2dacd5', class: "metric-label" }, "FRAME"), h("span", { key: 'e2bb4b7351869a76e810f8bbf20d805154495e35', class: `metric-value ${this.performanceData.frameProcessingTime > 50 ? 'warning' : this.performanceData.frameProcessingTime > 100 ? 'danger' : 'good'}` }, this.performanceData.frameProcessingTime, "ms"))), h("div", { key: '5700d7ef839fa77686299d79445203090dc8079f', class: "metrics-row" }, h("div", { key: 'a2999a035fccb7f250c01b084075490678513c87', class: "metric-compact" }, h("span", { key: '3677d58665996fa5969507dbaff9e956b2ea54ee', class: "metric-label" }, "DET"), h("span", { key: 'c584312438b339c82a3bdc33f00fb985ff2a6f55', class: "metric-value good" }, this.performanceData.successfulDetections, "/", this.performanceData.totalDetections)), h("div", { key: '58866219f213bf8607083f30be2d5ca5d0515cea', class: "metric-compact" }, h("span", { key: 'd90b450051331347f219b6c0f197536d0dcee9b7', class: "metric-label" }, "RATE"), h("span", { key: 'f6e6cd7948e06014e5a0416e4e81394fa36ec61d', class: `metric-value ${this.performanceData.detectionRate < 30 ? 'danger' : this.performanceData.detectionRate < 60 ? 'warning' : 'good'}` }, this.performanceData.detectionRate, "%")))))), h("div", { key: 'c1d0194f181a0082cc1aa5452de382908da61b65', class: "watermark" }, h("img", { key: 'e04d35f3c79a2b4a3922ab5b0f102220171fa7c0', src: "https://storage.googleapis.com/jaak-static/commons/powered-by-jaak.png", alt: "Powered by Jaak" })))));
+            : 'Saltar reverso')))), captureState.isVideoActive && (h("div", { key: 'de6e5c4fad4d4d996b894457c9af52bc71e533fb', class: "camera-controls" }, h("button", { key: 'cfddcf2420d5f5923a6b02ca446bbe1b8e9fc5e4', 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: '5fb73f958b9a5a6f9242032c4530b0bdab84f6c5', class: "camera-selector-dropdown" }, h("div", { key: '8ee2d26b1001e571e7b6c326e927926fa08287fd', class: "camera-selector-header" }, h("span", { key: '78350b0fb1bd933f7c8c59d8dab0b7122ffbe363' }, "Seleccionar C\u00E1mara"), h("button", { key: 'bb750e0ddd5a1ee5ff96bd57805a7f90b8821e9f', class: "close-selector", onClick: () => this.toggleCameraSelector(), type: "button" }, "\u00D7")), h("div", { key: 'd0f6343cf1b7367f3da33ec8cf64891109d923b8', 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}`, camera.hasAutofocus && (h("span", { class: "autofocus-icon", title: "Autofoco disponible" }, "\u29BF"))), cameraInfo.selectedCameraId === camera.id && (h("span", { class: "selected-indicator" }, "\u2713")))))), h("div", { key: 'c9642fbfb0acea766d3f0542f4cc9f17f4af4d7b', class: "device-info" }, h("small", { key: 'b6e9507ff7addf011f339f6c22a88a96b40db68a' }, "Dispositivo: ", cameraInfo.deviceType)))), this.showManualCaptureButton && captureState.step === 'front' && !captureState.showFlipAnimation && !captureState.showSuccessAnimation && (h("div", { key: '04ae9262409284782850b90945eb7038673e2097', class: "manual-capture-section" }, h("button", { key: '27c315e503ccba468b89ebd58d6b70f40ddd06ba', class: "manual-capture-button", onClick: () => this.takeManualScreenshot(), type: "button", disabled: this.processingButton !== null }, this.processingButton === 'capture-front' && (h("span", { key: '8f2dcd2df9a218b37eb0b8204a8724362cfeaa53', class: "button-spinner" })), "Capturar Frente"))))), captureState.isCapturing && (h("div", { key: '6fd6fe1d0213b01c8119a67fb8108f73227feee1', class: "capture-animation" })), captureState.showFlipAnimation && (h("div", { key: 'fba3816b48b99ca64510ecbefc0d41431569c9ae', class: "flip-animation" }, h("div", { key: 'beea1c8245b5d81f1008efc6d1b079a61c821e7f', class: "id-card-icon" }), h("div", { key: 'f0fbc34f619a653e2c0ade764ca99e7aa582d157', class: "flip-text" }, "\u00A1Voltea tu identificaci\u00F3n!"))), captureState.showSuccessAnimation && (h("div", { key: 'e4a0e6d31112e3a50024d1d0430b4ad997049fe7', class: "success-animation" }, h("div", { key: '5dd3f781f55630bc904c81207548ae35bc79b452', class: "check-icon" }), h("div", { key: 'a10ebc557582325091efb0abd12d62b27a43b98c', class: "success-text" }, "\u00A1Proceso completado!"))), h("div", { key: '975865955dee1803b5215ecf049701c98b324855', class: `component-status status-${this.currentStatus.type}` }, (this.currentStatus.type === 'loading' || this.currentStatus.type === 'initializing') && (h("div", { key: '84f6f67202e26ce80f7fc5d5f321e23b5bc55c57', class: "status-spinner" })), h("div", { key: 'a1ae56ed156e8feb279a1bf160f749c5d0b5ce45', class: "status-content" }, h("div", { key: 'd62932554cea257ce19763df26e0ba702e50eeca', class: "status-message" }, this.currentStatus.message), this.currentStatus.description && (h("div", { key: 'c5506fa12dd0d37d26dc26c9f2381c843330451f', class: "status-description" }, this.currentStatus.description)))), this.debug && (h("div", { key: '2097eda63185f336f7319014fae2ef6db1e41761', class: "performance-monitor" }, h("div", { key: 'd611c494c6b1a5930ef64aebdcba41e5d94c9ee6', class: "performance-expanded" }, h("div", { key: '800d46831e7b9bec260d9c5e67ea1a3eb9c2933e', class: "metrics-row" }, h("div", { key: 'dd0db1faa9050d98e71da4b5cd26a4a484c37c64', class: "metric-compact" }, h("span", { key: 'f0e6ea61a35ddb2ae5c2a6aff8c255a02c5c1219', class: "metric-label" }, "FPS"), h("span", { key: 'cbf4df4d142f6f01e45f566a8ede8fbbf29ad673', class: `metric-value ${this.performanceData.fps < 15 ? 'warning' : this.performanceData.fps < 10 ? 'danger' : 'good'}` }, this.performanceData.fps)), h("div", { key: '83861ad31fa46c8199a5583e4b3f8eefd44bacd6', class: "metric-compact" }, h("span", { key: '41b8de4cda47959dfc9df393e95fdadde534dd21', class: "metric-label" }, "MEM"), h("span", { key: 'b268f13cc78066e240ed158f1443113a94827aff', class: `metric-value ${this.performanceData.memoryUsage > 100 ? 'warning' : this.performanceData.memoryUsage > 200 ? 'danger' : 'good'}` }, this.performanceData.memoryUsage, "MB"))), h("div", { key: '9f9a9d0690906b186492af23b900c5fa0f5cff89', class: "metrics-row" }, h("div", { key: '84fa6e453dc36e4a74e8b573447b17230766229e', class: "metric-compact" }, h("span", { key: 'f17d52899090c89f532d74c552dd8c5338fc2d83', class: "metric-label" }, "INF"), h("span", { key: '2beca0d7ce55ed574f6b01efc086c5846983e024', class: `metric-value ${this.performanceData.inferenceTime > 100 ? 'warning' : this.performanceData.inferenceTime > 200 ? 'danger' : 'good'}` }, this.performanceData.inferenceTime, "ms")), h("div", { key: '981e300cf076e81bfe946974f6cffd63619eacde', class: "metric-compact" }, h("span", { key: '3dfb0c996a69eb87b0f711322675cad69c471146', class: "metric-label" }, "FRAME"), h("span", { key: '3ae2ac6e90cda77f23e559f3197c3b761f9bdc40', class: `metric-value ${this.performanceData.frameProcessingTime > 50 ? 'warning' : this.performanceData.frameProcessingTime > 100 ? 'danger' : 'good'}` }, this.performanceData.frameProcessingTime, "ms"))), h("div", { key: '2c51216838d87728d9d7764e5ba8a50fa02eb493', class: "metrics-row" }, h("div", { key: 'eda810ffb80ec38ab84583f59b26706f90a50fc9', class: "metric-compact" }, h("span", { key: '978ba9c0c67d6da6b29b3535af33a314bab9276a', class: "metric-label" }, "DET"), h("span", { key: '3e5e169fd4a3906283d8f918b5bbc7c5df6ccd0f', class: "metric-value good" }, this.performanceData.successfulDetections, "/", this.performanceData.totalDetections)), h("div", { key: 'b4b915c745e35c09470a4dc5edfc112d32cfb8b6', class: "metric-compact" }, h("span", { key: '3e2a7b88a4446813c955efb0dfa9e2958e8e1448', class: "metric-label" }, "RATE"), h("span", { key: 'f4f073f7ee622167a241c6a1c535ef580c13d9ab', class: `metric-value ${this.performanceData.detectionRate < 30 ? 'danger' : this.performanceData.detectionRate < 60 ? 'warning' : 'good'}` }, this.performanceData.detectionRate, "%")))))), h("div", { key: '76c556e92f6d7980539f1a30efe8751f665164fb', class: "watermark" }, h("img", { key: 'af23e115d6b4e92a72e55d6d98fde0e4b1d09e9b', src: "https://storage.googleapis.com/jaak-static/commons/powered-by-jaak.png", alt: "Powered by Jaak" })))));
     }
     // Utility methods
     updateDetectionBoxes(boxes) {
@@ -709,35 +1075,18 @@ export class JaakStamps {
         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) {
                 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
-                });
                 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.takeScreenshot().catch(() => {
+                        // Handle screenshot error silently
                     });
                     this.hasScreenshotTaken = true;
                     this.alignmentStartTime = undefined;
@@ -760,24 +1109,150 @@ export class JaakStamps {
             }
         }
     }
+    async takeManualScreenshot() {
+        console.log('🔵 Botón clicked: Capturar (Frente/Reverso)');
+        // Set processing state immediately
+        const captureState = this.stateManager?.getCaptureState();
+        if (captureState?.step === 'front') {
+            this.processingButton = 'capture-front';
+        }
+        else if (captureState?.step === 'back') {
+            this.processingButton = 'capture-back';
+        }
+        console.log('🔵 processingButton set to:', this.processingButton);
+        // Add small delay to show spinner
+        await new Promise(resolve => setTimeout(resolve, 100));
+        if (!this.videoRef) {
+            this.processingButton = null;
+            return;
+        }
+        // When using manual capture, use mask coordinates for cropping
+        // Note: processingButton will be cleared inside takeScreenshotWithMaskCoordinates
+        await this.takeScreenshotWithMaskCoordinates();
+    }
+    async takeScreenshotWithMaskCoordinates() {
+        if (!this.videoRef || !this.detectionContainer)
+            return;
+        this.stateManager.updateCaptureState({ isCapturing: true });
+        this.triggerCaptureAnimation();
+        // Use pooled canvas for optimization
+        const captureCanvas = this.getPooledCanvas(this.videoRef.videoWidth, this.videoRef.videoHeight);
+        const captureCtx = captureCanvas.getContext('2d', { alpha: false });
+        captureCtx.clearRect(0, 0, captureCanvas.width, captureCanvas.height);
+        captureCtx.drawImage(this.videoRef, 0, 0, captureCanvas.width, captureCanvas.height);
+        // Calculate mask coordinates for cropping
+        const container = this.detectionContainer.parentElement;
+        const containerRect = container.getBoundingClientRect();
+        // Get mask dimensions from CSS properties
+        const maskWidthPercent = parseFloat(this.el.style.getPropertyValue('--mask-width').replace('%', '')) || 90;
+        const maskHeightPercent = parseFloat(this.el.style.getPropertyValue('--mask-height').replace('%', '')) || 56.25;
+        const maskCenterXPercent = parseFloat(this.el.style.getPropertyValue('--mask-center-x').replace('%', '')) || 50;
+        const maskCenterYPercent = parseFloat(this.el.style.getPropertyValue('--mask-center-y').replace('%', '')) || 50;
+        // Convert percentages to actual video coordinates
+        const videoWidth = this.videoRef.videoWidth;
+        const videoHeight = this.videoRef.videoHeight;
+        const videoAspectRatio = videoWidth / videoHeight;
+        const containerAspectRatio = containerRect.width / containerRect.height;
+        let displayedVideoWidth, displayedVideoHeight;
+        let videoOffsetX = 0, videoOffsetY = 0;
+        if (videoAspectRatio > containerAspectRatio) {
+            displayedVideoWidth = containerRect.width;
+            displayedVideoHeight = containerRect.width / videoAspectRatio;
+            videoOffsetY = (containerRect.height - displayedVideoHeight) / 2;
+        }
+        else {
+            displayedVideoHeight = containerRect.height;
+            displayedVideoWidth = containerRect.height * videoAspectRatio;
+            videoOffsetX = (containerRect.width - displayedVideoWidth) / 2;
+        }
+        // Calculate mask coordinates in video space
+        const maskWidthInContainer = (maskWidthPercent / 100) * containerRect.width;
+        const maskHeightInContainer = (maskHeightPercent / 100) * containerRect.height;
+        const maskCenterXInContainer = (maskCenterXPercent / 100) * containerRect.width;
+        const maskCenterYInContainer = (maskCenterYPercent / 100) * containerRect.height;
+        // Convert to video coordinates
+        const scaleX = videoWidth / displayedVideoWidth;
+        const scaleY = videoHeight / displayedVideoHeight;
+        const maskCenterXInVideo = (maskCenterXInContainer - videoOffsetX) * scaleX;
+        const maskCenterYInVideo = (maskCenterYInContainer - videoOffsetY) * scaleY;
+        const maskWidthInVideo = maskWidthInContainer * scaleX;
+        const maskHeightInVideo = maskHeightInContainer * scaleY;
+        // Calculate crop coordinates
+        const cropX = Math.max(0, maskCenterXInVideo - (maskWidthInVideo / 2) - this.cropMargin);
+        const cropY = Math.max(0, maskCenterYInVideo - (maskHeightInVideo / 2) - this.cropMargin);
+        const cropWidth = Math.min(maskWidthInVideo + (2 * this.cropMargin), videoWidth - cropX);
+        const cropHeight = Math.min(maskHeightInVideo + (2 * this.cropMargin), videoHeight - cropY);
+        // Use pooled canvas for cropped version
+        const croppedCanvas = this.getPooledCanvas(cropWidth, cropHeight);
+        const croppedCtx = croppedCanvas.getContext('2d', { alpha: false });
+        croppedCtx.clearRect(0, 0, croppedCanvas.width, croppedCanvas.height);
+        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/jpeg'),
+                    cropped: croppedCanvas.toDataURL('image/jpeg')
+                }
+            });
+            // Check if document classification is enabled (independent of detector)
+            if (this.useDocumentClassification) {
+                try {
+                    const classification = await this.detectionService.classifyDocument(croppedCanvas);
+                    if (classification && classification.class === 'passport') {
+                        this.completeProcess(true);
+                        this.returnCanvasToPool(captureCanvas);
+                        this.returnCanvasToPool(croppedCanvas);
+                        // Clear processing button when passport is detected
+                        this.processingButton = null;
+                        return;
+                    }
+                }
+                catch (classifyError) {
+                    // No cambiar a manual aquí, solo registrar el error y continuar
+                }
+            }
+            this.stateManager.updateCaptureState({
+                step: 'back',
+                isDetectionPaused: true,
+                showFlipAnimation: true
+            });
+            this.triggerRerender();
+            setTimeout(() => {
+                this.stateManager.updateCaptureState({
+                    showFlipAnimation: false,
+                    isDetectionPaused: false
+                });
+                this.triggerRerender();
+                this.startBackDocumentTimer();
+                // Clear processing button after animation completes
+                this.processingButton = null;
+            }, 3000);
+        }
+        else if (captureState.step === 'back') {
+            this.stateManager.setCapturedImages({
+                back: {
+                    fullFrame: captureCanvas.toDataURL('image/jpeg'),
+                    cropped: croppedCanvas.toDataURL('image/jpeg')
+                }
+            });
+            this.completeProcess(false);
+            // Clear processing button after back capture completes
+            this.processingButton = null;
+        }
+        // Return canvases to pool after use
+        this.returnCanvasToPool(captureCanvas);
+        this.returnCanvasToPool(croppedCanvas);
+    }
     async takeScreenshot() {
         if (!this.videoRef || !this.lastDetectedBox)
             return;
-        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();
-        // Create capture canvas
-        const captureCanvas = document.createElement('canvas');
-        captureCanvas.width = this.videoRef.videoWidth;
-        captureCanvas.height = this.videoRef.videoHeight;
+        // Use pooled canvas for optimization
+        const captureCanvas = this.getPooledCanvas(this.videoRef.videoWidth, this.videoRef.videoHeight);
         const captureCtx = captureCanvas.getContext('2d', { alpha: false });
+        captureCtx.clearRect(0, 0, captureCanvas.width, captureCanvas.height);
         captureCtx.drawImage(this.videoRef, 0, 0, captureCanvas.width, captureCanvas.height);
         // Calculate crop coordinates
         const INPUT_SIZE = 320;
@@ -787,27 +1262,30 @@ export class JaakStamps {
         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);
-        // Create cropped version
-        const croppedCanvas = document.createElement('canvas');
-        croppedCanvas.width = cropWidth;
-        croppedCanvas.height = cropHeight;
+        // Use pooled canvas for cropped version
+        const croppedCanvas = this.getPooledCanvas(cropWidth, cropHeight);
         const croppedCtx = croppedCanvas.getContext('2d', { alpha: false });
+        croppedCtx.clearRect(0, 0, croppedCanvas.width, croppedCanvas.height);
         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')
+                    fullFrame: captureCanvas.toDataURL('image/jpeg'),
+                    cropped: croppedCanvas.toDataURL('image/jpeg')
                 }
             });
             // Check if document classification is enabled
             if (this.useDocumentClassification) {
-                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;
+                try {
+                    const classification = await this.detectionService.classifyDocument(croppedCanvas);
+                    if (classification && classification.class === 'passport') {
+                        this.completeProcess(true);
+                        return;
+                    }
+                }
+                catch (classifyError) {
+                    // No cambiar a manual aquí, solo registrar el error y continuar
                 }
             }
             this.stateManager.updateCaptureState({
@@ -826,12 +1304,15 @@ export class JaakStamps {
         else if (captureState.step === 'back') {
             this.stateManager.setCapturedImages({
                 back: {
-                    fullFrame: captureCanvas.toDataURL('image/png'),
-                    cropped: croppedCanvas.toDataURL('image/png')
+                    fullFrame: captureCanvas.toDataURL('image/jpeg'),
+                    cropped: croppedCanvas.toDataURL('image/jpeg')
                 }
             });
             this.completeProcess(false);
         }
+        // Return canvases to pool after use
+        this.returnCanvasToPool(captureCanvas);
+        this.returnCanvasToPool(croppedCanvas);
     }
     triggerCaptureAnimation() {
         const cardOutline = this.el.shadowRoot?.querySelector('.card-outline');
@@ -841,6 +1322,138 @@ export class JaakStamps {
             cardOutline?.classList.remove('capturing');
         }, 600);
     }
+    // Método simplificado para cambio a modo manual
+    switchToManualMode() {
+        // Only switch if detector is enabled and not already switched
+        if (!this.useDocumentDetector || this.hasAutoSwitchedToManual) {
+            return;
+        }
+        // Detener todo el monitoreo de performance
+        this.stopPerformanceMonitoring();
+        // Liberar recursos de ONNX
+        this.releaseOnnxResources();
+        // Resetear máscara a blanco y limpiar detecciones
+        this.resetMaskToWhite();
+        this.detectionBoxes = [];
+        this.hasAutoSwitchedToManual = true;
+        this.performanceDegradedMode = true;
+        this.showManualCaptureButton = true;
+        this.showPerformanceMessage = true;
+        // Hide performance message after 5 seconds
+        setTimeout(() => {
+            this.showPerformanceMessage = false;
+        }, 5000);
+    }
+    // Método para cambiar a modo manual por errores de ONNX
+    switchToManualModeWithWarning(warningMessage) {
+        // Solo cambiar si el detector está habilitado y no se ha cambiado ya
+        if (!this.useDocumentDetector || this.hasAutoSwitchedToManual) {
+            return;
+        }
+        // No necesitamos liberar recursos ONNX porque no se han cargado aún
+        // Resetear máscara a blanco y limpiar detecciones
+        this.resetMaskToWhite();
+        this.detectionBoxes = [];
+        // Cambiar a modo manual
+        this.hasAutoSwitchedToManual = true;
+        this.performanceDegradedMode = true;
+        this.showManualCaptureButton = true;
+        this.useDocumentDetector = false; // Desactivar detector automático
+        // Actualizar el estado con mensaje informativo (no error)
+        this.updateStatus('Modo manual activado', warningMessage, 'active');
+        // Continuar con la configuración de cámara
+        this.continueWithCameraSetup();
+    }
+    async continueWithCameraSetup() {
+        try {
+            // Paso 2: Detectar y configurar dispositivos
+            this.updateStatus('Configurando cámara...', 'Buscando dispositivos disponibles', 'loading');
+            try {
+                await this.cameraService.enumerateDevices();
+            }
+            catch (enumerateError) {
+                throw new Error(`Error al enumerar dispositivos: ${enumerateError.message}`);
+            }
+            try {
+                await this.updateCameraInfoWithAutofocus();
+            }
+            catch (cameraInfoError) {
+                throw new Error(`Error al actualizar información de cámara: ${cameraInfoError.message}`);
+            }
+            // Paso 3: Configurar cámara seleccionada
+            this.updateStatus('Ajustando cámara...', 'Configurando calidad de imagen', 'loading');
+            let stream;
+            try {
+                stream = await this.cameraService.setupCamera();
+            }
+            catch (setupError) {
+                throw new Error(`Error al configurar cámara: ${setupError.message}`);
+            }
+            // Paso 4: Inicializar video
+            this.updateStatus('Captura manual', 'Posicione su documento y use el botón para capturar', 'active');
+            try {
+                await this.initializeVideoStream(stream);
+            }
+            catch (videoError) {
+                throw new Error(`Error al inicializar video: ${videoError.message}`);
+            }
+            // Paso 5: Calibrar máscara
+            if (this.detectionContainer) {
+                const container = this.detectionContainer.parentElement;
+                const rect = container.getBoundingClientRect();
+                this.updateMaskDimensions(rect);
+            }
+            // Finalizar
+            this.startTime = Date.now();
+            this.stateManager.updateCaptureState({ isLoading: false });
+            // Mostrar botón manual (ya debe estar habilitado)
+            this.showManualCaptureButton = true;
+        }
+        catch (error) {
+            this.updateStatus('Error de cámara', error.message, 'error');
+            throw error;
+        }
+    }
+    switchToManualModeWithError(errorMessage) {
+        // Solo cambiar si el detector está habilitado y no se ha cambiado ya
+        if (!this.useDocumentDetector || this.hasAutoSwitchedToManual) {
+            return;
+        }
+        // Liberar recursos de ONNX inmediatamente
+        this.releaseOnnxResources();
+        // Resetear máscara a blanco y limpiar detecciones
+        this.resetMaskToWhite();
+        this.detectionBoxes = [];
+        // Cambiar a modo manual
+        this.hasAutoSwitchedToManual = true;
+        this.performanceDegradedMode = true;
+        this.showManualCaptureButton = true;
+        this.useDocumentDetector = false; // Desactivar detector automático
+        // Actualizar el estado con mensaje de error
+        this.updateStatus('Modo manual activado', errorMessage, 'error');
+        // Continuar con la configuración de cámara para mostrar el video
+        this.continueWithCameraSetup().catch(() => {
+            // Si falla la configuración de cámara, mantener el mensaje de error pero cambiar el estado
+            setTimeout(() => {
+                this.updateStatus('Captura manual', 'Use el botón para capturar', 'ready');
+            }, 5000);
+        });
+    }
+    stopPerformanceMonitoring() {
+        // Nota: No necesitamos limpiar más variables porque ya no se usarán
+        // El sistema automáticamente saltará la lógica de performance una vez que hasAutoSwitchedToManual = true
+    }
+    // Método para liberar recursos de ONNX cuando se cambia a modo manual
+    releaseOnnxResources() {
+        try {
+            // Liberar recursos del servicio de detección
+            if (this.detectionService) {
+                this.detectionService.cleanup();
+            }
+        }
+        catch (error) {
+        }
+    }
     completeProcess(skippedBack = false) {
         this.stateManager.updateCaptureState({
             step: 'completed',
@@ -860,11 +1473,6 @@ export class JaakStamps {
         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) {
@@ -873,7 +1481,6 @@ export class JaakStamps {
         }
         this.clearBackDocumentTimer();
         this.detectionBoxes = [];
-        this.logger.state('DETECTOR_DETENIDO', { timestamp: Date.now() });
     }
     startBackDocumentTimer() {
         if (!this.enableBackDocumentTimer)
@@ -902,17 +1509,28 @@ export class JaakStamps {
             return; // Don't toggle if switching camera
         this.showCameraSelector = !this.showCameraSelector;
     }
+    async updateCameraInfoWithAutofocus() {
+        try {
+            const cameraInfo = await this.cameraService.getCameraInfo();
+            this.cameraInfoWithAutofocus = cameraInfo;
+        }
+        catch (error) {
+            // Keep existing state if update fails
+        }
+    }
     async handleCameraSwitch(cameraId) {
         if (this.isSwitchingCamera)
             return; // Prevent multiple simultaneous switches
         try {
             // Close the selector immediately when user selects a camera
             this.showCameraSelector = false;
+            // Check if user selected the same camera that's already active
+            const currentCameraId = this.cameraService.getSelectedCameraId();
+            if (currentCameraId === cameraId) {
+                // Same camera selected, just close the selector without switching
+                return;
+            }
             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());
@@ -923,21 +1541,17 @@ export class JaakStamps {
             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)
-            });
+            // Update camera info with autofocus data
+            await this.updateCameraInfoWithAutofocus();
         }
         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');
+                this.updateStatus('Error al cambiar cámara', 'No se pudo cambiar el dispositivo', 'error');
             }
         }
         finally {
@@ -959,6 +1573,13 @@ export class JaakStamps {
         this.detectionBoxes = [];
         this.alignmentStartTime = undefined;
         this.hasDocumentDetected = false;
+        // Reset sistema simplificado
+        this.processedFramesCount = 0;
+        this.slowFrameCount = 0;
+        // Reset performance degradation state
+        this.hasAutoSwitchedToManual = false;
+        this.performanceDegradedMode = false;
+        this.showPerformanceMessage = false;
         if (this.alignmentTimer) {
             clearTimeout(this.alignmentTimer);
             this.alignmentTimer = undefined;
@@ -978,7 +1599,7 @@ export class JaakStamps {
             this.stateManager.updateCaptureState({ isVideoActive: false, isLoading: false });
         }
         this.isMaskReady = false;
-        this.updateStatus('Sesión finalizada', '', 'ready');
+        this.updateStatus('Captura finalizada', '', 'ready');
         this.detectionBoxes = [];
         this.cleanup();
     }
@@ -989,7 +1610,6 @@ export class JaakStamps {
         this.performanceUpdateInterval = window.setInterval(() => {
             this.updatePerformanceMetrics();
         }, 500);
-        this.logger.debug('Monitor de performance inicializado');
     }
     updatePerformanceMetrics() {
         const currentTime = performance.now();
@@ -1032,6 +1652,84 @@ export class JaakStamps {
         if (detectionsFound > 0) {
             this.performanceMetrics.successfulDetections++;
         }
+        // Update performance history for adaptive frame skipping
+        this.performanceHistory.push(processingTime);
+        if (this.performanceHistory.length > this.PERFORMANCE_HISTORY_SIZE) {
+            this.performanceHistory.shift();
+        }
+    }
+    // Adaptive frame skipping based on performance
+    getAdaptiveFrameSkip() {
+        // Base conditions for high frame skip
+        if (this.consecutiveFailures > 20)
+            return this.MAX_FRAME_SKIP;
+        if (this.performanceMetrics.inferenceTime > 200)
+            return 6;
+        if (this.performanceMetrics.memoryUsage > 200)
+            return 5;
+        // Calculate average processing time
+        if (this.performanceHistory.length > 0) {
+            const avgProcessingTime = this.performanceHistory.reduce((a, b) => a + b, 0) / this.performanceHistory.length;
+            if (avgProcessingTime > 100)
+                return 4;
+            if (avgProcessingTime > 80)
+                return 3;
+            if (avgProcessingTime > 60)
+                return this.BASE_FRAME_SKIP + 1;
+        }
+        // Low memory devices get higher frame skip
+        if (this.performanceMetrics.memoryUsage > 150)
+            return 4;
+        // Performance is good, use base frame skip
+        return this.BASE_FRAME_SKIP;
+    }
+    // Método para resetear la máscara a color blanco
+    resetMaskToWhite() {
+        const cardOutline = this.el.shadowRoot?.querySelector('.card-outline');
+        const corners = this.el.shadowRoot?.querySelectorAll('.corner');
+        const topSide = this.el.shadowRoot?.querySelector('.side-top');
+        const rightSide = this.el.shadowRoot?.querySelector('.side-right');
+        const bottomSide = this.el.shadowRoot?.querySelector('.side-bottom');
+        const leftSide = this.el.shadowRoot?.querySelector('.side-left');
+        // Remover todas las clases de alineación y estado perfecto
+        cardOutline?.classList.remove('perfect-match');
+        corners?.forEach(corner => corner.classList.remove('perfect-match'));
+        topSide?.classList.remove('aligned');
+        rightSide?.classList.remove('aligned');
+        bottomSide?.classList.remove('aligned');
+        leftSide?.classList.remove('aligned');
+        // Resetear estado de alineación
+        this.sideAlignment = { top: false, right: false, bottom: false, left: false };
+    }
+    // Canvas pool management for screenshots
+    getPooledCanvas(width, height) {
+        // Try to find a canvas with matching dimensions
+        const matchingIndex = this.canvasPool.findIndex(canvas => canvas.width === width && canvas.height === height);
+        if (matchingIndex !== -1) {
+            return this.canvasPool.splice(matchingIndex, 1)[0];
+        }
+        // If no matching canvas, try to reuse any canvas and resize
+        if (this.canvasPool.length > 0) {
+            const canvas = this.canvasPool.pop();
+            canvas.width = width;
+            canvas.height = height;
+            return canvas;
+        }
+        // Create new canvas if pool is empty
+        const canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+        return canvas;
+    }
+    returnCanvasToPool(canvas) {
+        // Only return to pool if not at max capacity
+        if (this.canvasPool.length < this.MAX_CANVAS_POOL_SIZE) {
+            // Clear the canvas before returning to pool
+            const ctx = canvas.getContext('2d');
+            ctx.clearRect(0, 0, canvas.width, canvas.height);
+            this.canvasPool.push(canvas);
+        }
+        // If pool is full, let the canvas be garbage collected
     }
     static get is() { return "jaak-stamps"; }
     static get encapsulation() { return "shadow"; }
@@ -1147,6 +1845,26 @@ export class JaakStamps {
                 "reflect": false,
                 "defaultValue": "false"
             },
+            "useDocumentDetector": {
+                "type": "boolean",
+                "attribute": "use-document-detector",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "true"
+            },
             "preferredCamera": {
                 "type": "string",
                 "attribute": "preferred-camera",
@@ -1238,9 +1956,15 @@ export class JaakStamps {
             "showCameraSelector": {},
             "isSwitchingCamera": {},
             "hasDocumentDetected": {},
+            "cameraInfoWithAutofocus": {},
             "currentStatus": {},
             "performanceData": {},
-            "backDocumentTimerRemaining": {}
+            "backDocumentTimerRemaining": {},
+            "showManualCaptureButton": {},
+            "performanceDegradedMode": {},
+            "showPerformanceMessage": {},
+            "captureStateVersion": {},
+            "processingButton": {}
         };
     }
     static get events() {
@@ -1319,7 +2043,7 @@ export class JaakStamps {
             },
             "startCapture": {
                 "complexType": {
-                    "signature": "() => Promise<void>",
+                    "signature": "() => Promise<{ success: boolean; error?: undefined; } | { success: boolean; error: any; }>",
                     "parameters": [],
                     "references": {
                         "Promise": {
@@ -1327,7 +2051,7 @@ export class JaakStamps {
                             "id": "global::Promise"
                         }
                     },
-                    "return": "Promise<void>"
+                    "return": "Promise<{ success: boolean; error?: undefined; } | { success: boolean; error: any; }>"
                 },
                 "docs": {
                     "text": "",
@@ -1336,7 +2060,7 @@ export class JaakStamps {
             },
             "stopCapture": {
                 "complexType": {
-                    "signature": "() => Promise<void>",
+                    "signature": "() => Promise<{ success: boolean; error?: undefined; } | { success: boolean; error: any; }>",
                     "parameters": [],
                     "references": {
                         "Promise": {
@@ -1344,7 +2068,7 @@ export class JaakStamps {
                             "id": "global::Promise"
                         }
                     },
-                    "return": "Promise<void>"
+                    "return": "Promise<{ success: boolean; error?: undefined; } | { success: boolean; error: any; }>"
                 },
                 "docs": {
                     "text": "",
@@ -1353,7 +2077,7 @@ export class JaakStamps {
             },
             "resetCapture": {
                 "complexType": {
-                    "signature": "() => Promise<void>",
+                    "signature": "() => Promise<{ success: boolean; error?: undefined; } | { success: boolean; error: any; }>",
                     "parameters": [],
                     "references": {
                         "Promise": {
@@ -1361,7 +2085,7 @@ export class JaakStamps {
                             "id": "global::Promise"
                         }
                     },
-                    "return": "Promise<void>"
+                    "return": "Promise<{ success: boolean; error?: undefined; } | { success: boolean; error: any; }>"
                 },
                 "docs": {
                     "text": "",
@@ -1370,7 +2094,7 @@ export class JaakStamps {
             },
             "skipBackCapture": {
                 "complexType": {
-                    "signature": "() => Promise<void>",
+                    "signature": "() => Promise<{ success: boolean; error?: undefined; } | { success: boolean; error: any; }>",
                     "parameters": [],
                     "references": {
                         "Promise": {
@@ -1378,7 +2102,7 @@ export class JaakStamps {
                             "id": "global::Promise"
                         }
                     },
-                    "return": "Promise<void>"
+                    "return": "Promise<{ success: boolean; error?: undefined; } | { success: boolean; error: any; }>"
                 },
                 "docs": {
                     "text": "",
@@ -1448,7 +2172,7 @@ export class JaakStamps {
             },
             "setPreferredCamera": {
                 "complexType": {
-                    "signature": "(camera: \"auto\" | \"front\" | \"back\") => Promise<{ success: boolean; selectedCamera: string; availableCameras: number; }>",
+                    "signature": "(camera: \"auto\" | \"front\" | \"back\") => Promise<{ success: boolean; selectedCamera: string; availableCameras: number; error?: undefined; } | { success: boolean; error: any; selectedCamera: any; availableCameras: number; }>",
                     "parameters": [{
                             "name": "camera",
                             "type": "\"auto\" | \"front\" | \"back\"",
@@ -1460,7 +2184,7 @@ export class JaakStamps {
                             "id": "global::Promise"
                         }
                     },
-                    "return": "Promise<{ success: boolean; selectedCamera: string; availableCameras: number; }>"
+                    "return": "Promise<{ success: boolean; selectedCamera: string; availableCameras: number; error?: undefined; } | { success: boolean; error: any; selectedCamera: any; availableCameras: number; }>"
                 },
                 "docs": {
                     "text": "",
@@ -1469,7 +2193,7 @@ export class JaakStamps {
             },
             "setCaptureDelay": {
                 "complexType": {
-                    "signature": "(delay: number) => Promise<{ success: boolean; captureDelay: number; }>",
+                    "signature": "(delay: number) => Promise<{ success: boolean; error: string; captureDelay: number; } | { success: boolean; captureDelay: number; error?: undefined; }>",
                     "parameters": [{
                             "name": "delay",
                             "type": "number",
@@ -1481,7 +2205,7 @@ export class JaakStamps {
                             "id": "global::Promise"
                         }
                     },
-                    "return": "Promise<{ success: boolean; captureDelay: number; }>"
+                    "return": "Promise<{ success: boolean; error: string; captureDelay: number; } | { success: boolean; captureDelay: number; error?: undefined; }>"
                 },
                 "docs": {
                     "text": "",
@@ -1504,52 +2228,6 @@ export class JaakStamps {
                     "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": "",
-                    "tags": []
-                }
             }
         };
     }