progmune-runtime 3.7.42 → 3.7.43

package/CHANGELOG.md

@@ -1,5 +1,69 @@
 # 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：名字级传播的精度收窄（形参-实参位置对齐 + 返回值依赖分析）

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

@@ -1380,3 +1380,60 @@ const WRITE_LAYER = [
         }, 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,60 @@ 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 = [];
@@ -820,12 +874,12 @@ function splitTopLevelArgs(argText) {
  * 抹掉的是**证据**，`shaped` 判定仍看原式 —— helper 是不是塑形，与它的返回值
  * 依不依赖实参是两件事。
  */
-function maskNonDependentArgs(text, info) {
+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);
+        const next = maskNonDependentArgsOnce(cur, info, memberNames);
         if (next === null)
             break;
         cur = next;
@@ -833,12 +887,15 @@ function maskNonDependentArgs(text, info) {
     return cur;
 }
 /** 抹掉**一个**最内层调用；没有任何调用需要抹时返回 null（供调用方收敛） */
-function maskNonDependentArgsOnce(text, info) {
+function maskNonDependentArgsOnce(text, info, memberNames) {
     for (const [name, si] of info) {
-        const re = new RegExp(`(?:^|[^\\w$.])${escapeRe(name)}\\s*\\(`, "g");
+        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 = m.index + (m[0].startsWith(name) ? 0 : 1);
+            // 成员形态的匹配从 `.` 起算，替换也连点一起换掉
+            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;
@@ -872,10 +929,10 @@ function maskNonDependentArgsOnce(text, info) {
  * return 表达式真正依赖哪些形参：把「已知 helper 调用里不被依赖的实参」抹掉后，
  * 剩下的形参名就是会流进返回值的那些。`wrap(n) { return discard(n); }` ⇒ 空集。
  */
-function returnDeps(exprs, params, info) {
+function returnDeps(exprs, params, info, memberNames = new Set()) {
     const deps = new Set();
     for (const raw of exprs) {
-        const masked = maskNonDependentArgs(raw, info);
+        const masked = maskNonDependentArgs(raw, info, memberNames);
         for (const p of params) {
             if (new RegExp(`(?:^|[^\\w$.])${escapeRe(p)}(?:[^\\w$]|$)`).test(masked))
                 deps.add(p);
@@ -926,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";`
@@ -943,9 +1000,47 @@ 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))
@@ -961,7 +1056,10 @@ function pureShaperFunctionNames(project) {
             if (!ok)
                 continue;
             names.add(c.name);
-            info.set(c.name, { params: c.paramList, deps: returnDeps(c.rets, c.paramList, info) });
+            info.set(c.name, {
+                params: c.paramList,
+                deps: returnDeps(c.rets, c.paramList, info, memberNames),
+            });
             added = true;
         }
         if (!added)
@@ -977,7 +1075,7 @@ function pureShaperFunctionNames(project) {
             const c = byName.get(name);
             if (!c)
                 continue;
-            const d = returnDeps(c.rets, si.params, info);
+            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;
@@ -986,7 +1084,7 @@ function pureShaperFunctionNames(project) {
         if (!changed)
             break;
     }
-    return { names, info };
+    return { names, memberNames, info };
 }
 const TS_FILE_SINK_NAMES = [
     "readFile", "readFileSync", "writeFile", "writeFileSync",
@@ -1213,8 +1311,13 @@ function taintedViaShaper(text, tainted, shapers) {
     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` 提前退出 —— 种子是根模式
@@ -1235,11 +1338,12 @@ function taintedViaShaper(text, tainted, shapers) {
                 continue;
             const shaped = TS_PATH_SHAPER_RE.test(rhs) ||
                 TS_CONCAT_RE.test(rhs) ||
-                (localShaperRe !== null && localShaperRe.test(rhs));
+                (localShaperRe !== null && localShaperRe.test(rhs)) ||
+                (memberShaperRe !== null && memberShaperRe.test(rhs));
             // 证据看的是【抹掉不被依赖的实参之后】的 rhs：`discard(k)` 里 k 不流出，
             // 那条支路就不该算证据。`shaped` 仍看原式 —— helper 是不是塑形，与它的
             // 返回值依不依赖实参是两件事。
-            const evidence = shaperInfo ? maskNonDependentArgs(rhs, shaperInfo) : rhs;
+            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.42";
+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.42",
+  "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/",