progmune-runtime 3.7.45 → 3.7.47

package/CHANGELOG.md

@@ -1,5 +1,195 @@
 # Changelog
 
+## [3.7.47] — 2026-09-21
+
+### 类方法的真实调用必须进 IR（状态机在 OO 代码上没有输入）
+
+**一句话**：主 IR 循环的类方法分支**只调了 `computeMarkerCalls`（产 `__progmune_*` 语义
+标记），从来没调过 `extractDirectCalls`（产真实调用名）**；而函数声明 / 箭头 / 包装箭头
+三个分支都是两行齐全。后果是类方法的 `calls` 里永远只有标记、没有真实调用 ⇒ **协议状态
+机在 OO 代码上拿不到输入**。
+
+这不是新引入的回归。Claude 补充的历史事实：修 A1 时类方法提取循环里写死的就是
+`calls: []`，`extractDirectCalls` 只对函数声明和箭头函数调用过，类方法从未接上。A1 只是
+给方法条目挂标记时动过这个数组，基础的调用提取从来没补。**自该功能诞生之日起就空转**，
+taintpath 十一族语料全是函数载体，从来没有东西逼它现形。
+
+**顺带解释了三件悬案**：真实语料 `protocol=0`、引擎自扫「0 误报」、NestJS 语料过分干净
+—— 裁判一直没拿到证据。
+
+**修复**：类方法分支补上 `extractDirectCalls(m, mText)`（签名形参加 `MethodDeclaration`，
+遍历逻辑无需改动），顺序与既有三个载体一致：先真实调用，再追加语义标记。
+
+| 探针形态（18 条） | 修复前 | 修复后 |
+|---|---|---|
+| 类方法（同步 / async / this 成员 / 装饰器 / 构造函数注入） | 全空 | ✓ 全部提出 |
+| static / private / 抽象类实现方法 / `this.a.b()` 链式 / 计算属性名 | 全空 | ✓ 全部提出 |
+| 函数声明 / 箭头（基线对照） | ✓ | ✓ 不变 |
+
+**三条不修**（探针确认后明确登记，避免下一轮重踩）：
+
+1. **getter / setter / 构造函数体 / 对象字面量方法 / 类表达式** —— 这五种不是「calls 空」，
+   而是**条目压根不在 IR 里**（载体未收集）。属另一类缺陷，风险量级不同（新增条目 = 新增
+   检测面），不能与本轮混在一起，否则反向验证无法归因。
+2. **嵌套箭头回调里的调用** —— `extractDirectCalls` 遇嵌套函数即 `traversal.skip()`。实测
+   函数声明 / 箭头 / 类方法三者口径**完全一致**（都只提得到 `setTimeout`），是既有设计。
+3. **计算属性名的名字解算** —— `C.[K]` 名字不可解是另一回事，不影响 calls。
+
+### FP 观测池：把「裁判拿到证据」量化出来
+
+修复后重扫（`fp-pool-scan.ts`，4 切片 / 197 文件）：
+
+| 读数 | 修复前 | 修复后 |
+|---|---|---|
+| 空 calls 函数 | 140 / 197（**71%**） | 23 / 197（**12%**） |
+| 其中类方法空转 | 126 | 9 |
+| NestJS 切片 | 59 / 61 空 | 3 / 61 空 |
+| Express 切片 | 76 / 113 空 | 15 / 113 空 |
+
+**代价也量出来了**：项目级 safeguard 19 → 21，但 **perFunction 层面新增 18 条** —— 类方法
+第一次有了 calls，规则第一次看见这些序列。逐条判定：**FP 15 / 弱真 3 / 真漏洞 0**。四条
+规则侧校准线索已登记在 `fp-pool.json`（迁移与种子脚本应豁免、TypeORM query builder 链被
+Input Validation 误判、内部工具方法不应被要求 Authorization、`validate` 已存在却仍报缺校验
+⇒ 是词表不认 class-validator）。
+
+上一轮 7 条人工判定里那条「无法判定」的 `UserController.login`（Token Security）**本轮变
+成有效票**：有了 calls 才看得出它是标准 `jwt.sign` 签发 ⇒ FP。
+
+### 验收
+
+| 门 | 结果 |
+|---|---|
+| taintpath 闸门 | **160/160** |
+| fr-007 / fr-016 | pre 5→post 0 / pre 7→post 0 **均维持** |
+| 定向用例 | **241 passed / 6 文件**（新增 E1 组 14 条：10 正 2 正对照 2 负对照） |
+| TS 盲测 | 111 项目 / perFunction **3201 条**：**LOST 0 / ADDED 0**，汇总完全一致 |
+| 反向验证 | 三刀，残留 0（见下） |
+| tsc | 零错误 |
+
+**反向验证三刀**（`/tmp/rev_e1.py（原名 rev_c4k.py）`）：
+
+| 刀 | 退回的旧行为 | 转红 |
+|---|---|---|
+| ① 类方法只留标记 | `const mCalls = computeMarkerCalls(...)` | **12 条**：正例 ①–⑩ + 负对照 ①② |
+| ② 类方法不追加标记 | 摘掉 `mCalls.push(...computeMarkerCalls(...))` | 0 条（marker 由**调用方侧**补上） |
+| ③ 同上（闸门视角） | 同 ② | 闸门仍 160/160 |
+
+刀①归因**干净**：转红的 12 条全在类方法组，正对照 ⑪⑫（函数声明 / 箭头）仍绿。
+刀②③顺带证明两件事：marker 链路有调用方侧兜底（不是单点）；**taintpath 语料里根本没有
+类方法 ⇒ 闸门对本轮是空过**，真正的验收在 fp-pool 与定向用例。
+
+### 方法学
+
+- **R22 第三次应验**：负对照·② 一开始写错期望（以为类方法体内有 sink 就会有 marker），
+  跑探针才确认 —— marker 只在**调用方把污点传进来**时才注入到被调用方。写 expect 之前
+  先把判据抄进探针注释，这条规矩已经是第三次救我。
+- **R20 的适用边界**（Claude 指出）：那三问（pre 有无校验 / 污点根是否在切片内 / fix 是否
+  新增校验）只适用于**修复回归语料**，**别误用到 FP 观测池**——池的标准是「真实 + HTTP
+  入口 + 文件操作」，不要求 CVE。两边管的方向不同（召回 vs 精度），标准本来就不同。
+
+## [3.7.46] — 2026-09-21
+
+### C4j：载体收口的最后一批 + 一处既有缺陷的回归门
+
+C4i 的备忘留了四条候选。按 R17 先写探针复现，同时塞进七条「没人提过但看着差不多」的
+形状 —— 三轮探针：24 条覆盖面 → 17 条**防修过头**的边界 → 6 条给默认导出补真 import。
+真缺口六条；另有一条**不是这轮引入**的缺陷被探针顺手挖出来（见下）。
+
+| 形状 | 旧行为 | 机制 |
+|---|---|---|
+| `typeof m === "string" \|\| n + ".md"` | 整条 helper 落选 | `typeof` 被当成**未知自由标识符** ⇒ 判据不通过 |
+| `((n) => …) as Fn` / `satisfies` / `<Fn>…` | 不收 | 初值是**断言表达式**不是箭头；成员位同理 |
+| `get mk() { return (n) => … }` | 不收 | getter 没有形参，`getFunctions()` 取不到 |
+| `lvl3("a")("b")(k)` 三/四跳 | 不展 | 旧机制只吃**两跳** |
+| `factory(".md").toPath(k)` | 不展 | 真正塑形的是**返回对象里的成员方法** |
+| `export default (n) => …` | 收不到 | 匿名默认导出**没有名字**可登记 |
+
+**精度侧一条：运算符关键字。** `typeof` / `void` / `in` / `instanceof` 是运算符不是自由
+标识符，出现在 return 表达式里不该让整条 helper 落选。**只放行运算符** —— `this` /
+`super` 不放行，它们指向宿主状态，放行等于给「返回值依赖 this」的假塑形开口子。
+
+**召回侧五条。**
+
+- **断言解包**：`unwrapFns` 解 `as` / `satisfies` / `<T>` 类型断言，**变量位、属性位、
+  调用点 callee、返回位**都要用 —— `get mk() { return ((n) => …) as Fn }` 就是「返回位
+  没解」漏出来的。
+- **getter 返回的箭头**：getter 自己的形参表是空的，判据要落在**它返回出来的那一层**，
+  与柯里化同一条路。
+- **柯里化推广成「跳链」**：`CurrySpec` 从写死的「外层 + 一层内层」改成
+  `{ outerParams, hops: CurryHop[], allParams, rets }`。`lvl3 = (a) => (b) => (n) => n+a+b`
+  ⇒ `outerParams=[a]`、`hops=[call[b], call[n]]`；工厂形态 ⇒ `hops=[member toPath [n]]`。
+  调用点从「两层实参代入」改成**逐跳消费**，跳数不设死上限（爬取有界 4 层），首跳实参
+  同样被闭包捕获（所以 `lvl3(k)("a")("b")` 与 `lvl3("a")("b")(k)` 都要对）。
+- **工厂形态 = 一个名字多条链**：按**成员名**选链（`makeMixed(".md").mix(k)` 走 mix 那条），
+  脏链（返回常量 / 体内有 sink）单独剔掉，不许污染同名的另一条。
+- **匿名默认导出**：没名字 ⇒ 用**导入方**起的本地名发布（`import toPath from "./helpers"`）。
+
+### 探针挖出的一处既有缺陷（C4h-② 的洞）
+
+C4h 把「同名成员唯一才登记」换成「全组确证」，但只把**通过判据**的实现算进组：判据不
+成立的实现没进组 ⇒ 组看起来「全组确证」⇒ 成员调用位放行 ⇒ 误标。
+
+```
+同名三处 getter：无形参的（判据①不成立）/ 正常塑形 / 体内有 sink 的（判据③不成立）
+后两处进组、第一处没进 ⇒ 组"干净" ⇒ .mk( 放行 ⇒ ONoParam.mk(k) 被误标
+```
+
+修法 `noteUnaccepted`：**失败的实现也记进组**（记 key + group，不进候选）。组一脏，整组
+不放行。教训：**「全组」的分母必须包含被判据拒掉的那些**，否则「全组确证」会退化成
+「通过者全体确证」—— 已升为方法学规则 **R19**。
+
+### 又一条「探针期望写错」（第二次）
+
+- **F9a**：探针忘了写 import。匿名默认导出的名字只能来自导入它的文件，两文件之间没有
+  import 就无从登记 —— 期望本身不可达。补上真 import 后通过。
+- **F9f**：期望 unmarked、实测 mark。查清后是**期望写错**不是误报：`(0, (n) => n + ".md")(k)`
+  里那个**内联匿名箭头自己就是塑形函数**，与默认导出无关 —— 把 `helpers.ts` 删掉照样标。
+
+⇒ 两条都不是机制错，是**预测错**。写期望前先问：这条标/不标，到底由**哪一个机制**决定。
+
+### 三条「看着像缺口、这轮故意不修」的边界
+
+探针里留着（F5 / F7 / A6 / F12），都退回保守侧：`switch` 分支与 `if` 早返回的返回值取
+**并集**（常量分支和污点分支混在一起，判不出）；`x != null` 这类**比较式**左值不折；
+标识符位「先声明后赋值」（`let f; f = (n) => …`）不收。这三条不是漏，是「判不出就退回
+保守」的固有代价 —— 要收得让调用点折叠长出手臂（按分支路径分别代入），属另一轮的量级。
+
+### 验收
+
+| 门 | 结果 |
+|---|---|
+| taintpath 闸门 | **160/160**（新增 K 族 22 条：12 mark / 9 no-taint / 1 suppressed） |
+| fr-007 真实语料 | pre 5 / post 0 **维持** |
+| fr-016 真实语料 | pre 7 / post 0 **维持** |
+| 定向用例 | 提取器定向用例 **227 passed / 6 个测试文件**（其中本文件新增 C4j 组 23 条：12 正 11 负，含两条回归·⑦） |
+| TS 盲测 | 111 项目 / perFunction 口径 **3201 条**：**LOST 0 / ADDED 18**，全部来自新增的 K 族 —— 其中 12 条 `path_traversal` 是本该标的，6 条 `data_integrity`（写文件无审计）属新项目的无关类别；基线那 3183 条**零漂移零丢失** |
+| tsc | 零错误 |
+
+### 反向验证七刀（归因）
+
+每刀只把一个机制退回**旧行为**（R18：不许 `return null` 逼停）：
+
+| 刀 | 改动 | 转红 |
+|---|---|---|
+| 1 | 关掉运算符关键字放行 | emitKw |
+| 2 | 摘掉 getter 收集 | emitGetterCls / emitGetterObj |
+| 3 | 断言解包退回只脱括号 | emitAs / emitAsSat / emitAsMember |
+| 4 | 柯里化退回两跳语义 | emitCurry3 / emitCurry4 / emitCurryFirst |
+| 5 | 工厂形态不登记 | emitFactory / emitFactoryMix |
+| 6 | 摘掉匿名默认导出收集 | emitDefault |
+| 7 | 成员组退回「判据失败不进组」 | 定向用例 回归·⑦ 两条 |
+
+闸门其余 148 条、定向用例 C4j 组其余 21 条全程不动 ⇒ 七处互不相干，归因干净。
+
+### 实现坑三条
+
+1. **解包要解到位**：`returnedValueOf` 也得解断言 —— `get mk() { return ((n) => …) as Fn }`
+   漏的就是这一处（"返回位没解"）。
+2. **一条名字多条链时，脏链要单独剔掉**：`makeMixed` 的 `skip`（返回常量）不许把 `mix`
+   那条链带下水，否则「张冠李戴」在链层面复现。
+3. **`expandCurried` 的实参位置**：首跳实参落在外层形参的第一个，不是内层 —— 从「两层
+   实参代入」改成「逐跳消费」时最容易写反。
+
 ## [3.7.45] — 2026-09-21
 
 ### C4i：又一批可判定分支 + 又一批 helper 载体

package/dist/extract-ir-taint-structural.test.js

@@ -1737,3 +1737,381 @@ const WRITE_LAYER = [
         }, 150000);
     }
 });
+// C4j（2026-09-21）：再一批载体 + 一条判据误杀 + 一处**既有**缺陷的回归门
+//   召回 ① 运算符关键字（typeof）不再让整条 helper 落选
+//        ② getter 返回出来的箭头（类 / 对象字面量）
+//        ③ as / satisfies / 类型断言包住箭头
+//        ④ 柯里化多跳（≥3 跳）+ 首跳实参是污点
+//        ⑤ 工厂形态：返回的对象字面量里再取方法
+//        ⑥ export default 匿名箭头（名字只能来自导入方）
+//   回归 ⑦ 成员组必须**记全**：同名三处里只要有一处判据不成立，成员调用位就不许放行
+//        （C4h-② 的"全组确证"漏掉了"进不了组"的实现 —— 探针 B4/B6 实测挖到）
+// 每条真缺口都配镜像负对照（R14/R15）。
+(0, vitest_1.describe)("C4j：载体收口的最后一批 + 成员组完整性回归", () => {
+    const emit = (relExpr, pre = "", imports = "", helpers = "") => ({
+        "helpers.ts": helpers,
+        "it.ts": [
+            'import * as fs from "fs";',
+            ...(imports ? [`import { ${imports} } from "./helpers";`] : []),
+            "export function emit(doc: Record<string, any>, outDir: string, mode: string) {",
+            ...(pre ? [`  ${pre}`] : []),
+            "  Object.keys(doc).forEach((k) => {",
+            `    const rel = ${relExpr};`,
+            '    fs.writeFileSync(outDir + "/" + rel, "x");',
+            "  });",
+            "}",
+        ].join("\n"),
+    });
+    /** 默认导出形态：helpers.ts 里 default 导出，it.ts 里真的 import 它 */
+    const emitDef = (relExpr, importLine, helpers) => ({
+        "helpers.ts": helpers,
+        "it.ts": [
+            'import * as fs from "fs";',
+            importLine,
+            "export function emit(doc: Record<string, any>, outDir: string, mode: string) {",
+            "  Object.keys(doc).forEach((k) => {",
+            `    const rel = ${relExpr};`,
+            '    fs.writeFileSync(outDir + "/" + rel, "x");',
+            "  });",
+            "}",
+        ].join("\n"),
+    });
+    // ── ① 关键字判据 ─────────────────────────────────────────────────
+    const H_KW = [
+        'export const viaKw = (n: string, m: string): any => typeof m === "string" || n + ".md";',
+        'export const viaKwDrop = (n: string, m: string): any => typeof m === "string" || "fixed.md";',
+    ].join("\n");
+    // ── ② getter 返回箭头（含同名三处的组成员完整性）─────────────────
+    const H_GET = [
+        "import * as fs from 'fs';",
+        // 同一个文件里三个同名 getter，覆盖三类命运：
+        //   无形参（判据①不收）/ 好 helper（确证）/ 体内有 sink（判据③不收）
+        'export const ONoParam: any = { get mk() { return (): string => "fixed.md"; } };',
+        'export const OSideCall: any = { get mk() { return (n: string): string => { __audit(n); return n + ".md"; }; } };',
+        'export const OWithSink: any = { get mk() { return (n: string): void => { fs.writeFileSync(n, ""); }; } };',
+    ].join("\n");
+    const H_GET_CLS = [
+        'export class CfgMk { get mk(): (n: string) => string { return (n: string): string => n + ".md"; } }',
+    ].join("\n");
+    const H_GET_DROP = [
+        'export const OGet2: any = { get mk() { return (_n: string): string => "fixed.md"; } };',
+    ].join("\n");
+    // ── ③ 断言解包 ───────────────────────────────────────────────────
+    const H_ASSERT = [
+        'export const toPathAs = ((n: string): string => n + ".md") as (n: string) => string;',
+        'export const toPathSat = ((n: string): string => n + ".md") satisfies (n: string) => string;',
+        'export const ObjAs: any = { toPath: ((n: string): string => n + ".md") as any };',
+        'export const notFn = (("x") as any);',
+    ].join("\n");
+    // ── ④ 柯里化多跳 ─────────────────────────────────────────────────
+    const H_LVL = [
+        'export const lvl3 = (a: string) => (b: string) => (n: string): string => n + a + b;',
+        'export const lvl4 = (a: string) => (b: string) => (c: string) => (n: string): string => n + a + b + c;',
+        'export const dropLast = (a: string) => (b: string) => (_n: string): string => "fixed.md";',
+    ].join("\n");
+    // ── ⑤ 工厂形态 ───────────────────────────────────────────────────
+    const H_FACT = [
+        "import * as fs from 'fs';",
+        'export const factory = (ext: string) => ({ toPath: (n: string): string => n + ext });',
+        'export const factoryDrop = (_ext: string) => ({ toPath: (_n: string): string => "fixed.md" });',
+        'export const factorySink = (ext: string) => ({ toPath: (n: string): string => { fs.readFileSync(n); return ext; } });',
+    ].join("\n");
+    // 一个工厂返回含**两个**方法的对象：一个塑形、一个丢弃。
+    // 这守的是「一个名字 → 多条链，按成员名选链」——选错就等于张冠李戴。
+    const H_MIX = [
+        'export const makeMixed = (ext: string) => ({',
+        '  mix: (n: string): string => n + ext,',
+        '  skip: (_n: string): string => "fixed.md",',
+        '});',
+    ].join("\n");
+    // ── ⑥ 默认导出 ───────────────────────────────────────────────────
+    const H_DEF = 'export default (n: string): string => n + ".md";';
+    const H_DEF_DROP = 'export default (_n: string): string => "fixed.md";';
+    const H_DEF_NOTFN = 'export default "fixed.md";';
+    const cases = [
+        // ① 关键字
+        { name: "正例·① 含 typeof 的 helper 要能进名录", fn: "emit", files: emit("viaKw(k, mode)", "", "viaKw", H_KW),
+            expectMark: true, why: "旧代码把 typeof 当成未知自由标识符 ⇒ 整条判据不通过 ⇒ 漏报" },
+        { name: "负对照·① 同形但返回值是常量", fn: "emit", files: emit("viaKwDrop(k, mode)", "", "viaKwDrop", H_KW),
+            expectMark: false, why: "关键字放行不等于放水：依赖分析照旧；正对照 = 上一条" },
+        // ② getter
+        { name: "正例·② 类 getter 返回的箭头", fn: "emit", files: emit("new CfgMk().mk(k)", "", "CfgMk", H_GET_CLS),
+            expectMark: true, why: "getter 不是方法声明（没有形参）⇒ 旧收集整族漏" },
+        { name: "正例·② 对象 getter 返回的箭头", fn: "emit", files: emit("OSideCall.mk(k)", "", "OSideCall", H_GET),
+            expectMark: true, why: "靠限定名 OSideCall.mk 接上（裸名 mk 因组里有未确证的实现而不放行）" },
+        { name: "回归·⑦ 同名 getter 有一处无形参 ⇒ 成员位不许放行", fn: "emit", files: emit("ONoParam.mk(k)", "", "ONoParam", H_GET),
+            expectMark: false, why: "组必须记全：进不了组的实现（判据①不成立）也算「不是全组确证」" },
+        { name: "回归·⑦ 同名 getter 有一处体内有 sink ⇒ 成员位不许放行", fn: "emit", files: emit("OWithSink.mk(k)", "", "OWithSink", H_GET),
+            expectMark: false, why: "同上，判据③不成立的那一处同样要进组" },
+        { name: "负对照·② getter 返回的箭头丢弃形参", fn: "emit", files: emit("OGet2.mk(k)", "", "OGet2", H_GET_DROP),
+            expectMark: false, why: "载体换了，收窄照旧；正对照 = ② 对象 getter" },
+        // ③ 断言解包
+        { name: "正例·③ as 断言包住箭头", fn: "emit", files: emit("toPathAs(k)", "", "toPathAs", H_ASSERT),
+            expectMark: true, why: "初值是 AsExpression，旧代码只认「初值就是箭头」" },
+        { name: "正例·③ satisfies 断言包住箭头", fn: "emit", files: emit("toPathSat(k)", "", "toPathSat", H_ASSERT),
+            expectMark: true, why: "同族另一种写法" },
+        { name: "正例·③ 成员位也要解断言", fn: "emit", files: emit("ObjAs.toPath(k)", "", "ObjAs", H_ASSERT),
+            expectMark: true, why: "属性位的初值同样被断言包着" },
+        { name: "负对照·③ as 包住的不是函数", fn: "emit", files: emit("notFn(k)", "", "notFn", H_ASSERT),
+            expectMark: false, why: "解断言不等于把任意 as 表达式当 helper" },
+        // ④ 柯里化多跳
+        { name: "正例·④ 三跳柯里化", fn: "emit", files: emit('lvl3("a")("b")(k)', "", "lvl3", H_LVL),
+            expectMark: true, why: "旧代码只吃两跳 ⇒ 三跳整条不展" },
+        { name: "正例·④ 四跳柯里化", fn: "emit", files: emit('lvl4("a")("b")("c")(k)', "", "lvl4", H_LVL),
+            expectMark: true, why: "链式消费各跳实参，跳数不设上限（爬取有界 4 层）" },
+        { name: "正例·④ 三跳·污点在第一跳", fn: "emit", files: emit('lvl3(k)("a")("b")', "", "lvl3", H_LVL),
+            expectMark: true, why: "首跳实参被闭包一路捕获" },
+        { name: "负对照·④ 三跳·最后一跳丢弃形参", fn: "emit", files: emit('dropLast("a")("b")(k)', "", "dropLast", H_LVL),
+            expectMark: false, why: "多跳之下依赖分析仍要生效；正对照 = ④ 三跳" },
+        // ⑤ 工厂形态
+        { name: "正例·⑤ 返回对象再取方法", fn: "emit", files: emit('factory(".md").toPath(k)', "", "factory", H_FACT),
+            expectMark: true, why: "真正塑形的是返回出来的那个成员方法" },
+        { name: "负对照·⑤ 工厂里方法丢弃形参", fn: "emit", files: emit('factoryDrop(".md").toPath(k)', "", "factoryDrop", H_FACT),
+            expectMark: false, why: "镜像" },
+        { name: "负对照·⑤ 工厂里方法体内有 sink", fn: "emit", files: emit('factorySink(".md").toPath(k)', "", "factorySink", H_FACT),
+            expectMark: false, why: "判据③在链的最内层照旧生效" },
+        { name: "正例·⑤ 工厂返回多个方法·取塑形那个", fn: "emit", files: emit('makeMixed(".md").mix(k)', "", "makeMixed", H_MIX),
+            expectMark: true, why: "一个工厂名对多条链，按**成员名**选链" },
+        { name: "负对照·⑤ 工厂返回多个方法·取丢弃那个", fn: "emit", files: emit('makeMixed(".md").skip(k)', "", "makeMixed", H_MIX),
+            expectMark: false, why: "同名工厂的另条链返回常量 ⇒ 不许张冠李戴；正对照 = 上一条" },
+        // ⑥ 默认导出
+        { name: "正例·⑥ 匿名默认导出（名字来自导入方）", fn: "emit", files: emitDef("toPath(k)", 'import toPath from "./helpers";', H_DEF),
+            expectMark: true, why: "匿名 default 没有名字可登记 ⇒ 只能用导入它的文件里起的本地名" },
+        { name: "负对照·⑥ 匿名默认导出·丢弃形参", fn: "emit", files: emitDef("toPath(k)", 'import toPath from "./helpers";', H_DEF_DROP),
+            expectMark: false, why: "镜像" },
+        { name: "负对照·⑥ 默认导出的不是函数", fn: "emit", files: emitDef("toPath(k)", 'import toPath from "./helpers";', H_DEF_NOTFN),
+            expectMark: false, why: "边界：不许乱收" },
+    ];
+    for (const c of cases) {
+        (0, vitest_1.it)(`${c.name} —— ${c.why}`, () => {
+            const dir = makeProject(c.files);
+            try {
+                const marks = marksFor(dir, c.fn);
+                if (c.expectMark)
+                    (0, vitest_1.expect)(marks).toContain(PATH_MARK);
+                else
+                    (0, vitest_1.expect)(marks).not.toContain(PATH_MARK);
+            }
+            finally {
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+        }, 150000);
+    }
+});
+// ═══════════════════════════════════════════════════════════════
+// E1：类方法的**真实调用**必须进 IR（2026-09-21）
+//
+// 命名说明：C4k 已被占用（容器承载轴「属性写入 ⇒ 容器传播」，实测收益上限 0，
+// 判定不修，见设计稿 §十七）。本组是**提取器主干**，另开 E（Extractor）系列。
+//
+// 背景（Claude 补充的历史事实）：主 IR 循环的类方法分支自该功能诞生之日起
+// 只调 computeMarkerCalls（产 __progmune_* 语义标记），从未调 extractDirectCalls
+// （产真实调用名）；函数声明 / 箭头 / 包装箭头三个分支都是两行齐全。
+// 结果：类方法的 calls 里永远只有标记、没有真实调用 ⇒ **状态机在 OO 代码上
+// 拿不到输入**。FP 观测池实测：NestJS 切片 61 个函数里 59 个 calls 为空（97%），
+// 池合计 197 个里 140 个空。此前未暴露是因为 taintpath 十一族语料全是函数载体。
+//
+// 判据：类方法条目的 calls 必须同时含「真实调用名」与「语义标记」——
+//      本轮是**补**真实调用，不是拿它替换标记（负对照·②守这条）。
+// ═══════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("E1：类方法的真实调用必须进 IR（此前只有标记，状态机拿不到输入）", () => {
+    const cases = [
+        // ── 正例：此前全空的五种已知形态 ──────────────────────────
+        {
+            name: "正例·① 类方法（同步）",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export class C { m() { helper(); } }
+`,
+            },
+            want: ["helper"],
+            why: "最基础的类方法；此前 calls 为空",
+        },
+        {
+            name: "正例·② 类方法（async / await）",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export class C { async m() { await helper(); } }
+`,
+            },
+            want: ["helper"],
+            why: "async 方法体同样是 Block，此前一样空",
+        },
+        {
+            name: "正例·③ 类方法经 this 成员调用",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+export class C { private repo: any; m() { this.repo.save(); } }
+`,
+            },
+            want: ["save"],
+            why: "NestJS/TypeORM 的实际写法；属性访问取末端名",
+        },
+        {
+            name: "正例·④ 类方法带装饰器",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+function Get(): any { return () => {}; }
+export class C { @Get() m() { helper(); } }
+`,
+            },
+            want: ["helper"],
+            why: "装饰器不得影响方法体遍历",
+        },
+        {
+            name: "正例·⑤ 构造函数注入（方法用注入进来的依赖）",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+export class C { constructor(private repo: any) {} m() { this.repo.save(); } }
+`,
+            },
+            want: ["save"],
+            why: "DI 形态；探针里五种已知失效形态之一",
+        },
+        // ── 正例：顺手测到的、没人提过的形状 ──────────────────────
+        {
+            name: "正例·⑥ static 方法",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export class C { static m() { helper(); } }
+`,
+            },
+            want: ["helper"],
+            why: "static 也在 getMethods() 内，同属本轮",
+        },
+        {
+            name: "正例·⑦ private 方法",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export class C { private m() { helper(); } }
+`,
+            },
+            want: ["helper"],
+            why: "可见性修饰符不得影响提取",
+        },
+        {
+            name: "正例·⑧ 抽象类里的实现方法",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export abstract class C { abstract a(): void; m() { helper(); } }
+`,
+            },
+            want: ["helper"],
+            why: "abstract 无体，但有体的方法照旧要提",
+        },
+        {
+            name: "正例·⑨ 链式调用 this.a.b()",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+export class C { a: any; m() { this.a.b(); } }
+`,
+            },
+            want: ["b"],
+            why: "末端名即被调用的方法名",
+        },
+        {
+            name: "正例·⑩ 计算属性名方法",
+            fn: "C.[K]",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+const K = "m";
+export class C { [K]() { helper(); } }
+`,
+            },
+            want: ["helper"],
+            why: "名字解不解得出是另一回事，calls 不该受名字影响",
+        },
+        // ── 正对照：既有载体不得被误伤 ────────────────────────────
+        {
+            name: "正对照·⑪ 函数声明（基线）",
+            fn: "plain",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export function plain() { helper(); }
+`,
+            },
+            want: ["helper"],
+            why: "本轮只补类方法，函数声明分支不得回归",
+        },
+        {
+            name: "正对照·⑫ 箭头函数（基线）",
+            fn: "arrow",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export const arrow = () => { helper(); };
+`,
+            },
+            want: ["helper"],
+            why: "同上；箭头分支不得回归",
+        },
+        // ── 负对照：防修过头 ─────────────────────────────────────
+        {
+            name: "负对照·① 嵌套箭头回调里的调用仍不提取",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export class C { m() { setTimeout(() => { helper(); }, 0); } }
+`,
+            },
+            want: ["setTimeout"],
+            dontWant: ["helper"],
+            why: "既有设计：extractDirectCalls 遇嵌套函数即 skip。已实测函数声明/箭头/类方法三者口径一致 ⇒ 本轮不动",
+        },
+        {
+            name: "负对照·② 真实调用不得挤掉语义标记",
+            fn: "Uploader.read",
+            files: {
+                "handler.ts": `
+import * as fs from "fs";
+export class Uploader {
+  read(filePath: string) {
+    return fs.readFileSync(filePath, "utf-8");
+  }
+}
+export function dispatchTool(args: any) {
+  const target = params.arguments.file_path;
+  return new Uploader().read(target);
+}
+`,
+            },
+            want: ["readFileSync", PATH_MARK],
+            why: "本轮是**补**真实调用，标记必须仍在——否则污点轴会整体倒退。" +
+                "（写这条用例时先跑探针确认判据：marker 只在**调用方把污点传进来**时才注入到" +
+                "被调用方，无调用方的类方法本就无 marker —— 探针 ①/④ 一致、②/③ 一致）",
+        },
+    ];
+    for (const c of cases) {
+        (0, vitest_1.it)(`${c.name} —— ${c.why}`, () => {
+            const dir = makeProject(c.files);
+            try {
+                const calls = marksFor(dir, c.fn);
+                for (const w of c.want)
+                    (0, vitest_1.expect)(calls).toContain(w);
+                for (const d of c.dontWant ?? [])
+                    (0, vitest_1.expect)(calls).not.toContain(d);
+            }
+            finally {
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+        }, 150000);
+    }
+});

package/dist/extract-ir.js

@@ -338,6 +338,18 @@ function manualResolveModule(moduleSpecifier, sourceFilePath, projectRoot, origi
     }
     return null;
 }
+/**
+ * 提取函数体内**真实出现的调用名**（区别于 computeMarkerCalls 产出的语义标记）。
+ *
+ * 2026-09-21（类方法空转修复）：形参类型补 MethodDeclaration。
+ *   此前本函数只对函数声明 / 箭头 / 包装箭头三个载体调用过；主 IR 循环里的
+ *   **类方法分支从来没调过它**，只调了 computeMarkerCalls ⇒ 类方法的 calls 里
+ *   永远只有标记、没有真实调用 ⇒ 状态机在 OO 代码上拿不到输入（FP 观测池实测：
+ *   NestJS 切片 61 个函数里 59 个 calls 为空）。该空转自类方法提取功能诞生即存在，
+ *   因 taintpath 十一族语料全是函数载体而从未现形。
+ *   MethodDeclaration 与 FunctionDeclaration 一样具备 getBody() / getText()，
+ *   遍历逻辑无需改动。
+ */
 function extractDirectCalls(func, preText) {
     const body = func.getBody();
     if (!body)
@@ -669,6 +681,21 @@ const VALUE_STRING_METHODS = new Set([
 const SHAPER_ALLOWED_FREE_IDENTS = new Set([
     "path", "sep", "undefined", "null", "true", "false", "String", "Number",
 ]);
+/**
+ * C4j：**运算符关键字**——本身不携带数据，出现在 return 表达式里不该让整条 helper 落选。
+ *
+ * 缺陷实证（2026-09-21 探针 G1/G2）：`(n, m) => typeof m === "string" || n + ".md"`
+ * 整条判据不通过 —— 单趟标识符扫描把 `typeof` 当成"未知的自由标识符"给否了。
+ * 后果不是"少收一点精度"，而是**整个 helper 不进名录** ⇒ 调用点拿不到任何证据 ⇒ 漏报。
+ * 差别只在 typeof：G2 同形去掉 typeof 后 MARKED，G1 不标。
+ *
+ * `this` / `super` 刻意**不放行**：它们是接收者，可能携带数据（`this.prefix + n`），
+ * 属于另一个话题（要不要把接收者纳入证据），不能靠"关键字"这条口子捎带进来。
+ */
+const SHAPER_ALLOWED_KEYWORDS = new Set([
+    "typeof", "void", "delete", "in", "instanceof", "keyof", "as", "satisfies",
+    "is", "asserts", "readonly", "infer", "new", "await", "yield", "of",
+]);
 /** 允许出现在调用位的值转换函数（不改变路径语义） */
 const VALUE_CONVERTER_CALLS = new Set(["String", "Number", "Boolean"]);
 /**
@@ -713,6 +740,8 @@ function isPureShaperExpr(expr, params, shapers, extraIdents) {
         // 自由标识符：必须是自己的形参、语言级常量白名单，或**已确证的字面量常量 / path 别名**
         if (params.has(n) || SHAPER_ALLOWED_FREE_IDENTS.has(n))
             continue;
+        if (SHAPER_ALLOWED_KEYWORDS.has(n))
+            continue; // C4j：运算符关键字不携带数据
         if (extraIdents && extraIdents.has(n))
             continue;
         return false;
@@ -891,11 +920,35 @@ function moduleQualifier(fn) {
     }
     return null;
 }
-/** 脱掉包住表达式的括号（可能多层）—— `((n) => n + ".md")` ⇒ 箭头本身 */
-function unparen(n) {
+/**
+ * 剥掉包在**函数体外面的**那几层壳，露出真正的箭头 / 函数表达式：
+ * 括号 `((n) => …)`、类型断言 `((n) => …) as Fn`、`satisfies Fn`、`<Fn>(…)`。
+ *
+ * C4j 补后三种。实测（探针 F3b/F3c）：`export const toPath = ((n) => n + ".md")
+ * satisfies Fn` 与 `{ toPath: ((n) => n + ".md") as any }` 都不传播 ——
+ * 旧代码只认「初值就是箭头」，断言把它们包了一层，整族漏。
+ */
+function unwrapFns(n) {
     let cur = n;
-    while (cur && ts_morph_1.Node.isParenthesizedExpression(cur))
-        cur = cur.getExpression();
+    for (let i = 0; i < 6 && cur; i++) {
+        if (ts_morph_1.Node.isParenthesizedExpression(cur)) {
+            cur = cur.getExpression();
+            continue;
+        }
+        if (ts_morph_1.Node.isAsExpression(cur)) {
+            cur = cur.getExpression();
+            continue;
+        }
+        if (ts_morph_1.Node.isSatisfiesExpression(cur)) {
+            cur = cur.getExpression();
+            continue;
+        }
+        if (ts_morph_1.Node.isTypeAssertion(cur)) {
+            cur = cur.getExpression();
+            continue;
+        }
+        break;
+    }
     return cur;
 }
 /**
@@ -906,23 +959,23 @@ function unparen(n) {
 function functionLikeOf(init) {
     // 实测：`(() => (n) => n + ".md")()` 里被括号包住的**不止**内层箭头 ——
     // 连被调用的 callee 都是 ParenthesizedExpression。两处都得脱。
-    const base = unparen(init);
+    const base = unwrapFns(init);
     if (!base)
         return null;
     if (ts_morph_1.Node.isArrowFunction(base) || ts_morph_1.Node.isFunctionExpression(base))
         return base;
     if (ts_morph_1.Node.isCallExpression(base)) {
-        const callee = unparen(base.getExpression());
+        const callee = unwrapFns(base.getExpression());
         if (!ts_morph_1.Node.isArrowFunction(callee) && !ts_morph_1.Node.isFunctionExpression(callee))
             return null;
         const b = callee.getBody();
         if (!ts_morph_1.Node.isBlock(b)) {
             // 简洁体：`(() => (n) => n + ".md")()` —— 括号包着也算（unparen）
-            const e = unparen(b);
+            const e = unwrapFns(b);
             return e && (ts_morph_1.Node.isArrowFunction(e) || ts_morph_1.Node.isFunctionExpression(e)) ? e : null;
         }
         for (const rs of b.getDescendantsOfKind(ts.SyntaxKind.ReturnStatement)) {
-            const e = unparen(rs.getExpression());
+            const e = unwrapFns(rs.getExpression());
             if (e && (ts_morph_1.Node.isArrowFunction(e) || ts_morph_1.Node.isFunctionExpression(e)))
                 return e;
         }
@@ -975,51 +1028,135 @@ function paramIndexOf(si, argIndex) {
     return si.restAt >= 0 && argIndex >= si.restAt ? si.restAt : argIndex;
 }
 /**
- * C4i：柯里化 helper —— 函数体【返回】另一个箭头 / 函数表达式
- * （`const withExt = (ext) => (n) => n + ext`）。这时被调用的不是这一层，
- * 而是它返回出来的内层函数；真正塑形的地方在内层，外层只负责捕获第一批实参。
- * 内层无形参 ⇒ 不存在「经内层实参进来」的污点 ⇒ 返回 null（外层按普通 helper 走）。
+ * C4i/C4j：柯里化 helper —— 函数体【返回】另一个函数
+ * （`(ext) => (n) => n + ext`、`(a) => (b) => (n) => n + a + b`）。
+ * 被调用的不是最外层，而是它一路返回出来的最内层；真正塑形在那里，
+ * 外层只负责捕获自己那一批实参。返回的不是函数（含返回对象字面量的工厂形态）
+ * 一律返回 null，交给 currySpecsOf 的另一条路。
  */
-function currySpecOf(outerParams, body) {
-    const inner = returnedFunctionOf(body);
-    if (!inner)
+function curryChainOf(outerParams, body) {
+    const ret = returnedValueOf(body);
+    if (!ret)
         return null;
-    const innerParams = inner.getParameters().flatMap(paramNamesOf).filter(Boolean);
-    if (innerParams.length === 0)
+    if (!ts_morph_1.Node.isArrowFunction(ret) && !ts_morph_1.Node.isFunctionExpression(ret))
         return null;
-    const innerBody = inner.getBody();
-    if (!innerBody)
-        return null;
-    const rets = returnExprsOf(innerBody);
-    if (rets.length === 0)
-        return null;
-    return { outerParams, innerParams, rets };
+    const hops = [];
+    let cur = ret;
+    for (let depth = 0; depth < 4; depth++) {
+        if (!cur)
+            break;
+        if (!ts_morph_1.Node.isArrowFunction(cur) && !ts_morph_1.Node.isFunctionExpression(cur))
+            return null;
+        const fbody = cur.getBody();
+        if (!fbody)
+            return null;
+        const params = cur.getParameters().flatMap(paramNamesOf).filter(Boolean);
+        hops.push({ kind: "call", name: "", params });
+        const next = returnedFunctionOf(fbody);
+        if (!next) {
+            const rets = returnExprsOf(fbody);
+            if (rets.length === 0)
+                return null;
+            // 内层无形参 ⇒ 没有「经内层实参进来」的污点，外层按普通 helper 处理
+            if (hops[hops.length - 1].params.length === 0)
+                return null;
+            const allParams = new Set(outerParams);
+            for (const h of hops)
+                for (const p of h.params)
+                    allParams.add(p);
+            return { outerParams, hops, allParams: [...allParams], rets };
+        }
+        cur = next;
+    }
+    return null;
+}
+/**
+ * C4j：一个函数体对应的全部调用链。
+ *   - 「返回函数」形态 ⇒ 0 或 1 条（沿返回值爬到最内层）；
+ *   - 「返回对象字面量」形态 ⇒ 每个**函数属性**各一条（工厂 / builder 的常态，
+ *     `factory(".md").toPath(k)` 里的 `toPath` 才是塑形那一层）。
+ * 属性名算不出（计算属性名而常量不可见）或无形参 / 无返回的，跳过该条。
+ */
+function currySpecsOf(outerParams, body) {
+    const ret = returnedValueOf(body);
+    if (!ret)
+        return [];
+    if (!ts_morph_1.Node.isObjectLiteralExpression(ret)) {
+        const one = curryChainOf(outerParams, body);
+        return one ? [one] : [];
+    }
+    const specs = [];
+    for (const prop of ret.getProperties()) {
+        let name = null;
+        let fn;
+        if (ts_morph_1.Node.isPropertyAssignment(prop)) {
+            name = prop.getName().replace(/^["'`]|["'`]$/g, "");
+            const inner = unwrapFns(prop.getInitializer());
+            if (inner && (ts_morph_1.Node.isArrowFunction(inner) || ts_morph_1.Node.isFunctionExpression(inner))) {
+                fn = inner;
+            }
+        }
+        else if (ts_morph_1.Node.isMethodDeclaration(prop)) {
+            name = prop.getName();
+            fn = prop;
+        }
+        if (!fn || !name || !/^[A-Za-z_$][\w$]*$/.test(name))
+            continue;
+        const fbody = fn.getBody();
+        if (!fbody)
+            continue; // 重载签名 / declare
+        const params = fn.getParameters().flatMap(paramNamesOf).filter(Boolean);
+        if (params.length === 0)
+            continue; // 判据①
+        const rets = returnExprsOf(fbody);
+        if (rets.length === 0)
+            continue;
+        specs.push({
+            outerParams,
+            hops: [{ kind: "member", name, params }],
+            allParams: [...outerParams, ...params],
+            rets,
+        });
+    }
+    return specs;
+}
+/** 函数体返回出来的那个值（简洁体本身 / return 语句的表达式，都先解断言与括号） */
+function returnedValueOf(body) {
+    if (!ts_morph_1.Node.isBlock(body))
+        return unwrapFns(body);
+    for (const rs of body.getDescendantsOfKind(ts.SyntaxKind.ReturnStatement)) {
+        const e = unwrapFns(rs.getExpression());
+        if (e)
+            return e;
+    }
+    return undefined;
 }
 /** 函数体返回出来的那个箭头 / 函数表达式（没有则 null） */
 function returnedFunctionOf(body) {
     if (!ts_morph_1.Node.isBlock(body)) {
         // 箭头简洁体本身就是要返回的函数：`(ext) => (n) => n + ext`（可能被括号包住）
-        const e = unparen(body);
+        const e = unwrapFns(body);
         return e && (ts_morph_1.Node.isArrowFunction(e) || ts_morph_1.Node.isFunctionExpression(e)) ? e : null;
     }
     for (const rs of body.getDescendantsOfKind(ts.SyntaxKind.ReturnStatement)) {
-        const e = unparen(rs.getExpression());
+        const e = unwrapFns(rs.getExpression());
         if (e && (ts_morph_1.Node.isArrowFunction(e) || ts_morph_1.Node.isFunctionExpression(e)))
             return e;
     }
     return null;
 }
 /**
- * C4i：柯里化 helper 的调用点展开。`withExt(".md")(k)` 这种两跳调用，真正塑形的是
- * 内层函数 —— 这里把【内层 return 表达式】按两层实参代入后原地摊开，之后的污点检测
- * 直接看摊开后的串：`withExt(".md")(k)` ⇒ `k + ".md"`，`withExt(k)("name")` ⇒
- * `"name" + k`。丢形参的内层（`(_n) => "fixed.md"`）摊开后是常量 ⇒ 自然不传播。
+ * C4i/C4j：柯里化与工厂形态的调用点展开。`withExt(".md")(k)`、`lvl4(a)(b)(c)(k)`、
+ * `factory(".md").toPath(k)` 里真正塑形的是链的**最后一跳** —— 这里按各跳的实参把
+ * 最内层 return 表达式代入后原地摊开，之后的污点检测直接看摊开后的串：
+ *   `withExt(".md")(k)` ⇒ `k + ".md"`；`factory(".md").toPath(k)` ⇒ `k + ".md"`。
+ * 丢形参的最后一跳（`(_n) => "fixed.md"`）摊开后是常量 ⇒ 自然不传播。
  */
 function expandCurried(text, curried) {
     if (curried.size === 0)
         return text;
     let cur = text;
-    for (let round = 0; round < 3; round++) {
+    for (let round = 0; round < 4; round++) {
         const next = expandCurriedOnce(cur, curried);
         if (next === null)
             break;
@@ -1027,9 +1164,9 @@ function expandCurried(text, curried) {
     }
     return cur;
 }
-/** 摊开**一处**柯里化调用；没有可摊的返回 null（供调用方收敛） */
+/** 摊开**一处**柯里化 / 工厂形态调用；没有可摊的返回 null（供调用方收敛） */
 function expandCurriedOnce(text, curried) {
-    for (const [name, cs] of curried) {
+    for (const [name, specs] of curried) {
         const re = new RegExp(`(?:^|[^\\w$.])${escapeRe(name)}\\s*\\(`, "g");
         let m;
         while ((m = re.exec(text)) !== null) {
@@ -1037,32 +1174,61 @@ function expandCurriedOnce(text, curried) {
             const close1 = matchingParen(text, open1);
             if (close1 < 0)
                 continue;
-            // 第二跳：紧跟其后的那个 `(`
-            let j = close1 + 1;
-            while (j < text.length && /\s/.test(text[j]))
-                j++;
-            if (text[j] !== "(")
-                continue;
-            const close2 = matchingParen(text, j);
-            if (close2 < 0)
-                continue;
-            const args1 = splitTopLevelArgs(text.slice(open1 + 1, close1));
-            const args2 = splitTopLevelArgs(text.slice(j + 1, close2));
-            const map = new Map();
-            args1.forEach((a, i) => {
-                const p = cs.outerParams[i];
-                if (p !== undefined)
-                    map.set(p, stripOuterParens(a.trim()));
-            });
-            args2.forEach((a, i) => {
-                const p = cs.innerParams[i];
-                if (p !== undefined && !map.has(p))
-                    map.set(p, stripOuterParens(a.trim()));
-            });
-            const inner = cs.rets.length === 1 ? cs.rets[0] : cs.rets.join(" + ");
-            const expanded = foldDecidableTernary(substituteParams(inner, map));
-            const nameStart = m.index + (m[0].startsWith(name) ? 0 : 1);
-            return text.slice(0, nameStart) + expanded + text.slice(close2 + 1);
+            const args0 = splitTopLevelArgs(text.slice(open1 + 1, close1));
+            for (const cs of specs) {
+                const map = new Map();
+                args0.forEach((a, i) => {
+                    const p = cs.outerParams[i];
+                    if (p !== undefined)
+                        map.set(p, stripOuterParens(a.trim()));
+                });
+                // 沿链一路吃掉各跳：普通跳是紧跟的 `(`，成员跳是 `.name(`
+                let cursor = close1 + 1;
+                let ok = true;
+                for (const hop of cs.hops) {
+                    let j = cursor;
+                    while (j < text.length && /\s/.test(text[j]))
+                        j++;
+                    if (hop.kind === "member") {
+                        if (text[j] === "?")
+                            j++; // 可选链 `?.toPath(`
+                        if (text[j] !== ".") {
+                            ok = false;
+                            break;
+                        }
+                        j++;
+                        const nm = /^[A-Za-z_$][\w$]*/.exec(text.slice(j));
+                        if (!nm || nm[0] !== hop.name) {
+                            ok = false;
+                            break;
+                        }
+                        j += nm[0].length;
+                        while (j < text.length && /\s/.test(text[j]))
+                            j++;
+                    }
+                    if (text[j] !== "(") {
+                        ok = false;
+                        break;
+                    }
+                    const cl = matchingParen(text, j);
+                    if (cl < 0) {
+                        ok = false;
+                        break;
+                    }
+                    splitTopLevelArgs(text.slice(j + 1, cl)).forEach((a, i) => {
+                        const p = hop.params[i];
+                        if (p !== undefined && !map.has(p))
+                            map.set(p, stripOuterParens(a.trim()));
+                    });
+                    cursor = cl + 1;
+                }
+                if (!ok)
+                    continue;
+                const inner = cs.rets.length === 1 ? cs.rets[0] : cs.rets.join(" + ");
+                const expanded = foldDecidableTernary(substituteParams(inner, map));
+                const nameStart = m.index + (m[0].startsWith(name) ? 0 : 1);
+                return text.slice(0, nameStart) + expanded + text.slice(cursor);
+            }
         }
     }
     return null;
@@ -1589,6 +1755,34 @@ function returnExprsOf(body) {
     }
     return rets;
 }
+/**
+ * C4j：`export default (n) => n + ".md"` 这种**匿名**默认导出没有名字可登记，
+ * 能用的名字只有「别的文件 import 它时起的本地名」。用 ts-morph 的模块解析找到
+ * 真正指向该文件的默认导入（解析不出的模块一律跳过 —— 认不出就不收）。
+ */
+function defaultImportLocalNames(project, target) {
+    const out = new Set();
+    const targetPath = target.getFilePath();
+    for (const sf of project.getSourceFiles()) {
+        if (sf.getFilePath() === targetPath)
+            continue;
+        for (const imp of sf.getImportDeclarations()) {
+            let resolved;
+            try {
+                resolved = imp.getModuleSpecifierSourceFile() ?? undefined;
+            }
+            catch {
+                continue; // 解析不了（路径写错 / 别名没配）—— 跳过
+            }
+            if (!resolved || resolved.getFilePath() !== targetPath)
+                continue;
+            const d = imp.getDefaultImport();
+            if (d)
+                out.add(d.getText());
+        }
+    }
+    return out;
+}
 /** 扫描全项目，收集「纯塑形」helper 的名字 + 返回值依赖（有界两轮不动点） */
 function pureShaperFunctionNames(project) {
     const sinkRe = tsSinkCallRegex();
@@ -1597,21 +1791,37 @@ function pureShaperFunctionNames(project) {
     const groups = new Map();
     // 模块级字面量常量（值一并留着：C4i 的计算属性名 `[KEY]` 要靠它解）
     const constTexts = moduleConstTexts(project);
+    /**
+     * 把一个**没通过判据**的实现记进它所属的成员组。
+     *
+     * C4j 修（探针 B4/B6 实测）：C4h-② 的"全组确证"只在**进了组**的候选之间成立，
+     * 而三条判据不成立的实现在 consider() 里就 return 了 —— 它压根不在组里，于是
+     * 「同名三处，一处无形参、一处体内有 sink、一处是好 helper」会被当成"全组都确证"，
+     * 成员调用位被放行 ⇒ 误标。组必须记全：**存在过但没确证**也要算进"不是全组确证"。
+     */
+    const noteUnaccepted = (key, group) => {
+        if (group === null)
+            return;
+        const list = groups.get(group) ?? [];
+        if (!list.includes(key))
+            list.push(key);
+        groups.set(group, list);
+    };
     /** 登记一个候选：三条判据 —— 有形参 / 有返回值 / 体内无 sink */
     const consider = (key, name, group, paramNodes, restAt, curry, declText, bodyNode) => {
         const paramList = paramNodes.filter(Boolean);
         const params = new Set(paramList);
         if (params.size === 0)
-            return;
+            return noteUnaccepted(key, group); // 判据①
         sinkRe.lastIndex = 0;
         if (sinkRe.test(declText))
-            return; // ②
+            return noteUnaccepted(key, group); // ②
         // 用 AST 取 return 表达式，而不是正则 —— 模板字面量里的 `${}` 会
         // 让「遇到花括号就停」的朴素正则在 `path.join(a,b) + \`.${c}\`` 上截断。
         const rets = returnExprsOf(bodyNode);
-        // 柯里化：return 出来的是函数 ⇒ 判据①看的是【内层】有没有返回表达式
-        if (rets.length === 0 && curry === null)
-            return; // ①
+        // 柯里化 / 工厂形态：return 出来的是函数或装着函数的对象 ⇒ 判据①看的是最内层
+        if (rets.length === 0 && curry.length === 0)
+            return noteUnaccepted(key, group); // ③
         let pub = name;
         if (pub !== null) {
             if (takenNames.has(pub))
@@ -1646,7 +1856,7 @@ function pureShaperFunctionNames(project) {
             const ps = fn.getParameters();
             const paramNodes = ps.flatMap(paramNamesOf);
             const restAt = restIndexOf(ps);
-            const curry = currySpecOf(paramNodes, body);
+            const curry = currySpecsOf(paramNodes, body);
             const owner = moduleQualifier(fn);
             // namespace 内却认不出宿主链 ⇒ 不收（宁可漏，不可张冠李戴）
             if (!ts_morph_1.Node.isSourceFile(parent) && owner === null)
@@ -1674,7 +1884,7 @@ function pureShaperFunctionNames(project) {
                 continue;
             const ps = fnLike.getParameters();
             const paramNodes = ps.flatMap(paramNamesOf);
-            consider(`var:${vd.getName()}`, vd.getName(), null, paramNodes, restIndexOf(ps), currySpecOf(paramNodes, body), init.getText(), // IIFE 时含整条调用 ⇒ sink 检查仍覆盖得到
+            consider(`var:${vd.getName()}`, vd.getName(), null, paramNodes, restIndexOf(ps), currySpecsOf(paramNodes, body), init.getText(), // IIFE 时含整条调用 ⇒ sink 检查仍覆盖得到
             body);
         }
     }
@@ -1702,35 +1912,40 @@ function pureShaperFunctionNames(project) {
                 continue; // 重载签名 / declare
             const ps = md.getParameters();
             const pns = ps.flatMap(paramNamesOf);
-            considerMember(bare, ownerQualifier(md, constTexts), pns, restIndexOf(ps), currySpecOf(pns, body), md.getText(), body);
+            considerMember(bare, ownerQualifier(md, constTexts), pns, restIndexOf(ps), currySpecsOf(pns, body), md.getText(), body);
         }
         // (d) 属性承载的箭头 / 函数表达式 —— 现代工程里 Objects-as-namespace 的常态。
         //     ownerQualifier 从父链走（对象字面量 → 属性赋值 → 变量声明），嵌套也认。
+        //     C4j：初值外面可能还包着 as / satisfies（`{ toPath: ((n) => …) as any }`）。
         for (const pa of sf.getDescendantsOfKind(ts.SyntaxKind.PropertyAssignment)) {
-            const init = pa.getInitializer();
+            const rawInit = pa.getInitializer();
+            if (!rawInit)
+                continue;
+            const init = unwrapFns(rawInit);
             if (!init)
                 continue;
             if (!ts_morph_1.Node.isArrowFunction(init) && !ts_morph_1.Node.isFunctionExpression(init))
                 continue;
-            const body = init.getBody();
+            const fn = init;
+            const body = fn.getBody();
             if (!body)
                 continue;
             const bare = propertyNameOf(pa, constTexts);
             if (!bare || !/^[A-Za-z_$][\w$]*$/.test(bare))
                 continue;
-            const ps = init.getParameters();
+            const ps = fn.getParameters();
             const pns = ps.flatMap(paramNamesOf);
-            considerMember(bare, ownerQualifier(pa, constTexts), pns, restIndexOf(ps), currySpecOf(pns, body), init.getText(), body);
+            considerMember(bare, ownerQualifier(pa, constTexts), pns, restIndexOf(ps), currySpecsOf(pns, body), rawInit.getText(), body);
         }
         // (e) 后挂上去的属性箭头 `Util.toPath = (n) => …`（monkey patch / 渐进导出）
         for (const be of sf.getDescendantsOfKind(ts.SyntaxKind.BinaryExpression)) {
             if (be.getOperatorToken().getKind() !== ts.SyntaxKind.EqualsToken)
                 continue;
             const left = be.getLeft();
-            const right = be.getRight();
+            const right = unwrapFns(be.getRight());
             if (!ts_morph_1.Node.isPropertyAccessExpression(left))
                 continue;
-            if (!ts_morph_1.Node.isArrowFunction(right) && !ts_morph_1.Node.isFunctionExpression(right))
+            if (!right || (!ts_morph_1.Node.isArrowFunction(right) && !ts_morph_1.Node.isFunctionExpression(right)))
                 continue;
             const body = right.getBody();
             if (!body)
@@ -1742,7 +1957,52 @@ function pureShaperFunctionNames(project) {
             const bare = qname.split(".").pop();
             const ps = right.getParameters();
             const pns = ps.flatMap(paramNamesOf);
-            considerMember(bare, qname.slice(0, -(bare.length + 1)), pns, restIndexOf(ps), currySpecOf(pns, body), right.getText(), body);
+            considerMember(bare, qname.slice(0, -(bare.length + 1)), pns, restIndexOf(ps), currySpecsOf(pns, body), right.getText(), body);
+        }
+        // (f) C4j：getter 返回出来的箭头 —— `get mk() { return (n) => n + ".md"; }`。
+        //     它既不是 MethodDeclaration（没有形参）也不是 PropertyAssignment（值是 getter），
+        //     上一轮三种载体都收不到它，整族漏（探针 B1/B2）。真正塑形的是**返回出来的箭头**，
+        //     所以判据看的是内层：无形参不收（B4）、体内有 sink 不收（B6）。
+        //     注意这里**不**走 currySpecOf —— getter 的读取本身不消耗实参，调用点是
+        //     `o.mk(k)` 一次调用，不是 `mk()(k)` 两跳。
+        for (const ga of sf.getDescendantsOfKind(ts.SyntaxKind.GetAccessor)) {
+            const body = ga.getBody();
+            if (!body)
+                continue;
+            const inner = returnedFunctionOf(body);
+            if (!inner)
+                continue; // getter 直接返回拼接（无形参）⇒ 判据①本就不成立
+            const innerBody = inner.getBody();
+            if (!innerBody)
+                continue;
+            const bare = propertyNameOf(ga, constTexts);
+            if (!bare || !/^[A-Za-z_$][\w$]*$/.test(bare))
+                continue;
+            const ps = inner.getParameters();
+            const pns = ps.flatMap(paramNamesOf);
+            considerMember(bare, ownerQualifier(ga, constTexts), pns, restIndexOf(ps), currySpecsOf(pns, innerBody), ga.getText(), innerBody);
+        }
+        // (g) C4j：`export default (n) => …` —— 匿名默认导出。它既不是函数声明（没有名字）
+        //     也不是变量声明，上一轮整族漏（探针 F9）。名字只能用**导入它的文件**里起的
+        //     本地名；多个文件用不同名字导入 ⇒ 每个名字各登记一条（takenNames 仍然先到先得）。
+        for (const ea of sf.getDescendantsOfKind(ts.SyntaxKind.ExportAssignment)) {
+            if (ea.isExportEquals())
+                continue;
+            const fn = unwrapFns(ea.getExpression());
+            if (!fn || (!ts_morph_1.Node.isArrowFunction(fn) && !ts_morph_1.Node.isFunctionExpression(fn)))
+                continue;
+            const fnBody = fn.getBody();
+            if (!fnBody)
+                continue;
+            const localNames = defaultImportLocalNames(project, sf);
+            if (localNames.size === 0)
+                continue; // 没人默认导入 ⇒ 名字无从谈起
+            const ps = fn.getParameters();
+            const pns = ps.flatMap(paramNamesOf);
+            const curry = currySpecsOf(pns, fnBody);
+            for (const ln of localNames) {
+                consider(`def:${sf.getFilePath()}:${ln}`, ln, null, pns, restIndexOf(ps), curry, ea.getText(), fnBody);
+            }
         }
     }
     // 形参之外允许出现的自由标识符 = 模块级字面量常量 ∪ 确证的 path 模块别名
@@ -1763,18 +2023,23 @@ function pureShaperFunctionNames(project) {
         names.add(name);
         info.set(name, si);
     };
+    /** C4j：确证通过的链（工厂可能有几条，脏的那条会被剔掉，见下） */
+    const pureCurried = new Map();
     for (let round = 0; round < 2; round++) {
         let added = false;
         for (const c of cands) {
             if (acceptedKeys.has(c.key))
                 continue;
             let si;
-            if (c.curry !== null) {
-                // 柯里化：判据落在【内层】的 return 上，形参集合是两层并起来
-                const all = new Set([...c.params, ...c.curry.innerParams]);
-                if (!c.curry.rets.every((e) => isPureShaperExpr(e, all, names, extraIdents)))
+            if (c.curry.length > 0) {
+                // 柯里化 / 工厂形态：判据落在**最内层**的 return 上，形参集合是本链各层并起来。
+                // 每个 spec 各自过判据：工厂返回多个方法时，只把**确证过的那些**收进名录，
+                // 脏的那条不发 spec ⇒ 调用点不会摊开它 ⇒ 退化为漏报而不是误报（保守侧）。
+                const pure = c.curry.filter((spec) => spec.rets.every((e) => isPureShaperExpr(e, new Set([...c.params, ...spec.allParams]), names, extraIdents)));
+                if (pure.length === 0)
                     continue;
                 acceptedKeys.add(c.key);
+                pureCurried.set(c.key, pure);
                 // 外层名照发：闭包会捕获外层实参（`const g = withExt(k)` 也是污的）。
                 // rets 留空 ⇒ 调用点折叠自动退回「全部依赖」（保守侧）。
                 si = { params: c.paramList, deps: new Set(c.paramList), rets: [], restAt: c.restAt };
@@ -1798,14 +2063,22 @@ function pureShaperFunctionNames(project) {
         if (!added)
             break;
     }
-    // C4i：柯里化名录。只有**发布了名字**的才登记 —— 名字被别处同名定义占用时
+    // C4i/C4j：柯里化与工厂名录。只有**发布了名字**的才登记 —— 名字被别处同名定义占用时
     // （pub 降为 null），`withExt(a)(b)` 里的 withExt 可能指的不是这个 helper，
     // 展开它会张冠李戴 ⇒ 宁可不展（保守侧，退化为漏报而非误报）。
+    // 一个名字可以对多条链（工厂返回含多个方法的对象）。
     const curried = new Map();
     for (const c of cands) {
-        if (c.curry !== null && c.name !== null && acceptedKeys.has(c.key)) {
-            curried.set(c.name, c.curry);
-        }
+        if (c.name === null || !acceptedKeys.has(c.key))
+            continue;
+        const pure = pureCurried.get(c.key);
+        if (!pure || pure.length === 0)
+            continue;
+        const list = curried.get(c.name) ?? [];
+        for (const spec of pure)
+            if (!list.includes(spec))
+                list.push(spec);
+        curried.set(c.name, list);
     }
     // C4f：依赖分析有次序依赖 —— `wrap(n) { return discard(n); }` 若在 discard 之前
     // 被接受，那一刻 info 里还没有 discard ⇒ deps 偏宽（偏宽 = 继续传播 = 保守侧，
@@ -2600,7 +2873,10 @@ function _extractSingleProject(absRoot, tsconfigPath) {
                     continue;
                 const mParams = m.getParameters();
                 const mText = m.getText();
-                const mCalls = computeMarkerCalls(mText, mParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns, directGuardFns, shapers);
+                // 2026-09-21：补上真实调用提取（此前只有 computeMarkerCalls，见 extractDirectCalls 注释）。
+                // 顺序与函数声明 / 箭头两个分支保持一致：先真实调用，再追加语义标记。
+                const mCalls = extractDirectCalls(m, mText);
+                mCalls.push(...computeMarkerCalls(mText, mParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns, directGuardFns, shapers));
                 funcs.push({
                     name: `${cn}.${mn}`,
                     params: mParams.map((p) => ({ name: p.getName(), type: getParamType(p), typeDetail: getParamTypeDetail(p) })),

package/dist/sdk.js

@@ -20,7 +20,7 @@ const risk_model_1 = require("./risk-model");
 const protocol_knowledge_1 = require("./protocol-knowledge");
 const evidence_repository_1 = require("./evidence-repository");
 /** Runtime version — stable public identifier. Internal layers evolve underneath. */
-exports.RUNTIME_VERSION = "3.7.45";
+exports.RUNTIME_VERSION = "3.7.47";
 function verify(filePath) {
     const cert = (0, certify_1.certify)(filePath);
     const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "progmune-runtime",
-  "version": "3.7.45",
+  "version": "3.7.47",
   "description": "Progmune — AI Trust Decision Engine. Verify AI-generated code before it reaches production. Outputs APPROVED / NEEDS_REVIEW / BLOCKED with evidence.",
   "files": [
     "dist/",