@zaplier/sdk 1.1.1 → 1.1.3

package/dist/sdk.js

@@ -5139,46 +5139,47 @@
         const parallelTasks = [];
         // Group 1: Independent rendering components (can run in parallel)
         if (shouldIncludeComponent("canvas", opts) && isCanvasAvailable$1()) {
-            parallelTasks.push(collectComponent("canvas", getCanvasFingerprint, opts).then(result => ({
+            parallelTasks.push(collectComponent("canvas", getCanvasFingerprint, opts).then((result) => ({
                 component: "canvas",
-                result
+                result,
             })));
         }
         if (shouldIncludeComponent("webgl", opts) && isWebGLAvailable()) {
-            parallelTasks.push(collectComponent("webgl", getWebGLFingerprint, opts).then(result => ({
+            parallelTasks.push(collectComponent("webgl", getWebGLFingerprint, opts).then((result) => ({
                 component: "webgl",
-                result
+                result,
             })));
         }
         if (shouldIncludeComponent("audio", opts) && isAudioAvailable()) {
-            parallelTasks.push(collectComponent("audio", getAudioFingerprint, opts).then(result => ({
+            parallelTasks.push(collectComponent("audio", getAudioFingerprint, opts).then((result) => ({
                 component: "audio",
-                result
+                result,
             })));
         }
         // Group 2: Fast synchronous components (can run in parallel)
         if (shouldIncludeComponent("fonts", opts) && isFontDetectionAvailable()) {
-            parallelTasks.push(collectComponent("fonts", () => getFontFingerprint(!opts.gdprMode), opts).then(result => ({
+            parallelTasks.push(collectComponent("fonts", () => getFontFingerprint(!opts.gdprMode), opts).then((result) => ({
                 component: "fonts",
-                result
+                result,
             })));
         }
         if (shouldIncludeComponent("screen", opts) && isScreenAvailable()) {
-            parallelTasks.push(collectComponent("screen", getScreenFingerprint, opts).then(result => ({
+            parallelTasks.push(collectComponent("screen", getScreenFingerprint, opts).then((result) => ({
                 component: "screen",
-                result
+                result,
             })));
         }
-        if (shouldIncludeComponent("browser", opts) && isBrowserFingerprintingAvailable()) {
-            parallelTasks.push(collectComponent("browser", getBrowserFingerprint, opts).then(result => ({
+        if (shouldIncludeComponent("browser", opts) &&
+            isBrowserFingerprintingAvailable()) {
+            parallelTasks.push(collectComponent("browser", getBrowserFingerprint, opts).then((result) => ({
                 component: "browser",
-                result
+                result,
             })));
         }
         // Execute all parallel tasks and handle results
         const parallelResults = await Promise.allSettled(parallelTasks);
         parallelResults.forEach((promiseResult, index) => {
-            if (promiseResult.status === 'fulfilled' && promiseResult.value.result) {
+            if (promiseResult.status === "fulfilled" && promiseResult.value.result) {
                 const { component, result } = promiseResult.value;
                 fingerprintData[component] = result;
                 collectedComponents.push(component);
@@ -5186,10 +5187,10 @@
             else {
                 // Extract component name from the corresponding task
                 const taskComponent = parallelTasks[index];
-                const componentName = taskComponent?.toString().match(/component: "(\w+)"/)?.[1] || 'unknown';
+                const componentName = taskComponent?.toString().match(/component: "(\w+)"/)?.[1] || "unknown";
                 failedComponents.push({
                     component: componentName,
-                    error: promiseResult.status === 'rejected'
+                    error: promiseResult.status === "rejected"
                         ? promiseResult.reason?.message || "Promise rejected"
                         : "Collection failed or timeout",
                 });
@@ -5237,7 +5238,7 @@
                     const fallbackHardware = {
                         hardwareConcurrency: navigator.hardwareConcurrency || 0,
                         deviceMemory: navigator.deviceMemory || 0,
-                        platform: navigator.platform || 'unknown'
+                        platform: navigator.platform || "unknown",
                     };
                     fingerprintData.hardware = {
                         value: fallbackHardware,
@@ -5704,146 +5705,31 @@
                 platform: (browser?.platform || "unknown").toLowerCase(),
                 // PRIORITY 5: Device type (critical for differentiation, ultra-stable)
                 deviceType,
-                // PRIORITY 6: Enhanced screen resolution with exact dimensions for mobile differentiation
-                // For mobile devices, we NEED exact dimensions to differentiate between similar models (S22 vs A54)
-                // For desktop, bucketing is sufficient as hardware varies more
-                screen: screen
-                    ? (() => {
-                        // 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
@@ -6034,12 +5920,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
@@ -6064,15 +5951,19 @@
             // - Screen frame (can vary slightly)
             // - Vendor flavors (can change)
             // - Exact hardware values (use buckets)
-            // DEBUG: Log coreVector components to identify DevTools instability
-            if (opts.debug || (typeof window !== 'undefined' && window._rabbitTrackerDebug)) {
-                console.log('[RabbitTracker DEBUG] coreVector components:', {
+            // 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,
-                    _entropy: coreVector._entropy
+                    primaryLanguage: coreVector.primaryLanguage,
+                    hasHardware: !!coreVector.hardware,
+                    hasDisplay: !!coreVector.display,
+                    hasScreenFrame: !!coreVector.screenFrame,
+                    _entropy: coreVector._entropy,
                 });
             }
             // Generate ultra-stable hash with additional collision resistance
@@ -6117,7 +6008,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,
                 });
             }