@srsergio/taptapp-ar 1.0.77 → 1.0.79

package/src/compiler/features/temporal-filter-feature.ts

@@ -0,0 +1,68 @@
+import { ControllerFeature } from "./feature-base.js";
+
+export interface TemporalState {
+    showing: boolean;
+    trackCount: number;
+    trackMiss: number;
+}
+
+export class TemporalFilterFeature implements ControllerFeature {
+    id = "temporal-filter";
+    name = "Temporal Filter";
+    description = "Provides warmup tolerance (to avoid false positives) and miss tolerance (to maintain tracking during brief occlusions).";
+    enabled = true;
+
+    private states: TemporalState[] = [];
+    private warmupTolerance: number;
+    private missTolerance: number;
+    private onToggleShowing?: (targetIndex: number, showing: boolean) => void;
+
+    constructor(warmup: number = 2, miss: number = 5, onToggleShowing?: (targetIndex: number, showing: boolean) => void) {
+        this.warmupTolerance = warmup;
+        this.missTolerance = miss;
+        this.onToggleShowing = onToggleShowing;
+    }
+
+    private getState(targetIndex: number): TemporalState {
+        if (!this.states[targetIndex]) {
+            this.states[targetIndex] = {
+                showing: false,
+                trackCount: 0,
+                trackMiss: 0,
+            };
+        }
+        return this.states[targetIndex];
+    }
+
+    shouldShow(targetIndex: number, isTracking: boolean): boolean {
+        if (!this.enabled) return isTracking;
+
+        const state = this.getState(targetIndex);
+
+        if (!state.showing) {
+            if (isTracking) {
+                state.trackMiss = 0;
+                state.trackCount += 1;
+                if (state.trackCount > this.warmupTolerance) {
+                    state.showing = true;
+                    this.onToggleShowing?.(targetIndex, true);
+                }
+            } else {
+                state.trackCount = 0;
+            }
+        } else {
+            if (!isTracking) {
+                state.trackCount = 0;
+                state.trackMiss += 1;
+                if (state.trackMiss > this.missTolerance) {
+                    state.showing = false;
+                    this.onToggleShowing?.(targetIndex, false);
+                }
+            } else {
+                state.trackMiss = 0;
+            }
+        }
+
+        return state.showing;
+    }
+}

package/src/compiler/offline-compiler.ts

@@ -11,7 +11,6 @@ import { extractTrackingFeatures } from "./tracker/extract-utils.js";
 import { DetectorLite } from "./detector/detector-lite.js";
 import { build as hierarchicalClusteringBuild } from "./matching/hierarchical-clustering.js";
 import * as msgpack from "@msgpack/msgpack";
-import { WorkerPool } from "./utils/worker-pool.js";
 
 // Detect environment
 const isNode = typeof process !== "undefined" &&
@@ -22,40 +21,9 @@ const CURRENT_VERSION = 7; // Protocol v7: Moonshot - 4-bit Packed Tracking Data
 
 export class OfflineCompiler {
     data: any = null;
-    workerPool: WorkerPool | null = null;
 
     constructor() {
-        // Workers only in Node.js
-        if (!isNode) {
-            console.log("🌐 OfflineCompiler: Browser mode (no workers)");
-        }
-    }
-
-    async _initNodeWorkers() {
-        try {
-            const pathModule = "path";
-            const urlModule = "url";
-            const osModule = "os";
-            const workerThreadsModule = "node:worker_threads";
-
-            const [path, url, os, { Worker }] = await Promise.all([
-                import(/* @vite-ignore */ pathModule),
-                import(/* @vite-ignore */ urlModule),
-                import(/* @vite-ignore */ osModule),
-                import(/* @vite-ignore */ workerThreadsModule)
-            ]);
-
-            const __filename = url.fileURLToPath(import.meta.url);
-            const __dirname = path.dirname(__filename);
-            const workerPath = path.join(__dirname, "node-worker.js");
-
-            // Limit workers to avoid freezing system
-            const numWorkers = Math.min(os.cpus().length, 4);
-
-            this.workerPool = new WorkerPool(workerPath, numWorkers, Worker);
-        } catch (e) {
-            console.log("⚡ OfflineCompiler: Running without workers (initialization failed)", e);
-        }
+        console.log("⚡ OfflineCompiler: Main thread mode (no workers)");
     }
 
     async compileImageTargets(images: any[], progressCallback: (p: number) => void) {
@@ -108,25 +76,7 @@ export class OfflineCompiler {
     }
 
     async _compileTarget(targetImages: any[], progressCallback: (p: number) => void) {
-        if (isNode) await this._initNodeWorkers();
-
-        if (this.workerPool) {
-            const progressMap = new Float32Array(targetImages.length);
-            const wrappedPromises = targetImages.map((targetImage: any, index: number) => {
-                return this.workerPool!.runTask({
-                    type: 'compile-all', // 🚀 MOONSHOT: Combined task
-                    targetImage,
-                    onProgress: (p: number) => {
-                        progressMap[index] = p;
-                        const sum = progressMap.reduce((a, b) => a + b, 0);
-                        progressCallback(sum / targetImages.length);
-                    }
-                });
-            });
-            return Promise.all(wrappedPromises);
-        }
-
-        // Fallback or non-worker implementation: run match and track sequentially
+        // Run match and track sequentially to match browser behavior exactly
         const matchingResults = await this._compileMatch(targetImages, (p) => progressCallback(p * 0.5));
         const trackingResults = await this._compileTrack(targetImages, (p) => progressCallback(50 + p * 0.5));
 
@@ -140,27 +90,6 @@ export class OfflineCompiler {
         const percentPerImage = 100 / targetImages.length;
         let currentPercent = 0;
 
-        if (isNode) await this._initNodeWorkers();
-        if (this.workerPool) {
-            const progressMap = new Float32Array(targetImages.length);
-
-            const wrappedPromises = targetImages.map((targetImage: any, index: number) => {
-                return this.workerPool!.runTask({
-                    type: 'match',
-                    targetImage,
-                    percentPerImage,
-                    basePercent: 0,
-                    onProgress: (p: number) => {
-                        progressMap[index] = p;
-                        const sum = progressMap.reduce((a, b) => a + b, 0);
-                        progressCallback(sum);
-                    }
-                });
-            });
-
-            return Promise.all(wrappedPromises);
-        }
-
         const results = [];
         for (let i = 0; i < targetImages.length; i++) {
             const targetImage = targetImages[i];
@@ -201,24 +130,6 @@ export class OfflineCompiler {
         const percentPerImage = 100 / targetImages.length;
         let currentPercent = 0;
 
-        if (this.workerPool) {
-            const progressMap = new Float32Array(targetImages.length);
-            const wrappedPromises = targetImages.map((targetImage: any, index: number) => {
-                return this.workerPool!.runTask({
-                    type: 'compile',
-                    targetImage,
-                    percentPerImage,
-                    basePercent: 0,
-                    onProgress: (p: number) => {
-                        progressMap[index] = p;
-                        const sum = progressMap.reduce((a, b) => a + b, 0);
-                        progressCallback(sum);
-                    }
-                });
-            });
-            return Promise.all(wrappedPromises);
-        }
-
         const results = [];
         for (let i = 0; i < targetImages.length; i++) {
             const targetImage = targetImages[i];
@@ -480,9 +391,7 @@ export class OfflineCompiler {
     }
 
     async destroy() {
-        if (this.workerPool) {
-            await this.workerPool.destroy();
-        }
+        // No workers to destroy
     }
 
 

package/src/react/TaptappAR.tsx

@@ -169,6 +169,9 @@ export const TaptappAR: React.FC<TaptappARProps> = ({
                     display: block;
                     width: 100%;
                     height: auto;
+                    opacity: 0;
+                    pointer-events: none;
+                    transition: opacity 0.3s ease;
                 }
             `}</style>
         </div>

package/src/react/use-ar.ts

@@ -52,6 +52,7 @@ export const useAR = (config: ARConfig): UseARReturn => {
                     targetSrc: config.targetTaarSrc,
                     overlay: overlayRef.current!,
                     scale: config.scale,
+                    debug: false,
                     onFound: async ({ targetIndex }) => {
                         console.log(`🎯 Target ${targetIndex} detected!`);
                         if (!isMounted) return;