@srsergio/taptapp-ar 1.0.88 → 1.0.90

package/dist/core/matching/matching.js

@@ -3,18 +3,28 @@ 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 = 5.0; // Tightened from 10 to 5 for better precision
-const MIN_NUM_INLIERS = 8; // Restored to 8
-const CLUSTER_MAX_POP = 20;
-const HAMMING_THRESHOLD = 0.85; // Relaxed from 0.8 back to 0.85
+import { refineWithMorphology } from "../estimation/morph-refinement.js";
+import { popcount32 } from "./hierarchical-clustering.js";
+const INLIER_THRESHOLD = 15.0; // 🚀 More tolerance for initial noise
+const MIN_NUM_INLIERS = 6; // 🎯 Lowered from 8 to catch the marker earlier
+const CLUSTER_MAX_POP = 25;
+const HAMMING_THRESHOLD = 0.85;
+const HDC_RATIO_THRESHOLD = 0.85;
+const MAX_MATCH_QUERY_POINTS = 800; // 🚀 Increased to handle 3000+ points detected
 // match list of querpoints against pre-built list of keyframes
-const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) => {
+const match = ({ keyframe, querypoints: rawQuerypoints, querywidth, queryheight, debugMode }) => {
     let debugExtra = {};
+    // 🎯 Performance Optimizer: Use only the most "salient" points (highest response)
+    const querypoints = rawQuerypoints.length > MAX_MATCH_QUERY_POINTS
+        ? [...rawQuerypoints].sort((a, b) => (b.score || b.response || 0) - (a.score || a.response || 0)).slice(0, MAX_MATCH_QUERY_POINTS)
+        : rawQuerypoints;
     const matches = [];
     const qlen = querypoints.length;
     const kmax = keyframe.max;
     const kmin = keyframe.min;
-    const descSize = 2; // Protocol V6: 64-bit LSH (2 x 32-bit)
+    const isHDC = keyframe.hdc === true || (kmax && kmax.hdc === 1);
+    const descSize = isHDC ? 1 : 2;
+    const currentRatioThreshold = isHDC ? HDC_RATIO_THRESHOLD : HAMMING_THRESHOLD;
     for (let j = 0; j < qlen; j++) {
         const querypoint = querypoints[j];
         const col = querypoint.maxima ? kmax : kmin;
@@ -23,14 +33,15 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
         const rootNode = col.t;
         const keypointIndexes = [];
         const queue = new TinyQueue([], (a1, a2) => a1.d - a2.d);
-        // query potential candidates from the columnar tree
         _query({
             node: rootNode,
             descriptors: col.d,
             querypoint,
             queue,
             keypointIndexes,
-            numPop: 0
+            numPop: 0,
+            isHDC,
+            descSize
         });
         let bestIndex = -1;
         let bestD1 = Number.MAX_SAFE_INTEGER;
@@ -39,8 +50,13 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
         const cDesc = col.d;
         for (let k = 0; k < keypointIndexes.length; k++) {
             const idx = keypointIndexes[k];
-            // Use offsets based on detected descriptor size
-            const d = hammingCompute({ v1: cDesc, v1Offset: idx * descSize, v2: qDesc });
+            let d;
+            if (isHDC) {
+                d = popcount32(cDesc[idx] ^ querypoint.hdcSignature);
+            }
+            else {
+                d = hammingCompute({ v1: cDesc, v1Offset: idx * descSize, v2: qDesc });
+            }
             if (d < bestD1) {
                 bestD2 = bestD1;
                 bestD1 = d;
@@ -51,7 +67,7 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
             }
         }
         if (bestIndex !== -1) {
-            if (bestD2 === Number.MAX_SAFE_INTEGER || (bestD1 / bestD2) < HAMMING_THRESHOLD) {
+            if (bestD2 === Number.MAX_SAFE_INTEGER || (bestD1 / bestD2) < currentRatioThreshold) {
                 matches.push({
                     querypoint,
                     keypoint: {
@@ -59,26 +75,39 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
                         y: col.y[bestIndex],
                         angle: col.a[bestIndex],
                         scale: col.s ? col.s[bestIndex] : keyframe.s
-                    }
+                    },
+                    d: bestD1
                 });
             }
         }
     }
-    if (matches.length < MIN_NUM_INLIERS)
+    if (matches.length < MIN_NUM_INLIERS) {
         return { debugExtra };
+    }
+    // Debug: Log Hamming results
+    if (Math.random() < 0.1 && debugMode) {
+        console.log(`MATCH_DL: Hamming found ${matches.length} initial matches`);
+    }
+    // 🌌 Moonshot: Constellation matching disabled for performance calibration
+    const constellationMatches = matches;
+    if (debugMode)
+        debugExtra.constellationMatches = constellationMatches;
     const houghMatches = computeHoughMatches({
-        keywidth: keyframe.w,
-        keyheight: keyframe.h,
+        keywidth: keyframe.w || keyframe.width,
+        keyheight: keyframe.h || keyframe.height,
         querywidth,
         queryheight,
-        matches,
+        matches: constellationMatches,
     });
     if (debugMode)
         debugExtra.houghMatches = houghMatches;
+    if (houghMatches.length < MIN_NUM_INLIERS) {
+        return { debugExtra };
+    }
     const H = computeHomography({
         srcPoints: houghMatches.map((m) => [m.keypoint.x, m.keypoint.y]),
         dstPoints: houghMatches.map((m) => [m.querypoint.x, m.querypoint.y]),
-        keyframe: { width: keyframe.w, height: keyframe.h },
+        keyframe: { width: keyframe.w || keyframe.width, height: keyframe.h || keyframe.height },
     });
     if (H === null) {
         return { debugExtra };
@@ -90,11 +119,14 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
     });
     if (debugMode)
         debugExtra.inlierMatches = inlierMatches;
-    if (inlierMatches.length < MIN_NUM_INLIERS)
+    if (inlierMatches.length < MIN_NUM_INLIERS) {
         return { debugExtra };
-    // Second pass with homography guided matching
+    }
+    if (debugMode && Math.random() < 0.02) {
+        console.log(`MATCH: Homography success with ${inlierMatches.length} inliers`);
+    }
     const HInv = matrixInverse33(H, 0.00001);
-    const dThreshold2 = 100; // 10 * 10
+    const dThreshold2 = 100;
     const matches2 = [];
     const hi00 = HInv[0], hi01 = HInv[1], hi02 = HInv[2];
     const hi10 = HInv[3], hi11 = HInv[4], hi12 = HInv[5];
@@ -102,7 +134,6 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
     for (let j = 0; j < qlen; j++) {
         const querypoint = querypoints[j];
         const qx = querypoint.x, qy = querypoint.y;
-        // Inline multiplyPointHomographyInhomogenous
         const uz = (qx * hi20) + (qy * hi21) + hi22;
         const invZ = 1.0 / uz;
         const mapX = ((qx * hi00) + (qy * hi01) + hi02) * invZ;
@@ -121,7 +152,13 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
             const d2 = dx * dx + dy * dy;
             if (d2 > dThreshold2)
                 continue;
-            const d = hammingCompute({ v1: cd, v1Offset: k * descSize, v2: qDesc });
+            let d;
+            if (isHDC) {
+                d = popcount32(cd[k] ^ querypoint.hdcSignature);
+            }
+            else {
+                d = hammingCompute({ v1: cd, v1Offset: k * descSize, v2: qDesc });
+            }
             if (d < bestD1) {
                 bestD2 = bestD1;
                 bestD1 = d;
@@ -132,7 +169,7 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
             }
         }
         if (bestIndex !== -1 &&
-            (bestD2 === Number.MAX_SAFE_INTEGER || (bestD1 / bestD2) < HAMMING_THRESHOLD)) {
+            (bestD2 === Number.MAX_SAFE_INTEGER || (bestD1 / bestD2) < currentRatioThreshold)) {
             matches2.push({
                 querypoint,
                 keypoint: {
@@ -147,8 +184,8 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
     if (debugMode)
         debugExtra.matches2 = matches2;
     const houghMatches2 = computeHoughMatches({
-        keywidth: keyframe.w,
-        keyheight: keyframe.h,
+        keywidth: keyframe.w || keyframe.width,
+        keyheight: keyframe.h || keyframe.height,
         querywidth,
         queryheight,
         matches: matches2,
@@ -158,7 +195,7 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
     const H2 = computeHomography({
         srcPoints: houghMatches2.map((m) => [m.keypoint.x, m.keypoint.y]),
         dstPoints: houghMatches2.map((m) => [m.querypoint.x, m.querypoint.y]),
-        keyframe: { width: keyframe.w, height: keyframe.h },
+        keyframe: { width: keyframe.w || keyframe.width, height: keyframe.h || keyframe.height },
     });
     if (H2 === null)
         return { debugExtra };
@@ -169,10 +206,17 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
     });
     if (debugMode)
         debugExtra.inlierMatches2 = inlierMatches2;
-    return { H: H2, matches: inlierMatches2, debugExtra };
+    const refinedH = refineWithMorphology({
+        imageData: rawQuerypoints[0].imageData,
+        width: querywidth,
+        height: queryheight,
+        targetData: { w: keyframe.w || keyframe.width, h: keyframe.h || keyframe.height },
+        initialH: H2,
+        iterations: 3
+    });
+    return { H: refinedH || H2, matches: inlierMatches2, debugExtra };
 };
-const _query = ({ node, descriptors, querypoint, queue, keypointIndexes, numPop }) => {
-    const descSize = 2;
+const _query = ({ node, descriptors, querypoint, queue, keypointIndexes, numPop, isHDC, descSize }) => {
     const isLeaf = node[0] === 1;
     const childrenOrIndices = node[2];
     if (isLeaf) {
@@ -188,27 +232,33 @@ const _query = ({ node, descriptors, querypoint, queue, keypointIndexes, numPop
     for (let i = 0; i < clen; i++) {
         const childNode = childrenOrIndices[i];
         const cIdx = childNode[1];
-        const d = hammingCompute({
-            v1: descriptors,
-            v1Offset: cIdx * descSize,
-            v2: qDesc,
-        });
+        let d;
+        if (isHDC) {
+            d = popcount32(descriptors[cIdx] ^ querypoint.hdcSignature);
+        }
+        else {
+            d = hammingCompute({
+                v1: descriptors,
+                v1Offset: cIdx * descSize,
+                v2: qDesc,
+            });
+        }
         distances[i] = d;
         if (d < minD)
             minD = d;
     }
     for (let i = 0; i < clen; i++) {
         const dist = distances[i];
-        if (dist !== minD) {
-            queue.push({ node: childrenOrIndices[i], d: dist });
+        if (dist <= minD) {
+            _query({ node: childrenOrIndices[i], descriptors, querypoint, queue, keypointIndexes, numPop: numPop + 1, isHDC, descSize });
         }
         else {
-            _query({ node: childrenOrIndices[i], descriptors, querypoint, queue, keypointIndexes, numPop: numPop + 1 });
+            queue.push({ node: childrenOrIndices[i], d: dist });
         }
     }
     if (numPop < CLUSTER_MAX_POP && queue.length > 0) {
         const { node } = queue.pop();
-        _query({ node, descriptors, querypoint, queue, keypointIndexes, numPop: numPop + 1 });
+        _query({ node, descriptors, querypoint, queue, keypointIndexes, numPop: numPop + 1, isHDC, descSize });
     }
 };
 const _findInlierMatches = (options) => {
@@ -222,7 +272,6 @@ const _findInlierMatches = (options) => {
         const m = matches[i];
         const qp = m.querypoint;
         const kp = m.keypoint;
-        // Inline multiplyPointHomographyInhomogenous
         const uz = (kp.x * h20) + (kp.y * h21) + h22;
         const invZ = 1.0 / uz;
         const mx = ((kp.x * h00) + (kp.y * h01) + h02) * invZ;
@@ -235,4 +284,85 @@ const _findInlierMatches = (options) => {
     }
     return goodMatches;
 };
+const _applyConstellationFilter = (matches) => {
+    const len = matches.length;
+    if (len < 3)
+        return matches;
+    const pool = matches.slice().sort((a, b) => a.d - b.d).slice(0, 1500);
+    const RATIO_TOLERANCE = 0.25;
+    const COSINE_TOLERANCE = 0.2;
+    const MAX_NEIGHBORS = 6;
+    const MIN_VERIFICATIONS = 1;
+    const gridSize = 50;
+    const grid = new Map();
+    const getGridKey = (x, y) => `${Math.floor(x / gridSize)},${Math.floor(y / gridSize)}`;
+    for (let i = 0; i < pool.length; i++) {
+        const qp = pool[i].querypoint;
+        const key = getGridKey(qp.x, qp.y);
+        if (!grid.has(key))
+            grid.set(key, []);
+        grid.get(key).push(i);
+    }
+    const scores = new Int32Array(pool.length);
+    for (let i = 0; i < pool.length; i++) {
+        const m1 = pool[i];
+        const qp1 = m1.querypoint;
+        const neighbors = [];
+        const gx = Math.floor(qp1.x / gridSize);
+        const gy = Math.floor(qp1.y / gridSize);
+        for (let dx = -1; dx <= 1; dx++) {
+            for (let dy = -1; dy <= 1; dy++) {
+                const cell = grid.get(`${gx + dx},${gy + dy}`);
+                if (!cell)
+                    continue;
+                for (const idx of cell) {
+                    if (idx === i)
+                        continue;
+                    const m2 = pool[idx];
+                    const distSq = Math.pow(m2.querypoint.x - qp1.x, 2) + Math.pow(m2.querypoint.y - qp1.y, 2);
+                    neighbors.push({ index: idx, d2: distSq });
+                }
+            }
+        }
+    }
+    const filtered = [];
+    // Dummy logic just to keep the structure
+    for (let i = 0; i < pool.length; i++) {
+        filtered.push(pool[i]);
+    }
+    return filtered;
+};
+const _checkTriadConsistency = (m1, m2, m3, ratioTol, cosTol) => {
+    const q1x = m1.querypoint.x, q1y = m1.querypoint.y;
+    const q2x = m2.querypoint.x, q2y = m2.querypoint.y;
+    const q3x = m3.querypoint.x, q3y = m3.querypoint.y;
+    const v21q = [q2x - q1x, q2y - q1y];
+    const v31q = [q3x - q1x, q3y - q1y];
+    const k1x = m1.keypoint.x, k1y = m1.keypoint.y;
+    const k2x = m2.keypoint.x, k2y = m2.keypoint.y;
+    const k3x = m3.keypoint.x, k3y = m3.keypoint.y;
+    const v21k = [k2x - k1x, k2y - k1y];
+    const v31k = [k3x - k1x, k3y - k1y];
+    const d21q2 = v21q[0] * v21q[0] + v21q[1] * v21q[1];
+    const d31q2 = v31q[0] * v31q[0] + v31q[1] * v31q[1];
+    const d21k2 = v21k[0] * v21k[0] + v21k[1] * v21k[1];
+    const d31k2 = v31k[0] * v31k[0] + v31k[1] * v31k[1];
+    if (d31q2 < 1e-4 || d31k2 < 1e-4)
+        return false;
+    const ratioQ = d21q2 / d31q2;
+    const ratioK = d21k2 / d31k2;
+    if (Math.abs(ratioQ - ratioK) / (ratioK + 1e-6) > ratioTol * 2)
+        return false;
+    const dotQ = v21q[0] * v31q[0] + v21q[1] * v31q[1];
+    const cosQ = dotQ / Math.sqrt(d21q2 * d31q2);
+    const dotK = v21k[0] * v31k[0] + v21k[1] * v31k[1];
+    const cosK = dotK / Math.sqrt(d21k2 * d31k2);
+    if (Math.abs(cosQ - cosK) > cosTol)
+        return false;
+    const crossQ = v21q[0] * v31q[1] - v21q[1] * v31q[0];
+    const crossK = v21k[0] * v31k[1] - v21k[1] * v31k[0];
+    if ((crossQ > 0) !== (crossK > 0))
+        return false;
+    return true;
+};
 export { match };

package/dist/core/matching/ransacHomography.js

@@ -3,8 +3,8 @@ import { quadrilateralConvex, matrixInverse33, smallestTriangleArea, multiplyPoi
 import { solveHomography } from "../utils/homography.js";
 const CAUCHY_SCALE = 0.01;
 const CHUNK_SIZE = 10;
-const NUM_HYPOTHESES = 20;
-const NUM_HYPOTHESES_QUICK = 10;
+const NUM_HYPOTHESES = 100;
+const NUM_HYPOTHESES_QUICK = 50;
 // Using RANSAC to estimate homography
 const computeHomography = (options) => {
     const { srcPoints, dstPoints, keyframe, quickMode } = options;
@@ -89,13 +89,10 @@ const computeHomography = (options) => {
     return finalH;
 };
 const _checkHeuristics = ({ H, testPoints, keyframe }) => {
-    const HInv = matrixInverse33(H, 0.00001);
-    if (HInv === null)
-        return false;
     const mp = [];
     for (let i = 0; i < testPoints.length; i++) {
         // 4 test points, corner of keyframe
-        mp.push(multiplyPointHomographyInhomogenous(testPoints[i], HInv));
+        mp.push(multiplyPointHomographyInhomogenous(testPoints[i], H));
     }
     const smallArea = smallestTriangleArea(mp[0], mp[1], mp[2], mp[3]);
     if (smallArea < keyframe.width * keyframe.height * 0.0001)

package/dist/core/protocol.d.ts

@@ -1,4 +1,5 @@
-export declare const CURRENT_VERSION = 8;
+export declare const CURRENT_VERSION = 9;
+export declare const HDC_SEED = 322420463;
 /**
  * Morton Order calculation for spatial sorting
  */
@@ -14,12 +15,13 @@ export declare function unpack4Bit(packed: Uint8Array, width: number, height: nu
 /**
  * Columnarizes point data for efficient storage and transfer
  */
-export declare function columnarize(points: any[], tree: any, width: number, height: number): {
+export declare function columnarize(points: any[], tree: any, width: number, height: number, useHDC?: boolean): {
     x: Uint16Array<ArrayBuffer>;
     y: Uint16Array<ArrayBuffer>;
     a: Int16Array<ArrayBuffer>;
     s: Uint8Array<ArrayBuffer>;
-    d: Uint32Array<ArrayBuffer>;
+    d: any;
+    hdc: number;
     t: any;
 };
 /**

package/dist/core/protocol.js

@@ -1,5 +1,6 @@
 import * as msgpack from "@msgpack/msgpack";
-export const CURRENT_VERSION = 8;
+export const CURRENT_VERSION = 9; // Bumped for HDC support
+export const HDC_SEED = 0x1337BEEF; // Default system seed
 /**
  * Morton Order calculation for spatial sorting
  */
@@ -49,21 +50,35 @@ export function unpack4Bit(packed, width, height) {
 /**
  * Columnarizes point data for efficient storage and transfer
  */
-export function columnarize(points, tree, width, height) {
+export function columnarize(points, tree, width, height, useHDC = false) {
     const count = points.length;
     const x = new Uint16Array(count);
     const y = new Uint16Array(count);
     const angle = new Int16Array(count);
     const scale = new Uint8Array(count);
-    const descriptors = new Uint32Array(count * 2);
+    let descriptors;
+    if (useHDC) {
+        descriptors = new Uint32Array(count); // HDC Signatures (32-bit)
+    }
+    else {
+        descriptors = new Uint32Array(count * 2); // Raw Descriptors (64-bit)
+    }
     for (let i = 0; i < count; i++) {
         x[i] = Math.round((points[i].x / width) * 65535);
         y[i] = Math.round((points[i].y / height) * 65535);
         angle[i] = Math.round((points[i].angle / Math.PI) * 32767);
         scale[i] = Math.round(Math.log2(points[i].scale || 1));
         if (points[i].descriptors && points[i].descriptors.length >= 2) {
-            descriptors[i * 2] = points[i].descriptors[0];
-            descriptors[(i * 2) + 1] = points[i].descriptors[1];
+            if (useHDC) {
+                // For HDC, we'd normally call project + compress here
+                // But protocol.ts should be agnostic of the generator.
+                // We'll assume points[i].hdcSignature exists if pre-calculated
+                descriptors[i] = points[i].hdcSignature || 0;
+            }
+            else {
+                descriptors[i * 2] = points[i].descriptors[0];
+                descriptors[(i * 2) + 1] = points[i].descriptors[1];
+            }
         }
     }
     return {
@@ -72,6 +87,7 @@ export function columnarize(points, tree, width, height) {
         a: angle,
         s: scale,
         d: descriptors,
+        hdc: useHDC ? 1 : 0, // HDC Flag (renamed from h to avoid collision with height)
         t: compactTree(tree.rootNode),
     };
 }
@@ -182,7 +198,13 @@ export function decodeTaar(buffer) {
                     col.s = s;
                 }
                 if (col.d instanceof Uint8Array) {
-                    col.d = new Uint32Array(col.d.buffer.slice(col.d.byteOffset, col.d.byteOffset + col.d.byteLength));
+                    // Check if it's HDC (Uint32) or Raw (Uint32 x 2)
+                    if (col.hdc === 1) {
+                        col.d = new Uint32Array(col.d.buffer.slice(col.d.byteOffset, col.d.byteOffset + col.d.byteLength));
+                    }
+                    else {
+                        col.d = new Uint32Array(col.d.buffer.slice(col.d.byteOffset, col.d.byteOffset + col.d.byteLength));
+                    }
                 }
             }
         }

package/dist/runtime/controller.js

@@ -66,16 +66,19 @@ class Controller {
         if (this.worker)
             this._setupWorkerListener();
         // Moonshot: Full frame detector for better sensitivity
-        this.fullDetector = new DetectorLite(this.inputWidth, this.inputHeight, { useLSH: true });
+        this.fullDetector = new DetectorLite(this.inputWidth, this.inputHeight, {
+            useLSH: true,
+            maxFeaturesPerBucket: 24 // Increased from 12 for better small target density
+        });
         this.featureManager.init({
             inputWidth: this.inputWidth,
             inputHeight: this.inputHeight,
             projectionTransform: [], // Will be set below
             debugMode: this.debugMode
         });
-        const near = 10;
-        const far = 100000;
-        const fovy = (45.0 * Math.PI) / 180;
+        const near = 1.0;
+        const far = 10000;
+        const fovy = (60.0 * Math.PI) / 180;
         const f = this.inputHeight / 2 / Math.tan(fovy / 2);
         this.projectionTransform = [
             [f, 0, this.inputWidth / 2],
@@ -245,9 +248,11 @@ class Controller {
                 }
             }
         }
-        // STRICT QUALITY CHECK: We only update the transform if we have enough HIGH CONFIDENCE points
-        const stableAndReliable = reliabilities.filter((r, idx) => r > 0.8 && stabilities[indices[idx]] > 0.6).length;
-        if (stableAndReliable < 6 || finalWorldCoords.length < 8) {
+        // 🚀 WARMUP FIX: If we just started tracking (less than 15 frames), we are much more relaxed
+        const isWarmup = state.trackCount < 15;
+        const numTracked = finalWorldCoords.length;
+        const minPoints = isWarmup ? 4 : 5; // Start with 4, then require 5
+        if (numTracked < minPoints) {
             return {
                 modelViewTransform: null,
                 screenCoords: finalScreenCoords,
@@ -255,6 +260,7 @@ class Controller {
                 stabilities: finalStabilities
             };
         }
+        state.trackCount++;
         const modelViewTransform = await this._workerTrackUpdate(lastModelViewTransform, {
             worldCoords: finalWorldCoords,
             screenCoords: finalWorldCoords.map((_, i) => {
@@ -544,15 +550,14 @@ class Controller {
         });
     }
     _glModelViewMatrix(modelViewTransform, targetIndex) {
-        const height = this.markerDimensions[targetIndex][1];
+        // Transformation to map Computer Vision coordinates (Y-down, Z-forward) 
+        // to OpenGL coordinates (Y-up, Z-backward). 
+        // We negate the 2nd and 3rd rows of the pose matrix.
         return [
             modelViewTransform[0][0], -modelViewTransform[1][0], -modelViewTransform[2][0], 0,
-            -modelViewTransform[0][1], modelViewTransform[1][1], modelViewTransform[2][1], 0,
-            -modelViewTransform[0][2], modelViewTransform[1][2], modelViewTransform[2][2], 0,
-            modelViewTransform[0][1] * height + modelViewTransform[0][3],
-            -(modelViewTransform[1][1] * height + modelViewTransform[1][3]),
-            -(modelViewTransform[2][1] * height + modelViewTransform[2][3]),
-            1,
+            modelViewTransform[0][1], -modelViewTransform[1][1], -modelViewTransform[2][1], 0,
+            modelViewTransform[0][2], -modelViewTransform[1][2], -modelViewTransform[2][2], 0,
+            modelViewTransform[0][3], -modelViewTransform[1][3], -modelViewTransform[2][3], 1,
         ];
     }
     _glProjectionMatrix({ projectionTransform, width, height, near, far }) {

package/dist/runtime/controller.worker.js

@@ -19,7 +19,10 @@ onmessage = (msg) => {
             if (data.trackingDataList && data.markerDimensions) {
                 tracker = new Tracker(data.markerDimensions, data.trackingDataList, data.projectionTransform, data.inputWidth, data.inputHeight, debugMode);
             }
-            detector = new DetectorLite(data.inputWidth, data.inputHeight, { useLSH: true });
+            detector = new DetectorLite(data.inputWidth, data.inputHeight, {
+                useLSH: true,
+                maxFeaturesPerBucket: 24
+            });
             break;
         case "match":
             const interestedTargetIndexes = data.targetIndexes;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@srsergio/taptapp-ar",
-    "version": "1.0.88",
+    "version": "1.0.90",
     "description": "Ultra-fast Augmented Reality (AR) SDK for Node.js and Browser. Image tracking with 100% pure JavaScript, zero-dependencies, and high-performance compilation.",
     "keywords": [
         "augmented reality",
@@ -52,7 +52,8 @@
         "build": "tsc",
         "prepublishOnly": "npm run build",
         "test": "vitest",
-        "test:react": "vite --port 4321 --open tests/react-test.html"
+        "test:react": "vite --port 4321 --open tests/reliability-test.html",
+        "test:pnp": "pnpm build && node scripts/pnp-verify-cli.js"
     },
     "peerDependencies": {
         "aframe": ">=1.5.0",

package/src/compiler/offline-compiler.ts

@@ -12,6 +12,7 @@ import { DetectorLite } from "../core/detector/detector-lite.js";
 import { build as hierarchicalClusteringBuild } from "../core/matching/hierarchical-clustering.js";
 import * as protocol from "../core/protocol.js";
 import { triangulate, getEdges } from "../core/utils/delaunay.js";
+import { generateBasis, projectDescriptor, compressToSignature } from "../core/matching/hdc.js";
 
 // Detect environment
 const isNode = typeof process !== "undefined" &&
@@ -92,15 +93,26 @@ export class OfflineCompiler {
         const results = [];
         for (let i = 0; i < targetImages.length; i++) {
             const targetImage = targetImages[i];
-            const imageList = buildImageList(targetImage);
+            const fullImageList = buildImageList(targetImage);
+            // 🚀 MOONSHOT: Keep many scales for better robustness
+            const imageList = fullImageList;
             const percentPerImageScale = percentPerImage / imageList.length;
 
             const keyframes = [];
 
             for (const image of imageList as any[]) {
-                const detector = new DetectorLite(image.width, image.height, { useLSH: true, maxFeaturesPerBucket: 20 });
+                const detector = new DetectorLite(image.width, image.height, { useLSH: true, maxFeaturesPerBucket: 40 });
                 const { featurePoints: ps } = detector.detect(image.data);
 
+                // HDC Pre-calculation
+                const hdcBasis = generateBasis(protocol.HDC_SEED, 1024);
+                for (const p of ps) {
+                    if (p.descriptors) {
+                        const hv = projectDescriptor(p.descriptors, hdcBasis);
+                        p.hdcSignature = compressToSignature(hv);
+                    }
+                }
+
                 const maximaPoints = ps.filter((p: any) => p.maxima);
                 const minimaPoints = ps.filter((p: any) => !p.maxima);
                 const maximaPointsCluster = hierarchicalClusteringBuild({ points: maximaPoints });
@@ -204,8 +216,9 @@ export class OfflineCompiler {
                     w: kf.width,
                     h: kf.height,
                     s: kf.scale,
-                    max: protocol.columnarize(kf.maximaPoints, kf.maximaPointsCluster, kf.width, kf.height),
-                    min: protocol.columnarize(kf.minimaPoints, kf.minimaPointsCluster, kf.width, kf.height),
+                    hdc: false,
+                    max: protocol.columnarize(kf.maximaPoints, kf.maximaPointsCluster, kf.width, kf.height, false),
+                    min: protocol.columnarize(kf.minimaPoints, kf.minimaPointsCluster, kf.width, kf.height, false),
                 })),
             };
         });