pure-js-db 2.53.0 → 2.53.1

package/src/security/sql-injection-detector.js

@@ -85,6 +85,225 @@ function _evalTautology(numLeft, numOp, numRight, strLeft, strOp, strRight, bool
 }
 
 
+// ── 常量表达式恒真检测（2026-10-31 渗透测试 H-01 修复）──
+// 原 TAUTOLOGY_RE 只覆盖「数字比较 / 字符串相等 / TRUE/FALSE / NULL IS」。
+// 实测 `OR 1 BETWEEN 1 AND 1`、`OR 'a' LIKE 'a'`、`OR 1 IN (1)`、`OR (1=1)`、
+// `OR NOT 1=2` 等恒真变体可绕过 HTTP 层 critical/high 门禁。
+// 以下实现一个轻量 tokenizer + 递归下降求值器，专门识别「连接词后跟纯常量表达式」
+// 的恒真/恒假构造（BETWEEN / IN / LIKE / 括号 / NOT / IS NULL / 比较）。
+function _constTokenize(str) {
+  const tokens = [];
+  let i = 0;
+  const n = str.length;
+  while (i < n) {
+    const c = str[i];
+    if (/\s/.test(c)) { i++; continue; }
+    if (c === '(' || c === ')') { tokens.push({ type: 'paren', value: c }); i++; continue; }
+    if (c === ',') { tokens.push({ type: 'comma' }); i++; continue; }
+    // 字符串字面量（'' 转义）
+    if (c === "'") {
+      let j = i + 1;
+      let val = '';
+      while (j < n) {
+        if (str[j] === "'") {
+          if (str[j + 1] === "'") { val += "'"; j += 2; continue; }
+          j++;
+          break;
+        }
+        val += str[j];
+        j++;
+      }
+      if (j > n) return null; // 未闭合
+      tokens.push({ type: 'string', value: val });
+      i = j;
+      continue;
+    }
+    // 数字（含 +/- 前缀、小数、科学计数法）
+    if (/[0-9]/.test(c) || ((c === '-' || c === '+') && /[0-9]/.test(str[i + 1]))) {
+      let j = i + 1;
+      while (j < n && /[0-9.eE]/.test(str[j])) j++;
+      // 处理 1e-5 / 1E+3 形式的尾随符号
+      if (j < n && (str[j] === '-' || str[j] === '+') && (str[j - 1] === 'e' || str[j - 1] === 'E')) j++;
+      while (j < n && /[0-9]/.test(str[j])) j++;
+      const num = Number(str.slice(i, j));
+      if (Number.isNaN(num)) return null;
+      tokens.push({ type: 'number', value: num });
+      i = j;
+      continue;
+    }
+    // 比较运算符
+    const two = str.slice(i, i + 2);
+    if (two === '<=' || two === '>=' || two === '<>' || two === '!=') {
+      tokens.push({ type: 'op', value: two });
+      i += 2;
+      continue;
+    }
+    if (c === '=' || c === '<' || c === '>') {
+      tokens.push({ type: 'op', value: c });
+      i++;
+      continue;
+    }
+    // 关键字 / 标识符
+    if (/[A-Za-z_]/.test(c)) {
+      let j = i;
+      while (j < n && /[A-Za-z0-9_]/.test(str[j])) j++;
+      const word = str.slice(i, j).toUpperCase();
+      i = j;
+      if (word === 'AND' || word === 'OR' || word === 'XOR' || word === 'NOT'
+        || word === 'BETWEEN' || word === 'IN' || word === 'LIKE' || word === 'IS'
+        || word === 'NULL' || word === 'TRUE' || word === 'FALSE') {
+        tokens.push({ type: 'kw', value: word });
+        continue;
+      }
+      return null; // 出现列名等标识符 → 非纯常量表达式，跳过
+    }
+    return null; // 未知字符（含 -- 注释、LIMIT 等尾随关键字）
+  }
+  return tokens;
+}
+
+function _likeMatch(value, pattern) {
+  // 将 SQL LIKE 模式（% 任意序列、_ 单字符、\ 转义）转为正则做常量求值
+  let re = '^';
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === '%') re += '.*';
+    else if (ch === '_') re += '.';
+    else if (ch === '\\' && i + 1 < pattern.length) {
+      re += pattern[i + 1].replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      i++;
+    } else {
+      re += ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+  }
+  re += '$';
+  try {
+    return new RegExp(re).test(value);
+  } catch {
+    return false;
+  }
+}
+
+function _constParse(tokens) {
+  let pos = 0;
+  const peek = () => tokens[pos];
+  const next = () => tokens[pos++];
+  const expect = (type, val) => {
+    const t = next();
+    if (!t || t.type !== type || (val !== undefined && t.value !== val)) {
+      throw new Error('unexpected token');
+    }
+    return t;
+  };
+
+  function parseOr() {
+    let left = parseAnd();
+    while (peek() && peek().type === 'kw' && (peek().value === 'OR' || peek().value === 'XOR')) {
+      const op = next().value;
+      const right = parseAnd();
+      left = op === 'XOR' ? Boolean(left) !== Boolean(right) : (left || right);
+    }
+    return left;
+  }
+
+  function parseAnd() {
+    let left = parseNot();
+    while (peek() && peek().type === 'kw' && peek().value === 'AND') {
+      next();
+      const right = parseNot();
+      left = left && right;
+    }
+    return left;
+  }
+
+  function parseNot() {
+    if (peek() && peek().type === 'kw' && peek().value === 'NOT') {
+      next();
+      return !parseNot();
+    }
+    // 括号表达式：OR (1=1) / AND (1=1 OR 2=2)
+    if (peek() && peek().type === 'paren' && peek().value === '(') {
+      next();
+      const v = parseOr();
+      expect('paren', ')');
+      return v;
+    }
+    return parseComparison();
+  }
+
+  function parseValue() {
+    const t = next();
+    if (!t) throw new Error('eof');
+    if (t.type === 'number' || t.type === 'string') return t.value;
+    if (t.type === 'kw') {
+      if (t.value === 'TRUE') return true;
+      if (t.value === 'FALSE') return false;
+      if (t.value === 'NULL') return null;
+    }
+    throw new Error('not a constant');
+  }
+
+  function parseComparison() {
+    const left = parseValue();
+
+    // BETWEEN low AND high
+    if (peek() && peek().type === 'kw' && peek().value === 'BETWEEN') {
+      next();
+      const low = parseValue();
+      expect('kw', 'AND');
+      const high = parseValue();
+      return left !== null && left >= low && left <= high;
+    }
+    // IN (v1, v2, ...)
+    if (peek() && peek().type === 'kw' && peek().value === 'IN') {
+      next();
+      expect('paren', '(');
+      const vals = [parseValue()];
+      while (peek() && peek().type === 'comma') {
+        next();
+        vals.push(parseValue());
+      }
+      expect('paren', ')');
+      return left !== null && vals.some(v => v === left);
+    }
+    // LIKE pattern
+    if (peek() && peek().type === 'kw' && peek().value === 'LIKE') {
+      next();
+      const pattern = parseValue();
+      if (left === null || typeof left !== 'string' || typeof pattern !== 'string') return false;
+      return _likeMatch(left, pattern);
+    }
+    // IS [NOT] NULL
+    if (peek() && peek().type === 'kw' && peek().value === 'IS') {
+      next();
+      let negate = false;
+      if (peek() && peek().type === 'kw' && peek().value === 'NOT') {
+        next();
+        negate = true;
+      }
+      expect('kw', 'NULL');
+      const isNull = left === null;
+      return negate ? !isNull : isNull;
+    }
+    // 比较
+    if (peek() && peek().type === 'op') {
+      const op = next().value;
+      const right = parseValue();
+      // eslint-disable-next-line eqeqeq -- 与 SQL 语义对齐（'1' == 1 → true）
+      if (op === '=') return left == right;
+      // eslint-disable-next-line eqeqeq
+      if (op === '<>' || op === '!=') return left != right;
+      if (op === '<') return left < right;
+      if (op === '>') return left > right;
+      if (op === '<=') return left <= right;
+      if (op === '>=') return left >= right;
+    }
+    // 无比较运算符 → 裸布尔值
+    return Boolean(left);
+  }
+
+  return parseOr();
+}
 // 治理立项④（docs/internal/audit/2026-09-26-eslint-security-triage.md 第四节）：检测器输入独立长度上限。
 // 上游 executor 全局 SQL 上限为 1MB（2026-08-15 生产审计 M-01）；本检测器逐模式扫描为
 // CPU 密集路径，超长输入不再逐模式扫描，直接按 HIGH 级别判为可疑（fail-closed：
@@ -269,6 +488,7 @@ export class SQLInjectionDetector {
       this._detectFileSystemAccess,
       this._detectSystemCommand,
       this._detectAlwaysTrueCondition,
+      this._detectConstTautology,
     ];
   }
 
@@ -618,6 +838,74 @@ export class SQLInjectionDetector {
     }
     return null;
   }
+
+  // ── 检测器 11: 常量恒真/恒假表达式（2026-10-31 渗透测试 H-01 修复）──
+  // 捕获 `OR 1 BETWEEN 1 AND 1`、`OR 'a' LIKE 'a'`、`OR 1 IN (1)`、`OR (1=1)`、
+  // `OR NOT 1=2`、`OR 1 IS NOT NULL` 等纯常量恒真变体（原 TAUTOLOGY_RE 未覆盖）。
+  _detectConstTautology(sql, _upperSql, rawSql, _rawUpper) {
+    const findings = [];
+    const push = (type, severity, confidence, evidence, description) => {
+      findings.push(new InjectionFinding({ type, severity, confidence, evidence, description }));
+    };
+
+    const run = (text, inStripped) => {
+      // 剥离 SQL 注释，避免 -- / # / /* */ 截断检测
+      const cleaned = text
+        .replace(/--[^\n]*/g, ' ')
+        .replace(/#[^\n]*/g, ' ')
+        .replace(/\/\*[\s\S]*?\*\//g, ' ');
+      const connectorRe = /(?:^|[\s('])(OR|AND|XOR)\s+/gi;
+      const matches = cleaned.matchAll(connectorRe);
+      for (const m of matches) {
+        const op = m[1].toUpperCase();
+        // BETWEEN 子句内部的 AND 不是逻辑连接词，跳过以避免误报（如 `b BETWEEN 1 AND 2`）
+        if (op === 'AND' && /BETWEEN\s+[^;()]*\s*$/i.test(cleaned.slice(0, m.index))) {
+          continue;
+        }
+        const rest = cleaned.slice(m.index + m[0].length);
+        let truth;
+        try {
+          const tokens = _constTokenize(rest);
+          if (!tokens || tokens.length === 0) continue;
+          truth = _constParse(tokens);
+        } catch {
+          continue;
+        }
+        if (typeof truth !== 'boolean') continue;
+        const evidence = (m[0].trim() + ' ' + rest.trim()).slice(0, 120);
+        if ((op === 'OR' || op === 'XOR') && truth === true) {
+          push(
+            'boolean-blind',
+            inStripped ? SEVERITY.CRITICAL : SEVERITY.HIGH,
+            inStripped ? 0.9 : 0.8,
+            evidence,
+            `Boolean-based blind injection: ${op} 常量恒真表达式（${evidence}）`,
+          );
+        } else if (op === 'AND' && truth === true) {
+          push(
+            'boolean-blind',
+            SEVERITY.HIGH,
+            0.8,
+            evidence,
+            `Boolean-based blind injection: AND 常量恒真表达式（${evidence}）`,
+          );
+        } else if (op === 'AND' && truth === false) {
+          push(
+            'boolean-blind',
+            SEVERITY.MEDIUM,
+            0.6,
+            evidence,
+            `Boolean-based blind injection: AND 常量恒假探测（${evidence}）`,
+          );
+        }
+      }
+    };
+
+    run(sql, true);
+    run(rawSql, false);
+
+    return findings.length > 0 ? findings : null;
+  }
 }
 
 // ── 全局实例（便捷使用）──

package/src/security/ssrf-guard.js

@@ -319,6 +319,8 @@ export class SSRFGuard {
     this.maxRedirects = opts.maxRedirects ?? DEFAULT_MAX_REDIRECTS;
     this.requestTimeoutMs = opts.requestTimeoutMs ?? 10000;
     this.followRedirects = opts.followRedirects !== false;
+    // 2026-10-31 M-04：validateDeep 的 DNS 解析超时（毫秒）
+    this.dnsTimeoutMs = opts.dnsTimeoutMs ?? 3000;
 
     // 统计计数器
     this._stats = { allowed: 0, blocked: 0, redirected: 0 };
@@ -584,6 +586,82 @@ export class SSRFGuard {
 
   // ── 安全 fetch（含 DNS 校验 + 重定向跟踪）──
 
+  /**
+   * 深度 URL 校验 = 静态校验 + DNS 解析校验（2026-10-31 渗透测试 M-04 修复）
+   *
+   * 生产出站 HTTP 此前只用静态 validate()（不解析 DNS、不处理重定向），
+   * 攻击者控制域名解析到内网/云元数据（169.254.169.254）即可绕过。
+   * validateDeep 在静态校验基础上异步解析 DNS 并复验解析 IP，
+   * 调用方应在实际发出请求前 await 本方法。
+   *
+   * @param {string} urlStr - 待校验 URL
+   * @returns {Promise<{allowed: boolean, reason?: string, host?: string, ips?: string[]}>}
+   */
+  async validateDeep(urlStr) {
+    const check = this.validate(urlStr);
+    if (!check.allowed) {
+      return check;
+    }
+    let dns;
+    try {
+      // 加 3s 超时，避免 DNS 解析缓慢拖住生产出站请求
+      dns = await Promise.race([
+        this.validateDNS(check.host),
+        new Promise(resolve => setTimeout(() => resolve({ allowed: true, timeout: true }), this.dnsTimeoutMs || 3000)),
+      ]);
+    } catch {
+      dns = { allowed: true, resolutionFailed: true };
+    }
+    if (!dns.allowed) {
+      // DNS 解析失败（ENOTFOUND/EAI_AGAIN 等）：实际请求同样无法解析目标主机，
+      // 无 SSRF 风险，放行交由下层连接报错（同时兼容测试中不可解析的 mock 主机名）。
+      if (dns.reason && dns.reason.includes('DNS 解析失败')) {
+        return { allowed: true, host: check.host, resolutionFailed: true };
+      }
+      return {
+        allowed: false,
+        reason: dns.reason,
+        host: check.host,
+      };
+    }
+    return { allowed: true, host: check.host, ips: dns.ips };
+  }
+
+  /**
+   * 解析并返回可直连的钉扎目标（2026-10-31 渗透测试 R6 修复）
+   *
+   * 供基于 node:http/node:https 的传输层（非 fetch 路径）使用：
+   * 返回已通过校验的解析 IP 与原始 Host 头（含端口），调用方应把
+   * `hostname` 设为 `ip`，并在请求头保留 `Host: hostHeader`（https 还需
+   * `servername: 原始主机名` 以维持 SNI）。这消除「DNS 校验与实际请求之间
+   * DNS 再次变化」的 rebinding TOCTOU 窗口。
+   *
+   * @param {string} urlStr - 目标 URL
+   * @returns {Promise<{ip: string, hostHeader: string, hostname: string, port: number}>}
+   * @throws {Error} 校验失败/无可用 IP 时抛错（code='SSRF_BLOCKED'）
+   */
+  async resolvePinnedHost(urlStr) {
+    const check = this.validate(urlStr);
+    if (!check.allowed) {
+      const err = new Error(`SSRF blocked: ${check.reason}`);
+      err.code = 'SSRF_BLOCKED';
+      throw err;
+    }
+    const dns = await this.validateDNS(check.host);
+    if (!dns.allowed || !dns.ips || dns.ips.length === 0) {
+      const err = new Error(`SSRF pinned DNS blocked: ${dns.reason || '无可解析 IP'}`);
+      err.code = 'SSRF_BLOCKED';
+      throw err;
+    }
+    const url = new URL(urlStr);
+    return {
+      ip: dns.ips[0],
+      hostHeader: url.host,
+      hostname: url.hostname,
+      port: url.port ? Number.parseInt(url.port, 10) : (url.protocol === 'https:' ? 443 : 80),
+    };
+  }
+
   /**
    * 包裹 fetch 的安全请求方法
    *

package/src/sync/sync-engine.js

@@ -356,11 +356,11 @@ export class SyncEngine {
    * @returns {Promise<Object|null>}
    */
   async _httpRequest(method, path, body = null) {
-    // v1.34.5: SSRF 防护校验服务端 URL（Node.js 环境下生效）
+    // v1.34.5: SSRF 防护校验服务端 URL（2026-10-31 M-04：升级为静态+DNS 深度校验）
     const fullUrl = `${this.serverUrl}${path}`;
     const guard = await this._getSSRFGuard();
     if (guard) {
-      const check = guard.validate(fullUrl);
+      const check = await guard.validateDeep(fullUrl);
       if (!check.allowed) {
         if (this._onError) {
           try {
@@ -381,7 +381,11 @@ export class SyncEngine {
         options.body = JSON.stringify(body);
       }
 
-      const response = await fetch(fullUrl, options);
+      // 2026-10-31 M-04：浏览器路径若已配置 SSRF guard，改用 safeFetch 以在
+      // 重定向逐跳时重新校验（防止 302 跳到内网/云元数据）。
+      const response = guard
+        ? await guard.safeFetch(fullUrl, options)
+        : await fetch(fullUrl, options);
       if (!response.ok) {
         return null;
       }

package/src/vector/distributed-vector-search.js

@@ -28,7 +28,7 @@
  *   - 接口: POST /search { vector, k, options } → { results: [{rowId, distance}] }
  */
 
-
+
 
 // ═══════════════════════════════════════════
 // 分片策略
@@ -260,11 +260,11 @@ class RemoteVectorShard {
       throw new Error(`远程分片 ${this.shardId} 无可用 fetch 函数`);
     }
 
-    // v1.34.5: SSRF 防护校验远程分片 endpoint
+    // v1.34.5: SSRF 防护校验远程分片 endpoint（2026-10-31 M-04：升级为静态+DNS 深度校验）
     const requestUrl = `${this.endpoint}/search`;
     const guard = await this._getSSRFGuard();
     if (guard) {
-      const check = guard.validate(requestUrl);
+      const check = await guard.validateDeep(requestUrl);
       if (!check.allowed) {
         throw new Error(`SSRF 阻止远程分片 ${this.shardId} 请求: ${check.reason}`);
       }

package/src/version.js

@@ -14,6 +14,6 @@
  * 并校验所有 JS 文件不再硬编码版本号。
  */
 
-export const VERSION = '2.53.0';
+export const VERSION = '2.53.1';
 
 export const PHASE = 'v2.53.0 性能服务化（P0-5/P0-6 请求级查询取消与超时）：执行器新增 options 级取消检查 _abortCheck（直接读 options.signal，避免共享 Executor 并发异步查询互相覆盖实例级取消状态），接线到全部分片让出检查点（分片过滤/分片 GROUP BY/_finishSelectAfterRows 阶段边界/JOIN 派发前/parallelHashJoinWithWorker 键计算让出点）；executeSQLAsync 与 parallelHashJoinWithWorker 对取消错误（QUERY_ABORTED）上抛而非静默回退同步；routeSQL(sql, params, res) 为每个请求创建 AbortController——客户端断开（res 提前 close）即中止 + this._timeout 超时中止，取消在让出检查点真实生效（P0-6）；query handler 主查询与 SELECT 端点传递 res；新增 query-cancel.test.js 6 项（预中止/JOIN 路径/运行中/routeSQL 断开/超时/正常回归）已注册 run-all；' + 'v2.52.0 性能服务化（P0-1 Worker 并行 JOIN + P0-3 HTTP WorkerPool）：JoinEngine.parallelHashJoinWithWorker 把 Hash Join 探测（JOIN_PROBE）真实分发到 Worker 线程（主线程预计算键 + 浅拷贝行附加 __joinKey + execAll 分发 + 合并 + LEFT 补行 + 失败回退同步 _parallelHashJoin）；Executor._performJoinAsync 委托 JoinExecutor 供异步路径使用；execSelectShardedAsync 支持单普通表等值 INNER/LEFT JOIN 的 Worker 并行（_canShardAsyncSelect 扩展 + WHERE 不得引用右表列的安全限制）；DBServer 启动时初始化 WorkerPool（lazy，默认 CPU-1，可 enableWorkerPool=false 关闭）并在 stop 时终止，使 HTTP 服务中 JOIN/SORT/FILTER/GROUP_BY 并行算子真实可用；新增 worker-join.test.js 5 项（INNER/LEFT/无池回退/右表列回退/任务分发断言）已注册 run-all；' + 'v2.51.0 缺陷修复（物化视图注册为可查询关系 + WAL 大批次分块）：物化视图作为只读关系注册到 Database（materializedViews 注册表 + hasTable/getTable 识别 + 只读表外观 + 命名冲突双向拒绝 + INFORMATION_SCHEMA.TABLES/COLUMNS 与 pg_class 可见 + CLI/.tables 与 HTTP 表列表纳入 + 持久化重建后重新注册 + SELECT/JOIN/EXPLAIN/跨库可解析），修复 CREATE MATERIALIZED VIEW 通过 SQL 调用时校验错误变为未处理 Promise 拒绝的问题（createMaterializedView 同步抛出 + execCreateMaterializedView 透传异步刷新）；事务 WAL 按 maxEntriesPerBatch 分块，消除同步突发写入 >65535 条时 serializeBatch 的 RangeError 崩溃路径（守卫保留供防御测试）；物化视图测试 +4 项（注册/冲突/只读/持久化），wal-count-bound 7/7 全绿；' + 'v2.50.0 T-05/T-06 架构清理：优化器 barrel 补齐 5 个生产可达类导出（ExplainVisualizer/JoinOrderOptimizer/QueryPlanCache/Histogram·HistogramBucket/TimestampQueryRewriter，经 engine/public-api.js 接主入口）+ StorageEngine 统一存储引擎接口（STORAGE_ENGINE_METHODS 契约 + isStorageEngine/assertStorageEngine 校验 + STORAGE_BACKENDS 四后端工厂 memory/file/binary/buffered + StorageEngine.switchBackend 运行时切换 + createStorageEngine）+ T-06 lockfree-worker.js 占位桩整体移除（lockfree-manager 移除 _startWorkers/useWorkers，单线程 COW 模式收敛）；storage-engine.test 16 项（含绕过）+ optimizer-exports.test 4 项（含主入口接线）已注册 run-all，全量 806/806 全绿、幻影审计 A 类 0/B 类 0、dist 22/22 含新符号；' + 'v2.49.0 E34 数据血缘收尾（UPDATE 源追踪 + CREATE VIEW 事前环拒绝 + Mermaid 导出）：extractUpdateColumnLineage（UPDATE SET 列级血缘，直接列/表达式/函数，常量不产生依赖，多表 UPDATE...FROM 无前缀 unresolved）+ recordStatement UpdateStatement 分支；wouldCreateCycle + DDLExecutor._assertNoLineageCycle（CREATE VIEW/CREATE MATERIALIZED VIEW 事前环拒绝，仅目标视图已存在时预检，保留 v2.11 E15 M2 T3 前向引用后补行为）；toMermaid/getLineageMermaid（Mermaid flowchart 导出）；生产入口导出 + lineage-e34 19 项 + 生产接线 4 项，run-all 804/804 全绿；' + 'v2.48.0 数据血缘全链路落地（P7 M1-M4 + P8 深化 + P9 版本历史）：表级/列级血缘自动记录（CREATE VIEW/MATERIALIZED VIEW/INSERT...SELECT）、LINEAGE SQL 语句（LINEAGE TABLE/COLUMN + lineage-executor + MCP 工具）、任务级登记（CopyStream/Migrator）、持久化（meta v5 随 PersistedDatabase 落盘）、环检测 detectCycles、CTE 列级推导（collectCtes）、HTML 可视化 toHTML、版本历史（getLineageHistory/getLineageAtTime/getLineageEvolution）、变更影响分析（analyzeImpact），生产入口全导出 + 常驻测试 70 项；run-all 全量通过 + vitest 123/123 + c8 Lines 91.99%/Branches 88.43%；' + 'v2.45.2 双缺陷修复（多轮门禁盘点发现）：① REGEXP (?g)/(?y) 全局/粘性标志剥离——编译产物跨行 LRU 缓存复用而 g/y 的 lastIndex 状态使求值行依赖（(?g)a 四行 [1,0,1,0]），REGEXP 逐行独立求值语义下 g/y 无意义且有害，编译期剥离（i/m/s/u 保持）；② WASM min/max 对齐区 NaN 传播——f32x4.min/max 按 IEEE 语义传播 NaN 与"NaN 被忽略"文档语义相悖（v2.45.1 激活 SIMD 路径后成为实际行为），NaN 结果 ⟺ 对齐区有 NaN lane，JS 重扫跳过 NaN 与降级路径对齐；绕过测试 v2450 +2（29 项）、wasm-simd-engine E3 守卫（23 项）；' + 'v2.45.1 WASM SIMD 常量错位修复 + 覆盖率债务清零：f32x4_max 误写 0xEA（实为 f32x4.pmin）致 init 运行时验证恒败、引擎自引入即静默降级（SIMD 路径从未激活，全部流量走 TypedArray fallback）——修正 0xE9 并经验解码验证（0xE7=div/0xE8=min/0xE9=max/0xEA=pmin/0xEB=pmax），修复后 READY/WASM_SIMD 五算子精确正确；wasm-simd-engine 移出 c8 exclude 并补全路径测试（初始化/SIMD 数值/降级/扩容/单例 + 修复守卫）；lockfree-worker.js 人工评估归档（确认占位桩：主路径不经 Worker，保持 exclude 豁免）；' + 'v2.45.0 安满分诊 P1/P2 治理落地（eslint-security 58 errors 分诊第四节立项 ①②③④ 全部修复）：REGEXP 用户正则防护（security/regex-guard.js compileUserRegex：模式长度上限 1024 + 嵌套量词灾难回溯编译期筛查，bitmap-filter _getRegex 接线）+ LIKE/GLOB/KEYS→regex 转换入口统一模式长度上限 1024（bitmap-filter _likeToRegex/_buildEscapeRegex、btree/offheap 部分索引 LikeExpr、cache-adapter KEYS、sqlite-kv-adapter LIKE、expression.js GLOB 共 7 处）+ oracle-adapter DECODE 线性解析重写（消除指数回溯，修复多分支 CASE 语义 + 括号/引号感知 + 嵌套 DECODE 递归转换）+ 输入长度上限（sql-injection-detector 256KB fail-closed、schema-versioning DDL 256KB + 顶层逗号线性切分）；绕过测试 v2450-p0-bypass-boundary 通过；v2.0 长期路线图收官：v2.0-1..6 全部落地（JSONB 二进制 JSON / Lambda 表达式 x->x+1 / UNNEST 多列并行 / DEFERRABLE 约束 / EXCLUDE 排他约束 / LISTEN-NOTIFY 异步通知，DoD 5/5 各 27-39 用例）；v2.0-7 WAL flush 慢 seq 初始化 flaky 修复 + wal-crash-validation 测试加固（10/10 稳定 + 绕过测试有效性验证）+ flush-timeout-simulation FT2/FT4 libuv 时钟边界修复；全量回归 run-all 459/459 全绿（历史首次）；v2.0-8 SQL:2016 阶段1 聚合补全（PERCENTILE_CONT/DISC + STRING_AGG/ARRAY_AGG + MODE + BOOL_AND/OR/EVERY + WIDTH_BUCKET + REGR_*，DoD 5/5 37/37）；v2.0-9 SQL:2016 阶段2 MATCH_RECOGNIZE 行模式识别（Part 2 §21.6 新执行器，DoD 5/5 30/30）；v2.0-10 SQL:2016 阶段3 多态表函数 PTF（Part 2 §10.9：ANY TABLE/COLUMN/MAX(n) + RETURNS TABLE + 函数体 AST 重写 + 物化临时表 + JOIN 内调用 + 幂等性/零副作用，DoD 5/5 25/25，run-all 461/462 + audit-log A8 时间竞态 flaky 修复）；v2.0-11 SQL:2016 阶段4 RATIO_TO_REPORT 分析函数（Part 2 §9.6 G9：分区求和比例 + NULL/除零语义 + 参数校验，DoD 5/5 14/14）+ 窗口函数源表零副作用 P0 修复（window-functions.js 浅拷贝行，156 项窗口回归全绿）；v2.0-12 SQL:2016 阶段5 类型系统深化（Part 2 §4.4 G11 INTERVAL 完整类型：YEAR/MONTH/DAY/HOUR/MINUTE/SECOND 字段子句 + 单位内嵌 + 纯时间/天数自动判断 + DAY TO MINUTE HH:MM + DAY TO HOUR/MINUTE/SECOND 时间部分列宽 + date/timestamp±interval 日历月 clamp + 算术/比较/CAST/一元运算；G12 TIMESTAMP WITH TIME ZONE：带偏移解析→UTC 内部存储 + 会话时区显示 + SET TIME ZONE/SHOW TIME ZONE + INSERT/UPDATE 归一化 + 混合比较，DoD 5/5 62/62）；v1.42.x 基础：STRUCT 类型 / LIST-ARRAY 完整操作 / WITHOUT ROWID 表 / VACUUM-REINDEX / user_version-application_id 持久化 + v1.42.1 全量回归闭环（16 个预存失败清零 + 2 个源码回归修复：query-isolation 原型链 / select-executor ORDER BY 聚合别名）；v1.41.x 基础：ASOF JOIN / ATTACH DATABASE / COMMENT ON / PIVOT 多聚合 / WITH CHECK OPTION；v1.40.4 基础：PRAGMA 完整集（25+ SQLite 标准）+ 版本号多 SDK 单一来源同步；v1.40.3 基础：3 个 P0 安全修复真实现 + SECURITY DEFINER 真实现 + 循环依赖 0；v2.11（E15）遗留清零：WAL 恢复数据版本一致性 + 视图 lossy 根治 + 多视图 CASCADED 链 + SECURITY DEFINER 真实现 + RedisCacheAdapter 真实现 + Arrow 有限宽度 guard + WAL count 上界 + executor 拆分（sql-reconstructor）；v2.12（E16）稳定性与分布式闭环：flaky 三件套根治（2pc-perf/index-build/soak-test + vector-executor 门槛统一）+ 跨库 DDL/事务 + WAL hot-standby 探针 + 分布式真实网络验证（raft/3PC/2PC + PK fastpath WAL 缺陷修复 + 2PC rejection 修复）+ executor PRAGMA 族拆离（pragma-executor，-550 行）+ 全量回归 612/612 + DL-D3 时序 flaky 修复；v2.13（E17）收尾治理与 SQL/XML：版本号全量对齐 + SQL:2016 阶段6 G10（XMLSERIALIZE/XMLAGG/XMLTABLE）+ 全量 c8 复验 + 跨库 TPC-H 数据刷新 + SQL:2023 roadmap 收敛；v2.14（E18）列存文件格式 M1+M2：PJDC 二进制列文件格式（表签名三层校验：schemaHash + rowCount + columnCount）+ save/load 持久化加速缓存 + 列存 roundtrip 持久化验证（22+8 用例全绿）；v2.15（E19）列存文件格式 M3：WAL _invalidateTableIndexes 修复（checkpoint 后索引失效重建）+ run-all 618/618 全绿；v2.15（E20）工程化基线清零：parquet.js 3 处 setUint32 guard 补零 + 超限绕过测试 + 版本号同步 2.13.0→2.15.0 + c8 覆盖率实测 + 审计章节归档；';