@nudojs/service 1.0.1 → 1.1.0

package/dist/{chunk-2VHITMTM.js → chunk-ZXVAX7DE.js}

@@ -235,6 +235,75 @@ 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,
@@ -255,9 +324,28 @@ function resolveEnvNames(names) {
   names.forEach(visit);
   return [...resolved];
 }
-var pathEnvCache = /* @__PURE__ */ new Map();
-var pathEnvByPath = /* @__PURE__ */ new Map();
+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;
@@ -281,7 +369,7 @@ function rewriteBareImports(text) {
 }
 async function importPathEnv(resolvedPath, mtimeMs) {
   const cacheKey = `${resolvedPath}:${mtimeMs}`;
-  if (pathEnvCache.has(cacheKey)) return;
+  if (pathEnvCache.get(cacheKey)) return;
   let mod = null;
   try {
     const url = pathToFileURL(resolvedPath).href + `?mtime=${mtimeMs}`;
@@ -306,7 +394,10 @@ async function importPathEnv(resolvedPath, mtimeMs) {
   }
   if (mod && typeof mod.defineEnv === "function") {
     pathEnvCache.set(cacheKey, mod.defineEnv);
-    pathEnvByPath.set(resolvedPath, mod.defineEnv);
+    pathEnvByPath.set(resolvedPath, {
+      factory: mod.defineEnv,
+      mtimeMs
+    });
   }
 }
 function lookupPathEnv(name) {
@@ -314,12 +405,28 @@ function lookupPathEnv(name) {
   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;
+    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);
+  addPathEnvBaseDir(baseDir);
   for (const name of envNames) {
     if (!isPathEnvName(name, baseDir)) continue;
     const resolved = resolvePath(baseDir, name);
@@ -359,11 +466,146 @@ function loadEnvs(envNames, globalEnv) {
 // 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?.interface?.emit;
+  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?.interface?.autoBind ?? true,
+    autoBind: config?.contract?.autoBind ?? true,
     emit
   };
 }
@@ -414,7 +656,10 @@ function findProjectConfig(startDir) {
       try {
         const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
         if (pkg.nudo) {
-          return { config: pkg.nudo, projectDir: dir };
+          const nudo = pkg.nudo;
+          setSessionCacheFromProject(nudo.sessionCache);
+          applyBForkBudgetFromConfig(nudo);
+          return { config: nudo, projectDir: dir };
         }
       } catch {
       }
@@ -423,11 +668,12 @@ function findProjectConfig(startDir) {
     if (parent === dir) break;
     dir = parent;
   }
+  applyBForkBudgetFromConfig(null);
   return null;
 }
 
 // src/evaluator/resolve-npm.ts
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+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);
@@ -441,6 +687,72 @@ function findNodeModules(startDir) {
   }
   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];
@@ -474,15 +786,30 @@ function resolveNpmNudo(source, fromDir) {
 }
 
 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,
-  resolveNpmNudo,
-  BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS,
-  describeAbsMember,
-  builtinProtoMemberNames,
-  builtinProtoMember
+  findProjectConfig
 };

package/dist/config-DDB588oA.d.ts

@@ -0,0 +1,114 @@
+type NudoConfig = {
+    env?: string[];
+    mocks?: Record<string, string>;
+    contract?: {
+        /** 侧车 ambient 绑定总开关（check/LSP 执法与 contract 打印共用） */
+        autoBind?: boolean;
+        /**
+         * emit 白名单（Phase 3，§7.3）：glob 数组，相对 projectDir。
+         * 省略/空 = 不按路径过滤（仍受 --fn/--all 与「默认只刷已有生成段」约束）。
+         */
+        emit?: string[] | string;
+    };
+    /** 分析范围与噪声档（design-cli-semantics.md §7） */
+    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";
+        /**
+         * B $fork 总次数上限（默认 5000）。env `NUDO_MAX_FORKS` 优先。
+         * n≥1 有限整数；非法值回默认。启动时 set 进 core（setBForkBudgetLimit）。
+         */
+        maxForks?: number;
+    };
+    /** 磁盘缓存（B3）：true → `.nudo/cache`；字符串 → 自定义根；false/省略 → 关 */
+    cache?: boolean | string;
+    /**
+     * 进程内会话 LRU 上限（内存/速度权衡）。多项目开 IDE 时调低封顶；
+     * 单大仓 warm 命中可调高。0 = 关闭该层。env `NUDO_CACHE_MAX_*` 优先。
+     */
+    sessionCache?: {
+        maxFiles?: number;
+        maxFns?: number;
+        maxBRuns?: number;
+    };
+    /** check 门禁（design-cli-semantics §3） */
+    check?: {
+        /** L2 入口 may-throw：error | warning | off（默认 error） */
+        entryThrows?: "error" | "warning" | "off";
+        /** L2 --ignore-throws 类型名列表 */
+        ignoreThrows?: 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";
+    /** B $fork 总次数上限（已归一化；非法值回 core 默认） */
+    maxForks: number;
+};
+type CheckConfig = {
+    /** L2 入口 may-throw 执法档；默认 error */
+    entryThrows: "error" | "warning" | "off";
+    /** L2 ignoreThrows 类型名；默认空 */
+    ignoreThrows: string[];
+};
+/** package.json#nudo.check → 执法选项 */
+declare function checkConfig(config: NudoConfig | null | undefined): CheckConfig;
+/** 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;
+/**
+ * 把 fork 预算写进 core（core 保持无 IO）。
+ * 优先级：env `NUDO_MAX_FORKS` > `package.json#nudo.analysis.maxForks` > 默认 5000。
+ * 约定：n≥1 有限整数；非法值回默认。返回实际生效值。
+ * 由 findProjectConfig / 宿主启动时调用（与 setSessionCacheFromProject 同时机）。
+ */
+declare function applyBForkBudgetFromConfig(config: NudoConfig | null | undefined, env?: NodeJS.ProcessEnv): number;
+/** 当前生效 fork 上限（调试/测试；与 core getBForkBudgetLimit 同源） */
+declare function currentBForkBudgetLimit(): number;
+/** 磁盘缓存根（B3）：config.cache / NUDO_CACHE_DIR / 默认关 */
+declare function diskCacheRoot(config: NudoConfig | null | undefined, projectDir: string | undefined): string | undefined;
+/**
+ * 归一化 `nudo.contract` 配置段。
+ * - 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 CheckConfig as C, type DiagnosticsLevel as D, type InterfaceConfig as I, type NudoConfig as N, type AnalysisMode as a, analysisConfig as b, checkConfig as c, diskCacheRoot as d, DEFAULT_ANALYSIS_MODE as e, findProjectConfig as f, applyBForkBudgetFromConfig as g, currentBForkBudgetLimit as h, interfaceConfig as i, matchesEmitAllowlist as m };