@nudojs/service 1.0.0 → 1.0.1

package/dist/chunk-2VHITMTM.js

@@ -0,0 +1,488 @@
+// 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, mod.defineEnv);
+  }
+}
+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) return hit;
+  }
+  return void 0;
+}
+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";
+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 {
+  preloadPathEnvs,
+  loadEnvsAsync,
+  loadEnvs,
+  interfaceConfig,
+  matchesEmitAllowlist,
+  findProjectConfig,
+  resolveNpmNudo,
+  BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS,
+  describeAbsMember,
+  builtinProtoMemberNames,
+  builtinProtoMember
+};

package/dist/config-NqDRWWpn.d.ts

@@ -0,0 +1,68 @@
+import { Abs } 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 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;
+    };
+};
+type InterfaceConfig = {
+    autoBind: boolean;
+    /** emit 路径白名单（已归一化；空数组 = 不限制） */
+    emit: string[];
+};
+/**
+ * 归一化 `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 CallRecord as C, type InterfaceConfig as I, type NudoConfig as N, findProjectConfig as f, interfaceConfig as i, matchesEmitAllowlist as m };

package/dist/evaluator/evaluator-api.d.ts

@@ -1,23 +1,21 @@
-export { C as CallRecord, I as InterfaceConfig, N as NudoConfig, U as USAGE_SITE_MODULE, a as UnknownRecord, e as evaluate, b as evaluateFunction, c as evaluateFunctionFull, d as evaluateProgram, f as findProjectConfig, g as getUnreachableRanges, i as interfaceConfig, m as memberMayExistOn, r as resetEnvModules, h as resetMemo, j as resetMockModules, k as resetUnreachableRanges, s as setCallCollector, l as setCurrentFileDir, n as setCurrentSource, o as setEnvModules, p as setMaxConcreteIter, q as setMockModules, t as setModuleResolver, u as setNodeTypeCollector, v as setProvenanceTracking, w as setSampleCount, x as setUnknownBuiltinHandler, y as setUnknownCollector, z as setUsageSiteTag } from '../config-UlReSTfh.js';
-import { Node } from '@babel/types';
-import { Environment, TypeValue } from '@nudojs/core';
+export { C as CallRecord, I as InterfaceConfig, N as NudoConfig, f as findProjectConfig, i as interfaceConfig } from '../config-NqDRWWpn.js';
+import { Abs, Environment } from '@nudojs/core';
 
 /**
- * Given a test expression and the current environment, produce two
- * environments: one where the test is truthy, one where it is falsy.
+ * 内置类原型成员近似表（Abs 声明）。
+ * LSP 补全唯一真值；TypeValue 求值器已删，不再承载 impl 微求值。
  */
-declare function narrow(test: Node, env: Environment): [trueEnv: Environment, falseEnv: Environment];
 
-/**
- * 内置类原型机制：错误类集合、可构造内置类、Object/Array/Map/Set/…/Buffer
- * 的原型成员近似表，以及 `X.prototype` 单例与类命名空间记忆化。
- * 求值器成员分派与补全侧成员派生共用本表的唯一真值。
- */
-
-declare const BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS: Record<string, Record<string, TypeValue>>;
+declare const BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS: Record<string, Record<string, Abs>>;
+/** LSP detail：Abs fn → `(a: number) => string` 形态 */
+declare function describeAbsMember(a: Abs): string | null;
+declare function builtinProtoMemberNames(className: string): string[];
+declare function builtinProtoMember(className: string, member: string): Abs | null;
 
 type LoadedEnv = {
-    modules: Record<string, Record<string, TypeValue>>;
+    /** Abs 原生模块导出（B 路径 / Abs 模块图） */
+    modules: Record<string, Record<string, Abs>>;
+    globals: Record<string, Abs>;
 };
 declare function preloadPathEnvs(envNames: string[], baseDir: string): Promise<void>;
 declare function loadEnvsAsync(envNames: string[], globalEnv: Environment, baseDir?: string): Promise<LoadedEnv>;
@@ -25,4 +23,4 @@ declare function loadEnvs(envNames: string[], globalEnv: Environment): LoadedEnv
 
 declare function resolveNpmNudo(source: string, fromDir: string): string | null;
 
-export { BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS, type LoadedEnv, loadEnvs, loadEnvsAsync, narrow, preloadPathEnvs, resolveNpmNudo };
+export { BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS, type LoadedEnv, builtinProtoMember, builtinProtoMemberNames, describeAbsMember, loadEnvs, loadEnvsAsync, preloadPathEnvs, resolveNpmNudo };

package/dist/evaluator/evaluator-api.js

@@ -1,68 +1,24 @@
 import {
   BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS,
-  USAGE_SITE_MODULE,
-  evaluate,
-  evaluateFunction,
-  evaluateFunctionFull,
-  evaluateProgram,
+  builtinProtoMember,
+  builtinProtoMemberNames,
+  describeAbsMember,
   findProjectConfig,
-  getUnreachableRanges,
   interfaceConfig,
   loadEnvs,
   loadEnvsAsync,
-  memberMayExistOn,
-  narrow,
   preloadPathEnvs,
-  resetEnvModules,
-  resetMemo,
-  resetMockModules,
-  resetUnreachableRanges,
-  resolveNpmNudo,
-  setCallCollector,
-  setCurrentFileDir,
-  setCurrentSource,
-  setEnvModules,
-  setMaxConcreteIter,
-  setMockModules,
-  setModuleResolver,
-  setNodeTypeCollector,
-  setProvenanceTracking,
-  setSampleCount,
-  setUnknownBuiltinHandler,
-  setUnknownCollector,
-  setUsageSiteTag
-} from "../chunk-FSIHAE7I.js";
+  resolveNpmNudo
+} from "../chunk-2VHITMTM.js";
 export {
   BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS,
-  USAGE_SITE_MODULE,
-  evaluate,
-  evaluateFunction,
-  evaluateFunctionFull,
-  evaluateProgram,
+  builtinProtoMember,
+  builtinProtoMemberNames,
+  describeAbsMember,
   findProjectConfig,
-  getUnreachableRanges,
   interfaceConfig,
   loadEnvs,
   loadEnvsAsync,
-  memberMayExistOn,
-  narrow,
   preloadPathEnvs,
-  resetEnvModules,
-  resetMemo,
-  resetMockModules,
-  resetUnreachableRanges,
-  resolveNpmNudo,
-  setCallCollector,
-  setCurrentFileDir,
-  setCurrentSource,
-  setEnvModules,
-  setMaxConcreteIter,
-  setMockModules,
-  setModuleResolver,
-  setNodeTypeCollector,
-  setProvenanceTracking,
-  setSampleCount,
-  setUnknownBuiltinHandler,
-  setUnknownCollector,
-  setUsageSiteTag
+  resolveNpmNudo
 };