@zaplier/sdk 1.1.1 → 1.1.3

package/dist/index.cjs

@@ -5137,46 +5137,47 @@ async function collectFingerprint(options = {}) {
     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);
@@ -5184,10 +5185,10 @@ async function collectFingerprint(options = {}) {
         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",
             });
@@ -5235,7 +5236,7 @@ async function collectFingerprint(options = {}) {
                 const fallbackHardware = {
                     hardwareConcurrency: navigator.hardwareConcurrency || 0,
                     deviceMemory: navigator.deviceMemory || 0,
-                    platform: navigator.platform || 'unknown'
+                    platform: navigator.platform || "unknown",
                 };
                 fingerprintData.hardware = {
                     value: fallbackHardware,
@@ -5702,146 +5703,31 @@ async function collectFingerprint(options = {}) {
             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
@@ -6032,12 +5918,13 @@ async function collectFingerprint(options = {}) {
         };
         // 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
@@ -6062,15 +5949,19 @@ async function collectFingerprint(options = {}) {
         // - 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
@@ -6115,7 +6006,10 @@ async function collectFingerprint(options = {}) {
                 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,
             });
         }