customer-chat-sdk 1.0.38 → 1.0.41

package/dist/customer-sdk.cjs.js

@@ -2472,12 +2472,24 @@ async function domToDataUrl(node, options) {
   return dataUrl;
 }
 
+async function domToJpeg(node, options) {
+  return domToDataUrl(
+    await orCreateContext(node, { ...options, type: "image/jpeg" })
+  );
+}
+
 async function domToPng(node, options) {
   return domToDataUrl(
     await orCreateContext(node, { ...options, type: "image/png" })
   );
 }
 
+async function domToWebp(node, options) {
+  return domToDataUrl(
+    await orCreateContext(node, { ...options, type: "image/webp" })
+  );
+}
+
 /*
 * snapdom
 * v.1.9.14
@@ -14311,6 +14323,13 @@ class ScreenshotManager {
         this.screenshotTimer = null;
         // modern-screenshot Worker 上下文（用于复用，避免频繁创建和销毁）
         this.screenshotContext = null;
+        this.contextElement = null; // 当前 context 对应的元素
+        this.contextOptionsHash = ''; // context 配置的哈希值，用于判断是否需要重新创建
+        // 截图锁，防止并发截图
+        this.isScreenshotInProgress = false;
+        // 截图队列（用于处理频繁的截图请求）
+        this.screenshotQueue = [];
+        this.isProcessingQueue = false;
         // PostMessage 监听器
         this.messageHandler = null;
         // 动态轮询间隔（由 iframe 消息控制）
@@ -14336,7 +14355,7 @@ class ScreenshotManager {
         this.globalRejectionHandler = null;
         this.targetElement = targetElement;
         this.options = {
-            interval: options.interval ?? 5000,
+            interval: options.interval ?? 1000,
             quality: options.quality ?? 0.3, // 降低默认质量：0.4 -> 0.3，减少 base64 大小
             scale: options.scale ?? 1,
             maxHistory: options.maxHistory ?? 10,
@@ -14363,7 +14382,8 @@ class ScreenshotManager {
             maxCacheSize: options.maxCacheSize ?? 50, // 默认最大50MB
             maxCacheAge: options.maxCacheAge ?? 86400000, // 默认24小时（86400000ms）
             maxImageSize: options.maxImageSize ?? 5, // 不使用代理时，单个图片最大尺寸（MB），默认5MB
-            skipLargeImages: options.skipLargeImages ?? true // 不使用代理时，是否跳过过大的图片，默认true（跳过）
+            skipLargeImages: options.skipLargeImages ?? true, // 不使用代理时，是否跳过过大的图片，默认true（跳过）
+            workerNumber: options.workerNumber ?? undefined // modern-screenshot Worker 数量，默认自动计算（undefined 表示自动）
         };
         this.setupMessageListener();
         this.setupVisibilityChangeListener();
@@ -14391,15 +14411,22 @@ class ScreenshotManager {
      * 设置目标元素
      */
     setTargetElement(element) {
-        // 如果元素改变了，清理旧的 Worker 上下文
-        if (this.targetElement !== element && this.screenshotContext) {
-            try {
-                destroyContext(this.screenshotContext);
-            }
-            catch (e) {
-                // 忽略清理错误
+        // 如果元素变化，需要清理 context（下次截图时会重新创建）
+        if (this.targetElement !== element) {
+            if (this.screenshotContext) {
+                try {
+                    destroyContext(this.screenshotContext);
+                    if (!this.options.silentMode) {
+                        console.log('📸 目标元素变化，清理 context');
+                    }
+                }
+                catch (e) {
+                    // 忽略清理错误
+                }
+                this.screenshotContext = null;
+                this.contextElement = null;
+                this.contextOptionsHash = '';
             }
-            this.screenshotContext = null;
         }
         this.targetElement = element;
     }
@@ -14627,22 +14654,36 @@ class ScreenshotManager {
         if (!this.worker && this.options.compress) {
             this.worker = this.createWorker();
         }
-        // 设置定时器
-        this.screenshotTimer = setInterval(async () => {
+        // 设置定时器（使用递归 setTimeout，确保等待前一个完成）
+        // 这样可以避免 setInterval 不等待异步完成的问题
+        const scheduleNext = async () => {
             if (this.isRunning && this.isEnabled && !document.hidden) {
-                await this.takeScreenshot();
-                // 如果配置了上传，且当前有上传配置，自动上传
-                if (this.currentUploadConfig) {
-                    const latestScreenshot = this.getLatestScreenshot();
-                    if (latestScreenshot && !this.isUploading) {
-                        this.uploadScreenshot(latestScreenshot, this.currentUploadConfig)
-                            .catch((error) => {
-                            console.error('📸 [轮询] 自动上传失败:', error);
-                        });
+                try {
+                    await this.takeScreenshot();
+                    // 如果配置了上传，且当前有上传配置，自动上传
+                    if (this.currentUploadConfig) {
+                        const latestScreenshot = this.getLatestScreenshot();
+                        if (latestScreenshot && !this.isUploading) {
+                            this.uploadScreenshot(latestScreenshot, this.currentUploadConfig)
+                                .catch((error) => {
+                                console.error('📸 [轮询] 自动上传失败:', error);
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    if (!this.options.silentMode) {
+                        console.error('📸 [轮询] 截图失败:', error);
                     }
                 }
             }
-        }, currentInterval);
+            // 如果还在运行，安排下一次截图
+            if (this.isRunning) {
+                this.screenshotTimer = setTimeout(scheduleNext, currentInterval);
+            }
+        };
+        // 立即开始第一次
+        scheduleNext();
         // 注意：不再立即执行一次，因为已经在 takeScreenshotAndUpload 中执行了
     }
     /**
@@ -14945,16 +14986,22 @@ class ScreenshotManager {
             console.log('📸 使用 html2canvas 引擎截图...');
         }
         try {
+            // 检测 iOS 设备
+            const isIOS = /iPhone|iPad|iPod/i.test(navigator.userAgent);
             // html2canvas 需要确保样式完全加载，额外等待
-            // 等待所有样式表加载完成
+            // iOS 设备需要更长的等待时间，因为样式表加载和处理方式不同
             await this.waitForAllStylesLoaded();
             // 等待字体加载完成
             await this.waitForFonts();
+            // iOS 设备需要额外的等待时间，确保样式完全应用
+            if (isIOS) {
+                await new Promise(resolve => setTimeout(resolve, 300)); // iOS 额外等待 300ms
+            }
             // 等待 DOM 完全渲染
             await new Promise(resolve => {
                 requestAnimationFrame(() => {
                     requestAnimationFrame(() => {
-                        setTimeout(() => resolve(), 100);
+                        setTimeout(() => resolve(), isIOS ? 200 : 100); // iOS 使用更长的等待时间
                     });
                 });
             });
@@ -14990,9 +15037,11 @@ class ScreenshotManager {
                 // width: finalWidth,  // ❌ 移除，会导致宽度不正确
                 // height: finalHeight, // ❌ 移除，会导致高度不正确
                 // 关键配置：确保样式正确渲染
-                // 注意：不要设置 foreignObjectRendering，让 html2canvas 自动选择最佳渲染方式
-                // foreignObjectRendering 可能导致样式问题，所以不设置它
-                onclone: (clonedDoc, _clonedElement) => {
+                // iOS 特定配置：启用 foreignObjectRendering 以确保样式正确渲染
+                // iOS Safari 和 Chrome 对样式表的处理方式不同，需要启用此选项
+                onclone: (clonedDoc, clonedElement) => {
+                    // 检测 iOS 设备（需要在 onclone 内部检测，因为这是回调函数）
+                    const isIOS = /iPhone|iPad|iPod/i.test(navigator.userAgent);
                     // 在克隆的文档中，确保所有样式都正确应用
                     // html2canvas 会自动处理样式，但我们需要确保样式表被正确复制
                     // 确保 clonedDoc.head 存在
@@ -15081,10 +15130,53 @@ class ScreenshotManager {
                     catch (e) {
                         // 忽略错误，继续执行
                     }
+                    // 4. iOS 特定处理：将计算后的样式内联化（确保样式正确应用）
+                    // iOS Safari/Chrome 对样式表的处理方式不同，需要将计算后的样式内联化
+                    if (isIOS) {
+                        try {
+                            // 遍历克隆文档中的所有元素，将计算后的样式内联化
+                            const allElements = clonedElement.querySelectorAll('*');
+                            allElements.forEach((el) => {
+                                try {
+                                    const htmlEl = el;
+                                    const computedStyle = window.getComputedStyle(htmlEl);
+                                    // 获取关键样式属性并内联化
+                                    const importantStyles = [];
+                                    // 获取所有样式属性（iOS 需要更完整的样式）
+                                    for (let i = 0; i < computedStyle.length; i++) {
+                                        const prop = computedStyle[i];
+                                        const value = computedStyle.getPropertyValue(prop);
+                                        const priority = computedStyle.getPropertyPriority(prop);
+                                        // 只内联化非默认值的重要样式
+                                        if (value && value !== 'none' && value !== 'auto' && value !== 'normal') {
+                                            importantStyles.push(`${prop}: ${value}${priority === 'important' ? ' !important' : ''}`);
+                                        }
+                                    }
+                                    // 如果有关键样式，添加到内联样式
+                                    if (importantStyles.length > 0) {
+                                        const currentStyle = htmlEl.getAttribute('style') || '';
+                                        const newStyle = currentStyle
+                                            ? `${currentStyle}; ${importantStyles.join('; ')}`
+                                            : importantStyles.join('; ');
+                                        htmlEl.setAttribute('style', newStyle);
+                                    }
+                                }
+                                catch (e) {
+                                    // 忽略单个元素的错误
+                                }
+                            });
+                        }
+                        catch (e) {
+                            // 忽略内联化错误
+                            if (!this.options.silentMode) {
+                                console.warn('📸 iOS 样式内联化失败:', e);
+                            }
+                        }
+                    }
                     if (!this.options.silentMode) {
                         const styleLinks = clonedDoc.querySelectorAll('link[rel="stylesheet"]').length;
                         const styleTags = clonedDoc.querySelectorAll('style').length;
-                        console.log(`📸 onclone: 已复制 ${styleLinks} 个样式表链接和 ${styleTags} 个内联样式标签`);
+                        console.log(`📸 onclone: 已复制 ${styleLinks} 个样式表链接和 ${styleTags} 个内联样式标签${isIOS ? ' (iOS 模式：已内联化计算样式)' : ''}`);
                     }
                 },
                 // 性能优化
@@ -15210,389 +15302,514 @@ class ScreenshotManager {
      * - 页面资源较少
      */
     async takeScreenshotWithModernScreenshot(element) {
+        // 检查是否有截图正在进行（防止并发冲突）
+        // 如果正在进行，将请求加入队列，而不是直接拒绝
+        if (this.isScreenshotInProgress) {
+            // 队列最多保留 1 个请求，避免积压
+            if (this.screenshotQueue.length >= 1) {
+                if (!this.options.silentMode) {
+                    console.log('📸 截图队列已满，跳过当前请求（等待队列处理）');
+                }
+                // 等待队列中的请求完成
+                return new Promise((resolve, reject) => {
+                    const checkQueue = () => {
+                        if (!this.isScreenshotInProgress && this.screenshotQueue.length === 0) {
+                            // 队列已清空，重新尝试
+                            this.takeScreenshotWithModernScreenshot(element).then(resolve).catch(reject);
+                        }
+                        else {
+                            setTimeout(checkQueue, 100); // 100ms 后再次检查
+                        }
+                    };
+                    checkQueue();
+                });
+            }
+            // 将请求加入队列
+            return new Promise((resolve, reject) => {
+                this.screenshotQueue.push({ resolve: () => {
+                        this.takeScreenshotWithModernScreenshot(element).then(resolve).catch(reject);
+                    }, reject });
+                // 启动队列处理（如果还没启动）
+                if (!this.isProcessingQueue) {
+                    this.processScreenshotQueue();
+                }
+            });
+        }
+        this.isScreenshotInProgress = true;
         if (!this.options.silentMode) {
             console.log('📸 使用 modern-screenshot 引擎截图（Worker 模式）...');
         }
-        // 获取元素的实际尺寸（使用 scrollWidth/scrollHeight 获取完整内容尺寸）
-        // 对于 document.body，需要特殊处理，确保截取完整页面内容
-        let elementWidth;
-        let elementHeight;
-        if (element === document.body || element === document.documentElement) {
-            // 对于 body 或 html 元素，使用页面的完整尺寸（包括滚动内容）
-            elementWidth = Math.max(element.scrollWidth, element.offsetWidth, document.documentElement.scrollWidth, document.documentElement.offsetWidth, window.innerWidth);
-            elementHeight = Math.max(element.scrollHeight, element.offsetHeight, document.documentElement.scrollHeight, document.documentElement.offsetHeight, window.innerHeight);
-        }
-        else {
-            // 对于其他元素，使用元素的完整尺寸
-            elementWidth = element.scrollWidth || element.clientWidth || element.offsetWidth;
-            elementHeight = element.scrollHeight || element.clientHeight || element.offsetHeight;
-        }
-        if (!this.options.silentMode) {
-            console.log(`📸 目标元素: ${element.tagName}${element.id ? '#' + element.id : ''}${element.className ? '.' + element.className.split(' ').join('.') : ''}`);
-            console.log(`📸 元素尺寸: ${elementWidth}x${elementHeight}`);
-            console.log(`📸 scrollWidth: ${element.scrollWidth}, scrollHeight: ${element.scrollHeight}`);
-            console.log(`📸 clientWidth: ${element.clientWidth}, clientHeight: ${element.clientHeight}`);
-            console.log(`📸 offsetWidth: ${element.offsetWidth}, offsetHeight: ${element.offsetHeight}`);
+        try {
+            // 获取元素的实际尺寸（使用 scrollWidth/scrollHeight 获取完整内容尺寸）
+            // 对于 document.body，需要特殊处理，确保截取完整页面内容
+            let elementWidth;
+            let elementHeight;
             if (element === document.body || element === document.documentElement) {
-                console.log(`📸 页面完整尺寸: ${document.documentElement.scrollWidth}x${document.documentElement.scrollHeight}`);
-                console.log(`📸 窗口尺寸: ${window.innerWidth}x${window.innerHeight}`);
-            }
-        }
-        const isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
-        const isLowEndDevice = navigator.hardwareConcurrency && navigator.hardwareConcurrency <= 4;
-        // 进一步降低质量以减少 base64 大小
-        // 桌面设备：使用配置的质量（默认 0.3）
-        // 移动设备/低端设备：进一步降低到 0.2（最低）
-        const finalQuality = isMobile || isLowEndDevice
-            ? Math.max(this.options.quality * 0.65, 0.2) // 移动设备：质量 * 0.65，最低 0.2
-            : this.options.quality; // 桌面设备：使用配置的质量（默认 0.3）
-        // 计算压缩后的尺寸（对所有元素都应用，包括 document.body）
-        // 这样可以避免生成过大的截图，减少 base64 大小
-        const { width, height } = this.calculateCompressedSize(elementWidth, elementHeight, this.options.maxWidth, this.options.maxHeight);
-        // 对于所有元素都应用尺寸限制（包括 body），避免截图过大
-        // 如果计算后的尺寸小于元素实际尺寸，使用压缩尺寸；否则使用元素实际尺寸（但不超过最大值）
-        const finalWidth = width < elementWidth ? width : Math.min(elementWidth, this.options.maxWidth);
-        const finalHeight = height < elementHeight ? height : Math.min(elementHeight, this.options.maxHeight);
-        // 处理跨域图片的函数
-        const handleCrossOriginImage = async (url) => {
-            // 如果是 data URL 或 blob URL，直接返回
-            if (url.startsWith('data:') || url.startsWith('blob:')) {
-                return url;
+                // 对于 body 或 html 元素，使用页面的完整尺寸（包括滚动内容）
+                elementWidth = Math.max(element.scrollWidth, element.offsetWidth, document.documentElement.scrollWidth, document.documentElement.offsetWidth, window.innerWidth);
+                elementHeight = Math.max(element.scrollHeight, element.offsetHeight, document.documentElement.scrollHeight, document.documentElement.offsetHeight, window.innerHeight);
             }
-            // 如果是同源图片，直接返回
-            try {
-                const imgUrl = new URL(url, window.location.href);
-                if (imgUrl.origin === window.location.origin) {
-                    return url;
-                }
+            else {
+                // 对于其他元素，使用元素的完整尺寸
+                elementWidth = element.scrollWidth || element.clientWidth || element.offsetWidth;
+                elementHeight = element.scrollHeight || element.clientHeight || element.offsetHeight;
             }
-            catch (e) {
-                // URL 解析失败，继续处理
+            if (!this.options.silentMode) {
+                console.log(`📸 目标元素: ${element.tagName}${element.id ? '#' + element.id : ''}${element.className ? '.' + element.className.split(' ').join('.') : ''}`);
+                console.log(`📸 元素尺寸: ${elementWidth}x${elementHeight}`);
+                console.log(`📸 scrollWidth: ${element.scrollWidth}, scrollHeight: ${element.scrollHeight}`);
+                console.log(`📸 clientWidth: ${element.clientWidth}, clientHeight: ${element.clientHeight}`);
+                console.log(`📸 offsetWidth: ${element.offsetWidth}, offsetHeight: ${element.offsetHeight}`);
+                if (element === document.body || element === document.documentElement) {
+                    console.log(`📸 页面完整尺寸: ${document.documentElement.scrollWidth}x${document.documentElement.scrollHeight}`);
+                    console.log(`📸 窗口尺寸: ${window.innerWidth}x${window.innerHeight}`);
+                }
             }
-            // 如果配置了代理服务器，使用代理处理跨域图片
-            // 只有当 useProxy 为 true 且 proxyUrl 存在时才使用代理
-            const shouldUseProxy = this.options.useProxy && this.options.proxyUrl && this.options.proxyUrl.trim() !== '';
-            if (shouldUseProxy) {
-                // 检查内存缓存（优先使用缓存，带过期时间检查）
-                const cachedDataUrl = this.getCachedImage(url);
-                if (cachedDataUrl) {
-                    if (!this.options.silentMode) {
-                        console.log(`📸 ✅ 使用内存缓存图片: ${url.substring(0, 50)}...`);
+            const isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+            const isLowEndDevice = navigator.hardwareConcurrency && navigator.hardwareConcurrency <= 4;
+            // 进一步降低质量以减少 base64 大小
+            // 桌面设备：使用配置的质量（默认 0.3）
+            // 移动设备/低端设备：进一步降低到 0.2（最低）
+            const finalQuality = isMobile || isLowEndDevice
+                ? Math.max(this.options.quality * 0.65, 0.2) // 移动设备：质量 * 0.65，最低 0.2
+                : this.options.quality; // 桌面设备：使用配置的质量（默认 0.3）
+            // 计算压缩后的尺寸（对所有元素都应用，包括 document.body）
+            // 这样可以避免生成过大的截图，减少 base64 大小
+            const { width, height } = this.calculateCompressedSize(elementWidth, elementHeight, this.options.maxWidth, this.options.maxHeight);
+            // 对于所有元素都应用尺寸限制（包括 body），避免截图过大
+            // 如果计算后的尺寸小于元素实际尺寸，使用压缩尺寸；否则使用元素实际尺寸（但不超过最大值）
+            const finalWidth = width < elementWidth ? width : Math.min(elementWidth, this.options.maxWidth);
+            const finalHeight = height < elementHeight ? height : Math.min(elementHeight, this.options.maxHeight);
+            // 处理跨域图片的函数
+            const handleCrossOriginImage = async (url) => {
+                // 如果是 data URL 或 blob URL，直接返回
+                if (url.startsWith('data:') || url.startsWith('blob:')) {
+                    return url;
+                }
+                // 如果是同源图片，直接返回
+                try {
+                    const imgUrl = new URL(url, window.location.href);
+                    if (imgUrl.origin === window.location.origin) {
+                        return url;
                     }
-                    return cachedDataUrl;
                 }
-                // 检查 IndexedDB 缓存（如果启用）
-                if (this.options.useIndexedDB) {
-                    const indexedDBCache = await this.getIndexedDBCache(url);
-                    if (indexedDBCache) {
-                        // 同步到内存缓存
-                        this.setCachedImage(url, indexedDBCache);
+                catch (e) {
+                    // URL 解析失败，继续处理
+                }
+                // 如果配置了代理服务器，使用代理处理跨域图片
+                // 只有当 useProxy 为 true 且 proxyUrl 存在时才使用代理
+                const shouldUseProxy = this.options.useProxy && this.options.proxyUrl && this.options.proxyUrl.trim() !== '';
+                if (shouldUseProxy) {
+                    // 检查内存缓存（优先使用缓存，带过期时间检查）
+                    const cachedDataUrl = this.getCachedImage(url);
+                    if (cachedDataUrl) {
                         if (!this.options.silentMode) {
-                            console.log(`📸 ✅ 使用 IndexedDB 缓存图片: ${url.substring(0, 50)}...`);
+                            console.log(`📸 ✅ 使用内存缓存图片: ${url.substring(0, 50)}...`);
                         }
-                        return indexedDBCache;
+                        return cachedDataUrl;
                     }
-                }
-                try {
-                    // 构建代理请求参数
-                    const params = new URLSearchParams({
-                        url: url,
-                        maxWidth: String(this.options.maxWidth || 1600),
-                        maxHeight: String(this.options.maxHeight || 900),
-                        quality: String(Math.round((this.options.quality || 0.4) * 100)),
-                        format: this.options.outputFormat || 'webp'
-                    });
-                    let baseUrl = this.options.proxyUrl;
-                    baseUrl = baseUrl.replace(/[?&]$/, '');
-                    const proxyUrl = `${baseUrl}?${params.toString()}`;
-                    // 请求代理服务器（优化：添加超时控制和优先级）
-                    const controller = new AbortController();
-                    const timeoutId = setTimeout(() => controller.abort(), this.options.imageLoadTimeout);
-                    try {
-                        const fetchOptions = {
-                            method: 'GET',
-                            mode: 'cors',
-                            credentials: 'omit',
-                            headers: {
-                                'Accept': 'image/*'
-                            },
-                            cache: 'no-cache',
-                            signal: controller.signal
-                        };
-                        // 添加 fetch priority（如果支持）
-                        if ('priority' in fetchOptions) {
-                            fetchOptions.priority = this.options.fetchPriority;
+                    // 检查 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;
                         }
-                        const response = await fetch(proxyUrl, fetchOptions);
-                        clearTimeout(timeoutId);
-                        if (!response.ok) {
-                            throw new Error(`代理请求失败: ${response.status}`);
+                    }
+                    try {
+                        // 构建代理请求参数
+                        const params = new URLSearchParams({
+                            url: url,
+                            maxWidth: String(this.options.maxWidth || 1600),
+                            maxHeight: String(this.options.maxHeight || 900),
+                            quality: String(Math.round((this.options.quality || 0.4) * 100)),
+                            format: this.options.outputFormat || 'webp'
+                        });
+                        let baseUrl = this.options.proxyUrl;
+                        baseUrl = baseUrl.replace(/[?&]$/, '');
+                        const proxyUrl = `${baseUrl}?${params.toString()}`;
+                        // 请求代理服务器（优化：添加超时控制和优先级）
+                        const controller = new AbortController();
+                        const timeoutId = setTimeout(() => controller.abort(), this.options.imageLoadTimeout);
+                        try {
+                            const fetchOptions = {
+                                method: 'GET',
+                                mode: 'cors',
+                                credentials: 'omit',
+                                headers: {
+                                    'Accept': 'image/*'
+                                },
+                                cache: 'no-cache',
+                                signal: controller.signal
+                            };
+                            // 添加 fetch priority（如果支持）
+                            if ('priority' in fetchOptions) {
+                                fetchOptions.priority = this.options.fetchPriority;
+                            }
+                            const response = await fetch(proxyUrl, fetchOptions);
+                            clearTimeout(timeoutId);
+                            if (!response.ok) {
+                                throw new Error(`代理请求失败: ${response.status}`);
+                            }
+                            const blob = await response.blob();
+                            const dataUrl = await this.blobToDataUrl(blob);
+                            // 缓存结果（带时间戳，10分钟有效）
+                            this.setCachedImage(url, dataUrl);
+                            // 如果启用 IndexedDB，也保存到 IndexedDB
+                            if (this.options.useIndexedDB) {
+                                await this.setIndexedDBCache(url, dataUrl);
+                            }
+                            return dataUrl;
                         }
-                        const blob = await response.blob();
-                        const dataUrl = await this.blobToDataUrl(blob);
-                        // 缓存结果（带时间戳，10分钟有效）
-                        this.setCachedImage(url, dataUrl);
-                        // 如果启用 IndexedDB，也保存到 IndexedDB
-                        if (this.options.useIndexedDB) {
-                            await this.setIndexedDBCache(url, dataUrl);
+                        catch (fetchError) {
+                            clearTimeout(timeoutId);
+                            throw fetchError;
                         }
-                        return dataUrl;
                     }
-                    catch (fetchError) {
-                        clearTimeout(timeoutId);
-                        throw fetchError;
+                    catch (error) {
+                        if (!this.options.silentMode) {
+                            console.warn(`📸 代理处理图片失败: ${url.substring(0, 100)}...`, error);
+                        }
+                        // 失败时返回原 URL
+                        return url;
                     }
                 }
-                catch (error) {
-                    if (!this.options.silentMode) {
-                        console.warn(`📸 代理处理图片失败: ${url.substring(0, 100)}...`, error);
+                // 如果没有配置代理，需要添加内存保护机制
+                // 不使用代理时，modern-screenshot 会直接下载图片，可能导致内存问题
+                // 由于已配置 CORS，可以直接下载并检查大小
+                if (this.options.enableCORS) {
+                    // 对于不使用代理的情况，添加内存保护和缓存机制：
+                    // 1. 先检查内存缓存（避免重复下载）
+                    // 2. 检查 IndexedDB 缓存
+                    // 3. 使用下载队列避免并发重复下载
+                    // 4. 下载时检查大小，如果过大则使用占位符
+                    // 先检查内存缓存（优先使用缓存，避免重复下载）
+                    const cachedDataUrl = this.getCachedImage(url);
+                    if (cachedDataUrl) {
+                        if (!this.options.silentMode) {
+                            console.log(`📸 ✅ 使用内存缓存图片（无代理模式）: ${url.substring(0, 50)}...`);
+                        }
+                        return cachedDataUrl;
                     }
-                    // 失败时返回原 URL
-                    return url;
-                }
-            }
-            // 如果没有配置代理，需要添加内存保护机制
-            // 不使用代理时，modern-screenshot 会直接下载图片，可能导致内存问题
-            // 由于已配置 CORS，可以直接下载并检查大小
-            if (this.options.enableCORS) {
-                // 对于不使用代理的情况，添加内存保护和缓存机制：
-                // 1. 先检查内存缓存（避免重复下载）
-                // 2. 检查 IndexedDB 缓存
-                // 3. 使用下载队列避免并发重复下载
-                // 4. 下载时检查大小，如果过大则使用占位符
-                // 先检查内存缓存（优先使用缓存，避免重复下载）
-                const cachedDataUrl = this.getCachedImage(url);
-                if (cachedDataUrl) {
-                    if (!this.options.silentMode) {
-                        console.log(`📸 ✅ 使用内存缓存图片（无代理模式）: ${url.substring(0, 50)}...`);
+                    // 检查 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;
+                        }
                     }
-                    return cachedDataUrl;
-                }
-                // 检查 IndexedDB 缓存（如果启用）
-                if (this.options.useIndexedDB) {
-                    const indexedDBCache = await this.getIndexedDBCache(url);
-                    if (indexedDBCache) {
-                        // 同步到内存缓存
-                        this.setCachedImage(url, indexedDBCache);
+                    // 检查是否正在下载（避免重复下载）
+                    if (this.imageDownloadQueue.has(url)) {
+                        // 如果已经在下载队列中，等待现有下载完成
                         if (!this.options.silentMode) {
-                            console.log(`📸 ✅ 使用 IndexedDB 缓存图片（无代理模式）: ${url.substring(0, 50)}...`);
+                            console.log(`📸 ⏳ 等待图片下载完成: ${url.substring(0, 50)}...`);
                         }
-                        return indexedDBCache;
+                        return await this.imageDownloadQueue.get(url);
                     }
-                }
-                // 检查是否正在下载（避免重复下载）
-                if (this.imageDownloadQueue.has(url)) {
-                    // 如果已经在下载队列中，等待现有下载完成
-                    if (!this.options.silentMode) {
-                        console.log(`📸 ⏳ 等待图片下载完成: ${url.substring(0, 50)}...`);
+                    // 检查并发下载数限制
+                    if (this.activeDownloads.size >= this.maxConcurrentImageDownloads) {
+                        // 并发数已满，返回原 URL，让 modern-screenshot 自己处理（可能会失败，但不阻塞）
+                        if (!this.options.silentMode) {
+                            console.warn(`📸 ⚠️ 并发下载数已满（${this.activeDownloads.size}/${this.maxConcurrentImageDownloads}），跳过: ${url.substring(0, 50)}...`);
+                        }
+                        return url;
                     }
-                    return await this.imageDownloadQueue.get(url);
-                }
-                // 检查并发下载数限制
-                if (this.activeDownloads.size >= this.maxConcurrentImageDownloads) {
-                    // 并发数已满，返回原 URL，让 modern-screenshot 自己处理（可能会失败，但不阻塞）
-                    if (!this.options.silentMode) {
-                        console.warn(`📸 ⚠️ 并发下载数已满（${this.activeDownloads.size}/${this.maxConcurrentImageDownloads}），跳过: ${url.substring(0, 50)}...`);
+                    // 创建下载 Promise 并加入队列
+                    const downloadPromise = this.downloadImageWithoutProxy(url);
+                    this.imageDownloadQueue.set(url, downloadPromise);
+                    this.activeDownloads.add(url);
+                    try {
+                        const result = await downloadPromise;
+                        return result;
+                    }
+                    finally {
+                        // 下载完成后清理
+                        this.imageDownloadQueue.delete(url);
+                        this.activeDownloads.delete(url);
                     }
-                    return url;
-                }
-                // 创建下载 Promise 并加入队列
-                const downloadPromise = this.downloadImageWithoutProxy(url);
-                this.imageDownloadQueue.set(url, downloadPromise);
-                this.activeDownloads.add(url);
-                try {
-                    const result = await downloadPromise;
-                    return result;
-                }
-                finally {
-                    // 下载完成后清理
-                    this.imageDownloadQueue.delete(url);
-                    this.activeDownloads.delete(url);
                 }
+                // 默认返回原 URL
+                return url;
+            };
+            // 检查元素是否可见且有尺寸
+            const rect = element.getBoundingClientRect();
+            if (rect.width === 0 || rect.height === 0) {
+                throw new Error('元素尺寸为 0，无法截图');
             }
-            // 默认返回原 URL
-            return url;
-        };
-        // 检查元素是否可见且有尺寸
-        const rect = element.getBoundingClientRect();
-        if (rect.width === 0 || rect.height === 0) {
-            throw new Error('元素尺寸为 0，无法截图');
-        }
-        // 每次截图都重新创建 context，确保使用最新的元素状态
-        // 如果已有 context，先清理
-        if (this.screenshotContext) {
-            try {
-                destroyContext(this.screenshotContext);
+            // Worker 数量配置：智能计算或使用用户配置
+            // workerNumber > 0 会启用 Worker 模式，截图处理在后台线程执行，不会阻塞主线程 UI
+            // 如果用户指定了 workerNumber，直接使用；否则根据设备性能自动计算
+            let workerNumber;
+            if (this.options.workerNumber !== undefined && this.options.workerNumber > 0) {
+                // 用户明确指定了 workerNumber
+                workerNumber = this.options.workerNumber;
             }
-            catch (e) {
-                // 忽略清理错误
+            else {
+                // 自动计算 workerNumber
+                const cpuCores = navigator.hardwareConcurrency || 4; // 默认假设 4 核
+                if (isMobile || isLowEndDevice) {
+                    // 移动设备/低端设备：使用 1 个 Worker（避免内存压力）
+                    workerNumber = 1;
+                }
+                else if (cpuCores >= 8) {
+                    // 高性能设备（8核及以上）：使用 3-4 个 Worker（充分利用多核）
+                    // 但根据截图间隔调整：频繁截图（间隔 < 2秒）时使用更多 Worker
+                    const isFrequentScreenshot = this.options.interval < 2000;
+                    workerNumber = isFrequentScreenshot ? Math.min(4, Math.floor(cpuCores / 2)) : 3;
+                }
+                else if (cpuCores >= 4) {
+                    // 中等性能设备（4-7核）：使用 2 个 Worker
+                    workerNumber = 2;
+                }
+                else {
+                    // 低性能设备（< 4核）：使用 1 个 Worker
+                    workerNumber = 1;
+                }
             }
-            this.screenshotContext = null;
-        }
-        // Worker 数量配置：移动设备/低端设备使用 1 个 Worker，桌面设备使用 2 个
-        // workerNumber > 0 会启用 Worker 模式，截图处理在后台线程执行，不会阻塞主线程 UI
-        const workerNumber = isMobile || isLowEndDevice ? 1 : 2;
-        // 构建 createContext 配置
-        // 参考: https://github.com/qq15725/modern-screenshot/blob/main/src/options.ts
-        const contextOptions = {
-            workerNumber, // Worker 数量，> 0 启用 Worker 模式
-            quality: finalQuality, // 图片质量（0-1），已优化为更低的值以减少 base64 大小
-            fetchFn: handleCrossOriginImage, // 使用代理服务器处理跨域图片
-            fetch: {
-                requestInit: {
-                    cache: 'no-cache',
+            // 限制 workerNumber 范围：1-8（避免过多 Worker 导致资源竞争）
+            workerNumber = Math.max(1, Math.min(8, workerNumber));
+            // 构建 createContext 配置
+            // 参考: https://github.com/qq15725/modern-screenshot/blob/main/src/options.ts
+            const contextOptions = {
+                workerNumber, // Worker 数量，> 0 启用 Worker 模式
+                quality: finalQuality, // 图片质量（0-1），已优化为更低的值以减少 base64 大小
+                fetchFn: handleCrossOriginImage, // 使用代理服务器处理跨域图片
+                fetch: {
+                    requestInit: {
+                        cache: 'no-cache',
+                    },
+                    bypassingCache: true,
                 },
-                bypassingCache: true,
-            },
-            // 设置最大 canvas 尺寸，防止生成过大的 canvas（避免内存问题）
-            // 参考: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/canvas#maximum_canvas_size
-            // 大多数浏览器限制为 16,777,216 像素（4096x4096），这里设置为更保守的值
-            maximumCanvasSize: 16777216, // 16M 像素（约 4096x4096）
-        };
-        // 对所有元素都设置尺寸限制（包括 document.body），避免截图过大
-        // 这样可以减少 base64 大小，提高性能
-        if (finalWidth && finalHeight) {
-            contextOptions.width = finalWidth;
-            contextOptions.height = finalHeight;
-            if (!this.options.silentMode) {
-                if (element === document.body || element === document.documentElement) {
-                    console.log(`📸 截取完整页面（document.body），使用压缩尺寸: ${finalWidth}x${finalHeight}`);
+                // 设置最大 canvas 尺寸，防止生成过大的 canvas（避免内存问题）
+                // 参考: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/canvas#maximum_canvas_size
+                // 大多数浏览器限制为 16,777,216 像素（4096x4096），这里设置为更保守的值
+                maximumCanvasSize: 16777216, // 16M 像素（约 4096x4096）
+                // 使用 modern-screenshot 内置的 timeout（更可靠）
+                timeout: Math.max(this.options.interval * 6, 5000),
+            };
+            // 限制 timeout 最多 15 秒
+            contextOptions.timeout = Math.min(contextOptions.timeout, 15000);
+            // 如果用户指定了 workerUrl，使用指定的 URL
+            // 否则让 modern-screenshot 自动处理（它会尝试从 node_modules 或 CDN 加载）
+            // 注意：在某些构建工具（如 Rollup）中，可能需要手动指定 workerUrl
+            if (this.options.workerUrl) {
+                contextOptions.workerUrl = this.options.workerUrl;
+                if (!this.options.silentMode) {
+                    console.log(`📸 使用指定的 Worker URL: ${this.options.workerUrl}`);
                 }
-                else {
-                    console.log(`📸 使用压缩尺寸: ${finalWidth}x${finalHeight}`);
+            }
+            else {
+                // 未指定 workerUrl 时，modern-screenshot 会自动处理
+                // 但在某些构建环境中可能需要手动指定，可以使用 CDN 作为后备
+                // 这里不设置 workerUrl，让 modern-screenshot 自己处理
+                if (!this.options.silentMode) {
+                    console.log('📸 Worker URL 未指定，modern-screenshot 将自动处理');
                 }
             }
-        }
-        else {
-            if (!this.options.silentMode) {
-                console.log(`📸 使用元素实际尺寸: ${elementWidth}x${elementHeight}`);
+            // 对所有元素都设置尺寸限制（包括 document.body），避免截图过大
+            // 这样可以减少 base64 大小，提高性能
+            if (finalWidth && finalHeight) {
+                contextOptions.width = finalWidth;
+                contextOptions.height = finalHeight;
+                if (!this.options.silentMode) {
+                    if (element === document.body || element === document.documentElement) {
+                        console.log(`📸 截取完整页面（document.body），使用压缩尺寸: ${finalWidth}x${finalHeight}`);
+                    }
+                    else {
+                        console.log(`📸 使用压缩尺寸: ${finalWidth}x${finalHeight}`);
+                    }
+                }
             }
-        }
-        // 缩放配置：移动设备使用更低的缩放比例，进一步减少图片大小
-        // 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;
-        }
-        // modern-screenshot 会自动处理 worker URL，不需要手动设置 workerUrl
-        // 当 workerNumber > 0 时，截图处理会在 Worker 线程中执行，不会阻塞主线程 UI
-        // 创建 Worker 上下文（每次截图都创建新的，确保元素状态最新）
-        if (!this.options.silentMode) {
-            console.log(`📸 Worker 模式: ${workerNumber} 个 Worker，质量: ${finalQuality.toFixed(2)}，缩放: ${contextOptions.scale || 1}`);
-        }
-        this.screenshotContext = await createContext$1(element, contextOptions);
-        try {
-            // 使用 Worker 上下文进行截图
-            const dataUrl = await domToPng(this.screenshotContext);
-            // 验证截图结果
-            if (!dataUrl || dataUrl.length < 100) {
-                throw new Error('生成的截图数据无效或过短');
+            else {
+                if (!this.options.silentMode) {
+                    console.log(`📸 使用元素实际尺寸: ${elementWidth}x${elementHeight}`);
+                }
             }
-            // 根据输出格式转换
-            if (this.options.outputFormat !== 'png') {
-                // modern-screenshot 默认输出 PNG，如果需要其他格式，需要转换
-                const canvas = document.createElement('canvas');
-                const ctx = canvas.getContext('2d');
-                if (!ctx) {
-                    throw new Error('无法获取 canvas context');
+            // 缩放配置：移动设备使用更低的缩放比例，进一步减少图片大小
+            // 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;
+            }
+            // 优化：复用 context，避免频繁创建和销毁（性能提升 20%+）
+            // 只在元素变化或配置变化时重新创建 context
+            const contextOptionsHash = JSON.stringify({
+                workerNumber,
+                quality: finalQuality,
+                scale: contextOptions.scale,
+                width: contextOptions.width,
+                height: contextOptions.height,
+                maximumCanvasSize: contextOptions.maximumCanvasSize,
+                timeout: contextOptions.timeout
+            });
+            const needsRecreateContext = !this.screenshotContext ||
+                this.contextElement !== element ||
+                this.contextOptionsHash !== contextOptionsHash;
+            if (needsRecreateContext) {
+                if (!this.options.silentMode) {
+                    if (this.screenshotContext) {
+                        console.log('📸 检测到元素或配置变化，重新创建 context...');
+                    }
+                    else {
+                        console.log(`📸 Worker 模式: ${workerNumber} 个 Worker，质量: ${finalQuality.toFixed(2)}，缩放: ${contextOptions.scale || 1}`);
+                    }
                 }
-                const img = new Image();
-                let convertedDataUrl;
-                try {
-                    await new Promise((resolve, reject) => {
-                        img.onload = () => {
-                            canvas.width = img.width;
-                            canvas.height = img.height;
-                            ctx.drawImage(img, 0, 0);
-                            resolve();
-                        };
-                        img.onerror = reject;
-                        img.src = dataUrl;
-                    });
-                    let mimeType = 'image/jpeg';
-                    // 使用与 createContext 相同的质量设置
-                    let conversionQuality = finalQuality;
-                    if (this.options.outputFormat === 'webp' && !isMobile) {
-                        try {
-                            const testCanvas = document.createElement('canvas');
-                            testCanvas.width = 1;
-                            testCanvas.height = 1;
-                            const testDataUrl = testCanvas.toDataURL('image/webp');
-                            if (testDataUrl.indexOf('webp') !== -1) {
-                                mimeType = 'image/webp';
+                // 销毁旧 context
+                if (this.screenshotContext) {
+                    try {
+                        destroyContext(this.screenshotContext);
+                    }
+                    catch (e) {
+                        // 忽略清理错误
+                    }
+                    this.screenshotContext = null;
+                }
+                // 添加 progress 回调（可选，用于显示进度）
+                if (!this.options.silentMode) {
+                    contextOptions.progress = (current, total) => {
+                        if (total > 0) {
+                            const percent = Math.round((current / total) * 100);
+                            if (percent % 25 === 0 || current === total) { // 每 25% 或完成时打印
+                                console.log(`📸 截图进度: ${current}/${total} (${percent}%)`);
                             }
                         }
-                        catch {
-                            mimeType = 'image/jpeg';
+                    };
+                }
+                // 添加重试机制创建新 context
+                let retries = 0;
+                const maxRetries = this.options.maxRetries || 2;
+                while (retries <= maxRetries) {
+                    try {
+                        this.screenshotContext = await createContext$1(element, contextOptions);
+                        this.contextElement = element;
+                        this.contextOptionsHash = contextOptionsHash;
+                        break;
+                    }
+                    catch (error) {
+                        if (retries === maxRetries) {
+                            throw new Error(`创建截图上下文失败（已重试 ${maxRetries} 次）: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                        retries++;
+                        const delay = 1000 * retries; // 递增延迟：1秒、2秒...
+                        if (!this.options.silentMode) {
+                            console.warn(`📸 ⚠️ 创建截图上下文失败，${delay}ms 后重试 (${retries}/${maxRetries})...`);
                         }
+                        await new Promise(resolve => setTimeout(resolve, delay));
                     }
-                    // 使用优化后的质量进行格式转换
-                    convertedDataUrl = mimeType === 'image/png'
-                        ? canvas.toDataURL(mimeType)
-                        : canvas.toDataURL(mimeType, conversionQuality);
                 }
-                finally {
-                    // 清理资源，释放内存
-                    img.src = ''; // 清除图片引用
-                    img.onload = null;
-                    img.onerror = null;
-                    canvas.width = 0; // 清空 canvas
-                    canvas.height = 0;
-                    ctx.clearRect(0, 0, 0, 0); // 清除绘制内容
+            }
+            else {
+                if (!this.options.silentMode) {
+                    console.log('📸 复用现有 context（性能优化）');
                 }
-                return convertedDataUrl;
             }
-            return dataUrl;
+            try {
+                // 根据输出格式选择对应的 API，避免格式转换（性能优化）
+                // 注意：timeout 已经在 createContext 时设置，modern-screenshot 内部会处理超时
+                let dataUrl;
+                const outputFormat = this.options.outputFormat || 'webp';
+                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('生成的截图数据无效或过短');
+                }
+                if (!this.options.silentMode) {
+                    console.log(`📸 ✅ modern-screenshot 截图成功（${outputFormat.toUpperCase()} 格式，直接输出，无需转换）`);
+                }
+                return dataUrl;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (!this.options.silentMode) {
+                    console.error('📸 modern-screenshot 截图失败:', errorMessage);
+                    console.error('📸 元素信息:', {
+                        width: rect.width,
+                        height: rect.height,
+                        scrollWidth: element.scrollWidth,
+                        scrollHeight: element.scrollHeight,
+                        display: window.getComputedStyle(element).display,
+                        visibility: window.getComputedStyle(element).visibility
+                    });
+                }
+                throw error;
+            }
+            finally {
+                // 优化：不复用 context 时才清理（性能优化）
+                // 如果元素或配置没有变化，保留 context 以便下次复用
+                // 这样可以避免频繁创建和销毁 Worker，提升性能 20%+
+                // 释放截图锁
+                this.isScreenshotInProgress = false;
+            }
         }
         catch (error) {
+            // 外层错误处理：确保即使发生错误也释放锁
             const errorMessage = error instanceof Error ? error.message : String(error);
             if (!this.options.silentMode) {
-                console.error('📸 modern-screenshot 截图失败:', errorMessage);
-                console.error('📸 元素信息:', {
-                    width: rect.width,
-                    height: rect.height,
-                    scrollWidth: element.scrollWidth,
-                    scrollHeight: element.scrollHeight,
-                    display: window.getComputedStyle(element).display,
-                    visibility: window.getComputedStyle(element).visibility
-                });
+                console.error('📸 modern-screenshot 截图异常:', errorMessage);
             }
             throw error;
         }
         finally {
-            // 每次截图后立即清理 context，释放 Worker 和内存
-            // 这是防止内存泄漏的关键步骤
-            if (this.screenshotContext) {
-                try {
-                    destroyContext(this.screenshotContext);
-                    if (!this.options.silentMode) {
-                        console.log('📸 ✅ modern-screenshot context 已清理');
-                    }
-                }
-                catch (e) {
-                    if (!this.options.silentMode) {
-                        console.warn('📸 ⚠️ 清理 context 失败:', e);
-                    }
-                }
-                finally {
-                    // 确保 context 引用被清除
-                    this.screenshotContext = null;
-                }
+            // 确保截图锁被释放（即使发生未捕获的错误）
+            if (this.isScreenshotInProgress) {
+                this.isScreenshotInProgress = false;
             }
-            // 强制触发垃圾回收（如果可能）
-            // 注意：这需要浏览器支持，不是所有浏览器都有效
-            if (typeof window !== 'undefined' && window.gc && typeof window.gc === 'function') {
+            // 处理队列中的下一个请求
+            this.processScreenshotQueue();
+        }
+    }
+    /**
+     * 处理截图队列
+     */
+    async processScreenshotQueue() {
+        if (this.isProcessingQueue || this.screenshotQueue.length === 0) {
+            return;
+        }
+        this.isProcessingQueue = true;
+        while (this.screenshotQueue.length > 0 && !this.isScreenshotInProgress) {
+            const task = this.screenshotQueue.shift();
+            if (task) {
                 try {
-                    window.gc();
+                    task.resolve();
+                    // 等待当前截图完成
+                    while (this.isScreenshotInProgress) {
+                        await new Promise(resolve => setTimeout(resolve, 50));
+                    }
                 }
-                catch {
-                    // 忽略 GC 错误
+                catch (error) {
+                    task.reject(error instanceof Error ? error : new Error(String(error)));
                 }
             }
         }
+        this.isProcessingQueue = false;
     }
     /**
      * 预连接代理服务器（优化网络性能）
@@ -16466,6 +16683,18 @@ class ScreenshotManager {
      * 清理资源
      */
     destroy() {
+        // 清理 modern-screenshot context
+        if (this.screenshotContext) {
+            try {
+                destroyContext(this.screenshotContext);
+            }
+            catch (e) {
+                // 忽略清理错误
+            }
+            this.screenshotContext = null;
+            this.contextElement = null;
+            this.contextOptionsHash = '';
+        }
         this.stopScreenshot();
         if (this.worker) {
             this.worker.terminate();