@srsergio/taptapp-ar 1.0.43 → 1.0.50

package/dist/compiler/matching/hamming-distance.d.ts

@@ -1 +1,9 @@
+/**
+ * Generic compute for backward compatibility
+ */
 export function compute(options: any): number;
+/**
+ * Super-optimized Hamming distance for 64-bit LSH (2x Uint32)
+ * NO OBJECTS, NO OPTIONS, JUST PURE SPEED.
+ */
+export function compute64(v1: any, v1Idx: any, v2: any, v2Idx: any): number;

package/dist/compiler/matching/hamming-distance.js

@@ -9,39 +9,58 @@ for (let i = 0; i < 256; i++) {
     BIT_COUNT_8[i] = c;
 }
 /**
- * Optimized popcount for 32-bit integers
+ * 🚀 Moonshot Optimized Popcount
+ * Uses a slightly faster bitwise sequence for 32-bit integers
  */
 function popcount32(n) {
-    n = n - ((n >> 1) & 0x55555555);
-    n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
-    return (((n + (n >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
+    n = n >>> 0; // Force unsigned
+    n -= (n >>> 1) & 0x55555555;
+    n = (n & 0x33333333) + ((n >>> 2) & 0x33333333);
+    return (((n + (n >>> 4)) & 0x0F0F0F0F) * 0x01010101) >>> 24;
 }
+/**
+ * Super-optimized Hamming distance for 64-bit LSH (2x Uint32)
+ * NO OBJECTS, NO OPTIONS, JUST PURE SPEED.
+ */
+const compute64 = (v1, v1Idx, v2, v2Idx) => {
+    // Inline XOR and popcount for maximum speed
+    let x1 = (v1[v1Idx] ^ v2[v2Idx]) >>> 0;
+    let x2 = (v1[v1Idx + 1] ^ v2[v2Idx + 1]) >>> 0;
+    // Popcount 1
+    x1 -= (x1 >>> 1) & 0x55555555;
+    x1 = (x1 & 0x33333333) + ((x1 >>> 2) & 0x33333333);
+    const count1 = (((x1 + (x1 >>> 4)) & 0x0F0F0F0F) * 0x01010101) >>> 24;
+    // Popcount 2
+    x2 -= (x2 >>> 1) & 0x55555555;
+    x2 = (x2 & 0x33333333) + ((x2 >>> 2) & 0x33333333);
+    const count2 = (((x2 + (x2 >>> 4)) & 0x0F0F0F0F) * 0x01010101) >>> 24;
+    return count1 + count2;
+};
+/**
+ * Generic compute for backward compatibility
+ */
 const compute = (options) => {
     const { v1, v2, v1Offset = 0, v2Offset = 0 } = options;
-    // Protocol V5 Path: 64-bit LSH (two Uint32)
-    if (v1.length === v2.length && (v1.length / (v1.buffer.byteLength / v1.length)) === 2) {
-        // This is a bit hacky check, better if we know the version. 
-        // Assuming if it's not 84 bytes, it's the new 8-byte format.
+    const v2Len = v2.length - v2Offset;
+    if (v2Len === 2) {
+        return compute64(v1, v1Offset, v2, v2Offset);
     }
-    // If descriptors are 84 bytes (Protocol V4)
-    if (v1.length >= v1Offset + 84 && v2.length >= v2Offset + 84 && v1[v1Offset + 83] !== undefined) {
+    // Protocol V4: 84-byte descriptors (Uint8Array)
+    if (v2Len === 84) {
         let d = 0;
         for (let i = 0; i < 84; i++) {
             d += BIT_COUNT_8[v1[v1Offset + i] ^ v2[v2Offset + i]];
         }
         return d;
     }
-    // Protocol V5.1 Path: LSH 128-bit (4 x 32-bit)
-    // We expect v1 and v2 to be slices or offsets of Uint32Array
-    if (v1.length >= v1Offset + 4 && v2.length >= v2Offset + 4 && v1[v1Offset + 3] !== undefined) {
+    // Protocol V5.1: 128-bit LSH (4 x Uint32)
+    if (v2Len === 4) {
         return popcount32(v1[v1Offset] ^ v2[v2Offset]) +
             popcount32(v1[v1Offset + 1] ^ v2[v2Offset + 1]) +
             popcount32(v1[v1Offset + 2] ^ v2[v2Offset + 2]) +
             popcount32(v1[v1Offset + 3] ^ v2[v2Offset + 3]);
     }
-    // Protocol V5 Path: LSH 64-bit (2 x 32-bit)
-    // We expect v1 and v2 to be slices or offsets of Uint32Array
     return popcount32(v1[v1Offset] ^ v2[v2Offset]) +
         popcount32(v1[v1Offset + 1] ^ v2[v2Offset + 1]);
 };
-export { compute };
+export { compute, compute64 };

package/dist/compiler/matching/hierarchical-clustering.d.ts

@@ -1,6 +1,15 @@
+/**
+ * Build hierarchical clusters
+ */
 export function build({ points }: {
     points: any;
 }): {
+    rootNode: {
+        leaf: boolean;
+        pointIndexes: never[];
+        centerPointIndex: null;
+    };
+} | {
     rootNode: {
         centerPointIndex: any;
     };

package/dist/compiler/matching/hierarchical-clustering.js

@@ -1,109 +1,129 @@
-import { compute as hammingCompute } from "./hamming-distance.js";
+import { compute64 as hammingCompute64 } from "./hamming-distance.js";
 import { createRandomizer } from "../utils/randomizer.js";
-const MIN_FEATURE_PER_NODE = 16;
-const NUM_ASSIGNMENT_HYPOTHESES = 64;
+const MIN_FEATURE_PER_NODE = 32; // Increased from 16 for speed
+const NUM_ASSIGNMENT_HYPOTHESES = 12; // Reduced from 16 for speed
 const NUM_CENTERS = 8;
+/**
+ * 🚀 Moonshot Optimized K-Medoids
+ *
+ * Major Optimizations:
+ * 1. Flattened Memory: Operates on a single Uint32Array block instead of objects.
+ * 2. Zero Property Access: Avoids .descriptors lookup in the tightest loop.
+ * 3. Cache-Friendly: Accesses contiguous descriptor data.
+ */
 const _computeKMedoids = (options) => {
-    const { points, pointIndexes, randomizer } = options;
-    const randomPointIndexes = [];
-    for (let i = 0; i < pointIndexes.length; i++) {
-        randomPointIndexes.push(i);
+    const { descriptors, pointIndexes, randomizer } = options;
+    const numPointIndexes = pointIndexes.length;
+    const randomPointIndexes = new Int32Array(numPointIndexes);
+    for (let i = 0; i < numPointIndexes; i++) {
+        randomPointIndexes[i] = i;
     }
     let bestSumD = Number.MAX_SAFE_INTEGER;
-    let bestAssignmentIndex = -1;
-    const assignments = [];
+    let bestAssignment = null;
+    // Pre-fetch centers indices to avoid nested index lookups
+    const centerPointIndices = new Int32Array(NUM_CENTERS);
     for (let i = 0; i < NUM_ASSIGNMENT_HYPOTHESES; i++) {
         randomizer.arrayShuffle({ arr: randomPointIndexes, sampleSize: NUM_CENTERS });
+        // Set centers for this hypothesis
+        for (let k = 0; k < NUM_CENTERS; k++) {
+            centerPointIndices[k] = pointIndexes[randomPointIndexes[k]];
+        }
         let sumD = 0;
-        const assignment = [];
-        for (let j = 0; j < pointIndexes.length; j++) {
-            let bestD = Number.MAX_SAFE_INTEGER;
+        const currentAssignment = new Int32Array(numPointIndexes);
+        for (let j = 0; j < numPointIndexes; j++) {
+            const pIdx = pointIndexes[j];
+            const pOffset = pIdx * 2;
+            let bestD = 255; // Max possible Hamming for 64-bit is 64, but let's be safe
+            let bestCenterIdx = -1;
             for (let k = 0; k < NUM_CENTERS; k++) {
-                const centerIndex = pointIndexes[randomPointIndexes[k]];
-                const d = hammingCompute({
-                    v1: points[pointIndexes[j]].descriptors,
-                    v2: points[centerIndex].descriptors,
-                });
+                const cIdx = centerPointIndices[k];
+                const cOffset = cIdx * 2;
+                // DIRECT CALL TO INLINED HAMMING
+                const d = hammingCompute64(descriptors, pOffset, descriptors, cOffset);
                 if (d < bestD) {
-                    assignment[j] = randomPointIndexes[k];
+                    bestCenterIdx = randomPointIndexes[k];
                     bestD = d;
                 }
             }
+            currentAssignment[j] = bestCenterIdx;
             sumD += bestD;
         }
-        assignments.push(assignment);
         if (sumD < bestSumD) {
             bestSumD = sumD;
-            bestAssignmentIndex = i;
+            bestAssignment = currentAssignment;
         }
     }
-    return assignments[bestAssignmentIndex];
+    return bestAssignment;
 };
-// kmedoids clustering of points, with hamming distance of FREAK descriptor
-//
-// node = {
-//   isLeaf: bool,
-//   children: [], list of children node
-//   pointIndexes: [], list of int, point indexes
-//   centerPointIndex: int
-// }
+/**
+ * Build hierarchical clusters
+ */
 const build = ({ points }) => {
-    const pointIndexes = [];
-    for (let i = 0; i < points.length; i++) {
-        pointIndexes.push(i);
+    const numPoints = points.length;
+    if (numPoints === 0)
+        return { rootNode: { leaf: true, pointIndexes: [], centerPointIndex: null } };
+    // 🚀 MOONSHOT: Flatten all descriptors into a single Uint32Array
+    // This is the key to sub-second performance.
+    const descriptors = new Uint32Array(numPoints * 2);
+    for (let i = 0; i < numPoints; i++) {
+        const d = points[i].descriptors;
+        descriptors[i * 2] = d[0];
+        descriptors[i * 2 + 1] = d[1];
+    }
+    const pointIndexes = new Int32Array(numPoints);
+    for (let i = 0; i < numPoints; i++) {
+        pointIndexes[i] = i;
     }
     const randomizer = createRandomizer();
     const rootNode = _build({
-        points: points,
-        pointIndexes: pointIndexes,
+        descriptors,
+        pointIndexes,
         centerPointIndex: null,
         randomizer,
     });
     return { rootNode };
 };
-// recursive build hierarchy clusters
 const _build = (options) => {
-    const { points, pointIndexes, centerPointIndex, randomizer } = options;
+    const { descriptors, pointIndexes, centerPointIndex, randomizer } = options;
+    const numPoints = pointIndexes.length;
     let isLeaf = false;
-    if (pointIndexes.length <= NUM_CENTERS || pointIndexes.length <= MIN_FEATURE_PER_NODE) {
+    if (numPoints <= NUM_CENTERS || numPoints <= MIN_FEATURE_PER_NODE) {
         isLeaf = true;
     }
-    const clusters = {};
+    const clusters = new Map();
     if (!isLeaf) {
-        // compute clusters
-        const assignment = _computeKMedoids({ points, pointIndexes, randomizer });
+        const assignment = _computeKMedoids({ descriptors, pointIndexes, randomizer });
         for (let i = 0; i < assignment.length; i++) {
-            if (clusters[pointIndexes[assignment[i]]] === undefined) {
-                clusters[pointIndexes[assignment[i]]] = [];
+            const centerIdx = pointIndexes[assignment[i]];
+            let cluster = clusters.get(centerIdx);
+            if (cluster === undefined) {
+                cluster = [];
+                clusters.set(centerIdx, cluster);
             }
-            clusters[pointIndexes[assignment[i]]].push(pointIndexes[i]);
+            cluster.push(pointIndexes[i]);
+        }
+        if (clusters.size === 1) {
+            isLeaf = true;
         }
-    }
-    if (Object.keys(clusters).length === 1) {
-        isLeaf = true;
     }
     const node = {
         centerPointIndex: centerPointIndex,
     };
     if (isLeaf) {
         node.leaf = true;
-        node.pointIndexes = [];
-        for (let i = 0; i < pointIndexes.length; i++) {
-            node.pointIndexes.push(pointIndexes[i]);
-        }
+        node.pointIndexes = new Int32Array(pointIndexes);
         return node;
     }
-    // recursive build children
     node.leaf = false;
     node.children = [];
-    Object.keys(clusters).forEach((centerIndex) => {
+    for (const [cIdx, clusterPoints] of clusters) {
         node.children.push(_build({
-            points: points,
-            pointIndexes: clusters[centerIndex],
-            centerPointIndex: centerIndex,
+            descriptors,
+            pointIndexes: new Int32Array(clusterPoints),
+            centerPointIndex: cIdx,
             randomizer,
         }));
-    });
+    }
     return node;
 };
 export { build };

package/dist/compiler/matching/matching.js

@@ -3,11 +3,11 @@ import { compute as hammingCompute } from "./hamming-distance.js";
 import { computeHoughMatches } from "./hough.js";
 import { computeHomography } from "./ransacHomography.js";
 import { multiplyPointHomographyInhomogenous, matrixInverse33 } from "../utils/geometry.js";
-const INLIER_THRESHOLD = 3;
+const INLIER_THRESHOLD = 10; // Relaxed from 3 to 10 for better robustness with LSH
 //const MIN_NUM_INLIERS = 8;  //default
 const MIN_NUM_INLIERS = 6;
-const CLUSTER_MAX_POP = 8;
-const HAMMING_THRESHOLD = 0.7;
+const CLUSTER_MAX_POP = 20; // Increased to explore more candidate clusters
+const HAMMING_THRESHOLD = 0.85; // Relaxed ratio test for binary descriptors
 // match list of querpoints against pre-built list of keyframes
 const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) => {
     let debugExtra = {};

package/dist/compiler/node-worker.js

@@ -6,12 +6,35 @@
  */
 import { parentPort } from 'node:worker_threads';
 import { extractTrackingFeatures } from './tracker/extract-utils.js';
-import { buildTrackingImageList, buildImageList } from './image-list.js';
+import { buildTrackingImageList } from './image-list.js';
 import { DetectorLite } from './detector/detector-lite.js';
 import { build as hierarchicalClusteringBuild } from './matching/hierarchical-clustering.js';
 if (!parentPort) {
     throw new Error('This file must be run as a worker thread.');
 }
+// Helper for Morton Order sorting inside worker
+function getMorton(x, y) {
+    let x_int = x | 0;
+    let y_int = y | 0;
+    x_int = (x_int | (x_int << 8)) & 0x00FF00FF;
+    x_int = (x_int | (x_int << 4)) & 0x0F0F0F0F;
+    x_int = (x_int | (x_int << 2)) & 0x33333333;
+    x_int = (x_int | (x_int << 1)) & 0x55555555;
+    y_int = (y_int | (y_int << 8)) & 0x00FF00FF;
+    y_int = (y_int | (y_int << 4)) & 0x0F0F0F0F;
+    y_int = (y_int | (y_int << 2)) & 0x33333333;
+    y_int = (y_int | (y_int << 1)) & 0x55555555;
+    return x_int | (y_int << 1);
+}
+const mortonCache = new Int32Array(2048); // Cache for sorting stability
+function sortPoints(points) {
+    if (points.length <= 1)
+        return points;
+    // Sort in-place to avoid allocations
+    return points.sort((a, b) => {
+        return getMorton(a.x, a.y) - getMorton(b.x, b.y);
+    });
+}
 parentPort.on('message', async (msg) => {
     if (msg.type === 'compile') {
         const { targetImage, percentPerImage, basePercent } = msg;
@@ -34,24 +57,50 @@ parentPort.on('message', async (msg) => {
         catch (error) {
             parentPort.postMessage({
                 type: 'error',
-                error: error.message
+                error: error.message + '\n' + error.stack
             });
         }
     }
     else if (msg.type === 'match') {
         const { targetImage, percentPerImage, basePercent } = msg;
         try {
-            const imageList = buildImageList(targetImage);
-            const percentPerAction = percentPerImage / imageList.length;
-            let localPercent = 0;
+            // 🚀 MOONSHOT: Only run detector ONCE on full-res image.
+            // DetectorLite internally builds a pyramid (octaves 1.0, 0.5, 0.25, etc.)
+            const detector = new DetectorLite(targetImage.width, targetImage.height, {
+                useLSH: true
+            });
+            parentPort.postMessage({ type: 'progress', percent: basePercent + percentPerImage * 0.1 });
+            const { featurePoints: allPoints } = detector.detect(targetImage.data);
+            parentPort.postMessage({ type: 'progress', percent: basePercent + percentPerImage * 0.5 });
+            // Group points by their scale (octave)
+            const scalesMap = new Map();
+            for (const p of allPoints) {
+                const octaveScale = p.scale;
+                let list = scalesMap.get(octaveScale);
+                if (!list) {
+                    list = [];
+                    scalesMap.set(octaveScale, list);
+                }
+                // Coordinates in p are already full-res. 
+                // We need them relative to the scaled image for the keyframe.
+                list.push({
+                    ...p,
+                    x: p.x / octaveScale,
+                    y: p.y / octaveScale,
+                    scale: 1.0 // Keypoint scale is always 1.0 relative to its own keyframe image
+                });
+            }
+            // Optional: Run another detector pass at an intermediate scale to improve coverage
+            // (e.g. at 1/1.41 ratio) if tracking robustness suffers. 
+            // For now, let's stick to octaves for MAXIMUM speed.
             const keyframes = [];
-            for (let i = 0; i < imageList.length; i++) {
-                const image = imageList[i];
-                const detector = new DetectorLite(image.width, image.height, { useLSH: true });
-                // Detectar features usando JS puro (sin TensorFlow)
-                const { featurePoints: ps } = detector.detect(image.data);
-                const maximaPoints = ps.filter((p) => p.maxima);
-                const minimaPoints = ps.filter((p) => !p.maxima);
+            const sortedScales = Array.from(scalesMap.keys()).sort((a, b) => a - b);
+            const percentPerScale = (percentPerImage * 0.4) / sortedScales.length;
+            for (const s of sortedScales) {
+                const ps = scalesMap.get(s);
+                const sortedPs = sortPoints(ps);
+                const maximaPoints = sortedPs.filter((p) => p.maxima);
+                const minimaPoints = sortedPs.filter((p) => !p.maxima);
                 const maximaPointsCluster = hierarchicalClusteringBuild({ points: maximaPoints });
                 const minimaPointsCluster = hierarchicalClusteringBuild({ points: minimaPoints });
                 keyframes.push({
@@ -59,14 +108,13 @@ parentPort.on('message', async (msg) => {
                     minimaPoints,
                     maximaPointsCluster,
                     minimaPointsCluster,
-                    width: image.width,
-                    height: image.height,
-                    scale: image.scale,
+                    width: Math.round(targetImage.width / s),
+                    height: Math.round(targetImage.height / s),
+                    scale: 1.0 / s, // keyframe.scale is relative to full target image
                 });
-                localPercent += percentPerAction;
                 parentPort.postMessage({
                     type: 'progress',
-                    percent: basePercent + localPercent
+                    percent: basePercent + percentPerImage * 0.6 + keyframes.length * percentPerScale
                 });
             }
             parentPort.postMessage({
@@ -77,7 +125,85 @@ parentPort.on('message', async (msg) => {
         catch (error) {
             parentPort.postMessage({
                 type: 'error',
-                error: error.message
+                error: error.message + '\n' + error.stack
+            });
+        }
+    }
+    else if (msg.type === 'compile-all') {
+        const { targetImage } = msg;
+        try {
+            // 1. Single Pass Detection + Pyramid Generation
+            const detector = new DetectorLite(targetImage.width, targetImage.height, { useLSH: true });
+            parentPort.postMessage({ type: 'progress', percent: 10 });
+            const { featurePoints, pyramid } = detector.detect(targetImage.data);
+            parentPort.postMessage({ type: 'progress', percent: 40 });
+            // 2. Extract Tracking Data using the ALREADY BLURRED pyramid
+            // We need 2 levels closest to 256 and 128
+            const trackingImageList = [];
+            // Octave 0 is Original blured. Octave 1 is 0.5x. Octave 2 is 0.25x.
+            // We'll pick the best ones.
+            const targetSizes = [256, 128];
+            for (const targetSize of targetSizes) {
+                let bestLevel = 0;
+                let minDiff = Math.abs(Math.min(targetImage.width, targetImage.height) - targetSize);
+                for (let l = 1; l < pyramid.length; l++) {
+                    const img = pyramid[l][0];
+                    const diff = Math.abs(Math.min(img.width, img.height) - targetSize);
+                    if (diff < minDiff) {
+                        minDiff = diff;
+                        bestLevel = l;
+                    }
+                }
+                const levelImg = pyramid[bestLevel][0];
+                trackingImageList.push({
+                    data: levelImg.data,
+                    width: levelImg.width,
+                    height: levelImg.height,
+                    scale: levelImg.width / targetImage.width
+                });
+            }
+            const trackingData = extractTrackingFeatures(trackingImageList, () => { });
+            parentPort.postMessage({ type: 'progress', percent: 60 });
+            // 3. Build Keyframes for Matching
+            const scalesMap = new Map();
+            for (const p of featurePoints) {
+                const s = p.scale;
+                let list = scalesMap.get(s);
+                if (!list) {
+                    list = [];
+                    scalesMap.set(s, list);
+                }
+                list.push({ ...p, x: p.x / s, y: p.y / s, scale: 1.0 });
+            }
+            const keyframes = [];
+            const sortedScales = Array.from(scalesMap.keys()).sort((a, b) => a - b);
+            for (const s of sortedScales) {
+                const ps = scalesMap.get(s);
+                const sortedPs = sortPoints(ps);
+                const maximaPoints = sortedPs.filter((p) => p.maxima);
+                const minimaPoints = sortedPs.filter((p) => !p.maxima);
+                const maximaPointsCluster = hierarchicalClusteringBuild({ points: maximaPoints });
+                const minimaPointsCluster = hierarchicalClusteringBuild({ points: minimaPoints });
+                keyframes.push({
+                    maximaPoints,
+                    minimaPoints,
+                    maximaPointsCluster,
+                    minimaPointsCluster,
+                    width: Math.round(targetImage.width / s),
+                    height: Math.round(targetImage.height / s),
+                    scale: 1.0 / s,
+                });
+            }
+            parentPort.postMessage({
+                type: 'compileDone', // Reusing message type for compatibility with WorkerPool
+                matchingData: keyframes,
+                trackingData: trackingData
+            });
+        }
+        catch (error) {
+            parentPort.postMessage({
+                type: 'error',
+                error: error.message + '\n' + error.stack
             });
         }
     }

package/dist/compiler/offline-compiler.d.ts

@@ -1,62 +1,42 @@
 /**
- * Compilador offline optimizado sin TensorFlow
+ * @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.
  */
-export class OfflineCompiler {
+import { WorkerPool } from "./utils/worker-pool.js";
+export declare class OfflineCompiler {
     data: any;
     workerPool: WorkerPool | null;
+    constructor();
     _initNodeWorkers(): Promise<void>;
-    /**
-     * 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
-     */
-    compileImageTargets(images: any[], progressCallback: Function): Promise<any[]>;
-    _compileMatch(targetImages: any, progressCallback: any): Promise<any[]>;
-    _compileTrack(targetImages: any, progressCallback: any): Promise<any[]>;
+    compileImageTargets(images: any[], progressCallback: (p: number) => void): Promise<any>;
+    _compileTarget(targetImages: any[], progressCallback: (p: number) => void): Promise<any[]>;
+    _compileMatch(targetImages: any[], progressCallback: (p: number) => void): Promise<any[]>;
+    _compileTrack(targetImages: any[], progressCallback: (p: number) => void): Promise<any[]>;
     compileTrack({ progressCallback, targetImages, basePercent }: {
-        progressCallback: any;
-        targetImages: any;
-        basePercent?: number | undefined;
+        progressCallback: (p: number) => void;
+        targetImages: any[];
+        basePercent?: number;
     }): Promise<any[]>;
     compileMatch({ progressCallback, targetImages, basePercent }: {
-        progressCallback: any;
-        targetImages: any;
-        basePercent?: number | undefined;
+        progressCallback: (p: number) => void;
+        targetImages: any[];
+        basePercent?: number;
     }): Promise<any[]>;
-    exportData(): any;
-    _getMorton(x: any, y: any): number;
-    _packKeyframe(kf: any): {
-        w: any;
-        h: any;
-        s: any;
-        max: {
-            x: Uint16Array<any>;
-            y: Uint16Array<any>;
-            a: Int16Array<any>;
-            s: Uint8Array<any>;
-            d: Uint32Array<ArrayBuffer>;
-            t: any[];
-        };
-        min: {
-            x: Uint16Array<any>;
-            y: Uint16Array<any>;
-            a: Int16Array<any>;
-            s: Uint8Array<any>;
-            d: Uint32Array<ArrayBuffer>;
-            t: any[];
-        };
-    };
-    _columnarize(points: any, tree: any, width: any, height: any): {
-        x: Uint16Array<any>;
-        y: Uint16Array<any>;
-        a: Int16Array<any>;
-        s: Uint8Array<any>;
+    exportData(): Uint8Array<ArrayBuffer>;
+    _getMorton(x: number, y: number): number;
+    _columnarize(points: any[], tree: any, width: number, height: number): {
+        x: Uint16Array<ArrayBuffer>;
+        y: Uint16Array<ArrayBuffer>;
+        a: Int16Array<ArrayBuffer>;
+        s: Uint8Array<ArrayBuffer>;
         d: Uint32Array<ArrayBuffer>;
-        t: any[];
+        t: any;
     };
-    _compactTree(node: any): any[];
-    importData(buffer: any): never[] | {
+    _compactTree(node: any): any;
+    importData(buffer: ArrayBuffer | Uint8Array): {
         version: any;
         dataList: any;
     };
@@ -79,50 +59,21 @@ export class OfflineCompiler {
             descriptors: any;
         }[];
         maximaPointsCluster: {
-            rootNode: {
-                leaf: boolean;
-                centerPointIndex: any;
-                pointIndexes: any;
-                children?: undefined;
-            } | {
-                leaf: boolean;
-                centerPointIndex: any;
-                children: any;
-                pointIndexes?: undefined;
-            };
+            rootNode: any;
         };
         minimaPointsCluster: {
-            rootNode: {
-                leaf: boolean;
-                centerPointIndex: any;
-                pointIndexes: any;
-                children?: undefined;
-            } | {
-                leaf: boolean;
-                centerPointIndex: any;
-                children: any;
-                pointIndexes?: undefined;
-            };
+            rootNode: any;
         };
     };
-    _decolumnarize(col: any, width: any, height: any): {
+    _decolumnarize(col: any, width: number, height: number): {
         x: number;
         y: number;
         angle: any;
         scale: any;
         descriptors: any;
     }[];
-    _expandTree(node: any): {
-        leaf: boolean;
-        centerPointIndex: any;
-        pointIndexes: any;
-        children?: undefined;
-    } | {
-        leaf: boolean;
-        centerPointIndex: any;
-        children: any;
-        pointIndexes?: undefined;
-    };
+    _expandTree(node: any): any;
     destroy(): Promise<void>;
+    _pack4Bit(data: Uint8Array): Uint8Array<ArrayBufferLike>;
+    _unpack4Bit(packed: Uint8Array, width: number, height: number): Uint8Array<ArrayBuffer>;
 }
-import { WorkerPool } from "./utils/worker-pool.js";