@nudojs/service 0.3.0 → 0.3.2

package/src/dts-generator.ts

@@ -1,291 +0,0 @@
-import type { TypeValue } from "@nudojs/core";
-import { T, isTemplate, getTemplateParts, simplifyUnion, typeValueEquals, getFnSig } from "@nudojs/core";
-import type { AnalysisResult, FunctionAnalysis } from "./analyzer.ts";
-
-export function typeValueToTSType(tv: TypeValue): string {
-  switch (tv.kind) {
-    case "literal": {
-      const v = tv.value;
-      if (v === null) return "null";
-      if (v === undefined) return "undefined";
-      if (typeof v === "string") return JSON.stringify(v);
-      if (typeof v === "boolean") return String(v);
-      return String(v);
-    }
-    case "primitive":
-      return tv.type;
-    case "refined": {
-      if (isTemplate(tv)) {
-        const parts = getTemplateParts(tv)!;
-        const inner = parts
-          .map((p) => (p.kind === "literal" && typeof p.value === "string" ? p.value : `\${${typeValueToTSType(p)}}`))
-          .join("");
-        return `\`${inner}\``;
-      }
-      return typeValueToTSType(tv.base);
-    }
-    case "object": {
-      const entries = Object.entries(tv.properties);
-      if (entries.length === 0) return "{}";
-      const inner = entries
-        .map(([k, v]) => `${k}: ${typeValueToTSType(v)}`)
-        .join("; ");
-      return `{ ${inner} }`;
-    }
-    case "array":
-      return `${wrapComplexType(tv.element)}[]`;
-    case "tuple": {
-      const inner = tv.elements.map(typeValueToTSType).join(", ");
-      return `[${inner}]`;
-    }
-    case "function": {
-      const params = tv.params
-        .map((p) => `${p}: unknown`)
-        .join(", ");
-      const sig = getFnSig(tv);
-      const retStr = sig?.returnType ? typeValueToTSType(sig.returnType) : "unknown";
-      return `(${params}) => ${retStr}`;
-    }
-    case "promise":
-      return `Promise<${typeValueToTSType(tv.value)}>`;
-    case "instance":
-      return tv.className;
-    case "union":
-      return tv.members.map(typeValueToTSType).join(" | ");
-    case "never":
-      return "never";
-    case "unknown":
-      return "unknown";
-  }
-}
-
-function wrapComplexType(tv: TypeValue): string {
-  const ts = typeValueToTSType(tv);
-  if (tv.kind === "union") return `(${ts})`;
-  return ts;
-}
-
-function getParamName(fn: FunctionAnalysis, index: number): string {
-  if (fn.paramNames && fn.paramNames[index]) {
-    return fn.paramNames[index];
-  }
-  return `arg${index}`;
-}
-
-// ---------------------------------------------------------------------------
-// Widening —— 主签名语义
-//
-// case 形状携带字面量精度（10、"Alice"、true、[1,2,3]、{ id: 1 }），但
-// .d.ts 是调用面而非 case 台账：按 case 生成重载时 `safeSqrt(arg0: 10): 10`
-// 会让合法调用 `safeSqrt(5)` 匹配不到任何重载，直接编译错误（tsc 5.9.3
-// 实测 TS2769，见 __tests__/dts-generator.test.ts 的 safeSqrt 场景）。
-// 主签名因此取 Combined 语义：每个参数位置取各 case 对应参数类型的联合
-// 并 widen，返回类型对 combined 同样 widen（顶层标量字面量 → 基类型
-// number/string/boolean/bigint；null/undefined 字面量本身是基类型，不变）。
-//
-// 参数位是逆变位，拦截面最广，widen 递归进结构（tsc --strict 实测）：
-//   - 同构元组 [1,2,3,4,5] → number[]：定长 widened 元组
-//     [number,number,number,number,number] 仍会拒收变长合法实参（TS2345
-//     "Source has 2 element(s) but target requires 3"），而字面量长度只是
-//     单次调用观察，不该构成约束；
-//   - 异构元组 [1,"two"] → [number, string]：位置语义真实，且不拦截
-//     合法的按位调用（实测 f([1,"x"]) 通过）；
-//   - 对象属性值 { id: 1 } → { id: number }、数组元素、Promise 载荷、
-//     实例属性同样递归 widen（全部处于逆变位，字面量精度同样拦截赋值）；
-//   - refined（模板串/数值收窄）剥到 base：参数位收窄拦截一切不匹配
-//     实参，精确形状由 JSDoc Case: 行保留。
-//
-// 返回值位是协变位，收窄只会让调用方拿到更精确的类型、不会拦截调用，
-// 维持现状：仅顶层（含 union 成员）标量字面量 widen，嵌套精度保留
-// （Promise<42>、返回元组字面量等）。
-//
-// 就地实现而不复用 core 的 widenLiteral：①本路径不依赖 core 侧并行改动的
-// 落地时序；②core 版本把 bigint 字面量映射到 unknown，不符合此处语义。
-// ---------------------------------------------------------------------------
-function widenLiteralToBase(tv: TypeValue): TypeValue {
-  if (tv.kind !== "literal") return tv;
-  const v = tv.value;
-  if (typeof v === "number") return T.number;
-  if (typeof v === "string") return T.string;
-  if (typeof v === "boolean") return T.boolean;
-  if (typeof v === "bigint") return T.bigint;
-  return tv;
-}
-
-/** 返回值位（协变）：仅顶层标量字面量 widen，嵌套精度保留 */
-function widenTopLevel(tv: TypeValue): TypeValue {
-  if (tv.kind !== "union") return widenLiteralToBase(tv);
-  return simplifyUnion(tv.members.map(widenLiteralToBase));
-}
-
-function widenProperties(properties: Record<string, TypeValue>): Record<string, TypeValue> {
-  const out: Record<string, TypeValue> = {};
-  for (const [k, v] of Object.entries(properties)) out[k] = widenParamType(v);
-  return out;
-}
-
-/** 参数位（逆变）递归 widen：结构内的字面量精度一律放宽到基类型 */
-function widenParamType(tv: TypeValue): TypeValue {
-  switch (tv.kind) {
-    case "literal":
-      return widenLiteralToBase(tv);
-    case "union":
-      return simplifyUnion(tv.members.map(widenParamType));
-    case "tuple": {
-      const widened = tv.elements.map(widenParamType);
-      const first = widened[0];
-      if (first && widened.every((el) => typeValueEquals(el, first))) {
-        return T.array(first);
-      }
-      return T.tuple(widened);
-    }
-    case "array":
-      return T.array(widenParamType(tv.element));
-    case "object":
-      return T.object(widenProperties(tv.properties));
-    case "promise":
-      return T.promise(widenParamType(tv.value));
-    case "instance":
-      return T.instanceOf(tv.className, widenProperties(tv.properties));
-    case "refined":
-      return widenParamType(tv.base);
-    default:
-      return tv;
-  }
-}
-
-/**
- * 各 case 在同一参数位的类型 → 拍平、递归 widen、去重后的单一 TypeValue。
- * 去重以 TS 渲染串为键：TypeValue 的对象/元组相等性是引用比较，两个同形
- * 的 widened 对象（如各 case 的 { id: number }）不去重会渲染成重复成员。
- */
-function widenedUnion(members: TypeValue[]): TypeValue {
-  const flat: TypeValue[] = [];
-  const collect = (tv: TypeValue): void => {
-    if (tv.kind === "union") {
-      tv.members.forEach(collect);
-      return;
-    }
-    flat.push(tv);
-  };
-  members.forEach(collect);
-  const widened = flat.map(widenParamType);
-  const seen = new Set<string>();
-  const deduped = widened.filter((tv) => {
-    const key = typeValueToTSType(tv);
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-  return simplifyUnion(deduped);
-}
-
-type MainSignature = {
-  /** 渲染后的参数声明（含 `?` / `...rest`），如 `["x: number", "y?: string"]` */
-  params: string[];
-  /** 去重后的参数名（JSDoc @param 与渲染共用，保证一致） */
-  paramNames: string[];
-  /** 各参数位 widen 后的 TS 类型串（JSDoc 与精确度比对用） */
-  paramTypes: string[];
-  /** widen 后的返回类型串 */
-  returnType: string;
-};
-
-function computeMainSignature(fn: FunctionAnalysis): MainSignature {
-  const arity = Math.max(...fn.cases.map((c) => c.args.length));
-  const minArity = Math.min(...fn.cases.map((c) => c.args.length));
-  const params: string[] = [];
-  const paramNames: string[] = [];
-  const paramTypes: string[] = [];
-  const usedNames = new Set<string>();
-  for (let i = 0; i < arity; i++) {
-    const members = fn.cases
-      .filter((c) => i < c.args.length)
-      .map((c) => c.args[i]);
-    const typeStr = typeValueToTSType(widenedUnion(members));
-    let name = getParamName(fn, i);
-    if (usedNames.has(name)) {
-      // 解构/模式参数在 AST 提取时都叫 "_"；单一签名里重名会让 .d.ts
-      // 非法（tsc TS2300 Duplicate identifier），序号去重
-      let n = 2;
-      while (usedNames.has(`${name}${n}`)) n++;
-      name = `${name}${n}`;
-    }
-    usedNames.add(name);
-    // 各 case 元数不一致时，短 case 不传的尾部参数标可选，长调用短调用都放行
-    const optional = i >= minArity && !name.startsWith("...");
-    params.push(optional ? `${name}?: ${typeStr}` : `${name}: ${typeStr}`);
-    paramNames.push(name);
-    paramTypes.push(typeStr);
-  }
-  const combined = fn.combined ?? simplifyUnion(fn.cases.map((c) => c.result));
-  const returnType = typeValueToTSType(widenTopLevel(combined));
-  return { params, paramNames, paramTypes, returnType };
-}
-
-function generateJSDoc(fn: FunctionAnalysis, sig: MainSignature): string {
-  if (fn.cases.length === 0) return "";
-  const lines: string[] = ["/**"];
-  // 精确 case 形状记录在主签名 JSDoc 而非生成精确重载。决策依据按实测修正
-  // （tsc 5.9.3，最小 .d.ts + 调用文件 + tsc --noEmit）：字面量参数重载其实
-  // 可达——「宽主签名在前则后置精确重载永不命中」不成立，新鲜与非新鲜
-  // （as const 传入）字面量实参都会优先命中字面量参数重载，与声明顺序无关。
-  // 即便如此仍只生成单一主签名：① --callsites 场景单个函数可合成几十个
-  // case，逐 case 重载会让声明面爆炸；② throwing case 的 `: never` 重载对
-  // 调用方是陷阱（对 never 取属性/运算直接报错）；③ 字面量精度由下面的
-  // Case: 行完整保留。与主签名同形的 case（无信息损失）不罗列。
-  for (const c of fn.cases) {
-    const preciseDiffers =
-      c.args.length !== sig.paramTypes.length ||
-      c.args.some((a, i) => typeValueToTSType(a) !== sig.paramTypes[i]) ||
-      typeValueToTSType(c.result) !== sig.returnType;
-    if (!preciseDiffers) continue;
-    const argsStr = c.args.map(typeValueToTSType).join(", ");
-    lines.push(` * Case: ${c.name} (${argsStr}) => ${typeValueToTSType(c.result)}`);
-  }
-  for (let i = 0; i < sig.paramTypes.length; i++) {
-    lines.push(` * @param ${sig.paramNames[i]} - ${sig.paramTypes[i]}`);
-  }
-  lines.push(` * @returns ${sig.returnType}`);
-  lines.push(" */");
-  return lines.join("\n");
-}
-
-/**
- * 为单个函数生成 .d.ts 声明行（JSDoc + 单一 widen 主签名）。
- * service 的 generateDts 与 CLI `--dts`（infer/watch）共用本函数，
- * 两条路径输出保持一致。
- */
-export function generateFunctionDtsLines(fn: FunctionAnalysis): string[] {
-  // CJS-style binding/assignment functions have no declaration-stable
-  // export name; they stay in infer/JSON output only.
-  if (fn.noDeclaration) return [];
-
-  if (fn.cases.length === 0) {
-    // skipped / entryOnly / 无 case 函数：只有声明或 combined 返回类型已知，
-    // 保持历史行为——rest-args 形式，combined（含 Promise<T>）原样输出。
-    if (fn.combined) {
-      return [
-        `export declare function ${fn.name}(...args: unknown[]): ${typeValueToTSType(fn.combined)};`,
-      ];
-    }
-    return [];
-  }
-
-  const sig = computeMainSignature(fn);
-  const jsdoc = generateJSDoc(fn, sig);
-  const lines: string[] = [];
-  if (jsdoc) lines.push(jsdoc);
-  lines.push(`export declare function ${fn.name}(${sig.params.join(", ")}): ${sig.returnType};`);
-  return lines;
-}
-
-export function generateDts(result: AnalysisResult): string {
-  const lines: string[] = [];
-
-  for (const fn of result.functions) {
-    lines.push(...generateFunctionDtsLines(fn));
-  }
-
-  return lines.join("\n") + "\n";
-}

package/src/env-to-abs.ts

@@ -1,57 +0,0 @@
-/**
- * env TypeValue → Abs：保留 fnSig impl，使 Promise.resolve / URL 等
- * 在 B 路径也能产出精确字面量。
- */
-
-import {
-  type TypeValue,
-  type Abs,
-  typeValueToAbs,
-  absToTypeValue,
-  getFnSig,
-  absFunction,
-  objOf,
-} from "@nudojs/core";
-
-export function envValueToAbs(tv: TypeValue): Abs {
-  if (!tv) return typeValueToAbs({ kind: "unknown" });
-
-  if (tv.kind === "function") {
-    const sig = getFnSig(tv);
-    if (sig?.impl) {
-      const params =
-        tv.kind === "function" && tv.params?.length
-          ? tv.params
-          : sig.paramTypes.map((_, i) => `_arg${i}`);
-      const dummyBody = {
-        type: "BlockStatement",
-        body: [],
-        directives: [],
-      } as never;
-      const impl = sig.impl;
-      return absFunction(params, {
-        body: dummyBody,
-        apply: (args: Abs[]): Abs => {
-          const tvArgs = args.map((a) => absToTypeValue(a));
-          try {
-            const r = impl(tvArgs);
-            if (!r) return typeValueToAbs(sig.returnType);
-            return envValueToAbs(r);
-          } catch {
-            return typeValueToAbs(sig.returnType);
-          }
-        },
-      });
-    }
-  }
-
-  if (tv.kind === "object") {
-    const slots: Record<string, { value: Abs }> = {};
-    for (const [k, v] of Object.entries(tv.properties)) {
-      slots[k] = { value: envValueToAbs(v) };
-    }
-    return objOf(slots);
-  }
-
-  return typeValueToAbs(tv);
-}

package/src/fn-analysis-cache.ts

@@ -1,119 +0,0 @@
-/**
- * Per-function FunctionAnalysis cache (body-edit: recompute only dirty fns).
- * Cleared together with B-path / whole-file analysis caches.
- */
-import type { TypeValue } from "@nudojs/core";
-
-// Structural types — avoid importing analyzer (cycle).
-export type CachedSourceLocation = {
-  start: { line: number; column: number };
-  end: { line: number; column: number };
-};
-
-export type CachedDiagnostic = {
-  range: CachedSourceLocation;
-  severity: "error" | "warning" | "info";
-  message: string;
-  tags?: string[];
-  code?: string;
-  suggestions?: string[];
-  data?: unknown;
-  origin?: { line: number; column: number };
-};
-
-export type CachedCaseHint = {
-  line: number;
-  label: string;
-  ok: boolean;
-};
-
-export type CachedCallRecord = {
-  // opaque; cloned shallowly. Position fields that need lineDelta shift
-  // (currently only callLoc) are listed on CallRecord in evaluator.ts —
-  // keep shiftCallRecordLines in sync when adding any.
-  [k: string]: unknown;
-};
-
-export type CachedFnAnalysis = {
-  analysis: {
-    name: string;
-    loc: CachedSourceLocation;
-    paramNames: string[];
-    cases: Array<{
-      name: string;
-      args: TypeValue[];
-      result: TypeValue;
-      throws: TypeValue;
-      throwLoc?: CachedSourceLocation;
-      source?: string;
-      expected?: TypeValue;
-      aggregatedFrom?: number;
-      intension?: Record<string, unknown>;
-    }>;
-    combined?: TypeValue;
-    entryOnly?: boolean;
-    skipped?: boolean;
-    noDeclaration?: boolean;
-    fromModule?: string;
-  };
-  diagnostics: CachedDiagnostic[];
-  caseHints: CachedCaseHint[];
-  callRecords: CachedCallRecord[];
-};
-
-const fnAnalysisCache = new Map<string, CachedFnAnalysis>();
-const MAX_FN_ANALYSIS_CACHE = 1024;
-
-export function clearFnAnalysisCache(): void {
-  fnAnalysisCache.clear();
-}
-
-export function fnAnalysisCacheGet(key: string): CachedFnAnalysis | undefined {
-  const hit = fnAnalysisCache.get(key);
-  if (hit !== undefined) {
-    fnAnalysisCache.delete(key);
-    fnAnalysisCache.set(key, hit);
-  }
-  return hit;
-}
-
-export function fnAnalysisCacheSet(key: string, value: CachedFnAnalysis): void {
-  // Only evict when inserting a new key; overwrite of an existing key keeps LRU size
-  if (fnAnalysisCache.size >= MAX_FN_ANALYSIS_CACHE && !fnAnalysisCache.has(key)) {
-    const oldest = fnAnalysisCache.keys().next().value;
-    if (oldest !== undefined) fnAnalysisCache.delete(oldest);
-  }
-  fnAnalysisCache.set(key, value);
-}
-
-/**
- * Dependency content changed: drop every per-fn entry for these entry files.
- * Keys are `filePath\0...`, so a prefix scan is sound and cheap at LRU size.
- */
-export function evictFnAnalysisCacheForFiles(files: string[]): number {
-  if (files.length === 0 || fnAnalysisCache.size === 0) return 0;
-  const prefixes = files.map((f) => `${f}\0`);
-  let n = 0;
-  for (const key of [...fnAnalysisCache.keys()]) {
-    if (prefixes.some((p) => key.startsWith(p))) {
-      fnAnalysisCache.delete(key);
-      n++;
-    }
-  }
-  return n;
-}
-
-export function caseDirectiveKey(
-  directives: Array<{ kind: string; name?: string; args?: TypeValue[] }>,
-  typeValueToString: (t: TypeValue) => string,
-): string {
-  return directives
-    .map((d) => {
-      if (d.kind === "case") {
-        const args = (d.args ?? []).map((a) => typeValueToString(a)).join(",");
-        return `c:${d.name ?? ""}:${args}`;
-      }
-      return d.kind;
-    })
-    .join("|");
-}

package/src/guard-generator.ts

@@ -1,57 +0,0 @@
-import type { TypeValue, Abs } from "@nudojs/core";
-import { denoteGuard } from "@nudojs/core";
-
-export function generateGuardFunction(name: string, tv: TypeValue): string {
-  const body = generateGuardBody(tv, "data");
-  return `export function ${name}(data) {\n  return ${body};\n}`;
-}
-
-/** Abs 指称守卫（设计 §2.7）：比 TypeValue 投影多保留 pred */
-export function generateGuardFunctionFromAbs(name: string, abs: Abs): string {
-  const body = denoteGuard(abs, "data");
-  return `export function ${name}(data) {\n  return ${body};\n}`;
-}
-
-function generateGuardBody(tv: TypeValue, varName: string): string {
-  switch (tv.kind) {
-    case "literal": {
-      if (tv.value === null) return `${varName} === null`;
-      if (tv.value === undefined) return `${varName} === undefined`;
-      return `${varName} === ${JSON.stringify(tv.value)}`;
-    }
-    case "primitive":
-      return `typeof ${varName} === '${tv.type}'`;
-    case "refined":
-      return generateGuardBody(tv.base, varName);
-    case "object": {
-      const checks = [`typeof ${varName} === 'object'`, `${varName} !== null`];
-      for (const [key, val] of Object.entries(tv.properties)) {
-        checks.push(generateGuardBody(val, `${varName}.${key}`));
-      }
-      return checks.join(" && ");
-    }
-    case "array":
-      return `Array.isArray(${varName}) && ${varName}.every(item => ${generateGuardBody(tv.element, "item")})`;
-    case "tuple": {
-      const checks = [`Array.isArray(${varName})`, `${varName}.length === ${tv.elements.length}`];
-      tv.elements.forEach((el, i) => {
-        checks.push(generateGuardBody(el, `${varName}[${i}]`));
-      });
-      return checks.join(" && ");
-    }
-    case "union": {
-      const members = tv.members.map((m) => generateGuardBody(m, varName));
-      return `(${members.join(" || ")})`;
-    }
-    case "never":
-      return "false";
-    case "unknown":
-      return "true";
-    case "function":
-      return `typeof ${varName} === 'function'`;
-    case "promise":
-      return `${varName} instanceof Promise`;
-    case "instance":
-      return `${varName} instanceof ${tv.className}`;
-  }
-}

package/src/harvest-auto.ts

@@ -1,86 +0,0 @@
-/**
- * harvest 自动化：源码裸 import → @types/package → env modules。
- * 手动 `nudo harvest` 仍保留；这里是分析路径上的按需注入。
- */
-
-import { parse } from "@nudojs/parser";
-import type { TypeValue } from "@nudojs/core";
-import { collectDependencySpecs } from "./static-imports.ts";
-import { harvestPackage, type PackageHarvest } from "./harvest-package.ts";
-
-/** 裸说明符 → 包名（含 scope）；相对/绝对/node: 内建返回 undefined */
-export function barePackageName(spec: string): string | undefined {
-  if (!spec) return undefined;
-  if (spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("node:")) return undefined;
-  const parts = spec.split("/");
-  if (spec.startsWith("@")) {
-    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : undefined;
-  }
-  return parts[0];
-}
-
-export function collectBarePackages(source: string): string[] {
-  try {
-    const ast = parse(source);
-    const names = new Set<string>();
-    for (const spec of collectDependencySpecs(ast)) {
-      const pkg = barePackageName(spec);
-      if (pkg) names.add(pkg);
-    }
-    return [...names];
-  } catch {
-    return [];
-  }
-}
-
-/** 进程内 harvest 缓存：同包只 walk 一次 dts */
-const harvestCache = new Map<string, PackageHarvest | null>();
-
-export function harvestPackageCached(pkg: string, fromDir: string): PackageHarvest | null {
-  const key = `${fromDir}::${pkg}`;
-  if (harvestCache.has(key)) return harvestCache.get(key)!;
-  let result: PackageHarvest | null = null;
-  try {
-    const h = harvestPackage(pkg, fromDir);
-    if (!("error" in h)) result = h;
-  } catch {
-    result = null;
-  }
-  harvestCache.set(key, result);
-  return result;
-}
-
-export function clearHarvestCache(): void {
-  harvestCache.clear();
-}
-
-/**
- * 自动 harvest 源码中全部裸包（有 @types 或包内 dts 时）。
- * 返回可注入 setEnvModules 的 modules 表；无包可 harvest 时为空对象。
- */
-export function autoHarvestModules(
-  source: string,
-  fromDir: string,
-): Record<string, Record<string, TypeValue>> {
-  const packages = collectBarePackages(source);
-  if (packages.length === 0) return {};
-  const modules: Record<string, Record<string, TypeValue>> = {};
-  for (const pkg of packages) {
-    const h = harvestPackageCached(pkg, fromDir);
-    if (!h) continue;
-    for (const [mod, exports] of Object.entries(h.env.modules)) {
-      // 模块键可能是相对路径形态；同时登记裸包名与原始键
-      modules[mod] = exports;
-      if (!modules[pkg]) modules[pkg] = exports;
-      // `path` / `node:path` 等别名：basename 匹配
-      const base = mod.replace(/^@types\//, "").replace(/\\/g, "/");
-      if (base && !modules[base]) modules[base] = exports;
-    }
-    for (const [k, v] of Object.entries(h.env.globals)) {
-      // 全局 API 也挂一份到包名模块，供 default/namespace 消费
-      if (!modules[pkg]) modules[pkg] = {};
-      if (modules[pkg]![k] === undefined) modules[pkg]![k] = v;
-    }
-  }
-  return modules;
-}

package/src/harvest-node.ts

@@ -1,48 +0,0 @@
-/**
- * 预置 Node API env：从 @types/node 的 .d.ts harvest。
- * 与 packages/env 的手写 env 并行；此路径自动、可刷新。
- */
-
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { harvestDts, type HarvestedEnv } from "@nudojs/harvester";
-import { collectDtsFiles, resolvePackageRoot } from "./harvest-package.ts";
-
-export type NodeEnvResult =
-  | { ok: true; env: HarvestedEnv; root: string; files: number }
-  | { ok: false; error: string };
-
-/** harvest @types/node（限制文件数 + 时间预算，避免拖垮启动） */
-export function harvestNodeTypes(
-  fromDir?: string,
-  maxFiles = 12,
-  maxMs = 2500,
-): NodeEnvResult {
-  // @types/node 在 node_modules/@types/node
-  const root =
-    resolvePackageRoot("@types/node", fromDir) ??
-    resolvePackageRoot("node", fromDir);
-  if (!root || !existsSync(root)) {
-    return { ok: false, error: "@types/node not found" };
-  }
-  // 优先 index.d.ts 等入口
-  const dts = collectDtsFiles(root, maxFiles);
-  if (dts.length === 0) {
-    return { ok: false, error: `no .d.ts under ${root}` };
-  }
-  const env = harvestDts(dts, { maxMs });
-  return { ok: true, env, root, files: env.stats.files };
-}
-
-/** 把 harvest 结果压成「模块名 → 导出名列表」摘要，便于日志/测试 */
-export function summarizeNodeEnv(env: HarvestedEnv): {
-  modules: string[];
-  globals: string[];
-  symbolCount: number;
-} {
-  return {
-    modules: Object.keys(env.modules).sort(),
-    globals: Object.keys(env.globals).sort().slice(0, 50),
-    symbolCount: env.stats.symbols,
-  };
-}