@adstage/web-sdk 2.4.12 → 2.5.1

package/dist/index.standalone.js

@@ -28,6 +28,47 @@ var DeviceType;
     DeviceType["TABLET"] = "TABLET";
 })(DeviceType || (DeviceType = {}));
 
+/**
+ * 단순한 VIEWABLE 이벤트 중복 방지 관리 클래스
+ * - 세션당 동일 광고 1회만 VIEWABLE 이벤트 허용
+ * - 메모리 기반 추적으로 단순화
+ */
+class ViewableEventTracker {
+    /**
+     * 중복 viewable 이벤트 여부 확인
+     */
+    static isDuplicateViewable(adId, slotId, debug = false) {
+        const key = `${adId}_${slotId}`;
+        // 이미 VIEWABLE 이벤트가 발생한 광고인지 확인
+        if (ViewableEventTracker.viewableTracker.has(key)) {
+            if (debug) {
+                console.log(`Duplicate viewable blocked for ad ${adId} in slot ${slotId}`);
+            }
+            return true;
+        }
+        // 새로운 VIEWABLE 이벤트 기록
+        ViewableEventTracker.viewableTracker.add(key);
+        if (debug) {
+            console.log(`✅ New viewable recorded for ad ${adId} in slot ${slotId}`);
+        }
+        return false;
+    }
+    /**
+     * 모든 추적 데이터 정리 (디버그용)
+     */
+    static clear() {
+        ViewableEventTracker.viewableTracker.clear();
+    }
+    /**
+     * 특정 광고의 viewable 추적 초기화 (디버그용)
+     */
+    static clearAdViewable(adId, slotId) {
+        const key = `${adId}_${slotId}`;
+        ViewableEventTracker.viewableTracker.delete(key);
+    }
+}
+ViewableEventTracker.viewableTracker = new Set();
+
 /**
  * SSR 안전한 DOM API 래퍼 클래스
  * 서버사이드 렌더링 환경에서 DOM API 접근 시 오류를 방지합니다.
@@ -449,6 +490,18 @@ class ApiHeaders {
     }
 }
 
+/**
+ * AdStage SDK - 버전 정보 유틸리티
+ */
+// package.json에서 버전 정보 가져오기 (빌드 시 자동으로 교체됨)
+const SDK_VERSION$1 = '"2.5.1"';
+/**
+ * SDK 버전 정보 반환
+ */
+function getSDKVersion() {
+    return SDK_VERSION$1;
+}
+
 /**
  * 광고 이벤트 추적 관리 클래스
  * - 광고 전용 이벤트 추적 및 전송
@@ -463,24 +516,32 @@ class AdvertisementEventTracker {
         this.slots = slots;
     }
     /**
-     * 광고 이벤트 추적 - viewability 데이터 지원
+     * 광고 이벤트 추적 - 단순화된 viewable 처리
      */
-    async trackAdvertisementEvent(adId, slotId, eventType, additionalData) {
+    async trackAdvertisementEvent(adId, slotId, eventType) {
         try {
             if (this.debug) {
                 console.log(`🚀 AdvertisementEventTracker: Processing ${eventType} event for ad ${adId} in slot ${slotId}`);
             }
+            // VIEWABLE 이벤트 중복 확인
+            if (eventType === AdEventType.VIEWABLE) {
+                if (ViewableEventTracker.isDuplicateViewable(adId, slotId, this.debug)) {
+                    if (this.debug) {
+                        console.log(`⏭️ Skipping duplicate viewable event for ad ${adId} in slot ${slotId}`);
+                    }
+                    return;
+                }
+            }
             // 현재 슬롯 정보 가져오기
             const slot = this.slots.get(slotId);
             // 디바이스 정보 수집
             const deviceInfo = DeviceInfoCollector.collectDeviceInfo();
-            // 광고 이벤트 데이터 구성 (DTO 구조에 맞춤)
-            // 서버에서 자동 설정: orgId (API 키로부터), advertisementId, action (URL 파라미터로부터)
+            // 광고 이벤트 데이터 구성 (단순화됨)
             const eventData = {
                 // 필수 필드들 (DTO 검증용)
                 adType: slot?.adType || 'BANNER',
                 platform: deviceInfo.platform,
-                deviceId: deviceInfo.deviceId, // DTO 검증을 위해 deviceId 직접 전송
+                deviceId: deviceInfo.deviceId,
                 // 디바이스 정보는 deviceInfo 객체로 래핑
                 deviceInfo: deviceInfo,
                 // 페이지 및 슬롯 정보
@@ -497,23 +558,13 @@ class AdvertisementEventTracker {
                 // 추가 메타데이터
                 metadata: {
                     eventType,
-                    sdkVersion: '1.0.0',
+                    sdkVersion: getSDKVersion(),
                     timestamp: Date.now(),
                 },
-                // viewable 관련 추가 데이터 (DTO 필드명과 매칭)
-                ...(additionalData?.viewabilityMetrics && {
-                    isViewable: additionalData.viewabilityMetrics.isViewable,
-                    exposureTime: additionalData.viewabilityMetrics.exposureTime,
-                    maxVisibilityRatio: additionalData.viewabilityMetrics.maxVisibilityRatio,
-                    firstViewableTime: additionalData.viewabilityMetrics.firstViewableTime,
-                    // IAB 표준 준수 여부
-                    iabCompliant: additionalData.viewabilityMetrics.isViewable,
-                }),
-                // fraud 관련 데이터 (DTO 필드명과 매칭)
-                ...(additionalData?.fraudScore !== undefined && {
-                    fraudScore: additionalData.fraudScore,
-                    fraudReasons: additionalData.fraudReasons,
-                    riskLevel: additionalData.riskLevel,
+                // VIEWABLE 이벤트의 경우 단순한 플래그만 설정
+                ...(eventType === AdEventType.VIEWABLE && {
+                    isViewable: true,
+                    iabCompliant: true, // 50% 노출 기준으로 단순 판정
                 }),
             };
             const url = `${this.baseUrl}/advertisements/events/${adId}/${eventType}`;
@@ -565,56 +616,15 @@ class AdvertisementEventTracker {
 }
 
 /**
- * IAB 표준 준수 viewable impression 측정
+ * 단순한 광고 노출 추적 (50% 노출시 즉시 VIEWABLE 이벤트)
  */
-// 광고 타입별 IAB 표준 설정
-const VIEWABILITY_STANDARDS = {
-    BANNER: {
-        threshold: 0.5,
-        minDuration: 1000,
-        maxMeasureTime: 30000
-    },
-    VIDEO: {
-        threshold: 0.5,
-        minDuration: 2000,
-        maxMeasureTime: 60000
-    },
-    NATIVE: {
-        threshold: 0.5,
-        minDuration: 1000,
-        maxMeasureTime: 30000
-    },
-    INTERSTITIAL: {
-        threshold: 0.5,
-        minDuration: 1000,
-        maxMeasureTime: 10000
-    },
-    TEXT: {
-        threshold: 0.5,
-        minDuration: 1000,
-        maxMeasureTime: 30000
-    },
-    POPUP: {
-        threshold: 0.5,
-        minDuration: 1000,
-        maxMeasureTime: 10000
-    }
-};
-class ViewabilityTracker {
-    constructor(element, adType, onViewable) {
+class SimpleViewabilityTracker {
+    constructor(element, onViewable) {
         this.observer = null;
-        this.viewabilityTimer = null;
-        this.maxVisibilityTimer = null;
-        this.startTime = 0;
-        this.maxVisibilityRatio = 0;
-        this.firstViewableTime = null;
-        this.isViewableAchieved = false;
+        this.isViewableTriggered = false;
         this.element = element;
-        this.config = VIEWABILITY_STANDARDS[adType] || VIEWABILITY_STANDARDS.BANNER;
         this.onViewableCallback = onViewable;
-        this.startTime = performance.now();
         this.initIntersectionObserver();
-        this.initMaxMeasureTimer();
     }
     initIntersectionObserver() {
         // IntersectionObserver 지원 확인
@@ -623,83 +633,28 @@ class ViewabilityTracker {
             return;
         }
         this.observer = new IntersectionObserver((entries) => this.handleIntersection(entries), {
-            threshold: [0, 0.1, 0.25, 0.5, 0.75, 1.0],
+            threshold: 0.5, // 50% 노출
             rootMargin: '0px'
         });
         this.observer.observe(this.element);
     }
     handleIntersection(entries) {
         entries.forEach(entry => {
-            const visibilityRatio = entry.intersectionRatio;
-            const isVisible = this.isDocumentVisible();
-            // 최대 가시성 비율 추적
-            this.maxVisibilityRatio = Math.max(this.maxVisibilityRatio, visibilityRatio);
-            // Viewable 조건 확인 (50% 이상 + 문서 가시성)
-            if (visibilityRatio >= this.config.threshold && isVisible) {
-                this.startViewabilityTimer();
-            }
-            else {
-                this.stopViewabilityTimer();
+            // 50% 이상 노출되고 문서가 가시상태이며 아직 트리거되지 않은 경우
+            if (entry.intersectionRatio >= 0.5 &&
+                this.isDocumentVisible() &&
+                !this.isViewableTriggered) {
+                this.isViewableTriggered = true;
+                if (this.onViewableCallback) {
+                    this.onViewableCallback();
+                }
             }
         });
     }
     isDocumentVisible() {
-        // 단순한 문서 가시성 확인
         return !document.hidden && document.visibilityState === 'visible';
     }
-    startViewabilityTimer() {
-        if (this.viewabilityTimer || this.isViewableAchieved)
-            return;
-        if (this.firstViewableTime === null) {
-            this.firstViewableTime = performance.now();
-        }
-        this.viewabilityTimer = setTimeout(() => {
-            this.onViewabilityAchieved();
-        }, this.config.minDuration);
-    }
-    stopViewabilityTimer() {
-        if (this.viewabilityTimer) {
-            clearTimeout(this.viewabilityTimer);
-            this.viewabilityTimer = null;
-        }
-    }
-    initMaxMeasureTimer() {
-        // 최대 측정 시간 후 자동 종료
-        this.maxVisibilityTimer = setTimeout(() => {
-            this.destroy();
-        }, this.config.maxMeasureTime);
-    }
-    onViewabilityAchieved() {
-        if (this.isViewableAchieved)
-            return;
-        this.isViewableAchieved = true;
-        const metrics = this.calculateMetrics();
-        if (this.onViewableCallback) {
-            this.onViewableCallback(metrics);
-        }
-    }
-    calculateMetrics() {
-        const currentTime = performance.now();
-        const exposureTime = this.firstViewableTime
-            ? currentTime - this.firstViewableTime
-            : 0;
-        return {
-            isViewable: this.isViewableAchieved,
-            exposureTime,
-            maxVisibilityRatio: this.maxVisibilityRatio,
-            firstViewableTime: this.firstViewableTime,
-            measureStartTime: this.startTime,
-        };
-    }
-    getMetrics() {
-        return this.calculateMetrics();
-    }
     destroy() {
-        this.stopViewabilityTimer();
-        if (this.maxVisibilityTimer) {
-            clearTimeout(this.maxVisibilityTimer);
-            this.maxVisibilityTimer = null;
-        }
         if (this.observer) {
             this.observer.disconnect();
             this.observer = null;
@@ -707,155 +662,6 @@ class ViewabilityTracker {
     }
 }
 
-/**
- * BasicFraudDetector - 현실적 구현 버전
- * 기본적인 봇 탐지 및 간단한 행동 패턴 분석
- */
-class BasicFraudDetector {
-    constructor() {
-        this.mouseEvents = 0;
-        this.keyboardEvents = 0;
-        this.scrollEvents = 0;
-        this.startTime = Date.now();
-        this.initBasicTracking();
-    }
-    initBasicTracking() {
-        // 기본적인 사용자 상호작용 추적
-        document.addEventListener('mousemove', () => this.mouseEvents++, { passive: true });
-        document.addEventListener('keydown', () => this.keyboardEvents++, { passive: true });
-        document.addEventListener('scroll', () => this.scrollEvents++, { passive: true });
-    }
-    calculateFraudScore() {
-        let score = 0;
-        const reasons = [];
-        // 1. 웹드라이버 탐지 (기본)
-        if (this.detectWebDriver()) {
-            score += 50;
-            reasons.push('WebDriver detected');
-        }
-        // 2. 헤드리스 브라우저 기본 탐지
-        if (this.detectBasicHeadless()) {
-            score += 40;
-            reasons.push('Headless browser signatures');
-        }
-        // 3. 사용자 상호작용 부족
-        const sessionTime = Date.now() - this.startTime;
-        if (sessionTime > 5000) { // 5초 이상 경과
-            if (this.mouseEvents === 0) {
-                score += 20;
-                reasons.push('No mouse interaction');
-            }
-            if (this.scrollEvents === 0 && sessionTime > 10000) {
-                score += 15;
-                reasons.push('No scroll activity');
-            }
-        }
-        // 4. 브라우저 환경 이상 징후
-        const browserCheck = this.checkBrowserEnvironment();
-        score += browserCheck.score;
-        reasons.push(...browserCheck.reasons);
-        // 5. 시간 패턴 이상 (너무 빠른 페이지 로드 후 즉시 클릭)
-        if (sessionTime < 1000) {
-            score += 25;
-            reasons.push('Suspiciously fast interaction');
-        }
-        const finalScore = Math.min(score, 100);
-        return {
-            score: finalScore,
-            riskLevel: this.getRiskLevel(finalScore),
-            reasons: reasons
-        };
-    }
-    detectWebDriver() {
-        // 기본적인 웹드라이버 탐지
-        return !!(window.webdriver ||
-            navigator.webdriver ||
-            window.__webdriver_evaluate ||
-            window.__selenium_evaluate ||
-            window.__webdriver_script_function ||
-            window.__webdriver_script_func ||
-            window.__webdriver_script_fn ||
-            window.__fxdriver_evaluate ||
-            window.__driver_unwrapped ||
-            window.__webdriver_unwrapped ||
-            window.__driver_evaluate ||
-            window.__selenium_unwrapped ||
-            window.__fxdriver_unwrapped);
-    }
-    detectBasicHeadless() {
-        const signatures = [];
-        // PhantomJS 탐지
-        if (window._phantom || window.phantom) {
-            signatures.push('PhantomJS');
-        }
-        // Chrome headless 기본 탐지
-        if (navigator.userAgent.includes('HeadlessChrome')) {
-            signatures.push('Chrome Headless');
-        }
-        // 플러그인 없음 (일반적이지 않음)
-        if (navigator.plugins.length === 0) {
-            signatures.push('No plugins');
-        }
-        return signatures.length > 0;
-    }
-    checkBrowserEnvironment() {
-        let score = 0;
-        const reasons = [];
-        // 언어 설정 이상
-        if (!navigator.language || navigator.language === 'C') {
-            score += 10;
-            reasons.push('Unusual language setting');
-        }
-        // 쿠키 비활성화
-        if (!navigator.cookieEnabled) {
-            score += 15;
-            reasons.push('Cookies disabled');
-        }
-        // 화면 해상도 이상
-        if (screen.width === 0 || screen.height === 0) {
-            score += 20;
-            reasons.push('Invalid screen resolution');
-        }
-        // 시간대 정보 없음
-        try {
-            const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-            if (!timezone || timezone === 'UTC') {
-                score += 5;
-                reasons.push('No timezone info');
-            }
-        }
-        catch (e) {
-            score += 10;
-            reasons.push('Timezone detection failed');
-        }
-        return { score, reasons };
-    }
-    getRiskLevel(score) {
-        if (score >= 70)
-            return 'CRITICAL';
-        if (score >= 50)
-            return 'HIGH';
-        if (score >= 30)
-            return 'MEDIUM';
-        return 'LOW';
-    }
-    getBrowserInfo() {
-        return {
-            userAgent: navigator.userAgent,
-            language: navigator.language,
-            platform: navigator.platform,
-            cookieEnabled: navigator.cookieEnabled,
-            doNotTrack: navigator.doNotTrack,
-            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-            screenResolution: `${screen.width}x${screen.height}`,
-            viewportSize: `${window.innerWidth}x${window.innerHeight}`
-        };
-    }
-    destroy() {
-        // 이벤트 리스너 정리는 생략 (메모리 누수 방지를 위해 필요시 구현)
-    }
-}
-
 /**
  * AdStage SDK 엔드포인트 상수 관리
  * 모든 API URL을 중앙에서 관리
@@ -1559,10 +1365,8 @@ class CarouselSliderManager {
                     }
                 });
             }
-            // 현재 슬라이드의 광고에 대해 노출 이벤트 추적
-            if (actualIndex > 0) { // 첫 번째는 이미 loadSlot에서 추적됨
-                trackEventCallback(advertisements[actualIndex]._id, slot.id, AdEventType.VIEWABLE);
-            }
+            // 현재 슬라이드의 광고에 대해 노출 이벤트 추적 (모든 슬라이드 포함)
+            trackEventCallback(advertisements[actualIndex]._id, slot.id, AdEventType.VIEWABLE);
         };
         // 무한 루프 처리 함수
         const handleInfiniteLoop = () => {
@@ -1604,8 +1408,12 @@ class CarouselSliderManager {
         if (dotContainer) {
             sliderWrapper.appendChild(dotContainer);
         }
-        // 첫 번째 도트 활성화
+        // 첫 번째 도트 활성화 및 초기 VIEWABLE 이벤트 발생
         moveToSlide(0);
+        // 슬라이더 DOM 추가 후 첫 번째 광고 VIEWABLE 이벤트 트리거 (500ms 후 실제 노출 확인)
+        setTimeout(() => {
+            trackEventCallback(advertisements[0]._id, slot.id, AdEventType.VIEWABLE);
+        }, 500);
         // 사용자가 크기를 지정하지 않은 경우, 첫 번째 슬라이드 크기에 맞춰 래퍼 크기 동적 조정
         if (!slot.width || slot.width === 0) {
             // DOM 렌더링 후 크기 측정
@@ -1946,113 +1754,6 @@ class TextTransitionManager {
     }
 }
 
-/**
- * VIEWABLE 이벤트 추적 및 중복 방지 관리 클래스
- * - 메모리 기반 중복 확인
- * - 세션 스토리지 기반 영구 추적
- * - 자동 정리 기능
- * - ViewabilityTracker와 함께 사용하여 중복 viewable 이벤트 방지
- */
-class ViewableEventTracker {
-    /**
-     * 중복 viewable 이벤트 여부 확인
-     */
-    static isDuplicateViewable(adId, slotId, debug = false) {
-        const key = `${adId}_${slotId}`;
-        const now = Date.now();
-        // 디버그 모드에 따른 쿨다운 시간 결정
-        const cooldownTime = debug ?
-            ViewableEventTracker.VIEWABLE_COOLDOWN_DEBUG :
-            ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION;
-        // 메모리 기반 중복 확인 (새로고침 시 초기화됨)
-        const lastViewable = ViewableEventTracker.viewableTracker.get(key);
-        if (lastViewable && (now - lastViewable) < cooldownTime) {
-            if (debug) {
-                console.log(`Duplicate viewable blocked for ad ${adId} in slot ${slotId}. Cooldown: ${Math.round((cooldownTime - (now - lastViewable)) / 1000)}s remaining (${debug ? 'debug' : 'production'} mode)`);
-            }
-            return true;
-        }
-        // 세션 스토리지 기반 중복 확인 (새로고침 시에도 유지)
-        const sessionKey = `adstage_viewable_${key}`;
-        const sessionViewable = sessionStorage.getItem(sessionKey);
-        if (sessionViewable) {
-            const sessionTime = parseInt(sessionViewable, 10);
-            if (!isNaN(sessionTime) && (now - sessionTime) < cooldownTime) {
-                if (debug) {
-                    console.log(`Session-based duplicate viewable blocked for ad ${adId} in slot ${slotId}. Cooldown: ${Math.round((cooldownTime - (now - sessionTime)) / 1000)}s remaining (${debug ? 'debug' : 'production'} mode)`);
-                }
-                // 메모리에도 기록하여 이후 요청 최적화
-                ViewableEventTracker.viewableTracker.set(key, sessionTime);
-                return true;
-            }
-        }
-        // viewable 이벤트 시점 기록 (메모리 + 세션 스토리지)
-        ViewableEventTracker.viewableTracker.set(key, now);
-        sessionStorage.setItem(sessionKey, now.toString());
-        // 오래된 세션 스토리지 데이터 정리 (선택적)
-        ViewableEventTracker.cleanupOldViewables();
-        if (debug) {
-            console.log(`✅ New viewable recorded for ad ${adId} in slot ${slotId} (${debug ? 'debug' : 'production'} mode)`);
-        }
-        return false;
-    }
-    /**
-     * 오래된 viewable 추적 데이터 정리
-     */
-    static cleanupOldViewables() {
-        const now = Date.now();
-        // 프로덕션 쿨다운의 2배 시간이 지난 데이터 정리
-        const cleanupThreshold = ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION * 2;
-        // 세션 스토리지 정리
-        for (let i = 0; i < sessionStorage.length; i++) {
-            const key = sessionStorage.key(i);
-            if (key && key.startsWith('adstage_viewable_')) {
-                const timestamp = sessionStorage.getItem(key);
-                if (timestamp) {
-                    const time = parseInt(timestamp, 10);
-                    if (!isNaN(time) && (now - time) > cleanupThreshold) {
-                        sessionStorage.removeItem(key);
-                        i--; // 인덱스 조정
-                    }
-                }
-            }
-        }
-        // 메모리 정리
-        for (const [key, timestamp] of ViewableEventTracker.viewableTracker.entries()) {
-            if ((now - timestamp) > cleanupThreshold) {
-                ViewableEventTracker.viewableTracker.delete(key);
-            }
-        }
-    }
-    /**
-     * 모든 추적 데이터 정리 (디버그용)
-     */
-    static clear() {
-        ViewableEventTracker.viewableTracker.clear();
-        // 세션 스토리지에서도 adstage_viewable_ 키들 제거
-        const keysToRemove = [];
-        for (let i = 0; i < sessionStorage.length; i++) {
-            const key = sessionStorage.key(i);
-            if (key && key.startsWith('adstage_viewable_')) {
-                keysToRemove.push(key);
-            }
-        }
-        keysToRemove.forEach(key => sessionStorage.removeItem(key));
-    }
-    /**
-     * 특정 광고의 viewable 추적 초기화 (디버그용)
-     */
-    static clearAdViewable(adId, slotId) {
-        const key = `${adId}_${slotId}`;
-        ViewableEventTracker.viewableTracker.delete(key);
-        const sessionKey = `adstage_viewable_${key}`;
-        sessionStorage.removeItem(sessionKey);
-    }
-}
-ViewableEventTracker.viewableTracker = new Map();
-ViewableEventTracker.VIEWABLE_COOLDOWN_PRODUCTION = 300000; // 5분 쿨다운 (프로덕션)
-ViewableEventTracker.VIEWABLE_COOLDOWN_DEBUG = 30000; // 30초 쿨다운 (디버그)
-
 /**
  * AdRenderer - 광고 렌더링 전용 클래스
  * AdsModule에서 렌더링 관련 기능을 분리
@@ -2248,7 +1949,7 @@ class AdRenderer {
                     if (this.debug) {
                         console.log(`🔄 Starting advertisement event tracking: ${eventType} for ad ${adId} in slot ${slotId}`);
                     }
-                    await this.advertisementEventTracker.trackAdvertisementEvent(adId, slotId, eventType, {});
+                    await this.advertisementEventTracker.trackAdvertisementEvent(adId, slotId, eventType);
                     if (this.debug) {
                         console.log(`📊 Advertisement event tracked: ${eventType} for ad ${adId} in slot ${slotId}`);
                     }
@@ -2804,14 +2505,10 @@ class AdsModule {
         if (!slot) {
             throw new Error(`Ad slot not found: ${slotId}`);
         }
-        // ViewabilityTracker 정리
+        // SimpleViewabilityTracker 정리
         if (slot.viewabilityTracker) {
             slot.viewabilityTracker.destroy();
         }
-        // BasicFraudDetector 정리
-        if (slot.fraudDetector) {
-            slot.fraudDetector.destroy();
-        }
         // DOM에서 제거
         const container = document.getElementById(slot.containerId);
         if (container) {
@@ -2881,19 +2578,6 @@ class AdsModule {
         }
         return slotId;
     }
-    // createAdSlot 제거: AdRenderer.createPlaceholder 사용
-    /**
-     * 여러 광고의 최적 컨테이너 크기 계산 (동적 크기 조정)
-     */
-    // calculateOptimalContainerSize 제거: AdRenderer.calculateOptimalContainerSize 사용
-    /**
-     * 최적 크기 조정 전략 선택
-     */
-    // selectOptimalSizeStrategy 제거: AdRenderer 내부 구현 사용
-    /**
-     * 전략에 따른 최적 높이 계산
-     */
-    // calculateOptimalHeight 제거: AdRenderer 내부 구현 사용
     /**
      * 백그라운드에서 광고 콘텐츠 로드
      */
@@ -2912,11 +2596,9 @@ class AdsModule {
             // 광고가 여러 개이거나 autoSlide 옵션이 있으면 슬라이더로 렌더링
             if (adstageData.length > 1 || slot.config?.autoSlide) {
                 await this.adRenderer?.renderAdSlider(slot, adstageData);
-                // 🔧 슬라이더의 첫 번째 광고도 자동 viewability 추적 시작
-                if (adstageData.length > 0) {
-                    setTimeout(() => {
-                        this.startBasicViewabilityTracking(slot, adstageData[0]);
-                    }, 100); // 슬라이더 렌더링 완료 후 추적 시작
+                // 🔧 슬라이더는 CarouselSliderManager에서 자체적으로 모든 광고의 VIEWABLE 이벤트를 처리
+                if (this._config?.debug) {
+                    console.log(`🎠 Slider will handle VIEWABLE events for ${adstageData.length} ads automatically`);
                 }
             }
             else {
@@ -2924,7 +2606,7 @@ class AdsModule {
                 slot.advertisement = adstageData[0];
                 await this.adRenderer?.renderAdElement(slot, adstageData[0]);
                 // ✅ 신규: Viewable impression 추적 시작 (기존 즉시 추적 대신)
-                this.startBasicViewabilityTracking(slot, adstageData[0]);
+                this.startSimpleViewabilityTracking(slot, adstageData[0]);
             }
             slot.isLoaded = true;
             if (this._config?.debug) {
@@ -2941,9 +2623,9 @@ class AdsModule {
      */
     // optimizeContainerForBannerAds 제거: AdRenderer.optimizeContainerForBannerAds 사용
     /**
-     * 기본 viewability 추적 시작 (재시도 로직 포함)
+     * 단순한 노출 추적 시작 (재시도 로직 포함)
      */
-    startBasicViewabilityTracking(slot, ad) {
+    startSimpleViewabilityTracking(slot, ad) {
         const tryStartTracking = (retryCount = 0) => {
             const element = document.getElementById(slot.id);
             if (!element) {
@@ -2959,44 +2641,28 @@ class AdsModule {
                 }
                 return;
             }
-            // 기본 fraud 검사
-            const fraudDetector = new BasicFraudDetector();
-            // viewability 추적
-            const tracker = new ViewabilityTracker(element, slot.adType, async (metrics) => {
-                await this.handleViewableEvent(ad, slot, metrics, fraudDetector);
+            // 단순한 노출 추적
+            const tracker = new SimpleViewabilityTracker(element, async () => {
+                await this.handleViewableEvent(ad, slot);
             });
             // 정리를 위해 저장
             slot.viewabilityTracker = tracker;
-            slot.fraudDetector = fraudDetector;
             if (this._config?.debug) {
-                console.log(`🎯 Viewability tracking started for slot: ${slot.id} (element found)`);
+                console.log(`🎯 Simple viewability tracking started for slot: ${slot.id} (element found)`);
             }
         };
         tryStartTracking();
     }
     /**
-     * Viewable 이벤트 처리
+     * Viewable 이벤트 처리 (단순화됨)
      */
-    async handleViewableEvent(ad, slot, metrics, fraudDetector) {
+    async handleViewableEvent(ad, slot) {
         try {
-            const fraudScore = fraudDetector.calculateFraudScore();
-            // 높은 위험도면 차단
-            if (fraudScore.riskLevel === 'CRITICAL') {
-                if (this._config?.debug) {
-                    console.warn(`🚫 Viewable blocked due to fraud risk: ${fraudScore.score}`, fraudScore.reasons);
-                }
-                return;
-            }
             // VIEWABLE 이벤트 전송
             if (this.advertisementEventTracker) {
-                await this.advertisementEventTracker.trackAdvertisementEvent(ad._id, slot.id, AdEventType.VIEWABLE, {
-                    viewabilityMetrics: metrics,
-                    fraudScore: fraudScore.score,
-                    fraudReasons: fraudScore.reasons,
-                    riskLevel: fraudScore.riskLevel
-                });
+                await this.advertisementEventTracker.trackAdvertisementEvent(ad._id, slot.id, AdEventType.VIEWABLE);
                 if (this._config?.debug) {
-                    console.log(`✅ Viewable impression tracked for ad ${ad._id} (fraud score: ${fraudScore.score})`);
+                    console.log(`✅ Simple viewable impression tracked for ad ${ad._id}`);
                 }
             }
         }
@@ -3004,14 +2670,6 @@ class AdsModule {
             console.error(`❌ Failed to track viewable impression:`, error);
         }
     }
-    /**
-     * Fallback 광고 렌더링 - AdStage 확실한 컨테이너 우선 탐지
-     */
-    // renderFallback 제거: AdRenderer.renderFallback 사용
-    /**
-     * 빈 컨테이너 생성 (컨테이너를 찾지 못한 경우)
-     */
-    // createEmptyContainer 제거: AdRenderer 내부 구현 사용
     /**
      * 광고 데이터 가져오기
      */
@@ -3071,18 +2729,6 @@ class AdsModule {
         }
         return advertisements;
     }
-    /**
-     * 광고 슬라이더 렌더링 (여러 광고 또는 autoSlide 옵션)
-     */
-    // renderAdSlider 제거: AdRenderer.renderAdSlider 사용
-    /**
-     * 광고 렌더링 (단일 광고용)
-     */
-    // renderAd 제거: AdRenderer.renderAd 사용
-    /**
-     * 광고 요소 렌더링 (기본 구현)
-     */
-    // renderAdElement 제거: AdRenderer.renderAdElement 사용
     /**
      * 광고 슬롯 새로고침
      */