@nudojs/service 1.0.0 → 2.0.0

package/dist/chunk-ADFCZP72.js

@@ -0,0 +1,556 @@
+// src/evaluator/builtins/builtin-prototype.ts
+import {
+  abs,
+  objOf,
+  formatAbs,
+  relationFn
+} from "@nudojs/core";
+function hasOwnProp(props, name) {
+  return Object.prototype.hasOwnProperty.call(props, name);
+}
+var BUILTIN_ERROR_CLASSES = /* @__PURE__ */ new Set([
+  "Error",
+  "TypeError",
+  "SyntaxError",
+  "RangeError",
+  "ReferenceError",
+  "URIError",
+  "EvalError"
+]);
+var BUILTIN_PROTOTYPE_CLASSES = /* @__PURE__ */ new Set([
+  ...BUILTIN_ERROR_CLASSES,
+  "Date",
+  "Object",
+  "Map",
+  "Set",
+  "Promise",
+  "RegExp",
+  "Array",
+  "Function",
+  "String",
+  "Number",
+  "Boolean",
+  "Symbol",
+  "WeakMap",
+  "WeakSet",
+  "Buffer"
+]);
+var numA = { shape: { k: "prim", type: "number" }, conf: "exact" };
+var strA = { shape: { k: "prim", type: "string" }, conf: "exact" };
+var boolA = { shape: { k: "prim", type: "boolean" }, conf: "exact" };
+var unkA = { shape: { k: "unknown" }, conf: "partial" };
+var undefA = abs({ k: "unknown" }, { op: "lit", value: void 0 }, void 0, "exact");
+var nullA = abs({ k: "unknown" }, { op: "lit", value: null }, void 0, "exact");
+function arrOf(el) {
+  return { shape: { k: "arr", element: el }, conf: "exact" };
+}
+function tupleOf(els) {
+  return { shape: { k: "tuple", elements: els }, conf: "exact" };
+}
+function promiseOf(inner) {
+  return { shape: { k: "eff", eff: "promise", inner }, conf: "exact" };
+}
+function sumOf(...members) {
+  if (members.length === 1) return members[0];
+  return { shape: { k: "sum", members }, conf: "exact" };
+}
+function brand(name) {
+  return { shape: { k: "brand", name, shape: unkA }, conf: "path" };
+}
+function emptyObj() {
+  return objOf({});
+}
+function sig(params, ret) {
+  return relationFn(params, ret, {
+    conf: "exact",
+    params: params.map((_, i) => `_arg${i}`)
+  });
+}
+var OBJECT_PROTOTYPE_METHODS = {
+  hasOwnProperty: sig([unkA], boolA),
+  isPrototypeOf: sig([unkA], boolA),
+  propertyIsEnumerable: sig([unkA], boolA),
+  toString: sig([], strA),
+  toLocaleString: sig([], strA),
+  valueOf: sig([], unkA)
+};
+var BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS = {
+  Object: { ...OBJECT_PROTOTYPE_METHODS },
+  Array: {
+    push: sig([unkA], numA),
+    pop: sig([], unkA),
+    shift: sig([], unkA),
+    unshift: sig([unkA], numA),
+    slice: sig([numA, numA], arrOf(unkA)),
+    splice: sig([numA, numA], arrOf(unkA)),
+    concat: sig([unkA], arrOf(unkA)),
+    join: sig([strA], strA),
+    indexOf: sig([unkA], numA),
+    lastIndexOf: sig([unkA], numA),
+    includes: sig([unkA], boolA),
+    map: sig([unkA], arrOf(unkA)),
+    flatMap: sig([unkA], arrOf(unkA)),
+    filter: sig([unkA], arrOf(unkA)),
+    forEach: sig([unkA], undefA),
+    find: sig([unkA], unkA),
+    findIndex: sig([unkA], numA),
+    some: sig([unkA], boolA),
+    every: sig([unkA], boolA),
+    reduce: sig([unkA, unkA], unkA),
+    sort: sig([unkA], arrOf(unkA)),
+    reverse: sig([], arrOf(unkA)),
+    toString: sig([], strA)
+  },
+  Function: {
+    call: sig([unkA], unkA),
+    apply: sig([unkA, unkA], unkA),
+    bind: sig([unkA], unkA),
+    toString: sig([], strA)
+  },
+  Map: {
+    get: sig([unkA], unkA),
+    set: sig([unkA, unkA], unkA),
+    has: sig([unkA], boolA),
+    delete: sig([unkA], boolA),
+    clear: sig([], undefA),
+    forEach: sig([unkA], undefA),
+    keys: sig([], arrOf(unkA)),
+    values: sig([], arrOf(unkA)),
+    entries: sig([], arrOf(tupleOf([unkA, unkA]))),
+    toString: sig([], strA)
+  },
+  Set: {
+    add: sig([unkA], unkA),
+    has: sig([unkA], boolA),
+    delete: sig([unkA], boolA),
+    clear: sig([], undefA),
+    forEach: sig([unkA], undefA),
+    keys: sig([], arrOf(unkA)),
+    values: sig([], arrOf(unkA)),
+    entries: sig([], arrOf(tupleOf([unkA, unkA]))),
+    toString: sig([], strA)
+  },
+  WeakMap: {
+    get: sig([unkA], unkA),
+    set: sig([unkA, unkA], unkA),
+    has: sig([unkA], boolA),
+    delete: sig([unkA], boolA),
+    toString: sig([], strA)
+  },
+  WeakSet: {
+    add: sig([unkA], unkA),
+    has: sig([unkA], boolA),
+    delete: sig([unkA], boolA),
+    toString: sig([], strA)
+  },
+  Promise: {
+    then: sig([unkA], promiseOf(unkA)),
+    catch: sig([unkA], promiseOf(unkA)),
+    finally: sig([unkA], promiseOf(unkA)),
+    toString: sig([], strA)
+  },
+  Date: {
+    getTime: sig([], numA),
+    valueOf: sig([], numA),
+    toISOString: sig([], strA),
+    toJSON: sig([], strA),
+    toLocaleString: sig([], strA),
+    toString: sig([], strA)
+  },
+  RegExp: {
+    test: sig([strA], boolA),
+    exec: sig([strA], sumOf(emptyObj(), nullA)),
+    toString: sig([], strA)
+  },
+  String: {
+    charAt: sig([numA], strA),
+    charCodeAt: sig([numA], numA),
+    indexOf: sig([strA], numA),
+    lastIndexOf: sig([strA], numA),
+    includes: sig([strA], boolA),
+    startsWith: sig([strA], boolA),
+    endsWith: sig([strA], boolA),
+    slice: sig([numA, numA], strA),
+    substring: sig([numA, numA], strA),
+    toUpperCase: sig([], strA),
+    toLowerCase: sig([], strA),
+    trim: sig([], strA),
+    replace: sig([unkA, strA], strA),
+    split: sig([strA], arrOf(strA)),
+    toString: sig([], strA),
+    valueOf: sig([], strA)
+  },
+  Number: {
+    toFixed: sig([numA], strA),
+    toPrecision: sig([numA], strA),
+    valueOf: sig([], numA),
+    toString: sig([numA], strA)
+  },
+  Boolean: {
+    valueOf: sig([], boolA),
+    toString: sig([], strA)
+  },
+  Symbol: {
+    toString: sig([], strA),
+    valueOf: sig([], brand("Symbol"))
+  },
+  Buffer: {
+    equals: sig([unkA], boolA),
+    compare: sig([unkA], numA),
+    toString: sig([unkA], strA),
+    toJSON: sig([], unkA)
+  },
+  Error: {
+    toString: sig([], strA)
+  }
+};
+function fmtNoConf(a) {
+  return formatAbs(a).replace(/\s+#(exact|path|widened|mock|partial|opaque)$/, "");
+}
+function describeAbsMember(a) {
+  if (a.shape.k !== "fn") return fmtNoConf(a);
+  const s = a.shape;
+  const pts = s.paramTypes ?? [];
+  const params = pts.map((p, i) => `${s.params[i] ?? `arg${i}`}: ${fmtNoConf(p)}`).join(", ");
+  const ret = s.returnType ? fmtNoConf(s.returnType) : "unknown";
+  return `(${params}) => ${ret}`;
+}
+function builtinProtoMemberNames(className) {
+  const table = hasOwnProp(BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS, className) ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS[className] : void 0;
+  return table ? Object.keys(table) : [];
+}
+function builtinProtoMember(className, member) {
+  const table = hasOwnProp(BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS, className) ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS[className] : BUILTIN_ERROR_CLASSES.has(className) ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS.Error : void 0;
+  if (!table) return null;
+  return table[member] ?? null;
+}
+
+// src/evaluator/env-loader.ts
+import { readFileSync, existsSync, statSync, mkdirSync, writeFileSync } from "fs";
+import { resolve as resolvePath, join as joinPath } from "path";
+import { pathToFileURL } from "url";
+import { createRequire } from "module";
+import { createHash } from "crypto";
+import { tmpdir } from "os";
+import { defineEnv as defineEsEnv } from "@nudojs/env/es";
+import { defineEnv as defineWebEnv } from "@nudojs/env/web";
+import { defineEnv as defineNodeEnv } from "@nudojs/env/node";
+var envFactories = {
+  es: defineEsEnv,
+  web: defineWebEnv,
+  node: defineNodeEnv
+};
+var impliedDeps = {
+  web: ["es"],
+  node: ["es"]
+};
+function resolveEnvNames(names) {
+  const resolved = /* @__PURE__ */ new Set();
+  const visit = (name) => {
+    if (resolved.has(name)) return;
+    const deps = impliedDeps[name];
+    if (deps) deps.forEach(visit);
+    resolved.add(name);
+  };
+  names.forEach(visit);
+  return [...resolved];
+}
+var pathEnvCache = /* @__PURE__ */ new Map();
+var pathEnvByPath = /* @__PURE__ */ new Map();
+var pathEnvBaseDirs = /* @__PURE__ */ new Set();
+function isPathEnvName(name, baseDir) {
+  if (name in envFactories) return false;
+  if (name.includes("/") || name.startsWith("./") || name.startsWith("../")) return true;
+  const resolved = resolvePath(baseDir, name);
+  return resolved.endsWith(".ts") && existsSync(resolved);
+}
+function rewriteBareImports(text) {
+  const require2 = createRequire(import.meta.url);
+  let rewrote = false;
+  const out = text.replace(/(["'])(@nudojs\/[a-z0-9-]+)\1/g, (_m, quote, spec) => {
+    try {
+      const entry = require2.resolve(spec);
+      const url = pathToFileURL(entry).href;
+      rewrote = true;
+      return `${quote}${url}${quote}`;
+    } catch {
+      return `${quote}${spec}${quote}`;
+    }
+  });
+  return rewrote ? out : null;
+}
+async function importPathEnv(resolvedPath, mtimeMs) {
+  const cacheKey = `${resolvedPath}:${mtimeMs}`;
+  if (pathEnvCache.has(cacheKey)) return;
+  let mod = null;
+  try {
+    const url = pathToFileURL(resolvedPath).href + `?mtime=${mtimeMs}`;
+    mod = await import(url);
+  } catch {
+    mod = null;
+  }
+  if (!mod) {
+    try {
+      const text = readFileSync(resolvedPath, "utf-8");
+      const rewritten = rewriteBareImports(text);
+      if (rewritten === null) return;
+      const cacheDir = joinPath(tmpdir(), "nudo-env");
+      mkdirSync(cacheDir, { recursive: true });
+      const hash = createHash("md5").update(`${resolvedPath}:${mtimeMs}`).digest("hex").slice(0, 16);
+      const copyPath = joinPath(cacheDir, `${hash}.ts`);
+      writeFileSync(copyPath, rewritten, "utf-8");
+      mod = await import(pathToFileURL(copyPath).href);
+    } catch {
+      return;
+    }
+  }
+  if (mod && typeof mod.defineEnv === "function") {
+    pathEnvCache.set(cacheKey, mod.defineEnv);
+    pathEnvByPath.set(resolvedPath, {
+      factory: mod.defineEnv,
+      mtimeMs
+    });
+  }
+}
+function lookupPathEnv(name) {
+  if (pathEnvByPath.size === 0) return void 0;
+  const candidates = name.startsWith("/") ? [name] : [name, ...[...pathEnvBaseDirs].map((d) => resolvePath(d, name))];
+  for (const candidate of candidates) {
+    const hit = pathEnvByPath.get(candidate);
+    if (!hit) continue;
+    try {
+      const { mtimeMs } = statSync(candidate);
+      if (mtimeMs !== hit.mtimeMs) {
+        pathEnvByPath.delete(candidate);
+        return void 0;
+      }
+    } catch {
+      pathEnvByPath.delete(candidate);
+      return void 0;
+    }
+    return hit.factory;
+  }
+  return void 0;
+}
+function clearPathEnvCaches() {
+  pathEnvCache.clear();
+  pathEnvByPath.clear();
+  pathEnvBaseDirs.clear();
+}
+async function preloadPathEnvs(envNames, baseDir) {
+  pathEnvBaseDirs.add(baseDir);
+  for (const name of envNames) {
+    if (!isPathEnvName(name, baseDir)) continue;
+    const resolved = resolvePath(baseDir, name);
+    if (!existsSync(resolved)) continue;
+    try {
+      const { mtimeMs } = statSync(resolved);
+      await importPathEnv(resolved, mtimeMs);
+    } catch {
+    }
+  }
+}
+async function loadEnvsAsync(envNames, globalEnv, baseDir = process.cwd()) {
+  await preloadPathEnvs(envNames, baseDir);
+  return loadEnvs(envNames, globalEnv);
+}
+function loadEnvs(envNames, globalEnv) {
+  const allModules = {};
+  const allGlobals = {};
+  const resolved = resolveEnvNames(envNames);
+  for (const name of resolved) {
+    const factory = envFactories[name] ?? lookupPathEnv(name);
+    if (!factory) continue;
+    const def = factory();
+    for (const [key, value] of Object.entries(def.globals)) {
+      allGlobals[key] = value;
+      globalEnv.bind(key, value);
+    }
+    if (def.modules) {
+      for (const [modName, exports] of Object.entries(def.modules)) {
+        allModules[modName] = { ...allModules[modName], ...exports };
+      }
+    }
+  }
+  return { modules: allModules, globals: allGlobals };
+}
+
+// src/evaluator/config.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { resolve, dirname, relative, sep } from "path";
+var DEFAULT_ANALYSIS_EXCLUDE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/coverage/**"
+];
+var DEFAULT_ANALYSIS_MODE = "exports";
+function toStringArray(raw, fallback) {
+  if (raw === void 0) return fallback;
+  const arr = Array.isArray(raw) ? raw : [raw];
+  const out = arr.filter((s) => typeof s === "string" && s.length > 0);
+  return out.length > 0 ? out : fallback;
+}
+function analysisConfig(config) {
+  const raw = config?.analysis;
+  const modeRaw = raw?.mode;
+  const mode = modeRaw === "exports" || modeRaw === "all" || modeRaw === "directives" ? modeRaw : DEFAULT_ANALYSIS_MODE;
+  const diagRaw = raw?.diagnostics;
+  const diagnostics = diagRaw === "off" || diagRaw === "errors" || diagRaw === "default" || diagRaw === "verbose" ? diagRaw : mode === "directives" ? "errors" : "default";
+  const budgetRaw = raw?.callSiteBudget;
+  const callSiteBudget = typeof budgetRaw === "number" && Number.isFinite(budgetRaw) && budgetRaw >= 1 ? Math.min(Math.floor(budgetRaw), 64) : 3;
+  return {
+    // include 空数组 = 不过滤（与「省略」同义）
+    include: toStringArray(raw?.include, []),
+    // exclude 空数组回落默认安全列表，避免误关 node_modules 保护
+    exclude: toStringArray(raw?.exclude, DEFAULT_ANALYSIS_EXCLUDE),
+    mode,
+    diagnostics,
+    callSiteBudget,
+    evalMissingSlot: raw?.evalMissingSlot === "warning" ? "warning" : "off"
+  };
+}
+function diskCacheRoot(config, projectDir) {
+  const raw = config?.cache;
+  if (raw === false) return void 0;
+  if (typeof raw === "string" && raw.length > 0) {
+    return projectDir ? resolve(projectDir, raw) : raw;
+  }
+  if (raw === true) {
+    return projectDir ? resolve(projectDir, ".nudo/cache") : void 0;
+  }
+  const env = process.env.NUDO_CACHE_DIR;
+  if (env === "off" || env === "0") return void 0;
+  if (env && env.length > 0) return env;
+  return void 0;
+}
+function interfaceConfig(config) {
+  const raw = config?.interface?.emit;
+  const emit = raw === void 0 ? [] : Array.isArray(raw) ? raw.filter((s) => typeof s === "string" && s.length > 0) : typeof raw === "string" && raw.length > 0 ? [raw] : [];
+  return {
+    autoBind: config?.interface?.autoBind ?? true,
+    emit
+  };
+}
+function matchesEmitAllowlist(absPath, projectDir, patterns) {
+  if (patterns.length === 0) return true;
+  if (!projectDir) return false;
+  const rel = relative(projectDir, absPath).split(sep).join("/");
+  if (rel.startsWith("..")) return false;
+  return patterns.some(
+    (p) => globMatch(
+      p.split(sep).join("/").replace(/^\.\//, ""),
+      rel
+    )
+  );
+}
+function globMatch(pattern, path) {
+  let rx = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*" && pattern[i + 1] === "*") {
+      if (pattern[i + 2] === "/") {
+        rx += "(?:.*/)?";
+        i += 2;
+      } else {
+        rx += ".*";
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === "*") {
+      rx += "[^/]*";
+      continue;
+    }
+    if (ch === "?") {
+      rx += "[^/]";
+      continue;
+    }
+    rx += /[.+^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
+  }
+  return new RegExp(`^${rx}$`).test(path);
+}
+function findProjectConfig(startDir) {
+  let dir = resolve(startDir);
+  const root = resolve("/");
+  while (dir !== root) {
+    const pkgPath = resolve(dir, "package.json");
+    if (existsSync2(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+        if (pkg.nudo) {
+          return { config: pkg.nudo, projectDir: dir };
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// src/evaluator/resolve-npm.ts
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { resolve as resolve2, join, dirname as dirname2 } from "path";
+function findNodeModules(startDir) {
+  let dir = resolve2(startDir);
+  const root = resolve2("/");
+  while (dir !== root) {
+    const nmPath = join(dir, "node_modules");
+    if (existsSync3(nmPath)) return nmPath;
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function resolveExportsNudo(exports, subpath) {
+  if (!exports || typeof exports !== "object") return null;
+  const entry = exports[subpath];
+  if (!entry) return null;
+  if (typeof entry === "object" && entry !== null && "nudo" in entry) {
+    const nudoEntry = entry["nudo"];
+    if (typeof nudoEntry === "string") return nudoEntry;
+  }
+  return null;
+}
+function resolveNpmNudo(source, fromDir) {
+  const isRelative = source.startsWith(".") || source.startsWith("/");
+  if (isRelative) return null;
+  const parts = source.startsWith("@") ? source.split("/").slice(0, 2) : source.split("/").slice(0, 1);
+  const pkgName = parts.join("/");
+  const subpath = source.slice(pkgName.length) || ".";
+  const nodeModules = findNodeModules(fromDir);
+  if (!nodeModules) return null;
+  const pkgJsonPath = join(nodeModules, pkgName, "package.json");
+  if (!existsSync3(pkgJsonPath)) return null;
+  try {
+    const pkg = JSON.parse(readFileSync3(pkgJsonPath, "utf-8"));
+    const nudoEntry = resolveExportsNudo(pkg.exports, subpath);
+    if (nudoEntry) {
+      const resolved = resolve2(dirname2(pkgJsonPath), nudoEntry);
+      if (existsSync3(resolved)) return resolved;
+    }
+  } catch {
+  }
+  return null;
+}
+
+export {
+  clearPathEnvCaches,
+  preloadPathEnvs,
+  loadEnvsAsync,
+  loadEnvs,
+  DEFAULT_ANALYSIS_MODE,
+  analysisConfig,
+  diskCacheRoot,
+  interfaceConfig,
+  matchesEmitAllowlist,
+  findProjectConfig,
+  resolveNpmNudo,
+  BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS,
+  describeAbsMember,
+  builtinProtoMemberNames,
+  builtinProtoMember
+};

package/dist/config-Cqj8zeZH.d.ts

@@ -0,0 +1,117 @@
+import { Abs, Environment } from '@nudojs/core';
+
+/**
+ * 调用点记录（CallRecord）。Abs 唯一真理源。
+ * argAbs/resultAbs/throwsAbs 必填；展示/外延在 CaseResult 边界再桥。
+ */
+
+type CallRecord = {
+    fnName: string;
+    /** 无损参数 Abs */
+    argAbs: Abs[];
+    /** 无损结果 Abs（threw 时为 never） */
+    resultAbs: Abs;
+    /** 无损抛出值 Abs（未抛为 never） */
+    throwsAbs: Abs;
+    /** Line-relative. Per-fn cache replay shifts this by lineDelta — if you
+     *  add another position field (callee loc, arg loc), extend
+     *  shiftCallRecordLines in analyzer.ts in the same change. */
+    callLoc?: {
+        line: number;
+        column: number;
+    };
+    targetModule?: string;
+    targetExport?: string;
+    /** export names the same function value was re-exported under after its
+     * defining module (barrel `index.js`, CJS forwarding shims); usage-site
+     * records stay name-matchable against them */
+    targetAliases?: string[];
+    /** module whose evaluation created the function value (definition site). */
+    fnModule?: string;
+};
+
+type LoadedEnv = {
+    /** Abs 原生模块导出（B 路径 / Abs 模块图） */
+    modules: Record<string, Record<string, Abs>>;
+    globals: Record<string, Abs>;
+};
+/** Host cache-clear hooks (CLI watch / vite / tests) must drop path-env modules too */
+declare function clearPathEnvCaches(): void;
+declare function preloadPathEnvs(envNames: string[], baseDir: string): Promise<void>;
+declare function loadEnvsAsync(envNames: string[], globalEnv: Environment, baseDir?: string): Promise<LoadedEnv>;
+declare function loadEnvs(envNames: string[], globalEnv: Environment): LoadedEnv;
+
+type NudoConfig = {
+    env?: string[];
+    mocks?: Record<string, string>;
+    interface?: {
+        /** 侧车 ambient 绑定总开关（check/LSP 执法与 interface 打印共用） */
+        autoBind?: boolean;
+        /**
+         * emit 白名单（Phase 3，§7.3）：glob 数组，相对 projectDir。
+         * 省略/空 = 不按路径过滤（仍受 --fn/--all 与「默认只刷已有生成段」约束）。
+         */
+        emit?: string[] | string;
+    };
+    /** 分析范围与噪声档（design-analysis-scope.md / A2） */
+    analysis?: {
+        include?: string[] | string;
+        exclude?: string[] | string;
+        /** directives | exports（默认）| all */
+        mode?: string;
+        /** off | errors | default | verbose */
+        diagnostics?: string;
+        /** polyvariant：保留的精确调用点 case 上限（默认 3）；超出进 symbolic #widened */
+        callSiteBudget?: number;
+        /** C0.5：求值命中闭对象缺字段 → nudo:missing-slot；默认 off */
+        evalMissingSlot?: "off" | "warning";
+    };
+    /** 磁盘缓存（B3）：true → `.nudo/cache`；字符串 → 自定义根；false/省略 → 关 */
+    cache?: boolean | string;
+};
+type InterfaceConfig = {
+    autoBind: boolean;
+    /** emit 路径白名单（已归一化；空数组 = 不限制） */
+    emit: string[];
+};
+type AnalysisMode = "directives" | "exports" | "all";
+type DiagnosticsLevel = "off" | "errors" | "default" | "verbose";
+type AnalysisConfig = {
+    include: string[];
+    exclude: string[];
+    mode: AnalysisMode;
+    diagnostics: DiagnosticsLevel;
+    /** polyvariant 精确调用点上限（B4） */
+    callSiteBudget: number;
+    /** C0.5 evaluation-driven missing-slot；默认 off */
+    evalMissingSlot: "off" | "warning";
+};
+/** A1 产品默认：exports — 普通带导出的 .js 进 IDE；directives/all 需显式 */
+declare const DEFAULT_ANALYSIS_MODE: AnalysisMode;
+/**
+ * 归一化 `nudo.analysis`。默认 mode=exports（A1：无指令但有 export/侧车的文件
+ * 进 IDE 分析；`all` / `directives` 需显式配置）。
+ * diagnostics：directives→errors，exports/all→default。
+ * include 空 = 不按路径过滤（isNudoTargetPath 已管扩展名）。
+ */
+declare function analysisConfig(config: NudoConfig | null | undefined): AnalysisConfig;
+/** 磁盘缓存根（B3）：config.cache / NUDO_CACHE_DIR / 默认关 */
+declare function diskCacheRoot(config: NudoConfig | null | undefined, projectDir: string | undefined): string | undefined;
+/**
+ * 归一化 `nudo.interface` 配置段。
+ * - autoBind 默认 true
+ * - emit：string | string[] → string[]（空 = 不限制路径）
+ */
+declare function interfaceConfig(config: NudoConfig | null | undefined): InterfaceConfig;
+/**
+ * 极简 glob（`**` / `*` / `?`）：相对 projectDir 匹配**源文件**绝对路径
+ * （不是侧车路径；侧车随源文件同目录写出）。无白名单 → true。
+ * 路径分隔符归一为 `/`。
+ */
+declare function matchesEmitAllowlist(absPath: string, projectDir: string | undefined, patterns: string[]): boolean;
+declare function findProjectConfig(startDir: string): {
+    config: NudoConfig;
+    projectDir: string;
+} | null;
+
+export { type AnalysisConfig as A, type CallRecord as C, type DiagnosticsLevel as D, type InterfaceConfig as I, type LoadedEnv as L, type NudoConfig as N, type AnalysisMode as a, DEFAULT_ANALYSIS_MODE as b, analysisConfig as c, clearPathEnvCaches as d, diskCacheRoot as e, findProjectConfig as f, loadEnvsAsync as g, interfaceConfig as i, loadEnvs as l, matchesEmitAllowlist as m, preloadPathEnvs as p };