@nudojs/service 4.0.0 → 5.0.0-beta.1

package/dist/{chunk-ADFCZP72.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}`;
@@ -338,7 +426,7 @@ function clearPathEnvCaches() {
   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);
@@ -378,6 +466,81 @@ 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/**",
@@ -406,9 +569,24 @@ function analysisConfig(config) {
     mode,
     diagnostics,
     callSiteBudget,
-    evalMissingSlot: raw?.evalMissingSlot === "warning" ? "warning" : "off"
+    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;
@@ -424,10 +602,10 @@ function diskCacheRoot(config, projectDir) {
   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
   };
 }
@@ -478,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 {
       }
@@ -487,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);
@@ -505,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];
@@ -538,19 +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-Cqj8zeZH.d.ts → config-DDB588oA.d.ts}

@@ -1,51 +1,8 @@
-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 打印共用） */
+    contract?: {
+        /** 侧车 ambient 绑定总开关（check/LSP 执法与 contract 打印共用） */
         autoBind?: boolean;
         /**
          * emit 白名单（Phase 3，§7.3）：glob 数组，相对 projectDir。
@@ -53,7 +10,7 @@ type NudoConfig = {
          */
         emit?: string[] | string;
     };
-    /** 分析范围与噪声档（design-analysis-scope.md / A2） */
+    /** 分析范围与噪声档（design-cli-semantics.md §7） */
     analysis?: {
         include?: string[] | string;
         exclude?: string[] | string;
@@ -65,9 +22,30 @@ type NudoConfig = {
         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;
@@ -85,7 +63,17 @@ type AnalysisConfig = {
     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;
 /**
@@ -95,10 +83,19 @@ declare const DEFAULT_ANALYSIS_MODE: AnalysisMode;
  * 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.interface` 配置段。
+ * 归一化 `nudo.contract` 配置段。
  * - autoBind 默认 true
  * - emit：string | string[] → string[]（空 = 不限制路径）
  */
@@ -114,4 +111,4 @@ declare function findProjectConfig(startDir: string): {
     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 };
+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 };