customer-chat-sdk 1.0.67 → 1.0.70

package/dist/customer-sdk.esm.js

@@ -14334,11 +14334,12 @@ class ScreenshotManager {
         this.dynamicInterval = null;
         // 过期定时器
         this.expirationTimer = null;
+        // 当前任务完成标志（用于串行定时任务）
+        this.isCurrentTaskCompleted = true;
+        // 保存 scheduleNext 函数引用（用于在压缩完成后触发下一次任务）
+        this.scheduleNextFn = null;
         // 图片代理缓存（带过期时间）
         this.imageProxyCache = new Map();
-        // IndexedDB 缓存（持久化）
-        this.indexedDBCache = null;
-        this.indexedDBReady = false;
         // Intersection Observer（用于高效检测可见性）
         this.intersectionObserver = null;
         this.visibleElementsCache = new Set();
@@ -14373,13 +14374,10 @@ class ScreenshotManager {
             maxConcurrentDownloads: options.maxConcurrentDownloads ?? 10, // 增加并发数
             onlyVisibleImages: options.onlyVisibleImages ?? true, // 默认只处理可视区域
             imageCacheTTL: options.imageCacheTTL ?? 600000, // 默认10分钟（600000ms）
-            useIndexedDB: options.useIndexedDB ?? true, // 默认启用 IndexedDB 持久化缓存
             usePreconnect: options.usePreconnect ?? true, // 默认预连接代理服务器
             imageLoadTimeout: options.imageLoadTimeout ?? 5000, // 默认5秒超时
             useIntersectionObserver: options.useIntersectionObserver ?? true, // 默认使用 Intersection Observer
             fetchPriority: options.fetchPriority ?? 'high', // 默认高优先级
-            maxCacheSize: options.maxCacheSize ?? 50, // 默认最大50MB
-            maxCacheAge: options.maxCacheAge ?? 86400000, // 默认24小时（86400000ms）
             maxImageSize: options.maxImageSize ?? 5, // 不使用代理时，单个图片最大尺寸（MB），默认5MB
             skipLargeImages: options.skipLargeImages ?? true, // 不使用代理时，是否跳过过大的图片，默认true（跳过）
             workerNumber: options.workerNumber ?? undefined // modern-screenshot Worker 数量，默认自动计算（undefined 表示自动）
@@ -14402,15 +14400,6 @@ class ScreenshotManager {
         if (this.options.useIntersectionObserver && this.options.onlyVisibleImages) {
             this.initIntersectionObserver();
         }
-        // 初始化 IndexedDB（如果启用）
-        if (this.options.useIndexedDB) {
-            this.initIndexedDB().catch(() => {
-                // IndexedDB 初始化失败，回退到内存缓存
-                if (!this.options.silentMode) {
-                    console.warn('📸 IndexedDB 初始化失败，使用内存缓存');
-                }
-            });
-        }
     }
     /**
      * 设置目标元素
@@ -14676,9 +14665,28 @@ class ScreenshotManager {
             this.worker = this.createWorker();
         }
         // 设置定时器（使用递归 setTimeout，确保等待前一个完成）
-        // 这样可以避免 setInterval 不等待异步完成的问题
+        // 串行执行：必须等待上次任务完成后才进行下次任务
         const scheduleNext = async () => {
+            // 如果上次任务还没完成，等待完成
+            if (!this.isCurrentTaskCompleted) {
+                if (!this.options.silentMode) {
+                    console.log('📸 [定时] 等待上次任务完成...');
+                }
+                // 每100ms检查一次任务是否完成
+                const checkInterval = setInterval(() => {
+                    if (this.isCurrentTaskCompleted && this.isRunning) {
+                        clearInterval(checkInterval);
+                        scheduleNext();
+                    }
+                    else if (!this.isRunning) {
+                        clearInterval(checkInterval);
+                    }
+                }, 100);
+                return;
+            }
             if (this.isRunning && this.isEnabled && !document.hidden) {
+                // 标记任务开始
+                this.isCurrentTaskCompleted = false;
                 // 记录定时开始时间
                 const scheduleStartTime = performance.now();
                 if (!this.options.silentMode) {
@@ -14746,25 +14754,36 @@ class ScreenshotManager {
                                 console.error('📸 [轮询] ❌ 处理二进制数据失败:', error);
                             }
                         }
+                        // 任务完成（无压缩模式）
+                        this.isCurrentTaskCompleted = true;
                     }
                     else if (this.currentBinaryConfig && this.options.compress) {
                         // 启用了压缩，等待 Worker 压缩完成后在 onmessage 中发送
+                        // 任务完成标志会在压缩完成的回调中设置
                         if (!this.options.silentMode) {
                             console.log('📸 [轮询] 等待 Worker 压缩完成后发送到 iframe...');
                         }
                     }
+                    else {
+                        // 没有二进制配置，任务完成
+                        this.isCurrentTaskCompleted = true;
+                    }
                 }
                 catch (error) {
                     if (!this.options.silentMode) {
                         console.error('📸 [轮询] 截图失败:', error);
                     }
+                    // 任务失败，标记为完成
+                    this.isCurrentTaskCompleted = true;
                 }
             }
-            // 如果还在运行，安排下一次截图
-            if (this.isRunning) {
+            // 如果还在运行且任务已完成，安排下一次截图
+            if (this.isRunning && this.isCurrentTaskCompleted) {
                 this.screenshotTimer = setTimeout(scheduleNext, currentInterval);
             }
         };
+        // 保存 scheduleNext 函数引用，以便在压缩完成的回调中使用
+        this.scheduleNextFn = scheduleNext;
         // 立即开始第一次
         scheduleNext();
         // 注意：不再立即执行一次，因为已经在 takeScreenshotAndUpload 中执行了
@@ -14784,6 +14803,9 @@ class ScreenshotManager {
             clearInterval(this.screenshotTimer);
             this.screenshotTimer = null;
         }
+        // 清理任务状态
+        this.isCurrentTaskCompleted = true;
+        this.scheduleNextFn = null;
     }
     /**
      * 手动截图一次（允许在未启用时也执行，用于测试）
@@ -14842,20 +14864,12 @@ class ScreenshotManager {
             if (this.options.preloadImages && this.options.enableCORS && selectedEngine === 'modern-screenshot') {
                 // 清理过期缓存
                 this.cleanExpiredCache();
-                // 如果启用 IndexedDB，也清理 IndexedDB 缓存
-                if (this.options.useIndexedDB) {
-                    await this.cleanIndexedDBCache();
-                }
                 await this.preprocessNetworkImages(this.targetElement);
                 await this.waitForImagesToLoad(this.targetElement);
             }
             else {
                 // 即使不预加载，也清理一下过期缓存
                 this.cleanExpiredCache();
-                // 如果启用 IndexedDB，也清理 IndexedDB 缓存
-                if (this.options.useIndexedDB) {
-                    await this.cleanIndexedDBCache();
-                }
             }
             let dataUrl;
             // 根据选择的引擎进行截图
@@ -15648,18 +15662,6 @@ class ScreenshotManager {
                         }
                         return cachedDataUrl;
                     }
-                    // 检查 IndexedDB 缓存（如果启用）
-                    if (this.options.useIndexedDB) {
-                        const indexedDBCache = await this.getIndexedDBCache(url);
-                        if (indexedDBCache) {
-                            // 同步到内存缓存
-                            this.setCachedImage(url, indexedDBCache);
-                            if (!this.options.silentMode) {
-                                console.log(`📸 ✅ 使用 IndexedDB 缓存图片: ${url.substring(0, 50)}...`);
-                            }
-                            return indexedDBCache;
-                        }
-                    }
                     try {
                         // 构建代理请求参数
                         const params = new URLSearchParams({
@@ -15699,10 +15701,6 @@ class ScreenshotManager {
                             const dataUrl = await this.blobToDataUrl(blob);
                             // 缓存结果（带时间戳，10分钟有效）
                             this.setCachedImage(url, dataUrl);
-                            // 如果启用 IndexedDB，也保存到 IndexedDB
-                            if (this.options.useIndexedDB) {
-                                await this.setIndexedDBCache(url, dataUrl);
-                            }
                             return dataUrl;
                         }
                         catch (fetchError) {
@@ -15735,18 +15733,6 @@ class ScreenshotManager {
                         }
                         return cachedDataUrl;
                     }
-                    // 检查 IndexedDB 缓存（如果启用）
-                    if (this.options.useIndexedDB) {
-                        const indexedDBCache = await this.getIndexedDBCache(url);
-                        if (indexedDBCache) {
-                            // 同步到内存缓存
-                            this.setCachedImage(url, indexedDBCache);
-                            if (!this.options.silentMode) {
-                                console.log(`📸 ✅ 使用 IndexedDB 缓存图片（无代理模式）: ${url.substring(0, 50)}...`);
-                            }
-                            return indexedDBCache;
-                        }
-                    }
                     // 检查是否正在下载（避免重复下载）
                     if (this.imageDownloadQueue.has(url)) {
                         // 如果已经在下载队列中，等待现有下载完成
@@ -15874,14 +15860,10 @@ class ScreenshotManager {
                     console.log(`📸 使用元素实际尺寸: ${elementWidth}x${elementHeight}`);
                 }
             }
-            // 缩放配置：移动设备使用更低的缩放比例，进一步减少图片大小
+            // 缩放配置：使用外部传递的参数
             // scale < 1 会降低图片分辨率，减少 base64 大小
-            if (this.options.scale !== 1) {
-                contextOptions.scale = isMobile ? 0.7 : this.options.scale; // 移动设备：0.8 -> 0.7
-            }
-            else if (isMobile) {
-                // 如果未指定 scale，移动设备默认使用 0.7
-                contextOptions.scale = 0.7;
+            if (this.options.scale !== undefined && this.options.scale !== 1) {
+                contextOptions.scale = this.options.scale;
             }
             // 优化：复用 context，避免频繁创建和销毁（性能提升 20%+）
             // 只在元素变化、配置变化或内容变化时重新创建 context
@@ -16079,28 +16061,83 @@ class ScreenshotManager {
                 if (!this.options.silentMode) {
                     console.log(`📸 使用 ${outputFormat.toUpperCase()} 格式截图（直接输出，无需转换）...`);
                 }
-                // 根据输出格式选择对应的 API
-                // modern-screenshot 内部已经处理了超时，不需要额外的 Promise.race
-                if (outputFormat === 'webp') {
-                    // 使用 domToWebp，直接输出 WebP 格式，无需转换
-                    dataUrl = await domToWebp(this.screenshotContext);
-                }
-                else if (outputFormat === 'jpeg') {
-                    // 使用 domToJpeg，直接输出 JPEG 格式，无需转换
-                    dataUrl = await domToJpeg(this.screenshotContext);
-                }
-                else {
-                    // 默认使用 domToPng
-                    dataUrl = await domToPng(this.screenshotContext);
-                }
-                // 验证截图结果
-                if (!dataUrl || dataUrl.length < 100) {
-                    throw new Error('生成的截图数据无效或过短');
+                // 尝试使用 Worker 模式（context）
+                try {
+                    // 根据输出格式选择对应的 API
+                    // modern-screenshot 内部已经处理了超时，不需要额外的 Promise.race
+                    if (outputFormat === 'webp') {
+                        // 使用 domToWebp，直接输出 WebP 格式，无需转换
+                        dataUrl = await domToWebp(this.screenshotContext);
+                    }
+                    else if (outputFormat === 'jpeg') {
+                        // 使用 domToJpeg，直接输出 JPEG 格式，无需转换
+                        dataUrl = await domToJpeg(this.screenshotContext);
+                    }
+                    else {
+                        // 默认使用 domToPng
+                        dataUrl = await domToPng(this.screenshotContext);
+                    }
+                    // 验证截图结果
+                    if (!dataUrl || dataUrl.length < 100) {
+                        throw new Error('生成的截图数据无效或过短');
+                    }
+                    if (!this.options.silentMode) {
+                        console.log(`📸 ✅ modern-screenshot 截图成功（Worker 模式，${outputFormat.toUpperCase()} 格式）`);
+                    }
+                    return dataUrl;
                 }
-                if (!this.options.silentMode) {
-                    console.log(`📸 ✅ modern-screenshot 截图成功（${outputFormat.toUpperCase()} 格式，直接输出，无需转换）`);
+                catch (workerError) {
+                    // Worker 模式失败，回退到普通模式（参考用户代码）
+                    if (!this.options.silentMode) {
+                        console.warn('📸 Worker 模式失败，回退到普通模式:', workerError);
+                    }
+                    // 销毁失败的 context
+                    if (this.screenshotContext) {
+                        try {
+                            destroyContext(this.screenshotContext);
+                        }
+                        catch {
+                            // 忽略销毁错误
+                        }
+                        this.screenshotContext = null;
+                    }
+                    // 回退到普通模式（直接使用 domToWebp，不传 context）
+                    // 使用外部传递的参数，并给出合理的默认值
+                    const fallbackOptions = {
+                        scale: this.options.scale ?? 1, // 使用外部参数，默认 1
+                        backgroundColor: '#ffffff', // 默认白色背景
+                        type: `image/${outputFormat}`, // 使用配置的输出格式
+                        quality: this.options.quality ?? 0.8, // 使用外部参数，默认 0.4
+                        drawImageInterval: 20, // 默认 20ms，减少主线程阻塞
+                        features: {
+                            copyScrollbar: false,
+                            removeAbnormalAttributes: true,
+                            removeControlCharacter: true,
+                            fixSvgXmlDecode: true,
+                            restoreScrollPosition: false,
+                        },
+                        timeout: Math.max((this.options.interval ?? 5000) * 6, 10000), // 使用外部参数计算超时，默认 10 秒
+                    };
+                    // 限制 timeout 最多 15 秒
+                    fallbackOptions.timeout = Math.min(fallbackOptions.timeout, 15000);
+                    if (outputFormat === 'webp') {
+                        dataUrl = await domToWebp(element, fallbackOptions);
+                    }
+                    else if (outputFormat === 'jpeg') {
+                        dataUrl = await domToJpeg(element, fallbackOptions);
+                    }
+                    else {
+                        dataUrl = await domToPng(element, fallbackOptions);
+                    }
+                    // 验证截图结果
+                    if (!dataUrl || dataUrl.length < 100) {
+                        throw new Error('生成的截图数据无效或过短');
+                    }
+                    if (!this.options.silentMode) {
+                        console.log(`📸 ✅ modern-screenshot 截图成功（普通模式，${outputFormat.toUpperCase()} 格式）`);
+                    }
+                    return dataUrl;
                 }
-                return dataUrl;
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
@@ -16212,94 +16249,6 @@ class ScreenshotManager {
             threshold: 0.01
         });
     }
-    /**
-     * 初始化 IndexedDB（持久化缓存）
-     */
-    async initIndexedDB() {
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.open('screenshot-cache', 1);
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => {
-                this.indexedDBCache = request.result;
-                this.indexedDBReady = true;
-                // 初始化后立即清理过期和超大小的缓存
-                this.cleanIndexedDBCache().catch(() => {
-                    // 清理失败不影响功能
-                });
-                resolve();
-            };
-            request.onupgradeneeded = (event) => {
-                const db = event.target.result;
-                if (!db.objectStoreNames.contains('images')) {
-                    const store = db.createObjectStore('images', { keyPath: 'url' });
-                    // 创建索引用于按时间排序
-                    store.createIndex('timestamp', 'timestamp', { unique: false });
-                }
-            };
-        });
-    }
-    /**
-     * 从 IndexedDB 获取缓存
-     */
-    async getIndexedDBCache(url) {
-        if (!this.indexedDBReady || !this.indexedDBCache) {
-            return null;
-        }
-        try {
-            const transaction = this.indexedDBCache.transaction(['images'], 'readonly');
-            const store = transaction.objectStore('images');
-            const request = store.get(url);
-            return new Promise((resolve) => {
-                request.onsuccess = () => {
-                    const result = request.result;
-                    if (result) {
-                        const now = Date.now();
-                        const age = now - result.timestamp;
-                        // 检查是否超过最大缓存时间
-                        if (age > this.options.maxCacheAge) {
-                            // 缓存过期，删除
-                            this.deleteIndexedDBCache(url);
-                            resolve(null);
-                            return;
-                        }
-                        // 返回缓存数据（即使超过 imageCacheTTL，只要未超过 maxCacheAge 仍可使用）
-                        resolve(result.dataUrl);
-                    }
-                    else {
-                        resolve(null);
-                    }
-                };
-                request.onerror = () => resolve(null);
-            });
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * 设置 IndexedDB 缓存（带大小和时间控制）
-     */
-    async setIndexedDBCache(url, dataUrl) {
-        if (!this.indexedDBReady || !this.indexedDBCache) {
-            return;
-        }
-        try {
-            // 计算当前缓存大小
-            const currentSize = await this.getIndexedDBCacheSize();
-            const newItemSize = this.estimateDataUrlSize(dataUrl);
-            const maxSizeBytes = (this.options.maxCacheSize || 50) * 1024 * 1024; // 转换为字节
-            // 如果添加新项后超过限制，清理最旧的数据
-            if (currentSize + newItemSize > maxSizeBytes) {
-                await this.cleanIndexedDBCacheBySize(maxSizeBytes - newItemSize);
-            }
-            const transaction = this.indexedDBCache.transaction(['images'], 'readwrite');
-            const store = transaction.objectStore('images');
-            store.put({ url, dataUrl, timestamp: Date.now() });
-        }
-        catch {
-            // IndexedDB 写入失败，忽略
-        }
-    }
     /**
      * 估算 data URL 的大小（字节）
      */
@@ -16310,156 +16259,32 @@ class ScreenshotManager {
         return Math.ceil(base64Data.length * 0.75) + 30;
     }
     /**
-     * 获取 IndexedDB 当前缓存大小（字节）
+     * 获取 IndexedDB 当前缓存大小（已移除，不再使用）
+     * @deprecated IndexedDB 已移除，不再使用
      */
     async getIndexedDBCacheSize() {
-        if (!this.indexedDBReady || !this.indexedDBCache) {
-            return 0;
-        }
-        try {
-            const transaction = this.indexedDBCache.transaction(['images'], 'readonly');
-            const store = transaction.objectStore('images');
-            const request = store.getAll();
-            return new Promise((resolve) => {
-                request.onsuccess = () => {
-                    const items = request.result || [];
-                    let totalSize = 0;
-                    items.forEach((item) => {
-                        totalSize += this.estimateDataUrlSize(item.dataUrl);
-                    });
-                    resolve(totalSize);
-                };
-                request.onerror = () => resolve(0);
-            });
-        }
-        catch {
-            return 0;
-        }
+        return 0;
     }
     /**
-     * 清理 IndexedDB 缓存（按时间和大小）
+     * 清理 IndexedDB 缓存（已移除，不再使用）
+     * @deprecated IndexedDB 已移除，不再使用
      */
     async cleanIndexedDBCache() {
-        if (!this.indexedDBReady || !this.indexedDBCache) {
-            return;
-        }
-        try {
-            const transaction = this.indexedDBCache.transaction(['images'], 'readwrite');
-            const store = transaction.objectStore('images');
-            const index = store.index('timestamp');
-            const request = index.getAll();
-            return new Promise((resolve) => {
-                request.onsuccess = () => {
-                    const items = request.result || [];
-                    const now = Date.now();
-                    const expiredUrls = [];
-                    let currentSize = 0;
-                    const maxSizeBytes = (this.options.maxCacheSize || 50) * 1024 * 1024;
-                    // 按时间排序（最旧的在前）
-                    items.sort((a, b) => a.timestamp - b.timestamp);
-                    // 清理过期数据
-                    items.forEach((item) => {
-                        const age = now - item.timestamp;
-                        if (age > this.options.maxCacheAge) {
-                            expiredUrls.push(item.url);
-                        }
-                        else {
-                            currentSize += this.estimateDataUrlSize(item.dataUrl);
-                        }
-                    });
-                    // 如果仍然超过大小限制，删除最旧的数据
-                    const urlsToDelete = [...expiredUrls];
-                    if (currentSize > maxSizeBytes) {
-                        for (const item of items) {
-                            if (expiredUrls.includes(item.url))
-                                continue;
-                            currentSize -= this.estimateDataUrlSize(item.dataUrl);
-                            urlsToDelete.push(item.url);
-                            if (currentSize <= maxSizeBytes) {
-                                break;
-                            }
-                        }
-                    }
-                    // 删除过期和超大小的数据
-                    urlsToDelete.forEach((url) => {
-                        store.delete(url);
-                    });
-                    if (urlsToDelete.length > 0 && !this.options.silentMode) {
-                        console.log(`📸 IndexedDB 清理了 ${urlsToDelete.length} 个缓存项（过期或超大小）`);
-                    }
-                    resolve();
-                };
-                request.onerror = () => resolve();
-            });
-        }
-        catch {
-            // 清理失败，忽略
-        }
+        // IndexedDB 已移除，不再使用
     }
     /**
-     * 按大小清理 IndexedDB 缓存
+     * 按大小清理 IndexedDB 缓存（已移除，不再使用）
+     * @deprecated IndexedDB 已移除，不再使用
      */
-    async cleanIndexedDBCacheBySize(targetSize) {
-        if (!this.indexedDBReady || !this.indexedDBCache) {
-            return;
-        }
-        try {
-            const transaction = this.indexedDBCache.transaction(['images'], 'readwrite');
-            const store = transaction.objectStore('images');
-            const index = store.index('timestamp');
-            const request = index.getAll();
-            return new Promise((resolve) => {
-                request.onsuccess = () => {
-                    const items = request.result || [];
-                    // 按时间排序（最旧的在前）
-                    items.sort((a, b) => a.timestamp - b.timestamp);
-                    let currentSize = 0;
-                    const urlsToDelete = [];
-                    // 计算当前大小
-                    items.forEach((item) => {
-                        currentSize += this.estimateDataUrlSize(item.dataUrl);
-                    });
-                    // 如果超过目标大小，删除最旧的数据
-                    if (currentSize > targetSize) {
-                        for (const item of items) {
-                            if (currentSize <= targetSize) {
-                                break;
-                            }
-                            currentSize -= this.estimateDataUrlSize(item.dataUrl);
-                            urlsToDelete.push(item.url);
-                        }
-                    }
-                    // 删除数据
-                    urlsToDelete.forEach((url) => {
-                        store.delete(url);
-                    });
-                    if (urlsToDelete.length > 0 && !this.options.silentMode) {
-                        console.log(`📸 IndexedDB 清理了 ${urlsToDelete.length} 个缓存项（超过大小限制）`);
-                    }
-                    resolve();
-                };
-                request.onerror = () => resolve();
-            });
-        }
-        catch {
-            // 清理失败，忽略
-        }
+    async cleanIndexedDBCacheBySize(_targetSize) {
+        // IndexedDB 已移除，不再使用
     }
     /**
-     * 删除 IndexedDB 缓存
+     * 删除 IndexedDB 缓存（已移除，不再使用）
+     * @deprecated IndexedDB 已移除，不再使用
      */
-    async deleteIndexedDBCache(url) {
-        if (!this.indexedDBReady || !this.indexedDBCache) {
-            return;
-        }
-        try {
-            const transaction = this.indexedDBCache.transaction(['images'], 'readwrite');
-            const store = transaction.objectStore('images');
-            store.delete(url);
-        }
-        catch {
-            // 忽略错误
-        }
+    async deleteIndexedDBCache(_url) {
+        // IndexedDB 已移除，不再使用
     }
     /**
      * 检查元素是否在可视区域内（优化：使用 Intersection Observer 或 getBoundingClientRect）
@@ -16674,10 +16499,6 @@ class ScreenshotManager {
                 const dataUrl = await this.blobToDataUrl(blob);
                 // 缓存结果（带时间戳，10分钟有效）
                 this.setCachedImage(url, dataUrl);
-                // 如果启用 IndexedDB，也保存到 IndexedDB
-                if (this.options.useIndexedDB) {
-                    await this.setIndexedDBCache(url, dataUrl);
-                }
                 return dataUrl;
             }
             // 如果下载失败，返回原 URL，让 modern-screenshot 自己处理
@@ -17156,6 +16977,16 @@ class ScreenshotManager {
                             this.sendCompressedScreenshotToIframe(compressed.dataUrl, scheduleStartTime, compressEndTime);
                         }
                     }
+                    // 任务完成（压缩模式）- 无论是否成功，都要标记为完成
+                    this.isCurrentTaskCompleted = true;
+                    // 如果还在运行，触发下一次任务
+                    if (this.isRunning && this.scheduleNextFn) {
+                        const currentInterval = this.dynamicInterval || this.options.interval;
+                        this.screenshotTimer = setTimeout(() => {
+                            this.screenshotTimer = null;
+                            this.scheduleNextFn?.();
+                        }, currentInterval);
+                    }
                 }
             };
             newWorker.onerror = (e) => {
@@ -17185,6 +17016,16 @@ class ScreenshotManager {
                         }
                     }
                 }
+                // Worker 错误时，任务也完成
+                this.isCurrentTaskCompleted = true;
+                // 如果还在运行，触发下一次任务
+                if (this.isRunning && this.scheduleNextFn) {
+                    const currentInterval = this.dynamicInterval || this.options.interval;
+                    this.screenshotTimer = setTimeout(() => {
+                        this.screenshotTimer = null;
+                        this.scheduleNextFn?.();
+                    }, currentInterval);
+                }
             };
             // 注意：不要立即 revokeObjectURL，因为 Worker 需要这个 URL 保持有效
             // 在 destroy() 方法中清理 Worker 时再 revoke
@@ -17687,12 +17528,7 @@ class ScreenshotManager {
             this.intersectionObserver = null;
             this.visibleElementsCache.clear();
         }
-        // 关闭 IndexedDB
-        if (this.indexedDBCache) {
-            this.indexedDBCache.close();
-            this.indexedDBCache = null;
-            this.indexedDBReady = false;
-        }
+        // IndexedDB 已移除，不再使用
         // 清理图片代理缓存
         this.imageProxyCache.clear();
         // 清理截图历史记录（释放大量内存）
@@ -17781,12 +17617,6 @@ class ScreenshotManager {
         // 每2分钟清理一次过期缓存（从5分钟改为2分钟，更频繁）
         setInterval(() => {
             this.cleanExpiredCache();
-            // 如果启用 IndexedDB，也清理 IndexedDB 缓存
-            if (this.options.useIndexedDB) {
-                this.cleanIndexedDBCache().catch(() => {
-                    // 清理失败，忽略
-                });
-            }
             if (!this.options.silentMode) {
                 const memoryCacheSize = this.imageProxyCache.size;
                 const memoryCacheSizeMB = Array.from(this.imageProxyCache.values())