progmune-runtime 3.7.43 → 3.7.46

package/dist/extract-ir.js

@@ -669,6 +669,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,15 +728,24 @@ 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;
     }
     return true;
 }
-/** 收集模块级（top-level）**字面量**常量名 —— helper 的 return 引用它们仍是纯塑形 */
-function moduleLiteralConstNames(project) {
-    const out = new Set();
+/**
+ * 收集模块级（top-level）**字面量**常量：名字 → 字面量文本（引号已脱）。
+ *
+ * 两个用途：
+ *   ① helper 的 return 引用它们仍是纯塑形（C4e）；
+ *   ② C4i：`{ [KEY]: (n) => … }` 这种计算属性名，只有 KEY 是字面量常量才解得
+ *      出来 —— 解不出一律不登记（与「看不见就不传播」同一条政策）。
+ */
+function moduleConstTexts(project) {
+    const out = new Map();
     for (const sf of project.getSourceFiles()) {
         for (const vd of sf.getVariableDeclarations()) {
             // 只要模块作用域：VariableStatement 的父节点必须是 SourceFile
@@ -739,7 +763,7 @@ function moduleLiteralConstNames(project) {
                 init.getKind() === ts.SyntaxKind.TrueKeyword ||
                 init.getKind() === ts.SyntaxKind.FalseKeyword;
             if (isLiteral)
-                out.add(vd.getName());
+                out.set(vd.getName(), init.getText().replace(/^["'`]|["'`]$/g, ""));
         }
     }
     return out;
@@ -788,12 +812,32 @@ function paramNamesOf(p) {
     }
     return out;
 }
+/**
+ * 属性名：普通标识符 / 字符串字面量直接取；**计算属性名** `[KEY]` 只有在 KEY 是
+ * 模块级字面量常量时才解（C4i）。解不出返回 null —— 认不出的一律不登记。
+ */
+function propertyNameOf(pa, constTexts) {
+    const nn = pa.getNameNode();
+    if (ts_morph_1.Node.isIdentifier(nn))
+        return nn.getText();
+    if (ts_morph_1.Node.isStringLiteral(nn) || ts_morph_1.Node.isNoSubstitutionTemplateLiteral(nn)) {
+        return nn.getText().replace(/^["'`]|["'`]$/g, "");
+    }
+    if (ts_morph_1.Node.isComputedPropertyName(nn)) {
+        const e = nn.getExpression();
+        // `const KEY = "toPath"; … { [KEY]: (n) => … }` —— KEY 的值必须看得见；
+        // `[key()]` 这种算不出来的，宁可整个不收（探针 K2 守的就是这条）。
+        if (ts_morph_1.Node.isIdentifier(e))
+            return constTexts.get(e.getText()) ?? null;
+    }
+    return null;
+}
 /**
  * 方法声明的宿主限定名：`const Util = { toPath(){} }` ⇒ "Util"、
  * `const Cfg = { inner: { toPath(){} } }` ⇒ "Cfg.inner"、`class Paths {…}` ⇒ "Paths"。
  * 取不出来就返回 null —— 认不出宿主的宁可不登记（保守侧）。
  */
-function ownerQualifier(md) {
+function ownerQualifier(md, constTexts = new Map()) {
     const parent = md.getParent();
     if (!parent)
         return null;
@@ -808,10 +852,9 @@ function ownerQualifier(md) {
         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, "");
+            const keyName = propertyNameOf(up, constTexts);
+            if (keyName === null)
+                return null;
             parts.unshift(keyName);
             cur = up.getParent();
             if (!cur)
@@ -826,6 +869,107 @@ function ownerQualifier(md) {
     }
     return null;
 }
+/**
+ * C4i：函数声明的命名空间限定名 —— `namespace P { export function toPath(){} }` ⇒ "P"
+ * （嵌套 namespace 拼成 "A.B"）。只认**纯 namespace 链**：函数套函数那种 helper
+ * 作用域与调用点不同，按同一名字发布会张冠李戴，一律返回 null 交给调用方跳过。
+ */
+function moduleQualifier(fn) {
+    const parts = [];
+    let cur = fn;
+    for (let guard = 0; guard < 6; guard++) {
+        const up = cur.getParent();
+        if (!up)
+            return null;
+        // 注意（实测）：`namespace P { export function f(){} }` 里函数的父节点是
+        // **ModuleBlock**（namespace 的体），ModuleDeclaration 在它的上一层。
+        if (ts_morph_1.Node.isModuleBlock(up)) {
+            const decl = up.getParent();
+            if (!decl || !ts_morph_1.Node.isModuleDeclaration(decl))
+                return null;
+            const n = decl.getName();
+            if (!n)
+                return null;
+            parts.unshift(n);
+            cur = decl;
+            continue;
+        }
+        if (ts_morph_1.Node.isModuleDeclaration(up)) {
+            const n = up.getName();
+            if (!n)
+                return null;
+            parts.unshift(n);
+            cur = up;
+            continue;
+        }
+        if (ts_morph_1.Node.isSourceFile(up))
+            return parts.length > 0 ? parts.join(".") : null;
+        return null; // 函数体内的嵌套声明：作用域不同，不收
+    }
+    return null;
+}
+/**
+ * 剥掉包在**函数体外面的**那几层壳，露出真正的箭头 / 函数表达式：
+ * 括号 `((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;
+    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;
+}
+/**
+ * C4i：变量初值承载的 helper 体。除箭头 / 函数表达式外，再解一层 IIFE ——
+ * `const toPath = (() => (n) => n + ".md")();` 的初值是**调用**不是箭头，
+ * 真正的 helper 是被 IIFE 返回出来的那个内层箭头（旧代码整条族漏）。
+ */
+function functionLikeOf(init) {
+    // 实测：`(() => (n) => n + ".md")()` 里被括号包住的**不止**内层箭头 ——
+    // 连被调用的 callee 都是 ParenthesizedExpression。两处都得脱。
+    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 = 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 = 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 = unwrapFns(rs.getExpression());
+            if (e && (ts_morph_1.Node.isArrowFunction(e) || ts_morph_1.Node.isFunctionExpression(e)))
+                return e;
+        }
+    }
+    return null;
+}
 /** 按顶层逗号切分实参串（跳过字符串与已配平的括号，后者由调用方保证不含嵌套） */
 function splitTopLevelArgs(argText) {
     const out = [];
@@ -860,6 +1004,223 @@ function splitTopLevelArgs(argText) {
         out.push(cur);
     return out;
 }
+/**
+ * C4i：形参表里 rest 形参（`...parts`）的位置；没有返回 -1。
+ * rest 形参对应的是【一批】实参，不是一位 —— 位置对齐必须让它吃掉末尾所有位。
+ */
+function restIndexOf(ps) {
+    return ps.findIndex((p) => p.isRestParameter());
+}
+/** 实参位 ⇒ 形参位（rest 形参吃掉从它开始的剩余位） */
+function paramIndexOf(si, argIndex) {
+    return si.restAt >= 0 && argIndex >= si.restAt ? si.restAt : argIndex;
+}
+/**
+ * C4i/C4j：柯里化 helper —— 函数体【返回】另一个函数
+ * （`(ext) => (n) => n + ext`、`(a) => (b) => (n) => n + a + b`）。
+ * 被调用的不是最外层，而是它一路返回出来的最内层；真正塑形在那里，
+ * 外层只负责捕获自己那一批实参。返回的不是函数（含返回对象字面量的工厂形态）
+ * 一律返回 null，交给 currySpecsOf 的另一条路。
+ */
+function curryChainOf(outerParams, body) {
+    const ret = returnedValueOf(body);
+    if (!ret)
+        return null;
+    if (!ts_morph_1.Node.isArrowFunction(ret) && !ts_morph_1.Node.isFunctionExpression(ret))
+        return null;
+    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 = 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 = unwrapFns(rs.getExpression());
+        if (e && (ts_morph_1.Node.isArrowFunction(e) || ts_morph_1.Node.isFunctionExpression(e)))
+            return e;
+    }
+    return null;
+}
+/**
+ * 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 < 4; round++) {
+        const next = expandCurriedOnce(cur, curried);
+        if (next === null)
+            break;
+        cur = next;
+    }
+    return cur;
+}
+/** 摊开**一处**柯里化 / 工厂形态调用；没有可摊的返回 null（供调用方收敛） */
+function expandCurriedOnce(text, curried) {
+    for (const [name, specs] of curried) {
+        const re = new RegExp(`(?:^|[^\\w$.])${escapeRe(name)}\\s*\\(`, "g");
+        let m;
+        while ((m = re.exec(text)) !== null) {
+            const open1 = m.index + m[0].length - 1;
+            const close1 = matchingParen(text, open1);
+            if (close1 < 0)
+                continue;
+            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;
+}
 /**
  * C4f：把 helper 调用里【返回值不依赖的那些实参】抹掉。
  *
@@ -916,7 +1277,13 @@ function maskNonDependentArgsOnce(text, info, memberNames) {
             if (/[([{]/.test(argText))
                 continue; // 还嵌着别的调用 —— 下一轮再处理
             const args = splitTopLevelArgs(argText);
-            const kept = args.filter((_, i) => si.params[i] !== undefined && si.deps.has(si.params[i]));
+            // C4h-①：按【本次调用】重算一下哪些位置会流出去 —— 名录里的 deps 是对所有
+            // 实参形状都成立的最宽结论，本次若喂了常量，可能一个都流不出来。
+            const flags = callSiteKeepFlags(si, args, info, memberNames);
+            const kept = args.filter((_, i) => {
+                const pi = paramIndexOf(si, i); // C4i：rest 形参吃掉剩余位
+                return si.params[pi] !== undefined && flags[pi] === true;
+            });
             if (kept.length === args.length)
                 continue; // 每个形参都被依赖 ⇒ 无需抹
             const replacement = kept.length > 0 ? `(${kept.join(" + ")})` : `""`;
@@ -926,7 +1293,431 @@ function maskNonDependentArgsOnce(text, info, memberNames) {
     return null;
 }
 /**
- * return 表达式真正依赖哪些形参：把「已知 helper 调用里不被依赖的实参」抹掉后，
+ * C4h-①（2026-09-20）：调用点专用的「哪些实参会流到返回值里」。
+ *
+ * 名录里的 deps 是**跨调用点**的并集 —— 对所有实参形状都成立的最宽结论。
+ * 但本次调用喂的可能是常量：
+ *
+ *   viaFlag(n, flag) { return flag ? "fixed.md" : n + ".md"; }
+ *   viaFlag(k, true)  ⇒ 返回值就是字面量 —— n 位虽然进了函数也出不来。
+ *
+ * 于是按位置把**字面量实参**代进 return 表达式，试着解掉 cond 可判定的三元，
+ * 再看还有哪些形参活着。两种情形一律退回名录的 deps（保守侧，宁可不收精度）：
+ *   - 实参一个常量都没有；
+ *   - cond 代入后判不出真假 —— 认不出就不收精度。
+ */
+function callSiteKeepFlags(si, args, info, memberNames) {
+    const fallback = si.params.map((p) => si.deps.has(p));
+    if (si.rets.length === 0)
+        return fallback;
+    const litArgs = new Map();
+    args.forEach((a, i) => {
+        // C4i：rest 形参拿到的是【一批】实参，不等于任意一个 —— 不代，否则
+        // `parts.join("/")` 会被代成 `"out".join("/"` 从而误判「不依赖 parts」
+        if (si.restAt >= 0 && i >= si.restAt)
+            return;
+        const p = si.params[i];
+        if (p === undefined)
+            return;
+        const t = stripOuterParens(a.trim());
+        // 只代【字面量】—— 变量名进来不等于知道它的值
+        if (litKind(t) !== null)
+            litArgs.set(p, t);
+    });
+    if (litArgs.size === 0)
+        return fallback;
+    const subbed = si.rets.map((r) => foldDecidableTernary(substituteParams(r, litArgs)));
+    const remaining = si.params.filter((p) => p !== undefined && !litArgs.has(p));
+    // 嵌套 helper 的支路仍由 returnDeps 负责抹
+    const deps = returnDeps(subbed, remaining, info, memberNames);
+    return si.params.map((p) => deps.has(p));
+}
+/** 把形参名替换成实参文本（跳字符串与模板字面量内部 —— 判不出就保守地留着形参） */
+function substituteParams(expr, litArgs) {
+    let out = "";
+    let quote = "";
+    let i = 0;
+    while (i < expr.length) {
+        const ch = expr[i];
+        if (quote) {
+            out += ch;
+            if (ch === "\\") {
+                out += expr[i + 1] ?? "";
+                i += 2;
+                continue;
+            }
+            if (ch === quote)
+                quote = "";
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            out += ch;
+            i++;
+            continue;
+        }
+        // C4i：模板串不能像普通字符串那样整段跳过 —— `${flag ? "fixed" : n}` 里的
+        // flag 是要代的。字面量部分照抄，只对 `${}` 内部递归代入。
+        if (ch === "`") {
+            out += ch;
+            i++;
+            while (i < expr.length) {
+                const c = expr[i];
+                if (c === "`")
+                    break; // 模板串内不可能有裸反引号（转义的已被下面处理）
+                if (c === "\\") {
+                    out += expr.slice(i, i + 2);
+                    i += 2;
+                    continue;
+                }
+                if (c === "$" && expr[i + 1] === "{") {
+                    let k = i + 2;
+                    let brace = 0;
+                    let inner = "";
+                    while (k < expr.length) {
+                        const d = expr[k];
+                        if (d === "{")
+                            brace++;
+                        else if (d === "}") {
+                            if (brace === 0)
+                                break;
+                            brace--;
+                        }
+                        inner += d;
+                        k++;
+                    }
+                    out += "${" + substituteParams(inner, litArgs) + "}";
+                    i = k + 1;
+                    continue;
+                }
+                out += c;
+                i++;
+            }
+            if (i < expr.length && expr[i] === "`") {
+                out += "`";
+                i++;
+            }
+            continue;
+        }
+        const m = /^[A-Za-z_$][\w$]*/.exec(expr.slice(i));
+        if (m && expr[i - 1] !== "." && litArgs.has(m[0])) {
+            // 不加括号：代进去的永远是【原子字面量】（字符串/数字/布尔/null），
+            // 不会改变优先级；而加括号会让 maskNonDependentArgsOnce 把参数串误判成嵌套
+            // 调用（它的判据是「实参里还有 `(`」），内层就再也轮不到它来处理。
+            out += litArgs.get(m[0]);
+            i += m[0].length;
+            continue;
+        }
+        out += ch;
+        i++;
+    }
+    return out;
+}
+/**
+ * 递归解掉 cond 可判定的三元 / 短路；判不出就保持原样（保守侧）。
+ *
+ * C4i（2026-09-21）补两类：
+ *   - 模板串内部的 `${...}` 是独立表达式，折叠必须能进去 —— 否则
+ *     `` `${flag ? "fixed" : n}.md` `` 这种写法（现代代码里比裸三元更常见）
+ *     永远收不住；
+ *   - 短路运算符 `||` / `&&` / `??`：与三元同形，只是判据从 cond 换成了
+ *     左操作数的真假。JS 求值是从左到右，短路一发生右边整段根本不执行。
+ */
+function foldDecidableTernary(expr, depth = 0) {
+    if (depth > 4)
+        return expr;
+    // 先脱掉包住整串的括号 —— 不脱的话 `(()flag ? a : b)` 这种写法切出来的 cond
+    // 是 `((true)`，括号不配对 ⇒ 判不出真假 ⇒ 白白丢掉一次收精度的机会
+    // （2026-09-20 探针：viaFlag(k, true) 一直没收住，根因就是这个）。
+    const s = stripOuterParens(expr);
+    // ① 模板串：先处理 `${}` 内部（外面那层字面量部分不参与判定）
+    const tpl = foldTemplateSubsts(s, depth);
+    if (tpl !== s)
+        return tpl;
+    // ② 三元
+    const t = topLevelTernary(s);
+    if (t) {
+        const v = truthOf(t.cond);
+        if (v !== null)
+            return foldDecidableTernary(v ? t.a : t.b, depth + 1);
+    }
+    // ③ 短路
+    const lg = topLevelLogical(s);
+    if (lg) {
+        const v = lg.op === "??" ? notNullish(lg.left) : truthOf(lg.left);
+        if (v !== null) {
+            // `||` 左为真 ⇒ 取左；`&&` 左为真 ⇒ 取右；`??` 左非空 ⇒ 取左
+            const takeLeft = lg.op === "&&" ? !v : v;
+            return foldDecidableTernary(takeLeft ? lg.left : lg.right, depth + 1);
+        }
+    }
+    return expr === s ? expr : s;
+}
+/**
+ * 折叠模板串里每个 `${...}` 的内部；没有任何一处可折叠就**原样返回**（让调用方
+ * 知道这一层没做事，好继续试三元/短路）。
+ */
+function foldTemplateSubsts(expr, depth) {
+    if (!expr.includes("`"))
+        return expr;
+    let out = "";
+    let changed = false;
+    let i = 0;
+    while (i < expr.length) {
+        const ch = expr[i];
+        if (ch !== "`") {
+            out += ch;
+            i++;
+            continue;
+        }
+        let seg = "";
+        let j = i + 1;
+        while (j < expr.length) {
+            const c = expr[j];
+            if (c === "\\") {
+                seg += expr.slice(j, j + 2);
+                j += 2;
+                continue;
+            }
+            if (c === "`")
+                break;
+            if (c === "$" && expr[j + 1] === "{") {
+                // 找与 `${` 配对的 `}`（`${ {a:1}.a }` 里的花括号要跳过）
+                let brace = 0;
+                let k = j + 2;
+                let inner = "";
+                while (k < expr.length) {
+                    const d = expr[k];
+                    if (d === "{")
+                        brace++;
+                    else if (d === "}") {
+                        if (brace === 0)
+                            break;
+                        brace--;
+                    }
+                    inner += d;
+                    k++;
+                }
+                const folded = foldDecidableTernary(inner, depth + 1);
+                if (folded !== inner)
+                    changed = true;
+                seg += "${" + folded + "}";
+                j = k + 1;
+                continue;
+            }
+            seg += c;
+            j++;
+        }
+        out += "`" + seg + "`";
+        i = j + 1;
+    }
+    return changed ? out : expr;
+}
+/**
+ * 顶层短路运算符：**最左边**的一个。优先级从低到高依次找 `||` → `??` → `&&`
+ * （TS 里 `??` 与 `||`/`&&` 同级混用必须加括号，加了括号就不是顶层了）。
+ * 只认左右都非空的那一个。
+ */
+function topLevelLogical(expr) {
+    for (const op of ["||", "??", "&&"]) {
+        let paren = 0;
+        let quote = "";
+        let i = 0;
+        while (i < expr.length) {
+            const ch = expr[i];
+            if (quote) {
+                if (ch === "\\")
+                    i++;
+                else if (ch === quote)
+                    quote = "";
+                i++;
+                continue;
+            }
+            if (ch === '"' || ch === "'" || ch === "`") {
+                quote = ch;
+                i++;
+                continue;
+            }
+            if (ch === "(" || ch === "[" || ch === "{")
+                paren++;
+            else if (ch === ")" || ch === "]" || ch === "}")
+                paren--;
+            else if (paren === 0 && expr.startsWith(op, i)) {
+                // `??`/`||`/`&&` 各占两字符，注意别把 `a ||= b` 这类当短路（赋值语义不同）
+                if (expr[i + 2] === "=") {
+                    i += 3;
+                    continue;
+                }
+                const left = expr.slice(0, i).trim();
+                const right = expr.slice(i + 2).trim();
+                if (left !== "" && right !== "")
+                    return { left, right, op };
+            }
+            i++;
+        }
+    }
+    return null;
+}
+/** 左操作数**确定不是** null/undefined 时返回 true；判不出返回 null */
+function notNullish(s) {
+    const lit = litOf(s);
+    if (!lit)
+        return null;
+    return lit.k !== "null";
+}
+/**
+ * 顶层三元的三段。要点是"顶层"：`a ? b ? c : d : e` 里第一个顶层 `:` 属于内层
+ * 三元，不能拿来切 —— 否则会把 b 误当成整个真值分支。
+ */
+function topLevelTernary(expr) {
+    let paren = 0;
+    let qDepth = 0;
+    let qPos = -1;
+    let cPos = -1;
+    let quote = "";
+    let i = 0;
+    while (i < expr.length) {
+        const ch = expr[i];
+        if (quote) {
+            if (ch === "\\")
+                i++;
+            else if (ch === quote)
+                quote = "";
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            quote = ch;
+            i++;
+            continue;
+        }
+        if (ch === "(" || ch === "[" || ch === "{")
+            paren++;
+        else if (ch === ")" || ch === "]" || ch === "}")
+            paren--;
+        else if (paren === 0) {
+            if (ch === "?") {
+                if (qDepth === 0)
+                    qPos = i;
+                qDepth++;
+            }
+            else if (ch === ":" && qDepth > 0) {
+                if (qDepth === 1) {
+                    cPos = i;
+                    break;
+                }
+                qDepth--;
+            }
+        }
+        i++;
+    }
+    if (qPos < 0 || cPos < 0)
+        return null;
+    return { cond: expr.slice(0, qPos), a: expr.slice(qPos + 1, cPos), b: expr.slice(cPos + 1) };
+}
+/**
+ * 脱掉**包住整串**的括号（`(x)` ⇒ `x`，可能多层）。只脱真的配到串尾的那种 ——
+ * `(a) + (b)` 的首个括号不到底，不会被误脱。
+ */
+function stripOuterParens(expr) {
+    let cur = expr.trim();
+    for (let guard = 0; guard < 8; guard++) {
+        if (!cur.startsWith("("))
+            break;
+        const close = matchingParen(cur, 0);
+        if (close !== cur.length - 1)
+            break;
+        const inner = cur.slice(1, -1).trim();
+        if (inner === "")
+            break;
+        cur = inner;
+    }
+    return cur;
+}
+/** 判得出来就返回 true/false，判不出返回 null */
+function truthOf(cond) {
+    const s = stripOuterParens(cond);
+    if (/^!\s*\S/.test(s)) {
+        const v = truthOf(s.replace(/^!\s*/, ""));
+        return v === null ? null : !v;
+    }
+    const lit = litOf(s);
+    if (lit) {
+        if (lit.k === "bool")
+            return lit.v === "true";
+        if (lit.k === "null")
+            return false; // null / undefined
+        if (lit.k === "num")
+            return Number(lit.v) !== 0;
+        return lit.v.length > 0; // 字符串
+    }
+    const eq = /^(.+?)\s*(===|!==)\s*(.+)$/.exec(s);
+    if (eq) {
+        const l = litOf(eq[1]);
+        const r = litOf(eq[3]);
+        // 两边都是字面量但类型不同（`"1" === 1`）—— JS 语义下也是 false/true，可判
+        if (l && r) {
+            const same = l.k === r.k && l.v === r.v;
+            return eq[2] === "===" ? same : !same;
+        }
+    }
+    return null;
+}
+/** 字面量种类：字符串 / 数字 / 布尔 / null-undefined；不是字面量返回 null */
+function litOf(s) {
+    const clean = stripOuterParens(s.trim()); // 代入时实参被套了括号：`(true) === true`
+    return litKind(clean);
+}
+function litKind(s) {
+    if (/^"(?:\\.|[^"\\])*"$/.test(s) || /^'(?:\\.|[^'\\])*'$/.test(s) || /^`(?:\\.|[^`\\])*`$/.test(s)) {
+        return { k: "str", v: s.slice(1, -1) };
+    }
+    if (/^-?\d+(?:\.\d+)?$/.test(s))
+        return { k: "num", v: s };
+    if (s === "true" || s === "false")
+        return { k: "bool", v: s };
+    if (s === "null" || s === "undefined")
+        return { k: "null", v: s };
+    return null;
+}
+/** s[open] 是开括号时，返回与之配对的闭括号下标；不配对返回 -1 */
+function matchingParen(s, open) {
+    let depth = 0;
+    for (let i = open; i < s.length; i++) {
+        if (s[i] === "(")
+            depth++;
+        else if (s[i] === ")") {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+/**
+ * 同名多处的依赖集合并：按**形参位**取并集（OR）—— 任何一个实现在某个位置
+ * 会流出污点，那个位置就得当成会流出（合并到保守侧）。
+ * 形参表不一致时不合并 return 表达式（`rets=[]` ⇒ 调用点折叠自动退回，
+ * 只按并集传播），因为把 A 的形参名代进 B 的 return 是错的。
+ */
+function mergeShapers(infos) {
+    if (infos.length === 0)
+        return { params: [], deps: new Set(), rets: [], restAt: -1 };
+    const widest = infos.reduce((a, b) => (b.params.length > a.params.length ? b : a));
+    const params = widest.params;
+    const flags = params.map(() => false);
+    let sameShape = true;
+    for (const si of infos) {
+        if (si.params.length !== params.length || si.params.some((p, i) => p !== params[i]))
+            sameShape = false;
+        si.params.forEach((p, i) => { if (i < flags.length && si.deps.has(p))
+            flags[i] = true; });
+    }
+    const rets = sameShape ? infos.flatMap((si) => si.rets) : [];
+    return { params, deps: new Set(params.filter((_, i) => flags[i])), rets, restAt: widest.restAt };
+}
+/** return 表达式真正依赖哪些形参：把「已知 helper 调用里不被依赖的实参」抹掉后，
  * 剩下的形参名就是会流进返回值的那些。`wrap(n) { return discard(n); }` ⇒ 空集。
  */
 function returnDeps(exprs, params, info, memberNames = new Set()) {
@@ -952,130 +1743,342 @@ 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();
     const cands = [];
+    const takenNames = new Set();
+    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 = (name, paramNodes, declText, bodyNode) => {
+    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);
-        if (rets.length === 0)
-            return; // ①
-        if (cands.some((c) => c.name === name))
-            return; // 同名重复登记：先到先得
-        cands.push({ name, params, paramList, rets });
+        // 柯里化 / 工厂形态：return 出来的是函数或装着函数的对象 ⇒ 判据①看的是最内层
+        if (rets.length === 0 && curry.length === 0)
+            return noteUnaccepted(key, group); // ③
+        let pub = name;
+        if (pub !== null) {
+            if (takenNames.has(pub))
+                pub = null; // 同名重复登记：先到先得，后者降到资格凭证
+            else
+                takenNames.add(pub);
+        }
+        cands.push({ key, name: pub, group, params, paramList, rets, restAt, curry });
+        if (group !== null) {
+            const list = groups.get(group) ?? [];
+            list.push(key);
+            groups.set(group, list);
+        }
     };
     for (const sf of project.getSourceFiles()) {
-        // (a) 函数声明
-        for (const fn of sf.getFunctions()) {
+        // (a) 函数声明 —— 顶层 + namespace 内
+        //     C4i：旧代码用 sf.getFunctions()，实测取不到 `namespace P { export
+        //     function toPath(){} }` 里的函数，整片漏（探针 F1）。改遍历声明节点，
+        //     但**只收顶层 / namespace 链上的**：函数体内嵌套声明的作用域与调用点
+        //     不同，按同一裸名发布会张冠李戴。
+        for (const fn of sf.getDescendantsOfKind(ts.SyntaxKind.FunctionDeclaration)) {
+            const parent = fn.getParent();
+            // 顶层 / namespace 体内两种；函数体内嵌套的声明作用域与调用点不同，不收
+            if (!ts_morph_1.Node.isSourceFile(parent) && !ts_morph_1.Node.isModuleBlock(parent))
+                continue;
             const name = fn.getName();
             if (!name)
                 continue;
             const body = fn.getBody();
             if (!body)
                 continue; // 重载签名 / declare 只有签名
-            consider(name, fn.getParameters().flatMap(paramNamesOf), fn.getText(), body);
+            const ps = fn.getParameters();
+            const paramNodes = ps.flatMap(paramNamesOf);
+            const restAt = restIndexOf(ps);
+            const curry = currySpecsOf(paramNodes, body);
+            const owner = moduleQualifier(fn);
+            // namespace 内却认不出宿主链 ⇒ 不收（宁可漏，不可张冠李戴）
+            if (!ts_morph_1.Node.isSourceFile(parent) && owner === null)
+                continue;
+            // namespace 内：`P.toPath(k)` 是主要写法。裸名同时登记是安全的 ——
+            // takenNames 先到先得，一个名字只会落到一处定义上（另一处会降级为资格凭证）。
+            if (owner !== null) {
+                consider(`fn:${owner}.${name}`, `${owner}.${name}`, null, paramNodes, restAt, curry, fn.getText(), body);
+            }
+            consider(`fn:${name}`, name, null, paramNodes, restAt, curry, fn.getText(), body);
         }
         // (b) 变量承载的箭头 / 函数表达式 —— 现代 TS 里 helper 的主力写法
         //     `export const toPath = (n: string) => n + ".md";`
         //     sf.getFunctions() 收不到这些，2026-09-20 实测整片漏。
+        //     C4i 再解一层 IIFE（functionLikeOf）。
         for (const vd of sf.getVariableDeclarations()) {
             const init = vd.getInitializer();
             if (!init)
                 continue;
-            const isArrow = ts_morph_1.Node.isArrowFunction(init);
-            const isFnExpr = ts_morph_1.Node.isFunctionExpression(init);
-            if (!isArrow && !isFnExpr)
+            const fnLike = functionLikeOf(init);
+            if (!fnLike)
                 continue;
-            const fnLike = init;
             const body = fnLike.getBody();
             if (!body)
                 continue;
-            consider(vd.getName(), fnLike.getParameters().flatMap(paramNamesOf), init.getText(), body);
+            const ps = fnLike.getParameters();
+            const paramNodes = ps.flatMap(paramNamesOf);
+            consider(`var:${vd.getName()}`, vd.getName(), null, paramNodes, restIndexOf(ps), currySpecsOf(paramNodes, body), init.getText(), // IIFE 时含整条调用 ⇒ sink 检查仍覆盖得到
+            body);
         }
     }
-    // (c) 对象字面量方法 / 类方法 —— C4g。
-    //     `const Util = { toPath(n) {…} }`、`class Paths { toPath(n) {…} }` 都不在
-    //     getFunctions() 里，C4e 时刻意没做：按裸名放行会让别的对象上的同名方法被
-    //     误认成塑形（R11）。这里只登记**限定名** Owner.method；只有当该方法名在全
-    //     项目唯一（不存在同名方法）时，才额外允许 `.method(` 这种不写宿主名的
-    //     成员调用 —— 实例方法的主要写法正是这个。
-    const methodCands = [];
+    // ── 成员形态的 helper（对象字面量方法 / 类方法 / 属性箭头 / 属性赋值箭头）──
+    //     `const Util = { toPath(n) {…} }`、`class Paths { toPath(n) {…} }`、
+    //     `const Util = { toPath: (n) => n + ".md" }`、`Util.toPath = (n) => …`
+    //     都不在 getFunctions() 里。C4e 时刻意不做的理由仍在（R11）：按裸名放行会
+    //     让别的对象上的同名条目被误认成塑形。所以这里只登记**限定名** Owner.method；
+    //     裸名（`.method(` 这种成员调用位）留给下面的 C4h-②，按「同名每一处都被
+    //     确证」这条不变量统一放行。
+    let memberSeq = 0;
+    /** 登记一个成员形态的函数体；owner 认得出时按限定名发布 */
+    const considerMember = (bare, owner, paramNodes, restAt, curry, declText, body) => {
+        memberSeq += 1;
+        consider(`mb:${memberSeq}`, owner !== null ? `${owner}.${bare}` : null, bare, paramNodes, restAt, curry, declText, body);
+    };
     for (const sf of project.getSourceFiles()) {
+        // (c) 对象字面量方法 / 类方法
         for (const md of sf.getDescendantsOfKind(ts.SyntaxKind.MethodDeclaration)) {
-            const bare = md.getName();
-            if (!bare)
-                continue;
+            const bare = propertyNameOf(md, constTexts);
+            if (!bare || !/^[A-Za-z_$][\w$]*$/.test(bare))
+                continue; // 算不出的属性名 ⇒ 不收
             const body = md.getBody();
             if (!body)
                 continue; // 重载签名 / declare
-            const owner = ownerQualifier(md);
-            methodCands.push({ qualified: owner ? `${owner}.${bare}` : null, bare, md });
+            const ps = md.getParameters();
+            const pns = ps.flatMap(paramNamesOf);
+            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 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 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 = fn.getParameters();
+            const pns = ps.flatMap(paramNamesOf);
+            considerMember(bare, ownerQualifier(pa, constTexts), pns, restIndexOf(ps), currySpecsOf(pns, body), rawInit.getText(), body);
         }
-    }
-    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);
+        // (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 = unwrapFns(be.getRight());
+            if (!ts_morph_1.Node.isPropertyAccessExpression(left))
+                continue;
+            if (!right || (!ts_morph_1.Node.isArrowFunction(right) && !ts_morph_1.Node.isFunctionExpression(right)))
+                continue;
+            const body = right.getBody();
+            if (!body)
+                continue;
+            const qname = left.getText();
+            // 只收 `Name.member` 这种纯静态链（`this.x` / `a[b].x` 一律不认）
+            if (!/^[A-Za-z_$][\w$]*(?:\.[\w$]+)+$/.test(qname))
+                continue;
+            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), 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);
+            }
         }
-        if (m.qualified)
-            consider(m.qualified, params, text, body);
     }
     // 形参之外允许出现的自由标识符 = 模块级字面量常量 ∪ 确证的 path 模块别名
-    const extraIdents = moduleLiteralConstNames(project);
+    const extraIdents = new Set(constTexts.keys());
     for (const a of pathModuleAliases(project))
         extraIdents.add(a);
     const names = new Set();
     const info = new Map();
+    const acceptedKeys = new Set();
+    const keyInfo = new Map();
+    // 给 maskNonDependentArgsOnce 用的成员名候选（**尚未确证**）。这里宽一点是安全
+    // 的：那里的替换只会针对 info 里确证过的名字发生，这个集合只决定「按成员位还是
+    // 按裸名位去匹配」。
+    const prelimMember = new Set(groups.keys());
+    const publish = (name, si) => {
+        if (names.has(name))
+            return;
+        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 (names.has(c.name))
-                continue;
-            const ok = c.rets.every((e) => isPureShaperExpr(e, c.params, names, extraIdents));
-            if (!ok)
+            if (acceptedKeys.has(c.key))
                 continue;
-            names.add(c.name);
-            info.set(c.name, {
-                params: c.paramList,
-                deps: returnDeps(c.rets, c.paramList, info, memberNames),
-            });
+            let si;
+            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 };
+            }
+            else {
+                if (!c.rets.every((e) => isPureShaperExpr(e, c.params, names, extraIdents)))
+                    continue;
+                acceptedKeys.add(c.key);
+                si = {
+                    params: c.paramList,
+                    deps: returnDeps(c.rets, c.paramList, info, prelimMember),
+                    rets: c.rets,
+                    restAt: c.restAt,
+                };
+            }
+            keyInfo.set(c.key, si);
+            if (c.name !== null)
+                publish(c.name, si);
             added = true;
         }
         if (!added)
             break;
     }
+    // C4i/C4j：柯里化与工厂名录。只有**发布了名字**的才登记 —— 名字被别处同名定义占用时
+    // （pub 降为 null），`withExt(a)(b)` 里的 withExt 可能指的不是这个 helper，
+    // 展开它会张冠李戴 ⇒ 宁可不展（保守侧，退化为漏报而非误报）。
+    // 一个名字可以对多条链（工厂返回含多个方法的对象）。
+    const curried = new Map();
+    for (const c of cands) {
+        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 偏宽（偏宽 = 继续传播 = 保守侧，
     // 不会误报，但收不紧）。名录定稿后按完整的 info 再算两轮，把次序依赖消掉。
-    const byName = new Map(cands.map((c) => [c.name, c]));
+    const candByKey = new Map(cands.map((c) => [c.key, c]));
     for (let round = 0; round < 2; round++) {
         let changed = false;
-        for (const [name, si] of info) {
-            const c = byName.get(name);
+        for (const [key, si] of keyInfo) {
+            const c = candByKey.get(key);
             if (!c)
                 continue;
-            const d = returnDeps(c.rets, si.params, info, memberNames);
+            const d = returnDeps(c.rets, si.params, info, prelimMember);
             if (d.size !== si.deps.size || [...d].some((x) => !si.deps.has(x))) {
                 si.deps = d;
                 changed = true;
@@ -1084,7 +2087,26 @@ function pureShaperFunctionNames(project) {
         if (!changed)
             break;
     }
-    return { names, memberNames, info };
+    // ── C4h-②（2026-09-20）：同名【成员】多处，只要**每一处**都被确证为纯塑形 ──
+    // 旧规则（C4g）是「该方法名全项目唯一才登记裸名」。唯一性只是【不可能认错】这个
+    // 不变量的一个充分条件，不是必要条件：同名两处都被确证了，`.toPath(` 这个成员
+    // 调用位同样不可能落到别的实现上。把"唯一"换成"全部确证"，两个类各有一个同名
+    //  helper 时两边都能接上；依赖集按形参位取并集（保守侧）。
+    //
+    // 顺带修掉一处真实缺陷：旧代码在 consider() 之后【无条件】把裸名塞进
+    // memberNames，于是「方法名唯一但三条判据不成立」的方法，其成员调用位照样被
+    // 当成塑形 ⇒ 误标。探针实测（2026-09-20）：
+    //   `class Reg { lookup(n) { return registry[n]; } }`（registry 是模块级非字面量
+    //   对象 ⇒ 判据③不成立）之后写 `r.lookup(k)`，照样MARKED。
+    // 现在改成确证之后才登记，这个口子自然封上。
+    const memberNames = new Set();
+    for (const [bare, keys] of groups) {
+        if (!keys.every((k) => acceptedKeys.has(k)))
+            continue;
+        memberNames.add(bare);
+        publish(bare, mergeShapers(keys.map((k) => keyInfo.get(k)).filter(Boolean)));
+    }
+    return { names, memberNames, info, curried };
 }
 const TS_FILE_SINK_NAMES = [
     "readFile", "readFileSync", "writeFile", "writeFileSync",
@@ -1336,14 +2358,19 @@ function taintedViaShaper(text, tainted, shapers) {
             const rhs = m[2];
             if (tainted.has(name))
                 continue;
-            const shaped = TS_PATH_SHAPER_RE.test(rhs) ||
-                TS_CONCAT_RE.test(rhs) ||
+            // C4i：柯里化调用先在证据里摊开 —— `withExt(".md")(k)` ⇒ `k + ".md"`，
+            // 摊开后的串自己就是拼接，shaped 也顺理成章成立。
+            const expanded = shapers ? expandCurried(rhs, shapers.curried) : rhs;
+            const shaped = TS_PATH_SHAPER_RE.test(expanded) ||
+                TS_CONCAT_RE.test(expanded) ||
                 (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;
+            const evidence = shaperInfo && memberNames
+                ? maskNonDependentArgs(expanded, shaperInfo, memberNames)
+                : expanded;
             if (taintRe.test(evidence) && shaped) {
                 tainted.add(name);
                 added = true;