@nudojs/service 1.0.0 → 1.0.1

package/dist/index.js

@@ -1,79 +1,169 @@
 import {
-  BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS,
-  USAGE_SITE_MODULE,
-  evaluate,
-  evaluateFunction,
-  evaluateFunctionFull,
-  evaluateProgram,
+  builtinProtoMember,
+  builtinProtoMemberNames,
+  describeAbsMember,
   findProjectConfig,
-  getUnreachableRanges,
   interfaceConfig,
   loadEnvs,
-  memberMayExistOn,
-  preloadPathEnvs,
-  resetEnvModules,
-  resetMemo,
-  resetMockModules,
-  resetUnreachableRanges,
-  resolveNpmNudo,
-  setCallCollector,
-  setCurrentFileDir,
-  setCurrentSource,
-  setEnvModules,
-  setMockModules,
-  setModuleResolver,
-  setNodeTypeCollector,
-  setProvenanceTracking,
-  setSampleCount,
-  setUnknownBuiltinHandler,
-  setUnknownCollector,
-  setUsageSiteTag
-} from "./chunk-FSIHAE7I.js";
+  matchesEmitAllowlist,
+  preloadPathEnvs
+} from "./chunk-2VHITMTM.js";
 
 // src/analyzer.ts
 import { readFileSync as readFileSync5, existsSync as existsSync4, statSync as statSync4, realpathSync } from "fs";
 import { resolve as resolve5, dirname as dirname6 } from "path";
 import traverse from "@babel/traverse";
 import {
-  T as T2,
-  typeValueToString as typeValueToString3,
-  simplifyUnion,
-  widenLiteral,
-  collapseLiteralUnion,
   createEnvironment as createEnvironment2,
-  isSubtypeOf,
-  mockHelperToTypeValue,
   generalizeFromAst as generalizeFromAst2,
   termToString,
   predToString,
-  analyzeFn,
+  analyzeFnFull,
   evalProgramAbs as evalProgramAbs2,
+  callFunctionFull,
   setAbsCallCollector,
+  unknown as absUnknown2,
   setAbsNodeCollector,
-  absFunction as absFunction5,
+  absFunction as absFunction4,
   checkInjectedDomainEvidence,
-  typeValueToAbs as typeValueToAbs5,
-  absToTypeValue as absToTypeValue2,
-  formatAbs as formatAbs3,
+  formatAbs as formatAbs4,
   formatAbsMultiline,
+  formatShape as formatShape2,
+  leqAbs,
+  numLit,
+  strLit,
+  boolLit,
+  abs as makeAbsVal,
   stableAnalyzeKeySource as stableAnalyzeKeySource2,
   fnFingerprints
 } from "@nudojs/core";
-import { parse as parse5, extractDirectives, extractFileDirectives, parseTypeValueExpr as parseTypeValueExpr2 } from "@nudojs/parser";
+import { parse as parse5, extractDirectives, extractFileDirectives } from "@nudojs/parser";
+
+// src/evaluator/call-record.ts
+import { formatAbs, joinAbs, litValue } from "@nudojs/core";
+var neverAbs = { shape: { k: "never" }, conf: "exact" };
+var undefAbs = {
+  shape: { k: "unknown" },
+  term: { op: "lit", value: void 0 },
+  conf: "exact"
+};
+function absStructureKey(a) {
+  const v = litValue(a);
+  if (v !== void 0) return `L:${typeof v}:${String(v)}`;
+  if (a.term?.op === "lit") return `L:${typeof a.term.value}:${String(a.term.value)}`;
+  try {
+    return formatAbs(a);
+  } catch {
+    return a.shape.k;
+  }
+}
+function shapeNodeCount(a, seen) {
+  if (!a || typeof a !== "object") return 1;
+  if (seen.has(a)) return 0;
+  seen.add(a);
+  const s = a.shape;
+  switch (s.k) {
+    case "arr":
+      return 1 + shapeNodeCount(s.element, seen);
+    case "tuple":
+      return 1 + s.elements.reduce((acc, e) => acc + shapeNodeCount(e, seen), 0);
+    case "obj": {
+      let n = 1;
+      for (const slot of Object.values(s.slots)) n += shapeNodeCount(slot.value, seen);
+      return n;
+    }
+    case "eff":
+      return 1 + shapeNodeCount(s.inner, seen);
+    case "sum":
+      return 1 + s.members.reduce((acc, e) => acc + shapeNodeCount(e, seen), 0);
+    case "brand":
+      return 1 + shapeNodeCount(s.shape, seen);
+    case "fn": {
+      let n = 1;
+      for (const p of s.paramTypes ?? []) n += shapeNodeCount(p, seen);
+      if (s.returnType) n += shapeNodeCount(s.returnType, seen);
+      return n;
+    }
+    default:
+      return 1;
+  }
+}
+var MAX_RECORD_TYPE_NODES = 2e3;
+function absNodeCount(a, seen = /* @__PURE__ */ new Set()) {
+  return shapeNodeCount(a, seen);
+}
+function isOversizedCallRecord(rec) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const a of rec.argAbs) {
+    if (absNodeCount(a, seen) > MAX_RECORD_TYPE_NODES) return true;
+  }
+  return absNodeCount(rec.resultAbs, seen) > MAX_RECORD_TYPE_NODES;
+}
+function isLeakedCallRecord(rec) {
+  return rec.resultAbs.shape.k === "never" && rec.throwsAbs.shape.k === "never";
+}
+function joinAllAbs(members) {
+  if (members.length === 0) return neverAbs;
+  return members.reduce((a, b) => joinAbs(a, b));
+}
+function isPrimLit(a) {
+  return a.shape.k === "prim" && a.term?.op === "lit";
+}
+function widenAbsPrim(a) {
+  if (a.shape.k === "prim" && a.term?.op === "lit") {
+    return { shape: a.shape, conf: a.conf === "exact" ? "path" : a.conf };
+  }
+  return a;
+}
+function collapseAbsLits(members, maxLits) {
+  const uniq = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of members) {
+    if (m.shape.k === "never") continue;
+    const k = absStructureKey(m);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    uniq.push(m);
+  }
+  if (uniq.length === 0) return neverAbs;
+  if (uniq.length === 1) return uniq[0];
+  const nonLitPrims = /* @__PURE__ */ new Set();
+  for (const m of uniq) {
+    if (m.shape.k === "prim" && m.term?.op !== "lit") {
+      nonLitPrims.add(m.shape.type);
+    }
+  }
+  if (nonLitPrims.size > 0) {
+    const absorbed = uniq.filter(
+      (m) => !(m.shape.k === "prim" && m.term?.op === "lit" && nonLitPrims.has(m.shape.type))
+    );
+    if (absorbed.length !== uniq.length) {
+      return collapseAbsLits(absorbed, maxLits);
+    }
+  }
+  if (uniq.length > maxLits && uniq.every(isPrimLit)) {
+    const t = uniq[0].shape.type;
+    if (uniq.every((m) => m.shape.k === "prim" && m.shape.type === t)) {
+      return { shape: { k: "prim", type: t }, conf: "path" };
+    }
+  }
+  return { shape: { k: "sum", members: uniq }, conf: "exact" };
+}
+function widenJoinAbs(members) {
+  return widenAbsPrim(joinAllAbs(members));
+}
 
 // src/mock-abs.ts
-import { parseTypeValueExpr } from "@nudojs/parser";
+import { parseCaseArgExpr } from "@nudojs/parser";
 import {
   absFunction,
   emptyEnv,
-  typeValueToAbs,
   abs as makeAbs,
   confJoin,
   unknown as absUnknown,
-  litValue,
-  formatAbs,
-  getFnImpl,
-  typeValueToString
+  litValue as litValue2,
+  formatAbs as formatAbs2,
+  getFnImpl
 } from "@nudojs/core";
 function markMockConf(a) {
   a.conf = confJoin(a.conf, "mock");
@@ -120,7 +210,7 @@ function constantMockFn(result) {
   };
   let retKey;
   try {
-    retKey = formatAbs(marked);
+    retKey = formatAbs2(marked);
   } catch {
     retKey = "?";
   }
@@ -131,17 +221,16 @@ function constantMockFn(result) {
 }
 function absArgMatches(declared, actual) {
   if (!actual) return false;
-  const declaredAbs = typeValueToAbs(declared);
-  const av = litValue(actual);
-  const dv = litValue(declaredAbs);
+  const av = litValue2(actual);
+  const dv = litValue2(declared);
   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 (declared.shape.k === "prim") {
+    if (actual.shape.k === "prim") return actual.shape.type === declared.shape.type;
     if (av !== void 0) {
       const t = typeof av;
-      return declared.type === "number" && t === "number" || declared.type === "string" && t === "string" || declared.type === "boolean" && t === "boolean" || declared.type === "bigint" && t === "bigint";
+      return declared.shape.type === "number" && t === "number" || declared.shape.type === "string" && t === "string" || declared.shape.type === "boolean" && t === "boolean" || declared.shape.type === "bigint" && t === "bigint";
     }
   }
   return false;
@@ -150,7 +239,7 @@ function dispatchMockFn(defaultReturn, cases) {
   if (!cases?.length) return constantMockFn(defaultReturn);
   const caseAbs = cases.map((c) => ({
     declared: c.args,
-    result: markMockConf(typeValueToAbs(c.returnValue))
+    result: markMockConf(c.returnValue)
   }));
   const dummyBody = {
     type: "BlockStatement",
@@ -159,12 +248,12 @@ function dispatchMockFn(defaultReturn, cases) {
   const markedDefault = markMockConf(defaultReturn);
   let defaultKey;
   try {
-    defaultKey = formatAbs(markedDefault);
+    defaultKey = formatAbs2(markedDefault);
   } catch {
     defaultKey = "?";
   }
   const caseKey = cases.map(
-    (c) => `${c.args.map((a) => typeValueToString(a)).join(",")}->${typeValueToString(c.returnValue)}`
+    (c) => `${c.args.map((a) => formatAbs2(a)).join(",")}->${formatAbs2(c.returnValue)}`
   ).join("|");
   return stampFingerprint(
     markMockConf(
@@ -185,18 +274,17 @@ function dispatchMockFn(defaultReturn, cases) {
   );
 }
 function absFromMockHelper(h) {
-  if (h.callsFakeImpl && h.callsFakeImpl.kind === "function") {
-    const fn = h.callsFakeImpl;
-    const body = fn.body;
+  if (h.callsFakeImpl) {
+    const { params, body, async } = h.callsFakeImpl;
     return stampFingerprint(
-      absFunction(fn.params, { body, async: false }),
-      `fake=${fn.params.join(",")}:${astContentKey(body)}`
+      absFunction(params, { body, async: async ?? false }),
+      `fake=${params.join(",")}:${astContentKey(body)}`
     );
   }
   let defaultReturn;
   if (h.resolvedValue) {
     defaultReturn = makeAbs(
-      { k: "eff", eff: "promise", inner: typeValueToAbs(h.resolvedValue) },
+      { k: "eff", eff: "promise", inner: h.resolvedValue },
       void 0,
       void 0,
       "path"
@@ -204,9 +292,9 @@ function absFromMockHelper(h) {
   } else if (h.rejectedValue) {
     defaultReturn = makeAbs({ k: "never" }, void 0, void 0, "exact");
   } else if (h.returnValue) {
-    defaultReturn = typeValueToAbs(h.returnValue);
+    defaultReturn = h.returnValue;
   } else if (h.onFirstCallValue) {
-    defaultReturn = typeValueToAbs(h.onFirstCallValue);
+    defaultReturn = h.onFirstCallValue;
   } else {
     defaultReturn = absUnknown;
   }
@@ -216,7 +304,7 @@ function absFromSinon(sinonExpr) {
   if (sinonExpr.resolvedValue) {
     return constantMockFn(
       makeAbs(
-        { k: "eff", eff: "promise", inner: typeValueToAbs(sinonExpr.resolvedValue) },
+        { k: "eff", eff: "promise", inner: sinonExpr.resolvedValue },
         void 0,
         void 0,
         "path"
@@ -227,7 +315,7 @@ function absFromSinon(sinonExpr) {
     return constantMockFn(makeAbs({ k: "never" }, void 0, void 0, "exact"));
   }
   if (sinonExpr.returnValue) {
-    return constantMockFn(typeValueToAbs(sinonExpr.returnValue));
+    return constantMockFn(sinonExpr.returnValue);
   }
   return constantMockFn(absUnknown);
 }
@@ -258,7 +346,7 @@ function mockDirectivesToAbsSeeds(functions) {
         seedVars[d.name] = markMockConf(absFromSinon(d.sinonExpr));
       } else if (d.expression) {
         try {
-          seedVars[d.name] = typeValueToAbs(parseTypeValueExpr(d.expression));
+          seedVars[d.name] = parseCaseArgExpr(d.expression);
         } catch {
           seedVars[d.name] = absUnknown;
         }
@@ -295,6 +383,23 @@ function defaultLoadModule(spec, fromFile) {
   }
 }
 
+// src/abs-modules-graph.ts
+import { readFileSync as readFileSync4, statSync as statSync3 } from "fs";
+import { dirname as dirname5, resolve as resolve4 } from "path";
+import { parse as parse3 } from "@nudojs/parser";
+import {
+  evalProgramAbs,
+  collectAbsExports,
+  absFunction as absFunction3
+} from "@nudojs/core";
+
+// src/harvest-to-abs.ts
+import {
+  confJoin as confJoin2,
+  absFunction as absFunction2
+} from "@nudojs/core";
+import { dirname as dirname4 } from "path";
+
 // src/harvest-auto.ts
 import { parse as parse2 } from "@nudojs/parser";
 
@@ -462,7 +567,7 @@ function collectStaticImports(entryFile, maxDepth = 8) {
 import { existsSync as existsSync3, readdirSync, statSync as statSync2, readFileSync as readFileSync3 } from "fs";
 import { join as join3, resolve as resolve3, dirname as dirname3, basename } from "path";
 import { harvestDts } from "@nudojs/harvester";
-import { typeValueToString as typeValueToString2 } from "@nudojs/core";
+import { formatShape } from "@nudojs/core";
 function resolvePackageRoot(pkg, fromDir = process.cwd()) {
   let dir = resolve3(fromDir);
   const bare = pkg.replace(/^@/, "").replace(/\//g, "__");
@@ -599,9 +704,9 @@ function formatHarvestSummary(h) {
 }
 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);
+  const a = mod?.[exportName] ?? h.env.globals[exportName];
+  if (!a) return void 0;
+  return formatShape(a);
 }
 
 // src/harvest-auto.ts
@@ -665,35 +770,15 @@ function autoHarvestModules(source, fromDir) {
   return modules;
 }
 
-// src/abs-modules-graph.ts
-import { readFileSync as readFileSync4, statSync as statSync3 } from "fs";
-import { dirname as dirname5, resolve as resolve4 } 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 dirname4 } 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}`);
+function harvestedValueToAbs(a) {
+  if (a.shape.k === "fn") {
+    const ret = a.shape.returnType ?? { shape: { k: "unknown" }, conf: "mock" };
+    const params = a.shape.params.length ? a.shape.params : a.shape.paramTypes?.map((_, i) => `_arg${i}`) ?? ["...args"];
     const dummyBody = {
       type: "BlockStatement",
       body: [],
@@ -702,11 +787,11 @@ function harvestedValueToAbs(tv) {
     return markMockConf2(
       absFunction2(params, {
         body: dummyBody,
-        apply: () => ret
+        apply: () => markMockConf2({ ...ret })
       })
     );
   }
-  return markMockConf2(typeValueToAbs2(tv));
+  return markMockConf2({ ...a });
 }
 function harvestToAbsModules(pkg, fromDir) {
   const h = harvestPackageCached(pkg, fromDir);
@@ -1013,68 +1098,14 @@ import {
   setBCallCollector,
   setMemberDiagCollector,
   setAbsTruncationCollector,
-  typeValueToAbs as typeValueToAbs4,
   createEnvironment,
   stableAnalyzeKeySource,
-  formatAbs as formatAbs2,
+  formatAbs as formatAbs3,
   hashSource,
   getFnImpl as getFnImpl2
 } from "@nudojs/core";
 import { parse as parse4, extractInlineDirectives } from "@nudojs/parser";
 
-// src/env-to-abs.ts
-import {
-  typeValueToAbs as typeValueToAbs3,
-  absToTypeValue,
-  getFnSig as getFnSig2,
-  absFunction as absFunction4,
-  relationFn,
-  objOf
-} from "@nudojs/core";
-function envValueToAbs(tv) {
-  if (!tv) return typeValueToAbs3({ kind: "unknown" });
-  if (tv.kind === "function") {
-    const sig = getFnSig2(tv);
-    if (sig) {
-      const paramTypes = sig.paramTypes.map(typeValueToAbs3);
-      const returnType = typeValueToAbs3(sig.returnType);
-      if (sig.impl) {
-        const params = 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 returnType;
-              return envValueToAbs(r);
-            } catch {
-              return returnType;
-            }
-          }
-        });
-      }
-      return relationFn(paramTypes, returnType, {
-        params: tv.params?.length ? tv.params : void 0
-      });
-    }
-  }
-  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;
@@ -1140,10 +1171,10 @@ function evictFnAnalysisCacheForFiles(files) {
   }
   return n;
 }
-function caseDirectiveKey(directives, typeValueToString7) {
+function caseDirectiveKey(directives, formatAbs7) {
   return directives.map((d) => {
     if (d.kind === "case") {
-      const args = (d.args ?? []).map((a) => typeValueToString7(a)).join(",");
+      const args = (d.argsAbs ?? []).map((a) => formatAbs7(a)).join(",");
       return `c:${d.name ?? ""}:${args}`;
     }
     return d.kind;
@@ -1158,7 +1189,7 @@ function absSeedPart(a) {
     const ret = impl?.env?.vars?.get("__nudo_mock_ret");
     if (ret) {
       try {
-        return `ret=${formatAbs2(ret)}`;
+        return `ret=${formatAbs3(ret)}`;
       } catch {
         return "ret=?";
       }
@@ -1166,7 +1197,7 @@ function absSeedPart(a) {
     if (impl?.apply) return "apply";
   }
   try {
-    return formatAbs2(a);
+    return formatAbs3(a);
   } catch {
     return "?";
   }
@@ -1194,15 +1225,10 @@ function collectEnvGlobals(envNames) {
   if (envNames.length === 0) return {};
   const env = createEnvironment();
   try {
-    loadEnvs(envNames, env);
+    return { ...loadEnvs(envNames, env).globals };
   } 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 {};
@@ -1214,12 +1240,8 @@ function collectEnvModules(envNames) {
     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 };
+  for (const [spec, named] of Object.entries(mods)) {
+    out[spec] = { named: { ...named } };
   }
   return out;
 }
@@ -1245,7 +1267,7 @@ function collectBPathReplacements(source) {
               stmtStart: loc?.start.line,
               stmtEnd: loc?.end.line
             });
-            values[varName] = typeValueToAbs4(d.typeExpr);
+            values[varName] = d.typeAbs;
           } else if (d.kind === "as" && loc) {
             const varName = `__as${i++}`;
             asTargets.push({
@@ -1253,7 +1275,7 @@ function collectBPathReplacements(source) {
               stmtStart: loc.start.line,
               stmtEnd: loc.end.line
             });
-            asValues[varName] = typeValueToAbs4(d.typeExpr);
+            asValues[varName] = d.typeAbs;
           }
         }
         const s = stmt;
@@ -1598,60 +1620,6 @@ function collectBPathDiagnostics(source, extraKnown) {
 
 // src/analyzer.ts
 import { setAbsTruncationCollector as setAbsTruncationCollector2 } from "@nudojs/core";
-function resolveModule(source, fromDir) {
-  const extensions = [".js", ".ts", ".mjs"];
-  const nudoPath = resolveNpmNudo(source, fromDir);
-  if (nudoPath) {
-    const src = readFileSync5(nudoPath, "utf-8");
-    return { ast: parse5(src), filePath: nudoPath };
-  }
-  const basePath = resolve5(fromDir, source);
-  for (const ext of ["", ...extensions]) {
-    const candidate = basePath + ext;
-    if (!existsSync4(candidate)) continue;
-    if (statSync4(candidate).isDirectory()) {
-      let entry = null;
-      const pkgPath = resolve5(candidate, "package.json");
-      if (existsSync4(pkgPath)) {
-        try {
-          const main = JSON.parse(readFileSync5(pkgPath, "utf-8")).main;
-          if (typeof main === "string") {
-            for (const e of ["", ...extensions]) {
-              const p = resolve5(candidate, main + e);
-              if (existsSync4(p) && statSync4(p).isFile()) {
-                entry = p;
-                break;
-              }
-            }
-          }
-        } catch {
-        }
-      }
-      if (!entry) {
-        for (const e of ["", ...extensions]) {
-          const p = resolve5(candidate, "index" + e);
-          if (existsSync4(p) && statSync4(p).isFile()) {
-            entry = p;
-            break;
-          }
-        }
-      }
-      if (!entry) return null;
-      const src2 = readFileSync5(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(readFileSync5(candidate, "utf-8")) };
-      } catch {
-        return null;
-      }
-    }
-    const src = readFileSync5(candidate, "utf-8");
-    return { ast: parse5(src), filePath: candidate };
-  }
-  return null;
-}
 function resolveImportPath(specifier, fromDir) {
   const basePath = resolve5(fromDir, specifier);
   for (const ext of ["", ".js", ".ts", ".mjs"]) {
@@ -1754,61 +1722,23 @@ function topoSortDirty(imports, dirty) {
   }
   return ordered;
 }
-function applyMocks(directives, env, filePath, diagnostics) {
+function validateMockDirectives(directives, diagnostics) {
   for (const d of directives) {
-    if (d.kind !== "mock") continue;
-    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, parseTypeValueExpr2(d.expression));
-    } else if (d.fromPath) {
-      const mockPath = resolve5(dirname6(filePath), d.fromPath);
-      const mockSource = readFileSync5(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;
+    if (d.kind !== "mock" || !d.expression) continue;
+    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; }"
+        ]
+      });
     }
-    return fn;
   }
-  return T2.unknown;
 }
 function locFromNode(node) {
   return {
@@ -1947,95 +1877,20 @@ function findSingleModuleExportsFunction(ast) {
   }
   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 (isOversizedCallRecord(rec)) continue;
+    const key = rec.argAbs.map(absStructureKey).join(",") + "=>" + absStructureKey(rec.resultAbs) + "!" + absStructureKey(rec.throwsAbs);
     if (seen.has(key)) continue;
     seen.add(key);
     out.push(rec);
   }
   return out;
 }
-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 } };
@@ -2056,7 +1911,7 @@ function synthesizeExternalFunctions(records, currentFile) {
   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 arity = Math.max(...deduped.map((r) => r.argAbs.length));
     const analysis = {
       name: exportName,
       loc: locFromCallLoc(deduped[0].callLoc),
@@ -2068,149 +1923,48 @@ function synthesizeExternalFunctions(records, currentFile) {
     for (const rec of precise) {
       analysis.cases.push({
         name: `call@L${rec.callLoc?.line ?? 0}`,
-        args: rec.argTypes,
-        result: rec.resultType,
-        throws: rec.throws,
+        argAbs: [...rec.argAbs],
+        abs: rec.resultAbs,
+        throwsAbs: rec.throwsAbs,
         source: "callsite"
       });
     }
     const remaining = deduped.slice(MAX_PRECISE_CALLSITE_CASES);
     if (remaining.length > 0) {
+      const symArgsAbs = Array.from(
+        { length: arity },
+        (_, i) => (
+          // 缺参按真实 JS 语义 widen 成 undefined 而非 unknown——可选参守卫
+          // （target || [] 等）对 unknown 全塌，对 undefined 正常走默认分支
+          widenJoinAbs(remaining.map((rec) => rec.argAbs[i] ?? undefAbs))
+        )
+      );
+      const symResultAbs = collapseAbsLits(
+        remaining.map((r) => r.resultAbs),
+        COLLAPSE_LITERAL_THRESHOLD
+      );
+      const symThrowsAbs = joinAllAbs(remaining.map((r) => r.throwsAbs));
       analysis.cases.push({
         name: "call@symbolic",
-        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)),
+        argAbs: symArgsAbs,
+        abs: symResultAbs,
+        throwsAbs: symThrowsAbs,
         source: "callsite",
         aggregatedFrom: remaining.length
       });
     }
     if (deduped.length > 1) {
-      analysis.combined = collapseLiteralUnion(
-        simplifyUnion(deduped.map((r) => r.resultType)),
+      analysis.combinedAbs = collapseAbsLits(
+        deduped.map((r) => r.resultAbs),
         COLLAPSE_LITERAL_THRESHOLD
       );
     } else {
-      analysis.combined = deduped[0].resultType;
+      analysis.combinedAbs = deduped[0].resultAbs;
     }
     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);
@@ -2228,19 +1982,34 @@ async function analyzeFileAsync(filePath, source, activeCases, externalCallRecor
   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(dirname6(filePath));
-  setCurrentSource(source);
-  setCallCollector((record) => records.push(record));
+  if (/\brequire\s*\(/.test(source) && filePath) {
+    try {
+      const run = tryRunBPath(source, filePath, { mode: "exec" });
+      if (run?.calls?.length) {
+        const importLocals2 = buildAbsImportLocalMap(source, filePath);
+        return run.calls.map((r) => callRecordFromAbsCall(r, importLocals2));
+      }
+    } catch {
+    }
+  }
+  let ast;
+  try {
+    ast = parse5(source, { errorRecovery: true });
+  } catch {
+    return [];
+  }
+  const absCalls = [];
+  const prevCollector = setAbsCallCollector((r) => absCalls.push(r));
+  let importLocals;
   try {
-    const env = createEnvironment2();
-    evaluateProgram(ast, env);
+    importLocals = buildAbsImportLocalMap(source, filePath);
+    let modules;
+    try {
+      modules = evalAbsModuleGraph(source, filePath).modules;
+    } catch {
+      modules = void 0;
+    }
+    const { env } = evalProgramAbs2(source, { file: ast, modules });
     const runCallbacks = (statements) => {
       for (const stmt of statements) {
         if (stmt.type !== "ExpressionStatement" || !("expression" in stmt)) continue;
@@ -2254,8 +2023,16 @@ function collectCallRecords(filePath, source) {
         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);
+          const params = (cb.params ?? []).map(
+            (p) => p.type === "Identifier" ? p.name : `_arg${Math.random().toString(36).slice(2, 6)}`
+          );
+          const tmpName = `__nudo_test_cb_${absCalls.length}`;
+          env.fns.set(tmpName, {
+            params,
+            body: cb.body,
+            async: false
+          });
+          callFunctionFull(env, tmpName, params.map(() => absUnknown2));
         } catch {
         }
         if (name === "describe" && cb.body.type === "BlockStatement") {
@@ -2266,11 +2043,9 @@ function collectCallRecords(filePath, source) {
     runCallbacks(ast.program.body);
   } catch {
   } finally {
-    setCallCollector(null);
-    setModuleResolver(null);
-    setUnknownBuiltinHandler(null);
+    setAbsCallCollector(prevCollector);
   }
-  return records;
+  return absCalls.map((r) => callRecordFromAbsCall(r, importLocals));
 }
 var TEST_CALLBACK_NAMES = /* @__PURE__ */ new Set(["it", "test", "describe"]);
 var externalRecordIds = /* @__PURE__ */ new WeakMap();
@@ -2302,7 +2077,7 @@ function cloneAnalysisResult(r) {
     diagnostics: r.diagnostics.map((d) => ({ ...d })),
     bindings: new Map(r.bindings),
     // Node 键与 AST LRU 共享身份；Map 浅拷贝即可
-    nodeTypeMap: new Map(r.nodeTypeMap),
+    nodeAbsMap: new Map(r.nodeAbsMap),
     caseHints: r.caseHints.map((h) => ({ ...h })),
     ...r.externalFunctions ? { externalFunctions: r.externalFunctions.map(cloneFunctionAnalysis) } : {}
   };
@@ -2313,7 +2088,7 @@ function cloneFunctionAnalysis(a) {
     paramNames: [...a.paramNames],
     cases: a.cases.map((c) => ({
       ...c,
-      args: [...c.args],
+      argAbs: [...c.argAbs],
       ...c.intension ? { intension: { ...c.intension } } : {}
     })),
     loc: { start: { ...a.loc.start }, end: { ...a.loc.end } }
@@ -2351,66 +2126,20 @@ function analyzeFile(filePath, source, activeCases, externalCallRecords) {
   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();
-  const nodeTypeMap = /* @__PURE__ */ new Map();
+  const nodeAbsMap = /* @__PURE__ */ new Map();
   const functionResults = [];
   const caseHints = [];
-  resetMemo();
-  resetUnreachableRanges();
-  resetEnvModules();
-  resetMockModules();
-  setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname6(filePath));
-  setCurrentSource(source);
   const fileDirectives = extractFileDirectives(ast);
   const fileEnvNames = fileDirectives.filter((d) => d.kind === "env").flatMap((d) => d.envs);
   const projectConfig = findProjectConfig(dirname6(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 ? loadEnvs(envNames, globalEnv) : { modules: {} };
-    const auto = autoHarvestModules(source, dirname6(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: resolve5(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 globalEnv = createEnvironment2();
   const bMemberDiagNames = /* @__PURE__ */ new Set();
   const bMemberDiagSeen = /* @__PURE__ */ new Set();
   const pushBMemberDiag = (d, fallbackLine) => {
@@ -2443,7 +2172,7 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
     });
   };
   for (const fn of functions) {
-    applyMocks(fn.directives, globalEnv, filePath, diagnostics);
+    validateMockDirectives(fn.directives, diagnostics);
   }
   const selfContained = isSelfContainedSource(source, envNames);
   const canAbsModules = absModulesOk(source, envNames);
@@ -2498,29 +2227,7 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
       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);
+          bTopCallRecords.push(callRecordFromAbsCall(c, impMap));
         }
       }
     }
@@ -2541,16 +2248,14 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
       for (const [name, absVal] of absBindsShared) {
         if (absVal?.shape?.k === "fn") continue;
         if (!globalEnv.has(name)) {
-          globalEnv.bind(name, absToTypeValue2(absVal));
+          globalEnv.bind(name, absVal);
         }
       }
       for (const [node, absVal] of absNodesShared) {
-        nodeTypeMap.set(node, absToTypeValue2(absVal));
+        nodeAbsMap.set(node, absVal);
       }
     } catch {
     }
-  } else {
-    evaluateProgram(ast, globalEnv);
   }
   if ((selfContained || canAbsModules) && absCallRecords.length > 0) {
     callRecords.length = 0;
@@ -2559,7 +2264,7 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
     callRecords.length = 0;
     callRecords.push(...bTopCallRecords);
   }
-  const unreachableRanges = bCapable ? [] : getUnreachableRanges();
+  const unreachableRanges = [];
   if (bCapable) {
     const bKnownGlobals = /* @__PURE__ */ new Set([
       ...Object.keys(collectEnvGlobals(envNames)),
@@ -2601,7 +2306,15 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
       });
     }
   }
-  collectBindings(ast, globalEnv, bindings);
+  if (!absNodesShared && !bHostedEval && (selfContained || canAbsModules)) {
+    try {
+      const collected = collectAbsBindsAndNodes(source, seeds, absGraphModules);
+      if (!absBindsShared) absBindsShared = collected.binds;
+      absNodesShared = collected.nodes;
+    } catch {
+    }
+  }
+  collectBindings(ast, globalEnv, bindings, absBindsShared);
   if (isBPathCapable(source, envNames)) {
     try {
       const absBinds = absBindsShared ?? collectAbsBindingsFromGraph(source, filePath, {
@@ -2611,7 +2324,7 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
       for (const [name, absVal] of absBinds) {
         const prev = bindings.get(name);
         bindings.set(name, {
-          type: absToTypeValue2(absVal),
+          abs: absVal,
           loc: prev?.loc
         });
       }
@@ -2636,7 +2349,7 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
     if (skipDirective && skipDirective.kind === "skip") {
       analysis.skipped = true;
       if (skipDirective.returns) {
-        analysis.combined = skipDirective.returns;
+        analysis.combinedAbs = skipDirective.returns;
       }
       functionResults.push(analysis);
       continue;
@@ -2649,7 +2362,7 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
       fp.own,
       fp.deps,
       String(activeCaseIdx),
-      caseDirectiveKey(caseDirectives, typeValueToString3),
+      caseDirectiveKey(caseDirectives, formatAbs4),
       envKeyFn,
       mockKeyFn
     ].join("\0") : void 0;
@@ -2688,35 +2401,30 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
     }
     if (isPure) {
       const fnVal = globalEnv.has(fn.name) ? globalEnv.lookup(fn.name) : null;
-      if (fnVal && fnVal.kind === "function") {
+      if (fnVal && fnVal.shape.k === "fn") {
         fnVal._memoize = fn.name;
       }
     }
     const sampleDirective = fn.directives.find((d) => d.kind === "sample");
-    if (sampleDirective && sampleDirective.kind === "sample") {
-      setSampleCount(sampleDirective.count);
-    } else {
-      setSampleCount(3);
-    }
+    void sampleDirective;
     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();
-      let caseValue;
       let caseAbs;
-      let caseThrows;
-      let fullResult = null;
+      let caseThrowsAbs;
+      let caseThrowLoc;
       let caseUnreachable = [];
       const bCapable2 = isBPathCapable(source, envNames);
       const bPrimary = bCapable2;
       if (bCapable2 && filePath) {
+        const caseArgsAbs = directive.argsAbs;
         const bFull = tryBPathCallFull(
           source,
           filePath,
           fn.name,
-          directive.args.map((a) => typeValueToAbs5(a)),
+          caseArgsAbs,
           { collectCalls: true, envNames, mocks: mockSeedsToAbsMocks(seeds) }
         );
         const res = bFull?.result;
@@ -2724,87 +2432,75 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
         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 };
+          caseThrowsAbs = bFull.throws;
           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);
+              callRecords.push(callRecordFromAbsCall(c, impMap));
             }
           }
         }
       }
-      if (!fullResult) {
+      if (!caseAbs) {
         if (bHostedEval) {
-          fullResult = { value: T2.unknown, throws: T2.never };
-          caseValue = T2.unknown;
+          caseAbs = absUnknown2;
+          caseThrowsAbs = neverAbs;
         } 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 caseArgsAbs = directive.argsAbs;
+          const absFull = selfContained || canAbsModules ? tryEvalAbsFull(
+            source,
+            fn.name,
+            caseArgsAbs,
+            filePath,
+            mockSeedsToAbsMocks(seeds)
+          ) : void 0;
+          const weak = !!absFull && absFull.result.shape.k === "unknown" && (!absFull.result.term || absFull.result.term.op === "lit" && absFull.result.term.value === void 0);
+          const absOk = !!absFull && !weak && absFull.result.conf !== "opaque" && absFull.throws.shape.k === "never";
+          const absThrew = !!absFull && !weak && absFull.result.shape.k === "never" && absFull.throws.shape.k !== "never";
+          if (absOk) {
+            caseAbs = absFull.result;
+            caseThrowsAbs = neverAbs;
+          } else if (absThrew) {
+            caseAbs = absFull.result;
+            caseThrowsAbs = absFull.throws;
+            const tl = absFull.throwLoc;
+            if (tl) caseThrowLoc = { start: { ...tl }, end: { ...tl } };
+          } else {
+            caseAbs = absUnknown2;
+            caseThrowsAbs = neverAbs;
           }
         }
       }
-      const tv = caseValue;
-      const throwsTv = caseThrows ?? fullResult.throws;
+      if (!caseThrowsAbs) caseThrowsAbs = neverAbs;
       const caseEntry = {
         name: directive.name,
-        args: directive.args,
-        result: tv,
-        throws: throwsTv,
-        throwLoc: fullResult.throwLoc,
+        argAbs: directive.argsAbs,
+        abs: caseAbs,
+        throwsAbs: caseThrowsAbs,
+        throwLoc: caseThrowLoc,
         expected: directive.expected,
         source: "directive"
       };
       tryAttachIntension(caseEntry, source, fn.name);
-      if (caseAbs) attachAbsToIntension(caseEntry, caseAbs, fn.name);
+      attachAbsToIntension(caseEntry, caseAbs, fn.name);
       analysis.cases.push(caseEntry);
       if (directive.commentLine) {
-        const hasThrow = throwsTv.kind !== "never";
-        const resultStr = tv.kind !== "never" ? typeValueToString3(tv) : "";
-        const throwStr = hasThrow ? `throws ${typeValueToString3(throwsTv)}` : "";
+        const hasThrow = caseThrowsAbs.shape.k !== "never";
+        const resultStr = caseAbs.shape.k !== "never" ? formatShape2(caseAbs) : "";
+        const throwStr = hasThrow ? `throws ${formatShape2(caseThrowsAbs)}` : "";
         const label = [resultStr, throwStr].filter(Boolean).join(" ");
         const hintLabel = `=> ${label}`;
         let ok = true;
         if (directive.expected) {
-          ok = isSubtypeOf(tv, directive.expected);
+          ok = leqAbs(caseAbs, directive.expected).ok;
           if (!ok) {
             diagnostics.push({
               range: { start: { line: directive.commentLine, column: 0 }, end: { line: directive.commentLine, column: 999 } },
               severity: "error",
-              message: `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`,
+              message: `Case "${directive.name}": expected ${formatShape2(directive.expected)}, got ${formatShape2(caseAbs)}. The inferred return type does not match the expected type declared in the @nudo:case directive`,
               code: "nudo:case-expected"
             });
           }
@@ -2813,12 +2509,12 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
       }
       const isActive = ci === Math.min(activeCaseIdx, caseDirectives.length - 1);
       if (isActive) {
-        if (throwsTv.kind !== "never") {
-          const throwRange = fullResult?.throwLoc ?? fnLoc;
+        if (caseThrowsAbs.shape.k !== "never") {
+          const throwRange = caseThrowLoc ?? fnLoc;
           diagnostics.push({
             range: throwRange,
             severity: "warning",
-            message: `Function "${fn.name}" case "${directive.name}" may throw: ${typeValueToString3(throwsTv)}. Consider adding a try-catch block or using @nudo:refine return <constraint>`,
+            message: `Function "${fn.name}" case "${directive.name}" may throw: ${formatShape2(caseThrowsAbs)}. Consider adding a try-catch block or using @nudo:refine return <constraint>`,
             code: "nudo-may-throw"
           });
         }
@@ -2836,10 +2532,11 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
         }
       }
     }
-    if (analysis.cases.length > 1) {
-      analysis.combined = collapseLiteralUnion(simplifyUnion(analysis.cases.map((c) => c.result)), COLLAPSE_LITERAL_THRESHOLD);
-    } else if (analysis.cases.length === 1) {
-      analysis.combined = analysis.cases[0].result;
+    if (analysis.cases.length > 0) {
+      analysis.combinedAbs = collapseAbsLits(
+        analysis.cases.map((c) => c.abs),
+        COLLAPSE_LITERAL_THRESHOLD
+      );
     }
     if (fnCacheKey) {
       fnAnalysisCacheSet(fnCacheKey, {
@@ -2932,13 +2629,13 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
       [
         ...callRecords.filter(matchingLocal),
         ...(externalCallRecords ?? []).filter(matchingExternal)
-      ].filter((r) => !(r.resultType.kind === "never" && r.throws.kind === "never"))
+      ].filter((r) => !isLeakedCallRecord(r))
     );
     reportInjectedDomainExceeds(candidate.name, candidate.node, candidate.analysis.loc);
     if (records.length > 0) {
       const informativeness = (r) => {
-        if (r.resultType.kind === "unknown") return 2;
-        if (r.resultType.kind === "never") return 1;
+        if (r.resultAbs.shape.k === "unknown") return 2;
+        if (r.resultAbs.shape.k === "never") return 1;
         return 0;
       };
       const ordered = records.map((r, i) => ({ r, i })).sort((a, b) => informativeness(a.r) - informativeness(b.r) || a.i - b.i).map(({ r }) => r);
@@ -2946,71 +2643,72 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
       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 (rec.resultAbs.shape.k !== "never" && rec.argAbs.length > 0) {
+          absRaw = tryEvalAbsRaw(source, candidate.name, rec.argAbs, filePath, mockSeedsToAbsMocks(seeds));
           if (absRaw) {
-            const projected = absToTypeValue2(absRaw);
-            if (absIsBetter(projected, rec.resultType)) absResult = projected;
+            if (absIsBetter(absRaw, rec.resultAbs)) {
+              absResult = absRaw;
+            }
           }
         }
+        if (!absRaw && rec.resultAbs.shape.k !== "never") {
+          absRaw = rec.resultAbs;
+        }
+        const caseAbs = absResult ?? rec.resultAbs;
         const caseResult2 = {
           name: `call@L${rec.callLoc?.line ?? candidate.analysis.loc.start.line}`,
-          args: rec.argTypes,
-          result: absResult ?? rec.resultType,
-          throws: rec.throws,
+          argAbs: [...rec.argAbs],
+          abs: caseAbs,
+          throwsAbs: rec.throwsAbs,
           source: "callsite"
         };
         tryAttachIntension(caseResult2, source, candidate.name);
         if (absRaw) attachAbsToIntension(caseResult2, absRaw, candidate.name);
         candidate.analysis.cases.push(caseResult2);
       }
-      const remaining = ordered.slice(MAX_PRECISE_CALLSITE_CASES).filter((rec) => !rec.argTypes.some((a) => a.kind === "unknown"));
+      const remaining = ordered.slice(MAX_PRECISE_CALLSITE_CASES).filter((rec) => !rec.argAbs.some((a) => a.shape.k === "unknown" && !a.term));
       if (remaining.length > 0) {
         const fnNode2 = resolveFunctionNode(candidate.node);
         const paramCount = extractParamNames(fnNode2).length;
-        const widenedArgs = Array.from(
+        const widenedArgsAbs = Array.from(
           { length: paramCount },
           (_, i) => (
             // 缺参按真实 JS 语义 widen 成 undefined 而非 unknown——可选参守卫
             // （target || [] 等）对 unknown 全塌，对 undefined 正常走默认分支
-            widenType(simplifyUnion(remaining.map((rec) => rec.argTypes[i] ?? T2.undefined)))
+            widenJoinAbs(remaining.map((rec) => rec.argAbs[i] ?? undefAbs))
           )
         );
-        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)),
+            widenedArgsAbs,
             { 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 absTry = tryEvalAbsRaw(
+            source,
+            candidate.name,
+            widenedArgsAbs,
+            filePath,
+            mockSeedsToAbsMocks(seeds)
+          );
+          const weak = !!absTry && absTry.shape.k === "unknown" && (!absTry.term || absTry.term.op === "lit" && absTry.term.value === void 0);
+          if (absTry && !weak && absTry.shape.k !== "never" && absTry.conf !== "opaque") {
+            symAbs = absTry;
+          }
         }
         const symCase = {
           name: "call@symbolic",
-          args: widenedArgs,
-          result: symValue ?? T2.unknown,
-          throws: symThrows,
-          throwLoc: symLoc,
+          argAbs: widenedArgsAbs,
+          abs: symAbs ?? absUnknown2,
+          throwsAbs: neverAbs,
           source: "callsite",
           aggregatedFrom: remaining.length
         };
@@ -3018,24 +2716,22 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
         if (symAbs) attachAbsToIntension(symCase, symAbs, candidate.name);
         candidate.analysis.cases.push(symCase);
       }
-      candidate.analysis.combined = collapseLiteralUnion(
-        simplifyUnion(records.map((r) => r.resultType)),
+      candidate.analysis.combinedAbs = collapseAbsLits(
+        records.map((r) => r.resultAbs),
         COLLAPSE_LITERAL_THRESHOLD
       );
       continue;
     }
     const fnNode = resolveFunctionNode(candidate.node);
-    const args = extractParamNames(fnNode).map(() => T2.unknown);
-    let entryValue;
-    let entryThrows = T2.never;
-    let entryLoc;
+    const argAbsEntry = extractParamNames(fnNode).map(() => absUnknown2);
     let entryAbs;
+    let entryThrowsAbs = neverAbs;
     if (isBPathCapable(source, envNames) && filePath) {
       const bEntryFull = tryBPathCallFull(
         source,
         filePath,
         candidate.analysis.name,
-        args.map((a) => typeValueToAbs5(a)),
+        argAbsEntry,
         { envNames, mocks: mockSeedsToAbsMocks(seeds), collectMemberDiags: true }
       );
       if (bEntryFull?.memberDiags?.length) {
@@ -3046,129 +2742,106 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
       const bEntry = bEntryFull?.result;
       if (bEntry && (bHostedEval || !(bEntry.shape.k === "unknown" && !bEntry.term))) {
         entryAbs = bEntry;
-        entryValue = absToTypeValue2(bEntry);
+        if (bEntryFull?.throws) entryThrowsAbs = bEntryFull.throws;
       }
     }
-    if (!entryValue) {
+    if (!entryAbs) {
       if (bHostedEval) {
-        entryValue = T2.unknown;
-        entryThrows = T2.never;
+        entryAbs = absUnknown2;
+        entryThrowsAbs = neverAbs;
       } 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 absEntry = tryEvalEntryAbs(source, candidate.analysis.name, argAbsEntry, filePath, seeds.seedVars);
+        if (absEntry) {
+          entryAbs = absEntry;
+          entryThrowsAbs = neverAbs;
+        } else {
+          entryAbs = absUnknown2;
+          entryThrowsAbs = neverAbs;
+        }
       }
     }
     const caseResult = {
       name: `entry@L${candidate.analysis.loc.start.line}`,
-      args,
-      result: entryValue,
-      throws: entryThrows,
-      throwLoc: entryLoc
+      argAbs: argAbsEntry,
+      abs: entryAbs,
+      throwsAbs: entryThrowsAbs
     };
     tryAttachIntension(caseResult, source, candidate.analysis.name);
-    if (entryAbs) attachAbsToIntension(caseResult, entryAbs, candidate.analysis.name);
+    attachAbsToIntension(caseResult, entryAbs, candidate.analysis.name);
     candidate.analysis.cases.push(caseResult);
     candidate.analysis.entryOnly = true;
-    candidate.analysis.combined = collapseLiteralUnion(entryValue, COLLAPSE_LITERAL_THRESHOLD);
+    candidate.analysis.combinedAbs = entryAbs;
   }
   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;
-      })
-    )
-  );
+    buildNodeTypeMap(ast, globalEnv, nodeAbsMap);
+  }
   const externalFunctions = synthesizeExternalFunctions(callRecords, filePath);
   return {
     functions: functionResults,
     diagnostics,
     bindings,
-    nodeTypeMap,
+    nodeAbsMap,
     caseHints,
     ...externalFunctions.length > 0 ? { externalFunctions } : {}
   };
 }
-function collectBindings(ast, env, bindings) {
+function collectBindings(ast, env, bindings, absBinds) {
   if (ast.type !== "File") return;
+  const setBinding = (name, loc) => {
+    const absVal = absBinds?.get(name) ?? absUnknown2;
+    bindings.set(name, {
+      abs: absVal,
+      loc
+    });
+  };
   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) : T2.unknown;
-      bindings.set(stmt.id.name, { type: val, loc: locFromNode(stmt) });
+      setBinding(stmt.id.name, 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) : T2.unknown;
-          bindings.set(decl.id.name, { type: val, loc: locFromNode(decl) });
+          setBinding(decl.id.name, locFromNode(decl));
         }
       }
     }
     if (stmt.type === "ClassDeclaration" && stmt.id) {
-      const val = env.has(stmt.id.name) ? env.lookup(stmt.id.name) : T2.unknown;
-      bindings.set(stmt.id.name, { type: val, loc: locFromNode(stmt) });
+      setBinding(stmt.id.name, locFromNode(stmt));
     }
     if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
-      collectBindings({ type: "File", program: { type: "Program", body: [stmt.declaration] } }, env, bindings);
+      collectBindings({ type: "File", program: { type: "Program", body: [stmt.declaration] } }, env, bindings, absBinds);
     }
   }
 }
-function buildNodeTypeMap(ast, env, nodeTypeMap) {
+function nullLitAbs() {
+  return makeAbsVal({ k: "unknown" }, { op: "lit", value: null }, void 0, "exact");
+}
+function buildNodeTypeMap(ast, env, nodeAbsMap) {
   const traverseFn = typeof traverse === "function" ? traverse : traverse.default;
   try {
     traverseFn(ast, {
       enter(path) {
         const node = path.node;
         try {
+          const setAbs = (a) => {
+            nodeAbsMap.set(node, a);
+          };
           if (node.type === "Identifier" && node.name !== "undefined" && path.parentPath?.node.type !== "FunctionDeclaration" && path.parentPath?.node.type !== "VariableDeclarator") {
             if (env.has(node.name)) {
-              nodeTypeMap.set(node, env.lookup(node.name));
+              setAbs(env.lookup(node.name));
             }
           }
           if (node.type === "NumericLiteral") {
-            nodeTypeMap.set(node, T2.literal(node.value));
+            setAbs(numLit(node.value));
           }
           if (node.type === "StringLiteral") {
-            nodeTypeMap.set(node, T2.literal(node.value));
+            setAbs(strLit(node.value));
           }
           if (node.type === "BooleanLiteral") {
-            nodeTypeMap.set(node, T2.literal(node.value));
+            setAbs(boolLit(node.value));
           }
           if (node.type === "NullLiteral") {
-            nodeTypeMap.set(node, T2.null);
+            setAbs(nullLitAbs());
           }
         } catch {
         }
@@ -3177,13 +2850,15 @@ function buildNodeTypeMap(ast, env, nodeTypeMap) {
   } catch {
   }
 }
-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;
+function absIsBetter(next, prev) {
+  const isBareUnknown = (a) => a.shape.k === "unknown" && !a.term;
+  const isNever = (a) => a.shape.k === "never";
+  const isStructured = (a) => a.term?.op === "lit" || a.shape.k === "obj" || a.shape.k === "arr" || a.shape.k === "tuple" || a.shape.k === "sum" || a.shape.k === "fn" || a.shape.k === "brand" || a.shape.k === "eff";
+  const hasPred = (a) => !!a.pred && a.pred.op !== "true";
+  if (isBareUnknown(prev)) return !isBareUnknown(next);
+  if (isBareUnknown(next) || isNever(next)) return false;
+  if (isStructured(prev)) return false;
+  if (hasPred(next) && prev.shape.k === "prim" && !hasPred(prev)) return true;
   return false;
 }
 function isSelfContainedSource(source, envNames) {
@@ -3227,21 +2902,7 @@ function collectAbsCallRecords(source, seeds, filePath, precomputedModules, envN
   } 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;
-  });
+  return absCalls.map((r) => callRecordFromAbsCall(r, importLocals));
 }
 function collectAbsBindsAndNodes(source, seeds, modules) {
   const binds = /* @__PURE__ */ new Map();
@@ -3259,7 +2920,7 @@ function collectAbsBindsAndNodes(source, seeds, modules) {
       if (!binds.has(name)) {
         binds.set(
           name,
-          absFunction5(impl.params, { body: impl.body, async: impl.async, env })
+          absFunction4(impl.params, { body: impl.body, async: impl.async, env })
         );
       }
     }
@@ -3274,21 +2935,49 @@ function buildAbsImportLocalMap(source, fromFile) {
   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 (stmt.type === "ImportDeclaration") {
+        const spec = stmt.source.value;
+        let modulePath = null;
+        if (spec.startsWith(".") || spec.startsWith("/")) {
+          modulePath = resolveImportAbs(spec, fromFile);
+        } else if (!spec.startsWith("node:")) {
+          modulePath = spec;
+        }
+        if (!modulePath) continue;
+        for (const s of stmt.specifiers) {
+          if (s.type === "ImportSpecifier") {
+            const imported = s.imported.type === "Identifier" ? s.imported.name : String(s.imported);
+            out.set(s.local.name, { modulePath, exportName: imported });
+          } else if (s.type === "ImportDefaultSpecifier") {
+            out.set(s.local.name, { modulePath, exportName: "default" });
+          }
+        }
+        continue;
       }
-      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" });
+      if (stmt.type === "VariableDeclaration") {
+        for (const d of stmt.declarations) {
+          if (d.init?.type !== "CallExpression") continue;
+          const callee = d.init.callee;
+          if (callee.type !== "Identifier" || callee.name !== "require") continue;
+          const arg0 = d.init.arguments[0];
+          if (!arg0 || arg0.type !== "StringLiteral") continue;
+          const spec = arg0.value;
+          let modulePath = null;
+          if (spec.startsWith(".") || spec.startsWith("/")) {
+            modulePath = resolveImportAbs(spec, fromFile);
+          } else if (!spec.startsWith("node:")) {
+            modulePath = spec;
+          }
+          if (!modulePath) continue;
+          if (d.id.type === "ObjectPattern") {
+            for (const p of d.id.properties) {
+              if (p.type !== "ObjectProperty" || p.computed) continue;
+              if (p.key.type !== "Identifier" || p.value.type !== "Identifier") continue;
+              out.set(p.value.name, { modulePath, exportName: p.key.name });
+            }
+          } else if (d.id.type === "Identifier") {
+            out.set(d.id.name, { modulePath, exportName: "default" });
+          }
         }
       }
     }
@@ -3304,33 +2993,54 @@ function resolveImportAbs(spec, fromFile) {
   }
   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) {
+  return tryEvalAbsFull(source, fnName, args, filePath, mocks)?.result;
+}
+function tryEvalAbsFull(source, fnName, args, filePath, mocks) {
   if (/\brequire\s*\(/.test(source)) return void 0;
   try {
-    const absArgs = args.map((a) => typeValueToAbs5(a));
+    const absArgs = args;
     if (filePath) {
-      const viaB = tryBPathCall(source, filePath, fnName, absArgs, { mocks });
-      if (viaB) return viaB;
+      const viaB = tryBPathCallFull(source, filePath, fnName, absArgs, { mocks });
+      if (viaB) {
+        const r = viaB.result;
+        if (r && !(r.shape.k === "unknown" && !r.term)) {
+          const throws = viaB.throws ?? { shape: { k: "never" }, conf: "exact" };
+          if (throws.shape.k !== "never") {
+            try {
+              let modules2;
+              if (/\bimport\s*[{'"*]/.test(source)) {
+                modules2 = evalAbsModuleGraph(source, filePath).modules;
+              }
+              const viaAst = analyzeFnFull(source, fnName, absArgs, { modules: modules2 });
+              return {
+                result: r,
+                throws,
+                ...viaAst.throwLoc ? { throwLoc: viaAst.throwLoc } : {}
+              };
+            } catch {
+              return { result: r, throws };
+            }
+          }
+          return { result: r, throws };
+        }
+      }
     }
     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) {
+    const full = analyzeFnFull(source, fnName, absArgs, { modules });
+    if (full.result.shape.k === "unknown" && !full.result.term) {
       return void 0;
     }
-    return result;
+    return full;
   } catch {
     return void 0;
   }
 }
 function tryEvalEntryAbs(source, fnName, args, filePath, mocks) {
-  return tryEvalAbs(source, fnName, args, filePath, mocks);
+  return tryEvalAbsRaw(source, fnName, args, filePath, mocks);
 }
 function tryAttachIntension(caseResult, source, fnName) {
   try {
@@ -3339,7 +3049,7 @@ function tryAttachIntension(caseResult, source, fnName) {
     const sym = g.symbolic;
     const intension = {
       display: g.display,
-      abs: formatAbs3(sym),
+      abs: formatAbs4(sym),
       absMultiline: formatAbsMultiline(sym, fnName)
     };
     if (sym.term && sym.term.op !== "lit") {
@@ -3358,25 +3068,48 @@ function attachAbsToIntension(caseResult, absVal, label) {
   caseResult.abs = absVal;
   caseResult.intension = {
     ...prev,
-    abs: formatAbs3(absVal),
+    abs: formatAbs4(absVal),
     absMultiline: formatAbsMultiline(absVal, label ?? caseResult.name),
     conf: absVal.conf
   };
 }
+function safeAbsOrUnknown(a) {
+  if (!a || typeof a !== "object" || !("shape" in a) || !a.shape) {
+    return { shape: { k: "unknown" }, conf: "opaque" };
+  }
+  return a;
+}
+function callRecordFromAbsCall(r, impMap) {
+  const argAbs = r.args.map(safeAbsOrUnknown);
+  const threw = !!r.threw;
+  const thrownOrResult = safeAbsOrUnknown(r.result);
+  const rec = {
+    fnName: r.fnName,
+    argAbs,
+    resultAbs: threw ? neverAbs : thrownOrResult,
+    throwsAbs: threw ? thrownOrResult : neverAbs,
+    callLoc: r.callLoc
+  };
+  const imp = impMap?.get(r.fnName);
+  if (imp) {
+    rec.targetModule = imp.modulePath;
+    rec.targetExport = imp.exportName;
+  }
+  return rec;
+}
 
 // src/lsp-surface.ts
 import { dirname as dirname7 } from "path";
 import traverse2 from "@babel/traverse";
 import {
-  typeValueToString as typeValueToString4,
-  createEnvironment as createEnvironment3,
   generalizeFromAst as generalizeFromAst3,
-  formatAbs as formatAbs4,
+  formatAbs as formatAbs5,
   formatAbsMultiline as formatAbsMultiline2,
-  getFnSig as getFnSig3,
+  formatShape as formatShape3,
   collectAbsNodeTypes,
   findAbsAtPosition,
-  absToTypeValue as absToTypeValue3
+  evalSource,
+  setAbsNodeCollector as setAbsNodeCollector2
 } from "@nudojs/core";
 import { parse as parse6, extractDirectives as extractDirectives2, extractFileDirectives as extractFileDirectives2 } from "@nudojs/parser";
 function getCasesForFile(filePath, source) {
@@ -3394,6 +3127,13 @@ async function getTypeAtPositionAsync(filePath, source, line, column, activeCase
   }
   return getTypeAtPosition(filePath, source, line, column, activeCases);
 }
+async function getAbsAtPositionAsync(filePath, source, line, column, activeCases) {
+  const envNames = collectEnvNames(filePath, source, false);
+  if (envNames.length > 0) {
+    await preloadPathEnvs(envNames, dirname7(filePath));
+  }
+  return getAbsAtPosition(filePath, source, line, column, activeCases);
+}
 function positionInsideCaseFunction(source, ast, line) {
   try {
     const enclosing = findEnclosingFunction(extractDirectives2(ast), line);
@@ -3402,68 +3142,81 @@ function positionInsideCaseFunction(source, ast, line) {
     return false;
   }
 }
-function getTypeAtPosition(filePath, source, line, column, activeCases) {
-  const ast = parse6(source);
-  const fileDirectives = extractFileDirectives2(ast);
-  const envNames = fileDirectives.filter((d) => d.kind === "env").flatMap((d) => d.envs);
-  if (isBPathCapable(source, envNames) && !positionInsideCaseFunction(source, ast, line)) {
-    try {
-      const seeds = mockDirectivesToAbsSeeds(extractDirectives2(ast));
-      const { modules } = evalAbsModuleGraph(source, filePath);
-      const absNodes = collectAbsNodeTypes(source, {
-        ...seeds,
-        modules,
-        file: ast
+function absFromBPath(filePath, source, line, column, ast, envNames) {
+  if (!isBPathCapable(source, envNames)) return null;
+  if (positionInsideCaseFunction(source, ast, line)) return null;
+  try {
+    const seeds = mockDirectivesToAbsSeeds(extractDirectives2(ast));
+    const { modules } = evalAbsModuleGraph(source, filePath);
+    const absNodes = collectAbsNodeTypes(source, {
+      ...seeds,
+      modules,
+      file: ast
+    });
+    const absAt = findAbsAtPosition(absNodes, line, column);
+    if (absAt) return absAt;
+    const ident = findIdentNameAtPosition(source, line, column, ast);
+    if (ident) {
+      const binds = collectAbsBindingsFromGraph(source, filePath, {
+        seedVars: seeds.seedVars,
+        seedFns: seeds.seedFns
       });
-      const absAt = findAbsAtPosition(absNodes, line, column);
-      if (absAt) return absToTypeValue3(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 absToTypeValue3(bound);
-      }
-    } catch {
+      const bound = binds.get(ident);
+      if (bound) return bound;
     }
+  } catch {
   }
-  resetMemo();
-  resetEnvModules();
-  setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname7(filePath));
-  setCurrentSource(source);
-  const globalEnv = createEnvironment3();
-  {
-    const loaded = envNames.length > 0 ? loadEnvs(envNames, globalEnv) : { modules: {} };
-    const auto = autoHarvestModules(source, dirname7(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);
+  return null;
+}
+function absFromCaseReplay(filePath, source, line, column, ast, activeCases) {
   const functions = extractDirectives2(ast);
   const enclosingFn = findEnclosingFunction(functions, line);
-  if (enclosingFn) {
-    const caseDirectives = enclosingFn.directives.filter((d) => d.kind === "case");
-    if (caseDirectives.length > 0) {
-      const caseIndex = activeCases?.get(enclosingFn.name) ?? 0;
-      const directive = caseDirectives[Math.min(caseIndex, caseDirectives.length - 1)];
-      const fnNodeTypeMap = /* @__PURE__ */ new Map();
-      setNodeTypeCollector((node, tv) => fnNodeTypeMap.set(node, tv));
-      evaluateFunctionFull(enclosingFn.node, directive.args, globalEnv);
-      setNodeTypeCollector(null);
-      for (const [node, tv] of fnNodeTypeMap) {
-        nodeTypeMap.set(node, tv);
-      }
+  if (!enclosingFn) return null;
+  const caseDirectives = enclosingFn.directives.filter((d) => d.kind === "case");
+  if (caseDirectives.length === 0) return null;
+  const caseIndex = activeCases?.get(enclosingFn.name) ?? 0;
+  const directive = caseDirectives[Math.min(caseIndex, caseDirectives.length - 1)];
+  const caseArgs = directive.argsAbs;
+  const map = /* @__PURE__ */ new Map();
+  setAbsNodeCollector2((node, value) => map.set(node, value));
+  try {
+    const seeds = mockDirectivesToAbsSeeds(functions);
+    let modules;
+    try {
+      modules = evalAbsModuleGraph(source, filePath).modules;
+    } catch {
+      modules = void 0;
     }
+    evalSource(
+      source,
+      { fn: enclosingFn.name, args: caseArgs },
+      {
+        file: ast,
+        modules,
+        seedVars: seeds.seedVars,
+        seedFns: seeds.seedFns
+      }
+    );
+  } catch {
+  } finally {
+    setAbsNodeCollector2(null);
+  }
+  if (map.size === 0) return null;
+  return findAbsAtPosition(map, line, column) ?? null;
+}
+function getAbsAtPosition(filePath, source, line, column, activeCases) {
+  const ast = parse6(source);
+  const envNames = extractFileDirectives2(ast).filter((d) => d.kind === "env").flatMap((d) => d.envs);
+  const fromB = absFromBPath(filePath, source, line, column, ast, envNames);
+  if (fromB) return fromB;
+  if (positionInsideCaseFunction(source, ast, line)) {
+    const fromCase = absFromCaseReplay(filePath, source, line, column, ast, activeCases);
+    if (fromCase) return fromCase;
   }
-  setModuleResolver(null);
-  resetEnvModules();
-  resetMockModules();
-  return findBestTypeAtPosition(nodeTypeMap, globalEnv, ast, line, column);
+  return null;
+}
+function getTypeAtPosition(filePath, source, line, column, activeCases) {
+  return getAbsAtPosition(filePath, source, line, column, activeCases);
 }
 function getHoverAtPosition(filePath, source, line, column, activeCases) {
   let file;
@@ -3482,23 +3235,23 @@ function getHoverAtPosition(filePath, source, line, column, activeCases) {
       const g = generalizeFromAst3(fnName, source, file ? { file } : {});
       if (g) {
         gDisplay = g.display;
-        gAbs = formatAbs4(g.symbolic);
+        gAbs = formatAbs5(g.symbolic);
         gMulti = formatAbsMultiline2(g.symbolic, fnName);
       }
     } catch {
     }
   }
-  const attachIntension = (info2) => {
-    if (!gDisplay) return info2;
-    if (!info2) {
+  const attachIntension = (info) => {
+    if (!gDisplay) return info;
+    if (!info) {
       return { typeText: gDisplay, intension: gDisplay, abs: gAbs, absMultiline: gMulti };
     }
     return {
-      ...info2,
+      ...info,
       intension: gDisplay,
       // 外延侧已有更准 Abs 时保留；否则用 symbolic 兜底
-      abs: info2.abs ?? gAbs,
-      absMultiline: info2.absMultiline ?? gMulti
+      abs: info.abs ?? gAbs,
+      absMultiline: info.absMultiline ?? gMulti
     };
   };
   const insideCaseFn = positionInsideCaseFunction(
@@ -3506,39 +3259,41 @@ function getHoverAtPosition(filePath, source, line, column, activeCases) {
     file ?? parse6(source),
     line
   );
-  if (isBPathCapable(source, envNames) && !insideCaseFn) {
-    try {
-      const seeds = mockDirectivesToAbsSeeds(extractDirectives2(file ?? parse6(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 && !fnName) {
-        const binds = collectAbsBindingsFromGraph(source, filePath, {
-          seedVars: seeds.seedVars,
-          seedFns: seeds.seedFns
-        });
-        const bound = binds.get(ident2);
-        if (bound) {
-          const absLine = formatAbs4(bound);
-          const absMulti = formatAbsMultiline2(bound, ident2);
-          return attachIntension({ typeText: absLine, abs: absLine, absMultiline: absMulti });
-        }
-      }
-      if (absAt) {
-        const absLine = formatAbs4(absAt);
-        const absMulti = formatAbsMultiline2(absAt, void 0);
-        return attachIntension({ typeText: absLine, abs: absLine, absMultiline: absMulti });
-      }
-    } catch {
+  if (!insideCaseFn) {
+    const fromB = absFromBPath(
+      filePath,
+      source,
+      line,
+      column,
+      file ?? parse6(source),
+      envNames
+    );
+    if (fromB) {
+      const absLine = formatAbs5(fromB);
+      const absMulti = formatAbsMultiline2(fromB, void 0);
+      return attachIntension({ typeText: absLine, abs: absLine, absMultiline: absMulti });
+    }
+  } else {
+    const fromCase = absFromCaseReplay(
+      filePath,
+      source,
+      line,
+      column,
+      file ?? parse6(source),
+      activeCases
+    );
+    if (fromCase) {
+      const absLine = formatAbs5(fromCase);
+      const absMulti = formatAbsMultiline2(fromCase, void 0);
+      return attachIntension({ typeText: absLine, abs: absLine, absMultiline: absMulti });
     }
   }
-  const tv = getTypeAtPosition(filePath, source, line, column, activeCases);
-  const info = tv ? { typeText: typeValueToString4(tv) } : null;
+  const absFallback = getAbsAtPosition(filePath, source, line, column, activeCases);
+  if (absFallback) {
+    const absLine = formatAbs5(absFallback);
+    const absMulti = formatAbsMultiline2(absFallback, void 0);
+    return attachIntension({ typeText: absLine, abs: absLine, absMultiline: absMulti });
+  }
   const ident = findIdentNameAtPosition(source, line, column, file);
   if (ident && !fnName && !insideCaseFn) {
     try {
@@ -3550,13 +3305,8 @@ function getHoverAtPosition(filePath, source, line, column, activeCases) {
         });
         const absBound = absBinds.get(ident);
         if (absBound) {
-          const absLine = formatAbs4(absBound);
+          const absLine = formatAbs5(absBound);
           const absMulti = formatAbsMultiline2(absBound, ident);
-          if (info) {
-            info.abs = absLine;
-            info.absMultiline = absMulti;
-            return attachIntension(info);
-          }
           return attachIntension({ typeText: absLine, abs: absLine, absMultiline: absMulti });
         }
       }
@@ -3576,19 +3326,14 @@ function getHoverAtPosition(filePath, source, line, column, activeCases) {
       });
       const absAt = findAbsAtPosition(nodeTypes, line, column);
       if (absAt) {
-        const absLine = formatAbs4(absAt);
+        const absLine = formatAbs5(absAt);
         const absMulti = formatAbsMultiline2(absAt, void 0);
-        if (info) {
-          info.abs = absLine;
-          info.absMultiline = absMulti;
-        } else {
-          return attachIntension({ typeText: absLine, abs: absLine, absMultiline: absMulti });
-        }
+        return attachIntension({ typeText: absLine, abs: absLine, absMultiline: absMulti });
       }
     }
   } catch {
   }
-  return attachIntension(info);
+  return null;
 }
 function findIdentNameAtPosition(source, line, column, fileAst) {
   try {
@@ -3641,46 +3386,6 @@ function findEnclosingFunction(functions, line) {
   }
   return null;
 }
-function findBestTypeAtPosition(nodeTypeMap, globalEnv, ast, line, column) {
-  let bestMatch = null;
-  let bestSize = Infinity;
-  for (const [node, tv] of nodeTypeMap) {
-    const loc = node.loc;
-    if (!loc) continue;
-    if (loc.start.line <= line && loc.end.line >= line && (loc.start.line < line || loc.start.column <= column) && (loc.end.line > line || loc.end.column >= column)) {
-      const size = (loc.end.line - loc.start.line) * 1e4 + (loc.end.column - loc.start.column);
-      if (size < bestSize) {
-        bestSize = size;
-        bestMatch = tv;
-      }
-    }
-  }
-  if (!bestMatch) {
-    const identAtPos = findIdentifierAtPosition(ast, line, column);
-    if (identAtPos && globalEnv.has(identAtPos)) {
-      bestMatch = globalEnv.lookup(identAtPos);
-    }
-  }
-  return bestMatch;
-}
-function findIdentifierAtPosition(ast, line, column) {
-  let found = null;
-  const traverseFn = typeof traverse2 === "function" ? traverse2 : traverse2.default;
-  try {
-    traverseFn(ast, {
-      Identifier(path) {
-        const loc = path.node.loc;
-        if (!loc) return;
-        if (loc.start.line === line && loc.start.column <= column && loc.end.column >= column) {
-          found = path.node.name;
-          path.stop();
-        }
-      }
-    });
-  } catch {
-  }
-  return found;
-}
 function getCompletionsAtPosition(filePath, source, line, column) {
   const textBefore = getTextBeforePosition(source, line, column);
   const dotMatch = textBefore.match(/(\w+)\.\s*\w*$/);
@@ -3697,19 +3402,20 @@ function getCompletionsAtPosition(filePath, source, line, column) {
       return [];
     }
   }
-  resetMemo();
-  setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname7(filePath));
-  const globalEnv = createEnvironment3();
-  evaluateProgram(ast, globalEnv);
-  if (!globalEnv.has(objName)) {
-    setModuleResolver(null);
-    return [];
+  try {
+    const seeds = mockDirectivesToAbsSeeds(extractDirectives2(ast));
+    const binds = collectAbsBindingsFromGraph(source, filePath, {
+      seedVars: seeds.seedVars,
+      seedFns: seeds.seedFns
+    });
+    const bound = binds.get(objName);
+    if (bound && bound.shape.k !== "unknown" && bound.shape.k !== "never") {
+      const absCompletions = getCompletionsForAbs(bound);
+      if (absCompletions.length > 0) return absCompletions;
+    }
+  } catch {
   }
-  const objType = globalEnv.lookup(objName);
-  const completions = getCompletionsForType(objType);
-  setModuleResolver(null);
-  return completions;
+  return [];
 }
 function sanitizeSourceForParsing(source) {
   return source.replace(/(\w+)\.\s*$/gm, "$1._ ");
@@ -3721,68 +3427,46 @@ function getTextBeforePosition(source, line, column) {
 }
 function getVariableCompletions(filePath, source) {
   const ast = parse6(source);
-  resetMemo();
-  setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname7(filePath));
-  const globalEnv = createEnvironment3();
-  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: typeValueToString4(tv)
-    });
-  }
-  setModuleResolver(null);
-  return completions;
-}
-function builtinMemberType(memberExpr) {
   try {
-    const result = evaluate(parse6(`${memberExpr};`), createEnvironment3());
-    if (!result || typeof result !== "object" || !("kind" in result)) return null;
-    return result;
+    const seeds = mockDirectivesToAbsSeeds(extractDirectives2(ast));
+    const binds = collectAbsBindingsFromGraph(source, filePath, {
+      seedVars: seeds.seedVars,
+      seedFns: seeds.seedFns
+    });
+    if (binds.size > 0) {
+      const completions = [];
+      for (const [name, absVal] of binds) {
+        if (name.startsWith("__export_")) continue;
+        completions.push({
+          label: name,
+          kind: absVal.shape.k === "fn" ? "method" : "variable",
+          detail: absDetail(absVal)
+        });
+      }
+      if (completions.length > 0) return completions;
+    }
   } catch {
-    return null;
   }
+  return [];
+}
+function builtinMemberAbs(className, member) {
+  return builtinProtoMember(className, member);
 }
 function builtinProtoMembers(className) {
-  const table = BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS[className];
-  return table ? Object.keys(table) : [];
+  return builtinProtoMemberNames(className);
 }
-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}`}: ${typeValueToString4(p)}`).join(", ");
-      return `(${params}) => ${typeValueToString4(sig.returnType)}`;
-    }
-    if (tv.kind !== "function") return typeValueToString4(tv);
+function describeMember(label, a, fallbackClass) {
+  if (a) {
+    const s = describeAbsMember(a);
+    if (s) return s;
   }
   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")
+    detail: describeMember(m, builtinMemberAbs("Promise", m), "Promise")
   }));
 }
 function getStringCompletions() {
@@ -3791,16 +3475,71 @@ function getStringCompletions() {
     completions.push({
       label: m,
       kind: "method",
-      detail: describeMember(m, builtinMemberType(`"s".${m}`), "String")
+      detail: describeMember(m, builtinMemberAbs("String", m), "String")
     });
   }
   completions.push({ label: "length", kind: "property", detail: "number" });
   return completions;
 }
-function getUnionCompletions(tv) {
-  const members = tv.members;
+function absDetail(a) {
+  try {
+    return formatShape3(a);
+  } catch {
+    return formatAbs5(a);
+  }
+}
+function absIsFn(a) {
+  return a.shape.k === "fn";
+}
+function getCompletionsForAbs(a) {
+  const s = a.shape;
+  switch (s.k) {
+    case "obj": {
+      const completions = [];
+      for (const [key, slot] of Object.entries(s.slots)) {
+        completions.push({
+          label: key,
+          kind: absIsFn(slot.value) ? "method" : "property",
+          detail: absDetail(slot.value)
+        });
+      }
+      return completions;
+    }
+    case "brand":
+      return getCompletionsForAbs(s.shape);
+    case "sum":
+      return getSumCompletions(s.members);
+    case "tuple":
+      if (a.conf === "exact") return getArrayCompletionsAbs(s.elements.length);
+      return [];
+    case "arr":
+      return getArrayCompletionsAbs(void 0);
+    case "eff":
+      if (s.eff === "promise") return getPromiseCompletions();
+      return [];
+    case "prim":
+      if (s.type === "string") return getStringCompletions();
+      return [];
+    default:
+      return [];
+  }
+}
+function getArrayCompletionsAbs(tupleLen) {
+  const completions = [];
+  for (const m of builtinProtoMembers("Array")) {
+    const detail = describeMember(m, builtinMemberAbs("Array", m), "Array");
+    completions.push({ label: m, kind: "method", detail });
+  }
+  completions.push({
+    label: "length",
+    kind: "property",
+    detail: tupleLen !== void 0 ? `${tupleLen}` : "number"
+  });
+  return completions;
+}
+function getSumCompletions(members) {
   if (members.length === 0) return [];
-  const labelsByMember = members.map((m) => getCompletionsForType(m));
+  const labelsByMember = members.map((m) => getCompletionsForAbs(m));
   const baseIdx = labelsByMember.findIndex((labels) => labels.length > 0);
   if (baseIdx === -1) return [];
   const common = [];
@@ -3824,57 +3563,34 @@ function getUnionCompletions(tv) {
   }
   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: typeValueToString4(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: typeValueToString4(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;
-}
 
 // src/index.ts
 import { collectAbsInlays } from "@nudojs/core";
 
 // src/infer-json.ts
-import { typeValueToString as typeValueToString5 } from "@nudojs/core";
+import { formatAbs as formatAbs6, formatShape as formatShape4 } from "@nudojs/core";
 function mapCase(c) {
   const out = {
     name: c.name,
-    args: c.args.map((a) => typeValueToString5(a)),
-    result: typeValueToString5(c.result),
-    throws: c.throws.kind !== "never" ? typeValueToString5(c.throws) : null,
+    args: c.argAbs.map((a) => formatShape4(a)),
+    result: formatShape4(c.abs),
+    throws: c.throwsAbs.shape.k !== "never" ? formatShape4(c.throwsAbs) : null,
     source: c.source ?? null
   };
   if (c.aggregatedFrom !== void 0) out.aggregatedFrom = c.aggregatedFrom;
+  if (c.argAbs.length > 0) {
+    out.argsAbs = c.argAbs.map((a) => {
+      try {
+        return formatAbs6(a);
+      } catch {
+        return "unknown";
+      }
+    });
+  }
+  try {
+    out.resultAbs = formatAbs6(c.abs);
+  } catch {
+  }
   if (c.intension) {
     const i = c.intension;
     out.intension = {
@@ -3896,7 +3612,13 @@ function mapFunction(f) {
     cases: f.cases.map(mapCase)
   };
   if (f.noDeclaration) out.noDeclaration = true;
-  if (f.combined) out.combined = typeValueToString5(f.combined);
+  if (f.combinedAbs) {
+    out.combined = formatShape4(f.combinedAbs);
+    try {
+      out.combinedAbs = formatAbs6(f.combinedAbs);
+    } catch {
+    }
+  }
   return out;
 }
 function serializeInferJson(result, file) {
@@ -3989,8 +3711,6 @@ function summarizeNodeEnv(env) {
 }
 
 // src/semantic-tokens.ts
-import { dirname as dirname8 } from "path";
-import { createEnvironment as createEnvironment4 } from "@nudojs/core";
 import { parse as parse7 } from "@nudojs/parser";
 var SEMANTIC_TOKEN_TYPES = [
   "function",
@@ -4030,6 +3750,20 @@ 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 collectFunctionBindingNames(filePath, source, _ast) {
+  try {
+    const binds = collectAbsBindingsFromGraph(source, filePath);
+    if (binds.size > 0) {
+      const fns = /* @__PURE__ */ new Set();
+      for (const [name, a] of binds) {
+        if (a.shape.k === "fn") fns.add(name);
+      }
+      return fns;
+    }
+  } catch {
+  }
+  return /* @__PURE__ */ new Set();
+}
 function buildSemanticTokens(filePath, source) {
   let ast;
   try {
@@ -4037,18 +3771,8 @@ function buildSemanticTokens(filePath, source) {
   } catch {
     return [];
   }
-  const env = createEnvironment4();
-  resetMemo();
-  setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname8(filePath));
-  try {
-    evaluateProgram(ast, env);
-  } catch {
-  } finally {
-    setModuleResolver(null);
-  }
+  const functionNames = collectFunctionBindingNames(filePath, source, ast);
   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;
@@ -4082,7 +3806,7 @@ function buildSemanticTokens(filePath, source) {
       }
     }
   };
-  const isFunctionValue = (name) => ownBindings[name]?.kind === "function";
+  const isFunctionValue = (name) => functionNames.has(name);
   const visit = (node) => {
     if (!node || typeof node !== "object") return;
     const n = node;
@@ -4142,144 +3866,206 @@ function buildSemanticTokens(filePath, source) {
 }
 
 // src/dts-generator.ts
-import { T as T3, isTemplate, getTemplateParts, simplifyUnion as simplifyUnion2, typeValueEquals, getFnSig as getFnSig4 } from "@nudojs/core";
-function typeValueToTSType(tv) {
-  switch (tv.kind) {
-    case "literal": {
-      const v = tv.value;
-      if (v === null) return "null";
-      if (v === void 0) return "undefined";
+import {
+  joinAbs as joinAbs2,
+  litValue as litValue3,
+  abs as makeAbs2,
+  isTemplateLike,
+  templatePartsOf
+} from "@nudojs/core";
+function wrapComplexAbs(a) {
+  const ts = absToTSType(a);
+  if (a.shape.k === "sum") return `(${ts})`;
+  return ts;
+}
+function absToTSType(a) {
+  if (a.term?.op === "lit") {
+    const v = a.term.value;
+    if (v === null) return "null";
+    if (v === void 0) return "undefined";
+    if (a.shape.k === "prim") {
       if (typeof v === "string") return JSON.stringify(v);
       if (typeof v === "boolean") return String(v);
-      return String(v);
-    }
-    case "primitive":
-      return tv.type;
-    case "refined": {
-      if (isTemplate(tv)) {
-        const parts = getTemplateParts(tv);
-        const inner = parts.map((p) => p.kind === "literal" && typeof p.value === "string" ? p.value : `\${${typeValueToTSType(p)}}`).join("");
-        return `\`${inner}\``;
-      }
-      return typeValueToTSType(tv.base);
-    }
-    case "object": {
-      const entries = Object.entries(tv.properties);
-      if (entries.length === 0) return "{}";
-      const inner = entries.map(([k, v]) => `${k}: ${typeValueToTSType(v)}`).join("; ");
-      return `{ ${inner} }`;
-    }
-    case "array":
-      return `${wrapComplexType(tv.element)}[]`;
-    case "tuple": {
-      const inner = tv.elements.map(typeValueToTSType).join(", ");
-      return `[${inner}]`;
+      if (typeof v === "number") return String(v);
     }
-    case "function": {
-      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)}>`;
-    case "instance":
-      return tv.className;
-    case "union":
-      return tv.members.map(typeValueToTSType).join(" | ");
+  }
+  if (a.shape.k === "prim" && a.shape.type === "string" && isTemplateLike(a)) {
+    const parts = templatePartsOf(a);
+    const inner = parts.map((p) => {
+      const lv = litValue3(p);
+      if (typeof lv === "string") return lv;
+      return `\${${absToTSType(p)}}`;
+    }).join("");
+    return `\`${inner}\``;
+  }
+  switch (a.shape.k) {
     case "never":
       return "never";
     case "unknown":
+    case "any":
+      return "unknown";
+    case "prim":
+      return a.shape.type;
+    case "obj": {
+      const entries = Object.entries(a.shape.slots).map(([k, slot]) => {
+        const inner = absToTSType(slot.value);
+        if (slot.optional) {
+          const t = slot.value.shape.k === "sum" ? `(${inner})` : inner;
+          return `${k}: ${t} | undefined`;
+        }
+        return `${k}: ${inner}`;
+      });
+      if (entries.length === 0) return "{}";
+      return `{ ${entries.join("; ")} }`;
+    }
+    case "arr":
+      return `${wrapComplexAbs(a.shape.element)}[]`;
+    case "tuple": {
+      const inner = a.shape.elements.map(absToTSType).join(", ");
+      return `[${inner}]`;
+    }
+    case "fn": {
+      const params = a.shape.params.map((p) => `${p}: unknown`).join(", ");
+      const ret = a.shape.returnType ? absToTSType(a.shape.returnType) : "unknown";
+      return `(${params}) => ${ret}`;
+    }
+    case "brand":
+      return a.shape.name;
+    case "eff":
+      if (a.shape.eff === "promise") return `Promise<${absToTSType(a.shape.inner)}>`;
+      return absToTSType(a.shape.inner);
+    case "sum": {
+      const parts = a.shape.members.map(absToTSType).filter((p) => p !== "never");
+      const uniq = [...new Set(parts)];
+      if (uniq.length === 0) return "never";
+      if (uniq.length === 1) return uniq[0];
+      return uniq.join(" | ");
+    }
+    default:
       return "unknown";
   }
 }
-function wrapComplexType(tv) {
-  const ts = typeValueToTSType(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 caseArgAbs(c, i) {
+  return c.argAbs[i];
 }
-function widenTopLevel(tv) {
-  if (tv.kind !== "union") return widenLiteralToBase(tv);
-  return simplifyUnion2(tv.members.map(widenLiteralToBase));
+function caseResultAbs(c) {
+  return c.abs;
 }
-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));
+function widenParamAbs(a) {
+  const s = a.shape;
+  switch (s.k) {
+    case "prim":
+      return makeAbs2(s, void 0, void 0, "exact");
     case "tuple": {
-      const widened = tv.elements.map(widenParamType);
+      const widened = s.elements.map(widenParamAbs);
       const first = widened[0];
-      if (first && widened.every((el) => typeValueEquals(el, first))) {
-        return T3.array(first);
+      if (first && widened.length > 0 && widened.every((el) => absToTSType(el) === absToTSType(first))) {
+        return makeAbs2({ k: "arr", element: first }, void 0, void 0, "exact");
       }
-      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);
+      return makeAbs2({ k: "tuple", elements: widened }, void 0, void 0, "exact");
+    }
+    case "arr":
+      return makeAbs2({ k: "arr", element: widenParamAbs(s.element) }, void 0, void 0, "exact");
+    case "obj": {
+      const slots = {};
+      for (const [k, slot] of Object.entries(s.slots)) {
+        slots[k] = {
+          value: widenParamAbs(slot.value),
+          ...slot.optional ? { optional: true } : {}
+        };
+      }
+      return makeAbs2({ k: "obj", slots }, void 0, void 0, "exact");
+    }
+    case "eff":
+      return makeAbs2(
+        { k: "eff", eff: s.eff, inner: widenParamAbs(s.inner) },
+        void 0,
+        void 0,
+        "exact"
+      );
+    case "brand":
+      return makeAbs2(
+        { k: "brand", name: s.name, shape: widenParamAbs(s.shape) },
+        void 0,
+        void 0,
+        "exact"
+      );
+    case "sum":
+      return makeAbs2(
+        { k: "sum", members: s.members.map(widenParamAbs) },
+        void 0,
+        void 0,
+        "exact"
+      );
     default:
-      return tv;
+      return a;
   }
 }
-function widenedUnion(members) {
-  const flat = [];
-  const collect = (tv) => {
-    if (tv.kind === "union") {
-      tv.members.forEach(collect);
-      return;
+function widenTopLevelAbs(a) {
+  if (a.shape.k === "sum") {
+    return makeAbs2(
+      { k: "sum", members: a.shape.members.map(widenTopLevelAbs) },
+      void 0,
+      void 0,
+      a.conf
+    );
+  }
+  return widenLiteralToPrimAbs(a);
+}
+function widenLiteralToPrimAbs(a) {
+  if (a.term?.op === "lit" && a.term.value === null) return a;
+  if (a.term?.op === "lit" && a.term.value === void 0) return a;
+  if (a.term?.op === "lit" && a.shape.k === "prim") {
+    const v = a.term.value;
+    if (typeof v === "number" || typeof v === "string" || typeof v === "boolean" || typeof v === "bigint") {
+      return makeAbs2(a.shape, void 0, void 0, a.conf);
     }
-    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);
+  }
+  return a;
+}
+function paramTypeFromAbs(members) {
+  if (members.length === 0) return "unknown";
+  let joined;
+  try {
+    joined = members.reduce((a, b) => joinAbs2(a, b));
+  } catch {
+    joined = members[0];
+  }
+  return absToTSType(widenParamAbs(joined));
+}
+function returnAbsOf(fn) {
+  if (fn.combinedAbs) return fn.combinedAbs;
+  const results = fn.cases.map(caseResultAbs);
+  if (results.length > 0) {
+    try {
+      return results.reduce((a, b) => joinAbs2(a, b));
+    } catch {
+    }
+    return results[0];
+  }
+  return void 0;
+}
+function getParamName(fn, index) {
+  if (fn.paramNames && fn.paramNames[index]) {
+    return fn.paramNames[index];
+  }
+  return `arg${index}`;
 }
 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 arity = Math.max(...fn.cases.map((c) => c.argAbs.length));
+  const minArity = Math.min(...fn.cases.map((c) => c.argAbs.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));
+    const members = [];
+    for (const c of fn.cases) {
+      if (i >= c.argAbs.length) continue;
+      const a = caseArgAbs(c, i);
+      if (a) members.push(a);
+    }
+    const typeStr = paramTypeFromAbs(members);
     let name = getParamName(fn, i);
     if (usedNames.has(name)) {
       let n = 2;
@@ -4292,18 +4078,18 @@ function computeMainSignature(fn) {
     paramNames.push(name);
     paramTypes.push(typeStr);
   }
-  const combined = fn.combined ?? simplifyUnion2(fn.cases.map((c) => c.result));
-  const returnType = typeValueToTSType(widenTopLevel(combined));
+  const retAbs = returnAbsOf(fn);
+  const returnType = retAbs ? absToTSType(widenTopLevelAbs(retAbs)) : "unknown";
   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;
+    const preciseDiffers = c.argAbs.length !== sig.paramTypes.length || c.argAbs.some((a, i) => absToTSType(a) !== sig.paramTypes[i]) || absToTSType(c.abs) !== sig.returnType;
     if (!preciseDiffers) continue;
-    const argsStr = c.args.map(typeValueToTSType).join(", ");
-    lines.push(` * Case: ${c.name} (${argsStr}) => ${typeValueToTSType(c.result)}`);
+    const argsStr = c.argAbs.map(absToTSType).join(", ");
+    lines.push(` * Case: ${c.name} (${argsStr}) => ${absToTSType(c.abs)}`);
   }
   for (let i = 0; i < sig.paramTypes.length; i++) {
     lines.push(` * @param ${sig.paramNames[i]} - ${sig.paramTypes[i]}`);
@@ -4315,12 +4101,14 @@ function generateJSDoc(fn, sig) {
 function generateFunctionDtsLines(fn) {
   if (fn.noDeclaration) return [];
   if (fn.cases.length === 0) {
-    if (fn.combined) {
+    const retAbs = fn.combinedAbs;
+    if (retAbs) {
       return [
-        `export declare function ${fn.name}(...args: unknown[]): ${typeValueToTSType(fn.combined)};`
+        `export declare function ${fn.name}(...args: unknown[]): ${absToTSType(retAbs)};`
       ];
     }
     return [];
+    return [];
   }
   const sig = computeMainSignature(fn);
   const jsdoc = generateJSDoc(fn, sig);
@@ -4338,102 +4126,59 @@ function generateDts(result) {
 }
 
 // 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(", ");
+function absToZodSchema(a) {
+  if (a.term?.op === "lit") {
+    const v = a.term.value;
+    if (v === null) return "z.null()";
+    if (v === void 0) return "z.undefined()";
+    if (typeof v === "string") return `z.literal(${JSON.stringify(v)})`;
+    if (typeof v === "boolean") return `z.literal(${v})`;
+    if (typeof v === "number") return `z.literal(${v})`;
+    if (typeof v === "bigint") return `z.literal(${v}n)`;
+  }
+  switch (a.shape.k) {
+    case "prim":
+      return `z.${a.shape.type}()`;
+    case "obj": {
+      const entries = Object.entries(a.shape.slots).map(([k, slot]) => `${k}: ${absToZodSchema(slot.value)}`).join(", ");
       return `z.object({ ${entries} })`;
     }
-    case "array":
-      return `z.array(${typeValueToZodSchema(tv.element)})`;
+    case "arr":
+      return `z.array(${absToZodSchema(a.shape.element)})`;
     case "tuple": {
-      const inner = tv.elements.map(typeValueToZodSchema).join(", ");
+      const inner = a.shape.elements.map(absToZodSchema).join(", ");
       return `z.tuple([${inner}])`;
     }
-    case "function":
+    case "fn":
       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(", ");
+    case "eff":
+      if (a.shape.eff === "promise") return `z.promise(${absToZodSchema(a.shape.inner)})`;
+      return absToZodSchema(a.shape.inner);
+    case "brand":
+      return `z.instanceof(${a.shape.name})`;
+    case "sum": {
+      const members = a.shape.members.map(absToZodSchema).join(", ");
       return `z.union([${members}])`;
     }
     case "never":
       return "z.never()";
     case "unknown":
+    case "any":
+    default:
       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}`;
-  }
+function generateGuardFunction(name, abs) {
+  return generateGuardFunctionFromAbs(name, abs);
 }
 
 // src/case-emitter.ts
@@ -4462,56 +4207,59 @@ function serializeObjectKey(key) {
   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}`;
+function serializeCaseArg(a) {
+  const s = a.shape;
+  if (a.term?.op === "lit") {
+    const v = a.term.value;
+    if (typeof v === "number") {
+      if (!Number.isFinite(v)) return null;
+      const n = String(v);
+      return NUMBER_LITERAL_REGEX.test(n) ? n : 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;
+    if (typeof v === "string") return serializeStringLiteral(v);
+    return null;
+  }
+  switch (s.k) {
+    case "prim":
+      if (s.type === "number" || s.type === "string" || s.type === "boolean") {
+        return `T.${s.type}`;
       }
       return null;
     case "unknown":
+    case "any":
       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": {
+    case "sum": {
       const parts = [];
-      for (const member of tv.members) {
-        const s = serializeCaseArg(member);
-        if (s === null) return null;
-        parts.push(s);
+      for (const member of s.members) {
+        const ser = serializeCaseArg(member);
+        if (ser === null) return null;
+        parts.push(ser);
       }
       return `T.union(${parts.join(", ")})`;
     }
-    case "array": {
-      const el = serializeCaseArg(tv.element);
+    case "arr": {
+      const el = serializeCaseArg(s.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);
+      for (const el of s.elements) {
+        const ser = serializeCaseArg(el);
+        if (ser === null) return null;
+        parts.push(ser);
       }
       return `[${parts.join(", ")}]`;
     }
-    case "object": {
+    case "obj": {
       const parts = [];
-      for (const [key, value] of Object.entries(tv.properties)) {
-        const vs = serializeCaseArg(value);
+      for (const [key, slot] of Object.entries(s.slots)) {
+        const vs = serializeCaseArg(slot.value);
         if (vs === null) return null;
         const ks = serializeObjectKey(key);
         if (ks === null) return null;
@@ -4523,10 +4271,10 @@ function serializeCaseArg(tv) {
       return null;
   }
 }
-function buildCaseDirective(name, args) {
+function buildCaseDirective(name, argsAbs) {
   if (name.includes('"') || /[\r\n]/.test(name)) return null;
   const parts = [];
-  for (const arg of args) {
+  for (const arg of argsAbs) {
     const s = serializeCaseArg(arg);
     if (s === null) return null;
     parts.push(s);
@@ -4629,7 +4377,7 @@ function insertGeneratedCaseDirectives(source, analysis) {
     const built = [];
     const names = [];
     for (const c of callsiteCases) {
-      const directive = buildCaseDirective(c.name, c.args);
+      const directive = buildCaseDirective(c.name, c.argAbs ?? []);
       if (directive === null) {
         skipped.push({ fn: fn.name, reason: "no-serializable-cases", detail: `case ${c.name} not serializable` });
       } else {
@@ -4792,16 +4540,16 @@ function unifiedDiff(a, b, path) {
 
 // src/interface-surface.ts
 import { readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname9, resolve as resolve6 } from "path";
+import { dirname as dirname8, resolve as resolve6 } from "path";
 import {
   effectiveInterface,
   formatConstraint,
+  formatShape as formatShape5,
   interfaceDiagCount,
   localNamedExports,
   refineDiagCount,
   takeInterfaceDiagsSince,
-  takeRefineDiagsSince,
-  typeValueToString as typeValueToString6
+  takeRefineDiagsSince
 } from "@nudojs/core";
 function formatInterfaceSurfaceLine(e) {
   const params = `(${e.params.map((p) => `${p.name}: ${p.display}`).join(", ")})`;
@@ -4810,12 +4558,19 @@ function formatInterfaceSurfaceLine(e) {
   if (e.kind === "local") line += "  (local)";
   return line;
 }
+function absToImplicitDisplay(a) {
+  try {
+    return formatShape5(a);
+  } catch {
+    return "unknown";
+  }
+}
 async function interfaceSurface(filePath, opts = {}) {
   const abs = resolve6(filePath);
   const source = readFileSync6(abs, "utf-8");
   const ifaceSince = interfaceDiagCount();
   const refineSince = refineDiagCount();
-  const autoBind = opts.autoBind ?? interfaceConfig(findProjectConfig(dirname9(abs))?.config).autoBind;
+  const autoBind = opts.autoBind ?? interfaceConfig(findProjectConfig(dirname8(abs))?.config).autoBind;
   const loadModule = opts.loadModule ?? defaultLoadModule;
   const exported = localNamedExports(source);
   const kindOf = (fnName) => exported.has(fnName) ? "export" : "local";
@@ -4836,14 +4591,21 @@ async function interfaceSurface(filePath, opts = {}) {
     const params = fn.paramNames.map((name, i) => {
       const seen = [];
       for (const c of fn.cases) {
-        const arg = c.args[i];
-        if (!arg) continue;
-        const s = typeValueToString6(arg);
-        if (!seen.includes(s)) seen.push(s);
+        const absArg = c.argAbs[i];
+        if (absArg) {
+          const s = absToImplicitDisplay(absArg);
+          if (!seen.includes(s)) seen.push(s);
+        }
       }
       return { name, display: seen.length > 0 ? seen.join(" | ") : "unknown" };
     });
-    const ret = fn.combined !== void 0 ? typeValueToString6(fn.combined) : fn.cases.length > 0 ? typeValueToString6(fn.cases[fn.cases.length - 1].result) : void 0;
+    let ret;
+    if (fn.combinedAbs) {
+      ret = absToImplicitDisplay(fn.combinedAbs);
+    } else if (fn.cases.length > 0) {
+      const last = fn.cases[fn.cases.length - 1];
+      ret = absToImplicitDisplay(last.abs);
+    }
     entries.push({ fn: fn.name, kind: kindOf(fn.name), source: "implicit", params, returns: ret });
   }
   takeInterfaceDiagsSince(ifaceSince);
@@ -4853,7 +4615,7 @@ async function interfaceSurface(filePath, opts = {}) {
 
 // src/interface-emitter.ts
 import { existsSync as existsSync6, readFileSync as readFileSync7, writeFileSync, renameSync, unlinkSync } from "fs";
-import { basename as basename2, dirname as dirname10, relative, resolve as resolve7 } from "path";
+import { basename as basename2, dirname as dirname9, relative, resolve as resolve7 } from "path";
 import {
   execNudoModule,
   formatConstraint as formatConstraint2,
@@ -4866,8 +4628,7 @@ import {
   refineDiagCount as refineDiagCount2,
   sidecarPathOf,
   takeInterfaceDiagsSince as takeInterfaceDiagsSince2,
-  takeRefineDiagsSince as takeRefineDiagsSince2,
-  typeValueToAbs as typeValueToAbs6
+  takeRefineDiagsSince as takeRefineDiagsSince2
 } from "@nudojs/core";
 import { randomBytes } from "crypto";
 var GENERATED_HEADER = "// @generated by nudo \u2014 do not edit; regenerate with `nudo interface --emit`";
@@ -4878,12 +4639,29 @@ async function emitInterface(filePath, opts) {
       `emit target '${abs}' is inside node_modules; contract sidecars are never written there`
     );
   }
+  const proj = findProjectConfig(dirname9(abs));
+  const allow = interfaceConfig(proj?.config).emit;
+  if (!matchesEmitAllowlist(abs, proj?.projectDir, allow)) {
+    return {
+      written: [],
+      skipped: [{ fn: opts.fnNames?.[0] ?? "*", reason: "emit-denied" }],
+      changed: false,
+      issues: [
+        {
+          code: "nudo:interface-emit-denied",
+          severity: "warning",
+          message: `emit target '${relative(process.cwd(), abs) || abs}' is outside package.json#nudo.interface.emit allowlist`
+        }
+      ],
+      sidecarPath: sidecarPathOf(abs)
+    };
+  }
   const source = readFileSync7(abs, "utf-8");
   const ifaceSince = interfaceDiagCount2();
   const refineSince = refineDiagCount2();
   const sidecarPath = sidecarPathOf(abs);
   const sidecarSrc = existsSync6(sidecarPath) ? readFileSync7(sidecarPath, "utf-8") : "";
-  const srcRel = relative(dirname10(sidecarPath), abs) || basename2(abs);
+  const srcRel = relative(dirname9(sidecarPath), abs) || basename2(abs);
   const sections = collectGeneratedSections(sidecarSrc);
   const generatedNames = new Set(sections.flatMap((s) => s.names));
   const declared = topLevelDeclaredNames(sidecarSrc);
@@ -5052,9 +4830,8 @@ function projectFunctionDsl(fn) {
   for (let i = 0; i < fn.paramNames.length; i++) {
     const argAbs = [];
     for (const c of paramCases) {
-      const a = c.args[i];
-      if (a === void 0) continue;
-      argAbs.push(safeTypeValueToAbs(a));
+      const a = c.argAbs[i];
+      if (a !== void 0) argAbs.push(a);
     }
     if (argAbs.length === 0) continue;
     const constraint = joinThenProject(argAbs);
@@ -5063,8 +4840,8 @@ function projectFunctionDsl(fn) {
   }
   const retAbs = [];
   for (const c of returnCases) {
-    if (c.throws !== void 0 && c.throws.kind !== "never") continue;
-    retAbs.push(c.abs ?? safeTypeValueToAbs(c.result));
+    if (c.throwsAbs.shape.k !== "never") continue;
+    retAbs.push(c.abs);
   }
   const retConstraint = retAbs.length > 0 ? joinThenProject(retAbs) : void 0;
   if (retConstraint === void 0 && paramParts.length === 0) return void 0;
@@ -5072,13 +4849,6 @@ function projectFunctionDsl(fn) {
   const ret = retConstraint === void 0 ? "" : `, ${formatConstraint2(retConstraint)}`;
   return `fn({ ${paramParts.join(", ")} }${ret})`;
 }
-function safeTypeValueToAbs(v) {
-  try {
-    return typeValueToAbs6(v);
-  } catch {
-    return { shape: { k: "unknown" }, conf: "opaque" };
-  }
-}
 function sectionText(fn, dsl, srcRel) {
   return `${GENERATED_HEADER}
 // source: ${srcRel}:${fn}
@@ -5201,9 +4971,939 @@ function joinSections(base, sectionTexts) {
 `;
   return lead + normalized.join("\n");
 }
+
+// src/interface-derivation.ts
+import { existsSync as existsSync7, readFileSync as readFileSync8, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename3, dirname as dirname10, relative as relative2, resolve as resolve8 } from "path";
+import { parse as parse9 } from "@nudojs/parser";
+import {
+  analyzeFn,
+  beginDerivationSession,
+  constraintToEntryAbs,
+  derivationChain,
+  effectiveInterface as effectiveInterface2,
+  endDerivationSession,
+  execNudoModule as execNudoModule2,
+  formatConstraint as formatConstraint3,
+  getDerivation,
+  interfaceDiagCount as interfaceDiagCount3,
+  isNodeModulesPath as isNodeModulesPath2,
+  isNudoConstraint as isNudoConstraint2,
+  joinThenProject as joinThenProject2,
+  parseSource as parseSource3,
+  projectDerivationDsl,
+  refineDiagCount as refineDiagCount3,
+  setAbsCallCollector as setAbsCallCollector2,
+  sidecarPathOf as sidecarPathOf2,
+  tagDerivationRoot,
+  takeInterfaceDiagsSince as takeInterfaceDiagsSince3,
+  takeRefineDiagsSince as takeRefineDiagsSince3,
+  unknown as unknownAbs
+} from "@nudojs/core";
+function extractFnConstraintSources(sidecarSrc, fnName) {
+  const out = { params: {} };
+  let ast;
+  try {
+    ast = parse9(sidecarSrc);
+  } catch {
+    return out;
+  }
+  const imports = /* @__PURE__ */ new Map();
+  const locals = /* @__PURE__ */ new Map();
+  const srcOf = (node) => {
+    const n = node;
+    if (!n?.type) return void 0;
+    if (n.type === "Identifier" && n.name) {
+      const imp = imports.get(n.name);
+      if (imp) {
+        return { expr: imp.imported, importFrom: imp.from, importName: imp.imported };
+      }
+      const local = locals.get(n.name);
+      if (local !== void 0) return { expr: local };
+      return { expr: n.name };
+    }
+    if (n.start != null && n.end != null) {
+      return { expr: sidecarSrc.slice(n.start, n.end) };
+    }
+    return void 0;
+  };
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ImportDeclaration") {
+      const from = stmt.source.value;
+      for (const s of stmt.specifiers) {
+        if (s.type === "ImportSpecifier") {
+          const imported = s.imported.type === "Identifier" ? s.imported.name : String(s.imported);
+          imports.set(s.local.name, { from, imported });
+        }
+      }
+      continue;
+    }
+    if (stmt.type !== "ExportNamedDeclaration" || stmt.source) continue;
+    const d = stmt.declaration;
+    if (!d || d.type !== "VariableDeclaration") continue;
+    for (const decl of d.declarations) {
+      if (decl.id.type !== "Identifier") continue;
+      const name = decl.id.name;
+      const init = decl.init;
+      if (!init) continue;
+      const text = init.start != null && init.end != null ? sidecarSrc.slice(init.start, init.end) : name;
+      if (init.type !== "CallExpression") {
+        locals.set(name, text);
+        continue;
+      }
+      const calleeName = init.callee.type === "Identifier" ? init.callee.name : void 0;
+      locals.set(name, text);
+      if (calleeName !== "fn" || name !== fnName) continue;
+      const paramsNode = init.arguments[0];
+      if (paramsNode?.type === "ObjectExpression") {
+        for (const prop of paramsNode.properties) {
+          if (prop.type !== "ObjectProperty") continue;
+          const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "StringLiteral" ? prop.key.value : void 0;
+          if (!key) continue;
+          const expr = srcOf(prop.value);
+          if (expr) out.params[key] = expr;
+        }
+      }
+      const retNode = init.arguments[1];
+      if (retNode) {
+        const expr = srcOf(retNode);
+        if (expr) out.returns = expr;
+      }
+    }
+  }
+  return out;
+}
+function functionParamNames(source, fnName) {
+  try {
+    const ast = parse9(source);
+    for (const stmt of ast.program.body) {
+      const d = stmt.type === "ExportNamedDeclaration" ? stmt.declaration ?? void 0 : stmt;
+      if (!d) continue;
+      if (d.type === "FunctionDeclaration" && d.id?.name === fnName) {
+        return d.params.map(paramNameOf);
+      }
+      if (d.type === "VariableDeclaration") {
+        for (const decl of d.declarations) {
+          if (decl.id.type === "Identifier" && decl.id.name === fnName && decl.init && (decl.init.type === "ArrowFunctionExpression" || decl.init.type === "FunctionExpression")) {
+            return decl.init.params.map(paramNameOf);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return [];
+}
+function paramNameOf(p) {
+  if (p.type === "Identifier" && p.name) return p.name;
+  if (p.type === "AssignmentPattern" && p.left?.type === "Identifier" && p.left.name) {
+    return p.left.name;
+  }
+  return "_";
+}
+function topLevelFnNames(source) {
+  const out = [];
+  try {
+    const ast = parse9(source);
+    for (const stmt of ast.program.body) {
+      const d = stmt.type === "ExportNamedDeclaration" ? stmt.declaration ?? void 0 : stmt;
+      if (!d) continue;
+      if (d.type === "FunctionDeclaration" && d.id) out.push(d.id.name);
+      if (d.type === "VariableDeclaration") {
+        for (const decl of d.declarations) {
+          if (decl.id.type === "Identifier" && decl.init && (decl.init.type === "ArrowFunctionExpression" || decl.init.type === "FunctionExpression")) {
+            out.push(decl.id.name);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+function importLocalMap(source, fromFile) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const ast = parse9(source);
+    const base = dirname10(resolve8(fromFile));
+    for (const stmt of ast.program.body) {
+      if (stmt.type !== "ImportDeclaration") continue;
+      const spec = stmt.source.value;
+      if (!spec.startsWith(".") && !spec.startsWith("/")) continue;
+      const raw = resolve8(base, spec);
+      let modulePath = null;
+      for (const cand of [raw, `${raw}.js`, `${raw}.ts`, `${raw}.mjs`]) {
+        if (existsSync7(cand)) {
+          modulePath = cand;
+          break;
+        }
+      }
+      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 });
+        }
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+function resolveRelImport(fromSpec, fromDir, targetDir) {
+  const abs = resolve8(fromDir, fromSpec);
+  let rel = relative2(targetDir, abs);
+  if (!rel.startsWith(".")) rel = `./${rel}`;
+  return rel.split("\\").join("/");
+}
+function projectParamSlot(absList, paramName) {
+  if (absList.length === 0) return void 0;
+  const constraint = joinThenProject2(absList);
+  if (constraint === void 0) return void 0;
+  if (absList.length === 1) {
+    const node = getDerivation(absList[0]);
+    if (node) {
+      const proj = projectDerivationDsl(node, paramName);
+      if (proj) {
+        const chain = derivationChain(node);
+        const root = chain[chain.length - 1];
+        const shiftCount = chain.filter((n) => n.kind === "shift").length;
+        return {
+          constraint,
+          dsl: proj.expr,
+          prelude: proj.prelude,
+          imports: proj.imports,
+          compositional: true,
+          ...root?.kind === "root" ? { rootNodeId: root.id } : {},
+          shiftCount
+        };
+      }
+    }
+  }
+  return {
+    constraint,
+    dsl: formatConstraint3(constraint),
+    prelude: [],
+    imports: [],
+    compositional: false
+  };
+}
+function projectReturnSlot(retAbs, params, paramNames) {
+  if (retAbs.length === 0) return void 0;
+  const constraint = joinThenProject2(retAbs);
+  if (constraint === void 0) return void 0;
+  if (retAbs.length === 1) {
+    const node = getDerivation(retAbs[0]);
+    if (node && !derivationChain(node).some((n) => n.kind === "join" || n.kind === "opaque")) {
+      const rel = projectReturnRelativeToParams(node, params, paramNames);
+      if (rel) {
+        return {
+          constraint,
+          dsl: rel.dsl,
+          prelude: rel.prelude,
+          imports: rel.imports,
+          compositional: true
+        };
+      }
+      const proj = projectDerivationDsl(node, paramNames[0] ?? "ret");
+      if (proj) {
+        return {
+          constraint,
+          dsl: proj.expr,
+          prelude: proj.prelude,
+          imports: proj.imports,
+          compositional: true
+        };
+      }
+    }
+  }
+  return {
+    constraint,
+    dsl: formatConstraint3(constraint),
+    prelude: [],
+    imports: [],
+    compositional: false
+  };
+}
+function projectReturnRelativeToParams(node, params, paramNames) {
+  const chain = derivationChain(node);
+  const root = chain[chain.length - 1];
+  if (!root || root.kind !== "root") return void 0;
+  const shifts = [];
+  for (let j = chain.length - 2; j >= 0; j--) {
+    const n = chain[j];
+    if (n.kind !== "shift" || n.offset === void 0) return void 0;
+    shifts.push(n.offset);
+  }
+  for (let i = 0; i < params.length; i++) {
+    const p = params[i];
+    if (p.rootNodeId === void 0 || p.rootNodeId !== root.id) continue;
+    const paramShiftCount = p.shiftCount ?? 0;
+    if (shifts.length < paramShiftCount) continue;
+    const tail = shifts.slice(paramShiftCount);
+    if (tail.length === 0) {
+      return { dsl: p.dsl, prelude: [], imports: [] };
+    }
+    let expr = p.name || paramNames[i] || "x";
+    for (const off of tail) expr = `${expr}.shift(${off})`;
+    return { dsl: expr, prelude: [], imports: [] };
+  }
+  return void 0;
+}
+function deriveFromRoot(filePath, opts = {}) {
+  const abs = resolve8(filePath);
+  const source = readFileSync8(abs, "utf-8");
+  const since = interfaceDiagCount3();
+  const autoBind = opts.autoBind ?? interfaceConfig(findProjectConfig(dirname10(abs))?.config).autoBind;
+  const loadModule = opts.loadModule ?? defaultLoadModule;
+  const sidecarPath = sidecarPathOf2(abs);
+  const sidecarSrc = existsSync7(sidecarPath) && !isNodeModulesPath2(sidecarPath) ? readFileSync8(sidecarPath, "utf-8") : "";
+  const fnNames = topLevelFnNames(source);
+  const roots = [];
+  const plans = [];
+  for (const fn of fnNames) {
+    const eff = effectiveInterface2(source, fn, { loadModule, fromFile: abs, autoBind });
+    if (!eff || eff.source !== "handwritten") continue;
+    roots.push(fn);
+    const sources = sidecarSrc ? extractFnConstraintSources(sidecarSrc, fn) : { params: {} };
+    const srcParams = functionParamNames(source, fn);
+    const planParams = srcParams.map((pname) => {
+      const hit = eff.params.find((p) => p.param === pname);
+      if (hit) {
+        const src = sources.params[pname];
+        return {
+          name: pname,
+          constraint: hit.constraint,
+          ...src ? { src } : {}
+        };
+      }
+      return {
+        name: pname,
+        constraint: { __nudoConstraint: true, preds: [] }
+      };
+    });
+    plans.push({ fnName: fn, params: planParams });
+  }
+  if (plans.length === 0) {
+    takeInterfaceDiagsSince3(since);
+    return { roots: [], derived: [], hasRoot: false };
+  }
+  let modules = {};
+  try {
+    modules = evalAbsModuleGraph(source, abs, { loadModule }).modules;
+  } catch {
+    modules = {};
+  }
+  const importLocals = importLocalMap(source, abs);
+  const wanted = opts.fnNames && opts.fnNames.length > 0 ? new Set(opts.fnNames) : void 0;
+  const derived = [];
+  for (const plan of plans) {
+    const relRoot = relative2(process.cwd(), abs);
+    const label = `${relRoot === "" || relRoot.startsWith("..") ? basename3(abs) : relRoot}:${plan.fnName}`;
+    const rows = deriveOneRoot(plan, source, abs, modules, importLocals, label);
+    for (const row of rows) {
+      if (wanted && !wanted.has(row.fn)) continue;
+      derived.push(row);
+    }
+  }
+  takeInterfaceDiagsSince3(since);
+  return { roots, derived, hasRoot: true };
+}
+function deriveOneRoot(plan, source, file, modules, importLocals, label) {
+  beginDerivationSession();
+  const entryArgs = [];
+  try {
+    for (const p of plan.params) {
+      const entry = constraintToEntryAbs(p.constraint, p.name);
+      if (p.src) {
+        tagDerivationRoot(entry, {
+          expr: p.src.expr,
+          ...p.src.importFrom !== void 0 ? { importFrom: p.src.importFrom } : {},
+          ...p.src.importName !== void 0 ? { importName: p.src.importName } : {}
+        });
+      } else if (p.constraint.preds.length === 0 && !p.constraint.prim) {
+      }
+      entryArgs.push(entry);
+    }
+    const calls = [];
+    const prevCallCollector = setAbsCallCollector2((r) => calls.push(r));
+    try {
+      analyzeFn(source, plan.fnName, entryArgs, void 0, void 0, void 0, modules);
+    } catch {
+      return [];
+    } finally {
+      setAbsCallCollector2(prevCallCollector);
+    }
+    const byCallee = /* @__PURE__ */ new Map();
+    for (const call of calls) {
+      const imp = importLocals.get(call.fnName);
+      let targetFile;
+      let targetExport = call.fnName;
+      if (imp) {
+        targetFile = imp.modulePath;
+        targetExport = imp.exportName;
+      } else {
+        targetFile = file;
+      }
+      if (isNodeModulesPath2(targetFile)) continue;
+      if (!existsSync7(targetFile)) continue;
+      const key = `${targetFile}::${targetExport}`;
+      let agg = byCallee.get(key);
+      if (!agg) {
+        agg = { targetFile, targetExport, argAbs: [], resultAbs: [] };
+        byCallee.set(key, agg);
+      }
+      agg.argAbs.push(call.args);
+      agg.resultAbs.push(call.threw ? unknownAbs : call.result);
+    }
+    const out = [];
+    for (const agg of byCallee.values()) {
+      let targetSource;
+      try {
+        targetSource = readFileSync8(agg.targetFile, "utf-8");
+      } catch {
+        continue;
+      }
+      const paramNames = functionParamNames(targetSource, agg.targetExport);
+      if (paramNames.length === 0 && agg.argAbs.every((a) => a.length === 0)) continue;
+      const width = Math.max(
+        paramNames.length,
+        ...agg.argAbs.map((a) => a.length),
+        0
+      );
+      const params = [];
+      let allCompositional = true;
+      let sawEvidence = false;
+      for (let i = 0; i < width; i++) {
+        const name = paramNames[i] ?? `_${i}`;
+        const absList = [];
+        for (const args of agg.argAbs) {
+          const a = args[i];
+          if (a) absList.push(a);
+        }
+        const slot = projectParamSlot(absList, name);
+        if (!slot) {
+          allCompositional = false;
+          continue;
+        }
+        sawEvidence = true;
+        if (!slot.compositional) allCompositional = false;
+        params.push({
+          name,
+          constraint: slot.constraint,
+          dsl: slot.dsl,
+          prelude: slot.prelude,
+          imports: slot.imports,
+          ...slot.rootNodeId !== void 0 ? { rootNodeId: slot.rootNodeId } : {},
+          ...slot.shiftCount !== void 0 ? { shiftCount: slot.shiftCount } : {}
+        });
+      }
+      const retAbs = agg.resultAbs.filter(
+        (a) => a.conf === "exact" || a.conf === "path"
+      );
+      const retSlot = projectReturnSlot(retAbs, params, paramNames);
+      if (retSlot && !retSlot.compositional) allCompositional = false;
+      if (retSlot) sawEvidence = true;
+      if (!sawEvidence) {
+        out.push({
+          file: agg.targetFile,
+          fn: agg.targetExport,
+          paramNames,
+          params: [],
+          derivedFrom: label,
+          compositional: false,
+          underivable: true
+        });
+        continue;
+      }
+      out.push({
+        file: agg.targetFile,
+        fn: agg.targetExport,
+        paramNames,
+        params,
+        ...retSlot ? {
+          returns: {
+            constraint: retSlot.constraint,
+            dsl: retSlot.dsl,
+            prelude: retSlot.prelude,
+            imports: retSlot.imports
+          }
+        } : {},
+        derivedFrom: label,
+        compositional: allCompositional && params.length > 0
+      });
+    }
+    return out;
+  } finally {
+    endDerivationSession();
+  }
+}
+var NameAllocator = class {
+  taken;
+  constructor(initial) {
+    this.taken = new Set(initial ?? []);
+  }
+  claim(preferred) {
+    if (!this.taken.has(preferred)) {
+      this.taken.add(preferred);
+      return preferred;
+    }
+    let i = 2;
+    while (this.taken.has(`${preferred}_${i}`)) i++;
+    const name = `${preferred}_${i}`;
+    this.taken.add(name);
+    return name;
+  }
+};
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function rewriteIdents(src, map) {
+  if (map.size === 0) return src;
+  let out = src;
+  const keys = [...map.keys()].sort((a, b) => b.length - a.length);
+  for (const k of keys) {
+    const v = map.get(k);
+    if (k === v) continue;
+    out = out.replace(new RegExp(`(?<![\\w$.])${escapeRegExp(k)}(?![\\w$])`, "g"), v);
+  }
+  return out;
+}
+function preludeLocalName(line) {
+  const m = /^const\s+([A-Za-z_$][\w$]*)\s*=/.exec(line.trim());
+  return m?.[1];
+}
+function formatDerivedSection(row, opts) {
+  if (row.underivable || row.params.length === 0) return void 0;
+  const importMap = /* @__PURE__ */ new Map();
+  const preludes = [];
+  const paramDsls = [];
+  for (const p of row.params) {
+    for (const imp of p.imports) {
+      const rel = resolveRelImport(imp.from, opts.rootSidecarDir, opts.targetSidecarDir);
+      const prev = importMap.get(imp.name);
+      if (prev !== void 0 && prev !== rel) return void 0;
+      importMap.set(imp.name, rel);
+    }
+    for (const line of p.prelude) {
+      if (!preludes.includes(line)) preludes.push(line);
+    }
+    paramDsls.push(p.dsl);
+  }
+  let retDsl = "";
+  if (row.returns) {
+    for (const imp of row.returns.imports) {
+      const rel = resolveRelImport(imp.from, opts.rootSidecarDir, opts.targetSidecarDir);
+      const prev = importMap.get(imp.name);
+      if (prev !== void 0 && prev !== rel) return void 0;
+      importMap.set(imp.name, rel);
+    }
+    for (const line of row.returns.prelude) {
+      if (!preludes.includes(line)) preludes.push(line);
+    }
+    retDsl = `, ${row.returns.dsl}`;
+  }
+  const namer = new NameAllocator(opts.takenNames);
+  namer.claim(row.fn);
+  const renames = /* @__PURE__ */ new Map();
+  const importLocals = [];
+  for (const [name, from] of [...importMap.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+    const local = namer.claim(name);
+    if (local !== name) renames.set(name, local);
+    importLocals.push({ original: name, local, from });
+  }
+  const preludeClaimed = /* @__PURE__ */ new Set();
+  const renamedPreludes = [];
+  for (const line of preludes) {
+    const local = preludeLocalName(line);
+    if (local !== void 0 && !preludeClaimed.has(local)) {
+      preludeClaimed.add(local);
+      if (!renames.has(local)) {
+        const next = namer.claim(local);
+        if (next !== local) renames.set(local, next);
+      }
+    }
+    renamedPreludes.push(rewriteIdents(line, renames));
+  }
+  const paramParts = row.params.map((p, i) => {
+    const dsl = rewriteIdents(paramDsls[i], renames);
+    const name = rewriteIdents(p.name, renames);
+    return dsl === name ? name : `${name}: ${dsl}`;
+  });
+  const retPart = retDsl === "" ? "" : `, ${rewriteIdents(row.returns.dsl, renames)}`;
+  const importLineTexts = importLocals.map(({ original, local, from }) => {
+    const spec = original === local ? local : `${original} as ${local}`;
+    return `import { ${spec} } from ${JSON.stringify(from)};`;
+  }).sort((a, b) => a.localeCompare(b));
+  const lines = [
+    ...importLineTexts,
+    ...importLineTexts.length > 0 && renamedPreludes.length > 0 ? [""] : [],
+    ...renamedPreludes,
+    `export const ${row.fn} = fn({ ${paramParts.join(", ")} }${retPart});`
+  ];
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const { local } of importLocals) usedNames.add(local);
+  for (const line of renamedPreludes) {
+    const n = preludeLocalName(line);
+    if (n) usedNames.add(n);
+  }
+  usedNames.add(row.fn);
+  return { text: lines.join("\n"), usedNames: [...usedNames] };
+}
+var DERIVED_HEADER = "// @generated by nudo \u2014 do not edit; regenerate with `nudo interface --emit`";
+function collectTopLevelNames(src) {
+  const names = /* @__PURE__ */ new Set();
+  if (src.trim() === "") return names;
+  let ast;
+  try {
+    ast = parseSource3(src);
+  } catch {
+    return names;
+  }
+  const addDecl = (d) => {
+    if (d.type === "VariableDeclaration") {
+      for (const decl of d.declarations) {
+        if (decl.id.type === "Identifier") names.add(decl.id.name);
+      }
+    } else if (d.type === "FunctionDeclaration" || d.type === "ClassDeclaration") {
+      if (d.id) names.add(d.id.name);
+    }
+  };
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ImportDeclaration") {
+      for (const s of stmt.specifiers) names.add(s.local.name);
+      continue;
+    }
+    if (stmt.type === "ExportNamedDeclaration") {
+      if (stmt.declaration) addDecl(stmt.declaration);
+      for (const spec of stmt.specifiers) {
+        names.add(
+          spec.exported.type === "Identifier" ? spec.exported.name : spec.exported.value
+        );
+      }
+      continue;
+    }
+    addDecl(stmt);
+  }
+  return names;
+}
+function sidecarAssembles(text, fromFile, loadModule) {
+  try {
+    parseSource3(text);
+    execNudoModule2(text, { loadModule, fromFile });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function emitDerivedFromRoot(rootFile, opts) {
+  const abs = resolve8(rootFile);
+  const derive = deriveFromRoot(abs, {
+    ...opts.loadModule ? { loadModule: opts.loadModule } : {},
+    ...opts.autoBind !== void 0 ? { autoBind: opts.autoBind } : {},
+    ...opts.fnNames && opts.fnNames.length > 0 ? { fnNames: opts.fnNames } : {}
+  });
+  if (!derive.hasRoot) {
+    return { sidecars: [], hasRoot: false, roots: [], entryOnly: true };
+  }
+  const proj = findProjectConfig(dirname10(abs));
+  const allow = interfaceConfig(proj?.config).emit;
+  const projectDir = proj?.projectDir;
+  const rootSidecarDir = dirname10(sidecarPathOf2(abs));
+  const wanted = opts.fnNames && opts.fnNames.length > 0 ? new Set(opts.fnNames) : void 0;
+  const result = {
+    sidecars: [],
+    hasRoot: true,
+    roots: derive.roots
+  };
+  const bySidecar = /* @__PURE__ */ new Map();
+  for (const row of derive.derived) {
+    if (wanted && !wanted.has(row.fn)) continue;
+    if (!matchesEmitAllowlist(row.file, projectDir, allow)) continue;
+    const sp = sidecarPathOf2(row.file);
+    if (isNodeModulesPath2(sp)) continue;
+    const list = bySidecar.get(sp) ?? [];
+    list.push(row);
+    bySidecar.set(sp, list);
+  }
+  for (const [sidecarPath, rows0] of bySidecar) {
+    const targetFile = rows0[0].file;
+    const targetSidecarDir = dirname10(sidecarPath);
+    const prevSrc = existsSync7(sidecarPath) ? readFileSync8(sidecarPath, "utf-8") : "";
+    const rows = opts.refreshExistingOnly ? rows0.filter((r) => findGeneratedSectionText(prevSrc, r.fn) !== void 0) : rows0;
+    if (rows.length === 0) continue;
+    const handwritten = handwrittenNames(prevSrc);
+    const loadModule = opts.loadModule ?? defaultLoadModule;
+    const batchFns = new Set(
+      rows.filter((r) => !r.underivable && !handwritten.has(r.fn)).map((r) => r.fn)
+    );
+    const baseForNames = opts.mode === "update" ? stripGeneratedFor(prevSrc, batchFns) : prevSrc;
+    const taken = collectTopLevelNames(baseForNames);
+    const accepted = [];
+    const issues = [];
+    const written = [];
+    let anySkip;
+    for (const row of rows) {
+      if (handwritten.has(row.fn)) {
+        issues.push({
+          code: "nudo:interface-name-clash",
+          severity: "error",
+          message: `sidecar already has a handwritten binding '${row.fn}' (${relative2(process.cwd(), sidecarPath) || sidecarPath}); handwritten wins \u2014 skipping emit`
+        });
+        anySkip = "name-clash";
+        continue;
+      }
+      if (row.underivable) {
+        issues.push({
+          code: "nudo:interface-underivable",
+          severity: "info",
+          message: `${row.fn}: contract underivable from ${row.derivedFrom} (opaque / truncated / no evidence)`
+        });
+        anySkip = "underivable";
+        continue;
+      }
+      const prevSection = findGeneratedSectionText(prevSrc, row.fn);
+      const body = formatDerivedSection(row, {
+        rootSidecarDir,
+        targetSidecarDir,
+        takenNames: taken
+      });
+      if (!body) {
+        anySkip = "not-projectable";
+        if (prevSection !== void 0) {
+          for (const n of collectTopLevelNames(prevSection)) taken.add(n);
+        }
+        continue;
+      }
+      for (const n of body.usedNames) taken.add(n);
+      const srcRel = relative2(targetSidecarDir, targetFile) || basename3(targetFile);
+      const section = [
+        DERIVED_HEADER,
+        `// source: ${srcRel}:${row.fn}`,
+        `// derived-from: ${row.derivedFrom}`,
+        body.text,
+        ""
+      ].join("\n");
+      if (!derivedRoundTrips(section, row.fn, sidecarPath, loadModule)) {
+        anySkip = "not-projectable";
+        if (prevSection !== void 0) {
+          for (const n of collectTopLevelNames(prevSection)) taken.add(n);
+        }
+        continue;
+      }
+      if (opts.mode === "add" && prevSection !== void 0) {
+        anySkip = "no-change";
+        for (const n of collectTopLevelNames(prevSection)) taken.add(n);
+        continue;
+      }
+      const norm = normalizeSectionText(section);
+      if (prevSection !== void 0 && normalizeSectionText(prevSection) === norm) {
+        anySkip = "no-change";
+        accepted.push({ fn: row.fn, text: prevSection, prevText: prevSection });
+        for (const n of collectTopLevelNames(prevSection)) taken.add(n);
+        continue;
+      }
+      written.push(row.fn);
+      accepted.push({ fn: row.fn, text: section, ...prevSection !== void 0 ? { prevText: prevSection } : {} });
+    }
+    let finalContent;
+    if (accepted.length === 0) {
+      finalContent = prevSrc;
+    } else if (opts.mode === "add") {
+      finalContent = joinSectionTexts(prevSrc, accepted.map((a) => a.text));
+    } else {
+      const acceptedFns = new Set(accepted.map((a) => a.fn));
+      const stripped = stripGeneratedFor(prevSrc, acceptedFns);
+      const preserved = collectGeneratedSectionsRaw(prevSrc).filter(
+        (s) => !s.names.some((n) => acceptedFns.has(n))
+      );
+      finalContent = joinSectionTexts(stripped, [
+        ...preserved.map((s) => normalizeSectionText(s.text)),
+        ...accepted.map((a) => a.text)
+      ]);
+    }
+    if (finalContent.trim() !== "" && !sidecarAssembles(finalContent, sidecarPath, loadModule)) {
+      issues.push({
+        code: "nudo:interface-not-projectable",
+        severity: "error",
+        message: `assembled sidecar failed round-trip (${relative2(process.cwd(), sidecarPath) || sidecarPath}); refusing to write`
+      });
+      anySkip = "not-projectable";
+      result.sidecars.push({
+        file: targetFile,
+        sidecarPath,
+        fn: rows.map((r) => r.fn).join(","),
+        written: false,
+        changed: false,
+        ...anySkip ? { skipped: anySkip } : {},
+        issues
+      });
+      continue;
+    }
+    const changed = finalContent !== prevSrc;
+    const diff = changed ? unifiedDiff(prevSrc, finalContent, relative2(process.cwd(), sidecarPath) || sidecarPath) : void 0;
+    if (changed && !opts.dryRun) {
+      const tmp = `${sidecarPath}.tmp-${process.pid}-${Math.random().toString(16).slice(2, 10)}`;
+      try {
+        writeFileSync2(tmp, finalContent, "utf-8");
+        renameSync2(tmp, sidecarPath);
+      } catch (e) {
+        try {
+          if (existsSync7(tmp)) unlinkSync2(tmp);
+        } catch {
+        }
+        throw e;
+      }
+    }
+    result.sidecars.push({
+      file: targetFile,
+      sidecarPath,
+      fn: rows.map((r) => r.fn).join(","),
+      written: written.length > 0 && changed,
+      changed,
+      ...anySkip ? { skipped: anySkip } : {},
+      ...diff !== void 0 ? { diff } : {},
+      issues
+    });
+  }
+  return result;
+}
+function collectGeneratedSectionsRaw(src) {
+  if (src.trim() === "") return [];
+  let ast;
+  try {
+    ast = parseSource3(src);
+  } catch {
+    return [];
+  }
+  const stmts = ast.program.body;
+  const out = [];
+  for (const headerPos of findGeneratedHeaderOffsets(src)) {
+    for (let i = 0; i < stmts.length; i++) {
+      const stmt = stmts[i];
+      if (stmt.type !== "ExportNamedDeclaration" || stmt.source) continue;
+      if (stmt.start == null || stmt.end == null || stmt.start < headerPos) continue;
+      const d = stmt.declaration;
+      if (!d) continue;
+      const names = [];
+      if (d.type === "VariableDeclaration") {
+        for (const decl of d.declarations) {
+          if (decl.id.type === "Identifier") names.push(decl.id.name);
+        }
+      } else if (d.type === "FunctionDeclaration" || d.type === "ClassDeclaration") {
+        if (d.id) names.push(d.id.name);
+      }
+      if (names.length === 0) continue;
+      out.push({
+        names,
+        start: headerPos,
+        end: stmt.end,
+        text: src.slice(headerPos, stmt.end)
+      });
+      break;
+    }
+  }
+  return out;
+}
+function findGeneratedHeaderOffsets(src) {
+  const out = [];
+  let pos = 0;
+  for (const line of src.split("\n")) {
+    const t = line.trim();
+    if ((t.startsWith("//") || t.startsWith("/*") || t.startsWith("*")) && /@generated/.test(t)) {
+      out.push(pos);
+    }
+    pos += line.length + 1;
+  }
+  return out;
+}
+function generatedSectionNames(src) {
+  return new Set(collectGeneratedSectionsRaw(src).flatMap((s) => s.names));
+}
+function handwrittenNames(src) {
+  if (src.trim() === "") return /* @__PURE__ */ new Set();
+  let ast;
+  try {
+    ast = parseSource3(src);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+  const names = /* @__PURE__ */ new Set();
+  const collect = (stmt) => {
+    if (stmt.type === "VariableDeclaration") {
+      for (const d of stmt.declarations) {
+        if (d.id.type === "Identifier") names.add(d.id.name);
+      }
+    } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
+      if (stmt.id) names.add(stmt.id.name);
+    }
+  };
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ExportNamedDeclaration") {
+      if (stmt.declaration) collect(stmt.declaration);
+      if (!stmt.source) {
+        for (const spec of stmt.specifiers) {
+          names.add(
+            spec.exported.type === "Identifier" ? spec.exported.name : spec.exported.value
+          );
+        }
+      }
+    } else {
+      collect(stmt);
+    }
+  }
+  for (const n of generatedSectionNames(src)) names.delete(n);
+  return names;
+}
+function findGeneratedSectionText(src, fn) {
+  return collectGeneratedSectionsRaw(src).find((s) => s.names.includes(fn))?.text;
+}
+function stripGeneratedFor(src, fns) {
+  const sections = collectGeneratedSectionsRaw(src).filter(
+    (s) => s.names.some((n) => fns.has(n))
+  );
+  if (sections.length === 0) return src;
+  const sorted = [...sections].sort((a, b) => a.start - b.start);
+  let out = "";
+  let pos = 0;
+  for (const s of sorted) {
+    out += src.slice(pos, s.start);
+    pos = Math.max(pos, s.end);
+  }
+  out += src.slice(pos);
+  return out;
+}
+function normalizeSectionText(text) {
+  return text.replace(/\s*$/, "") + "\n";
+}
+function joinSectionTexts(base, sectionTexts) {
+  const normalized = sectionTexts.map(normalizeSectionText).filter((t) => t.trim() !== "");
+  const tailTrimmed = base.replace(/\s+$/, "");
+  if (normalized.length === 0) return tailTrimmed === "" ? "" : `${tailTrimmed}
+`;
+  const trimmed = tailTrimmed.replace(/^\s+/, "");
+  const lead = trimmed === "" ? "" : `${trimmed}
+
+`;
+  return lead + normalized.join("\n");
+}
+function derivedRoundTrips(text, fn, fromFile, loadModule) {
+  const since = refineDiagCount3();
+  try {
+    const exports = execNudoModule2(text, { loadModule, fromFile });
+    const v = exports[fn];
+    return isNudoConstraint2(v) && v.fn !== void 0;
+  } catch {
+    return false;
+  } finally {
+    takeRefineDiagsSince3(since);
+  }
+}
 export {
   SEMANTIC_TOKEN_MODIFIERS,
   SEMANTIC_TOKEN_TYPES,
+  absToTSType,
+  absToZodSchema,
   analyzeExportsFromSource,
   analyzeFile,
   analyzeFileAsync,
@@ -5233,9 +5933,10 @@ export {
   computeDirtySet,
   defaultAbsLoadModule,
   defaultLoadModule,
+  deriveFromRoot,
+  emitDerivedFromRoot,
   emitInterface,
   encodeSemanticTokens,
-  envValueToAbs,
   evalAbsModuleGraph,
   evalProgramAbsWithModules,
   evictAbsModuleCacheFiles,
@@ -5243,7 +5944,9 @@ export {
   evictAnalysisFileCacheForFiles,
   evictBPathCacheForFiles,
   evictFnAnalysisCacheForFiles,
+  extractFnConstraintSources,
   findProjectConfig,
+  formatDerivedSection,
   formatEmitSummary,
   formatHarvestSummary,
   formatInterfaceSurfaceLine,
@@ -5251,6 +5954,8 @@ export {
   generateFunctionDtsLines,
   generateGuardFunction,
   generateGuardFunctionFromAbs,
+  getAbsAtPosition,
+  getAbsAtPositionAsync,
   getAnalysisFileCacheSize,
   getCasesForFile,
   getCompletionsAtPosition,
@@ -5268,6 +5973,7 @@ export {
   isBPathCapable,
   isNudoTargetPath,
   lookupHarvested,
+  matchesEmitAllowlist,
   mockDirectivesToAbsSeeds,
   packageHarvestToAbsModules,
   resetAllAnalysisCaches,
@@ -5280,7 +5986,5 @@ export {
   tryBPathCall,
   tryBPathCallFull,
   tryRunBPath,
-  typeValueToTSType,
-  typeValueToZodSchema,
   unifiedDiff
 };