progmune-runtime 3.7.42 → 3.7.45

package/CHANGELOG.md

@@ -1,5 +1,237 @@
 # Changelog
 
+## [3.7.45] — 2026-09-21
+
+### C4i：又一批可判定分支 + 又一批 helper 载体
+
+备忘里挂着两条（getter/computed 属性 helper、常量代入扩展到短路与模板串）。按 R17
+先写探针复现，跑完 19 个形状：**备忘只覆盖了一半**，真缺口有六个，其中柯里化与 rest
+两条备忘里根本没有。
+
+| 形状 | 探针实测 | 结论 |
+|---|---|---|
+| 短路 `\|\|` / `&&` / `??` | `viaOr(k, "fixed.md")` 误标 | 真误报（精度侧） |
+| 模板串内嵌三元 | `viaTpl(k, true)` 误标 | 真误报（精度侧） |
+| 柯里化 `withExt(".md")(k)` | 不标 | 真漏报（备忘未列） |
+| namespace 内函数声明 | `P.toPath(k)` 不标 | 真漏报 |
+| rest 形参 `...parts` | `joinAll("out", k)` 不标 | 真漏报（备忘未列） |
+| IIFE 定义 / 计算属性名 | `toPathIife(k)`、`Box.toPath(k)` 不标 | 真漏报 |
+| getter（无形参） | 不标 | **不是缺口** —— 无形参 ⇒ 判据①本就不成立 |
+
+**精度侧：可判定分支的扩展。** 三元之外，短路运算符与三元同形，只是判据从 cond 换成
+**左操作数的真假**（`\|\|` 左真取左、`&&` 左真取右、`??` 左非空取左）。模板串的
+`${...}` 是独立表达式，折叠要能进去 —— 现代代码里 `` `${flag ? "fixed" : n}.md` `` 比
+裸三元更常见。判不出一律退回原串。
+
+**召回侧：四个新载体。**
+
+- **柯里化**：`withExt(ext)(n)` 真正塑形的是被返回出来的内层函数。收集时识别「return
+  箭头」，判据落在内层；调用点把 `NAME(a)(b)` 按两层实参代入后**原地摊开**
+  （⇒ `k + ".md"`），之后的污点检测直接看摊开后的串。
+- **namespace**：旧收集走 `sf.getFunctions()`，实测取不到 namespace 里的函数 ⇒ 改遍历
+  声明节点，只收顶层 / namespace 链上的（函数体内嵌套的作用域与调用点不同，不收）。
+- **rest 形参**：它吃掉的是**一批**实参，不是一位。原先按位对齐会把第二位当成「越界」
+  抹掉 ⇒ 漏报。现在 rest 位吃掉末尾所有位，且常量代入时跳过 rest 位。
+- **IIFE / 计算属性名**：`(() => (n) => …)()` 的初值是调用不是箭头；`{ [KEY]: (n) => … }`
+  的属性名只有在 KEY 是**模块级字面量常量**时才解 —— 解不出就不登记。
+
+### 又一条「用例自己写错了」
+
+初版把「属性名算不出来」的 `DynBox` 和同名可解的 `Box` 放在同一个项目里，期望
+unmarked 却实测 mark。原因不是机制错：成员调用位 `.name(` 的匹配**本就与宿主无关**
+（C4g 的保守策略），`Box.toPath` 登记之后 `DynBox.toPath` 必然被顺带命中。教训：写负
+对照前先确认「不标」到底是因为哪一个机制不成立 —— 这条已写进语料注释。
+
+### 验收
+
+| 门 | 结果 |
+|---|---|
+| taintpath 闸门 | **138/138**（新增 J 族 26 条：13 mark / 12 no-taint / 1 suppressed） |
+| fr-007 真实语料 | pre 5 / post 0 **维持** |
+| fr-016 真实语料 | pre 7 / post 0 **维持** |
+| 定向用例 | 提取器定向用例 **204 passed / 6 个测试文件**（其中本文件新增 C4i 组 26 条：11 正 15 负） |
+| TS 盲测 | 110 项目 / perFunction 口径 **3183 条**：**LOST 0 / ADDED 18**，全部来自新增的 J 族 —— 其中 12 条 `path_traversal` 是本该标的，6 条 `data_integrity`（写文件无审计）属新项目的无关类别；基线那 3165 条**零漂移零丢失** |
+| tsc | 零错误 |
+
+### 反向验证七刀
+
+| 刀 | 改动 | 转红 |
+|---|---|---|
+| 1 | `topLevelLogical` 恒返回 null（关短路折叠） | `emitOrTakeLeft` / `emitAndTakeLeft` / `emitNullishTakeLeft`（no-taint 转误标） |
+| 2 | `foldTemplateSubsts` 恒返回原串 | `emitTplConst`（转误标） |
+| 3 | `currySpecOf` 恒返回 null（柯里化不登记） | `emitCurrySecond` / `emitCurryFirst` / `emitCurryFn`（转漏报） |
+| 4 | `moduleQualifier` 恒返回 null（namespace 不发限定名） | `emitNsPath`（转漏报） |
+| 5 | `paramIndexOf` 退回按位（rest 位截断） | `emitRestJoin`（转漏报） |
+| 6 | 不解 IIFE（`functionLikeOf` 的 CallExpression 分支） | `emitIifePath`（转漏报） |
+| 7 | 不解计算属性名（`propertyNameOf` 的 computed 分支） | `emitComputed`（转漏报） |
+
+七刀各自只动自己那一组，没有交叉。第 2 刀和第 5 刀第一次都**打偏了**（详见下），
+打偏的刀会连累无关用例 —— 已升为方法学规则 **R18**。
+
+### 实现坑三条
+
+1. **`substituteParams` 把模板串整段跳过了** —— 折叠逻辑写对了也没用，`${flag ? …}`
+   里的 flag 根本没被代进去。模板串要按 `${}` 逐段递归代入，字面量部分照抄。
+2. **ts-morph 的两层包装**：`namespace P { … }` 里函数的父节点是 **ModuleBlock**
+   （ModuleDeclaration 在上一层）；`(() => (n) => …)()` 里被括号包住的**不止**内层
+   箭头，连被调用的 callee 都是 `ParenthesizedExpression`。两处都得脱。
+3. **模板串里写注释会提前终结模板串**（生成器里 `${}`、反引号都要转义）—— 报错信息
+   指向的是文件末尾，很容易误判成别处语法错。
+
+### 反向验证的两刀打偏（R18）
+
+反向验证不是"随便让一个函数失效"就行，退回必须是**旧行为**：
+
+- 第 5 刀第一次写成 `paramIndexOf` 返回 `null` —— rest 位不是"退回按位"，而是整个
+  失去对应形参 ⇒ 所有 helper 的实参被抹光 ⇒ **40 条漏报**。正确写法是 `return argIndex`。
+- 第 2 刀第一次写成 `foldTemplateSubsts` 返回 `null` —— 调用方靠 `tpl !== s` 判断
+  "这一层有没有做事"，返回 null 会被当成"已折叠" ⇒ 连带 11 条无关用例转红。
+
+⇒ R18：**反向验证的刀要退回旧行为，不能随便 return null**；刀的转红清单必须落在
+自己那一组，一旦出现跨组转红，先怀疑刀打偏了，而不是"机制有耦合"。
+
+## [3.7.44] — 2026-09-20
+
+### C4h：名录之外的三处收口
+
+helper 名录这轮的起点是三个备忘候选，动工前先写探针复现（R12），结果只有两个是真
+缺口，外加一个**探针顺手挖出来的既有缺陷**：
+
+| 候选 | 探针实测 | 结论 |
+|---|---|---|
+| 调用点常量实参代入 | `viaFlag(k, true)` 误标 | 真误报，本轮修（精度侧） |
+| 同名方法出现两次 | `u.toPath(k)` 不标 | 真漏报，本轮修（召回侧） |
+| 属性承载的箭头 helper | `Util.toPath(k)` 不标 | 真漏报，本轮修（召回侧） |
+| ——（非备忘项） | 方法名唯一但判据不成立时，成员调用位照样进名录 | **既有缺陷**，`r.lookup(k)` 误标 |
+
+**① 调用点常量代入。** 名录里的依赖集是**跨调用点**的并集 —— 对所有实参形状都成立
+的最宽结论，收不住个案：
+
+```ts
+const viaFlag = (n: string, flag: boolean): string => (flag ? "fixed.md" : n + ".md");
+const rel = viaFlag(k, true);   // 本次调用的返回值就是字面量 —— n 位进了函数也出不来
+```
+
+按形参位把**字面量实参**代回 return 表达式，试着解掉 cond 可判定的三元，再看还有
+哪些形参活着；判不出（实参不是常量、cond 代入后算不出真假）就一律退回名录结论 ——
+保守侧，认不出就不收精度。
+
+**② 同名成员多处。** 旧规则要求方法名全项目唯一才登记 `.method(` 成员调用位。唯一性
+只是「不可能认错」的**充分条件**，不是必要条件：同名两处都被确证为纯塑形时，同样
+不可能认错。换成「全组确证」之后依赖集按形参位取并集（任一实现在某位会流出，那位
+就算会流出）。
+
+同一处顺带补上一个坑：候选登记改成 `key / name / group` 三段，**确证之后**才发布到
+成员名录 —— 旧代码在确证之前就把裸名登记进去，于是
+`class Reg { lookup(n) { return registry[n]; } }`（registry 是模块级非字面量对象 ⇒
+判据③不成立）之后的 `r.lookup(k)` 被当成塑形 ⇒ 误标。
+
+**③ 属性承载的箭头。** `const Util = { toPath: (n) => … }` 与 `Util.toPath = (n) => …`
+既不是方法声明也不是变量声明，旧名录一片都收不到。现在与方法同表登记（限定名 +
+同组确证发布裸名）。
+
+### R13 第二次的变种：假通过也会发生在**定向用例**里
+
+C4g 组的静态类方法用例原本叫 `Renderer.stat(k)` —— `stat` 就在 fs sink 名单里，调用点
+被 sink 兜底直接标中，**那条用例一直在假通过**（删掉整段方法收集它照样绿）。改名
+`toFile` 后才真的在测 helper 传播。R16 原只约束盲测语料命名，本轮起同样适用于定向
+用例：写 fixture 前先 grep `TS_FILE_SINK_NAMES`。
+
+### 验收
+
+| 门 | 结果 |
+|---|---|
+| taintpath 闸门 | **112/112**（新增 I 族 20 条：11 mark / 8 no-taint / 1 suppressed） |
+| fr-007 真实语料 | pre 5 / post 0 **维持** |
+| fr-016 真实语料 | pre 7 / post 0 **维持** |
+| 定向用例 | 提取器定向用例 **178 passed / 6 个测试文件**（其中本文件 102 passed，新增 C4h 组 21 条：12 正 9 负） |
+| TS 盲测 | 109 项目 / perFunction 口径 **3165 条**：**LOST 0 / ADDED 11**，全部是新增 I 族里那 11 条本该标的 path_traversal；基线那 3152 条**零漂移零丢失**（另 2 条 `data_integrity` 属新项目的无关类别） |
+| tsc | 零错误 |
+
+### 反向验证四刀
+
+| 刀 | 改动 | 转红 |
+|---|---|---|
+| 1 | 关掉调用点折叠（`callSiteKeepFlags` 退回名录 deps） | `emitFlagTrue` / `emitPickMiss` / `emitFlagNested` / `emitWrapFlagTrue`（4 条由 no-taint 转误标） |
+| 2 | 同名合并退回「全项目唯一」 | `emitSameNameA` / `emitSameNameB`（转漏报） |
+| 3 | 摘掉属性箭头收集（(d)(e) 两个分支） | `emitPropArrow` / `emitNestedPropArrow` / `emitPatchedArrow`（转漏报） |
+| 4 | 成员名退回「确证之前就登记」 | `emitNonShaperMember` / `emitSameNameRejected`（转误标 —— 那个缺陷就是这么被探针逮到的） |
+
+四刀各自只动自己那一组，没有交叉：归因是干净的。
+
+### 实现坑两条
+
+1. **整条括号会让 cond 切不干净**：return 表达式常被写成 `=> (flag ? a : b)`，在第一
+   个顶层 `?` 处切开得到的前缀 `((true)` 括号不配对 ⇒ 判不出真假 ⇒ 折叠静默失效。
+   要先脱掉包住整串的括号（`stripOuterParens`）。
+2. **代入时别给字面量加括号**：`(true)` 会让 `maskNonDependentArgsOnce` 把实参串误判
+   成嵌套调用（它的判据是「实参里还有 `(`」），于是内层 helper 永远轮不到被处理 ——
+   两跳那条（`wrapFlag(k, true)`）就卡在这儿。
+
+## [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,360 @@ 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"; }',
+        // 原名 stat —— **stat 在 fs sink 名单里**，调用点会被 sink 兜底直接标中，
+        // 这条用例于是变成假通过（测的根本不是 helper 传播，R13）。改名后才测得准。
+        '  static toFile(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.toFile(k)") },
+            expectMark: true, why: "与对象字面量同形，走限定名（方法名刻意避开 sink 名单，否则用例是假通过）" },
+        { 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);
+    }
+});
+// ══════════════════════════════════════════════════════════════════════
+// C4h（2026-09-20）：三件都在「名录 ↔ 调用点」交界上的事
+//
+//   ① 调用点常量代入 —— helper 的 return 走三元，本次调用喂的是常量 ⇒ 返回值
+//      其实是字面量。名录里的依赖集是**跨调用点**的并集，收不住这种个案
+//      （探针实测：`viaFlag(k, true)` 误标）。按位置把常量代回去、解掉可判定的
+//      三元，判不出就退回原结论（保守侧）。
+//   ② 同名成员多处 —— 旧规则要求方法名全项目唯一才登记 `.method(`。唯一性只是
+//      「不可能认错」的充分条件：同名两处**都被确证**时同样不可能认错。
+//      顺带修掉一处真实缺陷：旧代码在确证之前就把裸名塞进了成员名录。
+//   ③ 属性承载的箭头 helper —— `const Util = { toPath: (n) => … }` 与
+//      `Util.toPath = (n) => …`，这两种既不是方法声明也不是变量声明。
+//
+// 写法约定（与前几族同源）：sink 实参里**不直接出现**污点变量 k。
+// ══════════════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("C4h：名录之外的三处收口（调用点常量 / 同名成员 / 属性箭头）", () => {
+    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) {",
+            ...(pre ? [`  ${pre}`] : []),
+            "  Object.keys(doc).forEach((k) => {",
+            `    const rel = ${relExpr};`,
+            '    fs.writeFileSync(outDir + "/" + rel, "x");',
+            "  });",
+            "}",
+        ].join("\n"),
+    });
+    // ── ① 调用点常量代入 ───────────────────────────────────────────────
+    const H_CONST = [
+        'export const viaFlag = (n: string, flag: boolean): string => (flag ? "fixed.md" : n + ".md");',
+        // 两支都含形参 —— 收精度不能收到这儿
+        "export const eitherWay = (n: string, flag: boolean): string => (flag ? n : n + '.md');",
+        "export const pickMode = (n: string, mode: string): string => (mode === 'raw' ? n : 'fixed.md');",
+        // 两跳：折叠要能穿过 helper 之间的嵌套调用
+        'export const wrapFlag = (n: string, flag: boolean): string => viaFlag(n, flag);',
+    ].join("\n");
+    // ── ② 同名成员多处 ─────────────────────────────────────────────────
+    const H_TWICE_OK = [
+        "export class Uploader { toPath(n: string): string { return n + '.md'; } }",
+        "export class Downloader { toPath(n: string): string { return n + '.tmp'; } }",
+    ].join("\n");
+    const H_TWICE_DROP = [
+        "export class DropA { still(n: string): string { return 'fixed.md'; } }",
+        "export class DropB { still(n: string): string { return 'other.md'; } }",
+    ].join("\n");
+    // 一处引用了模块级**非字面量**对象 ⇒ 判据③不成立 ⇒ 整个同名组都不许放行。
+    // 刻意不含 sink —— 否则会被跨函数 sink 形参映射标中，归因就不干净了（R13）。
+    const H_TWICE_BAD = [
+        "export class Uploader { toPath(n: string): string { return n + '.md'; } }",
+        "export const dict: Record<string, string> = {};",
+        "export class Weird { toPath(n: string): string { return dict[n]; } }",
+    ].join("\n");
+    const H_SOLO = [
+        "export class Solo { toPath(n: string): string { return n + '.md'; } }",
+    ].join("\n");
+    // ── ③ 属性承载的箭头 ───────────────────────────────────────────────
+    const H_PROP = [
+        "export const Util2 = {",
+        "  toPath: (n: string): string => n + '.md',",
+        "};",
+        "export const NS = {",
+        "  path: {",
+        "    toPath: (n: string): string => n + '.md',",
+        "  },",
+        "};",
+        "export const Patched: any = {};",
+        "Patched.toPath = (n: string): string => n + '.md';",
+        "export const DropProp = {",
+        "  fixed: (n: string): string => 'fixed.md',",
+        "};",
+    ].join("\n");
+    // ── 缺陷回归门：非塑形方法的成员调用位不能算塑形 ────────────────────
+    const H_NONSHAPER = [
+        "export const registry: Record<string, string> = {};",
+        "export class Reg {",
+        "  lookup(n: string): string { return registry[n]; }",
+        "}",
+    ].join("\n");
+    const H_SHAPER_LOOKUP = [
+        "export class RegSafe {",
+        "  lookup(n: string): string { return n + '.md'; }",
+        "}",
+    ].join("\n");
+    const cases = [
+        // ① —— 精度侧
+        { name: "正例·① 走真流出分支", fn: "emit", files: emit("viaFlag(k, false)", "", "viaFlag", H_CONST),
+            expectMark: true, why: "flag=false ⇒ 走的是含 n 的那支" },
+        { name: "正例·① 两支都含形参", fn: "emit", files: emit("eitherWay(k, true)", "", "eitherWay", H_CONST),
+            expectMark: true, why: "收精度不许收过头 —— 选中的分支里仍有 n" },
+        { name: "正例·① 字符串比较命中", fn: "emit", files: emit('pickMode(k, "raw")', "", "pickMode", H_CONST),
+            expectMark: true, why: "mode === 'raw' 命中 ⇒ 返回 n" },
+        { name: "正例·① 第二参是变量（判不出就照标）", fn: "emit", files: emit("viaFlag(k, dyn)", "const dyn = Math.random() > 0;", "viaFlag", H_CONST),
+            expectMark: true, why: "保守侧：实参不是常量 ⇒ 一律退回名录结论，不许假装看得懂" },
+        { name: "负对照·① 常量把分支钉死成字面量", fn: "emit", files: emit("viaFlag(k, true)", "", "viaFlag", H_CONST),
+            expectMark: false, why: "本次调用的返回值就是 'fixed.md' —— 名录级依赖集收不住这种个案；正对照 = ① 走真流出分支" },
+        { name: "负对照·① 字符串比较没命中", fn: "emit", files: emit('pickMode(k, "cooked")', "", "pickMode", H_CONST),
+            expectMark: false, why: "mode 不是 'raw' ⇒ 走常量支；正对照 = ① 字符串比较命中" },
+        { name: "负对照·① 嵌套在 path.join 里", fn: "emit", files: emit('path.join("out", viaFlag(k, true))', "", "viaFlag", H_CONST),
+            expectMark: false, why: "整条 rhs 含 k，但那条支路不流出 —— 折叠要能作用在嵌套的内层" },
+        { name: "负对照·① 两跳 + 常量", fn: "emit", files: emit("wrapFlag(k, true)", "", "wrapFlag", H_CONST),
+            expectMark: false, why: "wrapFlag(n, flag) = viaFlag(n, flag)，折叠要穿过一层 helper" },
+        { name: "正对照·① 两跳走流出分支", fn: "emit", files: emit("wrapFlag(k, false)", "", "wrapFlag", H_CONST),
+            expectMark: true, why: "与上一条镜像：常量改变量 ⇒ 立刻转红，证明归因在这条机制上" },
+        // ② —— 召回侧
+        { name: "正例·② 同名成员两处均塑形", fn: "emit", files: emit("u.toPath(k)", "const u = new Uploader();", "Uploader", H_TWICE_OK),
+            expectMark: true, why: "两处都被确证 ⇒ `.toPath(` 不可能落到别的实现上（唯一性换成全组确证）" },
+        { name: "正例·② 另一处同名也被识别", fn: "emit", files: emit("d.toPath(k)", "const d = new Downloader();", "Downloader", H_TWICE_OK),
+            expectMark: true, why: "合并是对称的：同组的另一个宿主同样要接得上" },
+        { name: "正例·② 单处同名的老对照组", fn: "emit", files: emit("s.toPath(k)", "const s = new Solo();", "Solo", H_SOLO),
+            expectMark: true, why: "全组确证是旧唯一性规则的上位，老行为必须还在" },
+        { name: "负对照·② 同名两处都丢弃形参", fn: "emit", files: emit("a.still(k)", "const a = new DropA();", "DropA", H_TWICE_DROP),
+            expectMark: false, why: "合并后的依赖集按位取并集 —— 两处都丢 ⇒ 仍为空，精度不许丢" },
+        { name: "负对照·② 同名一处非塑形", fn: "emit", files: emit("u.toPath(k)", "const u = new Uploader();", "Uploader", H_TWICE_BAD),
+            expectMark: false, why: "整组不放行（R11 的不变量：必须在每一种实现上都成立）；正对照 = ② 同名成员两处均塑形" },
+        // ③ —— 召回侧
+        { name: "正例·③ 属性箭头 helper", fn: "emit", files: emit("Util2.toPath(k)", "", "Util2", H_PROP),
+            expectMark: true, why: "`{ toPath: (n) => … }` 既不是方法声明也不是变量声明 —— 旧名录整片漏" },
+        { name: "正例·③ 嵌套对象的属性箭头", fn: "emit", files: emit("NS.path.toPath(k)", "", "NS", H_PROP),
+            expectMark: true, why: "限定名要能沿 owner 链一路拼到最外层变量" },
+        { name: "正例·③ 属性赋值箭头", fn: "emit", files: emit("Patched.toPath(k)", "", "Patched", H_PROP),
+            expectMark: true, why: "`Obj.method = (n) => …` 这种后挂写法同属一族" },
+        { name: "负对照·③ 属性箭头丢弃形参", fn: "emit", files: emit("DropProp.fixed(k)", "", "DropProp", H_PROP),
+            expectMark: false, why: "召回放宽到新载体，C4f/C4h-① 的收窄要跟得上；正对照 = ③ 属性箭头 helper" },
+        { name: "负对照·③ 属性箭头喂字面量", fn: "emit", files: emit('Util2.toPath("lit")', "", "Util2", H_PROP),
+            expectMark: false, why: "无污点流入" },
+        // 缺陷回归门（旧行为：确证之前就把裸名登记进成员名录）
+        { name: "负对照·非塑形方法的成员调用位不算塑形", fn: "emit", files: emit("r.lookup(k)", "const r = new Reg();", "Reg", H_NONSHAPER),
+            expectMark: false, why: "lookup 引用了模块级非字面量对象 ⇒ 三条判据不成立 ⇒ 成员调用位不许进名录" },
+        { name: "正对照·同一个名字换成塑形版", fn: "emit", files: emit("r.lookup(k)", "const r = new RegSafe();", "RegSafe", H_SHAPER_LOOKUP),
+            expectMark: true, 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);
+    }
+});
+// C4i（2026-09-21）：六个缺口 —— 三个是精度、三个是召回载体
+//   精度 ① 短路运算符（|| / && / ?? 与三元同形，只是判据换成左操作数的真假）
+//        ② 模板串内嵌的三元（${} 内部是独立表达式，折叠要能进去）
+//   召回 ③ 柯里化高阶 helper    ④ namespace 内的函数声明
+//        ⑤ rest 形参            ⑥ IIFE 定义 / 计算属性名
+// 每组都配「判不出 ⇒ 退回保守」与「helper 真丢弃 ⇒ 仍不标」两条镜像（R14/R15）。
+(0, vitest_1.describe)("C4i：helper 的又一批载体与又一批可判定分支", () => {
+    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) {",
+            ...(pre ? [`  ${pre}`] : []),
+            "  Object.keys(doc).forEach((k) => {",
+            `    const rel = ${relExpr};`,
+            '    fs.writeFileSync(outDir + "/" + rel, "x");',
+            "  });",
+            "}",
+        ].join("\n"),
+    });
+    // ── ① 短路 + ② 模板串 ─────────────────────────────────────────────
+    const H_FOLD = [
+        'export const viaOr = (n: string, s: any): string => s || n + ".md";',
+        'export const viaAnd = (n: string, s: any): string => s && n + ".md";',
+        'export const viaNull = (n: string, s: any): string => s ?? n + ".md";',
+        'export const viaTpl = (n: string, f: boolean): string => `${f ? "fixed" : n}.md`;',
+    ].join("\n");
+    // ── ③ 柯里化 ─────────────────────────────────────────────────────
+    const H_CURRY = [
+        'export const withExt = (ext: string) => (n: string): string => n + ext;',
+        'export const dropExt = (_ext: string) => (_n: string): string => "fixed.md";',
+        'export function curriedFn(ext: string) { return (n: string): string => n + ext; }',
+    ].join("\n");
+    // ── ④ namespace ──────────────────────────────────────────────────
+    const H_NS = [
+        'import * as fs from "fs";',
+        "export namespace P {",
+        "  export function toPath(n: string): string { return n + '.md'; }",
+        "  export function dropPath(_n: string): string { return 'fixed.md'; }",
+        "}",
+        "export namespace L {",
+        "  export function leakPath(n: string): string { fs.readFileSync(n); return 'x'; }",
+        "}",
+    ].join("\n");
+    // ── ⑤ rest 形参 ──────────────────────────────────────────────────
+    const H_REST = [
+        'export function joinAll(...parts: string[]): string { return parts.join("/"); }',
+        'export function fixedAll(..._parts: string[]): string { return "fixed.md"; }',
+    ].join("\n");
+    // ── ⑥ IIFE 定义 ──────────────────────────────────────────────────
+    const H_IIFE = [
+        'import * as fs from "fs";',
+        'export const toPathIife = (() => (n: string): string => n + ".md")();',
+        'export const dropIife = (() => (_n: string): string => "fixed.md")();',
+        'export const leakIife = (() => (n: string): string => { fs.readFileSync(n); return "x"; })();',
+    ].join("\n");
+    // ── ⑦ 计算属性名（只有 KEY 是模块级字面量常量才解得出来）────────────
+    const H_COMPUTED = [
+        'const KEY = "toPath";',
+        'const DROP = "toFile";',
+        "export const Box: any = { [KEY]: (n: string): string => n + '.md' };",
+        "export const DropBox: any = { [DROP]: (_n: string): string => 'fixed.md' };",
+    ].join("\n");
+    // 刻意**单独一个文件**：成员调用位 `.toPath(` 的匹配与宿主无关（C4g 的保守策略），
+    // 把它和上面那个可解的 Box 放进同一个文件，会被 Box 登记的成员名顺带命中 ——
+    // 那条期望就得改成 mark，测的也就不是「算不出」了（2026-09-21 实测踩到）。
+    const H_DYN = [
+        "const RANDOM = String(Math.random());",
+        "export const DynBox: any = { [RANDOM]: (n: string): string => n + '.md' };",
+    ].join("\n");
+    const cases = [
+        // ① 短路 —— 精度侧
+        { name: "正例·① ||左为假值 ⇒ 取右支", fn: "emit", files: emit('viaOr(k, "")', "", "viaOr", H_FOLD),
+            expectMark: true, why: "空串 falsy ⇒ 真的会走到含 n 的那支" },
+        { name: "负对照·① ||左为真值 ⇒ 取左支", fn: "emit", files: emit('viaOr(k, "fixed.md")', "", "viaOr", H_FOLD),
+            expectMark: false, why: "返回值就是左值常量；正对照 = 上一条" },
+        { name: "正例·① &&左为真值 ⇒ 取右支", fn: "emit", files: emit('viaAnd(k, "pre")', "", "viaAnd", H_FOLD),
+            expectMark: true, why: "truthy ⇒ 走到形参那支" },
+        { name: "负对照·① &&左为假值 ⇒ 取左支", fn: "emit", files: emit('viaAnd(k, "")', "", "viaAnd", H_FOLD),
+            expectMark: false, why: "短路在左值就结束了；正对照 = 上一条" },
+        { name: "负对照·① ??左非 null ⇒ 取左支", fn: "emit", files: emit('viaNull(k, "fixed.md")', "", "viaNull", H_FOLD),
+            expectMark: false, why: "?? 的判据是「非空」而不是「真」，两种语义不能混" },
+        { name: "正例·① ??左为 null ⇒ 取右支", fn: "emit", files: emit("viaNull(k, null)", "", "viaNull", H_FOLD),
+            expectMark: true, why: "与上一条镜像 ⇒ 归因确实落在 ?? 的判定上" },
+        { name: "保守侧·① 实参是变量 ⇒ 判不出就照标", fn: "emit", files: emit("viaOr(k, dyn)", "const dyn = Math.random() > 0;", "viaOr", H_FOLD),
+            expectMark: true, why: "认不出就不收精度 —— 这条守的是保守侧的底线" },
+        // ② 模板串 —— 精度侧
+        { name: "正例·② 模板串里走流出分支", fn: "emit", files: emit("viaTpl(k, false)", "", "viaTpl", H_FOLD),
+            expectMark: true, why: "f=false ⇒ ${} 里取 n" },
+        { name: "负对照·② 模板串里走常量分支", fn: "emit", files: emit("viaTpl(k, true)", "", "viaTpl", H_FOLD),
+            expectMark: false, why: "折叠必须能进 ${} 内部；正对照 = 上一条" },
+        { name: "保守侧·② 模板串的 flag 是变量", fn: "emit", files: emit("viaTpl(k, dyn)", "const dyn = Math.random() > 0;", "viaTpl", H_FOLD),
+            expectMark: true, why: "判不出 ⇒ 退回保守" },
+        // ③ 柯里化 —— 召回侧
+        { name: "正例·③ 柯里化·污点在第二跳", fn: "emit", files: emit('withExt(".md")(k)', "", "withExt", H_CURRY),
+            expectMark: true, why: "真正塑形的是被返回出来的内层函数" },
+        { name: "正例·③ 柯里化·污点在第一跳", fn: "emit", files: emit('withExt(k)("name")', "", "withExt", H_CURRY),
+            expectMark: true, why: "外层实参被闭包捕获，同样是流进去的" },
+        { name: "正例·③ 柯里化·函数声明写法", fn: "emit", files: emit('curriedFn(".md")(k)', "", "curriedFn", H_CURRY),
+            expectMark: true, why: "return 箭头不只出现在箭头 helper 上" },
+        { name: "负对照·③ 柯里化·内层丢弃形参", fn: "emit", files: emit('dropExt(".md")(k)', "", "dropExt", H_CURRY),
+            expectMark: false, why: "召回放宽到新载体，收窄要跟得上；正对照 = ③ 污点在第二跳" },
+        { name: "负对照·③ 柯里化·两边都是常量", fn: "emit", files: emit('withExt(".md")("fixed")', "", "withExt", H_CURRY),
+            expectMark: false, why: "根本没有污点进来" },
+        // ④ namespace —— 召回侧
+        { name: "正例·④ namespace 内的 helper", fn: "emit", files: emit("P.toPath(k)", "", "P", H_NS),
+            expectMark: true, why: "旧收集只走 sf.getFunctions() ⇒ namespace 里整片漏" },
+        { name: "负对照·④ namespace 内丢弃形参", fn: "emit", files: emit("P.dropPath(k)", "", "P", H_NS),
+            expectMark: false, why: "限定名也要走依赖分析；正对照 = 上一条" },
+        { name: "负对照·④ namespace 内有 sink", fn: "emit", files: emit("L.leakPath(k)", "", "L", H_NS),
+            expectMark: false, why: "判据③照旧生效 —— 载体换了不等于放水" },
+        // ⑤ rest —— 召回侧
+        { name: "正例·⑤ rest 形参吃掉剩余实参", fn: "emit", files: emit('joinAll("out", k)', "", "joinAll", H_REST),
+            expectMark: true, why: "rest 位是**一批**实参，按位截断会把第二位当成越界抹掉" },
+        { name: "负对照·⑤ rest 但丢弃", fn: "emit", files: emit('fixedAll("out", k)', "", "fixedAll", H_REST),
+            expectMark: false, why: "召回放宽后精度不许丢；正对照 = 上一条" },
+        // ⑥ IIFE —— 召回侧
+        { name: "正例·⑥ IIFE 定义 helper", fn: "emit", files: emit("toPathIife(k)", "", "toPathIife", H_IIFE),
+            expectMark: true, why: "初值是**调用**不是箭头 —— 真正的 helper 在返回值里" },
+        { name: "负对照·⑥ IIFE 内丢弃形参", fn: "emit", files: emit("dropIife(k)", "", "dropIife", H_IIFE),
+            expectMark: false, why: "收窄要跟得上；正对照 = 上一条" },
+        { name: "负对照·⑥ IIFE 体内有 sink", fn: "emit", files: emit("leakIife(k)", "", "leakIife", H_IIFE),
+            expectMark: false, why: "declText 取的是整条 IIFE ⇒ sink 检查仍覆盖得到" },
+        // ⑦ 计算属性名 —— 召回侧
+        { name: "正例·⑦ 计算属性名可解", fn: "emit", files: emit("Box.toPath(k)", "", "Box", H_COMPUTED),
+            expectMark: true, why: "KEY 是模块级字面量常量 ⇒ 名字解得出来" },
+        { name: "负对照·⑦ 计算属性名里的 helper 丢弃形参", fn: "emit", files: emit("DropBox.toFile(k)", "", "DropBox", H_COMPUTED),
+            expectMark: false, why: "收窄要跟得上；正对照 = 上一条" },
+        { name: "负对照·⑦ 属性名算不出来", fn: "emit", files: emit("DynBox.toPath(k)", "", "DynBox", H_DYN),
+            expectMark: false, why: "`String(Math.random())` 不是常量 ⇒ 不登记（认不出就不传播）" },
+    ];
+    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);
+    }
+});