@nudojs/service 1.0.0 → 1.1.0

package/dist/chunk-ZXVAX7DE.js

@@ -0,0 +1,815 @@
+// 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";
+
+// src/lru-map.ts
+var BoundedLruMap = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  constructor(max) {
+    this.max = max;
+  }
+  get size() {
+    return this.map.size;
+  }
+  /** 当前上限（可动态收紧；收紧时立刻按 LRU 压到新上限） */
+  getMax() {
+    return this.max;
+  }
+  setMax(max) {
+    this.max = max;
+    this.trim();
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  get(key) {
+    const hit = this.map.get(key);
+    if (hit === void 0) return void 0;
+    this.map.delete(key);
+    this.map.set(key, hit);
+    return hit;
+  }
+  /** 命中不改变 LRU 序（只读探测） */
+  peek(key) {
+    return this.map.get(key);
+  }
+  set(key, value) {
+    if (this.max <= 0) return;
+    while (this.map.size >= this.max && !this.map.has(key)) {
+      const oldest = this.map.keys().next().value;
+      if (oldest === void 0) break;
+      this.map.delete(oldest);
+    }
+    this.map.delete(key);
+    this.map.set(key, value);
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  keys() {
+    return this.map.keys();
+  }
+  values() {
+    return this.map.values();
+  }
+  entries() {
+    return this.map.entries();
+  }
+  /** 压到当前 max（调低上限时收内存） */
+  trim() {
+    while (this.map.size > this.max) {
+      const oldest = this.map.keys().next().value;
+      if (oldest === void 0) break;
+      this.map.delete(oldest);
+    }
+  }
+};
+
+// src/evaluator/env-loader.ts
+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 PATH_ENV_CACHE_MAX = 64;
+var PATH_ENV_BY_PATH_MAX = 64;
+var PATH_ENV_BASE_DIRS_MAX = 64;
+var pathEnvCache = new BoundedLruMap(PATH_ENV_CACHE_MAX);
+var pathEnvByPath = new BoundedLruMap(PATH_ENV_BY_PATH_MAX);
+var pathEnvBaseDirs = /* @__PURE__ */ new Set();
+function addPathEnvBaseDir(baseDir) {
+  pathEnvBaseDirs.delete(baseDir);
+  pathEnvBaseDirs.add(baseDir);
+  while (pathEnvBaseDirs.size > PATH_ENV_BASE_DIRS_MAX) {
+    const oldest = pathEnvBaseDirs.values().next().value;
+    if (oldest === void 0) break;
+    pathEnvBaseDirs.delete(oldest);
+  }
+}
+function getPathEnvCacheSizes() {
+  return {
+    byKey: pathEnvCache.size,
+    byPath: pathEnvByPath.size,
+    baseDirs: pathEnvBaseDirs.size
+  };
+}
+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.get(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) {
+  addPathEnvBaseDir(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";
+
+// src/session-cache-limits.ts
+var DEFAULT_SESSION_CACHE_LIMITS = {
+  maxFiles: 64,
+  maxFns: 1024,
+  maxBRuns: 32
+};
+var HARD_CAP = 65536;
+function clampEntries(n, fallback) {
+  if (typeof n !== "number" || !Number.isFinite(n)) return fallback;
+  return Math.max(0, Math.min(HARD_CAP, Math.floor(n)));
+}
+function parseLimit(raw, fallback) {
+  if (raw === void 0 || raw === "") return fallback;
+  if (raw === "off" || raw === "0") return 0;
+  const n = Number(raw);
+  return clampEntries(n, fallback);
+}
+var explicit = {};
+var fromProject = {};
+var envCache = null;
+function envLimits(env) {
+  return {
+    maxFiles: parseLimit(env.NUDO_CACHE_MAX_FILES, NaN),
+    maxFns: parseLimit(env.NUDO_CACHE_MAX_FNS, NaN),
+    maxBRuns: parseLimit(env.NUDO_CACHE_MAX_BRUNS, NaN)
+  };
+}
+function pick(key, env, fallback) {
+  const e = env[key];
+  if (typeof e === "number" && Number.isFinite(e)) return e;
+  const x = explicit[key];
+  if (typeof x === "number" && Number.isFinite(x)) return clampEntries(x, fallback);
+  const p = fromProject[key];
+  if (typeof p === "number" && Number.isFinite(p)) return clampEntries(p, fallback);
+  return fallback;
+}
+function getSessionCacheLimits(env = process.env) {
+  if (envCache === null) envCache = envLimits(env);
+  return {
+    maxFiles: pick("maxFiles", envCache, DEFAULT_SESSION_CACHE_LIMITS.maxFiles),
+    maxFns: pick("maxFns", envCache, DEFAULT_SESSION_CACHE_LIMITS.maxFns),
+    maxBRuns: pick("maxBRuns", envCache, DEFAULT_SESSION_CACHE_LIMITS.maxBRuns)
+  };
+}
+function setSessionCacheLimits(partial) {
+  explicit = partial ? { ...partial } : {};
+  return getSessionCacheLimits();
+}
+function setSessionCacheFromProject(partial) {
+  fromProject = partial ? { ...partial } : {};
+}
+function resetSessionCacheLimitState() {
+  explicit = {};
+  fromProject = {};
+  envCache = null;
+}
+
+// src/evaluator/config.ts
+import { setBForkBudgetLimit, getBForkBudgetLimit, MAX_B_TOTAL_FORKS } from "@nudojs/core/internal";
+function checkConfig(config) {
+  const raw = config?.check;
+  const rawEntry = raw?.entryThrows;
+  let entryThrows = "error";
+  if (rawEntry === "off" || rawEntry === "warning" || rawEntry === "error") {
+    entryThrows = rawEntry;
+  } else if (rawEntry !== void 0) {
+    process.stderr?.write?.(
+      `nudo.check.entryThrows: invalid value ${JSON.stringify(rawEntry)} (expected error|warning|off); using error
+`
+    );
+  }
+  const ignore = Array.isArray(raw?.ignoreThrows) ? raw.ignoreThrows.filter((s) => typeof s === "string" && s.length > 0) : [];
+  return { entryThrows, ignoreThrows: ignore };
+}
+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",
+    maxForks: parseMaxForks(raw?.maxForks) ?? MAX_B_TOTAL_FORKS
+  };
+}
+function parseMaxForks(raw) {
+  if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 1) return void 0;
+  return Math.floor(raw);
+}
+function applyBForkBudgetFromConfig(config, env = process.env) {
+  const fromEnv = parseMaxForks(
+    env.NUDO_MAX_FORKS === void 0 ? void 0 : Number(env.NUDO_MAX_FORKS)
+  );
+  const fromCfg = parseMaxForks(config?.analysis?.maxForks);
+  return setBForkBudgetLimit(fromEnv ?? fromCfg ?? MAX_B_TOTAL_FORKS);
+}
+function currentBForkBudgetLimit() {
+  return getBForkBudgetLimit();
+}
+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?.contract?.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?.contract?.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) {
+          const nudo = pkg.nudo;
+          setSessionCacheFromProject(nudo.sessionCache);
+          applyBForkBudgetFromConfig(nudo);
+          return { config: nudo, projectDir: dir };
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  applyBForkBudgetFromConfig(null);
+  return null;
+}
+
+// src/evaluator/resolve-npm.ts
+import { readFileSync as readFileSync3, existsSync as existsSync3, statSync as statSync2 } 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 resolveNpmJsEntry(source, fromDir) {
+  if (!source || source.startsWith(".") || source.startsWith("/") || source.startsWith("node:")) {
+    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).replace(/^\//, "") || ".";
+  const nodeModules = findNodeModules(fromDir);
+  if (!nodeModules) return null;
+  const pkgDir = join(nodeModules, pkgName);
+  const pkgJsonPath = join(pkgDir, "package.json");
+  if (!existsSync3(pkgJsonPath)) return null;
+  const tryFile = (p) => {
+    for (const c of [p, `${p}.js`, `${p}.cjs`, `${p}.mjs`, join(p, "index.js"), join(p, "index.cjs")]) {
+      try {
+        if (existsSync3(c) && statSync2(c).isFile()) return c;
+      } catch {
+      }
+    }
+    return null;
+  };
+  let pkg = {};
+  try {
+    pkg = JSON.parse(readFileSync3(pkgJsonPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  const exportsField = pkg.exports;
+  const pickExport = (entry) => {
+    if (typeof entry === "string") return entry;
+    if (entry && typeof entry === "object") {
+      const o = entry;
+      for (const k of ["nudo", "node", "require", "import", "default"]) {
+        const v = o[k];
+        const r = pickExport(v);
+        if (r) return r;
+      }
+    }
+    return null;
+  };
+  if (exportsField) {
+    let rel = null;
+    if (typeof exportsField === "string" && subpath === ".") rel = exportsField;
+    else if (exportsField && typeof exportsField === "object") {
+      const map = exportsField;
+      const key = subpath === "." ? "." : `./${subpath}`;
+      rel = pickExport(map[key] ?? (subpath === "." ? map : void 0));
+    }
+    if (rel) {
+      const hit = tryFile(resolve2(pkgDir, rel));
+      if (hit) return hit;
+    }
+  }
+  if (subpath === ".") {
+    const main = typeof pkg.main === "string" ? pkg.main : void 0;
+    const hit = tryFile(resolve2(pkgDir, main ?? "."));
+    if (hit) return hit;
+    const mod = typeof pkg.module === "string" ? pkg.module : void 0;
+    if (mod) {
+      const hitMod = tryFile(resolve2(pkgDir, mod));
+      if (hitMod) return hitMod;
+    }
+    return null;
+  }
+  return tryFile(resolve2(pkgDir, subpath));
+}
+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 {
+  resolveNpmJsEntry,
+  resolveNpmNudo,
+  BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS,
+  describeAbsMember,
+  builtinProtoMemberNames,
+  builtinProtoMember,
+  BoundedLruMap,
+  getPathEnvCacheSizes,
+  clearPathEnvCaches,
+  preloadPathEnvs,
+  loadEnvsAsync,
+  loadEnvs,
+  DEFAULT_SESSION_CACHE_LIMITS,
+  getSessionCacheLimits,
+  setSessionCacheLimits,
+  setSessionCacheFromProject,
+  resetSessionCacheLimitState,
+  checkConfig,
+  DEFAULT_ANALYSIS_MODE,
+  analysisConfig,
+  applyBForkBudgetFromConfig,
+  currentBForkBudgetLimit,
+  diskCacheRoot,
+  interfaceConfig,
+  matchesEmitAllowlist,
+  findProjectConfig
+};