@zaplier/sdk 1.0.5 → 1.0.7

package/dist/index.d.ts

@@ -1289,7 +1289,7 @@ declare function hash32(input: string): string;
 /**
  * Hash fingerprint components into a stable identifier
  */
-declare function hashFingerprint(components: Record<string, any>): string;
+declare function hashFingerprint(components: Record<string, any>, debug?: boolean): string;
 /**
  * Generate a visitor ID from fingerprint hash
  */

package/dist/index.esm.js

@@ -151,8 +151,12 @@ function x64hash128(input, seed = 0) {
     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;
 }
 /**
@@ -172,13 +176,26 @@ function hash32(input) {
 /**
  * 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
@@ -187,8 +204,33 @@ function generateVisitorId(fingerprintHash) {
     // 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)
@@ -203,6 +245,10 @@ function canonicalizeStable(input) {
         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;
@@ -223,9 +269,22 @@ function canonicalizeStable(input) {
 /**
  * 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;
 }
 
 /**
@@ -4936,7 +4995,7 @@ async function collectComponent(componentType, collector, options) {
         "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 {
@@ -5568,7 +5627,9 @@ async function collectFingerprint(options = {}) {
                     // 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;
                 }
             })(),
@@ -5576,8 +5637,10 @@ async function collectFingerprint(options = {}) {
             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(),
@@ -5685,11 +5748,24 @@ async function collectFingerprint(options = {}) {
                         // 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
@@ -5800,10 +5876,13 @@ async function collectFingerprint(options = {}) {
                     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
@@ -5829,10 +5908,14 @@ async function collectFingerprint(options = {}) {
                     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
@@ -5856,7 +5939,7 @@ async function collectFingerprint(options = {}) {
                 return {
                     depth: depthClass,
                     gamut: gamutClass,
-                    class: getDisplayClass(depthClass, gamutClass)
+                    class: getDisplayClass(depthClass, gamutClass),
                 };
             })(),
         };
@@ -5875,7 +5958,9 @@ async function collectFingerprint(options = {}) {
             // 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);
         }
@@ -5891,7 +5976,7 @@ async function collectFingerprint(options = {}) {
         // - 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 = {
@@ -5900,7 +5985,7 @@ async function collectFingerprint(options = {}) {
             // 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