@nudojs/service 4.0.0 → 5.0.0-beta.0

package/dist/chunk-QAFMPM2E.js

@@ -0,0 +1,3687 @@
+import {
+  bareSpecToAbsModules
+} from "./chunk-U7JYTRIB.js";
+import {
+  analysisConfig,
+  findProjectConfig,
+  getSessionCacheLimits,
+  interfaceConfig,
+  resolveNpmJsEntry
+} from "./chunk-YLALZXTZ.js";
+import {
+  BoundedLruMap,
+  loadEnvs,
+  preloadPathEnvs
+} from "./chunk-PVJIMQRI.js";
+
+// src/analyzer-module-load.ts
+import { readFileSync, existsSync, statSync } from "fs";
+import { resolve, dirname } from "path";
+import { parse } from "@nudojs/parser";
+function resolveImportPath(specifier, fromDir) {
+  const basePath = resolve(fromDir, specifier);
+  for (const ext of ["", ".js", ".ts", ".mjs"]) {
+    const candidate = basePath + ext;
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function buildModuleGraph(files, cache) {
+  const imports = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  const edge = (from, to) => {
+    if (!imports.has(from)) imports.set(from, /* @__PURE__ */ new Set());
+    if (!dependents.has(to)) dependents.set(to, /* @__PURE__ */ new Set());
+    imports.get(from).add(to);
+    dependents.get(to).add(from);
+  };
+  for (const file of files) {
+    if (!imports.has(file)) imports.set(file, /* @__PURE__ */ new Set());
+    if (!dependents.has(file)) dependents.set(file, /* @__PURE__ */ new Set());
+    let edges;
+    if (cache) {
+      let stat = null;
+      try {
+        stat = statSync(file);
+      } catch {
+      }
+      const cached = stat ? cache.get(file) : void 0;
+      if (stat && cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+        edges = cached.edges;
+      } else {
+        edges = extractImportEdges(file);
+        if (stat) cache.set(file, { mtimeMs: stat.mtimeMs, size: stat.size, edges });
+      }
+    } else {
+      edges = extractImportEdges(file);
+    }
+    for (const to of edges) edge(file, to);
+  }
+  return { imports, dependents };
+}
+function extractImportEdges(file) {
+  const edges = [];
+  let ast;
+  try {
+    ast = parse(readFileSync(file, "utf-8"));
+  } catch {
+    return edges;
+  }
+  for (const stmt of ast.program.body) {
+    if (stmt.type !== "ImportDeclaration") continue;
+    const specifier = stmt.source.value;
+    if (!specifier.startsWith(".") && !specifier.startsWith("/")) continue;
+    const resolved = resolveImportPath(specifier, dirname(file));
+    if (resolved) edges.push(resolved);
+  }
+  return edges;
+}
+function computeDirtySet(dependents, changedFile) {
+  const dirty = [];
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [changedFile];
+  while (queue.length > 0) {
+    const file = queue.shift();
+    if (visited.has(file)) continue;
+    visited.add(file);
+    dirty.push(file);
+    for (const dep of dependents.get(file) ?? []) {
+      if (!visited.has(dep)) queue.push(dep);
+    }
+  }
+  return dirty;
+}
+function topoSortDirty(imports, dirty) {
+  const inSet = new Set(dirty);
+  const pending = /* @__PURE__ */ new Map();
+  for (const file of dirty) {
+    let count = 0;
+    for (const dep of imports.get(file) ?? []) {
+      if (inSet.has(dep)) count++;
+    }
+    pending.set(file, count);
+  }
+  const ordered = [];
+  const ready = dirty.filter((f) => pending.get(f) === 0);
+  while (ready.length > 0) {
+    const file = ready.shift();
+    ordered.push(file);
+    for (const other of dirty) {
+      if (pending.get(other) === void 0) continue;
+      if ((imports.get(other) ?? /* @__PURE__ */ new Set()).has(file)) {
+        const next = pending.get(other) - 1;
+        pending.set(other, next);
+        if (next === 0) ready.push(other);
+      }
+    }
+  }
+  for (const file of dirty) {
+    if (pending.has(file) && pending.get(file) > 0) ordered.push(file);
+  }
+  return ordered;
+}
+
+// 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-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}`;
+  }
+  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);
+    }
+  } 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 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 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 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 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 {
+    ...r,
+    callLoc: { line: r.callLoc.line + lineDelta, column: r.callLoc.column }
+  };
+}
+
+// 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
+    });
+  }
+  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;
+  }
+}
+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;
+}
+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);
+    }
+  };
+  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));
+        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;
+    }
+  }
+  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));
+    }
+    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));
+      }
+    }
+  }
+  return out;
+}
+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;
+  }
+  const out = { named };
+  if (def) out.default = def;
+  return out;
+}
+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 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 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 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) {
+  if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
+  try {
+    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;
+  }
+}
+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;
+  }
+  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 envPathDependents(envPath) {
+  return [...envDependents.peek(norm(envPath)) ?? []];
+}
+function clearEnvPathDeps() {
+  envDependents.clear();
+}
+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);
+}
+
+// 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` };
+  }
+  return {
+    ok: true,
+    run,
+    absPath: entryFile,
+    source,
+    modules
+  };
+}
+
+// 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
+    };
+  }
+  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 pickNamed(mock, names) {
+  const named = {};
+  let def;
+  for (const n of names) {
+    if (n === "default") {
+      if (mock.default) def = mock.default;
+      continue;
+    }
+    const v = mock.named[n];
+    if (v !== void 0) named[n] = v;
+  }
+  return def !== void 0 ? { named, default: def } : { named };
+}
+function applyMockModuleDirectives(base, fileDirectives, opts) {
+  const mods = fileDirectives.filter(
+    (d) => d.kind === "mock-module"
+  );
+  if (mods.length === 0) {
+    return { modules: base, errors: [], applied: false };
+  }
+  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 { 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 });
+}
+function evictAnalysisFileCacheForFiles(files) {
+  let n = 0;
+  for (const f of files) {
+    if (analysisByFile.delete(f)) n++;
+  }
+  return n;
+}
+
+// src/fn-analysis-cache.ts
+var fnAnalysisCache = /* @__PURE__ */ new Map();
+function getFnAnalysisCacheSize() {
+  return fnAnalysisCache.size;
+}
+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);
+  }
+}
+function fnAnalysisCacheGet(key) {
+  const hit = fnAnalysisCache.get(key);
+  if (hit !== void 0) {
+    fnAnalysisCache.delete(key);
+    fnAnalysisCache.set(key, hit);
+  }
+  return hit;
+}
+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 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 n;
+}
+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/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 formatAbs(a);
+  } catch {
+    return "?";
+  }
+}
+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])}`);
+  }
+  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 collectEnvGlobals(envNames) {
+  if (envNames.length === 0) return {};
+  const env = createEnvironment();
+  try {
+    return { ...loadEnvs(envNames, env).globals };
+  } catch {
+    return {};
+  }
+}
+function collectEnvModules(envNames) {
+  if (envNames.length === 0) return {};
+  const env = createEnvironment();
+  let mods = {};
+  try {
+    mods = loadEnvs(envNames, env).modules;
+  } catch {
+    return {};
+  }
+  const out = {};
+  for (const [spec, named] of Object.entries(mods)) {
+    out[spec] = { named: { ...named } };
+  }
+  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;
+    }
+    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 {
+      }
+    }
+    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 collectBPathReplacements(source) {
+  const targets = [];
+  const values = {};
+  const asTargets = [];
+  const asValues = {};
+  let i = 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);
+  } catch {
+  }
+  return { targets, values, asTargets, asValues };
+}
+function isBPathCapable(source, envNames = []) {
+  void envNames;
+  void source;
+  return true;
+}
+var bRunByFile = /* @__PURE__ */ new Map();
+function bPathDepKey(source, filePath) {
+  try {
+    const fp = loadModuleDepsFingerprint2(source, defaultLoadModule, filePath);
+    if (fp.truncated) return null;
+    return hashSource2(fp.fp);
+  } catch {
+    return null;
+  }
+}
+function clearBPathCache() {
+  bRunByFile.clear();
+  clearAnalysisFileCache();
+  clearFnAnalysisCache();
+}
+function getBPathCacheSize() {
+  return bRunByFile.size;
+}
+function evictBPathCacheForFiles(files) {
+  let n = 0;
+  for (const f of files) {
+    if (bRunByFile.delete(f)) n++;
+  }
+  return n;
+}
+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);
+  }
+  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);
+  }
+}
+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 { 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);
+    }
+  } catch {
+    out = null;
+  }
+  if (canCache && depKey !== null) {
+    bPathCacheSet(filePath, stable, mode, envKey, mockKey, depKey, out);
+  }
+  return out ?? void 0;
+}
+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 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") {
+      continue;
+    }
+    const v = obj[key];
+    if (v && typeof v === "object") parts.push(`${key}:{${astContentKey(v, depth + 1)}}`);
+  }
+  return parts.join("|");
+}
+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 }
+      }
+    ]
+  };
+  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 }]
+  };
+  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}`
+  );
+}
+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);
+}
+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(absUnknown);
+}
+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}'`
+    };
+  }
+  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;
+  }
+  return { abs: markMockConf(absVal) };
+}
+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 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;
+        }
+      }
+    }
+  }
+  return { seedVars, seedFns, ...fromErrors.length > 0 ? { fromErrors } : {} };
+}
+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 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)}`;
+  try {
+    return formatAbs3(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;
+  }
+}
+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);
+    }
+  }
+  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 (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" };
+    }
+  }
+  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;
+}
+function isSelfContainedSource(source, envNames) {
+  if (envNames.length > 0) return false;
+  return !/\brequire\s*\(|\bimport\s*[{'"*]/.test(source);
+}
+function absModulesOk(source, envNames) {
+  void source;
+  void envNames;
+  return true;
+}
+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" });
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  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;
+  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;
+  }
+}
+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 {
+  }
+}
+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 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;
+  }
+  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;
+        }
+      }
+    });
+  }
+  return absUnknown2;
+}
+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;
+}
+
+// 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 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 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++;
+    }
+  }
+  return out;
+}
+
+// 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);
+      }
+      break;
+    case "ExportNamedDeclaration":
+    case "ExportDefaultDeclaration": {
+      const decl = n.declaration;
+      if (decl) walkUnreachable(decl, out);
+      break;
+    }
+    default:
+      break;
+  }
+}
+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);
+    }
+  };
+  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);
+    }
+  };
+  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");
+      }
+    } 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);
+        }
+      });
+    } else if (v && typeof v === "object" && "type" in v) {
+      walkBuiltinUnknown(v, declared, out, seen, known, key);
+    }
+  }
+}
+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/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;
+    }
+    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);
+      }
+    }
+  };
+  walk(exportsField, false);
+}
+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);
+    }
+    for (const k of Object.keys(bField)) {
+      if (k.startsWith(".")) node.push(k);
+    }
+  }
+  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;
+  }
+  const kind = typeof p.exports !== "undefined" && collectExportHasBrowser(p.exports) ? "exports-conditions" : "browser-field";
+  return { kind, browser: [...new Set(browser)], node: [...new Set(node)] };
+}
+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 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];
+}
+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;
+      }
+    }
+    if (dir === root) return null;
+    const parent = dirname7(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function dualEntryForFile(filePath) {
+  let owning = null;
+  try {
+    owning = findOwningPackage(filePath);
+  } 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
+  };
+}
+
+// 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 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));
+  }
+  if (fn.type === "VariableDeclaration") {
+    const init = getDeclaratorInit(getDeclarations(fn)[0]);
+    if (init && (init.type === "FunctionExpression" || init.type === "ArrowFunctionExpression")) {
+      return formalParamDisplayNames(formalParamsFromNodes(init.params));
+    }
+  }
+  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;
+  }
+  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;
+  }
+  const idLoc = fnOrClassIdLoc(d);
+  if (idLoc) return idLoc;
+  return fallback;
+}
+function isFnExprValue(node) {
+  return !!node && (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression");
+}
+function namedFnExprId(node) {
+  return node.type === "FunctionExpression" && node.id ? node.id.name : null;
+}
+function isModuleExportsTarget(node) {
+  return node.type === "MemberExpression" && !node.computed && isModuleExportsMember(node);
+}
+function deepestAssignValue(expr) {
+  let cur = expr;
+  while (cur) {
+    const assign = asAssignmentExpression(cur);
+    if (!assign) break;
+    cur = assign.right;
+  }
+  return cur ?? null;
+}
+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 null;
+  }
+  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
+      });
+    }
+  };
+  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;
+      }
+      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 (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;
+    }
+  }
+  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;
+    }
+    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.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 } : {} });
+      }
+    }
+  }
+  for (const cname of exportedClassNames) {
+    const hit = classDecls.get(cname);
+    if (!hit) continue;
+    collectClassMethods(cname, hit.node, hit.stmt);
+  }
+  return results;
+}
+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 (!targetsModuleExports) continue;
+    if (found) return null;
+    found = fn;
+  }
+  return found;
+}
+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]);
+      }
+    }
+  };
+  walk(programBody(ast));
+}
+function nullLitAbs() {
+  return makeAbsVal({ k: "unknown" }, { op: "lit", value: null }, void 0, "exact");
+}
+function buildNodeTypeMap(ast, env, nodeAbsMap) {
+  const traverseFn = unwrapDefaultExport(traverse);
+  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 {
+        }
+      }
+    });
+  } catch {
+  }
+}
+
+// src/analyzer-diagnose.ts
+function validateMockDirectives(directives, diagnostics) {
+  for (const d of directives) {
+    if (d.kind !== "mock" || !d.expression) continue;
+    if (d.arrowFn || d.sinonExpr || d.nudoMock) continue;
+    const expr = d.expression.trim();
+    const isTypeExpr = /^(number|string|boolean|any|array|shape|lit|union|fn|partial|pick|omit|record|required|readonly|nonNullable|and)\s*\(/.test(expr) || expr === "unknown" || expr === "any" || expr === "never" || expr === "true" || expr === "false" || expr === "null" || expr === "undefined" || /^-?\d+(\.\d+)?$/.test(expr) || (expr.startsWith('"') && expr.endsWith('"') || expr.startsWith("'") && expr.endsWith("'")) || expr.startsWith("{") || expr.startsWith("[");
+    const looksLikeCall = expr.includes("(") && expr.includes(")") || expr.includes("=>");
+    if (looksLikeCall && !isTypeExpr) {
+      diagnostics.push({
+        range: { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } },
+        severity: "warning",
+        message: `Mock expression "${expr}" could not be parsed as a known pattern`,
+        code: "nudo:mock-invalid",
+        suggestions: [
+          "Supported formats: stub(), stub().returns(value), spy(), mock()",
+          "Arrow functions: (args) => expression or (args) => { statements; return value; }",
+          "Type expressions: number(), string(), shape({...}), union(...), or concrete literals"
+        ]
+      });
+    }
+  }
+}
+var DEFAULT_CALLSITE_BUDGET = 3;
+var COLLAPSE_LITERAL_THRESHOLD = 4;
+function dedupeCallRecords(records) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const rec of records) {
+    if (isOversizedCallRecord(rec)) continue;
+    const key = rec.argAbs.map(absStructureKey).join(",") + "=>" + absStructureKey(rec.resultAbs) + "!" + absStructureKey(rec.throwsAbs);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(rec);
+  }
+  return out;
+}
+function locFromCallLoc(loc) {
+  const p = loc ?? { line: 0, column: 0 };
+  return { start: { line: p.line, column: p.column }, end: { line: p.line, column: p.column } };
+}
+function synthesizeExternalFunctions(records, currentFile, callSiteBudget = DEFAULT_CALLSITE_BUDGET) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const rec of records) {
+    if (!rec.targetModule || !rec.targetExport) continue;
+    if (rec.targetModule === currentFile) continue;
+    const key = `${rec.targetModule}\0${rec.targetExport}`;
+    let group = groups.get(key);
+    if (!group) {
+      group = { module: rec.targetModule, exportName: rec.targetExport, records: [] };
+      groups.set(key, group);
+    }
+    group.records.push(rec);
+  }
+  const out = [];
+  for (const { module, exportName, records: records2 } of groups.values()) {
+    const deduped = dedupeCallRecords(records2);
+    const arity = Math.max(...deduped.map((r) => r.argAbs.length));
+    const analysis = {
+      name: exportName,
+      loc: locFromCallLoc(deduped[0].callLoc),
+      paramNames: Array.from({ length: arity }, (_, i) => `arg${i}`),
+      cases: [],
+      fromModule: module
+    };
+    const precise = deduped.slice(0, callSiteBudget);
+    for (const rec of precise) {
+      analysis.cases.push({
+        name: `call@L${rec.callLoc?.line ?? 0}`,
+        argAbs: [...rec.argAbs],
+        abs: rec.resultAbs,
+        throwsAbs: rec.throwsAbs,
+        source: "callsite"
+      });
+    }
+    const remaining = deduped.slice(callSiteBudget);
+    if (remaining.length > 0) {
+      const symArgsAbs = Array.from(
+        { length: arity },
+        (_, i) => (
+          // 缺参按真实 JS 语义 widen 成 undefined 而非 unknown——可选参守卫
+          // （target || [] 等）对 unknown 全塌，对 undefined 正常走默认分支
+          widenJoinAbs(remaining.map((rec) => rec.argAbs[i] ?? undefAbs))
+        )
+      );
+      const symResultAbs = collapseAbsLits(
+        remaining.map((r) => r.resultAbs),
+        COLLAPSE_LITERAL_THRESHOLD
+      );
+      const symThrowsAbs = joinAllAbs(remaining.map((r) => r.throwsAbs));
+      analysis.cases.push({
+        name: "call@symbolic",
+        argAbs: symArgsAbs,
+        abs: symResultAbs,
+        throwsAbs: symThrowsAbs,
+        source: "callsite",
+        aggregatedFrom: remaining.length
+      });
+    }
+    if (deduped.length > 1) {
+      analysis.combinedAbs = collapseAbsLits(
+        deduped.map((r) => r.resultAbs),
+        COLLAPSE_LITERAL_THRESHOLD
+      );
+    } else {
+      analysis.combinedAbs = deduped[0].resultAbs;
+    }
+    out.push(analysis);
+  }
+  return out;
+}
+function findModuleImportLoc(source, module) {
+  const bare = module.startsWith("node:") ? module.slice("node:".length) : module;
+  const alts = [.../* @__PURE__ */ new Set([module, bare, `node:${bare}`])];
+  const lines = source.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const alt of alts) {
+      const re = new RegExp(
+        `["'\`]${alt.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["'\`]`
+      );
+      const m = re.exec(line);
+      if (m && m.index !== void 0) {
+        return { line: i, column: m.index, length: m[0].length };
+      }
+    }
+  }
+  return null;
+}
+
+// src/analyzer-orchestrate-uncached.ts
+function analyzeFileUncached(filePath, source, activeCases, externalCallRecords, loadModule, caseMode = "all") {
+  const projectConfig = findProjectConfig(dirname8(filePath));
+  const missingSlotOn = analysisConfig(projectConfig?.config).evalMissingSlot === "warning";
+  return runWithEvalMissingSlot(
+    missingSlotOn,
+    () => analyzeFileUncachedInner(
+      filePath,
+      source,
+      activeCases,
+      externalCallRecords,
+      loadModule,
+      caseMode
+    )
+  );
+}
+function analyzeFileUncachedInner(filePath, source, activeCases, externalCallRecords, loadModule, caseMode = "all") {
+  const ast = parse8(source);
+  const functions = extractDirectives2(ast);
+  const diagnostics = [];
+  const bindings = /* @__PURE__ */ new Map();
+  const nodeAbsMap = /* @__PURE__ */ new Map();
+  const functionResults = [];
+  const caseHints = [];
+  const envHarvestConflicts = [];
+  const prevHarvestConflictCollector = setEnvHarvestConflictCollector((c) => {
+    if (!envHarvestConflicts.some((x) => x.module === c.module)) {
+      envHarvestConflicts.push(c);
+    } else {
+      const prev = envHarvestConflicts.find((x) => x.module === c.module);
+      for (const e of c.exports) {
+        if (!prev.exports.includes(e)) prev.exports.push(e);
+      }
+      prev.defaultOverwritten ||= c.defaultOverwritten;
+    }
+  });
+  const fileDirectives = extractFileDirectives3(ast);
+  const fileEnvNames = fileDirectives.filter((d) => d.kind === "env").flatMap((d) => d.envs);
+  const projectConfig = findProjectConfig(dirname8(filePath));
+  const projectEnvNames = projectConfig?.config.env ?? [];
+  const envNames = [.../* @__PURE__ */ new Set([...projectEnvNames, ...fileEnvNames])];
+  const analysisCfg = analysisConfig(projectConfig?.config);
+  const callSiteBudget = analysisCfg.callSiteBudget;
+  const callRecords = [];
+  const globalEnv = createEnvironment2();
+  const bMemberDiagNames = /* @__PURE__ */ new Set();
+  const bMemberDiagSeen = /* @__PURE__ */ new Set();
+  const pushBMemberDiag = (d, fallbackLine) => {
+    bMemberDiagNames.add(d.name);
+    const key = `${d.kind}:${d.name}:${d.receiver}:${d.line ?? fallbackLine}:${d.column ?? 0}:${d.code ?? ""}`;
+    if (bMemberDiagSeen.has(key)) return;
+    bMemberDiagSeen.add(key);
+    if (d.code === "nudo:missing-slot") {
+      diagnostics.push({
+        range: {
+          start: { line: d.line ?? fallbackLine, column: d.column ?? 0 },
+          end: { line: d.line ?? fallbackLine, column: (d.column ?? 0) + d.name.length }
+        },
+        severity: "warning",
+        message: `Field '${d.name}' is missing on the evaluated object shape`,
+        code: "nudo:missing-slot",
+        ...d.origin ? { origin: d.origin } : {}
+      });
+      return;
+    }
+    if (d.receiver === "unknown") {
+      diagnostics.push({
+        range: {
+          start: { line: d.line ?? fallbackLine, column: d.column ?? 0 },
+          end: { line: d.line ?? fallbackLine, column: (d.column ?? 0) + d.name.length }
+        },
+        severity: "warning",
+        message: `Cannot resolve '${d.name}' on unknown value`,
+        code: "nudo:unknown-recv",
+        ...d.origin ? { origin: d.origin } : {}
+      });
+      return;
+    }
+    diagnostics.push({
+      range: {
+        start: { line: d.line ?? fallbackLine, column: d.column ?? 0 },
+        end: { line: d.line ?? fallbackLine, column: (d.column ?? 0) + d.name.length }
+      },
+      severity: d.receiver === "number" || d.receiver === "boolean" || d.receiver === "bigint" || d.receiver === "symbol" ? "error" : "warning",
+      message: d.kind === "method" ? `Method '${d.name}' does not exist on type '${d.receiver}'` : `Property '${d.name}' does not exist on type '${d.receiver}'`,
+      code: "nudo:no-method",
+      ...d.origin ? { origin: d.origin } : {}
+    });
+  };
+  for (const fn of functions) {
+    validateMockDirectives(fn.directives, diagnostics);
+  }
+  const selfContained = isSelfContainedSource(source, envNames);
+  const canAbsModules = absModulesOk(source, envNames);
+  const bCapable = isBPathCapable(source, envNames);
+  const bModuleIssueKinds = /* @__PURE__ */ new Set();
+  const bTruncatedFns = /* @__PURE__ */ new Set();
+  const bBuiltinUnknownNames = /* @__PURE__ */ new Set();
+  let bHostedEval = false;
+  const pushBModuleIssues = (issues) => {
+    if (!issues) return;
+    for (const iss of issues) {
+      bModuleIssueKinds.add(iss.kind);
+      const code = iss.kind === "cycle" ? "nudo:module-cycle" : iss.kind === "depth" ? "nudo:module-depth" : "nudo:module-missing";
+      diagnostics.push({
+        range: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+        severity: iss.kind === "missing" ? "error" : "warning",
+        message: iss.reason,
+        code
+      });
+    }
+  };
+  const seeds = mockDirectivesToAbsSeeds(functions, {
+    fromFile: filePath || void 0,
+    ...loadModule ? { loadModule } : {}
+  });
+  for (const fe of seeds.fromErrors ?? []) {
+    diagnostics.push({
+      range: { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } },
+      severity: "error",
+      message: fe.message,
+      code: "nudo:module-missing",
+      suggestions: [
+        `Create the mock file or fix the path in @nudo:mock ${fe.name} from "${fe.fromPath}"`,
+        "The mock module must define a binding with the same name as the mock"
+      ]
+    });
+  }
+  let absCallRecords = [];
+  let bTopCallRecords = [];
+  let absGraphModules;
+  let absBindsShared;
+  let absNodesShared;
+  if (bCapable && filePath) {
+    try {
+      const g = evalAbsModuleGraph(source, filePath, {
+        seedVars: seeds.seedVars,
+        seedFns: seeds.seedFns,
+        ...loadModule ? { loadModule } : {}
+      });
+      absGraphModules = mergeHarvestUnderEnv(g.modules, collectEnvModules(envNames));
+      const mm = applyMockModuleDirectives(absGraphModules, fileDirectives, {
+        fromFile: filePath,
+        ...loadModule ? { loadModule } : {}
+      });
+      absGraphModules = mm.modules;
+      for (const fe of mm.errors) {
+        diagnostics.push({
+          range: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+          severity: "error",
+          message: fe.message,
+          code: "nudo:module-missing"
+        });
+      }
+      pushBModuleIssues(g.issues);
+    } catch {
+    }
+    const bRun = tryRunBPath(source, filePath, {
+      envNames,
+      mocks: mockSeedsToAbsMocks(seeds)
+    });
+    if (bRun) {
+      bHostedEval = true;
+      if (bRun.memberDiags?.length) {
+        for (const d of bRun.memberDiags) {
+          pushBMemberDiag(d, 1);
+        }
+      }
+      if (bRun.truncatedFns) {
+        for (const fn of bRun.truncatedFns) bTruncatedFns.add(fn);
+      }
+      if (bRun.calls?.length) {
+        const impMap = buildAbsImportLocalMap(source, filePath);
+        for (const c of bRun.calls) {
+          bTopCallRecords.push(callRecordFromAbsCall(c, impMap));
+        }
+      }
+    }
+  }
+  if (bHostedEval && bTopCallRecords.length > 0) {
+    callRecords.length = 0;
+    callRecords.push(...bTopCallRecords);
+  } else if ((selfContained || canAbsModules) && absCallRecords.length > 0) {
+    callRecords.length = 0;
+    callRecords.push(...absCallRecords);
+  } else if (bTopCallRecords.length > 0) {
+    callRecords.length = 0;
+    callRecords.push(...bTopCallRecords);
+  }
+  const unreachableRanges = [];
+  if (bCapable) {
+    const bKnownGlobals = /* @__PURE__ */ new Set([
+      ...Object.keys(collectEnvGlobals(envNames)),
+      ...Object.keys(mockSeedsToAbsMocks(seeds))
+    ]);
+    const bDiag = collectBPathDiagnostics(source, bKnownGlobals);
+    for (const ur of bDiag.unreachable) {
+      diagnostics.push({
+        range: ur.range,
+        severity: "info",
+        message: "Code after return/throw statement is unreachable",
+        tags: ["unnecessary"],
+        code: "nudo-unreachable",
+        suggestions: ["Remove the unreachable code after the return/throw statement"]
+      });
+    }
+    for (const b of bDiag.builtinUnknown) {
+      bBuiltinUnknownNames.add(b.name);
+      diagnostics.push({
+        range: b.range,
+        severity: "warning",
+        message: `Built-in API "${b.name}" is not covered by Nudo's type inference`,
+        code: "nudo:builtin-unknown",
+        suggestions: [
+          `Use @nudo:mock to define the type: @nudo:mock ${b.name} = stub().returns(...)`,
+          `Or use @nudo:contract return <constraint> to declare the return contract`
+        ]
+      });
+    }
+  } else {
+    for (const ur of unreachableRanges) {
+      diagnostics.push({
+        range: ur,
+        severity: "info",
+        message: "Code after return/throw statement is unreachable",
+        tags: ["unnecessary"],
+        code: "nudo-unreachable",
+        suggestions: ["Remove the unreachable code after the return/throw statement"]
+      });
+    }
+  }
+  if (!absNodesShared && !bHostedEval && (selfContained || canAbsModules)) {
+    try {
+      const collected = { binds: /* @__PURE__ */ new Map(), nodes: /* @__PURE__ */ new Map() };
+      if (!absBindsShared) absBindsShared = collected.binds;
+      absNodesShared = collected.nodes;
+    } catch {
+    }
+  }
+  collectBindings(ast, globalEnv, bindings, absBindsShared);
+  if (isBPathCapable(source, envNames)) {
+    try {
+      const absBinds = absBindsShared ?? collectAbsBindingsFromGraph(source, filePath, {
+        seedVars: seeds.seedVars,
+        seedFns: seeds.seedFns
+      });
+      if (!absBinds) {
+      } else for (const [name, absVal0] of absBinds) {
+        const absVal = absVal0;
+        const prev = bindings.get(name);
+        bindings.set(name, {
+          abs: absVal,
+          loc: prev?.loc
+        });
+      }
+    } catch {
+    }
+  }
+  const synthCandidates = [];
+  let fnFpMap;
+  try {
+    fnFpMap = fnFingerprints(source, ast);
+  } catch {
+    fnFpMap = void 0;
+  }
+  const envKeyFn = envNames.join(",");
+  const mockKeyFn = mockSeedFingerprint(seeds.seedVars, seeds.seedFns);
+  for (const fn of functions) {
+    const isPure = fn.directives.some((d) => d.kind === "pure");
+    const skipDirective = fn.directives.find((d) => d.kind === "skip");
+    const fnLoc = locFromNode(fn.node);
+    const paramNames = extractParamNames(fn.node);
+    const formals = formalParamsFromNodes2(
+      fn.node.params ?? []
+    );
+    const analysis = {
+      name: fn.name,
+      loc: fnLoc,
+      paramNames,
+      ...formals.length > 0 ? { formals } : {},
+      cases: []
+    };
+    if (skipDirective && skipDirective.kind === "skip") {
+      analysis.skipped = true;
+      if (skipDirective.returns) {
+        analysis.combinedAbs = skipDirective.returns;
+      }
+      functionResults.push(analysis);
+      continue;
+    }
+    const caseDirectives = fn.directives.filter((d) => d.kind === "case");
+    const activeCaseIdx = activeCases?.get(fn.name) ?? 0;
+    const caseIdxsToRun = caseMode === "none" || caseDirectives.length === 0 ? [] : caseMode === "all" ? caseDirectives.map((_, i) => i) : activeCases?.has(fn.name) ? [Math.min(activeCaseIdx, caseDirectives.length - 1)] : [];
+    const fp = fnFpMap?.get(fn.name);
+    const analysisFnKey = `m=${analysisCfg.mode}|e=${analysisCfg.evalMissingSlot}|b=${analysisCfg.callSiteBudget}`;
+    let fnDepSeg = "-";
+    let fnDepFailClosed = false;
+    try {
+      const dfp = loadModuleDepsFingerprint3(source, loadModule ?? defaultLoadModule, filePath);
+      if (dfp.truncated) {
+        fnDepFailClosed = true;
+        fnDepSeg = null;
+      } else {
+        fnDepSeg = hashSource3(dfp.fp);
+      }
+    } catch {
+      fnDepFailClosed = true;
+      fnDepSeg = null;
+    }
+    const fnCacheKey = !fnDepFailClosed && fp && caseDirectives.length > 0 ? [
+      filePath,
+      fp.own,
+      fp.deps,
+      String(activeCaseIdx),
+      caseDirectiveKey(caseDirectives, formatAbs5),
+      envKeyFn,
+      mockKeyFn,
+      analysisFnKey,
+      fnDepSeg ?? "-",
+      `cm=${caseMode}`
+    ].join("\0") : void 0;
+    const dLen0 = diagnostics.length;
+    const hLen0 = caseHints.length;
+    const cLen0 = callRecords.length;
+    if (fnCacheKey) {
+      const hitFn = fnAnalysisCacheGet(fnCacheKey);
+      if (hitFn) {
+        const cached = cloneFunctionAnalysis(hitFn.analysis);
+        const lineDelta = fnLoc.start.line - cached.loc.start.line;
+        cached.loc = fnLoc;
+        if (lineDelta !== 0) {
+          for (const c of cached.cases) {
+            if (c.throwLoc) c.throwLoc = shiftSourceLoc(c.throwLoc, lineDelta);
+          }
+        }
+        if (lineDelta === 0) {
+          diagnostics.push(...hitFn.diagnostics);
+          caseHints.push(...hitFn.caseHints);
+          callRecords.push(...hitFn.callRecords);
+        } else {
+          for (const d of hitFn.diagnostics) {
+            diagnostics.push(shiftDiagnosticLines(d, lineDelta));
+          }
+          for (const h of hitFn.caseHints) {
+            caseHints.push({ ...h, line: h.line + lineDelta });
+          }
+          for (const r of hitFn.callRecords) {
+            callRecords.push(shiftCallRecordLines(r, lineDelta));
+          }
+        }
+        functionResults.push(cached);
+        continue;
+      }
+    }
+    if (isPure) {
+      const fnVal = globalEnv.has(fn.name) ? globalEnv.lookup(fn.name) : null;
+      if (fnVal && typeof fnVal === "object") {
+        markPureFn(fnVal, fn.name);
+      }
+    }
+    const sampleDirective = fn.directives.find((d) => d.kind === "sample");
+    void sampleDirective;
+    if (caseIdxsToRun.length === 0) {
+      synthCandidates.push({ name: fn.name, node: fn.node, analysis });
+    }
+    for (const ci of caseIdxsToRun) {
+      const directive = caseDirectives[ci];
+      let caseAbs;
+      let caseThrowsAbs;
+      let caseThrowLoc;
+      let caseUnreachable = [];
+      const bCapable2 = isBPathCapable(source, envNames);
+      const bPrimary = bCapable2;
+      if (bCapable2 && filePath) {
+        const caseArgsAbs = directive.argsAbs;
+        const bFull = tryBPathCallFull(
+          source,
+          filePath,
+          fn.name,
+          caseArgsAbs,
+          { collectCalls: true, envNames, mocks: mockSeedsToAbsMocks(seeds) }
+        );
+        const res = bFull?.result;
+        const weakUnknown = !!res && res.shape.k === "unknown" && (!res.term || res.term.op === "lit" && res.term.value === void 0);
+        const bOk = !!res && (bHostedEval || !weakUnknown && res.conf !== "opaque");
+        if (bOk && bFull && bPrimary) {
+          caseAbs = bFull.result;
+          caseThrowsAbs = bFull.throws;
+          for (const d of bFull.memberDiags ?? []) {
+            pushBMemberDiag(d, fnLoc.start.line);
+          }
+          if (bFull.calls?.length) {
+            const impMap = buildAbsImportLocalMap(source, filePath);
+            for (const c of bFull.calls) {
+              callRecords.push(callRecordFromAbsCall(c, impMap));
+            }
+          }
+        }
+      }
+      if (!caseAbs) {
+        if (bHostedEval) {
+          caseAbs = absUnknown5;
+          caseThrowsAbs = neverAbs;
+        } else {
+          const caseArgsAbs = directive.argsAbs;
+          const absFull = selfContained || canAbsModules ? tryEvalAbsFull(
+            source,
+            fn.name,
+            caseArgsAbs,
+            filePath,
+            mockSeedsToAbsMocks(seeds)
+          ) : void 0;
+          const weak = !!absFull && absFull.result.shape.k === "unknown" && (!absFull.result.term || absFull.result.term.op === "lit" && absFull.result.term.value === void 0);
+          const absOk = !!absFull && !weak && absFull.result.conf !== "opaque" && absFull.throws.shape.k === "never";
+          const absThrew = !!absFull && !weak && absFull.result.shape.k === "never" && absFull.throws.shape.k !== "never";
+          if (absOk) {
+            caseAbs = absFull.result;
+            caseThrowsAbs = neverAbs;
+          } else if (absThrew) {
+            caseAbs = absFull.result;
+            caseThrowsAbs = absFull.throws;
+            const tl = absFull.throwLoc;
+            if (tl) caseThrowLoc = { start: { ...tl }, end: { ...tl } };
+          } else {
+            caseAbs = absUnknown5;
+            caseThrowsAbs = neverAbs;
+          }
+        }
+      }
+      if (!caseThrowsAbs) caseThrowsAbs = neverAbs;
+      const caseEntry = {
+        name: directive.name,
+        argAbs: directive.argsAbs,
+        abs: caseAbs,
+        throwsAbs: caseThrowsAbs,
+        throwLoc: caseThrowLoc,
+        expected: directive.expected,
+        source: "directive"
+      };
+      tryAttachIntension(caseEntry, source, fn.name);
+      attachAbsToIntension(caseEntry, caseAbs, fn.name);
+      analysis.cases.push(caseEntry);
+      if (directive.commentLine) {
+        const hasThrow = caseThrowsAbs.shape.k !== "never";
+        const resultStr = caseAbs.shape.k !== "never" ? formatShape(caseAbs) : "";
+        const throwStr = hasThrow ? `throws ${formatShape(caseThrowsAbs)}` : "";
+        const label = [resultStr, throwStr].filter(Boolean).join(" ");
+        const hintLabel = `=> ${label}`;
+        let ok = true;
+        if (directive.expected) {
+          ok = leqAbs(caseAbs, directive.expected).ok;
+          if (!ok) {
+            diagnostics.push({
+              range: { start: { line: directive.commentLine, column: 0 }, end: { line: directive.commentLine, column: 999 } },
+              severity: "error",
+              message: `debug "${directive.name}": expected ${formatShape(directive.expected)}, got ${formatShape(caseAbs)}. The inferred return type does not match the expected type declared in the @nudo:case witness`,
+              code: "nudo:case-expected"
+            });
+          }
+        }
+        caseHints.push({ line: directive.commentLine, label: hintLabel, ok });
+      }
+      const isActive = ci === Math.min(activeCaseIdx, caseDirectives.length - 1);
+      if (isActive) {
+        if (caseThrowsAbs.shape.k !== "never") {
+          const throwRange = caseThrowLoc ?? fnLoc;
+          diagnostics.push({
+            range: throwRange,
+            severity: "warning",
+            message: `Function "${fn.name}" case "${directive.name}" may throw: ${formatShape(caseThrowsAbs)}. Consider adding a try-catch block or using @nudo:contract return <constraint>`,
+            code: "nudo:may-throw"
+          });
+        }
+        if (!isBPathCapable(source, envNames)) {
+          for (const ur of caseUnreachable) {
+            diagnostics.push({
+              range: ur,
+              severity: "info",
+              message: "Code after return/throw statement is unreachable",
+              tags: ["unnecessary"],
+              code: "nudo-unreachable",
+              suggestions: ["Remove the unreachable code after the return/throw statement"]
+            });
+          }
+        }
+      }
+    }
+    if (analysis.cases.length > 0) {
+      analysis.combinedAbs = collapseAbsLits(
+        analysis.cases.map((c) => c.abs),
+        COLLAPSE_LITERAL_THRESHOLD
+      );
+    }
+    attachHofSnapshot(analysis, source);
+    if (fnCacheKey) {
+      fnAnalysisCacheSet(fnCacheKey, {
+        analysis: cloneFunctionAnalysis(analysis),
+        diagnostics: diagnostics.slice(dLen0),
+        caseHints: caseHints.slice(hLen0),
+        callRecords: callRecords.slice(cLen0)
+      });
+    }
+    functionResults.push(analysis);
+  }
+  const directiveFnNames = new Set(functions.map((f) => f.name));
+  const directiveFnStmts = new Set(functions.map((f) => f.node));
+  for (const { name, node, stmt, noDeclaration, assignedName } of collectTopLevelFunctions(ast)) {
+    if (directiveFnNames.has(name)) continue;
+    if (directiveFnStmts.has(stmt)) continue;
+    const analysis = { name, loc: locFromNode(node), paramNames: extractParamNames(node), cases: [] };
+    if (noDeclaration) analysis.noDeclaration = true;
+    functionResults.push(analysis);
+    synthCandidates.push({ name, node, analysis, assignedName });
+  }
+  const modulePathCache = /* @__PURE__ */ new Map();
+  const normalizeModulePath = (p) => {
+    let n = modulePathCache.get(p);
+    if (n === void 0) {
+      try {
+        n = realpathSync(p);
+      } catch {
+        n = p;
+      }
+      modulePathCache.set(p, n);
+    }
+    return n;
+  };
+  const currentModulePath = normalizeModulePath(resolve7(filePath));
+  const singleExportFn = findSingleModuleExportsFunction(ast);
+  const reportInjectedDomainExceeds = (name, node, fallbackLoc) => {
+    if (!externalCallRecords || externalCallRecords.length === 0) return;
+    const singleExportHit = singleExportFn !== null && node === singleExportFn;
+    const nameRoutes = (r) => r.fnName === name || r.targetExport === name || (r.targetAliases?.includes(name) ?? false) || singleExportHit && (r.fnModule !== void 0 || r.targetModule !== void 0);
+    const matchingExternal = (r) => {
+      const attributed = r.fnModule !== void 0 && normalizeModulePath(r.fnModule) === currentModulePath || r.targetModule !== void 0 && normalizeModulePath(r.targetModule) === currentModulePath;
+      if (!attributed) return false;
+      return nameRoutes(r);
+    };
+    const injected = externalCallRecords.filter(matchingExternal);
+    if (injected.length === 0) return;
+    const nameLoc = fnNameLoc(node, fallbackLoc);
+    const fnNode = resolveFunctionNode(node);
+    const autoBind = interfaceConfig(findProjectConfig(dirname8(filePath))?.config).autoBind;
+    const domainIssues = checkInjectedDomainEvidence(name, source, injected, {
+      paramNames: extractParamNames(fnNode),
+      loadModule: loadModule ?? defaultLoadModule,
+      fromFile: filePath,
+      loc: { line: nameLoc.start.line, column: nameLoc.start.column },
+      ...autoBind === false ? { autoBind: false } : {}
+    });
+    for (const issue of domainIssues) {
+      const line = issue.line ?? nameLoc.start.line;
+      const column = issue.column ?? nameLoc.start.column;
+      diagnostics.push({
+        range: { start: { line, column }, end: { line, column: column + name.length } },
+        severity: issue.severity,
+        message: issue.message,
+        code: issue.code,
+        suggestions: issue.suggestion ? [issue.suggestion] : void 0,
+        data: { actual: issue.actual, expected: issue.expected }
+      });
+    }
+  };
+  for (const fn of functions) {
+    if (fn.directives.some((d) => d.kind === "case")) {
+      reportInjectedDomainExceeds(fn.name, fn.node, locFromNode(fn.node));
+    }
+  }
+  for (const candidate of synthCandidates) {
+    const singleExportHit = singleExportFn !== null && candidate.node === singleExportFn;
+    const nameRoutes = (r) => r.fnName === candidate.name || r.targetExport === candidate.name || (r.targetAliases?.includes(candidate.name) ?? false) || singleExportHit && (r.fnModule !== void 0 || r.targetModule !== void 0);
+    const matchingLocal = (r) => {
+      const targetsThisFile = r.targetModule === void 0 || normalizeModulePath(r.targetModule) === currentModulePath;
+      if (!targetsThisFile) return false;
+      return nameRoutes(r);
+    };
+    const matchingExternal = (r) => {
+      const attributed = r.fnModule !== void 0 && normalizeModulePath(r.fnModule) === currentModulePath || r.targetModule !== void 0 && normalizeModulePath(r.targetModule) === currentModulePath;
+      if (!attributed) return false;
+      return nameRoutes(r);
+    };
+    const records = dedupeCallRecords(
+      [
+        ...callRecords.filter(matchingLocal),
+        ...(externalCallRecords ?? []).filter(matchingExternal)
+      ].filter((r) => !isLeakedCallRecord(r))
+    );
+    reportInjectedDomainExceeds(candidate.name, candidate.node, candidate.analysis.loc);
+    if (records.length > 0) {
+      const informativeness = (r) => {
+        if (r.resultAbs.shape.k === "unknown") return 2;
+        if (r.resultAbs.shape.k === "never") return 1;
+        return 0;
+      };
+      const ordered = records.map((r, i) => ({ r, i })).sort((a, b) => informativeness(a.r) - informativeness(b.r) || a.i - b.i).map(({ r }) => r);
+      const precise = ordered.slice(0, callSiteBudget);
+      for (const rec of precise) {
+        let absRaw;
+        let absResult;
+        if (rec.resultAbs.shape.k !== "never" && rec.argAbs.length > 0) {
+          absRaw = tryEvalAbsRaw(source, candidate.name, rec.argAbs, filePath, mockSeedsToAbsMocks(seeds));
+          if (absRaw) {
+            if (absIsBetter(absRaw, rec.resultAbs)) {
+              absResult = absRaw;
+            }
+          }
+        }
+        if (!absRaw && rec.resultAbs.shape.k !== "never") {
+          absRaw = rec.resultAbs;
+        }
+        const caseAbs = absResult ?? rec.resultAbs;
+        const caseResult2 = {
+          name: `call@L${rec.callLoc?.line ?? candidate.analysis.loc.start.line}`,
+          argAbs: [...rec.argAbs],
+          abs: caseAbs,
+          throwsAbs: rec.throwsAbs,
+          source: "callsite"
+        };
+        tryAttachIntension(caseResult2, source, candidate.name);
+        if (absRaw) attachAbsToIntension(caseResult2, absRaw, candidate.name);
+        candidate.analysis.cases.push(caseResult2);
+      }
+      const remaining = ordered.slice(callSiteBudget).filter((rec) => !rec.argAbs.some((a) => a.shape.k === "unknown" && !a.term));
+      if (remaining.length > 0) {
+        const fnNode2 = resolveFunctionNode(candidate.node);
+        const paramCount = extractParamNames(fnNode2).length;
+        const widenedArgsAbs = Array.from(
+          { length: paramCount },
+          (_, i) => (
+            // 缺参按真实 JS 语义 widen 成 undefined 而非 unknown——可选参守卫
+            // （target || [] 等）对 unknown 全塌，对 undefined 正常走默认分支
+            widenJoinAbs(remaining.map((rec) => rec.argAbs[i] ?? undefAbs))
+          )
+        );
+        let symAbs;
+        if (isBPathCapable(source, envNames) && filePath) {
+          const bSym = tryBPathCall(
+            source,
+            filePath,
+            candidate.name,
+            widenedArgsAbs,
+            { envNames, mocks: mockSeedsToAbsMocks(seeds) }
+          );
+          if (bSym && (bHostedEval || !(bSym.shape.k === "unknown" && !bSym.term))) {
+            symAbs = bSym;
+          }
+        }
+        if (!symAbs && !bHostedEval) {
+          const absTry = tryEvalAbsRaw(
+            source,
+            candidate.name,
+            widenedArgsAbs,
+            filePath,
+            mockSeedsToAbsMocks(seeds)
+          );
+          const weak = !!absTry && absTry.shape.k === "unknown" && (!absTry.term || absTry.term.op === "lit" && absTry.term.value === void 0);
+          if (absTry && !weak && absTry.shape.k !== "never" && absTry.conf !== "opaque") {
+            symAbs = absTry;
+          }
+        }
+        const symCase = {
+          name: "call@symbolic",
+          argAbs: widenedArgsAbs,
+          // B4：超预算聚合必须 #widened（可解释降级）
+          abs: symAbs ? { ...symAbs, conf: symAbs.conf === "exact" ? "widened" : symAbs.conf } : absUnknown5,
+          throwsAbs: neverAbs,
+          source: "callsite",
+          aggregatedFrom: remaining.length
+        };
+        tryAttachIntension(symCase, source, candidate.name);
+        if (symAbs) attachAbsToIntension(symCase, symAbs, candidate.name);
+        candidate.analysis.cases.push(symCase);
+      }
+      candidate.analysis.combinedAbs = collapseAbsLits(
+        records.map((r) => r.resultAbs),
+        COLLAPSE_LITERAL_THRESHOLD
+      );
+      continue;
+    }
+    const fnNode = resolveFunctionNode(candidate.node);
+    const argAbsEntry = extractParamNames(fnNode).map(() => anyAbs);
+    let entryAbs;
+    let entryThrowsAbs = makeAbsVal2({ k: "never" }, void 0, void 0, "exact");
+    const entryEffects = [];
+    setMayThrowCollector((e) => entryEffects.push(e));
+    try {
+      if (isBPathCapable(source, envNames) && filePath) {
+        const bEntryFull = tryBPathCallFull(
+          source,
+          filePath,
+          candidate.analysis.name,
+          argAbsEntry,
+          { envNames, mocks: mockSeedsToAbsMocks(seeds), collectMemberDiags: true }
+        ) ?? (candidate.assignedName ? tryBPathCallFull(source, filePath, candidate.assignedName, argAbsEntry, {
+          envNames,
+          mocks: mockSeedsToAbsMocks(seeds)
+        }) : void 0);
+        if (bEntryFull?.memberDiags?.length) {
+          for (const d of bEntryFull.memberDiags) {
+            pushBMemberDiag(d, candidate.analysis.loc.start.line);
+          }
+        }
+        const bEntry = bEntryFull?.result;
+        if (bEntry && (bHostedEval || !(bEntry.shape.k === "unknown" && !bEntry.term))) {
+          entryAbs = bEntry;
+          if (bEntryFull?.throws) entryThrowsAbs = bEntryFull.throws;
+        }
+      }
+      if (!entryAbs) {
+        if (bHostedEval) {
+          entryAbs = absUnknown5;
+          entryThrowsAbs = makeAbsVal2({ k: "never" }, void 0, void 0, "exact");
+        } else {
+          const absEntry = tryEvalEntryAbs(source, candidate.analysis.name, argAbsEntry, filePath, seeds.seedVars, candidate.assignedName);
+          if (absEntry) {
+            entryAbs = absEntry;
+            entryThrowsAbs = makeAbsVal2({ k: "never" }, void 0, void 0, "exact");
+          } else {
+            entryAbs = absUnknown5;
+            entryThrowsAbs = makeAbsVal2({ k: "never" }, void 0, void 0, "exact");
+          }
+        }
+      }
+    } finally {
+      setMayThrowCollector(null);
+    }
+    const softThrows = mayThrowEffectsToAbs(entryEffects);
+    if (entryThrowsAbs.shape.k === "never" && softThrows.shape.k !== "never") {
+      entryThrowsAbs = softThrows;
+    } else if (entryThrowsAbs.shape.k !== "never" && softThrows.shape.k !== "never") {
+      const hard = formatThrowsAbs(entryThrowsAbs);
+      const soft = formatThrowsAbs(softThrows);
+      if (hard && soft && hard !== soft) {
+        entryThrowsAbs = makeAbsVal2(
+          { k: "sum", members: [entryThrowsAbs, softThrows] },
+          void 0,
+          void 0,
+          "exact"
+        );
+      }
+    }
+    const caseResult = {
+      name: `entry@L${candidate.analysis.loc.start.line}`,
+      argAbs: argAbsEntry,
+      abs: entryAbs,
+      throwsAbs: entryThrowsAbs
+    };
+    tryAttachIntension(caseResult, source, candidate.analysis.name);
+    attachAbsToIntension(caseResult, entryAbs, candidate.analysis.name);
+    candidate.analysis.cases.push(caseResult);
+    candidate.analysis.entryOnly = true;
+    candidate.analysis.combinedAbs = entryAbs;
+    attachHofSnapshot(candidate.analysis, source);
+    try {
+      const exportNames = localNamedExports(source);
+      const isEntry = exportNames.has(candidate.analysis.name) || candidate.assignedName !== void 0 && exportNames.has(candidate.assignedName);
+      if (isEntry) {
+        const autoBind = interfaceConfig(
+          findProjectConfig(dirname8(filePath))?.config
+        ).autoBind;
+        const eff = effectiveInterface(source, candidate.analysis.name, {
+          loadModule: loadModule ?? defaultLoadModule,
+          fromFile: filePath,
+          ...autoBind === false ? { autoBind: false } : {}
+        });
+        if (!eff) {
+          diagnostics.push({
+            range: {
+              start: candidate.analysis.loc.start,
+              end: candidate.analysis.loc.start
+            },
+            severity: "info",
+            message: `export '${candidate.analysis.name}' has no contract root and no call-site domain (entry-only)`,
+            code: "nudo:interface-entry-only"
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  if (!bHostedEval) {
+    buildNodeTypeMap(ast, globalEnv, nodeAbsMap);
+  }
+  const externalFunctions = synthesizeExternalFunctions(
+    callRecords,
+    filePath,
+    analysisConfig(projectConfig?.config).callSiteBudget
+  );
+  setEnvHarvestConflictCollector(prevHarvestConflictCollector);
+  for (const c of envHarvestConflicts) {
+    const parts = [];
+    if (c.exports.length > 0) parts.push(`export(s) ${c.exports.join(", ")}`);
+    if (c.defaultOverwritten) parts.push("default");
+    const detail = parts.length > 0 ? ` \u2014 ${parts.join("; ")}` : "";
+    const loc = findModuleImportLoc(source, c.module);
+    const range = loc ? {
+      start: { line: loc.line, column: loc.column },
+      end: { line: loc.line, column: loc.column + loc.length }
+    } : { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } };
+    diagnostics.push({
+      range,
+      severity: "warning",
+      message: `handwritten @nudo:env wins over harvest on module "${c.module}"${detail}; harvest only fills missing slots (B8). code=nudo:env-harvest-conflict`,
+      code: "nudo:env-harvest-conflict"
+    });
+  }
+  try {
+    const dual = dualEntryForFile(filePath);
+    if (dual) {
+      diagnostics.push({
+        range: { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } },
+        severity: "info",
+        message: dualEntryMessage(dual),
+        code: "nudo:dual-entry",
+        suggestions: [dualEntrySuggestion()]
+      });
+    }
+  } catch {
+  }
+  return {
+    functions: functionResults,
+    diagnostics,
+    bindings,
+    nodeAbsMap,
+    caseHints,
+    ...externalFunctions.length > 0 ? { externalFunctions } : {}
+  };
+}
+
+// src/analyzer-orchestrate.ts
+async function analyzeFileAsync(filePath, source, activeCases, externalCallRecords, loadModule, caseMode = "all") {
+  const envNames = collectEnvNames(filePath, source, true);
+  noteEnvPathDeps(filePath, source);
+  if (envNames.length > 0) {
+    await preloadPathEnvs(envNames, dirname9(filePath));
+  }
+  return analyzeFile(filePath, source, activeCases, externalCallRecords, loadModule, caseMode);
+}
+function analyzeFile(filePath, source, activeCases, externalCallRecords, loadModule, caseMode = "all") {
+  const projectConfig = findProjectConfig(dirname9(filePath));
+  const cfg = analysisConfig(projectConfig?.config);
+  const projectEnvNames = projectConfig?.config.env ?? [];
+  const autoBind = interfaceConfig(projectConfig?.config).autoBind;
+  const k = analysisFileCacheKey(
+    filePath,
+    source,
+    activeCases,
+    externalCallRecords,
+    cfg,
+    loadModule,
+    projectEnvNames,
+    autoBind !== false,
+    caseMode
+  );
+  if (!k.noCache) {
+    const hit = analysisCacheGet(k.filePath, k.source, k.auxKey);
+    if (hit !== void 0) {
+      return cloneAnalysisResult(hit);
+    }
+  }
+  const result = analyzeFileUncached(
+    filePath,
+    source,
+    activeCases,
+    externalCallRecords,
+    loadModule,
+    caseMode
+  );
+  if (!k.noCache) {
+    analysisCacheSet(k.filePath, k.source, k.auxKey, result);
+  }
+  return cloneAnalysisResult(result);
+}
+
+export {
+  buildModuleGraph,
+  computeDirtySet,
+  topoSortDirty,
+  locFromNode,
+  defaultLoadModule,
+  analysisFileCacheKey,
+  defaultAbsLoadModule,
+  getAbsModuleCacheSize,
+  clearAbsModuleCache,
+  evictAbsModuleCacheFiles,
+  evalAbsModuleGraph,
+  collectAbsBindingsFromGraph,
+  getEnvPathDepsSize,
+  noteEnvPathDeps,
+  envPathDependents,
+  clearEnvPathDeps,
+  isEnvTemplatePath,
+  applyMockModuleDirectives,
+  applyMockModuleDirectivesFromSource,
+  clearAnalysisFileCache,
+  getAnalysisFileCacheSize,
+  trimAnalysisFileCache,
+  evictAnalysisFileCacheForFiles,
+  getFnAnalysisCacheSize,
+  clearFnAnalysisCache,
+  trimFnAnalysisCache,
+  evictFnAnalysisCacheForFiles,
+  collectEnvGlobals,
+  collectEnvModules,
+  setEnvHarvestConflictCollector,
+  getEnvHarvestConflictCollector,
+  mergeHarvestUnderEnv,
+  collectBPathReplacements,
+  isBPathCapable,
+  clearBPathCache,
+  getBPathCacheSize,
+  evictBPathCacheForFiles,
+  trimBPathCache,
+  tryRunBPath,
+  tryBPathCallFull,
+  tryBPathCall,
+  mockSeedsToAbsMocks,
+  mockDirectivesToAbsSeeds,
+  mockSeedsForSource,
+  collectEnvNames,
+  collectCallRecords,
+  collectBPathDiagnostics,
+  detectDualEntryFromPackageJson,
+  findOwningPackage,
+  dualEntryForFile,
+  dualEntryIssueForFile,
+  analyzeFileAsync,
+  analyzeFile
+};