@nudojs/service 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,18 +1,42 @@
 // src/analyzer.ts
-import { readFileSync, existsSync } from "fs";
-import { resolve, dirname } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync3, statSync as statSync3, realpathSync } from "fs";
+import { resolve as resolve4, dirname as dirname5 } from "path";
 import traverse from "@babel/traverse";
 import {
-  T,
-  typeValueToString,
+  T as T2,
+  typeValueToString as typeValueToString3,
   simplifyUnion,
-  createEnvironment,
-  isSubtypeOf
+  widenLiteral,
+  collapseLiteralUnion,
+  createEnvironment as createEnvironment2,
+  isSubtypeOf,
+  mockHelperToTypeValue,
+  getFnSig as getFnSig3,
+  generalizeFromAst as generalizeFromAst2,
+  termToString,
+  predToString,
+  analyzeFn,
+  evalProgramAbs as evalProgramAbs2,
+  setAbsCallCollector,
+  setAbsNodeCollector,
+  absFunction as absFunction5,
+  collectAbsNodeTypes,
+  findAbsAtPosition,
+  typeValueToAbs as typeValueToAbs5,
+  absToTypeValue as absToTypeValue2,
+  formatAbs as formatAbs3,
+  formatAbsMultiline,
+  stableAnalyzeKeySource as stableAnalyzeKeySource2,
+  fnFingerprints
 } from "@nudojs/core";
-import { parse, extractDirectives, parseTypeValueExpr } from "@nudojs/parser";
+import { parse as parse5, extractDirectives, extractFileDirectives, parseTypeValueExpr } from "@nudojs/parser";
 import {
+  evaluate,
   evaluateFunction,
   evaluateFunctionFull,
+  memberMayExistOn,
+  setUsageSiteTag,
+  USAGE_SITE_MODULE,
   evaluateProgram,
   setModuleResolver,
   setCurrentFileDir,
@@ -20,44 +44,2266 @@ import {
   getUnreachableRanges,
   resetUnreachableRanges,
   setNodeTypeCollector,
-  setSampleCount
+  setCallCollector,
+  setUnknownCollector,
+  setProvenanceTracking,
+  setSampleCount,
+  setUnknownBuiltinHandler,
+  setEnvModules,
+  resetEnvModules,
+  setMockModules,
+  resetMockModules,
+  setCurrentSource,
+  loadEnvs as loadEnvs2,
+  preloadPathEnvs,
+  findProjectConfig,
+  resolveNpmNudo,
+  BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS
 } from "@nudojs/cli/evaluator";
+
+// src/mock-abs.ts
+import {
+  absFunction,
+  emptyEnv,
+  typeValueToAbs,
+  abs as makeAbs,
+  confJoin,
+  unknown as absUnknown,
+  litValue,
+  formatAbs,
+  getFnImpl,
+  typeValueToString
+} 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 = getFnImpl(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 = formatAbs(marked);
+  } catch {
+    retKey = "?";
+  }
+  return stampFingerprint(
+    markMockConf(absFunction(["...args"], { body, env: mockEnv })),
+    `ret=${retKey}`
+  );
+}
+function absArgMatches(declared, actual) {
+  if (!actual) return false;
+  const declaredAbs = typeValueToAbs(declared);
+  const av = litValue(actual);
+  const dv = litValue(declaredAbs);
+  if (dv !== void 0) {
+    return av !== void 0 && Object.is(av, dv);
+  }
+  if (declared.kind === "primitive") {
+    if (actual.shape.k === "prim") return actual.shape.type === declared.type;
+    if (av !== void 0) {
+      const t = typeof av;
+      return declared.type === "number" && t === "number" || declared.type === "string" && t === "string" || declared.type === "boolean" && t === "boolean" || declared.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(typeValueToAbs(c.returnValue))
+  }));
+  const dummyBody = {
+    type: "BlockStatement",
+    body: [{ type: "ReturnStatement", argument: null }]
+  };
+  const markedDefault = markMockConf(defaultReturn);
+  let defaultKey;
+  try {
+    defaultKey = formatAbs(markedDefault);
+  } catch {
+    defaultKey = "?";
+  }
+  const caseKey = cases.map(
+    (c) => `${c.args.map((a) => typeValueToString(a)).join(",")}->${typeValueToString(c.returnValue)}`
+  ).join("|");
+  return stampFingerprint(
+    markMockConf(
+      absFunction(["...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 && h.callsFakeImpl.kind === "function") {
+    const fn = h.callsFakeImpl;
+    const body = fn.body;
+    return stampFingerprint(
+      absFunction(fn.params, { body, async: false }),
+      `fake=${fn.params.join(",")}:${astContentKey(body)}`
+    );
+  }
+  let defaultReturn;
+  if (h.resolvedValue) {
+    defaultReturn = makeAbs(
+      { k: "eff", eff: "promise", inner: typeValueToAbs(h.resolvedValue) },
+      void 0,
+      void 0,
+      "path"
+    );
+  } else if (h.rejectedValue) {
+    defaultReturn = makeAbs({ k: "never" }, void 0, void 0, "exact");
+  } else if (h.returnValue) {
+    defaultReturn = typeValueToAbs(h.returnValue);
+  } else if (h.onFirstCallValue) {
+    defaultReturn = typeValueToAbs(h.onFirstCallValue);
+  } else {
+    defaultReturn = absUnknown;
+  }
+  return dispatchMockFn(defaultReturn, h.withArgsCases);
+}
+function absFromSinon(sinonExpr) {
+  if (sinonExpr.resolvedValue) {
+    return constantMockFn(
+      makeAbs(
+        { k: "eff", eff: "promise", inner: typeValueToAbs(sinonExpr.resolvedValue) },
+        void 0,
+        void 0,
+        "path"
+      )
+    );
+  }
+  if (sinonExpr.rejectedValue) {
+    return constantMockFn(makeAbs({ k: "never" }, void 0, void 0, "exact"));
+  }
+  if (sinonExpr.returnValue) {
+    return constantMockFn(typeValueToAbs(sinonExpr.returnValue));
+  }
+  return constantMockFn(absUnknown);
+}
+function mockSeedsToAbsMocks(seeds) {
+  const out = { ...seeds.seedVars };
+  for (const [name, fn] of Object.entries(seeds.seedFns)) {
+    out[name] = absFunction(fn.params, { body: fn.body, async: fn.async ?? false });
+  }
+  return out;
+}
+function mockDirectivesToAbsSeeds(functions) {
+  const seedVars = {};
+  const seedFns = {};
+  for (const fn of functions) {
+    for (const d of fn.directives) {
+      if (d.kind !== "mock") 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));
+      }
+    }
+  }
+  return { seedVars, seedFns };
+}
+
+// src/harvest-auto.ts
+import { parse as parse2 } from "@nudojs/parser";
+
+// src/static-imports.ts
+import { parse } from "@nudojs/parser";
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { generalizeFromAst } from "@nudojs/core";
+function resolveRelative(fromFile, spec) {
+  if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
+  const base = resolve(dirname(fromFile), spec);
+  for (const cand of [
+    base,
+    base + ".js",
+    base + ".cjs",
+    base + ".mjs",
+    base + ".ts",
+    base + ".mts",
+    base + ".cts",
+    join(base, "index.js"),
+    join(base, "index.cjs"),
+    join(base, "index.mjs"),
+    join(base, "index.ts")
+  ]) {
+    if (existsSync(cand)) return cand;
+  }
+  return void 0;
+}
+function collectDependencySpecs(ast) {
+  const specs = [];
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ImportDeclaration") {
+      specs.push(stmt.source.value);
+    }
+    if (stmt.type === "ExportNamedDeclaration" && stmt.source) {
+      specs.push(stmt.source.value);
+    }
+    if (stmt.type === "ExportAllDeclaration" && stmt.source) {
+      specs.push(stmt.source.value);
+    }
+    collectRequires(stmt, specs);
+  }
+  return specs;
+}
+function collectRequires(node, out) {
+  const visit = (n) => {
+    if (!n || typeof n !== "object") return;
+    const obj = n;
+    if (obj.type === "CallExpression" && obj.callee?.type === "Identifier" && obj.callee.name === "require" && obj.arguments?.[0]?.type === "StringLiteral") {
+      const spec = obj.arguments[0].value;
+      if (typeof spec === "string") out.push(spec);
+    }
+    for (const key of Object.keys(obj)) {
+      if (key === "loc" || key === "start" || key === "end") continue;
+      const v = obj[key];
+      if (Array.isArray(v)) v.forEach(visit);
+      else if (v && typeof v === "object") visit(v);
+    }
+  };
+  visit(node);
+}
+function analyzeExportsFromSource(filePath, source) {
+  const file = parse(source);
+  const named = /* @__PURE__ */ new Map();
+  let defaultExport;
+  const poly = /* @__PURE__ */ new Map();
+  for (const stmt of file.program.body) {
+    let decl = stmt;
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+    }
+    if (decl.type === "FunctionDeclaration" && decl.id) {
+      named.set(decl.id.name, decl.id.name);
+    }
+    if (decl.type === "VariableDeclaration") {
+      for (const d of decl.declarations) {
+        if (d.id.type === "Identifier") named.set(d.id.name, d.id.name);
+      }
+    }
+    if (decl.type === "ClassDeclaration" && decl.id) {
+      named.set(decl.id.name, decl.id.name);
+    }
+    if (stmt.type === "ExportDefaultDeclaration") {
+      const d = stmt.declaration;
+      if (d.type === "FunctionDeclaration" && d.id) defaultExport = d.id.name;
+      if (d.type === "Identifier") defaultExport = d.name;
+    }
+    collectCjsExports(stmt, named, (n) => {
+      defaultExport = n;
+    });
+  }
+  for (const name of named.values()) {
+    const g = generalizeFromAst(name, source);
+    if (g) poly.set(name, g);
+  }
+  if (defaultExport) {
+    const g = generalizeFromAst(defaultExport, source);
+    if (g) poly.set("default", g);
+  }
+  return { path: filePath, named, defaultExport, source, poly };
+}
+function collectCjsExports(stmt, named, setDefault) {
+  const visit = (n) => {
+    if (!n || typeof n !== "object") return;
+    const obj = n;
+    if (obj.type !== "AssignmentExpression") {
+      for (const key of Object.keys(obj)) {
+        if (key === "loc" || key === "start" || key === "end") continue;
+        const v = obj[key];
+        if (Array.isArray(v)) v.forEach(visit);
+        else if (v && typeof v === "object") visit(v);
+      }
+      return;
+    }
+    const left = obj.left;
+    const right = obj.right;
+    if (left?.type === "MemberExpression" && left.object?.type === "Identifier" && left.object.name === "exports" && left.property?.type === "Identifier" && left.property.name) {
+      named.set(left.property.name, left.property.name);
+    }
+    if (left?.type === "MemberExpression" && left.object?.type === "Identifier" && left.object.name === "module" && left.property?.type === "Identifier" && left.property.name === "exports") {
+      if (right?.type === "Identifier" && typeof right.name === "string") {
+        named.set(right.name, right.name);
+        setDefault(right.name);
+      }
+      if (right?.type === "ObjectExpression") {
+        const props = right.properties;
+        for (const p of props) {
+          if (p.type !== "ObjectProperty") continue;
+          const key = p.key;
+          const val = p.value;
+          const exportName = key?.type === "Identifier" ? key.name : key?.type === "StringLiteral" ? key.value : void 0;
+          if (exportName) named.set(exportName, exportName);
+          if (val?.type === "Identifier" && val.name && exportName) {
+          }
+        }
+      }
+    }
+  };
+  visit(stmt);
+}
+function collectStaticImports(entryFile, maxDepth = 8) {
+  const graph = /* @__PURE__ */ new Map();
+  const queue = [
+    { file: resolve(entryFile), depth: 0 }
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const { file, depth } = queue.shift();
+    if (seen.has(file) || depth > maxDepth) continue;
+    seen.add(file);
+    if (!existsSync(file)) continue;
+    const source = readFileSync(file, "utf8");
+    const mod = analyzeExportsFromSource(file, source);
+    graph.set(file, mod);
+    const ast = parse(source);
+    for (const spec of collectDependencySpecs(ast)) {
+      const resolved = resolveRelative(file, spec);
+      if (resolved) queue.push({ file: resolved, depth: depth + 1 });
+    }
+  }
+  return graph;
+}
+
+// src/harvest-package.ts
+import { existsSync as existsSync2, readdirSync, statSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2, resolve as resolve2, dirname as dirname2, basename } from "path";
+import { harvestDts } from "@nudojs/harvester";
+import { typeValueToString as typeValueToString2 } from "@nudojs/core";
+function resolvePackageRoot(pkg, fromDir = process.cwd()) {
+  let dir = resolve2(fromDir);
+  const bare = pkg.replace(/^@/, "").replace(/\//g, "__");
+  for (let i = 0; i < 8; i++) {
+    const typesPath = join2(dir, "node_modules", "@types", bare);
+    if (existsSync2(typesPath)) return typesPath;
+    const pkgPath = join2(dir, "node_modules", pkg);
+    if (existsSync2(pkgPath)) return pkgPath;
+    const parent = resolve2(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "test", "tests", "docs", "doc", "examples", "__tests__"]);
+var MAX_DTS_BYTES = 15e5;
+function dtsPriority(p, root) {
+  const base = basename(p);
+  const rel = p.slice(root.length);
+  if (base === "index.d.ts") return 0;
+  if (base === "index.d.mts") return 1;
+  if (rel.includes("/types/") && base === "index.d.ts") return 2;
+  if (base.endsWith(".d.ts") && !base.includes(".")) return 3;
+  return 10;
+}
+function collectDtsFiles(root, maxFiles = 8) {
+  const out = [];
+  const walk = (dir) => {
+    if (out.length >= maxFiles * 3) return;
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (out.length >= maxFiles * 3) return;
+      if (SKIP_DIRS.has(name)) continue;
+      const p = join2(dir, name);
+      let st;
+      try {
+        st = statSync(p);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) walk(p);
+      else if (name.endsWith(".d.ts") && !name.endsWith(".d.ts.map")) {
+        if (st.size > MAX_DTS_BYTES) continue;
+        out.push(p);
+      }
+    }
+  };
+  walk(root);
+  out.sort((a, b) => dtsPriority(a, root) - dtsPriority(b, root) || a.length - b.length);
+  return out.slice(0, maxFiles);
+}
+function entryDtsFromPackageJson(root) {
+  const pj = join2(root, "package.json");
+  if (!existsSync2(pj)) return void 0;
+  try {
+    const raw = JSON.parse(readFileSync2(pj, "utf8"));
+    const entry = raw.types ?? raw.typings;
+    if (typeof entry === "string" && entry.endsWith(".d.ts")) {
+      const p = resolve2(root, entry);
+      if (existsSync2(p)) {
+        const st = statSync(p);
+        if (st.size <= MAX_DTS_BYTES) return p;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function collectDtsFromEntry(entry, maxFiles = 200) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [entry];
+  const REFERENCE_PATH_REGEX = /<reference\s+path=["']([^"']+)["']\s*\/>/g;
+  const RELATIVE_FROM_REGEX = /\bfrom\s+["'](\.[^"']+)["']/g;
+  while (queue.length > 0 && files.length < maxFiles) {
+    const current = queue.shift();
+    if (seen.has(current) || !existsSync2(current)) continue;
+    seen.add(current);
+    if (!current.endsWith(".d.ts")) continue;
+    files.push(current);
+    let text;
+    try {
+      text = readFileSync2(current, "utf-8");
+    } catch {
+      continue;
+    }
+    const dir = dirname2(current);
+    for (const match of text.matchAll(REFERENCE_PATH_REGEX)) {
+      queue.push(resolve2(dir, match[1]));
+    }
+    for (const match of text.matchAll(RELATIVE_FROM_REGEX)) {
+      const base = resolve2(dir, match[1]);
+      for (const candidate of [`${base}.d.ts`, join2(base, "index.d.ts")]) {
+        if (existsSync2(candidate)) {
+          queue.push(candidate);
+          break;
+        }
+      }
+    }
+  }
+  return files;
+}
+function harvestPackage(pkg, fromDir, maxFiles = 8) {
+  const root = resolvePackageRoot(pkg, fromDir);
+  if (!root) return { error: `package not found: ${pkg}` };
+  const entry = entryDtsFromPackageJson(root) ?? join2(root, "index.d.ts");
+  let dtsFiles = existsSync2(entry) ? collectDtsFromEntry(entry, maxFiles) : [];
+  if (dtsFiles.length === 0) {
+    const collected = collectDtsFiles(root, maxFiles);
+    dtsFiles = entry && existsSync2(entry) && !collected.includes(entry) ? [entry, ...collected.filter((f) => f !== entry)].slice(0, maxFiles) : collected;
+  }
+  if (dtsFiles.length === 0) {
+    return { error: `no .d.ts under ${root}` };
+  }
+  const env = harvestDts(dtsFiles);
+  return { pkg, root, dtsFiles, env };
+}
+function formatHarvestSummary(h) {
+  const lines = [];
+  lines.push(`${h.pkg}: ${h.dtsFiles.length} d.ts, ${h.env.stats.symbols} symbols`);
+  const mods = Object.keys(h.env.modules);
+  for (const m of mods.slice(0, 5)) {
+    const exports = h.env.modules[m];
+    const names = Object.keys(exports).slice(0, 12);
+    lines.push(`  module "${m}": ${names.join(", ")}${Object.keys(exports).length > 12 ? "\u2026" : ""}`);
+  }
+  if (mods.length > 5) lines.push(`  \u2026 ${mods.length - 5} more modules`);
+  return lines.join("\n");
+}
+function lookupHarvested(h, moduleName, exportName) {
+  const mod = h.env.modules[moduleName];
+  const tv = mod?.[exportName] ?? h.env.globals[exportName];
+  if (!tv) return void 0;
+  return typeValueToString2(tv);
+}
+
+// src/harvest-auto.ts
+function barePackageName(spec) {
+  if (!spec) return void 0;
+  if (spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("node:")) return void 0;
+  const parts = spec.split("/");
+  if (spec.startsWith("@")) {
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : void 0;
+  }
+  return parts[0];
+}
+function collectBarePackages(source) {
+  try {
+    const ast = parse2(source);
+    const names = /* @__PURE__ */ new Set();
+    for (const spec of collectDependencySpecs(ast)) {
+      const pkg = barePackageName(spec);
+      if (pkg) names.add(pkg);
+    }
+    return [...names];
+  } catch {
+    return [];
+  }
+}
+var harvestCache = /* @__PURE__ */ new Map();
+function harvestPackageCached(pkg, fromDir) {
+  const key = `${fromDir}::${pkg}`;
+  if (harvestCache.has(key)) return harvestCache.get(key);
+  let result = null;
+  try {
+    const h = harvestPackage(pkg, fromDir);
+    if (!("error" in h)) result = h;
+  } catch {
+    result = null;
+  }
+  harvestCache.set(key, result);
+  return result;
+}
+function clearHarvestCache() {
+  harvestCache.clear();
+}
+function autoHarvestModules(source, fromDir) {
+  const packages = collectBarePackages(source);
+  if (packages.length === 0) return {};
+  const modules = {};
+  for (const pkg of packages) {
+    const h = harvestPackageCached(pkg, fromDir);
+    if (!h) continue;
+    for (const [mod, exports] of Object.entries(h.env.modules)) {
+      modules[mod] = exports;
+      if (!modules[pkg]) modules[pkg] = exports;
+      const base = mod.replace(/^@types\//, "").replace(/\\/g, "/");
+      if (base && !modules[base]) modules[base] = exports;
+    }
+    for (const [k, v] of Object.entries(h.env.globals)) {
+      if (!modules[pkg]) modules[pkg] = {};
+      if (modules[pkg][k] === void 0) modules[pkg][k] = v;
+    }
+  }
+  return modules;
+}
+
+// src/abs-modules-graph.ts
+import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { dirname as dirname4, resolve as resolve3 } from "path";
+import { parse as parse3 } from "@nudojs/parser";
+import {
+  evalProgramAbs,
+  collectAbsExports,
+  absFunction as absFunction3
+} from "@nudojs/core";
+
+// src/harvest-to-abs.ts
+import {
+  T,
+  typeValueToAbs as typeValueToAbs2,
+  confJoin as confJoin2,
+  getFnSig,
+  absFunction as absFunction2
+} from "@nudojs/core";
+import { dirname as dirname3 } from "path";
+function markMockConf2(a) {
+  a.conf = confJoin2(a.conf, "mock");
+  return a;
+}
+function harvestedValueToAbs(tv) {
+  if (!tv) return markMockConf2(typeValueToAbs2(T.unknown));
+  const sig = getFnSig(tv);
+  if (sig) {
+    const ret = markMockConf2(typeValueToAbs2(sig.returnType));
+    const params = tv.kind === "function" && tv.params?.length ? tv.params : sig.paramTypes.map((_, i) => `_arg${i}`);
+    const dummyBody = {
+      type: "BlockStatement",
+      body: [],
+      directives: []
+    };
+    return markMockConf2(
+      absFunction2(params, {
+        body: dummyBody,
+        apply: () => ret
+      })
+    );
+  }
+  return markMockConf2(typeValueToAbs2(tv));
+}
+function harvestToAbsModules(pkg, fromDir) {
+  const h = harvestPackageCached(pkg, fromDir);
+  if (!h) return {};
+  return packageHarvestToAbsModules(pkg, h);
+}
+function packageHarvestToAbsModules(pkg, h) {
+  const out = {};
+  const convertRecord = (rec) => {
+    const named = {};
+    for (const [k, v] of Object.entries(rec)) {
+      named[k] = harvestedValueToAbs(v);
+    }
+    return named;
+  };
+  const register = (key, exports) => {
+    if (!out[key]) out[key] = exports;
+  };
+  for (const [mod, rec] of Object.entries(h.env.modules)) {
+    const named = convertRecord(rec);
+    const exports = { named };
+    const def = rec["default"];
+    if (def) exports.default = harvestedValueToAbs(def);
+    register(mod, exports);
+    register(pkg, exports);
+    const stripped = mod.replace(/^@types\//, "").replace(/\\/g, "/");
+    if (stripped) register(stripped, exports);
+    const base = stripped.split("/").filter(Boolean).pop();
+    if (base && base !== pkg) register(base, exports);
+  }
+  const globalNamed = convertRecord(h.env.globals);
+  if (Object.keys(globalNamed).length > 0) {
+    const existing = out[pkg];
+    if (existing) {
+      out[pkg] = { named: { ...globalNamed, ...existing.named }, default: existing.default };
+    } else {
+      out[pkg] = { named: globalNamed };
+    }
+  }
+  return out;
+}
+function bareSpecToAbsModules(spec, fromFile) {
+  if (!spec || spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("node:")) {
+    return void 0;
+  }
+  const parts = spec.split("/");
+  const pkg = spec.startsWith("@") ? parts.length >= 2 ? `${parts[0]}/${parts[1]}` : void 0 : parts[0];
+  if (!pkg) return void 0;
+  const table = harvestToAbsModules(pkg, dirname3(fromFile));
+  return table[spec] ?? table[pkg];
+}
+
+// src/abs-modules-graph.ts
+function defaultAbsLoadModule(spec, fromFile) {
+  if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
+  try {
+    const p = resolve3(dirname4(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(dirname4(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 = parse3(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?.type === "Identifier" && o.callee.name === "require" && o.arguments?.[0]?.type === "StringLiteral") {
+      const spec = o.arguments[0].value;
+      if (typeof spec === "string") 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 bare = bareSpecToAbsModules(spec, fromFile);
+      if (bare) modules[spec] = bare;
+    }
+  }
+  void maxDepth;
+  return modules;
+}
+var absModuleCache = /* @__PURE__ */ new Map();
+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 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 = statSync2(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);
+    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;
+    try {
+      const file = parse3(source);
+      const { env } = evalProgramAbs(source, { file, modules: modules2 });
+      exports = collectAbsExports(file, env, modules2);
+    } catch {
+      exports = { named: {} };
+    } finally {
+      loading.pop();
+    }
+    cache.set(absPath, exports);
+    let fingerprint;
+    try {
+      const st = statSync2(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 evalProgramAbsWithModules(source, entryFile, opts = {}) {
+  const { modules } = evalAbsModuleGraph(source, entryFile, opts);
+  return evalProgramAbs(source, {
+    file: opts.file,
+    modules,
+    seedVars: opts.seedVars,
+    seedFns: opts.seedFns
+  });
+}
+function collectAbsBindingsFromGraph(source, filePath, opts = {}) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const { env } = evalProgramAbsWithModules(source, filePath, opts);
+    for (const [k, v] of env.vars) {
+      out.set(k, v);
+    }
+    for (const [name, impl] of env.fns) {
+      if (!out.has(name)) {
+        out.set(
+          name,
+          absFunction3(impl.params, { body: impl.body, async: impl.async, env })
+        );
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+
+// src/bpath-run.ts
+import {
+  runTranspiled,
+  callTranspiledExport,
+  callTranspiledExportFull,
+  setBCallCollector,
+  setMemberDiagCollector,
+  setAbsTruncationCollector,
+  typeValueToAbs as typeValueToAbs4,
+  createEnvironment,
+  stableAnalyzeKeySource,
+  formatAbs as formatAbs2,
+  hashSource,
+  getFnImpl as getFnImpl2
+} from "@nudojs/core";
+import { parse as parse4, extractInlineDirectives } from "@nudojs/parser";
+import { loadEnvs } from "@nudojs/cli/evaluator";
+
+// src/env-to-abs.ts
+import {
+  typeValueToAbs as typeValueToAbs3,
+  absToTypeValue,
+  getFnSig as getFnSig2,
+  absFunction as absFunction4,
+  objOf
+} from "@nudojs/core";
+function envValueToAbs(tv) {
+  if (!tv) return typeValueToAbs3({ kind: "unknown" });
+  if (tv.kind === "function") {
+    const sig = getFnSig2(tv);
+    if (sig?.impl) {
+      const params = tv.kind === "function" && tv.params?.length ? tv.params : sig.paramTypes.map((_, i) => `_arg${i}`);
+      const dummyBody = {
+        type: "BlockStatement",
+        body: [],
+        directives: []
+      };
+      const impl = sig.impl;
+      return absFunction4(params, {
+        body: dummyBody,
+        apply: (args) => {
+          const tvArgs = args.map((a) => absToTypeValue(a));
+          try {
+            const r = impl(tvArgs);
+            if (!r) return typeValueToAbs3(sig.returnType);
+            return envValueToAbs(r);
+          } catch {
+            return typeValueToAbs3(sig.returnType);
+          }
+        }
+      });
+    }
+  }
+  if (tv.kind === "object") {
+    const slots = {};
+    for (const [k, v] of Object.entries(tv.properties)) {
+      slots[k] = { value: envValueToAbs(v) };
+    }
+    return objOf(slots);
+  }
+  return typeValueToAbs3(tv);
+}
+
+// src/analysis-file-cache.ts
+var analysisByFile = /* @__PURE__ */ new Map();
+var MAX_ANALYSIS_FILE_CACHE = 64;
+function clearAnalysisFileCache() {
+  analysisByFile.clear();
+}
+function getAnalysisFileCacheSize() {
+  return analysisByFile.size;
+}
+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) {
+  if (analysisByFile.size >= MAX_ANALYSIS_FILE_CACHE && !analysisByFile.has(filePath)) {
+    const oldest = analysisByFile.keys().next().value;
+    if (oldest !== void 0) 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();
+var MAX_FN_ANALYSIS_CACHE = 1024;
+function clearFnAnalysisCache() {
+  fnAnalysisCache.clear();
+}
+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) {
+  if (fnAnalysisCache.size >= MAX_FN_ANALYSIS_CACHE && !fnAnalysisCache.has(key)) {
+    const oldest = fnAnalysisCache.keys().next().value;
+    if (oldest !== void 0) 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, typeValueToString5) {
+  return directives.map((d) => {
+    if (d.kind === "case") {
+      const args = (d.args ?? []).map((a) => typeValueToString5(a)).join(",");
+      return `c:${d.name ?? ""}:${args}`;
+    }
+    return d.kind;
+  }).join("|");
+}
+
+// src/bpath-run.ts
+function absSeedPart(a) {
+  const impl = getFnImpl2(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=${formatAbs2(ret)}`;
+      } catch {
+        return "ret=?";
+      }
+    }
+    if (impl?.apply) return "apply";
+  }
+  try {
+    return formatAbs2(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 hashSource(parts.join(";"));
+}
+function collectEnvGlobals(envNames) {
+  if (envNames.length === 0) return {};
+  const env = createEnvironment();
+  try {
+    loadEnvs(envNames, env);
+  } catch {
+    return {};
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(env.getOwnBindings())) {
+    out[k] = envValueToAbs(v);
+  }
+  return out;
+}
+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, exports] of Object.entries(mods)) {
+    const named = {};
+    for (const [k, v] of Object.entries(exports)) {
+      named[k] = envValueToAbs(v);
+    }
+    out[spec] = { 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] = typeValueToAbs4(d.typeExpr);
+          } else if (d.kind === "as" && loc) {
+            const varName = `__as${i++}`;
+            asTargets.push({
+              varName,
+              stmtStart: loc.start.line,
+              stmtEnd: loc.end.line
+            });
+            asValues[varName] = typeValueToAbs4(d.typeExpr);
+          }
+        }
+        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;
+  if (/(^|[^.\w$])this\s*\./.test(source) && !/\bclass\s+/.test(source)) return false;
+  return true;
+}
+var bRunByFile = /* @__PURE__ */ new Map();
+var MAX_B_RUN_CACHE = 32;
+function clearBPathCache() {
+  bRunByFile.clear();
+  clearAnalysisFileCache();
+  clearFnAnalysisCache();
+}
+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, value) {
+  if (bRunByFile.size >= MAX_B_RUN_CACHE && !bRunByFile.has(filePath)) {
+    const oldest = bRunByFile.keys().next().value;
+    if (oldest !== void 0) bRunByFile.delete(oldest);
+  }
+  bRunByFile.set(filePath, { stableSource, mode, envKey, mockKey, value });
+}
+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 = stableAnalyzeKeySource(source);
+  const cached = bRunByFile.get(filePath);
+  if (cached && cached.stableSource === stable && cached.mode === mode && cached.envKey === envKey && cached.mockKey === mockKey) {
+    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 = [];
+    setMemberDiagCollector((d) => memberDiags.push(d));
+    setAbsTruncationCollector((label) => truncated.add(label));
+    setBCallCollector((r) => topCalls.push(r));
+    try {
+      const { modules: graphMods, issues } = evalAbsModuleGraph(source, filePath);
+      const envMods = collectEnvModules(opts.envNames ?? []);
+      const modules = { ...envMods, ...graphMods };
+      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
+      });
+      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(null);
+      setAbsTruncationCollector(null);
+      setBCallCollector(null);
+    }
+  } catch {
+    out = null;
+  }
+  bPathCacheSet(filePath, stable, mode, envKey, mockKey, 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 = [...run.calls ?? []];
+  const memberDiags = [];
+  if (opts.collectCalls) {
+    setBCallCollector((r) => collected.push(r));
+  }
+  if (opts.collectMemberDiags ?? true) {
+    setMemberDiagCollector((d) => memberDiags.push(d));
+  }
+  try {
+    const full = callTranspiledExportFull(run.exports, fnName, args);
+    const all = [...run.memberDiags ?? [], ...memberDiags];
+    return {
+      ...full,
+      calls: opts.collectCalls || run.calls?.length ? collected : void 0,
+      memberDiags: all.length ? all : void 0,
+      moduleIssues: run.moduleIssues,
+      truncatedFns: run.truncatedFns
+    };
+  } finally {
+    if (opts.collectCalls) setBCallCollector(null);
+    setMemberDiagCollector(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/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;
+      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 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" && n.callee?.type === "Identifier") {
+    flag(n.callee, n.callee.name);
+  } else if (n.type === "Identifier" && typeof n.name === "string" && 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/analyzer.ts
+import { setAbsTruncationCollector as setAbsTruncationCollector2 } from "@nudojs/core";
 function resolveModule(source, fromDir) {
   const extensions = [".js", ".ts", ".mjs"];
-  const basePath = resolve(fromDir, source);
+  const nudoPath = resolveNpmNudo(source, fromDir);
+  if (nudoPath) {
+    const src = readFileSync4(nudoPath, "utf-8");
+    return { ast: parse5(src), filePath: nudoPath };
+  }
+  const basePath = resolve4(fromDir, source);
   for (const ext of ["", ...extensions]) {
     const candidate = basePath + ext;
-    if (existsSync(candidate)) {
-      const src = readFileSync(candidate, "utf-8");
-      return { ast: parse(src), filePath: candidate };
+    if (!existsSync3(candidate)) continue;
+    if (statSync3(candidate).isDirectory()) {
+      let entry = null;
+      const pkgPath = resolve4(candidate, "package.json");
+      if (existsSync3(pkgPath)) {
+        try {
+          const main = JSON.parse(readFileSync4(pkgPath, "utf-8")).main;
+          if (typeof main === "string") {
+            for (const e of ["", ...extensions]) {
+              const p = resolve4(candidate, main + e);
+              if (existsSync3(p) && statSync3(p).isFile()) {
+                entry = p;
+                break;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      if (!entry) {
+        for (const e of ["", ...extensions]) {
+          const p = resolve4(candidate, "index" + e);
+          if (existsSync3(p) && statSync3(p).isFile()) {
+            entry = p;
+            break;
+          }
+        }
+      }
+      if (!entry) return null;
+      const src2 = readFileSync4(entry, "utf-8");
+      return { ast: parse5(src2), filePath: entry };
+    }
+    if (candidate.endsWith(".json")) {
+      try {
+        return { ast: parse5("module.exports = undefined;"), filePath: candidate, json: JSON.parse(readFileSync4(candidate, "utf-8")) };
+      } catch {
+        return null;
+      }
+    }
+    const src = readFileSync4(candidate, "utf-8");
+    return { ast: parse5(src), filePath: candidate };
+  }
+  return null;
+}
+function resolveImportPath(specifier, fromDir) {
+  const basePath = resolve4(fromDir, specifier);
+  for (const ext of ["", ".js", ".ts", ".mjs"]) {
+    const candidate = basePath + ext;
+    if (existsSync3(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 = statSync3(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 = parse5(readFileSync4(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, dirname5(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);
   }
-  return null;
+  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;
 }
-function applyMocks(directives, env, filePath) {
+function applyMocks(directives, env, filePath, diagnostics) {
   for (const d of directives) {
     if (d.kind !== "mock") continue;
-    if (d.expression) {
+    if (d.arrowFn) {
+      const fnType = T2.fn(d.arrowFn.params, d.arrowFn.body, env);
+      fnType._paramPatterns = d.arrowFn.paramPatterns;
+      env.bind(d.name, fnType);
+    } else if (d.nudoMock) {
+      const typeVal = mockHelperToTypeValue(d.nudoMock, env);
+      env.bind(d.name, typeVal);
+    } else if (d.sinonExpr) {
+      const sinonType = createSinonTypeValue(d.sinonExpr, env);
+      env.bind(d.name, sinonType);
+    } else if (d.expression) {
+      const expr = d.expression.trim();
+      if (expr.includes("(") && expr.includes(")") && !expr.startsWith("T.")) {
+        diagnostics.push({
+          range: { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } },
+          severity: "warning",
+          message: `Mock expression "${expr}" could not be parsed as a known pattern`,
+          code: "nudo:mock-invalid",
+          suggestions: [
+            "Supported formats: stub(), stub().returns(value), spy(), mock()",
+            "Arrow functions: (args) => expression or (args) => { statements; return value; }"
+          ]
+        });
+      }
       env.bind(d.name, parseTypeValueExpr(d.expression));
     } else if (d.fromPath) {
-      const mockPath = resolve(dirname(filePath), d.fromPath);
-      const mockSource = readFileSync(mockPath, "utf-8");
-      const mockAst = parse(mockSource);
-      const mockEnv = createEnvironment();
+      const mockPath = resolve4(dirname5(filePath), d.fromPath);
+      const mockSource = readFileSync4(mockPath, "utf-8");
+      const mockAst = parse5(mockSource);
+      const mockEnv = createEnvironment2();
       evaluateProgram(mockAst, mockEnv);
       const mockVal = mockEnv.lookup(d.name);
       env.bind(d.name, mockVal);
     }
   }
 }
+function createSinonTypeValue(sinonExpr, env) {
+  if (sinonExpr.type === "stub" || sinonExpr.type === "spy") {
+    const body = { type: "BlockStatement", body: [] };
+    const fn = T2.fn(["...args"], body, env);
+    if (sinonExpr.returnValue) {
+      fn._directReturn = sinonExpr.returnValue;
+    } else if (sinonExpr.resolvedValue) {
+      fn._directReturn = T2.promise(sinonExpr.resolvedValue);
+    } else if (sinonExpr.rejectedValue) {
+      fn._directReturn = T2.never;
+    } else {
+      fn._directReturn = T2.unknown;
+    }
+    return fn;
+  }
+  return T2.unknown;
+}
 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 analyzeFile(filePath, source, activeCases) {
-  const ast = parse(source);
+function extractParamNames(node) {
+  const fn = node.type === "ExportDefaultDeclaration" ? node.declaration : node;
+  if (fn.type === "FunctionDeclaration" || fn.type === "FunctionExpression" || fn.type === "ArrowFunctionExpression") {
+    return fn.params.map((p) => {
+      if (p.type === "Identifier") return p.name;
+      if (p.type === "AssignmentPattern" && p.left.type === "Identifier") return p.left.name;
+      if (p.type === "RestElement" && p.argument.type === "Identifier") return `...${p.argument.name}`;
+      return "_";
+    });
+  }
+  if (fn.type === "VariableDeclaration") {
+    const decl = fn.declarations[0];
+    if (decl.init?.type === "FunctionExpression" || decl.init?.type === "ArrowFunctionExpression") {
+      return decl.init.params.map((p) => {
+        if (p.type === "Identifier") return p.name;
+        if (p.type === "AssignmentPattern" && p.left.type === "Identifier") return p.left.name;
+        if (p.type === "RestElement" && p.argument.type === "Identifier") return `...${p.argument.name}`;
+        return "_";
+      });
+    }
+  }
+  return [];
+}
+function resolveFunctionNode(node) {
+  if (node.type === "ExportNamedDeclaration" && node.declaration) return resolveFunctionNode(node.declaration);
+  if (node.type === "ExportDefaultDeclaration") return resolveFunctionNode(node.declaration);
+  if (node.type === "VariableDeclaration") {
+    const init = node.declarations[0]?.init;
+    if (init && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")) return init;
+  }
+  return node;
+}
+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 && node.object?.type === "Identifier" && node.object.name === "module" && node.property?.type === "Identifier" && node.property.name === "exports";
+}
+function memberPropertyKey(member) {
+  if (member.type !== "MemberExpression" || member.computed) return null;
+  const prop = member.property;
+  if (prop?.type === "Identifier") return prop.name;
+  if (prop?.type === "StringLiteral") return String(prop.value);
+  return null;
+}
+function deepestAssignValue(expr) {
+  let cur = expr;
+  while (cur?.type === "AssignmentExpression") cur = cur.right;
+  return cur ?? null;
+}
+function assignmentChainName(expr) {
+  let cur = expr;
+  while (cur?.type === "AssignmentExpression") {
+    const target = cur.left;
+    if (target.type === "Identifier") return target.name;
+    if (target.type === "MemberExpression") {
+      if (isModuleExportsTarget(target)) {
+        cur = cur.right;
+        continue;
+      }
+      return memberPropertyKey(target);
+    }
+    return null;
+  }
+  return null;
+}
+function collectTopLevelFunctions(ast) {
+  const results = [];
+  if (ast.type !== "File") return results;
+  for (const stmt of ast.program.body) {
+    const decl = resolveFunctionNode(stmt);
+    if (decl.type === "FunctionDeclaration" && decl.id) {
+      results.push({ name: decl.id.name, node: decl, stmt, noDeclaration: false });
+      continue;
+    }
+    if (stmt.type === "VariableDeclaration") {
+      for (const declarator of stmt.declarations) {
+        if (declarator.id?.type === "Identifier" && isFnExprValue(declarator.init)) {
+          results.push({ name: declarator.id.name, node: declarator.init, stmt, noDeclaration: true });
+        }
+      }
+      continue;
+    }
+    if (stmt.type === "ExpressionStatement" && stmt.expression?.type === "AssignmentExpression") {
+      const expr = stmt.expression;
+      const fn = deepestAssignValue(expr);
+      if (isFnExprValue(fn)) {
+        const name = namedFnExprId(fn) ?? assignmentChainName(expr) ?? "default";
+        results.push({ name, node: fn, stmt, noDeclaration: true });
+      }
+    }
+  }
+  return results;
+}
+function findSingleModuleExportsFunction(ast) {
+  if (ast.type !== "File") return null;
+  let found = null;
+  for (const stmt of ast.program.body) {
+    if (stmt.type !== "ExpressionStatement") continue;
+    const expr = stmt.expression;
+    if (expr?.type !== "AssignmentExpression") continue;
+    const fn = deepestAssignValue(expr);
+    if (!isFnExprValue(fn)) continue;
+    let targetsModuleExports = false;
+    let cur = expr;
+    while (cur?.type === "AssignmentExpression") {
+      if (isModuleExportsTarget(cur.left)) {
+        targetsModuleExports = true;
+        break;
+      }
+      cur = cur.right;
+    }
+    if (!targetsModuleExports) continue;
+    if (found) return null;
+    found = fn;
+  }
+  return found;
+}
+function typeStructureKey(tv) {
+  return typeStructureKeyUncached(tv, /* @__PURE__ */ new Set());
+}
+function typeStructureKeyUncached(tv, seen) {
+  const enter = (inner) => {
+    if (inner && typeof inner === "object") {
+      if (seen.has(inner)) return "\xABcycle\xBB";
+      seen.add(inner);
+      const out = typeStructureKeyUncached(inner, seen);
+      seen.delete(inner);
+      return out;
+    }
+    return typeStructureKeyUncached(inner, seen);
+  };
+  switch (tv.kind) {
+    case "literal":
+      return `lit(${typeof tv.value}:${String(tv.value)})`;
+    case "primitive":
+      return `prim(${tv.type})`;
+    case "array":
+      return `arr(${enter(tv.element)})`;
+    case "tuple":
+      return `tup(${tv.elements.map(enter).join(",")})`;
+    case "object":
+      return `obj(${Object.keys(tv.properties).sort().map((k) => `${k}:${enter(tv.properties[k])}`).join(",")})`;
+    case "function":
+      return `fn(${tv.params.join(",")})`;
+    case "promise":
+      return `prom(${enter(tv.value)})`;
+    case "instance":
+      return `inst(${tv.className})`;
+    case "refined":
+      return `ref(${enter(tv.base)})`;
+    case "union":
+      return `uni(${tv.members.map(enter).sort().join("|")})`;
+    default:
+      return tv.kind;
+  }
+}
+var MAX_PRECISE_CALLSITE_CASES = 3;
+var COLLAPSE_LITERAL_THRESHOLD = 4;
+function widenType(tv) {
+  if (tv.kind === "union") return simplifyUnion(tv.members.map(widenLiteral));
+  return widenLiteral(tv);
+}
+function dedupeCallRecords(records) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const rec of records) {
+    if (isOversizedRecord(rec)) continue;
+    const key = rec.argTypes.map(typeStructureKey).join(",") + "=>" + typeStructureKey(rec.resultType) + "!" + typeStructureKey(rec.throws);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(rec);
+  }
+  return out;
+}
+var MAX_RECORD_TYPE_NODES = 2e3;
+function typeNodeCount(tv, seen) {
+  if (tv === null || typeof tv !== "object") return 1;
+  if (seen.has(tv)) return 0;
+  seen.add(tv);
+  switch (tv.kind) {
+    case "array":
+      return 1 + typeNodeCount(tv.element, seen);
+    case "tuple":
+      return 1 + tv.elements.reduce((acc, e) => acc + typeNodeCount(e, seen), 0);
+    case "object": {
+      let n = 1;
+      for (const v of Object.values(tv.properties)) n += typeNodeCount(v, seen);
+      return n;
+    }
+    case "promise":
+      return 1 + typeNodeCount(tv.value, seen);
+    case "union":
+      return 1 + tv.members.reduce((acc, e) => acc + typeNodeCount(e, seen), 0);
+    case "refined":
+      return 1 + typeNodeCount(tv.base, seen);
+    default:
+      return 1;
+  }
+}
+function isOversizedRecord(rec) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const a of rec.argTypes) {
+    if (typeNodeCount(a, seen) > MAX_RECORD_TYPE_NODES) return true;
+  }
+  return typeNodeCount(rec.resultType, seen) > MAX_RECORD_TYPE_NODES;
+}
+function locFromCallLoc(loc) {
+  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) {
+  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.argTypes.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, MAX_PRECISE_CALLSITE_CASES);
+    for (const rec of precise) {
+      analysis.cases.push({
+        name: `call@L${rec.callLoc?.line ?? 0}`,
+        args: rec.argTypes,
+        result: rec.resultType,
+        throws: rec.throws,
+        source: "callsite"
+      });
+    }
+    const remaining = deduped.slice(MAX_PRECISE_CALLSITE_CASES);
+    if (remaining.length > 0) {
+      analysis.cases.push({
+        name: "call@symbolic",
+        args: Array.from(
+          { length: arity },
+          (_, i) => (
+            // 缺参按真实 JS 语义 widen 成 undefined 而非 unknown——可选参守卫
+            // （target || [] 等）对 unknown 全塌，对 undefined 正常走默认分支
+            widenType(simplifyUnion(remaining.map((rec) => rec.argTypes[i] ?? T2.undefined)))
+          )
+        ),
+        result: collapseLiteralUnion(simplifyUnion(remaining.map((r) => r.resultType)), COLLAPSE_LITERAL_THRESHOLD),
+        throws: simplifyUnion(remaining.map((r) => r.throws)),
+        source: "callsite",
+        aggregatedFrom: remaining.length
+      });
+    }
+    if (deduped.length > 1) {
+      analysis.combined = collapseLiteralUnion(
+        simplifyUnion(deduped.map((r) => r.resultType)),
+        COLLAPSE_LITERAL_THRESHOLD
+      );
+    } else {
+      analysis.combined = deduped[0].resultType;
+    }
+    out.push(analysis);
+  }
+  return out;
+}
+function receiverTypeToDisplay(tv) {
+  switch (tv.kind) {
+    case "literal": {
+      const v = tv.value;
+      if (v === null) return "null";
+      if (v === void 0) return "undefined";
+      return typeof v;
+    }
+    case "union":
+      return tv.members.map(receiverTypeToDisplay).join(" | ");
+    default:
+      return typeValueToString3(tv);
+  }
+}
+function receiverIsConcrete(tv) {
+  if (tv.kind === "unknown") return false;
+  if (tv.kind === "union") return tv.members.every((m) => m.kind !== "unknown");
+  return true;
+}
+function unknownRecordsToDiagnostics(records) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const r of records) {
+    const line = r.loc?.line ?? 0;
+    const column = r.loc?.column ?? 0;
+    const key = `${line}:${column}:${r.name}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const range = {
+      start: { line, column },
+      end: { line, column: column + r.name.length }
+    };
+    if (r.kind === "global") {
+      if (r.name.startsWith("recursion:")) {
+        out.push({
+          range,
+          severity: "warning",
+          message: `Recursive evaluation of '${r.name.slice("recursion:".length)}' was truncated (depth/size budget); result widened to unknown`,
+          code: "nudo:recursion-truncated"
+        });
+        continue;
+      }
+      if (r.name.startsWith("module-cycle:")) {
+        out.push({
+          range,
+          severity: "warning",
+          message: r.reason ?? "Circular module load detected",
+          code: "nudo:module-cycle"
+        });
+        continue;
+      }
+      if (r.name.startsWith("module-depth:")) {
+        out.push({
+          range,
+          severity: "warning",
+          message: r.reason ?? "Module load chain too deep",
+          code: "nudo:module-depth"
+        });
+        continue;
+      }
+      if (r.name.startsWith("module-missing:")) {
+        out.push({
+          range,
+          severity: "error",
+          message: r.reason ?? "Module file not found",
+          code: "nudo:module-missing"
+        });
+        continue;
+      }
+      out.push({
+        range,
+        severity: "warning",
+        message: `Unknown global identifier '${r.name}'`,
+        code: "nudo:unknown-global"
+      });
+      continue;
+    }
+    const receiver = r.receiverType;
+    if (receiver && receiverIsConcrete(receiver)) {
+      const isApprox = (() => {
+        const members = receiver.kind === "union" ? receiver.members : [receiver];
+        return members.some(
+          (m) => m.kind === "instance" || m.kind === "function" || m.kind === "tuple" || m.kind === "array" || m.kind === "object" || m.kind === "refined" || // wrapper/instance 近似表上可能持有该成员（'x'.charCodeAt 于
+          // number|string：string 侧存在，number 侧缺失 → 不确定 → warning）
+          memberMayExistOn(m, r.name)
+        );
+      })();
+      const kindLabel = r.kind === "method" ? "Method" : "Property";
+      out.push({
+        range,
+        severity: isApprox ? "warning" : "error",
+        message: `${kindLabel} '${r.name}' does not exist on type '${receiverTypeToDisplay(receiver)}'`,
+        code: "nudo:no-method",
+        ...r.origin ? { origin: r.origin } : {}
+      });
+    } else {
+      out.push({
+        range,
+        severity: "warning",
+        message: `Cannot resolve '${r.name}' on unknown value`,
+        code: "nudo:unknown-recv",
+        ...r.origin ? { origin: r.origin } : {}
+      });
+    }
+  }
+  return out;
+}
+function collectEnvNames(filePath, source, includeProject) {
+  const ast = parse5(source);
+  const fileDirectives = extractFileDirectives(ast);
+  const fileEnvNames = fileDirectives.filter((d) => d.kind === "env").flatMap((d) => d.envs);
+  if (!includeProject) return fileEnvNames;
+  const projectConfig = findProjectConfig(dirname5(filePath));
+  const projectEnvNames = projectConfig?.config.env ?? [];
+  return [.../* @__PURE__ */ new Set([...projectEnvNames, ...fileEnvNames])];
+}
+async function analyzeFileAsync(filePath, source, activeCases, externalCallRecords) {
+  const envNames = collectEnvNames(filePath, source, true);
+  if (envNames.length > 0) {
+    await preloadPathEnvs(envNames, dirname5(filePath));
+  }
+  return analyzeFile(filePath, source, activeCases, externalCallRecords);
+}
+function collectCallRecords(filePath, source) {
+  const records = [];
+  const ast = parse5(source, { errorRecovery: true });
+  resetMemo();
+  resetUnreachableRanges();
+  resetEnvModules();
+  resetMockModules();
+  setModuleResolver(resolveModule);
+  setCurrentFileDir(dirname5(filePath));
+  setCurrentSource(source);
+  setCallCollector((record) => records.push(record));
+  try {
+    const env = createEnvironment2();
+    evaluateProgram(ast, env);
+    const runCallbacks = (statements) => {
+      for (const stmt of statements) {
+        if (stmt.type !== "ExpressionStatement" || !("expression" in stmt)) continue;
+        const expr = stmt.expression;
+        if (expr.type !== "CallExpression") continue;
+        const callee = expr.callee;
+        if (callee.type !== "MemberExpression" && callee.type !== "Identifier") continue;
+        const name = callee.type === "Identifier" ? callee.name : callee.property.type === "Identifier" ? callee.property.name : null;
+        if (!name || !TEST_CALLBACK_NAMES.has(name)) continue;
+        const args = expr.arguments;
+        const cb = args.find((a) => a.type === "ArrowFunctionExpression" || a.type === "FunctionExpression");
+        if (!cb) continue;
+        try {
+          const params = cb.params ?? [];
+          evaluateFunction(cb, params.map(() => T2.unknown), env);
+        } catch {
+        }
+        if (name === "describe" && cb.body.type === "BlockStatement") {
+          runCallbacks(cb.body.body);
+        }
+      }
+    };
+    runCallbacks(ast.program.body);
+  } catch {
+  } finally {
+    setCallCollector(null);
+    setModuleResolver(null);
+    setUnknownBuiltinHandler(null);
+  }
+  return records;
+}
+var TEST_CALLBACK_NAMES = /* @__PURE__ */ new Set(["it", "test", "describe"]);
+var externalRecordIds = /* @__PURE__ */ new WeakMap();
+var nextExternalRecordId = 1;
+function analysisFileCacheKey(filePath, source, activeCases, externalCallRecords) {
+  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}`;
+  }
+  return {
+    filePath,
+    // 尾部无 @nudo 注释/空行不进键：comment-only 编辑命中 AnalysisResult
+    source: stableAnalyzeKeySource2(source),
+    auxKey: `${cases}\0${ext}`
+  };
+}
+function cloneAnalysisResult(r) {
+  return {
+    functions: r.functions.map(cloneFunctionAnalysis),
+    diagnostics: r.diagnostics.map((d) => ({ ...d })),
+    bindings: new Map(r.bindings),
+    // Node 键与 AST LRU 共享身份；Map 浅拷贝即可
+    nodeTypeMap: new Map(r.nodeTypeMap),
+    caseHints: r.caseHints.map((h) => ({ ...h })),
+    ...r.externalFunctions ? { externalFunctions: r.externalFunctions.map(cloneFunctionAnalysis) } : {}
+  };
+}
+function cloneFunctionAnalysis(a) {
+  return {
+    ...a,
+    paramNames: [...a.paramNames],
+    cases: a.cases.map((c) => ({
+      ...c,
+      args: [...c.args],
+      ...c.intension ? { intension: { ...c.intension } } : {}
+    })),
+    loc: { start: { ...a.loc.start }, end: { ...a.loc.end } }
+  };
+}
+function shiftSourceLoc(loc, 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 }
+  };
+}
+function analyzeFile(filePath, source, activeCases, externalCallRecords) {
+  const k = analysisFileCacheKey(filePath, source, activeCases, externalCallRecords);
+  const hit = analysisCacheGet(k.filePath, k.source, k.auxKey);
+  if (hit !== void 0) {
+    return cloneAnalysisResult(hit);
+  }
+  const result = analyzeFileUncached(filePath, source, activeCases, externalCallRecords);
+  analysisCacheSet(k.filePath, k.source, k.auxKey, result);
+  return cloneAnalysisResult(result);
+}
+function analyzeFileUncached(filePath, source, activeCases, externalCallRecords) {
+  for (const rec of externalCallRecords ?? []) {
+    for (const a of rec.argTypes) setUsageSiteTag(a);
+  }
+  const ast = parse5(source);
   const functions = extractDirectives(ast);
   const diagnostics = [];
   const bindings = /* @__PURE__ */ new Map();
@@ -66,34 +2312,329 @@ function analyzeFile(filePath, source, activeCases) {
   const caseHints = [];
   resetMemo();
   resetUnreachableRanges();
+  resetEnvModules();
+  resetMockModules();
   setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname(filePath));
-  const globalEnv = createEnvironment();
-  evaluateProgram(ast, globalEnv);
-  const unreachableRanges = getUnreachableRanges();
-  for (const ur of unreachableRanges) {
+  setCurrentFileDir(dirname5(filePath));
+  setCurrentSource(source);
+  const fileDirectives = extractFileDirectives(ast);
+  const fileEnvNames = fileDirectives.filter((d) => d.kind === "env").flatMap((d) => d.envs);
+  const projectConfig = findProjectConfig(dirname5(filePath));
+  const projectEnvNames = projectConfig?.config.env ?? [];
+  const envNames = [.../* @__PURE__ */ new Set([...projectEnvNames, ...fileEnvNames])];
+  setUnknownBuiltinHandler((name, loc) => {
+    if (isBPathCapable(source, envNames)) return;
+    diagnostics.push({
+      range: loc ? { start: loc.start, end: loc.end } : { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } },
+      severity: "warning",
+      message: `Built-in API "${name}" is not covered by Nudo's type inference`,
+      code: "nudo:builtin-unknown",
+      suggestions: [
+        `Use @nudo:mock to define the type: @nudo:mock ${name} = stub().returns(...)`,
+        `Or use @nudo:refine return <constraint> to declare the return contract`
+      ]
+    });
+  });
+  const globalEnv = createEnvironment2();
+  {
+    const loaded = envNames.length > 0 ? loadEnvs2(envNames, globalEnv) : { modules: {} };
+    const auto = autoHarvestModules(source, dirname5(filePath));
+    const modules = { ...loaded.modules, ...auto };
+    if (Object.keys(modules).length > 0) setEnvModules(modules);
+  }
+  const mocks = /* @__PURE__ */ new Map();
+  if (projectConfig?.config.mocks) {
+    for (const [source2, mockPath] of Object.entries(projectConfig.config.mocks)) {
+      mocks.set(source2, { fromPath: resolve4(projectConfig.projectDir, mockPath) });
+    }
+  }
+  const mockModuleDirectives = fileDirectives.filter((d) => d.kind === "mock-module");
+  for (const d of mockModuleDirectives) {
+    mocks.set(d.source, { fromPath: d.fromPath, names: d.names });
+  }
+  if (mocks.size > 0) {
+    setMockModules(mocks);
+  }
+  const callRecords = [];
+  setCallCollector((record) => callRecords.push(record));
+  const unknownRecords = [];
+  setUnknownCollector((r) => unknownRecords.push(r));
+  setProvenanceTracking(true);
+  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}`;
+    if (bMemberDiagSeen.has(key)) return;
+    bMemberDiagSeen.add(key);
+    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: ur,
-      severity: "info",
-      message: "Unreachable code",
-      tags: ["unnecessary"]
+      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) {
+    applyMocks(fn.directives, globalEnv, filePath, 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);
+  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
+      });
+      absGraphModules = g.modules;
+      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) {
+          const safeAbs = (a) => {
+            if (!a || typeof a !== "object" || !("shape" in a) || !a.shape) {
+              return T2.unknown;
+            }
+            try {
+              return absToTypeValue2(a);
+            } catch {
+              return T2.unknown;
+            }
+          };
+          const rec = {
+            fnName: c.fnName,
+            argTypes: c.args.map(safeAbs),
+            resultType: c.threw ? T2.never : safeAbs(c.result),
+            throws: c.threw ? safeAbs(c.result) : T2.never,
+            callLoc: c.callLoc
+          };
+          const imp = impMap.get(c.fnName);
+          if (imp) {
+            rec.targetModule = imp.modulePath;
+            rec.targetExport = imp.exportName;
+          }
+          bTopCallRecords.push(rec);
+        }
+      }
+    }
+  }
+  if (selfContained || canAbsModules) {
+    setAbsTruncationCollector2((label) => bTruncatedFns.add(label));
+    try {
+      absCallRecords = collectAbsCallRecords(source, seeds, filePath, absGraphModules);
+    } finally {
+      setAbsTruncationCollector2(null);
+    }
+  }
+  if (bHostedEval) {
+    try {
+      const collected = collectAbsBindsAndNodes(source, seeds, absGraphModules);
+      absBindsShared = collected.binds;
+      absNodesShared = collected.nodes;
+      for (const [name, absVal] of absBindsShared) {
+        if (absVal?.shape?.k === "fn") continue;
+        if (!globalEnv.has(name)) {
+          globalEnv.bind(name, absToTypeValue2(absVal));
+        }
+      }
+      for (const [node, absVal] of absNodesShared) {
+        nodeTypeMap.set(node, absToTypeValue2(absVal));
+      }
+    } catch {
+    }
+  } else {
+    evaluateProgram(ast, globalEnv);
+  }
+  if ((selfContained || canAbsModules) && absCallRecords.length > 0) {
+    callRecords.length = 0;
+    callRecords.push(...absCallRecords);
+  } else if (bTopCallRecords.length > 0) {
+    callRecords.length = 0;
+    callRecords.push(...bTopCallRecords);
+  }
+  const unreachableRanges = bCapable ? [] : getUnreachableRanges();
+  if (bCapable) {
+    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:refine return <constraint> to declare the return contract`
+        ]
+      });
+    }
+  } else {
+    for (const ur of unreachableRanges) {
+      diagnostics.push({
+        range: ur,
+        severity: "info",
+        message: "Code after return/throw statement is unreachable",
+        tags: ["unnecessary"],
+        code: "nudo-unreachable",
+        suggestions: ["Remove the unreachable code after the return/throw statement"]
+      });
+    }
   }
   collectBindings(ast, globalEnv, bindings);
+  if (isBPathCapable(source, envNames)) {
+    try {
+      const absBinds = absBindsShared ?? collectAbsBindingsFromGraph(source, filePath, {
+        seedVars: seeds.seedVars,
+        seedFns: seeds.seedFns
+      });
+      for (const [name, absVal] of absBinds) {
+        const prev = bindings.get(name);
+        bindings.set(name, {
+          type: absToTypeValue2(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) {
-    applyMocks(fn.directives, globalEnv, filePath);
     const isPure = fn.directives.some((d) => d.kind === "pure");
     const skipDirective = fn.directives.find((d) => d.kind === "skip");
-    const returnsDirective = fn.directives.find((d) => d.kind === "returns");
     const fnLoc = locFromNode(fn.node);
-    const analysis = { name: fn.name, loc: fnLoc, cases: [] };
+    const paramNames = extractParamNames(fn.node);
+    const analysis = { name: fn.name, loc: fnLoc, paramNames, cases: [] };
     if (skipDirective && skipDirective.kind === "skip") {
+      analysis.skipped = true;
       if (skipDirective.returns) {
         analysis.combined = skipDirective.returns;
       }
       functionResults.push(analysis);
       continue;
     }
+    const caseDirectives = fn.directives.filter((d) => d.kind === "case");
+    const activeCaseIdx = activeCases?.get(fn.name) ?? 0;
+    const fp = fnFpMap?.get(fn.name);
+    const fnCacheKey = fp && caseDirectives.length > 0 ? [
+      filePath,
+      fp.own,
+      fp.deps,
+      String(activeCaseIdx),
+      caseDirectiveKey(caseDirectives, typeValueToString3),
+      envKeyFn,
+      mockKeyFn
+    ].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 && fnVal.kind === "function") {
@@ -106,34 +2647,114 @@ function analyzeFile(filePath, source, activeCases) {
     } else {
       setSampleCount(3);
     }
-    const caseDirectives = fn.directives.filter((d) => d.kind === "case");
-    const activeCaseIdx = activeCases?.get(fn.name) ?? 0;
+    if (caseDirectives.length === 0) {
+      synthCandidates.push({ name: fn.name, node: fn.node, analysis });
+    }
     for (let ci = 0; ci < caseDirectives.length; ci++) {
       const directive = caseDirectives[ci];
       resetUnreachableRanges();
-      const fullResult = evaluateFunctionFull(fn.node, directive.args, globalEnv);
-      const caseUnreachable = [...getUnreachableRanges()];
-      analysis.cases.push({
+      let caseValue;
+      let caseAbs;
+      let caseThrows;
+      let fullResult = null;
+      let caseUnreachable = [];
+      const bCapable2 = isBPathCapable(source, envNames);
+      const bPrimary = bCapable2;
+      if (bCapable2 && filePath) {
+        const bFull = tryBPathCallFull(
+          source,
+          filePath,
+          fn.name,
+          directive.args.map((a) => typeValueToAbs5(a)),
+          { collectCalls: true, envNames, mocks: mockSeedsToAbsMocks(seeds) }
+        );
+        const res = bFull?.result;
+        const weakUnknown = !!res && res.shape.k === "unknown" && (!res.term || res.term.op === "lit" && res.term.value === void 0);
+        const bOk = !!res && (bHostedEval || !weakUnknown && res.conf !== "opaque");
+        if (bOk && bFull && bPrimary) {
+          caseAbs = bFull.result;
+          caseValue = absToTypeValue2(bFull.result);
+          caseThrows = bFull.throws.shape.k !== "never" ? absToTypeValue2(bFull.throws) : T2.never;
+          fullResult = { value: caseValue, throws: caseThrows };
+          for (const d of bFull.memberDiags ?? []) {
+            pushBMemberDiag(d, fnLoc.start.line);
+          }
+          if (bFull.calls?.length) {
+            const impMap = buildAbsImportLocalMap(source, filePath);
+            const safeAbs = (a) => {
+              if (!a || typeof a !== "object" || !("shape" in a) || !a.shape) {
+                return T2.unknown;
+              }
+              try {
+                return absToTypeValue2(a);
+              } catch {
+                return T2.unknown;
+              }
+            };
+            for (const c of bFull.calls) {
+              const rec = {
+                fnName: c.fnName,
+                argTypes: c.args.map(safeAbs),
+                resultType: c.threw ? T2.never : safeAbs(c.result),
+                throws: c.threw ? safeAbs(c.result) : T2.never,
+                callLoc: c.callLoc
+              };
+              const imp = impMap.get(c.fnName);
+              if (imp) {
+                rec.targetModule = imp.modulePath;
+                rec.targetExport = imp.exportName;
+              }
+              callRecords.push(rec);
+            }
+          }
+        }
+      }
+      if (!fullResult) {
+        if (bHostedEval) {
+          fullResult = { value: T2.unknown, throws: T2.never };
+          caseValue = T2.unknown;
+        } else {
+          fullResult = evaluateFunctionFull(fn.node, directive.args, globalEnv);
+          caseUnreachable = [...getUnreachableRanges()];
+          caseValue = fullResult.value;
+          if ((selfContained || canAbsModules) && fullResult.value.kind !== "never") {
+            caseAbs = tryEvalAbsRaw(source, fn.name, directive.args, filePath, mockSeedsToAbsMocks(seeds));
+            if (caseAbs) {
+              const projected = absToTypeValue2(caseAbs);
+              if (absIsBetter(projected, fullResult.value)) caseValue = projected;
+            }
+          }
+        }
+      }
+      const tv = caseValue;
+      const throwsTv = caseThrows ?? fullResult.throws;
+      const caseEntry = {
         name: directive.name,
         args: directive.args,
-        result: fullResult.value,
-        throws: fullResult.throws,
-        throwLoc: fullResult.throwLoc
-      });
+        result: tv,
+        throws: throwsTv,
+        throwLoc: fullResult.throwLoc,
+        expected: directive.expected,
+        source: "directive"
+      };
+      tryAttachIntension(caseEntry, source, fn.name);
+      if (caseAbs) attachAbsToIntension(caseEntry, caseAbs, fn.name);
+      analysis.cases.push(caseEntry);
       if (directive.commentLine) {
-        const hasThrow = fullResult.throws.kind !== "never";
-        const resultStr = fullResult.value.kind !== "never" ? typeValueToString(fullResult.value) : "";
-        const throwStr = hasThrow ? `throws ${typeValueToString(fullResult.throws)}` : "";
+        const hasThrow = throwsTv.kind !== "never";
+        const resultStr = tv.kind !== "never" ? typeValueToString3(tv) : "";
+        const throwStr = hasThrow ? `throws ${typeValueToString3(throwsTv)}` : "";
         const label = [resultStr, throwStr].filter(Boolean).join(" ");
         const hintLabel = `=> ${label}`;
         let ok = true;
         if (directive.expected) {
-          ok = isSubtypeOf(fullResult.value, directive.expected);
+          ok = isSubtypeOf(tv, directive.expected);
           if (!ok) {
             diagnostics.push({
               range: { start: { line: directive.commentLine, column: 0 }, end: { line: directive.commentLine, column: 999 } },
               severity: "error",
-              message: `Case "${directive.name}": expected ${typeValueToString(directive.expected)}, got ${typeValueToString(fullResult.value)}`
+              message: `Case "${directive.name}": expected ${typeValueToString3(directive.expected)}, got ${typeValueToString3(tv)}. The inferred return type does not match the expected type declared in the @nudo:case directive`,
+              code: "nudo:case-expected"
             });
           }
         }
@@ -141,74 +2762,292 @@ function analyzeFile(filePath, source, activeCases) {
       }
       const isActive = ci === Math.min(activeCaseIdx, caseDirectives.length - 1);
       if (isActive) {
-        if (fullResult.throws.kind !== "never") {
-          const throwRange = fullResult.throwLoc ?? fnLoc;
+        if (throwsTv.kind !== "never") {
+          const throwRange = fullResult?.throwLoc ?? fnLoc;
           diagnostics.push({
             range: throwRange,
             severity: "warning",
-            message: `Function "${fn.name}" case "${directive.name}" may throw: ${typeValueToString(fullResult.throws)}`
+            message: `Function "${fn.name}" case "${directive.name}" may throw: ${typeValueToString3(throwsTv)}. Consider adding a try-catch block or using @nudo:refine return <constraint>`,
+            code: "nudo-may-throw"
           });
         }
-        for (const ur of caseUnreachable) {
-          diagnostics.push({
-            range: ur,
-            severity: "info",
-            message: "Unreachable code",
-            tags: ["unnecessary"]
-          });
+        if (!isBPathCapable(source, envNames)) {
+          for (const ur of caseUnreachable) {
+            diagnostics.push({
+              range: ur,
+              severity: "info",
+              message: "Code after return/throw statement is unreachable",
+              tags: ["unnecessary"],
+              code: "nudo-unreachable",
+              suggestions: ["Remove the unreachable code after the return/throw statement"]
+            });
+          }
         }
       }
     }
     if (analysis.cases.length > 1) {
-      analysis.combined = simplifyUnion(analysis.cases.map((c) => c.result));
+      analysis.combined = collapseLiteralUnion(simplifyUnion(analysis.cases.map((c) => c.result)), COLLAPSE_LITERAL_THRESHOLD);
     } else if (analysis.cases.length === 1) {
       analysis.combined = analysis.cases[0].result;
     }
-    if (returnsDirective && returnsDirective.kind === "returns") {
-      analysis.assertionErrors = [];
-      for (const directive of caseDirectives) {
-        const result = evaluateFunction(fn.node, directive.args, globalEnv);
-        const matches = isSubtypeOf(result, returnsDirective.expected);
-        if (!matches) {
-          const msg = `@nudo:returns assertion failed for case "${directive.name}": expected ${typeValueToString(returnsDirective.expected)}, got ${typeValueToString(result)}`;
-          analysis.assertionErrors.push(msg);
-          diagnostics.push({
-            range: fnLoc,
-            severity: "error",
-            message: msg
-          });
+    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 } 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 });
+  }
+  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(resolve4(filePath));
+  const singleExportFn = findSingleModuleExportsFunction(ast);
+  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) => !(r.resultType.kind === "never" && r.throws.kind === "never"))
+    );
+    if (records.length > 0) {
+      const informativeness = (r) => {
+        if (r.resultType.kind === "unknown") return 2;
+        if (r.resultType.kind === "never") return 1;
+        return 0;
+      };
+      const ordered = records.map((r, i) => ({ r, i })).sort((a, b) => informativeness(a.r) - informativeness(b.r) || a.i - b.i).map(({ r }) => r);
+      const precise = ordered.slice(0, MAX_PRECISE_CALLSITE_CASES);
+      for (const rec of precise) {
+        let absRaw;
+        let absResult;
+        if (rec.resultType.kind !== "never" && rec.argTypes.length > 0) {
+          absRaw = tryEvalAbsRaw(source, candidate.name, rec.argTypes, filePath, mockSeedsToAbsMocks(seeds));
+          if (absRaw) {
+            const projected = absToTypeValue2(absRaw);
+            if (absIsBetter(projected, rec.resultType)) absResult = projected;
+          }
+        }
+        const caseResult2 = {
+          name: `call@L${rec.callLoc?.line ?? candidate.analysis.loc.start.line}`,
+          args: rec.argTypes,
+          result: absResult ?? rec.resultType,
+          throws: rec.throws,
+          source: "callsite"
+        };
+        tryAttachIntension(caseResult2, source, candidate.name);
+        if (absRaw) attachAbsToIntension(caseResult2, absRaw, candidate.name);
+        candidate.analysis.cases.push(caseResult2);
+      }
+      const remaining = ordered.slice(MAX_PRECISE_CALLSITE_CASES).filter((rec) => !rec.argTypes.some((a) => a.kind === "unknown"));
+      if (remaining.length > 0) {
+        const fnNode2 = resolveFunctionNode(candidate.node);
+        const paramCount = extractParamNames(fnNode2).length;
+        const widenedArgs = Array.from(
+          { length: paramCount },
+          (_, i) => (
+            // 缺参按真实 JS 语义 widen 成 undefined 而非 unknown——可选参守卫
+            // （target || [] 等）对 unknown 全塌，对 undefined 正常走默认分支
+            widenType(simplifyUnion(remaining.map((rec) => rec.argTypes[i] ?? T2.undefined)))
+          )
+        );
+        const absSymRaw = tryEvalAbs(source, candidate.name, widenedArgs, filePath, mockSeedsToAbsMocks(seeds));
+        const absSym = absSymRaw && absIsBetter(
+          absSymRaw,
+          /* 无先验：仅 unknown 时 */
+          { kind: "unknown" }
+        ) ? absSymRaw : void 0;
+        let symValue;
+        let symThrows = T2.never;
+        let symLoc;
+        let symAbs;
+        if (isBPathCapable(source, envNames) && filePath) {
+          const bSym = tryBPathCall(
+            source,
+            filePath,
+            candidate.name,
+            widenedArgs.map((a) => typeValueToAbs5(a)),
+            { envNames, mocks: mockSeedsToAbsMocks(seeds) }
+          );
+          if (bSym && (bHostedEval || !(bSym.shape.k === "unknown" && !bSym.term))) {
+            symAbs = bSym;
+            symValue = absToTypeValue2(bSym);
+          }
+        }
+        if (!symAbs && !bHostedEval) {
+          const full = evaluateFunctionFull(fnNode2, widenedArgs, globalEnv);
+          symValue = full.value.kind === "unknown" && absSym ? absSym : full.value;
+          symThrows = full.throws;
+          symLoc = full.throwLoc;
+        }
+        const symCase = {
+          name: "call@symbolic",
+          args: widenedArgs,
+          result: symValue ?? T2.unknown,
+          throws: symThrows,
+          throwLoc: symLoc,
+          source: "callsite",
+          aggregatedFrom: remaining.length
+        };
+        tryAttachIntension(symCase, source, candidate.name);
+        if (symAbs) attachAbsToIntension(symCase, symAbs, candidate.name);
+        candidate.analysis.cases.push(symCase);
+      }
+      candidate.analysis.combined = collapseLiteralUnion(
+        simplifyUnion(records.map((r) => r.resultType)),
+        COLLAPSE_LITERAL_THRESHOLD
+      );
+      continue;
+    }
+    const fnNode = resolveFunctionNode(candidate.node);
+    const args = extractParamNames(fnNode).map(() => T2.unknown);
+    let entryValue;
+    let entryThrows = T2.never;
+    let entryLoc;
+    let entryAbs;
+    if (isBPathCapable(source, envNames) && filePath) {
+      const bEntryFull = tryBPathCallFull(
+        source,
+        filePath,
+        candidate.analysis.name,
+        args.map((a) => typeValueToAbs5(a)),
+        { envNames, mocks: mockSeedsToAbsMocks(seeds), collectMemberDiags: true }
+      );
+      if (bEntryFull?.memberDiags?.length) {
+        for (const d of bEntryFull.memberDiags) {
+          pushBMemberDiag(d, candidate.analysis.loc.start.line);
         }
       }
+      const bEntry = bEntryFull?.result;
+      if (bEntry && (bHostedEval || !(bEntry.shape.k === "unknown" && !bEntry.term))) {
+        entryAbs = bEntry;
+        entryValue = absToTypeValue2(bEntry);
+      }
     }
-    functionResults.push(analysis);
+    if (!entryValue) {
+      if (bHostedEval) {
+        entryValue = T2.unknown;
+        entryThrows = T2.never;
+      } else {
+        const absEntry = tryEvalEntryAbs(source, candidate.analysis.name, args, filePath, seeds.seedVars);
+        const full = absEntry ? { value: absEntry, throws: T2.never, throwLoc: void 0 } : evaluateFunctionFull(fnNode, args, globalEnv);
+        entryValue = full.value;
+        entryThrows = full.throws;
+        entryLoc = full.throwLoc;
+      }
+    }
+    const caseResult = {
+      name: `entry@L${candidate.analysis.loc.start.line}`,
+      args,
+      result: entryValue,
+      throws: entryThrows,
+      throwLoc: entryLoc
+    };
+    tryAttachIntension(caseResult, source, candidate.analysis.name);
+    if (entryAbs) attachAbsToIntension(caseResult, entryAbs, candidate.analysis.name);
+    candidate.analysis.cases.push(caseResult);
+    candidate.analysis.entryOnly = true;
+    candidate.analysis.combined = collapseLiteralUnion(entryValue, COLLAPSE_LITERAL_THRESHOLD);
   }
-  buildNodeTypeMap(ast, globalEnv, nodeTypeMap);
+  if (!bHostedEval) {
+    buildNodeTypeMap(ast, globalEnv, nodeTypeMap);
+  }
+  setUnknownBuiltinHandler(null);
+  setCallCollector(null);
+  setUnknownCollector(null);
+  setProvenanceTracking(false);
   setModuleResolver(null);
+  resetEnvModules();
+  resetMockModules();
+  const maxLine = source.split("\n").length;
+  diagnostics.push(
+    ...unknownRecordsToDiagnostics(
+      unknownRecords.filter((r) => {
+        if ((r.loc?.line ?? 0) > maxLine) return false;
+        if (r.originModule === USAGE_SITE_MODULE) return false;
+        if (bHostedEval && (r.kind === "method" || r.kind === "property")) {
+          return false;
+        }
+        if ((r.kind === "method" || r.kind === "property") && bMemberDiagNames.has(r.name)) {
+          return false;
+        }
+        if (r.kind === "global") {
+          if (r.name.startsWith("module-cycle:") && bModuleIssueKinds.has("cycle")) return false;
+          if (r.name.startsWith("module-depth:") && bModuleIssueKinds.has("depth")) return false;
+          if (r.name.startsWith("module-missing:") && bModuleIssueKinds.has("missing")) return false;
+          if (r.name.startsWith("recursion:")) {
+            const fn = r.name.slice("recursion:".length);
+            if (bTruncatedFns.has(fn) || bTruncatedFns.has(fn.split(".").pop() ?? fn)) {
+              return false;
+            }
+          }
+          if (bBuiltinUnknownNames.has(r.name)) return false;
+        }
+        return true;
+      })
+    )
+  );
+  const externalFunctions = synthesizeExternalFunctions(callRecords, filePath);
   return {
     functions: functionResults,
     diagnostics,
     bindings,
     nodeTypeMap,
-    caseHints
+    caseHints,
+    ...externalFunctions.length > 0 ? { externalFunctions } : {}
   };
 }
 function collectBindings(ast, env, bindings) {
   if (ast.type !== "File") return;
   for (const stmt of ast.program.body) {
     if (stmt.type === "FunctionDeclaration" && stmt.id) {
-      const val = env.has(stmt.id.name) ? env.lookup(stmt.id.name) : T.unknown;
+      const val = env.has(stmt.id.name) ? env.lookup(stmt.id.name) : T2.unknown;
       bindings.set(stmt.id.name, { type: val, loc: locFromNode(stmt) });
     }
     if (stmt.type === "VariableDeclaration") {
       for (const decl of stmt.declarations) {
         if (decl.id.type === "Identifier") {
-          const val = env.has(decl.id.name) ? env.lookup(decl.id.name) : T.unknown;
+          const val = env.has(decl.id.name) ? env.lookup(decl.id.name) : T2.unknown;
           bindings.set(decl.id.name, { type: val, loc: locFromNode(decl) });
         }
       }
     }
     if (stmt.type === "ClassDeclaration" && stmt.id) {
-      const val = env.has(stmt.id.name) ? env.lookup(stmt.id.name) : T.unknown;
+      const val = env.has(stmt.id.name) ? env.lookup(stmt.id.name) : T2.unknown;
       bindings.set(stmt.id.name, { type: val, loc: locFromNode(stmt) });
     }
     if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
@@ -229,16 +3068,16 @@ function buildNodeTypeMap(ast, env, nodeTypeMap) {
             }
           }
           if (node.type === "NumericLiteral") {
-            nodeTypeMap.set(node, T.literal(node.value));
+            nodeTypeMap.set(node, T2.literal(node.value));
           }
           if (node.type === "StringLiteral") {
-            nodeTypeMap.set(node, T.literal(node.value));
+            nodeTypeMap.set(node, T2.literal(node.value));
           }
           if (node.type === "BooleanLiteral") {
-            nodeTypeMap.set(node, T.literal(node.value));
+            nodeTypeMap.set(node, T2.literal(node.value));
           }
           if (node.type === "NullLiteral") {
-            nodeTypeMap.set(node, T.null);
+            nodeTypeMap.set(node, T2.null);
           }
         } catch {
         }
@@ -248,19 +3087,59 @@ function buildNodeTypeMap(ast, env, nodeTypeMap) {
   }
 }
 function getCasesForFile(filePath, source) {
-  const ast = parse(source);
+  const ast = parse5(source);
   const functions = extractDirectives(ast);
   return functions.map((fn) => {
     const cases = fn.directives.filter((d) => d.kind === "case").map((d, i) => ({ name: d.name, index: i }));
     return { functionName: fn.name, cases, loc: locFromNode(fn.node) };
   });
 }
+async function getTypeAtPositionAsync(filePath, source, line, column, activeCases) {
+  const envNames = collectEnvNames(filePath, source, false);
+  if (envNames.length > 0) {
+    await preloadPathEnvs(envNames, dirname5(filePath));
+  }
+  return getTypeAtPosition(filePath, source, line, column, activeCases);
+}
 function getTypeAtPosition(filePath, source, line, column, activeCases) {
-  const ast = parse(source);
+  const ast = parse5(source);
+  const fileDirectives = extractFileDirectives(ast);
+  const envNames = fileDirectives.filter((d) => d.kind === "env").flatMap((d) => d.envs);
+  if (isBPathCapable(source, envNames)) {
+    try {
+      const seeds = mockDirectivesToAbsSeeds(extractDirectives(ast));
+      const { modules } = evalAbsModuleGraph(source, filePath);
+      const absNodes = collectAbsNodeTypes(source, {
+        ...seeds,
+        modules,
+        file: ast
+      });
+      const absAt = findAbsAtPosition(absNodes, line, column);
+      if (absAt) return absToTypeValue2(absAt);
+      const ident = findIdentNameAtPosition(source, line, column, ast);
+      if (ident) {
+        const binds = collectAbsBindingsFromGraph(source, filePath, {
+          seedVars: seeds.seedVars,
+          seedFns: seeds.seedFns
+        });
+        const bound = binds.get(ident);
+        if (bound) return absToTypeValue2(bound);
+      }
+    } catch {
+    }
+  }
   resetMemo();
+  resetEnvModules();
   setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname(filePath));
-  const globalEnv = createEnvironment();
+  setCurrentFileDir(dirname5(filePath));
+  setCurrentSource(source);
+  const globalEnv = createEnvironment2();
+  {
+    const loaded = envNames.length > 0 ? loadEnvs2(envNames, globalEnv) : { modules: {} };
+    const auto = autoHarvestModules(source, dirname5(filePath));
+    const modules = { ...loaded.modules, ...auto };
+    if (Object.keys(modules).length > 0) setEnvModules(modules);
+  }
   evaluateProgram(ast, globalEnv);
   const nodeTypeMap = /* @__PURE__ */ new Map();
   buildNodeTypeMap(ast, globalEnv, nodeTypeMap);
@@ -281,8 +3160,164 @@ function getTypeAtPosition(filePath, source, line, column, activeCases) {
     }
   }
   setModuleResolver(null);
+  resetEnvModules();
+  resetMockModules();
   return findBestTypeAtPosition(nodeTypeMap, globalEnv, ast, line, column);
 }
+function getHoverAtPosition(filePath, source, line, column, activeCases) {
+  let file;
+  try {
+    file = parse5(source);
+  } catch {
+    file = void 0;
+  }
+  const envNames = collectEnvNames(filePath, source, false);
+  if (isBPathCapable(source, envNames)) {
+    try {
+      const seeds = mockDirectivesToAbsSeeds(extractDirectives(file ?? parse5(source)));
+      const { modules } = evalAbsModuleGraph(source, filePath);
+      const absNodes = collectAbsNodeTypes(source, {
+        ...seeds,
+        modules,
+        ...file ? { file } : {}
+      });
+      const absAt = findAbsAtPosition(absNodes, line, column);
+      const ident2 = findIdentNameAtPosition(source, line, column, file);
+      if (ident2 && !findFunctionNameAtPosition(source, line, column, file)) {
+        const binds = collectAbsBindingsFromGraph(source, filePath, {
+          seedVars: seeds.seedVars,
+          seedFns: seeds.seedFns
+        });
+        const bound = binds.get(ident2);
+        if (bound) {
+          const absLine = formatAbs3(bound);
+          const absMulti = formatAbsMultiline(bound, ident2);
+          return { typeText: absLine, abs: absLine, absMultiline: absMulti };
+        }
+      }
+      if (absAt) {
+        const absLine = formatAbs3(absAt);
+        const absMulti = formatAbsMultiline(absAt, void 0);
+        return { typeText: absLine, abs: absLine, absMultiline: absMulti };
+      }
+    } catch {
+    }
+  }
+  const tv = getTypeAtPosition(filePath, source, line, column, activeCases);
+  const info = tv ? { typeText: typeValueToString3(tv) } : null;
+  const fnName = findFunctionNameAtPosition(source, line, column, file);
+  if (fnName) {
+    try {
+      const g = generalizeFromAst2(fnName, source, file ? { file } : {});
+      if (g) {
+        if (info) {
+          info.intension = g.display;
+          info.abs = formatAbs3(g.symbolic);
+          info.absMultiline = formatAbsMultiline(g.symbolic, fnName);
+        } else {
+          return {
+            typeText: g.display,
+            intension: g.display,
+            abs: formatAbs3(g.symbolic),
+            absMultiline: formatAbsMultiline(g.symbolic, fnName)
+          };
+        }
+      }
+    } catch {
+    }
+  }
+  const ident = findIdentNameAtPosition(source, line, column, file);
+  if (ident && !fnName) {
+    try {
+      if (isBPathCapable(source, []) || !/\brequire\s*\(/.test(source)) {
+        const seeds = mockDirectivesToAbsSeeds(extractDirectives(file ?? parse5(source)));
+        const absBinds = collectAbsBindingsFromGraph(source, filePath, {
+          seedVars: seeds.seedVars,
+          seedFns: seeds.seedFns
+        });
+        const absBound = absBinds.get(ident);
+        if (absBound) {
+          const absLine = formatAbs3(absBound);
+          const absMulti = formatAbsMultiline(absBound, ident);
+          if (info) {
+            info.abs = absLine;
+            info.absMultiline = absMulti;
+            return info;
+          }
+          return { typeText: absLine, abs: absLine, absMultiline: absMulti };
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    if (isBPathCapable(source, []) || !/\brequire\s*\(|\bimport\s*[{'"*]/.test(source)) {
+      const seeds = mockDirectivesToAbsSeeds(
+        extractDirectives(file ?? parse5(source))
+      );
+      const { modules } = evalAbsModuleGraph(source, filePath);
+      const nodeTypes = collectAbsNodeTypes(source, {
+        ...seeds,
+        modules,
+        ...file ? { file } : {}
+      });
+      const absAt = findAbsAtPosition(nodeTypes, line, column);
+      if (absAt) {
+        const absLine = formatAbs3(absAt);
+        const absMulti = formatAbsMultiline(absAt, void 0);
+        if (info) {
+          info.abs = absLine;
+          info.absMultiline = absMulti;
+        } else {
+          return { typeText: absLine, abs: absLine, absMultiline: absMulti };
+        }
+      }
+    }
+  } catch {
+  }
+  return info;
+}
+function findIdentNameAtPosition(source, line, column, fileAst) {
+  try {
+    const ast = fileAst ?? parse5(source);
+    let found;
+    traverse(ast, {
+      Identifier(path) {
+        const loc = path.node.loc;
+        if (!loc) return;
+        if (loc.start.line !== line) return;
+        if (column < loc.start.column || column > loc.end.column) return;
+        found = path.node.name;
+      }
+    });
+    return found;
+  } catch {
+    return void 0;
+  }
+}
+function findFunctionNameAtPosition(source, line, column, fileAst) {
+  try {
+    const ast = fileAst ?? parse5(source);
+    let found;
+    traverse(ast, {
+      Identifier(path) {
+        const loc = path.node.loc;
+        if (!loc) return;
+        if (loc.start.line !== line) return;
+        if (column < loc.start.column || column > loc.end.column) return;
+        const parent = path.parent;
+        if (parent.type === "FunctionDeclaration" && parent.id === path.node) {
+          found = path.node.name;
+        } else if (parent.type === "CallExpression" && parent.callee === path.node) {
+          found = path.node.name;
+        }
+      }
+    });
+    return found;
+  } catch {
+    return void 0;
+  }
+}
 function findEnclosingFunction(functions, line) {
   for (const fn of functions) {
     const loc = fn.node.loc;
@@ -331,129 +3366,685 @@ function findIdentifierAtPosition(ast, line, column) {
     });
   } catch {
   }
-  return found;
+  return found;
+}
+function getCompletionsAtPosition(filePath, source, line, column) {
+  const textBefore = getTextBeforePosition(source, line, column);
+  const dotMatch = textBefore.match(/(\w+)\.\s*\w*$/);
+  if (!dotMatch) return getVariableCompletions(filePath, source);
+  const objName = dotMatch[1];
+  const safeSource = sanitizeSourceForParsing(source);
+  let ast;
+  try {
+    ast = parse5(safeSource);
+  } catch {
+    try {
+      ast = parse5(source);
+    } catch {
+      return [];
+    }
+  }
+  resetMemo();
+  setModuleResolver(resolveModule);
+  setCurrentFileDir(dirname5(filePath));
+  const globalEnv = createEnvironment2();
+  evaluateProgram(ast, globalEnv);
+  if (!globalEnv.has(objName)) {
+    setModuleResolver(null);
+    return [];
+  }
+  const objType = globalEnv.lookup(objName);
+  const completions = getCompletionsForType(objType);
+  setModuleResolver(null);
+  return completions;
+}
+function sanitizeSourceForParsing(source) {
+  return source.replace(/(\w+)\.\s*$/gm, "$1._ ");
+}
+function getTextBeforePosition(source, line, column) {
+  const lines = source.split("\n");
+  if (line < 1 || line > lines.length) return "";
+  return lines[line - 1].slice(0, column);
+}
+function getVariableCompletions(filePath, source) {
+  const ast = parse5(source);
+  resetMemo();
+  setModuleResolver(resolveModule);
+  setCurrentFileDir(dirname5(filePath));
+  const globalEnv = createEnvironment2();
+  evaluateProgram(ast, globalEnv);
+  const ownBindings = globalEnv.getOwnBindings();
+  const completions = [];
+  for (const [name, tv] of Object.entries(ownBindings)) {
+    if (name.startsWith("__export_")) continue;
+    completions.push({
+      label: name,
+      kind: tv.kind === "function" ? "method" : "variable",
+      detail: typeValueToString3(tv)
+    });
+  }
+  setModuleResolver(null);
+  return completions;
+}
+function builtinMemberType(memberExpr) {
+  try {
+    const result = evaluate(parse5(`${memberExpr};`), createEnvironment2());
+    if (!result || typeof result !== "object" || !("kind" in result)) return null;
+    return result;
+  } catch {
+    return null;
+  }
+}
+function builtinProtoMembers(className) {
+  const table = BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS[className];
+  return table ? Object.keys(table) : [];
+}
+function describeMember(label, tv, fallbackClass) {
+  if (tv) {
+    const sig = getFnSig3(tv);
+    if (sig) {
+      const paramNames = tv.kind === "function" ? tv.params : [];
+      const params = sig.paramTypes.map((p, i) => `${paramNames[i] ?? `arg${i}`}: ${typeValueToString3(p)}`).join(", ");
+      return `(${params}) => ${typeValueToString3(sig.returnType)}`;
+    }
+    if (tv.kind !== "function") return typeValueToString3(tv);
+  }
+  return `${label}(\u2026)@${fallbackClass}`;
+}
+function getArrayCompletions(tv) {
+  const completions = [];
+  for (const m of builtinProtoMembers("Array")) {
+    const detail = describeMember(m, builtinMemberType(`Array.prototype.${m}`), "Array");
+    completions.push({ label: m, kind: "method", detail });
+  }
+  completions.push({
+    label: "length",
+    kind: "property",
+    // tuple 长度是精确字面量；array 是 number（保持原展示语义）
+    detail: tv.kind === "tuple" ? `${tv.elements.length}` : "number"
+  });
+  return completions;
+}
+function getPromiseCompletions() {
+  return builtinProtoMembers("Promise").map((m) => ({
+    label: m,
+    kind: "method",
+    detail: describeMember(m, builtinMemberType(`Promise.prototype.${m}`), "Promise")
+  }));
+}
+function getStringCompletions() {
+  const completions = [];
+  for (const m of builtinProtoMembers("String")) {
+    completions.push({
+      label: m,
+      kind: "method",
+      detail: describeMember(m, builtinMemberType(`"s".${m}`), "String")
+    });
+  }
+  completions.push({ label: "length", kind: "property", detail: "number" });
+  return completions;
+}
+function getUnionCompletions(tv) {
+  const members = tv.members;
+  if (members.length === 0) return [];
+  const labelsByMember = members.map((m) => getCompletionsForType(m));
+  const baseIdx = labelsByMember.findIndex((labels) => labels.length > 0);
+  if (baseIdx === -1) return [];
+  const common = [];
+  for (const base of labelsByMember[baseIdx]) {
+    let allPresent = true;
+    const memberTypes = [base.detail ?? base.label];
+    for (let i = 0; i < members.length; i++) {
+      if (i === baseIdx) continue;
+      const labels = labelsByMember[i];
+      if (labels.length === 0) continue;
+      const hit = labels.find((l) => l.label === base.label);
+      if (!hit) {
+        allPresent = false;
+        break;
+      }
+      memberTypes.push(hit.detail ?? hit.label);
+    }
+    if (allPresent) {
+      common.push({ ...base, detail: memberTypes.join(" | ") });
+    }
+  }
+  return common;
+}
+function getCompletionsForType(tv) {
+  const completions = [];
+  if (tv.kind === "object") {
+    for (const [key, val] of Object.entries(tv.properties)) {
+      completions.push({
+        label: key,
+        kind: val.kind === "function" ? "method" : "property",
+        detail: typeValueToString3(val)
+      });
+    }
+    return completions;
+  }
+  if (tv.kind === "instance") {
+    for (const [key, val] of Object.entries(tv.properties)) {
+      completions.push({
+        label: key,
+        kind: val.kind === "function" ? "method" : "property",
+        detail: typeValueToString3(val)
+      });
+    }
+    return completions;
+  }
+  if (tv.kind === "union") {
+    return getUnionCompletions(tv);
+  }
+  if (tv.kind === "array" || tv.kind === "tuple") {
+    return getArrayCompletions(tv);
+  }
+  if (tv.kind === "promise") {
+    return getPromiseCompletions();
+  }
+  if (tv.kind === "primitive" && tv.type === "string") {
+    return getStringCompletions();
+  }
+  return completions;
+}
+function absIsBetter(absTv, prev) {
+  if (prev.kind === "unknown") return absTv.kind !== "unknown";
+  if (absTv.kind === "unknown" || absTv.kind === "never") return false;
+  if (prev.kind === "literal" || prev.kind === "object" || prev.kind === "array" || prev.kind === "tuple" || prev.kind === "union" || prev.kind === "function" || prev.kind === "instance" || prev.kind === "promise") {
+    return false;
+  }
+  if (absTv.kind === "refined" && prev.kind === "primitive") 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 collectAbsCallRecords(source, seeds, filePath, precomputedModules) {
+  const absCalls = [];
+  let modules = precomputedModules;
+  let importLocals = /* @__PURE__ */ new Map();
+  if (filePath && absModulesOk(source, [])) {
+    if (!modules) {
+      try {
+        const graph = evalAbsModuleGraph(source, filePath, {
+          seedVars: seeds?.seedVars,
+          seedFns: seeds?.seedFns
+        });
+        modules = graph.modules;
+      } catch {
+        modules = void 0;
+      }
+    }
+    try {
+      importLocals = buildAbsImportLocalMap(source, filePath);
+    } catch {
+      importLocals = /* @__PURE__ */ new Map();
+    }
+  }
+  setAbsCallCollector((r) => absCalls.push(r));
+  try {
+    evalProgramAbs2(source, { ...seeds, modules });
+  } catch {
+  } finally {
+    setAbsCallCollector(null);
+  }
+  return absCalls.map((r) => {
+    const rec = {
+      fnName: r.fnName,
+      argTypes: r.args.map((a) => absToTypeValue2(a)),
+      resultType: r.threw ? T2.never : absToTypeValue2(r.result),
+      throws: r.threw ? absToTypeValue2(r.result) : T2.never,
+      callLoc: r.callLoc
+    };
+    const imp = importLocals.get(r.fnName);
+    if (imp) {
+      rec.targetModule = imp.modulePath;
+      rec.targetExport = imp.exportName;
+    }
+    return rec;
+  });
+}
+function collectAbsBindsAndNodes(source, seeds, modules) {
+  const binds = /* @__PURE__ */ new Map();
+  const nodes = /* @__PURE__ */ new Map();
+  setAbsNodeCollector((node, value) => {
+    nodes.set(node, value);
+  });
+  try {
+    const { env } = evalProgramAbs2(source, {
+      ...seeds,
+      modules
+    });
+    for (const [k, v] of env.vars) binds.set(k, v);
+    for (const [name, impl] of env.fns) {
+      if (!binds.has(name)) {
+        binds.set(
+          name,
+          absFunction5(impl.params, { body: impl.body, async: impl.async, env })
+        );
+      }
+    }
+  } catch {
+  } finally {
+    setAbsNodeCollector(null);
+  }
+  return { binds, nodes };
+}
+function buildAbsImportLocalMap(source, fromFile) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const file = parse5(source);
+    for (const stmt of file.program.body) {
+      if (stmt.type !== "ImportDeclaration") continue;
+      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" });
+        }
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+function resolveImportAbs(spec, fromFile) {
+  const base = dirname5(resolve4(fromFile));
+  const p = resolve4(base, spec);
+  for (const cand of [p, `${p}.js`, `${p}.mjs`, `${p}.ts`, resolve4(p, "index.js")]) {
+    if (existsSync3(cand) && !statSync3(cand).isDirectory()) return cand;
+  }
+  return null;
+}
+function tryEvalAbs(source, fnName, args, filePath, mocks) {
+  const raw = tryEvalAbsRaw(source, fnName, args, filePath, mocks);
+  return raw ? absToTypeValue2(raw) : void 0;
+}
+function tryEvalAbsRaw(source, fnName, args, filePath, mocks) {
+  if (/\brequire\s*\(/.test(source)) return void 0;
+  try {
+    const absArgs = args.map((a) => typeValueToAbs5(a));
+    if (filePath) {
+      const viaB = tryBPathCall(source, filePath, fnName, absArgs, { mocks });
+      if (viaB) return viaB;
+    }
+    let modules;
+    if (filePath && /\bimport\s*[{'"*]/.test(source)) {
+      modules = evalAbsModuleGraph(source, filePath).modules;
+    }
+    const result = analyzeFn(source, fnName, absArgs, void 0, void 0, void 0, modules);
+    if (result.shape.k === "unknown" && !result.term) {
+      return void 0;
+    }
+    return result;
+  } catch {
+    return void 0;
+  }
+}
+function tryEvalEntryAbs(source, fnName, args, filePath, mocks) {
+  return tryEvalAbs(source, fnName, args, filePath, mocks);
+}
+function tryAttachIntension(caseResult, source, fnName) {
+  try {
+    const g = generalizeFromAst2(fnName, source);
+    if (!g) return;
+    const sym = g.symbolic;
+    const intension = {
+      display: g.display,
+      abs: formatAbs3(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 attachAbsToIntension(caseResult, absVal, label) {
+  const prev = caseResult.intension ?? {};
+  caseResult.abs = absVal;
+  caseResult.intension = {
+    ...prev,
+    abs: formatAbs3(absVal),
+    absMultiline: formatAbsMultiline(absVal, label ?? caseResult.name),
+    conf: absVal.conf
+  };
+}
+
+// src/index.ts
+import { collectAbsInlays } from "@nudojs/core";
+
+// src/infer-json.ts
+import { typeValueToString as typeValueToString4 } from "@nudojs/core";
+function mapCase(c) {
+  const out = {
+    name: c.name,
+    args: c.args.map((a) => typeValueToString4(a)),
+    result: typeValueToString4(c.result),
+    throws: c.throws.kind !== "never" ? typeValueToString4(c.throws) : null,
+    source: c.source ?? null
+  };
+  if (c.aggregatedFrom !== void 0) out.aggregatedFrom = c.aggregatedFrom;
+  if (c.intension) {
+    const i = c.intension;
+    out.intension = {
+      ...i.display !== void 0 ? { display: i.display } : {},
+      ...i.abs !== void 0 ? { abs: i.abs } : {},
+      ...i.absMultiline !== void 0 ? { absMultiline: i.absMultiline } : {},
+      ...i.term !== void 0 ? { term: i.term } : {},
+      ...i.pred !== void 0 ? { pred: i.pred } : {},
+      ...i.conf !== void 0 ? { conf: i.conf } : {}
+    };
+  }
+  return out;
+}
+function mapFunction(f) {
+  const out = {
+    name: f.name,
+    loc: f.loc,
+    entryOnly: f.entryOnly ?? false,
+    cases: f.cases.map(mapCase)
+  };
+  if (f.noDeclaration) out.noDeclaration = true;
+  if (f.combined) out.combined = typeValueToString4(f.combined);
+  return out;
+}
+function serializeInferJson(result, file) {
+  const functions = result.functions.map(mapFunction);
+  const external = result.externalFunctions?.map((f) => ({
+    name: f.name,
+    fromModule: f.fromModule,
+    cases: f.cases.map(mapCase)
+  }));
+  const caseCount = functions.reduce((n, f) => n + f.cases.length, 0) + (external ?? []).reduce((n, f) => n + f.cases.length, 0);
+  const json = {
+    version: 1,
+    file,
+    summary: {
+      functions: functions.length,
+      externalFunctions: external?.length ?? 0,
+      cases: caseCount,
+      diagnostics: result.diagnostics.length
+    },
+    functions,
+    diagnostics: result.diagnostics.map((d) => ({
+      range: d.range,
+      severity: d.severity,
+      message: d.message,
+      ...d.code !== void 0 ? { code: d.code } : {},
+      ...d.suggestions ? { suggestions: d.suggestions } : {},
+      ...d.tags ? { tags: d.tags } : {},
+      ...d.origin ? { origin: d.origin } : {}
+    }))
+  };
+  if (external) json.externalFunctions = external;
+  return json;
+}
+
+// src/target-path.ts
+function isNudoTargetPath(path) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".d.ts")) return false;
+  return lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".ts");
+}
+
+// src/load-module.ts
+import { existsSync as existsSync4, statSync as statSync4, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname6, resolve as resolve5, join as join3 } from "path";
+function defaultLoadModule(spec, fromFile) {
+  if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
+  try {
+    const base = dirname6(resolve5(fromFile));
+    const p = resolve5(base, spec);
+    for (const cand of [
+      p,
+      `${p}.js`,
+      `${p}.mjs`,
+      `${p}.ts`,
+      join3(p, "index.js"),
+      join3(p, "index.mjs"),
+      join3(p, "index.ts")
+    ]) {
+      if (existsSync4(cand) && !statSync4(cand).isDirectory()) {
+        return readFileSync5(cand, "utf-8");
+      }
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/session-cache.ts
+import {
+  resetGeneralizeMemo,
+  resetCheckSourceMemo,
+  resetNudoModuleExecCache,
+  resetParseSourceCache
+} from "@nudojs/core";
+function evictAnalysisCachesForFiles(files) {
+  if (files.length === 0) return;
+  evictBPathCacheForFiles(files);
+  evictAnalysisFileCacheForFiles(files);
+  evictFnAnalysisCacheForFiles(files);
+  evictAbsModuleCacheFiles(files);
+}
+function clearAnalysisSessionCaches() {
+  clearBPathCache();
+  clearAbsModuleCache();
+  resetGeneralizeMemo();
+  resetCheckSourceMemo();
+  resetNudoModuleExecCache();
+}
+function resetAllAnalysisCaches() {
+  clearAnalysisSessionCaches();
+  resetParseSourceCache();
+}
+
+// src/harvest-node.ts
+import { existsSync as existsSync5 } from "fs";
+import { harvestDts as harvestDts2 } from "@nudojs/harvester";
+function harvestNodeTypes(fromDir, maxFiles = 12, maxMs = 2500) {
+  const root = resolvePackageRoot("@types/node", fromDir) ?? resolvePackageRoot("node", fromDir);
+  if (!root || !existsSync5(root)) {
+    return { ok: false, error: "@types/node not found" };
+  }
+  const dts = collectDtsFiles(root, maxFiles);
+  if (dts.length === 0) {
+    return { ok: false, error: `no .d.ts under ${root}` };
+  }
+  const env = harvestDts2(dts, { maxMs });
+  return { ok: true, env, root, files: env.stats.files };
 }
-function getCompletionsAtPosition(filePath, source, line, column) {
-  const textBefore = getTextBeforePosition(source, line, column);
-  const dotMatch = textBefore.match(/(\w+)\.\s*\w*$/);
-  if (!dotMatch) return getVariableCompletions(filePath, source);
-  const objName = dotMatch[1];
-  const safeSource = sanitizeSourceForParsing(source);
+function summarizeNodeEnv(env) {
+  return {
+    modules: Object.keys(env.modules).sort(),
+    globals: Object.keys(env.globals).sort().slice(0, 50),
+    symbolCount: env.stats.symbols
+  };
+}
+
+// src/semantic-tokens.ts
+import { dirname as dirname7 } from "path";
+import { createEnvironment as createEnvironment3 } from "@nudojs/core";
+import { parse as parse6 } from "@nudojs/parser";
+import {
+  evaluateProgram as evaluateProgram2,
+  setModuleResolver as setModuleResolver2,
+  setCurrentFileDir as setCurrentFileDir2,
+  resetMemo as resetMemo2
+} from "@nudojs/cli/evaluator";
+var SEMANTIC_TOKEN_TYPES = [
+  "function",
+  "variable",
+  "parameter",
+  "property",
+  "type",
+  "keyword",
+  "string",
+  "number",
+  "comment",
+  "decorator",
+  "method"
+];
+var SEMANTIC_TOKEN_MODIFIERS = [
+  "declaration",
+  "readonly",
+  "deprecated",
+  "unreachable"
+];
+function encodeSemanticTokens(tokens) {
+  const result = [];
+  let prevLine = 0;
+  let prevChar = 0;
+  for (const token of tokens) {
+    const deltaLine = token.line - prevLine;
+    const deltaChar = deltaLine === 0 ? token.char - prevChar : token.char;
+    result.push(deltaLine, deltaChar, token.length, token.typeIndex, token.modifierBitmask);
+    prevLine = token.line;
+    prevChar = token.char;
+  }
+  return result;
+}
+var TYPE_FUNCTION = SEMANTIC_TOKEN_TYPES.indexOf("function");
+var TYPE_VARIABLE = SEMANTIC_TOKEN_TYPES.indexOf("variable");
+var TYPE_PARAMETER = SEMANTIC_TOKEN_TYPES.indexOf("parameter");
+var TYPE_PROPERTY = SEMANTIC_TOKEN_TYPES.indexOf("property");
+var TYPE_METHOD = SEMANTIC_TOKEN_TYPES.indexOf("method");
+var MOD_DECLARATION = 1 << SEMANTIC_TOKEN_MODIFIERS.indexOf("declaration");
+function buildSemanticTokens(filePath, source) {
   let ast;
   try {
-    ast = parse(safeSource);
+    ast = parse6(source);
   } catch {
-    try {
-      ast = parse(source);
-    } catch {
-      return [];
-    }
-  }
-  resetMemo();
-  setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname(filePath));
-  const globalEnv = createEnvironment();
-  evaluateProgram(ast, globalEnv);
-  if (!globalEnv.has(objName)) {
-    setModuleResolver(null);
     return [];
   }
-  const objType = globalEnv.lookup(objName);
-  const completions = getCompletionsForType(objType);
-  setModuleResolver(null);
-  return completions;
-}
-function sanitizeSourceForParsing(source) {
-  return source.replace(/(\w+)\.\s*$/gm, "$1._ ");
-}
-function getTextBeforePosition(source, line, column) {
-  const lines = source.split("\n");
-  if (line < 1 || line > lines.length) return "";
-  return lines[line - 1].slice(0, column);
-}
-function getVariableCompletions(filePath, source) {
-  const ast = parse(source);
-  resetMemo();
-  setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname(filePath));
-  const globalEnv = createEnvironment();
-  evaluateProgram(ast, globalEnv);
-  const ownBindings = globalEnv.getOwnBindings();
-  const completions = [];
-  for (const [name, tv] of Object.entries(ownBindings)) {
-    if (name.startsWith("__export_")) continue;
-    completions.push({
-      label: name,
-      kind: tv.kind === "function" ? "method" : "variable",
-      detail: typeValueToString(tv)
-    });
+  const env = createEnvironment3();
+  resetMemo2();
+  setModuleResolver2(resolveModule);
+  setCurrentFileDir2(dirname7(filePath));
+  try {
+    evaluateProgram2(ast, env);
+  } catch {
+  } finally {
+    setModuleResolver2(null);
   }
-  setModuleResolver(null);
-  return completions;
-}
-function getCompletionsForType(tv) {
-  const completions = [];
-  if (tv.kind === "object") {
-    for (const [key, val] of Object.entries(tv.properties)) {
-      completions.push({
-        label: key,
-        kind: val.kind === "function" ? "method" : "property",
-        detail: typeValueToString(val)
-      });
+  const program = ast.program ?? ast;
+  const ownBindings = env.getOwnBindings();
+  const topLevelDeclarators = /* @__PURE__ */ new Set();
+  for (const stmt of program.body ?? []) {
+    const decl = stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration" ? stmt.declaration ?? null : stmt;
+    if (decl && decl.type === "VariableDeclaration") {
+      for (const d of decl.declarations) {
+        topLevelDeclarators.add(d);
+      }
     }
-    return completions;
   }
-  if (tv.kind === "instance") {
-    for (const [key, val] of Object.entries(tv.properties)) {
-      completions.push({
-        label: key,
-        kind: val.kind === "function" ? "method" : "property",
-        detail: typeValueToString(val)
-      });
+  const tokens = [];
+  const pushIdentifier = (id, typeIndex) => {
+    const loc = id.loc;
+    const name = id.name;
+    if (!loc || typeof name !== "string") return;
+    tokens.push({
+      line: loc.start.line - 1,
+      char: loc.start.column,
+      length: name.length,
+      typeIndex,
+      modifierBitmask: MOD_DECLARATION
+    });
+  };
+  const collectParams = (params) => {
+    for (const p of params) {
+      if (!p) continue;
+      if (p.type === "Identifier") pushIdentifier(p, TYPE_PARAMETER);
+      else if (p.type === "AssignmentPattern" && p.left?.type === "Identifier") {
+        pushIdentifier(p.left, TYPE_PARAMETER);
+      } else if (p.type === "RestElement" && p.argument?.type === "Identifier") {
+        pushIdentifier(p.argument, TYPE_PARAMETER);
+      }
     }
-    return completions;
-  }
-  if (tv.kind === "array" || tv.kind === "tuple") {
-    const arrayMethods = [
-      { label: "map", detail: "map(callback)" },
-      { label: "filter", detail: "filter(callback)" },
-      { label: "reduce", detail: "reduce(callback, init)" },
-      { label: "find", detail: "find(callback)" },
-      { label: "some", detail: "some(callback)" },
-      { label: "every", detail: "every(callback)" },
-      { label: "forEach", detail: "forEach(callback)" },
-      { label: "flatMap", detail: "flatMap(callback)" },
-      { label: "includes", detail: "includes(value)" },
-      { label: "indexOf", detail: "indexOf(value)" },
-      { label: "join", detail: "join(separator)" },
-      { label: "slice", detail: "slice(start, end)" },
-      { label: "concat", detail: "concat(other)" },
-      { label: "push", detail: "push(value)" },
-      { label: "length", detail: tv.kind === "tuple" ? `${tv.elements.length}` : "number" }
-    ];
-    for (const m of arrayMethods) {
-      completions.push({ label: m.label, kind: "method", detail: m.detail });
+  };
+  const isFunctionValue = (name) => ownBindings[name]?.kind === "function";
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    const n = node;
+    switch (n.type) {
+      case "VariableDeclarator": {
+        const id = n.id;
+        if (id?.type === "Identifier") {
+          const isTopLevel = topLevelDeclarators.has(node);
+          const typeIndex = isTopLevel && isFunctionValue(id.name) ? TYPE_FUNCTION : TYPE_VARIABLE;
+          pushIdentifier(id, typeIndex);
+        }
+        break;
+      }
+      case "FunctionDeclaration":
+      case "FunctionExpression": {
+        const id = n.id;
+        if (id?.type === "Identifier") pushIdentifier(id, TYPE_FUNCTION);
+        collectParams(n.params ?? []);
+        break;
+      }
+      case "ArrowFunctionExpression":
+        collectParams(n.params ?? []);
+        break;
+      case "ObjectMethod": {
+        const key = n.key;
+        if (key?.type === "Identifier" && !n.computed) pushIdentifier(key, TYPE_METHOD);
+        collectParams(n.params ?? []);
+        break;
+      }
+      case "ObjectProperty": {
+        const key = n.key;
+        const value = n.value;
+        if (key?.type === "Identifier" && !n.computed) {
+          const isFn = value?.type === "FunctionExpression" || value?.type === "ArrowFunctionExpression";
+          pushIdentifier(key, isFn ? TYPE_METHOD : TYPE_PROPERTY);
+        }
+        break;
+      }
     }
-    return completions;
-  }
-  if (tv.kind === "promise") {
-    completions.push({ label: "then", kind: "method", detail: "then(callback)" });
-    completions.push({ label: "catch", kind: "method", detail: "catch(callback)" });
-    completions.push({ label: "finally", kind: "method", detail: "finally(callback)" });
-    return completions;
-  }
-  if (tv.kind === "primitive" && tv.type === "string") {
-    const stringMethods = ["toUpperCase", "toLowerCase", "trim", "split", "slice", "includes", "indexOf", "replace", "startsWith", "endsWith", "charAt", "length"];
-    for (const m of stringMethods) {
-      completions.push({ label: m, kind: "method", detail: `string.${m}` });
+    for (const key of Object.keys(n)) {
+      if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") continue;
+      const child = n[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item && typeof item === "object" && typeof item.type === "string") {
+            visit(item);
+          }
+        }
+      } else if (child && typeof child === "object" && typeof child.type === "string") {
+        visit(child);
+      }
     }
-    return completions;
-  }
-  return completions;
+  };
+  visit(program);
+  tokens.sort((a, b) => a.line - b.line || a.char - b.char);
+  return encodeSemanticTokens(tokens);
 }
 
 // src/dts-generator.ts
-import { isTemplate, getTemplateParts } from "@nudojs/core";
+import { T as T3, isTemplate, getTemplateParts, simplifyUnion as simplifyUnion2, typeValueEquals, getFnSig as getFnSig4 } from "@nudojs/core";
 function typeValueToTSType(tv) {
   switch (tv.kind) {
     case "literal": {
@@ -487,8 +4078,10 @@ function typeValueToTSType(tv) {
       return `[${inner}]`;
     }
     case "function": {
-      const params = tv.params.map((p, i) => `${p}: unknown`).join(", ");
-      return `(${params}) => unknown`;
+      const params = tv.params.map((p) => `${p}: unknown`).join(", ");
+      const sig = getFnSig4(tv);
+      const retStr = sig?.returnType ? typeValueToTSType(sig.returnType) : "unknown";
+      return `(${params}) => ${retStr}`;
     }
     case "promise":
       return `Promise<${typeValueToTSType(tv.value)}>`;
@@ -507,33 +4100,671 @@ function wrapComplexType(tv) {
   if (tv.kind === "union") return `(${ts})`;
   return ts;
 }
+function getParamName(fn, index) {
+  if (fn.paramNames && fn.paramNames[index]) {
+    return fn.paramNames[index];
+  }
+  return `arg${index}`;
+}
+function widenLiteralToBase(tv) {
+  if (tv.kind !== "literal") return tv;
+  const v = tv.value;
+  if (typeof v === "number") return T3.number;
+  if (typeof v === "string") return T3.string;
+  if (typeof v === "boolean") return T3.boolean;
+  if (typeof v === "bigint") return T3.bigint;
+  return tv;
+}
+function widenTopLevel(tv) {
+  if (tv.kind !== "union") return widenLiteralToBase(tv);
+  return simplifyUnion2(tv.members.map(widenLiteralToBase));
+}
+function widenProperties(properties) {
+  const out = {};
+  for (const [k, v] of Object.entries(properties)) out[k] = widenParamType(v);
+  return out;
+}
+function widenParamType(tv) {
+  switch (tv.kind) {
+    case "literal":
+      return widenLiteralToBase(tv);
+    case "union":
+      return simplifyUnion2(tv.members.map(widenParamType));
+    case "tuple": {
+      const widened = tv.elements.map(widenParamType);
+      const first = widened[0];
+      if (first && widened.every((el) => typeValueEquals(el, first))) {
+        return T3.array(first);
+      }
+      return T3.tuple(widened);
+    }
+    case "array":
+      return T3.array(widenParamType(tv.element));
+    case "object":
+      return T3.object(widenProperties(tv.properties));
+    case "promise":
+      return T3.promise(widenParamType(tv.value));
+    case "instance":
+      return T3.instanceOf(tv.className, widenProperties(tv.properties));
+    case "refined":
+      return widenParamType(tv.base);
+    default:
+      return tv;
+  }
+}
+function widenedUnion(members) {
+  const flat = [];
+  const collect = (tv) => {
+    if (tv.kind === "union") {
+      tv.members.forEach(collect);
+      return;
+    }
+    flat.push(tv);
+  };
+  members.forEach(collect);
+  const widened = flat.map(widenParamType);
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = widened.filter((tv) => {
+    const key = typeValueToTSType(tv);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  return simplifyUnion2(deduped);
+}
+function computeMainSignature(fn) {
+  const arity = Math.max(...fn.cases.map((c) => c.args.length));
+  const minArity = Math.min(...fn.cases.map((c) => c.args.length));
+  const params = [];
+  const paramNames = [];
+  const paramTypes = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  for (let i = 0; i < arity; i++) {
+    const members = fn.cases.filter((c) => i < c.args.length).map((c) => c.args[i]);
+    const typeStr = typeValueToTSType(widenedUnion(members));
+    let name = getParamName(fn, i);
+    if (usedNames.has(name)) {
+      let n = 2;
+      while (usedNames.has(`${name}${n}`)) n++;
+      name = `${name}${n}`;
+    }
+    usedNames.add(name);
+    const optional = i >= minArity && !name.startsWith("...");
+    params.push(optional ? `${name}?: ${typeStr}` : `${name}: ${typeStr}`);
+    paramNames.push(name);
+    paramTypes.push(typeStr);
+  }
+  const combined = fn.combined ?? simplifyUnion2(fn.cases.map((c) => c.result));
+  const returnType = typeValueToTSType(widenTopLevel(combined));
+  return { params, paramNames, paramTypes, returnType };
+}
+function generateJSDoc(fn, sig) {
+  if (fn.cases.length === 0) return "";
+  const lines = ["/**"];
+  for (const c of fn.cases) {
+    const preciseDiffers = c.args.length !== sig.paramTypes.length || c.args.some((a, i) => typeValueToTSType(a) !== sig.paramTypes[i]) || typeValueToTSType(c.result) !== sig.returnType;
+    if (!preciseDiffers) continue;
+    const argsStr = c.args.map(typeValueToTSType).join(", ");
+    lines.push(` * Case: ${c.name} (${argsStr}) => ${typeValueToTSType(c.result)}`);
+  }
+  for (let i = 0; i < sig.paramTypes.length; i++) {
+    lines.push(` * @param ${sig.paramNames[i]} - ${sig.paramTypes[i]}`);
+  }
+  lines.push(` * @returns ${sig.returnType}`);
+  lines.push(" */");
+  return lines.join("\n");
+}
+function generateFunctionDtsLines(fn) {
+  if (fn.noDeclaration) return [];
+  if (fn.cases.length === 0) {
+    if (fn.combined) {
+      return [
+        `export declare function ${fn.name}(...args: unknown[]): ${typeValueToTSType(fn.combined)};`
+      ];
+    }
+    return [];
+  }
+  const sig = computeMainSignature(fn);
+  const jsdoc = generateJSDoc(fn, sig);
+  const lines = [];
+  if (jsdoc) lines.push(jsdoc);
+  lines.push(`export declare function ${fn.name}(${sig.params.join(", ")}): ${sig.returnType};`);
+  return lines;
+}
 function generateDts(result) {
   const lines = [];
   for (const fn of result.functions) {
-    if (fn.cases.length === 0 && fn.combined) {
-      lines.push(`export declare function ${fn.name}(...args: unknown[]): ${typeValueToTSType(fn.combined)};`);
+    lines.push(...generateFunctionDtsLines(fn));
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/schema-generator.ts
+function typeValueToZodSchema(tv) {
+  switch (tv.kind) {
+    case "literal": {
+      if (tv.value === null) return "z.null()";
+      if (tv.value === void 0) return "z.undefined()";
+      if (typeof tv.value === "string") return `z.literal(${JSON.stringify(tv.value)})`;
+      if (typeof tv.value === "boolean") return `z.literal(${tv.value})`;
+      return `z.literal(${tv.value})`;
+    }
+    case "primitive":
+      return `z.${tv.type}()`;
+    case "refined":
+      return typeValueToZodSchema(tv.base);
+    case "object": {
+      const entries = Object.entries(tv.properties).map(([k, v]) => `${k}: ${typeValueToZodSchema(v)}`).join(", ");
+      return `z.object({ ${entries} })`;
+    }
+    case "array":
+      return `z.array(${typeValueToZodSchema(tv.element)})`;
+    case "tuple": {
+      const inner = tv.elements.map(typeValueToZodSchema).join(", ");
+      return `z.tuple([${inner}])`;
+    }
+    case "function":
+      return "z.function()";
+    case "promise":
+      return `z.promise(${typeValueToZodSchema(tv.value)})`;
+    case "instance":
+      return `z.instanceof(${tv.className})`;
+    case "union": {
+      const members = tv.members.map(typeValueToZodSchema).join(", ");
+      return `z.union([${members}])`;
+    }
+    case "never":
+      return "z.never()";
+    case "unknown":
+      return "z.unknown()";
+  }
+}
+
+// src/guard-generator.ts
+import { denoteGuard } from "@nudojs/core";
+function generateGuardFunction(name, tv) {
+  const body = generateGuardBody(tv, "data");
+  return `export function ${name}(data) {
+  return ${body};
+}`;
+}
+function generateGuardFunctionFromAbs(name, abs) {
+  const body = denoteGuard(abs, "data");
+  return `export function ${name}(data) {
+  return ${body};
+}`;
+}
+function generateGuardBody(tv, varName) {
+  switch (tv.kind) {
+    case "literal": {
+      if (tv.value === null) return `${varName} === null`;
+      if (tv.value === void 0) return `${varName} === undefined`;
+      return `${varName} === ${JSON.stringify(tv.value)}`;
+    }
+    case "primitive":
+      return `typeof ${varName} === '${tv.type}'`;
+    case "refined":
+      return generateGuardBody(tv.base, varName);
+    case "object": {
+      const checks = [`typeof ${varName} === 'object'`, `${varName} !== null`];
+      for (const [key, val] of Object.entries(tv.properties)) {
+        checks.push(generateGuardBody(val, `${varName}.${key}`));
+      }
+      return checks.join(" && ");
+    }
+    case "array":
+      return `Array.isArray(${varName}) && ${varName}.every(item => ${generateGuardBody(tv.element, "item")})`;
+    case "tuple": {
+      const checks = [`Array.isArray(${varName})`, `${varName}.length === ${tv.elements.length}`];
+      tv.elements.forEach((el, i) => {
+        checks.push(generateGuardBody(el, `${varName}[${i}]`));
+      });
+      return checks.join(" && ");
+    }
+    case "union": {
+      const members = tv.members.map((m) => generateGuardBody(m, varName));
+      return `(${members.join(" || ")})`;
+    }
+    case "never":
+      return "false";
+    case "unknown":
+      return "true";
+    case "function":
+      return `typeof ${varName} === 'function'`;
+    case "promise":
+      return `${varName} instanceof Promise`;
+    case "instance":
+      return `${varName} instanceof ${tv.className}`;
+  }
+}
+
+// src/case-emitter.ts
+import { parse as parse7, extractDirectives as extractDirectives2 } from "@nudojs/parser";
+var GENERATED_PREFIX = "call@";
+var GENERATED_CASE_LINE_REGEX = /^\s*\*?\s*@nudo:case\s+"(call@[^"]*)"/;
+var IDENT_KEY_REGEX = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var NUMBER_LITERAL_REGEX = /^-?\d+(\.\d+)?$/;
+var UNSAFE_STRING_CHARS = /[,()[\]{}]/;
+var UNSAFE_KEY_CHARS = /[,()[\]{}:]/;
+var CONTROL_CHARS = /[\x00-\x1f\x7f]/;
+function serializeStringLiteral(value) {
+  if (CONTROL_CHARS.test(value)) return null;
+  if (value.includes("*/")) return null;
+  if (UNSAFE_STRING_CHARS.test(value)) return null;
+  const hasDbl = value.includes('"');
+  const hasSgl = value.includes("'");
+  if (hasDbl && hasSgl) return null;
+  return hasDbl ? `'${value}'` : `"${value}"`;
+}
+function serializeObjectKey(key) {
+  if (IDENT_KEY_REGEX.test(key)) return key;
+  if (CONTROL_CHARS.test(key)) return null;
+  if (key.includes('"')) return null;
+  if (UNSAFE_KEY_CHARS.test(key) || key.includes("*/")) return null;
+  if (/^['"]|['"]$/.test(key)) return null;
+  return `"${key}"`;
+}
+function serializeCaseArg(tv) {
+  switch (tv.kind) {
+    case "primitive":
+      if (tv.type === "number" || tv.type === "string" || tv.type === "boolean") {
+        return `T.${tv.type}`;
+      }
+      return null;
+    case "unknown":
+      return "T.unknown";
+    case "never":
+      return "T.never";
+    case "literal": {
+      const v = tv.value;
+      if (typeof v === "number") {
+        if (!Number.isFinite(v)) return null;
+        const s = String(v);
+        return NUMBER_LITERAL_REGEX.test(s) ? s : null;
+      }
+      if (typeof v === "boolean") return v ? "true" : "false";
+      if (v === null) return "null";
+      if (v === void 0) return "undefined";
+      if (typeof v === "bigint") return null;
+      return serializeStringLiteral(v);
+    }
+    case "union": {
+      const parts = [];
+      for (const member of tv.members) {
+        const s = serializeCaseArg(member);
+        if (s === null) return null;
+        parts.push(s);
+      }
+      return `T.union(${parts.join(", ")})`;
+    }
+    case "array": {
+      const el = serializeCaseArg(tv.element);
+      return el === null ? null : `T.array(${el})`;
+    }
+    case "tuple": {
+      const parts = [];
+      for (const el of tv.elements) {
+        const s = serializeCaseArg(el);
+        if (s === null) return null;
+        parts.push(s);
+      }
+      return `[${parts.join(", ")}]`;
+    }
+    case "object": {
+      const parts = [];
+      for (const [key, value] of Object.entries(tv.properties)) {
+        const vs = serializeCaseArg(value);
+        if (vs === null) return null;
+        const ks = serializeObjectKey(key);
+        if (ks === null) return null;
+        parts.push(`${ks}: ${vs}`);
+      }
+      return parts.length === 0 ? "{}" : `{ ${parts.join(", ")} }`;
+    }
+    default:
+      return null;
+  }
+}
+function buildCaseDirective(name, args) {
+  if (name.includes('"') || /[\r\n]/.test(name)) return null;
+  const parts = [];
+  for (const arg of args) {
+    const s = serializeCaseArg(arg);
+    if (s === null) return null;
+    parts.push(s);
+  }
+  return ` * @nudo:case "${name}" (${parts.join(", ")})`;
+}
+function stripGeneratedCaseDirectives(source) {
+  const lines = source.split("\n");
+  const removed = [];
+  const drop = new Array(lines.length).fill(false);
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(GENERATED_CASE_LINE_REGEX);
+    if (m) {
+      drop[i] = true;
+      removed.push(m[1]);
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    if (!/^\s*\/\*\*\s*$/.test(lines[i])) continue;
+    let j = i + 1;
+    let clean = true;
+    while (j < lines.length) {
+      if (/\*\//.test(lines[j])) break;
+      if (/\/\*/.test(lines[j])) {
+        clean = false;
+        break;
+      }
+      j++;
+    }
+    if (!clean || j >= lines.length) continue;
+    if (!/^\s*\*\/\s*$/.test(lines[j])) continue;
+    let onlyFiller = true;
+    for (let k = i + 1; k < j; k++) {
+      if (drop[k]) continue;
+      const t = lines[k].trim();
+      if (t !== "" && !/^\*{1,2}$/.test(t)) {
+        onlyFiller = false;
+        break;
+      }
+    }
+    if (onlyFiller) {
+      for (let k = i; k <= j; k++) drop[k] = true;
+    }
+  }
+  return {
+    source: lines.filter((_, i) => !drop[i]).join("\n"),
+    removed
+  };
+}
+function collectExistingCases(source) {
+  const byName = /* @__PURE__ */ new Map();
+  let ast;
+  try {
+    ast = parse7(source, { errorRecovery: true });
+  } catch {
+    return byName;
+  }
+  for (const { name, directives } of extractDirectives2(ast)) {
+    for (const d of directives) {
+      if (d.kind !== "case") continue;
+      const list = byName.get(name);
+      if (list) list.push(d);
+      else byName.set(name, [d]);
+    }
+  }
+  return byName;
+}
+function insertGeneratedCaseDirectives(source, analysis) {
+  const written = [];
+  const skipped = [];
+  const existing = collectExistingCases(source);
+  const edits = [];
+  for (const fn of analysis.functions) {
+    const existingCases = existing.get(fn.name) ?? [];
+    if (existingCases.some((c) => !c.name.startsWith(GENERATED_PREFIX))) {
+      skipped.push({ fn: fn.name, reason: "hand-written" });
+      continue;
+    }
+    if (existingCases.length > 0) {
+      skipped.push({ fn: fn.name, reason: "already-generated" });
+      continue;
+    }
+    if (fn.skipped) {
+      skipped.push({ fn: fn.name, reason: "skipped" });
+      continue;
+    }
+    if (fn.noDeclaration) {
+      skipped.push({ fn: fn.name, reason: "no-declaration" });
+      continue;
+    }
+    if (fn.entryOnly) {
+      skipped.push({ fn: fn.name, reason: "entry-only" });
+      continue;
+    }
+    const callsiteCases = fn.cases.filter((c) => c.source === "callsite");
+    if (callsiteCases.length === 0) {
+      skipped.push({ fn: fn.name, reason: "no-serializable-cases", detail: "no callsite cases" });
       continue;
     }
-    if (fn.cases.length === 1) {
-      const c = fn.cases[0];
-      const params = c.args.map((a, i) => `arg${i}: ${typeValueToTSType(a)}`).join(", ");
-      const ret = typeValueToTSType(c.result);
-      lines.push(`export declare function ${fn.name}(${params}): ${ret};`);
+    const built = [];
+    const names = [];
+    for (const c of callsiteCases) {
+      const directive = buildCaseDirective(c.name, c.args);
+      if (directive === null) {
+        skipped.push({ fn: fn.name, reason: "no-serializable-cases", detail: `case ${c.name} not serializable` });
+      } else {
+        built.push(directive);
+        names.push(c.name);
+      }
+    }
+    if (built.length === 0) continue;
+    edits.push({ line: fn.loc.start.line, column: fn.loc.start.column, directives: built, fn: fn.name });
+    written.push({ fn: fn.name, cases: names });
+  }
+  edits.sort((a, b) => b.line - a.line);
+  const lines = source.split("\n");
+  for (const edit of edits) {
+    const declIdx = edit.line - 1;
+    const indent = " ".repeat(edit.column);
+    let insertIdx = -1;
+    let blockIndent = "";
+    const aboveIdx = declIdx - 1;
+    if (aboveIdx >= 0 && /^\s*\*\/\s*$/.test(lines[aboveIdx])) {
+      let s = aboveIdx - 1;
+      while (s >= 0) {
+        const t = lines[s];
+        if (/^\s*\/\*\*/.test(t)) {
+          insertIdx = s + 1;
+          blockIndent = t.match(/^\s*/)?.[0] ?? "";
+          break;
+        }
+        if (/^\s*\*/.test(t) || t.trim() === "") {
+          s--;
+          continue;
+        }
+        break;
+      }
+    }
+    if (insertIdx >= 0) {
+      lines.splice(insertIdx, 0, ...edit.directives.map((d) => blockIndent + d));
+    } else {
+      lines.splice(declIdx, 0, `${indent}/**`, ...edit.directives.map((d) => indent + d), `${indent} */`);
+    }
+  }
+  return {
+    source: lines.join("\n"),
+    changed: written.length > 0,
+    written,
+    skipped
+  };
+}
+function diffOps(a, b) {
+  let start = 0;
+  while (start < a.length && start < b.length && a[start] === b[start]) start++;
+  let endA = a.length;
+  let endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+    endA--;
+    endB--;
+  }
+  const midA = a.slice(start, endA);
+  const midB = b.slice(start, endB);
+  const n = midA.length;
+  const m = midB.length;
+  const dp = new Int32Array((n + 1) * (m + 1));
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      dp[i2 * (m + 1) + j2] = midA[i2] === midB[j2] ? dp[(i2 + 1) * (m + 1) + (j2 + 1)] + 1 : Math.max(dp[(i2 + 1) * (m + 1) + j2], dp[i2 * (m + 1) + (j2 + 1)]);
+    }
+  }
+  const ops = [];
+  for (let k = 0; k < start; k++) ops.push({ type: "equal", text: a[k] });
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (midA[i] === midB[j]) {
+      ops.push({ type: "equal", text: midA[i] });
+      i++;
+      j++;
+    } else if (dp[(i + 1) * (m + 1) + j] >= dp[i * (m + 1) + (j + 1)]) {
+      ops.push({ type: "delete", text: midA[i] });
+      i++;
+    } else {
+      ops.push({ type: "insert", text: midB[j] });
+      j++;
+    }
+  }
+  while (i < n) ops.push({ type: "delete", text: midA[i++] });
+  while (j < m) ops.push({ type: "insert", text: midB[j++] });
+  for (let k = endA; k < a.length; k++) ops.push({ type: "equal", text: a[k] });
+  return ops;
+}
+var DIFF_CONTEXT = 3;
+function formatRange(start, count) {
+  const s = count === 0 ? start - 1 : start;
+  return count === 1 ? `${s}` : `${s},${count}`;
+}
+function unifiedDiff(a, b, path) {
+  if (a === b) return "";
+  const ops = diffOps(a.split("\n"), b.split("\n"));
+  const hunks = [];
+  let idx = 0;
+  while (idx < ops.length) {
+    if (ops[idx].type === "equal") {
+      idx++;
       continue;
     }
-    for (const c of fn.cases) {
-      const params = c.args.map((a, i) => `arg${i}: ${typeValueToTSType(a)}`).join(", ");
-      const ret = typeValueToTSType(c.result);
-      lines.push(`export declare function ${fn.name}(${params}): ${ret};`);
+    let start = idx;
+    let ctx = 0;
+    while (start > 0 && ops[start - 1].type === "equal" && ctx < DIFF_CONTEXT) {
+      start--;
+      ctx++;
+    }
+    let j = idx;
+    let equalRun = 0;
+    let lastChange = idx;
+    while (j < ops.length) {
+      if (ops[j].type === "equal") {
+        equalRun++;
+        if (equalRun > DIFF_CONTEXT * 2) break;
+      } else {
+        equalRun = 0;
+        lastChange = j;
+      }
+      j++;
+    }
+    let end = lastChange + 1;
+    ctx = 0;
+    while (end < ops.length && ops[end].type === "equal" && ctx < DIFF_CONTEXT) {
+      end++;
+      ctx++;
     }
+    hunks.push({ start, ops: ops.slice(start, end) });
+    idx = end;
   }
-  return lines.join("\n") + "\n";
+  const out = [`--- a/${path}`, `+++ b/${path}`];
+  for (let h = 0; h < hunks.length; h++) {
+    const { start, ops: hunkOps } = hunks[h];
+    let oldCount = 0;
+    let newCount = 0;
+    for (let k = 0; k < start; k++) {
+      if (ops[k].type !== "insert") oldCount++;
+      if (ops[k].type !== "delete") newCount++;
+    }
+    let dels = 0;
+    let ins = 0;
+    for (const op of hunkOps) {
+      if (op.type === "delete") dels++;
+      else if (op.type === "insert") ins++;
+      else {
+        dels++;
+        ins++;
+      }
+    }
+    out.push(`@@ -${formatRange(oldCount + 1, dels)} +${formatRange(newCount + 1, ins)} @@`);
+    for (const op of hunkOps) {
+      const prefix = op.type === "equal" ? " " : op.type === "delete" ? "-" : "+";
+      out.push(prefix + op.text);
+    }
+  }
+  return out.join("\n") + "\n";
 }
 export {
+  SEMANTIC_TOKEN_MODIFIERS,
+  SEMANTIC_TOKEN_TYPES,
+  analyzeExportsFromSource,
   analyzeFile,
+  analyzeFileAsync,
+  autoHarvestModules,
+  barePackageName,
+  bareSpecToAbsModules,
+  buildCaseDirective,
+  buildModuleGraph,
+  buildSemanticTokens,
+  clearAbsModuleCache,
+  clearAnalysisFileCache,
+  clearAnalysisSessionCaches,
+  clearBPathCache,
+  clearFnAnalysisCache,
+  clearHarvestCache,
+  collectAbsBindingsFromGraph,
+  collectAbsInlays,
+  collectBPathDiagnostics,
+  collectBPathReplacements,
+  collectBarePackages,
+  collectCallRecords,
+  collectDependencySpecs,
+  collectDtsFromEntry,
+  collectEnvGlobals,
+  collectEnvModules,
+  collectStaticImports,
+  computeDirtySet,
+  defaultAbsLoadModule,
+  defaultLoadModule,
+  encodeSemanticTokens,
+  envValueToAbs,
+  evalAbsModuleGraph,
+  evalProgramAbsWithModules,
+  evictAbsModuleCacheFiles,
+  evictAnalysisCachesForFiles,
+  evictAnalysisFileCacheForFiles,
+  evictBPathCacheForFiles,
+  evictFnAnalysisCacheForFiles,
+  formatHarvestSummary,
   generateDts,
+  generateFunctionDtsLines,
+  generateGuardFunction,
+  generateGuardFunctionFromAbs,
+  getAnalysisFileCacheSize,
   getCasesForFile,
   getCompletionsAtPosition,
+  getHoverAtPosition,
   getTypeAtPosition,
-  typeValueToTSType
+  getTypeAtPositionAsync,
+  harvestNodeTypes,
+  harvestPackage,
+  harvestPackageCached,
+  harvestToAbsModules,
+  harvestedValueToAbs,
+  insertGeneratedCaseDirectives,
+  isBPathCapable,
+  isNudoTargetPath,
+  lookupHarvested,
+  mockDirectivesToAbsSeeds,
+  packageHarvestToAbsModules,
+  resetAllAnalysisCaches,
+  resolvePackageRoot,
+  serializeCaseArg,
+  serializeInferJson,
+  stripGeneratedCaseDirectives,
+  summarizeNodeEnv,
+  topoSortDirty,
+  tryBPathCall,
+  tryBPathCallFull,
+  tryRunBPath,
+  typeValueToTSType,
+  typeValueToZodSchema,
+  unifiedDiff
 };