@zaplier/sdk 1.1.2 → 1.1.4

package/dist/sdk.js

@@ -5696,156 +5696,51 @@
                 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
-                    : "unknown",
+                primaryLanguage: (() => {
+                    try {
+                        const languages = browser?.languages;
+                        if (Array.isArray(languages) && languages.length > 0 && languages[0]) {
+                            return languages[0].toLowerCase().split("-")[0]; // Only language code (en, pt, fr), not region
+                        }
+                        // Fallback to navigator.language if browser.languages is not available
+                        if (typeof navigator !== 'undefined' && navigator.language) {
+                            return navigator.language.toLowerCase().split("-")[0];
+                        }
+                        return "unknown";
+                    }
+                    catch {
+                        return "unknown";
+                    }
+                })(),
                 // PRIORITY 4: Platform (ultra-stable - OS doesn't change)
                 platform: (browser?.platform || "unknown").toLowerCase(),
                 // PRIORITY 5: Device type (critical for differentiation, ultra-stable)
                 deviceType,
-                // PRIORITY 6: Enhanced screen resolution - ONLY for mobile/tablet
-                // CRITICAL: Desktop screen detection is UNSTABLE with DevTools (viewport changes)
-                // For desktop, we rely on hardware + display + platform for differentiation
-                // For mobile/tablet, screen is STABLE (no DevTools viewport issues)
-                screen: screen && (deviceType === "mobile" || deviceType === "tablet")
-                    ? (() => {
-                        // Use enhanced screen buckets for modern display landscape
-                        const dims = [screen.width, screen.height].sort((a, b) => b - a);
-                        const w = dims[0];
-                        const h = dims[1];
-                        // Enhanced screen bucketing based on 2024 display standards
-                        const getScreenBucket = (width, height) => {
-                            // Ultra-high resolution displays (2024: 8K, 5K, etc.)
-                            if (width >= 7680)
-                                return "8k"; // 8K displays
-                            if (width >= 5120)
-                                return "5k"; // 5K displays (iMac, etc.)
-                            if (width >= 4096)
-                                return "4k_cinema"; // Cinema 4K
-                            if (width >= 3840)
-                                return "4k_uhd"; // 4K UHD standard
-                            if (width >= 3440)
-                                return "ultrawide"; // Ultrawide QHD
-                            if (width >= 2880)
-                                return "retina_4k"; // Retina 4K/5K scaled
-                            if (width >= 2560)
-                                return "qhd"; // QHD/WQHD
-                            // Standard high-resolution displays
-                            if (width >= 2048)
-                                return "qxga"; // QXGA
-                            if (width >= 1920)
-                                return "fhd"; // Full HD 1080p
-                            if (width >= 1680)
-                                return "wsxga+"; // WSXGA+
-                            if (width >= 1600)
-                                return "uxga"; // UXGA
-                            if (width >= 1440)
-                                return "wxga++"; // WXGA++
-                            if (width >= 1366)
-                                return "hd"; // HD 720p
-                            if (width >= 1280)
-                                return "sxga"; // SXGA
-                            // Tablet and mobile displays
-                            if (width >= 1024)
-                                return "xga"; // XGA (tablets)
-                            if (width >= 768)
-                                return "svga"; // SVGA (small tablets)
-                            if (width >= 640)
-                                return "vga"; // VGA (phones)
-                            if (width >= 480)
-                                return "hvga"; // HVGA (older phones)
-                            if (width >= 320)
-                                return "qvga"; // QVGA (legacy phones)
-                            return "minimal"; // Sub-QVGA
-                        };
-                        // Enhanced aspect ratio classification for device type hints
-                        const getAspectRatioClass = (width, height) => {
-                            if (height === 0)
-                                return "unknown";
-                            const ratio = width / height;
-                            // Ultra-wide displays (gaming, productivity)
-                            if (ratio >= 3.0)
-                                return "super_ultrawide"; // 32:9+
-                            if (ratio >= 2.3)
-                                return "ultrawide"; // 21:9
-                            if (ratio >= 2.0)
-                                return "wide"; // 18:9
-                            // Standard desktop ratios
-                            if (ratio >= 1.7 && ratio <= 1.8)
-                                return "standard"; // 16:9
-                            if (ratio >= 1.6 && ratio <= 1.67)
-                                return "classic"; // 16:10, 5:3
-                            if (ratio >= 1.3 && ratio <= 1.35)
-                                return "traditional"; // 4:3
-                            // Mobile/portrait ratios
-                            if (ratio >= 0.5 && ratio <= 0.8)
-                                return "mobile_portrait"; // Phones in portrait
-                            if (ratio >= 0.4 && ratio <= 0.5)
-                                return "tall_mobile"; // Modern tall phones
-                            return "custom"; // Non-standard ratio
-                        };
-                        // Ensure w and h are valid numbers
-                        const width = w || 0;
-                        const height = h || 0;
-                        // Screen density class based on common DPR patterns
-                        const getDensityClass = (pixelRatio) => {
-                            if (!pixelRatio)
-                                return "standard";
-                            if (pixelRatio >= 3.0)
-                                return "ultra_high"; // iPhone Plus, high-end Android
-                            if (pixelRatio >= 2.0)
-                                return "high"; // Retina, standard high-DPI
-                            if (pixelRatio >= 1.5)
-                                return "medium"; // Mid-range displays
-                            if (pixelRatio >= 1.25)
-                                return "enhanced"; // Slightly enhanced DPI
-                            return "standard"; // Standard 1x displays
-                        };
-                        // CRITICAL: Do NOT include exact dimensions in stableCoreVector for mobile!
-                        // Reason: Screen dimensions change when:
-                        // - Chrome address bar appears/disappears (scroll behavior)
-                        // - Virtual keyboard opens/closes
-                        // - Screen rotates (portrait ↔ landscape)
-                        // - Browser zoom changes
-                        // These changes would cause stableCoreHash to change, breaking visitor identification
-                        //
-                        // INSTEAD: Use ONLY stable screen characteristics (bucket, aspect, density)
-                        // For device differentiation (S22 vs A54), use:
-                        // - screenFrame (bezel measurements)
-                        // - Combination of bucket + hardware + display
-                        // - Vector similarity in IdentityResolver
-                        return {
-                            bucket: getScreenBucket(width),
-                            aspectClass: getAspectRatioClass(width, height),
-                            densityClass: getDensityClass(screen.pixelRatio || window.devicePixelRatio),
-                            // 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",
-                            // ❌ REMOVED: exact dimensions (causes instability on mobile)
-                            // Device differentiation is now handled by:
-                            // 1. screenFrame (bezel measurements - stable)
-                            // 2. hardware + display combination
-                            // 3. Vector similarity in IdentityResolver
-                        };
-                    })()
-                    : {
-                        bucket: "unknown",
-                        aspectClass: "unknown",
-                        densityClass: "unknown",
-                        ratio: 0,
-                        sizeCategory: "unknown",
-                    },
+                // ❌ PRIORITY 6: Screen - REMOVED FROM stableCoreVector
+                // REASON: Screen properties are UNSTABLE across all device types:
+                //
+                // Desktop:
+                // - DevTools changes viewport (lateral vs bottom)
+                // - Browser zoom changes dimensions
+                // - Window resize changes available space
+                //
+                // Mobile:
+                // - Address bar appears/disappears on scroll
+                // - Virtual keyboard opens/closes
+                // - Screen rotation (portrait ↔ landscape)
+                // - Pull-to-refresh changes viewport
+                //
+                // RESULT: Even "bucket" detection is unreliable due to viewport changes
+                //
+                // SOLUTION: Device differentiation now relies ONLY on:
+                // 1. screenFrame (bezel measurements - MORE stable)
+                // 2. hardware (cores, memory, arch - STABLE)
+                // 3. display (color depth, gamut - STABLE)
+                // 4. platform + deviceType + ua (ULTRA-STABLE)
+                // 5. timezone + primaryLanguage (USER-STABLE)
+                //
+                // Note: screen is still collected in full fingerprint for analytics,
+                // but excluded from stableCoreHash to ensure visitor identification stability
                 // 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
@@ -6036,12 +5931,13 @@
             };
             // ADDITIONAL ENTROPY: Add a deterministic but unique component based on ultra-stable signals
             // This helps prevent collisions while maintaining deterministic behavior
+            // Note: screen removed as it's unstable (viewport changes)
             const entropyComponents = [
                 coreVector.ua || "",
                 coreVector.platform || "",
                 coreVector.deviceType || "",
-                coreVector.screen?.bucket || "",
                 coreVector.timezone || "",
+                coreVector.primaryLanguage || "",
             ].filter(Boolean);
             if (entropyComponents.length >= 3) {
                 // Create a stable entropy string from the most stable components
@@ -6066,15 +5962,18 @@
             // - Screen frame (can vary slightly)
             // - Vendor flavors (can change)
             // - Exact hardware values (use buckets)
-            // DEBUG: Log coreVector components to identify DevTools instability
+            // DEBUG: Log coreVector components for monitoring
             if (opts.debug ||
                 (typeof window !== "undefined" && window._rabbitTrackerDebug)) {
                 console.log("[RabbitTracker DEBUG] coreVector components:", {
                     ua: coreVector.ua,
                     platform: coreVector.platform,
                     deviceType: coreVector.deviceType,
-                    screenBucket: coreVector.screen?.bucket,
                     timezone: coreVector.timezone,
+                    primaryLanguage: coreVector.primaryLanguage,
+                    hasHardware: !!coreVector.hardware,
+                    hasDisplay: !!coreVector.display,
+                    hasScreenFrame: !!coreVector.screenFrame,
                     _entropy: coreVector._entropy,
                 });
             }
@@ -6120,7 +6019,10 @@
                     ua: coreVector.ua,
                     deviceType: coreVector.deviceType,
                     platform: coreVector.platform,
-                    screenBucket: coreVector.screen?.bucket,
+                    timezone: coreVector.timezone,
+                    hasScreenFrame: !!coreVector.screenFrame,
+                    hardwareClass: coreVector.hardware?.class,
+                    displayClass: coreVector.display?.class,
                     totalComponentsInHash: Object.keys(enhancedComponentValues).length,
                 });
             }