@nudojs/service 0.3.1 → 1.0.0

package/dist/index.js

@@ -1,6 +1,38 @@
+import {
+  BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS,
+  USAGE_SITE_MODULE,
+  evaluate,
+  evaluateFunction,
+  evaluateFunctionFull,
+  evaluateProgram,
+  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";
+
 // src/analyzer.ts
-import { readFileSync as readFileSync4, existsSync as existsSync3, statSync as statSync3, realpathSync } from "fs";
-import { resolve as resolve4, dirname as dirname5 } from "path";
+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,
@@ -11,7 +43,6 @@ import {
   createEnvironment as createEnvironment2,
   isSubtypeOf,
   mockHelperToTypeValue,
-  getFnSig as getFnSig3,
   generalizeFromAst as generalizeFromAst2,
   termToString,
   predToString,
@@ -20,8 +51,7 @@ import {
   setAbsCallCollector,
   setAbsNodeCollector,
   absFunction as absFunction5,
-  collectAbsNodeTypes,
-  findAbsAtPosition,
+  checkInjectedDomainEvidence,
   typeValueToAbs as typeValueToAbs5,
   absToTypeValue as absToTypeValue2,
   formatAbs as formatAbs3,
@@ -30,36 +60,6 @@ import {
   fnFingerprints
 } from "@nudojs/core";
 import { parse as parse5, extractDirectives, extractFileDirectives, parseTypeValueExpr as parseTypeValueExpr2 } from "@nudojs/parser";
-import {
-  evaluate,
-  evaluateFunction,
-  evaluateFunctionFull,
-  memberMayExistOn,
-  setUsageSiteTag,
-  USAGE_SITE_MODULE,
-  evaluateProgram,
-  setModuleResolver,
-  setCurrentFileDir,
-  resetMemo,
-  getUnreachableRanges,
-  resetUnreachableRanges,
-  setNodeTypeCollector,
-  setCallCollector,
-  setUnknownCollector,
-  setProvenanceTracking,
-  setSampleCount,
-  setUnknownBuiltinHandler,
-  setEnvModules,
-  resetEnvModules,
-  setMockModules,
-  resetMockModules,
-  setCurrentSource,
-  loadEnvs as loadEnvs2,
-  preloadPathEnvs,
-  findProjectConfig,
-  resolveNpmNudo,
-  BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS
-} from "@nudojs/cli/evaluator";
 
 // src/mock-abs.ts
 import { parseTypeValueExpr } from "@nudojs/parser";
@@ -268,17 +268,44 @@ function mockDirectivesToAbsSeeds(functions) {
   return { seedVars, seedFns };
 }
 
+// src/load-module.ts
+import { existsSync, statSync, readFileSync } from "fs";
+import { dirname, resolve, join } from "path";
+function defaultLoadModule(spec, fromFile) {
+  if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
+  try {
+    const base = dirname(resolve(fromFile));
+    const p = resolve(base, spec);
+    for (const cand of [
+      p,
+      `${p}.js`,
+      `${p}.mjs`,
+      `${p}.ts`,
+      join(p, "index.js"),
+      join(p, "index.mjs"),
+      join(p, "index.ts")
+    ]) {
+      if (existsSync(cand) && !statSync(cand).isDirectory()) {
+        return readFileSync(cand, "utf-8");
+      }
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+
 // src/harvest-auto.ts
 import { parse as parse2 } from "@nudojs/parser";
 
 // src/static-imports.ts
 import { parse } from "@nudojs/parser";
-import { readFileSync, existsSync } from "fs";
-import { resolve, dirname, join } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { resolve as resolve2, dirname as dirname2, join as join2 } from "path";
 import { generalizeFromAst } from "@nudojs/core";
 function resolveRelative(fromFile, spec) {
   if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
-  const base = resolve(dirname(fromFile), spec);
+  const base = resolve2(dirname2(fromFile), spec);
   for (const cand of [
     base,
     base + ".js",
@@ -287,12 +314,12 @@ function resolveRelative(fromFile, spec) {
     base + ".ts",
     base + ".mts",
     base + ".cts",
-    join(base, "index.js"),
-    join(base, "index.cjs"),
-    join(base, "index.mjs"),
-    join(base, "index.ts")
+    join2(base, "index.js"),
+    join2(base, "index.cjs"),
+    join2(base, "index.mjs"),
+    join2(base, "index.ts")
   ]) {
-    if (existsSync(cand)) return cand;
+    if (existsSync2(cand)) return cand;
   }
   return void 0;
 }
@@ -411,15 +438,15 @@ function collectCjsExports(stmt, named, setDefault) {
 function collectStaticImports(entryFile, maxDepth = 8) {
   const graph = /* @__PURE__ */ new Map();
   const queue = [
-    { file: resolve(entryFile), depth: 0 }
+    { file: resolve2(entryFile), depth: 0 }
   ];
   const seen = /* @__PURE__ */ new Set();
   while (queue.length > 0) {
     const { file, depth } = queue.shift();
     if (seen.has(file) || depth > maxDepth) continue;
     seen.add(file);
-    if (!existsSync(file)) continue;
-    const source = readFileSync(file, "utf8");
+    if (!existsSync2(file)) continue;
+    const source = readFileSync2(file, "utf8");
     const mod = analyzeExportsFromSource(file, source);
     graph.set(file, mod);
     const ast = parse(source);
@@ -432,19 +459,19 @@ function collectStaticImports(entryFile, maxDepth = 8) {
 }
 
 // src/harvest-package.ts
-import { existsSync as existsSync2, readdirSync, statSync, readFileSync as readFileSync2 } from "fs";
-import { join as join2, resolve as resolve2, dirname as dirname2, basename } from "path";
+import { 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";
 function resolvePackageRoot(pkg, fromDir = process.cwd()) {
-  let dir = resolve2(fromDir);
+  let dir = resolve3(fromDir);
   const bare = pkg.replace(/^@/, "").replace(/\//g, "__");
   for (let i = 0; i < 8; i++) {
-    const typesPath = join2(dir, "node_modules", "@types", bare);
-    if (existsSync2(typesPath)) return typesPath;
-    const pkgPath = join2(dir, "node_modules", pkg);
-    if (existsSync2(pkgPath)) return pkgPath;
-    const parent = resolve2(dir, "..");
+    const typesPath = join3(dir, "node_modules", "@types", bare);
+    if (existsSync3(typesPath)) return typesPath;
+    const pkgPath = join3(dir, "node_modules", pkg);
+    if (existsSync3(pkgPath)) return pkgPath;
+    const parent = resolve3(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -474,10 +501,10 @@ function collectDtsFiles(root, maxFiles = 8) {
     for (const name of entries) {
       if (out.length >= maxFiles * 3) return;
       if (SKIP_DIRS.has(name)) continue;
-      const p = join2(dir, name);
+      const p = join3(dir, name);
       let st;
       try {
-        st = statSync(p);
+        st = statSync2(p);
       } catch {
         continue;
       }
@@ -493,15 +520,15 @@ function collectDtsFiles(root, maxFiles = 8) {
   return out.slice(0, maxFiles);
 }
 function entryDtsFromPackageJson(root) {
-  const pj = join2(root, "package.json");
-  if (!existsSync2(pj)) return void 0;
+  const pj = join3(root, "package.json");
+  if (!existsSync3(pj)) return void 0;
   try {
-    const raw = JSON.parse(readFileSync2(pj, "utf8"));
+    const raw = JSON.parse(readFileSync3(pj, "utf8"));
     const entry = raw.types ?? raw.typings;
     if (typeof entry === "string" && entry.endsWith(".d.ts")) {
-      const p = resolve2(root, entry);
-      if (existsSync2(p)) {
-        const st = statSync(p);
+      const p = resolve3(root, entry);
+      if (existsSync3(p)) {
+        const st = statSync2(p);
         if (st.size <= MAX_DTS_BYTES) return p;
       }
     }
@@ -517,24 +544,24 @@ function collectDtsFromEntry(entry, maxFiles = 200) {
   const RELATIVE_FROM_REGEX = /\bfrom\s+["'](\.[^"']+)["']/g;
   while (queue.length > 0 && files.length < maxFiles) {
     const current = queue.shift();
-    if (seen.has(current) || !existsSync2(current)) continue;
+    if (seen.has(current) || !existsSync3(current)) continue;
     seen.add(current);
     if (!current.endsWith(".d.ts")) continue;
     files.push(current);
     let text;
     try {
-      text = readFileSync2(current, "utf-8");
+      text = readFileSync3(current, "utf-8");
     } catch {
       continue;
     }
-    const dir = dirname2(current);
+    const dir = dirname3(current);
     for (const match of text.matchAll(REFERENCE_PATH_REGEX)) {
-      queue.push(resolve2(dir, match[1]));
+      queue.push(resolve3(dir, match[1]));
     }
     for (const match of text.matchAll(RELATIVE_FROM_REGEX)) {
-      const base = resolve2(dir, match[1]);
-      for (const candidate of [`${base}.d.ts`, join2(base, "index.d.ts")]) {
-        if (existsSync2(candidate)) {
+      const base = resolve3(dir, match[1]);
+      for (const candidate of [`${base}.d.ts`, join3(base, "index.d.ts")]) {
+        if (existsSync3(candidate)) {
           queue.push(candidate);
           break;
         }
@@ -546,11 +573,11 @@ function collectDtsFromEntry(entry, maxFiles = 200) {
 function harvestPackage(pkg, fromDir, maxFiles = 8) {
   const root = resolvePackageRoot(pkg, fromDir);
   if (!root) return { error: `package not found: ${pkg}` };
-  const entry = entryDtsFromPackageJson(root) ?? join2(root, "index.d.ts");
-  let dtsFiles = existsSync2(entry) ? collectDtsFromEntry(entry, maxFiles) : [];
+  const entry = entryDtsFromPackageJson(root) ?? join3(root, "index.d.ts");
+  let dtsFiles = existsSync3(entry) ? collectDtsFromEntry(entry, maxFiles) : [];
   if (dtsFiles.length === 0) {
     const collected = collectDtsFiles(root, maxFiles);
-    dtsFiles = entry && existsSync2(entry) && !collected.includes(entry) ? [entry, ...collected.filter((f) => f !== entry)].slice(0, maxFiles) : collected;
+    dtsFiles = entry && existsSync3(entry) && !collected.includes(entry) ? [entry, ...collected.filter((f) => f !== entry)].slice(0, maxFiles) : collected;
   }
   if (dtsFiles.length === 0) {
     return { error: `no .d.ts under ${root}` };
@@ -639,8 +666,8 @@ function autoHarvestModules(source, fromDir) {
 }
 
 // src/abs-modules-graph.ts
-import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
-import { dirname as dirname4, resolve as resolve3 } from "path";
+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,
@@ -656,7 +683,7 @@ import {
   getFnSig,
   absFunction as absFunction2
 } from "@nudojs/core";
-import { dirname as dirname3 } from "path";
+import { dirname as dirname4 } from "path";
 function markMockConf2(a) {
   a.conf = confJoin2(a.conf, "mock");
   return a;
@@ -728,7 +755,7 @@ function bareSpecToAbsModules(spec, fromFile) {
   const parts = spec.split("/");
   const pkg = spec.startsWith("@") ? parts.length >= 2 ? `${parts[0]}/${parts[1]}` : void 0 : parts[0];
   if (!pkg) return void 0;
-  const table = harvestToAbsModules(pkg, dirname3(fromFile));
+  const table = harvestToAbsModules(pkg, dirname4(fromFile));
   return table[spec] ?? table[pkg];
 }
 
@@ -736,10 +763,10 @@ function bareSpecToAbsModules(spec, fromFile) {
 function defaultAbsLoadModule(spec, fromFile) {
   if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
   try {
-    const p = resolve3(dirname4(resolve3(fromFile)), spec);
-    for (const cand of [p, `${p}.js`, `${p}.mjs`, `${p}.ts`, resolve3(p, "index.js")]) {
+    const p = resolve4(dirname5(resolve4(fromFile)), spec);
+    for (const cand of [p, `${p}.js`, `${p}.mjs`, `${p}.ts`, resolve4(p, "index.js")]) {
       try {
-        return readFileSync3(cand, "utf-8");
+        return readFileSync4(cand, "utf-8");
       } catch {
       }
     }
@@ -749,14 +776,14 @@ function defaultAbsLoadModule(spec, fromFile) {
   }
 }
 function relCandidates(spec, fromFile) {
-  const p = resolve3(dirname4(resolve3(fromFile)), spec);
-  return [p, `${p}.js`, `${p}.mjs`, `${p}.ts`, resolve3(p, "index.js")];
+  const p = resolve4(dirname5(resolve4(fromFile)), spec);
+  return [p, `${p}.js`, `${p}.mjs`, `${p}.ts`, resolve4(p, "index.js")];
 }
 function resolveRel(spec, fromFile) {
   if (!spec.startsWith(".") && !spec.startsWith("/")) return null;
   for (const cand of relCandidates(spec, fromFile)) {
     try {
-      readFileSync3(cand, "utf-8");
+      readFileSync4(cand, "utf-8");
       return cand;
     } catch {
     }
@@ -854,7 +881,7 @@ function evalAbsModuleGraph(entrySource, entryFile, opts = {}) {
     const shared = absModuleCache.get(absPath);
     if (shared) {
       try {
-        const st = statSync2(absPath);
+        const st = statSync3(absPath);
         if (st.mtimeMs === shared.mtimeMs && st.size === shared.size) {
           for (const iss of shared.issues) pushIssue(iss.kind, iss.label, iss.reason);
           cache.set(absPath, shared.exports);
@@ -919,7 +946,7 @@ function evalAbsModuleGraph(entrySource, entryFile, opts = {}) {
     cache.set(absPath, exports);
     let fingerprint;
     try {
-      const st = statSync2(absPath);
+      const st = statSync3(absPath);
       fingerprint = { mtimeMs: st.mtimeMs, size: st.size };
     } catch {
     }
@@ -994,7 +1021,6 @@ import {
   getFnImpl as getFnImpl2
 } from "@nudojs/core";
 import { parse as parse4, extractInlineDirectives } from "@nudojs/parser";
-import { loadEnvs } from "@nudojs/cli/evaluator";
 
 // src/env-to-abs.ts
 import {
@@ -1114,10 +1140,10 @@ function evictFnAnalysisCacheForFiles(files) {
   }
   return n;
 }
-function caseDirectiveKey(directives, typeValueToString5) {
+function caseDirectiveKey(directives, typeValueToString7) {
   return directives.map((d) => {
     if (d.kind === "case") {
-      const args = (d.args ?? []).map((a) => typeValueToString5(a)).join(",");
+      const args = (d.args ?? []).map((a) => typeValueToString7(a)).join(",");
       return `c:${d.name ?? ""}:${args}`;
     }
     return d.kind;
@@ -1576,23 +1602,23 @@ function resolveModule(source, fromDir) {
   const extensions = [".js", ".ts", ".mjs"];
   const nudoPath = resolveNpmNudo(source, fromDir);
   if (nudoPath) {
-    const src = readFileSync4(nudoPath, "utf-8");
+    const src = readFileSync5(nudoPath, "utf-8");
     return { ast: parse5(src), filePath: nudoPath };
   }
-  const basePath = resolve4(fromDir, source);
+  const basePath = resolve5(fromDir, source);
   for (const ext of ["", ...extensions]) {
     const candidate = basePath + ext;
-    if (!existsSync3(candidate)) continue;
-    if (statSync3(candidate).isDirectory()) {
+    if (!existsSync4(candidate)) continue;
+    if (statSync4(candidate).isDirectory()) {
       let entry = null;
-      const pkgPath = resolve4(candidate, "package.json");
-      if (existsSync3(pkgPath)) {
+      const pkgPath = resolve5(candidate, "package.json");
+      if (existsSync4(pkgPath)) {
         try {
-          const main = JSON.parse(readFileSync4(pkgPath, "utf-8")).main;
+          const main = JSON.parse(readFileSync5(pkgPath, "utf-8")).main;
           if (typeof main === "string") {
             for (const e of ["", ...extensions]) {
-              const p = resolve4(candidate, main + e);
-              if (existsSync3(p) && statSync3(p).isFile()) {
+              const p = resolve5(candidate, main + e);
+              if (existsSync4(p) && statSync4(p).isFile()) {
                 entry = p;
                 break;
               }
@@ -1603,34 +1629,34 @@ function resolveModule(source, fromDir) {
       }
       if (!entry) {
         for (const e of ["", ...extensions]) {
-          const p = resolve4(candidate, "index" + e);
-          if (existsSync3(p) && statSync3(p).isFile()) {
+          const p = resolve5(candidate, "index" + e);
+          if (existsSync4(p) && statSync4(p).isFile()) {
             entry = p;
             break;
           }
         }
       }
       if (!entry) return null;
-      const src2 = readFileSync4(entry, "utf-8");
+      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(readFileSync4(candidate, "utf-8")) };
+        return { ast: parse5("module.exports = undefined;"), filePath: candidate, json: JSON.parse(readFileSync5(candidate, "utf-8")) };
       } catch {
         return null;
       }
     }
-    const src = readFileSync4(candidate, "utf-8");
+    const src = readFileSync5(candidate, "utf-8");
     return { ast: parse5(src), filePath: candidate };
   }
   return null;
 }
 function resolveImportPath(specifier, fromDir) {
-  const basePath = resolve4(fromDir, specifier);
+  const basePath = resolve5(fromDir, specifier);
   for (const ext of ["", ".js", ".ts", ".mjs"]) {
     const candidate = basePath + ext;
-    if (existsSync3(candidate)) return candidate;
+    if (existsSync4(candidate)) return candidate;
   }
   return null;
 }
@@ -1650,7 +1676,7 @@ function buildModuleGraph(files, cache) {
     if (cache) {
       let stat = null;
       try {
-        stat = statSync3(file);
+        stat = statSync4(file);
       } catch {
       }
       const cached = stat ? cache.get(file) : void 0;
@@ -1671,7 +1697,7 @@ function extractImportEdges(file) {
   const edges = [];
   let ast;
   try {
-    ast = parse5(readFileSync4(file, "utf-8"));
+    ast = parse5(readFileSync5(file, "utf-8"));
   } catch {
     return edges;
   }
@@ -1679,7 +1705,7 @@ function extractImportEdges(file) {
     if (stmt.type !== "ImportDeclaration") continue;
     const specifier = stmt.source.value;
     if (!specifier.startsWith(".") && !specifier.startsWith("/")) continue;
-    const resolved = resolveImportPath(specifier, dirname5(file));
+    const resolved = resolveImportPath(specifier, dirname6(file));
     if (resolved) edges.push(resolved);
   }
   return edges;
@@ -1757,8 +1783,8 @@ function applyMocks(directives, env, filePath, diagnostics) {
       }
       env.bind(d.name, parseTypeValueExpr2(d.expression));
     } else if (d.fromPath) {
-      const mockPath = resolve4(dirname5(filePath), d.fromPath);
-      const mockSource = readFileSync4(mockPath, "utf-8");
+      const mockPath = resolve5(dirname6(filePath), d.fromPath);
+      const mockSource = readFileSync5(mockPath, "utf-8");
       const mockAst = parse5(mockSource);
       const mockEnv = createEnvironment2();
       evaluateProgram(mockAst, mockEnv);
@@ -1822,6 +1848,16 @@ function resolveFunctionNode(node) {
   }
   return node;
 }
+function fnNameLoc(node, fallback) {
+  const unwrap = (n) => n.type === "ExportNamedDeclaration" && n.declaration ? n.declaration : n.type === "ExportDefaultDeclaration" ? n.declaration : n;
+  const d = unwrap(node);
+  if (d.type === "VariableDeclaration") {
+    const id = d.declarations[0]?.id;
+    if (id?.type === "Identifier" && id.loc) return id.loc;
+  }
+  if (d.id?.loc) return d.id.loc;
+  return fallback;
+}
 function isFnExprValue(node) {
   return !!node && (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression");
 }
@@ -2180,14 +2216,14 @@ function collectEnvNames(filePath, source, includeProject) {
   const fileDirectives = extractFileDirectives(ast);
   const fileEnvNames = fileDirectives.filter((d) => d.kind === "env").flatMap((d) => d.envs);
   if (!includeProject) return fileEnvNames;
-  const projectConfig = findProjectConfig(dirname5(filePath));
+  const projectConfig = findProjectConfig(dirname6(filePath));
   const projectEnvNames = projectConfig?.config.env ?? [];
   return [.../* @__PURE__ */ new Set([...projectEnvNames, ...fileEnvNames])];
 }
 async function analyzeFileAsync(filePath, source, activeCases, externalCallRecords) {
   const envNames = collectEnvNames(filePath, source, true);
   if (envNames.length > 0) {
-    await preloadPathEnvs(envNames, dirname5(filePath));
+    await preloadPathEnvs(envNames, dirname6(filePath));
   }
   return analyzeFile(filePath, source, activeCases, externalCallRecords);
 }
@@ -2199,7 +2235,7 @@ function collectCallRecords(filePath, source) {
   resetEnvModules();
   resetMockModules();
   setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname5(filePath));
+  setCurrentFileDir(dirname6(filePath));
   setCurrentSource(source);
   setCallCollector((record) => records.push(record));
   try {
@@ -2330,11 +2366,11 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
   resetEnvModules();
   resetMockModules();
   setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname5(filePath));
+  setCurrentFileDir(dirname6(filePath));
   setCurrentSource(source);
   const fileDirectives = extractFileDirectives(ast);
   const fileEnvNames = fileDirectives.filter((d) => d.kind === "env").flatMap((d) => d.envs);
-  const projectConfig = findProjectConfig(dirname5(filePath));
+  const projectConfig = findProjectConfig(dirname6(filePath));
   const projectEnvNames = projectConfig?.config.env ?? [];
   const envNames = [.../* @__PURE__ */ new Set([...projectEnvNames, ...fileEnvNames])];
   setUnknownBuiltinHandler((name, loc) => {
@@ -2352,15 +2388,15 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
   });
   const globalEnv = createEnvironment2();
   {
-    const loaded = envNames.length > 0 ? loadEnvs2(envNames, globalEnv) : { modules: {} };
-    const auto = autoHarvestModules(source, dirname5(filePath));
+    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: resolve4(projectConfig.projectDir, mockPath) });
+      mocks.set(source2, { fromPath: resolve5(projectConfig.projectDir, mockPath) });
     }
   }
   const mockModuleDirectives = fileDirectives.filter((d) => d.kind === "mock-module");
@@ -2838,8 +2874,47 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
     }
     return n;
   };
-  const currentModulePath = normalizeModulePath(resolve4(filePath));
+  const currentModulePath = normalizeModulePath(resolve5(filePath));
   const singleExportFn = findSingleModuleExportsFunction(ast);
+  const reportInjectedDomainExceeds = (name, node, fallbackLoc) => {
+    if (!externalCallRecords || externalCallRecords.length === 0) return;
+    const singleExportHit = singleExportFn !== null && node === singleExportFn;
+    const nameRoutes = (r) => r.fnName === name || r.targetExport === name || (r.targetAliases?.includes(name) ?? false) || singleExportHit && (r.fnModule !== void 0 || r.targetModule !== void 0);
+    const matchingExternal = (r) => {
+      const attributed = r.fnModule !== void 0 && normalizeModulePath(r.fnModule) === currentModulePath || r.targetModule !== void 0 && normalizeModulePath(r.targetModule) === currentModulePath;
+      if (!attributed) return false;
+      return nameRoutes(r);
+    };
+    const injected = externalCallRecords.filter(matchingExternal);
+    if (injected.length === 0) return;
+    const nameLoc = fnNameLoc(node, fallbackLoc);
+    const fnNode = resolveFunctionNode(node);
+    const autoBind = interfaceConfig(findProjectConfig(dirname6(filePath))?.config).autoBind;
+    const domainIssues = checkInjectedDomainEvidence(name, source, injected, {
+      paramNames: extractParamNames(fnNode),
+      loadModule: defaultLoadModule,
+      fromFile: filePath,
+      loc: { line: nameLoc.start.line, column: nameLoc.start.column },
+      ...autoBind === false ? { autoBind: false } : {}
+    });
+    for (const issue of domainIssues) {
+      const line = issue.line ?? nameLoc.start.line;
+      const column = issue.column ?? nameLoc.start.column;
+      diagnostics.push({
+        range: { start: { line, column }, end: { line, column: column + name.length } },
+        severity: issue.severity,
+        message: issue.message,
+        code: issue.code,
+        suggestions: issue.suggestion ? [issue.suggestion] : void 0,
+        data: { actual: issue.actual, expected: issue.expected }
+      });
+    }
+  };
+  for (const fn of functions) {
+    if (fn.directives.some((d) => d.kind === "case")) {
+      reportInjectedDomainExceeds(fn.name, fn.node, locFromNode(fn.node));
+    }
+  }
   for (const candidate of synthCandidates) {
     const singleExportHit = singleExportFn !== null && candidate.node === singleExportFn;
     const nameRoutes = (r) => r.fnName === candidate.name || r.targetExport === candidate.name || (r.targetAliases?.includes(candidate.name) ?? false) || singleExportHit && (r.fnModule !== void 0 || r.targetModule !== void 0);
@@ -2859,6 +2934,7 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords)
         ...(externalCallRecords ?? []).filter(matchingExternal)
       ].filter((r) => !(r.resultType.kind === "never" && r.throws.kind === "never"))
     );
+    reportInjectedDomainExceeds(candidate.name, candidate.node, candidate.analysis.loc);
     if (records.length > 0) {
       const informativeness = (r) => {
         if (r.resultType.kind === "unknown") return 2;
@@ -3101,103 +3177,313 @@ function buildNodeTypeMap(ast, env, nodeTypeMap) {
   } catch {
   }
 }
-function getCasesForFile(filePath, source) {
-  const ast = parse5(source);
-  const functions = extractDirectives(ast);
-  return functions.map((fn) => {
-    const cases = fn.directives.filter((d) => d.kind === "case").map((d, i) => ({ name: d.name, index: i }));
-    return { functionName: fn.name, cases, loc: locFromNode(fn.node) };
-  });
-}
-async function getTypeAtPositionAsync(filePath, source, line, column, activeCases) {
-  const envNames = collectEnvNames(filePath, source, false);
-  if (envNames.length > 0) {
-    await preloadPathEnvs(envNames, dirname5(filePath));
+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;
   }
-  return getTypeAtPosition(filePath, source, line, column, activeCases);
+  if (absTv.kind === "refined" && prev.kind === "primitive") return true;
+  return false;
 }
-function getTypeAtPosition(filePath, source, line, column, activeCases) {
-  const ast = parse5(source);
-  const fileDirectives = extractFileDirectives(ast);
-  const envNames = fileDirectives.filter((d) => d.kind === "env").flatMap((d) => d.envs);
-  if (isBPathCapable(source, envNames)) {
-    try {
-      const seeds = mockDirectivesToAbsSeeds(extractDirectives(ast));
-      const { modules } = evalAbsModuleGraph(source, filePath);
-      const absNodes = collectAbsNodeTypes(source, {
-        ...seeds,
-        modules,
-        file: ast
-      });
-      const absAt = findAbsAtPosition(absNodes, line, column);
-      if (absAt) return absToTypeValue2(absAt);
-      const ident = findIdentNameAtPosition(source, line, column, ast);
-      if (ident) {
-        const binds = collectAbsBindingsFromGraph(source, filePath, {
-          seedVars: seeds.seedVars,
-          seedFns: seeds.seedFns
+function isSelfContainedSource(source, envNames) {
+  if (envNames.length > 0) return false;
+  return !/\brequire\s*\(|\bimport\s*[{'"*]/.test(source);
+}
+function absModulesOk(source, envNames) {
+  void source;
+  void envNames;
+  return true;
+}
+function collectAbsCallRecords(source, seeds, filePath, precomputedModules, envNames = []) {
+  const absCalls = [];
+  let modules = precomputedModules;
+  let importLocals = /* @__PURE__ */ new Map();
+  if (filePath && absModulesOk(source, envNames)) {
+    if (!modules) {
+      try {
+        const graph = evalAbsModuleGraph(source, filePath, {
+          seedVars: seeds?.seedVars,
+          seedFns: seeds?.seedFns
         });
-        const bound = binds.get(ident);
-        if (bound) return absToTypeValue2(bound);
+        modules = graph.modules;
+      } catch {
+        modules = void 0;
       }
+    }
+    if (envNames.length > 0) {
+      modules = { ...collectEnvModules(envNames), ...modules ?? {} };
+    }
+    try {
+      importLocals = buildAbsImportLocalMap(source, filePath);
     } catch {
+      importLocals = /* @__PURE__ */ new Map();
     }
   }
-  resetMemo();
-  resetEnvModules();
-  setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname5(filePath));
-  setCurrentSource(source);
-  const globalEnv = createEnvironment2();
-  {
-    const loaded = envNames.length > 0 ? loadEnvs2(envNames, globalEnv) : { modules: {} };
-    const auto = autoHarvestModules(source, dirname5(filePath));
-    const modules = { ...loaded.modules, ...auto };
-    if (Object.keys(modules).length > 0) setEnvModules(modules);
+  setAbsCallCollector((r) => absCalls.push(r));
+  try {
+    evalProgramAbs2(source, { ...seeds, modules });
+  } catch {
+  } finally {
+    setAbsCallCollector(null);
   }
-  evaluateProgram(ast, globalEnv);
-  const nodeTypeMap = /* @__PURE__ */ new Map();
-  buildNodeTypeMap(ast, globalEnv, nodeTypeMap);
-  const functions = extractDirectives(ast);
-  const enclosingFn = findEnclosingFunction(functions, line);
-  if (enclosingFn) {
-    const caseDirectives = enclosingFn.directives.filter((d) => d.kind === "case");
-    if (caseDirectives.length > 0) {
-      const caseIndex = activeCases?.get(enclosingFn.name) ?? 0;
-      const directive = caseDirectives[Math.min(caseIndex, caseDirectives.length - 1)];
-      const fnNodeTypeMap = /* @__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);
+  return absCalls.map((r) => {
+    const rec = {
+      fnName: r.fnName,
+      argTypes: r.args.map((a) => absToTypeValue2(a)),
+      resultType: r.threw ? T2.never : absToTypeValue2(r.result),
+      throws: r.threw ? absToTypeValue2(r.result) : T2.never,
+      callLoc: r.callLoc
+    };
+    const imp = importLocals.get(r.fnName);
+    if (imp) {
+      rec.targetModule = imp.modulePath;
+      rec.targetExport = imp.exportName;
+    }
+    return rec;
+  });
+}
+function collectAbsBindsAndNodes(source, seeds, modules) {
+  const binds = /* @__PURE__ */ new Map();
+  const nodes = /* @__PURE__ */ new Map();
+  setAbsNodeCollector((node, value) => {
+    nodes.set(node, value);
+  });
+  try {
+    const { env } = evalProgramAbs2(source, {
+      ...seeds,
+      modules
+    });
+    for (const [k, v] of env.vars) binds.set(k, v);
+    for (const [name, impl] of env.fns) {
+      if (!binds.has(name)) {
+        binds.set(
+          name,
+          absFunction5(impl.params, { body: impl.body, async: impl.async, env })
+        );
       }
     }
+  } catch {
+  } finally {
+    setAbsNodeCollector(null);
   }
-  setModuleResolver(null);
-  resetEnvModules();
-  resetMockModules();
-  return findBestTypeAtPosition(nodeTypeMap, globalEnv, ast, line, column);
+  return { binds, nodes };
 }
-function getHoverAtPosition(filePath, source, line, column, activeCases) {
-  let file;
+function buildAbsImportLocalMap(source, fromFile) {
+  const out = /* @__PURE__ */ new Map();
   try {
-    file = parse5(source);
+    const file = parse5(source);
+    for (const stmt of file.program.body) {
+      if (stmt.type !== "ImportDeclaration") continue;
+      const spec = stmt.source.value;
+      let modulePath = null;
+      if (spec.startsWith(".") || spec.startsWith("/")) {
+        modulePath = resolveImportAbs(spec, fromFile);
+      } else if (!spec.startsWith("node:")) {
+        modulePath = spec;
+      }
+      if (!modulePath) continue;
+      for (const s of stmt.specifiers) {
+        if (s.type === "ImportSpecifier") {
+          const imported = s.imported.type === "Identifier" ? s.imported.name : String(s.imported);
+          out.set(s.local.name, { modulePath, exportName: imported });
+        } else if (s.type === "ImportDefaultSpecifier") {
+          out.set(s.local.name, { modulePath, exportName: "default" });
+        }
+      }
+    }
   } catch {
-    file = void 0;
   }
-  const envNames = collectEnvNames(filePath, source, false);
-  const fnName = findFunctionNameAtPosition(source, line, column, file);
-  let gDisplay;
+  return out;
+}
+function resolveImportAbs(spec, fromFile) {
+  const base = dirname6(resolve5(fromFile));
+  const p = resolve5(base, spec);
+  for (const cand of [p, `${p}.js`, `${p}.mjs`, `${p}.ts`, resolve5(p, "index.js")]) {
+    if (existsSync4(cand) && !statSync4(cand).isDirectory()) return cand;
+  }
+  return null;
+}
+function tryEvalAbs(source, fnName, args, filePath, mocks) {
+  const raw = tryEvalAbsRaw(source, fnName, args, filePath, mocks);
+  return raw ? absToTypeValue2(raw) : void 0;
+}
+function tryEvalAbsRaw(source, fnName, args, filePath, mocks) {
+  if (/\brequire\s*\(/.test(source)) return void 0;
+  try {
+    const absArgs = args.map((a) => typeValueToAbs5(a));
+    if (filePath) {
+      const viaB = tryBPathCall(source, filePath, fnName, absArgs, { mocks });
+      if (viaB) return viaB;
+    }
+    let modules;
+    if (filePath && /\bimport\s*[{'"*]/.test(source)) {
+      modules = evalAbsModuleGraph(source, filePath).modules;
+    }
+    const result = analyzeFn(source, fnName, absArgs, void 0, void 0, void 0, modules);
+    if (result.shape.k === "unknown" && !result.term) {
+      return void 0;
+    }
+    return result;
+  } catch {
+    return void 0;
+  }
+}
+function tryEvalEntryAbs(source, fnName, args, filePath, mocks) {
+  return tryEvalAbs(source, fnName, args, filePath, mocks);
+}
+function tryAttachIntension(caseResult, source, fnName) {
+  try {
+    const g = generalizeFromAst2(fnName, source);
+    if (!g) return;
+    const sym = g.symbolic;
+    const intension = {
+      display: g.display,
+      abs: formatAbs3(sym),
+      absMultiline: formatAbsMultiline(sym, fnName)
+    };
+    if (sym.term && sym.term.op !== "lit") {
+      intension.term = termToString(sym.term);
+    }
+    if (sym.pred && sym.pred.op !== "true") {
+      intension.pred = predToString(sym.pred);
+    }
+    intension.conf = sym.conf;
+    caseResult.intension = intension;
+  } catch {
+  }
+}
+function attachAbsToIntension(caseResult, absVal, label) {
+  const prev = caseResult.intension ?? {};
+  caseResult.abs = absVal;
+  caseResult.intension = {
+    ...prev,
+    abs: formatAbs3(absVal),
+    absMultiline: formatAbsMultiline(absVal, label ?? caseResult.name),
+    conf: absVal.conf
+  };
+}
+
+// src/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,
+  formatAbsMultiline as formatAbsMultiline2,
+  getFnSig as getFnSig3,
+  collectAbsNodeTypes,
+  findAbsAtPosition,
+  absToTypeValue as absToTypeValue3
+} from "@nudojs/core";
+import { parse as parse6, extractDirectives as extractDirectives2, extractFileDirectives as extractFileDirectives2 } from "@nudojs/parser";
+function getCasesForFile(filePath, source) {
+  const ast = parse6(source);
+  const functions = extractDirectives2(ast);
+  return functions.map((fn) => {
+    const cases = fn.directives.filter((d) => d.kind === "case").map((d, i) => ({ name: d.name, index: i }));
+    return { functionName: fn.name, cases, loc: locFromNode(fn.node) };
+  });
+}
+async function getTypeAtPositionAsync(filePath, source, line, column, activeCases) {
+  const envNames = collectEnvNames(filePath, source, false);
+  if (envNames.length > 0) {
+    await preloadPathEnvs(envNames, dirname7(filePath));
+  }
+  return getTypeAtPosition(filePath, source, line, column, activeCases);
+}
+function positionInsideCaseFunction(source, ast, line) {
+  try {
+    const enclosing = findEnclosingFunction(extractDirectives2(ast), line);
+    return !!enclosing && enclosing.directives.some((d) => d.kind === "case");
+  } catch {
+    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
+      });
+      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 {
+    }
+  }
+  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);
+  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);
+      }
+    }
+  }
+  setModuleResolver(null);
+  resetEnvModules();
+  resetMockModules();
+  return findBestTypeAtPosition(nodeTypeMap, globalEnv, ast, line, column);
+}
+function getHoverAtPosition(filePath, source, line, column, activeCases) {
+  let file;
+  try {
+    file = parse6(source);
+  } catch {
+    file = void 0;
+  }
+  const envNames = collectEnvNames(filePath, source, false);
+  const fnName = findFunctionNameAtPosition(source, line, column, file);
+  let gDisplay;
   let gAbs;
   let gMulti;
   if (fnName) {
     try {
-      const g = generalizeFromAst2(fnName, source, file ? { file } : {});
+      const g = generalizeFromAst3(fnName, source, file ? { file } : {});
       if (g) {
         gDisplay = g.display;
-        gAbs = formatAbs3(g.symbolic);
-        gMulti = formatAbsMultiline(g.symbolic, fnName);
+        gAbs = formatAbs4(g.symbolic);
+        gMulti = formatAbsMultiline2(g.symbolic, fnName);
       }
     } catch {
     }
@@ -3215,9 +3501,14 @@ function getHoverAtPosition(filePath, source, line, column, activeCases) {
       absMultiline: info2.absMultiline ?? gMulti
     };
   };
-  if (isBPathCapable(source, envNames)) {
+  const insideCaseFn = positionInsideCaseFunction(
+    source,
+    file ?? parse6(source),
+    line
+  );
+  if (isBPathCapable(source, envNames) && !insideCaseFn) {
     try {
-      const seeds = mockDirectivesToAbsSeeds(extractDirectives(file ?? parse5(source)));
+      const seeds = mockDirectivesToAbsSeeds(extractDirectives2(file ?? parse6(source)));
       const { modules } = evalAbsModuleGraph(source, filePath);
       const absNodes = collectAbsNodeTypes(source, {
         ...seeds,
@@ -3233,34 +3524,34 @@ function getHoverAtPosition(filePath, source, line, column, activeCases) {
         });
         const bound = binds.get(ident2);
         if (bound) {
-          const absLine = formatAbs3(bound);
-          const absMulti = formatAbsMultiline(bound, ident2);
+          const absLine = formatAbs4(bound);
+          const absMulti = formatAbsMultiline2(bound, ident2);
           return attachIntension({ typeText: absLine, abs: absLine, absMultiline: absMulti });
         }
       }
       if (absAt) {
-        const absLine = formatAbs3(absAt);
-        const absMulti = formatAbsMultiline(absAt, void 0);
+        const absLine = formatAbs4(absAt);
+        const absMulti = formatAbsMultiline2(absAt, void 0);
         return attachIntension({ typeText: absLine, abs: absLine, absMultiline: absMulti });
       }
     } catch {
     }
   }
   const tv = getTypeAtPosition(filePath, source, line, column, activeCases);
-  const info = tv ? { typeText: typeValueToString3(tv) } : null;
+  const info = tv ? { typeText: typeValueToString4(tv) } : null;
   const ident = findIdentNameAtPosition(source, line, column, file);
-  if (ident && !fnName) {
+  if (ident && !fnName && !insideCaseFn) {
     try {
       if (isBPathCapable(source, []) || !/\brequire\s*\(/.test(source)) {
-        const seeds = mockDirectivesToAbsSeeds(extractDirectives(file ?? parse5(source)));
+        const seeds = mockDirectivesToAbsSeeds(extractDirectives2(file ?? parse6(source)));
         const absBinds = collectAbsBindingsFromGraph(source, filePath, {
           seedVars: seeds.seedVars,
           seedFns: seeds.seedFns
         });
         const absBound = absBinds.get(ident);
         if (absBound) {
-          const absLine = formatAbs3(absBound);
-          const absMulti = formatAbsMultiline(absBound, ident);
+          const absLine = formatAbs4(absBound);
+          const absMulti = formatAbsMultiline2(absBound, ident);
           if (info) {
             info.abs = absLine;
             info.absMultiline = absMulti;
@@ -3273,9 +3564,9 @@ function getHoverAtPosition(filePath, source, line, column, activeCases) {
     }
   }
   try {
-    if (isBPathCapable(source, []) || !/\brequire\s*\(|\bimport\s*[{'"*]/.test(source)) {
+    if (!insideCaseFn && (isBPathCapable(source, []) || !/\brequire\s*\(|\bimport\s*[{'"*]/.test(source))) {
       const seeds = mockDirectivesToAbsSeeds(
-        extractDirectives(file ?? parse5(source))
+        extractDirectives2(file ?? parse6(source))
       );
       const { modules } = evalAbsModuleGraph(source, filePath);
       const nodeTypes = collectAbsNodeTypes(source, {
@@ -3285,8 +3576,8 @@ function getHoverAtPosition(filePath, source, line, column, activeCases) {
       });
       const absAt = findAbsAtPosition(nodeTypes, line, column);
       if (absAt) {
-        const absLine = formatAbs3(absAt);
-        const absMulti = formatAbsMultiline(absAt, void 0);
+        const absLine = formatAbs4(absAt);
+        const absMulti = formatAbsMultiline2(absAt, void 0);
         if (info) {
           info.abs = absLine;
           info.absMultiline = absMulti;
@@ -3301,9 +3592,9 @@ function getHoverAtPosition(filePath, source, line, column, activeCases) {
 }
 function findIdentNameAtPosition(source, line, column, fileAst) {
   try {
-    const ast = fileAst ?? parse5(source);
+    const ast = fileAst ?? parse6(source);
     let found;
-    traverse(ast, {
+    traverse2(ast, {
       Identifier(path) {
         const loc = path.node.loc;
         if (!loc) return;
@@ -3319,9 +3610,9 @@ function findIdentNameAtPosition(source, line, column, fileAst) {
 }
 function findFunctionNameAtPosition(source, line, column, fileAst) {
   try {
-    const ast = fileAst ?? parse5(source);
+    const ast = fileAst ?? parse6(source);
     let found;
-    traverse(ast, {
+    traverse2(ast, {
       Identifier(path) {
         const loc = path.node.loc;
         if (!loc) return;
@@ -3374,7 +3665,7 @@ function findBestTypeAtPosition(nodeTypeMap, globalEnv, ast, line, column) {
 }
 function findIdentifierAtPosition(ast, line, column) {
   let found = null;
-  const traverseFn = typeof traverse === "function" ? traverse : traverse.default;
+  const traverseFn = typeof traverse2 === "function" ? traverse2 : traverse2.default;
   try {
     traverseFn(ast, {
       Identifier(path) {
@@ -3398,18 +3689,18 @@ function getCompletionsAtPosition(filePath, source, line, column) {
   const safeSource = sanitizeSourceForParsing(source);
   let ast;
   try {
-    ast = parse5(safeSource);
+    ast = parse6(safeSource);
   } catch {
     try {
-      ast = parse5(source);
+      ast = parse6(source);
     } catch {
       return [];
     }
   }
   resetMemo();
   setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname5(filePath));
-  const globalEnv = createEnvironment2();
+  setCurrentFileDir(dirname7(filePath));
+  const globalEnv = createEnvironment3();
   evaluateProgram(ast, globalEnv);
   if (!globalEnv.has(objName)) {
     setModuleResolver(null);
@@ -3429,11 +3720,11 @@ function getTextBeforePosition(source, line, column) {
   return lines[line - 1].slice(0, column);
 }
 function getVariableCompletions(filePath, source) {
-  const ast = parse5(source);
+  const ast = parse6(source);
   resetMemo();
   setModuleResolver(resolveModule);
-  setCurrentFileDir(dirname5(filePath));
-  const globalEnv = createEnvironment2();
+  setCurrentFileDir(dirname7(filePath));
+  const globalEnv = createEnvironment3();
   evaluateProgram(ast, globalEnv);
   const ownBindings = globalEnv.getOwnBindings();
   const completions = [];
@@ -3442,7 +3733,7 @@ function getVariableCompletions(filePath, source) {
     completions.push({
       label: name,
       kind: tv.kind === "function" ? "method" : "variable",
-      detail: typeValueToString3(tv)
+      detail: typeValueToString4(tv)
     });
   }
   setModuleResolver(null);
@@ -3450,7 +3741,7 @@ function getVariableCompletions(filePath, source) {
 }
 function builtinMemberType(memberExpr) {
   try {
-    const result = evaluate(parse5(`${memberExpr};`), createEnvironment2());
+    const result = evaluate(parse6(`${memberExpr};`), createEnvironment3());
     if (!result || typeof result !== "object" || !("kind" in result)) return null;
     return result;
   } catch {
@@ -3466,10 +3757,10 @@ function describeMember(label, tv, fallbackClass) {
     const sig = getFnSig3(tv);
     if (sig) {
       const paramNames = tv.kind === "function" ? tv.params : [];
-      const params = sig.paramTypes.map((p, i) => `${paramNames[i] ?? `arg${i}`}: ${typeValueToString3(p)}`).join(", ");
-      return `(${params}) => ${typeValueToString3(sig.returnType)}`;
+      const params = sig.paramTypes.map((p, i) => `${paramNames[i] ?? `arg${i}`}: ${typeValueToString4(p)}`).join(", ");
+      return `(${params}) => ${typeValueToString4(sig.returnType)}`;
     }
-    if (tv.kind !== "function") return typeValueToString3(tv);
+    if (tv.kind !== "function") return typeValueToString4(tv);
   }
   return `${label}(\u2026)@${fallbackClass}`;
 }
@@ -3540,7 +3831,7 @@ function getCompletionsForType(tv) {
       completions.push({
         label: key,
         kind: val.kind === "function" ? "method" : "property",
-        detail: typeValueToString3(val)
+        detail: typeValueToString4(val)
       });
     }
     return completions;
@@ -3550,7 +3841,7 @@ function getCompletionsForType(tv) {
       completions.push({
         label: key,
         kind: val.kind === "function" ? "method" : "property",
-        detail: typeValueToString3(val)
+        detail: typeValueToString4(val)
       });
     }
     return completions;
@@ -3569,204 +3860,18 @@ function getCompletionsForType(tv) {
   }
   return completions;
 }
-function absIsBetter(absTv, prev) {
-  if (prev.kind === "unknown") return absTv.kind !== "unknown";
-  if (absTv.kind === "unknown" || absTv.kind === "never") return false;
-  if (prev.kind === "literal" || prev.kind === "object" || prev.kind === "array" || prev.kind === "tuple" || prev.kind === "union" || prev.kind === "function" || prev.kind === "instance" || prev.kind === "promise") {
-    return false;
-  }
-  if (absTv.kind === "refined" && prev.kind === "primitive") return true;
-  return false;
-}
-function isSelfContainedSource(source, envNames) {
-  if (envNames.length > 0) return false;
-  return !/\brequire\s*\(|\bimport\s*[{'"*]/.test(source);
-}
-function absModulesOk(source, envNames) {
-  void source;
-  void envNames;
-  return true;
-}
-function collectAbsCallRecords(source, seeds, filePath, precomputedModules, envNames = []) {
-  const absCalls = [];
-  let modules = precomputedModules;
-  let importLocals = /* @__PURE__ */ new Map();
-  if (filePath && absModulesOk(source, envNames)) {
-    if (!modules) {
-      try {
-        const graph = evalAbsModuleGraph(source, filePath, {
-          seedVars: seeds?.seedVars,
-          seedFns: seeds?.seedFns
-        });
-        modules = graph.modules;
-      } catch {
-        modules = void 0;
-      }
-    }
-    if (envNames.length > 0) {
-      modules = { ...collectEnvModules(envNames), ...modules ?? {} };
-    }
-    try {
-      importLocals = buildAbsImportLocalMap(source, filePath);
-    } catch {
-      importLocals = /* @__PURE__ */ new Map();
-    }
-  }
-  setAbsCallCollector((r) => absCalls.push(r));
-  try {
-    evalProgramAbs2(source, { ...seeds, modules });
-  } catch {
-  } finally {
-    setAbsCallCollector(null);
-  }
-  return absCalls.map((r) => {
-    const rec = {
-      fnName: r.fnName,
-      argTypes: r.args.map((a) => absToTypeValue2(a)),
-      resultType: r.threw ? T2.never : absToTypeValue2(r.result),
-      throws: r.threw ? absToTypeValue2(r.result) : T2.never,
-      callLoc: r.callLoc
-    };
-    const imp = importLocals.get(r.fnName);
-    if (imp) {
-      rec.targetModule = imp.modulePath;
-      rec.targetExport = imp.exportName;
-    }
-    return rec;
-  });
-}
-function collectAbsBindsAndNodes(source, seeds, modules) {
-  const binds = /* @__PURE__ */ new Map();
-  const nodes = /* @__PURE__ */ new Map();
-  setAbsNodeCollector((node, value) => {
-    nodes.set(node, value);
-  });
-  try {
-    const { env } = evalProgramAbs2(source, {
-      ...seeds,
-      modules
-    });
-    for (const [k, v] of env.vars) binds.set(k, v);
-    for (const [name, impl] of env.fns) {
-      if (!binds.has(name)) {
-        binds.set(
-          name,
-          absFunction5(impl.params, { body: impl.body, async: impl.async, env })
-        );
-      }
-    }
-  } catch {
-  } finally {
-    setAbsNodeCollector(null);
-  }
-  return { binds, nodes };
-}
-function buildAbsImportLocalMap(source, fromFile) {
-  const out = /* @__PURE__ */ new Map();
-  try {
-    const file = parse5(source);
-    for (const stmt of file.program.body) {
-      if (stmt.type !== "ImportDeclaration") continue;
-      const spec = stmt.source.value;
-      let modulePath = null;
-      if (spec.startsWith(".") || spec.startsWith("/")) {
-        modulePath = resolveImportAbs(spec, fromFile);
-      } else if (!spec.startsWith("node:")) {
-        modulePath = spec;
-      }
-      if (!modulePath) continue;
-      for (const s of stmt.specifiers) {
-        if (s.type === "ImportSpecifier") {
-          const imported = s.imported.type === "Identifier" ? s.imported.name : String(s.imported);
-          out.set(s.local.name, { modulePath, exportName: imported });
-        } else if (s.type === "ImportDefaultSpecifier") {
-          out.set(s.local.name, { modulePath, exportName: "default" });
-        }
-      }
-    }
-  } catch {
-  }
-  return out;
-}
-function resolveImportAbs(spec, fromFile) {
-  const base = dirname5(resolve4(fromFile));
-  const p = resolve4(base, spec);
-  for (const cand of [p, `${p}.js`, `${p}.mjs`, `${p}.ts`, resolve4(p, "index.js")]) {
-    if (existsSync3(cand) && !statSync3(cand).isDirectory()) return cand;
-  }
-  return null;
-}
-function tryEvalAbs(source, fnName, args, filePath, mocks) {
-  const raw = tryEvalAbsRaw(source, fnName, args, filePath, mocks);
-  return raw ? absToTypeValue2(raw) : void 0;
-}
-function tryEvalAbsRaw(source, fnName, args, filePath, mocks) {
-  if (/\brequire\s*\(/.test(source)) return void 0;
-  try {
-    const absArgs = args.map((a) => typeValueToAbs5(a));
-    if (filePath) {
-      const viaB = tryBPathCall(source, filePath, fnName, absArgs, { mocks });
-      if (viaB) return viaB;
-    }
-    let modules;
-    if (filePath && /\bimport\s*[{'"*]/.test(source)) {
-      modules = evalAbsModuleGraph(source, filePath).modules;
-    }
-    const result = analyzeFn(source, fnName, absArgs, void 0, void 0, void 0, modules);
-    if (result.shape.k === "unknown" && !result.term) {
-      return void 0;
-    }
-    return result;
-  } catch {
-    return void 0;
-  }
-}
-function tryEvalEntryAbs(source, fnName, args, filePath, mocks) {
-  return tryEvalAbs(source, fnName, args, filePath, mocks);
-}
-function tryAttachIntension(caseResult, source, fnName) {
-  try {
-    const g = generalizeFromAst2(fnName, source);
-    if (!g) return;
-    const sym = g.symbolic;
-    const intension = {
-      display: g.display,
-      abs: formatAbs3(sym),
-      absMultiline: formatAbsMultiline(sym, fnName)
-    };
-    if (sym.term && sym.term.op !== "lit") {
-      intension.term = termToString(sym.term);
-    }
-    if (sym.pred && sym.pred.op !== "true") {
-      intension.pred = predToString(sym.pred);
-    }
-    intension.conf = sym.conf;
-    caseResult.intension = intension;
-  } catch {
-  }
-}
-function attachAbsToIntension(caseResult, absVal, label) {
-  const prev = caseResult.intension ?? {};
-  caseResult.abs = absVal;
-  caseResult.intension = {
-    ...prev,
-    abs: formatAbs3(absVal),
-    absMultiline: formatAbsMultiline(absVal, label ?? caseResult.name),
-    conf: absVal.conf
-  };
-}
 
 // src/index.ts
 import { collectAbsInlays } from "@nudojs/core";
 
 // src/infer-json.ts
-import { typeValueToString as typeValueToString4 } from "@nudojs/core";
+import { typeValueToString as typeValueToString5 } from "@nudojs/core";
 function mapCase(c) {
   const out = {
     name: c.name,
-    args: c.args.map((a) => typeValueToString4(a)),
-    result: typeValueToString4(c.result),
-    throws: c.throws.kind !== "never" ? typeValueToString4(c.throws) : null,
+    args: c.args.map((a) => typeValueToString5(a)),
+    result: typeValueToString5(c.result),
+    throws: c.throws.kind !== "never" ? typeValueToString5(c.throws) : null,
     source: c.source ?? null
   };
   if (c.aggregatedFrom !== void 0) out.aggregatedFrom = c.aggregatedFrom;
@@ -3791,7 +3896,7 @@ function mapFunction(f) {
     cases: f.cases.map(mapCase)
   };
   if (f.noDeclaration) out.noDeclaration = true;
-  if (f.combined) out.combined = typeValueToString4(f.combined);
+  if (f.combined) out.combined = typeValueToString5(f.combined);
   return out;
 }
 function serializeInferJson(result, file) {
@@ -3830,36 +3935,10 @@ function serializeInferJson(result, file) {
 function isNudoTargetPath(path) {
   const lower = path.toLowerCase();
   if (lower.endsWith(".d.ts")) return false;
+  if (lower.endsWith(".nudo.js") || lower.endsWith(".nudo.ts")) return false;
   return lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".ts");
 }
 
-// src/load-module.ts
-import { existsSync as existsSync4, statSync as statSync4, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname6, resolve as resolve5, join as join3 } from "path";
-function defaultLoadModule(spec, fromFile) {
-  if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
-  try {
-    const base = dirname6(resolve5(fromFile));
-    const p = resolve5(base, spec);
-    for (const cand of [
-      p,
-      `${p}.js`,
-      `${p}.mjs`,
-      `${p}.ts`,
-      join3(p, "index.js"),
-      join3(p, "index.mjs"),
-      join3(p, "index.ts")
-    ]) {
-      if (existsSync4(cand) && !statSync4(cand).isDirectory()) {
-        return readFileSync5(cand, "utf-8");
-      }
-    }
-    return void 0;
-  } catch {
-    return void 0;
-  }
-}
-
 // src/session-cache.ts
 import {
   resetGeneralizeMemo,
@@ -3910,15 +3989,9 @@ function summarizeNodeEnv(env) {
 }
 
 // src/semantic-tokens.ts
-import { dirname as dirname7 } from "path";
-import { createEnvironment as createEnvironment3 } from "@nudojs/core";
-import { parse as parse6 } from "@nudojs/parser";
-import {
-  evaluateProgram as evaluateProgram2,
-  setModuleResolver as setModuleResolver2,
-  setCurrentFileDir as setCurrentFileDir2,
-  resetMemo as resetMemo2
-} from "@nudojs/cli/evaluator";
+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",
   "variable",
@@ -3960,19 +4033,19 @@ var MOD_DECLARATION = 1 << SEMANTIC_TOKEN_MODIFIERS.indexOf("declaration");
 function buildSemanticTokens(filePath, source) {
   let ast;
   try {
-    ast = parse6(source);
+    ast = parse7(source);
   } catch {
     return [];
   }
-  const env = createEnvironment3();
-  resetMemo2();
-  setModuleResolver2(resolveModule);
-  setCurrentFileDir2(dirname7(filePath));
+  const env = createEnvironment4();
+  resetMemo();
+  setModuleResolver(resolveModule);
+  setCurrentFileDir(dirname8(filePath));
   try {
-    evaluateProgram2(ast, env);
+    evaluateProgram(ast, env);
   } catch {
   } finally {
-    setModuleResolver2(null);
+    setModuleResolver(null);
   }
   const program = ast.program ?? ast;
   const ownBindings = env.getOwnBindings();
@@ -4364,7 +4437,7 @@ function generateGuardBody(tv, varName) {
 }
 
 // src/case-emitter.ts
-import { parse as parse7, extractDirectives as extractDirectives2 } from "@nudojs/parser";
+import { parse as parse8, extractDirectives as extractDirectives3 } from "@nudojs/parser";
 var GENERATED_PREFIX = "call@";
 var GENERATED_CASE_LINE_REGEX = /^\s*\*?\s*@nudo:case\s+"(call@[^"]*)"/;
 var IDENT_KEY_REGEX = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
@@ -4507,11 +4580,11 @@ function collectExistingCases(source) {
   const byName = /* @__PURE__ */ new Map();
   let ast;
   try {
-    ast = parse7(source, { errorRecovery: true });
+    ast = parse8(source, { errorRecovery: true });
   } catch {
     return byName;
   }
-  for (const { name, directives } of extractDirectives2(ast)) {
+  for (const { name, directives } of extractDirectives3(ast)) {
     for (const d of directives) {
       if (d.kind !== "case") continue;
       const list = byName.get(name);
@@ -4716,6 +4789,418 @@ function unifiedDiff(a, b, path) {
   }
   return out.join("\n") + "\n";
 }
+
+// src/interface-surface.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname9, resolve as resolve6 } from "path";
+import {
+  effectiveInterface,
+  formatConstraint,
+  interfaceDiagCount,
+  localNamedExports,
+  refineDiagCount,
+  takeInterfaceDiagsSince,
+  takeRefineDiagsSince,
+  typeValueToString as typeValueToString6
+} from "@nudojs/core";
+function formatInterfaceSurfaceLine(e) {
+  const params = `(${e.params.map((p) => `${p.name}: ${p.display}`).join(", ")})`;
+  let line = `  ${e.fn}  [${e.source}]  ${params}`;
+  if (e.returns !== void 0) line += ` \u2192 ${e.returns}`;
+  if (e.kind === "local") line += "  (local)";
+  return line;
+}
+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 loadModule = opts.loadModule ?? defaultLoadModule;
+  const exported = localNamedExports(source);
+  const kindOf = (fnName) => exported.has(fnName) ? "export" : "local";
+  const analysis = await analyzeFileAsync(abs, source, void 0, opts.records);
+  const entries = [];
+  for (const fn of analysis.functions) {
+    const eff = effectiveInterface(source, fn.name, { loadModule, fromFile: abs, autoBind });
+    if (eff) {
+      entries.push({
+        fn: fn.name,
+        kind: kindOf(fn.name),
+        source: eff.source,
+        params: eff.params.map((p) => ({ name: p.param, display: formatConstraint(p.constraint) })),
+        returns: eff.returns ? formatConstraint(eff.returns.constraint) : void 0
+      });
+      continue;
+    }
+    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);
+      }
+      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;
+    entries.push({ fn: fn.name, kind: kindOf(fn.name), source: "implicit", params, returns: ret });
+  }
+  takeInterfaceDiagsSince(ifaceSince);
+  takeRefineDiagsSince(refineSince);
+  return entries;
+}
+
+// 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 {
+  execNudoModule,
+  formatConstraint as formatConstraint2,
+  interfaceDiagCount as interfaceDiagCount2,
+  isNodeModulesPath,
+  isNudoConstraint,
+  joinThenProject,
+  localNamedExports as localNamedExports2,
+  parseSource as parseSource2,
+  refineDiagCount as refineDiagCount2,
+  sidecarPathOf,
+  takeInterfaceDiagsSince as takeInterfaceDiagsSince2,
+  takeRefineDiagsSince as takeRefineDiagsSince2,
+  typeValueToAbs as typeValueToAbs6
+} from "@nudojs/core";
+import { randomBytes } from "crypto";
+var GENERATED_HEADER = "// @generated by nudo \u2014 do not edit; regenerate with `nudo interface --emit`";
+async function emitInterface(filePath, opts) {
+  const abs = resolve7(filePath);
+  if (isNodeModulesPath(abs) || isNodeModulesPath(sidecarPathOf(abs))) {
+    throw new Error(
+      `emit target '${abs}' is inside node_modules; contract sidecars are never written there`
+    );
+  }
+  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 sections = collectGeneratedSections(sidecarSrc);
+  const generatedNames = new Set(sections.flatMap((s) => s.names));
+  const declared = topLevelDeclaredNames(sidecarSrc);
+  if (declared === void 0) {
+    throw new Error(
+      `sidecar '${relative(process.cwd(), sidecarPath) || sidecarPath}' is not parseable; fix it before emitting`
+    );
+  }
+  for (const n of generatedNames) declared.delete(n);
+  const analysis = await analyzeFileAsync(abs, source, void 0, opts.records);
+  const exported = localNamedExports2(source);
+  const fnByName = /* @__PURE__ */ new Map();
+  for (const f of analysis.functions) {
+    if (!fnByName.has(f.name)) fnByName.set(f.name, f);
+  }
+  const fileExportOrder = analysis.functions.map((f) => f.name).filter((n) => exported.has(n));
+  let targetNames;
+  if (opts.fnNames && opts.fnNames.length > 0) {
+    targetNames = [...new Set(opts.fnNames)];
+  } else if (opts.all) {
+    targetNames = fileExportOrder;
+  } else {
+    targetNames = fileExportOrder.filter((n) => generatedNames.has(n));
+  }
+  const targetSet = new Set(targetNames);
+  const written = [];
+  const skipped = [];
+  const issues = [];
+  const accepted = [];
+  const planCache = /* @__PURE__ */ new Map();
+  const planFor = (name) => {
+    const hit = planCache.get(name);
+    if (hit) return hit;
+    const fn = fnByName.get(name);
+    const dsl = fn === void 0 ? void 0 : projectFunctionDsl(fn);
+    const roundTrip = dsl !== void 0 && roundTrips(sectionText(name, dsl, srcRel), name);
+    const rec = { dsl, roundTrip };
+    planCache.set(name, rec);
+    return rec;
+  };
+  const atomicSections = /* @__PURE__ */ new Set();
+  for (const s of sections) {
+    if (s.names.length <= 1) continue;
+    const everyRewritable = s.names.every(
+      (n) => targetSet.has(n) && exported.has(n) && !declared.has(n) && planFor(n).dsl !== void 0 && planFor(n).roundTrip
+    );
+    if (!everyRewritable) atomicSections.add(s);
+  }
+  const acceptedAtomic = /* @__PURE__ */ new Set();
+  for (const name of targetNames) {
+    if (!exported.has(name) || !fnByName.has(name)) {
+      skipped.push({
+        fn: name,
+        reason: "not-an-export"
+      });
+      continue;
+    }
+    if (declared.has(name)) {
+      skipped.push({ fn: name, reason: "name-clash" });
+      issues.push({
+        code: "nudo:interface-name-clash",
+        severity: "error",
+        message: `sidecar already has a handwritten binding '${name}' (${srcRel}); handwritten wins \u2014 skipping emit for it`
+      });
+      continue;
+    }
+    const prev = sections.find((s) => s.names.includes(name));
+    if (prev !== void 0 && atomicSections.has(prev)) {
+      if (!acceptedAtomic.has(prev)) {
+        acceptedAtomic.add(prev);
+        const keptText = normalizeSection(prev.text);
+        accepted.push({ fn: prev.names.join("+"), text: keptText, prevText: keptText });
+        issues.push({
+          code: "nudo:interface-multi-declarator",
+          severity: "warning",
+          message: `generated section '${prev.names.join(", ")}' is a hand-merged multi-declarator form; kept verbatim (split it into one export per section to re-emit)`
+        });
+      }
+      skipped.push({ fn: name, reason: "multi-declarator" });
+      continue;
+    }
+    const prevText = prev === void 0 ? void 0 : normalizeSection(prev.text);
+    const plan = planFor(name);
+    if (plan.dsl === void 0 || !plan.roundTrip) {
+      skipped.push({ fn: name, reason: "not-projectable" });
+      if (prevText !== void 0) {
+        accepted.push({ fn: name, text: prevText, prevText });
+      }
+      continue;
+    }
+    const text = sectionText(name, plan.dsl, srcRel);
+    if (opts.mode === "add" && prev !== void 0) {
+      skipped.push({ fn: name, reason: "no-change" });
+      continue;
+    }
+    if (prevText !== void 0 && prevText === normalizeSection(text)) {
+      skipped.push({ fn: name, reason: "no-change" });
+      accepted.push({ fn: name, text: prevText, prevText });
+      continue;
+    }
+    written.push(name);
+    accepted.push({ fn: name, text, prevText });
+  }
+  let finalContent;
+  if (opts.mode === "add") {
+    finalContent = accepted.length === 0 ? sidecarSrc : joinSections(sidecarSrc, accepted.map((a) => a.text));
+  } else {
+    const base = removeSections(sidecarSrc, sections);
+    const preserved = sections.filter((s) => !s.names.some((n) => targetSet.has(n))).map((s) => normalizeSection(s.text));
+    finalContent = joinSections(base, [...preserved, ...accepted.map((a) => a.text)]);
+  }
+  const changed = finalContent !== sidecarSrc;
+  const diff = changed ? unifiedDiff(sidecarSrc, finalContent, relative(process.cwd(), sidecarPath) || sidecarPath) : void 0;
+  if (changed && !opts.dryRun) {
+    const tmp = `${sidecarPath}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
+    try {
+      writeFileSync(tmp, finalContent, "utf-8");
+      renameSync(tmp, sidecarPath);
+    } catch (e) {
+      try {
+        if (existsSync6(tmp)) unlinkSync(tmp);
+      } catch {
+      }
+      throw e;
+    }
+  }
+  takeRefineDiagsSince2(refineSince);
+  takeInterfaceDiagsSince2(ifaceSince);
+  return {
+    written,
+    skipped,
+    changed,
+    ...diff !== void 0 ? { diff } : {},
+    issues,
+    sidecarPath,
+    ...opts.fnNames && opts.fnNames.length > 0 ? {} : opts.all ? {} : targetNames.length === 0 ? { emptyDefaultTargets: true } : {}
+  };
+}
+function formatEmitSummary(sourcePath, sidecarRel, result) {
+  const lines = [];
+  if (result.changed) {
+    lines.push(`Updated ${sourcePath} \u2192 ${sidecarRel}`);
+    lines.push(`  written: ${result.written.join(", ") || "(none)"}`);
+  } else {
+    lines.push(`${sourcePath}: no interface changes`);
+    if (result.emptyDefaultTargets) {
+      lines.push(
+        `  tip: default --emit only refreshes existing @generated segments; pass --fn <name> or --all to create new ones`
+      );
+    }
+  }
+  for (const s of result.skipped.filter((x) => x.reason !== "no-change")) {
+    lines.push(`  skipped ${s.fn} (${s.reason})`);
+  }
+  for (const i of result.issues) {
+    lines.push(`  [${i.severity}] ${i.code}: ${i.message}`);
+  }
+  return lines;
+}
+function projectFunctionDsl(fn) {
+  const callsite = fn.cases.filter((c) => c.source === "callsite");
+  const directive = fn.cases.filter((c) => c.source === "directive");
+  const paramCases = callsite.length > 0 ? callsite : directive;
+  const returnCases = callsite.length > 0 ? callsite : directive.length > 0 ? directive : fn.cases;
+  const paramParts = [];
+  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));
+    }
+    if (argAbs.length === 0) continue;
+    const constraint = joinThenProject(argAbs);
+    if (constraint === void 0) return void 0;
+    paramParts.push(`${fn.paramNames[i]}: ${formatConstraint2(constraint)}`);
+  }
+  const retAbs = [];
+  for (const c of returnCases) {
+    if (c.throws !== void 0 && c.throws.kind !== "never") continue;
+    retAbs.push(c.abs ?? safeTypeValueToAbs(c.result));
+  }
+  const retConstraint = retAbs.length > 0 ? joinThenProject(retAbs) : void 0;
+  if (retConstraint === void 0 && paramParts.length === 0) return void 0;
+  if (retAbs.length > 0 && retConstraint === void 0) return void 0;
+  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}
+export const ${fn} = ${dsl};
+`;
+}
+function roundTrips(text, fn) {
+  const since = refineDiagCount2();
+  try {
+    const exports = execNudoModule(text);
+    const v = exports[fn];
+    return isNudoConstraint(v) && v.fn !== void 0;
+  } catch {
+    return false;
+  } finally {
+    takeRefineDiagsSince2(since);
+  }
+}
+function collectGeneratedSections(sidecarSrc) {
+  if (sidecarSrc.trim() === "") return [];
+  let ast;
+  try {
+    ast = parseSource2(sidecarSrc);
+  } catch {
+    throw new Error("sidecar is not parseable");
+  }
+  const out = [];
+  for (const stmt of ast.program.body) {
+    if (stmt.type !== "ExportNamedDeclaration" || stmt.source) continue;
+    const d = stmt.declaration;
+    if (!d || stmt.start == null || stmt.end == null) 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;
+    const blockStart = generatedCommentBlockStart(sidecarSrc, stmt.start);
+    if (blockStart === void 0) continue;
+    out.push({ names, start: blockStart, end: stmt.end, text: sidecarSrc.slice(blockStart, stmt.end) });
+  }
+  return out;
+}
+function generatedCommentBlockStart(src, pos) {
+  const lines = src.slice(0, pos).split("\n");
+  let blockStartLine = -1;
+  let sawGenerated = false;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (line === "" || line === "*/") continue;
+    if (line.startsWith("//") || line.startsWith("/*") || line.startsWith("*")) {
+      blockStartLine = i;
+      if (/@generated/.test(line)) sawGenerated = true;
+      continue;
+    }
+    break;
+  }
+  if (!sawGenerated || blockStartLine < 0) return void 0;
+  const prefix = lines.slice(0, blockStartLine);
+  return prefix.length === 0 ? 0 : prefix.join("\n").length + 1;
+}
+function topLevelDeclaredNames(sidecarSrc) {
+  if (sidecarSrc.trim() === "") return /* @__PURE__ */ new Set();
+  let ast;
+  try {
+    ast = parseSource2(sidecarSrc);
+  } catch {
+    return void 0;
+  }
+  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);
+    }
+  }
+  return names;
+}
+function removeSections(src, sections) {
+  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 normalizeSection(text) {
+  return text.replace(/\s*$/, "") + "\n";
+}
+function joinSections(base, sectionTexts) {
+  const normalized = sectionTexts.map(normalizeSection).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");
+}
 export {
   SEMANTIC_TOKEN_MODIFIERS,
   SEMANTIC_TOKEN_TYPES,
@@ -4748,6 +5233,7 @@ export {
   computeDirtySet,
   defaultAbsLoadModule,
   defaultLoadModule,
+  emitInterface,
   encodeSemanticTokens,
   envValueToAbs,
   evalAbsModuleGraph,
@@ -4757,7 +5243,10 @@ export {
   evictAnalysisFileCacheForFiles,
   evictBPathCacheForFiles,
   evictFnAnalysisCacheForFiles,
+  findProjectConfig,
+  formatEmitSummary,
   formatHarvestSummary,
+  formatInterfaceSurfaceLine,
   generateDts,
   generateFunctionDtsLines,
   generateGuardFunction,
@@ -4774,6 +5263,8 @@ export {
   harvestToAbsModules,
   harvestedValueToAbs,
   insertGeneratedCaseDirectives,
+  interfaceConfig,
+  interfaceSurface,
   isBPathCapable,
   isNudoTargetPath,
   lookupHarvested,