@nudojs/service 4.0.0 → 5.0.0-beta.0

package/dist/{chunk-ADFCZP72.js → chunk-YLALZXTZ.js}

@@ -225,159 +225,84 @@ function builtinProtoMember(className, member) {
   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"]
+// src/evaluator/config.ts
+import { readFileSync, existsSync } 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
 };
-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);
+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)
   };
-  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 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 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 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 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 {
-    }
-  }
+function setSessionCacheLimits(partial) {
+  explicit = partial ? { ...partial } : {};
+  return getSessionCacheLimits();
 }
-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 };
+function setSessionCacheFromProject(partial) {
+  fromProject = partial ? { ...partial } : {};
+}
+function resetSessionCacheLimitState() {
+  explicit = {};
+  fromProject = {};
+  envCache = null;
 }
 
 // src/evaluator/config.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { resolve, dirname, relative, sep } from "path";
+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 +331,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 +364,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
   };
 }
@@ -474,11 +414,14 @@ function findProjectConfig(startDir) {
   const root = resolve("/");
   while (dir !== root) {
     const pkgPath = resolve(dir, "package.json");
-    if (existsSync2(pkgPath)) {
+    if (existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync(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,24 +430,91 @@ 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 readFileSync2, existsSync as existsSync2, statSync } 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;
+    if (existsSync2(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 (!existsSync2(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 (existsSync2(c) && statSync(c).isFile()) return c;
+      } catch {
+      }
+    }
+    return null;
+  };
+  let pkg = {};
+  try {
+    pkg = JSON.parse(readFileSync2(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];
@@ -524,13 +534,13 @@ function resolveNpmNudo(source, fromDir) {
   const nodeModules = findNodeModules(fromDir);
   if (!nodeModules) return null;
   const pkgJsonPath = join(nodeModules, pkgName, "package.json");
-  if (!existsSync3(pkgJsonPath)) return null;
+  if (!existsSync2(pkgJsonPath)) return null;
   try {
-    const pkg = JSON.parse(readFileSync3(pkgJsonPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
     const nudoEntry = resolveExportsNudo(pkg.exports, subpath);
     if (nudoEntry) {
       const resolved = resolve2(dirname2(pkgJsonPath), nudoEntry);
-      if (existsSync3(resolved)) return resolved;
+      if (existsSync2(resolved)) return resolved;
     }
   } catch {
   }
@@ -538,19 +548,24 @@ function resolveNpmNudo(source, fromDir) {
 }
 
 export {
-  clearPathEnvCaches,
-  preloadPathEnvs,
-  loadEnvsAsync,
-  loadEnvs,
+  resolveNpmJsEntry,
+  resolveNpmNudo,
+  BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS,
+  describeAbsMember,
+  builtinProtoMemberNames,
+  builtinProtoMember,
+  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
 };