@nudojs/service 0.3.0 → 0.3.2

package/src/analyzer.ts

@@ -1,3133 +0,0 @@
-import { readFileSync, existsSync, statSync, realpathSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import type { Node } from "@babel/types";
-import traverse from "@babel/traverse";
-import {
-  type TypeValue,
-  T,
-  typeValueToString,
-  simplifyUnion,
-  widenLiteral,
-  collapseLiteralUnion,
-  createEnvironment,
-  isSubtypeOf,
-  type Environment,
-  mockHelperToTypeValue,
-  getFnSig,
-  generalizeFromAst,
-  termToString,
-  predToString,
-  analyzeFn,
-  evalProgramAbs,
-  setAbsCallCollector,
-  setAbsNodeCollector,
-  absFunction,
-  type AbsCallRecord,
-  collectAbsNodeTypes,
-  findAbsAtPosition,
-  typeValueToAbs,
-  absToTypeValue,
-  formatAbs,
-  formatAbsMultiline,
-  type Abs,
-  stableAnalyzeKeySource,
-  fnFingerprints,
-} from "@nudojs/core";
-import { parse, extractDirectives, extractFileDirectives, parseTypeValueExpr } from "@nudojs/parser";
-import type { FunctionWithDirectives, SinonExpression } from "@nudojs/parser";
-import {
-  evaluate,
-  evaluateFunction,
-  evaluateFunctionFull,
-  memberMayExistOn,
-  setUsageSiteTag,
-  USAGE_SITE_MODULE,
-  evaluateProgram,
-  setModuleResolver,
-  setCurrentFileDir,
-  resetMemo,
-  getUnreachableRanges,
-  resetUnreachableRanges,
-  setNodeTypeCollector,
-  setCallCollector,
-  type CallRecord,
-  setUnknownCollector,
-  setProvenanceTracking,
-  type UnknownRecord,
-  setSampleCount,
-  setUnknownBuiltinHandler,
-  setEnvModules,
-  resetEnvModules,
-  setMockModules,
-  resetMockModules,
-  setCurrentSource,
-  loadEnvs,
-  preloadPathEnvs,
-  findProjectConfig,
-  resolveNpmNudo,
-  BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS,
-} from "@nudojs/cli/evaluator";
-import { mockDirectivesToAbsSeeds, mockSeedsToAbsMocks } from "./mock-abs.ts";
-import { autoHarvestModules } from "./harvest-auto.ts";
-import { evalAbsModuleGraph, collectAbsBindingsFromGraph, evalProgramAbsWithModules } from "./abs-modules-graph.ts";
-import { tryBPathCall, tryBPathCallFull, tryRunBPath, isBPathCapable, mockSeedFingerprint, collectEnvGlobals } from "./bpath-run.ts";
-import { collectBPathDiagnostics } from "./bpath-diagnostics.ts";
-import { setAbsTruncationCollector } from "@nudojs/core";
-import {
-  analysisCacheGet,
-  analysisCacheSet,
-} from "./analysis-file-cache.ts";
-import {
-  fnAnalysisCacheGet,
-  fnAnalysisCacheSet,
-  caseDirectiveKey,
-  type CachedFnAnalysis,
-} from "./fn-analysis-cache.ts";
-export { clearFnAnalysisCache } from "./fn-analysis-cache.ts";
-
-export type SourceLocation = {
-  start: { line: number; column: number };
-  end: { line: number; column: number };
-};
-
-export type DiagnosticSeverity = "error" | "warning" | "info";
-
-export type DiagnosticTag = "unnecessary";
-
-export type Diagnostic = {
-  range: SourceLocation;
-  severity: DiagnosticSeverity;
-  message: string;
-  tags?: DiagnosticTag[];
-  code?: string;
-  suggestions?: string[];
-  data?: unknown;
-  /** provenance of the receiver value (callsite argument that flowed into the error) */
-  origin?: { line: number; column: number };
-};
-
-export type CaseResult = {
-  name: string;
-  args: TypeValue[];
-  result: TypeValue;
-  throws: TypeValue;
-  throwLoc?: SourceLocation;
-  source?: "directive" | "callsite";
-  /** `@nudo:case "name" (…) => expected` — presence means the case is a test assertion */
-  expected?: TypeValue;
-  /** number of additional call sites folded into a symbolic case */
-  aggregatedFrom?: number;
-  /**
-   * 内涵摘要（代数 generalize）：无损 Abs + term/pred/conf。
-   * 仅在 entry@ / call@（Abs 路径）填充；外延 TypeValue 不变。
-   */
-  intension?: {
-    display?: string;
-    term?: string;
-    pred?: string;
-    conf?: string;
-    /** 无损 Abs 单行（formatAbs） */
-    abs?: string;
-    /** 无损 Abs 多行（formatAbsMultiline） */
-    absMultiline?: string;
-  };
-  /** 无损 Abs（denote/守卫用）；仅 Abs 路径 case 填充 */
-  abs?: Abs;
-};
-
-export type FunctionAnalysis = {
-  name: string;
-  loc: SourceLocation;
-  paramNames: string[];
-  cases: CaseResult[];
-  combined?: TypeValue;
-  entryOnly?: boolean;
-  skipped?: boolean;
-  /**
-   * True for functions collected from CJS-style bindings/assignments
-   * (`exports.X = fn`, `module.exports = fn`, `const f = fn`): their name has
-   * no declaration-level stability, so .d.ts generation skips them while
-   * infer/JSON output still reports them.
-   */
-  noDeclaration?: boolean;
-  /** absolute path of the module this function is imported from (externalFunctions only) */
-  fromModule?: string;
-};
-
-export type BindingInfo = {
-  type: TypeValue;
-  loc?: SourceLocation;
-};
-
-export type CaseHint = {
-  line: number;
-  label: string;
-  ok: boolean;
-};
-
-export type AnalysisResult = {
-  functions: FunctionAnalysis[];
-  diagnostics: Diagnostic[];
-  bindings: Map<string, BindingInfo>;
-  /**
-   * Node identity is from the analysis-time parse. A later re-parse of the
-   * same source returns a *different* File (new Nodes) if the AST LRU evicted
-   * the original — lookups must use the File that produced this result, not a
-   * freshly parsed one. getTypeAtPosition rebuilds its own map and is unaffected.
-   */
-  nodeTypeMap: Map<Node, TypeValue>;
-  caseHints: CaseHint[];
-  /** functions imported from other modules, synthesized from cross-file call sites observed while analyzing this file */
-  externalFunctions?: FunctionAnalysis[];
-};
-
-export type CompletionItem = {
-  label: string;
-  kind: "property" | "method" | "variable";
-  detail?: string;
-};
-
-export type SymbolInfo = {
-  name: string;
-  kind: "function" | "variable" | "class" | "parameter";
-  loc: SourceLocation;
-  uri?: string;
-};
-
-export type ReferenceInfo = {
-  name: string;
-  loc: SourceLocation;
-  uri?: string;
-};
-
-export type SymbolTable = {
-  definitions: Map<string, SymbolInfo>;
-  references: ReferenceInfo[];
-};
-
-export function resolveModule(source: string, fromDir: string): { ast: ReturnType<typeof parse>; filePath: string; json?: unknown } | null {
-  const extensions = [".js", ".ts", ".mjs"];
-
-  const nudoPath = resolveNpmNudo(source, fromDir);
-  if (nudoPath) {
-    const src = readFileSync(nudoPath, "utf-8");
-    return { ast: parse(src), filePath: nudoPath };
-  }
-
-  const basePath = resolve(fromDir, source);
-  for (const ext of ["", ...extensions]) {
-    const candidate = basePath + ext;
-    if (!existsSync(candidate)) continue;
-    // 目录：按 package.json main / index.js 解析（require('..') 模式）
-    if (statSync(candidate).isDirectory()) {
-      let entry: string | null = null;
-      const pkgPath = resolve(candidate, "package.json");
-      if (existsSync(pkgPath)) {
-        try {
-          const main = JSON.parse(readFileSync(pkgPath, "utf-8")).main;
-          if (typeof main === "string") {
-            for (const e of ["", ...extensions]) {
-              const p = resolve(candidate, main + e);
-              if (existsSync(p) && statSync(p).isFile()) { entry = p; break; }
-            }
-          }
-        } catch { /* 无效 package.json → fallback index */ }
-      }
-      if (!entry) {
-        for (const e of ["", ...extensions]) {
-          const p = resolve(candidate, "index" + e);
-          if (existsSync(p) && statSync(p).isFile()) { entry = p; break; }
-        }
-      }
-      if (!entry) return null;
-      const src = readFileSync(entry, "utf-8");
-      return { ast: parse(src), filePath: entry };
-    }
-    // .json 模块：require('../package.json') 等模式——按 JSON 求值而非 JS parse
-    if (candidate.endsWith(".json")) {
-      try {
-        return { ast: parse("module.exports = undefined;"), filePath: candidate, json: JSON.parse(readFileSync(candidate, "utf-8")) };
-      } catch {
-        return null;
-      }
-    }
-    const src = readFileSync(candidate, "utf-8");
-    return { ast: parse(src), filePath: candidate };
-  }
-  return null;
-}
-
-/** Resolve a relative import specifier to an existing file (extension rules identical to CLI resolveModule: ''/'.js'/'.ts'/'.mjs'); null when unresolvable. */
-function resolveImportPath(specifier: string, fromDir: string): string | null {
-  const basePath = resolve(fromDir, specifier);
-  for (const ext of ["", ".js", ".ts", ".mjs"]) {
-    const candidate = basePath + ext;
-    if (existsSync(candidate)) return candidate;
-  }
-  return null;
-}
-
-/** mtime 边缓存：key 为文件路径，edges 为已抽取的相对 import 边（与 buildModuleGraph 返回语义一致）。 */
-export type ModuleGraphCache = Map<string, { mtimeMs: number; size: number; edges: string[] }>;
-
-/** Statically extract each file's relative import edges (extension resolution identical to CLI resolveModule: ''/'.js'/'.ts'/'.mjs'; bare npm specifiers skipped). */
-export function buildModuleGraph(
-  files: string[],
-  cache?: ModuleGraphCache,
-): {
-  imports: Map<string, Set<string>>;
-  dependents: Map<string, Set<string>>;
-} {
-  const imports = new Map<string, Set<string>>();
-  const dependents = new Map<string, Set<string>>();
-  const edge = (from: string, to: string) => {
-    if (!imports.has(from)) imports.set(from, new Set());
-    if (!dependents.has(to)) dependents.set(to, new Set());
-    imports.get(from)!.add(to);
-    dependents.get(to)!.add(from);
-  };
-  for (const file of files) {
-    if (!imports.has(file)) imports.set(file, new Set());
-    if (!dependents.has(file)) dependents.set(file, new Set());
-    let edges: string[];
-    if (cache) {
-      // stat 仅取元数据不读内容；mtimeMs+size 均一致视为命中，复用边并跳过磁盘读取与解析
-      let stat: ReturnType<typeof statSync> | null = null;
-      try {
-        stat = statSync(file);
-      } catch {
-        /* stat 失败（文件被删等）按未命中处理，走直读兜底 */
-      }
-      const cached = stat ? cache.get(file) : undefined;
-      if (stat && cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
-        edges = cached.edges;
-      } else {
-        edges = extractImportEdges(file);
-        if (stat) cache.set(file, { mtimeMs: stat.mtimeMs, size: stat.size, edges });
-      }
-    } else {
-      edges = extractImportEdges(file);
-    }
-    for (const to of edges) edge(file, to);
-  }
-  return { imports, dependents };
-}
-
-/** 磁盘直读并解析单个文件，抽取其相对 import 边（读取/解析失败返回空数组）。 */
-function extractImportEdges(file: string): string[] {
-  const edges: string[] = [];
-  let ast: ReturnType<typeof parse>;
-  try {
-    ast = parse(readFileSync(file, "utf-8"));
-  } catch {
-    return edges;
-  }
-  for (const stmt of ast.program.body) {
-    if (stmt.type !== "ImportDeclaration") continue;
-    const specifier = stmt.source.value;
-    if (!specifier.startsWith(".") && !specifier.startsWith("/")) continue;
-    const resolved = resolveImportPath(specifier, dirname(file));
-    if (resolved) edges.push(resolved);
-  }
-  return edges;
-}
-
-/** changed plus its transitive dependents (reverse-edge BFS); cycle-safe via visited. */
-export function computeDirtySet(dependents: Map<string, Set<string>>, changedFile: string): string[] {
-  const dirty: string[] = [];
-  const visited = new Set<string>();
-  const queue = [changedFile];
-  while (queue.length > 0) {
-    const file = queue.shift()!;
-    if (visited.has(file)) continue;
-    visited.add(file);
-    dirty.push(file);
-    for (const dep of dependents.get(file) ?? []) {
-      if (!visited.has(dep)) queue.push(dep);
-    }
-  }
-  return dirty;
-}
-
-/** Topological order with dependencies before dependents (only imports edges internal to dirty; cycles tolerated — remaining files appended in arbitrary order). */
-export function topoSortDirty(imports: Map<string, Set<string>>, dirty: string[]): string[] {
-  const inSet = new Set(dirty);
-  const pending = new Map<string, number>();
-  for (const file of dirty) {
-    let count = 0;
-    for (const dep of imports.get(file) ?? []) {
-      if (inSet.has(dep)) count++;
-    }
-    pending.set(file, count);
-  }
-  const ordered: string[] = [];
-  const ready = dirty.filter((f) => pending.get(f) === 0);
-  while (ready.length > 0) {
-    const file = ready.shift()!;
-    ordered.push(file);
-    for (const other of dirty) {
-      if (pending.get(other) === undefined) continue;
-      if ((imports.get(other) ?? new Set<string>()).has(file)) {
-        const next = pending.get(other)! - 1;
-        pending.set(other, next);
-        if (next === 0) ready.push(other);
-      }
-    }
-  }
-  for (const file of dirty) {
-    if (pending.has(file) && pending.get(file)! > 0) ordered.push(file);
-  }
-  return ordered;
-}
-
-function applyMocks(
-  directives: FunctionWithDirectives["directives"],
-  env: Environment,
-  filePath: string,
-  diagnostics: Diagnostic[],
-): void {
-  for (const d of directives) {
-    if (d.kind !== "mock") continue;
-    if (d.arrowFn) {
-      const fnType = T.fn(d.arrowFn.params, d.arrowFn.body, env);
-      (fnType as any)._paramPatterns = d.arrowFn.paramPatterns;
-      env.bind(d.name, fnType);
-    } else if (d.nudoMock) {
-      const typeVal = mockHelperToTypeValue(d.nudoMock, env);
-      env.bind(d.name, typeVal);
-    } else if (d.sinonExpr) {
-      const sinonType = createSinonTypeValue(d.sinonExpr, env);
-      env.bind(d.name, sinonType);
-    } else if (d.expression) {
-      const expr = d.expression.trim();
-      if (expr.includes("(") && expr.includes(")") && !expr.startsWith("T.")) {
-        diagnostics.push({
-          range: { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } },
-          severity: "warning",
-          message: `Mock expression "${expr}" could not be parsed as a known pattern`,
-          code: "nudo:mock-invalid",
-          suggestions: [
-            "Supported formats: stub(), stub().returns(value), spy(), mock()",
-            "Arrow functions: (args) => expression or (args) => { statements; return value; }",
-          ],
-        });
-      }
-      env.bind(d.name, parseTypeValueExpr(d.expression));
-    } else if (d.fromPath) {
-      const mockPath = resolve(dirname(filePath), d.fromPath);
-      const mockSource = readFileSync(mockPath, "utf-8");
-      const mockAst = parse(mockSource);
-      const mockEnv = createEnvironment();
-      evaluateProgram(mockAst, mockEnv);
-      const mockVal = mockEnv.lookup(d.name);
-      env.bind(d.name, mockVal);
-    }
-  }
-}
-
-function createSinonTypeValue(sinonExpr: SinonExpression, env: Environment): TypeValue {
-  // For stub and spy, create a function that returns the specified value
-  if (sinonExpr.type === "stub" || sinonExpr.type === "spy") {
-    const body = { type: "BlockStatement", body: [] } as any;
-    const fn = T.fn(["...args"], body, env);
-
-    if (sinonExpr.returnValue) {
-      // Store the return value directly on the function
-      (fn as any)._directReturn = sinonExpr.returnValue;
-    } else if (sinonExpr.resolvedValue) {
-      // Store as promise
-      (fn as any)._directReturn = T.promise(sinonExpr.resolvedValue);
-    } else if (sinonExpr.rejectedValue) {
-      // Store as never (rejected promise)
-      (fn as any)._directReturn = T.never;
-    } else {
-      // Default: return unknown
-      (fn as any)._directReturn = T.unknown;
-    }
-    return fn;
-  }
-  // For mock, return unknown for now
-  return T.unknown;
-}
-
-function rangeKey(r: SourceLocation): string {
-  return `${r.start.line}:${r.start.column}-${r.end.line}:${r.end.column}`;
-}
-
-function findCommonUnreachable(perCase: SourceLocation[][]): SourceLocation[] {
-  if (perCase.length === 0) return [];
-  const counts = new Map<string, { count: number; range: SourceLocation }>();
-  for (const ranges of perCase) {
-    for (const r of ranges) {
-      const key = rangeKey(r);
-      const existing = counts.get(key);
-      if (existing) {
-        existing.count++;
-      } else {
-        counts.set(key, { count: 1, range: r });
-      }
-    }
-  }
-  return [...counts.values()]
-    .filter((v) => v.count === perCase.length)
-    .map((v) => v.range);
-}
-
-function locFromNode(node: Node): SourceLocation {
-  return {
-    start: { line: node.loc?.start.line ?? 1, column: node.loc?.start.column ?? 0 },
-    end: { line: node.loc?.end.line ?? 1, column: node.loc?.end.column ?? 0 },
-  };
-}
-
-function extractParamNames(node: Node): string[] {
-  const fn = node.type === "ExportDefaultDeclaration" ? node.declaration : node;
-  if (fn.type === "FunctionDeclaration" || fn.type === "FunctionExpression" || fn.type === "ArrowFunctionExpression") {
-    return fn.params.map((p: any) => {
-      if (p.type === "Identifier") return p.name;
-      if (p.type === "AssignmentPattern" && p.left.type === "Identifier") return p.left.name;
-      if (p.type === "RestElement" && p.argument.type === "Identifier") return `...${p.argument.name}`;
-      return "_";
-    });
-  }
-  if (fn.type === "VariableDeclaration") {
-    const decl = fn.declarations[0];
-    if (decl.init?.type === "FunctionExpression" || decl.init?.type === "ArrowFunctionExpression") {
-      return decl.init.params.map((p: any) => {
-        if (p.type === "Identifier") return p.name;
-        if (p.type === "AssignmentPattern" && p.left.type === "Identifier") return p.left.name;
-        if (p.type === "RestElement" && p.argument.type === "Identifier") return `...${p.argument.name}`;
-        return "_";
-      });
-    }
-  }
-  return [];
-}
-
-function resolveFunctionNode(node: Node): Node {
-  if (node.type === "ExportNamedDeclaration" && node.declaration) return resolveFunctionNode(node.declaration);
-  if (node.type === "ExportDefaultDeclaration") return resolveFunctionNode(node.declaration);
-  if (node.type === "VariableDeclaration") {
-    const init = (node as any).declarations[0]?.init;
-    if (init && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")) return init;
-  }
-  return node;
-}
-
-function isFnExprValue(node: Node | null | undefined): node is Node {
-  return !!node && (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression");
-}
-
-function namedFnExprId(node: Node): string | null {
-  return node.type === "FunctionExpression" && node.id ? node.id.name : null;
-}
-
-/** `module.exports` — the only assignment target carrying no stable name of its own. */
-function isModuleExportsTarget(node: Node): boolean {
-  return (
-    node.type === "MemberExpression" &&
-    !node.computed &&
-    (node as any).object?.type === "Identifier" &&
-    (node as any).object.name === "module" &&
-    (node as any).property?.type === "Identifier" &&
-    (node as any).property.name === "exports"
-  );
-}
-
-function memberPropertyKey(member: Node): string | null {
-  if (member.type !== "MemberExpression" || member.computed) return null;
-  const prop = (member as any).property;
-  if (prop?.type === "Identifier") return prop.name;
-  if (prop?.type === "StringLiteral") return String(prop.value);
-  return null;
-}
-
-/** Rightmost value of a chained assignment (`a = b = fn` → fn). */
-function deepestAssignValue(expr: Node): Node | null {
-  let cur: any = expr;
-  while (cur?.type === "AssignmentExpression") cur = cur.right;
-  return cur ?? null;
-}
-
-/**
- * First stable name on an assignment chain, left to right: an identifier
- * binding, or a member property that is not `module.exports` itself. Returns
- * null for chains ending in a bare `module.exports = fn` or in computed
- * members (`exports[k] = fn`) — callers fall back to "default".
- */
-function assignmentChainName(expr: Node): string | null {
-  let cur: any = expr;
-  while (cur?.type === "AssignmentExpression") {
-    const target = cur.left;
-    if (target.type === "Identifier") return target.name;
-    if (target.type === "MemberExpression") {
-      if (isModuleExportsTarget(target)) {
-        cur = cur.right;
-        continue;
-      }
-      return memberPropertyKey(target);
-    }
-    return null;
-  }
-  return null;
-}
-
-/**
- * Top-level functions eligible for case synthesis. Besides FunctionDeclarations
- * this collects CJS-style function bindings:
- *
- *   const f = function () {};                           // declarator init
- *   exports.applyToDefaults = function (a, b) {};       // namespace property
- *   module.exports = internals.clone = function () {};  // chained export
- *
- * Naming: identifier bindings win (call sites dispatch on them, and the
- * evaluator's call records key on the callee identifier); a named function
- * expression's own id beats a member property name; a bare
- * `module.exports = fn` becomes "default" (ESM default-export analogue).
- * Collected non-declaration entries carry `noDeclaration` — see FunctionAnalysis.
- *
- * v1 limitation: `internals.clone()`-style member calls go through method
- * dispatch and never produce call records, so such functions fall back to the
- * entry@ evaluation; same-file `X(...)` calls after `exports.X = fn` are not
- * tracked either.
- */
-function collectTopLevelFunctions(ast: Node): { name: string; node: Node; stmt: Node; noDeclaration: boolean }[] {
-  const results: { name: string; node: Node; stmt: Node; noDeclaration: boolean }[] = [];
-  if (ast.type !== "File") return results;
-  for (const stmt of (ast as any).program.body) {
-    const decl = resolveFunctionNode(stmt);
-    if (decl.type === "FunctionDeclaration" && decl.id) {
-      results.push({ name: decl.id.name, node: decl, stmt, noDeclaration: false });
-      continue;
-    }
-    if (stmt.type === "VariableDeclaration") {
-      for (const declarator of (stmt as any).declarations) {
-        if (declarator.id?.type === "Identifier" && isFnExprValue(declarator.init)) {
-          results.push({ name: declarator.id.name, node: declarator.init, stmt, noDeclaration: true });
-        }
-      }
-      continue;
-    }
-    if (stmt.type === "ExpressionStatement" && (stmt as any).expression?.type === "AssignmentExpression") {
-      const expr = (stmt as any).expression as Node;
-      const fn = deepestAssignValue(expr);
-      if (isFnExprValue(fn)) {
-        const name = namedFnExprId(fn) ?? assignmentChainName(expr) ?? "default";
-        results.push({ name, node: fn, stmt, noDeclaration: true });
-      }
-    }
-  }
-  return results;
-}
-
-/** The function value of the file's single `module.exports = <function>`
- * top-level assignment, when there is exactly one. Assigning module.exports
- * replaces the whole exports object, so such a file exports exactly that one
- * function and usage-site records may reach it under any re-export name —
- * matching by targetModule alone is then unambiguous. Returns null for
- * multi-export shapes (no such assignment, several, or `module.exports =
- * {...}`), where a name/alias match is still required so sibling functions
- * don't get misattributed. */
-function findSingleModuleExportsFunction(ast: Node): Node | null {
-  if (ast.type !== "File") return null;
-  let found: Node | null = null;
-  for (const stmt of (ast as any).program.body) {
-    if (stmt.type !== "ExpressionStatement") continue;
-    const expr = (stmt as any).expression;
-    if (expr?.type !== "AssignmentExpression") continue;
-    const fn = deepestAssignValue(expr);
-    if (!isFnExprValue(fn)) continue;
-    let targetsModuleExports = false;
-    let cur: any = expr;
-    while (cur?.type === "AssignmentExpression") {
-      if (isModuleExportsTarget(cur.left)) {
-        targetsModuleExports = true;
-        break;
-      }
-      cur = cur.right;
-    }
-    if (!targetsModuleExports) continue;
-    if (found) return null; // a second `module.exports = fn` → ambiguous
-    found = fn;
-  }
-  return found;
-}
-
-function typeStructureKey(tv: TypeValue): string {
-  // Self-referential structures (x.y = x surviving a clone) would recurse
-  // infinitely: a seen-set renders revisits as a cycle token.
-  return typeStructureKeyUncached(tv, new Set());
-}
-
-function typeStructureKeyUncached(tv: TypeValue, seen: Set<object>): string {
-  // Path-scoped seen-set (backtracked after each expansion): a node renders
-  // as a cycle token only while its own expansion is on the stack, so
-  // shared singletons keep their full key.
-  const enter = (inner: TypeValue): string => {
-    if (inner && typeof inner === "object") {
-      if (seen.has(inner)) return "«cycle»";
-      seen.add(inner);
-      const out = typeStructureKeyUncached(inner, seen);
-      seen.delete(inner);
-      return out;
-    }
-    return typeStructureKeyUncached(inner, seen);
-  };
-  switch (tv.kind) {
-    case "literal":
-      return `lit(${typeof tv.value}:${String(tv.value)})`;
-    case "primitive":
-      return `prim(${tv.type})`;
-    case "array":
-      return `arr(${enter(tv.element)})`;
-    case "tuple":
-      return `tup(${tv.elements.map(enter).join(",")})`;
-    case "object":
-      return `obj(${Object.keys(tv.properties).sort().map((k) => `${k}:${enter(tv.properties[k])}`).join(",")})`;
-    case "function":
-      return `fn(${tv.params.join(",")})`;
-    case "promise":
-      return `prom(${enter(tv.value)})`;
-    case "instance":
-      return `inst(${tv.className})`;
-    case "refined":
-      return `ref(${enter(tv.base)})`;
-    case "union":
-      return `uni(${tv.members.map(enter).sort().join("|")})`;
-    default:
-      return tv.kind;
-  }
-}
-
-const MAX_PRECISE_CALLSITE_CASES = 3;
-const COLLAPSE_LITERAL_THRESHOLD = 4;
-
-/** widenLiteral for unions: widen each member, then dedupe (1|2|…|20 → number). */
-function widenType(tv: TypeValue): TypeValue {
-  if (tv.kind === "union") return simplifyUnion(tv.members.map(widenLiteral));
-  return widenLiteral(tv);
-}
-
-function dedupeCallRecords(records: CallRecord[]): CallRecord[] {
-  const seen = new Set<string>();
-  const out: CallRecord[] = [];
-  for (const rec of records) {
-    // 类型值是重共享的 DAG（同一 JSON fixture 字面量流入多个参数/记录），
-    // 下方树形 key 会随共享度指数膨胀。超大记录与 resultType=never 一样
-    // 没有逐调用信息量（其 widen 后的形态才有），在 key 计算前统一丢弃。
-    if (isOversizedRecord(rec)) continue;
-    // key 必须含结果形态：同实参形状但不同结果（错误路径 never+throws vs
-    // 成功路径 Promise<...>）是不同的 case，只按实参去重会把成功记录吞进
-    // 首条错误记录里（parseChunked 的 Promise 记录曾被 L203 的 throw 吞掉）。
-    const key =
-      rec.argTypes.map(typeStructureKey).join(",") +
-      "=>" +
-      typeStructureKey(rec.resultType) +
-      "!" +
-      typeStructureKey(rec.throws);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(rec);
-  }
-  return out;
-}
-
-/** DAG node budget for a usable call record; tree-shaped renderings of a
- * type (the dedup key, the synthesized case output) grow exponentially with
- * substructure sharing, so records whose argument/result DAGs exceed the
- * budget are dropped rather than blown up. */
-const MAX_RECORD_TYPE_NODES = 2000;
-
-/** Linear-in-DAG-size node count (a `seen` set makes shared subtrees count
- * once, so this stays cheap where a naive tree walk is exponential). */
-function typeNodeCount(tv: TypeValue, seen: Set<object>): number {
-  if (tv === null || typeof tv !== "object") return 1;
-  if (seen.has(tv)) return 0;
-  seen.add(tv);
-  switch (tv.kind) {
-    case "array":
-      return 1 + typeNodeCount(tv.element, seen);
-    case "tuple":
-      return 1 + tv.elements.reduce((acc, e) => acc + typeNodeCount(e, seen), 0);
-    case "object": {
-      let n = 1;
-      for (const v of Object.values(tv.properties)) n += typeNodeCount(v, seen);
-      return n;
-    }
-    case "promise":
-      return 1 + typeNodeCount(tv.value, seen);
-    case "union":
-      return 1 + tv.members.reduce((acc, e) => acc + typeNodeCount(e, seen), 0);
-    case "refined":
-      return 1 + typeNodeCount(tv.base, seen);
-    default:
-      return 1;
-  }
-}
-
-function isOversizedRecord(rec: CallRecord): boolean {
-  const seen = new Set<object>();
-  for (const a of rec.argTypes) {
-    if (typeNodeCount(a, seen) > MAX_RECORD_TYPE_NODES) return true;
-  }
-  return typeNodeCount(rec.resultType, seen) > MAX_RECORD_TYPE_NODES;
-}
-
-function locFromCallLoc(loc: { line: number; column: number } | undefined): SourceLocation {
-  const p = loc ?? { line: 0, column: 0 };
-  return { start: { line: p.line, column: p.column }, end: { line: p.line, column: p.column } };
-}
-
-/**
- * Cross-file call-site aggregation: call records whose callee is a function
- * exported by another module (tagged by the evaluator's export side table)
- * are grouped by (targetModule, targetExport) and synthesized directly into
- * FunctionAnalysis entries — no re-evaluation needed, each CallRecord already
- * carries the resultType/throws computed when this file was evaluated.
- *
- * v1 limitation: only named-import direct calls are recorded by the
- * evaluator; `import * as ns` member calls go through the method path and
- * never reach this synthesis.
- */
-function synthesizeExternalFunctions(records: CallRecord[], currentFile: string): FunctionAnalysis[] {
-  const groups = new Map<string, { module: string; exportName: string; records: CallRecord[] }>();
-  for (const rec of records) {
-    if (!rec.targetModule || !rec.targetExport) continue;
-    if (rec.targetModule === currentFile) continue;
-    const key = `${rec.targetModule}\0${rec.targetExport}`;
-    let group = groups.get(key);
-    if (!group) {
-      group = { module: rec.targetModule, exportName: rec.targetExport, records: [] };
-      groups.set(key, group);
-    }
-    group.records.push(rec);
-  }
-
-  const out: FunctionAnalysis[] = [];
-  for (const { module, exportName, records } of groups.values()) {
-    const deduped = dedupeCallRecords(records);
-    const arity = Math.max(...deduped.map((r) => r.argTypes.length));
-    const analysis: FunctionAnalysis = {
-      name: exportName,
-      loc: locFromCallLoc(deduped[0].callLoc),
-      paramNames: Array.from({ length: arity }, (_, i) => `arg${i}`),
-      cases: [],
-      fromModule: module,
-    };
-
-    // Same capping as local synthesis: at most MAX_PRECISE_CALLSITE_CASES
-    // precise cases. The symbolic aggregate cannot re-evaluate the foreign
-    // function (its AST belongs to another file's analysis), so it unions the
-    // observed argument/result/throws types of the remaining records instead.
-    const precise = deduped.slice(0, MAX_PRECISE_CALLSITE_CASES);
-    for (const rec of precise) {
-      analysis.cases.push({
-        name: `call@L${rec.callLoc?.line ?? 0}`,
-        args: rec.argTypes,
-        result: rec.resultType,
-        throws: rec.throws,
-        source: "callsite",
-      });
-    }
-    const remaining = deduped.slice(MAX_PRECISE_CALLSITE_CASES);
-    if (remaining.length > 0) {
-      analysis.cases.push({
-        name: "call@symbolic",
-        args: Array.from({ length: arity }, (_, i) =>
-          // 缺参按真实 JS 语义 widen 成 undefined 而非 unknown——可选参守卫
-          // （target || [] 等）对 unknown 全塌，对 undefined 正常走默认分支
-          widenType(simplifyUnion(remaining.map((rec) => rec.argTypes[i] ?? T.undefined))),
-        ),
-        result: collapseLiteralUnion(simplifyUnion(remaining.map((r) => r.resultType)), COLLAPSE_LITERAL_THRESHOLD),
-        throws: simplifyUnion(remaining.map((r) => r.throws)),
-        source: "callsite",
-        aggregatedFrom: remaining.length,
-      });
-    }
-
-    if (deduped.length > 1) {
-      analysis.combined = collapseLiteralUnion(
-        simplifyUnion(deduped.map((r) => r.resultType)),
-        COLLAPSE_LITERAL_THRESHOLD,
-      );
-    } else {
-      analysis.combined = deduped[0].resultType;
-    }
-    out.push(analysis);
-  }
-  return out;
-}
-
-function receiverTypeToDisplay(tv: TypeValue): string {
-  switch (tv.kind) {
-    case "literal": {
-      const v = tv.value;
-      if (v === null) return "null";
-      if (v === undefined) return "undefined";
-      return typeof v;
-    }
-    case "union":
-      return tv.members.map(receiverTypeToDisplay).join(" | ");
-    default:
-      return typeValueToString(tv);
-  }
-}
-
-function receiverIsConcrete(tv: TypeValue): boolean {
-  if (tv.kind === "unknown") return false;
-  if (tv.kind === "union") return tv.members.every((m) => m.kind !== "unknown");
-  return true;
-}
-
-function unknownRecordsToDiagnostics(records: UnknownRecord[]): Diagnostic[] {
-  const out: Diagnostic[] = [];
-  const seen = new Set<string>();
-  for (const r of records) {
-    const line = r.loc?.line ?? 0;
-    const column = r.loc?.column ?? 0;
-    const key = `${line}:${column}:${r.name}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-
-    const range = {
-      start: { line, column },
-      end: { line, column: column + r.name.length },
-    };
-
-    if (r.kind === "global") {
-      // 递归截断记录（name 形如 "recursion:fnName"）来自求值预算，非未知全局
-      if (r.name.startsWith("recursion:")) {
-        out.push({
-          range,
-          severity: "warning",
-          message: `Recursive evaluation of '${r.name.slice("recursion:".length)}' was truncated (depth/size budget); result widened to unknown`,
-          code: "nudo:recursion-truncated",
-        });
-        continue;
-      }
-      // 模块加载守卫记录（evaluator.ts loadModuleEnv / mock-module 路径）：
-      // reason 自带环链 / 链深 / 完整候选路径，直接作为诊断文案。
-      if (r.name.startsWith("module-cycle:")) {
-        out.push({
-          range,
-          severity: "warning",
-          message: r.reason ?? "Circular module load detected",
-          code: "nudo:module-cycle",
-        });
-        continue;
-      }
-      if (r.name.startsWith("module-depth:")) {
-        out.push({
-          range,
-          severity: "warning",
-          message: r.reason ?? "Module load chain too deep",
-          code: "nudo:module-depth",
-        });
-        continue;
-      }
-      if (r.name.startsWith("module-missing:")) {
-        out.push({
-          range,
-          severity: "error",
-          message: r.reason ?? "Module file not found",
-          code: "nudo:module-missing",
-        });
-        continue;
-      }
-      out.push({
-        range,
-        severity: "warning",
-        message: `Unknown global identifier '${r.name}'`,
-        code: "nudo:unknown-global",
-      });
-      continue;
-    }
-
-    const receiver = r.receiverType;
-    if (receiver && receiverIsConcrete(receiver)) {
-      // instance 类型的方法集是声明的近似（未列出 ≠ 运行时不存在），
-      // 只有基类型（number/string 等）上的方法缺失才是确定错误。
-      // union 混合（Set | [] | {}）同理：部分 member 可能有该方法，
-      // 缺失不确定 → warning。
-      const isApprox = (() => {
-        const members =
-          receiver.kind === "union" ? receiver.members : [receiver];
-        return members.some(
-          (m) =>
-            m.kind === "instance" ||
-            m.kind === "function" ||
-            m.kind === "tuple" ||
-            m.kind === "array" ||
-            m.kind === "object" ||
-            m.kind === "refined" ||
-            // wrapper/instance 近似表上可能持有该成员（'x'.charCodeAt 于
-            // number|string：string 侧存在，number 侧缺失 → 不确定 → warning）
-            memberMayExistOn(m, r.name),
-        );
-      })();
-      const kindLabel = r.kind === "method" ? "Method" : "Property";
-      out.push({
-        range,
-        severity: isApprox ? "warning" : "error",
-        message: `${kindLabel} '${r.name}' does not exist on type '${receiverTypeToDisplay(receiver)}'`,
-        code: "nudo:no-method",
-        ...(r.origin ? { origin: r.origin } : {}),
-      });
-    } else {
-      out.push({
-        range,
-        severity: "warning",
-        message: `Cannot resolve '${r.name}' on unknown value`,
-        code: "nudo:unknown-recv",
-        ...(r.origin ? { origin: r.origin } : {}),
-      });
-    }
-  }
-  return out;
-}
-
-function collectEnvNames(filePath: string, source: string, includeProject: boolean): string[] {
-  const ast = parse(source);
-  const fileDirectives = extractFileDirectives(ast);
-  const fileEnvNames = fileDirectives
-    .filter((d) => d.kind === "env")
-    .flatMap((d) => d.envs);
-  if (!includeProject) return fileEnvNames;
-  const projectConfig = findProjectConfig(dirname(filePath));
-  const projectEnvNames = projectConfig?.config.env ?? [];
-  return [...new Set([...projectEnvNames, ...fileEnvNames])];
-}
-
-/**
- * Async entry to analyzeFile: preloads path-based env files
- * (`/// @nudo:env ./nudo-harvest-node.ts`) via dynamic import — impossible
- * synchronously in ESM — then runs the sync analysis, which picks the
- * preloaded factories up from the env-loader cache. The sync analyzeFile
- * signature is unchanged for existing consumers (LSP, MCP, vite-plugin).
- */
-export async function analyzeFileAsync(
-  filePath: string,
-  source: string,
-  activeCases?: Map<string, number>,
-  externalCallRecords?: CallRecord[],
-): Promise<AnalysisResult> {
-  const envNames = collectEnvNames(filePath, source, true);
-  if (envNames.length > 0) {
-    await preloadPathEnvs(envNames, dirname(filePath));
-  }
-  return analyzeFile(filePath, source, activeCases, externalCallRecords);
-}
-
-/**
- * 调用点发现（阶段一）：在"使用现场"文件（测试 / 上层应用）中求值
- * 顶层代码，收集它对（外部模块导出的）函数的调用记录。每条记录带
- * 真实的实参类型与结果类型——后续 analyzeFile 将其注入合成 case，
- * 使被使用方从 entry-only（参数全 unknown）升级为真实调用形态。
- *
- * 只做求值与记录，不产出诊断；求值异常不抛出（使用现场文件可能
- * 依赖未 mock 的全局，收集不到就收集不到，不能拖垮主分析）。
- */
-export function collectCallRecords(filePath: string, source: string): CallRecord[] {
-  const records: CallRecord[] = [];
-  // 使用现场可能是老 CJS（八进制字面量等历史语法）——宽松恢复模式，
-  // 收集尽力而为；主分析的 parse 不受影响
-  const ast = parse(source, { errorRecovery: true });
-  resetMemo();
-  resetUnreachableRanges();
-  resetEnvModules();
-  resetMockModules();
-  setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname(filePath));
-  setCurrentSource(source);
-  setCallCollector((record) => records.push(record));
-  try {
-    const env = createEnvironment();
-    evaluateProgram(ast, env);
-    // 测试框架语义近似：it/describe/test 的回调在顶层求值中不会执行，
-    // 但它们的函数体正是真实调用点所在。以 unknown 参数手动执行每个
-    // 回调体；describe 回调体内嵌的 it(...) 继续展开（测试常嵌套）。
-    const runCallbacks = (statements: Node[]): void => {
-      for (const stmt of statements) {
-        if (stmt.type !== "ExpressionStatement" || !("expression" in stmt)) continue;
-        const expr = (stmt as { expression: Node }).expression;
-        if (expr.type !== "CallExpression") continue;
-        const callee = (expr as Node & { callee: Node }).callee;
-        if (callee.type !== "MemberExpression" && callee.type !== "Identifier") continue;
-        const name =
-          callee.type === "Identifier"
-            ? callee.name
-            : callee.property.type === "Identifier"
-              ? callee.property.name
-              : null;
-        if (!name || !TEST_CALLBACK_NAMES.has(name)) continue;
-        const args = (expr as Node & { arguments: Node[] }).arguments;
-        const cb = args.find((a) => a.type === "ArrowFunctionExpression" || a.type === "FunctionExpression") as
-          | (Node & { body: Node })
-          | undefined;
-        if (!cb) continue;
-        try {
-          // 以 unknown 参数执行回调体（evaluate 只构造函数类型不执行）
-          const params = (cb as unknown as { params?: Node[] }).params ?? [];
-          evaluateFunction(cb, params.map(() => T.unknown), env);
-        } catch {
-          /* 单个回调失败不影响其余 */
-        }
-        // describe 回调体是语句列表——递归展开嵌套的 it/describe
-        if (name === "describe" && cb.body.type === "BlockStatement") {
-          runCallbacks((cb.body as unknown as { body: Node[] }).body);
-        }
-      }
-    };
-    runCallbacks(ast.program.body as unknown as Node[]);
-  } catch {
-    /* 收集尽力而为 */
-  } finally {
-    setCallCollector(null);
-    setModuleResolver(null);
-    setUnknownBuiltinHandler(null);
-  }
-  return records;
-}
-
-/** 测试框架的回调注册函数：回调体里是真实调用点 */
-const TEST_CALLBACK_NAMES = new Set(["it", "test", "describe"]);
-
-// --- 整文件 AnalysisResult memo（warm analyzeFile / LSP 重复文档） ---
-
-const externalRecordIds = new WeakMap<object, number>();
-let nextExternalRecordId = 1;
-
-function analysisFileCacheKey(
-  filePath: string,
-  source: string,
-  activeCases?: Map<string, number>,
-  externalCallRecords?: CallRecord[],
-): { filePath: string; source: string; auxKey: string } {
-  let cases = "-";
-  if (activeCases && activeCases.size > 0) {
-    cases = [...activeCases.entries()]
-      .sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
-      .map(([k, v]) => `${k}=${v}`)
-      .join(",");
-  }
-  let ext = "-";
-  if (externalCallRecords && externalCallRecords.length > 0) {
-    let id = externalRecordIds.get(externalCallRecords);
-    if (id === undefined) {
-      id = nextExternalRecordId++;
-      externalRecordIds.set(externalCallRecords, id);
-    }
-    ext = `n${externalCallRecords.length}#id${id}`;
-  }
-  return {
-    filePath,
-    // 尾部无 @nudo 注释/空行不进键：comment-only 编辑命中 AnalysisResult
-    source: stableAnalyzeKeySource(source),
-    auxKey: `${cases}\0${ext}`,
-  };
-}
-
-function cloneAnalysisResult(r: AnalysisResult): AnalysisResult {
-  return {
-    functions: r.functions.map(cloneFunctionAnalysis),
-    diagnostics: r.diagnostics.map((d) => ({ ...d })),
-    bindings: new Map(r.bindings),
-    // Node 键与 AST LRU 共享身份；Map 浅拷贝即可
-    nodeTypeMap: new Map(r.nodeTypeMap),
-    caseHints: r.caseHints.map((h) => ({ ...h })),
-    ...(r.externalFunctions
-      ? { externalFunctions: r.externalFunctions.map(cloneFunctionAnalysis) }
-      : {}),
-  };
-}
-
-// --- 函数级 FunctionAnalysis 缓存（body-edit：只重算脏函数及其调用者） ---
-
-function cloneFunctionAnalysis(a: FunctionAnalysis): FunctionAnalysis {
-  return {
-    ...a,
-    paramNames: [...a.paramNames],
-    cases: a.cases.map((c) => ({
-      ...c,
-      args: [...c.args],
-      ...(c.intension ? { intension: { ...c.intension } } : {}),
-    })),
-    loc: { start: { ...a.loc.start }, end: { ...a.loc.end } },
-  };
-}
-
-function shiftSourceLoc(loc: SourceLocation, lineDelta: number): SourceLocation {
-  return {
-    start: { line: loc.start.line + lineDelta, column: loc.start.column },
-    end: { line: loc.end.line + lineDelta, column: loc.end.column },
-  };
-}
-
-function shiftDiagnosticLines(d: Diagnostic, lineDelta: number): Diagnostic {
-  if (lineDelta === 0) return { ...d };
-  const out: Diagnostic = { ...d, range: shiftSourceLoc(d.range, lineDelta) };
-  if (d.origin) {
-    out.origin = { line: d.origin.line + lineDelta, column: d.origin.column };
-  }
-  return out;
-}
-
-function shiftCallRecordLines(r: CallRecord, lineDelta: number): CallRecord {
-  if (lineDelta === 0 || !r.callLoc) return { ...r };
-  return {
-    ...r,
-    callLoc: { line: r.callLoc.line + lineDelta, column: r.callLoc.column },
-  };
-}
-
-/**
- * 整文件分析。同 (path, source, cases, external) 命中 memo → O(1)。
- * 不再每次 clearBPathCache：B 路径按本文件 source 键控。
- *
- * 宿主契约：入口 source 未变但依赖模块内容变了时，必须调用
- * `evictBPathCacheForFiles` / `evictAnalysisFileCacheForFiles` /
- * `evictFnAnalysisCacheForFiles`（LSP 已接好）。非 LSP 宿主
- * （CLI watch / vite-plugin）在 dep 变更时应 `clearBPathCache()` 或上述逐出。
- */
-export function analyzeFile(filePath: string, source: string, activeCases?: Map<string, number>, externalCallRecords?: CallRecord[]): AnalysisResult {
-  const k = analysisFileCacheKey(filePath, source, activeCases, externalCallRecords);
-  const hit = analysisCacheGet<AnalysisResult>(k.filePath, k.source, k.auxKey);
-  if (hit !== undefined) {
-    return cloneAnalysisResult(hit);
-  }
-  const result = analyzeFileUncached(filePath, source, activeCases, externalCallRecords);
-  analysisCacheSet(k.filePath, k.source, k.auxKey, result);
-  return cloneAnalysisResult(result);
-}
-
-function analyzeFileUncached(filePath: string, source: string, activeCases?: Map<string, number>, externalCallRecords?: CallRecord[]): AnalysisResult {
-  // 外部实参里的闭包在使用现场文件定义——先打 usage-site 标记再进入任何
-  // 求值（case 合成重求值会执行它们，泄漏的错误记录靠此标记丢弃）。
-  for (const rec of externalCallRecords ?? []) {
-    for (const a of rec.argTypes) setUsageSiteTag(a);
-  }
-  const ast = parse(source);
-  const functions = extractDirectives(ast);
-  const diagnostics: Diagnostic[] = [];
-  const bindings = new Map<string, BindingInfo>();
-  const nodeTypeMap = new Map<Node, TypeValue>();
-  const functionResults: FunctionAnalysis[] = [];
-  const caseHints: CaseHint[] = [];
-
-  resetMemo();
-  resetUnreachableRanges();
-  resetEnvModules();
-  resetMockModules();
-  setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname(filePath));
-  setCurrentSource(source);
-
-  const fileDirectives = extractFileDirectives(ast);
-  const fileEnvNames = fileDirectives
-    .filter((d) => d.kind === "env")
-    .flatMap((d) => d.envs);
-
-  const projectConfig = findProjectConfig(dirname(filePath));
-  const projectEnvNames = projectConfig?.config.env ?? [];
-  const envNames = [...new Set([...projectEnvNames, ...fileEnvNames])];
-
-  setUnknownBuiltinHandler((name, loc) => {
-    // B 路径可分析时由静态收集器接管，避免双报
-    if (isBPathCapable(source, envNames)) return;
-    diagnostics.push({
-      range: loc ? { start: loc.start, end: loc.end } : { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } },
-      severity: "warning",
-      message: `Built-in API "${name}" is not covered by Nudo's type inference`,
-      code: "nudo:builtin-unknown",
-      suggestions: [
-        `Use @nudo:mock to define the type: @nudo:mock ${name} = stub().returns(...)`,
-        `Or use @nudo:refine return <constraint> to declare the return contract`,
-      ],
-    });
-  });
-
-  const globalEnv = createEnvironment();
-
-  {
-    const loaded = envNames.length > 0 ? loadEnvs(envNames, globalEnv) : { modules: {} };
-    const auto = autoHarvestModules(source, dirname(filePath));
-    const modules = { ...loaded.modules, ...auto };
-    if (Object.keys(modules).length > 0) setEnvModules(modules);
-  }
-
-  const mocks = new Map<string, { fromPath: string; names?: string[] }>();
-
-  if (projectConfig?.config.mocks) {
-    for (const [source, mockPath] of Object.entries(projectConfig.config.mocks)) {
-      mocks.set(source, { fromPath: resolve(projectConfig.projectDir, mockPath) });
-    }
-  }
-
-  const mockModuleDirectives = fileDirectives.filter((d) => d.kind === "mock-module");
-  for (const d of mockModuleDirectives) {
-    mocks.set(d.source, { fromPath: d.fromPath, names: d.names });
-  }
-
-  if (mocks.size > 0) {
-    setMockModules(mocks);
-  }
-
-  const callRecords: CallRecord[] = [];
-  setCallCollector((record) => callRecords.push(record));
-
-  const unknownRecords: UnknownRecord[] = [];
-  setUnknownCollector((r) => unknownRecords.push(r));
-
-  setProvenanceTracking(true);
-
-  /** B 路径已报告的 method/property 名（避免 TypeValue 双报） */
-  const bMemberDiagNames = new Set<string>();
-  const bMemberDiagSeen = new Set<string>();
-  const pushBMemberDiag = (d: { kind: string; name: string; receiver: string; line?: number; column?: number; origin?: { line: number; column: number } }, fallbackLine: number) => {
-    bMemberDiagNames.add(d.name);
-    const key = `${d.kind}:${d.name}:${d.receiver}:${d.line ?? fallbackLine}:${d.column ?? 0}`;
-    if (bMemberDiagSeen.has(key)) return;
-    bMemberDiagSeen.add(key);
-    // unknown 接收者 → unknown-recv（与 TypeValue 口径一致，warning）
-    if (d.receiver === "unknown") {
-      diagnostics.push({
-        range: {
-          start: { line: d.line ?? fallbackLine, column: d.column ?? 0 },
-          end: { line: d.line ?? fallbackLine, column: (d.column ?? 0) + d.name.length },
-        },
-        severity: "warning",
-        message: `Cannot resolve '${d.name}' on unknown value`,
-        code: "nudo:unknown-recv",
-        ...(d.origin ? { origin: d.origin } : {}),
-      });
-      return;
-    }
-    diagnostics.push({
-      range: {
-        start: { line: d.line ?? fallbackLine, column: d.column ?? 0 },
-        end: { line: d.line ?? fallbackLine, column: (d.column ?? 0) + d.name.length },
-      },
-      severity:
-        d.receiver === "number" || d.receiver === "boolean" || d.receiver === "bigint" || d.receiver === "symbol"
-          ? "error"
-          : "warning",
-      message:
-        d.kind === "method"
-          ? `Method '${d.name}' does not exist on type '${d.receiver}'`
-          : `Property '${d.name}' does not exist on type '${d.receiver}'`,
-      code: "nudo:no-method",
-      ...(d.origin ? { origin: d.origin } : {}),
-    });
-  };
-
-  // @nudo:mock 绑定必须先于全程序求值：顶层调用点（如 mockHof([1,2,3])）
-  // 在 evaluateProgram 中执行并由 callCollector 记录 call@ case 的
-  // resultType——mock 晚于此绑定会让「mock 函数值作为回调实参」在该路径
-  // 整体降级 unknown（@nudo:case 求值发生在下方循环内，此前不受影响）。
-  for (const fn of functions) {
-    applyMocks(fn.directives, globalEnv, filePath, diagnostics);
-  }
-
-  // @nudo:mock 已编译为 Abs seed 注入；env/require 强制 TypeValue 路径
-  const selfContained = isSelfContainedSource(source, envNames);
-  const canAbsModules = absModulesOk(source, envNames);
-  const bCapable = isBPathCapable(source, envNames);
-
-  /** B 已上报的模块加载问题种类 + 递归截断函数名（压 TypeValue 叠报） */
-  const bModuleIssueKinds = new Set<"cycle" | "depth" | "missing">();
-  const bTruncatedFns = new Set<string>();
-  /** B 静态 builtin-unknown 名（压 TypeValue unknown-global 叠报） */
-  const bBuiltinUnknownNames = new Set<string>();
-  /** B 成功跑通本文件 → TypeValue method/property 诊断整类让位 */
-  let bHostedEval = false;
-
-  const pushBModuleIssues = (
-    issues: Array<{ kind: "cycle" | "depth" | "missing"; label: string; reason: string }> | undefined,
-  ) => {
-    if (!issues) return;
-    for (const iss of issues) {
-      bModuleIssueKinds.add(iss.kind);
-      const code =
-        iss.kind === "cycle"
-          ? "nudo:module-cycle"
-          : iss.kind === "depth"
-            ? "nudo:module-depth"
-            : "nudo:module-missing";
-      diagnostics.push({
-        range: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-        severity: iss.kind === "missing" ? "error" : "warning",
-        message: iss.reason,
-        code,
-      });
-    }
-  };
-
-  const seeds = mockDirectivesToAbsSeeds(functions);
-  let absCallRecords: CallRecord[] = [];
-  /** B 顶层 $callNamed 记录（call@ 合成；TypeValue skip 后的主源） */
-  let bTopCallRecords: CallRecord[] = [];
-  /** 一次模块图 + 一次 evalProgramAbs 的共享产物（避免 B 路径 4+ 次重求值） */
-  let absGraphModules: Record<string, import("@nudojs/core").AbsModuleExports> | undefined;
-  let absBindsShared: Map<string, Abs> | undefined;
-  let absNodesShared: Map<Node, Abs> | undefined;
-
-  // B 模块图：cycle/depth/missing + 顶层 memberDiags（注入 @nudo:mock，
-  // 避免缩进 const 调到真 fetch；$callNamed 实参 loc 提供参数级 provenance）
-  if (bCapable && filePath) {
-    try {
-      const g = evalAbsModuleGraph(source, filePath, {
-        seedVars: seeds.seedVars,
-        seedFns: seeds.seedFns as never,
-      });
-      absGraphModules = g.modules;
-      pushBModuleIssues(g.issues);
-    } catch {
-      /* 模块图失败交还 TypeValue */
-    }
-    const bRun = tryRunBPath(source, filePath, {
-      envNames,
-      mocks: mockSeedsToAbsMocks(seeds),
-    });
-    if (bRun) {
-      bHostedEval = true;
-      if (bRun.memberDiags?.length) {
-        for (const d of bRun.memberDiags) {
-          pushBMemberDiag(d, 1);
-        }
-      }
-      if (bRun.truncatedFns) {
-        for (const fn of bRun.truncatedFns) bTruncatedFns.add(fn);
-      }
-      if (bRun.calls?.length) {
-        const impMap = buildAbsImportLocalMap(source, filePath);
-        for (const c of bRun.calls) {
-          const safeAbs = (a: Abs | undefined): TypeValue => {
-            if (!a || typeof a !== "object" || !("shape" in a) || !a.shape) {
-              return T.unknown;
-            }
-            try {
-              return absToTypeValue(a);
-            } catch {
-              return T.unknown;
-            }
-          };
-          const rec: CallRecord = {
-            fnName: c.fnName,
-            argTypes: c.args.map(safeAbs),
-            resultType: c.threw ? T.never : safeAbs(c.result),
-            throws: c.threw ? safeAbs(c.result) : T.never,
-            callLoc: c.callLoc,
-          };
-          const imp = impMap.get(c.fnName);
-          if (imp) {
-            rec.targetModule = imp.modulePath;
-            rec.targetExport = imp.exportName;
-          }
-          bTopCallRecords.push(rec);
-        }
-      }
-    }
-  }
-  if (selfContained || canAbsModules) {
-    // Abs 程序求值的递归截断（call@ 记录路径）；modules 已预计算时不再重跑模块图
-    setAbsTruncationCollector((label) => bTruncatedFns.add(label));
-    try {
-      absCallRecords = collectAbsCallRecords(source, seeds, filePath, absGraphModules);
-    } finally {
-      setAbsTruncationCollector(null);
-    }
-  }
-
-  // B hosted：跳过 TypeValue evaluateProgram。一次 eval 同时产出 bindings + nodeTypes。
-  if (bHostedEval) {
-    try {
-      const collected = collectAbsBindsAndNodes(source, seeds, absGraphModules);
-      absBindsShared = collected.binds;
-      absNodesShared = collected.nodes;
-      for (const [name, absVal] of absBindsShared) {
-        if (absVal?.shape?.k === "fn") continue;
-        if (!globalEnv.has(name)) {
-          globalEnv.bind(name, absToTypeValue(absVal));
-        }
-      }
-      for (const [node, absVal] of absNodesShared) {
-        nodeTypeMap.set(node, absToTypeValue(absVal));
-      }
-    } catch {
-      /* Abs 补齐失败仍以 B 诊断为准 */
-    }
-  } else {
-    evaluateProgram(ast, globalEnv);
-  }
-
-  // Abs / B 顶层调用记录优先；再空才保留 TypeValue
-  if ((selfContained || canAbsModules) && absCallRecords.length > 0) {
-    callRecords.length = 0;
-    callRecords.push(...absCallRecords);
-  } else if (bTopCallRecords.length > 0) {
-    callRecords.length = 0;
-    callRecords.push(...bTopCallRecords);
-  }
-
-  const unreachableRanges = bCapable ? [] : getUnreachableRanges();
-  if (bCapable) {
-    // B 路径静态诊断接管 unreachable + builtin-unknown
-    // env/mock 已覆盖的全局不在 builtin-unknown 之列（B 注入后不再是裸原生调用）
-    const bKnownGlobals = new Set<string>([
-      ...Object.keys(collectEnvGlobals(envNames)),
-      ...Object.keys(mockSeedsToAbsMocks(seeds)),
-    ]);
-    const bDiag = collectBPathDiagnostics(source, bKnownGlobals);
-    for (const ur of bDiag.unreachable) {
-      diagnostics.push({
-        range: ur.range,
-        severity: "info",
-        message: "Code after return/throw statement is unreachable",
-        tags: ["unnecessary"],
-        code: "nudo-unreachable",
-        suggestions: ["Remove the unreachable code after the return/throw statement"],
-      });
-    }
-    for (const b of bDiag.builtinUnknown) {
-      bBuiltinUnknownNames.add(b.name);
-      diagnostics.push({
-        range: b.range,
-        severity: "warning",
-        message: `Built-in API "${b.name}" is not covered by Nudo's type inference`,
-        code: "nudo:builtin-unknown",
-        suggestions: [
-          `Use @nudo:mock to define the type: @nudo:mock ${b.name} = stub().returns(...)`,
-          `Or use @nudo:refine return <constraint> to declare the return contract`,
-        ],
-      });
-    }
-  } else {
-    for (const ur of unreachableRanges) {
-      diagnostics.push({
-        range: ur,
-        severity: "info",
-        message: "Code after return/throw statement is unreachable",
-        tags: ["unnecessary"],
-        code: "nudo-unreachable",
-        suggestions: ["Remove the unreachable code after the return/throw statement"],
-      });
-    }
-  }
-
-  collectBindings(ast, globalEnv, bindings);
-
-  // B 路径可分析：用 Abs 模块图补全/覆盖绑定（含相对 import）
-  if (isBPathCapable(source, envNames)) {
-    try {
-      const absBinds =
-        absBindsShared ??
-        collectAbsBindingsFromGraph(source, filePath, {
-          seedVars: seeds.seedVars,
-          seedFns: seeds.seedFns as never,
-        });
-      for (const [name, absVal] of absBinds) {
-        const prev = bindings.get(name);
-        bindings.set(name, {
-          type: absToTypeValue(absVal),
-          loc: prev?.loc,
-        });
-      }
-    } catch {
-      /* keep TypeValue bindings */
-    }
-  }
-
-  const synthCandidates: { name: string; node: Node; analysis: FunctionAnalysis }[] = [];
-
-  // 函数级指纹：body-edit 时未引用的兄弟函数可命中缓存
-  let fnFpMap: Map<string, { own: string; deps: string }> | undefined;
-  try {
-    fnFpMap = fnFingerprints(source, ast as never);
-  } catch {
-    fnFpMap = undefined;
-  }
-  const envKeyFn = envNames.join(",");
-  const mockKeyFn = mockSeedFingerprint(seeds.seedVars, seeds.seedFns);
-
-  for (const fn of functions) {
-    const isPure = fn.directives.some((d) => d.kind === "pure");
-    const skipDirective = fn.directives.find((d) => d.kind === "skip");
-
-    const fnLoc = locFromNode(fn.node);
-    const paramNames = extractParamNames(fn.node);
-    const analysis: FunctionAnalysis = { name: fn.name, loc: fnLoc, paramNames, cases: [] };
-
-    if (skipDirective && skipDirective.kind === "skip") {
-      analysis.skipped = true;
-      if (skipDirective.returns) {
-        analysis.combined = skipDirective.returns;
-      }
-      functionResults.push(analysis);
-      continue;
-    }
-
-    const caseDirectives = fn.directives.filter((d) => d.kind === "case");
-    const activeCaseIdx = activeCases?.get(fn.name) ?? 0;
-
-    // Per-fn cache is intentionally case-scoped: synthesized cases (no
-    // @nudo:case) are built from whole-file call records observed while
-    // evaluating *other* functions — own/deps fingerprints cannot see those
-    // call sites, so caching a synthesis result under own/deps would be
-    // unsound (sibling body-edit that changes a call to this fn would miss
-    // the fingerprint). Case-directive results are self-contained.
-    const fp = fnFpMap?.get(fn.name);
-    const fnCacheKey =
-      fp && caseDirectives.length > 0
-        ? [
-            filePath,
-            fp.own,
-            fp.deps,
-            String(activeCaseIdx),
-            caseDirectiveKey(caseDirectives, typeValueToString),
-            envKeyFn,
-            mockKeyFn,
-          ].join("\0")
-        : undefined;
-    const dLen0 = diagnostics.length;
-    const hLen0 = caseHints.length;
-    const cLen0 = callRecords.length;
-
-    if (fnCacheKey) {
-      const hitFn = fnAnalysisCacheGet(fnCacheKey);
-      if (hitFn) {
-        const cached = cloneFunctionAnalysis(hitFn.analysis as FunctionAnalysis);
-        // own-hash is position-free: sibling inserts shift lines. Rewrite loc
-        // onto the current AST and shift any cached line-relative fields.
-        const lineDelta = fnLoc.start.line - cached.loc.start.line;
-        cached.loc = fnLoc;
-        if (lineDelta !== 0) {
-          for (const c of cached.cases) {
-            if (c.throwLoc) c.throwLoc = shiftSourceLoc(c.throwLoc, lineDelta);
-          }
-        }
-        if (lineDelta === 0) {
-          diagnostics.push(...(hitFn.diagnostics as Diagnostic[]));
-          caseHints.push(...(hitFn.caseHints as CaseHint[]));
-          callRecords.push(...(hitFn.callRecords as CallRecord[]));
-        } else {
-          for (const d of hitFn.diagnostics as Diagnostic[]) {
-            diagnostics.push(shiftDiagnosticLines(d, lineDelta));
-          }
-          for (const h of hitFn.caseHints as CaseHint[]) {
-            caseHints.push({ ...h, line: h.line + lineDelta });
-          }
-          for (const r of hitFn.callRecords as CallRecord[]) {
-            callRecords.push(shiftCallRecordLines(r, lineDelta));
-          }
-        }
-        functionResults.push(cached);
-        continue;
-      }
-    }
-
-    if (isPure) {
-      const fnVal = globalEnv.has(fn.name) ? globalEnv.lookup(fn.name) : null;
-      if (fnVal && fnVal.kind === "function") {
-        (fnVal as any)._memoize = fn.name;
-      }
-    }
-
-    const sampleDirective = fn.directives.find((d) => d.kind === "sample");
-    if (sampleDirective && sampleDirective.kind === "sample") {
-      setSampleCount(sampleDirective.count);
-    } else {
-      setSampleCount(3);
-    }
-
-    if (caseDirectives.length === 0) {
-      synthCandidates.push({ name: fn.name, node: fn.node, analysis });
-    }
-
-    for (let ci = 0; ci < caseDirectives.length; ci++) {
-      const directive = caseDirectives[ci];
-      resetUnreachableRanges();
-
-      // B 路径主求值（capable）：analyze 模式 + $callNamed 采集。
-      // 成功则跳过 evaluateFunctionFull；失败再落 TypeValue。
-      let caseValue: TypeValue | undefined;
-      let caseAbs: Abs | undefined;
-      let caseThrows: TypeValue | undefined;
-      let fullResult: {
-        value: TypeValue;
-        throws: TypeValue;
-        throwLoc?: SourceLocation;
-      } | null = null;
-      let caseUnreachable: SourceLocation[] = [];
-
-      const bCapable = isBPathCapable(source, envNames);
-      // env fnSig impl 已在 B 注入中保留，B 可作主路径
-      const bPrimary = bCapable;
-      if (bCapable && filePath) {
-        const bFull = tryBPathCallFull(
-          source,
-          filePath,
-          fn.name,
-          directive.args.map((a) => typeValueToAbs(a)),
-          { collectCalls: true, envNames, mocks: mockSeedsToAbsMocks(seeds) },
-        );
-        const res = bFull?.result;
-        const weakUnknown =
-          !!res &&
-          res.shape.k === "unknown" &&
-          (!res.term || (res.term.op === "lit" && res.term.value === undefined));
-        const bOk = !!res && (bHostedEval || (!weakUnknown && res.conf !== "opaque"));
-        if (bOk && bFull && bPrimary) {
-          caseAbs = bFull.result;
-          caseValue = absToTypeValue(bFull.result);
-          caseThrows =
-            bFull.throws.shape.k !== "never" ? absToTypeValue(bFull.throws) : T.never;
-          fullResult = { value: caseValue, throws: caseThrows };
-          // B 执行期 method-missing 诊断（唯一权威来源；TypeValue 按名去重）
-          for (const d of bFull.memberDiags ?? []) {
-            pushBMemberDiag(d, fnLoc.start.line);
-          }
-          if (bFull.calls?.length) {
-            const impMap = buildAbsImportLocalMap(source, filePath);
-            const safeAbs = (a: Abs | undefined): TypeValue => {
-              if (!a || typeof a !== "object" || !("shape" in a) || !a.shape) {
-                return T.unknown;
-              }
-              try {
-                return absToTypeValue(a);
-              } catch {
-                return T.unknown;
-              }
-            };
-            for (const c of bFull.calls) {
-              const rec: CallRecord = {
-                fnName: c.fnName,
-                argTypes: c.args.map(safeAbs),
-                resultType: c.threw ? T.never : safeAbs(c.result),
-                throws: c.threw ? safeAbs(c.result) : T.never,
-                callLoc: c.callLoc,
-              };
-              const imp = impMap.get(c.fnName);
-              if (imp) {
-                rec.targetModule = imp.modulePath;
-                rec.targetExport = imp.exportName;
-              }
-              callRecords.push(rec);
-            }
-          }
-        }
-      }
-
-      if (!fullResult) {
-        if (bHostedEval) {
-          fullResult = { value: T.unknown, throws: T.never };
-          caseValue = T.unknown;
-        } else {
-          fullResult = evaluateFunctionFull(fn.node, directive.args, globalEnv);
-          caseUnreachable = [...getUnreachableRanges()];
-          caseValue = fullResult.value;
-          if ((selfContained || canAbsModules) && fullResult.value.kind !== "never") {
-            caseAbs = tryEvalAbsRaw(source, fn.name, directive.args, filePath, mockSeedsToAbsMocks(seeds));
-            if (caseAbs) {
-              const projected = absToTypeValue(caseAbs);
-              if (absIsBetter(projected, fullResult.value)) caseValue = projected;
-            }
-          }
-        }
-      }
-
-      const tv = caseValue!;
-      const throwsTv = caseThrows ?? fullResult.throws;
-
-      const caseEntry: CaseResult = {
-        name: directive.name,
-        args: directive.args,
-        result: tv,
-        throws: throwsTv,
-        throwLoc: fullResult.throwLoc,
-        expected: directive.expected,
-        source: "directive",
-      };
-      tryAttachIntension(caseEntry, source, fn.name);
-      if (caseAbs) attachAbsToIntension(caseEntry, caseAbs, fn.name);
-      analysis.cases.push(caseEntry);
-
-      if (directive.commentLine) {
-        const hasThrow = throwsTv.kind !== "never";
-        const resultStr = tv.kind !== "never" ? typeValueToString(tv) : "";
-        const throwStr = hasThrow ? `throws ${typeValueToString(throwsTv)}` : "";
-        const label = [resultStr, throwStr].filter(Boolean).join(" ");
-        const hintLabel = `=> ${label}`;
-
-        let ok = true;
-        if (directive.expected) {
-          ok = isSubtypeOf(tv, directive.expected);
-          if (!ok) {
-            diagnostics.push({
-              range: { start: { line: directive.commentLine, column: 0 }, end: { line: directive.commentLine, column: 999 } },
-              severity: "error",
-              message: `Case "${directive.name}": expected ${typeValueToString(directive.expected)}, got ${typeValueToString(tv)}. The inferred return type does not match the expected type declared in the @nudo:case directive`,
-              code: "nudo:case-expected",
-            });
-          }
-        }
-
-        caseHints.push({ line: directive.commentLine, label: hintLabel, ok });
-      }
-
-      const isActive = ci === Math.min(activeCaseIdx, caseDirectives.length - 1);
-
-      if (isActive) {
-        if (throwsTv.kind !== "never") {
-          const throwRange = fullResult?.throwLoc ?? fnLoc;
-          diagnostics.push({
-            range: throwRange,
-            severity: "warning",
-            message: `Function "${fn.name}" case "${directive.name}" may throw: ${typeValueToString(throwsTv)}. Consider adding a try-catch block or using @nudo:refine return <constraint>`,
-            code: "nudo-may-throw",
-          });
-        }
-
-        // B 路径可分析时文件级静态收集已报 unreachable，跳过 case 级
-        if (!isBPathCapable(source, envNames)) {
-          for (const ur of caseUnreachable) {
-            diagnostics.push({
-              range: ur,
-              severity: "info",
-              message: "Code after return/throw statement is unreachable",
-              tags: ["unnecessary"],
-              code: "nudo-unreachable",
-              suggestions: ["Remove the unreachable code after the return/throw statement"],
-            });
-          }
-        }
-      }
-    }
-
-    if (analysis.cases.length > 1) {
-      analysis.combined = collapseLiteralUnion(simplifyUnion(analysis.cases.map((c) => c.result)), COLLAPSE_LITERAL_THRESHOLD);
-    } else if (analysis.cases.length === 1) {
-      analysis.combined = analysis.cases[0].result;
-    }
-
-    if (fnCacheKey) {
-      fnAnalysisCacheSet(fnCacheKey, {
-        analysis: cloneFunctionAnalysis(analysis),
-        diagnostics: diagnostics.slice(dLen0),
-        caseHints: caseHints.slice(hLen0),
-        callRecords: callRecords.slice(cLen0),
-      });
-    }
-
-    functionResults.push(analysis);
-  }
-
-  // Whole-program call inference: functions without @nudo:case directives
-  // get cases synthesized from observed call sites; functions with no call
-  // sites at all get a single entry evaluation with unknown parameters.
-  const directiveFnNames = new Set(functions.map((f) => f.name));
-  const directiveFnStmts = new Set(functions.map((f) => f.node));
-  for (const { name, node, stmt, noDeclaration } of collectTopLevelFunctions(ast)) {
-    if (directiveFnNames.has(name)) continue;
-    // A statement carrying @nudo directives is already analyzed through the
-    // directive path above (possibly under its "<anonymous>" name).
-    if (directiveFnStmts.has(stmt)) continue;
-    const analysis: FunctionAnalysis = { name, loc: locFromNode(node), paramNames: extractParamNames(node), cases: [] };
-    if (noDeclaration) analysis.noDeclaration = true;
-    functionResults.push(analysis);
-    synthCandidates.push({ name, node, analysis });
-  }
-
-  // 模块路匹配的前置量：本文件绝对路径（realpath 对齐符号链接后再比，
-  // 双侧同一归一化函数，避免单侧 realpath 造成不一致），以及
-  // `module.exports = function` 单导出形态的目标函数。
-  const modulePathCache = new Map<string, string>();
-  const normalizeModulePath = (p: string): string => {
-    let n = modulePathCache.get(p);
-    if (n === undefined) {
-      try {
-        n = realpathSync(p);
-      } catch {
-        n = p;
-      }
-      modulePathCache.set(p, n);
-    }
-    return n;
-  };
-  const currentModulePath = normalizeModulePath(resolve(filePath));
-  const singleExportFn = findSingleModuleExportsFunction(ast);
-
-  for (const candidate of synthCandidates) {
-    // 调用点来源有两路：本文件求值中观察到的调用，以及外部注入的
-    // （使用现场文件——如测试——对本文导出函数的真实调用，CLI 经
-    // --callsites 收集后传入）。带 targetModule 的记录先判归属：只有
-    // 指向本文件的记录才允许参与匹配——导出名/别名离开模块单独无意义
-    // （单导出文件的 targetExport 全是 "default"，不判模块会跨文件误染，
-    // 如 clone.js 的记录命中 applyToDefaults.js 的 "default" candidate）。
-    // 归属本文件（或无模块信息的本地记录）后再走三路：
-    //  1. 名字路：fnName（调用处可见名）或 targetExport（定义处导出名）
-    //  2. 别名路：re-export 链上后来出现的导出名（evaluator 的
-    //     targetAliases，如 barrel / CJS 转发 shim 下的属性名）
-    //  3. 模块路：本文件以 `module.exports = function` 单导出时直接收
-    //     ——使用方可能以任意转发名调用它；多导出文件不走模块路，
-    //     避免同文件多函数误染。
-    const singleExportHit = singleExportFn !== null && candidate.node === singleExportFn;
-    const nameRoutes = (r: CallRecord): boolean =>
-      r.fnName === candidate.name ||
-      r.targetExport === candidate.name ||
-      (r.targetAliases?.includes(candidate.name) ?? false) ||
-      (singleExportHit && (r.fnModule !== undefined || r.targetModule !== undefined));
-    // 本地记录：来自本文件求值。带 targetModule 的（本文件导出被调用）
-    // 判归属；无 tag 的内部调用按名字匹配（一直以来的行为）。
-    const matchingLocal = (r: CallRecord): boolean => {
-      const targetsThisFile =
-        r.targetModule === undefined || normalizeModulePath(r.targetModule) === currentModulePath;
-      if (!targetsThisFile) return false;
-      return nameRoutes(r);
-    };
-    // 外部记录（使用现场收集）必须可归因到本文件：fnModule（定义位点——
-    // require 传递求值中库内部调用的记录）或 targetModule（导出 tag）。
-    // 无归因的记录是测试本地函数或裸内置名，按名字撞库属跨文件污染
-    // （实测：测试局部 compare() 撞 contain.js internals.compare）。
-    const matchingExternal = (r: CallRecord): boolean => {
-      const attributed =
-        (r.fnModule !== undefined && normalizeModulePath(r.fnModule) === currentModulePath) ||
-        (r.targetModule !== undefined && normalizeModulePath(r.targetModule) === currentModulePath);
-      if (!attributed) return false;
-      return nameRoutes(r);
-    };
-    // resultType=never 且 throws=never 是求值中断的信号泄漏（如
-    // `new Promise(async …)` 高阶 async 中 await 切断求值），无信息量，
-    // 注入会产出误导 case；本地与注入记录一致跳过，全部被跳过的
-    // candidate 自然落入下方 entry@ 回退。resultType=never 但 throws≠never
-    // 是真实的抛出调用（argTypes + throws 都有信息），保留。
-    const records = dedupeCallRecords(
-      [
-        ...callRecords.filter(matchingLocal),
-        ...(externalCallRecords ?? []).filter(matchingExternal),
-      ].filter((r) => !(r.resultType.kind === "never" && r.throws.kind === "never")),
-    );
-    if (records.length > 0) {
-      // 案例选择偏好：结果有信息量的记录优先（精确/字面量/结构化），
-      // unknown 结果的排后——收集顺序里错误路径或 undefined 形态的测试
-      // 常排在前面，slice 截断会把 concrete-precise 记录挤掉（hoek clone
-      // 的 682 条记录曾由 3 条 undefined 形态占满前 3 席）。
-      const informativeness = (r: CallRecord): number => {
-        if (r.resultType.kind === "unknown") return 2;
-        if (r.resultType.kind === "never") return 1;
-        return 0;
-      };
-      const ordered = records
-        .map((r, i) => ({ r, i }))
-        .sort((a, b) => informativeness(a.r) - informativeness(b.r) || a.i - b.i)
-        .map(({ r }) => r);
-      const precise = ordered.slice(0, MAX_PRECISE_CALLSITE_CASES);
-      for (const rec of precise) {
-        // Abs 重求值仅在更有信息量时覆盖（不破坏 mock/callsite 精确结构）
-        let absRaw: Abs | undefined;
-        let absResult: TypeValue | undefined;
-        if (rec.resultType.kind !== "never" && rec.argTypes.length > 0) {
-          absRaw = tryEvalAbsRaw(source, candidate.name, rec.argTypes, filePath, mockSeedsToAbsMocks(seeds));
-          if (absRaw) {
-            const projected = absToTypeValue(absRaw);
-            if (absIsBetter(projected, rec.resultType)) absResult = projected;
-          }
-        }
-        const caseResult: CaseResult = {
-          name: `call@L${rec.callLoc?.line ?? candidate.analysis.loc.start.line}`,
-          args: rec.argTypes,
-          result: absResult ?? rec.resultType,
-          throws: rec.throws,
-          source: "callsite",
-        };
-        tryAttachIntension(caseResult, source, candidate.name);
-        if (absRaw) attachAbsToIntension(caseResult, absRaw, candidate.name);
-        candidate.analysis.cases.push(caseResult);
-      }
-      // symbolic 聚合只用全已知实参的记录：含 unknown 分量的记录不可重求值
-      // （unknown 吸收整个 union，一条循环引用 fixture 的记录就能毒化全部
-      // 剩余聚合——clone 704 条中的 53 条 unknown 实参曾拖垮其余 651 条）。
-      // 排除不声明覆盖，sound；全部不可求值时不产 symbolic case（诚实）。
-      const remaining = ordered
-        .slice(MAX_PRECISE_CALLSITE_CASES)
-        .filter((rec) => !rec.argTypes.some((a) => a.kind === "unknown"));
-      if (remaining.length > 0) {
-        const fnNode = resolveFunctionNode(candidate.node);
-        const paramCount = extractParamNames(fnNode).length;
-        const widenedArgs = Array.from({ length: paramCount }, (_, i) =>
-          // 缺参按真实 JS 语义 widen 成 undefined 而非 unknown——可选参守卫
-          // （target || [] 等）对 unknown 全塌，对 undefined 正常走默认分支
-          widenType(simplifyUnion(remaining.map((rec) => rec.argTypes[i] ?? T.undefined))),
-        );
-        const absSymRaw = tryEvalAbs(source, candidate.name, widenedArgs, filePath, mockSeedsToAbsMocks(seeds));
-        const absSym = absSymRaw && absIsBetter(absSymRaw, /* 无先验：仅 unknown 时 */ { kind: "unknown" })
-          ? absSymRaw
-          : undefined;
-        // B 路径优先（capable）；否则 TypeValue，Abs 仅在 unknown 时补
-        let symValue: TypeValue | undefined;
-        let symThrows: TypeValue = T.never as TypeValue;
-        let symLoc: SourceLocation | undefined;
-        let symAbs: Abs | undefined;
-        if (isBPathCapable(source, envNames) && filePath) {
-          const bSym = tryBPathCall(
-            source,
-            filePath,
-            candidate.name,
-            widenedArgs.map((a) => typeValueToAbs(a)),
-            { envNames, mocks: mockSeedsToAbsMocks(seeds) },
-          );
-          if (bSym && (bHostedEval || !(bSym.shape.k === "unknown" && !bSym.term))) {
-            symAbs = bSym;
-            symValue = absToTypeValue(bSym);
-          }
-        }
-        if (!symAbs && !bHostedEval) {
-          const full = evaluateFunctionFull(fnNode, widenedArgs, globalEnv);
-          symValue = full.value.kind === "unknown" && absSym ? absSym : full.value;
-          symThrows = full.throws;
-          symLoc = full.throwLoc;
-        }
-        const symCase: CaseResult = {
-          name: "call@symbolic",
-          args: widenedArgs,
-          result: symValue ?? T.unknown,
-          throws: symThrows,
-          throwLoc: symLoc,
-          source: "callsite",
-          aggregatedFrom: remaining.length,
-        };
-        tryAttachIntension(symCase, source, candidate.name);
-        if (symAbs) attachAbsToIntension(symCase, symAbs, candidate.name);
-        candidate.analysis.cases.push(symCase);
-      }
-      // Combined covers every observed call site (not just the retained
-      // cases), so a large set of same-base literal results collapses to
-      // the widened base type instead of a 20-literal union.
-      candidate.analysis.combined = collapseLiteralUnion(
-        simplifyUnion(records.map((r) => r.resultType)),
-        COLLAPSE_LITERAL_THRESHOLD,
-      );
-      continue;
-    }
-
-    const fnNode = resolveFunctionNode(candidate.node);
-    const args = extractParamNames(fnNode).map(() => T.unknown);
-    // B 路径主求值（capable）；失败再 Abs ast-eval / TypeValue
-    let entryValue: TypeValue | undefined;
-    let entryThrows: TypeValue = T.never as TypeValue;
-    let entryLoc: SourceLocation | undefined;
-    let entryAbs: Abs | undefined;
-    if (isBPathCapable(source, envNames) && filePath) {
-      const bEntryFull = tryBPathCallFull(
-        source,
-        filePath,
-        candidate.analysis.name,
-        args.map((a) => typeValueToAbs(a)),
-        { envNames, mocks: mockSeedsToAbsMocks(seeds), collectMemberDiags: true },
-      );
-      if (bEntryFull?.memberDiags?.length) {
-        for (const d of bEntryFull.memberDiags) {
-          pushBMemberDiag(d, candidate.analysis.loc.start.line);
-        }
-      }
-      const bEntry = bEntryFull?.result;
-      if (bEntry && (bHostedEval || !(bEntry.shape.k === "unknown" && !bEntry.term))) {
-        entryAbs = bEntry;
-        entryValue = absToTypeValue(bEntry);
-      }
-    }
-    if (!entryValue) {
-      if (bHostedEval) {
-        entryValue = T.unknown;
-        entryThrows = T.never as TypeValue;
-      } else {
-        const absEntry = tryEvalEntryAbs(source, candidate.analysis.name, args, filePath, seeds.seedVars);
-        const full = absEntry
-          ? { value: absEntry, throws: T.never as TypeValue, throwLoc: undefined }
-          : evaluateFunctionFull(fnNode, args, globalEnv);
-        entryValue = full.value;
-        entryThrows = full.throws;
-        entryLoc = full.throwLoc;
-      }
-    }
-    const caseResult: CaseResult = {
-      name: `entry@L${candidate.analysis.loc.start.line}`,
-      args,
-      result: entryValue,
-      throws: entryThrows,
-      throwLoc: entryLoc,
-    };
-    // display 来自 generalize；attachAbs 补无损 abs 字段（后写覆盖 abs/conf）
-    tryAttachIntension(caseResult, source, candidate.analysis.name);
-    if (entryAbs) attachAbsToIntension(caseResult, entryAbs, candidate.analysis.name);
-    candidate.analysis.cases.push(caseResult);
-    candidate.analysis.entryOnly = true;
-    candidate.analysis.combined = collapseLiteralUnion(entryValue, COLLAPSE_LITERAL_THRESHOLD);
-  }
-
-  if (!bHostedEval) {
-    buildNodeTypeMap(ast, globalEnv, nodeTypeMap);
-  }
-
-  setUnknownBuiltinHandler(null);
-  setCallCollector(null);
-  setUnknownCollector(null);
-  setProvenanceTracking(false);
-  setModuleResolver(null);
-  resetEnvModules();
-  resetMockModules();
-
-  // usage-site 执行泄漏守卫：case 合成重求值会执行注入实参携带的使用现场
-  // 闭包体（测试回调），其内部错误记录属于使用现场文件——不能记在本文件
-  // 名下（wait.js 曾背着 test/index.js:2407 的 no-method；json-ext 的
-  // slices.map 行号落在本文件行数内骗过纯行数守卫）。标记在 analyzeFile
-  // 入口处打；行数上限保留兜底（防无标记路径）。
-  const maxLine = source.split("\n").length;
-  diagnostics.push(
-    ...unknownRecordsToDiagnostics(
-      unknownRecords.filter((r) => {
-        if ((r.loc?.line ?? 0) > maxLine) return false;
-        if (r.originModule === USAGE_SITE_MODULE) return false;
-        // B 成功宿主本文件：TypeValue method/property 整类让位
-        //（transpile + ast-eval 成员分派均记 memberDiags）
-        if (bHostedEval && (r.kind === "method" || r.kind === "property")) {
-          return false;
-        }
-        // B 执行期已报的名（B 未 hosted 时兜底去重）
-        if ((r.kind === "method" || r.kind === "property") && bMemberDiagNames.has(r.name)) {
-          return false;
-        }
-        // B 模块图已报的 cycle/depth/missing：TypeValue loadModuleEnv 不再叠报
-        if (r.kind === "global") {
-          if (r.name.startsWith("module-cycle:") && bModuleIssueKinds.has("cycle")) return false;
-          if (r.name.startsWith("module-depth:") && bModuleIssueKinds.has("depth")) return false;
-          if (r.name.startsWith("module-missing:") && bModuleIssueKinds.has("missing")) return false;
-          // Abs 调用预算已截断的递归：不再由 TypeValue 记 recursion:*
-          if (r.name.startsWith("recursion:")) {
-            const fn = r.name.slice("recursion:".length);
-            if (bTruncatedFns.has(fn) || bTruncatedFns.has(fn.split(".").pop() ?? fn)) {
-              return false;
-            }
-          }
-          // B 静态 builtin-unknown 已报的裸标识符：不再 unknown-global 叠报
-          if (bBuiltinUnknownNames.has(r.name)) return false;
-        }
-        return true;
-      }),
-    ),
-  );
-
-  const externalFunctions = synthesizeExternalFunctions(callRecords, filePath);
-
-  return {
-    functions: functionResults,
-    diagnostics,
-    bindings,
-    nodeTypeMap,
-    caseHints,
-    ...(externalFunctions.length > 0 ? { externalFunctions } : {}),
-  };
-}
-
-function collectBindings(ast: Node, env: Environment, bindings: Map<string, BindingInfo>): void {
-  if (ast.type !== "File") return;
-  for (const stmt of (ast as any).program.body) {
-    if (stmt.type === "FunctionDeclaration" && stmt.id) {
-      const val = env.has(stmt.id.name) ? env.lookup(stmt.id.name) : T.unknown;
-      bindings.set(stmt.id.name, { type: val, loc: locFromNode(stmt) });
-    }
-    if (stmt.type === "VariableDeclaration") {
-      for (const decl of stmt.declarations) {
-        if (decl.id.type === "Identifier") {
-          const val = env.has(decl.id.name) ? env.lookup(decl.id.name) : T.unknown;
-          bindings.set(decl.id.name, { type: val, loc: locFromNode(decl) });
-        }
-      }
-    }
-    if (stmt.type === "ClassDeclaration" && stmt.id) {
-      const val = env.has(stmt.id.name) ? env.lookup(stmt.id.name) : T.unknown;
-      bindings.set(stmt.id.name, { type: val, loc: locFromNode(stmt) });
-    }
-    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
-      collectBindings({ type: "File", program: { type: "Program", body: [stmt.declaration] } } as any, env, bindings);
-    }
-  }
-}
-
-function buildNodeTypeMap(ast: Node, env: Environment, nodeTypeMap: Map<Node, TypeValue>): void {
-  const traverseFn = (typeof traverse === "function" ? traverse : (traverse as any).default) as typeof traverse;
-  try {
-    traverseFn(ast, {
-      enter(path) {
-        const node = path.node;
-        try {
-          if (
-            node.type === "Identifier" &&
-            node.name !== "undefined" &&
-            path.parentPath?.node.type !== "FunctionDeclaration" &&
-            path.parentPath?.node.type !== "VariableDeclarator"
-          ) {
-            if (env.has(node.name)) {
-              nodeTypeMap.set(node, env.lookup(node.name));
-            }
-          }
-          if (node.type === "NumericLiteral") {
-            nodeTypeMap.set(node, T.literal(node.value));
-          }
-          if (node.type === "StringLiteral") {
-            nodeTypeMap.set(node, T.literal(node.value));
-          }
-          if (node.type === "BooleanLiteral") {
-            nodeTypeMap.set(node, T.literal(node.value));
-          }
-          if (node.type === "NullLiteral") {
-            nodeTypeMap.set(node, T.null);
-          }
-        } catch {
-          // skip nodes that fail
-        }
-      },
-    });
-  } catch {
-    // traverse may fail on partial ASTs
-  }
-}
-
-export type CaseInfo = {
-  functionName: string;
-  caseName: string;
-  caseIndex: number;
-};
-
-export function getCasesForFile(filePath: string, source: string): { functionName: string; cases: { name: string; index: number }[]; loc: SourceLocation }[] {
-  const ast = parse(source);
-  const functions = extractDirectives(ast);
-  return functions.map((fn) => {
-    const cases = fn.directives
-      .filter((d) => d.kind === "case")
-      .map((d, i) => ({ name: d.name, index: i }));
-    return { functionName: fn.name, cases, loc: locFromNode(fn.node) };
-  });
-}
-
-/** Async entry to getTypeAtPosition with path-env preloading (see analyzeFileAsync). */
-export async function getTypeAtPositionAsync(
-  filePath: string,
-  source: string,
-  line: number,
-  column: number,
-  activeCases?: Map<string, number>,
-): Promise<TypeValue | null> {
-  const envNames = collectEnvNames(filePath, source, false);
-  if (envNames.length > 0) {
-    await preloadPathEnvs(envNames, dirname(filePath));
-  }
-  return getTypeAtPosition(filePath, source, line, column, activeCases);
-}
-
-export function getTypeAtPosition(
-  filePath: string,
-  source: string,
-  line: number,
-  column: number,
-  activeCases?: Map<string, number>,
-): TypeValue | null {
-  const ast = parse(source);
-  const fileDirectives = extractFileDirectives(ast);
-  const envNames = fileDirectives
-    .filter((d) => d.kind === "env")
-    .flatMap((d) => d.envs);
-
-  // B 路径 capable：节点表来自 evalProgramAbs（模块图注入），不跑 TypeValue evaluateProgram
-  if (isBPathCapable(source, envNames)) {
-    try {
-      const seeds = mockDirectivesToAbsSeeds(extractDirectives(ast));
-      const { modules } = evalAbsModuleGraph(source, filePath);
-      const absNodes = collectAbsNodeTypes(source, {
-        ...seeds,
-        modules,
-        file: ast as never,
-      });
-      const absAt = findAbsAtPosition(absNodes, line, column);
-      if (absAt) return absToTypeValue(absAt);
-      // 标识符绑定兜底
-      const ident = findIdentNameAtPosition(source, line, column, ast);
-      if (ident) {
-        const binds = collectAbsBindingsFromGraph(source, filePath, {
-          seedVars: seeds.seedVars,
-          seedFns: seeds.seedFns as never,
-        });
-        const bound = binds.get(ident);
-        if (bound) return absToTypeValue(bound);
-      }
-    } catch {
-      /* fall through to TypeValue */
-    }
-  }
-
-  resetMemo();
-  resetEnvModules();
-  setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname(filePath));
-  setCurrentSource(source);
-
-  const globalEnv = createEnvironment();
-
-  {
-    const loaded = envNames.length > 0 ? loadEnvs(envNames, globalEnv) : { modules: {} };
-    const auto = autoHarvestModules(source, dirname(filePath));
-    const modules = { ...loaded.modules, ...auto };
-    if (Object.keys(modules).length > 0) setEnvModules(modules);
-  }
-
-  evaluateProgram(ast, globalEnv);
-
-  const nodeTypeMap = new Map<Node, TypeValue>();
-  buildNodeTypeMap(ast, globalEnv, nodeTypeMap);
-
-  const functions = extractDirectives(ast);
-  const enclosingFn = findEnclosingFunction(functions, line);
-
-  if (enclosingFn) {
-    const caseDirectives = enclosingFn.directives.filter((d) => d.kind === "case");
-    if (caseDirectives.length > 0) {
-      const caseIndex = activeCases?.get(enclosingFn.name) ?? 0;
-      const directive = caseDirectives[Math.min(caseIndex, caseDirectives.length - 1)];
-
-      const fnNodeTypeMap = new Map<Node, TypeValue>();
-      setNodeTypeCollector((node, tv) => fnNodeTypeMap.set(node, tv));
-      evaluateFunctionFull(enclosingFn.node, directive.args, globalEnv);
-      setNodeTypeCollector(null);
-
-      for (const [node, tv] of fnNodeTypeMap) {
-        nodeTypeMap.set(node, tv);
-      }
-    }
-  }
-
-  setModuleResolver(null);
-  resetEnvModules();
-  resetMockModules();
-  return findBestTypeAtPosition(nodeTypeMap, globalEnv, ast, line, column);
-}
-
-export type HoverInfo = {
-  /** 外延 TypeValue 展示（bridge 有损，仅兜底） */
-  typeText: string;
-  /** 内涵签名（代数 generalize） */
-  intension?: string;
-  /** 无损 Abs 单行展示（shape / term / pred / conf） */
-  abs?: string;
-  /** 无损 Abs 多行展示 */
-  absMultiline?: string;
-};
-
-/**
- * LSP hover：优先无损 Abs（类型即计算本体），TypeValue 仅作外延对照。
- * 节点表也是 Abs（collectAbsNodeTypes），不经 bridge。
- */
-export function getHoverAtPosition(
-  filePath: string,
-  source: string,
-  line: number,
-  column: number,
-  activeCases?: Map<string, number>,
-): HoverInfo | null {
-  let file: ReturnType<typeof parse> | undefined;
-  try {
-    file = parse(source);
-  } catch {
-    file = undefined;
-  }
-  const envNames = collectEnvNames(filePath, source, false);
-
-  // B 路径：优先 Abs 节点表 / 标识符绑定，不经 TypeValue evaluateProgram
-  if (isBPathCapable(source, envNames)) {
-    try {
-      const seeds = mockDirectivesToAbsSeeds(extractDirectives(file ?? parse(source)));
-      const { modules } = evalAbsModuleGraph(source, filePath);
-      const absNodes = collectAbsNodeTypes(source, {
-        ...seeds,
-        modules,
-        ...(file ? { file: file as never } : {}),
-      });
-      const absAt = findAbsAtPosition(absNodes, line, column);
-      const ident = findIdentNameAtPosition(source, line, column, file);
-      if (ident && !findFunctionNameAtPosition(source, line, column, file)) {
-        const binds = collectAbsBindingsFromGraph(source, filePath, {
-          seedVars: seeds.seedVars,
-          seedFns: seeds.seedFns as never,
-        });
-        const bound = binds.get(ident);
-        if (bound) {
-          const absLine = formatAbs(bound);
-          const absMulti = formatAbsMultiline(bound, ident);
-          return { typeText: absLine, abs: absLine, absMultiline: absMulti };
-        }
-      }
-      if (absAt) {
-        const absLine = formatAbs(absAt);
-        const absMulti = formatAbsMultiline(absAt, undefined);
-        return { typeText: absLine, abs: absLine, absMultiline: absMulti };
-      }
-    } catch {
-      /* fall through */
-    }
-  }
-
-  const tv = getTypeAtPosition(filePath, source, line, column, activeCases);
-  const info: HoverInfo | null = tv ? { typeText: typeValueToString(tv) } : null;
-
-  const fnName = findFunctionNameAtPosition(source, line, column, file);
-  if (fnName) {
-    try {
-      const g = generalizeFromAst(fnName, source, file ? { file } : {});
-      if (g) {
-        if (info) {
-          info.intension = g.display;
-          info.abs = formatAbs(g.symbolic);
-          info.absMultiline = formatAbsMultiline(g.symbolic, fnName);
-        } else {
-          return {
-            typeText: g.display,
-            intension: g.display,
-            abs: formatAbs(g.symbolic),
-            absMultiline: formatAbsMultiline(g.symbolic, fnName),
-          };
-        }
-      }
-    } catch {
-      // ignore
-    }
-  }
-
-  // 标识符绑定优先（比粗粒度节点表更准）
-  const ident = findIdentNameAtPosition(source, line, column, file);
-  if (ident && !fnName) {
-    try {
-      // 经模块图（相对 + 裸包）求 Abs 绑定
-      if (isBPathCapable(source, []) || !/\brequire\s*\(/.test(source)) {
-        const seeds = mockDirectivesToAbsSeeds(extractDirectives(file ?? parse(source)));
-        const absBinds = collectAbsBindingsFromGraph(source, filePath, {
-          seedVars: seeds.seedVars,
-          seedFns: seeds.seedFns as never,
-        });
-        const absBound = absBinds.get(ident);
-        if (absBound) {
-          const absLine = formatAbs(absBound);
-          const absMulti = formatAbsMultiline(absBound, ident);
-          if (info) {
-            info.abs = absLine;
-            info.absMultiline = absMulti;
-            return info;
-          }
-          return { typeText: absLine, abs: absLine, absMultiline: absMulti };
-        }
-      }
-    } catch {
-      // ignore
-    }
-  }
-
-  // 任意表达式：Abs 节点表（无损）
-  try {
-    if (isBPathCapable(source, []) || !/\brequire\s*\(|\bimport\s*[{'"*]/.test(source)) {
-      const seeds = mockDirectivesToAbsSeeds(
-        extractDirectives(file ?? parse(source)),
-      );
-      const { modules } = evalAbsModuleGraph(source, filePath);
-      const nodeTypes = collectAbsNodeTypes(source, {
-        ...seeds,
-        modules,
-        ...(file ? { file } : {}),
-      });
-      const absAt = findAbsAtPosition(nodeTypes, line, column);
-      if (absAt) {
-        const absLine = formatAbs(absAt);
-        const absMulti = formatAbsMultiline(absAt, undefined);
-        if (info) {
-          info.abs = absLine;
-          info.absMultiline = absMulti;
-        } else {
-          return { typeText: absLine, abs: absLine, absMultiline: absMulti };
-        }
-      }
-    }
-  } catch {
-    // ignore
-  }
-
-  return info;
-}
-
-/** 光标处任意标识符（绑定 hover） */
-function findIdentNameAtPosition(
-  source: string,
-  line: number,
-  column: number,
-  fileAst?: ReturnType<typeof parse>,
-): string | undefined {
-  try {
-    const ast = fileAst ?? parse(source);
-    let found: string | undefined;
-    traverse(ast, {
-      Identifier(path) {
-        const loc = path.node.loc;
-        if (!loc) return;
-        if (loc.start.line !== line) return;
-        if (column < loc.start.column || column > loc.end.column) return;
-        found = path.node.name;
-      },
-    });
-    return found;
-  } catch {
-    return undefined;
-  }
-}
-
-/** 光标处标识符是否是顶层/导出函数名 */
-function findFunctionNameAtPosition(
-  source: string,
-  line: number,
-  column: number,
-  fileAst?: ReturnType<typeof parse>,
-): string | undefined {
-  try {
-    const ast = fileAst ?? parse(source);
-    let found: string | undefined;
-    traverse(ast, {
-      Identifier(path) {
-        const loc = path.node.loc;
-        if (!loc) return;
-        if (loc.start.line !== line) return;
-        if (column < loc.start.column || column > loc.end.column) return;
-        // 仅函数声明 id / 调用 callee；const x = 1 的 id 归绑定路径
-        const parent = path.parent;
-        if (
-          parent.type === "FunctionDeclaration" &&
-          parent.id === path.node
-        ) {
-          found = path.node.name;
-        } else if (
-          parent.type === "CallExpression" &&
-          parent.callee === path.node
-        ) {
-          found = path.node.name;
-        }
-      },
-    });
-    return found;
-  } catch {
-    return undefined;
-  }
-}
-
-function findEnclosingFunction(
-  functions: FunctionWithDirectives[],
-  line: number,
-): FunctionWithDirectives | null {
-  for (const fn of functions) {
-    const loc = fn.node.loc;
-    if (!loc) continue;
-    if (loc.start.line <= line && loc.end.line >= line) {
-      return fn;
-    }
-  }
-  return null;
-}
-
-function findBestTypeAtPosition(
-  nodeTypeMap: Map<Node, TypeValue>,
-  globalEnv: Environment,
-  ast: Node,
-  line: number,
-  column: number,
-): TypeValue | null {
-  let bestMatch: TypeValue | null = null;
-  let bestSize = Infinity;
-
-  for (const [node, tv] of nodeTypeMap) {
-    const loc = node.loc;
-    if (!loc) continue;
-    if (
-      loc.start.line <= line &&
-      loc.end.line >= line &&
-      (loc.start.line < line || loc.start.column <= column) &&
-      (loc.end.line > line || loc.end.column >= column)
-    ) {
-      const size = (loc.end.line - loc.start.line) * 10000 + (loc.end.column - loc.start.column);
-      if (size < bestSize) {
-        bestSize = size;
-        bestMatch = tv;
-      }
-    }
-  }
-
-  if (!bestMatch) {
-    const identAtPos = findIdentifierAtPosition(ast, line, column);
-    if (identAtPos && globalEnv.has(identAtPos)) {
-      bestMatch = globalEnv.lookup(identAtPos);
-    }
-  }
-
-  return bestMatch;
-}
-
-function findIdentifierAtPosition(ast: Node, line: number, column: number): string | null {
-  let found: string | null = null;
-  const traverseFn = (typeof traverse === "function" ? traverse : (traverse as any).default) as typeof traverse;
-  try {
-    traverseFn(ast, {
-      Identifier(path) {
-        const loc = path.node.loc;
-        if (!loc) return;
-        if (
-          loc.start.line === line &&
-          loc.start.column <= column &&
-          loc.end.column >= column
-        ) {
-          found = path.node.name;
-          path.stop();
-        }
-      },
-    });
-  } catch {
-    // ignore
-  }
-  return found;
-}
-
-export function getCompletionsAtPosition(
-  filePath: string,
-  source: string,
-  line: number,
-  column: number,
-): CompletionItem[] {
-  const textBefore = getTextBeforePosition(source, line, column);
-  const dotMatch = textBefore.match(/(\w+)\.\s*\w*$/);
-  if (!dotMatch) return getVariableCompletions(filePath, source);
-
-  const objName = dotMatch[1];
-
-  const safeSource = sanitizeSourceForParsing(source);
-
-  let ast;
-  try {
-    ast = parse(safeSource);
-  } catch {
-    try {
-      ast = parse(source);
-    } catch {
-      return [];
-    }
-  }
-
-  resetMemo();
-  setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname(filePath));
-
-  const globalEnv = createEnvironment();
-  evaluateProgram(ast, globalEnv);
-
-  if (!globalEnv.has(objName)) {
-    setModuleResolver(null);
-    return [];
-  }
-
-  const objType = globalEnv.lookup(objName);
-  const completions = getCompletionsForType(objType);
-
-  setModuleResolver(null);
-  return completions;
-}
-
-function sanitizeSourceForParsing(source: string): string {
-  return source.replace(/(\w+)\.\s*$/gm, "$1._ ");
-}
-
-function getTextBeforePosition(source: string, line: number, column: number): string {
-  const lines = source.split("\n");
-  if (line < 1 || line > lines.length) return "";
-  return lines[line - 1].slice(0, column);
-}
-
-function getVariableCompletions(filePath: string, source: string): CompletionItem[] {
-  const ast = parse(source);
-  resetMemo();
-  setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname(filePath));
-
-  const globalEnv = createEnvironment();
-  evaluateProgram(ast, globalEnv);
-
-  const ownBindings = globalEnv.getOwnBindings();
-  const completions: CompletionItem[] = [];
-  for (const [name, tv] of Object.entries(ownBindings)) {
-    if (name.startsWith("__export_")) continue;
-    completions.push({
-      label: name,
-      kind: tv.kind === "function" ? "method" : "variable",
-      detail: typeValueToString(tv),
-    });
-  }
-
-  setModuleResolver(null);
-  return completions;
-}
-
-/**
- * 内置成员的真实签名：把「<类>.prototype.<成员>」交给 evaluator 微求值。
- * 这是唯一真值来源（与诊断/求值同表——BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS），
- * 不在补全侧另建平行类型系统。evaluate 直接返回 TypeValue（或 return/throw
- * 控制标记，此处到不了）；无 kind 的结果一律视为不可用返回 null 由调用方回退。
- * 微求值受 evaluator 全局态（当前 env、resolver）影响，仅用于补全展示。
- */
-function builtinMemberType(memberExpr: string): TypeValue | null {
-  try {
-    const result: unknown = evaluate(parse(`${memberExpr};`), createEnvironment());
-    if (!result || typeof result !== "object" || !("kind" in result)) return null;
-    return result as TypeValue;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * 内置成员补全的唯一真值来源：求值器原型近似表
- * （BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS）。表内新增建模的方法
- * （如 flatMap）自动进入补全，不再手工同步平行名单；表外方法未建模，
- * 微求值拿 undefined、列出只会得到回退文案，故不派生。
- */
-function builtinProtoMembers(className: string): string[] {
-  const table = BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS[className];
-  return table ? Object.keys(table) : [];
-}
-
-/**
- * 成员 detail 的展示形态：内置方法优先取 evaluator 的真实 fnSig
- * （typeValueToString 渲染为 `(a: string) => boolean` 形式）；无签名
- * （未建模或求值异常）时退回 `成员名(…)@<类>` 概要。取舍：不伪造平行签名，
- * 缺席就明示缺席——detail 永远可解释、与求值结果一致。
- */
-function describeMember(label: string, tv: TypeValue | null, fallbackClass: string): string {
-  if (tv) {
-    const sig = getFnSig(tv);
-    if (sig) {
-      const paramNames = tv.kind === "function" ? tv.params : [];
-      const params = sig.paramTypes.map((p, i) => `${paramNames[i] ?? `arg${i}`}: ${typeValueToString(p)}`).join(", ");
-      return `(${params}) => ${typeValueToString(sig.returnType)}`;
-    }
-    if (tv.kind !== "function") return typeValueToString(tv);
-  }
-  return `${label}(…)@${fallbackClass}`;
-}
-
-function getArrayCompletions(tv: TypeValue): CompletionItem[] {
-  const completions: CompletionItem[] = [];
-  for (const m of builtinProtoMembers("Array")) {
-    const detail = describeMember(m, builtinMemberType(`Array.prototype.${m}`), "Array");
-    completions.push({ label: m, kind: "method", detail });
-  }
-  completions.push({
-    label: "length",
-    kind: "property",
-    // tuple 长度是精确字面量；array 是 number（保持原展示语义）
-    detail: tv.kind === "tuple" ? `${tv.elements.length}` : "number",
-  });
-  return completions;
-}
-
-function getPromiseCompletions(): CompletionItem[] {
-  return builtinProtoMembers("Promise").map((m) => ({
-    label: m,
-    kind: "method" as const,
-    detail: describeMember(m, builtinMemberType(`Promise.prototype.${m}`), "Promise"),
-  }));
-}
-
-function getStringCompletions(): CompletionItem[] {
-  const completions: CompletionItem[] = [];
-  for (const m of builtinProtoMembers("String")) {
-    completions.push({
-      label: m,
-      kind: "method",
-      detail: describeMember(m, builtinMemberType(`"s".${m}`), "String"),
-    });
-  }
-  completions.push({ label: "length", kind: "property", detail: "number" });
-  return completions;
-}
-
-/**
- * union 接收者：各成员补全取交集（对成员全部「可能存在」的公共键），
- * detail 为各成员该键类型字符串的并集渲染。键序取首个含该键的成员序，
- * 稳定且与成员书写顺序一致。无公共键返回空——打点补全只展示确定可用
- * 的成员，不做「部分成员才有」的投机提示。
- */
-function getUnionCompletions(tv: TypeValue & { kind: "union" }): CompletionItem[] {
-  const members = tv.members;
-  if (members.length === 0) return [];
-
-  const labelsByMember = members.map((m) => getCompletionsForType(m));
-  // 首个非空成员集的键序作基准；对空集成员（无任何已知成员，如 unknown）
-  // 视为「任何键都可能存在」——跳过其过滤而非让交集归零
-  const baseIdx = labelsByMember.findIndex((labels) => labels.length > 0);
-  if (baseIdx === -1) return [];
-
-  const common: CompletionItem[] = [];
-  for (const base of labelsByMember[baseIdx]) {
-    let allPresent = true;
-    const memberTypes: string[] = [base.detail ?? base.label];
-    for (let i = 0; i < members.length; i++) {
-      if (i === baseIdx) continue;
-      const labels = labelsByMember[i];
-      if (labels.length === 0) continue; // 该成员无已知成员集 → 不约束交集
-      const hit = labels.find((l) => l.label === base.label);
-      if (!hit) {
-        allPresent = false;
-        break;
-      }
-      memberTypes.push(hit.detail ?? hit.label);
-    }
-    if (allPresent) {
-      common.push({ ...base, detail: memberTypes.join(" | ") });
-    }
-  }
-  return common;
-}
-
-function getCompletionsForType(tv: TypeValue): CompletionItem[] {
-  const completions: CompletionItem[] = [];
-
-  if (tv.kind === "object") {
-    for (const [key, val] of Object.entries(tv.properties)) {
-      completions.push({
-        label: key,
-        kind: val.kind === "function" ? "method" : "property",
-        detail: typeValueToString(val),
-      });
-    }
-    return completions;
-  }
-
-  if (tv.kind === "instance") {
-    for (const [key, val] of Object.entries(tv.properties)) {
-      completions.push({
-        label: key,
-        kind: val.kind === "function" ? "method" : "property",
-        detail: typeValueToString(val),
-      });
-    }
-    return completions;
-  }
-
-  if (tv.kind === "union") {
-    return getUnionCompletions(tv);
-  }
-
-  if (tv.kind === "array" || tv.kind === "tuple") {
-    return getArrayCompletions(tv);
-  }
-
-  if (tv.kind === "promise") {
-    return getPromiseCompletions();
-  }
-
-  if (tv.kind === "primitive" && tv.type === "string") {
-    return getStringCompletions();
-  }
-
-  return completions;
-}
-
-/**
- * Abs 是否比 TypeValue 求值结果更有信息量。
- * 仅在 TypeValue 侧 unknown / 裸 number 且 Abs 带约束时替换，
- * 避免用 Abs 的粗结果盖掉 mock/callsite 已精确投影的结构。
- */
-function absIsBetter(absTv: TypeValue, prev: TypeValue): boolean {
-  if (prev.kind === "unknown") return absTv.kind !== "unknown";
-  if (absTv.kind === "unknown" || absTv.kind === "never") return false;
-  // 保留结构化结果（object/array/tuple/union/literal）
-  if (
-    prev.kind === "literal" ||
-    prev.kind === "object" ||
-    prev.kind === "array" ||
-    prev.kind === "tuple" ||
-    prev.kind === "union" ||
-    prev.kind === "function" ||
-    prev.kind === "instance" ||
-    prev.kind === "promise"
-  ) {
-    return false;
-  }
-  // Abs refined vs 裸 primitive：约束更有信息
-  if (absTv.kind === "refined" && prev.kind === "primitive") return true;
-  return false;
-}
-/**
- * 自包含 = 无 import/require、无 @nudo:env。
- * @nudo:mock 不阻断 Abs：已编译为 seedVars/seedFns 注入 evalProgramAbs。
- * 相对 import 经 Abs 模块图注入后，也不再阻断 Abs 路径。
- */
-function isSelfContainedSource(source: string, envNames: string[]): boolean {
-  if (envNames.length > 0) return false;
-  return !/\brequire\s*\(|\bimport\s*[{'"*]/.test(source);
-}
-
-/** Abs 模块图可处理：env 由 loadEnvs 处理（内置 + 预加载路径型） */
-function absModulesOk(source: string, envNames: string[]): boolean {
-  void source;
-  void envNames;
-  return true;
-}
-
-/**
- * Abs 程序级求值收集调用记录（类型即计算）。
- * filePath 存在时经模块图注入相对 import / 裸包 harvest；
- * import 局部名 → targetModule/targetExport（供 externalFunctions）。
- */
-function collectAbsCallRecords(
-  source: string,
-  seeds?: {
-    seedVars?: Record<string, Abs>;
-    seedFns?: Record<string, { params: string[]; body: Node; async?: boolean }>;
-  },
-  filePath?: string,
-  precomputedModules?: Record<string, import("@nudojs/core").AbsModuleExports>,
-): CallRecord[] {
-  const absCalls: AbsCallRecord[] = [];
-  let modules: Record<string, import("@nudojs/core").AbsModuleExports> | undefined =
-    precomputedModules;
-  let importLocals = new Map<string, { modulePath: string; exportName: string }>();
-  if (filePath && absModulesOk(source, [])) {
-    if (!modules) {
-      try {
-        const graph = evalAbsModuleGraph(source, filePath, {
-          seedVars: seeds?.seedVars,
-          seedFns: seeds?.seedFns,
-        });
-        modules = graph.modules;
-      } catch {
-        modules = undefined;
-      }
-    }
-    try {
-      importLocals = buildAbsImportLocalMap(source, filePath);
-    } catch {
-      importLocals = new Map();
-    }
-  }
-  setAbsCallCollector((r) => absCalls.push(r));
-  try {
-    evalProgramAbs(source, { ...seeds, modules });
-  } catch {
-    // Abs 求值失败：交还 TypeValue 路径
-  } finally {
-    setAbsCallCollector(null);
-  }
-  return absCalls.map((r): CallRecord => {
-    const rec: CallRecord = {
-      fnName: r.fnName,
-      argTypes: r.args.map((a) => absToTypeValue(a)),
-      resultType: r.threw ? T.never : absToTypeValue(r.result),
-      throws: r.threw ? absToTypeValue(r.result) : T.never,
-      callLoc: r.callLoc,
-    };
-    const imp = importLocals.get(r.fnName);
-    if (imp) {
-      rec.targetModule = imp.modulePath;
-      rec.targetExport = imp.exportName;
-    }
-    return rec;
-  });
-}
-
-/**
- * 一次 evalProgramAbs 同时收集顶层绑定 + 节点 Abs（B-hosted 补齐 hover/bindings）。
- * modules 可预计算，避免再跑一遍模块图。
- */
-function collectAbsBindsAndNodes(
-  source: string,
-  seeds?: {
-    seedVars?: Record<string, Abs>;
-    seedFns?: Record<string, { params: string[]; body: Node; async?: boolean }>;
-  },
-  modules?: Record<string, import("@nudojs/core").AbsModuleExports>,
-): { binds: Map<string, Abs>; nodes: Map<Node, Abs> } {
-  const binds = new Map<string, Abs>();
-  const nodes = new Map<Node, Abs>();
-  setAbsNodeCollector((node, value) => {
-    nodes.set(node, value);
-  });
-  try {
-    const { env } = evalProgramAbs(source, {
-      ...seeds,
-      modules,
-    });
-    for (const [k, v] of env.vars) binds.set(k, v);
-    for (const [name, impl] of env.fns) {
-      if (!binds.has(name)) {
-        binds.set(
-          name,
-          absFunction(impl.params, { body: impl.body, async: impl.async, env }),
-        );
-      }
-    }
-  } catch {
-    /* ignore */
-  } finally {
-    setAbsNodeCollector(null);
-  }
-  return { binds, nodes };
-}
-
-/** 入口 import 局部绑定 → 解析后的模块路径 + 导出名 */
-function buildAbsImportLocalMap(
-  source: string,
-  fromFile: string,
-): Map<string, { modulePath: string; exportName: string }> {
-  const out = new Map<string, { modulePath: string; exportName: string }>();
-  try {
-    const file = parse(source);
-    for (const stmt of file.program.body) {
-      if (stmt.type !== "ImportDeclaration") continue;
-      const spec = stmt.source.value;
-      let modulePath: string | null = null;
-      if (spec.startsWith(".") || spec.startsWith("/")) {
-        modulePath = resolveImportAbs(spec, fromFile);
-      } else if (!spec.startsWith("node:")) {
-        // 裸包：用说明符本身作 module 标（externalFunctions 可显示）
-        modulePath = spec;
-      }
-      if (!modulePath) continue;
-      for (const s of stmt.specifiers) {
-        if (s.type === "ImportSpecifier") {
-          const imported =
-            s.imported.type === "Identifier" ? s.imported.name : String(s.imported);
-          out.set(s.local.name, { modulePath, exportName: imported });
-        } else if (s.type === "ImportDefaultSpecifier") {
-          out.set(s.local.name, { modulePath, exportName: "default" });
-        }
-      }
-    }
-  } catch {
-    /* ignore */
-  }
-  return out;
-}
-
-function resolveImportAbs(spec: string, fromFile: string): string | null {
-  const base = dirname(resolve(fromFile));
-  const p = resolve(base, spec);
-  for (const cand of [p, `${p}.js`, `${p}.mjs`, `${p}.ts`, resolve(p, "index.js")]) {
-    if (existsSync(cand) && !statSync(cand).isDirectory()) return cand;
-  }
-  return null;
-}
-
-function tryEvalAbs(
-  source: string,
-  fnName: string,
-  args: TypeValue[],
-  filePath?: string,
-  mocks?: Record<string, Abs>,
-): TypeValue | undefined {
-  const raw = tryEvalAbsRaw(source, fnName, args, filePath, mocks);
-  return raw ? absToTypeValue(raw) : undefined;
-}
-
-/** Abs 原生重求值（无损）；B 路径 transpile+exec 优先，失败回退 ast-eval */
-function tryEvalAbsRaw(
-  source: string,
-  fnName: string,
-  args: TypeValue[],
-  filePath?: string,
-  mocks?: Record<string, Abs>,
-): Abs | undefined {
-  // require / env 不走 Abs
-  if (/\brequire\s*\(/.test(source)) return undefined;
-  try {
-    const absArgs: Abs[] = args.map((a) => typeValueToAbs(a));
-
-    // B 路径：transpile → Node new Function（进程内）；注入 @nudo:mock
-    if (filePath) {
-      const viaB = tryBPathCall(source, filePath, fnName, absArgs, { mocks });
-      if (viaB) return viaB;
-    }
-
-    let modules: Record<string, import("@nudojs/core").AbsModuleExports> | undefined;
-    if (filePath && /\bimport\s*[{'"*]/.test(source)) {
-      modules = evalAbsModuleGraph(source, filePath).modules;
-    }
-    const result = analyzeFn(source, fnName, absArgs, undefined, undefined, undefined, modules);
-    if (result.shape.k === "unknown" && !result.term) {
-      return undefined;
-    }
-    return result;
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * entry@ 的 Abs 原生路径：自包含源码用 ast-eval（类型即计算），
- * TypeValue 只在出口投影。含 import/require 或求值失败时返回 undefined。
- */
-function tryEvalEntryAbs(
-  source: string,
-  fnName: string,
-  args: TypeValue[],
-  filePath?: string,
-  mocks?: Record<string, Abs>,
-): TypeValue | undefined {
-  return tryEvalAbs(source, fnName, args, filePath, mocks);
-}
-
-/**
- * entry@ 附加内涵摘要（代数 generalize + 无损 Abs）。
- * 失败静默——不改变外延 TypeValue。
- */
-function tryAttachIntension(
-  caseResult: CaseResult,
-  source: string,
-  fnName: string,
-): void {
-  try {
-    const g = generalizeFromAst(fnName, source);
-    if (!g) return;
-    const sym = g.symbolic;
-    const intension: NonNullable<CaseResult["intension"]> = {
-      display: g.display,
-      abs: formatAbs(sym),
-      absMultiline: formatAbsMultiline(sym, fnName),
-    };
-    if (sym.term && sym.term.op !== "lit") {
-      intension.term = termToString(sym.term);
-    }
-    if (sym.pred && sym.pred.op !== "true") {
-      intension.pred = predToString(sym.pred);
-    }
-    intension.conf = sym.conf;
-    caseResult.intension = intension;
-  } catch {
-    // ignore
-  }
-}
-
-/** 把一次 Abs 求值结果挂到 case 的 intension（无损） */
-function attachAbsToIntension(
-  caseResult: CaseResult,
-  absVal: Abs,
-  label?: string,
-): void {
-  const prev = caseResult.intension ?? {};
-  caseResult.abs = absVal;
-  caseResult.intension = {
-    ...prev,
-    abs: formatAbs(absVal),
-    absMultiline: formatAbsMultiline(absVal, label ?? caseResult.name),
-    conf: absVal.conf,
-  };
-}
-
-export type { CallRecord } from "@nudojs/cli/evaluator";