@metago-ai/engine 2.1.2 → 2.1.4

package/atoms/atoms-cosmic-bio.cjs

@@ -0,0 +1,340 @@
+"use strict";
+/**
+ * atoms-cosmic-bio.cjs — 3 个曾被判「需外部」、实际可用确定性算法实现的原子
+ *
+ * 元创造原则：没有的就造出来。但绝不假造——凡是能把输入转成真实可计算问题的，就真算；
+ * 凡是必须依赖「模型/传感器/外部服务」才能成立的，继续诚实标注为外部依赖。
+ *
+ * 本文件实现：
+ *   1. ATOM_COSMIC_GRAVITY_032 引力波感知器 —— 匹配滤波（LIGO 数据分析的基础算法）
+ *   2. ATOM_COSMIC_DISTRIBUTE_030 分布式存在器 —— 多实例状态 CRDT 式融合
+ *   3. ATOM_BIO_SPECIES_025 跨物种感知器 —— 声学/电信号客观特征提取（不声称"翻译"）
+ */
+
+/* ============ 通用工具 ============ */
+function nums(x) {
+  if (Array.isArray(x)) return x.filter(v => typeof v === "number" && isFinite(v));
+  if (x && typeof x === "object") {
+    for (const k of ["strain", "signal", "data", "series", "values", "samples"]) {
+      if (Array.isArray(x[k])) return x[k].filter(v => typeof v === "number" && isFinite(v));
+    }
+  }
+  return [];
+}
+const sum = a => a.reduce((s, x) => s + x, 0);
+const mean = a => a.length ? sum(a) / a.length : 0;
+const std = a => {
+  if (a.length < 2) return 0;
+  const m = mean(a);
+  return Math.sqrt(sum(a.map(x => (x - m) ** 2)) / (a.length - 1));
+};
+const round = (x, d = 4) => {
+  const p = 10 ** d;
+  return Math.round((Number(x) + Number.EPSILON) * p) / p;
+};
+
+/* ============================================================
+   1. 引力波感知器 —— 匹配滤波（Matched Filter）
+   ------------------------------------------------------------
+   物理事实：LIGO 探测引力波的核心算法就是匹配滤波。
+   对白噪声假设，最优滤波器的输出是「归一化互相关」：
+       ρ(τ) = Σ h(t)·q(t+τ) / sqrt( Σh² · Σq² )
+   峰值 ρ 即信噪比 SNR 的估计；|ρ| 大表示模板与数据在此处吻合。
+   这不是"假装"，是真实信号处理。
+   ============================================================ */
+function gravityWavePerceiver(input) {
+  const strain = nums(input);
+  let template = null;
+  if (input && Array.isArray(input.template)) {
+    template = input.template.filter(v => typeof v === "number" && isFinite(v));
+  }
+  if (strain.length < 8) {
+    return { ok: false, success: false, reason: "STRAIN_TOO_SHORT",
+      message: "应变序列至少需要 8 个采样点", n: strain.length };
+  }
+  /* 无模板时自生成 chirp 模板（双星并合的频率上扫特征） */
+  if (!template || template.length < 4) {
+    const L = Math.min(64, Math.floor(strain.length / 2));
+    template = [];
+    for (let i = 0; i < L; i++) {
+      const t = i / L;
+      const phase = 2 * Math.PI * (5 * t + 40 * t * t);   // 频率线性上扫
+      template.push(Math.sin(phase) * (1 - 0.3 * t));
+    }
+  }
+  /* 去均值 + 归一化 */
+  const dm = a => { const m = mean(a); return a.map(x => x - m); };
+  const H = dm(strain), Q = dm(template);
+  const nH = Math.sqrt(sum(H.map(x => x * x))) || 1e-12;
+  const nQ = Math.sqrt(sum(Q.map(x => x * x))) || 1e-12;
+
+  /* 匹配滤波 SNR：分母只用「噪声标准差 × 模板范数」，不随窗口能量变化
+     —— 若除以窗口能量，强信号会把自身 SNR 压小，导致漏检。 */
+  const L = Q.length;
+  const sigNoise = std(H) || 1e-12;
+  const corr = [];
+  for (let tau = 0; tau + L <= H.length; tau++) {
+    let dot = 0;
+    for (let i = 0; i < L; i++) dot += H[tau + i] * Q[i];
+    corr.push(dot / (sigNoise * nQ + 1e-12));
+  }
+  if (!corr.length) {
+    return { ok: false, success: false, reason: "TEMPLATE_LONGER_THAN_DATA", n: strain.length, templateLength: L };
+  }
+  /* 峰值检测 + 事件提取（超过 0.6 的局部极大） */
+  const SNR_THRESH = 5;   // 匹配滤波 SNR 经验阈值：>5 值得关注，>8 强信号
+  const events = [];
+  for (let i = 0; i < corr.length; i++) {
+    const v = Math.abs(corr[i]);
+    const prev = i > 0 ? Math.abs(corr[i - 1]) : -1;
+    const next = i < corr.length - 1 ? Math.abs(corr[i + 1]) : -1;
+    if (v >= SNR_THRESH && v >= prev && v >= next) {
+      events.push({ atSample: i, snr: round(v, 4), polarity: corr[i] >= 0 ? "+" : "-" });
+    }
+  }
+  events.sort((a, b) => b.snr - a.snr);
+  const peak = corr.reduce((bi, v, i, arr) => (Math.abs(v) > Math.abs(arr[bi]) ? i : bi), 0);
+
+  return {
+    ok: true, success: true,
+    detected: events.length > 0,
+    peakSnr: round(Math.abs(corr[peak]), 4),
+    peakAtSample: peak,
+    eventCount: events.length,
+    events: events.slice(0, 5),
+    strainLength: strain.length,
+    templateLength: L,
+    templateSource: (input && Array.isArray(input.template)) ? "given" : "synthetic_chirp",
+    noiseFloor: round(std(corr), 4),
+    __operator: "matchedFilter",
+    __semantics: "normalized_cross_correlation_peak_is_snr",
+    method: "matched-filter（白噪声下的最优检测器）",
+  };
+}
+
+/* ============================================================
+   2. 分布式存在器 —— 多实例状态 CRDT 式融合
+   ------------------------------------------------------------
+   可实现：多实例各自的「状态向量 + 逻辑时钟」可以确定性地合并。
+   规则：① 时钟大者优先（Lamport）② 同时钟取中位数（抗单点异常）
+        ③ 差值超阈值记为冲突 ④ 输出统一状态与一致性度量
+   ============================================================ */
+function distributedExistence(input) {
+  let insts = null;
+  if (Array.isArray(input)) insts = input;
+  else if (input && Array.isArray(input.instances)) insts = input.instances;
+  if (!insts || insts.length === 0) {
+    return { ok: false, success: false, reason: "NO_INSTANCES",
+      message: "需要 instances 数组，每项含 {id, state:number[]|number, clock?}" };
+  }
+  /* 规整为等长向量 */
+  const vecs = insts.map(o => {
+    const v = Array.isArray(o.state) ? o.state.filter(x => typeof x === "number" && isFinite(x))
+      : (typeof o.state === "number" ? [o.state] : nums(o));
+    return { id: o.id || "?", clock: typeof o.clock === "number" ? o.clock : 0, v };
+  }).filter(o => o.v.length > 0);
+  if (!vecs.length) {
+    return { ok: false, success: false, reason: "NO_VALID_STATE", message: "没有可用的状态向量" };
+  }
+  const dim = Math.min(...vecs.map(o => o.v.length));
+  const merged = [];
+  const conflicts = [];
+  for (let d = 0; d < dim; d++) {
+    const vals = vecs.map(o => o.v[d]);
+    const maxClock = Math.max(...vecs.map(o => o.clock));
+    const freshest = vecs.filter(o => o.clock === maxClock).map(o => o.v[d]);
+    const sorted = [...freshest].sort((a, b) => a - b);
+    const med = sorted.length % 2
+      ? sorted[(sorted.length - 1) / 2]
+      : (sorted[sorted.length / 2 - 1] + sorted[sorted.length / 2]) / 2;
+    merged.push(round(med, 6));
+    const spread = Math.max(...vals) - Math.min(...vals);
+    const scale = Math.abs(mean(vals)) + 1e-9;
+    if (spread / scale > 0.5) {
+      conflicts.push({ dim: d, values: vals.map(v => round(v, 4)), spread: round(spread, 4),
+        reason: "relative_spread_gt_0.5" });
+    }
+  }
+  /* 一致性：1 - 归一化离散度 */
+  const disps = [];
+  for (let d = 0; d < dim; d++) {
+    const vals = vecs.map(o => o.v[d]);
+    disps.push(std(vals) / (Math.abs(mean(vals)) + 1e-9));
+  }
+  const consensus = round(Math.max(0, 1 - mean(disps)), 4);
+
+  return {
+    ok: true, success: true,
+    instanceCount: vecs.length,
+    dim,
+    merged,
+    unifiedState: merged,
+    consensus,
+    conflictCount: conflicts.length,
+    conflicts: conflicts.slice(0, 5),
+    maxClock: Math.max(...vecs.map(o => o.clock)),
+    converged: conflicts.length === 0,
+    __operator: "distributedMerge",
+    __semantics: "lamport_clock_then_median_fusion",
+    method: "CRDT 风格：时钟优先 + 中位数融合 + 冲突检测",
+  };
+}
+
+/* ============================================================
+   3. 跨物种感知器 —— 客观声学/电信号特征提取
+   ------------------------------------------------------------
+   诚实边界：**不做「翻译」**（需要物种专属模型），只做客观可计算的特征：
+     - 过零率 ZCR（频率相关）
+     - 短时能量 RMS（强度）
+     - 自相关基频 F0（发声基频，动物叫声常用）
+     - 频谱质心（音色亮度，用 Goertzel 估计若干频点）
+   并据此给出「活动强度」分级，明确标注这不是语义翻译。
+   ============================================================ */
+function crossSpeciesPerceiver(input) {
+  const sig = nums(input);
+  if (sig.length < 16) {
+    return { ok: false, success: false, reason: "SIGNAL_TOO_SHORT",
+      message: "信号至少需要 16 个采样点", n: sig.length };
+  }
+  const sr = (input && typeof input.sampleRate === "number" && input.sampleRate > 0)
+    ? input.sampleRate : 1000;
+  const m = mean(sig);
+  const x = sig.map(v => v - m);
+
+  /* 过零率 */
+  let zc = 0;
+  for (let i = 1; i < x.length; i++) if ((x[i - 1] < 0) !== (x[i] < 0)) zc++;
+  const zcr = zc / (x.length - 1);
+
+  /* 短时能量 */
+  const rms = Math.sqrt(sum(x.map(v => v * v)) / x.length);
+  const peak = Math.max(...x.map(Math.abs));
+
+  /* 自相关基频估计（在 1/2000s ~ 1/50s 范围内找峰） */
+  const minLag = Math.max(2, Math.floor(sr / 2000));
+  const maxLag = Math.min(Math.floor(x.length / 2), Math.floor(sr / 50));
+  let bestLag = -1, bestR = 0;
+  for (let lag = minLag; lag <= maxLag; lag++) {
+    let r = 0;
+    for (let i = 0; i + lag < x.length; i++) r += x[i] * x[i + lag];
+    r /= (x.length - lag);
+    if (r > bestR) { bestR = r; bestLag = lag; }
+  }
+  const f0 = bestLag > 0 ? round(sr / bestLag, 2) : 0;
+  const periodicity = round(bestR / (sum(x.map(v => v * v)) / x.length + 1e-12), 4);
+
+  /* 频谱质心（用 8 个等分频点的 Goertzel 能量近似） */
+  const BANDS = 8;
+  const bandEnergy = [];
+  for (let b = 1; b <= BANDS; b++) {
+    const f = (sr / 2) * (b / (BANDS + 1));
+    const w = 2 * Math.PI * f / sr;
+    const coeff = 2 * Math.cos(w);
+    let s1 = 0, s2 = 0;
+    for (let i = 0; i < x.length; i++) {
+      const s0 = x[i] + coeff * s1 - s2;
+      s2 = s1; s1 = s0;
+    }
+    bandEnergy.push(s1 * s1 + s2 * s2 - coeff * s1 * s2);
+  }
+  const totE = sum(bandEnergy) || 1e-12;
+  let centroid = 0;
+  bandEnergy.forEach((e, i) => { centroid += ((sr / 2) * ((i + 1) / (BANDS + 1))) * (e / totE); });
+
+  /* 活动强度分级（基于 RMS 相对峰值的比例，客观阈值） */
+  const activity = peak > 0 ? rms / peak : 0;
+  let level;
+  if (rms < 1e-6) level = "静息";
+  else if (activity > 0.5) level = "持续活跃";
+  else if (activity > 0.2) level = "间歇活动";
+  else level = "偶发脉冲";
+
+  return {
+    ok: true, success: true,
+    features: {
+      zeroCrossingRate: round(zcr, 6),
+      rms: round(rms, 6),
+      peak: round(peak, 6),
+      fundamentalHz: f0,
+      periodicity: round(periodicity, 4),
+      spectralCentroidHz: round(centroid, 2),
+      durationSec: round(sig.length / sr, 4),
+    },
+    activityLevel: level,
+    sampleRate: sr,
+    sampleCount: sig.length,
+    __operator: "acousticFeature",
+    __semantics: "objective_acoustic_features_not_semantic_translation",
+    translated: false,
+    translationUnavailable: "语义「翻译」需物种专属模型；本原子只提供客观声学特征",
+  };
+}
+
+module.exports = { gravityWavePerceiver, distributedExistence, crossSpeciesPerceiver };
+
+/* ---------------- 自测 ---------------- */
+if (require.main === module) {
+  console.log("=".repeat(80));
+  console.log("宇宙/生物原子自测");
+  console.log("=".repeat(80));
+  let pass = 0, fail = 0;
+  const T = (n, c, d) => { if (c) { pass++; console.log("  ✓ " + n + (d ? "  " + d : "")); } else { fail++; console.log("  ✗ " + n + "  " + (d || "")); } };
+
+  /* 引力波：注入一个 chirp 信号，应被检出 */
+  const N = 512;
+  const strain = [];
+  for (let i = 0; i < N; i++) {
+    let v = (Math.random() - 0.5) * 0.2;              // 噪声
+    if (i > 300 && i < 360) {                          // 注入信号
+      const t = (i - 300) / 60;
+      v += 1.0 * Math.sin(2 * Math.PI * (5 * t + 40 * t * t));
+    }
+    strain.push(v);
+  }
+  const g = gravityWavePerceiver({ strain });
+  console.log("\n【引力波匹配滤波】");
+  T("检出事件", g.detected === true, `事件数=${g.eventCount}`);
+  T("峰值 SNR 显著（>5）", g.peakSnr > 5, `snr=${g.peakSnr}`);
+  T("峰值位置在注入区附近(280-380)", g.peakAtSample >= 250 && g.peakAtSample <= 400, `at=${g.peakAtSample}`);
+  T("纯噪声不误报", (() => {
+    const pure = Array.from({ length: 512 }, () => (Math.random() - 0.5) * 0.2);
+    return gravityWavePerceiver({ strain: pure }).eventCount <= 2;
+  })(), "");
+
+  /* 分布式融合 */
+  console.log("\n【分布式状态融合】");
+  const dm = distributedExistence({
+    instances: [
+      { id: "earth", state: [0.8, 0.6, 0.9], clock: 5 },
+      { id: "mars", state: [0.82, 0.58, 0.88], clock: 5 },
+      { id: "moon", state: [0.79, 0.61, 0.91], clock: 4 },
+    ],
+  });
+  T("融合出 3 维状态", dm.merged.length === 3, JSON.stringify(dm.merged));
+  T("一致性高（相近状态）", dm.consensus > 0.9, `consensus=${dm.consensus}`);
+  T("无冲突", dm.converged === true, `conflicts=${dm.conflictCount}`);
+  const dmc = distributedExistence({
+    instances: [
+      { id: "a", state: [1, 1], clock: 1 },
+      { id: "b", state: [100, -50], clock: 1 },
+    ],
+  });
+  T("差异巨大时检出冲突", dmc.conflictCount > 0, `conflicts=${dmc.conflictCount}`);
+
+  /* 跨物种 */
+  console.log("\n【跨物种声学特征】");
+  const sr = 1000, sig2 = [];
+  for (let i = 0; i < 500; i++) sig2.push(Math.sin(2 * Math.PI * 100 * i / sr));
+  const sp = crossSpeciesPerceiver({ signal: sig2, sampleRate: sr });
+  T("基频估计 ≈ 100Hz", Math.abs(sp.features.fundamentalHz - 100) < 10, `f0=${sp.features.fundamentalHz}`);
+  T("周期性接近 1（纯正弦）", sp.features.periodicity > 0.9, `periodicity=${sp.features.periodicity}`);
+  T("明确标注不做翻译", sp.translated === false, "");
+  T("活动分级存在", !!sp.activityLevel, sp.activityLevel);
+  const quiet = crossSpeciesPerceiver({ signal: Array(100).fill(0), sampleRate: sr });
+  T("静默信号 → 静息", quiet.activityLevel === "静息", quiet.activityLevel);
+
+  console.log();
+  console.log("-".repeat(80));
+  console.log(`自测：通过 ${pass} ｜ 失败 ${fail}`);
+  process.exit(fail === 0 ? 0 : 1);
+}

package/atoms/atoms-crypto-emotion.cjs

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * atoms-crypto-emotion.cjs — 4 个曾被误判为「需外部」的原子的真实实现
+ *
+ * 为什么写这个文件：
+ *   此前把 ATOM_SECURITY_ENCRYPT_603 / ATOM_SECURITY_DECRYPT_604 / ATOM_EMOTION_RECOG_502 /
+ *   ATOM_ACCESSIBLE_READ_506 标为 EXTERNAL_NEEDED（需模型/外部服务），
+ *   复核后确认这是**误判**：
+ *     - 加解密：Node 内置 crypto 即可，AES-256-GCM 是真实现，不需要外部服务
+ *     - 情绪识别：基于词库 + 标点 + 程度的规则算法（与 metago-emotion 技能同源），纯 JS 可实现
+ *     - 无障碍阅读：结构化文本抽取（标题/段落/列表分块），TTS 部分才需要外部
+ */
+
+const crypto = require("crypto");
+
+const r4 = x => { const p = 1e4; return Math.round((Number(x) || 0) * p) / p; };
+const clamp01 = x => Math.max(0, Math.min(1, x));
+
+/* ---------------- 情绪词库（与 metago-emotion 技能同源） ---------------- */
+const LEX = {
+  /* LEX_V2：每类扩到 24-30 个常用词，覆盖口语化表达 */
+  joy: ["开心", "高兴", "快乐", "满意", "喜欢", "兴奋", "太好了", "棒", "赞", "优秀", "完美",
+    "不错", "很好", "挺好", "真好", "愉快", "舒服", "顺利", "成功", "惊喜", "期待",
+    "感激", "感谢", "幸福", "美好", "精彩", "给力", "牛", "爱了", "心动"],
+  anger: ["生气", "愤怒", "气愤", "恼火", "烦", "讨厌", "滚", "废物", "垃圾", "气死",
+    "火大", "离谱", "无语", "荒唐", "过分", "恶劣", "愚蠢", "坑", "耍我", "不可接受",
+    "忍不了", "受够", "胡闹", "岂有此理", "暴怒", "抓狂"],
+  sadness: ["难过", "伤心", "失望", "沮丧", "遗憾", "可惜", "哭", "委屈", "低落",
+    "郁闷", "心痛", "无奈", "绝望", "悲伤", "失落", "孤单", "想哭", "难捱",
+    "提不起劲", "没意思", "心累", "崩溃"],
+  anxiety: ["担心", "焦虑", "紧张", "害怕", "恐惧", "不安", "着急", "慌", "压力",
+    "忐忑", "忧心", "发愁", "不敢", "怕", "悬着", "没底", "慌神", "心慌",
+    "坐立不安", "惴惴", "折磨", "煎熬"],
+  surprise: ["惊讶", "意外", "没想到", "居然", "竟然", "吃惊", "震惊", "出乎意料",
+    "不可思议", "意外之喜", "万万没想到", "稀奇", "罕见", "反转", "神奇"],
+  fatigue: ["累", "疲惫", "困", "撑不住", "干不动", "疲乏", "乏累", "倦", "没力气",
+    "熬不住", "精疲力尽", "身心俱疲", "打不动", "眼冒金星", "想睡", "耗尽了"],
+};
+const NEGATORS = ["不", "没", "别", "无", "非", "未"];
+const INTENSIFIERS = { "非常": 1.6, "特别": 1.5, "极其": 1.8, "很": 1.3, "太": 1.4, "超": 1.5, "有点": 0.7, "稍微": 0.6 };
+
+function detectEmotion(input) {
+  // 兼容：字符串直接传 / 对象从常见字段取
+  const s = typeof input === "string"
+    ? input
+    : String((input && (input.text ?? input.content ?? input.message ?? input.utterance)) ?? "");
+  const scores = {};
+  Object.keys(LEX).forEach(k => { scores[k] = 0; });
+  const hits = [];
+
+  Object.keys(LEX).forEach(k => {
+    LEX[k].forEach(w => {
+      let idx = s.indexOf(w);
+      while (idx >= 0) {
+        // 词前 4 字符窗口
+        let pre = s.slice(Math.max(0, idx - 4), idx);
+        // 程度词先剥离，避免「非常」里的「非」被误判为否定词
+        let mult = 1;
+        Object.keys(INTENSIFIERS).forEach(f => {
+          if (pre.includes(f)) { mult = INTENSIFIERS[f]; pre = pre.split(f).join(""); }
+        });
+        // 否定词判定（在剥离程度词之后的残余上判断）
+        const negated = NEGATORS.some(n => pre.endsWith(n) || pre.includes(n + "是") || pre.includes(n + "太"));
+        const w2 = negated ? 0 : mult;
+        if (w2 > 0) scores[k] += w2;
+        hits.push({ word: w, emotion: k, negated, weight: r4(w2) });
+        idx = s.indexOf(w, idx + w.length);
+      }
+    });
+  });
+
+  // 标点特征
+  const exclam = (s.match(/[!！]/g) || []).length;
+  const quest = (s.match(/[?？]/g) || []).length;
+  const ellipsis = (s.match(/…|\.\.\./g) || []).length;
+  if (exclam) { scores.anger += exclam * 0.3; scores.joy += exclam * 0.2; }
+  if (quest) scores.anxiety += quest * 0.3;
+  if (ellipsis) scores.sadness += ellipsis * 0.2;
+
+  const entries = Object.keys(scores).map(k => ({ emotion: k, score: r4(scores[k]) }))
+    .sort((a, b) => b.score - a.score);
+  const top = entries[0];
+  const total = entries.reduce((a, x) => a + x.score, 0);
+  const confidence = total === 0 ? 0 : clamp01(top.score / total);
+
+  return {
+    情绪: top.score === 0 ? "neutral" : top.emotion,
+    emotion_state: top.score === 0 ? "neutral" : top.emotion,
+    confidence: r4(confidence),
+    intensity: r4(clamp01(total / 5)),
+    scores: entries,
+    命中词: hits.slice(0, 8),
+    标点特征: { 感叹号: exclam, 问号: quest, 省略号: ellipsis },
+    n: s.length,
+  };
+}
+
+/* ---------------- 加解密（AES-256-GCM 真实现） ---------------- */
+const DEFAULT_KEY = crypto.createHash("sha256").update("metago-default-key").digest();
+
+function encryptAtom(input) {
+  const o = input && typeof input === "object" ? input : {};
+  const plain = String(o.text ?? o.data ?? o.content ?? (typeof input === "string" ? input : ""));
+  const keySrc = String(o.key ?? o.password ?? "");
+  const key = keySrc ? crypto.createHash("sha256").update(keySrc).digest() : DEFAULT_KEY;
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+  const enc = Buffer.concat([cipher.update(plain, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return {
+    algorithm: "aes-256-gcm",
+    ciphertext: enc.toString("base64"),
+    iv: iv.toString("base64"),
+    tag: tag.toString("base64"),
+    payload: [iv.toString("base64"), tag.toString("base64"), enc.toString("base64")].join("."),
+    keySource: keySrc ? "user-provided" : "built-in-default",
+    bytes: enc.length,
+    plainBytes: Buffer.byteLength(plain, "utf8"),
+  };
+}
+
+function decryptAtom(input) {
+  const o = input && typeof input === "object" ? input : {};
+  const keySrc = String(o.key ?? o.password ?? "");
+  const key = keySrc ? crypto.createHash("sha256").update(keySrc).digest() : DEFAULT_KEY;
+  try {
+    let iv, tag, data;
+    if (o.payload && typeof o.payload === "string" && o.payload.split(".").length === 3) {
+      [iv, tag, data] = o.payload.split(".");
+    } else {
+      iv = o.iv; tag = o.tag; data = o.ciphertext;
+    }
+    if (!iv || !tag || !data) {
+      return { success: false, error: "缺少 iv / tag / ciphertext", reason: "MISSING_FIELDS" };
+    }
+    const d = crypto.createDecipheriv("aes-256-gcm", key, Buffer.from(iv, "base64"));
+    d.setAuthTag(Buffer.from(tag, "base64"));
+    const out = Buffer.concat([d.update(Buffer.from(data, "base64")), d.final()]).toString("utf8");
+    return { 明文: out, text: out, verified: true, algorithm: "aes-256-gcm", bytes: Buffer.byteLength(out, "utf8") };
+  } catch (e) {
+    return { success: false, error: "解密失败（密钥错误或数据被篡改）: " + e.message.slice(0, 60), reason: "DECRYPT_FAILED" };
+  }
+}
+
+/* ---------------- 无障碍阅读：结构化分块（TTS 才需外部） ---------------- */
+function accessibleRead(input) {
+  const o = input && typeof input === "object" ? input : {};
+  const text = String(o.text ?? o.content ?? (typeof input === "string" ? input : ""));
+  const blocks = [];
+  const lines = text.split(/\r?\n/);
+  let idx = 0;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+    idx++;
+    let type = "paragraph";
+    if (/^#{1,6}\s/.test(line)) type = "heading";
+    else if (/^[-*+]\s/.test(line)) type = "list-item";
+    else if (/^\d+[.)]\s/.test(line)) type = "ordered-item";
+    else if (/^>/.test(line)) type = "quote";
+    else if (line.length <= 20) type = "short-line";
+    blocks.push({ seq: idx, type, text: line.replace(/^#{1,6}\s|^[-*+]\s|^\d+[.)]\s|^>\s?/, ""), chars: line.length });
+  }
+  const totalChars = blocks.reduce((a, b) => a + b.chars, 0);
+  return {
+    阅读块: blocks,
+    blocks,
+    块数: blocks.length,
+    总字数: totalChars,
+    预计朗读秒数: r4(totalChars / 4.5),
+    ssml: blocks.map(b => `<p>${b.text.replace(/[<>&]/g, c => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;" }[c]))}</p>`).join(""),
+    ttsRequired: true,
+    note: "结构化分块与 SSML 为纯 JS 产出；实际语音合成需接入 TTS 服务",
+  };
+}
+
+module.exports = { detectEmotion, encryptAtom, decryptAtom, accessibleRead, LEX };
+
+/* 自测 */
+if (require.main === module) {
+  console.log("=".repeat(74));
+  console.log("曾被误判为「需外部」的 4 个原子 · 真实实现自测");
+  console.log("=".repeat(74));
+  let pass = 0, fail = 0;
+  const ok = (n, c, d) => { if (c) { pass++; console.log("PASS  " + n.padEnd(18) + d); } else { fail++; console.log("FAIL  " + n.padEnd(18) + d); } };
+
+  // 情绪
+  const e1 = detectEmotion("太生气了！这个功能怎么又坏了！！");
+  ok("情绪识别·愤怒", e1.emotion_state === "anger", JSON.stringify({ 情绪: e1.emotion_state, 置信: e1.confidence, 强度: e1.intensity }));
+  const e2 = detectEmotion("今天心情很好，非常满意");
+  ok("情绪识别·喜悦", e2.emotion_state === "joy", JSON.stringify({ 情绪: e2.emotion_state, 置信: e2.confidence }));
+  const e3 = detectEmotion("嗯，知道了");
+  ok("情绪识别·中性", e3.emotion_state === "neutral", JSON.stringify({ 情绪: e3.emotion_state }));
+  const e4 = detectEmotion("我不开心");
+  ok("情绪识别·否定处理", e4.scores.find(s => s.emotion === "joy").score === 0, "「不开心」不应计为喜悦");
+
+  // 加解密
+  const enc = encryptAtom({ text: "元构机密数据 2026", key: "my-secret" });
+  ok("加密", enc.algorithm === "aes-256-gcm" && enc.ciphertext.length > 0, "算法=" + enc.algorithm + " 密文长度=" + enc.ciphertext.length);
+  const dec = decryptAtom({ payload: enc.payload, key: "my-secret" });
+  ok("解密·正确密钥", dec.明文 === "元构机密数据 2026", JSON.stringify({ 明文: dec.明文, 校验: dec.verified }));
+  const dec2 = decryptAtom({ payload: enc.payload, key: "wrong-key" });
+  ok("解密·错误密钥应失败", dec2.success === false, dec2.error.slice(0, 40));
+  const enc2 = encryptAtom({ text: "same text", key: "k" });
+  ok("加密·随机 IV", enc2.payload !== encryptAtom({ text: "same text", key: "k" }).payload, "两次加密结果不同（IV 随机）");
+
+  // 无障碍阅读
+  const ar = accessibleRead({ text: "# 标题\n这是一段正文内容。\n- 列表项一\n- 列表项二\n> 引用内容" });
+  ok("无障碍阅读", ar.块数 === 5 && ar.阅读块[0].type === "heading", JSON.stringify({ 块数: ar.块数, 类型: ar.阅读块.map(b => b.type) }));
+
+  console.log();
+  console.log(`合计 ${pass + fail} 项 ｜ 通过 ${pass} ｜ 失败 ${fail}`);
+  console.log(fail === 0 ? "总判定：PASS" : "总判定：FAIL");
+  process.exit(fail === 0 ? 0 : 1);
+}