@nudojs/harvester 0.2.7 → 0.2.8

package/dist/index.js

@@ -1,14 +1,18 @@
-// src/index.ts
+// src/harvest-dts.ts
 import { readFileSync, statSync } from "fs";
 import ts from "typescript";
 import {
   abs as makeAbs,
   lit as termLit,
+  v as termVar,
   numLit,
   strLit,
   boolLit,
   objOf,
-  joinAbs
+  joinAbs,
+  relationFn,
+  getFnImpl,
+  substAbs
 } from "@nudojs/core";
 var MAX_ALIAS_DEPTH = 8;
 function scopeKey(scope) {
@@ -46,6 +50,25 @@ function absArr(element) {
 function absPromise(inner) {
   return absExact({ k: "eff", eff: "promise", inner });
 }
+function absMapType(name, key, value) {
+  return absExact({
+    k: "brand",
+    name,
+    shape: absObj({
+      __key: key,
+      __value: value
+    })
+  });
+}
+function absSetType(name, elem) {
+  return absExact({
+    k: "brand",
+    name,
+    shape: absObj({
+      __elem: elem
+    })
+  });
+}
 function absObj(properties) {
   const slots = {};
   for (const [k, v] of Object.entries(properties)) {
@@ -56,14 +79,16 @@ function absObj(properties) {
 function absBrand(name, properties) {
   return absExact({ k: "brand", name, shape: absObj(properties) });
 }
-function absFnSig(paramTypes, returnType) {
-  return absExact({
-    k: "fn",
+function absFnSig(paramTypes, returnType, extra) {
+  return relationFn(paramTypes, returnType, {
     params: paramTypes.map((_, i) => `_arg${i}`),
-    paramTypes,
-    returnType
+    conf: "exact",
+    ...extra ?? {}
   });
 }
+function typeVarAbs(name) {
+  return makeAbs({ k: "any" }, termVar(name), void 0, "path");
+}
 function absUnion(members) {
   if (members.length === 0) return absNever();
   return members.reduce((acc, m) => joinAbs(acc, m));
@@ -71,6 +96,19 @@ function absUnion(members) {
 function isPlainUnknown(a) {
   return a.shape.k === "unknown" && !(a.term?.op === "lit");
 }
+function hasTypeVar(a, depth = 0) {
+  if (depth > 6) return false;
+  if (a.term?.op === "var") return true;
+  const s = a.shape;
+  if (s.k === "arr") return hasTypeVar(s.element, depth + 1);
+  if (s.k === "tuple") return s.elements.some((e) => hasTypeVar(e, depth + 1));
+  if (s.k === "sum") return s.members.some((m) => hasTypeVar(m, depth + 1));
+  if (s.k === "obj") return Object.values(s.slots).some((sl) => hasTypeVar(sl.value, depth + 1));
+  if (s.k === "fn") {
+    return (s.paramTypes ?? []).some((p) => hasTypeVar(p, depth + 1)) || (s.returnType ? hasTypeVar(s.returnType, depth + 1) : false);
+  }
+  return false;
+}
 function harvestDts(files, opts) {
   const maxBytes = opts?.maxFileBytes ?? 15e5;
   const deadline = opts?.maxMs !== void 0 ? Date.now() + opts.maxMs : void 0;
@@ -84,6 +122,7 @@ function harvestDts(files, opts) {
     classes: /* @__PURE__ */ new Map(),
     instanceCache: /* @__PURE__ */ new Map(),
     expanding: /* @__PURE__ */ new Set(),
+    typeParams: /* @__PURE__ */ new Set(),
     moduleAliases: [],
     importEquals: /* @__PURE__ */ new Map(),
     declaredModules: /* @__PURE__ */ new Set(),
@@ -141,7 +180,7 @@ function emitEnvModule(env, pkgName) {
     constLines.push("");
   }
   const lines = [];
-  lines.push("// Auto-generated by nudo harvest \u2014 DO NOT EDIT");
+  lines.push("// Auto-generated by @nudojs/harvester \u2014 DO NOT EDIT");
   lines.push(`// Source package: ${pkgName}`);
   lines.push(
     'import { num, str, bool, never as absNever, unknown as absUnknown, numLit, strLit, boolLit, objOf, relationFn, abs as makeAbs } from "@nudojs/core";'
@@ -222,9 +261,17 @@ function collectStatement(ctx, stmt, scope) {
         ctx.skipped++;
         continue;
       }
-      const iface = decl.type ? interfaceDeclOf(ctx, decl.type) : void 0;
-      if (iface) {
-        expandInterfaceAsModuleMembers(ctx, scope, iface);
+      const ifaceName = decl.type && ts.isTypeReferenceNode(decl.type) ? typeNameString(decl.type.typeName) : void 0;
+      if (ifaceName && (ctx.interfaces.has(ifaceName) || ctx.qualifiedInterfaces.has(ifaceName) || true)) {
+        ctx.pending.push({
+          t: "iface-expand",
+          scope,
+          localName: decl.name.text,
+          typeRefName: ifaceName
+        });
+        ctx.symbols++;
+        ctx.pending.push({ t: "var", scope, name: decl.name.text, typeNode: decl.type });
+        ctx.symbols++;
         continue;
       }
       ctx.pending.push({ t: "var", scope, name: decl.name.text, typeNode: decl.type });
@@ -320,66 +367,122 @@ function collectStatement(ctx, stmt, scope) {
   ctx.skipped++;
 }
 function registerTypeDecl(ctx, scope, name, decl) {
-  if (!ctx.interfaces.has(name)) ctx.interfaces.set(name, decl);
+  const push = (map, key) => {
+    const list = map.get(key);
+    if (list) {
+      if (!list.includes(decl)) list.push(decl);
+    } else {
+      map.set(key, [decl]);
+    }
+  };
+  push(ctx.interfaces, name);
   if (ts.isClassDeclaration(decl)) return;
   const qualified = [...scope.ns, name].join(".");
-  if (qualified !== name && !ctx.qualifiedInterfaces.has(qualified)) {
-    ctx.qualifiedInterfaces.set(qualified, decl);
-  }
+  if (qualified !== name) push(ctx.qualifiedInterfaces, qualified);
 }
-function interfaceDeclOf(ctx, typeNode) {
-  if (!ts.isTypeReferenceNode(typeNode)) return void 0;
-  const name = typeNameString(typeNode.typeName);
-  const d = ctx.interfaces.get(name) ?? ctx.qualifiedInterfaces.get(name);
-  return d && ts.isInterfaceDeclaration(d) ? d : void 0;
+function interfaceDeclsOf(ctx, typeNode) {
+  const name = typeof typeNode === "string" ? typeNode : ts.isTypeReferenceNode(typeNode) ? typeNameString(typeNode.typeName) : void 0;
+  if (!name) return [];
+  const short = name.includes(".") ? name.split(".").pop() : name;
+  const keys = name === short ? [name] : [name, short];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const key of keys) {
+    for (const d of [
+      ...ctx.interfaces.get(key) ?? [],
+      ...ctx.qualifiedInterfaces.get(key) ?? []
+    ]) {
+      if (ts.isInterfaceDeclaration(d) && !seen.has(d)) {
+        seen.add(d);
+        out.push(d);
+      }
+    }
+  }
+  return out;
 }
-function expandInterfaceAsModuleMembers(ctx, scope, iface) {
-  for (const member of iface.members) {
-    if (ts.isMethodSignature(member)) {
-      const name = memberName(member);
-      if (name === void 0) continue;
-      const existing = ctx.pending.find(
-        (p) => p.t === "fn" && p.name === name && scopeKey(p.scope) === scopeKey(scope)
-      );
-      if (existing && existing.t === "fn") {
-        existing.decls.push(member);
+function expandInterfaceAsModuleMembers(ctx, scope, ifaces) {
+  for (const iface of ifaces) {
+    for (const member of iface.members) {
+      if (ts.isMethodSignature(member)) {
+        const name = memberName(member);
+        if (name === void 0) continue;
+        const existing = ctx.pending.find(
+          (p) => p.t === "fn" && p.name === name && scopeKey(p.scope) === scopeKey(scope)
+        );
+        if (existing && existing.t === "fn") {
+          existing.decls.push(member);
+          continue;
+        }
+        ctx.pending.push({ t: "fn", scope, name, decls: [member] });
+        ctx.symbols++;
         continue;
       }
-      ctx.pending.push({ t: "fn", scope, name, decls: [member] });
-      ctx.symbols++;
-      continue;
-    }
-    if (ts.isPropertySignature(member)) {
-      const name = memberName(member);
-      if (name === void 0) continue;
-      ctx.pending.push({ t: "var", scope, name, typeNode: member.type });
-      ctx.symbols++;
+      if (ts.isPropertySignature(member)) {
+        const name = memberName(member);
+        if (name === void 0) continue;
+        if (ctx.pending.some((p) => p.t === "var" && p.name === name && scopeKey(p.scope) === scopeKey(scope))) {
+          continue;
+        }
+        ctx.pending.push({ t: "var", scope, name, typeNode: member.type });
+        ctx.symbols++;
+      }
     }
   }
 }
 function registerAlias(ctx, scope, stmt) {
   const name = stmt.name.text;
-  if (!ctx.aliases.has(name)) ctx.aliases.set(name, stmt);
+  const push = (map, key) => {
+    const list = map.get(key);
+    if (list) {
+      if (!list.includes(stmt)) list.push(stmt);
+    } else {
+      map.set(key, [stmt]);
+    }
+  };
+  push(ctx.aliases, name);
   const qualified = [...scope.ns, name].join(".");
-  if (qualified !== name && !ctx.qualifiedAliases.has(qualified)) {
-    ctx.qualifiedAliases.set(qualified, stmt);
-  }
+  if (qualified !== name) push(ctx.qualifiedAliases, qualified);
 }
 function materialize(ctx) {
+  const expanded = [];
   for (const p of ctx.pending) {
+    if (p.t !== "iface-expand") {
+      expanded.push(p);
+      continue;
+    }
+    const ifaces = interfaceDeclsOf(ctx, p.typeRefName);
+    if (ifaces.length === 0) {
+      continue;
+    }
+    const before = ctx.pending.length;
+    expandInterfaceAsModuleMembers(ctx, p.scope, ifaces);
+    for (let i = before; i < ctx.pending.length; i++) {
+      const n = ctx.pending[i];
+      if (n.t === "fn" || n.t === "var") expanded.push(n);
+    }
+  }
+  ctx.pending = expanded;
+  for (const p of ctx.pending) {
+    if (p.t === "iface-expand") continue;
     const rec = recordFor(ctx, p.scope);
     if (p.t === "fn") {
       if (rec[p.name] !== void 0) continue;
-      const value = signatureToFnSig(ctx, p.decls[0]);
-      const sig = value.shape.k === "fn" ? value.shape : void 0;
-      if (sig) {
+      const sigs = p.decls.map((d) => signatureToFnSig(ctx, d));
+      const value = sigs[0];
+      const shape0 = value.shape.k === "fn" ? value.shape : void 0;
+      if (shape0 && sigs.length > 1) {
         const returns = [];
-        for (const decl of p.decls) {
-          if (!decl.type) continue;
-          const ret = mapType(ctx, decl.type, 0);
-          if (!isPlainUnknown(ret)) returns.push(ret);
+        for (const s of sigs) {
+          if (s.shape.k !== "fn") continue;
+          const ret = s.shape.returnType;
+          if (ret && !isPlainUnknown(ret)) returns.push(ret);
         }
-        sig.returnType = returns.length > 0 ? absUnion(returns) : absUnknown();
+        const withVars = returns.filter((r) => hasTypeVar(r));
+        const pool = withVars.length > 0 ? withVars : returns;
+        const mergedRet = pool.length > 0 ? absUnion(pool) : absUnknown();
+        shape0.returnType = mergedRet;
+        const rel = getFnImpl(value)?.relation;
+        if (rel) rel.returnType = mergedRet;
       }
       rec[p.name] = value;
       continue;
@@ -434,58 +537,91 @@ function memberName(node) {
   if (ts.isIdentifier(n) || ts.isStringLiteral(n) || ts.isNumericLiteral(n)) return n.text;
   return void 0;
 }
-function instanceFor(ctx, key) {
-  const cached = ctx.instanceCache.get(key);
+function instanceFor(ctx, key, typeArgs) {
+  const cacheKey = typeArgs && typeArgs.length > 0 ? `${key}::${typeArgs.length}` : key;
+  const cached = ctx.instanceCache.get(cacheKey);
   if (cached !== void 0) return cached;
-  const decl = ctx.interfaces.get(key) ?? ctx.qualifiedInterfaces.get(key);
+  const decls = interfaceDeclsOf(ctx, key);
+  const decl = decls[0];
   if (!decl) return absUnknown();
   if (ctx.expanding.has(key)) {
     return absBrand(decl.name?.text ?? key, {});
   }
   ctx.expanding.add(key);
+  const savedTp = ctx.typeParams;
+  ctx.typeParams = new Set(savedTp);
+  for (const d of decls) {
+    for (const tp of d.typeParameters ?? []) ctx.typeParams.add(tp.name.text);
+  }
   const properties = {};
   try {
-    const members = decl.members;
-    for (const member of members) {
-      const modifiers = member.modifiers;
-      if (modifiers?.some((mod) => mod.kind === ts.SyntaxKind.StaticKeyword)) continue;
-      if (ts.isPropertySignature(member) || ts.isPropertyDeclaration(member)) {
-        const name = memberName(member);
-        if (name === void 0) continue;
-        let type = member.type ? mapType(ctx, member.type, 0) : absUnknown();
-        if (member.questionToken) type = absUnion([type, absUndefLit()]);
-        properties[name] = type;
-      } else if (ts.isMethodSignature(member) || ts.isMethodDeclaration(member)) {
-        const name = memberName(member);
-        if (name === void 0 || properties[name] !== void 0) continue;
-        properties[name] = signatureToFnSig(ctx, member);
-      } else if (ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) {
-        const name = memberName(member);
-        if (name === void 0 || properties[name] !== void 0 || !member.type) continue;
-        properties[name] = mapType(ctx, member.type, 0);
+    for (const d of decls) {
+      const members = d.members;
+      for (const member of members) {
+        const modifiers = member.modifiers;
+        if (modifiers?.some((mod) => mod.kind === ts.SyntaxKind.StaticKeyword)) continue;
+        if (ts.isPropertySignature(member) || ts.isPropertyDeclaration(member)) {
+          const name = memberName(member);
+          if (name === void 0) continue;
+          let type = member.type ? mapType(ctx, member.type, 0) : absUnknown();
+          if (member.questionToken) type = absUnion([type, absUndefLit()]);
+          properties[name] = type;
+        } else if (ts.isMethodSignature(member) || ts.isMethodDeclaration(member)) {
+          const name = memberName(member);
+          if (name === void 0 || properties[name] !== void 0) continue;
+          properties[name] = signatureToFnSig(ctx, member);
+        } else if (ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) {
+          const name = memberName(member);
+          if (name === void 0 || properties[name] !== void 0 || !member.type) continue;
+          properties[name] = mapType(ctx, member.type, 0);
+        }
       }
     }
   } finally {
+    ctx.typeParams = savedTp;
     ctx.expanding.delete(key);
   }
-  const value = absBrand(decl.name?.text ?? key, properties);
-  ctx.instanceCache.set(key, value);
+  let value = absBrand(decl.name?.text ?? key, properties);
+  if (typeArgs && typeArgs.length > 0 && Object.keys(properties).length <= 40) {
+    const map = /* @__PURE__ */ new Map();
+    const tps = decls[0].typeParameters ?? [];
+    tps.forEach((tp, i) => {
+      const arg = typeArgs[i];
+      if (arg) map.set(tp.name.text, arg);
+    });
+    if (map.size > 0) value = substAbs(value, map);
+  }
+  ctx.instanceCache.set(cacheKey, value);
   return value;
 }
 function signatureToFnSig(ctx, sig) {
-  const paramTypes = sig.parameters.map((param) => {
-    let type;
-    if (param.dotDotDotToken) {
-      const inner = param.type && ts.isArrayTypeNode(param.type) ? param.type.elementType : param.type;
-      type = inner ? absArr(mapType(ctx, inner, 0)) : absUnknown();
-    } else {
-      type = param.type ? mapType(ctx, param.type, 0) : absUnknown();
-    }
-    if (param.questionToken && !param.dotDotDotToken) type = absUnion([type, absUndefLit()]);
-    return type;
-  });
-  const returnType = sig.type ? mapType(ctx, sig.type, 0) : absUnknown();
-  return absFnSig(paramTypes, returnType);
+  const savedTp = ctx.typeParams;
+  ctx.typeParams = new Set(savedTp);
+  for (const tp of sig.typeParameters ?? []) {
+    ctx.typeParams.add(tp.name.text);
+  }
+  try {
+    const paramTypes = sig.parameters.map((param) => {
+      let type;
+      if (param.dotDotDotToken) {
+        const inner = param.type && ts.isArrayTypeNode(param.type) ? param.type.elementType : param.type;
+        type = inner ? absArr(mapType(ctx, inner, 0)) : absUnknown();
+      } else {
+        type = param.type ? mapType(ctx, param.type, 0) : absUnknown();
+      }
+      if (param.questionToken && !param.dotDotDotToken) type = absUnion([type, absUndefLit()]);
+      return type;
+    });
+    const returnType = sig.type ? mapType(ctx, sig.type, 0) : absUnknown();
+    const cond = ctx.pendingCond;
+    ctx.pendingCond = void 0;
+    return absFnSig(paramTypes, returnType, cond ? {
+      inferFrom: { fromVar: cond.fromVar, via: cond.via, inferVar: cond.inferVar },
+      condFallback: cond.fallback
+    } : void 0);
+  } finally {
+    ctx.typeParams = savedTp;
+  }
 }
 function mapTypeMembers(ctx, members, depth) {
   const properties = {};
@@ -507,22 +643,163 @@ function mapTypeMembers(ctx, members, depth) {
 function mapTypeRef(ctx, node, depth) {
   const name = typeNameString(node.typeName);
   const args = node.typeArguments ?? [];
+  if (ctx.typeParams.has(name) && args.length === 0) {
+    return typeVarAbs(name);
+  }
   if ((name === "Array" || name === "ReadonlyArray") && args.length >= 1) {
     return absArr(mapType(ctx, args[0], depth));
   }
+  if ((name === "List" || name === "ArrayLike" || name === "Collection" || name === "Many" || name === "NumericDictionary" || name === "Dictionary") && args.length >= 1) {
+    return absArr(mapType(ctx, args[0], depth));
+  }
   if (name === "Promise" && args.length >= 1) {
     return absPromise(mapType(ctx, args[0], depth));
   }
+  if ((name === "Map" || name === "ReadonlyMap" || name === "WeakMap") && args.length >= 2) {
+    return absMapType(name, mapType(ctx, args[0], depth), mapType(ctx, args[1], depth));
+  }
+  if ((name === "Set" || name === "ReadonlySet" || name === "WeakSet") && args.length >= 1) {
+    return absSetType(name, mapType(ctx, args[0], depth));
+  }
   if (name === "Record") {
     return absObj({});
   }
   if (ctx.interfaces.has(name) || ctx.qualifiedInterfaces.has(name)) {
-    return instanceFor(ctx, name);
+    return instanceFor(ctx, name, args.map((a) => mapType(ctx, a, depth)));
   }
-  const alias = ctx.aliases.get(name) ?? ctx.qualifiedAliases.get(name);
+  const aliases = ctx.aliases.get(name) ?? ctx.qualifiedAliases.get(name) ?? [];
+  const alias = aliases[0];
   if (alias) return mapType(ctx, alias.type, depth + 1);
   return absUnknown();
 }
+function collectInferNames(node, out = /* @__PURE__ */ new Set()) {
+  const visit = (n) => {
+    if (!n) return;
+    if (ts.isInferTypeNode(n)) {
+      out.add(n.typeParameter.name.text);
+      visit(n.typeParameter.constraint);
+      return;
+    }
+    n.forEachChild(visit);
+  };
+  visit(node);
+  return out;
+}
+function absExtends(check, ext) {
+  if (check.term?.op === "var") return "unknown";
+  if (ext.term?.op === "lit" && (ext.term.value === null || ext.term.value === void 0)) {
+    if (check.term?.op === "lit") {
+      return check.term.value === ext.term.value ? "true" : "false";
+    }
+    if (check.shape.k === "prim" || check.shape.k === "arr" || check.shape.k === "obj" || check.shape.k === "fn" || check.shape.k === "brand" || check.shape.k === "eff") {
+      return "false";
+    }
+    return "unknown";
+  }
+  if (ext.shape.k === "unknown") return "true";
+  if (ext.shape.k === "any") return "true";
+  const cs = check.shape;
+  const es = ext.shape;
+  if (es.k === "prim" && cs.k === "prim") {
+    return cs.type === es.type ? "true" : "false";
+  }
+  if (es.k === "sum") {
+    const flags = es.members.map((m) => absExtends(check, m));
+    if (flags.some((f) => f === "true")) return "true";
+    if (flags.every((f) => f === "false")) return "false";
+    return "unknown";
+  }
+  if (cs.k === "sum") {
+    const flags = cs.members.map((m) => absExtends(m, ext));
+    if (flags.every((f) => f === "true")) return "true";
+    if (flags.every((f) => f === "false")) return "false";
+    return "unknown";
+  }
+  if (cs.k === "arr" && es.k === "arr") {
+    return absExtends(cs.element, es.element);
+  }
+  if (cs.k === "eff" && es.k === "eff" && cs.eff === es.eff) {
+    return absExtends(cs.inner, es.inner);
+  }
+  if (cs.k === "brand" && es.k === "brand") {
+    return cs.name === es.name ? "true" : "false";
+  }
+  if (cs.k === "never") return "true";
+  return "unknown";
+}
+function matchExtendsInfer(pattern, actual, inferMap, depth = 0) {
+  if (depth > 6) return "unknown";
+  if (ts.isInferTypeNode(pattern)) {
+    const name = pattern.typeParameter.name.text;
+    if (!inferMap.has(name)) inferMap.set(name, actual);
+    return "true";
+  }
+  if (ts.isArrayTypeNode(pattern) && actual.shape.k === "arr") {
+    return matchExtendsInfer(pattern.elementType, actual.shape.element, inferMap, depth + 1);
+  }
+  if (ts.isTypeReferenceNode(pattern)) {
+    const name = typeNameString(pattern.typeName);
+    const args = pattern.typeArguments ?? [];
+    if ((name === "Array" || name === "ReadonlyArray" || name === "List" || name === "ArrayLike") && args[0] && actual.shape.k === "arr") {
+      return matchExtendsInfer(args[0], actual.shape.element, inferMap, depth + 1);
+    }
+    if (name === "Promise" && args[0] && actual.shape.k === "eff" && actual.shape.eff === "promise") {
+      return matchExtendsInfer(args[0], actual.shape.inner, inferMap, depth + 1);
+    }
+    return "unknown";
+  }
+  if (ts.isUnionTypeNode(pattern)) {
+    const flags = pattern.types.map((t) => matchExtendsInfer(t, actual, inferMap, depth + 1));
+    if (flags.some((f) => f === "true")) return "true";
+    if (flags.every((f) => f === "false")) return "false";
+    return "unknown";
+  }
+  return "unknown";
+}
+function mapConditionalType(ctx, node, depth) {
+  const inferMap = /* @__PURE__ */ new Map();
+  const inferNames = collectInferNames(node.extendsType);
+  const check = mapType(ctx, node.checkType, depth + 1);
+  const astMatch = matchExtendsInfer(node.extendsType, check, inferMap);
+  const extAbs = mapType(ctx, node.extendsType, depth + 1);
+  const absMatch = astMatch !== "unknown" ? astMatch : absExtends(check, extAbs);
+  const condMeta = analyzeCondPattern(ctx, node, check);
+  const savedTp = ctx.typeParams;
+  ctx.typeParams = new Set(savedTp);
+  for (const n of inferNames) ctx.typeParams.add(n);
+  try {
+    const trueAbs = inferMap.size > 0 ? substAbs(mapType(ctx, node.trueType, depth + 1), inferMap) : mapType(ctx, node.trueType, depth + 1);
+    const falseAbs = mapType(ctx, node.falseType, depth + 1);
+    if (absMatch === "true") return trueAbs;
+    if (absMatch === "false") return falseAbs;
+    if (condMeta && check.term?.op === "var") {
+      ctx.pendingCond = { ...condMeta, fallback: falseAbs };
+      return typeVarAbs(condMeta.inferVar);
+    }
+    return absUnion([trueAbs, falseAbs]);
+  } finally {
+    ctx.typeParams = savedTp;
+  }
+}
+function analyzeCondPattern(_ctx, node, check) {
+  if (check.term?.op !== "var") return void 0;
+  const fromVar = check.term.id;
+  const ext = node.extendsType;
+  const names = collectInferNames(ext);
+  const inferVar = [...names][0];
+  if (!inferVar) return void 0;
+  if (ts.isArrayTypeNode(ext)) {
+    return { fromVar, via: "arr", inferVar };
+  }
+  if (ts.isTypeReferenceNode(ext)) {
+    const n = typeNameString(ext.typeName);
+    if (n === "Promise" || n === "PromiseLike") return { fromVar, via: "promise", inferVar };
+    if (n === "Array" || n === "ReadonlyArray" || n === "List" || n === "ArrayLike") {
+      return { fromVar, via: "arr", inferVar };
+    }
+  }
+  return void 0;
+}
 function mapType(ctx, node, depth) {
   if (!node || depth > MAX_ALIAS_DEPTH) return absUnknown();
   if (ts.isParenthesizedTypeNode(node)) return mapType(ctx, node.type, depth);
@@ -536,7 +813,12 @@ function mapType(ctx, node, depth) {
     return absUnknown();
   }
   if (ts.isUnionTypeNode(node)) {
-    return absUnion(node.types.map((t) => mapType(ctx, t, depth)));
+    const members = node.types.map((t) => mapType(ctx, t, depth));
+    const hasLit = members.some((m) => m.term?.op === "lit");
+    if (hasLit && members.length > 1) {
+      return absExact({ k: "sum", members });
+    }
+    return absUnion(members);
   }
   if (ts.isIntersectionTypeNode(node)) {
     const members = node.types.map((t) => mapType(ctx, t, depth));
@@ -558,6 +840,7 @@ function mapType(ctx, node, depth) {
     if (ts.isNumericLiteral(lit)) return absLit(Number(lit.text));
     if (lit.kind === ts.SyntaxKind.TrueKeyword) return absLit(true);
     if (lit.kind === ts.SyntaxKind.FalseKeyword) return absLit(false);
+    if (lit.kind === ts.SyntaxKind.NullKeyword) return absNullLit();
     if (ts.isPrefixUnaryExpression(lit) && lit.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(lit.operand)) {
       return absLit(-Number(lit.operand.text));
     }
@@ -580,6 +863,12 @@ function mapType(ctx, node, depth) {
   if (ts.isTypeOperatorNode(node)) {
     return node.operator === ts.SyntaxKind.ReadonlyKeyword ? mapType(ctx, node.type, depth) : absUnknown();
   }
+  if (ts.isConditionalTypeNode(node)) {
+    return mapConditionalType(ctx, node, depth);
+  }
+  if (ts.isInferTypeNode(node)) {
+    return typeVarAbs(node.typeParameter.name.text);
+  }
   switch (node.kind) {
     case ts.SyntaxKind.StringKeyword:
       return absPrim("string");
@@ -684,7 +973,1372 @@ function emitAbs(a, expanding) {
       return "absUnknown";
   }
 }
+
+// src/dts-contract-draft.ts
+import { readFileSync as readFileSync2, existsSync, statSync as statSync2, readdirSync } from "fs";
+import { basename, dirname, join } from "path";
+import ts2 from "typescript";
+var BUILDERS = [
+  "fn",
+  "number",
+  "string",
+  "boolean",
+  "any",
+  "shape",
+  "array",
+  "lit",
+  "union"
+];
+function keywordDsl(node) {
+  switch (node.kind) {
+    case ts2.SyntaxKind.NumberKeyword:
+      return "number()";
+    case ts2.SyntaxKind.StringKeyword:
+      return "string()";
+    case ts2.SyntaxKind.BooleanKeyword:
+      return "boolean()";
+    case ts2.SyntaxKind.AnyKeyword:
+    case ts2.SyntaxKind.UnknownKeyword:
+    case ts2.SyntaxKind.VoidKeyword:
+    case ts2.SyntaxKind.UndefinedKeyword:
+    case ts2.SyntaxKind.NullKeyword:
+    case ts2.SyntaxKind.ObjectKeyword:
+    case ts2.SyntaxKind.NeverKeyword:
+      return "any()";
+    case ts2.SyntaxKind.BigIntKeyword:
+    case ts2.SyntaxKind.SymbolKeyword:
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+function litDsl(node) {
+  const lit = node.literal;
+  if (ts2.isStringLiteral(lit)) return `lit(${JSON.stringify(lit.text)})`;
+  if (ts2.isNumericLiteral(lit)) return `lit(${lit.text})`;
+  if (lit.kind === ts2.SyntaxKind.TrueKeyword) return "lit(true)";
+  if (lit.kind === ts2.SyntaxKind.FalseKeyword) return "lit(false)";
+  return void 0;
+}
+function typeRefName(node) {
+  const n = node.typeName;
+  if (ts2.isIdentifier(n)) return n.text;
+  if (ts2.isQualifiedName(n)) {
+    const parts = [];
+    let cur = n;
+    while (ts2.isQualifiedName(cur)) {
+      parts.unshift(cur.right.text);
+      cur = cur.left;
+    }
+    if (ts2.isIdentifier(cur)) parts.unshift(cur.text);
+    return parts.join(".");
+  }
+  return "?";
+}
+function typeToDsl(node, depth = 0) {
+  if (!node || depth > 6) return "any()";
+  const kw = keywordDsl(node);
+  if (kw !== void 0) return kw;
+  if (ts2.isLiteralTypeNode(node)) {
+    return litDsl(node) ?? "any()";
+  }
+  if (ts2.isArrayTypeNode(node)) {
+    const el = typeToDsl(node.elementType, depth + 1) ?? "any()";
+    return `array(${el})`;
+  }
+  if (ts2.isUnionTypeNode(node)) {
+    const parts = node.types.map((t) => typeToDsl(t, depth + 1) ?? "any()");
+    if (parts.length === 0) return "any()";
+    if (parts.length === 1) return parts[0];
+    return `union(${parts.join(", ")})`;
+  }
+  if (ts2.isParenthesizedTypeNode(node)) {
+    return typeToDsl(node.type, depth + 1);
+  }
+  if (ts2.isTypeLiteralNode(node)) {
+    const fields = [];
+    for (const m of node.members) {
+      if (!ts2.isPropertySignature(m)) continue;
+      const key = m.name && (ts2.isIdentifier(m.name) || ts2.isStringLiteral(m.name)) ? ts2.isIdentifier(m.name) ? m.name.text : m.name.text : void 0;
+      if (!key) continue;
+      const optional = m.questionToken ? true : false;
+      const val = typeToDsl(m.type, depth + 1) ?? "any()";
+      fields.push(optional ? `${key}: ${val}.optional()` : `${key}: ${val}`);
+    }
+    return fields.length === 0 ? "shape({})" : `shape({ ${fields.join(", ")} })`;
+  }
+  if (ts2.isFunctionTypeNode(node) || ts2.isConstructorTypeNode(node)) {
+    return fnSignatureDsl(node.parameters, node.type, depth);
+  }
+  if (ts2.isTypeReferenceNode(node)) {
+    const name = typeRefName(node);
+    const args = node.typeArguments ?? [];
+    if (name === "Array" || name === "ReadonlyArray" || name === "readonly") {
+      const el = args[0] ? typeToDsl(args[0], depth + 1) : "any()";
+      return `array(${el ?? "any()"})`;
+    }
+    if (name === "Promise") {
+      return args[0] ? typeToDsl(args[0], depth + 1) : "any()";
+    }
+    if (name === "Record") {
+      const val = args[1] ? typeToDsl(args[1], depth + 1) : "any()";
+      return `shape({}) /* open Record \u2192 ${val ?? "any()"} */`;
+    }
+    if (name === "Partial" && args[0]) {
+      const inner = typeToDsl(args[0], depth + 1);
+      return inner ?? "any()";
+    }
+    return void 0;
+  }
+  if (ts2.isExpressionWithTypeArguments(node)) {
+    return void 0;
+  }
+  return void 0;
+}
+function fnSignatureDsl(params, ret, depth) {
+  const fields = [];
+  const notes = [];
+  params.forEach((p, i) => {
+    let name;
+    if (p.name && ts2.isIdentifier(p.name)) name = p.name.text;
+    else name = `p${i}`;
+    if (p.dotDotDotToken) {
+      notes.push(`${name}: rest \u2014 array()`);
+      fields.push(`${name}: array(any())`);
+      return;
+    }
+    const optional = Boolean(p.questionToken) || p.initializer;
+    let dsl = typeToDsl(p.type, depth + 1);
+    if (dsl === void 0) {
+      notes.push(`${name}: unmodeled type \u2192 any()`);
+      dsl = "any()";
+    }
+    fields.push(optional ? `${name}: ${dsl}.optional()` : `${name}: ${dsl}`);
+  });
+  let retDsl = typeToDsl(ret, depth + 1);
+  if (retDsl === void 0) {
+    notes.push(`returns: unmodeled \u2192 any()`);
+    retDsl = "any()";
+  }
+  const obj = fields.length === 0 ? "{}" : `{ ${fields.join(", ")} }`;
+  return `fn(${obj}, ${retDsl})`;
+}
+function pickName(decl) {
+  return decl.name && ts2.isIdentifier(decl.name) ? decl.name.text : void 0;
+}
+function collectExports(sourceFile) {
+  const out = [];
+  const push = (e) => {
+    out.push(e);
+  };
+  for (const stmt of sourceFile.statements) {
+    if ((ts2.isFunctionDeclaration(stmt) || ts2.isMethodSignature(stmt)) && stmt.modifiers?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword)) {
+      const name = pickName(stmt);
+      if (!name) continue;
+      const fn = stmt;
+      const dsl = fnSignatureDsl(fn.parameters, fn.type, 0);
+      push({ name, dsl, kind: "function" });
+      continue;
+    }
+    if (ts2.isFunctionDeclaration(stmt) && pickName(stmt)) {
+      const isExport = stmt.modifiers?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword) ?? false;
+      if (!isExport) continue;
+      const name = pickName(stmt);
+      push({ name, dsl: fnSignatureDsl(stmt.parameters, stmt.type, 0), kind: "function" });
+      continue;
+    }
+    if (ts2.isVariableStatement(stmt)) {
+      const isExport = stmt.modifiers?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword) ?? false;
+      if (!isExport) continue;
+      for (const d of stmt.declarationList.declarations) {
+        const name = pickName(d);
+        if (!name) continue;
+        const dsl = typeToDsl(d.type, 0);
+        if (dsl === void 0) {
+          push({ name, note: "unmodeled type", kind: "value" });
+        } else if (dsl.startsWith("fn(")) {
+          push({ name, dsl, kind: "function" });
+        } else {
+          push({ name, dsl, kind: "value" });
+        }
+      }
+      continue;
+    }
+    if (ts2.isClassDeclaration(stmt)) {
+      const isExport = stmt.modifiers?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword) ?? false;
+      if (!isExport) continue;
+      const name = pickName(stmt);
+      if (!name) {
+        push({ name: "default", note: "anonymous class", kind: "class" });
+        continue;
+      }
+      let anyMethod = false;
+      for (const m of stmt.members) {
+        if (ts2.isMethodDeclaration(m) || ts2.isMethodSignature(m)) {
+          const mname = pickName(m);
+          if (!mname) continue;
+          anyMethod = true;
+          push({
+            name: `${name}.${mname}`,
+            dsl: fnSignatureDsl(m.parameters, m.type, 0),
+            kind: "function"
+          });
+        }
+      }
+      if (!anyMethod) {
+        push({ name, note: "class without public methods projected", kind: "class" });
+      }
+      continue;
+    }
+    if (ts2.isExportAssignment(stmt)) {
+      push({ name: "default", note: "export assignment \u2014 bind via sidecar default", kind: "other" });
+      continue;
+    }
+    if (ts2.isInterfaceDeclaration(stmt) || ts2.isTypeAliasDeclaration(stmt)) {
+      continue;
+    }
+  }
+  return out;
+}
+function draftExportName(name) {
+  return name.includes(".") ? name.replace(/\./g, "_") : name;
+}
+function formatDtsContractDraft(label, files, exports) {
+  const draftable = exports.filter((e) => e.dsl !== void 0);
+  const used = /* @__PURE__ */ new Set(["fn"]);
+  for (const e of draftable) {
+    for (const b of BUILDERS) {
+      if (new RegExp(`\\b${b}\\b`).test(e.dsl)) used.add(b);
+    }
+  }
+  if (draftable.some((e) => /\bany\s*\(/.test(e.dsl))) used.add("any");
+  const importList = BUILDERS.filter((b) => used.has(b)).join(", ");
+  const lines = [
+    "// @nudo:draft",
+    `// Generated by \`nudo contract --from-dts\` from ${label}`,
+    `// Sources: ${files.map((f) => basename(f)).join(", ")}`,
+    "//",
+    "// Reverse-engineered from TypeScript declarations \u2014 NOT a sidecar contract.",
+    "// This file is never loaded for check. Review each export, then copy it",
+    "// into <target>.nudo.js to accept (that is when obligations go live).",
+    "//",
+    "// After accept: strengthen with Pred builders (number().gt(0) \u2026) \u2014",
+    "// dts cannot express algebraic implications (x>0 \u21D2 x+1>1).",
+    "",
+    `import { ${importList} } from "@nudojs/core";`,
+    ""
+  ];
+  if (draftable.length === 0) {
+    lines.push("// (no projectable exports)");
+    lines.push("");
+  }
+  for (const e of exports) {
+    if (e.dsl === void 0) {
+      lines.push(`// ${e.name} \u2014 skipped (${e.note ?? "unmodeled"})`);
+      continue;
+    }
+    if (e.note) lines.push(`// ${e.name} \u2014 ${e.note}`);
+    else lines.push(`// ${e.name} \u2014 from TypeScript`);
+    lines.push(`export const ${draftExportName(e.name)} = ${e.dsl};`);
+    if (e.name.includes(".")) {
+      lines.push(`//   sidecar key may also be written as \`${e.name}\``);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function readDtsFiles(paths, maxFiles = 16) {
+  const out = [];
+  const walk = (dir, depth) => {
+    if (depth > 6 || out.length >= maxFiles * 3) return;
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (name === "node_modules" || name === "test" || name === "__tests__") continue;
+      const p = join(dir, name);
+      let st;
+      try {
+        st = statSync2(p);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) walk(p, depth + 1);
+      else if (name.endsWith(".d.ts") && !name.endsWith(".d.ts.map")) out.push(p);
+    }
+  };
+  for (const p of paths) {
+    if (!existsSync(p)) continue;
+    const st = statSync2(p);
+    if (st.isDirectory()) walk(p, 0);
+    else if (/\.d\.ts$/.test(p) || /\.(m)?ts$/.test(p)) {
+      if (!p.endsWith(".d.ts.map")) out.push(p);
+    }
+  }
+  return out.slice(0, maxFiles);
+}
+function dtsToContractDraft(dtsFiles, label) {
+  const files = dtsFiles.filter((f) => existsSync(f));
+  const exports = [];
+  let skippedFiles = 0;
+  for (const file of files) {
+    let content;
+    try {
+      content = readFileSync2(file, "utf8");
+    } catch {
+      skippedFiles++;
+      continue;
+    }
+    const sf = ts2.createSourceFile(file, content, ts2.ScriptTarget.Latest, true);
+    for (const e of collectExports(sf)) {
+      if (exports.some((x) => x.name === e.name && x.dsl)) continue;
+      exports.push(e);
+    }
+  }
+  const name = label ?? (files[0] ? basename(files[0]).replace(/\.d\.ts$/, "") : "dts");
+  const draftSource = formatDtsContractDraft(name, files, exports);
+  return {
+    label: name,
+    files,
+    exports,
+    draftSource,
+    stats: {
+      files: files.length - skippedFiles,
+      exports: exports.filter((e) => e.dsl !== void 0).length,
+      skipped: exports.filter((e) => e.dsl === void 0).length + skippedFiles
+    }
+  };
+}
+function dtsPathToContractDraft(path, label) {
+  const files = readDtsFiles([path]);
+  return dtsToContractDraft(files, label ?? basename(path).replace(/\.d\.ts$/, ""));
+}
+
+// src/harvest-package.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join2, resolve, dirname as dirname2, basename as basename2 } from "path";
+import { formatShape as formatShape2 } from "@nudojs/core";
+function resolvePackageRoot(pkg, fromDir = process.cwd()) {
+  let dir = resolve(fromDir);
+  const bare = pkg.replace(/^@/, "").replace(/\//g, "__");
+  for (let i = 0; i < 8; i++) {
+    const typesPath = join2(dir, "node_modules", "@types", bare);
+    if (existsSync2(typesPath)) return typesPath;
+    const pkgPath = join2(dir, "node_modules", pkg);
+    if (existsSync2(pkgPath)) return pkgPath;
+    const parent = resolve(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "test", "tests", "docs", "doc", "examples", "__tests__"]);
+var MAX_DTS_BYTES = 15e5;
+function dtsPriority(p, root) {
+  const base = basename2(p);
+  const rel = p.slice(root.length);
+  if (base === "index.d.ts") return 0;
+  if (base === "index.d.mts") return 1;
+  if (rel.includes("/types/") && base === "index.d.ts") return 2;
+  if (base.endsWith(".d.ts") && !base.includes(".")) return 3;
+  return 10;
+}
+function collectDtsFiles(root, maxFiles = 8) {
+  const out = [];
+  const walk = (dir) => {
+    if (out.length >= maxFiles * 3) return;
+    let entries;
+    try {
+      entries = readdirSync2(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (out.length >= maxFiles * 3) return;
+      if (SKIP_DIRS.has(name)) continue;
+      const p = join2(dir, name);
+      let st;
+      try {
+        st = statSync3(p);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) walk(p);
+      else if (name.endsWith(".d.ts") && !name.endsWith(".d.ts.map")) {
+        if (st.size > MAX_DTS_BYTES) continue;
+        out.push(p);
+      }
+    }
+  };
+  walk(root);
+  out.sort((a, b) => dtsPriority(a, root) - dtsPriority(b, root) || a.length - b.length);
+  return out.slice(0, maxFiles);
+}
+function entryDtsFromPackageJson(root) {
+  const pj = join2(root, "package.json");
+  if (!existsSync2(pj)) return void 0;
+  try {
+    const raw = JSON.parse(readFileSync3(pj, "utf8"));
+    const entry = raw.types ?? raw.typings;
+    if (typeof entry === "string" && entry.endsWith(".d.ts")) {
+      const p = resolve(root, entry);
+      if (existsSync2(p)) {
+        const st = statSync3(p);
+        if (st.size <= MAX_DTS_BYTES) return p;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function collectDtsFromEntry(entry, maxFiles = 200) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [entry];
+  const REFERENCE_PATH_REGEX = /<reference\s+path=["']([^"']+)["']\s*\/>/g;
+  const RELATIVE_FROM_REGEX = /\bfrom\s+["'](\.[^"']+)["']/g;
+  while (queue.length > 0 && files.length < maxFiles) {
+    const current = queue.shift();
+    if (seen.has(current) || !existsSync2(current)) continue;
+    seen.add(current);
+    if (!current.endsWith(".d.ts")) continue;
+    files.push(current);
+    let text;
+    try {
+      text = readFileSync3(current, "utf-8");
+    } catch {
+      continue;
+    }
+    const dir = dirname2(current);
+    for (const match of text.matchAll(REFERENCE_PATH_REGEX)) {
+      queue.push(resolve(dir, match[1]));
+    }
+    for (const match of text.matchAll(RELATIVE_FROM_REGEX)) {
+      const base = resolve(dir, match[1]);
+      for (const candidate of [`${base}.d.ts`, join2(base, "index.d.ts")]) {
+        if (existsSync2(candidate)) {
+          queue.push(candidate);
+          break;
+        }
+      }
+    }
+  }
+  return files;
+}
+function harvestPackage(pkg, fromDir, maxFiles = 24) {
+  const root = resolvePackageRoot(pkg, fromDir);
+  if (!root) return { error: `package not found: ${pkg}` };
+  const entry = entryDtsFromPackageJson(root) ?? join2(root, "index.d.ts");
+  let dtsFiles = existsSync2(entry) ? collectDtsFromEntry(entry, maxFiles) : [];
+  if (dtsFiles.length === 0) {
+    const collected = collectDtsFiles(root, maxFiles);
+    dtsFiles = entry && existsSync2(entry) && !collected.includes(entry) ? [entry, ...collected.filter((f) => f !== entry)].slice(0, maxFiles) : collected;
+  }
+  if (dtsFiles.length === 0) {
+    return { error: `no .d.ts under ${root}` };
+  }
+  const env = harvestDts(dtsFiles);
+  return { pkg, root, dtsFiles, env };
+}
+function formatHarvestSummary(h) {
+  const lines = [];
+  lines.push(`${h.pkg}: ${h.dtsFiles.length} d.ts, ${h.env.stats.symbols} symbols`);
+  const mods = Object.keys(h.env.modules);
+  for (const m of mods.slice(0, 5)) {
+    const exports = h.env.modules[m];
+    const names = Object.keys(exports).slice(0, 12);
+    lines.push(`  module "${m}": ${names.join(", ")}${Object.keys(exports).length > 12 ? "\u2026" : ""}`);
+  }
+  if (mods.length > 5) lines.push(`  \u2026 ${mods.length - 5} more modules`);
+  return lines.join("\n");
+}
+function lookupHarvested(h, moduleName, exportName) {
+  const mod = h.env.modules[moduleName];
+  const a = mod?.[exportName] ?? h.env.globals[exportName];
+  if (!a) return void 0;
+  return formatShape2(a);
+}
+
+// src/harvest-auto.ts
+import { parse } from "@nudojs/parser";
+
+// src/collect-specs.ts
+import { foldStaticStringExpr } from "@nudojs/core";
+function collectDependencySpecs(ast) {
+  const specs = [];
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ImportDeclaration") {
+      specs.push(stmt.source.value);
+    }
+    if (stmt.type === "ExportNamedDeclaration" && stmt.source) {
+      specs.push(stmt.source.value);
+    }
+    if (stmt.type === "ExportAllDeclaration" && stmt.source) {
+      specs.push(stmt.source.value);
+    }
+    collectRequires(stmt, specs);
+  }
+  return specs;
+}
+function collectRequires(node, out) {
+  const visit = (n) => {
+    if (!n || typeof n !== "object") return;
+    const obj = n;
+    if (obj.type === "CallExpression" && obj.callee) {
+      const c = obj.callee;
+      let spec;
+      if (c.type === "Identifier" && c.name === "require") {
+        spec = foldStaticStringExpr(obj.arguments?.[0]);
+      } else if (c.type === "MemberExpression" && !c.computed && c.object?.type === "Identifier" && c.object.name === "require" && c.property?.type === "Identifier" && c.property.name === "resolve") {
+        spec = foldStaticStringExpr(obj.arguments?.[0]);
+      }
+      if (spec !== void 0) out.push(spec);
+    }
+    for (const key of Object.keys(obj)) {
+      if (key === "loc" || key === "start" || key === "end") continue;
+      const v = obj[key];
+      if (Array.isArray(v)) v.forEach(visit);
+      else if (v && typeof v === "object") visit(v);
+    }
+  };
+  visit(node);
+}
+
+// src/harvest-disk.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join3, dirname as dirname3 } from "path";
+
+// src/harvest-json.ts
+import { createHash } from "crypto";
+import {
+  abs,
+  confJoin,
+  relationFn as relationFn2,
+  getFnImpl as getFnImpl2
+} from "@nudojs/core";
+var HARVEST_DISK_ABI = "nudo-harvest-disk-v7";
+function sha256Hex(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+function absToHarvestSig(a) {
+  if (a.term?.op === "var") {
+    return { k: "tvar", name: a.term.id };
+  }
+  const s = a.shape;
+  switch (s.k) {
+    case "prim":
+      return { k: "prim", type: s.type };
+    case "unknown":
+      return { k: "unknown" };
+    case "any":
+      return { k: "any" };
+    case "never":
+      return { k: "never" };
+    case "arr":
+      return { k: "arr", element: absToHarvestSig(s.element) };
+    case "tuple":
+      return { k: "tuple", elements: s.elements.map(absToHarvestSig) };
+    case "obj": {
+      const slots = {};
+      for (const [key, slot] of Object.entries(s.slots)) {
+        slots[key] = {
+          v: absToHarvestSig(slot.value),
+          ...slot.optional ? { opt: true } : {}
+        };
+      }
+      return { k: "obj", slots };
+    }
+    case "fn": {
+      const rel = getFnImpl2(a)?.relation;
+      const pts = rel?.paramTypes ?? s.paramTypes ?? s.params.map(() => ({ shape: { k: "unknown" }, conf: "mock" }));
+      const paramTypes = pts.map(absToHarvestSig);
+      const retSrc = rel?.returnType ?? s.returnType ?? { shape: { k: "unknown" }, conf: "mock" };
+      return {
+        k: "fn",
+        params: s.params,
+        paramTypes,
+        returns: absToHarvestSig(retSrc)
+      };
+    }
+    case "sum":
+      return { k: "sum", members: s.members.map(absToHarvestSig) };
+    case "eff":
+      return {
+        k: s.eff === "generator" ? "generator" : "promise",
+        value: absToHarvestSig(s.inner)
+      };
+    case "brand":
+      return { k: "brand", name: s.name, shape: absToHarvestSig(s.shape) };
+    default:
+      return { k: "unknown" };
+  }
+}
+function harvestSigToAbs(sig) {
+  const mark = (a) => {
+    a.conf = confJoin(a.conf, "mock");
+    return a;
+  };
+  switch (sig.k) {
+    case "prim":
+      return mark(
+        abs(
+          { k: "prim", type: sig.type },
+          void 0,
+          void 0,
+          "mock"
+        )
+      );
+    case "unknown":
+      return mark(abs({ k: "unknown" }, void 0, void 0, "mock"));
+    case "any":
+      return mark(abs({ k: "any" }, void 0, void 0, "mock"));
+    case "never":
+      return mark(abs({ k: "never" }, void 0, void 0, "mock"));
+    case "lit": {
+      const t = typeof sig.value === "number" ? "number" : typeof sig.value === "string" ? "string" : typeof sig.value === "boolean" ? "boolean" : typeof sig.value === "bigint" ? "bigint" : null;
+      if (sig.value === null || t === null) {
+        return mark(
+          abs({ k: "unknown" }, { op: "lit", value: sig.value }, void 0, "mock")
+        );
+      }
+      return mark(
+        abs(
+          { k: "prim", type: t },
+          { op: "lit", value: sig.value },
+          void 0,
+          "mock"
+        )
+      );
+    }
+    case "arr":
+      return mark(abs({ k: "arr", element: harvestSigToAbs(sig.element) }, void 0, void 0, "mock"));
+    case "tuple":
+      return mark(
+        abs({ k: "tuple", elements: sig.elements.map(harvestSigToAbs) }, void 0, void 0, "mock")
+      );
+    case "obj": {
+      const slots = {};
+      for (const [key, slot] of Object.entries(sig.slots)) {
+        slots[key] = {
+          value: harvestSigToAbs(slot.v),
+          ...slot.opt ? { optional: true } : {}
+        };
+      }
+      return mark(abs({ k: "obj", slots }, void 0, void 0, "mock"));
+    }
+    case "tvar":
+      return mark(abs({ k: "any" }, { op: "var", id: sig.name }, void 0, "mock"));
+    case "fn": {
+      const paramTypes = sig.paramTypes.map(harvestSigToAbs);
+      const returnType = harvestSigToAbs(sig.returns);
+      return mark(
+        relationFn2(paramTypes, returnType, {
+          params: sig.params,
+          conf: "mock"
+        })
+      );
+    }
+    case "sum":
+      return mark(
+        abs({ k: "sum", members: sig.members.map(harvestSigToAbs) }, void 0, void 0, "mock")
+      );
+    case "promise":
+    case "generator":
+      return mark(
+        abs(
+          {
+            k: "eff",
+            eff: sig.k === "generator" ? "generator" : "promise",
+            inner: harvestSigToAbs(sig.value)
+          },
+          void 0,
+          void 0,
+          "mock"
+        )
+      );
+    case "brand":
+      return mark(
+        abs(
+          { k: "brand", name: sig.name, shape: harvestSigToAbs(sig.shape) },
+          void 0,
+          void 0,
+          "mock"
+        )
+      );
+    default:
+      return mark(abs({ k: "unknown" }, void 0, void 0, "mock"));
+  }
+}
+function serializeHarvestJson(pkg, env, meta) {
+  const modules = {};
+  for (const [mod, rec] of Object.entries(env.modules)) {
+    const named = {};
+    for (const [k, v] of Object.entries(rec)) named[k] = absToHarvestSig(v);
+    modules[mod] = named;
+  }
+  const globals = {};
+  for (const [k, v] of Object.entries(env.globals)) globals[k] = absToHarvestSig(v);
+  return {
+    v: 1,
+    pkg,
+    ...meta.pkgVersion ? { pkgVersion: meta.pkgVersion } : {},
+    knobs: { maxFiles: meta.maxFiles, abi: HARVEST_DISK_ABI },
+    dtsHash: meta.dtsHash,
+    modules,
+    globals,
+    stats: env.stats
+  };
+}
+function materializeHarvestJson(j) {
+  if (!j || typeof j !== "object") return null;
+  const h = j;
+  if (h.v !== 1) return null;
+  if (h.knobs?.abi !== HARVEST_DISK_ABI) return null;
+  if (!h.modules || typeof h.modules !== "object") return null;
+  try {
+    const modules = {};
+    for (const [mod, rec] of Object.entries(h.modules)) {
+      const named = {};
+      for (const [k, sig] of Object.entries(rec)) named[k] = harvestSigToAbs(sig);
+      modules[mod] = named;
+    }
+    const globals = {};
+    for (const [k, sig] of Object.entries(h.globals ?? {})) {
+      globals[k] = harvestSigToAbs(sig);
+    }
+    return {
+      globals,
+      modules,
+      stats: h.stats ?? { files: 0, symbols: 0, skipped: 0 }
+    };
+  } catch {
+    return null;
+  }
+}
+function harvestCacheKey(pkg, meta) {
+  const raw = [
+    HARVEST_DISK_ABI,
+    pkg,
+    meta.pkgVersion ?? "-",
+    String(meta.maxFiles),
+    meta.dtsHash
+  ].join("\0");
+  return sha256Hex(raw);
+}
+
+// src/harvest-disk.ts
+function depsCacheRoot() {
+  const env = process.env.NUDO_DEPS_CACHE_DIR;
+  if (env === "off" || env === "0") return void 0;
+  if (env && env.length > 0) return env;
+  try {
+    return join3(homedir(), ".cache", "nudo", "deps");
+  } catch {
+    return void 0;
+  }
+}
+function readPkgVersion(root) {
+  try {
+    const raw = JSON.parse(readFileSync4(join3(root, "package.json"), "utf8"));
+    return raw.version;
+  } catch {
+    return void 0;
+  }
+}
+function dtsClosureHash(files) {
+  const h = createHash2("sha256");
+  for (const f of [...files].sort()) {
+    h.update(f.replace(/\\/g, "/"));
+    try {
+      h.update(readFileSync4(f));
+    } catch {
+      h.update("miss");
+    }
+  }
+  return h.digest("hex");
+}
+function diskPath(root, key) {
+  return join3(root, key.slice(0, 2), `${key}.json`);
+}
+function readHarvestDisk(root, key) {
+  try {
+    const p = diskPath(root, key);
+    if (!existsSync3(p)) return void 0;
+    const parsed = JSON.parse(readFileSync4(p, "utf8"));
+    if (parsed?.abi !== HARVEST_DISK_ABI) return void 0;
+    return parsed.value;
+  } catch {
+    return void 0;
+  }
+}
+function writeHarvestDisk(root, key, value) {
+  try {
+    const p = diskPath(root, key);
+    mkdirSync(dirname3(p), { recursive: true });
+    writeFileSync(p, JSON.stringify({ abi: HARVEST_DISK_ABI, value }), "utf8");
+  } catch {
+  }
+}
+function listPackageDts(pkg, fromDir, maxFiles) {
+  const root = resolvePackageRoot(pkg, fromDir);
+  if (!root) return null;
+  const entry = (() => {
+    try {
+      const raw = JSON.parse(readFileSync4(join3(root, "package.json"), "utf8"));
+      const e = raw.types ?? raw.typings;
+      return typeof e === "string" && e.endsWith(".d.ts") ? join3(root, e) : void 0;
+    } catch {
+      return void 0;
+    }
+  })();
+  let dtsFiles = entry && existsSync3(entry) ? collectDtsFromEntry(entry, Math.max(maxFiles, 24)) : [];
+  if (dtsFiles.length === 0) {
+    const collected = collectDtsFiles(root, maxFiles);
+    dtsFiles = entry && existsSync3(entry) && !collected.includes(entry) ? [entry, ...collected.filter((f) => f !== entry)].slice(0, maxFiles) : collected;
+  }
+  if (dtsFiles.length === 0) return null;
+  return { root, dtsFiles, pkgVersion: readPkgVersion(root) };
+}
+function harvestPackageWithDisk(pkg, fromDir, maxFiles = 24) {
+  const cacheRoot = depsCacheRoot();
+  const listed = listPackageDts(pkg, fromDir, maxFiles);
+  if (!listed) return null;
+  const key = harvestCacheKey(pkg, {
+    dtsHash: dtsClosureHash(listed.dtsFiles),
+    maxFiles,
+    pkgVersion: listed.pkgVersion
+  });
+  if (cacheRoot) {
+    const hit = readHarvestDisk(cacheRoot, key);
+    if (hit) {
+      const env = materializeHarvestJson(hit);
+      if (env) {
+        return { pkg, root: listed.root, dtsFiles: listed.dtsFiles, env };
+      }
+    }
+  }
+  let h = null;
+  try {
+    const raw = harvestPackage(pkg, fromDir, maxFiles);
+    if (!("error" in raw)) h = raw;
+  } catch {
+    h = null;
+  }
+  if (!h) return null;
+  if (cacheRoot) {
+    writeHarvestDisk(
+      cacheRoot,
+      key,
+      serializeHarvestJson(pkg, h.env, {
+        dtsHash: dtsClosureHash(h.dtsFiles),
+        maxFiles,
+        pkgVersion: listed.pkgVersion
+      })
+    );
+  }
+  return h;
+}
+function loadHarvestEnvFromDisk(pkg, meta) {
+  const root = depsCacheRoot();
+  if (!root) return null;
+  const key = harvestCacheKey(pkg, meta);
+  const hit = readHarvestDisk(root, key);
+  return hit ? materializeHarvestJson(hit) : null;
+}
+
+// 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/harvest-auto.ts
+var NODE_BUILTINS = /* @__PURE__ */ new Set([
+  "assert",
+  "async_hooks",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "diagnostics_channel",
+  "dns",
+  "domain",
+  "events",
+  "fs",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "module",
+  "net",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "stream",
+  "string_decoder",
+  "timers",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "wasi",
+  "worker_threads",
+  "zlib"
+]);
+function barePackageName(spec) {
+  if (!spec) return void 0;
+  if (spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("node:")) return void 0;
+  const parts = spec.split("/");
+  if (spec.startsWith("@")) {
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : void 0;
+  }
+  const name = parts[0];
+  if (NODE_BUILTINS.has(name)) return void 0;
+  return name;
+}
+function collectBarePackages(source) {
+  try {
+    const ast = parse(source);
+    const names = /* @__PURE__ */ new Set();
+    for (const spec of collectDependencySpecs(ast)) {
+      const pkg = barePackageName(spec);
+      if (pkg) names.add(pkg);
+    }
+    return [...names];
+  } catch {
+    return [];
+  }
+}
+var HARVEST_CACHE_MAX = 128;
+var harvestCache = new BoundedLruMap(HARVEST_CACHE_MAX);
+function getHarvestCacheSize() {
+  return harvestCache.size;
+}
+function harvestPackageCached(pkg, fromDir) {
+  const key = `${fromDir}::${pkg}`;
+  if (harvestCache.has(key)) return harvestCache.get(key);
+  let result = null;
+  try {
+    result = harvestPackageWithDisk(pkg, fromDir);
+  } catch {
+    result = null;
+  }
+  harvestCache.set(key, result);
+  return result;
+}
+function clearHarvestCache() {
+  harvestCache.clear();
+}
+function autoHarvestModules(source, fromDir) {
+  const packages = collectBarePackages(source);
+  if (packages.length === 0) return {};
+  const modules = {};
+  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;
+      const base = mod.replace(/^@types\//, "").replace(/\\/g, "/");
+      if (base && !modules[base]) modules[base] = exports;
+    }
+    for (const [k, v] of Object.entries(h.env.globals)) {
+      if (!modules[pkg]) modules[pkg] = {};
+      if (modules[pkg][k] === void 0) modules[pkg][k] = v;
+    }
+  }
+  return modules;
+}
+
+// src/harvest-to-abs.ts
+import {
+  confJoin as confJoin2,
+  absFunction,
+  getFnImpl as getFnImpl3,
+  instantiateReturn
+} from "@nudojs/core";
+import { dirname as dirname4 } from "path";
+function markMockConf(a) {
+  a.conf = confJoin2(a.conf, "mock");
+  return a;
+}
+function harvestedValueToAbs(a) {
+  if (a.shape.k === "fn") {
+    const ret = a.shape.returnType ?? { shape: { k: "unknown" }, conf: "mock" };
+    const relation = getFnImpl3(a)?.relation;
+    const params = a.shape.params.length > 0 ? a.shape.params : a.shape.paramTypes?.map((_, i) => `_arg${i}`) ?? ["...args"];
+    const dummyBody = {
+      type: "BlockStatement",
+      body: [],
+      directives: []
+    };
+    return markMockConf(
+      absFunction(params, {
+        body: dummyBody,
+        apply: (args) => {
+          if (relation) {
+            return markMockConf(instantiateReturn(a, args));
+          }
+          return markMockConf({ ...ret });
+        },
+        ...relation ? { relation } : {}
+      })
+    );
+  }
+  return markMockConf({ ...a });
+}
+function harvestToAbsModules(pkg, fromDir) {
+  const h = harvestPackageCached(pkg, fromDir);
+  if (!h) return {};
+  return packageHarvestToAbsModules(pkg, h);
+}
+function packageHarvestToAbsModules(pkg, h) {
+  const out = {};
+  const convertRecord = (rec) => {
+    const named = {};
+    for (const [k, v] of Object.entries(rec)) {
+      named[k] = harvestedValueToAbs(v);
+    }
+    return named;
+  };
+  const register = (key, exports) => {
+    if (!out[key]) out[key] = exports;
+  };
+  for (const [mod, rec] of Object.entries(h.env.modules)) {
+    const named = convertRecord(rec);
+    const exports = { named };
+    const def = rec["default"];
+    if (def) exports.default = harvestedValueToAbs(def);
+    register(mod, exports);
+    register(pkg, exports);
+    const stripped = mod.replace(/^@types\//, "").replace(/\\/g, "/");
+    if (stripped) register(stripped, exports);
+    const base = stripped.split("/").filter(Boolean).pop();
+    if (base && base !== pkg) register(base, exports);
+  }
+  const globalNamed = convertRecord(h.env.globals);
+  if (Object.keys(globalNamed).length > 0) {
+    const existing = out[pkg];
+    if (existing) {
+      out[pkg] = { named: { ...globalNamed, ...existing.named }, default: existing.default };
+    } else {
+      out[pkg] = { named: globalNamed };
+    }
+  }
+  return out;
+}
+function bareSpecToAbsModules(spec, fromFile) {
+  if (!spec || spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("node:")) {
+    return void 0;
+  }
+  const parts = spec.split("/");
+  const pkg = spec.startsWith("@") ? parts.length >= 2 ? `${parts[0]}/${parts[1]}` : void 0 : parts[0];
+  if (!pkg) return void 0;
+  const table = harvestToAbsModules(pkg, dirname4(fromFile));
+  return table[spec] ?? table[pkg];
+}
+
+// src/harvest-node.ts
+import { existsSync as existsSync4, statSync as statSync4, readFileSync as readFileSync5 } from "fs";
+import { join as join4 } from "path";
+import { createEnvironment } from "@nudojs/core";
+import { defineEnv as defineNodeEnv } from "@nudojs/env/node";
+import { defineEnv as defineEsEnv } from "@nudojs/env/es";
+var HARVEST_NODE_DEFAULT_MAX_FILES = 12;
+var HARVEST_NODE_DEFAULT_MAX_MS = 2500;
+var NODE_HARVEST_CACHE_MAX = 32;
+var nodeHarvestCache = new BoundedLruMap(NODE_HARVEST_CACHE_MAX);
+function notFoundCacheKey(fromDir) {
+  return `not-found|@types/node|${fromDir ?? ""}`;
+}
+function nodeHarvestCacheKey(root, maxFiles, maxMs) {
+  let sig = "nostat";
+  try {
+    const st = statSync4(join4(root, "package.json"));
+    sig = `${st.size}:${Math.floor(st.mtimeMs)}`;
+  } catch {
+  }
+  return `${root}|${maxFiles}|${maxMs}|${sig}`;
+}
+function clearNodeHarvestCache() {
+  nodeHarvestCache.clear();
+}
+function getNodeHarvestCacheSize() {
+  return nodeHarvestCache.size;
+}
+function isHarvestNodeDisabled(env = process.env) {
+  return env.NUDO_HARVEST_NODE === "off";
+}
+function readPkgVersion2(root) {
+  try {
+    const raw = JSON.parse(readFileSync5(join4(root, "package.json"), "utf8"));
+    return raw.version;
+  } catch {
+    return void 0;
+  }
+}
+function handwrittenNodeEnv() {
+  try {
+    const globalEnv = createEnvironment();
+    const allModules = {};
+    const allGlobals = {};
+    for (const def of [defineEsEnv(), defineNodeEnv()]) {
+      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,
+      stats: {
+        files: 0,
+        symbols: Object.keys(allGlobals).length,
+        skipped: 0
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function degradeToHandwritten(error, reason, cached = false) {
+  const env = handwrittenNodeEnv();
+  if (env) {
+    return {
+      ok: true,
+      env,
+      root: "@nudojs/env",
+      files: 0,
+      stats: env.stats,
+      cached,
+      degraded: true
+    };
+  }
+  return { ok: false, error, reason, ...cached ? { cached: true } : {} };
+}
+function harvestNodeTypes(fromDir, maxFiles = HARVEST_NODE_DEFAULT_MAX_FILES, maxMs = HARVEST_NODE_DEFAULT_MAX_MS) {
+  if (isHarvestNodeDisabled()) {
+    return {
+      ok: false,
+      error: "harvest disabled via NUDO_HARVEST_NODE=off",
+      reason: "disabled"
+    };
+  }
+  const root = resolvePackageRoot("@types/node", fromDir) ?? resolvePackageRoot("node", fromDir);
+  if (!root || !existsSync4(root)) {
+    const missKey = notFoundCacheKey(fromDir);
+    const miss = nodeHarvestCache.get(missKey);
+    if (miss) {
+      return miss.ok ? { ...miss, cached: true } : { ...miss, cached: true };
+    }
+    const result = degradeToHandwritten("@types/node not found", "not-found");
+    nodeHarvestCache.set(missKey, result);
+    return result;
+  }
+  const key = nodeHarvestCacheKey(root, maxFiles, maxMs);
+  const hit = nodeHarvestCache.get(key);
+  if (hit) {
+    return hit.ok ? { ...hit, cached: true } : { ...hit, cached: true };
+  }
+  const dts = collectDtsFiles(root, maxFiles);
+  if (dts.length === 0) {
+    const result = degradeToHandwritten(`no .d.ts under ${root}`, "no-dts");
+    nodeHarvestCache.set(key, result);
+    return result;
+  }
+  const diskRoot = depsCacheRoot();
+  const dtsHash = dtsClosureHash(dts);
+  const pkgVersion = readPkgVersion2(root);
+  const diskKey = harvestCacheKey("@types/node", {
+    dtsHash,
+    maxFiles,
+    ...pkgVersion !== void 0 ? { pkgVersion } : {}
+  });
+  if (diskRoot) {
+    const diskHit = readHarvestDisk(diskRoot, diskKey);
+    const env = diskHit ? materializeHarvestJson(diskHit) : null;
+    if (env) {
+      const stats = {
+        files: env.stats.files,
+        symbols: env.stats.symbols,
+        skipped: env.stats.skipped
+      };
+      const result = {
+        ok: true,
+        env,
+        root,
+        files: stats.files,
+        stats,
+        cached: true
+      };
+      nodeHarvestCache.set(key, result);
+      return result;
+    }
+  }
+  try {
+    const env = harvestDts(dts, { maxMs });
+    const stats = {
+      files: env.stats.files,
+      symbols: env.stats.symbols,
+      skipped: env.stats.skipped
+    };
+    if (diskRoot) {
+      writeHarvestDisk(
+        diskRoot,
+        diskKey,
+        serializeHarvestJson("@types/node", env, {
+          dtsHash,
+          maxFiles,
+          ...pkgVersion !== void 0 ? { pkgVersion } : {}
+        })
+      );
+    }
+    const result = {
+      ok: true,
+      env,
+      root,
+      files: stats.files,
+      stats,
+      cached: false
+    };
+    nodeHarvestCache.set(key, result);
+    return result;
+  } catch (e) {
+    const result = degradeToHandwritten(
+      `harvest failed: ${e.message}`,
+      "failed"
+    );
+    nodeHarvestCache.set(key, result);
+    return result;
+  }
+}
+function summarizeNodeEnv(env) {
+  return {
+    modules: Object.keys(env.modules).sort(),
+    globals: Object.keys(env.globals).sort().slice(0, 50),
+    symbolCount: env.stats.symbols
+  };
+}
 export {
+  HARVEST_NODE_DEFAULT_MAX_FILES,
+  HARVEST_NODE_DEFAULT_MAX_MS,
+  absToHarvestSig,
+  autoHarvestModules,
+  barePackageName,
+  bareSpecToAbsModules,
+  clearHarvestCache,
+  clearNodeHarvestCache,
+  collectBarePackages,
+  collectDtsFromEntry,
+  depsCacheRoot,
+  dtsClosureHash,
+  dtsPathToContractDraft,
+  dtsToContractDraft,
   emitEnvModule,
-  harvestDts
+  formatDtsContractDraft,
+  formatHarvestSummary,
+  getHarvestCacheSize,
+  getNodeHarvestCacheSize,
+  handwrittenNodeEnv,
+  harvestCacheKey,
+  harvestDts,
+  harvestNodeTypes,
+  harvestPackage,
+  harvestPackageCached,
+  harvestPackageWithDisk,
+  harvestSigToAbs,
+  harvestToAbsModules,
+  harvestedValueToAbs,
+  isHarvestNodeDisabled,
+  loadHarvestEnvFromDisk,
+  lookupHarvested,
+  materializeHarvestJson,
+  packageHarvestToAbsModules,
+  readHarvestDisk,
+  resolvePackageRoot,
+  serializeHarvestJson,
+  summarizeNodeEnv,
+  writeHarvestDisk
 };