@srsergio/taptapp-ar 1.0.2 → 1.0.3

package/src/compiler/offline-compiler.js

@@ -1,553 +1,388 @@
 /**
- * @fileoverview Compilador Offline para Procesamiento de Imágenes con TensorFlow.js
- *
- * Este módulo implementa un sistema avanzado de compilación de imágenes para tracking
- * utilizando TensorFlow.js, optimizado especialmente para entornos backend con alto rendimiento.
- *
- * Arquitectura y Componentes Principales:
- *
- * 1. Sistema de Inicialización:
- *    - Implementa un patrón Singleton para TensorFlow con inicialización temprana
- *    - Carga asíncrona y paralela de backends (CPU/WebGL/Node)
- *    - Detección automática de entorno (serverless/navegador/backend dedicado)
- *    - Precalentamiento agresivo para reducir cold starts
- *
- * 2. Gestión de Memoria:
- *    - Sistema de liberación ultra-agresiva de memoria con umbrales dinámicos
- *    - Monitoreo continuo del uso de tensores con cleanup automático
- *    - Estrategias de scope anidados para control preciso de recursos
- *    - Liberación proactiva entre operaciones intensivas
- *
- * 3. Optimizaciones de Rendimiento:
- *    - Precalentamiento estratégico del backend para eliminar latencia inicial
- *    - Ajustes específicos por backend con configuraciones óptimas por plataforma
- *    - Configuraciones especializadas para entornos backend de alto rendimiento
- *    - Reducción de precisión selectiva para operaciones no críticas
- *
- * 4. Procesamiento por Lotes:
- *    - Sistema adaptativo de tamaño de lotes basado en capacidad de hardware
- *    - Paralelización multinivel con control de concurrencia
- *    - Control de progreso granular con retroalimentación en tiempo real
- *    - Estrategias de división de trabajo para CPUs multi-núcleo
- *
- * 5. Gestión de Recursos:
- *    - Timeouts inteligentes con recuperación automática
- *    - Liberación proactiva de recursos con GC forzado estratégico
- *    - Manejo de errores robusto con recuperación de fallos
- *    - Monitoreo de rendimiento en tiempo real
- *
- * @requires tensorflow/tfjs
- * @requires ./compiler-base.js
- * @requires ./image-list.js
- * @requires ./tracker/extract-utils.js
- * @requires ./tensorflow-setup.js
+ * @fileoverview Compilador Offline Optimizado - Sin TensorFlow para máxima velocidad
+ * 
+ * Este módulo implementa un compilador de imágenes AR ultrarrápido
+ * que NO depende de TensorFlow, eliminando todos los problemas de
+ * inicialización, bloqueos y compatibilidad.
+ * 
+ * Usa JavaScript puro para:
+ * - Extracción de features de tracking (extract.js)
+ * - Detección de features para matching (DetectorLite)
+ * - Clustering jerárquico para features
+ * 
+ * Funciona en:
+ * - Node.js (con workers opcionales)
+ * - Browser (sin workers)
  */
 
-import { CompilerBase } from "./compiler-base.js";
-import { buildTrackingImageList } from "./image-list.js";
+import { buildTrackingImageList, buildImageList } from "./image-list.js";
 import { extractTrackingFeatures } from "./tracker/extract-utils.js";
-import { setupTensorFlow } from "./tensorflow-setup.js";
-import { tf } from "./tensorflow-setup.js";
-import os from "os";
-// OPTIMIZACIÓN CORE DEL PROCESO DE COMPILACIÓN
-// 1. Inicialización temprana y paralela de TensorFlow
-// 2. Optimizaciones de memoria y procesamiento agresivas
-// 3. Estrategias de paralelización avanzadas
-// 4. Ajustes para entornos serverless (Vercel, AWS Lambda, etc)
-
-// Detector de entorno serverless
-const isServerlessEnvironment = () => {
-  return process.env.VERCEL || process.env.AWS_LAMBDA_FUNCTION_NAME || process.env.NETLIFY;
-};
-
-// Configurar TensorFlow lo antes posible con un Singleton
-let tensorflowBackend = null;
-let setupPromise = null;
-
-const setupTensorFlowAsync = async () => {
-  // Si ya hay una configuración en curso, reutilizarla
-  if (setupPromise) return setupPromise;
-
-  // Iniciar configuración y guardar la promesa
-  setupPromise = (async () => {
-    try {
-      console.time("⏱️ Configuración de TensorFlow");
-      const backend = await setupTensorFlow();
-      tensorflowBackend = backend;
-      console.timeEnd("⏱️ Configuración de TensorFlow");
-      return backend;
-    } catch (error) {
-      console.error("Error crítico al configurar TensorFlow:", error);
-      return null;
+import { DetectorLite } from "./detector/detector-lite.js";
+import { build as hierarchicalClusteringBuild } from "./matching/hierarchical-clustering.js";
+import * as msgpack from "@msgpack/msgpack";
+
+// Detect environment
+const isNode = typeof process !== "undefined" &&
+  process.versions != null &&
+  process.versions.node != null;
+
+const CURRENT_VERSION = 3; // Protocol v3: High-performance Columnar Binary Format
+
+/**
+ * Compilador offline optimizado sin TensorFlow
+ */
+export class OfflineCompiler {
+  constructor() {
+    this.data = null;
+    this.workerPool = null;
+
+    // Workers solo en Node.js (no en browser)
+    if (isNode) {
+      this._initNodeWorkers();
+    } else {
+      console.log("🌐 OfflineCompiler: Browser mode (no workers)");
     }
-  })();
-
-  return setupPromise;
-};
-
-// Iniciar la configuración inmediatamente al importar el módulo
-const tensorflowSetupPromise = setupTensorFlowAsync();
-
-// Registrar los kernels necesarios para CPU (carga temprana)
-import "./detector/kernels/cpu/index.js";
-
-// Registrar los backends básicos
-import "@tensorflow/tfjs-backend-cpu";
-
-// Configuraciones avanzadas para maximizar rendimiento en backend
-const enablePerformanceOptimizations = async () => {
-  try {
-    // Esperar a que TensorFlow esté configurado
-    await tensorflowSetupPromise;
-
-    // Optimizaciones específicas según el backend
-    const backend = tf.getBackend();
-    console.log(`⚙️ Optimizando agresivamente para backend: ${backend}`);
-
-    // Entorno serverless necesita configuraciones especiales
-    const isServerless = isServerlessEnvironment();
-    const isBackendDedicated = !isServerless && process.env.NODE_ENV === "production";
-
-    if (isBackendDedicated) {
-      console.log(
-        "🚀🚀 Entorno backend dedicado detectado, aplicando configuraciones de alto rendimiento",
-      );
-
-      // Configuraciones agresivas para backend dedicado
-      tf.ENV.set("CPU_HANDOFF_SIZE_THRESHOLD", 1024 * 1024 * 16); // 16MB - más memoria disponible
-      tf.ENV.set("WEBGL_SIZE_UPLOAD_UNIFORM", 16); // Mayor capacidad de transferencia
-      tf.ENV.set("WEBGL_DELETE_TEXTURE_THRESHOLD", 64); // Más texturas en memoria
-
-      // Configuraciones para maximizar throughput
-      tf.ENV.set("WEBGL_FLUSH_THRESHOLD", 10); // Menos flushes para mejor rendimiento
-      tf.ENV.set("KEEP_INTERMEDIATE_TENSORS", false); // Liberar intermedios agresivamente
-      tf.ENV.set("WEBGL_PACK_BINARY_OPERATIONS", true); // Empaquetar operaciones binarias
-    } else if (isServerless) {
-      console.log(
-        "🚀 Entorno serverless detectado, aplicando configuraciones de memoria restrictivas",
-      );
-
-      // En serverless aplicamos configuraciones más conservadoras para memoria
-      tf.ENV.set("CPU_HANDOFF_SIZE_THRESHOLD", 1024 * 1024 * 4); // 4MB
-      tf.ENV.set("WEBGL_SIZE_UPLOAD_UNIFORM", 4);
-      tf.ENV.set("WEBGL_DELETE_TEXTURE_THRESHOLD", 10);
-
-      // Menor precisión para mejor rendimiento
-      tf.ENV.set("WEBGL_RENDER_FLOAT32_ENABLED", false);
+  }
+
+  async _initNodeWorkers() {
+    try {
+      const [os, path, url, workerModule] = await Promise.all([
+        import("os"),
+        import("path"),
+        import("url"),
+        import("./utils/worker-pool.js")
+      ]);
+
+      const __filename = url.fileURLToPath(import.meta.url);
+      const __dirname = path.dirname(__filename);
+      const workerPath = path.join(__dirname, "node-worker.js");
+
+      const numWorkers = Math.min(os.cpus().length, 4);
+      this.workerPool = new workerModule.WorkerPool(workerPath, numWorkers);
+      console.log(`🚀 OfflineCompiler: Node.js mode with ${numWorkers} workers`);
+    } catch (e) {
+      console.log("⚡ OfflineCompiler: Running without workers");
     }
+  }
 
-    // Optimizaciones generales para todos los backends
-    tf.ENV.set("WEBGL_CPU_FORWARD", false);
-    tf.ENV.set("DEBUG", false);
-    tf.ENV.set("CHECK_COMPUTATION_FOR_ERRORS", false); // Deshabilitar verificaciones para mayor velocidad
-
-    // Optimizar el uso de memoria con límites más altos
-    if (backend === "node") {
-      console.log("🔧 Aplicando optimizaciones avanzadas para Node.js backend");
-    } else if (backend === "webgl") {
-      // Optimizaciones específicas para WebGL
-      console.log("🔧 Aplicando optimizaciones avanzadas para WebGL backend");
-      tf.ENV.set("WEBGL_FORCE_F16_TEXTURES", true);
-      tf.ENV.set("WEBGL_PACK", true);
-      tf.ENV.set("WEBGL_PACK_DEPTHWISECONV", true);
-      tf.ENV.set("WEBGL_PACK_BINARY_OPERATIONS", true);
-      tf.ENV.set("WEBGL_PACK_ARRAY_OPERATIONS", true);
-      tf.ENV.set("WEBGL_PACK_IMAGE_OPERATIONS", true);
-      tf.ENV.set("WEBGL_PACK_REDUCE", true);
-
-      // Configuraciones de textura según entorno
-      if (isBackendDedicated) {
-        // En backend dedicado, usar valores más agresivos
-        tf.ENV.set("WEBGL_MAX_TEXTURE_SIZE", 8192); // Texturas más grandes
-        tf.ENV.set("WEBGL_MAX_TEXTURES_IN_SHADER", 16); // Más texturas por shader
-      } else if (isServerless) {
-        // En serverless, usamos valores más conservadores
-        tf.ENV.set("WEBGL_MAX_TEXTURE_SIZE", 2048);
-        tf.ENV.set("WEBGL_MAX_TEXTURES_IN_SHADER", 8);
-      } else {
-        // Entorno normal
-        tf.ENV.set("WEBGL_MAX_TEXTURE_SIZE", 4096);
-        tf.ENV.set("WEBGL_MAX_TEXTURES_IN_SHADER", 12);
+  /**
+   * Compila una lista de imágenes objetivo
+   * @param {Array} images - Lista de imágenes {width, height, data}
+   * @param {Function} progressCallback - Callback de progreso (0-100)
+   * @returns {Promise<Array>} Datos compilados
+   */
+  async compileImageTargets(images, progressCallback) {
+    console.time("⏱️ Compilación total");
+
+    const targetImages = [];
+
+    // Preparar imágenes
+    for (let i = 0; i < images.length; i++) {
+      const img = images[i];
+
+      if (!img || !img.width || !img.height || !img.data) {
+        throw new Error(
+          `Imagen inválida en posición ${i}. Debe tener propiedades width, height y data.`
+        );
       }
-    } else if (backend === "cpu") {
-      // Optimizaciones específicas para CPU
-      console.log("🔧 Aplicando optimizaciones para CPU backend");
-
-      // Intentar usar SIMD si está disponible
-      try {
-        if (
-          typeof WebAssembly.validate === "function" &&
-          WebAssembly.validate(
-            new Uint8Array([
-              0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 123, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65,
-              0, 253, 15, 253, 98, 11,
-            ]),
-          )
-        ) {
-          console.log("🚀 SIMD disponible, habilitando aceleración vectorial");
-          tf.ENV.set("WASM_HAS_SIMD_SUPPORT", true);
-          tf.ENV.set("WASM_HAS_MULTITHREAD_SUPPORT", true);
+
+      // Convertir a escala de grises
+      const greyImageData = new Uint8Array(img.width * img.height);
+
+      if (img.data.length === img.width * img.height) {
+        greyImageData.set(img.data);
+      } else if (img.data.length === img.width * img.height * 4) {
+        for (let j = 0; j < greyImageData.length; j++) {
+          const offset = j * 4;
+          greyImageData[j] = Math.floor(
+            (img.data[offset] + img.data[offset + 1] + img.data[offset + 2]) / 3
+          );
         }
-      } catch (e) {
-        console.warn("⚠️ No se pudo detectar soporte SIMD", e);
+      } else {
+        throw new Error(`Formato de datos de imagen no soportado en posición ${i}`);
       }
+
+      targetImages.push({
+        data: greyImageData,
+        height: img.height,
+        width: img.width,
+      });
     }
 
-    // Precalentamiento estratégico del backend para eliminar retrasos en la primera ejecución
-    // Implementamos un precalentamiento adaptativo según el entorno
-    console.time("🔥 Precalentamiento estratégico");
-    console.log("🔥 Precalentando TensorFlow con operaciones específicas...");
-
-    await tf.ready();
-
-    // Detectar si estamos en un entorno de backend dedicado
-
-    // Estrategia de precalentamiento adaptativa según entorno
-    const warmupStrategy = isBackendDedicated
-      ? "aggressive"
-      : isServerless
-        ? "minimal"
-        : "balanced";
-    console.log(`🔥 Aplicando estrategia de precalentamiento: ${warmupStrategy}`);
-
-    // Función para ejecutar y esperar operaciones tensores
-    const executeAndWait = async (tensors) => {
-      // Esperar a que todas las operaciones se completen
-      await Promise.all(tensors.map((t) => t.data()));
-      // Liberar memoria inmediatamente
-      tf.dispose(tensors);
-    };
+    // Fase 1: Matching (50%)
+    console.time("⏱️ Fase Matching");
+    const matchingDataList = await this._compileMatch(targetImages, (percent) => {
+      progressCallback(percent * 0.5);
+    });
+    console.timeEnd("⏱️ Fase Matching");
 
-    // Precalentamiento básico para todos los entornos
-    await tf.tidy(async () => {
-      // Operaciones básicas de álgebra tensorial
-      const a = tf.tensor([1, 2, 3, 4]);
-      const b = tf.tensor([2, 2, 2, 2]);
-      const result = a.add(b);
-      const mult = a.mul(b);
-      const div = a.div(b);
-      await executeAndWait([result, mult, div]);
+    // Fase 2: Tracking (50%)
+    console.time("⏱️ Fase Tracking");
+    const trackingDataList = await this._compileTrack(targetImages, (percent) => {
+      progressCallback(50 + percent * 0.5);
     });
+    console.timeEnd("⏱️ Fase Tracking");
 
-    // Tamaño de imagen adaptativo según entorno
-    const size = isBackendDedicated ? 224 : isServerless ? 64 : 128;
-    console.log(`🖼️ Precalentando con imagen de tamaño ${size}x${size}`);
+    // Compilar resultado
+    this.data = targetImages.map((targetImage, i) => ({
+      targetImage: { width: targetImage.width, height: targetImage.height },
+      trackingData: trackingDataList[i],
+      matchingData: matchingDataList[i],
+    }));
 
-    // Precalentamiento de operaciones de procesamiento de imágenes
-    await tf.tidy(async () => {
-      // Crear imagen sintética para precalentamiento
-      const image = tf.ones([size, size, 3]);
+    console.timeEnd("⏱️ Compilación total");
 
-      // Precalentar operaciones de preprocesamiento comunes
-      const normalized = image.div(tf.scalar(255));
-      const grayscale = image.mean(2, true); // Reducción de canal para escala de grises
-      await executeAndWait([normalized, grayscale]);
+    return this.data;
+  }
 
-      // Precalentar operaciones de convolución con diferentes configuraciones
-      // Estas operaciones son críticas para la extracción de características
-      const kernelSizes = warmupStrategy === "aggressive" ? [3, 5, 7] : [3];
-      const filterCounts = warmupStrategy === "aggressive" ? [8, 16] : [4];
+  /**
+   * Compila datos de matching usando DetectorLite (JS puro)
+   */
+  async _compileMatch(targetImages, progressCallback) {
+    const percentPerImage = 100 / targetImages.length;
+    let currentPercent = 0;
+
+    const results = [];
+
+    // Procesar secuencialmente para evitar overhead de workers
+    // (los workers son útiles para muchas imágenes, pero añaden latencia)
+    for (let i = 0; i < targetImages.length; i++) {
+      const targetImage = targetImages[i];
+      const imageList = buildImageList(targetImage);
+      const percentPerScale = percentPerImage / imageList.length;
+
+      const keyframes = [];
+
+      for (const image of imageList) {
+        const detector = new DetectorLite(image.width, image.height);
+        const { featurePoints: ps } = detector.detect(image.data);
+
+        const maximaPoints = ps.filter((p) => p.maxima);
+        const minimaPoints = ps.filter((p) => !p.maxima);
+        const maximaPointsCluster = hierarchicalClusteringBuild({ points: maximaPoints });
+        const minimaPointsCluster = hierarchicalClusteringBuild({ points: minimaPoints });
+
+        keyframes.push({
+          maximaPoints,
+          minimaPoints,
+          maximaPointsCluster,
+          minimaPointsCluster,
+          width: image.width,
+          height: image.height,
+          scale: image.scale,
+        });
+
+        currentPercent += percentPerScale;
+        progressCallback(currentPercent);
+      }
 
-      for (const kernelSize of kernelSizes) {
-        for (const filters of filterCounts) {
-          // Crear kernel aleatorio para convolución
-          const kernel = tf.randomNormal([kernelSize, kernelSize, 3, filters]);
+      results.push(keyframes);
+    }
 
-          // Aplicar convolución - operación clave en detección de características
-          const convResult = tf.conv2d(image, kernel, 1, "same");
+    return results;
+  }
 
-          // Operaciones de pooling - también críticas en redes de detección
-          const maxPooled = tf.maxPool(convResult, [2, 2], 2, "same");
-          const avgPooled = tf.avgPool(convResult, [2, 2], 2, "same");
+  /**
+   * Compila datos de tracking usando extractTrackingFeatures (JS puro)
+   */
+  async _compileTrack(targetImages, progressCallback) {
+    const percentPerImage = 100 / targetImages.length;
+    let currentPercent = 0;
 
-          // Activaciones comunes
-          const activated = tf.relu(convResult);
+    const results = [];
 
-          await executeAndWait([convResult, maxPooled, avgPooled, activated]);
-        }
-      }
+    for (let i = 0; i < targetImages.length; i++) {
+      const targetImage = targetImages[i];
+      const imageList = buildTrackingImageList(targetImage);
+      const percentPerScale = percentPerImage / imageList.length;
 
-      // En modo agresivo, precalentar operaciones más avanzadas
-      if (warmupStrategy === "aggressive") {
-        // Operaciones de transformación espacial comunes en tracking
-        const resized = tf.image.resizeBilinear(image, [size / 2, size / 2]);
-        const cropped = tf.slice(image, [0, 0, 0], [size / 2, size / 2, 3]);
-        await executeAndWait([resized, cropped]);
-
-        // Operaciones de detección de bordes (aproximación)
-        const sobelX = tf.conv2d(
-          grayscale,
-          tf.tensor4d(
-            [
-              [-1, 0, 1],
-              [-2, 0, 2],
-              [-1, 0, 1],
-            ],
-            [3, 3, 1, 1],
-          ),
-          1,
-          "same",
-        );
-        const sobelY = tf.conv2d(
-          grayscale,
-          tf.tensor4d(
-            [
-              [-1, -2, -1],
-              [0, 0, 0],
-              [1, 2, 1],
-            ],
-            [3, 3, 1, 1],
-          ),
-          1,
-          "same",
-        );
-        const edges = tf.sqrt(tf.add(tf.square(sobelX), tf.square(sobelY)));
-        await executeAndWait([sobelX, sobelY, edges]);
-      }
-    });
+      const trackingData = extractTrackingFeatures(imageList, () => {
+        currentPercent += percentPerScale;
+        progressCallback(currentPercent);
+      });
 
-    // Forzar recolección de basura para limpiar completamente
-    if (global.gc) {
-      try {
-        global.gc();
-        console.log("♻️ Recolección de basura manual ejecutada");
-      } catch (e) {
-        // Ignorar errores si no está disponible
-      }
+      results.push(trackingData);
     }
 
-    // Verificar estado de memoria después del precalentamiento
-    const memInfo = tf.memory();
-    console.log(
-      `📊 Estado de memoria post-precalentamiento: ${memInfo.numTensors} tensores, ${(memInfo.numBytes / (1024 * 1024)).toFixed(2)}MB`,
-    );
-
-    console.timeEnd("🔥 Precalentamiento estratégico");
-  } catch (error) {
-    console.warn("⚠️ No se pudieron aplicar todas las optimizaciones:", error);
+    return results;
   }
-};
 
-// Aplicar optimizaciones de manera asíncrona para no bloquear
-enablePerformanceOptimizations();
+  /**
+   * Método público para compilar tracking (compatibilidad con API anterior)
+   * @param {Object} options - Opciones de compilación
+   * @param {Function} options.progressCallback - Callback de progreso
+   * @param {Array} options.targetImages - Lista de imágenes objetivo
+   * @param {number} options.basePercent - Porcentaje base
+   * @returns {Promise<Array>} Datos de tracking
+   */
+  async compileTrack({ progressCallback, targetImages, basePercent = 0 }) {
+    return this._compileTrack(targetImages, (percent) => {
+      progressCallback(basePercent + percent * (100 - basePercent) / 100);
+    });
+  }
 
-// Versión optimizada del compilador
-export class OfflineCompiler extends CompilerBase {
-  constructor() {
-    super();
+  /**
+   * Método público para compilar matching (compatibilidad con API anterior)
+   */
+  async compileMatch({ progressCallback, targetImages, basePercent = 0 }) {
+    return this._compileMatch(targetImages, (percent) => {
+      progressCallback(basePercent + percent * (50 - basePercent) / 100);
+    });
+  }
 
-    // Detección de entorno
-    this.isServerless = isServerlessEnvironment();
-    if (this.isServerless) {
-      console.log("🚀 Compilador optimizado para entorno serverless");
+  /**
+   * Exporta datos compilados en formato binario columnar optimizado
+   */
+  exportData() {
+    if (!this.data) {
+      throw new Error("No hay datos compilados para exportar");
     }
 
-    // Inicializar inmediatamente para evitar arranque frío
-    this._ensureTensorflowReady();
+    const dataList = this.data.map((item) => {
+      // Optimizamos MatchingData convirtiéndolo a formato columnar
+      const matchingData = item.matchingData.map((kf) => this._packKeyframe(kf));
+
+      // Optimizamos TrackingData (Zero-copy layout)
+      const trackingData = item.trackingData.map((td) => {
+        const count = td.points.length;
+        const px = new Float32Array(count);
+        const py = new Float32Array(count);
+        for (let i = 0; i < count; i++) {
+          px[i] = td.points[i].x;
+          py[i] = td.points[i].y;
+        }
+        return {
+          w: td.width,
+          h: td.height,
+          s: td.scale,
+          px,
+          py,
+          d: td.data, // Grayscale pixel data (Uint8Array)
+        };
+      });
+
+      return {
+        targetImage: {
+          width: item.targetImage.width,
+          height: item.targetImage.height,
+        },
+        trackingData,
+        matchingData,
+      };
+    });
+
+    return msgpack.encode({
+      v: CURRENT_VERSION,
+      dataList,
+    });
   }
 
-  // Método privado para asegurar que TensorFlow esté listo
-  async _ensureTensorflowReady() {
-    if (!tensorflowBackend) {
-      await tensorflowSetupPromise;
-    }
-    return tensorflowBackend;
+  _packKeyframe(kf) {
+    return {
+      w: kf.width,
+      h: kf.height,
+      s: kf.scale,
+      max: this._columnarize(kf.maximaPoints, kf.maximaPointsCluster),
+      min: this._columnarize(kf.minimaPoints, kf.minimaPointsCluster),
+    };
   }
 
-  // Versión optimizada del método principal de compilación
-  compileTrack({ progressCallback, targetImages, basePercent }) {
-    return new Promise(async (resolve, reject) => {
-      // Prevenir errores de timeout en entornos serverless
-      let compilationTimeout;
-
-      // En serverless, establecer un límite estricto de tiempo para evitar timeouts
-      if (this.isServerless) {
-        const timeoutSeconds = 25; // Tiempo límite para compilación en serverless
-        compilationTimeout = setTimeout(() => {
-          reject(
-            new Error(
-              `Tiempo límite de compilación excedido (${timeoutSeconds}s). La imagen puede ser demasiado compleja para procesamiento serverless.`,
-            ),
-          );
-        }, timeoutSeconds * 1000);
-      }
+  _columnarize(points, tree) {
+    const count = points.length;
+    const x = new Float32Array(count);
+    const y = new Float32Array(count);
+    const angle = new Float32Array(count);
+    const descriptors = new Uint8Array(count * 84); // 84 bytes per point (FREAK)
+
+    for (let i = 0; i < count; i++) {
+      x[i] = points[i].x;
+      y[i] = points[i].y;
+      angle[i] = points[i].angle;
+      descriptors.set(points[i].descriptors, i * 84);
+    }
 
-      try {
-        // Asegurar que TensorFlow esté configurado
-        await this._ensureTensorflowReady();
-
-        console.time("⏱️ Tiempo de compilación de tracking");
-
-        const backend = tf.getBackend();
-        const percentPerImage = (100 - basePercent) / targetImages.length;
-        let percent = 0;
-        const list = [];
-
-        console.log(`🧮 Compilando con backend: ${backend}`);
-
-        // Optimizar el tamaño de lote según el backend disponible
-        // En serverless, siempre usar lotes más pequeños
-        // Estrategia adaptativa para tamaño de lote (CPU/GPU)
-        let batchSize = 1;
-        if (backend === "node") {
-          // Calcular tamaño óptimo basado en recursos
-          try {
-            const cpus = os.cpus().length;
-            const freeMem = os.freemem() / 1024 / 1024 / 1024; // GB libres
-
-            // Lógica de batch dinámico:
-            // - 1 núcleo: batch 1 (evitar sobrecarga)
-            // - 2-4 núcleos: batch 2-4 (balance carga/paralelismo)
-            // - >4 núcleos: batch escalable con memoria
-            batchSize =
-              cpus > 4
-                ? Math.min(Math.floor(freeMem * 0.5), 8) // 0.5GB por batch
-                : Math.min(cpus, 4);
-
-            console.log(
-              `🧠 Batch size calculado: ${batchSize} (${cpus} cores, ${freeMem.toFixed(1)}GB libres)`,
-            );
-          } catch (e) {
-            console.warn("⚠️ Error cálculo batch size:", e);
-            batchSize = 2; // Fallback: equilibrio seguridad/performance
-          }
-        } else if (this.isServerless) {
-          batchSize = 1; // Priorizar seguridad sobre performance
-        }
+    return {
+      x,
+      y,
+      a: angle,
+      d: descriptors,
+      t: this._compactTree(tree.rootNode),
+    };
+  }
 
-        // Garantizar límites operativos seguros:
-        // - Mínimo: Evitar underflow en procesamiento
-        // - Máximo: Prevenir OOM (Out Of Memory)
-        batchSize = Math.max(1, Math.min(batchSize, 8));
+  _compactTree(node) {
+    if (node.leaf) {
+      return [1, node.centerPointIndex || 0, node.pointIndexes];
+    }
+    return [0, node.centerPointIndex || 0, node.children.map((c) => this._compactTree(c))];
+  }
 
-        console.log(`📊 Procesando imágenes en lotes de ${batchSize}`);
+  /**
+   * Importa datos - Mantiene el formato columnar para máximo rendimiento (Zero-copy)
+   */
+  importData(buffer) {
+    const content = msgpack.decode(new Uint8Array(buffer));
 
-        // Solicitar memoria mínima antes de empezar procesamiento intensivo
-        if (global.gc) {
-          try {
-            global.gc();
-          } catch (e) {
-            // Ignorar errores
-          }
-        }
+    if (!content.v || content.v !== CURRENT_VERSION) {
+      console.error("Incompatible .mind version. Required: " + CURRENT_VERSION);
+      return [];
+    }
 
-        // Paralelismo para el procesamiento en lotes
-        for (let i = 0; i < targetImages.length; i += batchSize) {
-          // Procesar un lote de imágenes
-          const batch = targetImages.slice(i, Math.min(i + batchSize, targetImages.length));
-
-          // Imprimir información sobre el procesamiento por lotes
-          if (batch.length > 1) {
-            console.log(
-              `🔄 Procesando lote ${Math.floor(i / batchSize) + 1}: ${batch.length} imágenes`,
-            );
-          }
-
-          // Usar tf.engine().startScope() para mejor control de memoria por lote
-          tf.engine().startScope();
-
-          try {
-            // Procesamiento paralelo de imágenes en el lote
-            const batchResults = await Promise.all(
-              batch.map(async (targetImage) => {
-                const imageList = buildTrackingImageList(targetImage);
-                const percentPerAction = percentPerImage / imageList.length;
-
-                // Usar tf.tidy para liberar memoria automáticamente en cada imagen
-                return await tf.tidy(() => {
-                  // Extraer características con monitoreo de progreso
-                  const trackingData = extractTrackingFeatures(imageList, (index) => {
-                    percent += percentPerAction;
-                    progressCallback(basePercent + percent);
-                  });
-
-                  return trackingData;
-                });
-              }),
-            );
-
-            // Agregar resultados a la lista final
-            list.push(...batchResults);
-          } finally {
-            // Asegurar que siempre se cierre el scope para evitar fugas de memoria
-            tf.engine().endScope();
-          }
-
-          // Liberar memoria entre lotes grandes o al final
-          // En serverless, liberar más agresivamente
-          if (i % (this.isServerless ? 2 : 5) === 0 || i === targetImages.length - 1) {
-            await tf.nextFrame(); // Permitir que el recolector de basura libere memoria
-
-            // Cálculo de presión de memoria adaptativa
-            const memoryInfo = tf.memory();
-            const totalMem = os.totalmem();
-            const freeMem = os.freemem();
-            const memPressure = 1 - freeMem / totalMem;
-
-            // Umbrales dinámicos basados en:
-            // 1. Tipo de backend (mayor tolerancia en GPU)
-            // 2. Presión de memoria actual
-            // 3. Entorno de ejecución (serverless vs dedicado)
-            const baseThreshold = backend === "webgl" ? 50 : 30;
-            const adaptiveThreshold = Math.floor(
-              baseThreshold *
-                (1 - Math.min(memPressure, 0.5)) *
-                (this.isServerless ? 0.6 : 1) *
-                (this.isBackendDedicated ? 1.2 : 1),
-            );
-
-            console.log(
-              `🧠 Memoria: ${(freeMem / 1024 / 1024).toFixed(1)}MB libres | ` +
-                `Presión: ${(memPressure * 100).toFixed(1)}% | ` +
-                `Umbral: ${adaptiveThreshold} tensores`,
-            );
-
-            if (memoryInfo.numTensors > adaptiveThreshold) {
-              // Estrategia de limpieza diferenciada
-              console.log(
-                `🧹 Limpieza ${this.isServerless ? "conservadora" : "agresiva"}: ` +
-                  `${memoryInfo.numTensors} tensores, ${(memoryInfo.numBytes / 1024 / 1024).toFixed(2)}MB`,
-              );
-
-              // Estrategia de limpieza diferenciada:
-              // - Serverless: Liberación temprana preventiva
-              // - Dedicado: Postergar GC para mejor throughput
-              tf.disposeVariables();
-              tf.dispose();
-
-              // Forzar recolección de basura en Node.js si está disponible
-              if (global.gc) {
-                try {
-                  global.gc();
-                } catch (e) {
-                  // Ignorar errores si no está disponible
-                }
-              }
-            }
-          }
-        }
+    // Ya no de-columnarizamos aquí. Los motores (Tracker/Matcher)
+    // ahora están optimizados para leer directamente de los buffers.
+    this.data = content.dataList;
 
-        // Terminar medición de tiempo
-        console.timeEnd("⏱️ Tiempo de compilación de tracking");
+    return this.data;
+  }
 
-        // Liberar toda la memoria restante antes de finalizar
-        tf.dispose();
+  _unpackKeyframe(kf) {
+    return {
+      width: kf.w,
+      height: kf.h,
+      scale: kf.s,
+      maximaPoints: this._decolumnarize(kf.max),
+      minimaPoints: this._decolumnarize(kf.min),
+      maximaPointsCluster: { rootNode: this._expandTree(kf.max.t) },
+      minimaPointsCluster: { rootNode: this._expandTree(kf.min.t) },
+    };
+  }
 
-        // Limpiar timeout si existía
-        if (compilationTimeout) {
-          clearTimeout(compilationTimeout);
-        }
+  _decolumnarize(col) {
+    const points = [];
+    const count = col.x.length;
+    for (let i = 0; i < count; i++) {
+      points.push({
+        x: col.x[i],
+        y: col.y[i],
+        angle: col.a[i],
+        descriptors: col.d.slice(i * 84, (i + 1) * 84),
+      });
+    }
+    return points;
+  }
 
-        resolve(list);
-      } catch (error) {
-        // Limpiar timeout si existía
-        if (compilationTimeout) {
-          clearTimeout(compilationTimeout);
-        }
+  _expandTree(node) {
+    const isLeaf = node[0] === 1;
+    if (isLeaf) {
+      return {
+        leaf: true,
+        centerPointIndex: node[1],
+        pointIndexes: node[2],
+      };
+    }
+    return {
+      leaf: false,
+      centerPointIndex: node[1],
+      children: node[2].map((c) => this._expandTree(c)),
+    };
+  }
 
-        console.error("❌ Error en compilación:", error);
-        reject(error);
-      }
-    });
+  /**
+   * Destruye el pool de workers
+   */
+  async destroy() {
+    if (this.workerPool) {
+      await this.workerPool.destroy();
+    }
   }
 }