@nudojs/service 5.0.0-beta.0 → 5.0.0-beta.1

package/dist/{chunk-QAFMPM2E.js → chunk-NQXAF4LJ.js}

@@ -1,23 +1,73 @@
 import {
-  bareSpecToAbsModules
-} from "./chunk-U7JYTRIB.js";
-import {
+  BoundedLruMap,
   analysisConfig,
   findProjectConfig,
   getSessionCacheLimits,
   interfaceConfig,
-  resolveNpmJsEntry
-} from "./chunk-YLALZXTZ.js";
-import {
-  BoundedLruMap,
   loadEnvs,
-  preloadPathEnvs
-} from "./chunk-PVJIMQRI.js";
+  preloadPathEnvs,
+  resolveNpmJsEntry,
+  resolveNpmNudo
+} from "./chunk-ZXVAX7DE.js";
 
 // src/analyzer-module-load.ts
 import { readFileSync, existsSync, statSync } from "fs";
 import { resolve, dirname } from "path";
 import { parse } from "@nudojs/parser";
+function resolveModule(source, fromDir) {
+  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;
+    if (statSync(candidate).isDirectory()) {
+      let entry = 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 {
+        }
+      }
+      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 src2 = readFileSync(entry, "utf-8");
+      return { ast: parse(src2), filePath: entry };
+    }
+    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;
+}
 function resolveImportPath(specifier, fromDir) {
   const basePath = resolve(fromDir, specifier);
   for (const ext of ["", ".js", ".ts", ".mjs"]) {
@@ -121,2511 +171,2512 @@ function topoSortDirty(imports, dirty) {
   return ordered;
 }
 
-// src/load-module.ts
-import { existsSync as existsSync2, statSync as statSync2, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, resolve as resolve2, join } from "path";
-function defaultLoadModule(spec, fromFile) {
-  if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
-  try {
-    const base = dirname2(resolve2(fromFile));
-    const p = resolve2(base, spec);
-    for (const cand of [
-      p,
-      `${p}.js`,
-      `${p}.mjs`,
-      `${p}.ts`,
-      join(p, "index.js"),
-      join(p, "index.mjs"),
-      join(p, "index.ts")
-    ]) {
-      if (existsSync2(cand) && !statSync2(cand).isDirectory()) {
-        return readFileSync2(cand, "utf-8");
-      }
-    }
-    return void 0;
-  } catch {
-    return void 0;
-  }
+// src/analyzer-ast.ts
+import traverse from "@babel/traverse";
+import {
+  formalParamsFromNodes,
+  formalParamDisplayNames,
+  unknown as absUnknown,
+  abs as makeAbsVal,
+  numLit,
+  strLit,
+  boolLit
+} from "@nudojs/core";
+import {
+  programBody,
+  getDeclarations,
+  getDeclaratorInit,
+  getFirstDeclaratorId,
+  getExpressionStatementExpression,
+  unwrapExport,
+  asIdentifier,
+  asAssignmentExpression,
+  classIdName,
+  fnOrClassIdLoc,
+  isModuleExportsMember,
+  memberPropertyKey,
+  classInstanceMethods,
+  exportSpecifierLocalName,
+  exportSpecifierExportedName,
+  unwrapDefaultExport
+} from "@nudojs/parser";
+function locFromNode(node) {
+  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 }
+  };
 }
-
-// src/analyzer-cache.ts
-import { loadModuleDepsFingerprint, hashSource, stableAnalyzeKeySource } from "@nudojs/core/internal";
-var externalRecordIds = /* @__PURE__ */ new WeakMap();
-var nextExternalRecordId = 1;
-function analysisFileCacheKey(filePath, source, activeCases, externalCallRecords, analysisCfg, loadModule, projectEnvNames, autoBind, caseMode = "all") {
-  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 === void 0) {
-      id = nextExternalRecordId++;
-      externalRecordIds.set(externalCallRecords, id);
-    }
-    ext = `n${externalCallRecords.length}#id${id}`;
+function extractParamNames(node) {
+  const fn = node.type === "ExportDefaultDeclaration" ? node.declaration : node;
+  if (fn.type === "FunctionDeclaration" || fn.type === "FunctionExpression" || fn.type === "ArrowFunctionExpression" || fn.type === "ClassMethod" || fn.type === "ObjectMethod" || fn.type === "TSDeclareMethod") {
+    return formalParamDisplayNames(formalParamsFromNodes(fn.params));
   }
-  const cfg = analysisCfg ? `m=${analysisCfg.mode}|e=${analysisCfg.evalMissingSlot}|b=${analysisCfg.callSiteBudget}|d=${analysisCfg.diagnostics}` : "-";
-  const lm = loadModule !== void 0 && loadModule !== defaultLoadModule ? "lm1" : "lm0";
-  const envSeg = projectEnvNames && projectEnvNames.length > 0 ? projectEnvNames.join(",") : "-";
-  const abSeg = autoBind === false ? "ab0" : autoBind === true ? "ab1" : "ab?";
-  const effectiveLoader = loadModule ?? defaultLoadModule;
-  let depSeg = "-";
-  let noCache = false;
-  try {
-    const fp = loadModuleDepsFingerprint(source, effectiveLoader, filePath);
-    if (fp.truncated) {
-      noCache = true;
-      depSeg = `trunc:${fp.paths.length}`;
-    } else {
-      depSeg = hashSource(fp.fp);
+  if (fn.type === "VariableDeclaration") {
+    const init = getDeclaratorInit(getDeclarations(fn)[0]);
+    if (init && (init.type === "FunctionExpression" || init.type === "ArrowFunctionExpression")) {
+      return formalParamDisplayNames(formalParamsFromNodes(init.params));
     }
-  } catch {
-    noCache = true;
-    depSeg = "fperr";
   }
-  return {
-    filePath,
-    // 尾部无 @nudo 注释/空行不进键：comment-only 编辑命中 AnalysisResult
-    source: stableAnalyzeKeySource(source),
-    auxKey: `${cases}\0${ext}\0${cfg}\0${lm}\0${envSeg}\0${abSeg}\0${depSeg}\0cm=${caseMode}`,
-    noCache
-  };
+  return [];
 }
-function cloneAnalysisResult(r) {
-  return {
-    functions: r.functions.map(cloneFunctionAnalysis),
-    diagnostics: r.diagnostics.map((d) => ({ ...d })),
-    bindings: new Map(r.bindings),
-    // Node 键与 AST LRU 共享身份；Map 浅拷贝即可
-    nodeAbsMap: new Map(r.nodeAbsMap),
-    caseHints: r.caseHints.map((h) => ({ ...h })),
-    ...r.externalFunctions ? { externalFunctions: r.externalFunctions.map(cloneFunctionAnalysis) } : {}
-  };
+function resolveFunctionNode(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 = getDeclaratorInit(getDeclarations(node)[0]);
+    if (init && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")) return init;
+  }
+  return node;
 }
-function cloneFunctionAnalysis(a) {
-  return {
-    ...a,
-    paramNames: [...a.paramNames],
-    ...a.formals ? { formals: a.formals.map((f) => ({ ...f })) } : {},
-    cases: a.cases.map((c) => ({
-      ...c,
-      argAbs: [...c.argAbs],
-      ...c.intension ? { intension: { ...c.intension } } : {}
-    })),
-    loc: { start: { ...a.loc.start }, end: { ...a.loc.end } },
-    ...a.hof ? {
-      hof: {
-        ...a.hof.fnRels ? { fnRels: a.hof.fnRels.map((r) => ({ ...r })) } : {},
-        ...a.hof.entryShapes ? { entryShapes: a.hof.entryShapes.map((s) => ({ ...s })) } : {},
-        ...a.hof.symbolic ? { symbolic: a.hof.symbolic } : {}
-      }
-    } : {}
-  };
+function fnNameLoc(node, fallback) {
+  const { declaration: d } = unwrapExport(node);
+  if (d.type === "VariableDeclaration") {
+    const id = getFirstDeclaratorId(d);
+    if (id?.loc) return id.loc;
+  }
+  const idLoc = fnOrClassIdLoc(d);
+  if (idLoc) return idLoc;
+  return fallback;
 }
-function shiftSourceLoc(loc, lineDelta) {
-  return {
-    start: { line: loc.start.line + lineDelta, column: loc.start.column },
-    end: { line: loc.end.line + lineDelta, column: loc.end.column }
-  };
+function isFnExprValue(node) {
+  return !!node && (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression");
 }
-function shiftDiagnosticLines(d, lineDelta) {
-  if (lineDelta === 0) return { ...d };
-  const out = { ...d, range: shiftSourceLoc(d.range, lineDelta) };
-  if (d.origin) {
-    out.origin = { line: d.origin.line + lineDelta, column: d.origin.column };
-  }
-  return out;
+function namedFnExprId(node) {
+  return node.type === "FunctionExpression" && node.id ? node.id.name : null;
 }
-function shiftCallRecordLines(r, lineDelta) {
-  if (lineDelta === 0 || !r.callLoc) return { ...r };
-  return {
-    ...r,
-    callLoc: { line: r.callLoc.line + lineDelta, column: r.callLoc.column }
-  };
+function isModuleExportsTarget(node) {
+  return node.type === "MemberExpression" && !node.computed && isModuleExportsMember(node);
 }
-
-// src/abs-modules-graph.ts
-import { readFileSync as readFileSync3, statSync as statSync3 } from "fs";
-import { dirname as dirname3, resolve as resolve3 } from "path";
-import { parse as parse2 } from "@nudojs/parser";
-import {
-  abs as makeAbs,
-  absFunction,
-  bindingsOf,
-  tryRunTranspiled,
-  callTranspiledExportFull,
-  foldStaticStringExpr,
-  unknown
-} from "@nudojs/core";
-function seedFnsToMocks(seedVars, seedFns) {
-  const out = { ...seedVars };
-  for (const [name, fn] of Object.entries(seedFns)) {
-    out[name] = absFunction(fn.params, {
-      body: fn.body,
-      async: fn.async ?? false
-    });
+function deepestAssignValue(expr) {
+  let cur = expr;
+  while (cur) {
+    const assign = asAssignmentExpression(cur);
+    if (!assign) break;
+    cur = assign.right;
   }
-  return out;
+  return cur ?? null;
 }
-function defaultAbsLoadModule(spec, fromFile) {
-  if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
-  try {
-    const p = resolve3(dirname3(resolve3(fromFile)), spec);
-    for (const cand of [p, `${p}.js`, `${p}.mjs`, `${p}.ts`, resolve3(p, "index.js")]) {
-      try {
-        return readFileSync3(cand, "utf-8");
-      } catch {
+function assignmentChainName(expr) {
+  let cur = expr;
+  while (cur) {
+    const assign = asAssignmentExpression(cur);
+    if (!assign) break;
+    const target = assign.left;
+    if (target.type === "Identifier") return target.name;
+    if (target.type === "MemberExpression") {
+      if (isModuleExportsTarget(target)) {
+        cur = assign.right;
+        continue;
       }
+      return memberPropertyKey(target);
     }
-    return void 0;
-  } catch {
-    return void 0;
-  }
-}
-function relCandidates(spec, fromFile) {
-  const p = resolve3(dirname3(resolve3(fromFile)), spec);
-  return [p, `${p}.js`, `${p}.mjs`, `${p}.ts`, resolve3(p, "index.js")];
-}
-function resolveRel(spec, fromFile) {
-  if (!spec.startsWith(".") && !spec.startsWith("/")) return null;
-  for (const cand of relCandidates(spec, fromFile)) {
-    try {
-      readFileSync3(cand, "utf-8");
-      return cand;
-    } catch {
-    }
+    return null;
   }
   return null;
 }
-function importSpecs(source) {
-  try {
-    const file = parse2(source);
-    const out = [];
-    for (const stmt of file.program.body) {
-      if (stmt.type === "ImportDeclaration" || stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportAllDeclaration") {
-        const src = stmt.source;
-        if (src && typeof src.value === "string") {
-          out.push(src.value);
-        }
-      }
-      collectRequireSpecs(stmt, out);
-    }
-    return out;
-  } catch {
-    return [];
-  }
-}
-function collectRequireSpecs(node, out) {
-  const visit = (n) => {
-    if (!n || typeof n !== "object") return;
-    const o = n;
-    if (o.type === "CallExpression" && o.callee) {
-      const c = o.callee;
-      let spec;
-      if (c.type === "Identifier" && c.name === "require") {
-        spec = foldStaticStringExpr(o.arguments?.[0]);
-      } else if (c.type === "MemberExpression" && !c.computed && c.object?.type === "Identifier" && c.object.name === "require" && c.property?.type === "Identifier" && c.property.name === "resolve") {
-        spec = foldStaticStringExpr(o.arguments?.[0]);
-      }
-      if (spec !== void 0) out.push(spec);
-    }
-    for (const key of Object.keys(o)) {
-      if (key === "loc" || key === "start" || key === "end") continue;
-      const v = o[key];
-      if (Array.isArray(v)) v.forEach(visit);
-      else if (v && typeof v === "object") visit(v);
+function collectTopLevelFunctions(ast) {
+  const results = [];
+  if (ast.type !== "File") return results;
+  const body = programBody(ast);
+  const classDecls = /* @__PURE__ */ new Map();
+  const exportedClassNames = /* @__PURE__ */ new Set();
+  const collectClassMethods = (cname, decl, stmt) => {
+    for (const { name: keyName, node: methodNode } of classInstanceMethods(decl)) {
+      results.push({
+        name: `${cname}.${keyName}`,
+        node: methodNode,
+        stmt,
+        noDeclaration: true
+      });
     }
   };
-  visit(node);
-}
-function buildModulesForFile(source, fromFile, load, evalDep, depth, maxDepth, onMissing) {
-  const modules = {};
-  for (const spec of importSpecs(source)) {
-    if (spec.startsWith(".") || spec.startsWith("/")) {
-      const childPath = resolveRel(spec, fromFile);
-      if (!childPath) {
-        onMissing(spec, fromFile, relCandidates(spec, fromFile));
+  for (const stmt of body) {
+    const className = classIdName(stmt);
+    if (stmt.type === "ClassDeclaration" && className) {
+      classDecls.set(className, { node: stmt, stmt });
+      continue;
+    }
+    if (stmt.type === "ExportNamedDeclaration") {
+      const d = stmt.declaration;
+      const exportedClassName = classIdName(d);
+      if (d?.type === "ClassDeclaration" && exportedClassName) {
+        classDecls.set(exportedClassName, { node: d, stmt });
+        exportedClassNames.add(exportedClassName);
         continue;
       }
-      modules[spec] = evalDep(childPath, spec, fromFile, depth + 1);
-    } else if (!spec.startsWith("node:")) {
-      const entry = resolveNpmJsEntry(spec, dirname3(fromFile));
-      if (entry) {
-        const executed = evalDep(entry, spec, fromFile, depth + 1);
-        if (executed && (executed.default !== void 0 || Object.keys(executed.named ?? {}).length > 0)) {
-          modules[spec] = executed;
-          continue;
+      if (!d && stmt.specifiers) {
+        for (const spec of stmt.specifiers) {
+          if (spec.type !== "ExportSpecifier") continue;
+          const local = exportSpecifierLocalName(spec);
+          const exported = exportSpecifierExportedName(spec);
+          if (!local) continue;
+          if (classDecls.has(local) || body.some((s) => classIdName(s) === local)) {
+            exportedClassNames.add(local);
+          }
+          if (exported === "default") exportedClassNames.add(local);
         }
+        continue;
       }
-      const bare = bareSpecToAbsModules(spec, fromFile);
-      if (bare) modules[spec] = bare;
+    }
+    if (stmt.type === "ExportDefaultDeclaration") {
+      const d = stmt.declaration;
+      const defaultClassName = classIdName(d);
+      if (d?.type === "ClassDeclaration" && defaultClassName) {
+        classDecls.set(defaultClassName, { node: d, stmt });
+        exportedClassNames.add(defaultClassName);
+      } else {
+        const idName = asIdentifier(d)?.name;
+        if (idName) exportedClassNames.add(idName);
+      }
+      continue;
     }
   }
-  void maxDepth;
-  return modules;
-}
-var ABS_MODULE_CACHE_MAX = 512;
-var absModuleCache = new BoundedLruMap(ABS_MODULE_CACHE_MAX);
-function getAbsModuleCacheSize() {
-  return absModuleCache.size;
-}
-function clearAbsModuleCache() {
-  absModuleCache.clear();
-}
-function evictAbsModuleCacheFiles(paths) {
-  for (const p of paths) absModuleCache.delete(p);
-}
-function moduleLabel(p) {
-  const parts = p.split(/[/\\]/);
-  return parts[parts.length - 1] || p;
-}
-function isAbsVal(v) {
-  return !!v && typeof v === "object" && "shape" in v && "conf" in v;
-}
-function paramNameOf(p, i) {
-  if (p.type === "Identifier" && p.name) return p.name;
-  if (p.type === "RestElement" && p.argument?.type === "Identifier" && p.argument.name) {
-    return `...${p.argument.name}`;
-  }
-  return `arg${i}`;
-}
-function topLevelFnParams(file) {
-  const out = /* @__PURE__ */ new Map();
-  const body = file.program?.body ?? [];
   for (const stmt of body) {
-    if (stmt.type === "FunctionDeclaration" && stmt.id && stmt.params) {
-      out.set(stmt.id.name, stmt.params.map(paramNameOf));
+    const decl = resolveFunctionNode(stmt);
+    if (decl.type === "FunctionDeclaration" && decl.id) {
+      results.push({ name: decl.id.name, node: decl, stmt, noDeclaration: false });
+      continue;
+    }
+    if (decl.type === "ClassDeclaration" && decl.id?.name) {
+      continue;
+    }
+    if (stmt.type === "ExportNamedDeclaration") {
+      const d = resolveFunctionNode(stmt);
+      if (d.type === "FunctionDeclaration" && d.id) {
+        results.push({ name: d.id.name, node: d, stmt, noDeclaration: false });
+      }
+      if (d.type === "ClassDeclaration" && d.id?.name) {
+      }
+      continue;
     }
     if (stmt.type === "ExportDefaultDeclaration") {
       const d = stmt.declaration;
-      if (d && (d.type === "FunctionDeclaration" || d.type === "ArrowFunctionExpression") && d.params) {
-        out.set("default", d.params.map(paramNameOf));
+      if (d.type === "FunctionDeclaration") {
+        if (d.id) {
+          results.push({ name: d.id.name, node: d, stmt, noDeclaration: false });
+        } else {
+          results.push({ name: "default", node: d, stmt, noDeclaration: true });
+        }
+      } else if (isFnExprValue(d)) {
+        results.push({ name: "default", node: d, stmt, noDeclaration: true });
+      }
+      continue;
+    }
+    if (stmt.type === "VariableDeclaration") {
+      for (const declarator of getDeclarations(stmt)) {
+        const id = asIdentifier(declarator.id);
+        if (id && isFnExprValue(declarator.init)) {
+          results.push({ name: id.name, node: declarator.init, stmt, noDeclaration: true });
+        }
+      }
+      continue;
+    }
+    const expr = getExpressionStatementExpression(stmt);
+    if (expr?.type === "AssignmentExpression") {
+      const fn = deepestAssignValue(expr);
+      if (isFnExprValue(fn)) {
+        const name = namedFnExprId(fn) ?? assignmentChainName(expr) ?? "default";
+        const chain = assignmentChainName(expr);
+        const assignedName = namedFnExprId(fn) && chain && chain !== name ? chain : void 0;
+        results.push({ name, node: fn, stmt, noDeclaration: true, ...assignedName ? { assignedName } : {} });
       }
     }
   }
-  return out;
+  for (const cname of exportedClassNames) {
+    const hit = classDecls.get(cname);
+    if (!hit) continue;
+    collectClassMethods(cname, hit.node, hit.stmt);
+  }
+  return results;
 }
-function bPathExportsToModuleExports(run, file, fingerprintPrefix) {
-  const named = {};
-  let def;
-  const paramTable = topLevelFnParams(file);
-  for (const [k, v] of Object.entries(run)) {
-    if (v === void 0 || v === null) continue;
-    let absVal;
-    if (isAbsVal(v)) {
-      absVal = v;
-    } else if (typeof v === "function") {
-      const params = paramTable.get(k) ?? Array.from({ length: v.length ?? 0 }, (_, i) => `arg${i}`);
-      absVal = absFunction(params, {
-        apply: (args) => callTranspiledExportFull(run, k, args).result,
-        kind: "bpath-export",
-        // 无 body 的桥接 fn 预算键 = fingerprint ?? anon#N——缺省会让所有
-        // 桥接导出共享 anon#1，嵌套跨模块调用（a 调 b 调 a'）撞
-        // _activeCallKeys 递归守卫被误截断为 opaque。按 模块#导出 唯一化。
-        fingerprint: `${fingerprintPrefix}#${k}`
-      });
-    } else {
-      absVal = unknown;
+function findSingleModuleExportsFunction(ast) {
+  if (ast.type !== "File") return null;
+  let found = null;
+  for (const stmt of programBody(ast)) {
+    const expr = getExpressionStatementExpression(stmt);
+    if (expr?.type !== "AssignmentExpression") continue;
+    const fn = deepestAssignValue(expr);
+    if (!isFnExprValue(fn)) continue;
+    let targetsModuleExports = false;
+    let cur = expr;
+    while (cur) {
+      const assign = asAssignmentExpression(cur);
+      if (!assign) break;
+      if (isModuleExportsTarget(assign.left)) {
+        targetsModuleExports = true;
+        break;
+      }
+      cur = assign.right;
     }
-    if (k === "default") def = absVal;
-    else named[k] = absVal;
+    if (!targetsModuleExports) continue;
+    if (found) return null;
+    found = fn;
   }
-  const out = { named };
-  if (def) out.default = def;
-  return out;
+  return found;
 }
-function evalAbsModuleGraph(entrySource, entryFile, opts = {}) {
-  const load = opts.loadModule ?? defaultAbsLoadModule;
-  const maxDepth = opts.maxDepth ?? 16;
-  const cache = /* @__PURE__ */ new Map();
-  const loading = [];
-  const issues = [];
-  const seenIssue = /* @__PURE__ */ new Set();
-  const pushIssue = (kind, label, reason) => {
-    const key = `${kind}:${label}`;
-    if (seenIssue.has(key)) return;
-    seenIssue.add(key);
-    issues.push({ kind, label, reason });
+function collectBindings(ast, env, bindings, absBinds) {
+  if (ast.type !== "File") return;
+  const setBinding = (name, loc) => {
+    const absVal = absBinds?.get(name) ?? absUnknown;
+    bindings.set(name, {
+      abs: absVal,
+      loc
+    });
   };
-  function evalDep(absPath, spec, fromFile, depth) {
-    const cycleIndex = loading.indexOf(absPath);
-    if (cycleIndex !== -1) {
-      const chain = [...loading.slice(cycleIndex), absPath];
-      pushIssue(
-        "cycle",
-        moduleLabel(absPath),
-        `Circular module load: ${chain.join(" -> ")} (bindings inside the cycle resolve to their partially evaluated types)`
-      );
-      return cache.get(absPath) ?? { named: {} };
-    }
-    const shared = absModuleCache.get(absPath);
-    if (shared) {
-      try {
-        const st = statSync3(absPath);
-        if (st.mtimeMs === shared.mtimeMs && st.size === shared.size) {
-          for (const iss of shared.issues) pushIssue(iss.kind, iss.label, iss.reason);
-          cache.set(absPath, shared.exports);
-          return shared.exports;
+  const walk = (body) => {
+    for (const stmt of body) {
+      if (stmt.type === "FunctionDeclaration" && stmt.id) {
+        setBinding(stmt.id.name, locFromNode(stmt));
+      }
+      if (stmt.type === "VariableDeclaration") {
+        for (const decl of stmt.declarations) {
+          if (decl.id.type === "Identifier") {
+            setBinding(decl.id.name, locFromNode(decl));
+          }
         }
-      } catch {
       }
-      absModuleCache.delete(absPath);
-    }
-    if (cache.has(absPath)) return cache.get(absPath);
-    if (depth > maxDepth) {
-      const chain = [...loading, absPath];
-      pushIssue(
-        "depth",
-        moduleLabel(absPath),
-        `Module load chain too deep (depth ${chain.length} > ${maxDepth} max): ${chain.join(" -> ")} (loading truncated, deeper modules typed as unknown)`
-      );
-      const empty = { named: {} };
-      cache.set(absPath, empty);
-      return empty;
-    }
-    cache.set(absPath, { named: {} });
-    loading.push(absPath);
-    const source = load(spec, fromFile) ?? (() => {
-      try {
-        return readFileSync3(absPath, "utf-8");
-      } catch {
-        return void 0;
+      if (stmt.type === "ClassDeclaration" && stmt.id) {
+        setBinding(stmt.id.name, locFromNode(stmt));
       }
-    })();
-    if (source === void 0) {
-      pushIssue(
-        "missing",
-        spec,
-        `Module file not found for '${spec}' (from ${moduleLabel(fromFile)}); tried: ${absPath}`
-      );
-      const empty = { named: {} };
-      cache.set(absPath, empty);
-      loading.pop();
-      return empty;
-    }
-    const issueStart = issues.length;
-    const modules2 = buildModulesForFile(
-      source,
-      absPath,
-      load,
-      evalDep,
-      depth,
-      maxDepth,
-      (spec2, fromFile2, tried) => {
-        pushIssue(
-          "missing",
-          spec2,
-          `Module file not found for '${spec2}' (from ${moduleLabel(fromFile2)}); tried: ${tried.join(", ")}`
-        );
+      if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+        walk([stmt.declaration]);
       }
-    );
-    let exports;
-    const bRun = tryRunTranspiled(source, { mode: "analyze", modules: modules2 });
-    if (bRun) {
-      exports = bPathExportsToModuleExports(bRun, parse2(source), `bpath:${absPath}`);
-    } else {
-      exports = { named: {} };
-    }
-    loading.pop();
-    cache.set(absPath, exports);
-    let fingerprint;
-    try {
-      const st = statSync3(absPath);
-      fingerprint = { mtimeMs: st.mtimeMs, size: st.size };
-    } catch {
-    }
-    if (fingerprint) {
-      absModuleCache.set(absPath, {
-        ...fingerprint,
-        exports,
-        issues: issues.slice(issueStart)
-      });
-    }
-    return exports;
-  }
-  const modules = buildModulesForFile(
-    entrySource,
-    entryFile,
-    load,
-    evalDep,
-    0,
-    maxDepth,
-    (spec, fromFile, tried) => {
-      pushIssue(
-        "missing",
-        spec,
-        `Module file not found for '${spec}' (from ${moduleLabel(fromFile)}); tried: ${tried.join(", ")}`
-      );
     }
-  );
-  return { modules, byPath: cache, issues };
+  };
+  walk(programBody(ast));
 }
-function importLocalBindings(source, modules) {
-  const out = /* @__PURE__ */ new Map();
-  let file;
-  try {
-    file = parse2(source);
-  } catch {
-    return out;
-  }
-  const body = file.program?.body ?? [];
-  for (const stmt of body) {
-    if (stmt.type !== "ImportDeclaration" || typeof stmt.source?.value !== "string") continue;
-    const mod = modules[stmt.source.value];
-    if (!mod) continue;
-    for (const sp of stmt.specifiers ?? []) {
-      const local = sp.local?.name;
-      if (!local) continue;
-      if (sp.type === "ImportNamespaceSpecifier") {
-        const slots = {};
-        for (const [k, v] of Object.entries(mod.named)) slots[k] = { value: v };
-        if (mod.default) slots["default"] = { value: mod.default };
-        out.set(local, makeAbs({ k: "obj", slots, open: true }, void 0, void 0, "path"));
-      } else if (sp.type === "ImportDefaultSpecifier") {
-        if (mod.default) out.set(local, mod.default);
-      } else if (sp.type === "ImportSpecifier") {
-        const imported = sp.imported?.type === "StringLiteral" ? sp.imported.value : sp.imported?.name;
-        if (imported === void 0) continue;
-        const absVal = imported === "default" ? mod.default : mod.named[imported];
-        if (absVal) out.set(local, absVal);
-      }
-    }
-  }
-  return out;
+function nullLitAbs() {
+  return makeAbsVal({ k: "unknown" }, { op: "lit", value: null }, void 0, "exact");
 }
-function collectAbsBindingsFromGraph(source, filePath, opts = {}) {
-  const out = /* @__PURE__ */ new Map();
+function buildNodeTypeMap(ast, env, nodeAbsMap) {
+  const traverseFn = unwrapDefaultExport(traverse);
   try {
-    const { modules } = evalAbsModuleGraph(source, filePath, opts);
-    const mocks = seedFnsToMocks(opts.seedVars ?? {}, opts.seedFns ?? {});
-    const run = tryRunTranspiled(source, {
-      mode: "analyze",
-      modules,
-      envGlobals: Object.keys(mocks).length ? mocks : void 0
-    });
-    if (!run) return out;
-    const binds = bindingsOf(run);
-    if (binds) {
-      for (const [name, v] of binds) {
-        if (isAbsVal(v)) out.set(name, v);
+    traverseFn(ast, {
+      enter(path) {
+        const node = path.node;
+        try {
+          const setAbs = (a) => {
+            nodeAbsMap.set(node, a);
+          };
+          if (node.type === "Identifier" && node.name !== "undefined" && path.parentPath?.node.type !== "FunctionDeclaration" && path.parentPath?.node.type !== "VariableDeclarator") {
+            if (env.has(node.name)) {
+              setAbs(env.lookup(node.name));
+            }
+          }
+          if (node.type === "NumericLiteral") {
+            setAbs(numLit(node.value));
+          }
+          if (node.type === "StringLiteral") {
+            setAbs(strLit(node.value));
+          }
+          if (node.type === "BooleanLiteral") {
+            setAbs(boolLit(node.value));
+          }
+          if (node.type === "NullLiteral") {
+            setAbs(nullLitAbs());
+          }
+        } catch {
+        }
       }
-    }
-    const exports = bPathExportsToModuleExports(run, parse2(source), `bpath:bindings:${filePath}`);
-    for (const [name, v] of Object.entries(exports.named)) {
-      if (!out.has(name)) out.set(name, v);
-    }
-    for (const [local, absVal] of importLocalBindings(source, modules)) {
-      if (!out.has(local)) out.set(local, absVal);
-    }
+    });
   } catch {
   }
-  return out;
 }
 
-// src/env-path-deps.ts
-import { existsSync as existsSync3, statSync as statSync4 } from "fs";
-import { dirname as dirname4, resolve as resolve4, join as join2 } from "path";
-import { extractAllLoadSpecs } from "@nudojs/core/internal";
-var ENV_DEPENDENTS_MAX = 256;
-var ENV_DEPENDENTS_PER_KEY_MAX = 512;
-var envDependents = new BoundedLruMap(ENV_DEPENDENTS_MAX);
-function getEnvPathDepsSize() {
-  return envDependents.size;
-}
-function norm(p) {
-  return p.replace(/\\/g, "/");
-}
-function resolveLoadSpecPath(spec, fromFile) {
+// src/load-module.ts
+import { existsSync as existsSync2, statSync as statSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, resolve as resolve2, join } from "path";
+function defaultLoadModule(spec, fromFile) {
   if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
   try {
-    const base = dirname4(resolve4(fromFile));
-    const p = resolve4(base, spec);
+    const base = dirname2(resolve2(fromFile));
+    const p = resolve2(base, spec);
     for (const cand of [
       p,
       `${p}.js`,
       `${p}.mjs`,
       `${p}.ts`,
-      join2(p, "index.js"),
-      join2(p, "index.mjs"),
-      join2(p, "index.ts")
+      join(p, "index.js"),
+      join(p, "index.mjs"),
+      join(p, "index.ts")
     ]) {
-      if (existsSync3(cand) && !statSync4(cand).isDirectory()) return cand;
-    }
-    return void 0;
+      if (existsSync2(cand) && !statSync2(cand).isDirectory()) {
+        return readFileSync2(cand, "utf-8");
+      }
+    }
+    return void 0;
   } catch {
     return void 0;
   }
 }
-function noteEnvPathDeps(sourcePath, source) {
-  const src = norm(sourcePath);
-  for (const set of envDependents.values()) set.delete(src);
-  let specs = [];
-  try {
-    specs = extractAllLoadSpecs(source);
-  } catch {
-    return;
+
+// src/analyzer-cache.ts
+import { loadModuleDepsFingerprint, hashSource, stableAnalyzeKeySource } from "@nudojs/core/internal";
+var externalRecordIds = /* @__PURE__ */ new WeakMap();
+var nextExternalRecordId = 1;
+function analysisFileCacheKey(filePath, source, activeCases, externalCallRecords, analysisCfg, loadModule, projectEnvNames, autoBind, caseMode = "all") {
+  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(",");
   }
-  for (const spec of specs) {
-    if (!spec.startsWith(".") && !spec.startsWith("/")) continue;
-    const abs = resolveLoadSpecPath(spec, sourcePath);
-    if (!abs) continue;
-    const key = norm(abs);
-    let set = envDependents.get(key);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      envDependents.set(key, set);
+  let ext = "-";
+  if (externalCallRecords && externalCallRecords.length > 0) {
+    let id = externalRecordIds.get(externalCallRecords);
+    if (id === void 0) {
+      id = nextExternalRecordId++;
+      externalRecordIds.set(externalCallRecords, id);
     }
-    if (!set.has(src) && set.size >= ENV_DEPENDENTS_PER_KEY_MAX) {
-      const oldest = set.values().next().value;
-      if (oldest !== void 0) set.delete(oldest);
+    ext = `n${externalCallRecords.length}#id${id}`;
+  }
+  const cfg = analysisCfg ? `m=${analysisCfg.mode}|e=${analysisCfg.evalMissingSlot}|b=${analysisCfg.callSiteBudget}|d=${analysisCfg.diagnostics}` : "-";
+  const lm = loadModule !== void 0 && loadModule !== defaultLoadModule ? "lm1" : "lm0";
+  const envSeg = projectEnvNames && projectEnvNames.length > 0 ? projectEnvNames.join(",") : "-";
+  const abSeg = autoBind === false ? "ab0" : autoBind === true ? "ab1" : "ab?";
+  const effectiveLoader = loadModule ?? defaultLoadModule;
+  let depSeg = "-";
+  let noCache = false;
+  try {
+    const fp = loadModuleDepsFingerprint(source, effectiveLoader, filePath);
+    if (fp.truncated) {
+      noCache = true;
+      depSeg = `trunc:${fp.paths.length}`;
+    } else {
+      depSeg = hashSource(fp.fp);
     }
-    set.add(src);
+  } catch {
+    noCache = true;
+    depSeg = "fperr";
   }
+  return {
+    filePath,
+    // 尾部无 @nudo 注释/空行不进键：comment-only 编辑命中 AnalysisResult
+    source: stableAnalyzeKeySource(source),
+    auxKey: `${cases}\0${ext}\0${cfg}\0${lm}\0${envSeg}\0${abSeg}\0${depSeg}\0cm=${caseMode}`,
+    noCache
+  };
 }
-function envPathDependents(envPath) {
-  return [...envDependents.peek(norm(envPath)) ?? []];
+function cloneAnalysisResult(r) {
+  return {
+    functions: r.functions.map(cloneFunctionAnalysis),
+    diagnostics: r.diagnostics.map((d) => ({ ...d })),
+    bindings: new Map(r.bindings),
+    // Node 键与 AST LRU 共享身份；Map 浅拷贝即可
+    nodeAbsMap: new Map(r.nodeAbsMap),
+    caseHints: r.caseHints.map((h) => ({ ...h })),
+    ...r.externalFunctions ? { externalFunctions: r.externalFunctions.map(cloneFunctionAnalysis) } : {}
+  };
 }
-function clearEnvPathDeps() {
-  envDependents.clear();
+function cloneFunctionAnalysis(a) {
+  return {
+    ...a,
+    paramNames: [...a.paramNames],
+    ...a.formals ? { formals: a.formals.map((f) => ({ ...f })) } : {},
+    cases: a.cases.map((c) => ({
+      ...c,
+      argAbs: [...c.argAbs],
+      ...c.intension ? { intension: { ...c.intension } } : {}
+    })),
+    loc: { start: { ...a.loc.start }, end: { ...a.loc.end } },
+    ...a.hof ? {
+      hof: {
+        ...a.hof.fnRels ? { fnRels: a.hof.fnRels.map((r) => ({ ...r })) } : {},
+        ...a.hof.entryShapes ? { entryShapes: a.hof.entryShapes.map((s) => ({ ...s })) } : {},
+        ...a.hof.symbolic ? { symbolic: a.hof.symbolic } : {}
+      }
+    } : {}
+  };
 }
-function isEnvTemplatePath(path) {
-  const lower = norm(path).toLowerCase();
-  return lower.endsWith(".env.js") || lower.endsWith(".env.mjs") || lower.endsWith(".env.ts") || lower.endsWith(".env.cjs") || lower.endsWith(".env.cts") || lower.endsWith(".env.mts") || /\/mock-[^/]+\.(js|mjs|ts)$/.test(lower) || /\.mock\.(js|mjs|ts)$/.test(lower);
+function shiftSourceLoc(loc, lineDelta) {
+  return {
+    start: { line: loc.start.line + lineDelta, column: loc.start.column },
+    end: { line: loc.end.line + lineDelta, column: loc.end.column }
+  };
 }
-
-// src/mock-module.ts
-import { extractFileDirectives, parse as parse3 } from "@nudojs/parser";
-import { obj as absObj } from "@nudojs/core";
-
-// src/mock-file.ts
-import { tryRunTranspiled as tryRunTranspiled2 } from "@nudojs/core";
-function evalMockFileWithDeps(fromPath, fromFile, loadModule) {
-  const load = loadModule ?? defaultLoadModule;
-  let source;
-  try {
-    source = load(fromPath, fromFile);
-  } catch {
-    source = void 0;
-  }
-  if (source === void 0) {
-    return { ok: false, error: `Mock file not found (from "${fromPath}")` };
-  }
-  const entryFile = resolveLoadSpecPath(fromPath, fromFile) ?? fromPath;
-  let modules = {};
-  try {
-    modules = evalAbsModuleGraph(source, entryFile, { loadModule }).modules;
-  } catch {
-    modules = {};
-  }
-  let run;
-  try {
-    run = tryRunTranspiled2(source, {
-      mode: "exec",
-      modules
-    });
-  } catch {
-    run = void 0;
-  }
-  if (!run) {
-    return { ok: false, error: `Mock file "${fromPath}" failed to evaluate` };
+function shiftDiagnosticLines(d, lineDelta) {
+  if (lineDelta === 0) return { ...d };
+  const out = { ...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, lineDelta) {
+  if (lineDelta === 0 || !r.callLoc) return { ...r };
   return {
-    ok: true,
-    run,
-    absPath: entryFile,
-    source,
-    modules
+    ...r,
+    callLoc: { line: r.callLoc.line + lineDelta, column: r.callLoc.column }
   };
 }
 
-// src/mock-module.ts
-function loadMockModuleExports(fromPath, fromFile, loadModule) {
-  const evaled = evalMockFileWithDeps(fromPath, fromFile, loadModule);
-  if (!evaled.ok) {
-    return {
-      error: evaled.error.includes("not found") ? `Mock module not found (from "${fromPath}")` : evaled.error
-    };
+// src/abs-modules-graph.ts
+import { readFileSync as readFileSync3, statSync as statSync3 } from "fs";
+import { dirname as dirname3, resolve as resolve3 } from "path";
+import { parse as parse2 } from "@nudojs/parser";
+import {
+  abs as makeAbs,
+  absFunction,
+  bindingsOf,
+  tryRunTranspiled,
+  callTranspiledExportFull,
+  foldStaticStringExpr,
+  unknown
+} from "@nudojs/core";
+import { bareSpecToAbsModules } from "@nudojs/harvester";
+function seedFnsToMocks(seedVars, seedFns) {
+  const out = { ...seedVars };
+  for (const [name, fn] of Object.entries(seedFns)) {
+    out[name] = absFunction(fn.params, {
+      body: fn.body,
+      async: fn.async ?? false
+    });
   }
-  const exports = bPathExportsToModuleExports(evaled.run, parse3(evaled.source), `mock-module:${fromPath}`);
-  if (exports.default === void 0 && Object.keys(exports.named).length > 0) {
-    const slots = {};
-    for (const [k, v] of Object.entries(exports.named)) slots[k] = { value: v };
-    exports.default = absObj(slots);
+  return out;
+}
+function defaultAbsLoadModule(spec, fromFile) {
+  if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
+  try {
+    const p = resolve3(dirname3(resolve3(fromFile)), spec);
+    for (const cand of [p, `${p}.js`, `${p}.mjs`, `${p}.ts`, resolve3(p, "index.js")]) {
+      try {
+        return readFileSync3(cand, "utf-8");
+      } catch {
+      }
+    }
+    return void 0;
+  } catch {
+    return void 0;
   }
-  return { exports };
 }
-function pickNamed(mock, names) {
-  const named = {};
-  let def;
-  for (const n of names) {
-    if (n === "default") {
-      if (mock.default) def = mock.default;
-      continue;
+function relCandidates(spec, fromFile) {
+  const p = resolve3(dirname3(resolve3(fromFile)), spec);
+  return [p, `${p}.js`, `${p}.mjs`, `${p}.ts`, resolve3(p, "index.js")];
+}
+function resolveRel(spec, fromFile) {
+  if (!spec.startsWith(".") && !spec.startsWith("/")) return null;
+  for (const cand of relCandidates(spec, fromFile)) {
+    try {
+      readFileSync3(cand, "utf-8");
+      return cand;
+    } catch {
     }
-    const v = mock.named[n];
-    if (v !== void 0) named[n] = v;
   }
-  return def !== void 0 ? { named, default: def } : { named };
+  return null;
 }
-function applyMockModuleDirectives(base, fileDirectives, opts) {
-  const mods = fileDirectives.filter(
-    (d) => d.kind === "mock-module"
-  );
-  if (mods.length === 0) {
-    return { modules: base, errors: [], applied: false };
+function importSpecs(source) {
+  try {
+    const file = parse2(source);
+    const out = [];
+    for (const stmt of file.program.body) {
+      if (stmt.type === "ImportDeclaration" || stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportAllDeclaration") {
+        const src = stmt.source;
+        if (src && typeof src.value === "string") {
+          out.push(src.value);
+        }
+      }
+      collectRequireSpecs(stmt, out);
+    }
+    return out;
+  } catch {
+    return [];
   }
-  const out = { ...base };
-  const errors = [];
-  let applied = false;
-  for (const d of mods) {
-    const loaded = loadMockModuleExports(d.fromPath, opts.fromFile, opts.loadModule);
-    if (!loaded.exports) {
-      errors.push({
-        name: d.source,
-        fromPath: d.fromPath,
-        message: loaded.error ?? `Mock module "${d.fromPath}" could not be loaded`
-      });
-      continue;
-    }
-    const mock = loaded.exports;
-    if (!d.names || d.names.length === 0) {
-      out[d.source] = mock;
-      applied = true;
-      continue;
+}
+function collectRequireSpecs(node, out) {
+  const visit = (n) => {
+    if (!n || typeof n !== "object") return;
+    const o = n;
+    if (o.type === "CallExpression" && o.callee) {
+      const c = o.callee;
+      let spec;
+      if (c.type === "Identifier" && c.name === "require") {
+        spec = foldStaticStringExpr(o.arguments?.[0]);
+      } else if (c.type === "MemberExpression" && !c.computed && c.object?.type === "Identifier" && c.object.name === "require" && c.property?.type === "Identifier" && c.property.name === "resolve") {
+        spec = foldStaticStringExpr(o.arguments?.[0]);
+      }
+      if (spec !== void 0) out.push(spec);
     }
-    const orig = out[d.source] ?? { named: {} };
-    const overlay = pickNamed(mock, d.names);
-    const named = { ...orig.named, ...overlay.named };
-    const merged = { named };
-    const wantDefault = d.names.includes("default");
-    if (wantDefault && overlay.default !== void 0) {
-      merged.default = overlay.default;
-    } else if (orig.default !== void 0) {
-      merged.default = orig.default;
+    for (const key of Object.keys(o)) {
+      if (key === "loc" || key === "start" || key === "end") continue;
+      const v = o[key];
+      if (Array.isArray(v)) v.forEach(visit);
+      else if (v && typeof v === "object") visit(v);
     }
-    out[d.source] = merged;
-    applied = true;
-  }
-  return { modules: out, errors, applied };
-}
-function applyMockModuleDirectivesFromSource(source, base, opts) {
-  let fileDirectives = [];
-  try {
-    fileDirectives = extractFileDirectives(parse3(source));
-  } catch {
-    fileDirectives = [];
-  }
-  return applyMockModuleDirectives(base, fileDirectives, opts);
-}
-
-// src/analysis-file-cache.ts
-var analysisByFile = /* @__PURE__ */ new Map();
-function clearAnalysisFileCache() {
-  analysisByFile.clear();
-}
-function getAnalysisFileCacheSize() {
-  return analysisByFile.size;
-}
-function trimAnalysisFileCache() {
-  const max = getSessionCacheLimits().maxFiles;
-  while (analysisByFile.size > max) {
-    const oldest = analysisByFile.keys().next().value;
-    if (oldest === void 0) break;
-    analysisByFile.delete(oldest);
-  }
-}
-function analysisCacheGet(filePath, source, auxKey) {
-  const e = analysisByFile.get(filePath);
-  if (!e) return void 0;
-  if (e.source !== source || e.auxKey !== auxKey) return void 0;
-  analysisByFile.delete(filePath);
-  analysisByFile.set(filePath, e);
-  return e.value;
-}
-function analysisCacheSet(filePath, source, auxKey, value) {
-  const max = getSessionCacheLimits().maxFiles;
-  if (max <= 0) return;
-  while (analysisByFile.size >= max && !analysisByFile.has(filePath)) {
-    const oldest = analysisByFile.keys().next().value;
-    if (oldest === void 0) break;
-    analysisByFile.delete(oldest);
-  }
-  analysisByFile.set(filePath, { source, auxKey, value });
+  };
+  visit(node);
 }
-function evictAnalysisFileCacheForFiles(files) {
-  let n = 0;
-  for (const f of files) {
-    if (analysisByFile.delete(f)) n++;
+function buildModulesForFile(source, fromFile, load, evalDep, depth, maxDepth, onMissing) {
+  const modules = {};
+  for (const spec of importSpecs(source)) {
+    if (spec.startsWith(".") || spec.startsWith("/")) {
+      const childPath = resolveRel(spec, fromFile);
+      if (!childPath) {
+        onMissing(spec, fromFile, relCandidates(spec, fromFile));
+        continue;
+      }
+      modules[spec] = evalDep(childPath, spec, fromFile, depth + 1);
+    } else if (!spec.startsWith("node:")) {
+      const entry = resolveNpmJsEntry(spec, dirname3(fromFile));
+      if (entry) {
+        const executed = evalDep(entry, spec, fromFile, depth + 1);
+        if (executed && (executed.default !== void 0 || Object.keys(executed.named ?? {}).length > 0)) {
+          modules[spec] = executed;
+          continue;
+        }
+      }
+      const bare = bareSpecToAbsModules(spec, fromFile);
+      if (bare) modules[spec] = bare;
+    }
   }
-  return n;
+  void maxDepth;
+  return modules;
 }
-
-// src/fn-analysis-cache.ts
-var fnAnalysisCache = /* @__PURE__ */ new Map();
-function getFnAnalysisCacheSize() {
-  return fnAnalysisCache.size;
+var ABS_MODULE_CACHE_MAX = 512;
+var absModuleCache = new BoundedLruMap(ABS_MODULE_CACHE_MAX);
+function getAbsModuleCacheSize() {
+  return absModuleCache.size;
 }
-function clearFnAnalysisCache() {
-  fnAnalysisCache.clear();
+function clearAbsModuleCache() {
+  absModuleCache.clear();
 }
-function trimFnAnalysisCache() {
-  const max = getSessionCacheLimits().maxFns;
-  while (fnAnalysisCache.size > max) {
-    const oldest = fnAnalysisCache.keys().next().value;
-    if (oldest === void 0) break;
-    fnAnalysisCache.delete(oldest);
-  }
+function evictAbsModuleCacheFiles(paths) {
+  for (const p of paths) absModuleCache.delete(p);
 }
-function fnAnalysisCacheGet(key) {
-  const hit = fnAnalysisCache.get(key);
-  if (hit !== void 0) {
-    fnAnalysisCache.delete(key);
-    fnAnalysisCache.set(key, hit);
-  }
-  return hit;
+function moduleLabel(p) {
+  const parts = p.split(/[/\\]/);
+  return parts[parts.length - 1] || p;
 }
-function fnAnalysisCacheSet(key, value) {
-  const max = getSessionCacheLimits().maxFns;
-  if (max <= 0) return;
-  while (fnAnalysisCache.size >= max && !fnAnalysisCache.has(key)) {
-    const oldest = fnAnalysisCache.keys().next().value;
-    if (oldest === void 0) break;
-    fnAnalysisCache.delete(oldest);
-  }
-  fnAnalysisCache.set(key, value);
+function isAbsVal(v) {
+  return !!v && typeof v === "object" && "shape" in v && "conf" in v;
 }
-function evictFnAnalysisCacheForFiles(files) {
-  if (files.length === 0 || fnAnalysisCache.size === 0) return 0;
-  const prefixes = files.map((f) => `${f}\0`);
-  let n = 0;
-  for (const key of [...fnAnalysisCache.keys()]) {
-    if (prefixes.some((p) => key.startsWith(p))) {
-      fnAnalysisCache.delete(key);
-      n++;
-    }
+function paramNameOf(p, i) {
+  if (p.type === "Identifier" && p.name) return p.name;
+  if (p.type === "RestElement" && p.argument?.type === "Identifier" && p.argument.name) {
+    return `...${p.argument.name}`;
   }
-  return n;
+  return `arg${i}`;
 }
-function caseDirectiveKey(directives, formatAbs6) {
-  return directives.map((d) => {
-    if (d.kind === "case") {
-      const args = (d.argsAbs ?? []).map((a) => formatAbs6(a)).join(",");
-      return `c:${d.name ?? ""}:${args}`;
+function topLevelFnParams(file) {
+  const out = /* @__PURE__ */ new Map();
+  const body = file.program?.body ?? [];
+  for (const stmt of body) {
+    if (stmt.type === "FunctionDeclaration" && stmt.id && stmt.params) {
+      out.set(stmt.id.name, stmt.params.map(paramNameOf));
     }
-    return d.kind;
-  }).join("|");
-}
-
-// src/bpath-run.ts
-import { runTranspiled, callTranspiledExport, callTranspiledExportFull as callTranspiledExportFull2, setBCallCollector, createEnvironment, formatAbs, getFnImpl } from "@nudojs/core";
-import { setMemberDiagCollector, setAbsTruncationCollector, stableAnalyzeKeySource as stableAnalyzeKeySource2, hashSource as hashSource2, loadModuleDepsFingerprint as loadModuleDepsFingerprint2 } from "@nudojs/core/internal";
-import { parse as parse4, extractInlineDirectives } from "@nudojs/parser";
-function absSeedPart(a) {
-  const impl = getFnImpl(a);
-  if (impl?.fingerprint) return impl.fingerprint;
-  if (a.shape.k === "fn") {
-    const ret = impl?.env?.vars?.get("__nudo_mock_ret");
-    if (ret) {
-      try {
-        return `ret=${formatAbs(ret)}`;
-      } catch {
-        return "ret=?";
+    if (stmt.type === "ExportDefaultDeclaration") {
+      const d = stmt.declaration;
+      if (d && (d.type === "FunctionDeclaration" || d.type === "ArrowFunctionExpression") && d.params) {
+        out.set("default", d.params.map(paramNameOf));
       }
     }
-    if (impl?.apply) return "apply";
-  }
-  try {
-    return formatAbs(a);
-  } catch {
-    return "?";
   }
+  return out;
 }
-function seedFnPart(name, fn) {
-  if (fn.fingerprint) return `${name}:${fn.fingerprint}`;
-  const body = fn.body;
-  const bodyKey = body && typeof body.start === "number" && typeof body.end === "number" ? `${body.start}:${body.end}:${body.type ?? ""}` : String(body?.type ?? "?");
-  return `${name}(${fn.params.join(",")})@${bodyKey}`;
-}
-function mockSeedFingerprint(mocks, seedFns) {
-  const parts = [];
-  if (mocks) {
-    const names = Object.keys(mocks).sort();
-    for (const n of names) parts.push(`${n}=${absSeedPart(mocks[n])}`);
+function bPathExportsToModuleExports(run, file, fingerprintPrefix) {
+  const named = {};
+  let def;
+  const paramTable = topLevelFnParams(file);
+  for (const [k, v] of Object.entries(run)) {
+    if (v === void 0 || v === null) continue;
+    let absVal;
+    if (isAbsVal(v)) {
+      absVal = v;
+    } else if (typeof v === "function") {
+      const params = paramTable.get(k) ?? Array.from({ length: v.length ?? 0 }, (_, i) => `arg${i}`);
+      absVal = absFunction(params, {
+        apply: (args) => callTranspiledExportFull(run, k, args).result,
+        kind: "bpath-export",
+        // 无 body 的桥接 fn 预算键 = fingerprint ?? anon#N——缺省会让所有
+        // 桥接导出共享 anon#1，嵌套跨模块调用（a 调 b 调 a'）撞
+        // _activeCallKeys 递归守卫被误截断为 opaque。按 模块#导出 唯一化。
+        fingerprint: `${fingerprintPrefix}#${k}`
+      });
+    } else {
+      absVal = unknown;
+    }
+    if (k === "default") def = absVal;
+    else named[k] = absVal;
   }
-  if (seedFns) {
-    const names = Object.keys(seedFns).sort();
-    for (const n of names) parts.push(`fn:${seedFnPart(n, seedFns[n])}`);
-  }
-  if (parts.length === 0) return "-";
-  return hashSource2(parts.join(";"));
+  const out = { named };
+  if (def) out.default = def;
+  return out;
 }
-function collectEnvGlobals(envNames) {
-  if (envNames.length === 0) return {};
-  const env = createEnvironment();
-  try {
-    return { ...loadEnvs(envNames, env).globals };
-  } catch {
-    return {};
+function evalAbsModuleGraph(entrySource, entryFile, opts = {}) {
+  const load = opts.loadModule ?? defaultAbsLoadModule;
+  const maxDepth = opts.maxDepth ?? 16;
+  const cache = /* @__PURE__ */ new Map();
+  const loading = [];
+  const issues = [];
+  const seenIssue = /* @__PURE__ */ new Set();
+  const pushIssue = (kind, label, reason) => {
+    const key = `${kind}:${label}`;
+    if (seenIssue.has(key)) return;
+    seenIssue.add(key);
+    issues.push({ kind, label, reason });
+  };
+  function evalDep(absPath, spec, fromFile, depth) {
+    const cycleIndex = loading.indexOf(absPath);
+    if (cycleIndex !== -1) {
+      const chain = [...loading.slice(cycleIndex), absPath];
+      pushIssue(
+        "cycle",
+        moduleLabel(absPath),
+        `Circular module load: ${chain.join(" -> ")} (bindings inside the cycle resolve to their partially evaluated types)`
+      );
+      return cache.get(absPath) ?? { named: {} };
+    }
+    const shared = absModuleCache.get(absPath);
+    if (shared) {
+      try {
+        const st = statSync3(absPath);
+        if (st.mtimeMs === shared.mtimeMs && st.size === shared.size) {
+          for (const iss of shared.issues) pushIssue(iss.kind, iss.label, iss.reason);
+          cache.set(absPath, shared.exports);
+          return shared.exports;
+        }
+      } catch {
+      }
+      absModuleCache.delete(absPath);
+    }
+    if (cache.has(absPath)) return cache.get(absPath);
+    if (depth > maxDepth) {
+      const chain = [...loading, absPath];
+      pushIssue(
+        "depth",
+        moduleLabel(absPath),
+        `Module load chain too deep (depth ${chain.length} > ${maxDepth} max): ${chain.join(" -> ")} (loading truncated, deeper modules typed as unknown)`
+      );
+      const empty = { named: {} };
+      cache.set(absPath, empty);
+      return empty;
+    }
+    cache.set(absPath, { named: {} });
+    loading.push(absPath);
+    const source = load(spec, fromFile) ?? (() => {
+      try {
+        return readFileSync3(absPath, "utf-8");
+      } catch {
+        return void 0;
+      }
+    })();
+    if (source === void 0) {
+      pushIssue(
+        "missing",
+        spec,
+        `Module file not found for '${spec}' (from ${moduleLabel(fromFile)}); tried: ${absPath}`
+      );
+      const empty = { named: {} };
+      cache.set(absPath, empty);
+      loading.pop();
+      return empty;
+    }
+    const issueStart = issues.length;
+    const modules2 = buildModulesForFile(
+      source,
+      absPath,
+      load,
+      evalDep,
+      depth,
+      maxDepth,
+      (spec2, fromFile2, tried) => {
+        pushIssue(
+          "missing",
+          spec2,
+          `Module file not found for '${spec2}' (from ${moduleLabel(fromFile2)}); tried: ${tried.join(", ")}`
+        );
+      }
+    );
+    let exports;
+    const bRun = tryRunTranspiled(source, { mode: "analyze", modules: modules2 });
+    if (bRun) {
+      exports = bPathExportsToModuleExports(bRun, parse2(source), `bpath:${absPath}`);
+    } else {
+      exports = { named: {} };
+    }
+    loading.pop();
+    cache.set(absPath, exports);
+    let fingerprint;
+    try {
+      const st = statSync3(absPath);
+      fingerprint = { mtimeMs: st.mtimeMs, size: st.size };
+    } catch {
+    }
+    if (fingerprint) {
+      absModuleCache.set(absPath, {
+        ...fingerprint,
+        exports,
+        issues: issues.slice(issueStart)
+      });
+    }
+    return exports;
   }
+  const modules = buildModulesForFile(
+    entrySource,
+    entryFile,
+    load,
+    evalDep,
+    0,
+    maxDepth,
+    (spec, fromFile, tried) => {
+      pushIssue(
+        "missing",
+        spec,
+        `Module file not found for '${spec}' (from ${moduleLabel(fromFile)}); tried: ${tried.join(", ")}`
+      );
+    }
+  );
+  return { modules, byPath: cache, issues };
 }
-function collectEnvModules(envNames) {
-  if (envNames.length === 0) return {};
-  const env = createEnvironment();
-  let mods = {};
+function importLocalBindings(source, modules) {
+  const out = /* @__PURE__ */ new Map();
+  let file;
   try {
-    mods = loadEnvs(envNames, env).modules;
+    file = parse2(source);
   } catch {
-    return {};
+    return out;
   }
-  const out = {};
-  for (const [spec, named] of Object.entries(mods)) {
-    out[spec] = { named: { ...named } };
+  const body = file.program?.body ?? [];
+  for (const stmt of body) {
+    if (stmt.type !== "ImportDeclaration" || typeof stmt.source?.value !== "string") continue;
+    const mod = modules[stmt.source.value];
+    if (!mod) continue;
+    for (const sp of stmt.specifiers ?? []) {
+      const local = sp.local?.name;
+      if (!local) continue;
+      if (sp.type === "ImportNamespaceSpecifier") {
+        const slots = {};
+        for (const [k, v] of Object.entries(mod.named)) slots[k] = { value: v };
+        if (mod.default) slots["default"] = { value: mod.default };
+        out.set(local, makeAbs({ k: "obj", slots, open: true }, void 0, void 0, "path"));
+      } else if (sp.type === "ImportDefaultSpecifier") {
+        if (mod.default) out.set(local, mod.default);
+      } else if (sp.type === "ImportSpecifier") {
+        const imported = sp.imported?.type === "StringLiteral" ? sp.imported.value : sp.imported?.name;
+        if (imported === void 0) continue;
+        const absVal = imported === "default" ? mod.default : mod.named[imported];
+        if (absVal) out.set(local, absVal);
+      }
+    }
   }
   return out;
 }
-var envHarvestConflictCollector = null;
-function setEnvHarvestConflictCollector(collector) {
-  const prev = envHarvestConflictCollector;
-  envHarvestConflictCollector = collector;
-  return prev;
-}
-function getEnvHarvestConflictCollector() {
-  return envHarvestConflictCollector;
-}
-function mergeHarvestUnderEnv(harvestModules, envModules, opts) {
-  const out = {};
-  for (const [mod, exports] of Object.entries(harvestModules)) {
-    const named = { ...exports.named };
-    out[mod] = exports.default !== void 0 ? { named, default: exports.default } : { named };
-  }
-  const notify = opts?.onConflict ?? envHarvestConflictCollector;
-  for (const [mod, envExports] of Object.entries(envModules)) {
-    const existing = out[mod];
-    if (!existing) {
-      const named2 = { ...envExports.named };
-      out[mod] = envExports.default !== void 0 ? { named: named2, default: envExports.default } : { named: named2 };
-      continue;
+function collectAbsBindingsFromGraph(source, filePath, opts = {}) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const { modules } = evalAbsModuleGraph(source, filePath, opts);
+    const mocks = seedFnsToMocks(opts.seedVars ?? {}, opts.seedFns ?? {});
+    const run = tryRunTranspiled(source, {
+      mode: "analyze",
+      modules,
+      envGlobals: Object.keys(mocks).length ? mocks : void 0
+    });
+    if (!run) return out;
+    const binds = bindingsOf(run);
+    if (binds) {
+      for (const [name, v] of binds) {
+        if (isAbsVal(v)) out.set(name, v);
+      }
     }
-    const overwritten = [];
-    for (const key of Object.keys(envExports.named)) {
-      if (existing.named[key] !== void 0) overwritten.push(key);
+    const exports = bPathExportsToModuleExports(run, parse2(source), `bpath:bindings:${filePath}`);
+    for (const [name, v] of Object.entries(exports.named)) {
+      if (!out.has(name)) out.set(name, v);
     }
-    const defaultOverwritten = envExports.default !== void 0 && existing.default !== void 0;
-    if (notify && (overwritten.length > 0 || defaultOverwritten)) {
-      try {
-        notify({
-          module: mod,
-          exports: overwritten,
-          defaultOverwritten
-        });
-      } catch {
-      }
+    for (const [local, absVal] of importLocalBindings(source, modules)) {
+      if (!out.has(local)) out.set(local, absVal);
     }
-    const named = { ...existing.named, ...envExports.named };
-    const defaultAbs = envExports.default !== void 0 ? envExports.default : existing.default;
-    out[mod] = defaultAbs !== void 0 ? { named, default: defaultAbs } : { named };
+  } catch {
   }
   return out;
 }
-function collectBPathReplacements(source) {
-  const targets = [];
-  const values = {};
-  const asTargets = [];
-  const asValues = {};
-  let i = 0;
+
+// src/env-path-deps.ts
+import { existsSync as existsSync3, statSync as statSync4 } from "fs";
+import { dirname as dirname4, resolve as resolve4, join as join2 } from "path";
+import { extractAllLoadSpecs } from "@nudojs/core/internal";
+var ENV_DEPENDENTS_MAX = 256;
+var ENV_DEPENDENTS_PER_KEY_MAX = 512;
+var envDependents = new BoundedLruMap(ENV_DEPENDENTS_MAX);
+function getEnvPathDepsSize() {
+  return envDependents.size;
+}
+function norm(p) {
+  return p.replace(/\\/g, "/");
+}
+function resolveLoadSpecPath(spec, fromFile) {
+  if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
   try {
-    const file = parse4(source);
-    const visitStmts = (stmts) => {
-      for (const stmt of stmts) {
-        if (!stmt || typeof stmt !== "object") continue;
-        const loc = stmt.loc;
-        const dirs = extractInlineDirectives(stmt);
-        for (const d of dirs) {
-          if (d.kind === "replace") {
-            const varName = `__rep${i++}`;
-            targets.push({
-              target: d.targetSource,
-              varName,
-              stmtStart: loc?.start.line,
-              stmtEnd: loc?.end.line
-            });
-            values[varName] = d.typeAbs;
-          } else if (d.kind === "as" && loc) {
-            const varName = `__as${i++}`;
-            asTargets.push({
-              varName,
-              stmtStart: loc.start.line,
-              stmtEnd: loc.end.line
-            });
-            asValues[varName] = d.typeAbs;
-          }
-        }
-        const s = stmt;
-        if (s.type === "BlockStatement" && Array.isArray(s.body)) visitStmts(s.body);
-        if (s.type === "FunctionDeclaration" || s.type === "FunctionExpression") {
-          if (s.body) visitStmts([s.body]);
-        }
-        if (s.type === "ExportNamedDeclaration" && s.declaration) {
-          visitStmts([s.declaration]);
-        }
-        if (s.type === "IfStatement") {
-          if (s.consequent) visitStmts([s.consequent]);
-          if (s.alternate) visitStmts([s.alternate]);
-        }
-      }
-    };
-    visitStmts(file.program.body);
+    const base = dirname4(resolve4(fromFile));
+    const p = resolve4(base, spec);
+    for (const cand of [
+      p,
+      `${p}.js`,
+      `${p}.mjs`,
+      `${p}.ts`,
+      join2(p, "index.js"),
+      join2(p, "index.mjs"),
+      join2(p, "index.ts")
+    ]) {
+      if (existsSync3(cand) && !statSync4(cand).isDirectory()) return cand;
+    }
+    return void 0;
   } catch {
+    return void 0;
   }
-  return { targets, values, asTargets, asValues };
-}
-function isBPathCapable(source, envNames = []) {
-  void envNames;
-  void source;
-  return true;
 }
-var bRunByFile = /* @__PURE__ */ new Map();
-function bPathDepKey(source, filePath) {
+function noteEnvPathDeps(sourcePath, source) {
+  const src = norm(sourcePath);
+  for (const set of envDependents.values()) set.delete(src);
+  let specs = [];
   try {
-    const fp = loadModuleDepsFingerprint2(source, defaultLoadModule, filePath);
-    if (fp.truncated) return null;
-    return hashSource2(fp.fp);
+    specs = extractAllLoadSpecs(source);
   } catch {
-    return null;
+    return;
+  }
+  for (const spec of specs) {
+    if (!spec.startsWith(".") && !spec.startsWith("/")) continue;
+    const abs = resolveLoadSpecPath(spec, sourcePath);
+    if (!abs) continue;
+    const key = norm(abs);
+    let set = envDependents.get(key);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      envDependents.set(key, set);
+    }
+    if (!set.has(src) && set.size >= ENV_DEPENDENTS_PER_KEY_MAX) {
+      const oldest = set.values().next().value;
+      if (oldest !== void 0) set.delete(oldest);
+    }
+    set.add(src);
   }
 }
-function clearBPathCache() {
-  bRunByFile.clear();
-  clearAnalysisFileCache();
-  clearFnAnalysisCache();
+function envPathDependents(envPath) {
+  return [...envDependents.peek(norm(envPath)) ?? []];
 }
-function getBPathCacheSize() {
-  return bRunByFile.size;
+function clearEnvPathDeps() {
+  envDependents.clear();
 }
-function evictBPathCacheForFiles(files) {
-  let n = 0;
-  for (const f of files) {
-    if (bRunByFile.delete(f)) n++;
-  }
-  return n;
+function isEnvTemplatePath(path) {
+  const lower = norm(path).toLowerCase();
+  return lower.endsWith(".env.js") || lower.endsWith(".env.mjs") || lower.endsWith(".env.ts") || lower.endsWith(".env.cjs") || lower.endsWith(".env.cts") || lower.endsWith(".env.mts") || /\/mock-[^/]+\.(js|mjs|ts)$/.test(lower) || /\.mock\.(js|mjs|ts)$/.test(lower);
 }
-function bPathCacheSet(filePath, stableSource, mode, envKey, mockKey, depKey, value) {
-  const max = getSessionCacheLimits().maxBRuns;
-  if (max <= 0) return;
-  while (bRunByFile.size >= max && !bRunByFile.has(filePath)) {
-    const oldest = bRunByFile.keys().next().value;
-    if (oldest === void 0) break;
-    bRunByFile.delete(oldest);
+
+// src/mock-module.ts
+import { extractFileDirectives, parse as parse3 } from "@nudojs/parser";
+import { obj as absObj } from "@nudojs/core";
+
+// src/mock-file.ts
+import { tryRunTranspiled as tryRunTranspiled2 } from "@nudojs/core";
+function evalMockFileWithDeps(fromPath, fromFile, loadModule) {
+  const load = loadModule ?? defaultLoadModule;
+  let source;
+  try {
+    source = load(fromPath, fromFile);
+  } catch {
+    source = void 0;
   }
-  bRunByFile.set(filePath, { stableSource, mode, envKey, mockKey, depKey, value });
-}
-function trimBPathCache() {
-  const max = getSessionCacheLimits().maxBRuns;
-  while (bRunByFile.size > max) {
-    const oldest = bRunByFile.keys().next().value;
-    if (oldest === void 0) break;
-    bRunByFile.delete(oldest);
+  if (source === void 0) {
+    return { ok: false, error: `Mock file not found (from "${fromPath}")` };
   }
-}
-function tryRunBPath(source, filePath, opts = {}) {
-  if (!isBPathCapable(source, opts.envNames ?? [])) return void 0;
-  const mode = opts.mode ?? "analyze";
-  const envKey = (opts.envNames ?? []).join(",");
-  const mockKey = mockSeedFingerprint(opts.mocks);
-  const stable = stableAnalyzeKeySource2(source);
-  const depKey = bPathDepKey(source, filePath);
-  const canCache = depKey !== null;
-  if (canCache) {
-    const cached = bRunByFile.get(filePath);
-    if (cached && cached.stableSource === stable && cached.mode === mode && cached.envKey === envKey && cached.mockKey === mockKey && cached.depKey === depKey) {
-      bRunByFile.delete(filePath);
-      bRunByFile.set(filePath, cached);
-      return cached.value ?? void 0;
-    }
+  const entryFile = resolveLoadSpecPath(fromPath, fromFile) ?? fromPath;
+  let modules = {};
+  try {
+    modules = evalAbsModuleGraph(source, entryFile, { loadModule }).modules;
+  } catch {
+    modules = {};
   }
-  let out = null;
+  let run;
   try {
-    const memberDiags = [];
-    const truncated = /* @__PURE__ */ new Set();
-    const topCalls = [];
-    const prevMember = setMemberDiagCollector((d) => memberDiags.push(d));
-    const prevTrunc = setAbsTruncationCollector((label) => truncated.add(label));
-    const prevCall = setBCallCollector((r) => topCalls.push(r));
-    try {
-      const { modules: graphMods, issues } = evalAbsModuleGraph(source, filePath);
-      const envMods = collectEnvModules(opts.envNames ?? []);
-      let modules = mergeHarvestUnderEnv(graphMods, envMods);
-      const mm = applyMockModuleDirectivesFromSource(source, modules, { fromFile: filePath });
-      modules = mm.modules;
-      const { targets, values, asTargets, asValues } = collectBPathReplacements(source);
-      const envGlobals = {
-        ...collectEnvGlobals(opts.envNames ?? []),
-        ...opts.mocks ?? {}
-      };
-      const exports = runTranspiled(source, {
-        modules,
-        maxLoopIters: opts.maxLoopIters,
-        mode: opts.mode ?? "analyze",
-        replacementTargets: targets.length ? targets : void 0,
-        replacements: targets.length ? values : void 0,
-        asOverrideTargets: asTargets.length ? asTargets : void 0,
-        asOverrides: asTargets.length ? asValues : void 0,
-        envGlobals: Object.keys(envGlobals).length ? envGlobals : void 0,
-        lenientGlobals: opts.lenientGlobals
-      });
-      out = {
-        exports,
-        modules,
-        memberDiags: memberDiags.length ? memberDiags : void 0,
-        moduleIssues: issues.length ? issues : void 0,
-        truncatedFns: truncated.size ? [...truncated] : void 0,
-        calls: topCalls.length ? topCalls : void 0
-      };
-    } finally {
-      setMemberDiagCollector(prevMember);
-      setAbsTruncationCollector(prevTrunc);
-      setBCallCollector(prevCall);
-    }
+    run = tryRunTranspiled2(source, {
+      mode: "exec",
+      modules
+    });
   } catch {
-    out = null;
+    run = void 0;
   }
-  if (canCache && depKey !== null) {
-    bPathCacheSet(filePath, stable, mode, envKey, mockKey, depKey, out);
+  if (!run) {
+    return { ok: false, error: `Mock file "${fromPath}" failed to evaluate` };
   }
-  return out ?? void 0;
+  return {
+    ok: true,
+    run,
+    absPath: entryFile,
+    source,
+    modules
+  };
 }
-function tryBPathCallFull(source, filePath, fnName, args, opts = {}) {
-  const run = tryRunBPath(source, filePath, { envNames: opts.envNames, mocks: opts.mocks });
-  if (!run) return void 0;
-  if (!(fnName in run.exports)) return void 0;
-  const collected = [];
-  const memberDiags = [];
-  const prevCall = opts.collectCalls ? setBCallCollector((r) => collected.push(r)) : void 0;
-  const wantMember = opts.collectMemberDiags ?? true;
-  const prevMember = wantMember ? setMemberDiagCollector((d) => memberDiags.push(d)) : void 0;
-  try {
-    const full = callTranspiledExportFull2(run.exports, fnName, args, opts.phi ? { phi: opts.phi } : void 0);
-    const all = [...run.memberDiags ?? [], ...memberDiags];
+
+// src/mock-module.ts
+function loadMockModuleExports(fromPath, fromFile, loadModule) {
+  const evaled = evalMockFileWithDeps(fromPath, fromFile, loadModule);
+  if (!evaled.ok) {
     return {
-      ...full,
-      calls: opts.collectCalls ? collected : void 0,
-      memberDiags: all.length ? all : void 0,
-      moduleIssues: run.moduleIssues,
-      truncatedFns: run.truncatedFns
+      error: evaled.error.includes("not found") ? `Mock module not found (from "${fromPath}")` : evaled.error
     };
-  } finally {
-    if (opts.collectCalls) setBCallCollector(prevCall ?? null);
-    if (wantMember) setMemberDiagCollector(prevMember ?? null);
   }
+  const exports = bPathExportsToModuleExports(evaled.run, parse3(evaled.source), `mock-module:${fromPath}`);
+  if (exports.default === void 0 && Object.keys(exports.named).length > 0) {
+    const slots = {};
+    for (const [k, v] of Object.entries(exports.named)) slots[k] = { value: v };
+    exports.default = absObj(slots);
+  }
+  return { exports };
 }
-function tryBPathCall(source, filePath, fnName, args, opts = {}) {
-  const full = tryBPathCallFull(source, filePath, fnName, args, opts);
-  if (!full) return void 0;
-  const r = full.result;
-  if (!r) return void 0;
-  if (r.shape.k === "never" && full.throws.shape.k !== "never") {
-    return void 0;
-  }
-  if (r.shape.k === "unknown" && !r.term) return void 0;
-  return r;
-}
-
-// src/mock-abs.ts
-import { extractDirectives } from "@nudojs/parser";
-import { parse as parse5, parseCaseArgExpr } from "@nudojs/parser";
-import {
-  absFunction as absFunction2,
-  emptyEnv,
-  abs as makeAbs2,
-  confJoin,
-  unknown as absUnknown,
-  litValue,
-  formatAbs as formatAbs2,
-  getFnImpl as getFnImpl2,
-  bindingsOf as bindingsOf2,
-  callTranspiledExportFull as callTranspiledExportFull3
-} from "@nudojs/core";
-function markMockConf(a) {
-  a.conf = confJoin(a.conf, "mock");
-  return a;
-}
-function astContentKey(n, depth = 0) {
-  if (n == null || depth > 24) return "";
-  if (typeof n !== "object") return String(n);
-  if (Array.isArray(n)) return n.map((x) => astContentKey(x, depth + 1)).join(",");
-  const obj = n;
-  const type = typeof obj.type === "string" ? obj.type : "";
-  const parts = [type];
-  for (const key of ["name", "value", "raw", "operator", "computed"]) {
-    const v = obj[key];
-    if (v !== void 0 && (typeof v !== "object" || v === null)) parts.push(`${key}=${String(v)}`);
-  }
-  for (const key of Object.keys(obj)) {
-    if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments" || key === "innerComments" || key === "type" || key === "name" || key === "value" || key === "raw" || key === "operator" || key === "computed") {
+function pickNamed(mock, names) {
+  const named = {};
+  let def;
+  for (const n of names) {
+    if (n === "default") {
+      if (mock.default) def = mock.default;
       continue;
     }
-    const v = obj[key];
-    if (v && typeof v === "object") parts.push(`${key}:{${astContentKey(v, depth + 1)}}`);
+    const v = mock.named[n];
+    if (v !== void 0) named[n] = v;
   }
-  return parts.join("|");
-}
-function stampFingerprint(a, fp) {
-  const impl = getFnImpl2(a);
-  if (impl) impl.fingerprint = fp;
-  return a;
+  return def !== void 0 ? { named, default: def } : { named };
 }
-function constantMockFn(result) {
-  const marked = markMockConf(result);
-  const mockEnv = emptyEnv();
-  const retName = "__nudo_mock_ret";
-  mockEnv.vars.set(retName, marked);
-  const body = {
-    type: "BlockStatement",
-    body: [
-      {
-        type: "ReturnStatement",
-        argument: { type: "Identifier", name: retName }
-      }
-    ]
-  };
-  let retKey;
-  try {
-    retKey = formatAbs2(marked);
-  } catch {
-    retKey = "?";
-  }
-  return stampFingerprint(
-    markMockConf(absFunction2(["...args"], { body, env: mockEnv })),
-    `ret=${retKey}`
+function applyMockModuleDirectives(base, fileDirectives, opts) {
+  const mods = fileDirectives.filter(
+    (d) => d.kind === "mock-module"
   );
-}
-function absArgMatches(declared, actual) {
-  if (!actual) return false;
-  const av = litValue(actual);
-  const dv = litValue(declared);
-  if (dv !== void 0) {
-    return av !== void 0 && Object.is(av, dv);
+  if (mods.length === 0) {
+    return { modules: base, errors: [], applied: false };
   }
-  if (declared.shape.k === "prim") {
-    if (actual.shape.k === "prim") return actual.shape.type === declared.shape.type;
-    if (av !== void 0) {
-      const t = typeof av;
-      return declared.shape.type === "number" && t === "number" || declared.shape.type === "string" && t === "string" || declared.shape.type === "boolean" && t === "boolean" || declared.shape.type === "bigint" && t === "bigint";
+  const out = { ...base };
+  const errors = [];
+  let applied = false;
+  for (const d of mods) {
+    const loaded = loadMockModuleExports(d.fromPath, opts.fromFile, opts.loadModule);
+    if (!loaded.exports) {
+      errors.push({
+        name: d.source,
+        fromPath: d.fromPath,
+        message: loaded.error ?? `Mock module "${d.fromPath}" could not be loaded`
+      });
+      continue;
+    }
+    const mock = loaded.exports;
+    if (!d.names || d.names.length === 0) {
+      out[d.source] = mock;
+      applied = true;
+      continue;
+    }
+    const orig = out[d.source] ?? { named: {} };
+    const overlay = pickNamed(mock, d.names);
+    const named = { ...orig.named, ...overlay.named };
+    const merged = { named };
+    const wantDefault = d.names.includes("default");
+    if (wantDefault && overlay.default !== void 0) {
+      merged.default = overlay.default;
+    } else if (orig.default !== void 0) {
+      merged.default = orig.default;
     }
+    out[d.source] = merged;
+    applied = true;
   }
-  return false;
+  return { modules: out, errors, applied };
 }
-function dispatchMockFn(defaultReturn, cases) {
-  if (!cases?.length) return constantMockFn(defaultReturn);
-  const caseAbs = cases.map((c) => ({
-    declared: c.args,
-    result: markMockConf(c.returnValue)
-  }));
-  const dummyBody = {
-    type: "BlockStatement",
-    body: [{ type: "ReturnStatement", argument: null }]
-  };
-  const markedDefault = markMockConf(defaultReturn);
-  let defaultKey;
+function applyMockModuleDirectivesFromSource(source, base, opts) {
+  let fileDirectives = [];
   try {
-    defaultKey = formatAbs2(markedDefault);
+    fileDirectives = extractFileDirectives(parse3(source));
   } catch {
-    defaultKey = "?";
+    fileDirectives = [];
   }
-  const caseKey = cases.map(
-    (c) => `${c.args.map((a) => formatAbs2(a)).join(",")}->${formatAbs2(c.returnValue)}`
-  ).join("|");
-  return stampFingerprint(
-    markMockConf(
-      absFunction2(["...args"], {
-        body: dummyBody,
-        env: emptyEnv(),
-        apply: (args) => {
-          for (const c of caseAbs) {
-            if (c.declared.every((d, i) => absArgMatches(d, args[i]))) {
-              return c.result;
-            }
-          }
-          return markedDefault;
-        }
-      })
-    ),
-    `dispatch=default=${defaultKey};cases=${caseKey}`
-  );
+  return applyMockModuleDirectives(base, fileDirectives, opts);
 }
-function absFromMockHelper(h) {
-  if (h.callsFakeImpl) {
-    const { params, body, async } = h.callsFakeImpl;
-    return stampFingerprint(
-      absFunction2(params, { body, async: async ?? false }),
-      `fake=${params.join(",")}:${astContentKey(body)}`
-    );
-  }
-  let defaultReturn;
-  if (h.resolvedValue) {
-    defaultReturn = makeAbs2(
-      { k: "eff", eff: "promise", inner: h.resolvedValue },
-      void 0,
-      void 0,
-      "path"
-    );
-  } else if (h.rejectedValue) {
-    defaultReturn = makeAbs2({ k: "never" }, void 0, void 0, "exact");
-  } else if (h.returnValue) {
-    defaultReturn = h.returnValue;
-  } else if (h.onFirstCallValue) {
-    defaultReturn = h.onFirstCallValue;
-  } else {
-    defaultReturn = absUnknown;
-  }
-  return dispatchMockFn(defaultReturn, h.withArgsCases);
+
+// src/analysis-file-cache.ts
+var analysisByFile = /* @__PURE__ */ new Map();
+function clearAnalysisFileCache() {
+  analysisByFile.clear();
 }
-function absFromSinon(sinonExpr) {
-  if (sinonExpr.resolvedValue) {
-    return constantMockFn(
-      makeAbs2(
-        { k: "eff", eff: "promise", inner: sinonExpr.resolvedValue },
-        void 0,
-        void 0,
-        "path"
-      )
-    );
+function getAnalysisFileCacheSize() {
+  return analysisByFile.size;
+}
+function trimAnalysisFileCache() {
+  const max = getSessionCacheLimits().maxFiles;
+  while (analysisByFile.size > max) {
+    const oldest = analysisByFile.keys().next().value;
+    if (oldest === void 0) break;
+    analysisByFile.delete(oldest);
   }
-  if (sinonExpr.rejectedValue) {
-    return constantMockFn(makeAbs2({ k: "never" }, void 0, void 0, "exact"));
+}
+function analysisCacheGet(filePath, source, auxKey) {
+  const e = analysisByFile.get(filePath);
+  if (!e) return void 0;
+  if (e.source !== source || e.auxKey !== auxKey) return void 0;
+  analysisByFile.delete(filePath);
+  analysisByFile.set(filePath, e);
+  return e.value;
+}
+function analysisCacheSet(filePath, source, auxKey, value) {
+  const max = getSessionCacheLimits().maxFiles;
+  if (max <= 0) return;
+  while (analysisByFile.size >= max && !analysisByFile.has(filePath)) {
+    const oldest = analysisByFile.keys().next().value;
+    if (oldest === void 0) break;
+    analysisByFile.delete(oldest);
   }
-  if (sinonExpr.returnValue) {
-    return constantMockFn(sinonExpr.returnValue);
+  analysisByFile.set(filePath, { source, auxKey, value });
+}
+function evictAnalysisFileCacheForFiles(files) {
+  let n = 0;
+  for (const f of files) {
+    if (analysisByFile.delete(f)) n++;
   }
-  return constantMockFn(absUnknown);
+  return n;
 }
-function isAbsVal2(v) {
-  return !!v && typeof v === "object" && "shape" in v && "conf" in v;
+
+// src/fn-analysis-cache.ts
+var fnAnalysisCache = /* @__PURE__ */ new Map();
+function getFnAnalysisCacheSize() {
+  return fnAnalysisCache.size;
 }
-function loadFromMockBinding(name, fromPath, fromFile, loadModule) {
-  const base = fromFile ?? `${process.cwd()}/<mock-from>`;
-  const evaled = evalMockFileWithDeps(fromPath, base, loadModule);
-  if (!evaled.ok) {
-    return {
-      error: evaled.error.includes("not found") ? `Mock file not found for '${name}' (from "${fromPath}")` : evaled.error
-    };
-  }
-  const run = evaled.run;
-  let val = run[name];
-  if (val === void 0) {
-    const binds = bindingsOf2(run);
-    val = binds?.get(name);
-  }
-  if (val === void 0) {
-    return {
-      error: `Mock file "${fromPath}" does not define a binding named '${name}'`
-    };
+function clearFnAnalysisCache() {
+  fnAnalysisCache.clear();
+}
+function trimFnAnalysisCache() {
+  const max = getSessionCacheLimits().maxFns;
+  while (fnAnalysisCache.size > max) {
+    const oldest = fnAnalysisCache.keys().next().value;
+    if (oldest === void 0) break;
+    fnAnalysisCache.delete(oldest);
   }
-  let absVal;
-  if (isAbsVal2(val)) {
-    absVal = val;
-  } else if (typeof val === "function") {
-    const fn = val;
-    const params = Array.from({ length: fn.length ?? 0 }, (_, i) => `arg${i}`);
-    absVal = absFunction2(params, {
-      apply: (args) => callTranspiledExportFull3(run, name, args).result,
-      kind: "bpath-export",
-      fingerprint: `from-mock=${fromPath}#${name}`
-    });
-  } else {
-    absVal = absUnknown;
+}
+function fnAnalysisCacheGet(key) {
+  const hit = fnAnalysisCache.get(key);
+  if (hit !== void 0) {
+    fnAnalysisCache.delete(key);
+    fnAnalysisCache.set(key, hit);
   }
-  return { abs: markMockConf(absVal) };
+  return hit;
 }
-function mockSeedsToAbsMocks(seeds) {
-  const out = { ...seeds.seedVars };
-  for (const [name, fn] of Object.entries(seeds.seedFns)) {
-    out[name] = absFunction2(fn.params, { body: fn.body, async: fn.async ?? false });
+function fnAnalysisCacheSet(key, value) {
+  const max = getSessionCacheLimits().maxFns;
+  if (max <= 0) return;
+  while (fnAnalysisCache.size >= max && !fnAnalysisCache.has(key)) {
+    const oldest = fnAnalysisCache.keys().next().value;
+    if (oldest === void 0) break;
+    fnAnalysisCache.delete(oldest);
   }
-  return out;
+  fnAnalysisCache.set(key, value);
 }
-function mockDirectivesToAbsSeeds(functions, opts) {
-  const seedVars = {};
-  const seedFns = {};
-  const fromErrors = [];
-  for (const fn of functions) {
-    for (const d of fn.directives) {
-      if (d.kind !== "mock") continue;
-      if (d.fromPath) {
-        const r = loadFromMockBinding(d.name, d.fromPath, opts?.fromFile, opts?.loadModule);
-        if (r.abs) {
-          seedVars[d.name] = r.abs;
-        } else {
-          fromErrors.push({
-            name: d.name,
-            fromPath: d.fromPath,
-            message: r.error ?? `Mock file "${d.fromPath}" could not be loaded`
-          });
-        }
-        continue;
-      }
-      if (d.arrowFn) {
-        const body = d.arrowFn.body;
-        seedFns[d.name] = {
-          params: d.arrowFn.params,
-          body,
-          async: false,
-          fingerprint: `fake=${d.arrowFn.params.join(",")}:${astContentKey(body)}`
-        };
-      } else if (d.nudoMock) {
-        seedVars[d.name] = markMockConf(absFromMockHelper(d.nudoMock));
-      } else if (d.sinonExpr) {
-        seedVars[d.name] = markMockConf(absFromSinon(d.sinonExpr));
-      } else if (d.expression) {
-        try {
-          seedVars[d.name] = parseCaseArgExpr(d.expression);
-        } catch {
-          seedVars[d.name] = absUnknown;
-        }
-      }
+function evictFnAnalysisCacheForFiles(files) {
+  if (files.length === 0 || fnAnalysisCache.size === 0) return 0;
+  const prefixes = files.map((f) => `${f}\0`);
+  let n = 0;
+  for (const key of [...fnAnalysisCache.keys()]) {
+    if (prefixes.some((p) => key.startsWith(p))) {
+      fnAnalysisCache.delete(key);
+      n++;
     }
   }
-  return { seedVars, seedFns, ...fromErrors.length > 0 ? { fromErrors } : {} };
+  return n;
 }
-function mockSeedsForSource(source, opts) {
-  const fns = extractDirectives(parse5(source));
-  return mockSeedsToAbsMocks(mockDirectivesToAbsSeeds(fns, opts));
+function caseDirectiveKey(directives, formatAbs6) {
+  return directives.map((d) => {
+    if (d.kind === "case") {
+      const args = (d.argsAbs ?? []).map((a) => formatAbs6(a)).join(",");
+      return `c:${d.name ?? ""}:${args}`;
+    }
+    return d.kind;
+  }).join("|");
 }
 
-// src/analyzer-orchestrate-calls.ts
-import { dirname as dirname6 } from "path";
-import {
-  getBCallCollector,
-  getFnImpl as getFnImpl4,
-  setBCallCollector as setBCallCollector2,
-  $call as $call2,
-  unknown as absUnknown3
-} from "@nudojs/core";
-import { parse as parse7, extractFileDirectives as extractFileDirectives2 } from "@nudojs/parser";
-
-// src/analyzer-abs-eval.ts
-import { existsSync as existsSync4, statSync as statSync5 } from "fs";
-import { resolve as resolve5, dirname as dirname5 } from "path";
-import {
-  generalizeFromAst,
-  termToString,
-  predToString,
-  unknown as absUnknown2,
-  absFunction as absFunction3,
-  formatAbs as formatAbs4,
-  formatAbsMultiline
-} from "@nudojs/core";
-import { parse as parse6 } from "@nudojs/parser";
-
-// src/evaluator/call-record.ts
-import { formatAbs as formatAbs3, joinAbs, litValue as litValue2 } from "@nudojs/core";
-var neverAbs = { shape: { k: "never" }, conf: "exact" };
-var undefAbs = {
-  shape: { k: "unknown" },
-  term: { op: "lit", value: void 0 },
-  conf: "exact"
-};
-function absStructureKey(a) {
-  const v = litValue2(a);
-  if (v !== void 0) return `L:${typeof v}:${String(v)}`;
-  if (a.term?.op === "lit") return `L:${typeof a.term.value}:${String(a.term.value)}`;
+// src/bpath-run.ts
+import { runTranspiled, callTranspiledExport, callTranspiledExportFull as callTranspiledExportFull2, setBCallCollector, createEnvironment, formatAbs, getFnImpl } from "@nudojs/core";
+import { setMemberDiagCollector, setAbsTruncationCollector, stableAnalyzeKeySource as stableAnalyzeKeySource2, hashSource as hashSource2, loadModuleDepsFingerprint as loadModuleDepsFingerprint2 } from "@nudojs/core/internal";
+import { parse as parse4, extractInlineDirectives } from "@nudojs/parser";
+function absSeedPart(a) {
+  const impl = getFnImpl(a);
+  if (impl?.fingerprint) return impl.fingerprint;
+  if (a.shape.k === "fn") {
+    const ret = impl?.env?.vars?.get("__nudo_mock_ret");
+    if (ret) {
+      try {
+        return `ret=${formatAbs(ret)}`;
+      } catch {
+        return "ret=?";
+      }
+    }
+    if (impl?.apply) return "apply";
+  }
   try {
-    return formatAbs3(a);
+    return formatAbs(a);
   } catch {
-    return a.shape.k;
-  }
-}
-function shapeNodeCount(a, seen) {
-  if (!a || typeof a !== "object") return 1;
-  if (seen.has(a)) return 0;
-  seen.add(a);
-  const s = a.shape;
-  switch (s.k) {
-    case "arr":
-      return 1 + shapeNodeCount(s.element, seen);
-    case "tuple":
-      return 1 + s.elements.reduce((acc, e) => acc + shapeNodeCount(e, seen), 0);
-    case "obj": {
-      let n = 1;
-      for (const slot of Object.values(s.slots)) n += shapeNodeCount(slot.value, seen);
-      return n;
-    }
-    case "eff":
-      return 1 + shapeNodeCount(s.inner, seen);
-    case "sum":
-      return 1 + s.members.reduce((acc, e) => acc + shapeNodeCount(e, seen), 0);
-    case "brand":
-      return 1 + shapeNodeCount(s.shape, seen);
-    case "fn": {
-      let n = 1;
-      for (const p of s.paramTypes ?? []) n += shapeNodeCount(p, seen);
-      if (s.returnType) n += shapeNodeCount(s.returnType, seen);
-      return n;
-    }
-    default:
-      return 1;
+    return "?";
   }
 }
-var MAX_RECORD_TYPE_NODES = 2e3;
-function absNodeCount(a, seen = /* @__PURE__ */ new Set()) {
-  return shapeNodeCount(a, seen);
+function seedFnPart(name, fn) {
+  if (fn.fingerprint) return `${name}:${fn.fingerprint}`;
+  const body = fn.body;
+  const bodyKey = body && typeof body.start === "number" && typeof body.end === "number" ? `${body.start}:${body.end}:${body.type ?? ""}` : String(body?.type ?? "?");
+  return `${name}(${fn.params.join(",")})@${bodyKey}`;
 }
-function isOversizedCallRecord(rec) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const a of rec.argAbs) {
-    if (absNodeCount(a, seen) > MAX_RECORD_TYPE_NODES) return true;
+function mockSeedFingerprint(mocks, seedFns) {
+  const parts = [];
+  if (mocks) {
+    const names = Object.keys(mocks).sort();
+    for (const n of names) parts.push(`${n}=${absSeedPart(mocks[n])}`);
   }
-  return absNodeCount(rec.resultAbs, seen) > MAX_RECORD_TYPE_NODES;
-}
-function isLeakedCallRecord(rec) {
-  return rec.resultAbs.shape.k === "never" && rec.throwsAbs.shape.k === "never";
-}
-function joinAllAbs(members) {
-  if (members.length === 0) return neverAbs;
-  return members.reduce((a, b) => joinAbs(a, b));
-}
-function isPrimLit(a) {
-  return a.shape.k === "prim" && a.term?.op === "lit";
+  if (seedFns) {
+    const names = Object.keys(seedFns).sort();
+    for (const n of names) parts.push(`fn:${seedFnPart(n, seedFns[n])}`);
+  }
+  if (parts.length === 0) return "-";
+  return hashSource2(parts.join(";"));
 }
-function widenAbsPrim(a) {
-  if (a.shape.k === "prim" && a.term?.op === "lit") {
-    return { shape: a.shape, conf: a.conf === "exact" ? "path" : a.conf };
+function collectEnvGlobals(envNames) {
+  if (envNames.length === 0) return {};
+  const env = createEnvironment();
+  try {
+    return { ...loadEnvs(envNames, env).globals };
+  } catch {
+    return {};
   }
-  return a;
 }
-function collapseAbsLits(members, maxLits) {
-  const uniq = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const m of members) {
-    if (m.shape.k === "never") continue;
-    const k = absStructureKey(m);
-    if (seen.has(k)) continue;
-    seen.add(k);
-    uniq.push(m);
-  }
-  if (uniq.length === 0) return neverAbs;
-  if (uniq.length === 1) return uniq[0];
-  const nonLitPrims = /* @__PURE__ */ new Set();
-  for (const m of uniq) {
-    if (m.shape.k === "prim" && m.term?.op !== "lit") {
-      nonLitPrims.add(m.shape.type);
-    }
-  }
-  if (nonLitPrims.size > 0) {
-    const absorbed = uniq.filter(
-      (m) => !(m.shape.k === "prim" && m.term?.op === "lit" && nonLitPrims.has(m.shape.type))
-    );
-    if (absorbed.length !== uniq.length) {
-      return collapseAbsLits(absorbed, maxLits);
-    }
+function collectEnvModules(envNames) {
+  if (envNames.length === 0) return {};
+  const env = createEnvironment();
+  let mods = {};
+  try {
+    mods = loadEnvs(envNames, env).modules;
+  } catch {
+    return {};
   }
-  if (uniq.length > maxLits && uniq.every(isPrimLit)) {
-    const t = uniq[0].shape.type;
-    if (uniq.every((m) => m.shape.k === "prim" && m.shape.type === t)) {
-      return { shape: { k: "prim", type: t }, conf: "path" };
-    }
+  const out = {};
+  for (const [spec, named] of Object.entries(mods)) {
+    out[spec] = { named: { ...named } };
   }
-  return { shape: { k: "sum", members: uniq }, conf: "exact" };
-}
-function widenJoinAbs(members) {
-  return widenAbsPrim(joinAllAbs(members));
-}
-
-// src/analyzer-abs-eval.ts
-function absIsBetter(next, prev) {
-  const isBareUnknown = (a) => a.shape.k === "unknown" && !a.term;
-  const isNever = (a) => a.shape.k === "never";
-  const isStructured = (a) => a.term?.op === "lit" || a.shape.k === "obj" || a.shape.k === "arr" || a.shape.k === "tuple" || a.shape.k === "sum" || a.shape.k === "fn" || a.shape.k === "brand" || a.shape.k === "eff";
-  const hasPred = (a) => !!a.pred && a.pred.op !== "true";
-  if (isBareUnknown(prev)) return !isBareUnknown(next);
-  if (isBareUnknown(next) || isNever(next)) return false;
-  if (isStructured(prev)) return false;
-  if (hasPred(next) && prev.shape.k === "prim" && !hasPred(prev)) return true;
-  return false;
+  return out;
 }
-function isSelfContainedSource(source, envNames) {
-  if (envNames.length > 0) return false;
-  return !/\brequire\s*\(|\bimport\s*[{'"*]/.test(source);
+var envHarvestConflictCollector = null;
+function setEnvHarvestConflictCollector(collector) {
+  const prev = envHarvestConflictCollector;
+  envHarvestConflictCollector = collector;
+  return prev;
 }
-function absModulesOk(source, envNames) {
-  void source;
-  void envNames;
-  return true;
+function getEnvHarvestConflictCollector() {
+  return envHarvestConflictCollector;
 }
-function buildAbsImportLocalMap(source, fromFile) {
-  const out = /* @__PURE__ */ new Map();
-  try {
-    const file = parse6(source);
-    for (const stmt of file.program.body) {
-      if (stmt.type === "ImportDeclaration") {
-        const spec = stmt.source.value;
-        let modulePath = null;
-        if (spec.startsWith(".") || spec.startsWith("/")) {
-          modulePath = resolveImportAbs(spec, fromFile);
-        } else if (!spec.startsWith("node:")) {
-          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" });
-          } else if (s.type === "ImportNamespaceSpecifier") {
-            out.set(s.local.name, { modulePath, exportName: "*" });
-          }
-        }
-        continue;
-      }
-      if (stmt.type === "VariableDeclaration") {
-        for (const d of stmt.declarations) {
-          if (d.init?.type !== "CallExpression") continue;
-          const callee = d.init.callee;
-          if (callee.type !== "Identifier" || callee.name !== "require") continue;
-          const arg0 = d.init.arguments[0];
-          if (!arg0 || arg0.type !== "StringLiteral") continue;
-          const spec = arg0.value;
-          let modulePath = null;
-          if (spec.startsWith(".") || spec.startsWith("/")) {
-            modulePath = resolveImportAbs(spec, fromFile);
-          } else if (!spec.startsWith("node:")) {
-            modulePath = spec;
-          }
-          if (!modulePath) continue;
-          if (d.id.type === "ObjectPattern") {
-            for (const p of d.id.properties) {
-              if (p.type !== "ObjectProperty" || p.computed) continue;
-              if (p.key.type !== "Identifier" || p.value.type !== "Identifier") continue;
-              out.set(p.value.name, { modulePath, exportName: p.key.name });
-            }
-          } else if (d.id.type === "Identifier") {
-            out.set(d.id.name, { modulePath, exportName: "default" });
-          }
-        }
+function mergeHarvestUnderEnv(harvestModules, envModules, opts) {
+  const out = {};
+  for (const [mod, exports] of Object.entries(harvestModules)) {
+    const named = { ...exports.named };
+    out[mod] = exports.default !== void 0 ? { named, default: exports.default } : { named };
+  }
+  const notify = opts?.onConflict ?? envHarvestConflictCollector;
+  for (const [mod, envExports] of Object.entries(envModules)) {
+    const existing = out[mod];
+    if (!existing) {
+      const named2 = { ...envExports.named };
+      out[mod] = envExports.default !== void 0 ? { named: named2, default: envExports.default } : { named: named2 };
+      continue;
+    }
+    const overwritten = [];
+    for (const key of Object.keys(envExports.named)) {
+      if (existing.named[key] !== void 0) overwritten.push(key);
+    }
+    const defaultOverwritten = envExports.default !== void 0 && existing.default !== void 0;
+    if (notify && (overwritten.length > 0 || defaultOverwritten)) {
+      try {
+        notify({
+          module: mod,
+          exports: overwritten,
+          defaultOverwritten
+        });
+      } catch {
       }
     }
-  } catch {
+    const named = { ...existing.named, ...envExports.named };
+    const defaultAbs = envExports.default !== void 0 ? envExports.default : existing.default;
+    out[mod] = defaultAbs !== void 0 ? { named, default: defaultAbs } : { named };
   }
   return out;
 }
-function resolveImportAbs(spec, fromFile) {
-  const base = dirname5(resolve5(fromFile));
-  const p = resolve5(base, spec);
-  for (const cand of [p, `${p}.js`, `${p}.mjs`, `${p}.ts`, resolve5(p, "index.js")]) {
-    if (existsSync4(cand) && !statSync5(cand).isDirectory()) return cand;
-  }
-  return null;
-}
-function tryEvalAbsRaw(source, fnName, args, filePath, mocks, assignedName) {
-  return tryEvalAbsFull(source, fnName, args, filePath, mocks, assignedName)?.result;
-}
-function tryEvalAbsFull(source, fnName, args, filePath, mocks, assignedName) {
-  if (/\brequire\s*\(/.test(source)) return void 0;
+function collectBPathReplacements(source) {
+  const targets = [];
+  const values = {};
+  const asTargets = [];
+  const asValues = {};
+  let i = 0;
   try {
-    if (filePath) {
-      const viaB = tryBPathCallFull(source, filePath, fnName, args, { mocks }) ?? (assignedName ? tryBPathCallFull(source, filePath, assignedName, args, { mocks }) : void 0);
-      if (viaB) {
-        const r = viaB.result;
-        if (r && !(r.shape.k === "unknown" && !r.term)) {
-          const throws = viaB.throws ?? { shape: { k: "never" }, conf: "exact" };
-          return { result: r, throws };
+    const file = parse4(source);
+    const visitStmts = (stmts) => {
+      for (const stmt of stmts) {
+        if (!stmt || typeof stmt !== "object") continue;
+        const loc = stmt.loc;
+        const dirs = extractInlineDirectives(stmt);
+        for (const d of dirs) {
+          if (d.kind === "replace") {
+            const varName = `__rep${i++}`;
+            targets.push({
+              target: d.targetSource,
+              varName,
+              stmtStart: loc?.start.line,
+              stmtEnd: loc?.end.line
+            });
+            values[varName] = d.typeAbs;
+          } else if (d.kind === "as" && loc) {
+            const varName = `__as${i++}`;
+            asTargets.push({
+              varName,
+              stmtStart: loc.start.line,
+              stmtEnd: loc.end.line
+            });
+            asValues[varName] = d.typeAbs;
+          }
+        }
+        const s = stmt;
+        if (s.type === "BlockStatement" && Array.isArray(s.body)) visitStmts(s.body);
+        if (s.type === "FunctionDeclaration" || s.type === "FunctionExpression") {
+          if (s.body) visitStmts([s.body]);
+        }
+        if (s.type === "ExportNamedDeclaration" && s.declaration) {
+          visitStmts([s.declaration]);
+        }
+        if (s.type === "IfStatement") {
+          if (s.consequent) visitStmts([s.consequent]);
+          if (s.alternate) visitStmts([s.alternate]);
         }
       }
-    }
-    return void 0;
+    };
+    visitStmts(file.program.body);
   } catch {
-    return void 0;
   }
+  return { targets, values, asTargets, asValues };
 }
-function tryEvalEntryAbs(source, fnName, args, filePath, mocks, assignedName) {
-  return tryEvalAbsRaw(source, fnName, args, filePath, mocks, assignedName);
+function isBPathCapable(source, envNames = []) {
+  void envNames;
+  void source;
+  return true;
 }
-function tryAttachIntension(caseResult, source, fnName) {
+var bRunByFile = /* @__PURE__ */ new Map();
+function bPathDepKey(source, filePath) {
   try {
-    const g = generalizeFromAst(fnName, source);
-    if (!g) return;
-    const sym = g.symbolic;
-    const intension = {
-      display: g.display,
-      abs: formatAbs4(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;
+    const fp = loadModuleDepsFingerprint2(source, defaultLoadModule, filePath);
+    if (fp.truncated) return null;
+    return hashSource2(fp.fp);
   } catch {
+    return null;
   }
 }
-function attachHofSnapshot(analysis, source) {
-  if (analysis.hof) return;
-  try {
-    const g = generalizeFromAst(analysis.name, source);
-    if (!g) return;
-    const fnRels = g.fnRels ? [...g.fnRels.entries()].map(([param, rec]) => ({ param, abs: rec.abs })) : void 0;
-    const entryShapes = g.entryShapes ? [...g.entryShapes.entries()].map(([param, rec]) => ({ param, abs: rec.abs })) : void 0;
-    if (!fnRels?.length && !entryShapes?.length) return;
-    analysis.hof = {
-      ...fnRels?.length ? { fnRels } : {},
-      ...entryShapes?.length ? { entryShapes } : {},
-      symbolic: g.symbolic
-    };
-  } catch {
-  }
+function clearBPathCache() {
+  bRunByFile.clear();
+  clearAnalysisFileCache();
+  clearFnAnalysisCache();
 }
-function attachAbsToIntension(caseResult, absVal, label) {
-  const prev = caseResult.intension ?? {};
-  caseResult.abs = absVal;
-  caseResult.intension = {
-    ...prev,
-    abs: formatAbs4(absVal),
-    absMultiline: formatAbsMultiline(absVal, label ?? caseResult.name),
-    conf: absVal.conf
-  };
+function getBPathCacheSize() {
+  return bRunByFile.size;
 }
-function safeAbsOrUnknown(a) {
-  if (a && typeof a === "object" && "shape" in a && "conf" in a) {
-    return a;
-  }
-  if (typeof a === "function") {
-    const fn = a;
-    const n = Math.max(0, fn.length);
-    const params = Array.from({ length: n }, (_, i) => `arg${i}`);
-    return absFunction3(params, {
-      body: { type: "BlockStatement", body: [], directives: [] },
-      apply: (args) => {
-        try {
-          const r = fn(...args);
-          if (r && typeof r === "object" && "shape" in r) return r;
-          return absUnknown2;
-        } catch {
-          return absUnknown2;
-        }
-      }
-    });
+function evictBPathCacheForFiles(files) {
+  let n = 0;
+  for (const f of files) {
+    if (bRunByFile.delete(f)) n++;
   }
-  return absUnknown2;
+  return n;
 }
-function callRecordFromAbsCall(r, impMap) {
-  const argAbs = r.args.map(safeAbsOrUnknown);
-  const threw = !!r.threw;
-  const thrownOrResult = safeAbsOrUnknown(r.result);
-  const rec = {
-    fnName: r.fnName,
-    argAbs,
-    resultAbs: threw ? neverAbs : thrownOrResult,
-    throwsAbs: threw ? thrownOrResult : neverAbs,
-    callLoc: r.callLoc
-  };
-  const imp = impMap?.get(r.fnName) ?? // `ns.helper` / `Class.method`：先整名，再按首段点号拆命名空间成员
-  (() => {
-    const dot = r.fnName.indexOf(".");
-    if (dot <= 0) return void 0;
-    const base = impMap?.get(r.fnName.slice(0, dot));
-    if (!base || base.exportName !== "*") return void 0;
-    return {
-      modulePath: base.modulePath,
-      exportName: r.fnName.slice(dot + 1)
-    };
-  })();
-  if (imp) {
-    rec.targetModule = imp.modulePath;
-    rec.targetExport = imp.exportName;
+function bPathCacheSet(filePath, stableSource, mode, envKey, mockKey, depKey, value) {
+  const max = getSessionCacheLimits().maxBRuns;
+  if (max <= 0) return;
+  while (bRunByFile.size >= max && !bRunByFile.has(filePath)) {
+    const oldest = bRunByFile.keys().next().value;
+    if (oldest === void 0) break;
+    bRunByFile.delete(oldest);
   }
-  return rec;
+  bRunByFile.set(filePath, { stableSource, mode, envKey, mockKey, depKey, value });
 }
-
-// src/analyzer-orchestrate-calls.ts
-function collectEnvNames(filePath, source, includeProject) {
-  const ast = parse7(source);
-  const fileDirectives = extractFileDirectives2(ast);
-  const fileEnvNames = fileDirectives.filter((d) => d.kind === "env").flatMap((d) => d.envs);
-  if (!includeProject) return fileEnvNames;
-  const projectConfig = findProjectConfig(dirname6(filePath));
-  const projectEnvNames = projectConfig?.config.env ?? [];
-  return [.../* @__PURE__ */ new Set([...projectEnvNames, ...fileEnvNames])];
+function trimBPathCache() {
+  const max = getSessionCacheLimits().maxBRuns;
+  while (bRunByFile.size > max) {
+    const oldest = bRunByFile.keys().next().value;
+    if (oldest === void 0) break;
+    bRunByFile.delete(oldest);
+  }
 }
-function collectCallRecords(filePath, source) {
-  if (filePath) {
+function tryRunBPath(source, filePath, opts = {}) {
+  if (!isBPathCapable(source, opts.envNames ?? [])) return void 0;
+  const mode = opts.mode ?? "analyze";
+  const envKey = (opts.envNames ?? []).join(",");
+  const mockKey = mockSeedFingerprint(opts.mocks);
+  const stable = stableAnalyzeKeySource2(source);
+  const depKey = bPathDepKey(source, filePath);
+  const canCache = depKey !== null;
+  if (canCache) {
+    const cached = bRunByFile.get(filePath);
+    if (cached && cached.stableSource === stable && cached.mode === mode && cached.envKey === envKey && cached.mockKey === mockKey && cached.depKey === depKey) {
+      bRunByFile.delete(filePath);
+      bRunByFile.set(filePath, cached);
+      return cached.value ?? void 0;
+    }
+  }
+  let out = null;
+  try {
+    const memberDiags = [];
+    const truncated = /* @__PURE__ */ new Set();
+    const topCalls = [];
+    const prevMember = setMemberDiagCollector((d) => memberDiags.push(d));
+    const prevTrunc = setAbsTruncationCollector((label) => truncated.add(label));
+    const prevCall = setBCallCollector((r) => topCalls.push(r));
     try {
-      const mocks = mockSeedsForSource(source, {
-        fromFile: filePath || void 0
-      });
-      const run = tryRunBPath(source, filePath, {
-        mode: "exec",
-        lenientGlobals: true,
-        ...Object.keys(mocks).length > 0 ? { mocks } : {}
+      const { modules: graphMods, issues } = evalAbsModuleGraph(source, filePath);
+      const envMods = collectEnvModules(opts.envNames ?? []);
+      let modules = mergeHarvestUnderEnv(graphMods, envMods);
+      const mm = applyMockModuleDirectivesFromSource(source, modules, { fromFile: filePath });
+      modules = mm.modules;
+      const { targets, values, asTargets, asValues } = collectBPathReplacements(source);
+      const envGlobals = {
+        ...collectEnvGlobals(opts.envNames ?? []),
+        ...opts.mocks ?? {}
+      };
+      const exports = runTranspiled(source, {
+        modules,
+        maxLoopIters: opts.maxLoopIters,
+        mode: opts.mode ?? "analyze",
+        replacementTargets: targets.length ? targets : void 0,
+        replacements: targets.length ? values : void 0,
+        asOverrideTargets: asTargets.length ? asTargets : void 0,
+        asOverrides: asTargets.length ? asValues : void 0,
+        envGlobals: Object.keys(envGlobals).length ? envGlobals : void 0,
+        lenientGlobals: opts.lenientGlobals
       });
-      if (run?.calls?.length) {
-        const importLocals = buildAbsImportLocalMap(source, filePath);
-        return expandTestCallbacks(run.calls).map((r) => callRecordFromAbsCall(r, importLocals));
-      }
-    } catch {
+      out = {
+        exports,
+        modules,
+        memberDiags: memberDiags.length ? memberDiags : void 0,
+        moduleIssues: issues.length ? issues : void 0,
+        truncatedFns: truncated.size ? [...truncated] : void 0,
+        calls: topCalls.length ? topCalls : void 0
+      };
+    } finally {
+      setMemberDiagCollector(prevMember);
+      setAbsTruncationCollector(prevTrunc);
+      setBCallCollector(prevCall);
     }
+  } catch {
+    out = null;
   }
-  return [];
-}
-function expandTestCallbacks(calls) {
-  const out = [...calls];
-  const seenDescribe = /* @__PURE__ */ new Set();
-  let cursor = 0;
-  let expanded = 0;
-  while (cursor < out.length && expanded < 500) {
-    const rec = out[cursor++];
-    if (rec.fnName !== "it" && rec.fnName !== "test" && rec.fnName !== "describe") continue;
-    for (const a of rec.args) {
-      if (!a || typeof a !== "object" || !("shape" in a)) continue;
-      const abs = a;
-      if (abs.shape.k !== "fn") continue;
-      if (rec.fnName === "describe") {
-        if (seenDescribe.has(abs)) continue;
-        seenDescribe.add(abs);
-      }
-      const impl = getFnImpl4(abs);
-      const params = impl?.params ?? [];
-      const collected = [];
-      const prev = getBCallCollector();
-      setBCallCollector2((r) => collected.push(r));
-      try {
-        $call2(abs, params.map(() => absUnknown3));
-      } catch {
-      } finally {
-        setBCallCollector2(prev);
-      }
-      out.push(...collected);
-      expanded++;
-    }
+  if (canCache && depKey !== null) {
+    bPathCacheSet(filePath, stable, mode, envKey, mockKey, depKey, out);
   }
-  return out;
+  return out ?? void 0;
 }
-
-// src/bpath-diagnostics.ts
-import { parseSource } from "@nudojs/core";
-function locOf(node) {
-  if (!node.loc) return null;
-  return {
-    start: { line: node.loc.start.line, column: node.loc.start.column },
-    end: { line: node.loc.end.line, column: node.loc.end.column }
-  };
+function tryBPathCallFull(source, filePath, fnName, args, opts = {}) {
+  const run = tryRunBPath(source, filePath, { envNames: opts.envNames, mocks: opts.mocks });
+  if (!run) return void 0;
+  if (!(fnName in run.exports)) return void 0;
+  const collected = [];
+  const memberDiags = [];
+  const prevCall = opts.collectCalls ? setBCallCollector((r) => collected.push(r)) : void 0;
+  const wantMember = opts.collectMemberDiags ?? true;
+  const prevMember = wantMember ? setMemberDiagCollector((d) => memberDiags.push(d)) : void 0;
+  try {
+    const full = callTranspiledExportFull2(run.exports, fnName, args, opts.phi ? { phi: opts.phi } : void 0);
+    const all = [...run.memberDiags ?? [], ...memberDiags];
+    return {
+      ...full,
+      calls: opts.collectCalls ? collected : void 0,
+      memberDiags: all.length ? all : void 0,
+      moduleIssues: run.moduleIssues,
+      truncatedFns: run.truncatedFns
+    };
+  } finally {
+    if (opts.collectCalls) setBCallCollector(prevCall ?? null);
+    if (wantMember) setMemberDiagCollector(prevMember ?? null);
+  }
 }
-function isExit(stmt) {
-  return stmt.type === "ReturnStatement" || stmt.type === "ThrowStatement";
+function tryBPathCall(source, filePath, fnName, args, opts = {}) {
+  const full = tryBPathCallFull(source, filePath, fnName, args, opts);
+  if (!full) return void 0;
+  const r = full.result;
+  if (!r) return void 0;
+  if (r.shape.k === "never" && full.throws.shape.k !== "never") {
+    return void 0;
+  }
+  if (r.shape.k === "unknown" && !r.term) return void 0;
+  return r;
 }
-function walkUnreachable(node, out) {
-  const n = node;
-  const checkBlock = (block) => {
-    if (!block) return;
-    const body = block.body ?? (Array.isArray(block) ? block : null);
-    if (!Array.isArray(body)) return;
-    for (let i = 0; i < body.length; i++) {
-      walkUnreachable(body[i], out);
-      if (isExit(body[i])) {
-        for (let j = i + 1; j < body.length; j++) {
-          const r = locOf(body[j]);
-          if (r) out.push({ range: r });
-        }
-        break;
-      }
-    }
-  };
-  switch (n.type) {
-    case "Program":
-    case "BlockStatement":
-      checkBlock(n.body);
-      break;
-    case "FunctionDeclaration":
-    case "FunctionExpression":
-    case "ArrowFunctionExpression":
-      if (n.body) walkUnreachable(n.body, out);
-      break;
-    case "IfStatement":
-      if (n.consequent) walkUnreachable(n.consequent, out);
-      if (n.alternate) walkUnreachable(n.alternate, out);
-      break;
-    case "ForStatement":
-    case "ForInStatement":
-    case "ForOfStatement":
-    case "WhileStatement":
-    case "DoWhileStatement":
-      if (n.body) walkUnreachable(n.body, out);
-      break;
-    case "TryStatement":
-      if (n.block) walkUnreachable(n.block, out);
-      if (n.handler?.body) walkUnreachable(n.handler.body, out);
-      if (n.finalizer) walkUnreachable(n.finalizer, out);
-      break;
-    case "SwitchStatement":
-      for (const c of n.cases ?? []) {
-        checkBlock(c.consequent);
-      }
-      break;
-    case "ExportNamedDeclaration":
-    case "ExportDefaultDeclaration": {
-      const decl = n.declaration;
-      if (decl) walkUnreachable(decl, out);
-      break;
+
+// src/mock-abs.ts
+import { extractDirectives } from "@nudojs/parser";
+import { parse as parse5, parseCaseArgExpr } from "@nudojs/parser";
+import {
+  absFunction as absFunction2,
+  emptyEnv,
+  abs as makeAbs2,
+  confJoin,
+  unknown as absUnknown2,
+  litValue,
+  formatAbs as formatAbs2,
+  getFnImpl as getFnImpl2,
+  bindingsOf as bindingsOf2,
+  callTranspiledExportFull as callTranspiledExportFull3
+} from "@nudojs/core";
+function markMockConf(a) {
+  a.conf = confJoin(a.conf, "mock");
+  return a;
+}
+function astContentKey(n, depth = 0) {
+  if (n == null || depth > 24) return "";
+  if (typeof n !== "object") return String(n);
+  if (Array.isArray(n)) return n.map((x) => astContentKey(x, depth + 1)).join(",");
+  const obj = n;
+  const type = typeof obj.type === "string" ? obj.type : "";
+  const parts = [type];
+  for (const key of ["name", "value", "raw", "operator", "computed"]) {
+    const v = obj[key];
+    if (v !== void 0 && (typeof v !== "object" || v === null)) parts.push(`${key}=${String(v)}`);
+  }
+  for (const key of Object.keys(obj)) {
+    if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments" || key === "innerComments" || key === "type" || key === "name" || key === "value" || key === "raw" || key === "operator" || key === "computed") {
+      continue;
     }
-    default:
-      break;
+    const v = obj[key];
+    if (v && typeof v === "object") parts.push(`${key}:{${astContentKey(v, depth + 1)}}`);
   }
+  return parts.join("|");
 }
-function collectDeclared(file) {
-  const names = /* @__PURE__ */ new Set();
-  const addId = (id) => {
-    if (!id) return;
-    if (id.type === "Identifier") names.add(id.name);
-    if (id.type === "ObjectPattern") {
-      for (const p of id.properties) {
-        addId(p.value);
+function stampFingerprint(a, fp) {
+  const impl = getFnImpl2(a);
+  if (impl) impl.fingerprint = fp;
+  return a;
+}
+function constantMockFn(result) {
+  const marked = markMockConf(result);
+  const mockEnv = emptyEnv();
+  const retName = "__nudo_mock_ret";
+  mockEnv.vars.set(retName, marked);
+  const body = {
+    type: "BlockStatement",
+    body: [
+      {
+        type: "ReturnStatement",
+        argument: { type: "Identifier", name: retName }
       }
-    }
-    if (id.type === "ArrayPattern") {
-      for (const el of id.elements) addId(el);
-    }
+    ]
   };
-  const visit = (node) => {
-    if (!node || typeof node !== "object") return;
-    const o = node;
-    switch (o.type) {
-      case "FunctionDeclaration":
-      case "ClassDeclaration":
-        addId(o.id);
-        break;
-      case "VariableDeclarator":
-        addId(o.id);
-        break;
-      case "ImportSpecifier":
-      case "ImportDefaultSpecifier":
-      case "ImportNamespaceSpecifier":
-        addId(o.local);
-        break;
-      case "CatchClause":
-        addId(o.param);
-        break;
-      default:
-        break;
-    }
-    if (o.params && Array.isArray(o.params)) {
-      for (const p of o.params) addId(p);
-    }
-    for (const key of Object.keys(o)) {
-      if (key === "loc" || key === "start" || key === "end") continue;
-      const v = o[key];
-      if (Array.isArray(v)) v.forEach(visit);
-      else if (v && typeof v === "object") visit(v);
+  let retKey;
+  try {
+    retKey = formatAbs2(marked);
+  } catch {
+    retKey = "?";
+  }
+  return stampFingerprint(
+    markMockConf(absFunction2(["...args"], { body, env: mockEnv })),
+    `ret=${retKey}`
+  );
+}
+function absArgMatches(declared, actual) {
+  if (!actual) return false;
+  const av = litValue(actual);
+  const dv = litValue(declared);
+  if (dv !== void 0) {
+    return av !== void 0 && Object.is(av, dv);
+  }
+  if (declared.shape.k === "prim") {
+    if (actual.shape.k === "prim") return actual.shape.type === declared.shape.type;
+    if (av !== void 0) {
+      const t = typeof av;
+      return declared.shape.type === "number" && t === "number" || declared.shape.type === "string" && t === "string" || declared.shape.type === "boolean" && t === "boolean" || declared.shape.type === "bigint" && t === "bigint";
     }
+  }
+  return false;
+}
+function dispatchMockFn(defaultReturn, cases) {
+  if (!cases?.length) return constantMockFn(defaultReturn);
+  const caseAbs = cases.map((c) => ({
+    declared: c.args,
+    result: markMockConf(c.returnValue)
+  }));
+  const dummyBody = {
+    type: "BlockStatement",
+    body: [{ type: "ReturnStatement", argument: null }]
   };
-  visit(file);
-  return names;
+  const markedDefault = markMockConf(defaultReturn);
+  let defaultKey;
+  try {
+    defaultKey = formatAbs2(markedDefault);
+  } catch {
+    defaultKey = "?";
+  }
+  const caseKey = cases.map(
+    (c) => `${c.args.map((a) => formatAbs2(a)).join(",")}->${formatAbs2(c.returnValue)}`
+  ).join("|");
+  return stampFingerprint(
+    markMockConf(
+      absFunction2(["...args"], {
+        body: dummyBody,
+        env: emptyEnv(),
+        apply: (args) => {
+          for (const c of caseAbs) {
+            if (c.declared.every((d, i) => absArgMatches(d, args[i]))) {
+              return c.result;
+            }
+          }
+          return markedDefault;
+        }
+      })
+    ),
+    `dispatch=default=${defaultKey};cases=${caseKey}`
+  );
 }
-var KNOWN_GLOBALS = /* @__PURE__ */ new Set([
-  "Object",
-  "Array",
-  "String",
-  "Number",
-  "Boolean",
-  "Symbol",
-  "Math",
-  "JSON",
-  "Promise",
-  "Error",
-  "TypeError",
-  "RangeError",
-  "SyntaxError",
-  "RegExp",
-  "Date",
-  "Map",
-  "Set",
-  "WeakMap",
-  "WeakSet",
-  "console",
-  "undefined",
-  "NaN",
-  "Infinity",
-  "globalThis",
-  "parseInt",
-  "parseFloat",
-  "isNaN",
-  "isFinite"
-]);
-function isStaticStringExpr(node) {
-  if (!node || typeof node !== "object") return false;
-  const n = node;
-  if (n.type === "StringLiteral" || n.type === "NumericLiteral") return true;
-  if (n.type === "TemplateLiteral") {
-    return (n.expressions ?? []).every((e) => isStaticStringExpr(e));
+function absFromMockHelper(h) {
+  if (h.callsFakeImpl) {
+    const { params, body, async } = h.callsFakeImpl;
+    return stampFingerprint(
+      absFunction2(params, { body, async: async ?? false }),
+      `fake=${params.join(",")}:${astContentKey(body)}`
+    );
+  }
+  let defaultReturn;
+  if (h.resolvedValue) {
+    defaultReturn = makeAbs2(
+      { k: "eff", eff: "promise", inner: h.resolvedValue },
+      void 0,
+      void 0,
+      "path"
+    );
+  } else if (h.rejectedValue) {
+    defaultReturn = makeAbs2({ k: "never" }, void 0, void 0, "exact");
+  } else if (h.returnValue) {
+    defaultReturn = h.returnValue;
+  } else if (h.onFirstCallValue) {
+    defaultReturn = h.onFirstCallValue;
+  } else {
+    defaultReturn = absUnknown2;
+  }
+  return dispatchMockFn(defaultReturn, h.withArgsCases);
+}
+function absFromSinon(sinonExpr) {
+  if (sinonExpr.resolvedValue) {
+    return constantMockFn(
+      makeAbs2(
+        { k: "eff", eff: "promise", inner: sinonExpr.resolvedValue },
+        void 0,
+        void 0,
+        "path"
+      )
+    );
+  }
+  if (sinonExpr.rejectedValue) {
+    return constantMockFn(makeAbs2({ k: "never" }, void 0, void 0, "exact"));
+  }
+  if (sinonExpr.returnValue) {
+    return constantMockFn(sinonExpr.returnValue);
+  }
+  return constantMockFn(absUnknown2);
+}
+function isAbsVal2(v) {
+  return !!v && typeof v === "object" && "shape" in v && "conf" in v;
+}
+function loadFromMockBinding(name, fromPath, fromFile, loadModule) {
+  const base = fromFile ?? `${process.cwd()}/<mock-from>`;
+  const evaled = evalMockFileWithDeps(fromPath, base, loadModule);
+  if (!evaled.ok) {
+    return {
+      error: evaled.error.includes("not found") ? `Mock file not found for '${name}' (from "${fromPath}")` : evaled.error
+    };
+  }
+  const run = evaled.run;
+  let val = run[name];
+  if (val === void 0) {
+    const binds = bindingsOf2(run);
+    val = binds?.get(name);
+  }
+  if (val === void 0) {
+    return {
+      error: `Mock file "${fromPath}" does not define a binding named '${name}'`
+    };
   }
-  if (n.type === "BinaryExpression" && n.operator === "+") {
-    return isStaticStringExpr(n.left) && isStaticStringExpr(n.right);
+  let absVal;
+  if (isAbsVal2(val)) {
+    absVal = val;
+  } else if (typeof val === "function") {
+    const fn = val;
+    const params = Array.from({ length: fn.length ?? 0 }, (_, i) => `arg${i}`);
+    absVal = absFunction2(params, {
+      apply: (args) => callTranspiledExportFull3(run, name, args).result,
+      kind: "bpath-export",
+      fingerprint: `from-mock=${fromPath}#${name}`
+    });
+  } else {
+    absVal = absUnknown2;
   }
-  return false;
+  return { abs: markMockConf(absVal) };
 }
-function isFreeUnknown(name, declared, seen, known) {
-  return !declared.has(name) && !known.has(name) && !name.startsWith("$") && !seen.has(name);
+function mockSeedsToAbsMocks(seeds) {
+  const out = { ...seeds.seedVars };
+  for (const [name, fn] of Object.entries(seeds.seedFns)) {
+    out[name] = absFunction2(fn.params, { body: fn.body, async: fn.async ?? false });
+  }
+  return out;
 }
-function walkBuiltinUnknown(node, declared, out, seen, known, parentKey) {
-  const n = node;
-  const flag = (idNode, name) => {
-    if (!isFreeUnknown(name, declared, seen, known)) return;
-    const range = locOf(idNode) ?? locOf(node);
-    if (range) {
-      out.push({ name, range });
-      seen.add(name);
-    }
-  };
-  if (n.type === "CallExpression") {
-    const callee = n.callee;
-    const args = n.arguments ?? [];
-    if (callee?.type === "Identifier" && callee.name === "require") {
-      if (!isStaticStringExpr(args[0])) flag(n.callee, "require");
-    } else if (callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.name === "require") {
-      if (callee.property?.name === "resolve" && !isStaticStringExpr(args[0])) {
-        flag(callee.object, "require");
+function mockDirectivesToAbsSeeds(functions, opts) {
+  const seedVars = {};
+  const seedFns = {};
+  const fromErrors = [];
+  for (const fn of functions) {
+    for (const d of fn.directives) {
+      if (d.kind !== "mock") continue;
+      if (d.fromPath) {
+        const r = loadFromMockBinding(d.name, d.fromPath, opts?.fromFile, opts?.loadModule);
+        if (r.abs) {
+          seedVars[d.name] = r.abs;
+        } else {
+          fromErrors.push({
+            name: d.name,
+            fromPath: d.fromPath,
+            message: r.error ?? `Mock file "${d.fromPath}" could not be loaded`
+          });
+        }
+        continue;
       }
-    } else if (callee?.type === "Identifier") {
-      flag(n.callee, callee.name);
-    }
-  } else if (n.type === "Identifier" && typeof n.name === "string" && n.name !== "require" && parentKey !== "key" && parentKey !== "property" && parentKey !== "local" && parentKey !== "id") {
-    flag(node, n.name);
-  }
-  for (const key of Object.keys(n)) {
-    if (key === "loc" || key === "start" || key === "end") continue;
-    const v = n[key];
-    if (Array.isArray(v)) {
-      v.forEach((x) => {
-        if (x && typeof x === "object" && "type" in x) {
-          walkBuiltinUnknown(x, declared, out, seen, known, key);
+      if (d.arrowFn) {
+        const body = d.arrowFn.body;
+        seedFns[d.name] = {
+          params: d.arrowFn.params,
+          body,
+          async: false,
+          fingerprint: `fake=${d.arrowFn.params.join(",")}:${astContentKey(body)}`
+        };
+      } else if (d.nudoMock) {
+        seedVars[d.name] = markMockConf(absFromMockHelper(d.nudoMock));
+      } else if (d.sinonExpr) {
+        seedVars[d.name] = markMockConf(absFromSinon(d.sinonExpr));
+      } else if (d.expression) {
+        try {
+          seedVars[d.name] = parseCaseArgExpr(d.expression);
+        } catch {
+          seedVars[d.name] = absUnknown2;
         }
-      });
-    } else if (v && typeof v === "object" && "type" in v) {
-      walkBuiltinUnknown(v, declared, out, seen, known, key);
+      }
     }
   }
+  return { seedVars, seedFns, ...fromErrors.length > 0 ? { fromErrors } : {} };
 }
-function collectBPathDiagnostics(source, extraKnown) {
-  let file;
+function mockSeedsForSource(source, opts) {
+  const fns = extractDirectives(parse5(source));
+  return mockSeedsToAbsMocks(mockDirectivesToAbsSeeds(fns, opts));
+}
+
+// src/analyzer-orchestrate-calls.ts
+import { dirname as dirname6 } from "path";
+import {
+  getBCallCollector,
+  getFnImpl as getFnImpl4,
+  setBCallCollector as setBCallCollector2,
+  $call as $call2,
+  unknown as absUnknown4
+} from "@nudojs/core";
+import { parse as parse7, extractFileDirectives as extractFileDirectives2 } from "@nudojs/parser";
+
+// src/analyzer-abs-eval.ts
+import { existsSync as existsSync4, statSync as statSync5 } from "fs";
+import { resolve as resolve5, dirname as dirname5 } from "path";
+import {
+  generalizeFromAst,
+  termToString,
+  predToString,
+  unknown as absUnknown3,
+  absFunction as absFunction3,
+  formatAbs as formatAbs4,
+  formatAbsMultiline
+} from "@nudojs/core";
+import { parse as parse6 } from "@nudojs/parser";
+
+// src/evaluator/call-record.ts
+import { formatAbs as formatAbs3, joinAbs, litValue as litValue2 } from "@nudojs/core";
+var neverAbs = { shape: { k: "never" }, conf: "exact" };
+var undefAbs = {
+  shape: { k: "unknown" },
+  term: { op: "lit", value: void 0 },
+  conf: "exact"
+};
+function absStructureKey(a) {
+  const v = litValue2(a);
+  if (v !== void 0) return `L:${typeof v}:${String(v)}`;
+  if (a.term?.op === "lit") return `L:${typeof a.term.value}:${String(a.term.value)}`;
   try {
-    file = parseSource(source);
+    return formatAbs3(a);
   } catch {
-    return { unreachable: [], builtinUnknown: [] };
-  }
-  const unreachable = [];
-  const root = file.program ?? file;
-  walkUnreachable(root, unreachable);
-  const declared = collectDeclared(file);
-  const known = new Set(KNOWN_GLOBALS);
-  if (extraKnown) {
-    for (const n of extraKnown) known.add(n);
+    return a.shape.k;
   }
-  const builtinUnknown = [];
-  walkBuiltinUnknown(file, declared, builtinUnknown, /* @__PURE__ */ new Set(), known);
-  return { unreachable, builtinUnknown };
 }
-
-// src/dual-entry.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname7, join as join3, resolve as resolve6 } from "path";
-function collectExportFaces(exportsField, browser, node) {
-  if (exportsField == null) return;
-  if (typeof exportsField === "string") {
-    node.push(exportsField);
-    return;
-  }
-  const walk = (val, inBrowser) => {
-    if (typeof val === "string") {
-      if (inBrowser) browser.push(val);
-      else node.push(val);
-      return;
-    }
-    if (Array.isArray(val)) {
-      for (const v of val) walk(v, inBrowser);
-      return;
+function shapeNodeCount(a, seen) {
+  if (!a || typeof a !== "object") return 1;
+  if (seen.has(a)) return 0;
+  seen.add(a);
+  const s = a.shape;
+  switch (s.k) {
+    case "arr":
+      return 1 + shapeNodeCount(s.element, seen);
+    case "tuple":
+      return 1 + s.elements.reduce((acc, e) => acc + shapeNodeCount(e, seen), 0);
+    case "obj": {
+      let n = 1;
+      for (const slot of Object.values(s.slots)) n += shapeNodeCount(slot.value, seen);
+      return n;
     }
-    if (!val || typeof val !== "object") return;
-    for (const [k, v] of Object.entries(val)) {
-      if (k.startsWith(".")) {
-        walk(v, inBrowser);
-      } else if (k === "browser" || k === "web") {
-        walk(v, true);
-      } else {
-        walk(v, inBrowser);
-      }
+    case "eff":
+      return 1 + shapeNodeCount(s.inner, seen);
+    case "sum":
+      return 1 + s.members.reduce((acc, e) => acc + shapeNodeCount(e, seen), 0);
+    case "brand":
+      return 1 + shapeNodeCount(s.shape, seen);
+    case "fn": {
+      let n = 1;
+      for (const p of s.paramTypes ?? []) n += shapeNodeCount(p, seen);
+      if (s.returnType) n += shapeNodeCount(s.returnType, seen);
+      return n;
     }
-  };
-  walk(exportsField, false);
+    default:
+      return 1;
+  }
 }
-function detectDualEntryFromPackageJson(pkg) {
-  if (!pkg || typeof pkg !== "object") return null;
-  const p = pkg;
-  const browser = [];
-  const node = [];
-  collectExportFaces(p.exports, browser, node);
-  const bField = p.browser;
-  if (typeof bField === "string") browser.push(bField);
-  else if (bField && typeof bField === "object") {
-    for (const v of Object.values(bField)) {
-      if (typeof v === "string") browser.push(v);
+var MAX_RECORD_TYPE_NODES = 2e3;
+function absNodeCount(a, seen = /* @__PURE__ */ new Set()) {
+  return shapeNodeCount(a, seen);
+}
+function isOversizedCallRecord(rec) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const a of rec.argAbs) {
+    if (absNodeCount(a, seen) > MAX_RECORD_TYPE_NODES) return true;
+  }
+  return absNodeCount(rec.resultAbs, seen) > MAX_RECORD_TYPE_NODES;
+}
+function isLeakedCallRecord(rec) {
+  return rec.resultAbs.shape.k === "never" && rec.throwsAbs.shape.k === "never";
+}
+function joinAllAbs(members) {
+  if (members.length === 0) return neverAbs;
+  return members.reduce((a, b) => joinAbs(a, b));
+}
+function isPrimLit(a) {
+  return a.shape.k === "prim" && a.term?.op === "lit";
+}
+function widenAbsPrim(a) {
+  if (a.shape.k === "prim" && a.term?.op === "lit") {
+    return { shape: a.shape, conf: a.conf === "exact" ? "path" : a.conf };
+  }
+  return a;
+}
+function collapseAbsLits(members, maxLits) {
+  const uniq = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of members) {
+    if (m.shape.k === "never") continue;
+    const k = absStructureKey(m);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    uniq.push(m);
+  }
+  if (uniq.length === 0) return neverAbs;
+  if (uniq.length === 1) return uniq[0];
+  const nonLitPrims = /* @__PURE__ */ new Set();
+  for (const m of uniq) {
+    if (m.shape.k === "prim" && m.term?.op !== "lit") {
+      nonLitPrims.add(m.shape.type);
     }
-    for (const k of Object.keys(bField)) {
-      if (k.startsWith(".")) node.push(k);
+  }
+  if (nonLitPrims.size > 0) {
+    const absorbed = uniq.filter(
+      (m) => !(m.shape.k === "prim" && m.term?.op === "lit" && nonLitPrims.has(m.shape.type))
+    );
+    if (absorbed.length !== uniq.length) {
+      return collapseAbsLits(absorbed, maxLits);
     }
   }
-  if (typeof p.main === "string") node.push(p.main);
-  if (typeof p.module === "string") node.push(p.module);
-  const browserPaths = uniqueResolved(browser, null);
-  const nodePaths = uniqueResolved(node, null);
-  if (browserPaths.length === 0 || nodePaths.length === 0) return null;
-  const browserSet = new Set(browserPaths);
-  const nodeSet = new Set(nodePaths);
-  if (browserSet.size === nodeSet.size && [...browserSet].every((p2) => nodeSet.has(p2))) {
-    return null;
+  if (uniq.length > maxLits && uniq.every(isPrimLit)) {
+    const t = uniq[0].shape.type;
+    if (uniq.every((m) => m.shape.k === "prim" && m.shape.type === t)) {
+      return { shape: { k: "prim", type: t }, conf: "path" };
+    }
   }
-  const kind = typeof p.exports !== "undefined" && collectExportHasBrowser(p.exports) ? "exports-conditions" : "browser-field";
-  return { kind, browser: [...new Set(browser)], node: [...new Set(node)] };
+  return { shape: { k: "sum", members: uniq }, conf: "exact" };
 }
-function collectExportHasBrowser(exportsField) {
-  if (!exportsField || typeof exportsField !== "object") return false;
-  const walk = (val) => {
-    if (!val || typeof val !== "object") return false;
-    for (const [k, v] of Object.entries(val)) {
-      if (k === "browser" || k === "web") return true;
-      if (walk(v)) return true;
-    }
-    return false;
-  };
-  return walk(exportsField);
+function widenJoinAbs(members) {
+  return widenAbsPrim(joinAllAbs(members));
 }
-function uniqueResolved(targets, pkgDir) {
-  const out = /* @__PURE__ */ new Set();
-  for (const t of targets) {
-    if (typeof t !== "string" || t.length === 0) continue;
-    out.add(pkgDir === null ? normalizeTarget(t) : resolve6(pkgDir, t));
-  }
-  return [...out];
+
+// src/analyzer-abs-eval.ts
+function absIsBetter(next, prev) {
+  const isBareUnknown = (a) => a.shape.k === "unknown" && !a.term;
+  const isNever = (a) => a.shape.k === "never";
+  const isStructured = (a) => a.term?.op === "lit" || a.shape.k === "obj" || a.shape.k === "arr" || a.shape.k === "tuple" || a.shape.k === "sum" || a.shape.k === "fn" || a.shape.k === "brand" || a.shape.k === "eff";
+  const hasPred = (a) => !!a.pred && a.pred.op !== "true";
+  if (isBareUnknown(prev)) return !isBareUnknown(next);
+  if (isBareUnknown(next) || isNever(next)) return false;
+  if (isStructured(prev)) return false;
+  if (hasPred(next) && prev.shape.k === "prim" && !hasPred(prev)) return true;
+  return false;
 }
-function normalizeTarget(t) {
-  return t.replace(/^\.\//, "");
+function isSelfContainedSource(source, envNames) {
+  if (envNames.length > 0) return false;
+  return !/\brequire\s*\(|\bimport\s*[{'"*]/.test(source);
 }
-function findOwningPackage(fromFile) {
-  let dir = dirname7(resolve6(fromFile));
-  const root = resolve6("/");
-  for (; ; ) {
-    const pkgPath = join3(dir, "package.json");
-    if (existsSync5(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
-        return { path: pkgPath, dir, pkg };
-      } catch {
-        return null;
-      }
-    }
-    if (dir === root) return null;
-    const parent = dirname7(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
+function absModulesOk(source, envNames) {
+  void source;
+  void envNames;
+  return true;
 }
-function dualEntryForFile(filePath) {
-  let owning = null;
+function buildAbsImportLocalMap(source, fromFile) {
+  const out = /* @__PURE__ */ new Map();
   try {
-    owning = findOwningPackage(filePath);
+    const file = parse6(source);
+    for (const stmt of file.program.body) {
+      if (stmt.type === "ImportDeclaration") {
+        const spec = stmt.source.value;
+        let modulePath = null;
+        if (spec.startsWith(".") || spec.startsWith("/")) {
+          modulePath = resolveImportAbs(spec, fromFile);
+        } else if (!spec.startsWith("node:")) {
+          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" });
+          } else if (s.type === "ImportNamespaceSpecifier") {
+            out.set(s.local.name, { modulePath, exportName: "*" });
+          }
+        }
+        continue;
+      }
+      if (stmt.type === "VariableDeclaration") {
+        for (const d of stmt.declarations) {
+          if (d.init?.type !== "CallExpression") continue;
+          const callee = d.init.callee;
+          if (callee.type !== "Identifier" || callee.name !== "require") continue;
+          const arg0 = d.init.arguments[0];
+          if (!arg0 || arg0.type !== "StringLiteral") continue;
+          const spec = arg0.value;
+          let modulePath = null;
+          if (spec.startsWith(".") || spec.startsWith("/")) {
+            modulePath = resolveImportAbs(spec, fromFile);
+          } else if (!spec.startsWith("node:")) {
+            modulePath = spec;
+          }
+          if (!modulePath) continue;
+          if (d.id.type === "ObjectPattern") {
+            for (const p of d.id.properties) {
+              if (p.type !== "ObjectProperty" || p.computed) continue;
+              if (p.key.type !== "Identifier" || p.value.type !== "Identifier") continue;
+              out.set(p.value.name, { modulePath, exportName: p.key.name });
+            }
+          } else if (d.id.type === "Identifier") {
+            out.set(d.id.name, { modulePath, exportName: "default" });
+          }
+        }
+      }
+    }
   } catch {
-    return null;
   }
-  if (!owning) return null;
-  const faces = detectDualEntryFromPackageJson(owning.pkg);
-  if (!faces) return null;
-  const abs = resolve6(filePath);
-  const browserPaths = uniqueResolved(faces.browser, owning.dir);
-  const nodePaths = uniqueResolved(faces.node, owning.dir);
-  const inBrowser = browserPaths.includes(abs);
-  const inNode = nodePaths.includes(abs);
-  if (!inBrowser && !inNode) return null;
-  if (inBrowser && inNode) return null;
-  return {
-    pkgPath: owning.path,
-    pkgDir: owning.dir,
-    ...typeof owning.pkg.name === "string" ? { pkgName: owning.pkg.name } : {},
-    kind: faces.kind,
-    browserPaths,
-    nodePaths,
-    role: inBrowser ? "browser" : "node",
-    browserTargets: [...new Set(faces.browser.map(normalizeTarget))],
-    nodeTargets: [...new Set(faces.node.map(normalizeTarget))]
-  };
-}
-function dualEntryMessage(info) {
-  const name = info.pkgName ? `"${info.pkgName}"` : info.pkgPath;
-  const b = info.browserTargets.join(", ") || "(browser)";
-  const n = info.nodeTargets.join(", ") || "(node)";
-  return `dual-entry package ${name}: browser (${b}) and node (${n}) call-site records do not cross files \u2014 analysis observes only the ${info.role} entry variant`;
-}
-function dualEntrySuggestion() {
-  return "analyze the entry you ship and mock or skip the other variant; browser/node records stay file-scoped (limits: dual package entrypoints)";
-}
-function dualEntryIssueForFile(filePath) {
-  const info = dualEntryForFile(filePath);
-  if (!info) return null;
-  return {
-    severity: "info",
-    code: "nudo:dual-entry",
-    message: dualEntryMessage(info),
-    suggestion: dualEntrySuggestion(),
-    line: 0,
-    column: 0
-  };
+  return out;
 }
-
-// src/analyzer-orchestrate.ts
-import { dirname as dirname9 } from "path";
-
-// src/analyzer-orchestrate-uncached.ts
-import { realpathSync } from "fs";
-import { resolve as resolve7, dirname as dirname8 } from "path";
-import {
-  createEnvironment as createEnvironment2,
-  markPureFn,
-  unknown as absUnknown5,
-  anyAbs,
-  formatAbs as formatAbs5,
-  formatShape,
-  leqAbs,
-  localNamedExports,
-  effectiveInterface,
-  abs as makeAbsVal2,
-  formalParamsFromNodes as formalParamsFromNodes2
-} from "@nudojs/core";
-import {
-  setMayThrowCollector,
-  mayThrowEffectsToAbs,
-  formatThrowsAbs,
-  checkInjectedDomainEvidence,
-  runWithEvalMissingSlot,
-  fnFingerprints,
-  loadModuleDepsFingerprint as loadModuleDepsFingerprint3,
-  hashSource as hashSource3
-} from "@nudojs/core/internal";
-import { parse as parse8, extractDirectives as extractDirectives2, extractFileDirectives as extractFileDirectives3 } from "@nudojs/parser";
-
-// src/analyzer-ast.ts
-import traverse from "@babel/traverse";
-import {
-  formalParamsFromNodes,
-  formalParamDisplayNames,
-  unknown as absUnknown4,
-  abs as makeAbsVal,
-  numLit,
-  strLit,
-  boolLit
-} from "@nudojs/core";
-import {
-  programBody,
-  getDeclarations,
-  getDeclaratorInit,
-  getFirstDeclaratorId,
-  getExpressionStatementExpression,
-  unwrapExport,
-  asIdentifier,
-  asAssignmentExpression,
-  classIdName,
-  fnOrClassIdLoc,
-  isModuleExportsMember,
-  memberPropertyKey,
-  classInstanceMethods,
-  exportSpecifierLocalName,
-  exportSpecifierExportedName,
-  unwrapDefaultExport
-} from "@nudojs/parser";
-function locFromNode(node) {
-  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 resolveImportAbs(spec, fromFile) {
+  const base = dirname5(resolve5(fromFile));
+  const p = resolve5(base, spec);
+  for (const cand of [p, `${p}.js`, `${p}.mjs`, `${p}.ts`, resolve5(p, "index.js")]) {
+    if (existsSync4(cand) && !statSync5(cand).isDirectory()) return cand;
+  }
+  return null;
 }
-function extractParamNames(node) {
-  const fn = node.type === "ExportDefaultDeclaration" ? node.declaration : node;
-  if (fn.type === "FunctionDeclaration" || fn.type === "FunctionExpression" || fn.type === "ArrowFunctionExpression" || fn.type === "ClassMethod" || fn.type === "ObjectMethod" || fn.type === "TSDeclareMethod") {
-    return formalParamDisplayNames(formalParamsFromNodes(fn.params));
+function tryEvalAbsRaw(source, fnName, args, filePath, mocks, assignedName) {
+  return tryEvalAbsFull(source, fnName, args, filePath, mocks, assignedName)?.result;
+}
+function tryEvalAbsFull(source, fnName, args, filePath, mocks, assignedName) {
+  if (/\brequire\s*\(/.test(source)) return void 0;
+  try {
+    if (filePath) {
+      const viaB = tryBPathCallFull(source, filePath, fnName, args, { mocks }) ?? (assignedName ? tryBPathCallFull(source, filePath, assignedName, args, { mocks }) : void 0);
+      if (viaB) {
+        const r = viaB.result;
+        if (r && !(r.shape.k === "unknown" && !r.term)) {
+          const throws = viaB.throws ?? { shape: { k: "never" }, conf: "exact" };
+          return { result: r, throws };
+        }
+      }
+    }
+    return void 0;
+  } catch {
+    return void 0;
   }
-  if (fn.type === "VariableDeclaration") {
-    const init = getDeclaratorInit(getDeclarations(fn)[0]);
-    if (init && (init.type === "FunctionExpression" || init.type === "ArrowFunctionExpression")) {
-      return formalParamDisplayNames(formalParamsFromNodes(init.params));
+}
+function tryEvalEntryAbs(source, fnName, args, filePath, mocks, assignedName) {
+  return tryEvalAbsRaw(source, fnName, args, filePath, mocks, assignedName);
+}
+function tryAttachIntension(caseResult, source, fnName) {
+  try {
+    const g = generalizeFromAst(fnName, source);
+    if (!g) return;
+    const sym = g.symbolic;
+    const intension = {
+      display: g.display,
+      abs: formatAbs4(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 {
   }
-  return [];
 }
-function resolveFunctionNode(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 = getDeclaratorInit(getDeclarations(node)[0]);
-    if (init && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")) return init;
+function attachHofSnapshot(analysis, source) {
+  if (analysis.hof) return;
+  try {
+    const g = generalizeFromAst(analysis.name, source);
+    if (!g) return;
+    const fnRels = g.fnRels ? [...g.fnRels.entries()].map(([param, rec]) => ({ param, abs: rec.abs })) : void 0;
+    const entryShapes = g.entryShapes ? [...g.entryShapes.entries()].map(([param, rec]) => ({ param, abs: rec.abs })) : void 0;
+    if (!fnRels?.length && !entryShapes?.length) return;
+    analysis.hof = {
+      ...fnRels?.length ? { fnRels } : {},
+      ...entryShapes?.length ? { entryShapes } : {},
+      symbolic: g.symbolic
+    };
+  } catch {
   }
-  return node;
 }
-function fnNameLoc(node, fallback) {
-  const { declaration: d } = unwrapExport(node);
-  if (d.type === "VariableDeclaration") {
-    const id = getFirstDeclaratorId(d);
-    if (id?.loc) return id.loc;
+function attachAbsToIntension(caseResult, absVal, label) {
+  const prev = caseResult.intension ?? {};
+  caseResult.abs = absVal;
+  caseResult.intension = {
+    ...prev,
+    abs: formatAbs4(absVal),
+    absMultiline: formatAbsMultiline(absVal, label ?? caseResult.name),
+    conf: absVal.conf
+  };
+}
+function safeAbsOrUnknown(a) {
+  if (a && typeof a === "object" && "shape" in a && "conf" in a) {
+    return a;
   }
-  const idLoc = fnOrClassIdLoc(d);
-  if (idLoc) return idLoc;
-  return fallback;
+  if (typeof a === "function") {
+    const fn = a;
+    const n = Math.max(0, fn.length);
+    const params = Array.from({ length: n }, (_, i) => `arg${i}`);
+    return absFunction3(params, {
+      body: { type: "BlockStatement", body: [], directives: [] },
+      apply: (args) => {
+        try {
+          const r = fn(...args);
+          if (r && typeof r === "object" && "shape" in r) return r;
+          return absUnknown3;
+        } catch {
+          return absUnknown3;
+        }
+      }
+    });
+  }
+  return absUnknown3;
 }
-function isFnExprValue(node) {
-  return !!node && (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression");
+function callRecordFromAbsCall(r, impMap) {
+  const argAbs = r.args.map(safeAbsOrUnknown);
+  const threw = !!r.threw;
+  const thrownOrResult = safeAbsOrUnknown(r.result);
+  const rec = {
+    fnName: r.fnName,
+    argAbs,
+    resultAbs: threw ? neverAbs : thrownOrResult,
+    throwsAbs: threw ? thrownOrResult : neverAbs,
+    callLoc: r.callLoc
+  };
+  const imp = impMap?.get(r.fnName) ?? // `ns.helper` / `Class.method`：先整名，再按首段点号拆命名空间成员
+  (() => {
+    const dot = r.fnName.indexOf(".");
+    if (dot <= 0) return void 0;
+    const base = impMap?.get(r.fnName.slice(0, dot));
+    if (!base || base.exportName !== "*") return void 0;
+    return {
+      modulePath: base.modulePath,
+      exportName: r.fnName.slice(dot + 1)
+    };
+  })();
+  if (imp) {
+    rec.targetModule = imp.modulePath;
+    rec.targetExport = imp.exportName;
+  }
+  return rec;
 }
-function namedFnExprId(node) {
-  return node.type === "FunctionExpression" && node.id ? node.id.name : null;
+
+// src/analyzer-orchestrate-calls.ts
+function collectEnvNames(filePath, source, includeProject) {
+  const ast = parse7(source);
+  const fileDirectives = extractFileDirectives2(ast);
+  const fileEnvNames = fileDirectives.filter((d) => d.kind === "env").flatMap((d) => d.envs);
+  if (!includeProject) return fileEnvNames;
+  const projectConfig = findProjectConfig(dirname6(filePath));
+  const projectEnvNames = projectConfig?.config.env ?? [];
+  return [.../* @__PURE__ */ new Set([...projectEnvNames, ...fileEnvNames])];
 }
-function isModuleExportsTarget(node) {
-  return node.type === "MemberExpression" && !node.computed && isModuleExportsMember(node);
+function collectCallRecords(filePath, source) {
+  if (filePath) {
+    try {
+      const mocks = mockSeedsForSource(source, {
+        fromFile: filePath || void 0
+      });
+      const run = tryRunBPath(source, filePath, {
+        mode: "exec",
+        lenientGlobals: true,
+        ...Object.keys(mocks).length > 0 ? { mocks } : {}
+      });
+      if (run?.calls?.length) {
+        const importLocals = buildAbsImportLocalMap(source, filePath);
+        return expandTestCallbacks(run.calls).map((r) => callRecordFromAbsCall(r, importLocals));
+      }
+    } catch {
+    }
+  }
+  return [];
 }
-function deepestAssignValue(expr) {
-  let cur = expr;
-  while (cur) {
-    const assign = asAssignmentExpression(cur);
-    if (!assign) break;
-    cur = assign.right;
+function expandTestCallbacks(calls) {
+  const out = [...calls];
+  const seenDescribe = /* @__PURE__ */ new Set();
+  let cursor = 0;
+  let expanded = 0;
+  while (cursor < out.length && expanded < 500) {
+    const rec = out[cursor++];
+    if (rec.fnName !== "it" && rec.fnName !== "test" && rec.fnName !== "describe") continue;
+    for (const a of rec.args) {
+      if (!a || typeof a !== "object" || !("shape" in a)) continue;
+      const abs = a;
+      if (abs.shape.k !== "fn") continue;
+      if (rec.fnName === "describe") {
+        if (seenDescribe.has(abs)) continue;
+        seenDescribe.add(abs);
+      }
+      const impl = getFnImpl4(abs);
+      const params = impl?.params ?? [];
+      const collected = [];
+      const prev = getBCallCollector();
+      setBCallCollector2((r) => collected.push(r));
+      try {
+        $call2(abs, params.map(() => absUnknown4));
+      } catch {
+      } finally {
+        setBCallCollector2(prev);
+      }
+      out.push(...collected);
+      expanded++;
+    }
   }
-  return cur ?? null;
+  return out;
 }
-function assignmentChainName(expr) {
-  let cur = expr;
-  while (cur) {
-    const assign = asAssignmentExpression(cur);
-    if (!assign) break;
-    const target = assign.left;
-    if (target.type === "Identifier") return target.name;
-    if (target.type === "MemberExpression") {
-      if (isModuleExportsTarget(target)) {
-        cur = assign.right;
-        continue;
+
+// src/bpath-diagnostics.ts
+import { parseSource } from "@nudojs/core";
+function locOf(node) {
+  if (!node.loc) return null;
+  return {
+    start: { line: node.loc.start.line, column: node.loc.start.column },
+    end: { line: node.loc.end.line, column: node.loc.end.column }
+  };
+}
+function isExit(stmt) {
+  return stmt.type === "ReturnStatement" || stmt.type === "ThrowStatement";
+}
+function walkUnreachable(node, out) {
+  const n = node;
+  const checkBlock = (block) => {
+    if (!block) return;
+    const body = block.body ?? (Array.isArray(block) ? block : null);
+    if (!Array.isArray(body)) return;
+    for (let i = 0; i < body.length; i++) {
+      walkUnreachable(body[i], out);
+      if (isExit(body[i])) {
+        for (let j = i + 1; j < body.length; j++) {
+          const r = locOf(body[j]);
+          if (r) out.push({ range: r });
+        }
+        break;
+      }
+    }
+  };
+  switch (n.type) {
+    case "Program":
+    case "BlockStatement":
+      checkBlock(n.body);
+      break;
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+    case "ArrowFunctionExpression":
+      if (n.body) walkUnreachable(n.body, out);
+      break;
+    case "IfStatement":
+      if (n.consequent) walkUnreachable(n.consequent, out);
+      if (n.alternate) walkUnreachable(n.alternate, out);
+      break;
+    case "ForStatement":
+    case "ForInStatement":
+    case "ForOfStatement":
+    case "WhileStatement":
+    case "DoWhileStatement":
+      if (n.body) walkUnreachable(n.body, out);
+      break;
+    case "TryStatement":
+      if (n.block) walkUnreachable(n.block, out);
+      if (n.handler?.body) walkUnreachable(n.handler.body, out);
+      if (n.finalizer) walkUnreachable(n.finalizer, out);
+      break;
+    case "SwitchStatement":
+      for (const c of n.cases ?? []) {
+        checkBlock(c.consequent);
       }
-      return memberPropertyKey(target);
+      break;
+    case "ExportNamedDeclaration":
+    case "ExportDefaultDeclaration": {
+      const decl = n.declaration;
+      if (decl) walkUnreachable(decl, out);
+      break;
     }
-    return null;
+    default:
+      break;
   }
-  return null;
 }
-function collectTopLevelFunctions(ast) {
-  const results = [];
-  if (ast.type !== "File") return results;
-  const body = programBody(ast);
-  const classDecls = /* @__PURE__ */ new Map();
-  const exportedClassNames = /* @__PURE__ */ new Set();
-  const collectClassMethods = (cname, decl, stmt) => {
-    for (const { name: keyName, node: methodNode } of classInstanceMethods(decl)) {
-      results.push({
-        name: `${cname}.${keyName}`,
-        node: methodNode,
-        stmt,
-        noDeclaration: true
-      });
+function collectDeclared(file) {
+  const names = /* @__PURE__ */ new Set();
+  const addId = (id) => {
+    if (!id) return;
+    if (id.type === "Identifier") names.add(id.name);
+    if (id.type === "ObjectPattern") {
+      for (const p of id.properties) {
+        addId(p.value);
+      }
+    }
+    if (id.type === "ArrayPattern") {
+      for (const el of id.elements) addId(el);
     }
   };
-  for (const stmt of body) {
-    const className = classIdName(stmt);
-    if (stmt.type === "ClassDeclaration" && className) {
-      classDecls.set(className, { node: stmt, stmt });
-      continue;
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    const o = node;
+    switch (o.type) {
+      case "FunctionDeclaration":
+      case "ClassDeclaration":
+        addId(o.id);
+        break;
+      case "VariableDeclarator":
+        addId(o.id);
+        break;
+      case "ImportSpecifier":
+      case "ImportDefaultSpecifier":
+      case "ImportNamespaceSpecifier":
+        addId(o.local);
+        break;
+      case "CatchClause":
+        addId(o.param);
+        break;
+      default:
+        break;
     }
-    if (stmt.type === "ExportNamedDeclaration") {
-      const d = stmt.declaration;
-      const exportedClassName = classIdName(d);
-      if (d?.type === "ClassDeclaration" && exportedClassName) {
-        classDecls.set(exportedClassName, { node: d, stmt });
-        exportedClassNames.add(exportedClassName);
-        continue;
-      }
-      if (!d && stmt.specifiers) {
-        for (const spec of stmt.specifiers) {
-          if (spec.type !== "ExportSpecifier") continue;
-          const local = exportSpecifierLocalName(spec);
-          const exported = exportSpecifierExportedName(spec);
-          if (!local) continue;
-          if (classDecls.has(local) || body.some((s) => classIdName(s) === local)) {
-            exportedClassNames.add(local);
-          }
-          if (exported === "default") exportedClassNames.add(local);
-        }
-        continue;
-      }
+    if (o.params && Array.isArray(o.params)) {
+      for (const p of o.params) addId(p);
     }
-    if (stmt.type === "ExportDefaultDeclaration") {
-      const d = stmt.declaration;
-      const defaultClassName = classIdName(d);
-      if (d?.type === "ClassDeclaration" && defaultClassName) {
-        classDecls.set(defaultClassName, { node: d, stmt });
-        exportedClassNames.add(defaultClassName);
-      } else {
-        const idName = asIdentifier(d)?.name;
-        if (idName) exportedClassNames.add(idName);
+    for (const key of Object.keys(o)) {
+      if (key === "loc" || key === "start" || key === "end") continue;
+      const v = o[key];
+      if (Array.isArray(v)) v.forEach(visit);
+      else if (v && typeof v === "object") visit(v);
+    }
+  };
+  visit(file);
+  return names;
+}
+var KNOWN_GLOBALS = /* @__PURE__ */ new Set([
+  "Object",
+  "Array",
+  "String",
+  "Number",
+  "Boolean",
+  "Symbol",
+  "Math",
+  "JSON",
+  "Promise",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "SyntaxError",
+  "RegExp",
+  "Date",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "console",
+  "undefined",
+  "NaN",
+  "Infinity",
+  "globalThis",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite"
+]);
+function isStaticStringExpr(node) {
+  if (!node || typeof node !== "object") return false;
+  const n = node;
+  if (n.type === "StringLiteral" || n.type === "NumericLiteral") return true;
+  if (n.type === "TemplateLiteral") {
+    return (n.expressions ?? []).every((e) => isStaticStringExpr(e));
+  }
+  if (n.type === "BinaryExpression" && n.operator === "+") {
+    return isStaticStringExpr(n.left) && isStaticStringExpr(n.right);
+  }
+  return false;
+}
+function isFreeUnknown(name, declared, seen, known) {
+  return !declared.has(name) && !known.has(name) && !name.startsWith("$") && !seen.has(name);
+}
+function walkBuiltinUnknown(node, declared, out, seen, known, parentKey) {
+  const n = node;
+  const flag = (idNode, name) => {
+    if (!isFreeUnknown(name, declared, seen, known)) return;
+    const range = locOf(idNode) ?? locOf(node);
+    if (range) {
+      out.push({ name, range });
+      seen.add(name);
+    }
+  };
+  if (n.type === "CallExpression") {
+    const callee = n.callee;
+    const args = n.arguments ?? [];
+    if (callee?.type === "Identifier" && callee.name === "require") {
+      if (!isStaticStringExpr(args[0])) flag(n.callee, "require");
+    } else if (callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.name === "require") {
+      if (callee.property?.name === "resolve" && !isStaticStringExpr(args[0])) {
+        flag(callee.object, "require");
       }
-      continue;
+    } else if (callee?.type === "Identifier") {
+      flag(n.callee, callee.name);
     }
+  } else if (n.type === "Identifier" && typeof n.name === "string" && n.name !== "require" && parentKey !== "key" && parentKey !== "property" && parentKey !== "local" && parentKey !== "id") {
+    flag(node, n.name);
   }
-  for (const stmt of body) {
-    const decl = resolveFunctionNode(stmt);
-    if (decl.type === "FunctionDeclaration" && decl.id) {
-      results.push({ name: decl.id.name, node: decl, stmt, noDeclaration: false });
-      continue;
+  for (const key of Object.keys(n)) {
+    if (key === "loc" || key === "start" || key === "end") continue;
+    const v = n[key];
+    if (Array.isArray(v)) {
+      v.forEach((x) => {
+        if (x && typeof x === "object" && "type" in x) {
+          walkBuiltinUnknown(x, declared, out, seen, known, key);
+        }
+      });
+    } else if (v && typeof v === "object" && "type" in v) {
+      walkBuiltinUnknown(v, declared, out, seen, known, key);
     }
-    if (decl.type === "ClassDeclaration" && decl.id?.name) {
-      continue;
+  }
+}
+function collectBPathDiagnostics(source, extraKnown) {
+  let file;
+  try {
+    file = parseSource(source);
+  } catch {
+    return { unreachable: [], builtinUnknown: [] };
+  }
+  const unreachable = [];
+  const root = file.program ?? file;
+  walkUnreachable(root, unreachable);
+  const declared = collectDeclared(file);
+  const known = new Set(KNOWN_GLOBALS);
+  if (extraKnown) {
+    for (const n of extraKnown) known.add(n);
+  }
+  const builtinUnknown = [];
+  walkBuiltinUnknown(file, declared, builtinUnknown, /* @__PURE__ */ new Set(), known);
+  return { unreachable, builtinUnknown };
+}
+
+// src/entry-variants.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname7, join as join3, resolve as resolve6 } from "path";
+function collectExportFaces(exportsField, browser, node) {
+  if (exportsField == null) return;
+  if (typeof exportsField === "string") {
+    node.push(exportsField);
+    return;
+  }
+  const walk = (val, inBrowser) => {
+    if (typeof val === "string") {
+      if (inBrowser) browser.push(val);
+      else node.push(val);
+      return;
     }
-    if (stmt.type === "ExportNamedDeclaration") {
-      const d = resolveFunctionNode(stmt);
-      if (d.type === "FunctionDeclaration" && d.id) {
-        results.push({ name: d.id.name, node: d, stmt, noDeclaration: false });
-      }
-      if (d.type === "ClassDeclaration" && d.id?.name) {
-      }
-      continue;
+    if (Array.isArray(val)) {
+      for (const v of val) walk(v, inBrowser);
+      return;
     }
-    if (stmt.type === "ExportDefaultDeclaration") {
-      const d = stmt.declaration;
-      if (d.type === "FunctionDeclaration") {
-        if (d.id) {
-          results.push({ name: d.id.name, node: d, stmt, noDeclaration: false });
-        } else {
-          results.push({ name: "default", node: d, stmt, noDeclaration: true });
-        }
-      } else if (isFnExprValue(d)) {
-        results.push({ name: "default", node: d, stmt, noDeclaration: true });
+    if (!val || typeof val !== "object") return;
+    for (const [k, v] of Object.entries(val)) {
+      if (k.startsWith(".")) {
+        walk(v, inBrowser);
+      } else if (k === "browser" || k === "web") {
+        walk(v, true);
+      } else {
+        walk(v, inBrowser);
       }
-      continue;
     }
-    if (stmt.type === "VariableDeclaration") {
-      for (const declarator of getDeclarations(stmt)) {
-        const id = asIdentifier(declarator.id);
-        if (id && isFnExprValue(declarator.init)) {
-          results.push({ name: id.name, node: declarator.init, stmt, noDeclaration: true });
-        }
-      }
-      continue;
+  };
+  walk(exportsField, false);
+}
+function detectEntryVariantsFromPackageJson(pkg) {
+  if (!pkg || typeof pkg !== "object") return null;
+  const p = pkg;
+  const browser = [];
+  const node = [];
+  collectExportFaces(p.exports, browser, node);
+  const bField = p.browser;
+  if (typeof bField === "string") browser.push(bField);
+  else if (bField && typeof bField === "object") {
+    for (const v of Object.values(bField)) {
+      if (typeof v === "string") browser.push(v);
     }
-    const expr = getExpressionStatementExpression(stmt);
-    if (expr?.type === "AssignmentExpression") {
-      const fn = deepestAssignValue(expr);
-      if (isFnExprValue(fn)) {
-        const name = namedFnExprId(fn) ?? assignmentChainName(expr) ?? "default";
-        const chain = assignmentChainName(expr);
-        const assignedName = namedFnExprId(fn) && chain && chain !== name ? chain : void 0;
-        results.push({ name, node: fn, stmt, noDeclaration: true, ...assignedName ? { assignedName } : {} });
-      }
+    for (const k of Object.keys(bField)) {
+      if (k.startsWith(".")) node.push(k);
     }
   }
-  for (const cname of exportedClassNames) {
-    const hit = classDecls.get(cname);
-    if (!hit) continue;
-    collectClassMethods(cname, hit.node, hit.stmt);
+  if (typeof p.main === "string") node.push(p.main);
+  if (typeof p.module === "string") node.push(p.module);
+  const browserPaths = uniqueResolved(browser, null);
+  const nodePaths = uniqueResolved(node, null);
+  if (browserPaths.length === 0 || nodePaths.length === 0) return null;
+  const browserSet = new Set(browserPaths);
+  const nodeSet = new Set(nodePaths);
+  if (browserSet.size === nodeSet.size && [...browserSet].every((p2) => nodeSet.has(p2))) {
+    return null;
   }
-  return results;
+  const kind = typeof p.exports !== "undefined" && collectExportHasBrowser(p.exports) ? "exports-conditions" : "browser-field";
+  return { kind, browser: [...new Set(browser)], node: [...new Set(node)] };
 }
-function findSingleModuleExportsFunction(ast) {
-  if (ast.type !== "File") return null;
-  let found = null;
-  for (const stmt of programBody(ast)) {
-    const expr = getExpressionStatementExpression(stmt);
-    if (expr?.type !== "AssignmentExpression") continue;
-    const fn = deepestAssignValue(expr);
-    if (!isFnExprValue(fn)) continue;
-    let targetsModuleExports = false;
-    let cur = expr;
-    while (cur) {
-      const assign = asAssignmentExpression(cur);
-      if (!assign) break;
-      if (isModuleExportsTarget(assign.left)) {
-        targetsModuleExports = true;
-        break;
-      }
-      cur = assign.right;
+function collectExportHasBrowser(exportsField) {
+  if (!exportsField || typeof exportsField !== "object") return false;
+  const walk = (val) => {
+    if (!val || typeof val !== "object") return false;
+    for (const [k, v] of Object.entries(val)) {
+      if (k === "browser" || k === "web") return true;
+      if (walk(v)) return true;
     }
-    if (!targetsModuleExports) continue;
-    if (found) return null;
-    found = fn;
+    return false;
+  };
+  return walk(exportsField);
+}
+function uniqueResolved(targets, pkgDir) {
+  const out = /* @__PURE__ */ new Set();
+  for (const t of targets) {
+    if (typeof t !== "string" || t.length === 0) continue;
+    out.add(pkgDir === null ? normalizeTarget(t) : resolve6(pkgDir, t));
   }
-  return found;
+  return [...out];
 }
-function collectBindings(ast, env, bindings, absBinds) {
-  if (ast.type !== "File") return;
-  const setBinding = (name, loc) => {
-    const absVal = absBinds?.get(name) ?? absUnknown4;
-    bindings.set(name, {
-      abs: absVal,
-      loc
-    });
-  };
-  const walk = (body) => {
-    for (const stmt of body) {
-      if (stmt.type === "FunctionDeclaration" && stmt.id) {
-        setBinding(stmt.id.name, locFromNode(stmt));
-      }
-      if (stmt.type === "VariableDeclaration") {
-        for (const decl of stmt.declarations) {
-          if (decl.id.type === "Identifier") {
-            setBinding(decl.id.name, locFromNode(decl));
-          }
-        }
-      }
-      if (stmt.type === "ClassDeclaration" && stmt.id) {
-        setBinding(stmt.id.name, locFromNode(stmt));
-      }
-      if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
-        walk([stmt.declaration]);
+function normalizeTarget(t) {
+  return t.replace(/^\.\//, "");
+}
+function findOwningPackage(fromFile) {
+  let dir = dirname7(resolve6(fromFile));
+  const root = resolve6("/");
+  for (; ; ) {
+    const pkgPath = join3(dir, "package.json");
+    if (existsSync5(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+        return { path: pkgPath, dir, pkg };
+      } catch {
+        return null;
       }
     }
-  };
-  walk(programBody(ast));
-}
-function nullLitAbs() {
-  return makeAbsVal({ k: "unknown" }, { op: "lit", value: null }, void 0, "exact");
+    if (dir === root) return null;
+    const parent = dirname7(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
 }
-function buildNodeTypeMap(ast, env, nodeAbsMap) {
-  const traverseFn = unwrapDefaultExport(traverse);
+function entryVariantForFile(filePath) {
+  let owning = null;
   try {
-    traverseFn(ast, {
-      enter(path) {
-        const node = path.node;
-        try {
-          const setAbs = (a) => {
-            nodeAbsMap.set(node, a);
-          };
-          if (node.type === "Identifier" && node.name !== "undefined" && path.parentPath?.node.type !== "FunctionDeclaration" && path.parentPath?.node.type !== "VariableDeclarator") {
-            if (env.has(node.name)) {
-              setAbs(env.lookup(node.name));
-            }
-          }
-          if (node.type === "NumericLiteral") {
-            setAbs(numLit(node.value));
-          }
-          if (node.type === "StringLiteral") {
-            setAbs(strLit(node.value));
-          }
-          if (node.type === "BooleanLiteral") {
-            setAbs(boolLit(node.value));
-          }
-          if (node.type === "NullLiteral") {
-            setAbs(nullLitAbs());
-          }
-        } catch {
-        }
-      }
-    });
+    owning = findOwningPackage(filePath);
   } catch {
+    return null;
   }
+  if (!owning) return null;
+  const faces = detectEntryVariantsFromPackageJson(owning.pkg);
+  if (!faces) return null;
+  const abs = resolve6(filePath);
+  const browserPaths = uniqueResolved(faces.browser, owning.dir);
+  const nodePaths = uniqueResolved(faces.node, owning.dir);
+  const inBrowser = browserPaths.includes(abs);
+  const inNode = nodePaths.includes(abs);
+  if (!inBrowser && !inNode) return null;
+  if (inBrowser && inNode) return null;
+  return {
+    pkgPath: owning.path,
+    pkgDir: owning.dir,
+    ...typeof owning.pkg.name === "string" ? { pkgName: owning.pkg.name } : {},
+    kind: faces.kind,
+    browserPaths,
+    nodePaths,
+    role: inBrowser ? "browser" : "node",
+    browserTargets: [...new Set(faces.browser.map(normalizeTarget))],
+    nodeTargets: [...new Set(faces.node.map(normalizeTarget))]
+  };
+}
+function entryVariantMessage(info) {
+  const name = info.pkgName ? `"${info.pkgName}"` : info.pkgPath;
+  const b = info.browserTargets.join(", ") || "(browser)";
+  const n = info.nodeTargets.join(", ") || "(node)";
+  return `dual-entry package ${name}: browser (${b}) and node (${n}) call-site records do not cross files \u2014 analysis observes only the ${info.role} entry variant`;
+}
+function entryVariantSuggestion() {
+  return "analyze the entry you ship and mock or skip the other variant; browser/node records stay file-scoped (limits: dual package entrypoints)";
+}
+function entryVariantIssueForFile(filePath) {
+  const info = entryVariantForFile(filePath);
+  if (!info) return null;
+  return {
+    severity: "info",
+    code: "nudo:dual-entry",
+    message: entryVariantMessage(info),
+    suggestion: entryVariantSuggestion(),
+    line: 0,
+    column: 0
+  };
 }
 
+// src/analyzer-orchestrate.ts
+import { dirname as dirname9 } from "path";
+
+// src/analyzer-orchestrate-uncached.ts
+import { realpathSync } from "fs";
+import { resolve as resolve7, dirname as dirname8 } from "path";
+import {
+  createEnvironment as createEnvironment2,
+  markPureFn,
+  unknown as absUnknown5,
+  anyAbs,
+  formatAbs as formatAbs5,
+  formatShape,
+  leqAbs,
+  localNamedExports,
+  effectiveInterface,
+  abs as makeAbsVal2,
+  formalParamsFromNodes as formalParamsFromNodes2
+} from "@nudojs/core";
+import {
+  setMayThrowCollector,
+  mayThrowEffectsToAbs,
+  formatThrowsAbs,
+  checkInjectedDomainEvidence,
+  runWithEvalMissingSlot,
+  fnFingerprints,
+  loadModuleDepsFingerprint as loadModuleDepsFingerprint3,
+  hashSource as hashSource3
+} from "@nudojs/core/internal";
+import { parse as parse8, extractDirectives as extractDirectives2, extractFileDirectives as extractFileDirectives3 } from "@nudojs/parser";
+
 // src/analyzer-diagnose.ts
 function validateMockDirectives(directives, diagnostics) {
   for (const d of directives) {
@@ -3563,14 +3614,14 @@ function analyzeFileUncachedInner(filePath, source, activeCases, externalCallRec
     });
   }
   try {
-    const dual = dualEntryForFile(filePath);
+    const dual = entryVariantForFile(filePath);
     if (dual) {
       diagnostics.push({
         range: { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } },
         severity: "info",
-        message: dualEntryMessage(dual),
+        message: entryVariantMessage(dual),
         code: "nudo:dual-entry",
-        suggestions: [dualEntrySuggestion()]
+        suggestions: [entryVariantSuggestion()]
       });
     }
   } catch {
@@ -3631,6 +3682,7 @@ function analyzeFile(filePath, source, activeCases, externalCallRecords, loadMod
 }
 
 export {
+  resolveModule,
   buildModuleGraph,
   computeDirtySet,
   topoSortDirty,
@@ -3678,10 +3730,10 @@ export {
   collectEnvNames,
   collectCallRecords,
   collectBPathDiagnostics,
-  detectDualEntryFromPackageJson,
+  detectEntryVariantsFromPackageJson,
   findOwningPackage,
-  dualEntryForFile,
-  dualEntryIssueForFile,
+  entryVariantForFile,
+  entryVariantIssueForFile,
   analyzeFileAsync,
   analyzeFile
 };