progmune-runtime 3.7.41 → 3.7.43

package/CHANGELOG.md

@@ -1,5 +1,129 @@
 # Changelog
 
+## [3.7.43] — 2026-09-20
+
+### C4g：helper 换个载体（对象字面量方法 / 类方法 / 解构形参）
+
+helper 不一定是函数，也可能是方法：
+
+```ts
+export const Util = { toPath(n: string): string { return n + ".md"; } };   // 对象字面量方法
+export class Renderer { inst(n: string): string { return n + ".md"; } }    // 类实例方法
+```
+
+C4e 时刻意没做这一路（按裸名放行会让别的对象上的同名方法被误认成塑形，R11）。
+这一轮用**限定名 + 唯一性**解决：
+
+- 宿主名能确定时登记 `Owner.method`，调用点 `Util.toPath(k)` 直接对上；
+- 实例方法的主要写法是 `r.inst(k)`（宿主是变量，限定名对不上），所以该方法名在
+  **全项目唯一**时额外允许 `.inst(` 这种成员调用位匹配 —— 唯一性是 R11 的替代品，
+  不存在同名方法就不可能张冠李戴。同名方法出现两次时一律不登记，宁可漏报。
+
+另补**解构形参**：`function f({ name }) {…}` 的 `getName()` 给的是整个绑定模式
+而不是 `name`，要从 BindingElement 里逐个抽出来，否则这类 helper 一个都认不出。
+
+R12 第四次生效：备忘里列的「依赖分析深层形态」（三元返回、默认参、多 return）
+探针实测**本来就是通的**，真漏的只有解构形参。
+
+### 语料踩到的坑：helper 名字不能撞 sink 名单
+
+H 族第一版把静态方法写成 `Renderer.stat(k)`，闸门全绿；反向验证摘掉方法收集之后
+它**仍然标**。一查：`stat` 就在 `TS_FILE_SINK_NAMES` 里，调用点被 sink 兜底直接
+命中，与 helper 传播毫无关系 —— 实测 `Other.stat(k)`（接收者根本没定义）、以及类里
+压根没有 `stat` 方法，照样标。
+
+这是 R13 那条旁路的第二次出现，而且更阴：它让正例「标对了」，但标对的原因是另一
+回事。改名为 `toFile` 之后归因才干净。已登记为 **R16**。
+
+### 验收
+
+| 门 | 结果 |
+|---|---|
+| taintpath 闸门 | **92/92**（新增 H 族 11 条：7 mark / 3 no-taint / 1 suppressed） |
+| fr-007 真实语料 | pre 5 / post 0 **维持** |
+| fr-016 真实语料 | pre 7 / post 0 **维持** —— 放宽召回后守卫侧仍无新增误报 |
+| 定向用例 | **171 passed / 7 个测试文件**（新增 C4g 组 7 条：4 正 3 负） |
+| TS 盲测 | 108 项目，path_traversal **LOST 0 / ADDED 27**（H 7 + E 9 + F 6 + G 4 + D 1），基线那 104 个项目**零漂移零丢失** |
+| tsc | 零错误 |
+
+### 反向验证四刀
+
+| 刀 | 改动 | 转红 |
+|---|---|---|
+| 1 | 摘掉方法候选收集 | 3 条方法正例 |
+| 2 | 只摘掉成员调用位 `.method(` | emitClassInstance（宿主是变量那条） |
+| 3 | 解构形参名提取退回整体文本 | emitDestructured |
+| 4 | 关掉 C4f 收窄 | G 族 6 条 + H 族 `emitObjMethodDrop` |
+
+刀 4 顺带证明 C4f 的收窄对新载体同样生效 —— `Drop.fixed(k)` 不是空转对照。
+
+### 刻意不做：常量实参代入
+
+`viaTernaryDrop(n, flag) { return flag ? "fixed.md" : n + ".md"; }` 在
+`viaTernaryDrop(k, true)` 下走的是常量分支、形参不流出，现在仍会被判污染。要收这条
+得在调用点做常量传播（把实参字面量代入 return 再重算依赖），是另一个量级的改动，
+且代入出错的代价是漏报。登记为已知缺口。
+
+## [3.7.42] — 2026-09-20
+
+### C4f：名字级传播的精度收窄（形参-实参位置对齐 + 返回值依赖分析）
+
+前三轮（C4c/C4d/C4e）都在补召回，这一轮反过来**收精度**。
+
+传播此前是**名字级**的：赋值右侧出现污点名、且右侧看起来像塑形 ⇒ 新变量判为
+污染。它不看「这个 helper 的返回值到底依不依赖那个实参」：
+
+```ts
+const dropParam = (n: string): string => "fixed.md";   // 形参被丢掉
+const rel = dropParam(k);                                // k 流不出来，仍被判污染
+```
+
+现在给每个纯塑形 helper 多算一份 `deps` = **返回值真正依赖的形参集**，调用点按
+形参-实参位置对齐后才认证据：`dropParam(k)` ⇒ 无证据；`pickFirst("safe", k)`
+（只依赖第一个形参）⇒ 只留 `"safe"`。
+
+| 形态 | 收窄前 | 语义 |
+|---|---|---|
+| `dropParam(k)`（return 常量） | 误标 → 不标 | 依赖集为空 |
+| `pickFirst("safe", k)` | 误标 → 不标 | 位置不对齐 |
+| `path.join("out", dropParam(k))` | 误标 → 不标 | 该按支路算，不该整行一锅端 |
+| `wrapDrop(k)`（= dropParam(n)） | 误标 → 不标 | 依赖集跨函数传递后为空 |
+| `wrapPick("safe", k)` | 误标 → 不标 | 跨函数位置不对齐 |
+| `swapPick(k, "safe")`（= pickFirst(y, x)） | 误标 → 不标 | 换序后真正被依赖的是 y |
+
+换序那条最能说明价值：`swapPick("safe", k)` 该标、`swapPick(k, "safe")` 不该标 ——
+只看「实参里有没有污点名」两条都标，只看「形参有没有被用到」两条也都标，
+必须按位置穿过一次换序才分得开。
+
+`shaped`（右侧像不像塑形）仍看原式：helper 是不是塑形，与它的返回值依不依赖
+实参是两件事，不能互相替代。依赖分析有次序依赖（helper 若在它依赖的 helper 之前
+被接受，那一刻 deps 会偏宽），名录定稿后按完整的 info 再算两轮消掉 —— 偏宽是
+保守侧（继续传播），不会造成漏报。
+
+### 验收
+
+| 门 | 结果 |
+|---|---|
+| taintpath 闸门 | **81/81**（新增 G 族 12 条：4 mark / 7 no-taint / 1 suppressed） |
+| fr-007 真实语料 | pre 5 / post 0 **维持** |
+| fr-016 真实语料 | pre 7 / post 0 **维持** —— 收窄没有丢正例 |
+| 定向用例 | **164 passed / 7 个测试文件**（新增 C4f 组 11 条：4 正 7 负；taint-guard、structural、ssrf-loop、project-ir、C/Go/Java 提取组全绿） |
+| TS 盲测 | 107 项目，path_traversal **LOST 0 / ADDED 20**（G 4 + E 9 + F 6 + D 1），基线那 104 个项目**零漂移零丢失** |
+| tsc | 零错误 |
+
+### 门的方向也反过来了（R14 的一次镜像使用）
+
+前四轮 R7 咬的都是「语料零覆盖 ⇒ 门空过」。收窄轮最该防的是另外两件事：
+收窄过头把真阳性收掉（看 LOST）；以及那批 no-taint 用例其实空转（它们本来就不该
+标，旧代码也不会让它们红）。反向验证切了三刀：
+
+- **刀 A**：调用点退回「不按依赖抹实参」（等价收窄前）⇒ G 族 6 条 no-taint 全部
+  转红 —— 证明这批对照真的咬得住；
+- **刀 B**：只关掉跨函数传递（deps 只算直接依赖）⇒ 只有两跳相关的 3 条转红，
+  直接依赖那 3 条不动 —— 归因清晰；
+- **刀 C**：把收窄做得更激进（一律抹空）⇒ 3 条位置对齐正例转漏报，而
+  `emitPlainShaper`（常规塑形）不受影响 —— 正说明收窄没波及常规路径。
+
 ## [3.7.41] — 2026-09-20
 
 ### C4e：helper 的现代写法（箭头 / 函数表达式 / 模块常量）

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

@@ -1314,3 +1314,126 @@ const WRITE_LAYER = [
         }, 150000);
     }
 });
+(0, vitest_1.describe)("C4f：只有落在「返回值真依赖的形参位」上的污点才算流过去", () => {
+    // 与 C4e 同源的隔离写法：sink 实参里不出现污点变量 k，污点只能经 helper 返回值进来。
+    const emit = (relExpr) => [
+        'import * as fs from "fs";',
+        'import { dropParam, pickFirst, withExt, wrapDrop, wrapPick, swapPick } from "./helpers";',
+        "export function emit(doc: Record<string, any>, outDir: string) {",
+        "  Object.keys(doc).forEach((k) => {",
+        `    const rel = ${relExpr};`,
+        '    fs.writeFileSync(outDir + "/" + rel, "x");',
+        "  });",
+        "}",
+    ].join("\n");
+    const HELPERS = [
+        '// 依赖集为空：丢弃形参，返回常量',
+        'export const dropParam = (n: string): string => "fixed.md";',
+        '// 只依赖第一个形参',
+        'export const pickFirst = (a: string, b: string): string => a + ".md";',
+        '// 常规塑形（正对照）',
+        'export const withExt = (name: string): string => name + ".md";',
+        '// 两跳丢弃',
+        'export const wrapDrop = (n: string): string => dropParam(n);',
+        '// 两跳对齐',
+        'export const wrapPick = (a: string, b: string): string => pickFirst(a, b);',
+        '// 换序两跳：真正被依赖的是第二个形参',
+        'export const swapPick = (x: string, y: string): string => pickFirst(y, x);',
+    ].join("\n");
+    const cases = [
+        { name: "正例·常规塑形", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit("withExt(k)") },
+            expectMark: true, why: "收精度不得收过头 —— 这条必须照标" },
+        { name: "正例·污点在被依赖的形参位", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('pickFirst(k, "safe")') },
+            expectMark: true, why: "第一个形参真的影响返回值" },
+        { name: "正例·两跳仍在被依赖的位置", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('wrapPick(k, "safe")') },
+            expectMark: true, why: "依赖集要能跨函数传递" },
+        { name: "正例·换序两跳", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('swapPick("safe", k)') },
+            expectMark: true, why: "swapPick 真正依赖的是 y（第二个形参），位置对齐要跟着换" },
+        { name: "负对照·helper 丢弃形参", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit("dropParam(k)") },
+            expectMark: false, why: "return 常量 —— 实参带污点也流不出来；这是收窄前的真实误报" },
+        { name: "负对照·污点在不被依赖的形参位", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('pickFirst("safe", k)') },
+            expectMark: false, why: "第二个形参进了函数也出不来；正对照 = 正例·污点在被依赖的形参位" },
+        { name: "负对照·嵌套在 concat 里", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('path.join("out", dropParam(k))') },
+            expectMark: false, why: "整条 rhs 含 k，但那条支路不流出 —— 证据必须按支路算，不能整行一锅端" },
+        { name: "负对照·两跳后依赖集为空", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit("wrapDrop(k)") },
+            expectMark: false, why: "wrapDrop(n) = dropParam(n)，依赖集同样为空（跨函数对齐）" },
+        { name: "负对照·两跳位置不对齐", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('wrapPick("safe", k)') },
+            expectMark: false, why: "正对照 = 正例·两跳仍在被依赖的位置" },
+        { name: "负对照·换序的反向", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('swapPick(k, "safe")') },
+            expectMark: false, why: "k 落在不被依赖的 x 位；正对照 = 正例·换序两跳" },
+        { name: "负对照·实参本身无污点", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('dropParam("lit")') },
+            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);
+    }
+});
+(0, vitest_1.describe)("C4g：helper 换个载体（对象字面量方法 / 类方法 / 解构形参）也要能传播", () => {
+    const emit = (relExpr, pre = "") => [
+        'import * as fs from "fs";',
+        'import { Util, Drop, Renderer, viaName } from "./helpers";',
+        "export function emit(doc: Record<string, any>, outDir: string) {",
+        ...(pre ? [`  ${pre}`] : []),
+        "  Object.keys(doc).forEach((k) => {",
+        `    const rel = ${relExpr};`,
+        '    fs.writeFileSync(outDir + "/" + rel, "x");',
+        "  });",
+        "}",
+    ].join("\n");
+    const HELPERS = [
+        "export const Util = {",
+        '  toPath(n: string): string { return n + ".md"; },',
+        "};",
+        "export const Drop = {",
+        '  fixed(n: string): string { return "fixed.md"; },',
+        "};",
+        "export class Renderer {",
+        '  inst(n: string): string { return n + ".md"; }',
+        '  static stat(n: string): string { return n + ".txt"; }',
+        "}",
+        'export function viaName({ name }: any): string { return name + ".md"; }',
+    ].join("\n");
+    const cases = [
+        { name: "正例·对象字面量方法", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit("Util.toPath(k)") },
+            expectMark: true, why: "宿主名可确证 ⇒ 走限定名 Owner.method" },
+        { name: "正例·类实例方法", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit("r.inst(k)", "const r = new Renderer();") },
+            expectMark: true, why: "宿主是变量，限定名对不上 ⇒ 靠方法名唯一 + 成员调用位" },
+        { name: "正例·静态类方法", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit("Renderer.stat(k)") },
+            expectMark: true, why: "与对象字面量同形，走限定名" },
+        { name: "正例·解构形参", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit("viaName({ name: k })") },
+            expectMark: true, why: "形参名要从绑定模式里抽出来 —— getName() 给的是整个模式而不是 name" },
+        { name: "负对照·对象字面量方法丢弃形参", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit("Drop.fixed(k)") },
+            expectMark: false, why: "召回放宽到方法之后，C4f 的收窄也要跟得上新载体；正对照 = 正例·对象字面量方法" },
+        { name: "负对照·解构形参喂字面量", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('viaName({ name: "lit" })') },
+            expectMark: false, why: "无污点流入；正对照 = 正例·解构形参" },
+        { name: "负对照·方法是真塑形但实参是字面量", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('Util.toPath("static")') },
+            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);
+    }
+});

package/dist/extract-ir.js

@@ -772,6 +772,174 @@ function pathModuleAliases(project) {
     }
     return out;
 }
+/**
+ * 形参名列表：解构形参（`function f({ name }) {…}`）不能用 getName() 直接取，
+ * ts-morph 给的是整个绑定模式，要把里面的 BindingElement 名字逐个抽出来。
+ */
+function paramNamesOf(p) {
+    const nn = p.getNameNode();
+    if (ts_morph_1.Node.isIdentifier(nn))
+        return [nn.getText()];
+    const out = [];
+    for (const be of nn.getDescendantsOfKind(ts.SyntaxKind.BindingElement)) {
+        const n = be.getNameNode();
+        if (ts_morph_1.Node.isIdentifier(n))
+            out.push(n.getText());
+    }
+    return out;
+}
+/**
+ * 方法声明的宿主限定名：`const Util = { toPath(){} }` ⇒ "Util"、
+ * `const Cfg = { inner: { toPath(){} } }` ⇒ "Cfg.inner"、`class Paths {…}` ⇒ "Paths"。
+ * 取不出来就返回 null —— 认不出宿主的宁可不登记（保守侧）。
+ */
+function ownerQualifier(md) {
+    const parent = md.getParent();
+    if (!parent)
+        return null;
+    if (ts_morph_1.Node.isClassDeclaration(parent))
+        return parent.getName() ?? null;
+    if (!ts_morph_1.Node.isObjectLiteralExpression(parent))
+        return null;
+    const parts = [];
+    let cur = parent;
+    for (let guard = 0; guard < 5; guard++) {
+        const up = cur.getParent();
+        if (!up)
+            return null;
+        if (ts_morph_1.Node.isPropertyAssignment(up)) {
+            const key = up.getNameNode?.();
+            const keyName = key
+                ? key.getText().replace(/^["'`]|["'`]$/g, "")
+                : up.getChildAtIndex(0).getText().replace(/^["'`]|["'`]$/g, "");
+            parts.unshift(keyName);
+            cur = up.getParent();
+            if (!cur)
+                return null;
+            continue;
+        }
+        if (ts_morph_1.Node.isVariableDeclaration(up)) {
+            parts.unshift(up.getName());
+            return parts.join(".");
+        }
+        return null;
+    }
+    return null;
+}
+/** 按顶层逗号切分实参串（跳过字符串与已配平的括号，后者由调用方保证不含嵌套） */
+function splitTopLevelArgs(argText) {
+    const out = [];
+    let depth = 0;
+    let quote = "";
+    let cur = "";
+    for (let i = 0; i < argText.length; i++) {
+        const ch = argText[i];
+        if (quote) {
+            cur += ch;
+            if (ch === quote && argText[i - 1] !== "\\")
+                quote = "";
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            quote = ch;
+            cur += ch;
+            continue;
+        }
+        if (ch === "(" || ch === "[" || ch === "{")
+            depth++;
+        else if (ch === ")" || ch === "]" || ch === "}")
+            depth--;
+        if (ch === "," && depth === 0) {
+            out.push(cur);
+            cur = "";
+            continue;
+        }
+        cur += ch;
+    }
+    if (cur.trim() !== "" || out.length > 0)
+        out.push(cur);
+    return out;
+}
+/**
+ * C4f：把 helper 调用里【返回值不依赖的那些实参】抹掉。
+ *
+ * 名字级传播的老问题是：`discard(k) { return "fixed.md"; }` 明明把形参丢了，
+ * 只要 `k` 出现在赋值右侧就会被当成污点证据 ⇒ 误标。返回值既然不依赖那个形参，
+ * 那条支路就没有数据流。按形参-实参位置对齐后：
+ *
+ *   discard(k)          ⇒ `""`          （不依赖任何形参）
+ *   pick("safe", k)     ⇒ `("safe")`    （只依赖第一个形参）
+ *
+ * 只处理实参里不再嵌套括号的调用（最内层优先），有界 3 轮向外。
+ * 抹掉的是**证据**，`shaped` 判定仍看原式 —— helper 是不是塑形，与它的返回值
+ * 依不依赖实参是两件事。
+ */
+function maskNonDependentArgs(text, info, memberNames = new Set()) {
+    if (info.size === 0)
+        return text;
+    let cur = text;
+    for (let round = 0; round < 3; round++) {
+        const next = maskNonDependentArgsOnce(cur, info, memberNames);
+        if (next === null)
+            break;
+        cur = next;
+    }
+    return cur;
+}
+/** 抹掉**一个**最内层调用；没有任何调用需要抹时返回 null（供调用方收敛） */
+function maskNonDependentArgsOnce(text, info, memberNames) {
+    for (const [name, si] of info) {
+        const re = memberNames.has(name)
+            ? new RegExp(`\\.${escapeRe(name)}\\s*\\(`, "g")
+            : new RegExp(`(?:^|[${name.includes(".") ? "^\\w$" : "^\\w$."}])${escapeRe(name)}\\s*\\(`, "g");
+        let m;
+        while ((m = re.exec(text)) !== null) {
+            // 成员形态的匹配从 `.` 起算，替换也连点一起换掉
+            const nameStart = memberNames.has(name) ? m.index : m.index + (m[0].startsWith(name) ? 0 : 1);
+            const open = m.index + m[0].length - 1; // 开括号位置
+            let depth = 0;
+            let close = -1;
+            for (let i = open; i < text.length; i++) {
+                if (text[i] === "(")
+                    depth++;
+                else if (text[i] === ")") {
+                    depth--;
+                    if (depth === 0) {
+                        close = i;
+                        break;
+                    }
+                }
+            }
+            if (close < 0)
+                continue;
+            const argText = text.slice(open + 1, close);
+            if (/[([{]/.test(argText))
+                continue; // 还嵌着别的调用 —— 下一轮再处理
+            const args = splitTopLevelArgs(argText);
+            const kept = args.filter((_, i) => si.params[i] !== undefined && si.deps.has(si.params[i]));
+            if (kept.length === args.length)
+                continue; // 每个形参都被依赖 ⇒ 无需抹
+            const replacement = kept.length > 0 ? `(${kept.join(" + ")})` : `""`;
+            return text.slice(0, nameStart) + replacement + text.slice(close + 1);
+        }
+    }
+    return null;
+}
+/**
+ * return 表达式真正依赖哪些形参：把「已知 helper 调用里不被依赖的实参」抹掉后，
+ * 剩下的形参名就是会流进返回值的那些。`wrap(n) { return discard(n); }` ⇒ 空集。
+ */
+function returnDeps(exprs, params, info, memberNames = new Set()) {
+    const deps = new Set();
+    for (const raw of exprs) {
+        const masked = maskNonDependentArgs(raw, info, memberNames);
+        for (const p of params) {
+            if (new RegExp(`(?:^|[^\\w$.])${escapeRe(p)}(?:[^\\w$]|$)`).test(masked))
+                deps.add(p);
+        }
+    }
+    return deps;
+}
 /** return 表达式列表：块体取 return 语句，箭头简洁体把整个体当作返回值 */
 function returnExprsOf(body) {
     if (!ts_morph_1.Node.isBlock(body))
@@ -784,13 +952,14 @@ function returnExprsOf(body) {
     }
     return rets;
 }
-/** 扫描全项目，收集「纯塑形」helper 的名字（有界两轮不动点） */
+/** 扫描全项目，收集「纯塑形」helper 的名字 + 返回值依赖（有界两轮不动点） */
 function pureShaperFunctionNames(project) {
     const sinkRe = tsSinkCallRegex();
     const cands = [];
     /** 登记一个候选：三条判据 —— 有形参 / 有返回值 / 体内无 sink */
     const consider = (name, paramNodes, declText, bodyNode) => {
-        const params = new Set(paramNodes.filter(Boolean));
+        const paramList = paramNodes.filter(Boolean);
+        const params = new Set(paramList);
         if (params.size === 0)
             return;
         sinkRe.lastIndex = 0;
@@ -801,7 +970,9 @@ function pureShaperFunctionNames(project) {
         const rets = returnExprsOf(bodyNode);
         if (rets.length === 0)
             return; // ①
-        cands.push({ name, params, rets });
+        if (cands.some((c) => c.name === name))
+            return; // 同名重复登记：先到先得
+        cands.push({ name, params, paramList, rets });
     };
     for (const sf of project.getSourceFiles()) {
         // (a) 函数声明
@@ -812,7 +983,7 @@ function pureShaperFunctionNames(project) {
             const body = fn.getBody();
             if (!body)
                 continue; // 重载签名 / declare 只有签名
-            consider(name, fn.getParameters().map((p) => p.getName()), fn.getText(), body);
+            consider(name, fn.getParameters().flatMap(paramNamesOf), fn.getText(), body);
         }
         // (b) 变量承载的箭头 / 函数表达式 —— 现代 TS 里 helper 的主力写法
         //     `export const toPath = (n: string) => n + ".md";`
@@ -829,29 +1000,91 @@ function pureShaperFunctionNames(project) {
             const body = fnLike.getBody();
             if (!body)
                 continue;
-            consider(vd.getName(), fnLike.getParameters().map((p) => p.getName()), init.getText(), body);
+            consider(vd.getName(), fnLike.getParameters().flatMap(paramNamesOf), init.getText(), body);
+        }
+    }
+    // (c) 对象字面量方法 / 类方法 —— C4g。
+    //     `const Util = { toPath(n) {…} }`、`class Paths { toPath(n) {…} }` 都不在
+    //     getFunctions() 里，C4e 时刻意没做：按裸名放行会让别的对象上的同名方法被
+    //     误认成塑形（R11）。这里只登记**限定名** Owner.method；只有当该方法名在全
+    //     项目唯一（不存在同名方法）时，才额外允许 `.method(` 这种不写宿主名的
+    //     成员调用 —— 实例方法的主要写法正是这个。
+    const methodCands = [];
+    for (const sf of project.getSourceFiles()) {
+        for (const md of sf.getDescendantsOfKind(ts.SyntaxKind.MethodDeclaration)) {
+            const bare = md.getName();
+            if (!bare)
+                continue;
+            const body = md.getBody();
+            if (!body)
+                continue; // 重载签名 / declare
+            const owner = ownerQualifier(md);
+            methodCands.push({ qualified: owner ? `${owner}.${bare}` : null, bare, md });
+        }
+    }
+    const bareCount = new Map();
+    for (const m of methodCands)
+        bareCount.set(m.bare, (bareCount.get(m.bare) ?? 0) + 1);
+    const memberNames = new Set();
+    for (const m of methodCands) {
+        const params = m.md.getParameters().flatMap(paramNamesOf);
+        const text = m.md.getText();
+        const body = m.md.getBody();
+        if (!body)
+            continue;
+        // 实例方法的主要写法是 `p.toPath(k)` —— 宿主名是变量，限定名匹配不到，
+        // 所以唯一时额外登记「按成员调用位匹配」的裸名。
+        if (bareCount.get(m.bare) === 1) {
+            consider(m.bare, params, text, body);
+            memberNames.add(m.bare);
         }
+        if (m.qualified)
+            consider(m.qualified, params, text, body);
     }
     // 形参之外允许出现的自由标识符 = 模块级字面量常量 ∪ 确证的 path 模块别名
     const extraIdents = moduleLiteralConstNames(project);
     for (const a of pathModuleAliases(project))
         extraIdents.add(a);
-    const shapers = new Set();
+    const names = new Set();
+    const info = new Map();
     for (let round = 0; round < 2; round++) {
         let added = false;
         for (const c of cands) {
-            if (shapers.has(c.name))
+            if (names.has(c.name))
                 continue;
-            const ok = c.rets.every((e) => isPureShaperExpr(e, c.params, shapers, extraIdents));
+            const ok = c.rets.every((e) => isPureShaperExpr(e, c.params, names, extraIdents));
             if (!ok)
                 continue;
-            shapers.add(c.name);
+            names.add(c.name);
+            info.set(c.name, {
+                params: c.paramList,
+                deps: returnDeps(c.rets, c.paramList, info, memberNames),
+            });
             added = true;
         }
         if (!added)
             break;
     }
-    return shapers;
+    // C4f：依赖分析有次序依赖 —— `wrap(n) { return discard(n); }` 若在 discard 之前
+    // 被接受，那一刻 info 里还没有 discard ⇒ deps 偏宽（偏宽 = 继续传播 = 保守侧，
+    // 不会误报，但收不紧）。名录定稿后按完整的 info 再算两轮，把次序依赖消掉。
+    const byName = new Map(cands.map((c) => [c.name, c]));
+    for (let round = 0; round < 2; round++) {
+        let changed = false;
+        for (const [name, si] of info) {
+            const c = byName.get(name);
+            if (!c)
+                continue;
+            const d = returnDeps(c.rets, si.params, info, memberNames);
+            if (d.size !== si.deps.size || [...d].some((x) => !si.deps.has(x))) {
+                si.deps = d;
+                changed = true;
+            }
+        }
+        if (!changed)
+            break;
+    }
+    return { names, memberNames, info };
 }
 const TS_FILE_SINK_NAMES = [
     "readFile", "readFileSync", "writeFile", "writeFileSync",
@@ -1075,9 +1308,16 @@ function collectTaintedNames(text, shapers) {
 function taintedViaShaper(text, tainted, shapers) {
     // C4b：项目自有「纯塑形」helper 的调用也算子（如 getFileNamePath(dir, name, ext)）。
     // 见 pureShaperFunctionNames —— 只认三条判据全部成立的函数，认不出就不传播。
-    const localShaperRe = shapers && shapers.size > 0
-        ? new RegExp(`(?:^|[^\\w$.])(?:${[...shapers].map(escapeRe).join("|")})\\s*\\(`)
+    const localShaperRe = shapers && shapers.names.size > 0
+        ? new RegExp(`(?:^|[^\\w$.])(?:${[...shapers.names].map(escapeRe).join("|")})\\s*\\(`)
+        : null;
+    // C4g：成员调用位（`.toPath(`）—— 宿主是变量、限定名匹配不到时用
+    const memberShaperRe = shapers && shapers.memberNames.size > 0
+        ? new RegExp(`\\.(?:${[...shapers.memberNames].map(escapeRe).join("|")})\\s*\\(`)
         : null;
+    // C4f：helper 调用里【返回值不依赖的实参】不构成污点证据。
+    const shaperInfo = shapers?.info;
+    const memberNames = shapers?.memberNames;
     let grewAny = false;
     for (let depth = 0; depth < 3; depth++) {
         // 注意：这里**不能**以 `tainted.size === 0` 提前退出 —— 种子是根模式
@@ -1098,8 +1338,13 @@ function taintedViaShaper(text, tainted, shapers) {
                 continue;
             const shaped = TS_PATH_SHAPER_RE.test(rhs) ||
                 TS_CONCAT_RE.test(rhs) ||
-                (localShaperRe !== null && localShaperRe.test(rhs));
-            if (taintRe.test(rhs) && shaped) {
+                (localShaperRe !== null && localShaperRe.test(rhs)) ||
+                (memberShaperRe !== null && memberShaperRe.test(rhs));
+            // 证据看的是【抹掉不被依赖的实参之后】的 rhs：`discard(k)` 里 k 不流出，
+            // 那条支路就不该算证据。`shaped` 仍看原式 —— helper 是不是塑形，与它的
+            // 返回值依不依赖实参是两件事。
+            const evidence = shaperInfo && memberNames ? maskNonDependentArgs(rhs, shaperInfo, memberNames) : rhs;
+            if (taintRe.test(evidence) && shaped) {
                 tainted.add(name);
                 added = true;
             }

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.41";
+exports.RUNTIME_VERSION = "3.7.43";
 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.41",
+  "version": "3.7.43",
   "description": "Progmune — AI Trust Decision Engine. Verify AI-generated code before it reaches production. Outputs APPROVED / NEEDS_REVIEW / BLOCKED with evidence.",
   "files": [
     "dist/",