@vircle/sdk-web 0.2.0 → 0.2.2

package/dist/index.esm.js

@@ -418,6 +418,12 @@ class LocalStorageAdapter {
     getKey(key) {
         return `${this.prefix}${key}`;
     }
+    /**
+     * 전체 키 반환 (접두사 포함)
+     */
+    getFullKey(key) {
+        return this.getKey(key);
+    }
     /**
      * 값 저장
      *
@@ -493,15 +499,22 @@ class LocalStorageAdapter {
             if (data === null) {
                 return null;
             }
-            const parsed = JSON.parse(data);
-            // 구조가 올바른지 확인 (이전 버전 호환성)
-            if (parsed && typeof parsed === 'object' && 'value' in parsed && 'timestamp' in parsed) {
-                return parsed.value;
+            try {
+                const parsed = JSON.parse(data);
+                // 구조가 올바른지 확인 (이전 버전 호환성)
+                if (parsed && typeof parsed === 'object' && 'value' in parsed && 'timestamp' in parsed) {
+                    return parsed.value;
+                }
+                // 이전 버전 데이터 처리
+                return parsed;
+            }
+            catch (parseError) {
+                console.warn(`[Vircle] Failed to parse stored value for key "${key}":`, parseError);
+                return null;
             }
-            // 이전 버전 데이터 처리
-            return parsed;
         }
-        catch {
+        catch (error) {
+            console.warn(`[Vircle] Failed to get value from localStorage for key "${key}":`, error);
             return null;
         }
     }
@@ -560,10 +573,17 @@ class LocalStorageAdapter {
             // localStorage의 모든 키를 한번에 가져와서 필터링 (성능 최적화)
             const allKeys = Object.keys(localStorage);
             const keysToRemove = allKeys.filter((key) => key.startsWith(this.prefix));
-            keysToRemove.forEach((key) => localStorage.removeItem(key));
+            keysToRemove.forEach((key) => {
+                try {
+                    localStorage.removeItem(key);
+                }
+                catch (error) {
+                    console.warn(`[Vircle] Failed to remove key "${key}" during clear:`, error);
+                }
+            });
         }
-        catch {
-            // 무시
+        catch (error) {
+            console.warn('[Vircle] Failed to clear localStorage:', error);
         }
     }
     /**
@@ -711,271 +731,791 @@ class LocalStorageAdapter {
 }
 
 /**
- * 웹 성능 측정 및 추적
+ * IndexedDB를 사용하는 비동기 스토리지 어댑터
+ *
+ * @description
+ * 브라우저의 IndexedDB API를 활용하여 대용량 데이터를 비동기적으로 저장합니다.
+ * LocalStorage와 달리 메인 스레드를 차단하지 않으며, 더 큰 용량을 지원합니다.
+ *
+ * @example
+ * ```typescript
+ * const storage = new IndexedDBAdapter('vircle_')
+ * await storage.set('user_id', '12345')
+ * const userId = await storage.get('user_id')
+ * ```
  */
-class WebPerformanceTracker {
-    constructor() {
-        this.marks = new Map();
+class IndexedDBAdapter {
+    constructor(prefix = 'vircle_') {
+        this.db = null;
+        this.storeName = 'vircle_store';
+        this.dbVersion = 1;
+        this.initPromise = null;
+        this.isClosed = false;
+        this.prefix = prefix;
+        this.dbName = `${prefix}db`;
     }
     /**
-     * 성능 추적 시작
+     * IndexedDB 초기화
+     *
+     * @description
+     * IndexedDB 연결을 초기화하고 스토어를 생성합니다.
+     * 여러 번 호출되어도 한 번만 초기화됩니다.
+     *
+     * @private
+     * @returns {Promise<void>}
      */
-    startTracking() {
-        if (!this.isSupported()) {
-            return;
+    async init() {
+        // 명시적으로 닫힌 경우 에러 발생
+        if (this.isClosed) {
+            throw new VircleStorageError('IndexedDB adapter가 이미 닫혔습니다');
+        }
+        // 이미 초기화 중이면 기다림
+        if (this.initPromise) {
+            return this.initPromise;
         }
-        // Long Task 감지
-        this.observeLongTasks();
-        // Layout Shift 감지
-        this.observeLayoutShifts();
-        // Largest Contentful Paint 감지
-        this.observeLCP();
-        // First Input Delay 감지
-        this.observeFID();
+        // 이미 초기화됨
+        if (this.db) {
+            return Promise.resolve();
+        }
+        // 동시성 문제 방지를 위해 즉시 Promise 할당
+        this.initPromise = this.openDB();
+        try {
+            await this.initPromise;
+        }
+        catch (error) {
+            // 초기화 실패 시 Promise 초기화하여 재시도 가능하도록 함
+            this.initPromise = null;
+            throw error;
+        }
+        return this.initPromise;
     }
     /**
-     * 성능 추적 중지
+     * IndexedDB 연결 열기
+     *
+     * @private
+     * @returns {Promise<void>}
      */
-    stopTracking() {
-        if (this.observer) {
-            this.observer.disconnect();
-            this.observer = undefined;
-        }
-        this.marks.clear();
+    async openDB() {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.dbName, this.dbVersion);
+            request.onerror = () => {
+                reject(new VircleStorageError('IndexedDB 열기 실패', {
+                    error: request.error?.message,
+                }));
+            };
+            request.onsuccess = () => {
+                this.db = request.result;
+                resolve();
+            };
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                // 스토어가 없으면 생성
+                if (!db.objectStoreNames.contains(this.storeName)) {
+                    const store = db.createObjectStore(this.storeName, { keyPath: 'key' });
+                    store.createIndex('timestamp', 'timestamp', { unique: false });
+                }
+            };
+        });
     }
     /**
-     * Performance API 지원 여부 확인
+     * 키에 접두사 추가
+     *
+     * @private
+     * @param {string} key - 원본 키
+     * @returns {string} 접두사가 추가된 키
      */
-    isSupported() {
-        return (typeof PerformanceObserver !== 'undefined' &&
-            typeof performance !== 'undefined' &&
-            typeof performance.mark === 'function');
+    getKey(key) {
+        return `${this.prefix}${key}`;
     }
     /**
-     * Long Task 감지
+     * 값 저장
+     *
+     * @description
+     * IndexedDB에 값을 비동기적으로 저장합니다.
+     * 메인 스레드를 차단하지 않아 성능이 향상됩니다.
+     *
+     * @template T - 저장할 값의 타입
+     * @param {string} key - 키
+     * @param {T} value - 저장할 값
+     * @returns {Promise<void>}
      */
-    observeLongTasks() {
-        if (!('PerformanceObserver' in window)) {
-            return;
-        }
-        try {
-            const observer = new PerformanceObserver((list) => {
-                for (const entry of list.getEntries()) {
-                    if (entry.duration > 50) {
-                        // 50ms 이상
-                        console.warn('[Vircle] Long task detected:', {
-                            duration: entry.duration,
-                            startTime: entry.startTime,
-                            name: entry.name,
-                        });
+    async set(key, value) {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            if (!this.db) {
+                reject(new VircleStorageError('IndexedDB가 초기화되지 않음'));
+                return;
+            }
+            const transaction = this.db.transaction([this.storeName], 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const item = {
+                key: this.getKey(key),
+                value,
+                timestamp: Date.now(),
+            };
+            const request = store.put(item);
+            request.onerror = () => {
+                reject(new VircleStorageError('IndexedDB 저장 실패', {
+                    key,
+                    error: request.error?.message,
+                }));
+            };
+            request.onsuccess = () => {
+                resolve();
+            };
+        });
+    }
+    /**
+     * 값 가져오기
+     *
+     * @description
+     * IndexedDB에서 값을 비동기적으로 가져옵니다.
+     *
+     * @template T - 반환할 값의 타입
+     * @param {string} key - 키
+     * @returns {Promise<T | null>} 저장된 값 또는 null
+     */
+    async get(key) {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            if (!this.db) {
+                reject(new VircleStorageError('IndexedDB가 초기화되지 않음'));
+                return;
+            }
+            const transaction = this.db.transaction([this.storeName], 'readonly');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.get(this.getKey(key));
+            request.onerror = () => {
+                reject(new VircleStorageError('IndexedDB 읽기 실패', {
+                    key,
+                    error: request.error?.message,
+                }));
+            };
+            request.onsuccess = () => {
+                const result = request.result;
+                if (result && 'value' in result) {
+                    resolve(result.value);
+                }
+                else {
+                    resolve(null);
+                }
+            };
+        });
+    }
+    /**
+     * 값 삭제
+     *
+     * @description
+     * IndexedDB에서 특정 키의 값을 삭제합니다.
+     *
+     * @param {string} key - 키
+     * @returns {Promise<boolean>} 삭제 성공 여부
+     */
+    async remove(key) {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            if (!this.db) {
+                reject(new VircleStorageError('IndexedDB가 초기화되지 않음'));
+                return;
+            }
+            const transaction = this.db.transaction([this.storeName], 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.delete(this.getKey(key));
+            request.onerror = () => {
+                reject(new VircleStorageError('IndexedDB 삭제 실패', {
+                    key,
+                    error: request.error?.message,
+                }));
+            };
+            request.onsuccess = () => {
+                resolve(true);
+            };
+        });
+    }
+    /**
+     * 모든 값 삭제
+     *
+     * @description
+     * 현재 접두사로 시작하는 모든 키의 값을 삭제합니다.
+     *
+     * @returns {Promise<void>}
+     */
+    async clear() {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            if (!this.db) {
+                reject(new VircleStorageError('IndexedDB가 초기화되지 않음'));
+                return;
+            }
+            const transaction = this.db.transaction([this.storeName], 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            // 모든 키를 가져와서 prefix로 필터링
+            const request = store.openCursor();
+            const keysToDelete = [];
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor) {
+                    if (cursor.key.toString().startsWith(this.prefix)) {
+                        keysToDelete.push(cursor.key);
                     }
+                    cursor.continue();
                 }
-            });
-            observer.observe({ entryTypes: ['longtask'] });
-        }
-        catch {
-            // Long Task API를 지원하지 않는 브라우저
-        }
+                else {
+                    // 모든 키 순회 완료, 삭제 시작
+                    const deletePromises = keysToDelete.map(key => {
+                        return new Promise((resolveDelete, rejectDelete) => {
+                            const deleteRequest = store.delete(key);
+                            deleteRequest.onsuccess = () => resolveDelete();
+                            deleteRequest.onerror = () => rejectDelete(deleteRequest.error);
+                        });
+                    });
+                    Promise.all(deletePromises)
+                        .then(() => resolve())
+                        .catch(error => reject(new VircleStorageError('일부 항목 삭제 실패', { error })));
+                }
+            };
+            request.onerror = () => {
+                reject(new VircleStorageError('IndexedDB 커서 열기 실패', {
+                    error: request.error?.message,
+                }));
+            };
+        });
     }
     /**
-     * Layout Shift 감지
+     * 키 존재 여부 확인
+     *
+     * @param {string} key - 키
+     * @returns {Promise<boolean>} 존재 여부
      */
-    observeLayoutShifts() {
-        if (!('PerformanceObserver' in window)) {
-            return;
-        }
-        try {
-            const observer = new PerformanceObserver((list) => {
-                for (const entry of list.getEntries()) {
-                    const layoutShiftEntry = entry;
-                    if (!layoutShiftEntry.hadRecentInput) {
-                        // CLS would be tracked here: layoutShiftEntry.value
+    async has(key) {
+        const value = await this.get(key);
+        return value !== null;
+    }
+    /**
+     * 저장된 항목 수
+     *
+     * @description
+     * 현재 접두사로 저장된 모든 항목의 개수를 반환합니다.
+     *
+     * @returns {Promise<number>} 항목 수
+     */
+    async size() {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            if (!this.db) {
+                reject(new VircleStorageError('IndexedDB가 초기화되지 않음'));
+                return;
+            }
+            const transaction = this.db.transaction([this.storeName], 'readonly');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.openCursor();
+            let count = 0;
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor) {
+                    if (cursor.key.toString().startsWith(this.prefix)) {
+                        count++;
                     }
+                    cursor.continue();
                 }
-            });
-            observer.observe({ entryTypes: ['layout-shift'] });
-        }
-        catch {
-            // Layout Shift API를 지원하지 않는 브라우저
-        }
+                else {
+                    resolve(count);
+                }
+            };
+            request.onerror = () => {
+                reject(new VircleStorageError('IndexedDB 카운트 실패', {
+                    error: request.error?.message,
+                }));
+            };
+        });
     }
     /**
-     * Largest Contentful Paint 감지
+     * 모든 키 반환
+     *
+     * @description
+     * 현재 접두사로 저장된 모든 키를 배열로 반환합니다.
+     *
+     * @returns {Promise<string[]>} 키 배열
      */
-    observeLCP() {
-        if (!('PerformanceObserver' in window)) {
-            return;
-        }
-        try {
-            const observer = new PerformanceObserver((list) => {
-                const entries = list.getEntries();
-                if (entries.length > 0) {
-                    // LCP tracked: entries[entries.length - 1].startTime
+    async keys() {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            if (!this.db) {
+                reject(new VircleStorageError('IndexedDB가 초기화되지 않음'));
+                return;
+            }
+            const transaction = this.db.transaction([this.storeName], 'readonly');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.openCursor();
+            const keys = [];
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor) {
+                    const key = cursor.key.toString();
+                    if (key.startsWith(this.prefix)) {
+                        keys.push(key.substring(this.prefix.length));
+                    }
+                    cursor.continue();
                 }
-            });
-            observer.observe({ entryTypes: ['largest-contentful-paint'] });
-        }
-        catch {
-            // LCP API를 지원하지 않는 브라우저
-        }
+                else {
+                    resolve(keys);
+                }
+            };
+            request.onerror = () => {
+                reject(new VircleStorageError('IndexedDB 키 조회 실패', {
+                    error: request.error?.message,
+                }));
+            };
+        });
     }
     /**
-     * First Input Delay 감지
+     * 오래된 항목 정리 (LRU 방식)
+     *
+     * @description
+     * 용량이 부족할 때 타임스탬프 기준으로 오래된 항목을 삭제합니다.
+     *
+     * @param {number} percentage - 삭제할 비율 (0-1)
+     * @returns {Promise<void>}
      */
-    observeFID() {
-        if (!('PerformanceObserver' in window)) {
-            return;
-        }
-        try {
-            const observer = new PerformanceObserver((list) => {
-                for (const entry of list.getEntries()) {
-                    const fidEntry = entry;
-                    if (fidEntry.processingStart && fidEntry.startTime) {
-                        // FID tracked: fidEntry.processingStart - fidEntry.startTime
+    async clearOldItems(percentage = 0.2) {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            if (!this.db) {
+                reject(new VircleStorageError('IndexedDB가 초기화되지 않음'));
+                return;
+            }
+            const transaction = this.db.transaction([this.storeName], 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const index = store.index('timestamp');
+            const request = index.openCursor();
+            const items = [];
+            request.onsuccess = async () => {
+                const cursor = request.result;
+                if (cursor) {
+                    const primaryKey = cursor.primaryKey;
+                    if (primaryKey.startsWith(this.prefix)) {
+                        items.push({
+                            key: primaryKey,
+                            timestamp: cursor.value.timestamp,
+                        });
                     }
+                    cursor.continue();
                 }
-            });
-            observer.observe({ entryTypes: ['first-input'] });
-        }
-        catch {
-            // FID API를 지원하지 않는 브라우저
-        }
+                else {
+                    // 타임스탬프로 정렬
+                    items.sort((a, b) => a.timestamp - b.timestamp);
+                    // 삭제할 개수 계산
+                    const deleteCount = Math.max(1, Math.floor(items.length * percentage));
+                    const keysToDelete = items.slice(0, deleteCount).map(item => item.key);
+                    // 삭제 실행
+                    const deletePromises = keysToDelete.map(key => {
+                        return new Promise((resolveDelete, rejectDelete) => {
+                            const deleteRequest = store.delete(key);
+                            deleteRequest.onsuccess = () => resolveDelete();
+                            deleteRequest.onerror = () => rejectDelete(deleteRequest.error);
+                        });
+                    });
+                    Promise.all(deletePromises)
+                        .then(() => resolve())
+                        .catch(error => reject(new VircleStorageError('일부 항목 삭제 실패', { error })));
+                }
+            };
+            request.onerror = () => {
+                reject(new VircleStorageError('IndexedDB 인덱스 조회 실패', {
+                    error: request.error?.message,
+                }));
+            };
+        });
     }
     /**
-     * 커스텀 성능 마크 시작
-     * @param name - 마크 이름
+     * 연결 종료
+     *
+     * @description
+     * IndexedDB 연결을 명시적으로 종료합니다.
+     *
+     * @returns {Promise<void>}
      */
-    mark(name) {
-        if (!this.isSupported()) {
-            return;
+    async close() {
+        this.isClosed = true;
+        if (this.db) {
+            this.db.close();
+            this.db = null;
         }
-        performance.mark(`vircle_${name}_start`);
-        this.marks.set(name, performance.now());
+        this.initPromise = null;
     }
+}
+
+/**
+ * 스토리지 어댑터 팩토리
+ *
+ * @description
+ * 환경과 요구사항에 맞는 최적의 스토리지 어댑터를 생성합니다.
+ * IndexedDB를 우선 사용하고, 지원하지 않으면 LocalStorage로 폴백합니다.
+ */
+class StorageFactory {
     /**
-     * 커스텀 성능 측정
-     * @param name - 마크 이름
-     * @returns 측정된 시간 (ms)
+     * 스토리지 어댑터 생성 (동기)
+     *
+     * @description
+     * 동기적으로 스토리지 어댑터를 생성합니다.
+     * 'auto' 모드에서는 API 존재 여부만 확인하고 IndexedDB를 우선 사용합니다.
+     * Safari Private 모드 등에서 실제 사용 불가 시 런타임 에러가 발생할 수 있습니다.
+     *
+     * @param {string} prefix - 키 접두사
+     * @param {StorageType} type - 스토리지 타입
+     * @returns {StorageAdapter} 생성된 스토리지 어댑터
      */
-    measure(name) {
-        if (!this.isSupported() || !this.marks.has(name)) {
-            return null;
+    static create(prefix = 'vircle_', type = 'auto') {
+        switch (type) {
+            case 'localStorage':
+                return new LocalStorageAdapter(prefix);
+            case 'indexedDB':
+                return new IndexedDBAdapter(prefix);
+            case 'auto':
+            default:
+                return this.createAuto(prefix);
         }
-        const startTime = this.marks.get(name);
-        const duration = performance.now() - startTime;
-        performance.mark(`vircle_${name}_end`);
-        performance.measure(`vircle_${name}`, `vircle_${name}_start`, `vircle_${name}_end`);
-        this.marks.delete(name);
-        return duration;
     }
     /**
-     * 페이지 로드 메트릭 가져오기
+     * 스토리지 어댑터 생성 (비동기, 권장)
+     *
+     * @description
+     * 비동기적으로 스토리지 어댑터를 생성합니다.
+     * 'auto' 모드에서는 실제 IndexedDB 사용 가능 여부를 테스트한 후 결정합니다.
+     * Safari Private 모드 등에서도 안전하게 LocalStorage로 폴백됩니다.
+     *
+     * @param {string} prefix - 키 접두사
+     * @param {StorageType} type - 스토리지 타입
+     * @returns {Promise<StorageAdapter>} 생성된 스토리지 어댑터
      */
-    getLoadMetrics() {
-        if (!performance || !performance.timing) {
-            return {};
+    static async createAsync(prefix = 'vircle_', type = 'auto') {
+        switch (type) {
+            case 'localStorage':
+                return new LocalStorageAdapter(prefix);
+            case 'indexedDB':
+                return new IndexedDBAdapter(prefix);
+            case 'auto':
+            default:
+                return this.createAutoAsync(prefix);
         }
-        const timing = performance.timing;
-        const metrics = {};
-        // DNS 조회 시간
-        if (timing.domainLookupEnd && timing.domainLookupStart) {
-            metrics.dns = timing.domainLookupEnd - timing.domainLookupStart;
-        }
-        // TCP 연결 시간
-        if (timing.connectEnd && timing.connectStart) {
-            metrics.tcp = timing.connectEnd - timing.connectStart;
+    }
+    /**
+     * 자동으로 최적의 스토리지 선택 (비동기)
+     *
+     * @private
+     * @param {string} prefix - 키 접두사
+     * @returns {Promise<StorageAdapter>} 선택된 스토리지 어댑터
+     */
+    static async createAutoAsync(prefix) {
+        // IndexedDB 실제 사용 가능 여부 확인 (비동기)
+        const isIndexedDBAvailable = await this.isIndexedDBAvailableAsync();
+        if (isIndexedDBAvailable) {
+            return new IndexedDBAdapter(prefix);
         }
-        // 요청 시간
-        if (timing.responseStart && timing.requestStart) {
-            metrics.request = timing.responseStart - timing.requestStart;
+        return new LocalStorageAdapter(prefix);
+    }
+    /**
+     * 자동으로 최적의 스토리지 선택
+     *
+     * @private
+     * @param {string} prefix - 키 접두사
+     * @returns {StorageAdapter} 선택된 스토리지 어댑터
+     */
+    static createAuto(prefix) {
+        // IndexedDB 지원 여부 확인
+        if (this.isIndexedDBAvailable()) {
+            try {
+                const adapter = new IndexedDBAdapter(prefix);
+                return adapter;
+            }
+            catch (error) {
+                console.warn('[Vircle] IndexedDB 초기화 실패, LocalStorage로 폴백합니다:', error);
+            }
         }
-        // 응답 시간
-        if (timing.responseEnd && timing.responseStart) {
-            metrics.response = timing.responseEnd - timing.responseStart;
+        // LocalStorage로 폴백
+        return new LocalStorageAdapter(prefix);
+    }
+    /**
+     * IndexedDB 사용 가능 여부 확인 (동기)
+     *
+     * @description
+     * API 존재 여부만 동기적으로 확인합니다.
+     * Safari Private 모드 등에서의 실제 사용 가능 여부는 IndexedDBAdapter.init()에서 확인됩니다.
+     *
+     * @private
+     * @returns {boolean} API 존재 여부
+     */
+    static isIndexedDBAvailable() {
+        try {
+            // 기본 API 존재 확인만 수행 (동기)
+            // 실제 사용 가능 여부(Safari Private 모드 등)는
+            // IndexedDBAdapter.init()에서 비동기로 확인됨
+            return typeof window !== 'undefined' && !!window.indexedDB;
         }
-        // DOM 처리 시간
-        if (timing.domComplete && timing.domLoading) {
-            metrics.domProcessing = timing.domComplete - timing.domLoading;
+        catch {
+            return false;
         }
-        // 페이지 로드 완료 시간
-        if (timing.loadEventEnd && timing.navigationStart) {
-            metrics.pageLoad = timing.loadEventEnd - timing.navigationStart;
+    }
+    /**
+     * IndexedDB 사용 가능 여부 확인 (비동기)
+     *
+     * @description
+     * 실제로 IndexedDB를 열어서 사용 가능 여부를 확인합니다.
+     * Safari Private 모드 등에서의 제한도 감지합니다.
+     *
+     * @returns {Promise<boolean>} 사용 가능 여부
+     */
+    static async isIndexedDBAvailableAsync() {
+        if (typeof window === 'undefined' || !window.indexedDB) {
+            return false;
         }
-        return metrics;
+        return new Promise((resolve) => {
+            try {
+                const request = indexedDB.open('vircle_availability_test');
+                request.onsuccess = () => {
+                    request.result.close();
+                    indexedDB.deleteDatabase('vircle_availability_test');
+                    resolve(true);
+                };
+                request.onerror = () => {
+                    resolve(false);
+                };
+                // Safari Private 모드에서 발생할 수 있는 blocked 이벤트
+                request.onblocked = () => {
+                    resolve(false);
+                };
+            }
+            catch {
+                resolve(false);
+            }
+        });
     }
     /**
-     * 리소스 타이밍 데이터 가져오기
+     * LocalStorage 사용 가능 여부 확인
+     *
+     * @returns {boolean} 사용 가능 여부
      */
-    getResourceTimings() {
-        if (!performance || !performance.getEntriesByType) {
-            return [];
+    static isLocalStorageAvailable() {
+        try {
+            const testKey = '__vircle_test__';
+            localStorage.setItem(testKey, 'test');
+            localStorage.removeItem(testKey);
+            return true;
+        }
+        catch {
+            return false;
         }
-        const resources = performance.getEntriesByType('resource');
-        return resources.map((resource) => ({
-            name: resource.name,
-            type: resource.initiatorType,
-            duration: resource.duration,
-            size: resource.transferSize || 0,
-        }));
     }
 }
+
 /**
- * 함수 실행 시간 측정 데코레이터
- */
-function measurePerformance(target, propertyKey, descriptor) {
-    const originalMethod = descriptor.value;
-    descriptor.value = async function (...args) {
-        const start = performance.now();
-        const result = await originalMethod.apply(this, args);
-        performance.now() - start;
-        return result;
-    };
-    return descriptor;
-}
-/**
- * 디바운스 유틸리티
- * @param func - 디바운스할 함수
- * @param wait - 대기 시간 (ms)
- * @returns 디바운스된 함수
+ * Web Crypto API 기반 암호화 어댑터
+ *
+ * @description
+ * 브라우저의 Web Crypto API를 사용하여 하이브리드 암호화(AES-256-GCM + RSA-OAEP)를 구현합니다.
+ * 모든 암호화 작업은 브라우저의 네이티브 암호화 엔진을 사용하여 보안성과 성능을 보장합니다.
  */
-function debounce(func, wait) {
-    let timeoutId = null;
-    return function debounced(...args) {
-        if (timeoutId) {
-            clearTimeout(timeoutId);
-        }
-        timeoutId = setTimeout(() => {
-            func(...args);
-            timeoutId = null;
-        }, wait);
-    };
-}
 /**
- * 쓰로틀 유틸리티
- * @param func - 쓰로틀할 함수
- * @param limit - 제한 시간 (ms)
- * @returns 쓰로틀된 함수
+ * Web Crypto API를 사용하는 ExtendedCryptoAdapter 구현
  */
-function throttle(func, limit) {
-    let inThrottle = false;
-    let lastArgs = null;
-    return function throttled(...args) {
-        if (!inThrottle) {
-            func(...args);
-            inThrottle = true;
-            setTimeout(() => {
-                inThrottle = false;
-                if (lastArgs) {
-                    const args = lastArgs;
-                    lastArgs = null;
-                    throttled(...args);
-                }
-            }, limit);
+class WebExtendedCryptoAdapter {
+    constructor() {
+        this.crypto = null;
+        this.subtle = null;
+        this.available = false;
+        this.initCrypto();
+    }
+    /**
+     * Web Crypto API 초기화
+     */
+    initCrypto() {
+        try {
+            if (typeof window !== 'undefined' && window.crypto && window.crypto.subtle) {
+                this.crypto = window.crypto;
+                this.subtle = window.crypto.subtle;
+                this.available = true;
+            }
+            else if (typeof globalThis !== 'undefined' && globalThis.crypto && globalThis.crypto.subtle) {
+                this.crypto = globalThis.crypto;
+                this.subtle = globalThis.crypto.subtle;
+                this.available = true;
+            }
         }
-        else {
-            lastArgs = args;
+        catch (error) {
+            console.warn('[Vircle] Web Crypto API를 사용할 수 없습니다:', error);
+            this.available = false;
+        }
+    }
+    /**
+     * UUID v4 생성
+     */
+    generateUUID() {
+        if (this.crypto && typeof this.crypto.randomUUID === 'function') {
+            return this.crypto.randomUUID();
+        }
+        // Fallback: crypto.getRandomValues 사용
+        if (this.crypto) {
+            const bytes = new Uint8Array(16);
+            this.crypto.getRandomValues(bytes);
+            // Set version (4) and variant bits
+            bytes[6] = (bytes[6] & 0x0f) | 0x40;
+            bytes[8] = (bytes[8] & 0x3f) | 0x80;
+            // Convert to UUID string format
+            const hex = Array.from(bytes)
+                .map((b) => b.toString(16).padStart(2, '0'))
+                .join('');
+            return [
+                hex.substring(0, 8),
+                hex.substring(8, 12),
+                hex.substring(12, 16),
+                hex.substring(16, 20),
+                hex.substring(20, 32),
+            ].join('-');
+        }
+        // Final fallback (less secure)
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    /**
+     * HMAC-SHA256 서명 생성
+     */
+    async createHmacSignature(payload, secret) {
+        if (!this.subtle) {
+            throw new Error('Web Crypto API is required for HMAC operations');
+        }
+        const encoder = new TextEncoder();
+        const data = JSON.stringify(payload);
+        // Import secret key
+        const keyData = encoder.encode(secret);
+        const key = await this.subtle.importKey('raw', keyData, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+        // Sign data
+        const signature = await this.subtle.sign('HMAC', key, encoder.encode(data));
+        // Convert to hex string
+        return this.arrayBufferToHex(signature);
+    }
+    /**
+     * 하이브리드 암호화 (AES-256-GCM + RSA-OAEP)
+     *
+     * @description
+     * 1. AES-256-GCM으로 데이터 암호화
+     * 2. RSA-OAEP로 AES 키 암호화
+     */
+    async encryptPayload(data, publicKeyBase64) {
+        if (!this.subtle || !this.crypto) {
+            throw new Error('Web Crypto API is required for encryption operations');
+        }
+        let step = 'initialization';
+        try {
+            step = 'JSON serialization';
+            const jsonStr = JSON.stringify(data);
+            const encoder = new TextEncoder();
+            const dataBytes = encoder.encode(jsonStr);
+            // 1. Generate AES-256-GCM key
+            step = 'AES key generation';
+            const aesKey = await this.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt']);
+            // 2. Generate IV (96-bit for GCM)
+            step = 'IV generation';
+            const iv = this.crypto.getRandomValues(new Uint8Array(12));
+            // 3. Encrypt data with AES-GCM
+            step = 'AES-GCM encryption';
+            const encryptedData = await this.subtle.encrypt({ name: 'AES-GCM', iv, tagLength: 128 }, aesKey, dataBytes);
+            // AES-GCM returns ciphertext + authTag concatenated
+            // authTag is the last 16 bytes (128 bits)
+            const encryptedBytes = new Uint8Array(encryptedData);
+            const ciphertext = encryptedBytes.slice(0, -16);
+            const authTag = encryptedBytes.slice(-16);
+            // 4. Export AES key as raw bytes
+            step = 'AES key export';
+            const rawAesKey = await this.subtle.exportKey('raw', aesKey);
+            // 5. Import RSA public key
+            step = 'RSA public key import';
+            const rsaPublicKey = await this.importRsaPublicKey(publicKeyBase64);
+            // 6. Encrypt AES key with RSA-OAEP
+            step = 'RSA-OAEP encryption';
+            const encryptedKey = await this.subtle.encrypt({ name: 'RSA-OAEP' }, rsaPublicKey, rawAesKey);
+            // 7. Convert to base64 for transport
+            step = 'Base64 encoding';
+            return {
+                data: this.arrayBufferToBase64(ciphertext),
+                key: this.arrayBufferToBase64(encryptedKey),
+                iv: this.arrayBufferToBase64(iv),
+                authTag: this.arrayBufferToBase64(authTag),
+                metadata: {
+                    algorithm: 'AES-256-GCM',
+                    keyAlgorithm: 'RSA-OAEP',
+                    timestamp: new Date().toISOString(),
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`[WebExtendedCryptoAdapter] Encryption failed at step '${step}': ${errorMessage}`);
         }
-    };
+    }
+    /**
+     * Web Crypto API 사용 가능 여부
+     */
+    isAvailable() {
+        return this.available;
+    }
+    /**
+     * RSA 공개키 가져오기 (PEM/Base64 → CryptoKey)
+     */
+    async importRsaPublicKey(publicKeyBase64) {
+        if (!this.subtle) {
+            throw new Error('Web Crypto API is not available');
+        }
+        // Clean PEM headers and whitespace
+        const cleanedKey = publicKeyBase64
+            .replace(/-----BEGIN PUBLIC KEY-----/g, '')
+            .replace(/-----END PUBLIC KEY-----/g, '')
+            .replace(/-----BEGIN RSA PUBLIC KEY-----/g, '')
+            .replace(/-----END RSA PUBLIC KEY-----/g, '')
+            .replace(/\s/g, '');
+        // Decode base64 to ArrayBuffer
+        const keyData = this.base64ToArrayBuffer(cleanedKey);
+        // Import as SPKI format
+        return await this.subtle.importKey('spki', keyData, {
+            name: 'RSA-OAEP',
+            hash: 'SHA-256',
+        }, false, ['encrypt']);
+    }
+    /**
+     * ArrayBuffer를 Base64 문자열로 변환
+     */
+    arrayBufferToBase64(buffer) {
+        const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+        let binary = '';
+        const chunkSize = 0x8000; // 32KB chunks
+        for (let i = 0; i < bytes.length; i += chunkSize) {
+            const chunk = bytes.slice(i, Math.min(i + chunkSize, bytes.length));
+            binary += String.fromCharCode.apply(null, Array.from(chunk));
+        }
+        return btoa(binary);
+    }
+    /**
+     * Base64 문자열을 ArrayBuffer로 변환
+     */
+    base64ToArrayBuffer(base64) {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    /**
+     * ArrayBuffer를 Hex 문자열로 변환
+     */
+    arrayBufferToHex(buffer) {
+        const bytes = new Uint8Array(buffer);
+        return Array.from(bytes)
+            .map((b) => b.toString(16).padStart(2, '0'))
+            .join('');
+    }
 }
 
 /**
@@ -994,27 +1534,38 @@ function throttle(func, limit) {
  */
 class VircleWeb extends VircleCore {
     constructor(config, options = {}) {
-        // 웹 환경용 스토리지 어댑터 설정
-        const storageAdapter = new LocalStorageAdapter(config.storagePrefix);
+        // 웹 환경용 스토리지 어댑터 설정 - 성능 최적화를 위해 StorageFactory 사용
+        const storageAdapter = StorageFactory.create(config.storagePrefix || 'vircle_', config.storageType || 'auto');
+        // 암호화 어댑터 초기화
+        let cryptoAdapter;
+        if (config.enableEncryption || options.enableEncryption) {
+            cryptoAdapter = new WebExtendedCryptoAdapter();
+            if (cryptoAdapter.isAvailable()) ;
+            else {
+                console.warn('[Vircle] Web Crypto API를 사용할 수 없습니다. 암호화를 비활성화합니다.');
+                cryptoAdapter = undefined;
+            }
+        }
         const coreOptions = {
             ...options,
             storageAdapter,
+            cryptoAdapter,
+            enableEncryption: cryptoAdapter?.isAvailable() ?? false,
         };
         super(config, coreOptions);
         this.pageViewTracked = false;
+        this.lastActivityTime = Date.now();
         this.webConfig = config;
         this.webOptions = {
             flushOnUnload: true,
             contextCacheTime: 300000, // 5분
             idleScheduler: new WebIdleScheduler(),
-            enablePerformance: true,
             ...options,
         };
         // 웹 환경 전용 컴포넌트 초기화
         this.contextCollector = new WebContextCollector();
-        if (this.webOptions.enablePerformance) {
-            this.performanceTracker = new WebPerformanceTracker();
-        }
+        // 세션 타임아웃 설정 (기본 30분)
+        this.sessionTimeout = config.sessionTimeout ?? 30 * 60 * 1000;
     }
     /**
      * SDK 초기화 및 자동 추적 설정
@@ -1050,16 +1601,22 @@ class VircleWeb extends VircleCore {
                 await this.trackPageView();
                 this.pageViewTracked = true;
             }
-            // 성능 메트릭 수집 시작
-            if (this.performanceTracker) {
-                this.performanceTracker.startTracking();
-            }
         }
         catch (error) {
             console.error('[Vircle] 초기화 실패:', error);
             throw error;
         }
     }
+    /**
+     * 사용자 식별 (컨텍스트 캐시 무효화 포함)
+     *
+     * @description
+     * 사용자를 식별하고 컨텍스트 캐시를 무효화하여 이후 이벤트에 정확한 컨텍스트가 포함되도록 합니다.
+     */
+    async identify(userId, traits) {
+        this.contextCache.invalidate();
+        return super.identify(userId, traits);
+    }
     /**
      * 페이지뷰 추적
      *
@@ -1091,10 +1648,11 @@ class VircleWeb extends VircleCore {
     }
     /**
      * 웹 환경에 최적화된 이벤트 추적
-     * AIDEV-NOTE: 이제 코어의 TaskScheduler를 사용하여 requestIdleCallback 기반의
+     * 이제 코어의 TaskScheduler를 사용하여 requestIdleCallback 기반의
      * 일관된 성능 최적화 구현
      */
     async track(name, properties, context) {
+        this.lastActivityTime = Date.now();
         return new Promise((resolve) => {
             this.taskScheduler.enqueue(async () => {
                 try {
@@ -1123,7 +1681,7 @@ class VircleWeb extends VircleCore {
      * @private
      * @returns {Promise<EventContext>} 이벤트 컨텍스트
      *
-     * AIDEV-NOTE: 컨텍스트 수집은 DOM 접근이 많아 비용이 높으므로
+     * 컨텍스트 수집은 DOM 접근이 많아 비용이 높으므로
      * 캐싱을 통해 성능을 최적화. 중복 수집 방지를 위한 Promise 재사용 구현
      */
     async getCachedContext() {
@@ -1139,29 +1697,22 @@ class VircleWeb extends VircleCore {
      * @private
      */
     setupAutoTracking() {
-        // 페이지 언로드 시 플러시
+        // 페이지 언로드 시 sendBeacon으로 전송
         if (this.webOptions.flushOnUnload) {
-            this.unloadHandler = async () => {
-                try {
-                    // 대기 중인 idle 작업들 먼저 처리
-                    // Flush any pending tasks
-                    await this.flush();
-                    // 이벤트 플러시
-                    await this.flush();
-                }
-                catch (error) {
-                    console.warn('[Vircle] 언로드 시 플러시 실패:', error);
-                }
+            this.unloadHandler = () => {
+                this.transportService.flushViaBeacon();
             };
             window.addEventListener('beforeunload', this.unloadHandler);
-            // visibilitychange 이벤트도 처리 (모바일 브라우저 대응)
-            document.addEventListener('visibilitychange', () => {
+            // visibilitychange 이벤트 처리 (sendBeacon + 세션 타임아웃)
+            this.visibilityChangeHandler = () => {
                 if (document.visibilityState === 'hidden') {
-                    this.flush().catch((error) => {
-                        console.warn('[Vircle] 백그라운드 전환 시 플러시 실패:', error);
-                    });
+                    this.transportService.flushViaBeacon();
                 }
-            });
+                else if (document.visibilityState === 'visible') {
+                    this.checkSessionTimeout();
+                }
+            };
+            document.addEventListener('visibilitychange', this.visibilityChangeHandler);
         }
         // 에러 추적
         if (this.webConfig.trackErrors) {
@@ -1271,16 +1822,23 @@ class VircleWeb extends VircleCore {
      * @private
      */
     setupSPATracking() {
+        // 원래 함수 저장
+        this.originalPushState = history.pushState;
+        this.originalReplaceState = history.replaceState;
         // pushState/replaceState 래핑
-        const originalPushState = history.pushState;
-        const originalReplaceState = history.replaceState;
         history.pushState = (...args) => {
-            originalPushState.apply(history, args);
-            this.handleRouteChange();
+            this.originalPushState.apply(history, args);
+            try {
+                this.handleRouteChange();
+            }
+            catch (_) { /* SDK 오류가 호스트 앱 라우팅에 영향 주지 않도록 */ }
         };
         history.replaceState = (...args) => {
-            originalReplaceState.apply(history, args);
-            this.handleRouteChange();
+            this.originalReplaceState.apply(history, args);
+            try {
+                this.handleRouteChange();
+            }
+            catch (_) { /* SDK 오류가 호스트 앱 라우팅에 영향 주지 않도록 */ }
         };
         // popstate 이벤트 리스너
         this.popstateHandler = () => {
@@ -1307,6 +1865,34 @@ class VircleWeb extends VircleCore {
             });
         }
     }
+    /**
+     * 세션 타임아웃 체크
+     *
+     * @description
+     * 마지막 활동 시간으로부터 세션 타임아웃이 경과했는지 확인합니다.
+     * 만료 시 새 세션을 생성하고 session_start 이벤트를 추적합니다.
+     *
+     * @private
+     */
+    checkSessionTimeout() {
+        const now = Date.now();
+        const elapsed = now - this.lastActivityTime;
+        if (elapsed >= this.sessionTimeout) {
+            const newSessionId = `sess_${now}_${Math.random().toString(36).substr(2, 9)}`;
+            this.setSessionId(newSessionId);
+            this.lastActivityTime = now;
+            this.contextCache.invalidate();
+            this.track('session_start', {
+                reason: 'timeout',
+                previous_session_duration: elapsed,
+            }).catch((error) => {
+                console.warn('[Vircle] 세션 시작 추적 실패:', error);
+            });
+        }
+        else {
+            this.lastActivityTime = now;
+        }
+    }
     /**
      * 요소가 추적 대상인지 확인
      *
@@ -1368,8 +1954,8 @@ class VircleWeb extends VircleCore {
                 this.track('element_data_collected', {
                     ...properties,
                     data_attributes: dataAttributes,
-                }).catch((error) => {
-                    console.debug('[Vircle] Data attributes collection failed:', error);
+                }).catch(() => {
+                    // data attributes 수집 실패는 무시
                 });
             }
         });
@@ -1411,12 +1997,20 @@ class VircleWeb extends VircleCore {
             if (this.submitHandler) {
                 document.removeEventListener('submit', this.submitHandler, true);
             }
+            if (this.visibilityChangeHandler) {
+                document.removeEventListener('visibilitychange', this.visibilityChangeHandler);
+            }
             if (this.popstateHandler) {
                 window.removeEventListener('popstate', this.popstateHandler);
             }
-            // 성능 추적 정지
-            if (this.performanceTracker) {
-                this.performanceTracker.stopTracking();
+            // History API 원본 복원
+            if (this.originalPushState) {
+                history.pushState = this.originalPushState;
+                this.originalPushState = undefined;
+            }
+            if (this.originalReplaceState) {
+                history.replaceState = this.originalReplaceState;
+                this.originalReplaceState = undefined;
             }
             // Idle 작업 정리
             // Flush pending tasks
@@ -1468,5 +2062,5 @@ class VircleWeb extends VircleCore {
     }
 }
 
-export { LocalStorageAdapter, VircleBrowserCompatibilityError, VircleConfigError, VircleInitializationError, VircleStorageError, VircleWeb, VircleWebError, WebContextCollector, WebPerformanceTracker, debounce, VircleWeb as default, measurePerformance, throttle };
+export { IndexedDBAdapter, LocalStorageAdapter, StorageFactory, VircleBrowserCompatibilityError, VircleConfigError, VircleInitializationError, VircleStorageError, VircleWeb, VircleWebError, WebContextCollector, WebExtendedCryptoAdapter, VircleWeb as default };
 //# sourceMappingURL=index.esm.js.map