【Bug已解决】openclaw: "regex timeout" / RegExp execution exceeded — OpenClaw 正则表达式超时解决方案

1. 问题描述

在使用 OpenClaw 处理文本匹配或执行正则表达式操作时，系统报出正则表达式超时错误：

# 正则表达式执行超时
$ openclaw "使用复杂正则匹配大型文本"
Error: regex timeout
RegExp execution exceeded 5000ms limit
Pattern: /(\w+\s+){50}\w+/
Subject length: 5000000 chars

# 灾难性回溯
$ openclaw "正则匹配嵌套HTML"
Error: Maximum call stack exceeded
Catastrophic backtracking detected
Pattern: /(<div[^>]*>.*<\/div>)/s
Input size: 200KB

# 正则编译错误
$ openclaw "使用动态正则"
Error: Invalid regular expression
SyntaxError: Invalid group specified
Pattern: /(?<invalid>.*?)/

# 正则内存溢出
$ openclaw "正则提取大量匹配"
Error: Regex result memory exceeded
Captured groups: 100000
Memory limit: 256MB exceeded

这个问题在以下场景中特别常见：

• 正则表达式存在灾难性回溯（ReDoS）
• 输入文本过大（>1MB）
• 嵌套量词导致指数级回溯
• 贪婪匹配配合复杂分组
• 动态生成的正则表达式语法错误
• 无限循环的正则替换

2. 原因分析

正则表达式引擎匹配
    ↓
尝试路径1 ←──── 匹配失败
    ↓
回溯 ←──── 尝试路径2
    ↓
继续回溯 ←──── 指数级路径数
    ↓
执行时间爆炸 → 超时

原因分类	具体表现	占比
灾难性回溯	指数级回溯	约 40%
输入过大	>1MB文本	约 25%
贪婪匹配	过度消耗	约 15%
嵌套量词	(a+)+ 模式	约 10%
编译错误	语法无效	约 5%
内存溢出	匹配过多	约 5%

深层原理

JavaScript 的正则表达式引擎使用回溯（backtracking）算法。当匹配失败时，引擎会回退到上一个量词位置，尝试其他可能的匹配路径。某些正则模式会产生指数级的回溯路径，例如 (a+)+b 匹配 aaaa...aaaa!（末尾非 b），引擎需要尝试所有可能的分组方式，路径数为 2^n（n 为 a 的数量）。对于 30 个 a，需要尝试约 10 亿条路径，导致 CPU 100% 占用数分钟甚至更久。这种攻击被称为 ReDoS（Regular Expression Denial of Service）。V8 引擎虽然对部分模式有优化，但大多数复杂回溯模式仍无法避免。

3. 解决方案

方案一：优化正则表达式避免回溯（最推荐）

// 常见的灾难性回溯模式及修复

// ❌ 灾难性: 嵌套量词
const bad1 = /(\w+\s+)+\w+/;

// ✅ 修复: 使用非贪婪量词或原子组
const good1 = /(\w+\s+?)\w+/;  // 非贪婪
// 或更优: 使用具体分隔符
const better1 = /[\w\s]+/;     // 合并字符类

// ❌ 灾难性: 重叠交替
const bad2 = /(a|a)*b/;

// ✅ 修复: 去除重叠
const good2 = /a*b/;

// ❌ 灾难性: 贪婪匹配嵌套HTML
const bad3 = /<div[^>]*>.*<\/div>/s;

// ✅ 修复: 使用非贪婪或具体匹配
const good3 = /<div[^>]*>[\s\S]*?<\/div>/;  // 非贪婪

// ❌ 灾难性: 量词+分组+量词
const bad4 = /(\d+)+/;

// ✅ 修复: 去除冗余分组
const good4 = /\d+/;

// 正则优化检查工具
class RegexOptimizer {
    static checkPattern(pattern) {
        const warnings = [];
        const patternStr = pattern.toString();
        
        // 检查嵌套量词
        if (/(\+|\*|\{)\)[\+\*\{]/.test(patternStr)) {
            warnings.push('⚠️ 嵌套量词可能导致回溯');
        }
        
        // 检查重叠交替
        if (/\(([^|]+)\|.*\1.*\)/.test(patternStr)) {
            warnings.push('⚠️ 交替分支重叠可能导致回溯');
        }
        
        // 检查贪婪量词后跟可选
        if (/[\+\*]\?*\+/.test(patternStr)) {
            warnings.push('⚠️ 贪婪量词后跟可选量词可能回溯');
        }
        
        // 检查 . + 量词
        if (/\.\+|\.\*/.test(patternStr)) {
            warnings.push('⚠️ 点号+量词可能匹配过多');
        }
        
        return warnings;
    }
    
    static safeMatch(pattern, text, timeoutMs = 5000) {
        const warnings = RegexOptimizer.checkPattern(pattern);
        if (warnings.length > 0) {
            console.warn('正则警告:', warnings.join(', '));
        }
        
        const start = Date.now();
        try {
            const result = pattern.exec(text);
            const elapsed = Date.now() - start;
            
            if (elapsed > 1000) {
                console.warn(`⚠️ 正则执行耗时 ${elapsed}ms，考虑优化`);
            }
            
            return result;
        } catch (e) {
            console.error('正则执行失败:', e.message);
            return null;
        }
    }
}

方案二：配置正则执行超时和限制

# 配置 OpenClaw 的正则限制
python3 -c "
import json
with open('.openclaw/config.json', 'r') as f:
    config = json.load(f)

config['regex'] = {
    'timeoutMs': 5000,              # 5秒超时
    'maxInputSize': 1048576,        # 最大输入1MB
    'maxMatches': 100000,           # 最大匹配数
    'maxCapturedMemory': 268435456, # 最大捕获内存256MB
    'maxBacktracks': 1000000,       # 最大回溯次数
    'enableSafeMode': True,         # 安全模式
    'rejectDangerousPatterns': True,# 拒绝危险模式
    'warnOnSlowPattern': True,      # 慢正则警告
    'slowThresholdMs': 1000         # 慢正则阈值1秒
}

with open('.openclaw/config.json', 'w') as f:
    json.dump(config, f, indent=2)
print('正则限制已配置: 5秒超时, 1MB输入, 安全模式')
"

# 使用 Worker Thread 实现真正的超时
cat > .openclaw/regex_worker.js << 'JEOF'
// 正则表达式 Worker（支持超时终止）
const { parentPort, workerData } = require('worker_threads');

const { pattern, flags, text, timeout } = workerData;

try {
    const regex = new RegExp(pattern, flags);
    const start = Date.now();
    
    // 设置超时检查
    const timer = setInterval(() => {
        if (Date.now() - start > timeout) {
            parentPort.postMessage({
                type: 'timeout',
                elapsed: Date.now() - start
            });
            clearInterval(timer);
            process.exit(1);
        }
    }, 100);
    
    // 执行匹配
    const matches = [];
    let match;
    let count = 0;
    
    while ((match = regex.exec(text)) !== null && count < 100000) {
        matches.push({
            index: match.index,
            match: match[0],
            groups: match.slice(1)
        });
        count++;
        
        // 防止零宽匹配无限循环
        if (match.index === regex.lastIndex) {
            regex.lastIndex++;
        }
    }
    
    clearInterval(timer);
    
    parentPort.postMessage({
        type: 'result',
        matches: matches,
        count: count,
        elapsed: Date.now() - start
    });
} catch (error) {
    parentPort.postMessage({
        type: 'error',
        message: error.message
    });
}
JEOF

// 主线程调用
cat > .openclaw/safe_regex.js << 'JEOF'
const { Worker } = require('worker_threads');
const path = require('path');

function safeRegexMatch(pattern, flags, text, timeout = 5000) {
    return new Promise((resolve, reject) => {
        const worker = new Worker(path.join(__dirname, 'regex_worker.js'), {
            workerData: { pattern, flags, text, timeout }
        });
        
        const timer = setTimeout(() => {
            worker.terminate();
            reject(new Error(`Regex timeout after ${timeout}ms`));
        }, timeout + 1000);
        
        worker.on('message', (msg) => {
            clearTimeout(timer);
            worker.terminate();
            
            if (msg.type === 'result') {
                resolve(msg);
            } else if (msg.type === 'timeout') {
                reject(new Error(`Regex timeout after ${msg.elapsed}ms`));
            } else if (msg.type === 'error') {
                reject(new Error(msg.message));
            }
        });
        
        worker.on('error', (err) => {
            clearTimeout(timer);
            reject(err);
        });
    });
}

module.exports = { safeRegexMatch };
JEOF

方案三：使用替代方案处理复杂匹配

# 对于复杂文本匹配，使用字符串方法或解析器替代正则

class SafeTextMatcher:
    """安全的文本匹配工具（避免正则回溯）"""
    
    @staticmethod
    def extract_html_tags(html, tag_name):
        """提取 HTML 标签（使用解析器替代正则）"""
        from html.parser import HTMLParser
        
        class TagExtractor(HTMLParser):
            def __init__(self, target_tag):
                super().__init__()
                self.target_tag = target_tag
                self.results = []
                self.current_tag = None
                self.current_attrs = None
                self.current_data = []
            
            def handle_starttag(self, tag, attrs):
                if tag == self.target_tag:
                    self.current_tag = tag
                    self.current_attrs = dict(attrs)
                    self.current_data = []
            
            def handle_endtag(self, tag):
                if tag == self.target_tag and self.current_tag:
                    self.results.append({
                        'tag': self.current_tag,
                        'attrs': self.current_attrs,
                        'content': ''.join(self.current_data)
                    })
                    self.current_tag = None
            
            def handle_data(self, data):
                if self.current_tag:
                    self.current_data.append(data)
        
        extractor = TagExtractor(tag_name)
        extractor.feed(html)
        return extractor.results
    
    @staticmethod
    def find_pattern_safe(text, pattern, max_iterations=100000):
        """安全的模式匹配（限制迭代次数）"""
        import re
        
        count = 0
        matches = []
        
        try:
            for match in re.finditer(pattern, text):
                matches.append({
                    'start': match.start(),
                    'end': match.end(),
                    'group': match.group()
                })
                count += 1
                if count >= max_iterations:
                    print(f"⚠️ 达到最大迭代数: {max_iterations}")
                    break
        except re.error as e:
            print(f"正则错误: {e}")
        
        return matches
    
    @staticmethod
    def chunk_match(text, pattern, chunk_size=100000):
        """分块匹配大文本"""
        import re
        results = []
        offset = 0
        
        while offset < len(text):
            chunk = text[offset:offset + chunk_size]
            
            try:
                for match in re.finditer(pattern, chunk):
                    results.append({
                        'start': offset + match.start(),
                        'end': offset + match.end(),
                        'group': match.group()
                    })
            except re.error as e:
                print(f"块匹配错误: {e}")
                break
            
            offset += chunk_size
        
        return results
    
    @staticmethod
    def validate_regex(pattern):
        """验证正则表达式安全性"""
        import re
        warnings = []
        
        # 检查嵌套量词
        if re.search(r'(\+|\*|\{)\)\s*(\+|\*|\{)', pattern):
            warnings.append('嵌套量词: 可能导致回溯')
        
        # 检查重叠交替
        if re.search(r'\(([^|]+)\|.*\1', pattern):
            warnings.append('重叠交替: 可能导致回溯')
        
        # 检查贪婪量词
        if re.search(r'\.\+|\.\*', pattern):
            warnings.append('贪婪点号: 可能匹配过多')
        
        # 尝试编译
        try:
            re.compile(pattern)
        except re.error as e:
            return False, [f'编译错误: {e}']
        
        return len(warnings) == 0, warnings

if __name__ == "__main__":
    import sys
    
    matcher = SafeTextMatcher()
    
    # 验证正则
    pattern = sys.argv[1] if len(sys.argv) > 1 else r'(\w+\s+)+\w+'
    safe, warnings = matcher.validate_regex(pattern)
    
    print(f"正则: {pattern}")
    print(f"安全: {'✅' if safe else '❌'}")
    for w in warnings:
        print(f"  {w}")

方案四：预编译和缓存正则

// 正则表达式缓存和预编译
class RegexCache {
    constructor(maxSize = 100) {
        this.cache = new Map();
        this.maxSize = maxSize;
        this.stats = {
            hits: 0,
            misses: 0,
            compiles: 0
        };
    }
    
    get(pattern, flags = '') {
        const key = `${pattern}:${flags}`;
        
        if (this.cache.has(key)) {
            this.stats.hits++;
            return this.cache.get(key);
        }
        
        this.stats.misses++;
        
        // 编译正则
        try {
            const regex = new RegExp(pattern, flags);
            this.cache.set(key, regex);
            this.stats.compiles++;
            
            // LRU 淘汰
            if (this.cache.size > this.maxSize) {
                const firstKey = this.cache.keys().next().value;
                this.cache.delete(firstKey);
            }
            
            return regex;
        } catch (e) {
            throw new Error(`正则编译失败: ${e.message}`);
        }
    }
    
    getStats() {
        const total = this.stats.hits + this.stats.misses;
        return {
            ...this.stats,
            hitRate: total > 0 ? (this.stats.hits / total * 100).toFixed(1) + '%' : '0%',
            cacheSize: this.cache.size
        };
    }
}

// 全局缓存实例
const regexCache = new RegexCache(100);

// 预编译常用正则
const commonPatterns = {
    email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
    url: /^https?:\/\/[^\s]+$/,
    ipv4: /^(\d{1,3}\.){3}\d{1,3}$/,
    date: /^\d{4}-\d{2}-\d{2}$/,
    time: /^\d{2}:\d{2}(:\d{2})?$/
};

// 预编译
for (const [name, pattern] of Object.entries(commonPatterns)) {
    regexCache.get(pattern.source, pattern.flags);
}

module.exports = { regexCache, commonPatterns };

方案五：配置 ReDoS 防护

# 配置 ReDoS 防护
python3 -c "
import json
with open('.openclaw/config.json', 'r') as f:
    config = json.load(f)

config['regex']['redosProtection'] = {
    'enabled': True,
    'staticAnalysis': True,         # 静态分析检测危险模式
    'runtimeMonitoring': True,      # 运行时监控
    'autoReject': True,             # 自动拒绝危险正则
    'safeAlternatives': True,       # 提供安全替代方案
    'blockedPatterns': [
        '(\\w+\\s+)+\\w+',           # 嵌套量词
        '(a|a)*b',                   # 重叠交替
        '(<\\w+[^>]*>.*<\\/\\w+>)', # HTML贪婪匹配
        '(\\d+)+',                   # 冗余分组量词
        '.+.*',                      # 连续贪婪量词
        '([^/]+/)+[^/]+'            # 路径嵌套量词
    ]
}

with open('.openclaw/config.json', 'w') as f:
    json.dump(config, f, indent=2)
print('ReDoS 防护已启用: 静态分析+运行时监控+自动拒绝')
"

# 使用 safe-regex 库检测危险正则
# npm install safe-regex
node -e "
const safe = require('safe-regex');

const patterns = [
    /(\w+\s+)+\w+/,      // 危险
    /a*b/,                // 安全
    /(a|a)*b/,            // 危险
    /^[a-z]+$/,           // 安全
    /(<div[^>]*>.*<\/div>)/s,  // 危险
];

patterns.forEach(p => {
    const isSafe = safe(p);
    console.log(\`\${isSafe ? '✅' : '❌'} \${p}\`);
});
" 2>/dev/null || echo "安装 safe-regex: npm install safe-regex"

方案六：使用 RE2 引擎替代

# Google RE2 引擎不支持回溯，保证线性时间
# npm install re2

cat > .openclaw/re2_regex.js << 'JEOF'
// 使用 RE2 引擎（无回溯，线性时间保证）
const RE2 = require('re2');

class SafeRegex {
    constructor(pattern, flags) {
        try {
            this.regex = new RE2(pattern, flags);
        } catch (e) {
            throw new Error(`RE2 编译失败: ${e.message}`);
        }
    }
    
    exec(text) {
        return this.regex.exec(text);
    }
    
    test(text) {
        return this.regex.test(text);
    }
    
    replace(text, replacement) {
        return this.regex.replace(text, replacement);
    }
    
    match(text) {
        return this.regex.match(text);
    }
    
    // RE2 不支持的特性:
    // - 反向引用 (backreferences)
    // - 环视 (lookahead/lookbehind)
    // 如果需要这些特性，回退到原生 RegExp
}

// 检查正则是否需要原生引擎
function needsNativeEngine(pattern) {
    const nativeFeatures = [
        /\\1|\\2|\\3/,          // 反向引用
        /\(\?<[=!]/,             // 后向环视
        /\(\?[=!]/,              // 前向环视
    ];
    return nativeFeatures.some(re => re.test(pattern));
}

function createRegex(pattern, flags) {
    if (needsNativeEngine(pattern)) {
        console.warn('⚠️ 使用原生引擎（可能有回溯风险）:', pattern);
        return new RegExp(pattern, flags);
    }
    return new SafeRegex(pattern, flags);
}

module.exports = { SafeRegex, createRegex };
JEOF

echo "RE2 引擎替代方案已创建"

4. 各方案对比总结

方案	适用场景	推荐指数
方案一：优化正则	根本解决	⭐⭐⭐⭐⭐
方案二：超时限制	安全防护	⭐⭐⭐⭐⭐
方案三：替代方案	HTML/复杂匹配	⭐⭐⭐⭐
方案四：缓存编译	性能优化	⭐⭐⭐⭐
方案五：ReDoS防护	安全加固	⭐⭐⭐⭐⭐
方案六：RE2引擎	彻底解决	⭐⭐⭐⭐

5. 常见问题 FAQ

5.1 Windows 上正则性能差异

Windows 的 V8 正则性能可能与 Linux 不同：

# Windows 上设置性能标志
$env:NODE_OPTIONS = "--max-old-space-size=4096"
openclaw "正则匹配任务"

# 如果性能差，使用 RE2
# npm install re2

5.2 Docker 中正则行为不同

容器中的 Node.js 版本可能不同：

# 确保使用相同的 Node.js 版本
docker run --rm node:20 node -e "
const re = /(\w+\s+)+\w+/;
const text = 'word '.repeat(30) + 'word';
const start = Date.now();
re.test(text);
console.log('耗时:', Date.now() - start, 'ms');
"

# 如果需要 RE2，在 Dockerfile 中安装
RUN npm install re2

5.3 CI/CD 中正则测试超时

CI 中可能对正则有额外限制：

# CI 中设置超时
env:
  OPENCLAW_REGEX_TIMEOUT: 3000  # 3秒
steps:
  - name: Run regex tasks
    run: |
      timeout 30 openclaw "正则匹配"
    
  - name: Validate regex safety
    run: |
      node -e "
      const safe = require('safe-regex');
      // 检查项目中的正则
      "

5.4 动态生成的正则不安全

用户输入拼接的正则可能危险：

// ❌ 危险: 用户输入直接拼入正则
const userInput = getUserInput();
const regex = new RegExp(userInput);  // 可能导致 ReDoS

// ✅ 安全: 转义用户输入
function escapeRegex(str) {
    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

const safePattern = escapeRegex(userInput);
const regex = new RegExp(safePattern);

// ✅ 更安全: 使用 RE2
const RE2 = require('re2');
const regex = new RE2(userInput);  // RE2 保证线性时间

// ✅ 最佳: 验证 + 限制
function safeUserRegex(input) {
    // 转义
    const escaped = escapeRegex(input);
    
    // 限制长度
    if (escaped.length > 100) {
        throw new Error('正则过长');
    }
    
    // 使用 RE2
    return new RE2(escaped);
}

5.5 正则匹配大文件内存溢出

一次性读取大文件做正则匹配：

# 流式读取大文件进行正则匹配
import re

def stream_regex_match(filepath, pattern, chunk_size=65536):
    """流式正则匹配大文件"""
    regex = re.compile(pattern)
    results = []
    overlap = ''
    
    with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
        while True:
            chunk = f.read(chunk_size)
            if not chunk:
                break
            
            # 在重叠区域+当前块中匹配
            text = overlap + chunk
            
            for match in regex.finditer(text):
                # 确保匹配不在重叠区域
                if match.start() >= len(overlap):
                    results.append({
                        'start': match.start() - len(overlap),
                        'match': match.group()
                    })
            
            # 保留最后一部分作为下次的重叠
            overlap = text[-len(pattern) * 2:] if len(text) > len(pattern) * 2 else text
    
    return results

# 使用
matches = stream_regex_match('large_file.log', r'\d{4}-\d{2}-\d{2}')
print(f"找到 {len(matches)} 个匹配")

5.6 正则替换导致无限循环

某些替换模式可能导致无限循环：

# 危险的替换模式
# ❌ str.replace(/(.)/g, '$1$1')  # 可能导致无限增长

# 限制替换次数
python3 -c "
import re

def safe_replace(text, pattern, replacement, max_replacements=10000):
    count = 0
    result = text
    
    while count < max_replacements:
        new_result = re.sub(pattern, replacement, result, count=1)
        if new_result == result:
            break
        result = new_result
        count += 1
    
    if count >= max_replacements:
        print(f'⚠️ 达到最大替换次数: {max_replacements}')
    
    return result, count

text = 'Hello World'
result, count = safe_replace(text, r'l', 'LL')
print(f'替换 {count} 次: {result}')
"

5.7 Unicode 正则匹配问题

JavaScript 正则的 Unicode 处理：

// ❌ 不正确的 Unicode 匹配
'𝄞'.match(/./).length  // 2（surrogate pair）

// ✅ 使用 u 标志
'𝄞'.match(/./u).length  // 1

// 中文匹配
// ❌ 可能遗漏某些字符
const bad = /[\u4e00-\u9fa5]/;

// ✅ 使用 Unicode 属性转义
const good = /\p{Script=Han}/u;

// Emoji 匹配
const emoji = /\p{Extended_Pictographic}/u;

// 配置 OpenClaw 使用 Unicode 模式
// config['regex']['unicodeMode'] = true

5.8 多语言正则匹配

不同语言的文本匹配需要不同策略：

# 多语言正则匹配
import re

class MultilingualRegex:
    # 各语言的 Unicode 范围
    RANGES = {
        'chinese': r'\u4e00-\u9fff\u3400-\u4dbf',
        'japanese': r'\u3040-\u309f\u30a0-\u30ff',
        'korean': r'\uac00-\ud7af',
        'arabic': r'\u0600-\u06ff',
        'cyrillic': r'\u0400-\u04ff',
    }
    
    @staticmethod
    def match_language(text, language):
        """匹配特定语言的字符"""
        if language == 'unicode':
            # 使用 Unicode 属性
            pattern = r'\p{L}'
        elif language in MultilingualRegex.RANGES:
            pattern = f'[{MultilingualRegex.RANGES[language]}]'
        else:
            pattern = r'\w'
        
        return re.findall(pattern, text)
    
    @staticmethod
    def detect_dominant_language(text):
        """检测主要语言"""
        counts = {}
        for lang in MultilingualRegex.RANGES:
            chars = MultilingualRegex.match_language(text, lang)
            counts[lang] = len(chars)
        
        dominant = max(counts, key=counts.get) if counts else 'unknown'
        return dominant, counts

排查清单速查表

□ 1. 检查正则是否有嵌套量词: (\w+)+ 模式
□ 2. 检查是否有重叠交替: (a|a)* 模式
□ 3. 设置 regex.timeoutMs=5000
□ 4. 设置 regex.maxInputSize=1MB
□ 5. 使用 safe-regex 检测危险模式
□ 6. 考虑使用 RE2 引替（线性时间）
□ 7. 大文件使用流式分块匹配
□ 8. 预编译和缓存常用正则
□ 9. 转义用户输入防止注入
□ 10. HTML 解析用解析器替代正则

6. 总结

1. 最常见原因：灾难性回溯（40%）导致正则执行时间指数级增长
2. 根本解决：优化正则表达式，消除嵌套量词和重叠交替模式
3. 安全防护：配置 timeoutMs=5000 和 maxInputSize=1MB，启用 ReDoS 检测
4. RE2 引擎：安装 re2 包使用 Google 的线性时间正则引擎（不支持反向引用和环视）
5. 最佳实践建议：使用 safe-regex 库静态分析正则安全性，对大文件使用流式分块匹配，HTML 解析使用专用解析器而非正则，动态正则必须转义用户输入

故障排查流程图

flowchart TD
    A[正则超时] --> B[分析正则模式]
    B --> C[检查嵌套量词]
    C --> D{有危险模式?}
    D -->|是| E[优化正则表达式]
    D -->|否| F[检查输入大小]
    E --> G[消除嵌套量词]
    G --> H[使用非贪婪量词]
    H --> I[openclaw测试]
    F --> J{输入 > 1MB?}
    J -->|是| K[分块匹配]
    J -->|否| L[设置超时限制]
    K --> M[流式读取65536块]
    M --> I
    L --> N[regex.timeoutMs=5000]
    N --> O[使用Worker超时]
    O --> I
    I --> P{成功?}
    P -->|是| Q[✅ 问题解决]
    P -->|否| R[使用RE2引擎]
    R --> S[npm install re2]
    S --> T[RE2替代RegExp]
    T --> Q
    Q --> U[部署ReDoS防护]
    U --> V[safe-regex检测]
    V --> W[缓存预编译正则]
    W --> X[✅ 长期稳定]