@zaplier/sdk 1.0.5 → 1.0.7

package/dist/sdk.js

@@ -157,8 +157,12 @@
         h1 = x64Add(h1, h2);
         h2 = x64Add(h2, h1);
         // Convert to hex string
-        const hex1 = h1[0].toString(16).padStart(8, "0") + h1[1].toString(16).padStart(8, "0");
-        const hex2 = h2[0].toString(16).padStart(8, "0") + h2[1].toString(16).padStart(8, "0");
+        // CRITICAL: Use >>> 0 to convert to unsigned 32-bit integer before converting to hex
+        // This prevents negative numbers from generating hashes with minus signs (e.g., "-6b43973f")
+        const hex1 = (h1[0] >>> 0).toString(16).padStart(8, "0") +
+            (h1[1] >>> 0).toString(16).padStart(8, "0");
+        const hex2 = (h2[0] >>> 0).toString(16).padStart(8, "0") +
+            (h2[1] >>> 0).toString(16).padStart(8, "0");
         return hex1 + hex2;
     }
     /**
@@ -178,13 +182,26 @@
     /**
      * Hash fingerprint components into a stable identifier
      */
-    function hashFingerprint(components) {
+    function hashFingerprint(components, debug = false) {
         // Convert components to canonical string representation using deep sorting
         // CRITICAL: Do NOT use JSON.stringify(obj, keys) as it filters out nested properties!
         // Use canonicalizeStable instead which handles deep sorting and normalization.
-        const canonical = JSON.stringify(canonicalizeStable(components));
+        const canonicalized = canonicalizeStable(components);
+        const canonical = JSON.stringify(canonicalized);
+        if (debug) {
+            console.log("[RabbitTracker] hashFingerprint debug:", {
+                originalKeys: Object.keys(components),
+                canonicalizedKeys: Object.keys(canonicalized),
+                canonicalLength: canonical.length,
+                sample: canonical.substring(0, 200) + "...",
+            });
+        }
         // Use MurmurHash3 x64 for consistent hashing
-        return x64hash128(canonical);
+        const hash = x64hash128(canonical);
+        if (debug) {
+            console.log("[RabbitTracker] Generated fingerprintHash:", hash.substring(0, 32));
+        }
+        return hash;
     }
     /**
      * Generate a visitor ID from fingerprint hash
@@ -193,8 +210,33 @@
         // Use first 16 characters of the hash for visitor ID
         return "vis_" + fingerprintHash.substring(0, 16);
     }
+    /**
+     * Check if a key represents an unstable component that should be excluded from hashing
+     */
+    function isUnstableKey(key) {
+        // Unstable keys that change between requests:
+        // - duration: collection time varies
+        // - timestamp: changes every request
+        // - error: error messages can vary
+        // - errors: error arrays can vary
+        // - collectionTime: varies per request
+        const unstableKeys = [
+            "duration",
+            "timestamp",
+            "error",
+            "errors",
+            "collectionTime",
+            "startTime",
+            "endTime",
+            "_timestamp", // internal timestamp fields
+        ];
+        return (unstableKeys.includes(key) ||
+            key.endsWith("_timestamp") ||
+            key.endsWith("Timestamp"));
+    }
     /**
      * Canonicalize an object deeply with sorted keys and normalized primitives
+     * CRITICAL: Filters out unstable components that vary between requests
      */
     function canonicalizeStable(input) {
         if (input === null || input === undefined)
@@ -209,6 +251,10 @@
             const keys = Object.keys(input).sort();
             const out = {};
             for (const k of keys) {
+                // CRITICAL: Skip unstable keys that cause hash instability
+                if (isUnstableKey(k)) {
+                    continue;
+                }
                 const v = canonicalizeStable(input[k]);
                 if (v !== null)
                     out[k] = v;
@@ -229,9 +275,22 @@
     /**
      * Compute stable core hash from a minimal, invariant vector
      */
-    function hashStableCore(coreVector) {
-        const canonical = JSON.stringify(canonicalizeStable(coreVector));
-        return x64hash128(canonical);
+    function hashStableCore(coreVector, debug = false) {
+        const canonicalized = canonicalizeStable(coreVector);
+        const canonical = JSON.stringify(canonicalized);
+        if (debug) {
+            console.log("[RabbitTracker] hashStableCore debug:", {
+                originalKeys: Object.keys(coreVector),
+                canonicalizedKeys: Object.keys(canonicalized),
+                canonicalLength: canonical.length,
+                sample: canonical.substring(0, 200) + "...",
+            });
+        }
+        const hash = x64hash128(canonical);
+        if (debug) {
+            console.log("[RabbitTracker] Generated stableCoreHash:", hash.substring(0, 32));
+        }
+        return hash;
     }
 
     /**
@@ -4942,7 +5001,7 @@
             "system",
         ].includes(componentType);
         // Reduce retries for WebGL to prevent context leaks
-        const maxRetries = isWebGLComponent ? 2 : (isCriticalComponent ? 3 : 1);
+        const maxRetries = isWebGLComponent ? 2 : isCriticalComponent ? 3 : 1;
         const retryDelays = isWebGLComponent ? [200, 500] : [100, 250, 500]; // Longer delays for WebGL
         for (let attempt = 0; attempt < maxRetries; attempt++) {
             try {
@@ -5574,7 +5633,9 @@
                         // Fallback to legacy detection if imports fail
                         const ua = uaStr;
                         const m = ua.match(/(chrome|safari|firefox|edge|edg|brave|opera|opr|chromium)/i);
-                        const family = (m?.[1] || ua.split(" ")[0] || "unknown").toLowerCase();
+                        const family = (m?.[1] ||
+                            ua.split(" ")[0] ||
+                            "unknown").toLowerCase();
                         return family;
                     }
                 })(),
@@ -5582,8 +5643,10 @@
                 timezone: browser?.timezone || "unknown",
                 // PRIORITY 3: Primary language only (most stable language preference)
                 // Remove secondary languages as they can change more frequently
-                primaryLanguage: Array.isArray(browser?.languages) && browser.languages.length > 0 && browser.languages[0]
-                    ? browser.languages[0].toLowerCase().split('-')[0] // Only language code (en, pt, fr), not region
+                primaryLanguage: Array.isArray(browser?.languages) &&
+                    browser.languages.length > 0 &&
+                    browser.languages[0]
+                    ? browser.languages[0].toLowerCase().split("-")[0] // Only language code (en, pt, fr), not region
                     : "unknown",
                 // PRIORITY 4: Platform (ultra-stable - OS doesn't change)
                 platform: (browser?.platform || "unknown").toLowerCase(),
@@ -5691,11 +5754,24 @@
                             // Simplified ratio for matching (rounded to prevent micro-variations)
                             ratio: height > 0 ? Math.round((width / height) * 100) / 100 : 0,
                             // Size category for general device classification
-                            sizeCategory: width >= 2560 ? "large" : width >= 1920 ? "desktop" :
-                                width >= 1024 ? "laptop" : width >= 768 ? "tablet" : "mobile"
+                            sizeCategory: width >= 2560
+                                ? "large"
+                                : width >= 1920
+                                    ? "desktop"
+                                    : width >= 1024
+                                        ? "laptop"
+                                        : width >= 768
+                                            ? "tablet"
+                                            : "mobile",
                         };
                     })()
-                    : { bucket: "unknown", aspectClass: "unknown", densityClass: "unknown", ratio: 0, sizeCategory: "unknown" },
+                    : {
+                        bucket: "unknown",
+                        aspectClass: "unknown",
+                        densityClass: "unknown",
+                        ratio: 0,
+                        sizeCategory: "unknown",
+                    },
                 // CRITICAL: Do NOT include availability flags (canvas/webgl/audio) in stableCoreVector
                 // These flags can change between requests due to timeouts, permissions, or hardware issues
                 // and would cause the stableCoreHash to change, breaking visitor identification
@@ -5806,10 +5882,13 @@
                         arch: archBucket,
                         class: getHardwareClass(coresBucket, memoryBucket),
                         // Touch capability for mobile/desktop differentiation
-                        touch: deviceSignals$1.touchSupport?.maxTouchPoints ?
-                            (deviceSignals$1.touchSupport.maxTouchPoints >= 10 ? "multi" :
-                                deviceSignals$1.touchSupport.maxTouchPoints >= 5 ? "standard" : "basic") :
-                            "none"
+                        touch: deviceSignals$1.touchSupport?.maxTouchPoints
+                            ? deviceSignals$1.touchSupport.maxTouchPoints >= 10
+                                ? "multi"
+                                : deviceSignals$1.touchSupport.maxTouchPoints >= 5
+                                    ? "standard"
+                                    : "basic"
+                            : "none",
                     };
                 })(),
                 // PRIORITY 8: Enhanced color and display capabilities bucketing
@@ -5835,10 +5914,14 @@
                         if (!gamut)
                             return "unknown";
                         switch (gamut) {
-                            case "rec2020": return "professional"; // Professional/HDR displays
-                            case "p3": return "enhanced"; // Modern displays (Apple, etc.)
-                            case "srgb": return "standard"; // Standard displays
-                            default: return "unknown";
+                            case "rec2020":
+                                return "professional"; // Professional/HDR displays
+                            case "p3":
+                                return "enhanced"; // Modern displays (Apple, etc.)
+                            case "srgb":
+                                return "standard"; // Standard displays
+                            default:
+                                return "unknown";
                         }
                     };
                     // Combined display quality classification
@@ -5862,7 +5945,7 @@
                     return {
                         depth: depthClass,
                         gamut: gamutClass,
-                        class: getDisplayClass(depthClass, gamutClass)
+                        class: getDisplayClass(depthClass, gamutClass),
                     };
                 })(),
             };
@@ -5881,7 +5964,9 @@
                 // Add a simple checksum for additional uniqueness (deterministic)
                 let checksum = 0;
                 for (let i = 0; i < entropyString.length; i++) {
-                    checksum = ((checksum << 5) - checksum + entropyString.charCodeAt(i)) & 0xffffffff;
+                    checksum =
+                        ((checksum << 5) - checksum + entropyString.charCodeAt(i)) &
+                            0xffffffff;
                 }
                 coreVector._entropy = Math.abs(checksum).toString(36).substring(0, 8);
             }
@@ -5897,7 +5982,7 @@
             // - Vendor flavors (can change)
             // - Exact hardware values (use buckets)
             // Generate ultra-stable hash with additional collision resistance
-            const stableCoreHash = hashStableCore(coreVector);
+            const stableCoreHash = hashStableCore(coreVector, opts.debug);
             // CRITICAL: Generate enhanced fingerprint hash combining unstable + stable components
             // This prevents collisions by adding stable entropy to the fingerprint hash
             const enhancedComponentValues = {
@@ -5906,7 +5991,7 @@
                 // REMOVED: _hourlyEntropy - was causing visitor ID instability (same user = different IDs)
             };
             // Generate collision-resistant fingerprint hash
-            const enhancedHash = hashFingerprint(enhancedComponentValues);
+            const enhancedHash = hashFingerprint(enhancedComponentValues, opts.debug);
             // Update finalData with the enhanced hash
             finalData.hash = enhancedHash;
             // Log stable core components for debugging collision issues