@adstage/web-sdk 1.3.3 → 1.4.0

package/dist/index.esm.js

@@ -253,6 +253,72 @@ class DOMUtils {
             scrollLeft: this.getWindowProperty('pageXOffset', 0),
         };
     }
+    /**
+     * DOM 요소가 나타날 때까지 기다리기 (사용자 친화적 API)
+     */
+    static async waitForElement(id, options = {}) {
+        const { timeout = 3000, retryInterval = 100, debug = false } = options;
+        if (!this.canUseDOM()) {
+            throw new Error('DOM을 사용할 수 없는 환경입니다.');
+        }
+        // 즉시 찾을 수 있으면 바로 반환
+        const immediateElement = document.getElementById(id);
+        if (immediateElement) {
+            if (debug) {
+                console.log(`✅ 컨테이너 즉시 발견: ${id}`);
+            }
+            return immediateElement;
+        }
+        if (debug) {
+            console.log(`⏳ 컨테이너 대기 시작: ${id} (최대 ${timeout}ms)`);
+        }
+        return new Promise((resolve, reject) => {
+            let attempts = 0;
+            const maxAttempts = Math.ceil(timeout / retryInterval);
+            const checkElement = () => {
+                attempts++;
+                const element = document.getElementById(id);
+                if (element) {
+                    if (debug) {
+                        console.log(`✅ 컨테이너 발견: ${id} (${attempts}번째 시도, ${attempts * retryInterval}ms 경과)`);
+                    }
+                    resolve(element);
+                    return;
+                }
+                if (attempts >= maxAttempts) {
+                    const errorMessage = `❌ 컨테이너를 찾을 수 없습니다: "${id}"
+          
+다음을 확인해보세요:
+1. HTML에 id="${id}" 요소가 있는지 확인
+2. React 등에서 컴포넌트가 렌더링된 후 SDK 호출
+3. 철자가 정확한지 확인
+4. 중복된 ID가 없는지 확인
+
+대기 시간: ${timeout}ms (${attempts}번 시도)`;
+                    if (debug) {
+                        console.error(errorMessage);
+                    }
+                    reject(new Error(errorMessage));
+                    return;
+                }
+                if (debug && attempts % 10 === 0) {
+                    console.log(`⏳ 컨테이너 대기 중: ${id} (${attempts}/${maxAttempts})`);
+                }
+                // Exponential backoff: 처음엔 빠르게, 나중엔 느리게
+                const nextInterval = Math.min(retryInterval * Math.pow(1.2, attempts), 500);
+                setTimeout(checkElement, nextInterval);
+            };
+            // 첫 번째 체크는 즉시 실행
+            setTimeout(checkElement, retryInterval);
+        });
+    }
+    /**
+     * 여러 DOM 요소를 동시에 기다리기
+     */
+    static async waitForElements(ids, options = {}) {
+        const promises = ids.map(id => this.waitForElement(id, options));
+        return Promise.all(promises);
+    }
 }
 
 /**
@@ -704,14 +770,15 @@ AdRendererFactory.renderers = new Map();
 })();
 
 /**
- * 슬라이더 관리 클래스
- * - 다중 광고 슬라이더 생성 및 관리
- * - 무한 루프 슬라이더 지원
+ * 캐러셀 슬라이더 관리 클래스
+ * - 배너/비디오 광고용 가로 슬라이드 (횡 스크롤)
+ * - 무한 루프 캐러셀 지원
  * - 터치 제스처 및 자동 슬라이드 기능
+ * - 도트 인디케이터 포함
  */
-class SliderManager {
+class CarouselSliderManager {
     /**
-     * 슬라이더 컨테이너 생성
+     * Create carousel slider container with dot indicators and navigation
      */
     static createSliderContainer(slot, advertisements, options, trackEventCallback) {
         const sliderWrapper = document.createElement('div');
@@ -841,7 +908,7 @@ class SliderManager {
         // 텍스트 광고인지 확인 (모든 광고가 텍스트 타입인 경우)
         const isAllTextAds = advertisements.every(ad => ad.adType === AdType.TEXT);
         // 무채색 도트 인디케이터 생성 (원본 광고 수만큼) - 텍스트 광고가 아닐 때만
-        const dotContainer = isAllTextAds ? null : SliderManager.createMinimalDotIndicator(advertisements.length);
+        const dotContainer = isAllTextAds ? null : this.createMinimalDotIndicator(advertisements.length);
         // 슬라이더 상태 관리
         let currentSlide = 0;
         const totalSlides = advertisements.length;
@@ -917,7 +984,7 @@ class SliderManager {
             }, autoSlideInterval);
         });
         // 터치 제스처 지원 수정 (무한 루프 지원)
-        SliderManager.addTouchSupport(slideContainer, moveToSlide, () => currentSlide, totalSlides, handleInfiniteLoop);
+        this.addTouchSupport(slideContainer, moveToSlide, () => currentSlide, totalSlides, handleInfiniteLoop);
         // 요소들 조립 (화살표 제거, 도트는 텍스트 광고가 아닐 때만 추가)
         sliderWrapper.appendChild(slideContainer);
         if (dotContainer) {
@@ -1041,16 +1108,16 @@ class SliderManager {
 }
 
 /**
- * 페이드 슬라이더 관리 클래스
- * - 텍스트 광고 전용 페이드 인/아웃 슬라이더
- * - 상하 교차 효과 (위에서 아래로, 아래서 위로)
+ * 텍스트 전환 효과 관리 클래스
+ * - 텍스트 광고 전용 페이드 인/아웃 + 상하 움직임 효과
+ * - 부드러운 전환 애니메이션 (vertical transition)
  * - 무한 루프 지원
  */
-class FadeSliderManager {
+class TextTransitionManager {
     /**
-     * 페이드 슬라이더 컨테이너 생성
+     * 텍스트 전환 슬라이더 컨테이너 생성
      */
-    static createFadeSliderContainer(slot, advertisements, options, trackEventCallback) {
+    static createTextTransitionContainer(slot, advertisements, options, trackEventCallback) {
         const sliderWrapper = document.createElement('div');
         sliderWrapper.className = 'adstage-fade-slider-wrapper';
         // 래퍼 스타일 설정
@@ -1219,7 +1286,7 @@ class FadeSliderManager {
             }, autoSlideInterval);
         });
         // 터치 제스처 지원
-        FadeSliderManager.addTouchSupport(sliderWrapper, moveToSlide, () => currentSlide, totalSlides);
+        TextTransitionManager.addTouchSupport(sliderWrapper, moveToSlide, () => currentSlide, totalSlides);
         // 요소들 조립
         sliderWrapper.appendChild(slideContainer);
         return sliderWrapper;
@@ -1439,6 +1506,46 @@ class DeviceInfoCollector {
     }
 }
 
+/**
+ * AdStage SDK - API 헤더 유틸리티
+ * 공통 헤더 생성 로직
+ */
+class ApiHeaders {
+    /**
+     * 표준 API 헤더 생성
+     */
+    static create(apiKey, options) {
+        if (!apiKey) {
+            throw new Error('API key is required');
+        }
+        const headers = {
+            'x-api-key': apiKey,
+            'Content-Type': options?.contentType || 'application/json'
+        };
+        // User-Agent는 이벤트 추적에서 실제로 사용됨
+        if (typeof navigator !== 'undefined') {
+            headers['User-Agent'] = options?.userAgent || navigator.userAgent;
+        }
+        // X-Current-URL은 현재 서버에서 사용하지 않으므로 제거
+        // 필요시 이벤트 데이터 body에 포함
+        return headers;
+    }
+    /**
+     * 이벤트 추적용 헤더 생성
+     * User-Agent는 서버에서 실제로 사용됨
+     */
+    static createForEvents(apiKey, eventData) {
+        const baseHeaders = ApiHeaders.create(apiKey);
+        // User-Agent 오버라이드 (서버에서 실제 사용)
+        if (eventData?.userAgent) {
+            baseHeaders['User-Agent'] = eventData.userAgent;
+        }
+        // 다른 정보들은 HTTP 헤더가 아닌 이벤트 데이터 body에 포함하는 것이 적절
+        // (currentUrl, referrer 등은 POST body로 전송)
+        return baseHeaders;
+    }
+}
+
 /**
  * 이벤트 추적 관리 클래스
  * - 광고 이벤트 추적 및 전송
@@ -1514,10 +1621,7 @@ class EventTracker {
             };
             await fetch(`${this.baseUrl}/advertisements/events/${adId}/${eventType}`, {
                 method: 'POST',
-                headers: {
-                    'x-api-key': this.apiKey,
-                    'Content-Type': 'application/json',
-                },
+                headers: ApiHeaders.createForEvents(this.apiKey, eventData),
                 body: JSON.stringify(eventData),
             });
             if (this.debug) {
@@ -1545,558 +1649,791 @@ class EventTracker {
 }
 
 /**
- * SDK 유틸리티 함수 모음
- * - DOM 요소 속성 처리
- * - 자동 슬롯 검색
- * - 기타 헬퍼 함수들
+ * AdStage SDK 엔드포인트 상수 관리
+ * 모든 API URL을 중앙에서 관리
  */
-class SDKUtils {
-    /**
-     * HTML 요소에서 속성값 가져오기 (data- 프리픽스 선택적)
-     */
-    static getElementAttribute(element, attrName) {
-        // 1. data- 프리픽스가 있는 경우 우선
-        const dataAttr = element.dataset[attrName];
-        if (dataAttr)
-            return dataAttr;
-        // 2. 직접 속성 확인
-        const directAttr = element.getAttribute(attrName);
-        if (directAttr)
-            return directAttr;
-        // 3. 케밥 케이스로 확인 (ad-type -> adType)
-        const kebabAttr = element.getAttribute(attrName.replace(/[A-Z]/g, '-$&').toLowerCase());
-        if (kebabAttr)
-            return kebabAttr;
-        return undefined;
+/**
+ * 환경별 API 엔드포인트 (읽기 전용)
+ */
+const API_ENDPOINTS = {
+    /** 프로덕션 환경 */
+    production: 'https://api.adstage.io',
+    /** 베타 환경 (기본값) */
+    beta: 'https://beta-api.adstage.app'
+};
+/**
+ * API 경로 상수
+ */
+const API_PATHS = {
+    /** 광고 관련 */
+    advertisements: {
+        list: '/advertisements/list',
+        events: '/advertisements/events'
+    },
+    /** 이벤트 관련 */
+    events: {
+        track: '/events/track',
+        batch: '/events/batch'
+    }
+};
+/**
+ * 완전한 API URL 생성 헬퍼
+ */
+class EndpointBuilder {
+    constructor(baseUrl) {
+        /**
+         * 광고 엔드포인트
+         */
+        this.advertisements = {
+            list: () => `${this.baseUrl}${API_PATHS.advertisements.list}`,
+            events: (adId, eventType) => `${this.baseUrl}${API_PATHS.advertisements.events}/${adId}/${eventType}`
+        };
+        /**
+         * 이벤트 엔드포인트
+         */
+        this.events = {
+            track: () => `${this.baseUrl}${API_PATHS.events.track}`,
+            batch: () => `${this.baseUrl}${API_PATHS.events.batch}`
+        };
+        // 기본값은 베타 환경 사용
+        this.baseUrl = baseUrl || API_ENDPOINTS.beta;
     }
     /**
-     * DOM에서 자동 슬롯 요소 찾기 (SSR 안전)
+     * 기본 URL 변경
      */
-    static findAutoSlotElements() {
-        if (typeof document === 'undefined')
-            return [];
-        const elements = document.querySelectorAll('[data-adstage], [adstage]');
-        return Array.from(elements);
-    }
-    /**
-     * 요소에서 슬롯 정보 추출
-     */
-    static extractSlotInfo(element) {
-        // 슬롯 ID 가져오기
-        const slotId = SDKUtils.getElementAttribute(element, 'adstage');
-        // 광고 타입 가져오기
-        const adType = SDKUtils.getElementAttribute(element, 'adType') ||
-            SDKUtils.getElementAttribute(element, 'ad-type') ||
-            'BANNER';
-        // 크기 정보 가져오기 (다양한 형태 지원)
-        const width = SDKUtils.getElementAttribute(element, 'width');
-        const height = SDKUtils.getElementAttribute(element, 'height');
-        // 기타 옵션들
-        const language = SDKUtils.getElementAttribute(element, 'language');
-        const deviceType = SDKUtils.getElementAttribute(element, 'deviceType') ||
-            SDKUtils.getElementAttribute(element, 'device-type');
-        const country = SDKUtils.getElementAttribute(element, 'country');
-        const sliderEffect = SDKUtils.getElementAttribute(element, 'sliderEffect') ||
-            SDKUtils.getElementAttribute(element, 'slider-effect');
-        return {
-            slotId: slotId || null,
-            adType,
-            width,
-            height,
-            language,
-            deviceType,
-            country,
-            sliderEffect,
-        };
+    setBaseUrl(url) {
+        this.baseUrl = url;
+        console.log('🔄 API endpoint changed:', url);
     }
     /**
-     * AdType enum 값으로 변환
+     * 기본 URL 반환
      */
-    static parseAdType(adTypeStr, AdType) {
-        return AdType[adTypeStr] || AdType.BANNER;
+    getBaseUrl() {
+        return this.baseUrl;
     }
     /**
-     * 브라우저 환경 체크
+     * 커스텀 경로 생성
      */
-    static isBrowser() {
-        return typeof window !== 'undefined';
+    custom(path) {
+        return `${this.baseUrl}${path.startsWith('/') ? path : `/${path}`}`;
+    }
+}
+/**
+ * 전역 엔드포인트 빌더 인스턴스 (기본: 베타 환경)
+ */
+const endpoints = new EndpointBuilder();
+
+/**
+ * AdStage SDK - Ads 모듈
+ * 광고 관리 및 렌더링 기능
+ */
+class AdsModule {
+    constructor() {
+        this._isReady = false;
+        this._config = null;
+        this.slots = new Map();
+        this.eventTracker = null;
     }
     /**
-     * SSR 환경 체크
+     * Ads 모듈 초기화 (동기)
      */
-    static isSSR() {
-        return typeof window === 'undefined';
+    init(config) {
+        this._config = config;
+        // EventTracker 초기화 (환경 자동 감지된 엔드포인트 사용)
+        this.eventTracker = new EventTracker(endpoints.getBaseUrl(), config.apiKey, config.debug || false, this.slots);
+        this._isReady = true;
+        if (config.debug) {
+            console.log('🎯 Ads module initialized (sync mode)');
+        }
     }
     /**
-     * DOM 사용 가능 체크
+     * 모듈 준비 상태 확인
      */
-    static canUseDOM() {
-        return !this.isSSR() && typeof document !== 'undefined';
+    isReady() {
+        return this._isReady;
     }
     /**
-     * DOM 로드 완료 체크 (SSR 안전)
+     * 모듈 설정 반환
      */
-    static isDOMReady() {
-        if (!this.canUseDOM())
-            return false;
-        return document.readyState !== 'loading';
+    getConfig() {
+        return this._config;
     }
     /**
-     * DOM 로드 완료 대기 (SSR 안전)
+     * 배너 광고 생성 (동기)
      */
-    static waitForDOM() {
-        return new Promise((resolve) => {
-            if (!this.canUseDOM()) {
-                resolve(); // SSR 환경에서는 즉시 resolve
-                return;
-            }
-            if (SDKUtils.isDOMReady()) {
-                resolve();
-            }
-            else {
-                document.addEventListener('DOMContentLoaded', () => resolve());
-            }
-        });
+    banner(containerId, options) {
+        this.ensureReady();
+        const adstageOptions = {
+            width: options?.width || '100%',
+            height: options?.height || 250,
+            autoSlide: options?.autoSlide || false,
+            slideInterval: options?.slideInterval || 5000,
+            onClick: options?.onClick
+        };
+        return this.createAd(containerId, AdType.BANNER, adstageOptions);
     }
-}
-
-/**
- * AdStage SDK Standalone API
- * 간단하고 직관적인 사용을 위한 통합 API
- */
-let globalSDKInstance = null;
-let isInitializing = false;
-/**
- * SDK 초기화 (한 번만 호출)
- */
-async function initAdStage(config) {
-    if (globalSDKInstance) {
-        console.warn('AdStage SDK가 이미 초기화되었습니다.');
-        return;
-    }
-    if (isInitializing) {
-        console.warn('AdStage SDK 초기화가 진행 중입니다.');
-        return;
-    }
-    isInitializing = true;
-    try {
-        // 동적 import로 circular dependency 방지
-        const { AdStageSDK } = await Promise.resolve().then(function () { return index; });
-        globalSDKInstance = AdStageSDK.init({
-            apiKey: config.apiKey,
-            debug: config.debug || false
-        });
-        console.log('✅ AdStage SDK 초기화 완료');
+    /**
+     * 텍스트 광고 생성 (동기)
+     */
+    text(containerId, options) {
+        this.ensureReady();
+        const adstageOptions = {
+            maxLines: options?.maxLines || 3,
+            style: options?.style || 'default',
+            onClick: options?.onClick
+        };
+        return this.createAd(containerId, AdType.TEXT, adstageOptions);
     }
-    catch (error) {
-        console.error('❌ AdStage SDK 초기화 실패:', error);
-        throw error;
+    /**
+     * 비디오 광고 생성 (동기)
+     */
+    video(containerId, options) {
+        this.ensureReady();
+        const adstageOptions = {
+            width: options?.width || 640,
+            height: options?.height || 360,
+            autoplay: options?.autoplay || false,
+            muted: options?.muted || true,
+            onClick: options?.onClick
+        };
+        return this.createAd(containerId, AdType.VIDEO, adstageOptions);
     }
-    finally {
-        isInitializing = false;
+    /**
+     * 네이티브 광고 생성 (동기)
+     */
+    native(containerId, options) {
+        this.ensureReady();
+        return this.createAd(containerId, AdType.NATIVE, options || {});
     }
-}
-/**
- * 배너 광고 생성 (가장 간단한 API)
- */
-async function createBanner(containerId, options) {
-    if (!globalSDKInstance) {
-        throw new Error('AdStage SDK가 초기화되지 않았습니다. initAdStage()를 먼저 호출하세요.');
-    }
-    const slotId = `banner-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    return globalSDKInstance.createSlot(slotId, containerId, 'BANNER', {
-        width: options?.width || '100%',
-        height: options?.height || 120,
-        autoSlideInterval: options?.autoSlide ? (options.slideInterval || 5) : 0,
-        sliderEffect: 'fade'
-    });
-}
-/**
- * 텍스트 광고 생성
- */
-async function createTextAd(containerId, options) {
-    if (!globalSDKInstance) {
-        throw new Error('AdStage SDK가 초기화되지 않았습니다.');
-    }
-    const slotId = `text-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    return globalSDKInstance.createSlot(slotId, containerId, 'TEXT', {
-        maxLines: options?.maxLines || 3,
-        style: options?.style || 'card'
-    });
-}
-/**
- * 비디오 광고 생성
- */
-async function createVideoAd(containerId, options) {
-    if (!globalSDKInstance) {
-        throw new Error('AdStage SDK가 초기화되지 않았습니다.');
-    }
-    const slotId = `video-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    return globalSDKInstance.createSlot(slotId, containerId, 'VIDEO', {
-        width: options?.width || '100%',
-        height: options?.height || 300,
-        autoplay: options?.autoplay || false,
-        muted: options?.muted || true
-    });
-}
-/**
- * SDK 상태 확인
- */
-function isAdStageReady() {
-    return globalSDKInstance !== null && !isInitializing;
-}
-/**
- * SDK 인스턴스 가져오기 (고급 사용자용)
- */
-function getAdStageInstance() {
-    if (!globalSDKInstance) {
-        console.warn('AdStage SDK가 초기화되지 않았습니다.');
-        return null;
+    /**
+     * 전면 광고 생성 (동기)
+     */
+    interstitial(containerId, options) {
+        this.ensureReady();
+        return this.createAd(containerId, AdType.INTERSTITIAL, options || {});
     }
-    return globalSDKInstance;
-}
-/**
- * SDK 초기화 해제 (필요시)
- */
-function destroyAdStage() {
-    if (globalSDKInstance) {
-        try {
-            // SDK cleanup logic here
-            globalSDKInstance = null;
-            console.log('🧹 AdStage SDK 정리 완료');
+    /**
+     * 광고 새로고침
+     */
+    refresh(slotId) {
+        this.ensureReady();
+        const slot = this.slots.get(slotId);
+        if (!slot) {
+            throw new Error(`Ad slot not found: ${slotId}`);
         }
-        catch (error) {
-            console.error('SDK 정리 중 오류:', error);
+        // 광고 새로고침 로직
+        this.refreshAdSlot(slot);
+        if (this._config?.debug) {
+            console.log(`🔄 Ad slot refreshed: ${slotId}`);
         }
     }
-}
-
-/**
- * AdStage SDK 메인 클래스
- * - 간단한 API Key 기반 초기화
- * - 광고 슬롯 자동 관리
- * - 이벤트 자동 추적
- */
-class AdStageSDK {
-    constructor(config) {
-        this.baseUrl = 'https://beta-api.adstage.app';
-        this.slots = new Map();
-        this.initialized = false;
-        this.config = {
-            debug: false,
-            ...config,
-        };
-        this.eventTracker = new EventTracker(this.baseUrl, this.config.apiKey, this.config.debug || false, this.slots);
-    }
     /**
-     * SDK 초기화 및 인스턴스 반환
+     * 광고 제거
      */
-    static init(config) {
-        if (!AdStageSDK.instance) {
-            AdStageSDK.instance = new AdStageSDK(config);
+    destroy(slotId) {
+        this.ensureReady();
+        const slot = this.slots.get(slotId);
+        if (!slot) {
+            throw new Error(`Ad slot not found: ${slotId}`);
+        }
+        // DOM에서 제거
+        const container = document.getElementById(slot.containerId);
+        if (container) {
+            container.innerHTML = '';
+        }
+        // 슬롯 제거
+        this.slots.delete(slotId);
+        if (this._config?.debug) {
+            console.log(`🗑️ Ad slot destroyed: ${slotId}`);
         }
-        return AdStageSDK.instance;
     }
     /**
-     * SDK 인스턴스 반환 (이미 초기화된 경우)
+     * 모든 광고 슬롯 반환
      */
-    static getInstance() {
-        if (!AdStageSDK.instance) {
-            throw new Error('AdStageSDK must be initialized first. Call AdStageSDK.init(config)');
-        }
-        return AdStageSDK.instance;
+    getAllSlots() {
+        this.ensureReady();
+        return Array.from(this.slots.values());
     }
     /**
-     * 광고 슬롯 생성 및 로드
+     * 특정 광고 슬롯 반환
      */
-    async createSlot(id, containerId, adType = AdType.BANNER, options) {
-        const container = DOMUtils.safeGetElementById(containerId);
+    getSlotById(slotId) {
+        this.ensureReady();
+        return this.slots.get(slotId) || null;
+    }
+    /**
+     * 광고 생성 내부 메소드 (동기 + Lazy 로딩)
+     */
+    createAd(containerId, type, options) {
+        if (!this._config?.apiKey) {
+            throw new Error('API key not configured');
+        }
+        const container = document.getElementById(containerId);
         if (!container) {
-            if (DOMUtils.canUseDOM()) {
-                console.error(`Container with ID "${containerId}" not found`);
-            }
-            return;
+            throw new Error(`Container not found: ${containerId}`);
         }
+        // 고유한 슬롯 ID 생성
+        const slotId = `adstage-${type}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        // 즉시 placeholder 생성
+        this.createAdSlot(container, slotId, type, options);
+        // 광고 슬롯 정보 저장
         const slot = {
-            id,
+            id: slotId,
             containerId,
-            adType,
-            width: options?.width || 0, // 문자열도 지원
-            height: options?.height || 0, // 문자열도 지원
+            adType: type,
+            width: options.width || '100%',
+            height: options.height || 250,
             isLoaded: false,
             isVisible: false,
             refreshRate: 0,
             lazyLoad: false,
             targeting: {},
-            load: async () => { await this.loadSlot(slot, options); return null; },
-            render: (ad) => this.renderSlot(slot, ad),
-            refresh: () => this.refreshSlot(slot.id),
-            destroy: () => this.destroySlot(slot.id),
+            advertisement: undefined, // 나중에 로드
+            config: { type, ...options },
+            load: async () => this.fetchAdData(type, options).then(ads => ads[0] || null),
+            render: (ad) => this.renderAdElement(slot, ad),
+            refresh: async () => this.refreshAdSlot(slot),
+            destroy: () => this.destroy(slotId)
         };
-        this.slots.set(id, slot);
-        await this.loadSlot(slot, options);
+        // 슬롯 저장
+        this.slots.set(slotId, slot);
+        // 백그라운드에서 광고 로드
+        this.loadAdContentInBackground(slot);
+        // 이벤트 추적 준비
+        if (this.eventTracker && this._config?.debug) {
+            console.log(`📊 Event tracking enabled for slot: ${slotId}`);
+        }
+        return slotId;
+    }
+    /**
+     * 즉시 광고 슬롯 생성 (placeholder)
+     */
+    createAdSlot(container, slotId, type, options) {
+        const adElement = document.createElement('div');
+        adElement.id = slotId;
+        adElement.className = `adstage-slot adstage-${type.toLowerCase()}`;
+        adElement.style.width = typeof options.width === 'number' ? `${options.width}px` : (options.width || '100%');
+        adElement.style.height = typeof options.height === 'number' ? `${options.height}px` : (options.height || '250px');
+        adElement.style.border = '1px dashed #ccc';
+        adElement.style.display = 'flex';
+        adElement.style.alignItems = 'center';
+        adElement.style.justifyContent = 'center';
+        adElement.style.backgroundColor = '#f9f9f9';
+        adElement.style.color = '#666';
+        adElement.innerHTML = `<span>Loading ${type} ad...</span>`;
+        container.appendChild(adElement);
+        if (this._config?.debug) {
+            console.log(`📦 Placeholder created for slot: ${slotId}`);
+        }
     }
     /**
-     * 광고 슬롯 로드
+     * 백그라운드에서 광고 콘텐츠 로드
      */
-    async loadSlot(slot, options) {
+    async loadAdContentInBackground(slot) {
         try {
-            const queryParams = new URLSearchParams({
-                adType: slot.adType,
-                status: 'ACTIVE', // ACTIVE 상태인 광고만 조회
-                ...(options?.language && { language: options.language }),
-                ...(options?.deviceType && { deviceType: options.deviceType }),
-                ...(options?.country && { country: options.country }),
-            });
-            const requestUrl = `${this.baseUrl}/advertisements/list?${queryParams}`;
-            if (this.config.debug) {
-                console.log(`🌐 광고 API 요청 시작:`, {
-                    url: requestUrl,
-                    apiKey: this.config.apiKey.substring(0, 10) + '...',
-                    slot: slot.id
-                });
-            }
-            const response = await fetch(requestUrl, {
-                headers: {
-                    'x-api-key': this.config.apiKey,
-                    'Content-Type': 'application/json',
-                },
-            });
-            if (this.config.debug) {
-                console.log(`📡 API 응답 상태:`, {
-                    status: response.status,
-                    statusText: response.statusText,
-                    ok: response.ok
-                });
-            }
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const data = await response.json();
-            if (this.config.debug) {
-                console.log(`📊 API 응답 데이터:`, {
-                    data,
-                    advertisementsCount: data.advertisements ? data.advertisements.length : 0
-                });
+            // 광고 데이터 가져오기 - 여러 개 로드
+            const adstageData = await this.fetchAdData(slot.adType, slot.config);
+            if (!adstageData || adstageData.length === 0) {
+                this.renderFallback(slot);
+                return;
             }
-            const advertisements = data.advertisements || [];
-            if (advertisements.length > 0) {
-                if (this.config.debug) {
-                    console.log(`✅ ${advertisements.length}개 광고 발견:`, advertisements);
-                }
-                // 여러 광고가 있을 경우 슬라이드로 렌더링
-                this.renderSlotWithSlider(slot, advertisements, options);
-                // 첫 번째 광고에 대해서만 노출 이벤트 추적
-                await this.eventTracker.trackEvent(advertisements[0]._id, slot.id, AdEventType.IMPRESSION);
+            // 광고가 여러 개이거나 autoSlide 옵션이 있으면 슬라이더로 렌더링
+            if (adstageData.length > 1 || slot.config?.autoSlide) {
+                await this.renderAdSlider(slot, adstageData);
             }
             else {
-                console.warn(`⚠️ 슬롯 ${slot.id}에 사용 가능한 광고가 없습니다. API 응답:`, data);
+                // 광고가 1개면 일반 렌더링
+                slot.advertisement = adstageData[0];
+                await this.renderAdElement(slot, adstageData[0]);
+            }
+            slot.isLoaded = true;
+            if (this._config?.debug) {
+                console.log(`✅ Ad loaded for slot: ${slot.id} (${adstageData.length} ads)`);
             }
         }
         catch (error) {
-            console.error(`❌ 슬롯 ${slot.id} 로드 실패:`, error);
+            console.error(`❌ Failed to load ad for slot: ${slot.id}`, error);
+            this.renderFallback(slot);
         }
     }
     /**
-     * 광고 슬롯 렌더링 (슬라이더 포함)
+     * Fallback 광고 렌더링
      */
-    renderSlotWithSlider(slot, advertisements, options) {
-        const container = DOMUtils.safeGetElementById(slot.containerId);
-        if (!container) {
-            console.error(`❌ 컨테이너를 찾을 수 없습니다: ${slot.containerId}`);
-            return;
+    renderFallback(slot) {
+        const element = document.getElementById(slot.id);
+        if (element) {
+            element.innerHTML = `<span>Ad not available</span>`;
+            element.style.color = '#999';
+            if (this._config?.debug) {
+                console.warn(`⚠️ Fallback rendered for slot: ${slot.id}`);
+            }
         }
-        if (this.config.debug) {
-            console.log(`🎨 광고 렌더링 시작:`, {
-                slotId: slot.id,
-                containerId: slot.containerId,
-                advertisementCount: advertisements.length,
-                container: container
-            });
+    }
+    /**
+     * 광고 데이터 가져오기
+     */
+    async fetchAdData(type, options) {
+        if (!this._config?.apiKey) {
+            throw new Error('API key not configured');
         }
-        if (advertisements.length === 1) {
-            // 광고가 하나뿐이면 기본 렌더링
-            this.renderSlot(slot, advertisements[0]);
-            return;
+        // GET 요청용 query parameters 구성
+        const params = new URLSearchParams();
+        params.append('adType', type);
+        // userAgent와 url은 header나 자동으로 처리되므로 query에서 제외
+        // 기타 옵션들을 필요시 query parameter로 추가 가능
+        const url = `${endpoints.advertisements.list()}?${params.toString()}`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: ApiHeaders.create(this._config.apiKey)
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ad data: ${response.status}`);
         }
-        // 슬라이더 효과 결정 (옵션으로 지정하거나 텍스트 광고인 경우 fade 기본값)
-        const isAllTextAds = advertisements.every(ad => ad.adType === AdType.TEXT);
-        const useFadeEffect = options?.sliderEffect === 'fade' ||
-            (options?.sliderEffect !== 'slide' && isAllTextAds);
-        let sliderContainer;
-        if (useFadeEffect) {
-            // 페이드 슬라이더 사용
-            sliderContainer = FadeSliderManager.createFadeSliderContainer(slot, advertisements, options, (adId, slotId, eventType) => this.eventTracker.trackEvent(adId, slotId, eventType));
+        const result = await response.json();
+        return result.advertisements || [];
+    }
+    /**
+     * 광고 슬라이더 렌더링 (여러 광고 또는 autoSlide 옵션)
+     */
+    async renderAdSlider(slot, advertisements) {
+        const container = document.getElementById(slot.containerId);
+        if (!container) {
+            throw new Error(`Container not found: ${slot.containerId}`);
+        }
+        // 이벤트 추적 콜백 함수 (중복 노출 방지 포함)
+        const trackEventCallback = (adId, slotId, eventType) => {
+            // 노출 이벤트인 경우 중복 확인
+            if (eventType === AdEventType.IMPRESSION) {
+                if (ImpressionTracker.isDuplicateImpression(adId, slotId, this._config?.debug)) {
+                    if (this._config?.debug) {
+                        console.log(`🚫 Duplicate impression blocked for ad ${adId} in slot ${slotId}`);
+                    }
+                    return; // 중복 노출이면 추적하지 않음
+                }
+                if (this._config?.debug) {
+                    console.log(`✅ New impression recorded for ad ${adId} in slot ${slotId}`);
+                }
+            }
+            if (this.eventTracker && this._config?.debug) {
+                console.log(`📊 Event tracked: ${eventType} for ad ${adId} in slot ${slotId}`);
+            }
+        };
+        let sliderElement;
+        // 텍스트 광고는 TextTransitionManager 사용, 그 외는 CarouselSliderManager 사용
+        if (slot.adType === AdType.TEXT) {
+            sliderElement = TextTransitionManager.createTextTransitionContainer(slot, advertisements, {
+                autoSlideInterval: (slot.config?.slideInterval || 5000) / 1000,
+                ...slot.config
+            }, trackEventCallback);
+            if (this._config?.debug) {
+                console.log(`✨ Text transition created for TEXT slot: ${slot.id} with ${advertisements.length} ads`);
+            }
         }
         else {
-            // 기본 슬라이더 사용
-            sliderContainer = SliderManager.createSliderContainer(slot, advertisements, options, (adId, slotId, eventType) => this.eventTracker.trackEvent(adId, slotId, eventType));
+            sliderElement = CarouselSliderManager.createSliderContainer(slot, advertisements, {
+                autoSlideInterval: (slot.config?.slideInterval || 5000) / 1000,
+                ...slot.config
+            }, trackEventCallback);
+            if (this._config?.debug) {
+                console.log(`🎠 Carousel slider created for ${slot.adType} slot: ${slot.id} with ${advertisements.length} ads`);
+            }
         }
+        // 기존 내용 제거하고 슬라이더 추가
         container.innerHTML = '';
-        container.appendChild(sliderContainer);
-        slot.isLoaded = true;
-        if (this.config.debug) {
-            const sliderType = useFadeEffect ? 'fade slider' : 'slider';
-            console.log(`✅ ${advertisements.length}개 광고를 ${sliderType}로 렌더링 완료:`, {
-                slotId: slot.id,
-                container: container,
-                sliderContainer: sliderContainer
-            });
+        container.appendChild(sliderElement);
+    }
+    /**
+     * 광고 렌더링 (단일 광고용)
+     */
+    async renderAd(slot) {
+        if (!slot.advertisement) {
+            throw new Error('No advertisement to render');
         }
+        await this.renderAdElement(slot, slot.advertisement);
+        slot.isLoaded = true;
     }
     /**
-     * 광고 슬롯 렌더링 (단일 광고용)
+     * 광고 요소 렌더링 (기본 구현)
      */
-    renderSlot(slot, ad) {
-        const container = DOMUtils.safeGetElementById(slot.containerId);
-        if (!container) {
-            console.error(`❌ 컨테이너를 찾을 수 없습니다: ${slot.containerId}`);
+    async renderAdElement(slot, ad) {
+        const container = document.getElementById(slot.containerId);
+        if (!container)
             return;
+        // 기본 HTML 구조 생성
+        const adElement = document.createElement('div');
+        adElement.className = 'adstage-ad';
+        adElement.style.width = typeof slot.width === 'string' ? slot.width : `${slot.width}px`;
+        adElement.style.height = typeof slot.height === 'string' ? slot.height : `${slot.height}px`;
+        // 광고 타입별 렌더링
+        switch (slot.adType) {
+            case AdType.BANNER:
+                if (ad.imageUrl) {
+                    const img = document.createElement('img');
+                    img.src = ad.imageUrl;
+                    img.alt = ad.title;
+                    img.style.width = '100%';
+                    img.style.height = '100%';
+                    img.style.objectFit = 'cover';
+                    adElement.appendChild(img);
+                }
+                break;
+            case AdType.TEXT:
+                const textDiv = document.createElement('div');
+                textDiv.innerHTML = `
+          <h3>${ad.title}</h3>
+          ${ad.description ? `<p>${ad.description}</p>` : ''}
+          ${ad.textContent ? `<div>${ad.textContent}</div>` : ''}
+        `;
+                adElement.appendChild(textDiv);
+                break;
+            case AdType.VIDEO:
+                if (ad.videoUrl) {
+                    const video = document.createElement('video');
+                    video.src = ad.videoUrl;
+                    video.controls = true;
+                    video.style.width = '100%';
+                    video.style.height = '100%';
+                    adElement.appendChild(video);
+                }
+                break;
+            default:
+                adElement.innerHTML = `<div>${ad.title}</div>`;
         }
-        if (this.config.debug) {
-            console.log(`🎨 단일 광고 렌더링 시작:`, {
-                slotId: slot.id,
-                containerId: slot.containerId,
-                ad: ad,
-                container: container
-            });
-        }
-        // 팩토리를 사용해서 적절한 렌더러로 광고 생성
-        const adElement = AdRendererFactory.render(ad, slot, (adId, slotId, eventType) => this.eventTracker.trackEvent(adId, slotId, eventType));
-        if (this.config.debug) {
-            console.log(`🔧 광고 요소 생성됨:`, {
-                adElement: adElement,
-                tagName: adElement.tagName,
-                innerHTML: adElement.innerHTML.substring(0, 200) + '...'
+        // 클릭 이벤트 추가
+        if (ad.linkUrl) {
+            adElement.style.cursor = 'pointer';
+            adElement.addEventListener('click', () => {
+                window.open(ad.linkUrl, '_blank');
             });
         }
         container.innerHTML = '';
         container.appendChild(adElement);
-        slot.isLoaded = true;
-        if (this.config.debug) {
-            console.log(`✅ 단일 광고 렌더링 완료:`, {
-                slotId: slot.id,
-                ad: ad,
-                containerContent: container.innerHTML.substring(0, 200) + '...'
+    }
+    /**
+     * 광고 슬롯 새로고침
+     */
+    async refreshAdSlot(slot) {
+        try {
+            // 새로운 광고 데이터 가져오기 (config에서 타입과 옵션 정보 사용)
+            const newAdData = await this.fetchAdData(slot.adType, slot.config || {});
+            if (newAdData && newAdData.length > 0) {
+                slot.advertisement = newAdData[0]; // 첫 번째 광고로 업데이트
+                await this.renderAd(slot);
+                // 새로운 노출 추적
+                if (this.eventTracker) {
+                    console.log('New impression tracked for slot:', slot.id);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Failed to refresh ad slot: ${slot.id}`, error);
+        }
+    }
+    /**
+     * 모듈 준비 상태 확인
+     */
+    ensureReady() {
+        if (!this._isReady) {
+            throw new Error('Ads module not initialized. Call AdStage.init() first.');
+        }
+    }
+}
+
+/**
+ * AdStage SDK - Config 모듈
+ * 설정 관리 및 API 키 검증
+ */
+class ConfigModule {
+    constructor() {
+        this._isReady = false;
+        this._config = null;
+        this._organizationInfo = null;
+    }
+    /**
+     * Config 모듈 초기화 (동기)
+     */
+    init(config) {
+        // 설정만 저장 (서버 검증 없음)
+        this._config = {
+            timeout: 30000,
+            debug: false,
+            modules: ['ads', 'events', 'config'],
+            validateOnInit: false,
+            fallbackMode: true,
+            offlineMode: false,
+            productionMode: false,
+            ...config
+        };
+        // 사용자가 baseUrl을 제공한 경우 endpoints에 설정
+        if (config.baseUrl) {
+            endpoints.setBaseUrl(config.baseUrl);
+        }
+        this._isReady = true;
+        if (config.debug) {
+            console.log('✅ Config module initialized (sync mode)', {
+                modules: this._config.modules,
+                endpoint: endpoints.getBaseUrl(),
+                mode: config.productionMode ? 'production' : 'development'
             });
         }
     }
     /**
-     * 광고 슬롯 새로고침
+     * 모듈 준비 상태 확인
      */
-    async refreshSlot(slotId) {
-        const slot = this.slots.get(slotId);
-        if (slot) {
-            await this.loadSlot(slot);
+    isReady() {
+        return this._isReady;
+    }
+    /**
+     * 현재 설정 반환
+     */
+    getConfig() {
+        return this._config;
+    }
+    /**
+     * 조직 정보 반환
+     */
+    getOrganizationInfo() {
+        return this._organizationInfo;
+    }
+    /**
+     * API 엔드포인트 반환
+     */
+    getApiEndpoint() {
+        return endpoints.getBaseUrl();
+    }
+    /**
+     * 디버그 모드 여부 확인
+     */
+    isDebugMode() {
+        return this._config?.debug || false;
+    }
+    /**
+     * 활성화된 모듈 목록 반환
+     */
+    getEnabledModules() {
+        return this._config?.modules || [];
+    }
+    /**
+     * 특정 모듈이 활성화되어 있는지 확인
+     */
+    isModuleEnabled(moduleName) {
+        return this.getEnabledModules().includes(moduleName);
+    }
+    /**
+     * 설정 업데이트 (런타임)
+     */
+    updateConfig(updates) {
+        if (!this._config) {
+            throw new Error('Config module not initialized');
+        }
+        this._config = {
+            ...this._config,
+            ...updates
+        };
+        if (this.isDebugMode()) {
+            console.log('🔄 Config updated', updates);
         }
     }
     /**
-     * 광고 슬롯 제거
+     * API 헤더 생성 (공통 유틸리티 사용)
      */
-    destroySlot(slotId) {
-        const slot = this.slots.get(slotId);
-        if (slot) {
-            const container = DOMUtils.safeGetElementById(slot.containerId);
-            if (container) {
-                DOMUtils.safeSetInnerHTML(container, '');
+    getApiHeaders() {
+        if (!this._config?.apiKey) {
+            throw new Error('API key not available');
+        }
+        return ApiHeaders.create(this._config.apiKey);
+    }
+}
+
+/**
+ * AdStage SDK - Events 모듈 (기본 구조)
+ * 이벤트 추적 시스템 - Q1 2025 구현 예정
+ */
+class EventsModule {
+    constructor() {
+        this._isReady = false;
+        this._config = null;
+        // === 배치 처리 (향후 구현) ===
+        this.batch = {
+            start: () => {
+                console.log('🚧 [TODO] Batch events start');
+            },
+            add: (eventName, properties) => {
+                console.log('🚧 [TODO] Batch events add:', { eventName, properties });
+            },
+            flush: async () => {
+                console.log('🚧 [TODO] Batch events flush');
             }
-            this.slots.delete(slotId);
-        }
-    }
-    /**
-     * 자동 슬롯 검색 및 로드 (분리된 SDKUtils 사용)
-     */
-    async autoLoadSlots() {
-        const elements = SDKUtils.findAutoSlotElements();
-        for (const element of elements) {
-            const slotInfo = SDKUtils.extractSlotInfo(element);
-            if (!slotInfo.slotId || this.slots.has(slotInfo.slotId))
-                continue;
-            const adType = SDKUtils.parseAdType(slotInfo.adType, AdType);
-            await this.createSlot(slotInfo.slotId, element.id || slotInfo.slotId, adType, {
-                width: slotInfo.width,
-                height: slotInfo.height,
-                language: slotInfo.language,
-                deviceType: slotInfo.deviceType,
-                country: slotInfo.country,
-                sliderEffect: slotInfo.sliderEffect,
-            });
+        };
+        // === 실시간 이벤트 (향후 구현) ===
+        this.realtime = {
+            track: async (eventName, properties) => {
+                console.log('🚧 [TODO] Realtime event tracking:', { eventName, properties });
+            }
+        };
+    }
+    /**
+     * Events 모듈 초기화 (동기)
+     */
+    init(config) {
+        this._config = config;
+        this._isReady = true;
+        if (config.debug) {
+            console.log('📊 Events module initialized (sync mode)');
         }
     }
     /**
-     * SDK 정리
+     * 모듈 준비 상태 확인
      */
-    destroy() {
-        this.slots.clear();
-        ImpressionTracker.clear(); // 노출 추적 데이터도 정리
-        this.initialized = false;
-        AdStageSDK.instance = null;
+    isReady() {
+        return this._isReady;
     }
     /**
-     * 디바이스 ID 가져오기
+     * 모듈 설정 반환
      */
-    getDeviceId() {
-        return DeviceInfoCollector.generateDeviceId();
+    getConfig() {
+        return this._config;
     }
+    // === 향후 구현 예정 메소드들 ===
     /**
-     * 세션 ID 가져오기
+     * 커스텀 이벤트 추적
+     * @example AdStage.events.track('page_view', { page: '/products' })
      */
-    getSessionId() {
-        return DeviceInfoCollector.generateSessionId();
+    async track(eventName, properties) {
+        console.log('🚧 [TODO] Event tracking:', { eventName, properties });
+        // TODO: Q1 2025 구현 예정
     }
     /**
-     * 현재 로드된 슬롯 수 가져오기
+     * 페이지 뷰 이벤트
+     * @example AdStage.events.pageView({ page: '/home', title: 'Homepage' })
      */
-    getLoadedSlotCount() {
-        return this.slots.size;
+    async pageView(pageData) {
+        console.log('🚧 [TODO] Page view tracking:', pageData);
+        // TODO: Q1 2025 구현 예정
     }
     /**
-     * 모든 슬롯 정보 가져오기
+     * 사용자 액션 이벤트
+     * @example AdStage.events.userAction('button_click', { button_id: 'cta' })
      */
-    getAllSlots() {
-        return new Map(this.slots);
+    async userAction(actionType, metadata) {
+        console.log('🚧 [TODO] User action tracking:', { actionType, metadata });
+        // TODO: Q1 2025 구현 예정
+    }
+    /**
+     * 컨버전 이벤트
+     * @example AdStage.events.conversion({ type: 'purchase', value: 99.99 })
+     */
+    async conversion(conversionData) {
+        console.log('🚧 [TODO] Conversion tracking:', conversionData);
+        // TODO: Q1 2025 구현 예정
     }
 }
-AdStageSDK.instance = null;
-async function autoInit() {
-    if (DOMUtils.isBrowser() && window.adstageConfig) {
-        try {
-            const sdk = AdStageSDK.init(window.adstageConfig);
-            await sdk.autoLoadSlots();
+
+/**
+ * AdStage SDK - 메인 네임스페이스 클래스
+ * v2.0.0 - 확장 가능한 모듈 아키텍처
+ */
+class AdStage {
+    constructor() {
+        this._isInitialized = false;
+        this._config = null;
+        // 모듈 초기화 (ads, config는 완전 구현, events는 기본 구조)
+        this.config = new ConfigModule();
+        this.ads = new AdsModule();
+        this.events = new EventsModule();
+    }
+    /**
+     * AdStage SDK 초기화 (동기)
+     */
+    static init(config) {
+        if (!AdStage.instance) {
+            AdStage.instance = new AdStage();
         }
-        catch (error) {
-            console.error('Failed to auto-initialize AdStageSDK:', error);
+        const instance = AdStage.instance;
+        // 설정 검증
+        if (!config.apiKey) {
+            throw new Error('API key is required for AdStage initialization');
+        }
+        // 설정 저장 (서버 검증 없음)
+        instance._config = {
+            timeout: 30000,
+            debug: false,
+            modules: ['ads', 'events', 'config'],
+            validateOnInit: false,
+            fallbackMode: true,
+            offlineMode: false,
+            productionMode: false,
+            ...config
+        };
+        // 모듈 동기 초기화
+        const enabledModules = instance._config.modules || ['ads', 'events', 'config'];
+        for (const moduleName of enabledModules) {
+            const module = instance[moduleName];
+            if (module && typeof module.init === 'function') {
+                module.init(instance._config);
+            }
+        }
+        instance._isInitialized = true;
+        if (config.debug) {
+            console.log('🚀 AdStage SDK initialized (sync mode)', {
+                version: '2.0.0',
+                modules: enabledModules,
+                apiKey: config.apiKey.substring(0, 8) + '...',
+                mode: config.productionMode ? 'production' : 'development'
+            });
         }
     }
-}
-// 브라우저 환경에서 자동 초기화
-if (DOMUtils.isBrowser()) {
-    // 타입 단언을 사용하여 window 객체에 할당
-    window.AdStageSDK = AdStageSDK;
-    // DOM 로드 후 자동 초기화
-    if (DOMUtils.isDOMReady()) {
-        autoInit();
+    /**
+     * SDK 초기화 상태 확인
+     */
+    static isReady() {
+        return AdStage.instance?._isInitialized || false;
     }
-    else {
-        DOMUtils.waitForDOM().then(autoInit);
+    /**
+     * 현재 설정 반환
+     */
+    static getConfig() {
+        return AdStage.instance?._config || null;
+    }
+    /**
+     * SDK 인스턴스 반환 (공개 메소드로 변경)
+     */
+    static getInstance() {
+        if (!AdStage.instance) {
+            throw new Error('AdStage not initialized. Call AdStage.init() first.');
+        }
+        return AdStage.instance;
+    }
+    /**
+     * 편의성을 위한 정적 모듈 접근자들
+     */
+    static get ads() {
+        return AdStage.getInstance().ads;
+    }
+    static get events() {
+        return AdStage.getInstance().events;
+    }
+    static get config() {
+        return AdStage.getInstance().config;
+    }
+    /**
+     * SDK 리셋 (테스트용)
+     */
+    static reset() {
+        if (AdStage.instance) {
+            AdStage.instance._isInitialized = false;
+            AdStage.instance._config = null;
+        }
     }
 }
-// React exports (React가 있을 때만 사용 - 레거시)
-// export * from './react';
 
-var index = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get AdEventType () { return AdEventType; },
-    AdStageSDK: AdStageSDK,
-    get AdType () { return AdType; },
-    createBanner: createBanner,
-    createTextAd: createTextAd,
-    createVideoAd: createVideoAd,
-    default: AdStageSDK,
-    destroyAdStage: destroyAdStage,
-    getAdStageInstance: getAdStageInstance,
-    initAdStage: initAdStage,
-    isAdStageReady: isAdStageReady
-});
+/**
+ * AdStage Web SDK
+ * 네임스페이스 아키텍처 기반 SDK
+ */
+// 메인 네임스페이스 클래스
+// 버전 정보
+const SDK_VERSION = '2.0.0';
+const SUPPORTED_MODULES = ['ads', 'events', 'config'];
 
-export { AdEventType, AdStageSDK, AdType, createBanner, createTextAd, createVideoAd, AdStageSDK as default, destroyAdStage, getAdStageInstance, initAdStage, isAdStageReady };
+export { AdStage, SDK_VERSION, SUPPORTED_MODULES };