@adstage/web-sdk 2.4.11 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adstage/web-sdk",
-  "version": "2.4.11",
+  "version": "2.5.0",
   "description": "AdStage Web SDK - Production-ready marketing platform SDK with React Provider support for seamless integration",
   "type": "module",
   "main": "dist/index.cjs.js",

package/src/managers/ads/advertisement-event-tracker.ts

@@ -4,7 +4,7 @@ import { ViewableEventTracker } from './viewable-event-tracker';
 import { DeviceInfoCollector } from '../device-info-collector';
 import { DOMUtils } from '../../utils/dom-utils';
 import { ApiHeaders } from '../../utils/api-headers';
-import type { ViewabilityMetrics } from './viewability-tracker';
+import { getSDKVersion } from '../../utils/version';
 
 /**
  * 광고 이벤트 추적 관리 클래스
@@ -26,41 +26,44 @@ export class AdvertisementEventTracker {
   }
 
   /**
-   * 광고 이벤트 추적 - viewability 데이터 지원
+   * 광고 이벤트 추적 - 단순화된 viewable 처리
    */
   async trackAdvertisementEvent(
     adId: string, 
     slotId: string, 
-    eventType: AdEventType,
-    additionalData?: {
-      viewabilityMetrics?: ViewabilityMetrics;
-      fraudScore?: number;
-      fraudReasons?: string[];
-      riskLevel?: string;
-    }
+    eventType: AdEventType
   ): Promise<void> {
     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 직접 전송
-          
-          // 디바이스 정보는 deviceInfo 객체로 래핑
-          deviceInfo: deviceInfo,
+      // 광고 이벤트 데이터 구성 (단순화됨)
+      const eventData = {
+        // 필수 필드들 (DTO 검증용)
+        adType: slot?.adType || 'BANNER',
+        platform: deviceInfo.platform,
+        deviceId: deviceInfo.deviceId,
         
+        // 디바이스 정보는 deviceInfo 객체로 래핑
+        deviceInfo: deviceInfo,
+      
         // 페이지 및 슬롯 정보
         pageUrl: DOMUtils.getPageInfo().url,
         pageTitle: DOMUtils.getPageInfo().title,
@@ -77,29 +80,17 @@ export 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}`;
       const headers = ApiHeaders.createForEvents(this.apiKey, eventData);
       

package/src/managers/ads/viewability-tracker.ts

@@ -1,80 +1,21 @@
 /**
- * IAB 표준 준수 viewable impression 측정
+ * 단순한 광고 노출 추적 (50% 노출시 즉시 VIEWABLE 이벤트)
  */
 
-export interface ViewabilityConfig {
-  threshold: number;        // 노출 비율 (0.5 = 50%)
-  minDuration: number;      // 최소 지속 시간 (ms)
-  maxMeasureTime: number;   // 최대 측정 시간 (ms)
-}
-
-export interface ViewabilityMetrics {
-  isViewable: boolean;
-  exposureTime: number;
-  maxVisibilityRatio: number;
-  firstViewableTime: number | null;
-  measureStartTime: number;
-}
-
-// 광고 타입별 IAB 표준 설정
-export const VIEWABILITY_STANDARDS: Record<string, ViewabilityConfig> = {
-  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
-  }
-};
-
-export class ViewabilityTracker {
-  private config: ViewabilityConfig;
+export class SimpleViewabilityTracker {
   private element: HTMLElement;
   private observer: IntersectionObserver | null = null;
-  private viewabilityTimer: NodeJS.Timeout | null = null;
-  private maxVisibilityTimer: NodeJS.Timeout | null = null;
-  private startTime: number = 0;
-  private maxVisibilityRatio: number = 0;
-  private firstViewableTime: number | null = null;
-  private isViewableAchieved: boolean = false;
-  
-  private onViewableCallback?: (metrics: ViewabilityMetrics) => void;
+  private isViewableTriggered: boolean = false;
+  private onViewableCallback?: () => void;
   
   constructor(
     element: HTMLElement, 
-    adType: string,
-    onViewable?: (metrics: ViewabilityMetrics) => void
+    onViewable?: () => void
   ) {
     this.element = element;
-    this.config = VIEWABILITY_STANDARDS[adType] || VIEWABILITY_STANDARDS.BANNER;
     this.onViewableCallback = onViewable;
     
-    this.startTime = performance.now();
     this.initIntersectionObserver();
-    this.initMaxMeasureTimer();
   }
   
   private initIntersectionObserver(): void {
@@ -87,7 +28,7 @@ export class ViewabilityTracker {
     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'
       }
     );
@@ -97,90 +38,25 @@ export class ViewabilityTracker {
   
   private handleIntersection(entries: IntersectionObserverEntry[]): void {
     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();
+        }
       }
     });
   }
   
   private isDocumentVisible(): boolean {
-    // 단순한 문서 가시성 확인
     return !document.hidden && document.visibilityState === 'visible';
   }
   
-  private startViewabilityTimer(): void {
-    if (this.viewabilityTimer || this.isViewableAchieved) return;
-    
-    if (this.firstViewableTime === null) {
-      this.firstViewableTime = performance.now();
-    }
-    
-    this.viewabilityTimer = setTimeout(() => {
-      this.onViewabilityAchieved();
-    }, this.config.minDuration);
-  }
-  
-  private stopViewabilityTimer(): void {
-    if (this.viewabilityTimer) {
-      clearTimeout(this.viewabilityTimer);
-      this.viewabilityTimer = null;
-    }
-  }
-  
-  private initMaxMeasureTimer(): void {
-    // 최대 측정 시간 후 자동 종료
-    this.maxVisibilityTimer = setTimeout(() => {
-      this.destroy();
-    }, this.config.maxMeasureTime);
-  }
-  
-  private onViewabilityAchieved(): void {
-    if (this.isViewableAchieved) return;
-    
-    this.isViewableAchieved = true;
-    const metrics = this.calculateMetrics();
-    
-    if (this.onViewableCallback) {
-      this.onViewableCallback(metrics);
-    }
-  }
-  
-  private calculateMetrics(): ViewabilityMetrics {
-    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,
-    };
-  }
-  
-  public getMetrics(): ViewabilityMetrics {
-    return this.calculateMetrics();
-  }
-  
   public destroy(): void {
-    this.stopViewabilityTimer();
-    
-    if (this.maxVisibilityTimer) {
-      clearTimeout(this.maxVisibilityTimer);
-      this.maxVisibilityTimer = null;
-    }
-    
     if (this.observer) {
       this.observer.disconnect();
       this.observer = null;

package/src/managers/ads/viewable-event-tracker.ts

@@ -1,110 +1,40 @@
 /**
- * VIEWABLE 이벤트 추적 및 중복 방지 관리 클래스
- * - 메모리 기반 중복 확인
- * - 세션 스토리지 기반 영구 추적
- * - 자동 정리 기능
- * - ViewabilityTracker와 함께 사용하여 중복 viewable 이벤트 방지
+ * 단순한 VIEWABLE 이벤트 중복 방지 관리 클래스
+ * - 세션당 동일 광고 1회만 VIEWABLE 이벤트 허용
+ * - 메모리 기반 추적으로 단순화
  */
 export class ViewableEventTracker {
-  private static viewableTracker = new Map<string, number>();
-  private static readonly VIEWABLE_COOLDOWN_PRODUCTION = 300000; // 5분 쿨다운 (프로덕션)
-  private static readonly VIEWABLE_COOLDOWN_DEBUG = 30000; // 30초 쿨다운 (디버그)
+  private static viewableTracker = new Set<string>();
 
   /**
    * 중복 viewable 이벤트 여부 확인
    */
   static isDuplicateViewable(adId: string, slotId: string, debug = false): boolean {
     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) {
+    // 이미 VIEWABLE 이벤트가 발생한 광고인지 확인
+    if (ViewableEventTracker.viewableTracker.has(key)) {
       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)`);
+        console.log(`Duplicate viewable blocked for ad ${adId} in slot ${slotId}`);
       }
       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();
+    // 새로운 VIEWABLE 이벤트 기록
+    ViewableEventTracker.viewableTracker.add(key);
     
     if (debug) {
-      console.log(`✅ New viewable recorded for ad ${adId} in slot ${slotId} (${debug ? 'debug' : 'production'} mode)`);
+      console.log(`✅ New viewable recorded for ad ${adId} in slot ${slotId}`);
     }
     
     return false;
   }
 
-  /**
-   * 오래된 viewable 추적 데이터 정리
-   */
-  private static cleanupOldViewables(): void {
-    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(): void {
     ViewableEventTracker.viewableTracker.clear();
-    // 세션 스토리지에서도 adstage_viewable_ 키들 제거
-    const keysToRemove: string[] = [];
-    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));
   }
 
   /**
@@ -113,7 +43,5 @@ export class ViewableEventTracker {
   static clearAdViewable(adId: string, slotId: string): void {
     const key = `${adId}_${slotId}`;
     ViewableEventTracker.viewableTracker.delete(key);
-    const sessionKey = `adstage_viewable_${key}`;
-    sessionStorage.removeItem(sessionKey);
   }
 }

package/src/modules/ads/AdRenderer.ts

@@ -253,7 +253,7 @@ export 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}`);
           }

package/src/modules/ads/AdsModule.ts

@@ -8,9 +8,7 @@ import { AdType, AdEventType } from '../../types/advertisement';
 import type { AdSlot, Advertisement } from '../../types/advertisement';
 // 렌더링 관련 매니저/뷰 트래커는 AdRenderer로 이전됨
 import { AdvertisementEventTracker } from '../../managers/ads/advertisement-event-tracker';
-import { ViewabilityTracker, VIEWABILITY_STANDARDS } from '../../managers/ads/viewability-tracker';
-import { BasicFraudDetector } from '../../managers/ads/basic-fraud-detector';
-import type { ViewabilityMetrics } from '../../managers/ads/viewability-tracker';
+import { SimpleViewabilityTracker } from '../../managers/ads/viewability-tracker';
 import { endpoints } from '../../constants/endpoints';
 import { ApiHeaders } from '../../utils/api-headers';
 // 새로 분리된 클래스들
@@ -190,16 +188,11 @@ export class AdsModule implements BaseModule {
       throw new Error(`Ad slot not found: ${slotId}`);
     }
 
-    // ViewabilityTracker 정리
+    // SimpleViewabilityTracker 정리
     if ((slot as any).viewabilityTracker) {
       (slot as any).viewabilityTracker.destroy();
     }
 
-    // BasicFraudDetector 정리
-    if ((slot as any).fraudDetector) {
-      (slot as any).fraudDetector.destroy();
-    }
-
     // DOM에서 제거
     const container = document.getElementById(slot.containerId);
     if (container) {
@@ -283,23 +276,6 @@ export class AdsModule implements BaseModule {
     return slotId;
   }
 
-  // createAdSlot 제거: AdRenderer.createPlaceholder 사용
-
-  /**
-   * 여러 광고의 최적 컨테이너 크기 계산 (동적 크기 조정)
-   */
-  // calculateOptimalContainerSize 제거: AdRenderer.calculateOptimalContainerSize 사용
-
-  /**
-   * 최적 크기 조정 전략 선택
-   */
-  // selectOptimalSizeStrategy 제거: AdRenderer 내부 구현 사용
-
-  /**
-   * 전략에 따른 최적 높이 계산
-   */
-  // calculateOptimalHeight 제거: AdRenderer 내부 구현 사용
-
   /**
    * 백그라운드에서 광고 콘텐츠 로드
    */
@@ -321,13 +297,20 @@ export class AdsModule implements BaseModule {
       // 광고가 여러 개이거나 autoSlide 옵션이 있으면 슬라이더로 렌더링
       if (adstageData.length > 1 || (slot.config as any)?.autoSlide) {
         await this.adRenderer?.renderAdSlider(slot, adstageData);
+        
+        // 🔧 슬라이더의 첫 번째 광고도 자동 노출 추적 시작
+        if (adstageData.length > 0) {
+          setTimeout(() => {
+            this.startSimpleViewabilityTracking(slot, adstageData[0]);
+          }, 100); // 슬라이더 렌더링 완료 후 추적 시작
+        }
       } else {
         // 광고가 1개면 일반 렌더링
         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;
@@ -347,65 +330,59 @@ export class AdsModule implements BaseModule {
   // optimizeContainerForBannerAds 제거: AdRenderer.optimizeContainerForBannerAds 사용
 
   /**
-   * 기본 viewability 추적 시작
+   * 단순한 노출 추적 시작 (재시도 로직 포함)
    */
-  private startBasicViewabilityTracking(slot: AdSlot, ad: Advertisement): void {
-    const element = document.getElementById(slot.id);
-    if (!element) return;
-    
-    // 기본 fraud 검사
-    const fraudDetector = new BasicFraudDetector();
-    
-    // viewability 추적
-    const tracker = new ViewabilityTracker(element, slot.adType, async (metrics) => {
-      await this.handleViewableEvent(ad, slot, metrics, fraudDetector);
-    });
-    
-    // 정리를 위해 저장
-    (slot as any).viewabilityTracker = tracker;
-    (slot as any).fraudDetector = fraudDetector;
+  private startSimpleViewabilityTracking(slot: AdSlot, ad: Advertisement): void {
+    const tryStartTracking = (retryCount = 0) => {
+      const element = document.getElementById(slot.id);
+      
+      if (!element) {
+        if (retryCount < 5) {
+          // 최대 5번 재시도 (총 1.5초)
+          setTimeout(() => tryStartTracking(retryCount + 1), 300);
+          if (this._config?.debug) {
+            console.log(`🔄 Retrying viewability tracking for slot: ${slot.id} (attempt ${retryCount + 1})`);
+          }
+        } else {
+          console.warn(`❌ Failed to find element for viewability tracking: ${slot.id}`);
+        }
+        return;
+      }
+      
+      // 단순한 노출 추적
+      const tracker = new SimpleViewabilityTracker(element, async () => {
+        await this.handleViewableEvent(ad, slot);
+      });
+      
+      // 정리를 위해 저장
+      (slot as any).viewabilityTracker = tracker;
 
-    if (this._config?.debug) {
-      console.log(`🎯 Viewability tracking started for slot: ${slot.id}`);
-    }
+      if (this._config?.debug) {
+        console.log(`🎯 Simple viewability tracking started for slot: ${slot.id} (element found)`);
+      }
+    };
+
+    tryStartTracking();
   }
 
   /**
-   * Viewable 이벤트 처리
+   * Viewable 이벤트 처리 (단순화됨)
    */
   private async handleViewableEvent(
     ad: Advertisement, 
-    slot: AdSlot, 
-    metrics: ViewabilityMetrics,
-    fraudDetector: BasicFraudDetector
+    slot: AdSlot
   ): Promise<void> {
     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
-          }
+          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}`);
         }
       }
       
@@ -414,16 +391,6 @@ export class AdsModule implements BaseModule {
     }
   }
 
-  /**
-   * Fallback 광고 렌더링 - AdStage 확실한 컨테이너 우선 탐지
-   */
-  // renderFallback 제거: AdRenderer.renderFallback 사용
-
-  /**
-   * 빈 컨테이너 생성 (컨테이너를 찾지 못한 경우)
-   */
-  // createEmptyContainer 제거: AdRenderer 내부 구현 사용
-
   /**
    * 광고 데이터 가져오기
    */
@@ -500,21 +467,6 @@ export class AdsModule implements BaseModule {
     return advertisements;
   }
 
-  /**
-   * 광고 슬라이더 렌더링 (여러 광고 또는 autoSlide 옵션)
-   */
-  // renderAdSlider 제거: AdRenderer.renderAdSlider 사용
-
-  /**
-   * 광고 렌더링 (단일 광고용)
-   */
-  // renderAd 제거: AdRenderer.renderAd 사용
-
-  /**
-   * 광고 요소 렌더링 (기본 구현)
-   */
-  // renderAdElement 제거: AdRenderer.renderAdElement 사용
-
   /**
    * 광고 슬롯 새로고침
    */